@clawling/clawchat-plugin-openclaw 2026.9.11-1 → 2026.9.13-2

package/openclaw.plugin.json

@@ -138,6 +138,81 @@
           "timeout": { "type": "integer", "minimum": 100 },
           "autoResendOnTimeout": { "type": "boolean" }
         }
+      },
+      "defaultAccount": { "type": "string" },
+      "accounts": {
+        "type": "object",
+        "additionalProperties": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "enabled": { "type": "boolean" },
+            "websocketUrl": { "type": "string" },
+            "baseUrl": { "type": "string" },
+            "mediaBaseUrl": { "type": "string" },
+            "token": { "type": "string" },
+            "refreshToken": { "type": "string" },
+            "agentId": { "type": "string" },
+            "userId": { "type": "string" },
+            "ownerUserId": { "type": "string" },
+            "outputVisibility": { "type": "string", "enum": ["minimal", "normal", "full"] },
+            "chats": {
+              "type": "object",
+              "additionalProperties": {
+                "type": "object",
+                "additionalProperties": false,
+                "properties": {
+                  "outputVisibility": { "type": "string", "enum": ["minimal", "normal", "full"] }
+                }
+              }
+            },
+            "groupMode": { "type": "string", "enum": ["mention", "all"] },
+            "groupCommandMode": { "type": "string", "enum": ["owner", "all", "off"] },
+            "groups": {
+              "type": "object",
+              "additionalProperties": {
+                "type": "object",
+                "additionalProperties": false,
+                "properties": {
+                  "groupMode": { "type": "string", "enum": ["mention", "all"] },
+                  "groupCommandMode": { "type": "string", "enum": ["owner", "all", "off"] },
+                  "outputVisibility": { "type": "string", "enum": ["minimal", "normal", "full"] }
+                }
+              }
+            },
+            "forwardThinking": { "type": "boolean" },
+            "forwardToolCalls": { "type": "boolean" },
+            "richInteractions": { "type": "boolean" },
+            "awarenessNote": { "type": "boolean" },
+            "livewareSample": { "type": "boolean" },
+            "reconnect": {
+              "type": "object",
+              "additionalProperties": false,
+              "properties": {
+                "initialDelay": { "type": "integer", "minimum": 100 },
+                "maxDelay": { "type": "integer", "minimum": 100 },
+                "jitterRatio": { "type": "number", "minimum": 0 },
+                "maxRetries": { "type": "integer", "minimum": 0 }
+              }
+            },
+            "heartbeat": {
+              "type": "object",
+              "additionalProperties": false,
+              "properties": {
+                "interval": { "type": "integer", "minimum": 1000 },
+                "timeout": { "type": "integer", "minimum": 1000 }
+              }
+            },
+            "ack": {
+              "type": "object",
+              "additionalProperties": false,
+              "properties": {
+                "timeout": { "type": "integer", "minimum": 100 },
+                "autoResendOnTimeout": { "type": "boolean" }
+              }
+            }
+          }
+        }
       }
     }
   },
@@ -213,6 +288,81 @@
               "timeout": { "type": "integer", "minimum": 100 },
               "autoResendOnTimeout": { "type": "boolean" }
             }
