@gguf/pigbot 0.0.6 → 0.0.7

package/docs/channels/discord.md

@@ -11,7 +11,7 @@ Status: ready for DM and guild text channels via the official Discord bot gatewa
 ## Quick setup (beginner)
 1) Create a Discord bot and copy the bot token.
 2) In the Discord app settings, enable **Message Content Intent** (and **Server Members Intent** if you plan to use allowlists or name lookups).
-3) Set the token for Moltbot:
+3) Set the token for OpenClaw:
    - Env: `DISCORD_BOT_TOKEN=...`
    - Or config: `channels.discord.token: "..."`.
    - If both are set, config takes precedence (env fallback is default-account only).
@@ -32,7 +32,7 @@ Minimal config:
 ```
 
 ## Goals
-- Talk to Moltbot via Discord DMs or guild channels.
+- Talk to OpenClaw via Discord DMs or guild channels.
 - Direct chats collapse into the agent's main session (default `agent:main:main`); guild channels stay isolated as `agent:<agentId>:discord:channel:<channelId>` (display names use `discord:<guildSlug>#<channelSlug>`).
 - Group DMs are ignored by default; enable via `channels.discord.dm.groupEnabled` and optionally restrict by `channels.discord.dm.groupChannels`.
 - Keep routing deterministic: replies always go back to the channel they arrived on.
@@ -40,12 +40,12 @@ Minimal config:
 ## How it works
 1. Create a Discord application → Bot, enable the intents you need (DMs + guild messages + message content), and grab the bot token.
 2. Invite the bot to your server with the permissions required to read/send messages where you want to use it.
-3. Configure Moltbot with `channels.discord.token` (or `DISCORD_BOT_TOKEN` as a fallback).
+3. Configure OpenClaw with `channels.discord.token` (or `DISCORD_BOT_TOKEN` as a fallback).
 4. Run the gateway; it auto-starts the Discord channel when a token is available (config first, env fallback) and `channels.discord.enabled` is not `false`.
    - If you prefer env vars, set `DISCORD_BOT_TOKEN` (a config block is optional).
 5. Direct chats: use `user:<id>` (or a `<@id>` mention) when delivering; all turns land in the shared `main` session. Bare numeric IDs are ambiguous and rejected.
 6. Guild channels: use `channel:<channelId>` for delivery. Mentions are required by default and can be set per guild or per channel.
-7. Direct chats: secure by default via `channels.discord.dm.policy` (default: `"pairing"`). Unknown senders get a pairing code (expires after 1 hour); approve via `moltbot pairing approve discord <code>`.
+7. Direct chats: secure by default via `channels.discord.dm.policy` (default: `"pairing"`). Unknown senders get a pairing code (expires after 1 hour); approve via `openclaw pairing approve discord <code>`.
    - To keep old “open to anyone” behavior: set `channels.discord.dm.policy="open"` and `channels.discord.dm.allowFrom=["*"]`.
    - To hard-allowlist: set `channels.discord.dm.policy="allowlist"` and list senders in `channels.discord.dm.allowFrom`.
    - To ignore all DMs: set `channels.discord.dm.enabled=false` or `channels.discord.dm.policy="disabled"`.
@@ -75,7 +75,7 @@ Disable with:
 
 ## How to create your own bot
 
-This is the “Discord Developer Portal” setup for running Moltbot in a server (guild) channel like `#help`.
+This is the “Discord Developer Portal” setup for running OpenClaw in a server (guild) channel like `#help`.
 
 ### 1) Create the Discord app + bot user
 1. Discord Developer Portal → **Applications** → **New Application**
@@ -83,7 +83,7 @@ This is the “Discord Developer Portal” setup for running Moltbot in a server
    - **Bot** → **Add Bot**
    - Copy the **Bot Token** (this is what you put in `DISCORD_BOT_TOKEN`)
 
-### 2) Enable the gateway intents Moltbot needs
+### 2) Enable the gateway intents OpenClaw needs
 Discord blocks “privileged intents” unless you explicitly enable them.
 
 In **Bot** → **Privileged Gateway Intents**, enable:
