refactor: rename to openclaw

docs/platforms/android.md

@@ -31,12 +31,12 @@ Android connects directly to the Gateway WebSocket (default `ws://<host>:18789`)
   - Same LAN with mDNS/NSD, **or**
   - Same Tailscale tailnet using Wide-Area Bonjour / unicast DNS-SD (see below), **or**
   - Manual gateway host/port (fallback)
-- You can run the CLI (`moltbot`) on the gateway machine (or via SSH).
+- You can run the CLI (`openclaw`) on the gateway machine (or via SSH).
 
 ### 1) Start the Gateway
 
 ```bash
-moltbot gateway --port 18789 --verbose
+openclaw gateway --port 18789 --verbose
 ```
 
 Confirm in logs you see something like:
@@ -44,7 +44,7 @@ Confirm in logs you see something like:
 
 For tailnet-only setups (recommended for Vienna ⇄ London), bind the gateway to the tailnet IP:
 
-- Set `gateway.bind: "tailnet"` in `~/.clawdbot/moltbot.json` on the gateway host.
+- Set `gateway.bind: "tailnet"` in `~/.openclaw/openclaw.json` on the gateway host.
 - Restart the Gateway / macOS menubar app.
 
 ### 2) Verify discovery (optional)
@@ -52,7 +52,7 @@ For tailnet-only setups (recommended for Vienna ⇄ London), bind the gateway to
 From the gateway machine:
 
 ```bash
-dns-sd -B _moltbot-gw._tcp local.
+dns-sd -B _openclaw-gw._tcp local.
 ```
 
 More debugging notes: [Bonjour](/gateway/bonjour).
@@ -61,8 +61,8 @@ More debugging notes: [Bonjour](/gateway/bonjour).
 
 Android NSD/mDNS discovery won’t cross networks. If your Android node and the gateway are on different networks but connected via Tailscale, use Wide-Area Bonjour / unicast DNS-SD instead:
 
-1) Set up a DNS-SD zone (example `moltbot.internal.`) on the gateway host and publish `_moltbot-gw._tcp` records.
-2) Configure Tailscale split DNS for `moltbot.internal` pointing at that DNS server.
+1) Set up a DNS-SD zone (example `openclaw.internal.`) on the gateway host and publish `_openclaw-gw._tcp` records.
+2) Configure Tailscale split DNS for your chosen domain pointing at that DNS server.
 
 Details and example CoreDNS config: [Bonjour](/gateway/bonjour).
 
@@ -84,8 +84,8 @@ After the first successful pairing, Android auto-reconnects on launch:
 On the gateway machine:
 
 ```bash
-moltbot nodes pending
-moltbot nodes approve <requestId>
+openclaw nodes pending
+openclaw nodes approve <requestId>
 ```
 
 Pairing details: [Gateway pairing](/gateway/pairing).
@@ -94,11 +94,11 @@ Pairing details: [Gateway pairing](/gateway/pairing).
 
 - Via nodes status:
   ```bash
-  moltbot nodes status
+  openclaw nodes status
   ```
 - Via Gateway:
   ```bash
-  moltbot gateway call node.list --params "{}"
+  openclaw gateway call node.list --params "{}"
   ```
 
 ### 6) Chat + history
@@ -117,18 +117,18 @@ If you want the node to show real HTML/CSS/JS that the agent can edit on disk, p
 
 Note: nodes use the standalone canvas host on `canvasHost.port` (default `18793`).
 
-1) Create `~/clawd/canvas/index.html` on the gateway host.
+1) Create `~/.openclaw/workspace/canvas/index.html` on the gateway host.
 
 2) Navigate the node to it (LAN):
 
 ```bash
-moltbot nodes invoke --node "<Android Node>" --command canvas.navigate --params '{"url":"http://<gateway-hostname>.local:18793/__moltbot__/canvas/"}'
+openclaw nodes invoke --node "<Android Node>" --command canvas.navigate --params '{"url":"http://<gateway-hostname>.local:18793/__openclaw__/canvas/"}'
 ```
 
-Tailnet (optional): if both devices are on Tailscale, use a MagicDNS name or tailnet IP instead of `.local`, e.g. `http://<gateway-magicdns>:18793/__moltbot__/canvas/`.
+Tailnet (optional): if both devices are on Tailscale, use a MagicDNS name or tailnet IP instead of `.local`, e.g. `http://<gateway-magicdns>:18793/__openclaw__/canvas/`.
 
 This server injects a live-reload client into HTML and reloads on file changes.
-The A2UI host lives at `http://<gateway-host>:18793/__moltbot__/a2ui/`.
+The A2UI host lives at `http://<gateway-host>:18793/__openclaw__/a2ui/`.
 
 Canvas commands (foreground only):
 - `canvas.eval`, `canvas.snapshot`, `canvas.navigate` (use `{"url":""}` or `{"url":"/"}` to return to the default scaffold). `canvas.snapshot` returns `{ format, base64 }` (default `format="jpeg"`).

docs/platforms/digitalocean.md

@@ -1,15 +1,15 @@
 ---
-summary: "Moltbot on DigitalOcean (simple paid VPS option)"
+summary: "OpenClaw on DigitalOcean (simple paid VPS option)"
 read_when:
-  - Setting up Moltbot on DigitalOcean
-  - Looking for cheap VPS hosting for Moltbot
+  - Setting up OpenClaw on DigitalOcean
+  - Looking for cheap VPS hosting for OpenClaw
 ---
 
-# Moltbot on DigitalOcean
+# OpenClaw on DigitalOcean
 
 ## Goal
 
-Run a persistent Moltbot Gateway on DigitalOcean for **$6/month** (or $4/mo with reserved pricing).
+Run a persistent OpenClaw Gateway on DigitalOcean for **$6/month** (or $4/mo with reserved pricing).
 
 If you want a $0/month option and don’t mind ARM + provider-specific setup, see the [Oracle Cloud guide](/platforms/oracle).
 
@@ -54,7 +54,7 @@ If you want a $0/month option and don’t mind ARM + provider-specific setup, se
 ssh root@YOUR_DROPLET_IP
 ```
 
-## 3) Install Moltbot
+## 3) Install OpenClaw
 
 ```bash
 # Update system
@@ -64,17 +64,17 @@ apt update && apt upgrade -y
 curl -fsSL https://deb.nodesource.com/setup_22.x | bash -
 apt install -y nodejs
 
-# Install Moltbot
-curl -fsSL https://molt.bot/install.sh | bash
+# Install OpenClaw
+curl -fsSL https://openclaw.bot/install.sh | bash
 
 # Verify
-moltbot --version
+openclaw --version
 ```
 
 ## 4) Run Onboarding
 
 ```bash
-moltbot onboard --install-daemon
+openclaw onboard --install-daemon
 ```
 
 The wizard will walk you through:
@@ -87,13 +87,13 @@ The wizard will walk you through:
 
 ```bash
 # Check status
-moltbot status
+openclaw status
 
 # Check service
-systemctl --user status moltbot-gateway.service
+systemctl --user status openclaw-gateway.service
 
 # View logs
-journalctl --user -u moltbot-gateway.service -f
+journalctl --user -u openclaw-gateway.service -f
 ```
 
 ## 6) Access the Dashboard
@@ -115,8 +115,8 @@ curl -fsSL https://tailscale.com/install.sh | sh
 tailscale up
 
 # Configure Gateway to use Tailscale Serve
-moltbot config set gateway.tailscale.mode serve
-moltbot gateway restart
+openclaw config set gateway.tailscale.mode serve
+openclaw gateway restart
 ```
 
 Open: `https://<magicdns>/`
@@ -127,8 +127,8 @@ Notes:
 
 **Option C: Tailnet bind (no Serve)**
 ```bash
-moltbot config set gateway.bind tailnet
-moltbot gateway restart
+openclaw config set gateway.bind tailnet
+openclaw gateway restart
 ```
 
 Open: `http://<tailscale-ip>:18789` (token required).
@@ -137,13 +137,13 @@ Open: `http://<tailscale-ip>:18789` (token required).
 
 ### Telegram
 ```bash
-moltbot pairing list telegram
-moltbot pairing approve telegram <CODE>
+openclaw pairing list telegram
+openclaw pairing approve telegram <CODE>
 ```
 
 ### WhatsApp
 ```bash
-moltbot channels login whatsapp
+openclaw channels login whatsapp
 # Scan QR code
 ```
 
@@ -180,12 +180,12 @@ htop
 ## Persistence
 
 All state lives in:
-- `~/.clawdbot/` — config, credentials, session data
-- `~/clawd/` — workspace (SOUL.md, memory, etc.)
+- `~/.openclaw/` — config, credentials, session data
+- `~/.openclaw/workspace/` — workspace (SOUL.md, memory, etc.)
 
 These survive reboots. Back them up periodically:
 ```bash
-tar -czvf moltbot-backup.tar.gz ~/.clawdbot ~/clawd
+tar -czvf openclaw-backup.tar.gz ~/.openclaw ~/.openclaw/workspace
 ```
 
 ---
@@ -213,9 +213,9 @@ For the full setup guide, see [Oracle Cloud](/platforms/oracle). For signup tips
 
 ### Gateway won't start
 ```bash
-moltbot gateway status
-moltbot doctor --non-interactive
-journalctl -u moltbot --no-pager -n 50
+openclaw gateway status
+openclaw doctor --non-interactive
+journalctl -u openclaw --no-pager -n 50
 ```
 
 ### Port already in use

docs/platforms/exe-dev.md

@@ -1,5 +1,5 @@
 ---
-summary: "Run Moltbot Gateway on exe.dev (VM + HTTPS proxy) for remote access"
+summary: "Run OpenClaw Gateway on exe.dev (VM + HTTPS proxy) for remote access"
 read_when:
   - You want a cheap always-on Linux host for the Gateway
   - You want remote Control UI access without running your own VPS
@@ -7,13 +7,13 @@ read_when:
 
 # exe.dev
 
-Goal: Moltbot Gateway running on an exe.dev VM, reachable from your laptop via: `https://<vm-name>.exe.xyz`
+Goal: OpenClaw Gateway running on an exe.dev VM, reachable from your laptop via: `https://<vm-name>.exe.xyz`
 
 This page assumes exe.dev's default **exeuntu** image. If you picked a different distro, map packages accordingly.
 
 ## Beginner quick path
 
-1) [https://exe.new/moltbot](https://exe.new/moltbot)
+1) [https://exe.new/openclaw](https://exe.new/openclaw)
 2) Fill in your auth key/token as needed
 3) Click on "Agent" next to your VM, and wait...
 4) ???
@@ -27,11 +27,11 @@ This page assumes exe.dev's default **exeuntu** image. If you picked a different
 
 ## Automated Install with Shelley
 
