Initial commit: OpenClaw Skill Collection

6 custom skills (assign-task, dispatch-webhook, daily-briefing,
task-capture, qmd-brain, tts-voice) with technical documentation.
Compatible with Claude Code, OpenClaw, Codex CLI, and OpenCode.

openclaw-knowhow-skill/docs/channels/discord.md

@@ -0,0 +1,54 @@
+# Discord (Bot API)
+
+## Overview
+
+OpenClaw supports Discord integration for direct messages and guild text channels. The system requires a bot token, message content intent, and proper configuration to function.
+
+## Quick Setup
+
+To enable Discord:
+
+1. Create a Discord bot application and obtain the token
+2. Enable "Message Content Intent" and "Server Members Intent" in Discord Developer Portal
+3. Configure the token via environment variable (`DISCORD_BOT_TOKEN`) or config file
+4. Invite the bot to your server with appropriate permissions
+5. Start the gateway
+
+**Minimal configuration:**
+
+```json
+{
+  "channels": {
+    "discord": {
+      "enabled": true,
+      "token": "YOUR_BOT_TOKEN"
+    }
+  }
+}
+```
+
+## Key Features
+
+- **DM handling**: Uses pairing-based security by default; unknown senders receive time-limited pairing codes
+- **Guild channels**: Isolated sessions per channel with optional mention requirements
+- **Group DMs**: Disabled by default; can be enabled via configuration
+- **Message routing**: Replies always return to the originating channel
+- **File uploads**: Supported up to 8 MB (configurable)
+- **Reactions**: Available via the `discord` tool when enabled
+
+## Configuration Options
+
+The system supports granular control through:
+
+- Per-guild rules and channel-specific settings
+- User allowlists at multiple levels (DM, guild, channel)
+- Mention requirements for reducing noise in shared channels
+- Tool action gates (reactions, threads, moderation, etc.)
+- Reply threading via special tags in model output
+
+## Safety Considerations
+
+- Treat bot tokens as sensitive credentials; use environment variables in production
+- Grant only necessary permissions (View Channels, Send Messages, Read History)
+- Use allowlists to restrict access in shared spaces
+- Monitor rate limiting with retry policies

openclaw-knowhow-skill/docs/channels/feishu.md

@@ -0,0 +1,71 @@
+# Feishu Bot
+
+## Overview
+
+The Feishu plugin connects OpenClaw to Lark's team chat platform through WebSocket event subscriptions, eliminating the need for public webhook URLs.
+
+## Installation
+
+```bash
+openclaw plugins install @openclaw/feishu
+```
+
+## Configuration Methods
+
+- Onboarding wizard (recommended): `openclaw onboard`
+- CLI: `openclaw channels add`
+- Config file: Edit `~/.openclaw/openclaw.json`
+- Environment variables: `FEISHU_APP_ID` and `FEISHU_APP_SECRET`
+
+## Creating a Feishu App
+
+1. Visit Feishu Open Platform and create an enterprise app
+2. Collect App ID (format: `cli_xxx`) and App Secret from credentials section
+3. Import required permissions via batch import JSON
+4. Enable bot capability and set bot name
+5. Configure event subscription using long connection (WebSocket) with `im.message.receive_v1`
+6. Publish and await approval
+
+**Important:** Before setting event subscription, make sure you already ran `openclaw channels add` for Feishu and the gateway is operational.
+
+## Access Control
+
+### Direct Messages
+
+- Default pairing mode requires user approval via: `openclaw pairing approve feishu <CODE>`
+- Alternative allowlist mode restricts to specified Open IDs
+
+### Group Chats
+
+- Policy options: `open` (default), `allowlist`, or `disabled`
+- Per-group mention requirement configuration available
+
+## Retrieving IDs
+
+- Group IDs resemble `oc_xxx`
+- User IDs resemble `ou_xxx`
+
+Obtain these by starting the gateway, mentioning/messaging the bot, then checking logs via `openclaw logs --follow`.
+
+## Supported Features
+
+**Message Types Received:**
+- Text
+- Rich text
+- Images
+- Files
+- Audio
+- Video
+- Stickers
+
+**Message Types Sent:**
+- Text
+- Images
+- Files
+- Audio
+- Partial rich text support
+
+**Additional Capabilities:**
+- Streaming replies
+- Multi-agent routing
+- Multiple account support

openclaw-knowhow-skill/docs/channels/googlechat.md

@@ -0,0 +1,65 @@
+# Google Chat Integration
+
+## Overview
+
+This documentation covers setting up OpenClaw's Google Chat integration via the Chat API with webhook support for direct messages and spaces.
+
+## Setup Steps
+
+### 1. Google Cloud Project
+
+Enable the Chat API and create service account credentials, downloading a JSON key file for authentication.
+
+### 2. Chat App Configuration
+
+Register the app in Google Cloud Console with basic info (name, avatar, description), enable interactive features, and configure an HTTP endpoint.
+
+### 3. Webhook Configuration
+
+Set the endpoint to your gateway's public URL with "/googlechat" path and establish visibility restrictions to specific users.
+
+### 4. App Status Activation
+
+After saving, refresh and change app status to "Live" for user availability.
+
+### 5. OpenClaw Configuration
+
+Configure the service account file path and webhook audience settings via environment variables or config files.
+
+### 6. Adding to Chat
+
+Users can find the private app by searching its name in Google Chat and start conversations.
+
+## Security Architecture
+
+Only expose the `/googlechat` path to the internet. Three recommended approaches:
+
+### Tailscale Funnel
+
+Combines private dashboard access via Serve with public webhook exposure via Funnel.
+
+### Reverse Proxy (Caddy)
+
+Routes only the specific webhook path while blocking other requests.
+
+### Cloudflare Tunnel
+
+Configures ingress rules limiting access to the webhook endpoint.
+
+## Message Routing
+
+Messages are processed through space-based routing using session keys that differentiate between direct messages and group spaces.
+
+- **Direct messages** employ pairing by default requiring approval codes
+- **Group spaces** require @-mentions unless configured otherwise
+
+## Configuration Options
+
+The system supports:
+
+- Service account authentication
+- Optional bot user identification
+- Group allowlisting
+- Reaction handling
+- Typing indicators
+- Media attachments up to a configurable size limit