@@ -113,7 +113,7 @@ Avoid **Administrator** unless you’re debugging and fully trust the bot.
 Copy the generated URL, open it, pick your server, and install the bot.
 
 ### 4) Get the ids (guild/user/channel)
-Discord uses numeric ids everywhere; Moltbot config prefers ids.
+Discord uses numeric ids everywhere; OpenClaw config prefers ids.
 
 1. Discord (desktop/web) → **User Settings** → **Advanced** → enable **Developer Mode**
 2. Right-click:
@@ -121,7 +121,7 @@ Discord uses numeric ids everywhere; Moltbot config prefers ids.
    - Channel (e.g. `#help`) → **Copy Channel ID**
    - Your user → **Copy User ID**
 
-### 5) Configure Moltbot
+### 5) Configure OpenClaw
 
 #### Token
 Set the bot token via env var (recommended on servers):
@@ -187,7 +187,7 @@ Notes:
 3. If nothing happens: check **Troubleshooting** below.
 
 ### Troubleshooting
-- First: run `moltbot doctor` and `moltbot channels status --probe` (actionable warnings + quick audits).
+- First: run `openclaw doctor` and `openclaw channels status --probe` (actionable warnings + quick audits).
 - **“Used disallowed intents”**: enable **Message Content Intent** (and likely **Server Members Intent**) in the Developer Portal, then restart the gateway.
 - **Bot connects but never replies in a guild channel**:
   - Missing **Message Content Intent**, or
@@ -258,12 +258,12 @@ Outbound Discord API calls retry on rate limits (429) using Discord `retry_after
         policy: "pairing", // pairing | allowlist | open | disabled
         allowFrom: ["123456789012345678", "steipete"],
         groupEnabled: false,
-        groupChannels: ["clawd-dm"]
+        groupChannels: ["openclaw-dm"]
       },
       guilds: {
         "*": { requireMention: true },
         "123456789012345678": {
-          slug: "friends-of-clawd",
+          slug: "friends-of-openclaw",
           requireMention: false,
           reactionNotifications: "own",
           users: ["987654321098765432", "steipete"],
@@ -375,13 +375,13 @@ Allowlist matching notes:
 - When `guilds.<id>.channels` is omitted, all channels in the allowlisted guild are allowed.
 - To allow **no channels**, set `channels.discord.groupPolicy: "disabled"` (or keep an empty allowlist).
 - The configure wizard accepts `Guild/Channel` names (public + private) and resolves them to IDs when possible.
-- On startup, Moltbot resolves channel/user names in allowlists to IDs (when the bot can search members)
+- On startup, OpenClaw resolves channel/user names in allowlists to IDs (when the bot can search members)
   and logs the mapping; unresolved entries are kept as typed.
 
 Native command notes:
-- The registered commands mirror Moltbot’s chat commands.
+- The registered commands mirror OpenClaw’s chat commands.
 - Native commands honor the same allowlists as DMs/guild messages (`channels.discord.dm.allowFrom`, `channels.discord.guilds`, per-channel rules).
-- Slash commands may still be visible in Discord UI to users who aren’t allowlisted; Moltbot enforces allowlists on execution and replies “not authorized”.
+- Slash commands may still be visible in Discord UI to users who aren’t allowlisted; OpenClaw enforces allowlists on execution and replies “not authorized”.
 
 ## Tool actions
 The agent can call `discord` with actions like:
@@ -401,4 +401,4 @@ Emoji can be unicode (e.g., `✅`) or custom emoji syntax like `<:party_blob:123
 ## Safety & ops
 - Treat the bot token like a password; prefer the `DISCORD_BOT_TOKEN` env var on supervised hosts or lock down the config file permissions.
 - Only grant the bot permissions it needs (typically Read/Send Messages).
-- If the bot is stuck or rate limited, restart the gateway (`moltbot gateway --force`) after confirming no other processes own the Discord session.
+- If the bot is stuck or rate limited, restart the gateway (`openclaw gateway --force`) after confirming no other processes own the Discord session.

package/docs/channels/googlechat.md