-Shelley, [exe.dev](https://exe.dev)'s agent, can install Moltbot instantly with our
+Shelley, [exe.dev](https://exe.dev)'s agent, can install OpenClaw instantly with our
 prompt. The prompt used is as below:
 
 ```
-Set up Moltbot (https://docs.molt.bot/install) on this VM. Use the non-interactive and accept-risk flags for moltbot onboarding. Add the supplied auth or token as needed. Configure nginx to forward from the default port 18789 to the root location on the default enabled site config, making sure to enable Websocket support. Pairing is done by "moltbot devices list" and "moltbot device approve <request id>". Make sure the dashboard shows that Moltbot's health is OK. exe.dev handles forwarding from port 8000 to port 80/443 and HTTPS for us, so the final "reachable" should be <vm-name>.exe.xyz, without port specification.
+Set up OpenClaw (https://docs.openclaw.ai/install) on this VM. Use the non-interactive and accept-risk flags for openclaw onboarding. Add the supplied auth or token as needed. Configure nginx to forward from the default port 18789 to the root location on the default enabled site config, making sure to enable Websocket support. Pairing is done by "openclaw devices list" and "openclaw device approve <request id>". Make sure the dashboard shows that OpenClaw's health is OK. exe.dev handles forwarding from port 8000 to port 80/443 and HTTPS for us, so the final "reachable" should be <vm-name>.exe.xyz, without port specification.
 ```
 
 ## Manual installation
@@ -50,7 +50,7 @@ Then connect:
 ssh <vm-name>.exe.xyz
 ```
 
-Tip: keep this VM **stateful**. Moltbot stores state under `~/.clawdbot/` and `~/clawd/`.
+Tip: keep this VM **stateful**. OpenClaw stores state under `~/.openclaw/` and `~/.openclaw/workspace/`.
 
 ## 2) Install prerequisites (on the VM)
 
@@ -59,15 +59,15 @@ sudo apt-get update
 sudo apt-get install -y git curl jq ca-certificates openssl
 ```
 
-## 3) Install Moltbot
+## 3) Install OpenClaw
 
-Run the Moltbot install script:
+Run the OpenClaw install script:
 
 ```bash
-curl -fsSL https://molt.bot/install.sh | bash
+curl -fsSL https://openclaw.bot/install.sh | bash
 ```
 
-## 4) Setup nginx to proxy Moltbot to port 8000
+## 4) Setup nginx to proxy OpenClaw to port 8000
 
 Edit `/etc/nginx/sites-enabled/default` with
 
@@ -101,10 +101,10 @@ server {
 }
 ```
 
-## 5) Access Moltbot and grant privileges
+## 5) Access OpenClaw and grant privileges
 
 Access `https://<vm-name>.exe.xyz/?token=YOUR-TOKEN-FROM-TERMINAL`. Approve
-devices with `moltbot devices list` and `moltbot device approve`. When in doubt,
+devices with `openclaw devices list` and `openclaw device approve`. When in doubt,
 use Shelley from your browser!
 
 ## Remote Access
@@ -116,10 +116,10 @@ with email auth.
 ## Updating
 
 ```bash
-npm i -g moltbot@latest
-moltbot doctor
-moltbot gateway restart
-moltbot health
+npm i -g openclaw@latest
+openclaw doctor
+openclaw gateway restart
+openclaw health
 ```
 
 Guide: [Updating](/install/updating)

docs/platforms/fly.md

@@ -1,11 +1,11 @@
 ---
 title: Fly.io
-description: Deploy Moltbot on Fly.io
+description: Deploy OpenClaw on Fly.io
 ---
 
 # Fly.io Deployment
 
-**Goal:** Moltbot Gateway running on a [Fly.io](https://fly.io) machine with persistent storage, automatic HTTPS, and Discord/channel access.
+**Goal:** OpenClaw Gateway running on a [Fly.io](https://fly.io) machine with persistent storage, automatic HTTPS, and Discord/channel access.
 
 ## What you need
 
@@ -25,14 +25,14 @@ description: Deploy Moltbot on Fly.io
 
 ```bash
 # Clone the repo
-git clone https://github.com/moltbot/moltbot.git
-cd moltbot
+git clone https://github.com/openclaw/openclaw.git
+cd openclaw
 
 # Create a new Fly app (pick your own name)
-fly apps create my-moltbot
+fly apps create my-openclaw
 
 # Create a persistent volume (1GB is usually enough)
-fly volumes create moltbot_data --size 1 --region iad
+fly volumes create openclaw_data --size 1 --region iad
 ```
 
 **Tip:** Choose a region close to you. Common options: `lhr` (London), `iad` (Virginia), `sjc` (San Jose).
@@ -44,7 +44,7 @@ Edit `fly.toml` to match your app name and requirements.
 **Security note:** The default config exposes a public URL. For a hardened deployment with no public IP, see [Private Deployment](#private-deployment-hardened) or use `fly.private.toml`.
 
 ```toml
-app = "my-moltbot"  # Your app name
+app = "my-openclaw"  # Your app name
 primary_region = "iad"
 
 [build]
@@ -52,8 +52,8 @@ primary_region = "iad"
 
 [env]
   NODE_ENV = "production"
-  CLAWDBOT_PREFER_PNPM = "1"
-  CLAWDBOT_STATE_DIR = "/data"
+  OPENCLAW_PREFER_PNPM = "1"
+  OPENCLAW_STATE_DIR = "/data"
   NODE_OPTIONS = "--max-old-space-size=1536"
 
 [processes]
@@ -72,7 +72,7 @@ primary_region = "iad"
   memory = "2048mb"
 
 [mounts]
-  source = "moltbot_data"
+  source = "openclaw_data"
   destination = "/data"
 ```
 
@@ -82,15 +82,15 @@ primary_region = "iad"
 |---------|-----|
 | `--bind lan` | Binds to `0.0.0.0` so Fly's proxy can reach the gateway |
 | `--allow-unconfigured` | Starts without a config file (you'll create one after) |
-| `internal_port = 3000` | Must match `--port 3000` (or `CLAWDBOT_GATEWAY_PORT`) for Fly health checks |
+| `internal_port = 3000` | Must match `--port 3000` (or `OPENCLAW_GATEWAY_PORT`) for Fly health checks |
 | `memory = "2048mb"` | 512MB is too small; 2GB recommended |
-| `CLAWDBOT_STATE_DIR = "/data"` | Persists state on the volume |
+| `OPENCLAW_STATE_DIR = "/data"` | Persists state on the volume |
 
 ## 3) Set secrets
 
 ```bash
 # Required: Gateway token (for non-loopback binding)
-fly secrets set CLAWDBOT_GATEWAY_TOKEN=$(openssl rand -hex 32)
+fly secrets set OPENCLAW_GATEWAY_TOKEN=$(openssl rand -hex 32)
 
 # Model provider API keys
 fly secrets set ANTHROPIC_API_KEY=sk-ant-...
@@ -104,9 +104,9 @@ fly secrets set DISCORD_BOT_TOKEN=MTQ...
 ```
 
 **Notes:**
-- Non-loopback binds (`--bind lan`) require `CLAWDBOT_GATEWAY_TOKEN` for security.
+- Non-loopback binds (`--bind lan`) require `OPENCLAW_GATEWAY_TOKEN` for security.
 - Treat these tokens like passwords.
-- **Prefer env vars over config file** for all API keys and tokens. This keeps secrets out of `moltbot.json` where they could be accidentally exposed or logged.
+- **Prefer env vars over config file** for all API keys and tokens. This keeps secrets out of `openclaw.json` where they could be accidentally exposed or logged.
 
 ## 4) Deploy
 
@@ -139,7 +139,7 @@ fly ssh console
 Create the config directory and file:
 ```bash
 mkdir -p /data
-cat > /data/moltbot.json << 'EOF'
+cat > /data/openclaw.json << 'EOF'
 {
   "agents": {
     "defaults": {
@@ -191,7 +191,7 @@ cat > /data/moltbot.json << 'EOF'
 EOF
 ```
 
-**Note:** With `CLAWDBOT_STATE_DIR=/data`, the config path is `/data/moltbot.json`.
+**Note:** With `OPENCLAW_STATE_DIR=/data`, the config path is `/data/openclaw.json`.
 
 **Note:** The Discord token can come from either:
 - Environment variable: `DISCORD_BOT_TOKEN` (recommended for secrets)
@@ -214,9 +214,9 @@ Open in browser:
 fly open
 ```
 
-Or visit `https://my-moltbot.fly.dev/`
+Or visit `https://my-openclaw.fly.dev/`
 
-Paste your gateway token (the one from `CLAWDBOT_GATEWAY_TOKEN`) to authenticate.
+Paste your gateway token (the one from `OPENCLAW_GATEWAY_TOKEN`) to authenticate.
 
 ### Logs
 
@@ -243,7 +243,7 @@ The gateway is binding to `127.0.0.1` instead of `0.0.0.0`.
 
 Fly can't reach the gateway on the configured port.
 
-**Fix:** Ensure `internal_port` matches the gateway port (set `--port 3000` or `CLAWDBOT_GATEWAY_PORT=3000`).
+**Fix:** Ensure `internal_port` matches the gateway port (set `--port 3000` or `OPENCLAW_GATEWAY_PORT=3000`).
 
 ### OOM / Memory Issues
 
@@ -278,11 +278,11 @@ The lock file is at `/data/gateway.*.lock` (not in a subdirectory).
 
 ### Config Not Being Read
 
-If using `--allow-unconfigured`, the gateway creates a minimal config. Your custom config at `/data/moltbot.json` should be read on restart.
+If using `--allow-unconfigured`, the gateway creates a minimal config. Your custom config at `/data/openclaw.json` should be read on restart.
 
 Verify the config exists:
 ```bash
-fly ssh console --command "cat /data/moltbot.json"
+fly ssh console --command "cat /data/openclaw.json"
 ```
 
 ### Writing Config via SSH
@@ -291,23 +291,23 @@ The `fly ssh console -C` command doesn't support shell redirection. To write a c
 
 ```bash
 # Use echo + tee (pipe from local to remote)
-echo '{"your":"config"}' | fly ssh console -C "tee /data/moltbot.json"
+echo '{"your":"config"}' | fly ssh console -C "tee /data/openclaw.json"
 
 # Or use sftp
 fly sftp shell
-> put /local/path/config.json /data/moltbot.json
+> put /local/path/config.json /data/openclaw.json
 ```
 
 **Note:** `fly sftp` may fail if the file already exists. Delete first:
 ```bash
-fly ssh console --command "rm /data/moltbot.json"
+fly ssh console --command "rm /data/openclaw.json"
 ```
 
 ### State Not Persisting
 
 If you lose credentials or sessions after a restart, the state dir is writing to the container filesystem.
 
-**Fix:** Ensure `CLAWDBOT_STATE_DIR=/data` is set in `fly.toml` and redeploy.
+**Fix:** Ensure `OPENCLAW_STATE_DIR=/data` is set in `fly.toml` and redeploy.
 
 ## Updates
 
@@ -366,18 +366,18 @@ Or convert an existing deployment:
 
 ```bash
 # List current IPs
-fly ips list -a my-moltbot
+fly ips list -a my-openclaw
 
 # Release public IPs
-fly ips release <public-ipv4> -a my-moltbot
-fly ips release <public-ipv6> -a my-moltbot
+fly ips release <public-ipv4> -a my-openclaw
+fly ips release <public-ipv6> -a my-openclaw
 
 # Switch to private config so future deploys don't re-allocate public IPs
 # (remove [http_service] or deploy with the private template)
 fly deploy -c fly.private.toml
 
 # Allocate private-only IPv6
-fly ips allocate-v6 --private -a my-moltbot
+fly ips allocate-v6 --private -a my-openclaw
 ```
 
 After this, `fly ips list` should show only a `private` type IP:
@@ -393,7 +393,7 @@ Since there's no public URL, use one of these methods:
 **Option 1: Local proxy (simplest)**
 ```bash
 # Forward local port 3000 to the app
-fly proxy 3000:3000 -a my-moltbot
+fly proxy 3000:3000 -a my-openclaw
 
 # Then open http://localhost:3000 in browser
 ```
@@ -409,7 +409,7 @@ fly wireguard create
 
 **Option 3: SSH only**
 ```bash
-fly ssh console -a my-moltbot
+fly ssh console -a my-openclaw
 ```
 
 ### Webhooks with private deployment

docs/platforms/gcp.md

@@ -1,18 +1,18 @@
 ---
-summary: "Run Moltbot Gateway 24/7 on a GCP Compute Engine VM (Docker) with durable state"
+summary: "Run OpenClaw Gateway 24/7 on a GCP Compute Engine VM (Docker) with durable state"
 read_when:
-  - You want Moltbot running 24/7 on GCP
+  - You want OpenClaw running 24/7 on GCP
   - You want a production-grade, always-on Gateway on your own VM
   - You want full control over persistence, binaries, and restart behavior
 ---
 
-# Moltbot on GCP Compute Engine (Docker, Production VPS Guide)
+# OpenClaw on GCP Compute Engine (Docker, Production VPS Guide)
 
 ## Goal
 
-Run a persistent Moltbot Gateway on a GCP Compute Engine VM using Docker, with durable state, baked-in binaries, and safe restart behavior.
+Run a persistent OpenClaw Gateway on a GCP Compute Engine VM using Docker, with durable state, baked-in binaries, and safe restart behavior.
 
-If you want "Moltbot 24/7 for ~$5-12/mo", this is a reliable setup on Google Cloud.
+If you want "OpenClaw 24/7 for ~$5-12/mo", this is a reliable setup on Google Cloud.
 Pricing varies by machine type and region; pick the smallest VM that fits your workload and scale up if you hit OOMs.
 
 ## What are we doing (simple terms)?
@@ -20,8 +20,8 @@ Pricing varies by machine type and region; pick the smallest VM that fits your w
 - Create a GCP project and enable billing
 - Create a Compute Engine VM
 - Install Docker (isolated app runtime)
-- Start the Moltbot Gateway in Docker
-- Persist `~/.clawdbot` + `~/clawd` on the host (survives restarts/rebuilds)
+- Start the OpenClaw Gateway in Docker
+- Persist `~/.openclaw` + `~/.openclaw/workspace` on the host (survives restarts/rebuilds)
 - Access the Control UI from your laptop via an SSH tunnel
 
 The Gateway can be accessed via:
@@ -40,7 +40,7 @@ For the generic Docker flow, see [Docker](/install/docker).
 2) Create Compute Engine VM (e2-small, Debian 12, 20GB)
 3) SSH into the VM
 4) Install Docker
-5) Clone Moltbot repository
+5) Clone OpenClaw repository
 6) Create persistent host directories
 7) Configure `.env` and `docker-compose.yml`
 8) Bake required binaries, build, and launch
@@ -87,8 +87,8 @@ All steps can be done via the web UI at https://console.cloud.google.com
 **CLI:**
 
 ```bash
-gcloud projects create my-moltbot-project --name="Moltbot Gateway"
-gcloud config set project my-moltbot-project
+gcloud projects create my-openclaw-project --name="OpenClaw Gateway"
+gcloud config set project my-openclaw-project
 ```
 
 Enable billing at https://console.cloud.google.com/billing (required for Compute Engine).
@@ -120,7 +120,7 @@ gcloud services enable compute.googleapis.com
 **CLI:**
 
 ```bash
-gcloud compute instances create moltbot-gateway \
+gcloud compute instances create openclaw-gateway \
   --zone=us-central1-a \
   --machine-type=e2-small \
   --boot-disk-size=20GB \
@@ -131,7 +131,7 @@ gcloud compute instances create moltbot-gateway \
 **Console:**
 
 1. Go to Compute Engine > VM instances > Create instance
-2. Name: `moltbot-gateway`
+2. Name: `openclaw-gateway`
 3. Region: `us-central1`, Zone: `us-central1-a`
 4. Machine type: `e2-small`
 5. Boot disk: Debian 12, 20GB
@@ -144,7 +144,7 @@ gcloud compute instances create moltbot-gateway \
 **CLI:**
 
 ```bash
-gcloud compute ssh moltbot-gateway --zone=us-central1-a
+gcloud compute ssh openclaw-gateway --zone=us-central1-a
 ```
 
 **Console:**
@@ -173,7 +173,7 @@ exit
 Then SSH back in:
 
 ```bash
-gcloud compute ssh moltbot-gateway --zone=us-central1-a
+gcloud compute ssh openclaw-gateway --zone=us-central1-a
 ```
 
 Verify:
@@ -185,11 +185,11 @@ docker compose version
 
 ---
 
-## 6) Clone the Moltbot repository
+## 6) Clone the OpenClaw repository
 
 ```bash
-git clone https://github.com/moltbot/moltbot.git
-cd moltbot
+git clone https://github.com/openclaw/openclaw.git
+cd openclaw
 ```
 
 This guide assumes you will build a custom image to guarantee binary persistence.
@@ -202,8 +202,8 @@ Docker containers are ephemeral.
 All long-lived state must live on the host.
 
 ```bash
-mkdir -p ~/.clawdbot
-mkdir -p ~/clawd
+mkdir -p ~/.openclaw
+mkdir -p ~/.openclaw/workspace
 ```
 
 ---
@@ -213,16 +213,16 @@ mkdir -p ~/clawd
 Create `.env` in the repository root.
 
 ```bash
-CLAWDBOT_IMAGE=moltbot:latest
-CLAWDBOT_GATEWAY_TOKEN=change-me-now
-CLAWDBOT_GATEWAY_BIND=lan
-CLAWDBOT_GATEWAY_PORT=18789
+OPENCLAW_IMAGE=openclaw:latest
+OPENCLAW_GATEWAY_TOKEN=change-me-now
+OPENCLAW_GATEWAY_BIND=lan
+OPENCLAW_GATEWAY_PORT=18789
 
-CLAWDBOT_CONFIG_DIR=/home/$USER/.clawdbot
-CLAWDBOT_WORKSPACE_DIR=/home/$USER/clawd
+OPENCLAW_CONFIG_DIR=/home/$USER/.openclaw
+OPENCLAW_WORKSPACE_DIR=/home/$USER/.openclaw/workspace
 
 GOG_KEYRING_PASSWORD=change-me-now
-XDG_CONFIG_HOME=/home/node/.clawdbot
+XDG_CONFIG_HOME=/home/node/.openclaw
 ```
 
 Generate strong secrets:
@@ -241,8 +241,8 @@ Create or update `docker-compose.yml`.
 
 ```yaml
 services:
-  moltbot-gateway:
-    image: ${CLAWDBOT_IMAGE}
+  openclaw-gateway:
+    image: ${OPENCLAW_IMAGE}
     build: .
     restart: unless-stopped
     env_file:
@@ -251,19 +251,19 @@ services:
       - HOME=/home/node
       - NODE_ENV=production
       - TERM=xterm-256color
-      - CLAWDBOT_GATEWAY_BIND=${CLAWDBOT_GATEWAY_BIND}
-      - CLAWDBOT_GATEWAY_PORT=${CLAWDBOT_GATEWAY_PORT}
-      - CLAWDBOT_GATEWAY_TOKEN=${CLAWDBOT_GATEWAY_TOKEN}
+      - OPENCLAW_GATEWAY_BIND=${OPENCLAW_GATEWAY_BIND}
+      - OPENCLAW_GATEWAY_PORT=${OPENCLAW_GATEWAY_PORT}
+      - OPENCLAW_GATEWAY_TOKEN=${OPENCLAW_GATEWAY_TOKEN}
       - GOG_KEYRING_PASSWORD=${GOG_KEYRING_PASSWORD}
       - XDG_CONFIG_HOME=${XDG_CONFIG_HOME}
       - PATH=/home/linuxbrew/.linuxbrew/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
     volumes:
