@clawling/clawchat-plugin-openclaw 2026.10.8-2 → 2026.10.9-1

package/dist/src/dm-recall-default.js

@@ -0,0 +1,179 @@
+/**
+ * Turn off OpenClaw's cross-conversation recall for the agent ClawChat routes
+ * to, once, unless the owner already decided.
+ *
+ * OpenClaw >= 2026.8.1 has `memory.search.rememberAcrossConversations`. When it
+ * is not written anywhere, OpenClaw turns it on unless `session.dmScope` or a
+ * binding isolates DMs (`resolveRememberAcrossConversations`,
+ * packages/memory-host-sdk/src/host/config-utils.ts). The plugin isolates
+ * ClawChat DMs only in memory (`withClawChatSessionScope`), which OpenClaw
+ * cannot see, so recall stays on and a friend's DM can recall the owner's.
+ * Active Memory reads the live gateway config each turn, so a per-turn
+ * override does not reach it: the setting has to be in the config file.
+ *
+ * Where it is read (2026.8.1 / 2026.9.x): the agent's `agents.entries.<id>`
+ * or, when the roster is the legacy array, its `agents.list[]` entry (matched
+ * by `id`); then the global `memory.search`. With no roster in the file there
+ * is one implicit agent, so the global layer IS that agent's.
+ *
+ * Rules (relay openclaw-dm-recall, 10-08):
+ * - only on hosts >= 2026.8.1 (older ones have neither the key nor the recall);
+ * - only when neither layer sets it; an explicit `true` is the owner's choice:
+ *   kept, warned once; an explicit `false` is kept silently;
+ * - only once per agent: a marker in the plugin's state dir records it, so
+ *   whatever the owner changes later is never touched again.
+ */
+import fs from "node:fs";
+import path from "node:path";
+export const DM_RECALL_MARKER_FILENAME = "clawchat-dm-recall-default.json";
+export const DM_RECALL_MIN_HOST = [2026, 8, 1];
+function isRec(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeId(id) {
+    return typeof id === "string" ? id.trim().toLowerCase() : "";
+}
+/** True for a release host >= 2026.8.1. Pre-releases and unknown strings are false. */
+export function hostHasRememberAcrossConversations(version) {
+    const m = /^v?(\d+)\.(\d+)\.(\d+)$/.exec((version ?? "").trim());
+    if (!m)
+        return false;
+    const parts = [Number(m[1]), Number(m[2]), Number(m[3])];
+    for (let i = 0; i < 3; i += 1) {
+        if (parts[i] !== DM_RECALL_MIN_HOST[i])
+            return parts[i] > DM_RECALL_MIN_HOST[i];
+    }
+    return true;
+}
+function findAgentSlot(cfg, agentId) {
+    const agents = isRec(cfg.agents) ? cfg.agents : undefined;
+    const id = normalizeId(agentId);
+    if (agents && Object.hasOwn(agents, "entries") && agents.entries !== undefined) {
+        if (!isRec(agents.entries))
+            return { kind: "missing" };
+        for (const key of Object.keys(agents.entries)) {
+            const entry = agents.entries[key];
+            if (normalizeId(key) === id && isRec(entry))
+                return { kind: "entries", key, entry };
+        }
+        return { kind: "missing" };
+    }
+    if (agents && Object.hasOwn(agents, "list") && agents.list !== undefined) {
+        if (!Array.isArray(agents.list))
+            return { kind: "missing" };
+        const index = agents.list.findIndex((e) => isRec(e) && normalizeId(e.id) === id);
+        return index >= 0 ? { kind: "list", index, entry: agents.list[index] } : { kind: "missing" };
+    }
+    return { kind: "no-roster" };
+}
+function readFlag(holder) {
+    if (!isRec(holder) || !isRec(holder.memory) || !isRec(holder.memory.search))
+        return undefined;
+    const v = holder.memory.search.rememberAcrossConversations;
+    return typeof v === "boolean" ? v : undefined;
+}
+/** The value written at each layer, `undefined` where it is not written. */
+export function readRememberAcrossConversations(cfg, agentId) {
+    const slot = findAgentSlot(cfg, agentId);
+    const agent = slot.kind === "entries" || slot.kind === "list" ? readFlag(slot.entry) : undefined;
+    return { agent, global: readFlag(cfg) };
+}
+function setFlagFalse(holder) {
+    const memory = isRec(holder.memory) ? holder.memory : {};
+    const search = isRec(memory.search) ? memory.search : {};
+    holder.memory = { ...memory, search: { ...search, rememberAcrossConversations: false } };
+}
+/**
+ * Write `rememberAcrossConversations: false` at the agent's own layer of
+ * `cfg` (mutated in place). Returns the dotted path written, or `null` when a
+ * roster exists but does not list the agent (nothing written).
+ */
+export function setAgentRememberAcrossConversationsFalse(cfg, agentId) {
+    const slot = findAgentSlot(cfg, agentId);
+    if (slot.kind === "entries") {
+        setFlagFalse(slot.entry);
+        return `agents.entries.${slot.key}.memory.search`;
+    }
+    if (slot.kind === "list") {
+        setFlagFalse(slot.entry);
+        return `agents.list[${slot.index}].memory.search`;
+    }
+    if (slot.kind === "no-roster") {
+        setFlagFalse(cfg);
+        return "memory.search";
+    }
+    return null;
+}
+function readMarker(file) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+        return isRec(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function writeMarker(file, agentId, outcome) {
+    const marker = readMarker(file);
+    const agents = isRec(marker.agents) ? marker.agents : {};
+    agents[normalizeId(agentId)] = { outcome, at: new Date().toISOString() };
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify({ ...marker, agents }, null, 2)}\n`);
+}
+/** Apply the one-time default. Never throws. */
+export async function applyDmRecallDefault(params) {
+    const { agentId, log } = params;
+    const markerFile = path.join(params.stateDir, DM_RECALL_MARKER_FILENAME);
+    try {
+        if (readMarker(markerFile).agents?.[normalizeId(agentId)])
+            return "already-handled";
+        if (!hostHasRememberAcrossConversations(params.hostVersion))
+            return "unsupported-host";
+        const cfg = params.readConfig();
+        const current = readRememberAcrossConversations(isRec(cfg) ? cfg : {}, agentId);
+        const explicit = current.agent ?? current.global;
+        if (explicit === true) {
+            log?.warn?.(`clawchat-plugin-openclaw: memory.search.rememberAcrossConversations is true for agent '${agentId}', so a ` +
+                "friend's ClawChat direct chat can recall what the owner said in theirs. Kept as set. To turn it off: " +
+                `openclaw config set memory.search.rememberAcrossConversations false (or set it to false on agent '${agentId}'), then restart the gateway.`);
+            writeMarker(markerFile, agentId, "kept-true");
+            return "kept-true";
+        }
+        if (explicit === false) {
+            writeMarker(markerFile, agentId, "kept-false");
+            return "kept-false";
+        }
+        if (findAgentSlot(isRec(cfg) ? cfg : {}, agentId).kind === "missing") {
+            log?.info?.(`clawchat-plugin-openclaw: agent '${agentId}' is not in the agents roster; rememberAcrossConversations left unset`);
+            return "agent-not-in-roster";
+        }
+        let written = null;
+        let raced;
+        await params.mutateConfigFile({
+            afterWrite: { mode: "none", reason: "clawchat-plugin-openclaw: no recall across ClawChat direct chats" },
+            mutate(draft) {
+                // Re-check on the locked, current file: someone may have set it meanwhile.
+                const now = readRememberAcrossConversations(draft, agentId);
+                raced = now.agent ?? now.global;
+                if (raced !== undefined)
+                    return;
+                written = setAgentRememberAcrossConversationsFalse(draft, agentId);
+            },
+        });
+        if (written === null) {
+            if (raced === undefined)
+                return "agent-not-in-roster";
+            const outcome = raced ? "kept-true" : "kept-false";
+            writeMarker(markerFile, agentId, outcome);
+            return outcome;
+        }
+        writeMarker(markerFile, agentId, "wrote-false");
+        log?.info?.(`clawchat-plugin-openclaw: set ${written}.rememberAcrossConversations=false for agent '${agentId}' ` +
+            "(ClawChat direct chats with different people no longer recall each other)");
+        return "wrote-false";
+    }
+    catch (err) {
+        log?.error?.(`clawchat-plugin-openclaw: could not apply the rememberAcrossConversations default for agent '${agentId}': ${err instanceof Error ? err.message : String(err)}`);
+        return "write-failed";
+    }
+}

package/dist/src/runtime.js

@@ -1,3 +1,4 @@
+import { applyDmRecallDefault } from "./dm-recall-default.js";
 import { AckTimeoutError, AuthError, ProtocolError, StateError, TransportError, EVENT, recallTargetMessageId, } from "./protocol-types.js";
 import { waitUntilAbort } from "openclaw/plugin-sdk/channel-lifecycle";
 import { hasControlCommand } from "openclaw/plugin-sdk/command-detection";
@@ -937,6 +938,48 @@ export async function startOpenclawClawlingGateway(params) {
             ? runtimeConfig.mutateConfigFile
             : undefined;
     };
+    // OpenClaw >= 2026.8.1 recalls across a single agent's DMs unless DM isolation
+    // is visible in the gateway config; ours is in-memory only. Write the agent's
+    // `rememberAcrossConversations: false` once, unless the owner set it
+    // (dm-recall-default.ts). Fire-and-forget: never blocks or fails startup.
+    void (async () => {
+        const stateDir = runtime.state?.resolveStateDir?.();
+        const mutateConfigFile = resolveMutateConfigFile();
+        const readConfig = runtime.config?.current;
+        if (!stateDir || !mutateConfigFile || typeof readConfig !== "function")
+            return;
+        let agentId;
+        try {
+            agentId = runtime.channel.routing.resolveAgentRoute({
+                cfg: withClawChatSessionScope(cfg),
+                channel: CHANNEL_ID,
+                accountId,
+                peer: { kind: "direct", id: account.ownerUserId || "owner" },
+            }).agentId;
+        }
+        catch (err) {
+            log?.info?.(`[${accountId}] clawchat-plugin-openclaw rememberAcrossConversations default skipped: agent route unavailable (${err instanceof Error ? err.message : String(err)})`);
+            return;
+        }
+        await applyDmRecallDefault({
+            agentId,
+            hostVersion: runtime.version,
+            stateDir,
+            readConfig: () => readConfig.call(runtime.config),
+            mutateConfigFile: mutateConfigFile,
+            log: {
+                info: (m) => log?.info?.(`[${accountId}] ${m}`),
+                warn: (m) => {
+                    const warn = log?.warn;
+                    if (warn)
+                        warn(`[${accountId}] ${m}`);
+                    else
+                        log?.info?.(`[${accountId}] WARNING ${m}`);
+                },
+                error: (m) => log?.error?.(`[${accountId}] ${m}`),
+            },
+        });
+    })();
     // §0/§C.1 — write the account slot's `token`/`refreshToken` keys. `tokens=null`
     // blanks them (auto-logout); otherwise persists the rotated pair.
     const persistConfigTokens = async (tokens) => {

package/package.json

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

package/src/dm-recall-default.ts

@@ -0,0 +1,230 @@
+/**
+ * Turn off OpenClaw's cross-conversation recall for the agent ClawChat routes
+ * to, once, unless the owner already decided.
+ *
+ * OpenClaw >= 2026.8.1 has `memory.search.rememberAcrossConversations`. When it
+ * is not written anywhere, OpenClaw turns it on unless `session.dmScope` or a
+ * binding isolates DMs (`resolveRememberAcrossConversations`,
+ * packages/memory-host-sdk/src/host/config-utils.ts). The plugin isolates
+ * ClawChat DMs only in memory (`withClawChatSessionScope`), which OpenClaw
+ * cannot see, so recall stays on and a friend's DM can recall the owner's.
+ * Active Memory reads the live gateway config each turn, so a per-turn
+ * override does not reach it: the setting has to be in the config file.
+ *
+ * Where it is read (2026.8.1 / 2026.9.x): the agent's `agents.entries.<id>`
+ * or, when the roster is the legacy array, its `agents.list[]` entry (matched
+ * by `id`); then the global `memory.search`. With no roster in the file there
+ * is one implicit agent, so the global layer IS that agent's.
+ *
+ * Rules (relay openclaw-dm-recall, 10-08):
+ * - only on hosts >= 2026.8.1 (older ones have neither the key nor the recall);
+ * - only when neither layer sets it; an explicit `true` is the owner's choice:
+ *   kept, warned once; an explicit `false` is kept silently;
+ * - only once per agent: a marker in the plugin's state dir records it, so
+ *   whatever the owner changes later is never touched again.
+ */
+import fs from "node:fs";
+import path from "node:path";
+
+export const DM_RECALL_MARKER_FILENAME = "clawchat-dm-recall-default.json";
+export const DM_RECALL_MIN_HOST: readonly [number, number, number] = [2026, 8, 1];
+
+export type DmRecallOutcome =
+  | "wrote-false"
+  | "kept-true"
+  | "kept-false"
+  | "already-handled"
+  | "unsupported-host"
+  | "agent-not-in-roster"
+  | "write-failed";
+
+type Rec = Record<string, unknown>;
+
+type MutateConfigFile = (params: {
+  afterWrite: { mode: "none"; reason: string };
+  mutate: (draft: Rec) => void;
+}) => Promise<unknown>;
+
+type Log = {
+  info?: (msg: string) => void;
+  warn?: (msg: string) => void;
+  error?: (msg: string) => void;
+};
+
+function isRec(value: unknown): value is Rec {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function normalizeId(id: unknown): string {
+  return typeof id === "string" ? id.trim().toLowerCase() : "";
+}
+
+/** True for a release host >= 2026.8.1. Pre-releases and unknown strings are false. */
+export function hostHasRememberAcrossConversations(version: string | undefined | null): boolean {
+  const m = /^v?(\d+)\.(\d+)\.(\d+)$/.exec((version ?? "").trim());
+  if (!m) return false;
+  const parts = [Number(m[1]), Number(m[2]), Number(m[3])];
+  for (let i = 0; i < 3; i += 1) {
+    if (parts[i] !== DM_RECALL_MIN_HOST[i]) return parts[i] > DM_RECALL_MIN_HOST[i];
+  }
+  return true;
+}
+
+type AgentSlot =
+  | { kind: "entries"; key: string; entry: Rec }
+  | { kind: "list"; index: number; entry: Rec }
+  | { kind: "no-roster" }
+  | { kind: "missing" };
+
+function findAgentSlot(cfg: Rec, agentId: string): AgentSlot {
+  const agents = isRec(cfg.agents) ? cfg.agents : undefined;
+  const id = normalizeId(agentId);
+  if (agents && Object.hasOwn(agents, "entries") && agents.entries !== undefined) {
+    if (!isRec(agents.entries)) return { kind: "missing" };
+    for (const key of Object.keys(agents.entries)) {
+      const entry = agents.entries[key];
+      if (normalizeId(key) === id && isRec(entry)) return { kind: "entries", key, entry };
+    }
+    return { kind: "missing" };
+  }
+  if (agents && Object.hasOwn(agents, "list") && agents.list !== undefined) {
+    if (!Array.isArray(agents.list)) return { kind: "missing" };
+    const index = agents.list.findIndex((e) => isRec(e) && normalizeId(e.id) === id);
+    return index >= 0 ? { kind: "list", index, entry: agents.list[index] as Rec } : { kind: "missing" };
+  }
+  return { kind: "no-roster" };
+}
+
+function readFlag(holder: unknown): boolean | undefined {
+  if (!isRec(holder) || !isRec(holder.memory) || !isRec(holder.memory.search)) return undefined;
+  const v = holder.memory.search.rememberAcrossConversations;
+  return typeof v === "boolean" ? v : undefined;
+}
+
+/** The value written at each layer, `undefined` where it is not written. */
+export function readRememberAcrossConversations(
+  cfg: Rec,
+  agentId: string,
+): { agent: boolean | undefined; global: boolean | undefined } {
+  const slot = findAgentSlot(cfg, agentId);
+  const agent = slot.kind === "entries" || slot.kind === "list" ? readFlag(slot.entry) : undefined;
+  return { agent, global: readFlag(cfg) };
+}
+
+function setFlagFalse(holder: Rec): void {
+  const memory = isRec(holder.memory) ? holder.memory : {};
+  const search = isRec(memory.search) ? memory.search : {};
+  holder.memory = { ...memory, search: { ...search, rememberAcrossConversations: false } };
+}
+
+/**
+ * Write `rememberAcrossConversations: false` at the agent's own layer of
+ * `cfg` (mutated in place). Returns the dotted path written, or `null` when a
+ * roster exists but does not list the agent (nothing written).
+ */
+export function setAgentRememberAcrossConversationsFalse(cfg: Rec, agentId: string): string | null {
+  const slot = findAgentSlot(cfg, agentId);
+  if (slot.kind === "entries") {
+    setFlagFalse(slot.entry);
+    return `agents.entries.${slot.key}.memory.search`;
+  }
+  if (slot.kind === "list") {
+    setFlagFalse(slot.entry);
+    return `agents.list[${slot.index}].memory.search`;
+  }
+  if (slot.kind === "no-roster") {
+    setFlagFalse(cfg);
+    return "memory.search";
+  }
+  return null;
+}
+
+type Marker = { agents?: Record<string, { outcome: DmRecallOutcome; at: string }> };
+
+function readMarker(file: string): Marker {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, "utf8")) as unknown;
+    return isRec(parsed) ? (parsed as Marker) : {};
+  } catch {
+    return {};
+  }
+}
+
+function writeMarker(file: string, agentId: string, outcome: DmRecallOutcome): void {
+  const marker = readMarker(file);
+  const agents = isRec(marker.agents) ? marker.agents : {};
+  agents[normalizeId(agentId)] = { outcome, at: new Date().toISOString() };
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify({ ...marker, agents }, null, 2)}\n`);
+}
+
+/** Apply the one-time default. Never throws. */
+export async function applyDmRecallDefault(params: {
+  agentId: string;
+  hostVersion: string | undefined | null;
+  stateDir: string;
+  readConfig: () => unknown;
+  mutateConfigFile: MutateConfigFile;
+  log?: Log;
+}): Promise<DmRecallOutcome> {
+  const { agentId, log } = params;
+  const markerFile = path.join(params.stateDir, DM_RECALL_MARKER_FILENAME);
+  try {
+    if (readMarker(markerFile).agents?.[normalizeId(agentId)]) return "already-handled";
+    if (!hostHasRememberAcrossConversations(params.hostVersion)) return "unsupported-host";
+
+    const cfg = params.readConfig();
+    const current = readRememberAcrossConversations(isRec(cfg) ? cfg : {}, agentId);
+    const explicit = current.agent ?? current.global;
+    if (explicit === true) {
+      log?.warn?.(
+        `clawchat-plugin-openclaw: memory.search.rememberAcrossConversations is true for agent '${agentId}', so a ` +
+          "friend's ClawChat direct chat can recall what the owner said in theirs. Kept as set. To turn it off: " +
+          `openclaw config set memory.search.rememberAcrossConversations false (or set it to false on agent '${agentId}'), then restart the gateway.`,
+      );
+      writeMarker(markerFile, agentId, "kept-true");
+      return "kept-true";
+    }
+    if (explicit === false) {
+      writeMarker(markerFile, agentId, "kept-false");
+      return "kept-false";
+    }
+
+    if (findAgentSlot(isRec(cfg) ? cfg : {}, agentId).kind === "missing") {
+      log?.info?.(
+        `clawchat-plugin-openclaw: agent '${agentId}' is not in the agents roster; rememberAcrossConversations left unset`,
+      );
+      return "agent-not-in-roster";
+    }
+
+    let written: string | null = null;
+    let raced: boolean | undefined;
+    await params.mutateConfigFile({
+      afterWrite: { mode: "none", reason: "clawchat-plugin-openclaw: no recall across ClawChat direct chats" },
+      mutate(draft) {
+        // Re-check on the locked, current file: someone may have set it meanwhile.
+        const now = readRememberAcrossConversations(draft, agentId);
+        raced = now.agent ?? now.global;
+        if (raced !== undefined) return;
+        written = setAgentRememberAcrossConversationsFalse(draft, agentId);
+      },
+    });
+    if (written === null) {
+      if (raced === undefined) return "agent-not-in-roster";
+      const outcome: DmRecallOutcome = raced ? "kept-true" : "kept-false";
+      writeMarker(markerFile, agentId, outcome);
+      return outcome;
+    }
+    writeMarker(markerFile, agentId, "wrote-false");
+    log?.info?.(
+      `clawchat-plugin-openclaw: set ${written}.rememberAcrossConversations=false for agent '${agentId}' ` +
+        "(ClawChat direct chats with different people no longer recall each other)",
+    );
+    return "wrote-false";
+  } catch (err) {
+    log?.error?.(
+      `clawchat-plugin-openclaw: could not apply the rememberAcrossConversations default for agent '${agentId}': ${err instanceof Error ? err.message : String(err)}`,
+    );
+    return "write-failed";
+  }
+}