@@ -13,7 +13,7 @@ Status: ready for DMs + spaces via Google Chat API webhooks (HTTP only).
    - Enable the API if it is not already enabled.
 2) Create a **Service Account**:
    - Press **Create Credentials** > **Service Account**.
-   - Name it whatever you want (e.g., `moltbot-chat`).
+   - Name it whatever you want (e.g., `openclaw-chat`).
    - Leave permissions blank (press **Continue**).
    - Leave principals with access blank (press **Done**).
 3) Create and download the **JSON Key**:
@@ -21,17 +21,17 @@ Status: ready for DMs + spaces via Google Chat API webhooks (HTTP only).
    - Go to the **Keys** tab.
    - Click **Add Key** > **Create new key**.
    - Select **JSON** and press **Create**.
-4) Store the downloaded JSON file on your gateway host (e.g., `~/.clawdbot/googlechat-service-account.json`).
+4) Store the downloaded JSON file on your gateway host (e.g., `~/.openclaw/googlechat-service-account.json`).
 5) Create a Google Chat app in the [Google Cloud Console Chat Configuration](https://console.cloud.google.com/apis/api/chat.googleapis.com/hangouts-chat):
    - Fill in the **Application info**:
-     - **App name**: (e.g. `Moltbot`)
-     - **Avatar URL**: (e.g. `https://molt.bot/logo.png`)
+     - **App name**: (e.g. `OpenClaw`)
+     - **Avatar URL**: (e.g. `https://openclaw.ai/logo.png`)
      - **Description**: (e.g. `Personal AI Assistant`)
    - Enable **Interactive features**.
    - Under **Functionality**, check **Join spaces and group conversations**.
    - Under **Connection settings**, select **HTTP endpoint URL**.
    - Under **Triggers**, select **Use a common HTTP endpoint URL for all triggers** and set it to your gateway's public URL followed by `/googlechat`.
-     - *Tip: Run `moltbot status` to find your gateway's public URL.*
+     - *Tip: Run `openclaw status` to find your gateway's public URL.*
    - Under **Visibility**, check **Make this Chat app available to specific people and groups in <Your Domain>**.
    - Enter your email address (e.g. `user@example.com`) in the text box.
    - Click **Save** at the bottom.
@@ -40,7 +40,7 @@ Status: ready for DMs + spaces via Google Chat API webhooks (HTTP only).
    - Look for the **App status** section (usually near the top or bottom after saving).
    - Change the status to **Live - available to users**.
    - Click **Save** again.
-7) Configure Moltbot with the service account path + webhook audience:
+7) Configure OpenClaw with the service account path + webhook audience:
    - Env: `GOOGLE_CHAT_SERVICE_ACCOUNT_FILE=/path/to/service-account.json`
    - Or config: `channels.googlechat.serviceAccountFile: "/path/to/service-account.json"`.
 8) Set the webhook audience type + value (matches your Chat app config).
@@ -57,7 +57,7 @@ Once the gateway is running and your email is added to the visibility list:
 6) Send "Hello" to trigger the assistant!
 
 ## Public URL (Webhook-only)
-Google Chat webhooks require a public HTTPS endpoint. For security, **only expose the `/googlechat` path** to the internet. Keep the Moltbot dashboard and other sensitive endpoints on your private network.
+Google Chat webhooks require a public HTTPS endpoint. For security, **only expose the `/googlechat` path** to the internet. Keep the OpenClaw dashboard and other sensitive endpoints on your private network.
 
 ### Option A: Tailscale Funnel (Recommended)
 Use Tailscale Serve for the private dashboard and Funnel for the public webhook path. This keeps `/` private while exposing only `/googlechat`.