-      - ${CLAWDBOT_CONFIG_DIR}:/home/node/.clawdbot
-      - ${CLAWDBOT_WORKSPACE_DIR}:/home/node/clawd
+      - ${OPENCLAW_CONFIG_DIR}:/home/node/.openclaw
+      - ${OPENCLAW_WORKSPACE_DIR}:/home/node/.openclaw/workspace
     ports:
       # Recommended: keep the Gateway loopback-only on the VM; access via SSH tunnel.
       # To expose it publicly, remove the `127.0.0.1:` prefix and firewall accordingly.
-      - "127.0.0.1:${CLAWDBOT_GATEWAY_PORT}:18789"
+      - "127.0.0.1:${OPENCLAW_GATEWAY_PORT}:18789"
 
       # Optional: only if you run iOS/Android nodes against this VM and need Canvas host.
       # If you expose this publicly, read /gateway/security and firewall accordingly.
@@ -274,9 +274,9 @@ services:
         "dist/index.js",
         "gateway",
         "--bind",
-        "${CLAWDBOT_GATEWAY_BIND}",
+        "${OPENCLAW_GATEWAY_BIND}",
         "--port",
-        "${CLAWDBOT_GATEWAY_PORT}"
+        "${OPENCLAW_GATEWAY_PORT}"
       ]
 ```
 
@@ -347,15 +347,15 @@ CMD ["node","dist/index.js"]
 
 ```bash
 docker compose build
-docker compose up -d moltbot-gateway
+docker compose up -d openclaw-gateway
 ```
 
 Verify binaries:
 
 ```bash
-docker compose exec moltbot-gateway which gog
-docker compose exec moltbot-gateway which goplaces
-docker compose exec moltbot-gateway which wacli
+docker compose exec openclaw-gateway which gog
+docker compose exec openclaw-gateway which goplaces
+docker compose exec openclaw-gateway which wacli
 ```
 
 Expected output:
@@ -371,7 +371,7 @@ Expected output:
 ## 12) Verify Gateway
 
 ```bash
-docker compose logs -f moltbot-gateway
+docker compose logs -f openclaw-gateway
 ```
 
 Success:
@@ -387,7 +387,7 @@ Success:
 Create an SSH tunnel to forward the Gateway port:
 
 ```bash
-gcloud compute ssh moltbot-gateway --zone=us-central1-a -- -L 18789:127.0.0.1:18789
+gcloud compute ssh openclaw-gateway --zone=us-central1-a -- -L 18789:127.0.0.1:18789
 ```
 
 Open in your browser:
@@ -400,17 +400,17 @@ Paste your gateway token.
 
 ## What persists where (source of truth)
 
-Moltbot runs in Docker, but Docker is not the source of truth.
+OpenClaw runs in Docker, but Docker is not the source of truth.
 All long-lived state must survive restarts, rebuilds, and reboots.
 
 | Component | Location | Persistence mechanism | Notes |
 |---|---|---|---|
-| Gateway config | `/home/node/.clawdbot/` | Host volume mount | Includes `moltbot.json`, tokens |
-| Model auth profiles | `/home/node/.clawdbot/` | Host volume mount | OAuth tokens, API keys |
-| Skill configs | `/home/node/.clawdbot/skills/` | Host volume mount | Skill-level state |
-| Agent workspace | `/home/node/clawd/` | Host volume mount | Code and agent artifacts |
-| WhatsApp session | `/home/node/.clawdbot/` | Host volume mount | Preserves QR login |
-| Gmail keyring | `/home/node/.clawdbot/` | Host volume + password | Requires `GOG_KEYRING_PASSWORD` |
+| Gateway config | `/home/node/.openclaw/` | Host volume mount | Includes `openclaw.json`, tokens |
+| Model auth profiles | `/home/node/.openclaw/` | Host volume mount | OAuth tokens, API keys |
+| Skill configs | `/home/node/.openclaw/skills/` | Host volume mount | Skill-level state |
+| Agent workspace | `/home/node/.openclaw/workspace/` | Host volume mount | Code and agent artifacts |
+| WhatsApp session | `/home/node/.openclaw/` | Host volume mount | Preserves QR login |
+| Gmail keyring | `/home/node/.openclaw/` | Host volume + password | Requires `GOG_KEYRING_PASSWORD` |
 | External binaries | `/usr/local/bin/` | Docker image | Must be baked at build time |
 | Node runtime | Container filesystem | Docker image | Rebuilt every image build |
 | OS packages | Container filesystem | Docker image | Do not install at runtime |
@@ -420,10 +420,10 @@ All long-lived state must survive restarts, rebuilds, and reboots.
 
 ## Updates
 
-To update Moltbot on the VM:
+To update OpenClaw on the VM:
 
 ```bash
-cd ~/moltbot
+cd ~/openclaw
 git pull
 docker compose build
 docker compose up -d
@@ -453,15 +453,15 @@ If using e2-micro and hitting OOM, upgrade to e2-small or e2-medium:
 
 ```bash
 # Stop the VM first
-gcloud compute instances stop moltbot-gateway --zone=us-central1-a
+gcloud compute instances stop openclaw-gateway --zone=us-central1-a
 
 # Change machine type
-gcloud compute instances set-machine-type moltbot-gateway \
+gcloud compute instances set-machine-type openclaw-gateway \
   --zone=us-central1-a \
   --machine-type=e2-small
 
 # Start the VM
-gcloud compute instances start moltbot-gateway --zone=us-central1-a
+gcloud compute instances start openclaw-gateway --zone=us-central1-a
 ```
 
 ---
@@ -474,14 +474,14 @@ For automation or CI/CD pipelines, create a dedicated service account with minim
 
 1. Create a service account:
    ```bash
-   gcloud iam service-accounts create moltbot-deploy \
-     --display-name="Moltbot Deployment"
+   gcloud iam service-accounts create openclaw-deploy \
+     --display-name="OpenClaw Deployment"
    ```
 
 2. Grant Compute Instance Admin role (or narrower custom role):
    ```bash
-   gcloud projects add-iam-policy-binding my-moltbot-project \
-     --member="serviceAccount:moltbot-deploy@my-moltbot-project.iam.gserviceaccount.com" \
+   gcloud projects add-iam-policy-binding my-openclaw-project \
+     --member="serviceAccount:openclaw-deploy@my-openclaw-project.iam.gserviceaccount.com" \
      --role="roles/compute.instanceAdmin.v1"
    ```
 

docs/platforms/hetzner.md

@@ -1,26 +1,26 @@
 ---
-summary: "Run Moltbot Gateway 24/7 on a cheap Hetzner VPS (Docker) with durable state and baked-in binaries"
+summary: "Run OpenClaw Gateway 24/7 on a cheap Hetzner VPS (Docker) with durable state and baked-in binaries"
 read_when:
-  - You want Moltbot running 24/7 on a cloud VPS (not your laptop)
+  - You want OpenClaw running 24/7 on a cloud VPS (not your laptop)
   - You want a production-grade, always-on Gateway on your own VPS
   - You want full control over persistence, binaries, and restart behavior
-  - You are running Moltbot in Docker on Hetzner or a similar provider
+  - You are running OpenClaw in Docker on Hetzner or a similar provider
 ---
 
-# Moltbot on Hetzner (Docker, Production VPS Guide)
+# OpenClaw on Hetzner (Docker, Production VPS Guide)
 
 ## Goal
-Run a persistent Moltbot Gateway on a Hetzner VPS using Docker, with durable state, baked-in binaries, and safe restart behavior.
+Run a persistent OpenClaw Gateway on a Hetzner VPS using Docker, with durable state, baked-in binaries, and safe restart behavior.
 
-If you want “Moltbot 24/7 for ~$5”, this is the simplest reliable setup.
+If you want “OpenClaw 24/7 for ~$5”, this is the simplest reliable setup.
 Hetzner pricing changes; pick the smallest Debian/Ubuntu VPS and scale up if you hit OOMs.
 
 ## What are we doing (simple terms)?
 
 - Rent a small Linux server (Hetzner VPS)
 - Install Docker (isolated app runtime)
-- Start the Moltbot Gateway in Docker
-- Persist `~/.clawdbot` + `~/clawd` on the host (survives restarts/rebuilds)
+- Start the OpenClaw Gateway in Docker
+- Persist `~/.openclaw` + `~/.openclaw/workspace` on the host (survives restarts/rebuilds)
 - Access the Control UI from your laptop via an SSH tunnel
 
 The Gateway can be accessed via:
@@ -37,7 +37,7 @@ For the generic Docker flow, see [Docker](/install/docker).
 
 1) Provision Hetzner VPS  
 2) Install Docker  
-3) Clone Moltbot repository  
+3) Clone OpenClaw repository  
 4) Create persistent host directories  
 5) Configure `.env` and `docker-compose.yml`  
 6) Bake required binaries into the image  
@@ -93,11 +93,11 @@ docker compose version
 
 ---
 
-## 3) Clone the Moltbot repository
+## 3) Clone the OpenClaw repository
 
 ```bash
-git clone https://github.com/moltbot/moltbot.git
-cd moltbot
+git clone https://github.com/openclaw/openclaw.git
+cd openclaw
 ```
 
 This guide assumes you will build a custom image to guarantee binary persistence.
@@ -110,12 +110,12 @@ Docker containers are ephemeral.
 All long-lived state must live on the host.
 
 ```bash
-mkdir -p /root/.clawdbot
-mkdir -p /root/clawd
+mkdir -p /root/.openclaw
+mkdir -p /root/.openclaw/workspace
 
 # Set ownership to the container user (uid 1000):
-chown -R 1000:1000 /root/.clawdbot
-chown -R 1000:1000 /root/clawd
+chown -R 1000:1000 /root/.openclaw
+chown -R 1000:1000 /root/.openclaw/workspace
 ```
 
 ---
@@ -125,16 +125,16 @@ chown -R 1000:1000 /root/clawd
 Create `.env` in the repository root.
 
 ```bash
-CLAWDBOT_IMAGE=moltbot:latest
-CLAWDBOT_GATEWAY_TOKEN=change-me-now
-CLAWDBOT_GATEWAY_BIND=lan
-CLAWDBOT_GATEWAY_PORT=18789
+OPENCLAW_IMAGE=openclaw:latest
+OPENCLAW_GATEWAY_TOKEN=change-me-now
+OPENCLAW_GATEWAY_BIND=lan
+OPENCLAW_GATEWAY_PORT=18789
 
-CLAWDBOT_CONFIG_DIR=/root/.clawdbot
-CLAWDBOT_WORKSPACE_DIR=/root/clawd
+OPENCLAW_CONFIG_DIR=/root/.openclaw
+OPENCLAW_WORKSPACE_DIR=/root/.openclaw/workspace
 
 GOG_KEYRING_PASSWORD=change-me-now
-XDG_CONFIG_HOME=/home/node/.clawdbot
+XDG_CONFIG_HOME=/home/node/.openclaw
 ```
 
 Generate strong secrets:
@@ -153,8 +153,8 @@ Create or update `docker-compose.yml`.
 
 ```yaml
 services:
-  moltbot-gateway:
-    image: ${CLAWDBOT_IMAGE}
+  openclaw-gateway:
+    image: ${OPENCLAW_IMAGE}
     build: .
     restart: unless-stopped
     env_file:
@@ -163,19 +163,19 @@ services:
       - HOME=/home/node
       - NODE_ENV=production
       - TERM=xterm-256color
-      - CLAWDBOT_GATEWAY_BIND=${CLAWDBOT_GATEWAY_BIND}
-      - CLAWDBOT_GATEWAY_PORT=${CLAWDBOT_GATEWAY_PORT}
-      - CLAWDBOT_GATEWAY_TOKEN=${CLAWDBOT_GATEWAY_TOKEN}
+      - OPENCLAW_GATEWAY_BIND=${OPENCLAW_GATEWAY_BIND}
+      - OPENCLAW_GATEWAY_PORT=${OPENCLAW_GATEWAY_PORT}
+      - OPENCLAW_GATEWAY_TOKEN=${OPENCLAW_GATEWAY_TOKEN}
       - GOG_KEYRING_PASSWORD=${GOG_KEYRING_PASSWORD}
       - XDG_CONFIG_HOME=${XDG_CONFIG_HOME}
       - PATH=/home/linuxbrew/.linuxbrew/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
     volumes:
-      - ${CLAWDBOT_CONFIG_DIR}:/home/node/.clawdbot
-      - ${CLAWDBOT_WORKSPACE_DIR}:/home/node/clawd
+      - ${OPENCLAW_CONFIG_DIR}:/home/node/.openclaw
+      - ${OPENCLAW_WORKSPACE_DIR}:/home/node/.openclaw/workspace
     ports:
       # Recommended: keep the Gateway loopback-only on the VPS; access via SSH tunnel.
       # To expose it publicly, remove the `127.0.0.1:` prefix and firewall accordingly.
-      - "127.0.0.1:${CLAWDBOT_GATEWAY_PORT}:18789"
+      - "127.0.0.1:${OPENCLAW_GATEWAY_PORT}:18789"
 
       # Optional: only if you run iOS/Android nodes against this VPS and need Canvas host.
       # If you expose this publicly, read /gateway/security and firewall accordingly.
@@ -186,9 +186,9 @@ services:
         "dist/index.js",
         "gateway",
         "--bind",
-        "${CLAWDBOT_GATEWAY_BIND}",
+        "${OPENCLAW_GATEWAY_BIND}",
         "--port",
-        "${CLAWDBOT_GATEWAY_PORT}"
+        "${OPENCLAW_GATEWAY_PORT}"
       ]
 ```
 
@@ -259,15 +259,15 @@ CMD ["node","dist/index.js"]
 
 ```bash
 docker compose build
-docker compose up -d moltbot-gateway
+docker compose up -d openclaw-gateway
 ```
 
 Verify binaries:
 
 ```bash
-docker compose exec moltbot-gateway which gog
-docker compose exec moltbot-gateway which goplaces
-docker compose exec moltbot-gateway which wacli
+docker compose exec openclaw-gateway which gog
+docker compose exec openclaw-gateway which goplaces
+docker compose exec openclaw-gateway which wacli
 ```
 
 Expected output:
@@ -283,7 +283,7 @@ Expected output:
 ## 9) Verify Gateway
 
 ```bash
-docker compose logs -f moltbot-gateway
+docker compose logs -f openclaw-gateway
 ```
 
 Success:
@@ -308,17 +308,17 @@ Paste your gateway token.
 
 ## What persists where (source of truth)
 
-Moltbot runs in Docker, but Docker is not the source of truth.
+OpenClaw runs in Docker, but Docker is not the source of truth.
 All long-lived state must survive restarts, rebuilds, and reboots.
 
 | Component | Location | Persistence mechanism | Notes |
 |---|---|---|---|