package/src/runtime.ts

@@ -1,3 +1,4 @@
+import { applyDmRecallDefault } from "./dm-recall-default.ts";
 import {
   AckTimeoutError,
   AuthError,
@@ -1293,6 +1294,47 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
       : undefined;
   };
 
+  // OpenClaw >= 2026.8.1 recalls across a single agent's DMs unless DM isolation
+  // is visible in the gateway config; ours is in-memory only. Write the agent's
+  // `rememberAcrossConversations: false` once, unless the owner set it
+  // (dm-recall-default.ts). Fire-and-forget: never blocks or fails startup.
+  void (async () => {
+    const stateDir = runtime.state?.resolveStateDir?.();
+    const mutateConfigFile = resolveMutateConfigFile();
+    const readConfig = (runtime.config as { current?: () => unknown } | undefined)?.current;
+    if (!stateDir || !mutateConfigFile || typeof readConfig !== "function") return;
+    let agentId: string;
+    try {
+      agentId = runtime.channel.routing.resolveAgentRoute({
+        cfg: withClawChatSessionScope(cfg),
+        channel: CHANNEL_ID,
+        accountId,
+        peer: { kind: "direct", id: account.ownerUserId || "owner" },
+      }).agentId;
+    } catch (err) {
+      log?.info?.(
+        `[${accountId}] clawchat-plugin-openclaw rememberAcrossConversations default skipped: agent route unavailable (${err instanceof Error ? err.message : String(err)})`,
+      );
+      return;
+    }
+    await applyDmRecallDefault({
+      agentId,
+      hostVersion: runtime.version,
+      stateDir,
+      readConfig: () => readConfig.call(runtime.config),
+      mutateConfigFile: mutateConfigFile as never,
+      log: {
+        info: (m) => log?.info?.(`[${accountId}] ${m}`),
+        warn: (m) => {
+          const warn = (log as { warn?: (msg: string) => void } | undefined)?.warn;
+          if (warn) warn(`[${accountId}] ${m}`);
+          else log?.info?.(`[${accountId}] WARNING ${m}`);
+        },
+        error: (m) => log?.error?.(`[${accountId}] ${m}`),
+      },
+    });
+  })();
+
   // §0/§C.1 — write the account slot's `token`/`refreshToken` keys. `tokens=null`
   // blanks them (auto-logout); otherwise persists the rotated pair.
   const persistConfigTokens = async (