+          },
+          "defaultAccount": { "type": "string" },
+          "accounts": {
+            "type": "object",
+            "additionalProperties": {
+              "type": "object",
+              "additionalProperties": false,
+              "properties": {
+                "enabled": { "type": "boolean" },
+                "websocketUrl": { "type": "string" },
+                "baseUrl": { "type": "string" },
+                "mediaBaseUrl": { "type": "string" },
+                "token": { "type": "string" },
+                "refreshToken": { "type": "string" },
+                "agentId": { "type": "string" },
+                "userId": { "type": "string" },
+                "ownerUserId": { "type": "string" },
+                "outputVisibility": { "type": "string", "enum": ["minimal", "normal", "full"] },
+                "chats": {
+                  "type": "object",
+                  "additionalProperties": {
+                    "type": "object",
+                    "additionalProperties": false,
+                    "properties": {
+                      "outputVisibility": { "type": "string", "enum": ["minimal", "normal", "full"] }
+                    }
+                  }
+                },
+                "groupMode": { "type": "string", "enum": ["mention", "all"] },
+                "groupCommandMode": { "type": "string", "enum": ["owner", "all", "off"] },
+                "groups": {
+                  "type": "object",
+                  "additionalProperties": {
+                    "type": "object",
+                    "additionalProperties": false,
+                    "properties": {
+                      "groupMode": { "type": "string", "enum": ["mention", "all"] },
+                      "groupCommandMode": { "type": "string", "enum": ["owner", "all", "off"] },
+                      "outputVisibility": { "type": "string", "enum": ["minimal", "normal", "full"] }
+                    }
+                  }
+                },
+                "forwardThinking": { "type": "boolean" },
+                "forwardToolCalls": { "type": "boolean" },
+                "richInteractions": { "type": "boolean" },
+                "awarenessNote": { "type": "boolean" },
+                "livewareSample": { "type": "boolean" },
+                "reconnect": {
+                  "type": "object",
+                  "additionalProperties": false,
+                  "properties": {
+                    "initialDelay": { "type": "integer", "minimum": 100 },
+                    "maxDelay": { "type": "integer", "minimum": 100 },
+                    "jitterRatio": { "type": "number", "minimum": 0 },
+                    "maxRetries": { "type": "integer", "minimum": 0 }
+                  }
+                },
+                "heartbeat": {
+                  "type": "object",
+                  "additionalProperties": false,
+                  "properties": {
+                    "interval": { "type": "integer", "minimum": 1000 },
+                    "timeout": { "type": "integer", "minimum": 1000 }
+                  }
+                },
+                "ack": {
+                  "type": "object",
+                  "additionalProperties": false,
+                  "properties": {
+                    "timeout": { "type": "integer", "minimum": 100 },
+                    "autoResendOnTimeout": { "type": "boolean" }
+                  }
+                }
+              }
+            }
           }
         }
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawling/clawchat-plugin-openclaw",
-  "version": "2026.9.11-1",
+  "version": "2026.9.13-2",
   "description": "OpenClaw ClawChat channel plugin",
   "license": "MIT",
   "author": "CLAWLING PTE. LTD.",

package/src/account-config-writes.ts

@@ -0,0 +1,74 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/setup";
+import { CHANNEL_ID, normalizeOpenclawClawlingAccountId } from "./config.ts";
+
+function readRecord(value: unknown): Record<string, unknown> {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : {};
+}
+
+function findAccountKey(accounts: Record<string, unknown>, accountId: string): string | undefined {
+  return Object.keys(accounts).find((key) => normalizeOpenclawClawlingAccountId(key) === accountId);
+}
+
+function applyPatch(target: Record<string, unknown>, patch: Record<string, unknown>): Record<string, unknown> {
+  const next: Record<string, unknown> = { ...target };
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === undefined) delete next[key];
+    else next[key] = value;
+  }
+  return next;
+}
+
+/**
+ * Dotted config path of the slot {@link patchOpenclawClawlingAccountSection}
+ * writes `accountId` into, for operator-facing logs. Default:
+ * `channels.<channel>` — or `channels.<channel>.accounts.default` once the
+ * host's single-account promotion created that entry. Named:
+ * `channels.<channel>.accounts.<key>` with the existing key spelling.
+ */
+export function openclawClawlingAccountSlotPath(cfg: OpenClawConfig, accountId?: string | null): string {
+  const id = normalizeOpenclawClawlingAccountId(accountId);
+  const section = readRecord(readRecord((cfg as { channels?: unknown }).channels)[CHANNEL_ID]);
+  const key = findAccountKey(readRecord(section.accounts), id);
+  const base = `channels.${CHANNEL_ID}`;
+  if (key !== undefined) return `${base}.accounts.${key}`;
+  return id === DEFAULT_ACCOUNT_ID ? base : `${base}.accounts.${id}`;
+}
+
+/**
+ * The single config write point. Pure. Default → root section (or
+ * `accounts.default` when that entry exists, so a host-promoted token is never
+ * shadowed by a stale copy); named → `accounts.<id>` keeping the existing key
+ * spelling. A patch value of `undefined` deletes the key. `enabled` is only
+ * touched when the patch carries it.
+ */
+export function patchOpenclawClawlingAccountSection(
+  cfg: OpenClawConfig,
+  accountId: string | null | undefined,
+  patch: Record<string, unknown>,
+): OpenClawConfig {
+  const id = normalizeOpenclawClawlingAccountId(accountId);
+  const channels = readRecord((cfg as { channels?: unknown }).channels);
+  const section = readRecord(channels[CHANNEL_ID]);
+  const accounts = readRecord(section.accounts);
+  const existingKey = findAccountKey(accounts, id);
+  if (id === DEFAULT_ACCOUNT_ID && existingKey === undefined) {
+    return {
+      ...cfg,
+      channels: { ...channels, [CHANNEL_ID]: applyPatch(section, patch) },
+    } as OpenClawConfig;
+  }
+  const key = existingKey ?? id;
+  return {
+    ...cfg,
+    channels: {
+      ...channels,
+      [CHANNEL_ID]: {
+        ...section,
+        accounts: { ...accounts, [key]: applyPatch(readRecord(accounts[key]), patch) },
+      },
+    },
+  } as OpenClawConfig;
+}