-| Gateway config | `/home/node/.clawdbot/` | Host volume mount | Includes `moltbot.json`, tokens |
-| Model auth profiles | `/home/node/.clawdbot/` | Host volume mount | OAuth tokens, API keys |
-| Skill configs | `/home/node/.clawdbot/skills/` | Host volume mount | Skill-level state |
-| Agent workspace | `/home/node/clawd/` | Host volume mount | Code and agent artifacts |
-| WhatsApp session | `/home/node/.clawdbot/` | Host volume mount | Preserves QR login |
-| Gmail keyring | `/home/node/.clawdbot/` | Host volume + password | Requires `GOG_KEYRING_PASSWORD` |
+| Gateway config | `/home/node/.openclaw/` | Host volume mount | Includes `openclaw.json`, tokens |
+| Model auth profiles | `/home/node/.openclaw/` | Host volume mount | OAuth tokens, API keys |
+| Skill configs | `/home/node/.openclaw/skills/` | Host volume mount | Skill-level state |
+| Agent workspace | `/home/node/.openclaw/workspace/` | Host volume mount | Code and agent artifacts |
+| WhatsApp session | `/home/node/.openclaw/` | Host volume mount | Preserves QR login |
+| Gmail keyring | `/home/node/.openclaw/` | Host volume + password | Requires `GOG_KEYRING_PASSWORD` |
 | External binaries | `/usr/local/bin/` | Docker image | Must be baked at build time |
 | Node runtime | Container filesystem | Docker image | Rebuilt every image build |
 | OS packages | Container filesystem | Docker image | Do not install at runtime |

docs/platforms/index.md

@@ -6,7 +6,7 @@ read_when:
 ---
 # Platforms
 
-Moltbot core is written in TypeScript. **Node is the recommended runtime**.
+OpenClaw core is written in TypeScript. **Node is the recommended runtime**.
 Bun is not recommended for the Gateway (WhatsApp/Telegram bugs).
 
 Companion apps exist for macOS (menu bar app) and mobile nodes (iOS/Android). Windows and
@@ -34,17 +34,17 @@ Native companion apps for Windows are also planned; the Gateway is recommended v
 - Install guide: [Getting Started](/start/getting-started)
 - Gateway runbook: [Gateway](/gateway)
 - Gateway configuration: [Configuration](/gateway/configuration)
-- Service status: `moltbot gateway status`
+- Service status: `openclaw gateway status`
 
 ## Gateway service install (CLI)
 
 Use one of these (all supported):
 
-- Wizard (recommended): `moltbot onboard --install-daemon`
-- Direct: `moltbot gateway install`
-- Configure flow: `moltbot configure` → select **Gateway service**
-- Repair/migrate: `moltbot doctor` (offers to install or fix the service)
+- Wizard (recommended): `openclaw onboard --install-daemon`
+- Direct: `openclaw gateway install`
+- Configure flow: `openclaw configure` → select **Gateway service**
+- Repair/migrate: `openclaw doctor` (offers to install or fix the service)
 
 The service target depends on OS:
-- macOS: LaunchAgent (`bot.molt.gateway` or `bot.molt.<profile>`; legacy `com.clawdbot.*`)
-- Linux/WSL2: systemd user service (`moltbot-gateway[-<profile>].service`)
+- macOS: LaunchAgent (`bot.molt.gateway` or `bot.molt.<profile>`; legacy `com.openclaw.*`)
+- Linux/WSL2: systemd user service (`openclaw-gateway[-<profile>].service`)

docs/platforms/ios.md

@@ -20,7 +20,7 @@ Availability: internal preview. The iOS app is not publicly distributed yet.
 - Gateway running on another device (macOS, Linux, or Windows via WSL2).
 - Network path:
   - Same LAN via Bonjour, **or**
-  - Tailnet via unicast DNS-SD (`moltbot.internal.`), **or**
+  - Tailnet via unicast DNS-SD (example domain: `openclaw.internal.`), **or**
   - Manual host/port (fallback).
 
 ## Quick start (pair + connect)
@@ -28,7 +28,7 @@ Availability: internal preview. The iOS app is not publicly distributed yet.
 1) Start the Gateway:
 
 ```bash
-moltbot gateway --port 18789
+openclaw gateway --port 18789
 ```
 
 2) In the iOS app, open Settings and pick a discovered gateway (or enable Manual Host and enter host/port).
@@ -36,26 +36,26 @@ moltbot gateway --port 18789
 3) Approve the pairing request on the gateway host:
 
 ```bash
-moltbot nodes pending
-moltbot nodes approve <requestId>
+openclaw nodes pending
+openclaw nodes approve <requestId>
 ```
 
 4) Verify connection:
 
 ```bash
-moltbot nodes status
-moltbot gateway call node.list --params "{}"
+openclaw nodes status
+openclaw gateway call node.list --params "{}"
 ```
 
 ## Discovery paths
 
 ### Bonjour (LAN)
 
-The Gateway advertises `_moltbot._tcp` on `local.`. The iOS app lists these automatically.
+The Gateway advertises `_openclaw-gw._tcp` on `local.`. The iOS app lists these automatically.
 
 ### Tailnet (cross-network)
 
-If mDNS is blocked, use a unicast DNS-SD zone (recommended domain: `moltbot.internal.`) and Tailscale split DNS.
+If mDNS is blocked, use a unicast DNS-SD zone (choose a domain; example: `openclaw.internal.`) and Tailscale split DNS.
 See [Bonjour](/gateway/bonjour) for the CoreDNS example.
 
 ### Manual host/port