openclaw-knowhow-skill/docs/channels/grammy.md

@@ -0,0 +1,26 @@
+# grammY
+
+## grammY Integration (Telegram Bot API)
+
+## Why grammY
+
+- TS-first Bot API client with built-in long-poll + webhook helpers, middleware, error handling, rate limiter
+- Cleaner media helpers than hand-rolling fetch + FormData; supports all Bot API methods
+- Extensible: proxy support via custom fetch, session middleware (optional), type-safe context
+
+## What We Shipped
+
+- **Single client path:** fetch-based implementation removed; grammY is now the sole Telegram client (send + gateway) with the grammY throttler enabled by default
+- **Gateway:** `monitorTelegramProvider` builds a grammY `Bot`, wires mention/allowlist gating, media download via `getFile`/`download`, and delivers replies with `sendMessage/sendPhoto/sendVideo/sendAudio/sendDocument`. Supports long-poll or webhook via `webhookCallback`
+- **Proxy:** optional `channels.telegram.proxy` uses `undici.ProxyAgent` through grammY's `client.baseFetch`
+- **Webhook support:** `webhook-set.ts` wraps `setWebhook/deleteWebhook`; `webhook.ts` hosts the callback with health + graceful shutdown. Gateway enables webhook mode when `channels.telegram.webhookUrl` + `channels.telegram.webhookSecret` are set (otherwise it long-polls)
+- **Sessions:** direct chats collapse into the agent main session (`agent:<agentId>:<mainKey>`); groups use `agent:<agentId>:telegram:group:<chatId>`; replies route back to the same channel
+- **Config knobs:** `channels.telegram.botToken`, `channels.telegram.dmPolicy`, `channels.telegram.groups` (allowlist + mention defaults), `channels.telegram.allowFrom`, `channels.telegram.groupAllowFrom`, `channels.telegram.groupPolicy`, `channels.telegram.mediaMaxMb`, `channels.telegram.linkPreview`, `channels.telegram.proxy`, `channels.telegram.webhookSecret`, `channels.telegram.webhookUrl`
+- **Draft streaming:** optional `channels.telegram.streamMode` uses `sendMessageDraft` in private topic chats (Bot API 9.3+). This is separate from channel block streaming
+- **Tests:** grammy mocks cover DM + group mention gating and outbound send; more media/webhook fixtures still welcome
+
+## Open Questions
+
+- Optional grammY plugins (throttler) if we hit Bot API 429s
+- Add more structured media tests (stickers, voice notes)
+- Make webhook listen port configurable (currently fixed to 8787 unless wired through the gateway)

openclaw-knowhow-skill/docs/channels/imessage.md

@@ -0,0 +1,47 @@
+# iMessage
+
+## Overview
+
+The iMessage integration is a legacy external CLI tool that connects OpenClaw to Apple Messages on macOS.
+
+**Note:** BlueBubbles is recommended for new setups. The `imsg` channel may be removed in future releases.
+
+## Setup Requirements
+
+The basic configuration involves three steps:
+
+1. Ensure Messages is signed in
+2. Install the `imsg` tool via Homebrew
+3. Configure two paths in OpenClaw's settings
+
+The system requires:
+- Full Disk Access for OpenClaw + `imsg`
+- Automation permissions for sending messages
+
+## Account Configuration Options
+
+Users can set up iMessage in single-account or multi-account modes. For isolated bot identities, the documentation describes creating a dedicated Apple ID and separate macOS user account, with Remote Login enabled for SSH access.
+
+## Remote Setup
+
+The integration supports running `imsg` on a remote Mac via SSH, with automatic attachment retrieval through SCP.
+
+### Tailscale Example Architecture
+
+A Linux Gateway connects to a Mac over a private network, enabling iMessage functionality without direct macOS hosting.
+
+## Access Control
+
+Two policy types manage permissions:
+
+- **pairing** (default for DMs): Generates codes for unknown senders
+- **allowlist**: Restricts group participation
+
+The system uses mention patterns since iMessage lacks native mention metadata.
+
+## Message Handling
+
+- Messages are chunked to a configurable character limit (default 4000)
+- Optional newline-based chunking splits on paragraph boundaries
+- Group sessions receive isolated identifiers
+- DM sessions share the agent's main context

openclaw-knowhow-skill/docs/channels/index.md