package/src/account-removal.ts

@@ -0,0 +1,52 @@
+import fs from "node:fs";
+import { normalizeOpenclawClawlingAccountId } from "./config.ts";
+import { livewareNamedAccountRootDir } from "./liveware-cli.ts";
+import type { ClawChatStore } from "./storage.ts";
+
+/**
+ * `openclaw channels remove --account <id> [--delete]` — the host has already
+ * rewritten the config (hybrid adapter) and stopped the account. Blank that
+ * account's SQLite credentials so a later start of the same id cannot resume
+ * the old identity from the row. Identity columns are kept (re-pair mode).
+ *
+ * A NAMED account also owns a private liveware root
+ * (`<stateDir>/clawchat/accounts/<id>/`: the CLI home holding the
+ * `$HOME/.clawling` login session, and the sample tree); the whole root is
+ * removed so the identity does not linger on disk. The `default` account's
+ * paths are the shared pre-multi-account layout and are never touched here.
+ * The host stops the account before this hook (best effort), so a still-open
+ * file only costs a log line.
+ */
+export function clearOpenclawClawlingAccountOnRemoval(params: {
+  accountId: string;
+  store: Pick<ClawChatStore, "clearActivationCredentials"> | null;
+  /** Resolved OpenClaw state dir; absent → liveware directories are left alone. */
+  stateDir?: string | null;
+  log?: (message: string) => void;
+  rmFn?: (dir: string) => void;
+}): void {
+  const accountId = normalizeOpenclawClawlingAccountId(params.accountId);
+  if (!params.store) {
+    params.log?.(`[${accountId}] clawchat-plugin-openclaw account removed; sqlite unavailable, nothing to clear`);
+  } else {
+    try {
+      params.store.clearActivationCredentials({ platform: "openclaw", accountId });
+      params.log?.(`[${accountId}] clawchat-plugin-openclaw account removed; sqlite credentials cleared`);
+    } catch (err) {
+      params.log?.(
+        `[${accountId}] clawchat-plugin-openclaw account removed; sqlite clear failed: ${err instanceof Error ? err.message : String(err)}`,
+      );
+    }
+  }
+  if (!params.stateDir) return;
+  const dir = livewareNamedAccountRootDir(params.stateDir, accountId);
+  if (dir === null) return;
+  const rm = params.rmFn ?? ((target: string) => fs.rmSync(target, { recursive: true, force: true }));
+  try {
+    rm(dir);
+  } catch (err) {
+    params.log?.(
+      `[${accountId}] clawchat-plugin-openclaw account removed; liveware directory ${dir} not removed: ${err instanceof Error ? err.message : String(err)}`,
+    );
+  }
+}

package/src/channel.setup.ts

@@ -1,7 +1,8 @@
-import { createTopLevelChannelConfigAdapter } from "openclaw/plugin-sdk/channel-config-helpers";
+import { createHybridChannelConfigAdapter } from "openclaw/plugin-sdk/channel-config-helpers";
 import type { ChannelSetupInput } from "openclaw/plugin-sdk/channel-setup";
 import type { ChannelPlugin, OpenClawConfig } from "openclaw/plugin-sdk/core";
 import { mutateConfigFile } from "openclaw/plugin-sdk/config-mutation";
