@takibeiy/moltbot_cn 2026.2.1 → 2026.2.2

package/docs/gateway/configuration.md

@@ -1,13 +1,16 @@
 ---
-summary: "All configuration options for ~/.clawdbot/moltbot.json with examples"
+summary: "All configuration options for ~/.openclaw/openclaw.json with examples"
 read_when:
   - Adding or modifying config fields
+title: "Configuration"
 ---
+
 # Configuration 🔧
 
-Moltbot reads an optional **JSON5** config from `~/.clawdbot/moltbot.json` (comments + trailing commas allowed).
+OpenClaw reads an optional **JSON5** config from `~/.openclaw/openclaw.json` (comments + trailing commas allowed).
+
+If the file is missing, OpenClaw uses safe-ish defaults (embedded Pi agent + per-sender sessions + workspace `~/.openclaw/workspace`). You usually only need a config to:
 
-If the file is missing, Moltbot uses safe-ish defaults (embedded Pi agent + per-sender sessions + workspace `~/clawd`). You usually only need a config to:
 - restrict who can trigger the bot (`channels.whatsapp.allowFrom`, `channels.telegram.allowFrom`, etc.)
 - control group allowlists + mention behavior (`channels.whatsapp.groups`, `channels.telegram.groups`, `channels.discord.guilds`, `agents.list[].groupChat`)
 - customize message prefixes (`messages`)
@@ -19,14 +22,15 @@ If the file is missing, Moltbot uses safe-ish defaults (embedded Pi agent + per-
 
 ## Strict config validation
 
-Moltbot only accepts configurations that fully match the schema.
+OpenClaw only accepts configurations that fully match the schema.
 Unknown keys, malformed types, or invalid values cause the Gateway to **refuse to start** for safety.
 
 When validation fails:
+
 - The Gateway does not boot.
-- Only diagnostic commands are allowed (for example: `moltbot doctor`, `moltbot logs`, `moltbot health`, `moltbot status`, `moltbot service`, `moltbot help`).
-- Run `moltbot doctor` to see the exact issues.
-- Run `moltbot doctor --fix` (or `--yes`) to apply migrations/repairs.
+- Only diagnostic commands are allowed (for example: `openclaw doctor`, `openclaw logs`, `openclaw health`, `openclaw status`, `openclaw service`, `openclaw help`).
+- Run `openclaw doctor` to see the exact issues.
+- Run `openclaw doctor --fix` (or `--yes`) to apply migrations/repairs.
 
 Doctor never writes changes unless you explicitly opt into `--fix`/`--yes`.
 
@@ -47,9 +51,10 @@ Use `config.apply` to validate + write the full config and restart the Gateway i
 It writes a restart sentinel and pings the last active session after the Gateway comes back.
 
 Warning: `config.apply` replaces the **entire config**. If you want to change only a few keys,
-use `config.patch` or `moltbot config set`. Keep a backup of `~/.clawdbot/moltbot.json`.
+use `config.patch` or `openclaw config set`. Keep a backup of `~/.openclaw/openclaw.json`.
 
 Params:
+
 - `raw` (string) — JSON5 payload for the entire config
 - `baseHash` (optional) — config hash from `config.get` (required when a config already exists)
 - `sessionKey` (optional) — last active session key for the wake-up ping
@@ -59,9 +64,9 @@ Params:
 Example (via `gateway call`):
 
 ```bash
-moltbot gateway call config.get --params '{}' # capture payload.hash
-moltbot gateway call config.apply --params '{
-  "raw": "{\\n  agents: { defaults: { workspace: \\"~/clawd\\" } }\\n}\\n",
+openclaw gateway call config.get --params '{}' # capture payload.hash
+openclaw gateway call config.apply --params '{
+  "raw": "{\\n  agents: { defaults: { workspace: \\"~/.openclaw/workspace\\" } }\\n}\\n",
   "baseHash": "<hash-from-config.get>",
   "sessionKey": "agent:main:whatsapp:dm:+15555550123",
   "restartDelayMs": 1000
@@ -72,13 +77,15 @@ moltbot gateway call config.apply --params '{
 
 Use `config.patch` to merge a partial update into the existing config without clobbering
 unrelated keys. It applies JSON merge patch semantics:
+
 - objects merge recursively
 - `null` deletes a key
 - arrays replace
-Like `config.apply`, it validates, writes the config, stores a restart sentinel, and schedules
-the Gateway restart (with an optional wake when `sessionKey` is provided).
+  Like `config.apply`, it validates, writes the config, stores a restart sentinel, and schedules
+  the Gateway restart (with an optional wake when `sessionKey` is provided).
 
 Params:
+
 - `raw` (string) — JSON5 payload containing just the keys to change
 - `baseHash` (required) — config hash from `config.get`
 - `sessionKey` (optional) — last active session key for the wake-up ping
@@ -88,8 +95,8 @@ Params:
 Example:
 
 ```bash
-moltbot gateway call config.get --params '{}' # capture payload.hash
-moltbot gateway call config.patch --params '{
+openclaw gateway call config.get --params '{}' # capture payload.hash
+openclaw gateway call config.patch --params '{
   "raw": "{\\n  channels: { telegram: { groups: { \\"*\\": { requireMention: false } } } }\\n}\\n",
   "baseHash": "<hash-from-config.get>",
   "sessionKey": "agent:main:whatsapp:dm:+15555550123",
@@ -101,12 +108,13 @@ moltbot gateway call config.patch --params '{
 
 ```json5
 {
-  agents: { defaults: { workspace: "~/clawd" } },
-  channels: { whatsapp: { allowFrom: ["+15555550123"] } }
+  agents: { defaults: { workspace: "~/.openclaw/workspace" } },
+  channels: { whatsapp: { allowFrom: ["+15555550123"] } },
 }
 ```
 
 Build the default image once with:
+
 ```bash
 scripts/sandbox-setup.sh
 ```
@@ -118,27 +126,28 @@ To prevent the bot from responding to WhatsApp @-mentions in groups (only respon
 ```json5
 {
   agents: {
-    defaults: { workspace: "~/clawd" },
+    defaults: { workspace: "~/.openclaw/workspace" },
     list: [
       {
         id: "main",
-        groupChat: { mentionPatterns: ["@clawd", "reisponde"] }
-      }
-    ]
+        groupChat: { mentionPatterns: ["@openclaw", "reisponde"] },
+      },
+    ],
   },
   channels: {
     whatsapp: {
       // Allowlist is DMs only; including your own number enables self-chat mode.
       allowFrom: ["+15555550123"],
-      groups: { "*": { requireMention: true } }
-    }
-  }
+      groups: { "*": { requireMention: true } },
+    },
+  },
 }
 ```
 
 ## Config Includes (`$include`)
 
 Split your config into multiple files using the `$include` directive. This is useful for:
+
 - Organizing large configs (e.g., per-client agent definitions)
 - Sharing common settings across environments
 - Keeping sensitive configs separate
@@ -146,30 +155,25 @@ Split your config into multiple files using the `$include` directive. This is us
 ### Basic usage
 
 ```json5
-// ~/.clawdbot/moltbot.json
+// ~/.openclaw/openclaw.json
 {
   gateway: { port: 18789 },
-  
+
   // Include a single file (replaces the key's value)
-  agents: { "$include": "./agents.json5" },
-  
+  agents: { $include: "./agents.json5" },
+
   // Include multiple files (deep-merged in order)
-  broadcast: { 
-    "$include": [
-      "./clients/mueller.json5",
-      "./clients/schmidt.json5"
-    ]
-  }
+  broadcast: {
+    $include: ["./clients/mueller.json5", "./clients/schmidt.json5"],
+  },
 }
 ```
 
 ```json5
-// ~/.clawdbot/agents.json5
+// ~/.openclaw/agents.json5
 {
   defaults: { sandbox: { mode: "all", scope: "session" } },
-  list: [
-    { id: "main", workspace: "~/clawd" }
-  ]
+  list: [{ id: "main", workspace: "~/.openclaw/workspace" }],
 }
 ```
 
@@ -183,8 +187,8 @@ Split your config into multiple files using the `$include` directive. This is us
 ```json5
 // Sibling keys override included values
 {
-  "$include": "./base.json5",   // { a: 1, b: 2 }
-  b: 99                          // Result: { a: 1, b: 99 }
+  $include: "./base.json5", // { a: 1, b: 2 }
+  b: 99, // Result: { a: 1, b: 99 }
 }
 ```
 
@@ -195,8 +199,8 @@ Included files can themselves contain `$include` directives (up to 10 levels dee
 ```json5
 // clients/mueller.json5
 {
-  agents: { "$include": "./mueller/agents.json5" },
-  broadcast: { "$include": "./mueller/broadcast.json5" }
+  agents: { $include: "./mueller/agents.json5" },
+  broadcast: { $include: "./mueller/broadcast.json5" },
 }
 ```
 
@@ -208,7 +212,7 @@ Included files can themselves contain `$include` directives (up to 10 levels dee
 
 ```json5
 { "$include": "./sub/config.json5" }      // relative
-{ "$include": "/etc/moltbot/base.json5" } // absolute
+{ "$include": "/etc/openclaw/base.json5" } // absolute
 { "$include": "../shared/common.json5" }   // parent dir
 ```
 
@@ -221,44 +225,40 @@ Included files can themselves contain `$include` directives (up to 10 levels dee
 ### Example: Multi-client legal setup
 
 ```json5
-// ~/.clawdbot/moltbot.json
+// ~/.openclaw/openclaw.json
 {
   gateway: { port: 18789, auth: { token: "secret" } },
-  
+
   // Common agent defaults
   agents: {
     defaults: {
-      sandbox: { mode: "all", scope: "session" }
+      sandbox: { mode: "all", scope: "session" },
     },
     // Merge agent lists from all clients
-    list: { "$include": [
-      "./clients/mueller/agents.json5",
-      "./clients/schmidt/agents.json5"
-    ]}
+    list: { $include: ["./clients/mueller/agents.json5", "./clients/schmidt/agents.json5"] },
   },
-  
+
   // Merge broadcast configs
-  broadcast: { "$include": [
-    "./clients/mueller/broadcast.json5",
-    "./clients/schmidt/broadcast.json5"
-  ]},
-  
-  channels: { whatsapp: { groupPolicy: "allowlist" } }
+  broadcast: {
+    $include: ["./clients/mueller/broadcast.json5", "./clients/schmidt/broadcast.json5"],
+  },
+
+  channels: { whatsapp: { groupPolicy: "allowlist" } },
 }
 ```
 
 ```json5
-// ~/.clawdbot/clients/mueller/agents.json5
+// ~/.openclaw/clients/mueller/agents.json5
 [
   { id: "mueller-transcribe", workspace: "~/clients/mueller/transcribe" },
-  { id: "mueller-docs", workspace: "~/clients/mueller/docs" }
+  { id: "mueller-docs", workspace: "~/clients/mueller/docs" },
 ]
 ```
 
 ```json5
-// ~/.clawdbot/clients/mueller/broadcast.json5
+// ~/.openclaw/clients/mueller/broadcast.json5
 {
-  "120363403215116621@g.us": ["mueller-transcribe", "mueller-docs"]
+  "120363403215116621@g.us": ["mueller-transcribe", "mueller-docs"],
 }
 ```
 
@@ -266,11 +266,12 @@ Included files can themselves contain `$include` directives (up to 10 levels dee
 
 ### Env vars + `.env`
 
-Moltbot reads env vars from the parent process (shell, launchd/systemd, CI, etc.).
+OpenClaw reads env vars from the parent process (shell, launchd/systemd, CI, etc.).
 
 Additionally, it loads:
+
 - `.env` from the current working directory (if present)
-- a global fallback `.env` from `~/.clawdbot/.env` (aka `$CLAWDBOT_STATE_DIR/.env`)
+- a global fallback `.env` from `~/.openclaw/.env` (aka `$OPENCLAW_STATE_DIR/.env`)
 
 Neither `.env` file overrides existing env vars.
 
@@ -282,9 +283,9 @@ process env is missing the key (same non-overriding rule):
   env: {
     OPENROUTER_API_KEY: "sk-or-...",
     vars: {
-      GROQ_API_KEY: "gsk-..."
-    }
-  }
+      GROQ_API_KEY: "gsk-...",
+    },
+  },
 }
 ```
 
@@ -292,7 +293,7 @@ See [/environment](/environment) for full precedence and sources.
 
 ### `env.shellEnv` (optional)
 
-Opt-in convenience: if enabled and none of the expected keys are set yet, Moltbot runs your login shell and imports only the missing expected keys (never overrides).
+Opt-in convenience: if enabled and none of the expected keys are set yet, OpenClaw runs your login shell and imports only the missing expected keys (never overrides).
 This effectively sources your shell profile.
 
 ```json5
@@ -300,15 +301,16 @@ This effectively sources your shell profile.
   env: {
     shellEnv: {
       enabled: true,
-      timeoutMs: 15000
-    }
-  }
+      timeoutMs: 15000,
+    },
+  },
 }
 ```
 
 Env var equivalent:
-- `CLAWDBOT_LOAD_SHELL_ENV=1`
-- `CLAWDBOT_SHELL_ENV_TIMEOUT_MS=15000`
+
+- `OPENCLAW_LOAD_SHELL_ENV=1`
+- `OPENCLAW_SHELL_ENV_TIMEOUT_MS=15000`
 
 ### Env var substitution in config
 
@@ -320,19 +322,20 @@ You can reference environment variables directly in any config string value usin
   models: {
     providers: {
       "vercel-gateway": {
-        apiKey: "${VERCEL_GATEWAY_API_KEY}"
-      }
-    }
+        apiKey: "${VERCEL_GATEWAY_API_KEY}",
+      },
+    },
   },
   gateway: {
     auth: {
-      token: "${CLAWDBOT_GATEWAY_TOKEN}"
-    }
-  }
+      token: "${OPENCLAW_GATEWAY_TOKEN}",
+    },
+  },
 }
 ```
 
 **Rules:**
+
 - Only uppercase env var names are matched: `[A-Z_][A-Z0-9_]*`
 - Missing or empty env vars throw an error at config load
 - Escape with `$${VAR}` to output a literal `${VAR}`