@@ -0,0 +1,46 @@
+# Chat Channels
+
+## Overview
+
+OpenClaw integrates with numerous messaging platforms through its Gateway infrastructure. The documentation lists 20+ supported channels, with text support available universally while media and reaction capabilities vary by platform.
+
+## Supported Platforms
+
+The primary channels include established services like:
+
+- **WhatsApp** - Using Baileys with QR pairing
+- **Telegram** - Via grammY bot API
+- **Discord** - With server and DM support
+- **Slack** - Through Bolt SDK
+- **Signal** - For privacy-conscious users
+- **iMessage** - BlueBubbles recommended for integration
+
+## Key Features
+
+Channels can run simultaneously; configure multiple and OpenClaw will route per chat. This enables users to maintain presence across multiple messaging services with a single bot instance.
+
+### Platform Differences
+
+- **WhatsApp** setup requires QR pairing and maintains more local state
+- **Telegram** offers the quickest configuration path using only a bot token
+- **BlueBubbles** supports advanced iMessage features including message editing, unsending, and reaction handling (though edit functionality is currently broken on macOS 26 Tahoe)
+
+## Plugin-Based Extensions
+
+Several channels require separate plugin installation rather than core integration:
+
+- Feishu
+- Mattermost
+- Microsoft Teams
+- Matrix
+- LINE
+- Zalo
+
+## Security
+
+DM pairing and allowlists provide security controls. See the individual channel documentation for specific configuration options.
+
+## Related Documentation
+
+- [Location Parsing](location.md)
+- [Troubleshooting](troubleshooting.md)

openclaw-knowhow-skill/docs/channels/line.md

@@ -0,0 +1,165 @@
+# LINE
+
+## LINE (plugin)
+
+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.
+
+**Status:** Supported via plugin. Direct messages, group chats, media, locations, Flex messages, template messages, and quick replies are supported. Reactions and threads are not supported.
+
+## Plugin Required
+
+Install the LINE plugin:
+
+```bash
+openclaw plugins install @openclaw/line
+```
+
+Local checkout (when running from a git repo):
+
+```bash
+openclaw plugins install ./extensions/line
+```
+
+## Setup
+
+1. Create a LINE Developers account and open the Console: https://developers.line.biz/console/
+2. Create (or pick) a Provider and add a **Messaging API** channel
+3. Copy the **Channel access token** and **Channel Secret** from the channel settings
+4. Enable **Use webhook** in the Messaging API settings
+5. Set the webhook URL to your gateway endpoint (HTTPS required):
+
+```
+https://gateway-host/line/webhook
+```
+
+The gateway responds to LINE's webhook verification (GET) and inbound events (POST). If you need a custom path, set `channels.line.webhookPath` or `channels.line.accounts.<id>.webhookPath` and update the URL accordingly.
+
+## Configure
+
+**Minimal config:**
+
+```json5
+{
+  channels: {
+    line: {
+      enabled: true,
+      channelAccessToken: "LINE_CHANNEL_ACCESS_TOKEN",
+      channelSecret: "LINE_CHANNEL_SECRET",
+      dmPolicy: "pairing",
+    },
+  },
+}
+```
+
+**Environment variables (default account only):**
+
+- `LINE_CHANNEL_ACCESS_TOKEN`
+- `LINE_CHANNEL_SECRET`
+
+**Token/secret files:**
+
+```json5
+{
+  channels: {
+    line: {
+      tokenFile: "/path/to/line-token.txt",
+      secretFile: "/path/to/line-secret.txt",
+    },
+  },
+}
+```
+
+**Multiple accounts:**
+
+```json5
+{
+  channels: {
+    line: {
+      accounts: {
+        marketing: {
+          channelAccessToken: "...",
+          channelSecret: "...",
+          webhookPath: "/line/marketing",
+        },
+      },
+    },
+  },
+}
+```
+
+## Access Control
+
+Direct messages default to pairing. Unknown senders get a pairing code and their messages are ignored until approved.
+
+```bash
+openclaw pairing list line
+openclaw pairing approve line <CODE>
+```
+
+**Allowlists and policies:**
+
+- `channels.line.dmPolicy`: `pairing | allowlist | open | disabled`
+- `channels.line.allowFrom`: allowlisted LINE user IDs for DMs
+- `channels.line.groupPolicy`: `allowlist | open | disabled`
+- `channels.line.groupAllowFrom`: allowlisted LINE user IDs for groups
+- Per-group overrides: `channels.line.groups.<groupId>.allowFrom`
+
+LINE IDs are case-sensitive. Valid IDs look like:
+
+- User: `U` + 32 hex chars
+- Group: `C` + 32 hex chars
+- Room: `R` + 32 hex chars
+
+## Message Behavior
+
+- Text is chunked at 5000 characters
+- Markdown formatting is stripped; code blocks and tables are converted into Flex cards when possible
+- Streaming responses are buffered; LINE receives full chunks with a loading animation while the agent works
+- Media downloads are capped by `channels.line.mediaMaxMb` (default 10)
+
+## Channel Data (Rich Messages)
+
+Use `channelData.line` to send quick replies, locations, Flex cards, or template messages.
+
+```json5
+{
+  text: "Here you go",
+  channelData: {
+    line: {
+      quickReplies: ["Status", "Help"],
+      location: {
+        title: "Office",
+        address: "123 Main St",
+        latitude: 35.681236,
+        longitude: 139.767125,
+      },
+      flexMessage: {
+        altText: "Status card",
+        contents: {
+          /* Flex payload */
+        },
+      },
+      templateMessage: {
+        type: "confirm",
+        text: "Proceed?",
+        confirmLabel: "Yes",
+        confirmData: "yes",
+        cancelLabel: "No",
+        cancelData: "no",
+      },
+    },
+  },
+}
+```
+
+The LINE plugin also ships a `/card` command for Flex message presets:
+
+```
+/card info "Welcome" "Thanks for joining!"
+```
+
+## Troubleshooting
+
+- **Webhook verification fails:** ensure the webhook URL is HTTPS and the `channelSecret` matches the LINE console
+- **No inbound events:** confirm the webhook path matches `channels.line.webhookPath` and that the gateway is reachable from LINE
+- **Media download errors:** raise `channels.line.mediaMaxMb` if media exceeds the default limit