+import { patchOpenclawClawlingAccountSection } from "./account-config-writes.ts";
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/setup";
 import {
   createComputedAccountStatusAdapter,
@@ -11,79 +12,121 @@ import {
   CHANNEL_ID,
   canStartOpenclawClawlingAccount,
   listOpenclawClawlingAccountIds,
+  normalizeOpenclawClawlingAccountId,
   openclawClawlingConfigSchema,
   resolveOpenclawClawlingAccount,
+  resolveOpenclawClawlingDefaultAccountId,
   type ResolvedOpenclawClawlingAccount,
 } from "./config.ts";
 import type { OpenclawClawchatMutateConfigFile } from "./login.runtime.ts";
 
-const configAdapter = createTopLevelChannelConfigAdapter<ResolvedOpenclawClawlingAccount>({
+/** Keys a `channels remove --account default --delete` clears from the section. */
+const CLEAR_BASE_FIELDS = [
+  "websocketUrl",
+  "baseUrl",
+  "token",
+  "refreshToken",
+  "agentId",
+  "userId",
+  "ownerUserId",
+  "forwardThinking",
+  "forwardToolCalls",
+  "richInteractions",
+  "enabled",
+] as const;
+
+/**
+ * Hybrid layout: the channel root IS the `default` account (and the
+ * inheritance base); named accounts live under `accounts.<id>`. The SDK
+ * adapter branches `setAccountEnabled` / `deleteAccount` on the id for us.
+ */
+const hybridConfigAdapter = createHybridChannelConfigAdapter<ResolvedOpenclawClawlingAccount>({
   sectionKey: CHANNEL_ID,
-  resolveAccount: (cfg) => resolveOpenclawClawlingAccount(cfg),
-  listAccountIds: () => listOpenclawClawlingAccountIds(),
-  defaultAccountId: () => DEFAULT_ACCOUNT_ID,
-  deleteMode: "clear-fields",
-  clearBaseFields: [
-    "websocketUrl",
-    "baseUrl",
-    "token",
-    "userId",
-    "forwardThinking",
-    "forwardToolCalls",
-    "richInteractions",
-    "enabled",
-  ],
+  resolveAccount: (cfg, accountId) => resolveOpenclawClawlingAccount(cfg, accountId),
+  listAccountIds: (cfg) => listOpenclawClawlingAccountIds(cfg),
+  defaultAccountId: (cfg) => resolveOpenclawClawlingDefaultAccountId(cfg),
+  preserveSectionOnDefaultDelete: true,
+  clearBaseFields: [...CLEAR_BASE_FIELDS],
   resolveAllowFrom: (account) => account.allowFrom,
   formatAllowFrom: () => [],
 });
 
+/** `{ token: undefined, refreshToken: undefined, … }` — `undefined` deletes. */
+const CLEAR_BASE_FIELDS_PATCH: Record<string, undefined> = Object.fromEntries(
+  CLEAR_BASE_FIELDS.map((key) => [key, undefined]),
+);
+
+const configAdapter: typeof hybridConfigAdapter = {
+  ...hybridConfigAdapter,
+  /**
+   * The SDK's default branch clears `clearBaseFields` from the ROOT only. Once
+   * the host's single-account promotion has moved the identity into
+   * `accounts.default`, that leaves the deleted default fully credentialed:
+   * the default reader merges the promoted entry back over the blanked root,
+   * `ownerUserId` returns via the token's `oid` claim, and the account resolves
+   * `configured: true` again on the next gateway start. Clear the same keys
+   * from the promoted entry so `--delete` actually deletes. Named ids are the
+   * SDK's alone — it removes the whole `accounts.<id>` entry.
+   *
+   * Guard: a config with no channel section has nothing to clear, and the
+   * patch write would otherwise materialize an empty section out of nothing.
+   */
+  deleteAccount: (args) => {
+    const next = hybridConfigAdapter.deleteAccount?.(args) ?? args.cfg;
+    if (normalizeOpenclawClawlingAccountId(args.accountId) !== DEFAULT_ACCOUNT_ID) return next;
+    if (!hasOpenclawClawlingChannelSection(next)) return next;
+    return patchOpenclawClawlingAccountSection(next, DEFAULT_ACCOUNT_ID, CLEAR_BASE_FIELDS_PATCH);
+  },
+};
+
+function hasOpenclawClawlingChannelSection(cfg: OpenClawConfig): boolean {
+  const section = (cfg as { channels?: Record<string, unknown> }).channels?.[CHANNEL_ID];
+  return Boolean(section) && typeof section === "object" && !Array.isArray(section);
+}
+
+function readInviteCode(input: ChannelSetupInput): string {
+  return typeof input.code === "string" && input.code.trim()
+    ? input.code.trim()
+    : typeof input.token === "string"
+      ? input.token.trim()
+      : "";
+}
+
 /**
  * Invite-code setup adapter used by OpenClaw setup surfaces.
  *
- * `channels add --token` passes the invite code as setup input. The setup
- * write leaves channel config unchanged; `afterAccountConfigWritten` exchanges
- * the invite code and persists token/userId through the host runtime mutator.
+ * `channels add [--account <id>] --token <code>` passes the invite code as
+ * setup input and the (optional) account id from the host. The setup write
+ * leaves channel config unchanged; `afterAccountConfigWritten` exchanges the
+ * invite code and persists credentials for THAT account through the host
+ * runtime mutator.
  */
 const setupAdapter: NonNullable<ChannelPlugin<ResolvedOpenclawClawlingAccount>["setup"]> = {
-  resolveAccountId: () => DEFAULT_ACCOUNT_ID,
-  validateInput: ({ input }: { cfg: OpenClawConfig; accountId: string; input: ChannelSetupInput }) => {
-    const inviteCode =
-      typeof input.code === "string" && input.code.trim()
-        ? input.code.trim()
-        : typeof input.token === "string"
-          ? input.token.trim()
-          : "";
-    if (!inviteCode) {
-      return "ClawChat invite code is required.";
-    }
-    return null;
-  },
+  resolveAccountId: ({ accountId }) => normalizeOpenclawClawlingAccountId(accountId),
+  validateInput: ({ input }: { cfg: OpenClawConfig; accountId: string; input: ChannelSetupInput }) =>
+    readInviteCode(input) ? null : "ClawChat invite code is required.",
   applyAccountConfig: ({ cfg }: {
     cfg: OpenClawConfig;
     accountId: string;
     input: ChannelSetupInput;
   }) => cfg,
-  afterAccountConfigWritten: async ({ cfg, input, runtime }) => {
-    runtime.log("[default] clawchat-plugin-openclaw setup afterAccountConfigWritten invoked");
-    const code =
-      typeof input.code === "string" && input.code.trim()
-        ? input.code.trim()
-        : typeof input.token === "string"
-          ? input.token.trim()
-          : "";
+  afterAccountConfigWritten: async ({ cfg, accountId, input, runtime }) => {
+    const id = normalizeOpenclawClawlingAccountId(accountId);
+    runtime.log(`[${id}] clawchat-plugin-openclaw setup afterAccountConfigWritten invoked`);
+    const code = readInviteCode(input);
     if (!code) {
-      runtime.log("[default] clawchat-plugin-openclaw setup afterAccountConfigWritten skipped: empty invite code");
+      runtime.log(`[${id}] clawchat-plugin-openclaw setup afterAccountConfigWritten skipped: empty invite code`);
       return;
     }
     const { runOpenclawClawlingLogin } = await import("./login.runtime.ts");
     await runOpenclawClawlingLogin({
       cfg,
-      accountId: null,
+      accountId: id,
       runtime: { log: (message: string) => runtime.log(message) },
       readInviteCode: async () => code,
       mutateConfigFile: mutateConfigFile as OpenclawClawchatMutateConfigFile,
     });
-    runtime.log("[default] clawchat-plugin-openclaw setup afterAccountConfigWritten completed");
+    runtime.log(`[${id}] clawchat-plugin-openclaw setup afterAccountConfigWritten completed`);
   },
 };
 

package/src/channel.ts

@@ -1,5 +1,6 @@
 import { createChatChannelPlugin, type ChannelPlugin } from "openclaw/plugin-sdk/core";
 import { createEmptyChannelDirectoryAdapter } from "openclaw/plugin-sdk/directory-runtime";
+import { clearOpenclawClawlingAccountOnRemoval } from "./account-removal.ts";
 import {
   CHANNEL_ID,
   canStartOpenclawClawlingAccount,
@@ -9,6 +10,7 @@ import {
 import type { OpenclawClawchatMutateConfigFile } from "./login.runtime.ts";
 import { openclawClawlingOutbound } from "./outbound.ts";
 import { getOpenclawClawlingRuntime, startOpenclawClawlingGateway } from "./runtime.ts";
+import { clawChatDbPathForStateDir, getClawChatStore } from "./storage.ts";
 import { openclawClawlingSetupPlugin } from "./channel.setup.ts";
 import { getClawChatPlatformPrompt } from "./plugin-prompts.ts";
 
@@ -33,9 +35,34 @@ export const openclawClawlingPlugin: ChannelPlugin<ResolvedOpenclawClawlingAccou
           });
         },
       },
+      lifecycle: {
+        onAccountRemoved: ({ accountId, runtime }) => {
+          let store: ReturnType<typeof getClawChatStore> | null = null;
+          let stateDir: string | undefined;
+          try {
+            stateDir = getOpenclawClawlingRuntime().state?.resolveStateDir?.();
+          } catch {
+            stateDir = undefined;
+          }
+          try {
+            store = getClawChatStore({
+              ...(stateDir ? { dbPath: clawChatDbPathForStateDir(stateDir) } : {}),
+              log: { error: (message: string) => runtime.error(message) },
+            });
+          } catch {
+            store = null;
+          }
+          clearOpenclawClawlingAccountOnRemoval({
+            accountId,
+            store,
+            stateDir,
+            log: (message) => runtime.log(message),
+          });
+        },
+      },
       gateway: {
         startAccount: async (ctx) => {
-          const account = ctx.account ?? resolveOpenclawClawlingAccount(ctx.cfg);
+          const account = ctx.account ?? resolveOpenclawClawlingAccount(ctx.cfg, ctx.accountId);
           ctx.log?.info?.(
             `[${account.accountId}] clawchat-plugin-openclaw lifecycle START_ACCOUNT_CALLED configured=${account.configured} enabled=${account.enabled} hasToken=${Boolean(account.token)} hasUserId=${Boolean(account.userId)} websocketUrl=${account.websocketUrl || "(empty)"}`,
           );

package/src/commands.ts

@@ -1,6 +1,12 @@
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
 import type { OpenClawConfig, PluginCommandContext } from "openclaw/plugin-sdk/core";
-import { CHANNEL_ID, type OutputVisibility } from "./config.ts";
+import { patchOpenclawClawlingAccountSection } from "./account-config-writes.ts";
+import {
+  CHANNEL_ID,
+  normalizeOpenclawClawlingAccountId,
+  readOpenclawClawlingAccountSection,
+  type OutputVisibility,
+} from "./config.ts";
 import type { OpenclawClawchatMutateConfigFile } from "./login.runtime.ts";
 
 /** Activation intent flags — the two escape hatches out of the live-activation guard. */
@@ -10,6 +16,32 @@ function stripActivationFlags(raw: string): string {
   return ACTIVATION_FLAGS.reduce((acc, flag) => acc.split(flag).join(" "), raw);
 }
 
+/** `--account <id>` / `--account=<id>`; the value is removed before the code scan so it can never be mistaken for a code. */
+const ACCOUNT_FLAG_PATTERN = /(?:^|\s)--account(?:=|\s+)(\S+)/u;
+/** `--account` with nothing after it — including a dangling `--account=`, which
+ * is a typo rather than "use the default account". */
+const BARE_ACCOUNT_FLAG_PATTERN = /(?:^|\s)--account=?(?=\s|$)/u;
+
+function extractAccountFlag(value: unknown): { accountId: string | null; rest: string; error: string | null } {
+  const raw = typeof value === "string" ? value : "";
+  const match = ACCOUNT_FLAG_PATTERN.exec(raw);
+  if (match) {
+    const id = match[1] ?? "";
+    if (!id || id.startsWith("--")) {
+      return { accountId: null, rest: raw, error: "--account requires an account id" };
+    }
+    return {
+      accountId: normalizeOpenclawClawlingAccountId(id),
+      rest: raw.replace(match[0], " "),
+      error: null,
+    };
+  }
+  if (BARE_ACCOUNT_FLAG_PATTERN.test(raw)) {
+    return { accountId: null, rest: raw, error: "--account requires an account id" };
+  }
+  return { accountId: null, rest: raw, error: null };
+}
+
 /**
  * A whole argument token that looks like a ClawChat connect code.
  *
@@ -95,29 +127,25 @@ function resolveCommandChatId(ctx: PluginCommandContext): string {
 
 function persistOutputVisibility(
   draft: OpenClawConfig,
+  accountId: string,
   chatId: string,
   outputVisibility: OutputVisibility,
 ): void {
-  const channels = readRecord((draft as { channels?: unknown }).channels);
-  const channel = readRecord(channels[CHANNEL_ID]);
-  const chats = readRecord(channel.chats);
+  // Seeded from the MERGED view, never the raw target entry: `mergeAccountConfig`
+  // REPLACES `chats` rather than deep-merging it, so a first write seeded from an
+  // entry that has no `chats` of its own (a named account, or a `default` the
+  // host has promoted into `accounts.default`) would shadow every inherited
+  // conversation. Copying the inherited map forward and overriding one key keeps
+  // the resolved view additive.
+  const merged = readOpenclawClawlingAccountSection(draft, accountId);
+  const chats = readRecord(merged.chats);
   const chat = readRecord(chats[chatId]);
-  Object.assign(draft, {
-    ...draft,
-    channels: {
-      ...channels,
-      [CHANNEL_ID]: {
-        ...channel,
-        chats: {
-          ...chats,
-          [chatId]: {
-            ...chat,
-            outputVisibility,
-          },
-        },
-      },
-    },
-  });
+  Object.assign(
+    draft,
+    patchOpenclawClawlingAccountSection(draft, accountId, {
+      chats: { ...chats, [chatId]: { ...chat, outputVisibility } },
+    }),
+  );
 }
 
 function formatOutputVisibilityResult(outputVisibility: OutputVisibility): string {
@@ -139,21 +167,26 @@ function formatOutputVisibilityResult(outputVisibility: OutputVisibility): strin
 export function registerOpenclawClawlingCommands(api: Pick<OpenClawPluginApi, "registerCommand" | "logger" | "runtime">): void {
   api.registerCommand({
     name: "clawchat-activate",
-    description: "Activate ClawChat with an invite code, e.g. /clawchat-activate K7RM4TQP.",
+    description: "Activate ClawChat with an invite code, e.g. /clawchat-activate K7RM4TQP [--account <id>].",
     acceptsArgs: true,
     requireAuth: true,
     async handler(ctx) {
       const rawArgs = ctx.args ?? ctx.commandBody;
-      const code = extractInviteCode(rawArgs);
+      const accountFlag = extractAccountFlag(rawArgs);
+      if (accountFlag.error) {
+        return { text: `${accountFlag.error}. Usage: /clawchat-activate K7RM4TQP [--account <id>]` };
+      }
+      const code = extractInviteCode(accountFlag.rest);
       if (!code) {
-        return { text: "ClawChat invite code is required. Usage: /clawchat-activate K7RM4TQP" };
+        return { text: "ClawChat invite code is required. Usage: /clawchat-activate K7RM4TQP [--account <id>]" };
       }
-      const intent = extractActivationIntent(rawArgs);
+      const intent = extractActivationIntent(accountFlag.rest);
+      const accountId = accountFlag.accountId ?? normalizeOpenclawClawlingAccountId(ctx.accountId);
       try {
         const { runOpenclawClawlingLogin } = await import("./login.runtime.ts");
         await runOpenclawClawlingLogin({
           cfg: ctx.config,
-          accountId: ctx.accountId ?? null,
+          accountId,
           runtime: { log: (message: string) => api.logger?.info?.(message) },
           readInviteCode: async () => code,
           mutateConfigFile: (api.runtime.config as unknown as {
@@ -189,10 +222,11 @@ export function registerOpenclawClawlingCommands(api: Pick<OpenClawPluginApi, "r
       if (!mutateConfigFile) {
         return { text: "OpenClaw runtime config mutation is unavailable for /clawchat-output." };
       }
+      const accountId = normalizeOpenclawClawlingAccountId(ctx.accountId);
       await mutateConfigFile({
         afterWrite: { mode: "auto" },
         mutate(draft) {
-          persistOutputVisibility(draft, chatId, outputVisibility);
+          persistOutputVisibility(draft, accountId, chatId, outputVisibility);
         },
       });
       return { text: formatOutputVisibilityResult(outputVisibility) };