@@ -67,22 +67,22 @@ In Settings, enable **Manual Host** and enter the gateway host + port (default `
 The iOS node renders a WKWebView canvas. Use `node.invoke` to drive it:
 
 ```bash
-moltbot nodes invoke --node "iOS Node" --command canvas.navigate --params '{"url":"http://<gateway-host>:18793/__moltbot__/canvas/"}'
+openclaw nodes invoke --node "iOS Node" --command canvas.navigate --params '{"url":"http://<gateway-host>:18793/__openclaw__/canvas/"}'
 ```
 
 Notes:
-- The Gateway canvas host serves `/__moltbot__/canvas/` and `/__moltbot__/a2ui/`.
+- The Gateway canvas host serves `/__openclaw__/canvas/` and `/__openclaw__/a2ui/`.
 - The iOS node auto-navigates to A2UI on connect when a canvas host URL is advertised.
 - Return to the built-in scaffold with `canvas.navigate` and `{"url":""}`.
 
 ### Canvas eval / snapshot
 
 ```bash
-moltbot nodes invoke --node "iOS Node" --command canvas.eval --params '{"javaScript":"(() => { const {ctx} = window.__moltbot; ctx.clearRect(0,0,innerWidth,innerHeight); ctx.lineWidth=6; ctx.strokeStyle=\"#ff2d55\"; ctx.beginPath(); ctx.moveTo(40,40); ctx.lineTo(innerWidth-40, innerHeight-40); ctx.stroke(); return \"ok\"; })()"}'
+openclaw nodes invoke --node "iOS Node" --command canvas.eval --params '{"javaScript":"(() => { const {ctx} = window.__openclaw; ctx.clearRect(0,0,innerWidth,innerHeight); ctx.lineWidth=6; ctx.strokeStyle=\"#ff2d55\"; ctx.beginPath(); ctx.moveTo(40,40); ctx.lineTo(innerWidth-40, innerHeight-40); ctx.stroke(); return \"ok\"; })()"}'
 ```
 
 ```bash
-moltbot nodes invoke --node "iOS Node" --command canvas.snapshot --params '{"maxWidth":900,"format":"jpeg"}'
+openclaw nodes invoke --node "iOS Node" --command canvas.snapshot --params '{"maxWidth":900,"format":"jpeg"}'
 ```
 
 ## Voice wake + talk mode
@@ -94,7 +94,7 @@ moltbot nodes invoke --node "iOS Node" --command canvas.snapshot --params '{"max
 
 - `NODE_BACKGROUND_UNAVAILABLE`: bring the iOS app to the foreground (canvas/camera/screen commands require it).
 - `A2UI_HOST_NOT_CONFIGURED`: the Gateway did not advertise a canvas host URL; check `canvasHost` in [Gateway configuration](/gateway/configuration).
-- Pairing prompt never appears: run `moltbot nodes pending` and approve manually.
+- Pairing prompt never appears: run `openclaw nodes pending` and approve manually.
 - Reconnect fails after reinstall: the Keychain pairing token was cleared; re-pair the node.
 
 ## Related docs

docs/platforms/linux.md

@@ -14,8 +14,8 @@ Native Linux companion apps are planned. Contributions are welcome if you want t
 ## Beginner quick path (VPS)
 
 1) Install Node 22+  
-2) `npm i -g moltbot@latest`  
-3) `moltbot onboard --install-daemon`  
+2) `npm i -g openclaw@latest`  
+3) `openclaw onboard --install-daemon`  
 4) From your laptop: `ssh -N -L 18789:127.0.0.1:18789 <user>@<host>`  
 5) Open `http://127.0.0.1:18789/` and paste your token
 
@@ -35,19 +35,19 @@ Step-by-step VPS guide: [exe.dev](/platforms/exe-dev)
 Use one of these:
 
 ```
-moltbot onboard --install-daemon
+openclaw onboard --install-daemon
 ```
 
 Or:
 
 ```
-moltbot gateway install
+openclaw gateway install
 ```
 
 Or:
 
 ```
-moltbot configure
+openclaw configure
 ```
 
 Select **Gateway service** when prompted.
@@ -55,26 +55,26 @@ Select **Gateway service** when prompted.
 Repair/migrate:
 
 ```
-moltbot doctor
+openclaw doctor
 ```
 
 ## System control (systemd user unit)
-Moltbot installs a systemd **user** service by default. Use a **system**
+OpenClaw installs a systemd **user** service by default. Use a **system**
 service for shared or always-on servers. The full unit example and guidance
 live in the [Gateway runbook](/gateway).
 
 Minimal setup:
 
-Create `~/.config/systemd/user/moltbot-gateway[-<profile>].service`:
+Create `~/.config/systemd/user/openclaw-gateway[-<profile>].service`:
 
 ```
 [Unit]
-Description=Moltbot Gateway (profile: <profile>, v<version>)
+Description=OpenClaw Gateway (profile: <profile>, v<version>)
 After=network-online.target
 Wants=network-online.target
 
 [Service]
-ExecStart=/usr/local/bin/moltbot gateway --port 18789
+ExecStart=/usr/local/bin/openclaw gateway --port 18789
 Restart=always
 RestartSec=5
 
@@ -85,5 +85,5 @@ WantedBy=default.target
 Enable it:
 
 ```
-systemctl --user enable --now moltbot-gateway[-<profile>].service
+systemctl --user enable --now openclaw-gateway[-<profile>].service
 ```

docs/platforms/mac/bundled-gateway.md

@@ -1,24 +1,24 @@
 ---
 summary: "Gateway runtime on macOS (external launchd service)"
 read_when:
-  - Packaging Moltbot.app
+  - Packaging OpenClaw.app
   - Debugging the macOS gateway launchd service
   - Installing the gateway CLI for macOS
 ---
 
 # Gateway on macOS (external launchd)
 
-Moltbot.app no longer bundles Node/Bun or the Gateway runtime. The macOS app
-expects an **external** `moltbot` CLI install, does not spawn the Gateway as a
+OpenClaw.app no longer bundles Node/Bun or the Gateway runtime. The macOS app
+expects an **external** `openclaw` CLI install, does not spawn the Gateway as a
 child process, and manages a per‑user launchd service to keep the Gateway
 running (or attaches to an existing local Gateway if one is already running).
 
 ## Install the CLI (required for local mode)
 
-You need Node 22+ on the Mac, then install `moltbot` globally:
+You need Node 22+ on the Mac, then install `openclaw` globally:
 
 ```bash
-npm install -g moltbot@<version>
+npm install -g openclaw@<version>
 ```
 
 The macOS app’s **Install CLI** button runs the same flow via npm/pnpm (bun not recommended for Gateway runtime).
@@ -26,7 +26,7 @@ The macOS app’s **Install CLI** button runs the same flow via npm/pnpm (bun no
 ## Launchd (Gateway as LaunchAgent)
 
 Label:
-- `bot.molt.gateway` (or `bot.molt.<profile>`; legacy `com.clawdbot.*` may remain)
+- `bot.molt.gateway` (or `bot.molt.<profile>`; legacy `com.openclaw.*` may remain)
 
 Plist location (per‑user):
 - `~/Library/LaunchAgents/bot.molt.gateway.plist`
@@ -34,16 +34,16 @@ Plist location (per‑user):
 
 Manager:
 - The macOS app owns LaunchAgent install/update in Local mode.
-- The CLI can also install it: `moltbot gateway install`.
+- The CLI can also install it: `openclaw gateway install`.
 
 Behavior:
-- “Moltbot Active” enables/disables the LaunchAgent.
+- “OpenClaw Active” enables/disables the LaunchAgent.
 - App quit does **not** stop the gateway (launchd keeps it alive).
 - If a Gateway is already running on the configured port, the app attaches to
   it instead of starting a new one.
 
 Logging:
-- launchd stdout/err: `/tmp/moltbot/moltbot-gateway.log`
+- launchd stdout/err: `/tmp/openclaw/openclaw-gateway.log`
 
 ## Version compatibility
 
@@ -53,15 +53,15 @@ incompatible, update the global CLI to match the app version.
 ## Smoke check
 
 ```bash
-moltbot --version
+openclaw --version
 
-CLAWDBOT_SKIP_CHANNELS=1 \
-CLAWDBOT_SKIP_CANVAS_HOST=1 \
-moltbot gateway --port 18999 --bind loopback
+OPENCLAW_SKIP_CHANNELS=1 \
+OPENCLAW_SKIP_CANVAS_HOST=1 \
+openclaw gateway --port 18999 --bind loopback
 ```
 
 Then:
 
 ```bash
-moltbot gateway call health --url ws://127.0.0.1:18999 --timeout 3000
+openclaw gateway call health --url ws://127.0.0.1:18999 --timeout 3000
 ```

docs/platforms/mac/canvas.md

@@ -15,16 +15,16 @@ UI surfaces.
 
 Canvas state is stored under Application Support:
 
-- `~/Library/Application Support/Moltbot/canvas/<session>/...`
+- `~/Library/Application Support/OpenClaw/canvas/<session>/...`
 
 The Canvas panel serves those files via a **custom URL scheme**:
 
-- `moltbot-canvas://<session>/<path>`
+- `openclaw-canvas://<session>/<path>`
 
 Examples:
-- `moltbot-canvas://main/` → `<canvasRoot>/main/index.html`
-- `moltbot-canvas://main/assets/app.css` → `<canvasRoot>/main/assets/app.css`
-- `moltbot-canvas://main/widgets/todo/` → `<canvasRoot>/main/widgets/todo/index.html`
+- `openclaw-canvas://main/` → `<canvasRoot>/main/index.html`
+- `openclaw-canvas://main/assets/app.css` → `<canvasRoot>/main/assets/app.css`
+- `openclaw-canvas://main/widgets/todo/` → `<canvasRoot>/main/widgets/todo/index.html`
 
 If no `index.html` exists at the root, the app shows a **built‑in scaffold page**.
 
@@ -50,10 +50,10 @@ Canvas is exposed via the **Gateway WebSocket**, so the agent can:
 CLI examples:
 
 ```bash
-moltbot nodes canvas present --node <id>
-moltbot nodes canvas navigate --node <id> --url "/"
-moltbot nodes canvas eval --node <id> --js "document.title"
-moltbot nodes canvas snapshot --node <id>
+openclaw nodes canvas present --node <id>
+openclaw nodes canvas navigate --node <id> --url "/"
+openclaw nodes canvas eval --node <id> --js "document.title"
+openclaw nodes canvas snapshot --node <id>
 ```
 
 Notes:
@@ -69,7 +69,7 @@ A2UI host page on first open.
 Default A2UI host URL:
 
 ```
-http://<gateway-host>:18793/__moltbot__/a2ui/
+http://<gateway-host>:18793/__openclaw__/a2ui/
 ```
 
 ### A2UI commands (v0.8)
@@ -91,25 +91,25 @@ cat > /tmp/a2ui-v0.8.jsonl <<'EOFA2'
 {"beginRendering":{"surfaceId":"main","root":"root"}}
 EOFA2
 
-moltbot nodes canvas a2ui push --jsonl /tmp/a2ui-v0.8.jsonl --node <id>
+openclaw nodes canvas a2ui push --jsonl /tmp/a2ui-v0.8.jsonl --node <id>
 ```
 
 Quick smoke:
 
 ```bash
-moltbot nodes canvas a2ui push --node <id> --text "Hello from A2UI"
+openclaw nodes canvas a2ui push --node <id> --text "Hello from A2UI"
 ```
 
 ## Triggering agent runs from Canvas
 
 Canvas can trigger new agent runs via deep links:
 
-- `moltbot://agent?...`
+- `openclaw://agent?...`
 
 Example (in JS):
 
 ```js
-window.location.href = "moltbot://agent?message=Review%20this%20design";
+window.location.href = "openclaw://agent?message=Review%20this%20design";
 ```
 
 The app prompts for confirmation unless a valid key is provided.

docs/platforms/mac/child-process.md

@@ -8,7 +8,7 @@ read_when:
 The macOS app **manages the Gateway via launchd** by default and does not spawn
 the Gateway as a child process. It first tries to attach to an already‑running
 Gateway on the configured port; if none is reachable, it enables the launchd
-service via the external `moltbot` CLI (no embedded runtime). This gives you
+service via the external `openclaw` CLI (no embedded runtime). This gives you
 reliable auto‑start at login and restart on crashes.
 
 Child‑process mode (Gateway spawned directly by the app) is **not in use** today.
@@ -17,7 +17,7 @@ If you need tighter coupling to the UI, run the Gateway manually in a terminal.
 ## Default behavior (launchd)
 
 - The app installs a per‑user LaunchAgent labeled `bot.molt.gateway`
-  (or `bot.molt.<profile>` when using `--profile`/`CLAWDBOT_PROFILE`; legacy `com.clawdbot.*` is supported).
+  (or `bot.molt.<profile>` when using `--profile`/`OPENCLAW_PROFILE`; legacy `com.openclaw.*` is supported).
 - When Local mode is enabled, the app ensures the LaunchAgent is loaded and
   starts the Gateway if needed.
 - Logs are written to the launchd gateway log path (visible in Debug Settings).
@@ -36,19 +36,19 @@ Replace the label with `bot.molt.<profile>` when running a named profile.
 `scripts/restart-mac.sh --no-sign` is for fast local builds when you don’t have
 signing keys. To prevent launchd from pointing at an unsigned relay binary, it:
 
-- Writes `~/.clawdbot/disable-launchagent`.
+- Writes `~/.openclaw/disable-launchagent`.
 
 Signed runs of `scripts/restart-mac.sh` clear this override if the marker is
 present. To reset manually:
 
 ```bash
-rm ~/.clawdbot/disable-launchagent
+rm ~/.openclaw/disable-launchagent
 ```
 
 ## Attach-only mode
 
 To force the macOS app to **never install or manage launchd**, launch it with
-`--attach-only` (or `--no-launchd`). This sets `~/.clawdbot/disable-launchagent`,
+`--attach-only` (or `--no-launchd`). This sets `~/.openclaw/disable-launchagent`,
 so the app only attaches to an already running Gateway. You can toggle the same
 behavior in Debug Settings.
 

docs/platforms/mac/dev-setup.md

@@ -1,11 +1,11 @@
 ---
-summary: "Setup guide for developers working on the Moltbot macOS app"
+summary: "Setup guide for developers working on the OpenClaw macOS app"
 read_when:
   - Setting up the macOS development environment
 ---
 # macOS Developer Setup
 
-This guide covers the necessary steps to build and run the Moltbot macOS application from source.
+This guide covers the necessary steps to build and run the OpenClaw macOS application from source.
 
 ## Prerequisites
 
@@ -24,7 +24,7 @@ pnpm install
 
 ## 2. Build and Package the App
 
-To build the macOS app and package it into `dist/Moltbot.app`, run:
+To build the macOS app and package it into `dist/OpenClaw.app`, run:
 
 ```bash
 ./scripts/package-mac-app.sh
@@ -33,22 +33,22 @@ To build the macOS app and package it into `dist/Moltbot.app`, run:
 If you don't have an Apple Developer ID certificate, the script will automatically use **ad-hoc signing** (`-`). 
 
 For dev run modes, signing flags, and Team ID troubleshooting, see the macOS app README:
-https://github.com/moltbot/moltbot/blob/main/apps/macos/README.md
+https://github.com/openclaw/openclaw/blob/main/apps/macos/README.md
 
 > **Note**: Ad-hoc signed apps may trigger security prompts. If the app crashes immediately with "Abort trap 6", see the [Troubleshooting](#troubleshooting) section.
 
 ## 3. Install the CLI
 
-The macOS app expects a global `moltbot` CLI install to manage background tasks.
+The macOS app expects a global `openclaw` CLI install to manage background tasks.
 
 **To install it (recommended):**
-1.  Open the Moltbot app.
+1.  Open the OpenClaw app.
 2.  Go to the **General** settings tab.
 3.  Click **"Install CLI"**.
 
 Alternatively, install it manually:
 ```bash
-npm install -g moltbot@<version>
+npm install -g openclaw@<version>
 ```
 
 ## Troubleshooting
@@ -76,14 +76,14 @@ If the app crashes when you try to allow **Speech Recognition** or **Microphone*
    ```bash
    tccutil reset All bot.molt.mac.debug
    ```
-2. If that fails, change the `BUNDLE_ID` temporarily in [`scripts/package-mac-app.sh`](https://github.com/moltbot/moltbot/blob/main/scripts/package-mac-app.sh) to force a "clean slate" from macOS.
+2. If that fails, change the `BUNDLE_ID` temporarily in [`scripts/package-mac-app.sh`](https://github.com/openclaw/openclaw/blob/main/scripts/package-mac-app.sh) to force a "clean slate" from macOS.
 
 ### Gateway "Starting..." indefinitely
 If the gateway status stays on "Starting...", check if a zombie process is holding the port:
 
 ```bash
-moltbot gateway status
-moltbot gateway stop
+openclaw gateway status
+openclaw gateway stop
 
 # If you’re not using a LaunchAgent (dev mode / manual runs), find the listener:
 lsof -nP -iTCP:18789 -sTCP:LISTEN

docs/platforms/mac/health.md

@@ -21,8 +21,8 @@ How to see whether the linked channel is healthy from the menu bar app.
 - **Channels tab** surfaces channel status + controls for WhatsApp/Telegram (login QR, logout, probe, last disconnect/error).
 
 ## How the probe works
-- App runs `moltbot health --json` via `ShellExecutor` every ~60s and on demand. The probe loads creds and reports status without sending messages.
+- App runs `openclaw health --json` via `ShellExecutor` every ~60s and on demand. The probe loads creds and reports status without sending messages.
 - Cache the last good snapshot and the last error separately to avoid flicker; show the timestamp of each.
 
 ## When in doubt
-- You can still use the CLI flow in [Gateway health](/gateway/health) (`moltbot status`, `moltbot status --deep`, `moltbot health --json`) and tail `/tmp/moltbot/moltbot-*.log` for `web-heartbeat` / `web-reconnect`.
+- You can still use the CLI flow in [Gateway health](/gateway/health) (`openclaw status`, `openclaw status --deep`, `openclaw health --json`) and tail `/tmp/openclaw/openclaw-*.log` for `web-heartbeat` / `web-reconnect`.

docs/platforms/mac/icon.md

@@ -1,5 +1,5 @@
 ---
-summary: "Menu bar icon states and animations for Moltbot on macOS"
+summary: "Menu bar icon states and animations for OpenClaw on macOS"
 read_when:
   - Changing menu bar icon behavior
 ---

docs/platforms/mac/logging.md

@@ -1,5 +1,5 @@
 ---
-summary: "Moltbot logging: rolling diagnostics file log + unified log privacy flags"
+summary: "OpenClaw logging: rolling diagnostics file log + unified log privacy flags"
 read_when:
   - Capturing macOS logs or investigating private data logging
   - Debugging voice wake/session lifecycle issues
@@ -7,11 +7,11 @@ read_when:
 # Logging (macOS)
 
 ## Rolling diagnostics file log (Debug pane)
-Moltbot routes macOS app logs through swift-log (unified logging by default) and can write a local, rotating file log to disk when you need a durable capture.
+OpenClaw routes macOS app logs through swift-log (unified logging by default) and can write a local, rotating file log to disk when you need a durable capture.
 
 - Verbosity: **Debug pane → Logs → App logging → Verbosity**
 - Enable: **Debug pane → Logs → App logging → “Write rolling diagnostics log (JSONL)”**
-- Location: `~/Library/Logs/Moltbot/diagnostics.jsonl` (rotates automatically; old files are suffixed with `.1`, `.2`, …)
+- Location: `~/Library/Logs/OpenClaw/diagnostics.jsonl` (rotates automatically; old files are suffixed with `.1`, `.2`, …)
 - Clear: **Debug pane → Logs → App logging → “Clear”**
 
 Notes:
@@ -22,7 +22,7 @@ Notes:
 
 Unified logging redacts most payloads unless a subsystem opts into `privacy -off`. Per Peter's write-up on macOS [logging privacy shenanigans](https://steipete.me/posts/2025/logging-privacy-shenanigans) (2025) this is controlled by a plist in `/Library/Preferences/Logging/Subsystems/` keyed by the subsystem name. Only new log entries pick up the flag, so enable it before reproducing an issue.
 
-## Enable for Moltbot (`bot.molt`)
+## Enable for OpenClaw (`bot.molt`)
 - Write the plist to a temp file first, then install it atomically as root:
 
 ```bash

docs/platforms/mac/menu-bar.md

@@ -40,7 +40,7 @@ read_when:
 
 ## Status row text (menu)
 - While work is active: `<Session role> · <activity label>`
-  - Examples: `Main · exec: pnpm test`, `Other · read: apps/macos/Sources/Moltbot/AppState.swift`.
+  - Examples: `Main · exec: pnpm test`, `Other · read: apps/macos/Sources/OpenClaw/AppState.swift`.
 - When idle: falls back to the health summary.
 
 ## Event ingestion

docs/platforms/mac/peekaboo.md

@@ -1,28 +1,28 @@
 ---
 summary: "PeekabooBridge integration for macOS UI automation"
 read_when:
-  - Hosting PeekabooBridge in Moltbot.app
+  - Hosting PeekabooBridge in OpenClaw.app
   - Integrating Peekaboo via Swift Package Manager
   - Changing PeekabooBridge protocol/paths
 ---
 # Peekaboo Bridge (macOS UI automation)
 
-Moltbot can host **PeekabooBridge** as a local, permission‑aware UI automation
+OpenClaw can host **PeekabooBridge** as a local, permission‑aware UI automation
 broker. This lets the `peekaboo` CLI drive UI automation while reusing the
 macOS app’s TCC permissions.
 
 ## What this is (and isn’t)
 
-- **Host**: Moltbot.app can act as a PeekabooBridge host.
-- **Client**: use the `peekaboo` CLI (no separate `moltbot ui ...` surface).
-- **UI**: visual overlays stay in Peekaboo.app; Moltbot is a thin broker host.
+- **Host**: OpenClaw.app can act as a PeekabooBridge host.
+- **Client**: use the `peekaboo` CLI (no separate `openclaw ui ...` surface).
+- **UI**: visual overlays stay in Peekaboo.app; OpenClaw is a thin broker host.
 
 ## Enable the bridge
 
 In the macOS app:
 - Settings → **Enable Peekaboo Bridge**
 
-When enabled, Moltbot starts a local UNIX socket server. If disabled, the host
+When enabled, OpenClaw starts a local UNIX socket server. If disabled, the host
 is stopped and `peekaboo` will fall back to other available hosts.
 
 ## Client discovery order
@@ -31,7 +31,7 @@ Peekaboo clients typically try hosts in this order:
 
 1. Peekaboo.app (full UX)
 2. Claude.app (if installed)
-3. Moltbot.app (thin broker)
+3. OpenClaw.app (thin broker)
 
 Use `peekaboo bridge status --verbose` to see which host is active and which
 socket path is in use. You can override with:
@@ -43,7 +43,7 @@ export PEEKABOO_BRIDGE_SOCKET=/path/to/bridge.sock
 ## Security & permissions
 
 - The bridge validates **caller code signatures**; an allowlist of TeamIDs is
-  enforced (Peekaboo host TeamID + Moltbot app TeamID).
+  enforced (Peekaboo host TeamID + OpenClaw app TeamID).
 - Requests time out after ~10 seconds.
 - If required permissions are missing, the bridge returns a clear error message
   rather than launching System Settings.
@@ -58,5 +58,5 @@ If you need longer retention, re‑capture from the client.
 - If `peekaboo` reports “bridge client is not authorized”, ensure the client is
   properly signed or run the host with `PEEKABOO_ALLOW_UNSIGNED_SOCKET_CLIENTS=1`
   in **debug** mode only.
-- If no hosts are found, open one of the host apps (Peekaboo.app or Moltbot.app)
+- If no hosts are found, open one of the host apps (Peekaboo.app or OpenClaw.app)
   and confirm permissions are granted.

docs/platforms/mac/permissions.md

@@ -12,7 +12,7 @@ app's code signature, bundle identifier, and on-disk path. If any of those chang
 macOS treats the app as new and may drop or hide prompts.
 
 ## Requirements for stable permissions
-- Same path: run the app from a fixed location (for Moltbot, `dist/Moltbot.app`).
+- Same path: run the app from a fixed location (for OpenClaw, `dist/OpenClaw.app`).
 - Same bundle identifier: changing the bundle ID creates a new permission identity.
 - Signed app: unsigned or ad-hoc signed builds do not persist permissions.
 - Consistent signature: use a real Apple Development or Developer ID certificate

docs/platforms/mac/release.md

@@ -1,11 +1,11 @@
 ---
-summary: "Moltbot macOS release checklist (Sparkle feed, packaging, signing)"
+summary: "OpenClaw macOS release checklist (Sparkle feed, packaging, signing)"
 read_when:
-  - Cutting or validating a Moltbot macOS release
+  - Cutting or validating a OpenClaw macOS release
   - Updating the Sparkle appcast or feed assets
 ---
 
-# Moltbot macOS release (Sparkle)
+# OpenClaw macOS release (Sparkle)
 
 This app now ships Sparkle auto-updates. Release builds must be Developer ID–signed, zipped, and published with a signed appcast entry.
 
@@ -13,10 +13,10 @@ This app now ships Sparkle auto-updates. Release builds must be Developer ID–s
 - Developer ID Application cert installed (example: `Developer ID Application: <Developer Name> (<TEAMID>)`).
 - Sparkle private key path set in the environment as `SPARKLE_PRIVATE_KEY_FILE` (path to your Sparkle ed25519 private key; public key baked into Info.plist). If it is missing, check `~/.profile`.
 - Notary credentials (keychain profile or API key) for `xcrun notarytool` if you want Gatekeeper-safe DMG/zip distribution.
-  - We use a Keychain profile named `moltbot-notary`, created from App Store Connect API key env vars in your shell profile:
+  - We use a Keychain profile named `openclaw-notary`, created from App Store Connect API key env vars in your shell profile:
     - `APP_STORE_CONNECT_API_KEY_P8`, `APP_STORE_CONNECT_KEY_ID`, `APP_STORE_CONNECT_ISSUER_ID`
-    - `echo "$APP_STORE_CONNECT_API_KEY_P8" | sed 's/\\n/\n/g' > /tmp/moltbot-notary.p8`
-    - `xcrun notarytool store-credentials "moltbot-notary" --key /tmp/moltbot-notary.p8 --key-id "$APP_STORE_CONNECT_KEY_ID" --issuer "$APP_STORE_CONNECT_ISSUER_ID"`
+    - `echo "$APP_STORE_CONNECT_API_KEY_P8" | sed 's/\\n/\n/g' > /tmp/openclaw-notary.p8`
+    - `xcrun notarytool store-credentials "openclaw-notary" --key /tmp/openclaw-notary.p8 --key-id "$APP_STORE_CONNECT_KEY_ID" --issuer "$APP_STORE_CONNECT_ISSUER_ID"`
 - `pnpm` deps installed (`pnpm install --config.node-linker=hoisted`).
 - Sparkle tools are fetched automatically via SwiftPM at `apps/macos/.build/artifacts/sparkle/Sparkle/bin/` (`sign_update`, `generate_appcast`, etc.).
 
@@ -30,47 +30,47 @@ Notes:
 # From repo root; set release IDs so Sparkle feed is enabled.
 # APP_BUILD must be numeric + monotonic for Sparkle compare.
 BUNDLE_ID=bot.molt.mac \
-APP_VERSION=2026.1.29 \
+APP_VERSION=2026.1.27-beta.1 \
 APP_BUILD="$(git rev-list --count HEAD)" \
 BUILD_CONFIG=release \
 SIGN_IDENTITY="Developer ID Application: <Developer Name> (<TEAMID>)" \
 scripts/package-mac-app.sh
 
 # Zip for distribution (includes resource forks for Sparkle delta support)
-ditto -c -k --sequesterRsrc --keepParent dist/Moltbot.app dist/Moltbot-2026.1.29.zip
+ditto -c -k --sequesterRsrc --keepParent dist/OpenClaw.app dist/OpenClaw-2026.1.27-beta.1.zip
 
 # Optional: also build a styled DMG for humans (drag to /Applications)
-scripts/create-dmg.sh dist/Moltbot.app dist/Moltbot-2026.1.29.dmg
+scripts/create-dmg.sh dist/OpenClaw.app dist/OpenClaw-2026.1.27-beta.1.dmg
 
 # Recommended: build + notarize/staple zip + DMG
 # First, create a keychain profile once:
-#   xcrun notarytool store-credentials "moltbot-notary" \
+#   xcrun notarytool store-credentials "openclaw-notary" \
 #     --apple-id "<apple-id>" --team-id "<team-id>" --password "<app-specific-password>"
-NOTARIZE=1 NOTARYTOOL_PROFILE=moltbot-notary \
+NOTARIZE=1 NOTARYTOOL_PROFILE=openclaw-notary \
 BUNDLE_ID=bot.molt.mac \
-APP_VERSION=2026.1.29 \
+APP_VERSION=2026.1.27-beta.1 \
 APP_BUILD="$(git rev-list --count HEAD)" \
 BUILD_CONFIG=release \
 SIGN_IDENTITY="Developer ID Application: <Developer Name> (<TEAMID>)" \
 scripts/package-mac-dist.sh
 
 # Optional: ship dSYM alongside the release
-ditto -c -k --keepParent apps/macos/.build/release/Moltbot.app.dSYM dist/Moltbot-2026.1.29.dSYM.zip
+ditto -c -k --keepParent apps/macos/.build/release/OpenClaw.app.dSYM dist/OpenClaw-2026.1.27-beta.1.dSYM.zip
 ```
 
 ## Appcast entry
 Use the release note generator so Sparkle renders formatted HTML notes:
 ```bash
-SPARKLE_PRIVATE_KEY_FILE=/path/to/ed25519-private-key scripts/make_appcast.sh dist/Moltbot-2026.1.29.zip https://raw.githubusercontent.com/moltbot/moltbot/main/appcast.xml
+SPARKLE_PRIVATE_KEY_FILE=/path/to/ed25519-private-key scripts/make_appcast.sh dist/OpenClaw-2026.1.27-beta.1.zip https://raw.githubusercontent.com/openclaw/openclaw/main/appcast.xml
 ```
-Generates HTML release notes from `CHANGELOG.md` (via [`scripts/changelog-to-html.sh`](https://github.com/moltbot/moltbot/blob/main/scripts/changelog-to-html.sh)) and embeds them in the appcast entry.
+Generates HTML release notes from `CHANGELOG.md` (via [`scripts/changelog-to-html.sh`](https://github.com/openclaw/openclaw/blob/main/scripts/changelog-to-html.sh)) and embeds them in the appcast entry.
 Commit the updated `appcast.xml` alongside the release assets (zip + dSYM) when publishing.
 
 ## Publish & verify
-- Upload `Moltbot-2026.1.29.zip` (and `Moltbot-2026.1.29.dSYM.zip`) to the GitHub release for tag `v2026.1.29`.
-- Ensure the raw appcast URL matches the baked feed: `https://raw.githubusercontent.com/moltbot/moltbot/main/appcast.xml`.
+- Upload `OpenClaw-2026.1.27-beta.1.zip` (and `OpenClaw-2026.1.27-beta.1.dSYM.zip`) to the GitHub release for tag `v2026.1.27-beta.1`.
+- Ensure the raw appcast URL matches the baked feed: `https://raw.githubusercontent.com/openclaw/openclaw/main/appcast.xml`.
 - Sanity checks:
-  - `curl -I https://raw.githubusercontent.com/moltbot/moltbot/main/appcast.xml` returns 200.
+  - `curl -I https://raw.githubusercontent.com/openclaw/openclaw/main/appcast.xml` returns 200.
   - `curl -I <enclosure url>` returns 200 after assets upload.
   - On a previous public build, run “Check for Updates…” from the About tab and verify Sparkle installs the new build cleanly.
 

docs/platforms/mac/remote.md

@@ -1,16 +1,16 @@
 ---
-summary: "macOS app flow for controlling a remote Moltbot gateway over SSH"
+summary: "macOS app flow for controlling a remote OpenClaw gateway over SSH"
 read_when:
   - Setting up or debugging remote mac control
 ---
-# Remote Moltbot (macOS ⇄ remote host)
+# Remote OpenClaw (macOS ⇄ remote host)
 
 
-This flow lets the macOS app act as a full remote control for a Moltbot gateway running on another host (desktop/server). It’s the app’s **Remote over SSH** (remote run) feature. All features—health checks, Voice Wake forwarding, and Web Chat—reuse the same remote SSH configuration from *Settings → General*.
+This flow lets the macOS app act as a full remote control for a OpenClaw gateway running on another host (desktop/server). It’s the app’s **Remote over SSH** (remote run) feature. All features—health checks, Voice Wake forwarding, and Web Chat—reuse the same remote SSH configuration from *Settings → General*.
 
 ## Modes
 - **Local (this Mac)**: Everything runs on the laptop. No SSH involved.
-- **Remote over SSH (default)**: Moltbot commands are executed on the remote host. The mac app opens an SSH connection with `-o BatchMode` plus your chosen identity/key and a local port-forward.
+- **Remote over SSH (default)**: OpenClaw commands are executed on the remote host. The mac app opens an SSH connection with `-o BatchMode` plus your chosen identity/key and a local port-forward.
 - **Remote direct (ws/wss)**: No SSH tunnel. The mac app connects to the gateway URL directly (for example, via Tailscale Serve or a public HTTPS reverse proxy).
 
 ## Remote transports
@@ -19,21 +19,21 @@ Remote mode supports two transports:
 - **Direct (ws/wss)**: Connects straight to the gateway URL. The gateway sees the real client IP.
 
 ## Prereqs on the remote host
-1) Install Node + pnpm and build/install the Moltbot CLI (`pnpm install && pnpm build && pnpm link --global`).
-2) Ensure `moltbot` is on PATH for non-interactive shells (symlink into `/usr/local/bin` or `/opt/homebrew/bin` if needed).
+1) Install Node + pnpm and build/install the OpenClaw CLI (`pnpm install && pnpm build && pnpm link --global`).
+2) Ensure `openclaw` is on PATH for non-interactive shells (symlink into `/usr/local/bin` or `/opt/homebrew/bin` if needed).
 3) Open SSH with key auth. We recommend **Tailscale** IPs for stable reachability off-LAN.
 
 ## macOS app setup
 1) Open *Settings → General*.