openclaw-knowhow-skill/docs/channels/location.md

@@ -0,0 +1,37 @@
+# Channel Location Parsing
+
+OpenClaw converts location data from messaging platforms into both readable text and structured fields. The system supports Telegram, WhatsApp, and Matrix channels.
+
+## Text Rendering
+
+Locations appear as formatted strings appended to messages:
+
+- A pin displays as `"📍 48.858844, 2.294351 ±12m"`
+- A named venue shows the location name alongside coordinates
+- Live location shares are prefixed with a satellite emoji
+
+User captions or comments are added on subsequent lines when provided.
+
+## Structured Data
+
+When locations are detected, the auto-reply context receives these fields:
+
+- Latitude and longitude (numeric)
+- Accuracy measurement in meters (when available)
+- Optional place name and address
+- Source type designation
+- Live-sharing status indicator
+
+## Platform-Specific Details
+
+### Telegram
+
+Processes venue data into name and address fields. Live locations reference the `live_period` attribute.
+
+### WhatsApp
+
+Extracts comments from location messages and captions from live sharing.
+
+### Matrix
+
+Parses the `geo_uri` standard, treating all locations as static pins regardless of the `LocationIsLive` designation.

openclaw-knowhow-skill/docs/channels/matrix.md

@@ -0,0 +1,54 @@
+# Matrix Plugin
+
+## Overview
+
+OpenClaw integrates with Matrix, an open, decentralized messaging protocol. The plugin enables bot connectivity as a standard user account on any homeserver, supporting direct messaging, group rooms, threads, and encrypted communications.
+
+## Installation
+
+The Matrix functionality ships as a separate plugin requiring explicit installation via npm registry or local checkout from a git repository.
+
+```bash
+openclaw plugins install @openclaw/matrix
+```
+
+## Key Features
+
+The implementation provides comprehensive messaging capabilities including:
+
+- Direct message exchanges and room participation
+- Thread-based conversations
+- Media file handling
+- End-to-end encryption using Rust crypto SDK
+- Reaction and poll functionality
+- Geographic location sharing
+
+## Authentication Setup
+
+Users must create a Matrix account and obtain an access token. The documentation provides curl command examples for retrieving tokens via the Matrix login API, with options to supply credentials directly or store them as environment variables.
+
+## Encryption (E2EE)
+
+When enabled, the system handles encrypted room decryption automatically upon crypto module loading. Device verification through another Matrix client establishes trust for key sharing.
+
+If the crypto module fails to load, encrypted rooms remain inaccessible with appropriate logging warnings.
+
+## Access Controls
+
+### DMs
+
+Default pairing policy requires approval codes for unknown senders.
+
+### Rooms
+
+Mention-gating enabled by default; allowlist configuration restricts bot triggering to specified rooms and users.
+
+## Threading & Configuration
+
+Reply behavior customizes through `threadReplies` settings:
+
+- `off` - No threading
+- `inbound` - Thread replies to threaded messages
+- `always` - Always use threads
+
+Text output splits based on character limits or paragraph boundaries.

openclaw-knowhow-skill/docs/channels/mattermost.md

@@ -0,0 +1,64 @@
+# Mattermost Plugin
+
+## Overview
+
+OpenClaw integrates with Mattermost, a self-hostable team messaging platform, via a plugin.
+
+## Installation
+
+The plugin requires separate installation:
+
+```bash
+openclaw plugins install @openclaw/mattermost
+```
+
+## Core Configuration
+
+The minimal setup requires three elements:
+
+- A bot token
+- Base URL
+- A DM policy
+
+Mattermost responds to DMs automatically, with channel interactions governed by the `chatmode` setting.
+
+## Chat Modes
+
+Three response patterns are available:
+
+- **oncall** (default): responds only to @mentions
+- **onmessage**: replies to all channel messages
+- **onchar**: triggers on specific prefix characters like `>` or `!`
+
+## Access Controls
+
+### DM Security
+
+Uses a pairing code system by default, allowing administrators to approve unknown senders.
+
+### Channel Access
+
+Controlled via allowlists using the `groupAllowPolicy` setting.
+
+## Multi-Account Support
+
+Multiple Mattermost instances can be configured simultaneously under separate account identifiers, each with independent tokens and base URLs.
+
+## Message Delivery Targets
+
+Outbound messages use standardized formats:
+
+- `channel:<id>` - Channel messages
+- `user:<id>` - Direct messages by user ID
+- `@username` - Direct messages by username
+
+## Environment Variables
+
+Environment variable alternatives are available for the default account configuration.
+
+## Troubleshooting
+
+Common issues involve:
+
+- Channel visibility
+- Authentication issues

openclaw-knowhow-skill/docs/channels/msteams.md