@@ -345,34 +348,39 @@ You can reference environment variables directly in any config string value usin
   models: {
     providers: {
       custom: {
-        baseUrl: "${CUSTOM_API_BASE}/v1"  // → "https://api.example.com/v1"
-      }
-    }
-  }
+        baseUrl: "${CUSTOM_API_BASE}/v1", // → "https://api.example.com/v1"
+      },
+    },
+  },
 }
 ```
 
 ### Auth storage (OAuth + API keys)
 
-Moltbot stores **per-agent** auth profiles (OAuth + API keys) in:
-- `<agentDir>/auth-profiles.json` (default: `~/.clawdbot/agents/<agentId>/agent/auth-profiles.json`)
+OpenClaw stores **per-agent** auth profiles (OAuth + API keys) in:
+
+- `<agentDir>/auth-profiles.json` (default: `~/.openclaw/agents/<agentId>/agent/auth-profiles.json`)
 
 See also: [/concepts/oauth](/concepts/oauth)
 
 Legacy OAuth imports:
-- `~/.clawdbot/credentials/oauth.json` (or `$CLAWDBOT_STATE_DIR/credentials/oauth.json`)
+
+- `~/.openclaw/credentials/oauth.json` (or `$OPENCLAW_STATE_DIR/credentials/oauth.json`)
 
 The embedded Pi agent maintains a runtime cache at:
+
 - `<agentDir>/auth.json` (managed automatically; don’t edit manually)
 
 Legacy agent dir (pre multi-agent):
-- `~/.clawdbot/agent/*` (migrated by `moltbot doctor` into `~/.clawdbot/agents/<defaultAgentId>/agent/*`)
+
+- `~/.openclaw/agent/*` (migrated by `openclaw doctor` into `~/.openclaw/agents/<defaultAgentId>/agent/*`)
 
 Overrides:
-- OAuth dir (legacy import only): `CLAWDBOT_OAUTH_DIR`
-- Agent dir (default agent root override): `CLAWDBOT_AGENT_DIR` (preferred), `PI_CODING_AGENT_DIR` (legacy)
 
-On first use, Moltbot imports `oauth.json` entries into `auth-profiles.json`.
+- OAuth dir (legacy import only): `OPENCLAW_OAUTH_DIR`
+- Agent dir (default agent root override): `OPENCLAW_AGENT_DIR` (preferred), `PI_CODING_AGENT_DIR` (legacy)
+
+On first use, OpenClaw imports `oauth.json` entries into `auth-profiles.json`.
 
 ### `auth`
 
@@ -385,12 +393,12 @@ rotation order used for failover.
   auth: {
     profiles: {
       "anthropic:me@example.com": { provider: "anthropic", mode: "oauth", email: "me@example.com" },
-      "anthropic:work": { provider: "anthropic", mode: "api_key" }
+      "anthropic:work": { provider: "anthropic", mode: "api_key" },
     },
     order: {
-      anthropic: ["anthropic:me@example.com", "anthropic:work"]
-    }
-  }
+      anthropic: ["anthropic:me@example.com", "anthropic:work"],
+    },
+  },
 }
 ```
 
@@ -398,12 +406,14 @@ rotation order used for failover.
 
 Optional per-agent identity used for defaults and UX. This is written by the macOS onboarding assistant.
 
-If set, Moltbot derives defaults (only when you haven’t set them explicitly):
+If set, OpenClaw derives defaults (only when you haven’t set them explicitly):
+
 - `messages.ackReaction` from the **active agent**’s `identity.emoji` (falls back to 👀)
 - `agents.list[].groupChat.mentionPatterns` from the agent’s `identity.name`/`identity.emoji` (so “@Samantha” works in groups across Telegram/Slack/Discord/Google Chat/iMessage/WhatsApp)
 - `identity.avatar` accepts a workspace-relative image path or a remote URL/data URL. Local files must live inside the agent workspace.
 
 `identity.avatar` accepts:
+
 - Workspace-relative path (must stay within the agent workspace)
 - `http(s)` URL
 - `data:` URI
@@ -418,11 +428,11 @@ If set, Moltbot derives defaults (only when you haven’t set them explicitly):
           name: "Samantha",
           theme: "helpful sloth",
           emoji: "🦥",
-          avatar: "avatars/samantha.png"
-        }
-      }
-    ]
-  }
+          avatar: "avatars/samantha.png",
+        },
+      },
+    ],
+  },
 }
 ```
 
@@ -437,15 +447,15 @@ Metadata written by CLI wizards (`onboard`, `configure`, `doctor`).
     lastRunVersion: "2026.1.4",
     lastRunCommit: "abc1234",
     lastRunCommand: "configure",
-    lastRunMode: "local"
-  }
+    lastRunMode: "local",
+  },
 }
 ```
 
 ### `logging`
 
-- Default log file: `/tmp/moltbot/moltbot-YYYY-MM-DD.log`
-- If you want a stable path, set `logging.file` to `/tmp/moltbot/moltbot.log`.
+- Default log file: `/tmp/openclaw/openclaw-YYYY-MM-DD.log`
+- If you want a stable path, set `logging.file` to `/tmp/openclaw/openclaw.log`.
 - Console output can be tuned separately via:
   - `logging.consoleLevel` (defaults to `info`, bumps to `debug` when `--verbose`)
   - `logging.consoleStyle` (`pretty` | `compact` | `json`)
@@ -457,22 +467,23 @@ Metadata written by CLI wizards (`onboard`, `configure`, `doctor`).
 {
   logging: {
     level: "info",
-    file: "/tmp/moltbot/moltbot.log",
+    file: "/tmp/openclaw/openclaw.log",
     consoleLevel: "info",
     consoleStyle: "pretty",
     redactSensitive: "tools",
     redactPatterns: [
       // Example: override defaults with your own rules.
       "\\bTOKEN\\b\\s*[=:]\\s*([\"']?)([^\\s\"']+)\\1",
-      "/\\bsk-[A-Za-z0-9_-]{8,}\\b/gi"
-    ]
-  }
+      "/\\bsk-[A-Za-z0-9_-]{8,}\\b/gi",
+    ],
+  },
 }
 ```
 
 ### `channels.whatsapp.dmPolicy`
 
 Controls how WhatsApp direct chats (DMs) are handled:
+
 - `"pairing"` (default): unknown senders get a pairing code; owner must approve
 - `"allowlist"`: only allow senders in `channels.whatsapp.allowFrom` (or paired allow store)
 - `"open"`: allow all inbound DMs (**requires** `channels.whatsapp.allowFrom` to include `"*"`)
@@ -481,8 +492,9 @@ Controls how WhatsApp direct chats (DMs) are handled:
 Pairing codes expire after 1 hour; the bot only sends a pairing code when a new request is created. Pending DM pairing requests are capped at **3 per channel** by default.
 
 Pairing approvals:
-- `moltbot pairing list whatsapp`
-- `moltbot pairing approve whatsapp <code>`
+
+- `openclaw pairing list whatsapp`
+- `openclaw pairing approve whatsapp <code>`
 
 ### `channels.whatsapp.allowFrom`
 
@@ -498,9 +510,9 @@ For groups, use `channels.whatsapp.groupPolicy` + `channels.whatsapp.groupAllowF
       allowFrom: ["+15555550123", "+447700900123"],
       textChunkLimit: 4000, // optional outbound chunk size (chars)
       chunkMode: "length", // optional chunking mode (length | newline)
-      mediaMaxMb: 50 // optional inbound media cap (MB)
-    }
-  }
+      mediaMaxMb: 50, // optional inbound media cap (MB)
+    },
+  },
 }
 ```
 
@@ -515,8 +527,8 @@ Per-account override: `channels.whatsapp.accounts.<id>.sendReadReceipts`.
 ```json5
 {
   channels: {
-    whatsapp: { sendReadReceipts: false }
-  }
+    whatsapp: { sendReadReceipts: false },
+  },
 }
 ```
 
@@ -532,18 +544,19 @@ Run multiple WhatsApp accounts in one gateway:
         default: {}, // optional; keeps the default id stable
         personal: {},
         biz: {
-          // Optional override. Default: ~/.clawdbot/credentials/whatsapp/biz
-          // authDir: "~/.clawdbot/credentials/whatsapp/biz",
-        }
-      }
-    }
-  }
+          // Optional override. Default: ~/.openclaw/credentials/whatsapp/biz
+          // authDir: "~/.openclaw/credentials/whatsapp/biz",
+        },
+      },
+    },
+  },
 }
 ```
 
 Notes:
+
 - Outbound commands default to account `default` if present; otherwise the first configured account id (sorted).
-- The legacy single-account Baileys auth dir is migrated by `moltbot doctor` into `whatsapp/default`.
+- The legacy single-account Baileys auth dir is migrated by `openclaw doctor` into `whatsapp/default`.
 
 ### `channels.telegram.accounts` / `channels.discord.accounts` / `channels.googlechat.accounts` / `channels.slack.accounts` / `channels.mattermost.accounts` / `channels.signal.accounts` / `channels.imessage.accounts`
 
@@ -556,19 +569,20 @@ Run multiple accounts per channel (each account has its own `accountId` and opti
       accounts: {
         default: {
           name: "Primary bot",
-          botToken: "123456:ABC..."
+          botToken: "123456:ABC...",
         },
         alerts: {
           name: "Alerts bot",
-          botToken: "987654:XYZ..."
-        }
-      }
-    }
-  }
+          botToken: "987654:XYZ...",
+        },
+      },
+    },
+  },
 }
 ```
 
 Notes:
+
 - `default` is used when `accountId` is omitted (CLI + routing).
 - Env tokens only apply to the **default** account.
 - Base channel settings (group policy, mention gating, etc.) apply to all accounts unless overridden per account.
@@ -579,6 +593,7 @@ Notes:
 Group messages default to **require mention** (either metadata mention or regex patterns). Applies to WhatsApp, Telegram, Discord, Google Chat, and iMessage group chats.
 
 **Mention types:**
+
 - **Metadata mentions**: Native platform @-mentions (e.g., WhatsApp tap-to-mention). Ignored in WhatsApp self-chat mode (see `channels.whatsapp.allowFrom`).
 - **Text patterns**: Regex patterns defined in `agents.list[].groupChat.mentionPatterns`. Always checked regardless of self-chat mode.
 - Mention gating is enforced only when mention detection is possible (native mentions or at least one `mentionPattern`).
@@ -586,13 +601,11 @@ Group messages default to **require mention** (either metadata mention or regex
 ```json5
 {
   messages: {
-    groupChat: { historyLimit: 50 }
+    groupChat: { historyLimit: 50 },
   },
   agents: {
-    list: [
-      { id: "main", groupChat: { mentionPatterns: ["@clawd", "moltbot", "clawd"] } }
-    ]
-  }
+    list: [{ id: "main", groupChat: { mentionPatterns: ["@openclaw", "openclaw"] } }],
+  },
 }
 ```
 
@@ -606,16 +619,17 @@ DM conversations use session-based history managed by the agent. You can limit t
 {
   channels: {
     telegram: {
-      dmHistoryLimit: 30,  // limit DM sessions to 30 user turns
+      dmHistoryLimit: 30, // limit DM sessions to 30 user turns
       dms: {
-        "123456789": { historyLimit: 50 }  // per-user override (user ID)
-      }
-    }
-  }
+        "123456789": { historyLimit: 50 }, // per-user override (user ID)
+      },
+    },
+  },
 }
 ```
 
 Resolution order:
+
 1. Per-DM override: `channels.<provider>.dms[userId].historyLimit`
 2. Provider default: `channels.<provider>.dmHistoryLimit`
 3. No limit (all history retained)
@@ -623,28 +637,30 @@ Resolution order:
 Supported providers: `telegram`, `whatsapp`, `discord`, `slack`, `signal`, `imessage`, `msteams`.
 
 Per-agent override (takes precedence when set, even `[]`):
+
 ```json5
 {
   agents: {
     list: [
       { id: "work", groupChat: { mentionPatterns: ["@workbot", "\\+15555550123"] } },
-      { id: "personal", groupChat: { mentionPatterns: ["@homebot", "\\+15555550999"] } }
-    ]
-  }
+      { id: "personal", groupChat: { mentionPatterns: ["@homebot", "\\+15555550999"] } },
+    ],
+  },
 }
 ```
 
 Mention gating defaults live per channel (`channels.whatsapp.groups`, `channels.telegram.groups`, `channels.imessage.groups`, `channels.discord.guilds`). When `*.groups` is set, it also acts as a group allowlist; include `"*"` to allow all groups.
 
 To respond **only** to specific text triggers (ignoring native @-mentions):
+
 ```json5
 {
   channels: {
     whatsapp: {
       // Include your own number to enable self-chat mode (ignore native @-mentions).
       allowFrom: ["+15555550123"],
-      groups: { "*": { requireMention: true } }
-    }
+      groups: { "*": { requireMention: true } },
+    },
   },
   agents: {
     list: [
@@ -652,11 +668,11 @@ To respond **only** to specific text triggers (ignoring native @-mentions):
         id: "main",
         groupChat: {
           // Only these text patterns will trigger responses
-          mentionPatterns: ["reisponde", "@clawd"]
-        }
-      }
-    ]
-  }
+          mentionPatterns: ["reisponde", "@openclaw"],
+        },
+      },
+    ],
+  },
 }
 ```
 
@@ -669,41 +685,42 @@ Use `channels.*.groupPolicy` to control whether group/room messages are accepted
   channels: {
     whatsapp: {
       groupPolicy: "allowlist",
-      groupAllowFrom: ["+15551234567"]
+      groupAllowFrom: ["+15551234567"],
     },
     telegram: {
       groupPolicy: "allowlist",
-      groupAllowFrom: ["tg:123456789", "@alice"]
+      groupAllowFrom: ["tg:123456789", "@alice"],
     },
     signal: {
       groupPolicy: "allowlist",
-      groupAllowFrom: ["+15551234567"]
+      groupAllowFrom: ["+15551234567"],
     },
     imessage: {
       groupPolicy: "allowlist",
-      groupAllowFrom: ["chat_id:123"]
+      groupAllowFrom: ["chat_id:123"],
     },
     msteams: {
       groupPolicy: "allowlist",
-      groupAllowFrom: ["user@org.com"]
+      groupAllowFrom: ["user@org.com"],
     },
     discord: {
       groupPolicy: "allowlist",
       guilds: {
-        "GUILD_ID": {
-          channels: { help: { allow: true } }
-        }
-      }
+        GUILD_ID: {
+          channels: { help: { allow: true } },
+        },
+      },
     },
     slack: {
       groupPolicy: "allowlist",
-      channels: { "#general": { allow: true } }
-    }
-  }
+      channels: { "#general": { allow: true } },
+    },
+  },
 }
 ```
 
 Notes:
+
 - `"open"`: groups bypass allowlists; mention-gating still applies.
 - `"disabled"`: block all group/room messages.
 - `"allowlist"`: only allow groups/rooms that match the configured allowlist.
@@ -723,8 +740,8 @@ Inbound messages are routed to an agent via bindings.
   - `default`: optional; when multiple are set, the first wins and a warning is logged.
     If none are set, the **first entry** in the list is the default agent.
   - `name`: display name for the agent.
-  - `workspace`: default `~/clawd-<agentId>` (for `main`, falls back to `agents.defaults.workspace`).
-  - `agentDir`: default `~/.clawdbot/agents/<agentId>/agent`.
+  - `workspace`: default `~/.openclaw/workspace-<agentId>` (for `main`, falls back to `agents.defaults.workspace`).
+  - `agentDir`: default `~/.openclaw/agents/<agentId>/agent`.
   - `model`: per-agent default model, overrides `agents.defaults.model` for that agent.
     - string form: `"provider/model"`, overrides only `agents.defaults.model.primary`
     - object form: `{ primary, fallbacks }` (fallbacks override `agents.defaults.model.fallbacks`; `[]` disables global fallbacks for that agent)
@@ -752,12 +769,13 @@ Inbound messages are routed to an agent via bindings.
   - `match.guildId` / `match.teamId` (optional; channel-specific)
 
 Deterministic match order:
-1) `match.peer`
-2) `match.guildId`
-3) `match.teamId`
-4) `match.accountId` (exact, no peer/guild/team)
-5) `match.accountId: "*"` (channel-wide, no peer/guild/team)
-6) default agent (`agents.list[].default`, else first list entry, else `"main"`)
+
+1. `match.peer`
+2. `match.guildId`
+3. `match.teamId`
+4. `match.accountId` (exact, no peer/guild/team)
+5. `match.accountId: "*"` (channel-wide, no peer/guild/team)
+6. default agent (`agents.list[].default`, else first list entry, else `"main"`)
 
 Within each match tier, the first matching entry in `bindings` wins.
 
@@ -765,6 +783,7 @@ Within each match tier, the first matching entry in `bindings` wins.
 
 Each agent can carry its own sandbox + tool policy. Use this to mix access
 levels in one gateway:
+
 - **Full access** (personal agent)
 - **Read-only** tools + workspace
 - **No filesystem access** (messaging/session tools only)
@@ -773,63 +792,97 @@ See [Multi-Agent Sandbox & Tools](/multi-agent-sandbox-tools) for precedence and
 additional examples.
 
 Full access (no sandbox):
+
 ```json5
 {
   agents: {
     list: [
       {
         id: "personal",
-        workspace: "~/clawd-personal",
-        sandbox: { mode: "off" }
-      }
-    ]
-  }
+        workspace: "~/.openclaw/workspace-personal",
+        sandbox: { mode: "off" },
+      },
+    ],
+  },
 }
 ```
 
 Read-only tools + read-only workspace:
+
 ```json5
 {
   agents: {
     list: [
       {
         id: "family",
-        workspace: "~/clawd-family",
+        workspace: "~/.openclaw/workspace-family",
         sandbox: {
           mode: "all",
           scope: "agent",
-          workspaceAccess: "ro"
+          workspaceAccess: "ro",
         },
         tools: {
-          allow: ["read", "sessions_list", "sessions_history", "sessions_send", "sessions_spawn", "session_status"],
-          deny: ["write", "edit", "apply_patch", "exec", "process", "browser"]
-        }
-      }
-    ]
-  }
+          allow: [
+            "read",
+            "sessions_list",
+            "sessions_history",
+            "sessions_send",
+            "sessions_spawn",
+            "session_status",
+          ],
+          deny: ["write", "edit", "apply_patch", "exec", "process", "browser"],
+        },
+      },
+    ],
+  },
 }
 ```
 
 No filesystem access (messaging/session tools enabled):
+
 ```json5
 {
   agents: {
     list: [
       {
         id: "public",
-        workspace: "~/clawd-public",
+        workspace: "~/.openclaw/workspace-public",
         sandbox: {
           mode: "all",
           scope: "agent",
-          workspaceAccess: "none"
+          workspaceAccess: "none",
         },
         tools: {
-          allow: ["sessions_list", "sessions_history", "sessions_send", "sessions_spawn", "session_status", "whatsapp", "telegram", "slack", "discord", "gateway"],
-          deny: ["read", "write", "edit", "apply_patch", "exec", "process", "browser", "canvas", "nodes", "cron", "gateway", "image"]
-        }
-      }
-    ]
-  }
+          allow: [
+            "sessions_list",
+            "sessions_history",
+            "sessions_send",
+            "sessions_spawn",
+            "session_status",
+            "whatsapp",
+            "telegram",
+            "slack",
+            "discord",
+            "gateway",
+          ],
+          deny: [
+            "read",
+            "write",
+            "edit",
+            "apply_patch",
+            "exec",
+            "process",
+            "browser",
+            "canvas",
+            "nodes",
+            "cron",
+            "gateway",
+            "image",
+          ],
+        },
+      },
+    ],
+  },
 }
 ```
 
@@ -839,22 +892,22 @@ Example: two WhatsApp accounts → two agents:
 {
   agents: {
     list: [
-      { id: "home", default: true, workspace: "~/clawd-home" },
-      { id: "work", workspace: "~/clawd-work" }
-    ]
+      { id: "home", default: true, workspace: "~/.openclaw/workspace-home" },
+      { id: "work", workspace: "~/.openclaw/workspace-work" },
+    ],
   },
   bindings: [
     { agentId: "home", match: { channel: "whatsapp", accountId: "personal" } },
-    { agentId: "work", match: { channel: "whatsapp", accountId: "biz" } }
+    { agentId: "work", match: { channel: "whatsapp", accountId: "biz" } },
   ],
   channels: {
     whatsapp: {
       accounts: {
         personal: {},
         biz: {},
-      }
-    }
-  }
+      },
+    },
+  },
 }
 ```
 
@@ -867,9 +920,9 @@ Agent-to-agent messaging is opt-in:
   tools: {
     agentToAgent: {
       enabled: false,
-      allow: ["home", "work"]
-    }
-  }
+      allow: ["home", "work"],
+    },
+  },
 }
 ```
 
@@ -890,10 +943,10 @@ Controls how inbound messages behave when an agent run is already active.
         telegram: "collect",
         discord: "collect",
         imessage: "collect",
-        webchat: "collect"
-      }
-    }
-  }
+        webchat: "collect",
+      },
+    },
+  },
 }
 ```
 
@@ -911,14 +964,15 @@ and uses the most recent message for reply threading/IDs.
       byChannel: {
         whatsapp: 5000,
         slack: 1500,
-        discord: 1500
-      }
-    }
-  }
+        discord: 1500,
+      },
+    },
+  },
 }
 ```
 
 Notes:
+
 - Debounce batches **text-only** messages; media/attachments flush immediately.
 - Control commands (e.g. `/queue`, `/new`) bypass debouncing so they stay standalone.
 
@@ -929,19 +983,20 @@ Controls how chat commands are enabled across connectors.
 ```json5
 {
   commands: {
-    native: "auto",         // register native commands when supported (auto)
-    text: true,             // parse slash commands in chat messages
-    bash: false,            // allow ! (alias: /bash) (host-only; requires tools.elevated allowlists)
+    native: "auto", // register native commands when supported (auto)
+    text: true, // parse slash commands in chat messages
+    bash: false, // allow ! (alias: /bash) (host-only; requires tools.elevated allowlists)
     bashForegroundMs: 2000, // bash foreground window (0 backgrounds immediately)
-    config: false,          // allow /config (writes to disk)
-    debug: false,           // allow /debug (runtime-only overrides)
-    restart: false,         // allow /restart + gateway restart tool
-    useAccessGroups: true   // enforce access-group allowlists/policies for commands
-  }
+    config: false, // allow /config (writes to disk)
+    debug: false, // allow /debug (runtime-only overrides)
+    restart: false, // allow /restart + gateway restart tool
+    useAccessGroups: true, // enforce access-group allowlists/policies for commands
+  },
 }
 ```
 
 Notes:
+
 - Text commands must be sent as a **standalone** message and use the leading `/` (no plain-text aliases).
 - `commands.text: false` disables parsing chat messages for commands.
 - `commands.native: "auto"` (default) turns on native commands for Discord/Telegram and leaves Slack off; unsupported channels stay text-only.
@@ -949,7 +1004,7 @@ Notes:
 - `channels.telegram.customCommands` adds extra Telegram bot menu entries. Names are normalized; conflicts with native commands are ignored.
 - `commands.bash: true` enables `! <cmd>` to run host shell commands (`/bash <cmd>` also works as an alias). Requires `tools.elevated.enabled` and allowlisting the sender in `tools.elevated.allowFrom.<channel>`.
 - `commands.bashForegroundMs` controls how long bash waits before backgrounding. While a bash job is running, new `! <cmd>` requests are rejected (one at a time).
-- `commands.config: true` enables `/config` (reads/writes `moltbot.json`).
+- `commands.config: true` enables `/config` (reads/writes `openclaw.json`).
 - `channels.<provider>.configWrites` gates config mutations initiated by that channel (default: true). This applies to `/config set|unset` plus provider-specific auto-migrations (Telegram supergroup ID changes, Slack channel ID changes).
 - `commands.debug: true` enables `/debug` (runtime-only overrides).
 - `commands.restart: true` enables `/restart` and the gateway tool restart action.
@@ -972,15 +1027,15 @@ Set `web.enabled: false` to keep it off by default.
       maxMs: 120000,
       factor: 1.4,
       jitter: 0.2,
-      maxAttempts: 0
-    }
-  }
+      maxAttempts: 0,
+    },
+  },
 }
 ```
 
 ### `channels.telegram` (bot transport)
 
-Moltbot starts Telegram only when a `channels.telegram` config section exists. The bot token is resolved from `channels.telegram.botToken` (or `channels.telegram.tokenFile`), with `TELEGRAM_BOT_TOKEN` as a fallback for the default account.
+OpenClaw starts Telegram only when a `channels.telegram` config section exists. The bot token is resolved from `channels.telegram.botToken` (or `channels.telegram.tokenFile`), with `TELEGRAM_BOT_TOKEN` as a fallback for the default account.
 Set `channels.telegram.enabled: false` to disable automatic startup.
 Multi-account support lives under `channels.telegram.accounts` (see the multi-account section above). Env tokens only apply to the default account.
 Set `channels.telegram.configWrites: false` to block Telegram-initiated config writes (including supergroup ID migrations and `/config set|unset`).
@@ -991,8 +1046,8 @@ Set `channels.telegram.configWrites: false` to block Telegram-initiated config w
     telegram: {
       enabled: true,
       botToken: "your-bot-token",
-      dmPolicy: "pairing",                 // pairing | allowlist | open | disabled
-      allowFrom: ["tg:123456789"],         // optional; "open" requires ["*"]
+      dmPolicy: "pairing", // pairing | allowlist | open | disabled
+      allowFrom: ["tg:123456789"], // optional; "open" requires ["*"]
       groups: {
         "*": { requireMention: true },
         "-1001234567890": {
@@ -1002,50 +1057,54 @@ Set `channels.telegram.configWrites: false` to block Telegram-initiated config w
             "99": {
               requireMention: false,
               skills: ["search"],
-              systemPrompt: "Stay on topic."
-            }
-          }
-        }
+              systemPrompt: "Stay on topic.",
+            },
+          },
+        },
       },
       customCommands: [
         { command: "backup", description: "Git backup" },
-        { command: "generate", description: "Create an image" }
+        { command: "generate", description: "Create an image" },
       ],
-      historyLimit: 50,                     // include last N group messages as context (0 disables)
-      replyToMode: "first",                 // off | first | all
-      linkPreview: true,                   // toggle outbound link previews
-      streamMode: "partial",               // off | partial | block (draft streaming; separate from block streaming)
-      draftChunk: {                        // optional; only for streamMode=block
+      historyLimit: 50, // include last N group messages as context (0 disables)
+      replyToMode: "first", // off | first | all
+      linkPreview: true, // toggle outbound link previews
+      streamMode: "partial", // off | partial | block (draft streaming; separate from block streaming)
+      draftChunk: {
+        // optional; only for streamMode=block
         minChars: 200,
         maxChars: 800,
-        breakPreference: "paragraph"       // paragraph | newline | sentence
+        breakPreference: "paragraph", // paragraph | newline | sentence
       },
       actions: { reactions: true, sendMessage: true }, // tool action gates (false disables)
-      reactionNotifications: "own",   // off | own | all
+      reactionNotifications: "own", // off | own | all
       mediaMaxMb: 5,
-      retry: {                             // outbound retry policy
+      retry: {
+        // outbound retry policy
         attempts: 3,
         minDelayMs: 400,
         maxDelayMs: 30000,
-        jitter: 0.1
+        jitter: 0.1,
       },
-      network: {                           // transport overrides
-        autoSelectFamily: false
+      network: {
+        // transport overrides
+        autoSelectFamily: false,
       },
       proxy: "socks5://localhost:9050",
       webhookUrl: "https://example.com/telegram-webhook",
       webhookSecret: "secret",
-      webhookPath: "/telegram-webhook"
-    }
-  }
+      webhookPath: "/telegram-webhook",
+    },
+  },
 }
 ```
 
 Draft streaming notes:
+
 - Uses Telegram `sendMessageDraft` (draft bubble, not a real message).
 - Requires **private chat topics** (message_thread_id in DMs; bot has topics enabled).
 - `/reasoning stream` streams reasoning into the draft, then sends the final answer.
-Retry policy defaults and behavior are documented in [Retry policy](/concepts/retry).
+  Retry policy defaults and behavior are documented in [Retry policy](/concepts/retry).
 
 ### `channels.discord` (bot transport)
 
@@ -1058,9 +1117,10 @@ Multi-account support lives under `channels.discord.accounts` (see the multi-acc
     discord: {
       enabled: true,
       token: "your-bot-token",
-      mediaMaxMb: 8,                          // clamp inbound media size
-      allowBots: false,                       // allow bot-authored messages
-      actions: {                              // tool action gates (false disables)
+      mediaMaxMb: 8, // clamp inbound media size
+      allowBots: false, // allow bot-authored messages
+      actions: {
+        // tool action gates (false disables)
         reactions: true,
         stickers: true,
         polls: true,
@@ -1075,22 +1135,23 @@ Multi-account support lives under `channels.discord.accounts` (see the multi-acc
         channelInfo: true,
         voiceStatus: true,
         events: true,
-        moderation: false
+        moderation: false,
       },
-      replyToMode: "off",                     // off | first | all
+      replyToMode: "off", // off | first | all
       dm: {
-        enabled: true,                        // disable all DMs when false
-        policy: "pairing",                    // pairing | allowlist | open | disabled
+        enabled: true, // disable all DMs when false
+        policy: "pairing", // pairing | allowlist | open | disabled
         allowFrom: ["1234567890", "steipete"], // optional DM allowlist ("open" requires ["*"])
-        groupEnabled: false,                 // enable group DMs
-        groupChannels: ["clawd-dm"]          // optional group DM allowlist
+        groupEnabled: false, // enable group DMs
+        groupChannels: ["openclaw-dm"], // optional group DM allowlist
       },
       guilds: {
-        "123456789012345678": {               // guild id (preferred) or slug
-          slug: "friends-of-clawd",
-          requireMention: false,              // per-guild default
-          reactionNotifications: "own",       // off | own | all | allowlist
-          users: ["987654321098765432"],      // optional per-guild user allowlist
+        "123456789012345678": {
+          // guild id (preferred) or slug
+          slug: "friends-of-openclaw",
+          requireMention: false, // per-guild default
+          reactionNotifications: "own", // off | own | all | allowlist
+          users: ["987654321098765432"], // optional per-guild user allowlist
           channels: {
             general: { allow: true },
             help: {
@@ -1098,36 +1159,38 @@ Multi-account support lives under `channels.discord.accounts` (see the multi-acc
               requireMention: true,
               users: ["987654321098765432"],
               skills: ["docs"],
-              systemPrompt: "Short answers only."
-            }
-          }
-        }
+              systemPrompt: "Short answers only.",
+            },
+          },
+        },
       },
-      historyLimit: 20,                       // include last N guild messages as context
-      textChunkLimit: 2000,                   // optional outbound text chunk size (chars)
-      chunkMode: "length",                    // optional chunking mode (length | newline)
-      maxLinesPerMessage: 17,                 // soft max lines per message (Discord UI clipping)
-      retry: {                                // outbound retry policy
+      historyLimit: 20, // include last N guild messages as context
+      textChunkLimit: 2000, // optional outbound text chunk size (chars)
+      chunkMode: "length", // optional chunking mode (length | newline)
+      maxLinesPerMessage: 17, // soft max lines per message (Discord UI clipping)
+      retry: {
+        // outbound retry policy
         attempts: 3,
         minDelayMs: 500,
         maxDelayMs: 30000,
-        jitter: 0.1
-      }
-    }
-  }
+        jitter: 0.1,
+      },
+    },
+  },
 }
 ```
 
-Moltbot starts Discord only when a `channels.discord` config section exists. The token is resolved from `channels.discord.token`, with `DISCORD_BOT_TOKEN` as a fallback for the default account (unless `channels.discord.enabled` is `false`). Use `user:<id>` (DM) or `channel:<id>` (guild channel) when specifying delivery targets for cron/CLI commands; bare numeric IDs are ambiguous and rejected.
+OpenClaw starts Discord only when a `channels.discord` config section exists. The token is resolved from `channels.discord.token`, with `DISCORD_BOT_TOKEN` as a fallback for the default account (unless `channels.discord.enabled` is `false`). Use `user:<id>` (DM) or `channel:<id>` (guild channel) when specifying delivery targets for cron/CLI commands; bare numeric IDs are ambiguous and rejected.
 Guild slugs are lowercase with spaces replaced by `-`; channel keys use the slugged channel name (no leading `#`). Prefer guild ids as keys to avoid rename ambiguity.
 Bot-authored messages are ignored by default. Enable with `channels.discord.allowBots` (own messages are still filtered to prevent self-reply loops).
 Reaction notification modes:
+
 - `off`: no reaction events.
 - `own`: reactions on the bot's own messages (default).
 - `all`: all reactions on all messages.
 - `allowlist`: reactions from `guilds.<id>.users` on all messages (empty list disables).
-Outbound text is chunked by `channels.discord.textChunkLimit` (default 2000). Set `channels.discord.chunkMode="newline"` to split on blank lines (paragraph boundaries) before length chunking. Discord clients can clip very tall messages, so `channels.discord.maxLinesPerMessage` (default 17) splits long multi-line replies even when under 2000 chars.
-Retry policy defaults and behavior are documented in [Retry policy](/concepts/retry).
+  Outbound text is chunked by `channels.discord.textChunkLimit` (default 2000). Set `channels.discord.chunkMode="newline"` to split on blank lines (paragraph boundaries) before length chunking. Discord clients can clip very tall messages, so `channels.discord.maxLinesPerMessage` (default 17) splits long multi-line replies even when under 2000 chars.
+  Retry policy defaults and behavior are documented in [Retry policy](/concepts/retry).
 
 ### `channels.googlechat` (Chat API webhook)
 
@@ -1137,31 +1200,32 @@ Multi-account support lives under `channels.googlechat.accounts` (see the multi-
 ```json5
 {
   channels: {
-    "googlechat": {
+    googlechat: {
       enabled: true,
       serviceAccountFile: "/path/to/service-account.json",
-      audienceType: "app-url",             // app-url | project-number
+      audienceType: "app-url", // app-url | project-number
       audience: "https://gateway.example.com/googlechat",
       webhookPath: "/googlechat",
-      botUser: "users/1234567890",        // optional; improves mention detection
+      botUser: "users/1234567890", // optional; improves mention detection
       dm: {
         enabled: true,
-        policy: "pairing",                // pairing | allowlist | open | disabled
-        allowFrom: ["users/1234567890"]   // optional; "open" requires ["*"]
+        policy: "pairing", // pairing | allowlist | open | disabled
+        allowFrom: ["users/1234567890"], // optional; "open" requires ["*"]
       },
       groupPolicy: "allowlist",
       groups: {
-        "spaces/AAAA": { allow: true, requireMention: true }
+        "spaces/AAAA": { allow: true, requireMention: true },
       },
       actions: { reactions: true },
       typingIndicator: "message",
-      mediaMaxMb: 20
-    }
-  }
+      mediaMaxMb: 20,
+    },
+  },
 }
 ```
 
 Notes:
+
 - Service account JSON can be inline (`serviceAccount`) or file-based (`serviceAccountFile`).
 - Env fallbacks for the default account: `GOOGLE_CHAT_SERVICE_ACCOUNT` or `GOOGLE_CHAT_SERVICE_ACCOUNT_FILE`.
 - `audienceType` + `audience` must match the Chat app’s webhook auth config.
@@ -1183,7 +1247,7 @@ Slack runs in Socket Mode and requires both a bot token and app token:
         policy: "pairing", // pairing | allowlist | open | disabled
         allowFrom: ["U123", "U456", "*"], // optional; "open" requires ["*"]
         groupEnabled: false,
-        groupChannels: ["G123"]
+        groupChannels: ["G123"],
       },
       channels: {
         C123: { allow: true, requireMention: true, allowBots: false },
@@ -1193,53 +1257,55 @@ Slack runs in Socket Mode and requires both a bot token and app token:
           allowBots: false,
           users: ["U123"],
           skills: ["docs"],
-          systemPrompt: "Short answers only."
-        }
+          systemPrompt: "Short answers only.",
+        },
       },
-      historyLimit: 50,          // include last N channel/group messages as context (0 disables)
+      historyLimit: 50, // include last N channel/group messages as context (0 disables)
       allowBots: false,
       reactionNotifications: "own", // off | own | all | allowlist
       reactionAllowlist: ["U123"],
-      replyToMode: "off",           // off | first | all
+      replyToMode: "off", // off | first | all
       thread: {
-        historyScope: "thread",     // thread | channel
-        inheritParent: false
+        historyScope: "thread", // thread | channel
+        inheritParent: false,
       },
       actions: {
         reactions: true,
         messages: true,
         pins: true,
         memberInfo: true,
-        emojiList: true
+        emojiList: true,
       },
       slashCommand: {
         enabled: true,
-        name: "clawd",
+        name: "openclaw",
         sessionPrefix: "slack:slash",
-        ephemeral: true
+        ephemeral: true,
       },
       textChunkLimit: 4000,
       chunkMode: "length",
-      mediaMaxMb: 20
-    }
-  }
+      mediaMaxMb: 20,
+    },
+  },
 }
 ```
 
 Multi-account support lives under `channels.slack.accounts` (see the multi-account section above). Env tokens only apply to the default account.
 
-Moltbot starts Slack when the provider is enabled and both tokens are set (via config or `SLACK_BOT_TOKEN` + `SLACK_APP_TOKEN`). Use `user:<id>` (DM) or `channel:<id>` when specifying delivery targets for cron/CLI commands.
+OpenClaw starts Slack when the provider is enabled and both tokens are set (via config or `SLACK_BOT_TOKEN` + `SLACK_APP_TOKEN`). Use `user:<id>` (DM) or `channel:<id>` when specifying delivery targets for cron/CLI commands.
 Set `channels.slack.configWrites: false` to block Slack-initiated config writes (including channel ID migrations and `/config set|unset`).
 
 Bot-authored messages are ignored by default. Enable with `channels.slack.allowBots` or `channels.slack.channels.<id>.allowBots`.
 
 Reaction notification modes:
+
 - `off`: no reaction events.
 - `own`: reactions on the bot's own messages (default).
 - `all`: all reactions on all messages.
 - `allowlist`: reactions from `channels.slack.reactionAllowlist` on all messages (empty list disables).
 
 Thread session isolation:
+
 - `channels.slack.thread.historyScope` controls whether thread history is per-thread (`thread`, default) or shared across the channel (`channel`).
 - `channels.slack.thread.inheritParent` controls whether new thread sessions inherit the parent channel transcript (default: false).
 
@@ -1255,7 +1321,7 @@ Slack action groups (gate `slack` tool actions):
 ### `channels.mattermost` (bot token)
 
 Mattermost ships as a plugin and is not bundled with the core install.
-Install it first: `moltbot plugins install @moltbot/mattermost` (or `./extensions/mattermost` from a git checkout).
+Install it first: `openclaw plugins install @openclaw/mattermost` (or `./extensions/mattermost` from a git checkout).
 
 Mattermost requires a bot token plus the base URL for your server:
 
@@ -1270,20 +1336,22 @@ Mattermost requires a bot token plus the base URL for your server:
       chatmode: "oncall", // oncall | onmessage | onchar
       oncharPrefixes: [">", "!"],
       textChunkLimit: 4000,
-      chunkMode: "length"
-    }
-  }
+      chunkMode: "length",
+    },
+  },
 }
 ```
 
-Moltbot starts Mattermost when the account is configured (bot token + base URL) and enabled. The token + base URL are resolved from `channels.mattermost.botToken` + `channels.mattermost.baseUrl` or `MATTERMOST_BOT_TOKEN` + `MATTERMOST_URL` for the default account (unless `channels.mattermost.enabled` is `false`).
+OpenClaw starts Mattermost when the account is configured (bot token + base URL) and enabled. The token + base URL are resolved from `channels.mattermost.botToken` + `channels.mattermost.baseUrl` or `MATTERMOST_BOT_TOKEN` + `MATTERMOST_URL` for the default account (unless `channels.mattermost.enabled` is `false`).
 
 Chat modes:
+
 - `oncall` (default): respond to channel messages only when @mentioned.
 - `onmessage`: respond to every channel message.
 - `onchar`: respond when a message starts with a trigger prefix (`channels.mattermost.oncharPrefixes`, default `[">", "!"]`).
 
 Access control:
+
 - Default DMs: `channels.mattermost.dmPolicy="pairing"` (unknown senders get a pairing code).
 - Public DMs: `channels.mattermost.dmPolicy="open"` plus `channels.mattermost.allowFrom=["*"]`.
 - Groups: `channels.mattermost.groupPolicy="allowlist"` by default (mention-gated). Use `channels.mattermost.groupAllowFrom` to restrict senders.
@@ -1301,13 +1369,14 @@ Signal reactions can emit system events (shared reaction tooling):
     signal: {
       reactionNotifications: "own", // off | own | all | allowlist
       reactionAllowlist: ["+15551234567", "uuid:123e4567-e89b-12d3-a456-426614174000"],
-      historyLimit: 50 // include last N group messages as context (0 disables)
-    }
-  }
+      historyLimit: 50, // include last N group messages as context (0 disables)
+    },
+  },
 }
 ```
 
 Reaction notification modes:
+
 - `off`: no reaction events.
 - `own`: reactions on the bot's own messages (default).
 - `all`: all reactions on all messages.
@@ -1315,7 +1384,7 @@ Reaction notification modes:
 
 ### `channels.imessage` (imsg CLI)
 
-Moltbot spawns `imsg rpc` (JSON-RPC over stdio). No daemon or port required.
+OpenClaw spawns `imsg rpc` (JSON-RPC over stdio). No daemon or port required.
 
 ```json5
 {
@@ -1327,19 +1396,20 @@ Moltbot spawns `imsg rpc` (JSON-RPC over stdio). No daemon or port required.
       remoteHost: "user@gateway-host", // SCP for remote attachments when using SSH wrapper
       dmPolicy: "pairing", // pairing | allowlist | open | disabled
       allowFrom: ["+15555550123", "user@example.com", "chat_id:123"],
-      historyLimit: 50,    // include last N group messages as context (0 disables)
+      historyLimit: 50, // include last N group messages as context (0 disables)
       includeAttachments: false,
       mediaMaxMb: 16,
       service: "auto",
-      region: "US"
-    }
-  }
+      region: "US",
+    },
+  },
 }
 ```
 
 Multi-account support lives under `channels.imessage.accounts` (see the multi-account section above).
 
 Notes:
+
 - Requires Full Disk Access to the Messages DB.
 - The first send will prompt for Messages automation permission.
 - Prefer `chat_id:<id>` targets. Use `imsg chats --limit 20` to list chats.
@@ -1347,6 +1417,7 @@ Notes:
 - For remote SSH wrappers, set `channels.imessage.remoteHost` to fetch attachments via SCP when `includeAttachments` is enabled.
 
 Example wrapper:
+
 ```bash
 #!/usr/bin/env bash
 exec ssh -T gateway-host imsg "$@"
@@ -1356,11 +1427,11 @@ exec ssh -T gateway-host imsg "$@"
 
 Sets the **single global workspace directory** used by the agent for file operations.
 
-Default: `~/clawd`.
+Default: `~/.openclaw/workspace`.
 
 ```json5
 {
-  agents: { defaults: { workspace: "~/clawd" } }
+  agents: { defaults: { workspace: "~/.openclaw/workspace" } },
 }
 ```
 
@@ -1369,13 +1440,13 @@ own per-scope workspaces under `agents.defaults.sandbox.workspaceRoot`.
 
 ### `agents.defaults.repoRoot`
 
-Optional repository root to show in the system prompt’s Runtime line. If unset, Moltbot
+Optional repository root to show in the system prompt’s Runtime line. If unset, OpenClaw
 tries to detect a `.git` directory by walking upward from the workspace (and current
 working directory). The path must exist to be used.
 
 ```json5
 {
-  agents: { defaults: { repoRoot: "~/Projects/moltbot" } }
+  agents: { defaults: { repoRoot: "~/Projects/openclaw" } },
 }
 ```
 
@@ -1387,7 +1458,7 @@ Use this for pre-seeded deployments where your workspace files come from a repo.
 
 ```json5
 {
-  agents: { defaults: { skipBootstrap: true } }
+  agents: { defaults: { skipBootstrap: true } },
 }
 ```
 
@@ -1396,23 +1467,23 @@ Use this for pre-seeded deployments where your workspace files come from a repo.
 Max characters of each workspace bootstrap file injected into the system prompt
 before truncation. Default: `20000`.
 
-When a file exceeds this limit, Moltbot logs a warning and injects a truncated
+When a file exceeds this limit, OpenClaw logs a warning and injects a truncated
 head/tail with a marker.
 
 ```json5
 {
-  agents: { defaults: { bootstrapMaxChars: 20000 } }
+  agents: { defaults: { bootstrapMaxChars: 20000 } },
 }
 ```
 
 ### `agents.defaults.userTimezone`
 
 Sets the user’s timezone for **system prompt context** (not for timestamps in
-message envelopes). If unset, Moltbot uses the host timezone at runtime.
+message envelopes). If unset, OpenClaw uses the host timezone at runtime.
 
 ```json5
 {
-  agents: { defaults: { userTimezone: "America/Chicago" } }
+  agents: { defaults: { userTimezone: "America/Chicago" } },
 }
 ```
 
@@ -1423,7 +1494,7 @@ Default: `auto` (OS preference).
 
 ```json5
 {
-  agents: { defaults: { timeFormat: "auto" } } // auto | 12 | 24
+  agents: { defaults: { timeFormat: "auto" } }, // auto | 12 | 24
 }
 ```
 
@@ -1438,8 +1509,8 @@ See [Messages](/concepts/messages) for queueing, sessions, and streaming context
     responsePrefix: "🦞", // or "auto"
     ackReaction: "👀",
     ackReactionScope: "group-mentions",
-    removeAckAfterReply: false
-  }
+    removeAckAfterReply: false,
+  },
 }
 ```
 
@@ -1448,20 +1519,20 @@ streaming, final replies) across channels unless already present.
 
 If `messages.responsePrefix` is unset, no prefix is applied by default. WhatsApp self-chat
 replies are the exception: they default to `[{identity.name}]` when set, otherwise
-`[moltbot]`, so same-phone conversations stay legible.
+`[openclaw]`, so same-phone conversations stay legible.
 Set it to `"auto"` to derive `[{identity.name}]` for the routed agent (when set).
 
 #### Template variables
 
 The `responsePrefix` string can include template variables that resolve dynamically:
 
-| Variable | Description | Example |
-|----------|-------------|---------|
-| `{model}` | Short model name | `claude-opus-4-5`, `gpt-4o` |
-| `{modelFull}` | Full model identifier | `anthropic/claude-opus-4-5` |
-| `{provider}` | Provider name | `anthropic`, `openai` |
-| `{thinkingLevel}` | Current thinking level | `high`, `low`, `off` |
-| `{identity.name}` | Agent identity name | (same as `"auto"` mode) |
+| Variable          | Description            | Example                     |
+| ----------------- | ---------------------- | --------------------------- |
+| `{model}`         | Short model name       | `claude-opus-4-5`, `gpt-4o` |
+| `{modelFull}`     | Full model identifier  | `anthropic/claude-opus-4-5` |
+| `{provider}`      | Provider name          | `anthropic`, `openai`       |
+| `{thinkingLevel}` | Current thinking level | `high`, `low`, `off`        |
+| `{identity.name}` | Agent identity name    | (same as `"auto"` mode)     |
 
 Variables are case-insensitive (`{MODEL}` = `{model}`). `{think}` is an alias for `{thinkingLevel}`.
 Unresolved variables remain as literal text.
@@ -1469,17 +1540,17 @@ Unresolved variables remain as literal text.
 ```json5
 {
   messages: {
-    responsePrefix: "[{model} | think:{thinkingLevel}]"
-  }
+    responsePrefix: "[{model} | think:{thinkingLevel}]",
+  },
 }
 ```
 
 Example output: `[claude-opus-4-5 | think:high] Here's my response...`
 
 WhatsApp inbound prefix is configured via `channels.whatsapp.messagePrefix` (deprecated:
-`messages.messagePrefix`). Default stays **unchanged**: `"[moltbot]"` when
+`messages.messagePrefix`). Default stays **unchanged**: `"[openclaw]"` when
 `channels.whatsapp.allowFrom` is empty, otherwise `""` (no prefix). When using
-`"[moltbot]"`, Moltbot will instead use `[{identity.name}]` when the routed
+`"[openclaw]"`, OpenClaw will instead use `[{identity.name}]` when the routed
 agent has `identity.name` set.
 
 `ackReaction` sends a best-effort emoji reaction to acknowledge inbound messages
@@ -1487,6 +1558,7 @@ on channels that support reactions (Slack/Discord/Telegram/Google Chat). Default
 active agent’s `identity.emoji` when set, otherwise `"👀"`. Set it to `""` to disable.
 
 `ackReactionScope` controls when reactions fire:
+
 - `group-mentions` (default): only when a group/room requires mentions **and** the bot was mentioned
 - `group-all`: all group/room messages
 - `direct`: direct messages only
@@ -1497,7 +1569,7 @@ active agent’s `identity.emoji` when set, otherwise `"👀"`. Set it to `""` t
 
 #### `messages.tts`
 
-Enable text-to-speech for outbound replies. When on, Moltbot generates audio
+Enable text-to-speech for outbound replies. When on, OpenClaw generates audio
 using ElevenLabs or OpenAI and attaches it to responses. Telegram uses Opus
 voice notes; other channels send MP3 audio.
 
@@ -1510,11 +1582,11 @@ voice notes; other channels send MP3 audio.
       provider: "elevenlabs",
       summaryModel: "openai/gpt-4.1-mini",
       modelOverrides: {
-        enabled: true
+        enabled: true,
       },
       maxTextLength: 4000,
       timeoutMs: 30000,
-      prefsPath: "~/.clawdbot/settings/tts.json",
+      prefsPath: "~/.openclaw/settings/tts.json",
       elevenlabs: {
         apiKey: "elevenlabs_api_key",
         baseUrl: "https://api.elevenlabs.io",
@@ -1528,20 +1600,21 @@ voice notes; other channels send MP3 audio.
           similarityBoost: 0.75,
           style: 0.0,
           useSpeakerBoost: true,
-          speed: 1.0
-        }
+          speed: 1.0,
+        },
       },
       openai: {
         apiKey: "openai_api_key",
         model: "gpt-4o-mini-tts",
-        voice: "alloy"
-      }
-    }
-  }
+        voice: "alloy",
+      },
+    },
+  },
 }
 ```
 
 Notes:
+
 - `messages.tts.auto` controls auto‑TTS (`off`, `always`, `inbound`, `tagged`).
 - `/tts off|always|inbound|tagged` sets the per‑session auto mode (overrides config).
 - `messages.tts.enabled` is legacy; doctor migrates it to `messages.tts.auto`.
@@ -1568,13 +1641,13 @@ Defaults for Talk mode (macOS/iOS/Android). Voice IDs fall back to `ELEVENLABS_V
     voiceId: "elevenlabs_voice_id",
     voiceAliases: {
       Clawd: "EXAVITQu4vr4xnSDxMaL",
-      Roger: "CwhRBWXzGAHq8TQ4Fs17"
+      Roger: "CwhRBWXzGAHq8TQ4Fs17",
     },
     modelId: "eleven_v3",
     outputFormat: "mp3_44100_128",
     apiKey: "elevenlabs_api_key",
-    interruptOnSpeech: true
-  }
+    interruptOnSpeech: true,
+  },
 }
 ```
 
@@ -1585,6 +1658,7 @@ Controls the embedded agent runtime (model/thinking/verbose/timeouts).
 `agents.defaults.model.primary` sets the default model; `agents.defaults.model.fallbacks` are global failovers.
 `agents.defaults.imageModel` is optional and is **only used if the primary model lacks image input**.
 Each `agents.defaults.models` entry can include:
+
 - `alias` (optional model shortcut, e.g. `/opus`).
 - `params` (optional provider-specific API params passed through to the model request).
 
@@ -1598,22 +1672,23 @@ Example:
     defaults: {
       models: {
         "anthropic/claude-sonnet-4-5-20250929": {
-          params: { temperature: 0.6 }
+          params: { temperature: 0.6 },
         },
         "openai/gpt-5.2": {
-          params: { maxTokens: 8192 }
-        }
-      }
-    }
-  }
+          params: { maxTokens: 8192 },
+        },
+      },
+    },
+  },
 }
 ```
 
 Z.AI GLM-4.x models automatically enable thinking mode unless you:
+
 - set `--thinking off`, or
 - define `agents.defaults.models["zai/<model>"].params.thinking` yourself.
 
-Moltbot also ships a few built-in alias shorthands. Defaults only apply when the model
+OpenClaw also ships a few built-in alias shorthands. Defaults only apply when the model
 is already present in `agents.defaults.models`:
 
 - `opus` -> `anthropic/claude-opus-4-5`
@@ -1633,14 +1708,14 @@ Example: Opus 4.5 primary with MiniMax M2.1 fallback (hosted MiniMax):
     defaults: {
       models: {
         "anthropic/claude-opus-4-5": { alias: "opus" },
-        "minimax/MiniMax-M2.1": { alias: "minimax" }
+        "minimax/MiniMax-M2.1": { alias: "minimax" },
       },
       model: {
         primary: "anthropic/claude-opus-4-5",
-        fallbacks: ["minimax/MiniMax-M2.1"]
-      }
-    }
-  }
+        fallbacks: ["minimax/MiniMax-M2.1"],
+      },
+    },
+  },
 }
 ```
 
@@ -1653,6 +1728,7 @@ backup path when API providers fail. Image pass-through is supported when you co
 an `imageArg` that accepts file paths.
 
 Notes:
+
 - CLI backends are **text-first**; tools are always disabled.
 - Sessions are supported when `sessionArg` is set; session ids are persisted per backend.
 - For `claude-cli`, defaults are wired in. Override the command path if PATH is minimal
@@ -1666,7 +1742,7 @@ Example:
     defaults: {
       cliBackends: {
         "claude-cli": {
-          command: "/opt/homebrew/bin/claude"
+          command: "/opt/homebrew/bin/claude",
         },
         "my-cli": {
           command: "my-cli",
@@ -1678,11 +1754,11 @@ Example:
           systemPromptArg: "--system",
           systemPromptWhen: "first",
           imageArg: "--image",
-          imageMode: "repeat"
-        }
-      }
-    }
-  }
+          imageMode: "repeat",
+        },
+      },
+    },
+  },
 }
 ```
 
@@ -1699,23 +1775,21 @@ Example:
           params: {
             thinking: {
               type: "enabled",
-              clear_thinking: false
-            }
-          }
-        }
+              clear_thinking: false,
+            },
+          },
+        },
       },
       model: {
         primary: "anthropic/claude-opus-4-5",
         fallbacks: [
           "openrouter/deepseek/deepseek-r1:free",
-          "openrouter/meta-llama/llama-3.3-70b-instruct:free"
-        ]
+          "openrouter/meta-llama/llama-3.3-70b-instruct:free",
+        ],
       },
       imageModel: {
         primary: "openrouter/qwen/qwen-2.5-vl-72b-instruct:free",
-        fallbacks: [
-          "openrouter/google/gemini-2.0-flash-vision:free"
-        ]
+        fallbacks: ["openrouter/google/gemini-2.0-flash-vision:free"],
       },
       thinkingDefault: "low",
       verboseDefault: "off",
@@ -1724,22 +1798,22 @@ Example:
       mediaMaxMb: 5,
       heartbeat: {
         every: "30m",
-        target: "last"
+        target: "last",
       },
       maxConcurrent: 3,
       subagents: {
         model: "minimax/MiniMax-M2.1",
         maxConcurrent: 1,
-        archiveAfterMinutes: 60
+        archiveAfterMinutes: 60,
       },
       exec: {
         backgroundMs: 10000,
         timeoutSec: 1800,
-        cleanupMs: 1800000
+        cleanupMs: 1800000,
       },
-      contextTokens: 200000
-    }
-  }
+      contextTokens: 200000,
+    },
+  },
 }
 ```
 
@@ -1751,6 +1825,7 @@ It does **not** modify the session history on disk (`*.jsonl` remains complete).
 This is intended to reduce token usage for chatty agents that accumulate large tool outputs over time.
 
 High level:
+
 - Never touches user/assistant messages.
 - Protects the last `keepLastAssistants` assistant messages (no tool results after that point are pruned).
 - Protects the bootstrap prefix (nothing before the first user message is pruned).
@@ -1761,7 +1836,8 @@ High level:
   - `aggressive`: always replaces eligible tool results before the cutoff with the `hardClear.placeholder` (no ratio checks).
 
 Soft vs hard pruning (what changes in the context sent to the LLM):
-- **Soft-trim**: only for *oversized* tool results. Keeps the beginning + end and inserts `...` in the middle.
+
+- **Soft-trim**: only for _oversized_ tool results. Keeps the beginning + end and inserts `...` in the middle.
   - Before: `toolResult("…very long output…")`
   - After: `toolResult("HEAD…\n...\n…TAIL\n\n[Tool result trimmed: …]")`
 - **Hard-clear**: replaces the entire tool result with the placeholder.
@@ -1769,26 +1845,30 @@ Soft vs hard pruning (what changes in the context sent to the LLM):
   - After: `toolResult("[Old tool result content cleared]")`
 
 Notes / current limitations:
+
 - Tool results containing **image blocks are skipped** (never trimmed/cleared) right now.
 - The estimated “context ratio” is based on **characters** (approximate), not exact tokens.
 - If the session doesn’t contain at least `keepLastAssistants` assistant messages yet, pruning is skipped.
 - In `aggressive` mode, `hardClear.enabled` is ignored (eligible tool results are always replaced with `hardClear.placeholder`).
 
 Default (adaptive):
+
 ```json5
 {
-  agents: { defaults: { contextPruning: { mode: "adaptive" } } }
+  agents: { defaults: { contextPruning: { mode: "adaptive" } } },
 }
 ```
 
 To disable:
+
 ```json5
 {
-  agents: { defaults: { contextPruning: { mode: "off" } } }
+  agents: { defaults: { contextPruning: { mode: "off" } } },
 }
 ```
 
 Defaults (when `mode` is `"adaptive"` or `"aggressive"`):
+
 - `keepLastAssistants`: `3`
 - `softTrimRatio`: `0.3` (adaptive only)
 - `hardClearRatio`: `0.5` (adaptive only)
@@ -1797,13 +1877,15 @@ Defaults (when `mode` is `"adaptive"` or `"aggressive"`):
 - `hardClear`: `{ enabled: true, placeholder: "[Old tool result content cleared]" }`
 
 Example (aggressive, minimal):
+
 ```json5
 {
-  agents: { defaults: { contextPruning: { mode: "aggressive" } } }
+  agents: { defaults: { contextPruning: { mode: "aggressive" } } },
 }
 ```
 
 Example (adaptive tuned):
+
 ```json5
 {
   agents: {
@@ -1818,9 +1900,9 @@ Example (adaptive tuned):
         hardClear: { enabled: true, placeholder: "[Old tool result content cleared]" },
         // Optional: restrict pruning to specific tools (deny wins; supports "*" wildcards)
         tools: { deny: ["browser", "canvas"] },
-      }
-    }
-  }
+      },
+    },
+  },
 }
 ```
 
@@ -1839,6 +1921,7 @@ auto-compaction, instructing the model to store durable memories on disk (e.g.
 soft threshold below the compaction limit.
 
 Legacy defaults:
+
 - `memoryFlush.enabled`: `true`
 - `memoryFlush.softThresholdTokens`: `4000`
 - `memoryFlush.prompt` / `memoryFlush.systemPrompt`: built-in defaults with `NO_REPLY`
@@ -1846,6 +1929,7 @@ Legacy defaults:
   (`agents.defaults.sandbox.workspaceAccess: "ro"` or `"none"`).
 
 Example (tuned):
+
 ```json5
 {
   agents: {
@@ -1857,15 +1941,16 @@ Example (tuned):
           enabled: true,
           softThresholdTokens: 6000,
           systemPrompt: "Session nearing compaction. Store durable memories now.",
-          prompt: "Write any lasting notes to memory/YYYY-MM-DD.md; reply with NO_REPLY if nothing to store."
-        }
-      }
-    }
-  }
+          prompt: "Write any lasting notes to memory/YYYY-MM-DD.md; reply with NO_REPLY if nothing to store.",
+        },
+      },
+    },
+  },
 }
 ```
 
 Block streaming:
+
 - `agents.defaults.blockStreamingDefault`: `"on"`/`"off"` (default off).
 - Channel overrides: `*.blockStreaming` (and per-account variants) to force block streaming on/off.
   Non-Telegram channels require an explicit `*.blockStreaming: true` to enable block replies.
@@ -1875,7 +1960,7 @@ Block streaming:
   Example:
   ```json5
   {
-    agents: { defaults: { blockStreamingChunk: { minChars: 800, maxChars: 1200 } } }
+    agents: { defaults: { blockStreamingChunk: { minChars: 800, maxChars: 1200 } } },
   }
   ```
 - `agents.defaults.blockStreamingCoalesce`: merge streamed blocks before sending.
@@ -1893,27 +1978,29 @@ Block streaming:
   Example:
   ```json5
   {
-    agents: { defaults: { humanDelay: { mode: "natural" } } }
+    agents: { defaults: { humanDelay: { mode: "natural" } } },
   }
   ```
-See [/concepts/streaming](/concepts/streaming) for behavior + chunking details.
+  See [/concepts/streaming](/concepts/streaming) for behavior + chunking details.
 
 Typing indicators:
+
 - `agents.defaults.typingMode`: `"never" | "instant" | "thinking" | "message"`. Defaults to
   `instant` for direct chats / mentions and `message` for unmentioned group chats.
 - `session.typingMode`: per-session override for the mode.
 - `agents.defaults.typingIntervalSeconds`: how often the typing signal is refreshed (default: 6s).
 - `session.typingIntervalSeconds`: per-session override for the refresh interval.
-See [/concepts/typing-indicators](/concepts/typing-indicators) for behavior details.
+  See [/concepts/typing-indicators](/concepts/typing-indicators) for behavior details.
 
 `agents.defaults.model.primary` should be set as `provider/model` (e.g. `anthropic/claude-opus-4-5`).
 Aliases come from `agents.defaults.models.*.alias` (e.g. `Opus`).
-If you omit the provider, Moltbot currently assumes `anthropic` as a temporary
+If you omit the provider, OpenClaw currently assumes `anthropic` as a temporary
 deprecation fallback.
 Z.AI models are available as `zai/<model>` (e.g. `zai/glm-4.7`) and require
 `ZAI_API_KEY` (or legacy `Z_AI_API_KEY`) in the environment.
 
 `agents.defaults.heartbeat` configures periodic heartbeat runs:
+
 - `every`: duration string (`ms`, `s`, `m`, `h`); default unit minutes. Default:
   `30m`. Set `0m` to disable.
 - `model`: optional override model for heartbeat runs (`provider/model`).
@@ -1925,6 +2012,7 @@ Z.AI models are available as `zai/<model>` (e.g. `zai/glm-4.7`) and require
 - `ackMaxChars`: max chars allowed after `HEARTBEAT_OK` before delivery (default: 300).
 
 Per-agent heartbeats:
+
 - Set `agents.list[].heartbeat` to enable or override heartbeat settings for a specific agent.
 - If any agent entry defines `heartbeat`, **only those agents** run heartbeats; defaults
   become the shared baseline for those agents.
@@ -1933,17 +2021,19 @@ Heartbeats run full agent turns. Shorter intervals burn more tokens; be mindful
 of `every`, keep `HEARTBEAT.md` tiny, and/or choose a cheaper `model`.
 
 `tools.exec` configures background exec defaults:
+
 - `backgroundMs`: time before auto-background (ms, default 10000)
 - `timeoutSec`: auto-kill after this runtime (seconds, default 1800)
 - `cleanupMs`: how long to keep finished sessions in memory (ms, default 1800000)
 - `notifyOnExit`: enqueue a system event + request heartbeat when backgrounded exec exits (default true)
 - `applyPatch.enabled`: enable experimental `apply_patch` (OpenAI/OpenAI Codex only; default false)
 - `applyPatch.allowModels`: optional allowlist of model ids (e.g. `gpt-5.2` or `openai/gpt-5.2`)
-Note: `applyPatch` is only under `tools.exec`.
+  Note: `applyPatch` is only under `tools.exec`.
 
 `tools.web` configures web search + fetch tools:
+
 - `tools.web.search.enabled` (default: true when key is present)
-- `tools.web.search.apiKey` (recommended: set via `moltbot configure --section web`, or use `BRAVE_API_KEY` env var)
+- `tools.web.search.apiKey` (recommended: set via `openclaw configure --section web`, or use `BRAVE_API_KEY` env var)
 - `tools.web.search.maxResults` (1–10, default 5)
 - `tools.web.search.timeoutSeconds` (default 30)
 - `tools.web.search.cacheTtlMinutes` (default 15)
@@ -1961,6 +2051,7 @@ Note: `applyPatch` is only under `tools.exec`.
 - `tools.web.fetch.firecrawl.timeoutSeconds` (optional)
 
 `tools.media` configures inbound media understanding (image/audio/video):
+
 - `tools.media.models`: shared model list (capability-tagged; used after per-cap lists).
 - `tools.media.concurrency`: max concurrent capability runs (default 2).
 - `tools.media.image` / `tools.media.audio` / `tools.media.video`:
@@ -1989,6 +2080,7 @@ If no models are configured (or `enabled: false`), understanding is skipped; the
 Provider auth follows the standard model auth order (auth profiles, env vars like `OPENAI_API_KEY`/`GROQ_API_KEY`/`GEMINI_API_KEY`, or `models.providers.*.apiKey`).
 
 Example:
+
 ```json5
 {
   tools: {
@@ -1998,30 +2090,32 @@ Example:
         maxBytes: 20971520,
         scope: {
           default: "deny",
-          rules: [{ action: "allow", match: { chatType: "direct" } }]
+          rules: [{ action: "allow", match: { chatType: "direct" } }],
         },
         models: [
           { provider: "openai", model: "gpt-4o-mini-transcribe" },
-          { type: "cli", command: "whisper", args: ["--model", "base", "{{MediaPath}}"] }
-        ]
+          { type: "cli", command: "whisper", args: ["--model", "base", "{{MediaPath}}"] },
+        ],
       },
       video: {
         enabled: true,
         maxBytes: 52428800,
-        models: [{ provider: "google", model: "gemini-3-flash-preview" }]
-      }
-    }
-  }
+        models: [{ provider: "google", model: "gemini-3-flash-preview" }],
+      },
+    },
+  },
 }
 ```
 
 `agents.defaults.subagents` configures sub-agent defaults:
+
 - `model`: default model for spawned sub-agents (string or `{ primary, fallbacks }`). If omitted, sub-agents inherit the caller’s model unless overridden per agent or per call.
 - `maxConcurrent`: max concurrent sub-agent runs (default 1)
 - `archiveAfterMinutes`: auto-archive sub-agent sessions after N minutes (default 60; set `0` to disable)
 - Per-subagent tool policy: `tools.subagents.tools.allow` / `tools.subagents.tools.deny` (deny wins)
 
 `tools.profile` sets a **base tool allowlist** before `tools.allow`/`tools.deny`:
+
 - `minimal`: `session_status` only
 - `coding`: `group:fs`, `group:runtime`, `group:sessions`, `group:memory`, `image`
 - `messaging`: `group:messaging`, `sessions_list`, `sessions_history`, `sessions_send`, `session_status`
@@ -2030,22 +2124,24 @@ Example:
 Per-agent override: `agents.list[].tools.profile`.
 
 Example (messaging-only by default, allow Slack + Discord tools too):
+
 ```json5
 {
   tools: {
     profile: "messaging",
-    allow: ["slack", "discord"]
-  }
+    allow: ["slack", "discord"],
+  },
 }
 ```
 
 Example (coding profile, but deny exec/process everywhere):
+
 ```json5
 {
   tools: {
     profile: "coding",
-    deny: ["group:runtime"]
-  }
+    deny: ["group:runtime"],
+  },
 }
 ```
 
@@ -2057,26 +2153,28 @@ Provider keys accept either `provider` (e.g. `google-antigravity`) or `provider/
 (e.g. `openai/gpt-5.2`).
 
 Example (keep global coding profile, but minimal tools for Google Antigravity):
+
 ```json5
 {
   tools: {
     profile: "coding",
     byProvider: {
-      "google-antigravity": { profile: "minimal" }
-    }
-  }
+      "google-antigravity": { profile: "minimal" },
+    },
+  },
 }
 ```
 
 Example (provider/model-specific allowlist):
+
 ```json5
 {
   tools: {
     allow: ["group:fs", "group:runtime", "sessions_list"],
     byProvider: {
-      "openai/gpt-5.2": { allow: ["group:fs", "sessions_list"] }
-    }
-  }
+      "openai/gpt-5.2": { allow: ["group:fs", "sessions_list"] },
+    },
+  },
 }
 ```
 
@@ -2085,13 +2183,15 @@ Matching is case-insensitive and supports `*` wildcards (`"*"` means all tools).
 This is applied even when the Docker sandbox is **off**.
 
 Example (disable browser/canvas everywhere):
+
 ```json5
 {
-  tools: { deny: ["browser", "canvas"] }
+  tools: { deny: ["browser", "canvas"] },
 }
 ```
 
 Tool groups (shorthands) work in **global** and **per-agent** tool policies:
+
 - `group:runtime`: `exec`, `bash`, `process`
 - `group:fs`: `read`, `write`, `edit`, `apply_patch`
 - `group:sessions`: `sessions_list`, `sessions_history`, `sessions_send`, `sessions_spawn`, `session_status`
@@ -2101,9 +2201,10 @@ Tool groups (shorthands) work in **global** and **per-agent** tool policies:
 - `group:automation`: `cron`, `gateway`
 - `group:messaging`: `message`
 - `group:nodes`: `nodes`
-- `group:moltbot`: all built-in Moltbot tools (excludes provider plugins)
+- `group:openclaw`: all built-in OpenClaw tools (excludes provider plugins)
 
 `tools.elevated` controls elevated (host) exec access:
+
 - `enabled`: allow elevated mode (default true)
 - `allowFrom`: per-channel allowlists (empty = disabled)
   - `whatsapp`: E.164 numbers
@@ -2114,6 +2215,7 @@ Tool groups (shorthands) work in **global** and **per-agent** tool policies:
   - `webchat`: session ids or usernames
 
 Example:
+
 ```json5
 {
   tools: {
@@ -2121,14 +2223,15 @@ Example:
       enabled: true,
       allowFrom: {
         whatsapp: ["+15555550123"],
-        discord: ["steipete", "1234567890123"]
-      }
-    }
-  }
+        discord: ["steipete", "1234567890123"],
+      },
+    },
+  },
 }
 ```
 
 Per-agent override (further restrict):
+
 ```json5
 {
   agents: {
@@ -2136,15 +2239,16 @@ Per-agent override (further restrict):
       {
         id: "family",
         tools: {
-          elevated: { enabled: false }
-        }
-      }
-    ]
-  }
+          elevated: { enabled: false },
+        },
+      },
+    ],
+  },
 }
 ```
 
 Notes:
+
 - `tools.elevated` is the global baseline. `agents.list[].tools.elevated` can only further restrict (both must allow).
 - `/elevated on|off|ask|full` stores state per session key; inline directives apply to a single message.
 - Elevated `exec` runs on the host and bypasses sandboxing.
@@ -2162,10 +2266,11 @@ sessions so they cannot access your host system.
 Details: [Sandboxing](/gateway/sandboxing)
 
 Defaults (if enabled):
+
 - scope: `"agent"` (one container + workspace per agent)
 - Debian bookworm-slim based image
 - agent workspace access: `workspaceAccess: "none"` (default)
-  - `"none"`: use a per-scope sandbox workspace under `~/.clawdbot/sandboxes`
+  - `"none"`: use a per-scope sandbox workspace under `~/.openclaw/sandboxes`
 - `"ro"`: keep the sandbox workspace at `/workspace`, and mount the agent workspace read-only at `/agent` (disables `write`/`edit`/`apply_patch`)
   - `"rw"`: mount the agent workspace read/write at `/workspace`
 - auto-prune: idle > 24h OR age > 7d
@@ -2192,10 +2297,10 @@ For package installs, ensure network egress, a writable root FS, and a root user
         mode: "non-main", // off | non-main | all
         scope: "agent", // session | agent | shared (agent is default)
         workspaceAccess: "none", // none | ro | rw
-        workspaceRoot: "~/.clawdbot/sandboxes",
+        workspaceRoot: "~/.openclaw/sandboxes",
         docker: {
-          image: "moltbot-sandbox:bookworm-slim",
-          containerPrefix: "moltbot-sbx-",
+          image: "openclaw-sandbox:bookworm-slim",
+          containerPrefix: "openclaw-sbx-",
           workdir: "/workspace",
           readOnlyRoot: true,
           tmpfs: ["/tmp", "/var/tmp", "/run"],
@@ -2211,18 +2316,18 @@ For package installs, ensure network egress, a writable root FS, and a root user
           cpus: 1,
           ulimits: {
             nofile: { soft: 1024, hard: 2048 },
-            nproc: 256
+            nproc: 256,
           },
           seccompProfile: "/path/to/seccomp.json",
-          apparmorProfile: "moltbot-sandbox",
+          apparmorProfile: "openclaw-sandbox",
           dns: ["1.1.1.1", "8.8.8.8"],
           extraHosts: ["internal.service:10.0.0.5"],
-          binds: ["/var/run/docker.sock:/var/run/docker.sock", "/home/user/source:/source:rw"]
+          binds: ["/var/run/docker.sock:/var/run/docker.sock", "/home/user/source:/source:rw"],
         },
         browser: {
           enabled: false,
-          image: "moltbot-sandbox-browser:bookworm-slim",
-          containerPrefix: "moltbot-sbx-browser-",
+          image: "openclaw-sandbox-browser:bookworm-slim",
+          containerPrefix: "openclaw-sbx-browser-",
           cdpPort: 9222,
           vncPort: 5900,
           noVncPort: 6080,
@@ -2233,27 +2338,40 @@ For package installs, ensure network egress, a writable root FS, and a root user
           allowedControlHosts: ["browser.lab.local", "10.0.0.42"],
           allowedControlPorts: [18791],
           autoStart: true,
-          autoStartTimeoutMs: 12000
+          autoStartTimeoutMs: 12000,
         },
         prune: {
-          idleHours: 24,  // 0 disables idle pruning
-          maxAgeDays: 7   // 0 disables max-age pruning
-        }
-      }
-    }
+          idleHours: 24, // 0 disables idle pruning
+          maxAgeDays: 7, // 0 disables max-age pruning
+        },
+      },
+    },
   },
   tools: {
     sandbox: {
       tools: {
-        allow: ["exec", "process", "read", "write", "edit", "apply_patch", "sessions_list", "sessions_history", "sessions_send", "sessions_spawn", "session_status"],
-        deny: ["browser", "canvas", "nodes", "cron", "discord", "gateway"]
-      }
-    }
-  }
+        allow: [
+          "exec",
+          "process",
+          "read",
+          "write",
+          "edit",
+          "apply_patch",
+          "sessions_list",
+          "sessions_history",
+          "sessions_send",
+          "sessions_spawn",
+          "session_status",
+        ],
+        deny: ["browser", "canvas", "nodes", "cron", "discord", "gateway"],
+      },
+    },
+  },
 }
 ```
 
 Build the default sandbox image once with:
+
 ```bash
 scripts/sandbox-setup.sh
 ```
@@ -2266,6 +2384,7 @@ Note: inbound attachments are staged into the active workspace at `media/inbound
 Note: `docker.binds` mounts additional host directories; global and per-agent binds are merged.
 
 Build the optional browser image with:
+
 ```bash
 scripts/sandbox-browser-setup.sh
 ```
@@ -2282,21 +2401,23 @@ via the browser tool (`target: "host"`). Leave this off if you want strict
 sandbox isolation.
 
 Allowlists for remote control:
+
 - `allowedControlUrls`: exact control URLs permitted for `target: "custom"`.
 - `allowedControlHosts`: hostnames permitted (hostname only, no port).
 - `allowedControlPorts`: ports permitted (defaults: http=80, https=443).
-Defaults: all allowlists are unset (no restriction). `allowHostControl` defaults to false.
+  Defaults: all allowlists are unset (no restriction). `allowHostControl` defaults to false.
 
 ### `models` (custom providers + base URLs)
 
-Moltbot uses the **pi-coding-agent** model catalog. You can add custom providers
+OpenClaw uses the **pi-coding-agent** model catalog. You can add custom providers
 (LiteLLM, local OpenAI-compatible servers, Anthropic proxies, etc.) by writing
-`~/.clawdbot/agents/<agentId>/agent/models.json` or by defining the same schema inside your
-Moltbot config under `models.providers`.
+`~/.openclaw/agents/<agentId>/agent/models.json` or by defining the same schema inside your
+OpenClaw config under `models.providers`.
 Provider-by-provider overview + examples: [/concepts/model-providers](/concepts/model-providers).
 
-When `models.providers` is present, Moltbot writes/merges a `models.json` into
-`~/.clawdbot/agents/<agentId>/agent/` on startup:
+When `models.providers` is present, OpenClaw writes/merges a `models.json` into
+`~/.openclaw/agents/<agentId>/agent/` on startup:
+
 - default behavior: **merge** (keeps existing providers, overrides on name)
 - set `models.mode: "replace"` to overwrite the file contents
 
@@ -2308,9 +2429,9 @@ Select the model via `agents.defaults.model.primary` (provider/model).
     defaults: {
       model: { primary: "custom-proxy/llama-3.1-8b" },
       models: {
-        "custom-proxy/llama-3.1-8b": {}
-      }
-    }
+        "custom-proxy/llama-3.1-8b": {},
+      },
+    },
   },
   models: {
     mode: "merge",
@@ -2327,34 +2448,35 @@ Select the model via `agents.defaults.model.primary` (provider/model).
             input: ["text"],
             cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
             contextWindow: 128000,
-            maxTokens: 32000
-          }
-        ]
-      }
-    }
-  }
+            maxTokens: 32000,
+          },
+        ],
+      },
+    },
+  },
 }
 ```
 
 ### OpenCode Zen (multi-model proxy)
 
-OpenCode Zen is a multi-model gateway with per-model endpoints. Moltbot uses
+OpenCode Zen is a multi-model gateway with per-model endpoints. OpenClaw uses
 the built-in `opencode` provider from pi-ai; set `OPENCODE_API_KEY` (or
 `OPENCODE_ZEN_API_KEY`) from https://opencode.ai/auth.
 
 Notes:
+
 - Model refs use `opencode/<modelId>` (example: `opencode/claude-opus-4-5`).
 - If you enable an allowlist via `agents.defaults.models`, add each model you plan to use.
-- Shortcut: `moltbot onboard --auth-choice opencode-zen`.
+- Shortcut: `openclaw onboard --auth-choice opencode-zen`.
 
 ```json5
 {
   agents: {
     defaults: {
       model: { primary: "opencode/claude-opus-4-5" },
-      models: { "opencode/claude-opus-4-5": { alias: "Opus" } }
-    }
-  }
+      models: { "opencode/claude-opus-4-5": { alias: "Opus" } },
+    },
+  },
 }
 ```
 
@@ -2363,20 +2485,21 @@ Notes:
 Z.AI models are available via the built-in `zai` provider. Set `ZAI_API_KEY`
 in your environment and reference the model by provider/model.
 
-Shortcut: `moltbot onboard --auth-choice zai-api-key`.
+Shortcut: `openclaw onboard --auth-choice zai-api-key`.
 
 ```json5
 {
   agents: {
     defaults: {
       model: { primary: "zai/glm-4.7" },
-      models: { "zai/glm-4.7": {} }
-    }
-  }
+      models: { "zai/glm-4.7": {} },
+    },
+  },
 }
 ```
 
 Notes:
+
 - `z.ai/*` and `z-ai/*` are accepted aliases and normalize to `zai/*`.
 - If `ZAI_API_KEY` is missing, requests to `zai/*` will fail with an auth error at runtime.
 - Example error: `No API key found for provider "zai".`
@@ -2397,8 +2520,8 @@ Use Moonshot's OpenAI-compatible endpoint:
   agents: {
     defaults: {
       model: { primary: "moonshot/kimi-k2.5" },
-      models: { "moonshot/kimi-k2.5": { alias: "Kimi K2.5" } }
-    }
+      models: { "moonshot/kimi-k2.5": { alias: "Kimi K2.5" } },
+    },
   },
   models: {
     mode: "merge",
@@ -2415,62 +2538,41 @@ Use Moonshot's OpenAI-compatible endpoint:
             input: ["text"],
             cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
             contextWindow: 256000,
-            maxTokens: 8192
-          }
-        ]
-      }
-    }
-  }
+            maxTokens: 8192,
+          },
+        ],
+      },
+    },
+  },
 }
 ```
 
 Notes:
-- Set `MOONSHOT_API_KEY` in the environment or use `moltbot onboard --auth-choice moonshot-api-key`.
+
+- Set `MOONSHOT_API_KEY` in the environment or use `openclaw onboard --auth-choice moonshot-api-key`.
 - Model ref: `moonshot/kimi-k2.5`.
 - Use `https://api.moonshot.cn/v1` if you need the China endpoint.
 
-### Kimi Code
+### Kimi Coding
 
-Use Kimi Code's dedicated OpenAI-compatible endpoint (separate from Moonshot):
+Use Moonshot AI's Kimi Coding endpoint (Anthropic-compatible, built-in provider):
 
 ```json5
 {
-  env: { KIMICODE_API_KEY: "sk-..." },
+  env: { KIMI_API_KEY: "sk-..." },
   agents: {
     defaults: {
-      model: { primary: "kimi-code/kimi-for-coding" },
-      models: { "kimi-code/kimi-for-coding": { alias: "Kimi Code" } }
-    }
+      model: { primary: "kimi-coding/k2p5" },
+      models: { "kimi-coding/k2p5": { alias: "Kimi K2.5" } },
+    },
   },
-  models: {
-    mode: "merge",
-    providers: {
-      "kimi-code": {
-        baseUrl: "https://api.kimi.com/coding/v1",
-        apiKey: "${KIMICODE_API_KEY}",
-        api: "openai-completions",
-        models: [
-          {
-            id: "kimi-for-coding",
-            name: "Kimi For Coding",
-            reasoning: true,
-            input: ["text"],
-            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-            contextWindow: 262144,
-            maxTokens: 32768,
-            headers: { "User-Agent": "KimiCLI/0.77" },
-            compat: { supportsDeveloperRole: false }
-          }
-        ]
-      }
-    }
-  }
 }
 ```
 
 Notes:
-- Set `KIMICODE_API_KEY` in the environment or use `moltbot onboard --auth-choice kimi-code-api-key`.
-- Model ref: `kimi-code/kimi-for-coding`.
+
+- Set `KIMI_API_KEY` in the environment or use `openclaw onboard --auth-choice kimi-code-api-key`.
+- Model ref: `kimi-coding/k2p5`.
 
 ### Synthetic (Anthropic-compatible)
 
@@ -2482,8 +2584,8 @@ Use Synthetic's Anthropic-compatible endpoint:
   agents: {
     defaults: {
       model: { primary: "synthetic/hf:MiniMaxAI/MiniMax-M2.1" },
-      models: { "synthetic/hf:MiniMaxAI/MiniMax-M2.1": { alias: "MiniMax M2.1" } }
-    }
+      models: { "synthetic/hf:MiniMaxAI/MiniMax-M2.1": { alias: "MiniMax M2.1" } },
+    },
   },
   models: {
     mode: "merge",
@@ -2500,17 +2602,18 @@ Use Synthetic's Anthropic-compatible endpoint:
             input: ["text"],
             cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
             contextWindow: 192000,
-            maxTokens: 65536
-          }
-        ]
-      }
-    }
-  }
+            maxTokens: 65536,
+          },
+        ],
+      },
+    },
+  },
 }
 ```
 
 Notes:
-- Set `SYNTHETIC_API_KEY` or use `moltbot onboard --auth-choice synthetic-api-key`.
+
+- Set `SYNTHETIC_API_KEY` or use `openclaw onboard --auth-choice synthetic-api-key`.
 - Model ref: `synthetic/hf:MiniMaxAI/MiniMax-M2.1`.
 - Base URL should omit `/v1` because the Anthropic client appends it.
 
@@ -2528,8 +2631,8 @@ Use MiniMax M2.1 directly without LM Studio:
     model: { primary: "minimax/MiniMax-M2.1" },
     models: {
       "anthropic/claude-opus-4-5": { alias: "Opus" },
-      "minimax/MiniMax-M2.1": { alias: "Minimax" }
-    }
+      "minimax/MiniMax-M2.1": { alias: "Minimax" },
+    },
   },
   models: {
     mode: "merge",
@@ -2547,17 +2650,18 @@ Use MiniMax M2.1 directly without LM Studio:
             // Pricing: update in models.json if you need exact cost tracking.
             cost: { input: 15, output: 60, cacheRead: 2, cacheWrite: 10 },
             contextWindow: 200000,
-            maxTokens: 8192
-          }
-        ]
-      }
-    }
-  }
+            maxTokens: 8192,
+          },
+        ],
+      },
+    },
+  },
 }
 ```
 
 Notes:
-- Set `MINIMAX_API_KEY` environment variable or use `moltbot onboard --auth-choice minimax-api`.
+
+- Set `MINIMAX_API_KEY` environment variable or use `openclaw onboard --auth-choice minimax-api`.
 - Available model: `MiniMax-M2.1` (default).
 - Update pricing in `models.json` if you need exact cost tracking.
 
@@ -2572,13 +2676,13 @@ Use Cerebras via their OpenAI-compatible endpoint:
     defaults: {
       model: {
         primary: "cerebras/zai-glm-4.7",
-        fallbacks: ["cerebras/zai-glm-4.6"]
+        fallbacks: ["cerebras/zai-glm-4.6"],
       },
       models: {
         "cerebras/zai-glm-4.7": { alias: "GLM 4.7 (Cerebras)" },
-        "cerebras/zai-glm-4.6": { alias: "GLM 4.6 (Cerebras)" }
-      }
-    }
+        "cerebras/zai-glm-4.6": { alias: "GLM 4.6 (Cerebras)" },
+      },
+    },
   },
   models: {
     mode: "merge",
@@ -2589,24 +2693,26 @@ Use Cerebras via their OpenAI-compatible endpoint:
         api: "openai-completions",
         models: [
           { id: "zai-glm-4.7", name: "GLM 4.7 (Cerebras)" },
-          { id: "zai-glm-4.6", name: "GLM 4.6 (Cerebras)" }
-        ]
-      }
-    }
-  }
+          { id: "zai-glm-4.6", name: "GLM 4.6 (Cerebras)" },
+        ],
+      },
+    },
+  },
 }
 ```
 
 Notes:
+
 - Use `cerebras/zai-glm-4.7` for Cerebras; use `zai/glm-4.7` for Z.AI direct.
 - Set `CEREBRAS_API_KEY` in the environment or config.
 
 Notes:
+
 - Supported APIs: `openai-completions`, `openai-responses`, `anthropic-messages`,
   `google-generative-ai`
 - Use `authHeader: true` + `headers` for custom auth needs.
-- Override the agent config root with `CLAWDBOT_AGENT_DIR` (or `PI_CODING_AGENT_DIR`)
-  if you want `models.json` stored elsewhere (default: `~/.clawdbot/agents/main/agent`).
+- Override the agent config root with `OPENCLAW_AGENT_DIR` (or `PI_CODING_AGENT_DIR`)
+  if you want `models.json` stored elsewhere (default: `~/.openclaw/agents/main/agent`).
 
 ### `session`
 
@@ -2618,39 +2724,38 @@ Controls session scoping, reset policy, reset triggers, and where the session st
     scope: "per-sender",
     dmScope: "main",
     identityLinks: {
-      alice: ["telegram:123456789", "discord:987654321012345678"]
+      alice: ["telegram:123456789", "discord:987654321012345678"],
     },
     reset: {
       mode: "daily",
       atHour: 4,
-      idleMinutes: 60
+      idleMinutes: 60,
     },
     resetByType: {
       thread: { mode: "daily", atHour: 4 },
       dm: { mode: "idle", idleMinutes: 240 },
-      group: { mode: "idle", idleMinutes: 120 }
+      group: { mode: "idle", idleMinutes: 120 },
     },
     resetTriggers: ["/new", "/reset"],
-    // Default is already per-agent under ~/.clawdbot/agents/<agentId>/sessions/sessions.json
+    // Default is already per-agent under ~/.openclaw/agents/<agentId>/sessions/sessions.json
     // You can override with {agentId} templating:
-    store: "~/.clawdbot/agents/{agentId}/sessions/sessions.json",
+    store: "~/.openclaw/agents/{agentId}/sessions/sessions.json",
     // Direct chats collapse to agent:<agentId>:<mainKey> (default: "main").
     mainKey: "main",
     agentToAgent: {
       // Max ping-pong reply turns between requester/target (0–5).
-      maxPingPongTurns: 5
+      maxPingPongTurns: 5,
     },
     sendPolicy: {
-      rules: [
-        { action: "deny", match: { channel: "discord", chatType: "group" } }
-      ],
-      default: "allow"
-    }
-  }
+      rules: [{ action: "deny", match: { channel: "discord", chatType: "group" } }],
+      default: "allow",
+    },
+  },
 }
 ```
 
 Fields:
+
 - `mainKey`: direct-chat bucket key (default: `"main"`). Useful when you want to “rename” the primary DM thread without changing `agentId`.
   - Sandbox note: `agents.defaults.sandbox.mode: "non-main"` uses this key to detect the main session. Any session key that does not match `mainKey` (groups/channels) is sandboxed.
 - `dmScope`: how DM sessions are grouped (default: `"main"`).
@@ -2665,7 +2770,7 @@ Fields:
   - `atHour`: local hour (0-23) for the daily reset boundary.
   - `idleMinutes`: sliding idle window in minutes. When daily + idle are both configured, whichever expires first wins.
 - `resetByType`: per-session overrides for `dm`, `group`, and `thread`.
-  - If you only set legacy `session.idleMinutes` without any `reset`/`resetByType`, Moltbot stays in idle-only mode for backward compatibility.
+  - If you only set legacy `session.idleMinutes` without any `reset`/`resetByType`, OpenClaw stays in idle-only mode for backward compatibility.
 - `heartbeatIdleMinutes`: optional idle override for heartbeat checks (daily reset still applies when enabled).
 - `agentToAgent.maxPingPongTurns`: max reply-back turns between requester/target (0–5, default 5).
 - `sendPolicy.default`: `allow` or `deny` fallback when no rule matches.
@@ -2674,10 +2779,11 @@ Fields:
 ### `skills` (skills config)
 
 Controls bundled allowlist, install preferences, extra skill folders, and per-skill
-overrides. Applies to **bundled** skills and `~/.clawdbot/skills` (workspace skills
+overrides. Applies to **bundled** skills and `~/.openclaw/skills` (workspace skills
 still win on name conflicts).
 
 Fields:
+
 - `allowBundled`: optional allowlist for **bundled** skills only. If set, only those
   bundled skills are eligible (managed/workspace skills unaffected).
 - `load.extraDirs`: additional skill directories to scan (lowest precedence).
@@ -2686,6 +2792,7 @@ Fields:
 - `entries.<skillKey>`: per-skill config overrides.
 
 Per-skill fields:
+
 - `enabled`: set `false` to disable a skill even if it’s bundled/installed.
 - `env`: environment variables injected for the agent run (only if not already set).
 - `apiKey`: optional convenience for skills that declare a primary env var (e.g. `nano-banana-pro` → `GEMINI_API_KEY`).
@@ -2697,37 +2804,35 @@ Example:
   skills: {
     allowBundled: ["gemini", "peekaboo"],
     load: {
-      extraDirs: [
-        "~/Projects/agent-scripts/skills",
-        "~/Projects/oss/some-skill-pack/skills"
-      ]
+      extraDirs: ["~/Projects/agent-scripts/skills", "~/Projects/oss/some-skill-pack/skills"],
     },
     install: {
       preferBrew: true,
-      nodeManager: "npm"
+      nodeManager: "npm",
     },
     entries: {
       "nano-banana-pro": {
         apiKey: "GEMINI_KEY_HERE",
         env: {
-          GEMINI_API_KEY: "GEMINI_KEY_HERE"
-        }
+          GEMINI_API_KEY: "GEMINI_KEY_HERE",
+        },
       },
       peekaboo: { enabled: true },
-      sag: { enabled: false }
-    }
-  }
+      sag: { enabled: false },
+    },
+  },
 }
 ```
 
 ### `plugins` (extensions)
 
 Controls plugin discovery, allow/deny, and per-plugin config. Plugins are loaded
-from `~/.clawdbot/extensions`, `<workspace>/.clawdbot/extensions`, plus any
+from `~/.openclaw/extensions`, `<workspace>/.openclaw/extensions`, plus any
 `plugins.load.paths` entries. **Config changes require a gateway restart.**
 See [/plugin](/plugin) for full usage.
 
 Fields:
+
 - `enabled`: master toggle for plugin loading (default: true).
 - `allow`: optional allowlist of plugin ids; when set, only listed plugins load.
 - `deny`: optional denylist of plugin ids (deny wins).
@@ -2744,23 +2849,23 @@ Example:
     enabled: true,
     allow: ["voice-call"],
     load: {
-      paths: ["~/Projects/oss/voice-call-extension"]
+      paths: ["~/Projects/oss/voice-call-extension"],
     },
     entries: {
       "voice-call": {
         enabled: true,
         config: {
-          provider: "twilio"
-        }
-      }
-    }
-  }
+          provider: "twilio",
+        },
+      },
+    },
+  },
 }
 ```
 
-### `browser` (clawd-managed browser)
+### `browser` (openclaw-managed browser)
 
-Moltbot can start a **dedicated, isolated** Chrome/Brave/Edge/Chromium instance for clawd and expose a small loopback control service.
+OpenClaw can start a **dedicated, isolated** Chrome/Brave/Edge/Chromium instance for openclaw and expose a small loopback control service.
 Profiles can point at a **remote** Chromium-based browser via `profiles.<name>.cdpUrl`. Remote
 profiles are attach-only (start/stop/reset are disabled).
 
@@ -2768,12 +2873,13 @@ profiles are attach-only (start/stop/reset are disabled).
 scheme/host for profiles that only set `cdpPort`.
 
 Defaults:
+
 - enabled: `true`
 - evaluateEnabled: `true` (set `false` to disable `act:evaluate` and `wait --fn`)
 - control service: loopback only (port derived from `gateway.port`, default `18791`)
 - CDP URL: `http://127.0.0.1:18792` (control service + 1, legacy single-profile)
 - profile color: `#FF4500` (lobster-orange)
-- Note: the control server is started by the running gateway (Moltbot.app menubar, or `moltbot gateway`).
+- Note: the control server is started by the running gateway (OpenClaw.app menubar, or `openclaw gateway`).
 - Auto-detect order: default browser if Chromium-based; otherwise Chrome → Brave → Edge → Chromium → Chrome Canary.
 
 ```json5
@@ -2784,9 +2890,9 @@ Defaults:
     // cdpUrl: "http://127.0.0.1:18792", // legacy single-profile override
     defaultProfile: "chrome",
     profiles: {
-      clawd: { cdpPort: 18800, color: "#FF4500" },
+      openclaw: { cdpPort: 18800, color: "#FF4500" },
       work: { cdpPort: 18801, color: "#0066CC" },
-      remote: { cdpUrl: "http://10.0.0.42:9222", color: "#00AA00" }
+      remote: { cdpUrl: "http://10.0.0.42:9222", color: "#00AA00" },
     },
     color: "#FF4500",
     // Advanced:
@@ -2794,7 +2900,7 @@ Defaults:
     // noSandbox: false,
     // executablePath: "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser",
     // attachOnly: false, // set true when tunneling a remote CDP to localhost
-  }
+  },
 }
 ```
 
@@ -2811,10 +2917,10 @@ If unset, clients fall back to a muted light-blue.
     // Optional: Control UI assistant identity override.
     // If unset, the Control UI uses the active agent identity (config or IDENTITY.md).
     assistant: {
-      name: "Moltbot",
-      avatar: "CB" // emoji, short text, or image URL/data URI
-    }
-  }
+      name: "OpenClaw",
+      avatar: "CB", // emoji, short text, or image URL/data URI
+    },
+  },
 }
 ```
 
@@ -2823,6 +2929,7 @@ If unset, clients fall back to a muted light-blue.
 Use `gateway.mode` to explicitly declare whether this machine should run the Gateway.
 
 Defaults:
+
 - mode: **unset** (treated as “do not auto-start”)
 - bind: `loopback`
 - port: `18789` (single port for WS + HTTP)
@@ -2833,16 +2940,17 @@ Defaults:
     mode: "local", // or "remote"
     port: 18789, // WS + HTTP multiplex
     bind: "loopback",
-    // controlUi: { enabled: true, basePath: "/moltbot" }
+    // controlUi: { enabled: true, basePath: "/openclaw" }
     // auth: { mode: "token", token: "your-token" } // token gates WS + Control UI access
     // tailscale: { mode: "off" | "serve" | "funnel" }
-  }
+  },
 }
 ```
 
 Control UI base path:
+
 - `gateway.controlUi.basePath` sets the URL prefix where the Control UI is served.
-- Examples: `"/ui"`, `"/moltbot"`, `"/apps/moltbot"`.
+- Examples: `"/ui"`, `"/openclaw"`, `"/apps/openclaw"`.
 - Default: root (`/`) (unchanged).
 - `gateway.controlUi.allowInsecureAuth` allows token-only auth for the Control UI when
   device identity is omitted (typically over HTTP). Default: `false`. Prefer HTTPS
@@ -2851,33 +2959,37 @@ Control UI base path:
   Control UI (token/password only). Default: `false`. Break-glass only.
 
 Related docs:
+
 - [Control UI](/web/control-ui)
 - [Web overview](/web)
 - [Tailscale](/gateway/tailscale)
 - [Remote access](/gateway/remote)
 
 Trusted proxies:
+
 - `gateway.trustedProxies`: list of reverse proxy IPs that terminate TLS in front of the Gateway.
-- When a connection comes from one of these IPs, Moltbot uses `x-forwarded-for` (or `x-real-ip`) to determine the client IP for local pairing checks and HTTP auth/local checks.
+- When a connection comes from one of these IPs, OpenClaw uses `x-forwarded-for` (or `x-real-ip`) to determine the client IP for local pairing checks and HTTP auth/local checks.
 - Only list proxies you fully control, and ensure they **overwrite** incoming `x-forwarded-for`.
 
 Notes:
-- `moltbot gateway` refuses to start unless `gateway.mode` is set to `local` (or you pass the override flag).
+
+- `openclaw gateway` refuses to start unless `gateway.mode` is set to `local` (or you pass the override flag).
 - `gateway.port` controls the single multiplexed port used for WebSocket + HTTP (control UI, hooks, A2UI).
 - OpenAI Chat Completions endpoint: **disabled by default**; enable with `gateway.http.endpoints.chatCompletions.enabled: true`.
-- Precedence: `--port` > `CLAWDBOT_GATEWAY_PORT` > `gateway.port` > default `18789`.
+- Precedence: `--port` > `OPENCLAW_GATEWAY_PORT` > `gateway.port` > default `18789`.
 - Gateway auth is required by default (token/password or Tailscale Serve identity). Non-loopback binds require a shared token/password.
 - The onboarding wizard generates a gateway token by default (even on loopback).
 - `gateway.remote.token` is **only** for remote CLI calls; it does not enable local gateway auth. `gateway.token` is ignored.
 
 Auth and Tailscale:
+
 - `gateway.auth.mode` sets the handshake requirements (`token` or `password`). When unset, token auth is assumed.
 - `gateway.auth.token` stores the shared token for token auth (used by the CLI on the same machine).
 - When `gateway.auth.mode` is set, only that method is accepted (plus optional Tailscale headers).
-- `gateway.auth.password` can be set here, or via `CLAWDBOT_GATEWAY_PASSWORD` (recommended).
+- `gateway.auth.password` can be set here, or via `OPENCLAW_GATEWAY_PASSWORD` (recommended).
 - `gateway.auth.allowTailscale` allows Tailscale Serve identity headers
   (`tailscale-user-login`) to satisfy auth when the request arrives on loopback
-  with `x-forwarded-for`, `x-forwarded-proto`, and `x-forwarded-host`. Moltbot
+  with `x-forwarded-for`, `x-forwarded-proto`, and `x-forwarded-host`. OpenClaw
   verifies the identity by resolving the `x-forwarded-for` address via
   `tailscale whois` before accepting it. When `true`, Serve requests do not need
   a token/password; set `false` to require explicit credentials. Defaults to
@@ -2887,13 +2999,15 @@ Auth and Tailscale:
 - `gateway.tailscale.resetOnExit` resets Serve/Funnel config on shutdown.
 
 Remote client defaults (CLI):
+
 - `gateway.remote.url` sets the default Gateway WebSocket URL for CLI calls when `gateway.mode = "remote"`.
 - `gateway.remote.transport` selects the macOS remote transport (`ssh` default, `direct` for ws/wss). When `direct`, `gateway.remote.url` must be `ws://` or `wss://`. `ws://host` defaults to port `18789`.
 - `gateway.remote.token` supplies the token for remote calls (leave unset for no auth).
 - `gateway.remote.password` supplies the password for remote calls (leave unset for no auth).
 
 macOS app behavior:
-- Moltbot.app watches `~/.clawdbot/moltbot.json` and switches modes live when `gateway.mode` or `gateway.remote.url` changes.
+
+- OpenClaw.app watches `~/.openclaw/openclaw.json` and switches modes live when `gateway.mode` or `gateway.remote.url` changes.
 - If `gateway.mode` is unset but `gateway.remote.url` is set, the macOS app treats it as remote mode.
 - When you change connection mode in the macOS app, it writes `gateway.mode` (and `gateway.remote.url` + `gateway.remote.transport` in remote mode) back to the config file.
 
@@ -2904,9 +3018,9 @@ macOS app behavior:
     remote: {
       url: "ws://gateway.tailnet:18789",
       token: "your-token",
-      password: "your-password"
-    }
-  }
+      password: "your-password",
+    },
+  },
 }
 ```
 
@@ -2919,17 +3033,18 @@ Direct transport example (macOS app):
     remote: {
       transport: "direct",
       url: "wss://gateway.example.ts.net",
-      token: "your-token"
-    }
-  }
+      token: "your-token",
+    },
+  },
 }
 ```
 
 ### `gateway.reload` (Config hot reload)
 
-The Gateway watches `~/.clawdbot/moltbot.json` (or `CLAWDBOT_CONFIG_PATH`) and applies changes automatically.
+The Gateway watches `~/.openclaw/openclaw.json` (or `OPENCLAW_CONFIG_PATH`) and applies changes automatically.
 
 Modes:
+
 - `hybrid` (default): hot-apply safe changes; restart the Gateway for critical changes.
 - `hot`: only apply hot-safe changes; log when a restart is required.
 - `restart`: restart the Gateway on any config change.
@@ -2940,18 +3055,20 @@ Modes:
   gateway: {
     reload: {
       mode: "hybrid",
-      debounceMs: 300
-    }
-  }
+      debounceMs: 300,
+    },
+  },
 }
 ```
 
 #### Hot reload matrix (files + impact)
 
 Files watched:
-- `~/.clawdbot/moltbot.json` (or `CLAWDBOT_CONFIG_PATH`)
+
+- `~/.openclaw/openclaw.json` (or `OPENCLAW_CONFIG_PATH`)
 
 Hot-applied (no full gateway restart):
+
 - `hooks` (webhook auth/path/mappings) + `hooks.gmail` (Gmail watcher restarted)
 - `browser` (browser control server restart)
 - `cron` (cron service restart + concurrency update)
@@ -2961,6 +3078,7 @@ Hot-applied (no full gateway restart):
 - `agent`, `models`, `routing`, `messages`, `session`, `whatsapp`, `logging`, `skills`, `ui`, `talk`, `identity`, `wizard` (dynamic reads)
 
 Requires full Gateway restart:
+
 - `gateway` (port/bind/auth/control UI/tailscale)
 - `bridge` (legacy)
 - `discovery`
@@ -2971,23 +3089,26 @@ Requires full Gateway restart:
 ### Multi-instance isolation
 
 To run multiple gateways on one host (for redundancy or a rescue bot), isolate per-instance state + config and use unique ports:
-- `CLAWDBOT_CONFIG_PATH` (per-instance config)
-- `CLAWDBOT_STATE_DIR` (sessions/creds)
+
+- `OPENCLAW_CONFIG_PATH` (per-instance config)
+- `OPENCLAW_STATE_DIR` (sessions/creds)
 - `agents.defaults.workspace` (memories)
 - `gateway.port` (unique per instance)
 
 Convenience flags (CLI):
-- `moltbot --dev …` → uses `~/.clawdbot-dev` + shifts ports from base `19001`
-- `moltbot --profile <name> …` → uses `~/.clawdbot-<name>` (port via config/env/flags)
+
+- `openclaw --dev …` → uses `~/.openclaw-dev` + shifts ports from base `19001`
+- `openclaw --profile <name> …` → uses `~/.openclaw-<name>` (port via config/env/flags)
 
 See [Gateway runbook](/gateway) for the derived port mapping (gateway/browser/canvas).
 See [Multiple gateways](/gateway/multiple-gateways) for browser/CDP port isolation details.
 
 Example:
+
 ```bash
-CLAWDBOT_CONFIG_PATH=~/.clawdbot/a.json \
-CLAWDBOT_STATE_DIR=~/.clawdbot-a \
-moltbot gateway --port 19001
+OPENCLAW_CONFIG_PATH=~/.openclaw/a.json \
+OPENCLAW_STATE_DIR=~/.openclaw-a \
+openclaw gateway --port 19001
 ```
 
 ### `hooks` (Gateway webhooks)
@@ -2995,6 +3116,7 @@ moltbot gateway --port 19001
 Enable a simple HTTP webhook endpoint on the Gateway HTTP server.
 
 Defaults:
+
 - enabled: `false`
 - path: `/hooks`
 - maxBodyBytes: `262144` (256 KB)
@@ -3006,7 +3128,7 @@ Defaults:
     token: "shared-secret",
     path: "/hooks",
     presets: ["gmail"],
-    transformsDir: "~/.clawdbot/hooks",
+    transformsDir: "~/.openclaw/hooks",
     mappings: [
       {
         match: { path: "gmail" },
@@ -3014,23 +3136,24 @@ Defaults:
         wakeMode: "now",
         name: "Gmail",
         sessionKey: "hook:gmail:{{messages[0].id}}",
-        messageTemplate:
-          "From: {{messages[0].from}}\nSubject: {{messages[0].subject}}\n{{messages[0].snippet}}",
+        messageTemplate: "From: {{messages[0].from}}\nSubject: {{messages[0].subject}}\n{{messages[0].snippet}}",
         deliver: true,
         channel: "last",
         model: "openai/gpt-5.2-mini",
       },
     ],
-  }
+  },
 }
 ```
 
 Requests must include the hook token:
+
 - `Authorization: Bearer <token>` **or**
-- `x-moltbot-token: <token>` **or**
+- `x-openclaw-token: <token>` **or**
 - `?token=<token>`
 
 Endpoints:
+
 - `POST /hooks/wake` → `{ text, mode?: "now"|"next-heartbeat" }`
 - `POST /hooks/agent` → `{ message, name?, sessionKey?, wakeMode?, deliver?, channel?, to?, model?, thinking?, timeoutSeconds? }`
 - `POST /hooks/<name>` → resolved via `hooks.mappings`
@@ -3038,6 +3161,7 @@ Endpoints:
 `/hooks/agent` always posts a summary into the main session (and can optionally trigger an immediate heartbeat via `wakeMode: "now"`).
 
 Mapping notes:
+
 - `match.path` matches the sub-path after `/hooks` (e.g. `/hooks/gmail` → `gmail`).
 - `match.source` matches a payload field (e.g. `{ source: "gmail" }`) so you can use a generic `/hooks/ingest` path.
 - Templates like `{{messages[0].subject}}` read from the payload.
@@ -3046,13 +3170,13 @@ Mapping notes:
 - If there is no prior delivery route, set `channel` + `to` explicitly (required for Telegram/Discord/Google Chat/Slack/Signal/iMessage/MS Teams).
 - `model` overrides the LLM for this hook run (`provider/model` or alias; must be allowed if `agents.defaults.models` is set).
 
-Gmail helper config (used by `moltbot webhooks gmail setup` / `run`):
+Gmail helper config (used by `openclaw webhooks gmail setup` / `run`):
 
 ```json5
 {
   hooks: {
     gmail: {
-      account: "moltbot@gmail.com",
+      account: "openclaw@gmail.com",
       topic: "projects/<project-id>/topics/gog-gmail-watch",
       subscription: "gog-gmail-watch-push",
       pushToken: "shared-push-token",
@@ -3068,12 +3192,13 @@ Gmail helper config (used by `moltbot webhooks gmail setup` / `run`):
       model: "openrouter/meta-llama/llama-3.3-70b-instruct:free",
       // Optional: default thinking level for Gmail hooks
       thinking: "off",
-    }
-  }
+    },
+  },
 }
 ```
 
 Model override for Gmail hooks:
+
 - `hooks.gmail.model` specifies a model to use for Gmail hook processing (defaults to session primary).
 - Accepts `provider/model` refs or aliases from `agents.defaults.models`.
 - Falls back to `agents.defaults.model.fallbacks`, then `agents.defaults.model.primary`, on auth/rate-limit/timeouts.
@@ -3082,13 +3207,14 @@ Model override for Gmail hooks:
 - `hooks.gmail.thinking` sets the default thinking level for Gmail hooks and is overridden by per-hook `thinking`.
 
 Gateway auto-start:
+
 - If `hooks.enabled=true` and `hooks.gmail.account` is set, the Gateway starts
   `gog gmail watch serve` on boot and auto-renews the watch.
-- Set `CLAWDBOT_SKIP_GMAIL_WATCHER=1` to disable the auto-start (for manual runs).
+- Set `OPENCLAW_SKIP_GMAIL_WATCHER=1` to disable the auto-start (for manual runs).
 - Avoid running a separate `gog gmail watch serve` alongside the Gateway; it will
   fail with `listen tcp 127.0.0.1:8788: bind: address already in use`.
 
-Note: when `tailscale.mode` is on, Moltbot defaults `serve.path` to `/` so
+Note: when `tailscale.mode` is on, OpenClaw defaults `serve.path` to `/` so
 Tailscale can proxy `/gmail-pubsub` correctly (it strips the set-path prefix).
 If you need the backend to receive the prefixed path, set
 `hooks.gmail.tailscale.target` to a full URL (and align `serve.path`).
@@ -3097,36 +3223,39 @@ If you need the backend to receive the prefixed path, set
 
 The Gateway serves a directory of HTML/CSS/JS over HTTP so iOS/Android nodes can simply `canvas.navigate` to it.
 
-Default root: `~/clawd/canvas`  
-Default port: `18793` (chosen to avoid the clawd browser CDP port `18792`)  
+Default root: `~/.openclaw/workspace/canvas`  
+Default port: `18793` (chosen to avoid the openclaw browser CDP port `18792`)  
 The server listens on the **gateway bind host** (LAN or Tailnet) so nodes can reach it.
 
 The server:
+
 - serves files under `canvasHost.root`
 - injects a tiny live-reload client into served HTML
-- watches the directory and broadcasts reloads over a WebSocket endpoint at `/__moltbot/ws`
+- watches the directory and broadcasts reloads over a WebSocket endpoint at `/__openclaw__/ws`
 - auto-creates a starter `index.html` when the directory is empty (so you see something immediately)
-- also serves A2UI at `/__moltbot__/a2ui/` and is advertised to nodes as `canvasHostUrl`
+- also serves A2UI at `/__openclaw__/a2ui/` and is advertised to nodes as `canvasHostUrl`
   (always used by nodes for Canvas/A2UI)
 
 Disable live reload (and file watching) if the directory is large or you hit `EMFILE`:
+
 - config: `canvasHost: { liveReload: false }`
 
 ```json5
 {
   canvasHost: {
-    root: "~/clawd/canvas",
+    root: "~/.openclaw/workspace/canvas",
     port: 18793,
-    liveReload: true
-  }
+    liveReload: true,
+  },
 }
 ```
 
 Changes to `canvasHost.*` require a gateway restart (config reload will restart).
 
 Disable with:
+
 - config: `canvasHost: { enabled: false }`
-- env: `CLAWDBOT_SKIP_CANVAS_HOST=1`
+- env: `OPENCLAW_SKIP_CANVAS_HOST=1`
 
 ### `bridge` (legacy TCP bridge, removed)
 
@@ -3134,20 +3263,24 @@ Current builds no longer include the TCP bridge listener; `bridge.*` config keys
 Nodes connect over the Gateway WebSocket. This section is kept for historical reference.
 
 Legacy behavior:
+
 - The Gateway could expose a simple TCP bridge for nodes (iOS/Android), typically on port `18790`.
 
 Defaults:
+
 - enabled: `true`
 - port: `18790`
 - bind: `lan` (binds to `0.0.0.0`)
 
 Bind modes:
+
 - `lan`: `0.0.0.0` (reachable on any interface, including LAN/Wi‑Fi and Tailscale)
 - `tailnet`: bind only to the machine’s Tailscale IP (recommended for Vienna ⇄ London)
 - `loopback`: `127.0.0.1` (local only)
 - `auto`: prefer tailnet IP if present, else `lan`
 
 TLS:
+
 - `bridge.tls.enabled`: enable TLS for bridge connections (TLS-only when enabled).
 - `bridge.tls.autoGenerate`: generate a self-signed cert when no cert/key are present (default: true).
 - `bridge.tls.certPath` / `bridge.tls.keyPath`: PEM paths for the bridge certificate + private key.
@@ -3166,45 +3299,47 @@ Auto-generated certs require `openssl` on PATH; if generation fails, the bridge
     bind: "tailnet",
     tls: {
       enabled: true,
-      // Uses ~/.clawdbot/bridge/tls/bridge-{cert,key}.pem when omitted.
-      // certPath: "~/.clawdbot/bridge/tls/bridge-cert.pem",
-      // keyPath: "~/.clawdbot/bridge/tls/bridge-key.pem"
-    }
-  }
+      // Uses ~/.openclaw/bridge/tls/bridge-{cert,key}.pem when omitted.
+      // certPath: "~/.openclaw/bridge/tls/bridge-cert.pem",
+      // keyPath: "~/.openclaw/bridge/tls/bridge-key.pem"
+    },
+  },
 }
 ```
 
 ### `discovery.mdns` (Bonjour / mDNS broadcast mode)
 
-Controls LAN mDNS discovery broadcasts (`_moltbot-gw._tcp`).
+Controls LAN mDNS discovery broadcasts (`_openclaw-gw._tcp`).
 
 - `minimal` (default): omit `cliPath` + `sshPort` from TXT records
 - `full`: include `cliPath` + `sshPort` in TXT records
 - `off`: disable mDNS broadcasts entirely
+- Hostname: defaults to `openclaw` (advertises `openclaw.local`). Override with `OPENCLAW_MDNS_HOSTNAME`.
 
 ```json5
 {
-  discovery: { mdns: { mode: "minimal" } }
+  discovery: { mdns: { mode: "minimal" } },
 }
 ```
 
 ### `discovery.wideArea` (Wide-Area Bonjour / unicast DNS‑SD)
 
-When enabled, the Gateway writes a unicast DNS-SD zone for `_moltbot-bridge._tcp` under `~/.clawdbot/dns/` using the standard discovery domain `moltbot.internal.`
+When enabled, the Gateway writes a unicast DNS-SD zone for `_openclaw-gw._tcp` under `~/.openclaw/dns/` using the configured discovery domain (example: `openclaw.internal.`).
 
 To make iOS/Android discover across networks (Vienna ⇄ London), pair this with:
-- a DNS server on the gateway host serving `moltbot.internal.` (CoreDNS is recommended)
-- Tailscale **split DNS** so clients resolve `moltbot.internal` via that server
+
+- a DNS server on the gateway host serving your chosen domain (CoreDNS is recommended)
+- Tailscale **split DNS** so clients resolve that domain via the gateway DNS server
 
 One-time setup helper (gateway host):
 
 ```bash
-moltbot dns setup --apply
+openclaw dns setup --apply
 ```
 
 ```json5
 {
-  discovery: { wideArea: { enabled: true } }
+  discovery: { wideArea: { enabled: true } },
 }
 ```
 
@@ -3212,28 +3347,28 @@ moltbot dns setup --apply
 
 Template placeholders are expanded in `tools.media.*.models[].args` and `tools.media.models[].args` (and any future templated argument fields).
 
-| Variable | Description |
-|----------|-------------|
-| `{{Body}}` | Full inbound message body |
-| `{{RawBody}}` | Raw inbound message body (no history/sender wrappers; best for command parsing) |
-| `{{BodyStripped}}` | Body with group mentions stripped (best default for agents) |
-| `{{From}}` | Sender identifier (E.164 for WhatsApp; may differ per channel) |
-| `{{To}}` | Destination identifier |
-| `{{MessageSid}}` | Channel message id (when available) |
-| `{{SessionId}}` | Current session UUID |
-| `{{IsNewSession}}` | `"true"` when a new session was created |
-| `{{MediaUrl}}` | Inbound media pseudo-URL (if present) |
-| `{{MediaPath}}` | Local media path (if downloaded) |
-| `{{MediaType}}` | Media type (image/audio/document/…) |
-| `{{Transcript}}` | Audio transcript (when enabled) |
-| `{{Prompt}}` | Resolved media prompt for CLI entries |
-| `{{MaxChars}}` | Resolved max output chars for CLI entries |
-| `{{ChatType}}` | `"direct"` or `"group"` |
-| `{{GroupSubject}}` | Group subject (best effort) |
-| `{{GroupMembers}}` | Group members preview (best effort) |
-| `{{SenderName}}` | Sender display name (best effort) |
-| `{{SenderE164}}` | Sender phone number (best effort) |
-| `{{Provider}}` | Provider hint (whatsapp|telegram|discord|googlechat|slack|signal|imessage|msteams|webchat|…) |
+| Variable           | Description                                                                     |
+| ------------------ | ------------------------------------------------------------------------------- | -------- | ------- | ---------- | ----- | ------ | -------- | ------- | ------- | --- |
+| `{{Body}}`         | Full inbound message body                                                       |
+| `{{RawBody}}`      | Raw inbound message body (no history/sender wrappers; best for command parsing) |
+| `{{BodyStripped}}` | Body with group mentions stripped (best default for agents)                     |
+| `{{From}}`         | Sender identifier (E.164 for WhatsApp; may differ per channel)                  |
+| `{{To}}`           | Destination identifier                                                          |
+| `{{MessageSid}}`   | Channel message id (when available)                                             |
+| `{{SessionId}}`    | Current session UUID                                                            |
+| `{{IsNewSession}}` | `"true"` when a new session was created                                         |
+| `{{MediaUrl}}`     | Inbound media pseudo-URL (if present)                                           |
+| `{{MediaPath}}`    | Local media path (if downloaded)                                                |
+| `{{MediaType}}`    | Media type (image/audio/document/…)                                             |
+| `{{Transcript}}`   | Audio transcript (when enabled)                                                 |
+| `{{Prompt}}`       | Resolved media prompt for CLI entries                                           |
+| `{{MaxChars}}`     | Resolved max output chars for CLI entries                                       |
+| `{{ChatType}}`     | `"direct"` or `"group"`                                                         |
+| `{{GroupSubject}}` | Group subject (best effort)                                                     |
+| `{{GroupMembers}}` | Group members preview (best effort)                                             |
+| `{{SenderName}}`   | Sender display name (best effort)                                               |
+| `{{SenderE164}}`   | Sender phone number (best effort)                                               |
+| `{{Provider}}`     | Provider hint (whatsapp                                                         | telegram | discord | googlechat | slack | signal | imessage | msteams | webchat | …)  |
 
 ## Cron (Gateway scheduler)
 
@@ -3243,11 +3378,11 @@ Cron is a Gateway-owned scheduler for wakeups and scheduled jobs. See [Cron jobs
 {
   cron: {
     enabled: true,
-    maxConcurrentRuns: 2
-  }
+    maxConcurrentRuns: 2,
+  },
 }
 ```
 
 ---
 
-*Next: [Agent Runtime](/concepts/agent)* 🦞
+_Next: [Agent Runtime](/concepts/agent)_ 🦞