@@ -112,7 +112,7 @@ your-domain.com {
     reverse_proxy /googlechat* localhost:18789
 }
 ```
-With this config, any request to `your-domain.com/` will be ignored or returned as 404, while `your-domain.com/googlechat` is safely routed to Moltbot.
+With this config, any request to `your-domain.com/` will be ignored or returned as 404, while `your-domain.com/googlechat` is safely routed to OpenClaw.
 
 ### Option C: Cloudflare Tunnel
 Configure your tunnel's ingress rules to only route the webhook path:
@@ -122,14 +122,14 @@ Configure your tunnel's ingress rules to only route the webhook path:
 ## How it works
 
 1. Google Chat sends webhook POSTs to the gateway. Each request includes an `Authorization: Bearer <token>` header.
-2. Moltbot verifies the token against the configured `audienceType` + `audience`:
+2. OpenClaw verifies the token against the configured `audienceType` + `audience`:
    - `audienceType: "app-url"` → audience is your HTTPS webhook URL.
    - `audienceType: "project-number"` → audience is the Cloud project number.
 3. Messages are routed by space:
    - DMs use session key `agent:<agentId>:googlechat:dm:<spaceId>`.
    - Spaces use session key `agent:<agentId>:googlechat:group:<spaceId>`.
 4. DM access is pairing by default. Unknown senders receive a pairing code; approve with:
-   - `moltbot pairing approve googlechat <code>`
+   - `openclaw pairing approve googlechat <code>`
 5. Group spaces require @-mention by default. Use `botUser` if mention detection needs the app’s user name.
 
 ## Targets
@@ -187,32 +187,32 @@ status code: 405, reason phrase: HTTP error response: HTTP/1.1 405 Method Not Al
 This means the webhook handler isn't registered. Common causes:
 1. **Channel not configured**: The `channels.googlechat` section is missing from your config. Verify with:
    ```bash
-   moltbot config get channels.googlechat
+   openclaw config get channels.googlechat
    ```
    If it returns "Config path not found", add the configuration (see [Config highlights](#config-highlights)).
 
 2. **Plugin not enabled**: Check plugin status:
    ```bash
-   moltbot plugins list | grep googlechat
+   openclaw plugins list | grep googlechat
    ```
    If it shows "disabled", add `plugins.entries.googlechat.enabled: true` to your config.
 
 3. **Gateway not restarted**: After adding config, restart the gateway:
    ```bash
-   moltbot gateway restart
+   openclaw gateway restart
    ```
 
 Verify the channel is running:
 ```bash
-moltbot channels status
+openclaw channels status
 # Should show: Google Chat default: enabled, configured, ...
 ```
 
 ### Other issues
-- Check `moltbot channels status --probe` for auth errors or missing audience config.
+- Check `openclaw channels status --probe` for auth errors or missing audience config.
 - If no messages arrive, confirm the Chat app's webhook URL + event subscriptions.
 - If mention gating blocks replies, set `botUser` to the app's user resource name and verify `requireMention`.
-- Use `moltbot logs --follow` while sending a test message to see if requests reach the gateway.
+- Use `openclaw logs --follow` while sending a test message to see if requests reach the gateway.
 
 Related docs:
 - [Gateway configuration](/gateway/configuration)

package/docs/channels/imessage.md

@@ -13,7 +13,7 @@ Status: external CLI integration. Gateway spawns `imsg rpc` (JSON-RPC over stdio
 1) Ensure Messages is signed in on this Mac.
 2) Install `imsg`:
    - `brew install steipete/tap/imsg`
-3) Configure Moltbot with `channels.imessage.cliPath` and `channels.imessage.dbPath`.
+3) Configure OpenClaw with `channels.imessage.cliPath` and `channels.imessage.dbPath`.
 4) Start the gateway and approve any macOS prompts (Automation + Full Disk Access).
 
 Minimal config:
@@ -47,7 +47,7 @@ Disable with:
 
 ## Requirements
 - macOS with Messages signed in.
-- Full Disk Access for Moltbot + `imsg` (Messages DB access).
+- Full Disk Access for OpenClaw + `imsg` (Messages DB access).
 - Automation permission when sending.
 - `channels.imessage.cliPath` can point to any command that proxies stdin/stdout (for example, a wrapper script that SSHes to another Mac and runs `imsg rpc`).
 
@@ -60,7 +60,7 @@ If you want the bot to send from a **separate iMessage identity** (and keep your
 
 1) Create a dedicated Apple ID (example: `my-cool-bot@icloud.com`).
    - Apple may require a phone number for verification / 2FA.
-2) Create a macOS user (example: `clawdshome`) and sign into it.
+2) Create a macOS user (example: `openclawhome`) and sign into it.
 3) Open Messages in that macOS user and sign into iMessage using the bot Apple ID.
 4) Enable Remote Login (System Settings → General → Sharing → Remote Login).
 5) Install `imsg`:
@@ -103,7 +103,7 @@ Example config:
 For single-account setups, use flat options (`channels.imessage.cliPath`, `channels.imessage.dbPath`) instead of the `accounts` map.
 
 ### Remote/SSH variant (optional)
-If you want iMessage on another Mac, set `channels.imessage.cliPath` to a wrapper that runs `imsg` on the remote macOS host over SSH. Moltbot only needs stdio.
+If you want iMessage on another Mac, set `channels.imessage.cliPath` to a wrapper that runs `imsg` on the remote macOS host over SSH. OpenClaw only needs stdio.
 
 Example wrapper:
 ```bash