@@ -0,0 +1,69 @@
+# Microsoft Teams Plugin
+
+## Overview
+
+The Microsoft Teams integration for OpenClaw operates as a plugin (not included in core), enabling bot conversations via Teams DMs, group chats, and channels. This setup involves Azure Bot registration, Teams app manifest creation, and webhook configuration.
+
+## Installation
+
+```bash
+openclaw plugins install @openclaw/msteams
+```
+
+Configuration is stored in `~/.openclaw/openclaw.json`.
+
+## Key Setup Requirements
+
+### Essential Credentials
+
+- App ID and client secret from Azure Bot registration
+- Tenant ID (single-tenant recommended)
+- Webhook exposure via public URL or tunnel (port 3978 default)
+
+## Access Control Defaults
+
+- **DMs**: Use a "pairing" policy by default, requiring approval for unknown senders
+- **Group chats and channels**: Default to "allowlist" mode - blocked unless explicitly configured
+
+Configuration options support both user IDs and display names.
+
+## Technical Capabilities
+
+### What Works Without Graph API
+
+- Real-time text messaging via webhook
+- Personal DM file attachments
+- Channel message receiving (RSC permissions only)
+
+### What Requires Microsoft Graph Permissions
+
+- Channel/group image and file downloads
+- Message history retrieval
+- Per-user file sharing links
+
+## Limitations
+
+- Teams markdown support is more limited than Slack or Discord
+- Complex formatting may render incorrectly
+- Webhook timeouts can cause duplicate processing if LLM responses exceed Teams' timeout threshold
+- Private channels have inconsistent bot support across Microsoft's infrastructure
+
+## File Sharing Architecture
+
+### DMs
+
+Use the built-in FileConsentCard flow.
+
+### Group Chats and Channels
+
+Require SharePoint site integration with Graph API permissions (`Sites.ReadWrite.All`). Files upload to `/OpenClawShared/` within the configured SharePoint site.
+
+## Configuration Flexibility
+
+The system supports per-team and per-channel overrides for:
+
+- Reply style
+- Mention requirements
+- Tool policies
+
+Reply style configuration addresses Teams' dual UI paradigms (Posts vs. Threads), with "thread" as the default setting.

openclaw-knowhow-skill/docs/channels/signal.md