-2) Under **Moltbot runs**, pick **Remote over SSH** and set:
+2) Under **OpenClaw runs**, pick **Remote over SSH** and set:
    - **Transport**: **SSH tunnel** or **Direct (ws/wss)**.
    - **SSH target**: `user@host` (optional `:port`).
      - If the gateway is on the same LAN and advertises Bonjour, pick it from the discovered list to auto-fill this field.
    - **Gateway URL** (Direct only): `wss://gateway.example.ts.net` (or `ws://...` for local/LAN).
    - **Identity file** (advanced): path to your key.
    - **Project root** (advanced): remote checkout path used for commands.
-   - **CLI path** (advanced): optional path to a runnable `moltbot` entrypoint/binary (auto-filled when advertised).
-3) Hit **Test remote**. Success indicates the remote `moltbot status --json` runs correctly. Failures usually mean PATH/CLI issues; exit 127 means the CLI isn’t found remotely.
+   - **CLI path** (advanced): optional path to a runnable `openclaw` entrypoint/binary (auto-filled when advertised).
+3) Hit **Test remote**. Success indicates the remote `openclaw status --json` runs correctly. Failures usually mean PATH/CLI issues; exit 127 means the CLI isn’t found remotely.
 4) Health checks and Web Chat will now run through this SSH tunnel automatically.
 
 ## Web Chat
@@ -51,21 +51,21 @@ Remote mode supports two transports:
 - See [Security](/gateway/security) and [Tailscale](/gateway/tailscale).
 
 ## WhatsApp login flow (remote)
-- Run `moltbot channels login --verbose` **on the remote host**. Scan the QR with WhatsApp on your phone.
+- Run `openclaw channels login --verbose` **on the remote host**. Scan the QR with WhatsApp on your phone.
 - Re-run login on that host if auth expires. Health check will surface link problems.
 
 ## Troubleshooting
-- **exit 127 / not found**: `moltbot` isn’t on PATH for non-login shells. Add it to `/etc/paths`, your shell rc, or symlink into `/usr/local/bin`/`/opt/homebrew/bin`.
-- **Health probe failed**: check SSH reachability, PATH, and that Baileys is logged in (`moltbot status --json`).
+- **exit 127 / not found**: `openclaw` isn’t on PATH for non-login shells. Add it to `/etc/paths`, your shell rc, or symlink into `/usr/local/bin`/`/opt/homebrew/bin`.
+- **Health probe failed**: check SSH reachability, PATH, and that Baileys is logged in (`openclaw status --json`).
 - **Web Chat stuck**: confirm the gateway is running on the remote host and the forwarded port matches the gateway WS port; the UI requires a healthy WS connection.
 - **Node IP shows 127.0.0.1**: expected with the SSH tunnel. Switch **Transport** to **Direct (ws/wss)** if you want the gateway to see the real client IP.
 - **Voice Wake**: trigger phrases are forwarded automatically in remote mode; no separate forwarder is needed.
 
 ## Notification sounds
-Pick sounds per notification from scripts with `moltbot` and `node.invoke`, e.g.:
+Pick sounds per notification from scripts with `openclaw` and `node.invoke`, e.g.:
 
 ```bash
-moltbot nodes notify --node <id> --title "Ping" --body "Remote gateway ready" --sound Glass
+openclaw nodes notify --node <id> --title "Ping" --body "Remote gateway ready" --sound Glass
 ```
 
 There is no global “default sound” toggle in the app anymore; callers choose a sound (or none) per request.

docs/platforms/mac/signing.md

@@ -5,13 +5,13 @@ read_when:
 ---
 # mac signing (debug builds)
 