@@ -111,7 +111,7 @@ Example wrapper:
 exec ssh -T gateway-host imsg "$@"
 ```
 
-**Remote attachments:** When `cliPath` points to a remote host via SSH, attachment paths in the Messages database reference files on the remote machine. Moltbot can automatically fetch these over SCP by setting `channels.imessage.remoteHost`:
+**Remote attachments:** When `cliPath` points to a remote host via SSH, attachment paths in the Messages database reference files on the remote machine. OpenClaw can automatically fetch these over SCP by setting `channels.imessage.remoteHost`:
 
 ```json5
 {
@@ -125,7 +125,7 @@ exec ssh -T gateway-host imsg "$@"
 }
 ```
 
-If `remoteHost` is not set, Moltbot attempts to auto-detect it by parsing the SSH command in your wrapper script. Explicit configuration is recommended for reliability.
+If `remoteHost` is not set, OpenClaw attempts to auto-detect it by parsing the SSH command in your wrapper script. Explicit configuration is recommended for reliability.
 
 #### Remote Mac via Tailscale (example)
 If the Gateway runs on a Linux host/VM but iMessage must run on a Mac, Tailscale is the simplest bridge: the Gateway talks to the Mac over the tailnet, runs `imsg` via SSH, and SCPs attachments back.
@@ -134,7 +134,7 @@ Architecture:
 ```
 ┌──────────────────────────────┐          SSH (imsg rpc)          ┌──────────────────────────┐
 │ Gateway host (Linux/VM)      │──────────────────────────────────▶│ Mac with Messages + imsg │
-│ - moltbot gateway           │          SCP (attachments)        │ - Messages signed in     │
+│ - openclaw gateway           │          SCP (attachments)        │ - Messages signed in     │
 │ - channels.imessage.cliPath  │◀──────────────────────────────────│ - Remote Login enabled   │
 └──────────────────────────────┘                                   └──────────────────────────┘
               ▲