@@ -0,0 +1,194 @@
+# Signal
+
+## Signal (signal-cli)
+
+**Status:** External CLI integration. Gateway talks to `signal-cli` over HTTP JSON-RPC + SSE.
+
+## Quick Setup (Beginner)
+
+1. Use a **separate Signal number** for the bot (recommended)
+2. Install `signal-cli` (Java required)
+3. Link the bot device and start the daemon:
+   - `signal-cli link -n "OpenClaw"`
+4. Configure OpenClaw and start the gateway
+
+**Minimal config:**
+
+```json5
+{
+  channels: {
+    signal: {
+      enabled: true,
+      account: "+15551234567",
+      cliPath: "signal-cli",
+      dmPolicy: "pairing",
+      allowFrom: ["+15557654321"],
+    },
+  },
+}
+```
+
+## What It Is
+
+- Signal channel via `signal-cli` (not embedded libsignal)
+- Deterministic routing: replies always go back to Signal
+- DMs share the agent's main session; groups are isolated (`agent:<agentId>:signal:group:<groupId>`)
+
+## Config Writes
+
+By default, Signal is allowed to write config updates triggered by `/config set|unset` (requires `commands.config: true`).
+
+Disable with:
+
+```json5
+{
+  channels: { signal: { configWrites: false } },
+}
+```
+
+## The Number Model (Important)
+
+- The gateway connects to a **Signal device** (the `signal-cli` account)
+- If you run the bot on **your personal Signal account**, it will ignore your own messages (loop protection)
+- For "I text the bot and it replies," use a **separate bot number**
+
+## Setup (Fast Path)
+
+1. Install `signal-cli` (Java required)
+2. Link a bot account:
+   - `signal-cli link -n "OpenClaw"` then scan the QR in Signal
+3. Configure Signal and start the gateway
+
+**Example:**
+
+```json5
+{
+  channels: {
+    signal: {
+      enabled: true,
+      account: "+15551234567",
+      cliPath: "signal-cli",
+      dmPolicy: "pairing",
+      allowFrom: ["+15557654321"],
+    },
+  },
+}
+```
+
+Multi-account support: use `channels.signal.accounts` with per-account config and optional `name`.
+
+## External Daemon Mode (httpUrl)
+
+If you want to manage `signal-cli` yourself (slow JVM cold starts, container init, or shared CPUs), run the daemon separately and point OpenClaw at it:
+
+```json5
+{
+  channels: {
+    signal: {
+      httpUrl: "http://127.0.0.1:8080",
+      autoStart: false,
+    },
+  },
+}
+```
+
+This skips auto-spawn and the startup wait inside OpenClaw. For slow starts when auto-spawning, set `channels.signal.startupTimeoutMs`.
+
+## Access Control (DMs + Groups)
+
+### DMs
+
+- Default: `channels.signal.dmPolicy = "pairing"`
+- Unknown senders receive a pairing code; messages are ignored until approved (codes expire after 1 hour)
+- Approve via:
+  - `openclaw pairing list signal`
+  - `openclaw pairing approve signal <CODE>`
+- UUID-only senders (from `sourceUuid`) are stored as `uuid:<id>` in `channels.signal.allowFrom`
+
+### Groups
+
+- `channels.signal.groupPolicy = open | allowlist | disabled`
+- `channels.signal.groupAllowFrom` controls who can trigger in groups when `allowlist` is set
+
+## How It Works (Behavior)
+
+- `signal-cli` runs as a daemon; the gateway reads events via SSE
+- Inbound messages are normalized into the shared channel envelope
+- Replies always route back to the same number or group
+
+## Media + Limits
+
+- Outbound text is chunked to `channels.signal.textChunkLimit` (default 4000)
+- Optional newline chunking: set `channels.signal.chunkMode="newline"` to split on blank lines (paragraph boundaries) before length chunking
+- Attachments supported (base64 fetched from `signal-cli`)
+- Default media cap: `channels.signal.mediaMaxMb` (default 8)
+- Use `channels.signal.ignoreAttachments` to skip downloading media
+- Group history context uses `channels.signal.historyLimit` (or `channels.signal.accounts.*.historyLimit`), falling back to `messages.groupChat.historyLimit`. Set `0` to disable (default 50)
+
+## Typing + Read Receipts
+
+- **Typing indicators**: OpenClaw sends typing signals via `signal-cli sendTyping` and refreshes them while a reply is running
+- **Read receipts**: when `channels.signal.sendReadReceipts` is true, OpenClaw forwards read receipts for allowed DMs
+- Signal-cli does not expose read receipts for groups
+
+## Reactions (Message Tool)
+
+Use `message action=react` with `channel=signal`.
+
+- Targets: sender E.164 or UUID (use `uuid:<id>` from pairing output; bare UUID works too)
+- `messageId` is the Signal timestamp for the message you're reacting to
+- Group reactions require `targetAuthor` or `targetAuthorUuid`
+
+**Examples:**
+
+```
+message action=react channel=signal target=uuid:123e4567-e89b-12d3-a456-426614174000 messageId=1737630212345 emoji=🔥
+message action=react channel=signal target=+15551234567 messageId=1737630212345 emoji=🔥 remove=true
+message action=react channel=signal target=signal:group:<groupId> targetAuthor=uuid:<sender-uuid> messageId=1737630212345 emoji=✅
+```
+
+**Config:**
+
+- `channels.signal.actions.reactions`: enable/disable reaction actions (default true)
+- `channels.signal.reactionLevel`: `off | ack | minimal | extensive`
+  - `off`/`ack` disables agent reactions (message tool `react` will error)
+  - `minimal`/`extensive` enables agent reactions and sets the guidance level
+- Per-account overrides: `channels.signal.accounts.<id>.actions.reactions`, `channels.signal.accounts.<id>.reactionLevel`
+
+## Delivery Targets (CLI/cron)
+
+- DMs: `signal:+15551234567` (or plain E.164)
+- UUID DMs: `uuid:<id>` (or bare UUID)
+- Groups: `signal:group:<groupId>`
+- Usernames: `username:<name>` (if supported by your Signal account)
+
+## Configuration Reference (Signal)
+
+### Provider Options
+
+- `channels.signal.enabled`: enable/disable channel startup
+- `channels.signal.account`: E.164 for the bot account
+- `channels.signal.cliPath`: path to `signal-cli`
+- `channels.signal.httpUrl`: full daemon URL (overrides host/port)
+- `channels.signal.httpHost`, `channels.signal.httpPort`: daemon bind (default 127.0.0.1:8080)
+- `channels.signal.autoStart`: auto-spawn daemon (default true if `httpUrl` unset)
+- `channels.signal.startupTimeoutMs`: startup wait timeout in ms (cap 120000)
+- `channels.signal.receiveMode`: `on-start | manual`
+- `channels.signal.ignoreAttachments`: skip attachment downloads
+- `channels.signal.ignoreStories`: ignore stories from the daemon
+- `channels.signal.sendReadReceipts`: forward read receipts
+- `channels.signal.dmPolicy`: `pairing | allowlist | open | disabled` (default: pairing)
+- `channels.signal.allowFrom`: DM allowlist (E.164 or `uuid:<id>`). `open` requires `"*"`. Signal has no usernames; use phone/UUID ids
+- `channels.signal.groupPolicy`: `open | allowlist | disabled` (default: allowlist)
+- `channels.signal.groupAllowFrom`: group sender allowlist
+- `channels.signal.historyLimit`: max group messages to include as context (0 disables)
+- `channels.signal.dmHistoryLimit`: DM history limit in user turns. Per-user overrides: `channels.signal.dms["<phone_or_uuid>"].historyLimit`
+- `channels.signal.textChunkLimit`: outbound chunk size (chars)
+- `channels.signal.chunkMode`: `length` (default) or `newline` to split on blank lines (paragraph boundaries) before length chunking
+- `channels.signal.mediaMaxMb`: inbound/outbound media cap (MB)
+
+### Related Global Options
+
+- `agents.list[].groupChat.mentionPatterns` (Signal does not support native mentions)
+- `messages.groupChat.mentionPatterns` (global fallback)
+- `messages.responsePrefix`

openclaw-knowhow-skill/docs/channels/slack.md