-This app is usually built from [`scripts/package-mac-app.sh`](https://github.com/moltbot/moltbot/blob/main/scripts/package-mac-app.sh), which now:
+This app is usually built from [`scripts/package-mac-app.sh`](https://github.com/openclaw/openclaw/blob/main/scripts/package-mac-app.sh), which now:
 
-- sets a stable debug bundle identifier: `bot.molt.mac.debug`
+- sets a stable debug bundle identifier: `ai.openclaw.mac.debug`
 - writes the Info.plist with that bundle id (override via `BUNDLE_ID=...`)
-- calls [`scripts/codesign-mac-app.sh`](https://github.com/moltbot/moltbot/blob/main/scripts/codesign-mac-app.sh) to sign the main binary and app bundle so macOS treats each rebuild as the same signed bundle and keeps TCC permissions (notifications, accessibility, screen recording, mic, speech). For stable permissions, use a real signing identity; ad-hoc is opt-in and fragile (see [macOS permissions](/platforms/mac/permissions)).
+- calls [`scripts/codesign-mac-app.sh`](https://github.com/openclaw/openclaw/blob/main/scripts/codesign-mac-app.sh) to sign the main binary and app bundle so macOS treats each rebuild as the same signed bundle and keeps TCC permissions (notifications, accessibility, screen recording, mic, speech). For stable permissions, use a real signing identity; ad-hoc is opt-in and fragile (see [macOS permissions](/platforms/mac/permissions)).
 - uses `CODESIGN_TIMESTAMP=auto` by default; it enables trusted timestamps for Developer ID signatures. Set `CODESIGN_TIMESTAMP=off` to skip timestamping (offline debug builds).
-- inject build metadata into Info.plist: `MoltbotBuildTimestamp` (UTC) and `MoltbotGitCommit` (short hash) so the About pane can show build, git, and debug/release channel.
+- inject build metadata into Info.plist: `OpenClawBuildTimestamp` (UTC) and `OpenClawGitCommit` (short hash) so the About pane can show build, git, and debug/release channel.
 - **Packaging requires Node 22+**: the script runs TS builds and the Control UI build.
 - reads `SIGN_IDENTITY` from the environment. Add `export SIGN_IDENTITY="Apple Development: Your Name (TEAMID)"` (or your Developer ID Application cert) to your shell rc to always sign with your cert. Ad-hoc signing requires explicit opt-in via `ALLOW_ADHOC_SIGNING=1` or `SIGN_IDENTITY="-"` (not recommended for permission testing).
 - runs a Team ID audit after signing and fails if any Mach-O inside the app bundle is signed by a different Team ID. Set `SKIP_TEAM_ID_CHECK=1` to bypass.
@@ -33,11 +33,11 @@ When signing with `SIGN_IDENTITY="-"` (ad-hoc), the script automatically disable
 ## Build metadata for About
 
 `package-mac-app.sh` stamps the bundle with:
-- `MoltbotBuildTimestamp`: ISO8601 UTC at package time
-- `MoltbotGitCommit`: short git hash (or `unknown` if unavailable)
+- `OpenClawBuildTimestamp`: ISO8601 UTC at package time
+- `OpenClawGitCommit`: short git hash (or `unknown` if unavailable)
 
 The About tab reads these keys to show version, build date, git commit, and whether it’s a debug build (via `#if DEBUG`). Run the packager to refresh these values after code changes.
 
 ## Why
 
-TCC permissions are tied to the bundle identifier *and* code signature. Unsigned debug builds with changing UUIDs were causing macOS to forget grants after each rebuild. Signing the binaries (ad‑hoc by default) and keeping a fixed bundle id/path (`dist/Moltbot.app`) preserves the grants between builds, matching the VibeTunnel approach.
+TCC permissions are tied to the bundle identifier *and* code signature. Unsigned debug builds with changing UUIDs were causing macOS to forget grants after each rebuild. Signing the binaries (ad‑hoc by default) and keeping a fixed bundle id/path (`dist/OpenClaw.app`) preserves the grants between builds, matching the VibeTunnel approach.

docs/platforms/mac/skills.md

@@ -6,21 +6,21 @@ read_when:
 ---
 # Skills (macOS)
 
-The macOS app surfaces Moltbot skills via the gateway; it does not parse skills locally.
+The macOS app surfaces OpenClaw skills via the gateway; it does not parse skills locally.
 
 ## Data source
 - `skills.status` (gateway) returns all skills plus eligibility and missing requirements
   (including allowlist blocks for bundled skills).
-- Requirements are derived from `metadata.moltbot.requires` in each `SKILL.md`.
+- Requirements are derived from `metadata.openclaw.requires` in each `SKILL.md`.
 
 ## Install actions
-- `metadata.moltbot.install` defines install options (brew/node/go/uv).
+- `metadata.openclaw.install` defines install options (brew/node/go/uv).
 - The app calls `skills.install` to run installers on the gateway host.
 - The gateway surfaces only one preferred installer when multiple are provided
   (brew when available, otherwise node manager from `skills.install`, default npm).
 
 ## Env/API keys
-- The app stores keys in `~/.clawdbot/moltbot.json` under `skills.entries.<skillKey>`.
+- The app stores keys in `~/.openclaw/openclaw.json` under `skills.entries.<skillKey>`.
 - `skills.update` patches `enabled`, `apiKey`, and `env`.
 
 ## Remote mode

docs/platforms/mac/webchat.md

@@ -18,7 +18,7 @@ agent (with a session switcher for other sessions).
 - Manual: Lobster menu → “Open Chat”.
 - Auto‑open for testing:
   ```bash
-  dist/Moltbot.app/Contents/MacOS/Moltbot --webchat
+  dist/OpenClaw.app/Contents/MacOS/OpenClaw --webchat
   ```
 - Logs: `./scripts/clawlog.sh` (subsystem `bot.molt`, category `WebChatSwiftUI`).
 

docs/platforms/mac/xpc.md

@@ -1,11 +1,11 @@
 ---
-summary: "macOS IPC architecture for Moltbot app, gateway node transport, and PeekabooBridge"
+summary: "macOS IPC architecture for OpenClaw app, gateway node transport, and PeekabooBridge"
 read_when:
   - Editing IPC contracts or menu bar app IPC
 ---
-# Moltbot macOS IPC architecture
+# OpenClaw macOS IPC architecture
 
-**Current model:** a local Unix socket connects the **node host service** to the **macOS app** for exec approvals + `system.run`. A `moltbot-mac` debug CLI exists for discovery/connect checks; agent actions still flow through the Gateway WebSocket and `node.invoke`. UI automation uses PeekabooBridge.
+**Current model:** a local Unix socket connects the **node host service** to the **macOS app** for exec approvals + `system.run`. A `openclaw-mac` debug CLI exists for discovery/connect checks; agent actions still flow through the Gateway WebSocket and `node.invoke`. UI automation uses PeekabooBridge.
 
 ## Goals
 - Single GUI app instance that owns all TCC-facing work (notifications, screen recording, mic, speech, AppleScript).
@@ -32,7 +32,7 @@ Agent -> Gateway -> Node Service (WS)
 
 ### PeekabooBridge (UI automation)
 - UI automation uses a separate UNIX socket named `bridge.sock` and the PeekabooBridge JSON protocol.
-- Host preference order (client-side): Peekaboo.app → Claude.app → Moltbot.app → local execution.
+- Host preference order (client-side): Peekaboo.app → Claude.app → OpenClaw.app → local execution.
 - Security: bridge hosts require an allowed TeamID; DEBUG-only same-UID escape hatch is guarded by `PEEKABOO_ALLOW_UNSIGNED_SOCKET_CLIENTS=1` (Peekaboo convention).
 - See: [PeekabooBridge usage](/platforms/mac/peekaboo) for details.
 

docs/platforms/macos-vm.md

@@ -1,13 +1,13 @@
 ---
-summary: "Run Moltbot in a sandboxed macOS VM (local or hosted) when you need isolation or iMessage"
+summary: "Run OpenClaw in a sandboxed macOS VM (local or hosted) when you need isolation or iMessage"
 read_when:
-  - You want Moltbot isolated from your main macOS environment
+  - You want OpenClaw isolated from your main macOS environment
   - You want iMessage integration (BlueBubbles) in a sandbox
   - You want a resettable macOS environment you can clone
   - You want to compare local vs hosted macOS VM options
 ---
 
-# Moltbot on macOS VMs (Sandboxing)
+# OpenClaw on macOS VMs (Sandboxing)
 
 ## Recommended default (most users)
 
@@ -21,7 +21,7 @@ Use a macOS VM when you specifically need macOS-only capabilities (iMessage/Blue
 
 ### Local VM on your Apple Silicon Mac (Lume)
 
-Run Moltbot in a sandboxed macOS VM on your existing Apple Silicon Mac using [Lume](https://cua.ai/docs/lume).
+Run OpenClaw in a sandboxed macOS VM on your existing Apple Silicon Mac using [Lume](https://cua.ai/docs/lume).
 
 This gives you:
 - Full macOS environment in isolation (your host stays clean)
@@ -42,10 +42,10 @@ Once you have SSH access to a macOS VM, continue at step 6 below.
 ## Quick path (Lume, experienced users)
 
 1. Install Lume
-2. `lume create moltbot --os macos --ipsw latest`
+2. `lume create openclaw --os macos --ipsw latest`
 3. Complete Setup Assistant, enable Remote Login (SSH)
-4. `lume run moltbot --no-display`
-5. SSH in, install Moltbot, configure channels
+4. `lume run openclaw --no-display`
+5. SSH in, install OpenClaw, configure channels
 6. Done
 
 ---
@@ -84,7 +84,7 @@ Docs: [Lume Installation](https://cua.ai/docs/lume/guide/getting-started/install
 ## 2) Create the macOS VM
 
 ```bash
-lume create moltbot --os macos --ipsw latest
+lume create openclaw --os macos --ipsw latest
 ```
 
 This downloads macOS and creates the VM. A VNC window opens automatically.
@@ -110,7 +110,7 @@ After setup completes, enable SSH:
 ## 4) Get the VM's IP address
 
 ```bash
-lume get moltbot
+lume get openclaw
 ```
 
 Look for the IP address (usually `192.168.64.x`).
@@ -127,13 +127,13 @@ Replace `youruser` with the account you created, and the IP with your VM's IP.
 
 ---
 
-## 6) Install Moltbot
+## 6) Install OpenClaw
 
 Inside the VM:
 
 ```bash
-npm install -g moltbot@latest
-moltbot onboard --install-daemon
+npm install -g openclaw@latest
+openclaw onboard --install-daemon
 ```
 
 Follow the onboarding prompts to set up your model provider (Anthropic, OpenAI, etc.).
@@ -145,7 +145,7 @@ Follow the onboarding prompts to set up your model provider (Anthropic, OpenAI,
 Edit the config file:
 
 ```bash
-nano ~/.clawdbot/moltbot.json
+nano ~/.openclaw/openclaw.json
 ```
 
 Add your channels:
@@ -167,7 +167,7 @@ Add your channels:
 Then login to WhatsApp (scan QR):
 
 ```bash
-moltbot channels login
+openclaw channels login
 ```
 
 ---
@@ -177,23 +177,23 @@ moltbot channels login
 Stop the VM and restart without display:
 
 ```bash
-lume stop moltbot
-lume run moltbot --no-display
+lume stop openclaw
+lume run openclaw --no-display
 ```
 
-The VM runs in the background. Moltbot's daemon keeps the gateway running.
+The VM runs in the background. OpenClaw's daemon keeps the gateway running.
 
 To check status:
 
 ```bash
-ssh youruser@192.168.64.X "moltbot status"
+ssh youruser@192.168.64.X "openclaw status"
 ```
 
 ---
 
 ## Bonus: iMessage integration
 
-This is the killer feature of running on macOS. Use [BlueBubbles](https://bluebubbles.app) to add iMessage to Moltbot.
+This is the killer feature of running on macOS. Use [BlueBubbles](https://bluebubbles.app) to add iMessage to OpenClaw.
 
 Inside the VM:
 
@@ -202,7 +202,7 @@ Inside the VM:
 3. Enable the Web API and set a password
 4. Point BlueBubbles webhooks at your gateway (example: `https://your-gateway-host:3000/bluebubbles-webhook?password=<password>`)
 
-Add to your Moltbot config:
+Add to your OpenClaw config:
 
 ```json
 {
@@ -227,16 +227,16 @@ Full setup details: [BlueBubbles channel](/channels/bluebubbles)
 Before customizing further, snapshot your clean state:
 
 ```bash
-lume stop moltbot
-lume clone moltbot moltbot-golden
+lume stop openclaw
+lume clone openclaw openclaw-golden
 ```
 
 Reset anytime:
 
 ```bash
-lume stop moltbot && lume delete moltbot
-lume clone moltbot-golden moltbot
-lume run moltbot --no-display
+lume stop openclaw && lume delete openclaw
+lume clone openclaw-golden openclaw
+lume run openclaw --no-display
 ```
 
 ---
@@ -257,9 +257,9 @@ For true always-on, consider a dedicated Mac mini or a small VPS. See [VPS hosti
 | Problem | Solution |
 |---------|----------|
 | Can't SSH into VM | Check "Remote Login" is enabled in VM's System Settings |
-| VM IP not showing | Wait for VM to fully boot, run `lume get moltbot` again |
+| VM IP not showing | Wait for VM to fully boot, run `lume get openclaw` again |
 | Lume command not found | Add `~/.local/bin` to your PATH |
-| WhatsApp QR not scanning | Ensure you're logged into the VM (not host) when running `moltbot channels login` |
+| WhatsApp QR not scanning | Ensure you're logged into the VM (not host) when running `openclaw channels login` |
 
 ---
 

docs/platforms/macos.md

@@ -1,12 +1,12 @@
 ---
-summary: "Moltbot macOS companion app (menu bar + gateway broker)"
+summary: "OpenClaw macOS companion app (menu bar + gateway broker)"
 read_when:
   - Implementing macOS app features
   - Changing gateway lifecycle or node bridging on macOS
 ---
-# Moltbot macOS Companion (menu bar + gateway broker)
+# OpenClaw macOS Companion (menu bar + gateway broker)
 
-The macOS app is the **menu‑bar companion** for Moltbot. It owns permissions,
+The macOS app is the **menu‑bar companion** for OpenClaw. It owns permissions,
 manages/attaches to the Gateway locally (launchd or manual), and exposes macOS
 capabilities to the agent as a node.
 
@@ -19,12 +19,12 @@ capabilities to the agent as a node.
 - Exposes macOS‑only tools (Canvas, Camera, Screen Recording, `system.run`).
 - Starts the local node host service in **remote** mode (launchd), and stops it in **local** mode.
 - Optionally hosts **PeekabooBridge** for UI automation.
-- Installs the global CLI (`moltbot`) via npm/pnpm on request (bun not recommended for the Gateway runtime).
+- Installs the global CLI (`openclaw`) via npm/pnpm on request (bun not recommended for the Gateway runtime).
 
 ## Local vs remote mode
 
 - **Local** (default): the app attaches to a running local Gateway if present;
-  otherwise it enables the launchd service via `moltbot gateway install`.
+  otherwise it enables the launchd service via `openclaw gateway install`.
 - **Remote**: the app connects to a Gateway over SSH/Tailscale and never starts
   a local process.
   The app starts the local **node host service** so the remote Gateway can reach this Mac.
@@ -33,7 +33,7 @@ The app does not spawn the Gateway as a child process.
 ## Launchd control
 
 The app manages a per‑user LaunchAgent labeled `bot.molt.gateway`
-(or `bot.molt.<profile>` when using `--profile`/`CLAWDBOT_PROFILE`; legacy `com.clawdbot.*` still unloads).
+(or `bot.molt.<profile>` when using `--profile`/`OPENCLAW_PROFILE`; legacy `com.openclaw.*` still unloads).
 
 ```bash
 launchctl kickstart -k gui/$UID/bot.molt.gateway
@@ -43,7 +43,7 @@ launchctl bootout gui/$UID/bot.molt.gateway
 Replace the label with `bot.molt.<profile>` when running a named profile.
 
 If the LaunchAgent isn’t installed, enable it from the app or run
-`moltbot gateway install`.
+`openclaw gateway install`.
 
 ## Node capabilities (mac)
 
@@ -74,7 +74,7 @@ Gateway -> Node Service (WS)
 Security + ask + allowlist are stored locally on the Mac in:
 
 ```
-~/.clawdbot/exec-approvals.json
+~/.openclaw/exec-approvals.json
 ```
 
 Example:
@@ -105,14 +105,14 @@ Notes:
 
 ## Deep links
 
-The app registers the `moltbot://` URL scheme for local actions.
+The app registers the `openclaw://` URL scheme for local actions.
 
-### `moltbot://agent`
+### `openclaw://agent`
 
 Triggers a Gateway `agent` request.
 
 ```bash
-open 'moltbot://agent?message=Hello%20from%20deep%20link'
+open 'openclaw://agent?message=Hello%20from%20deep%20link'
 ```
 
 Query parameters:
@@ -129,7 +129,7 @@ Safety:
 
 ## Onboarding flow (typical)
 
-1) Install and launch **Moltbot.app**.
+1) Install and launch **OpenClaw.app**.
 2) Complete the permissions checklist (TCC prompts).
 3) Ensure **Local** mode is active and the Gateway is running.
 4) Install the CLI if you want terminal access.
@@ -137,7 +137,7 @@ Safety:
 ## Build & dev workflow (native)
 
 - `cd apps/macos && swift build`
-- `swift run Moltbot` (or Xcode)
+- `swift run OpenClaw` (or Xcode)
 - Package app: `scripts/package-mac-app.sh`
 
 ## Debug gateway connectivity (macOS CLI)
@@ -147,8 +147,8 @@ logic that the macOS app uses, without launching the app.
 
 ```bash
 cd apps/macos
-swift run moltbot-mac connect --json
-swift run moltbot-mac discover --timeout 3000 --json
+swift run openclaw-mac connect --json
+swift run openclaw-mac discover --timeout 3000 --json
 ```
 
 Connect options:
@@ -163,7 +163,7 @@ Discovery options:
 - `--timeout <ms>`: overall discovery window (default: `2000`)
 - `--json`: structured output for diffing
 
-Tip: compare against `moltbot gateway discover --json` to see whether the
+Tip: compare against `openclaw gateway discover --json` to see whether the
 macOS app’s discovery pipeline (NWBrowser + tailnet DNS‑SD fallback) differs from
 the Node CLI’s `dns-sd` based discovery.
 

docs/platforms/oracle.md

@@ -1,18 +1,18 @@
 ---
-summary: "Moltbot on Oracle Cloud (Always Free ARM)"
+summary: "OpenClaw on Oracle Cloud (Always Free ARM)"
 read_when:
-  - Setting up Moltbot on Oracle Cloud
-  - Looking for low-cost VPS hosting for Moltbot
-  - Want 24/7 Moltbot on a small server
+  - Setting up OpenClaw on Oracle Cloud
+  - Looking for low-cost VPS hosting for OpenClaw
+  - Want 24/7 OpenClaw on a small server
 ---
 
-# Moltbot on Oracle Cloud (OCI)
+# OpenClaw on Oracle Cloud (OCI)
 
 ## Goal
 
-Run a persistent Moltbot Gateway on Oracle Cloud's **Always Free** ARM tier.
+Run a persistent OpenClaw Gateway on Oracle Cloud's **Always Free** ARM tier.
 
-Oracle’s free tier can be a great fit for Moltbot (especially if you already have an OCI account), but it comes with tradeoffs:
+Oracle’s free tier can be a great fit for OpenClaw (especially if you already have an OCI account), but it comes with tradeoffs:
 
 - ARM architecture (most things work, but some binaries may be x86-only)
 - Capacity and signup can be finicky
@@ -40,7 +40,7 @@ Oracle’s free tier can be a great fit for Moltbot (especially if you already h
 1. Log into [Oracle Cloud Console](https://cloud.oracle.com/)
 2. Navigate to **Compute → Instances → Create Instance**
 3. Configure:
-   - **Name:** `moltbot`
+   - **Name:** `openclaw`
    - **Image:** Ubuntu 24.04 (aarch64)
    - **Shape:** `VM.Standard.A1.Flex` (Ampere ARM)
    - **OCPUs:** 2 (or up to 4)
@@ -69,7 +69,7 @@ sudo apt install -y build-essential
 
 ```bash
 # Set hostname
-sudo hostnamectl set-hostname moltbot
+sudo hostnamectl set-hostname openclaw
 
 # Set password for ubuntu user
 sudo passwd ubuntu
@@ -82,22 +82,22 @@ sudo loginctl enable-linger ubuntu
 
 ```bash
 curl -fsSL https://tailscale.com/install.sh | sh
-sudo tailscale up --ssh --hostname=moltbot
+sudo tailscale up --ssh --hostname=openclaw
 ```
 
-This enables Tailscale SSH, so you can connect via `ssh moltbot` from any device on your tailnet — no public IP needed.
+This enables Tailscale SSH, so you can connect via `ssh openclaw` from any device on your tailnet — no public IP needed.
 
 Verify:
 ```bash
 tailscale status
 ```
 
-**From now on, connect via Tailscale:** `ssh ubuntu@moltbot` (or use the Tailscale IP).
+**From now on, connect via Tailscale:** `ssh ubuntu@openclaw` (or use the Tailscale IP).
 
-## 5) Install Moltbot
+## 5) Install OpenClaw
 
 ```bash
-curl -fsSL https://molt.bot/install.sh | bash
+curl -fsSL https://openclaw.bot/install.sh | bash
 source ~/.bashrc
 ```
 
@@ -111,27 +111,27 @@ Use token auth as the default. It’s predictable and avoids needing any “inse
 
 ```bash
 # Keep the Gateway private on the VM
-moltbot config set gateway.bind loopback
+openclaw config set gateway.bind loopback
 
 # Require auth for the Gateway + Control UI
-moltbot config set gateway.auth.mode token
-moltbot doctor --generate-gateway-token
+openclaw config set gateway.auth.mode token
+openclaw doctor --generate-gateway-token
 
 # Expose over Tailscale Serve (HTTPS + tailnet access)
-moltbot config set gateway.tailscale.mode serve
-moltbot config set gateway.trustedProxies '["127.0.0.1"]'
+openclaw config set gateway.tailscale.mode serve
+openclaw config set gateway.trustedProxies '["127.0.0.1"]'
 
-systemctl --user restart moltbot-gateway
+systemctl --user restart openclaw-gateway
 ```
 
 ## 7) Verify
 
 ```bash
 # Check version
-moltbot --version
+openclaw --version
 
 # Check daemon status
-systemctl --user status moltbot-gateway
+systemctl --user status openclaw-gateway
 
 # Check Tailscale Serve
 tailscale serve status
@@ -159,7 +159,7 @@ This blocks SSH on port 22, HTTP, HTTPS, and everything else at the network edge
 From any device on your Tailscale network:
 
 ```
-https://moltbot.<tailnet-name>.ts.net/
+https://openclaw.<tailnet-name>.ts.net/
 ```
 
 Replace `<tailnet-name>` with your tailnet name (visible in `tailscale status`).
@@ -175,7 +175,7 @@ No SSH tunnel needed. Tailscale provides:
 
 With the VCN locked down (only UDP 41641 open) and the Gateway bound to loopback, you get strong defense-in-depth: public traffic is blocked at the network edge, and admin access happens over your tailnet.
 
-This setup often removes the *need* for extra host-based firewall rules purely to stop Internet-wide SSH brute force — but you should still keep the OS updated, run `moltbot security audit`, and verify you aren’t accidentally listening on public interfaces.
+This setup often removes the *need* for extra host-based firewall rules purely to stop Internet-wide SSH brute force — but you should still keep the OS updated, run `openclaw security audit`, and verify you aren’t accidentally listening on public interfaces.
 
 ### What's Already Protected
 
@@ -190,8 +190,8 @@ This setup often removes the *need* for extra host-based firewall rules purely t
 
 ### Still Recommended
 
-- **Credential permissions:** `chmod 700 ~/.clawdbot`
-- **Security audit:** `moltbot security audit`
+- **Credential permissions:** `chmod 700 ~/.openclaw`
+- **Security audit:** `openclaw security audit`
 - **System updates:** `sudo apt update && sudo apt upgrade` regularly
 - **Monitor Tailscale:** Review devices in [Tailscale admin console](https://login.tailscale.com/admin)
 
@@ -216,7 +216,7 @@ If Tailscale Serve isn't working, use an SSH tunnel:
 
 ```bash
 # From your local machine (via Tailscale)
-ssh -L 18789:127.0.0.1:18789 ubuntu@moltbot
+ssh -L 18789:127.0.0.1:18789 ubuntu@openclaw
 ```
 
 Then open `http://localhost:18789`.
@@ -237,14 +237,14 @@ Free tier ARM instances are popular. Try:
 sudo tailscale status
 
 # Re-authenticate
-sudo tailscale up --ssh --hostname=moltbot --reset
+sudo tailscale up --ssh --hostname=openclaw --reset
 ```
 
 ### Gateway won't start
 ```bash
-moltbot gateway status
-moltbot doctor --non-interactive
-journalctl --user -u moltbot-gateway -n 50
+openclaw gateway status
+openclaw doctor --non-interactive
+journalctl --user -u openclaw-gateway -n 50
 ```
 
 ### Can't reach Control UI
@@ -256,7 +256,7 @@ tailscale serve status
 curl http://localhost:18789
 
 # Restart if needed
-systemctl --user restart moltbot-gateway
+systemctl --user restart openclaw-gateway
 ```
 
 ### ARM binary issues
@@ -272,12 +272,12 @@ Most npm packages work fine. For binaries, look for `linux-arm64` or `aarch64` r
 ## Persistence
 
 All state lives in:
-- `~/.clawdbot/` — config, credentials, session data
-- `~/clawd/` — workspace (SOUL.md, memory, artifacts)
+- `~/.openclaw/` — config, credentials, session data
+- `~/.openclaw/workspace/` — workspace (SOUL.md, memory, artifacts)
 
 Back up periodically:
 ```bash
-tar -czvf moltbot-backup.tar.gz ~/.clawdbot ~/clawd
+tar -czvf openclaw-backup.tar.gz ~/.openclaw ~/.openclaw/workspace
 ```
 
 ---

docs/platforms/raspberry-pi.md

@@ -1,16 +1,16 @@
 ---
-summary: "Moltbot on Raspberry Pi (budget self-hosted setup)"
+summary: "OpenClaw on Raspberry Pi (budget self-hosted setup)"
 read_when:
-  - Setting up Moltbot on a Raspberry Pi
-  - Running Moltbot on ARM devices
+  - Setting up OpenClaw on a Raspberry Pi
+  - Running OpenClaw on ARM devices
   - Building a cheap always-on personal AI
 ---
 
-# Moltbot on Raspberry Pi
+# OpenClaw on Raspberry Pi
 
 ## Goal
 
-Run a persistent, always-on Moltbot Gateway on a Raspberry Pi for **~$35-80** one-time cost (no monthly fees).
+Run a persistent, always-on OpenClaw Gateway on a Raspberry Pi for **~$35-80** one-time cost (no monthly fees).
 
 Perfect for:
 - 24/7 personal AI assistant
@@ -105,19 +105,19 @@ echo 'vm.swappiness=10' | sudo tee -a /etc/sysctl.conf
 sudo sysctl -p
 ```
 
-## 6) Install Moltbot
+## 6) Install OpenClaw
 
 ### Option A: Standard Install (Recommended)
 
 ```bash
-curl -fsSL https://molt.bot/install.sh | bash
+curl -fsSL https://openclaw.bot/install.sh | bash
 ```
 
 ### Option B: Hackable Install (For tinkering)
 
 ```bash
-git clone https://github.com/moltbot/moltbot.git
-cd moltbot
+git clone https://github.com/openclaw/openclaw.git
+cd openclaw
 npm install
 npm run build
 npm link
@@ -128,7 +128,7 @@ The hackable install gives you direct access to logs and code — useful for deb
 ## 7) Run Onboarding
 
 ```bash
-moltbot onboard --install-daemon
+openclaw onboard --install-daemon
 ```
 
 Follow the wizard:
@@ -141,13 +141,13 @@ Follow the wizard:
 
 ```bash
 # Check status
-moltbot status
+openclaw status
 
 # Check service
-sudo systemctl status moltbot
+sudo systemctl status openclaw
 
 # View logs
-journalctl -u moltbot -f
+journalctl -u openclaw -f
 ```
 
 ## 9) Access the Dashboard
@@ -170,8 +170,8 @@ curl -fsSL https://tailscale.com/install.sh | sh
 sudo tailscale up
 
 # Update config
-moltbot config set gateway.bind tailnet
-sudo systemctl restart moltbot
+openclaw config set gateway.bind tailnet
+sudo systemctl restart openclaw
 ```
 
 ---
@@ -218,7 +218,7 @@ htop
 
 ### Binary Compatibility
 
-Most Moltbot features work on ARM64, but some external binaries may need ARM builds:
+Most OpenClaw features work on ARM64, but some external binaries may need ARM builds:
 
 | Tool | ARM64 Status | Notes |
 |------|--------------|-------|
@@ -268,13 +268,13 @@ The onboarding wizard sets this up, but to verify:
 
 ```bash
 # Check service is enabled
-sudo systemctl is-enabled moltbot
+sudo systemctl is-enabled openclaw
 
 # Enable if not
-sudo systemctl enable moltbot
+sudo systemctl enable openclaw
 
 # Start on boot
-sudo systemctl start moltbot
+sudo systemctl start openclaw
 ```
 
 ---
@@ -301,12 +301,12 @@ free -h
 
 ```bash
 # Check logs
-journalctl -u moltbot --no-pager -n 100
+journalctl -u openclaw --no-pager -n 100
 
 # Common fix: rebuild
-cd ~/moltbot  # if using hackable install
+cd ~/openclaw  # if using hackable install
 npm run build
-sudo systemctl restart moltbot
+sudo systemctl restart openclaw
 ```
 
 ### ARM Binary Issues

docs/platforms/windows.md

@@ -1,12 +1,12 @@
 ---
 summary: "Windows (WSL2) support + companion app status"
 read_when:
-  - Installing Moltbot on Windows
+  - Installing OpenClaw on Windows
   - Looking for Windows companion app status
 ---
 # Windows (WSL2)
 
-Moltbot on Windows is recommended **via WSL2** (Ubuntu recommended). The
+OpenClaw on Windows is recommended **via WSL2** (Ubuntu recommended). The
 CLI + Gateway run inside Linux, which keeps the runtime consistent and makes
 tooling far more compatible (Node/Bun/pnpm, Linux binaries, skills). Native
 Windows installs are untested and more problematic.
@@ -27,19 +27,19 @@ Native Windows companion apps are planned.
 Inside WSL2:
 
 ```
-moltbot onboard --install-daemon
+openclaw onboard --install-daemon
 ```
 
 Or:
 
 ```
-moltbot gateway install
+openclaw gateway install
 ```
 
 Or:
 
 ```
-moltbot configure
+openclaw configure
 ```
 
 Select **Gateway service** when prompted.
@@ -47,7 +47,7 @@ Select **Gateway service** when prompted.
 Repair/migrate:
 
 ```
-moltbot doctor
+openclaw doctor
 ```
 
 ## Advanced: expose WSL services over LAN (portproxy)
@@ -89,7 +89,7 @@ netsh interface portproxy add v4tov4 listenport=$ListenPort listenaddress=0.0.0.
 Notes:
 - SSH from another machine targets the **Windows host IP** (example: `ssh user@windows-host -p 2222`).
 - Remote nodes must point at a **reachable** Gateway URL (not `127.0.0.1`); use
-  `moltbot status --all` to confirm.
+  `openclaw status --all` to confirm.
 - Use `listenaddress=0.0.0.0` for LAN access; `127.0.0.1` keeps it local only.
 - If you want this automatic, register a Scheduled Task to run the refresh
   step at login.
@@ -132,17 +132,17 @@ Re-open Ubuntu, then verify:
 systemctl --user status
 ```
 
-### 3) Install Moltbot (inside WSL)
+### 3) Install OpenClaw (inside WSL)
 
 Follow the Linux Getting Started flow inside WSL:
 
 ```bash
-git clone https://github.com/moltbot/moltbot.git
-cd moltbot
+git clone https://github.com/openclaw/openclaw.git
+cd openclaw
 pnpm install
 pnpm ui:build # auto-installs UI deps on first run
 pnpm build
-moltbot onboard
+openclaw onboard
 ```
 
 Full guide: [Getting Started](/start/getting-started)