@@ -149,7 +149,7 @@ Concrete config example (Tailscale hostname):
   channels: {
     imessage: {
       enabled: true,
-      cliPath: "~/.clawdbot/scripts/imsg-ssh",
+      cliPath: "~/.openclaw/scripts/imsg-ssh",
       remoteHost: "bot@mac-mini.tailnet-1234.ts.net",
       includeAttachments: true,
       dbPath: "/Users/bot/Library/Messages/chat.db"
@@ -158,7 +158,7 @@ Concrete config example (Tailscale hostname):
 }
 ```
 
-Example wrapper (`~/.clawdbot/scripts/imsg-ssh`):
+Example wrapper (`~/.openclaw/scripts/imsg-ssh`):
 ```bash
 #!/usr/bin/env bash
 exec ssh -T bot@mac-mini.tailnet-1234.ts.net imsg "$@"
@@ -169,15 +169,15 @@ Notes:
 - Use SSH keys so `ssh bot@mac-mini.tailnet-1234.ts.net` works without prompts.
 - `remoteHost` should match the SSH target so SCP can fetch attachments.
 
-Multi-account support: use `channels.imessage.accounts` with per-account config and optional `name`. See [`gateway/configuration`](/gateway/configuration#telegramaccounts--discordaccounts--slackaccounts--signalaccounts--imessageaccounts) for the shared pattern. Don't commit `~/.clawdbot/moltbot.json` (it often contains tokens).
+Multi-account support: use `channels.imessage.accounts` with per-account config and optional `name`. See [`gateway/configuration`](/gateway/configuration#telegramaccounts--discordaccounts--slackaccounts--signalaccounts--imessageaccounts) for the shared pattern. Don't commit `~/.openclaw/openclaw.json` (it often contains tokens).
 
 ## Access control (DMs + groups)
 DMs:
 - Default: `channels.imessage.dmPolicy = "pairing"`.
 - Unknown senders receive a pairing code; messages are ignored until approved (codes expire after 1 hour).
 - Approve via:
-  - `moltbot pairing list imessage`
-  - `moltbot pairing approve imessage <CODE>`
+  - `openclaw pairing list imessage`
+  - `openclaw pairing approve imessage <CODE>`
 - Pairing is the default token exchange for iMessage DMs. Details: [Pairing](/start/pairing)
 
 Groups:
@@ -193,7 +193,7 @@ Groups:
 ## Group-ish threads (`is_group=false`)
 Some iMessage threads can have multiple participants but still arrive with `is_group=false` depending on how Messages stores the chat identifier.
 
-If you explicitly configure a `chat_id` under `channels.imessage.groups`, Moltbot treats that thread as a “group” for:
+If you explicitly configure a `chat_id` under `channels.imessage.groups`, OpenClaw treats that thread as a “group” for:
 - session isolation (separate `agent:<agentId>:imessage:group:<chat_id>` session key)
 - group allowlisting / mention gating behavior
 

package/docs/channels/index.md

@@ -1,12 +1,12 @@
 ---
-summary: "Messaging platforms Moltbot can connect to"
+summary: "Messaging platforms OpenClaw can connect to"
 read_when:
-  - You want to choose a chat channel for Moltbot
+  - You want to choose a chat channel for OpenClaw
   - You need a quick overview of supported messaging platforms
 ---
 # Chat Channels
 
-Moltbot can talk to you on any chat app you already use. Each channel connects via the Gateway.
+OpenClaw can talk to you on any chat app you already use. Each channel connects via the Gateway.
 Text is supported everywhere; media and reactions vary by channel.
 
 ## Supported channels
@@ -33,7 +33,7 @@ Text is supported everywhere; media and reactions vary by channel.
 
 ## Notes
 
-- Channels can run simultaneously; configure multiple and Moltbot will route per chat.
+- Channels can run simultaneously; configure multiple and OpenClaw will route per chat.
 - Fastest setup is usually **Telegram** (simple bot token). WhatsApp requires QR pairing and
   stores more state on disk.
 - Group behavior varies by channel; see [Groups](/concepts/groups).

package/docs/channels/line.md

@@ -1,14 +1,14 @@
 ---
 summary: "LINE Messaging API plugin setup, config, and usage"
 read_when:
-  - You want to connect Moltbot to LINE
+  - You want to connect OpenClaw to LINE
   - You need LINE webhook + credential setup
   - You want LINE-specific message options
 ---
 
 # LINE (plugin)
 
-LINE connects to Moltbot via the LINE Messaging API. The plugin runs as a webhook
+LINE connects to OpenClaw via the LINE Messaging API. The plugin runs as a webhook
 receiver on the gateway and uses your channel access token + channel secret for
 authentication.
 
@@ -21,13 +21,13 @@ are not supported.
 Install the LINE plugin:
 
 ```bash
-moltbot plugins install @moltbot/line
+openclaw plugins install @openclaw/line
 ```
 
 Local checkout (when running from a git repo):
 
 ```bash
-moltbot plugins install ./extensions/line
+openclaw plugins install ./extensions/line
 ```
 
 ## Setup
@@ -106,8 +106,8 @@ Direct messages default to pairing. Unknown senders get a pairing code and their
 messages are ignored until approved.
 
 ```bash
-moltbot pairing list line
-moltbot pairing approve line <CODE>
+openclaw pairing list line
+openclaw pairing approve line <CODE>
 ```
 
 Allowlists and policies:

package/docs/channels/location.md

@@ -7,7 +7,7 @@ read_when:
 
 # Channel location parsing
 
-Moltbot normalizes shared locations from chat channels into:
+OpenClaw normalizes shared locations from chat channels into:
 - human-readable text appended to the inbound body, and
 - structured fields in the auto-reply context payload.
 

package/docs/channels/matrix.md

@@ -5,7 +5,7 @@ read_when:
 ---
 # Matrix (plugin)
 
-Matrix is an open, decentralized messaging protocol. Moltbot connects as a Matrix **user**
+Matrix is an open, decentralized messaging protocol. OpenClaw connects as a Matrix **user**
 on any homeserver, so you need a Matrix account for the bot. Once it is logged in, you can DM
 the bot directly or invite it to rooms (Matrix "groups"). Beeper is a valid client option too,
 but it requires E2EE to be enabled.
@@ -20,25 +20,25 @@ Matrix ships as a plugin and is not bundled with the core install.
 Install via CLI (npm registry):
 
 ```bash
-moltbot plugins install @moltbot/matrix
+openclaw plugins install @openclaw/matrix
 ```
 
 Local checkout (when running from a git repo):
 
 ```bash
-moltbot plugins install ./extensions/matrix
+openclaw plugins install ./extensions/matrix
 ```
 
 If you choose Matrix during configure/onboarding and a git checkout is detected,
-Moltbot will offer the local install path automatically.
+OpenClaw will offer the local install path automatically.
 
 Details: [Plugins](/plugin)
 
 ## Setup
 
 1) Install the Matrix plugin:
-   - From npm: `moltbot plugins install @moltbot/matrix`
-   - From a local checkout: `moltbot plugins install ./extensions/matrix`
+   - From npm: `openclaw plugins install @openclaw/matrix`
+   - From a local checkout: `openclaw plugins install ./extensions/matrix`
 2) Create a Matrix account on a homeserver:
    - Browse hosting options at [https://matrix.org/ecosystem/hosting/](https://matrix.org/ecosystem/hosting/)
    - Or host it yourself.
@@ -60,8 +60,8 @@ Details: [Plugins](/plugin)
    ```
 
    - Replace `matrix.example.org` with your homeserver URL.
-   - Or set `channels.matrix.userId` + `channels.matrix.password`: Moltbot calls the same
-     login endpoint, stores the access token in `~/.clawdbot/credentials/matrix/credentials.json`,
+   - Or set `channels.matrix.userId` + `channels.matrix.password`: OpenClaw calls the same
+     login endpoint, stores the access token in `~/.openclaw/credentials/matrix/credentials.json`,
      and reuses it on next start.
 4) Configure credentials:
    - Env: `MATRIX_HOMESERVER`, `MATRIX_ACCESS_TOKEN` (or `MATRIX_USER_ID` + `MATRIX_PASSWORD`)
@@ -113,17 +113,17 @@ Enable with `channels.matrix.encryption: true`:
 
 - If the crypto module loads, encrypted rooms are decrypted automatically.
 - Outbound media is encrypted when sending to encrypted rooms.
-- On first connection, Moltbot requests device verification from your other sessions.
+- On first connection, OpenClaw requests device verification from your other sessions.
 - Verify the device in another Matrix client (Element, etc.) to enable key sharing.
 - If the crypto module cannot be loaded, E2EE is disabled and encrypted rooms will not decrypt;
-  Moltbot logs a warning.
+  OpenClaw logs a warning.
 - If you see missing crypto module errors (for example, `@matrix-org/matrix-sdk-crypto-nodejs-*`),
   allow build scripts for `@matrix-org/matrix-sdk-crypto-nodejs` and run
   `pnpm rebuild @matrix-org/matrix-sdk-crypto-nodejs` or fetch the binary with
   `node node_modules/@matrix-org/matrix-sdk-crypto-nodejs/download-lib.js`.
 
 Crypto state is stored per account + access token in
-`~/.clawdbot/matrix/accounts/<account>/<homeserver>__<user>/<token-hash>/crypto/`
+`~/.openclaw/matrix/accounts/<account>/<homeserver>__<user>/<token-hash>/crypto/`
 (SQLite database). Sync state lives alongside it in `bot-storage.json`.
 If the access token (device) changes, a new store is created and the bot must be
 re-verified for encrypted rooms.
@@ -142,8 +142,8 @@ Once verified, the bot can decrypt messages in encrypted rooms.
 
 - Default: `channels.matrix.dm.policy = "pairing"`. Unknown senders get a pairing code.
 - Approve via:
-  - `moltbot pairing list matrix`
-  - `moltbot pairing approve matrix <CODE>`
+  - `openclaw pairing list matrix`
+  - `openclaw pairing approve matrix <CODE>`
 - Public DMs: `channels.matrix.dm.policy="open"` plus `channels.matrix.dm.allowFrom=["*"]`.
 - `channels.matrix.dm.allowFrom` accepts user IDs or display names. The wizard resolves display names to user IDs when directory search is available.
 
@@ -172,7 +172,7 @@ Once verified, the bot can decrypt messages in encrypted rooms.
 - `groupAllowFrom` restricts which senders can trigger the bot in rooms (optional).
 - Per-room `users` allowlists can further restrict senders inside a specific room.
 - The configure wizard prompts for room allowlists (room IDs, aliases, or names) and resolves names when possible.
-- On startup, Moltbot resolves room/user names in allowlists to IDs and logs the mapping; unresolved entries are kept as typed.
+- On startup, OpenClaw resolves room/user names in allowlists to IDs and logs the mapping; unresolved entries are kept as typed.
 - Invites are auto-joined by default; control with `channels.matrix.autoJoin` and `channels.matrix.autoJoinAllowlist`.
 - To allow **no rooms**, set `channels.matrix.groupPolicy: "disabled"` (or keep an empty allowlist).
 - Legacy key: `channels.matrix.rooms` (same shape as `groups`).

package/docs/channels/mattermost.md

@@ -1,5 +1,5 @@
 ---
-summary: "Mattermost bot setup and Moltbot config"
+summary: "Mattermost bot setup and OpenClaw config"
 read_when:
   - Setting up Mattermost
   - Debugging Mattermost routing
@@ -16,16 +16,16 @@ Mattermost ships as a plugin and is not bundled with the core install.
 
 Install via CLI (npm registry):
 ```bash
-moltbot plugins install @moltbot/mattermost
+openclaw plugins install @openclaw/mattermost
 ```
 
 Local checkout (when running from a git repo):
 ```bash
-moltbot plugins install ./extensions/mattermost
+openclaw plugins install ./extensions/mattermost
 ```
 
 If you choose Mattermost during configure/onboarding and a git checkout is detected,
-Moltbot will offer the local install path automatically.
+OpenClaw will offer the local install path automatically.
 
 Details: [Plugins](/plugin)
 
@@ -33,7 +33,7 @@ Details: [Plugins](/plugin)
 1) Install the Mattermost plugin.
 2) Create a Mattermost bot account and copy the **bot token**.
 3) Copy the Mattermost **base URL** (e.g., `https://chat.example.com`).
-4) Configure Moltbot and start the gateway.
+4) Configure OpenClaw and start the gateway.
 
 Minimal config:
 ```json5
@@ -83,8 +83,8 @@ Notes:
 ## Access control (DMs)
 - Default: `channels.mattermost.dmPolicy = "pairing"` (unknown senders get a pairing code).
 - Approve via:
-  - `moltbot pairing list mattermost`
-  - `moltbot pairing approve mattermost <CODE>`
+  - `openclaw pairing list mattermost`
+  - `openclaw pairing approve mattermost <CODE>`
 - Public DMs: `channels.mattermost.dmPolicy="open"` plus `channels.mattermost.allowFrom=["*"]`.
 
 ## Channels (groups)
@@ -93,7 +93,7 @@ Notes:
 - Open channels: `channels.mattermost.groupPolicy="open"` (mention-gated).
 
 ## Targets for outbound delivery
-Use these target formats with `moltbot message send` or cron/webhooks:
+Use these target formats with `openclaw message send` or cron/webhooks:
 
 - `channel:<id>` for a channel
 - `user:<id>` for a DM