@@ -0,0 +1,48 @@
+# Slack Integration
+
+## Overview
+
+OpenClaw's Slack integration supports both Socket Mode (default) and HTTP webhook modes for server deployments.
+
+## Setup Methods
+
+### Socket Mode (Default)
+
+- Requires App Token (`xapp-...`) and Bot Token (`xoxb-...`)
+- Minimal configuration involves enabling Socket Mode in Slack app settings and generating tokens
+- Supports optional User Token (`xoxp-...`) for read operations like history and reactions
+
+### HTTP Mode
+
+- Alternative for server deployments with HTTPS accessibility
+- Uses Events API, Interactivity, and Slash Commands via shared webhook URL
+- Requires Signing Secret and Bot Token configuration
+
+## Configuration Options
+
+The system allows per-channel customization including:
+
+- User allowlists and skill filtering
+- Custom system prompts per channel
+- Bot message handling preferences
+- Tool action gating (reactions, messages, pins, member info, emoji)
+
+## Threading Options
+
+Three reply modes control message threading behavior:
+
+- **off** (default): replies in main channel unless message is already threaded
+- **first**: initial reply threads, subsequent replies appear in main channel
+- **all**: all replies use threading
+
+Per-chat-type overrides enable different behaviors for direct messages, group chats, and channels.
+
+## Security Considerations
+
+Writes default to the bot token so state-changing actions stay scoped to the app's bot permissions. User token writes require explicit opt-in and should be carefully gated.
+
+Multi-bot environments need protective measures against reply loops.
+
+## DM Protection
+
+Pairing mode (default) requires unknown senders to exchange approval codes, with configurable allowlists for trusted users or open access alternatives.

openclaw-knowhow-skill/docs/channels/telegram.md

@@ -0,0 +1,74 @@
+# Telegram Bot API Integration
+
+## Overview
+
+OpenClaw's Telegram channel supports bot communication via the Bot API, with long-polling as the default delivery mechanism. The system handles both direct messages and group conversations with distinct session isolation.
+
+## Setup Steps
+
+1. **Create a bot token** through @BotFather on Telegram
+2. **Configure the token** via environment variable (`TELEGRAM_BOT_TOKEN`) or config file (`channels.telegram.botToken`)
+3. **Start the gateway** - Telegram initialization occurs automatically when a valid token resolves
+4. **Approve pairings** for DM access (default behavior requires code confirmation)
+
+## Core Capabilities
+
+### Message Handling
+
+- DM conversations share the agent's main session
+- Group messages remain isolated with session keys formatted as `agent:<agentId>:telegram:group:<chatId>`
+- Replies deterministically route back through Telegram; the model cannot select alternative channels
+
+### Formatting & Media
+
+- Outbound text uses Telegram-safe HTML rendering (bold, italic, strikethrough, code, links)
+- Markdown input is automatically converted; raw HTML from models is escaped
+- Audio distinguishes between voice notes and file attachments
+- Static stickers (WEBP) are processed through vision with description caching
+
+### Advanced Features
+
+- Draft streaming in private chats with forum topics enabled
+- Inline keyboard buttons with callback data support
+- Reaction notifications and agent-initiated reactions
+- Forum topic threading with isolated configuration per thread
+
+## Group Configuration
+
+By default, bots only respond to direct mentions. Configure group behavior through `channels.telegram.groups`:
+
+```json5
+// Allowlist all groups with always-respond mode:
+{
+  "groups": { "*": { "requireMention": false } }
+}
+```
+
+**Important:** Setting `channels.telegram.groups` creates an allowlist - only listed groups or wildcard entries are accepted.
+
+### Two-Level Access Control
+
+- **Group allowlist** via configuration (which groups are permitted)
+- **Sender filtering** via `groupPolicy` (open, allowlist, or disabled)
+
+## Privacy & Permissions
+
+Telegram's default Privacy Mode restricts message visibility. To receive all group messages, either:
+
+- Disable privacy mode via `/setprivacy` at BotFather (then remove/re-add bot to groups)
+- Promote the bot to group admin status
+
+## Limitations
+
+- Outbound text is chunked to `channels.telegram.textChunkLimit` (default 4000) with optional paragraph-boundary splitting via `chunkMode="newline"`
+- Media uploads/downloads cap at `mediaMaxMb` (default 5MB)
+- Telegram Bot API does not support read receipts
+
+## Troubleshooting
+
+Common issues stem from:
+
+- IPv6 routing failures to `api.telegram.org` (force IPv4 or enable IPv6 egress)
+- Privacy Mode preventing group visibility (confirm via `/setprivacy`)
+- Missing group allowlist entries when `channels.telegram.groups` is configured
+- Authorization failures for command execution (pairing or `allowFrom` required)

openclaw-knowhow-skill/docs/channels/troubleshooting.md

@@ -0,0 +1,40 @@
+# Channel Troubleshooting
+
+## Overview
+
+This guide provides diagnostic guidance for resolving channel configuration issues in OpenClaw.
+
+## Diagnostic Commands
+
+Start with these commands:
+
+```bash
+openclaw doctor
+openclaw channels status --probe
+```
+
+The `channels status --probe` command prints warnings when it can detect common channel misconfigurations, and includes small live checks (credentials, some permissions/membership).
+
+## Supported Channels
+
+Three primary channels have dedicated troubleshooting sections:
+
+- Discord
+- Telegram
+- WhatsApp
+
+## Telegram-Specific Solutions
+
+### Network Request Failures
+
+IPv6 DNS problems may cause `HttpError` messages for 'sendMessage' or 'sendChatAction'.
+
+**Solution:** Force IPv4 or enable IPv6 support.
+
+### Command Configuration Issues
+
+When `setMyCommands failed` appears in logs, verify outbound HTTPS and DNS reachability to `api.telegram.org`. This frequently fails on restricted VPS environments or proxy setups.
+
+## Additional Resources
+
+See the complete documentation index at https://docs.openclaw.ai/llms.txt for discovering additional resources.

openclaw-knowhow-skill/docs/channels/whatsapp.md

@@ -0,0 +1,68 @@
+# WhatsApp Channel
+
+## Overview
+
+OpenClaw's WhatsApp integration via Baileys where the gateway owns the session(s). The setup enables multiple WhatsApp accounts within a single gateway process with deterministic message routing.
+
+## Quick Start
+
+Requirements:
+
+- A separate phone number (recommended)
+- Configuration in `~/.openclaw/openclaw.json`
+- Running `openclaw channels login` to scan a QR code
+- An active listener for sending messages
+
+## Operating Modes
+
+### Dedicated Number Approach (Preferred)
+
+Use a separate device with an eSIM to keep operations isolated from personal contacts. This avoids "self-chat quirks" and provides cleaner routing.
+
+### Personal Number Fallback
+
+Run OpenClaw on your own WhatsApp account by enabling `selfChatMode`, though this requires messaging yourself to test without spamming contacts.
+
+## Access Control
+
+The platform implements a pairing-based gating system for unknown senders. The first direct message from a new sender returns a short code (message is not processed). Users then approve access using:
+
+```bash
+openclaw pairing approve whatsapp <code>
+```
+
+Codes expire after one hour, with a maximum of three pending requests per channel.
+
+## Message Handling
+
+### Quoted Replies
+
+Include full context, appended as `[Replying to +1555 id:ABC123]` followed by the quoted content.
+
+### Media-Only Messages
+
+Use placeholders like `<media:image|video|audio|document|sticker>`.
+
+## Groups & History
+
+- Group messages require mentions or regex matching by default
+- Recent unprocessed messages (up to 50) are injected for context
+- Context messages are labeled with sender information and marked as "for context" to distinguish them from current messages
+
+## Acknowledgment Reactions
+
+Emoji reactions provide immediate receipt feedback before bot replies generate. Configuration allows customizing the emoji and limiting reactions to:
+
+- Direct chats
+- Group mentions
+- All group messages
+
+## Technical Limits
+
+| Limit | Default |
+|-------|---------|
+| Outbound text | 4,000 character chunks (configurable) |
+| Inbound media | 50 MB default cap |
+| Outbound media | 5 MB per item default |
+
+Images auto-optimize to JPEG within limits.

openclaw-knowhow-skill/docs/channels/zalo.md

@@ -0,0 +1,57 @@
+# Zalo Bot Integration
+
+## Overview
+
+Zalo is a Vietnam-focused messaging platform with Bot API support. This documentation describes setting up a Zalo bot channel for direct messaging through OpenClaw's gateway system.
+
+## Setup Steps
+
+1. **Install the plugin:**
+
+```bash
+openclaw plugins install @openclaw/zalo
+```
+
+2. **Configure bot token** via environment variable (`ZALO_BOT_TOKEN`) or config file
+
+3. **Restart the gateway** to activate the channel
+
+## Core Capabilities
+
+The integration supports:
+
+- **Direct messages** only (groups "coming soon" per Zalo documentation)
+- **Text messages** with 2000-character chunking
+- **Image handling** for inbound/outbound media
+- **Deterministic routing** ensuring replies return to Zalo
+
+## Access Control
+
+By default, unknown senders receive a pairing code that expires after one hour. Approval is managed through CLI commands:
+
+```bash
+openclaw pairing approve zalo <CODE>
+```
+
+Alternative policies include allowlisting specific user IDs.
+
+## Technical Constraints
+
+- The 2000-character output limit makes streaming blocked by default since it reduces practical utility
+- Media uploads and downloads are capped at 5 MB by default
+- Stickers and unsupported message types are logged but not processed
+
+## Deployment Options
+
+The channel supports two modes (mutually exclusive per Zalo API specifications):
+
+### Long-Polling (Default)
+
+No additional configuration required.
+
+### Webhook Mode
+
+Requires:
+
+- HTTPS endpoint
+- A secret token between 8-256 characters

openclaw-knowhow-skill/docs/channels/zalouser.md

@@ -0,0 +1,75 @@
+# Zalo Personal Integration
+
+## Overview
+
+This documentation describes an experimental, unofficial integration for automating personal Zalo accounts through the OpenClaw platform using `zca-cli`.
+
+**Warning:** This integration is unofficial and carries account suspension risks.
+
+## Setup Steps
+
+### 1. Plugin Installation
+
+```bash
+openclaw plugins install @openclaw/zalouser
+```
+
+### 2. Authentication
+
+Login using QR code scanning with the Zalo mobile app:
+
+```bash
+openclaw channels login --channel zalouser
+```
+
+### 3. Configuration
+
+Enable the channel with settings like:
+
+```json5
+{
+  channels: {
+    zalouser: {
+      enabled: true,
+      dmPolicy: "pairing"
+    }
+  }
+}
+```
+
+## Core Capabilities
+
+The integration leverages `zca listen` to receive messages and `zca msg` commands for sending text, media, and links. It's designed for personal account scenarios where the official Zalo Bot API isn't available.
+
+## Limitations
+
+- Text messages are chunked to approximately 2000 characters
+- Streaming functionality is disabled by default
+- The integration is unofficial and carries account suspension risks
+
+## Access Management
+
+### DM Policies
+
+- pairing
+- allowlist
+- open
+- disabled
+
+### Group Access
+
+- open
+- allowlist (restricted)
+- disabled
+
+The platform includes pairing approval workflows and multi-account support through zca profiles.
+
+## Troubleshooting
+
+### Missing `zca` Binary
+
+Ensure the `zca` binary is available on the system PATH.
+
+### Login Persistence Problems
+
+Re-authenticate if sessions expire or become invalid.