@botcord/daemon 0.2.70 → 0.2.72

package/dist/daemon.js

@@ -11,6 +11,7 @@ import { adoptDiscoveredOpenclawAgents, collectRuntimeSnapshot, createProvisione
 import { openclawAutoProvisionEnabled } from "./openclaw-discovery.js";
 import { SnapshotWriter } from "./snapshot-writer.js";
 import { createDaemonSystemContextBuilder } from "./system-context.js";
+import { readWorkingMemorySnapshot } from "./working-memory.js";
 import { createRoomStaticContextBuilder } from "./room-context.js";
 import { createRoomContextFetcher } from "./room-context-fetcher.js";
 import { buildLoopRiskPrompt, loopRiskSessionKey, recordInboundText as recordLoopRiskInbound, recordOutboundText as recordLoopRiskOutbound, } from "./loop-risk.js";
@@ -261,6 +262,7 @@ export async function startDaemon(opts) {
         const fallback = scBuilders.get(first);
         return fallback ? fallback(message) : undefined;
     };
+    const buildMemoryContext = (message) => readWorkingMemorySnapshot(message.accountId);
     // Observer runs after ack + before runtime.run. Keeping the side effect
     // outside the system-context builder (option A) means the builder stays
     // pure — a cleaner contract the gateway can also expose to non-daemon
@@ -362,6 +364,7 @@ export async function startDaemon(opts) {
         log: logger,
         turnTimeoutMs: DEFAULT_TURN_TIMEOUT_MS,
         buildSystemContext,
+        buildMemoryContext,
         onInbound,
         onOutbound,
         composeUserTurn: composeBotCordUserTurn,

package/dist/gateway/channels/feishu.js

@@ -8,6 +8,8 @@ import { splitText } from "./text-split.js";
 const FEISHU_PROVIDER = "feishu";
 const DEFAULT_SPLIT_AT = 4000;
 const MAX_SEEN_MESSAGES = 2048;
+const TYPING_EMOJI = "Typing";
+const TYPING_REACTION_TTL_MS = 20_000;
 function sdkDomain(domain) {
     const sdk = Lark;
     return domain === "lark" ? sdk.Domain?.Lark : sdk.Domain?.Feishu;
@@ -63,6 +65,7 @@ export function createFeishuChannel(opts) {
     let botOpenId;
     let botName;
     let liveSetStatus = null;
+    const activeTypingReactions = new Map();
     let statusSnapshot = {
         channel: opts.id,
         accountId: opts.accountId,
@@ -292,6 +295,45 @@ export function createFeishuChannel(opts) {
         return ((typeof res.data?.message_id === "string" ? res.data.message_id : undefined) ??
             (typeof res.message_id === "string" ? res.message_id : undefined));
     }
+    function resultReactionId(res) {
+        return ((typeof res.data?.reaction_id === "string" ? res.data.reaction_id : undefined) ??
+            (typeof res.reaction_id === "string" ? res.reaction_id : undefined) ??
+            null);
+    }
+    function messageIdFromTrace(traceId) {
+        if (!traceId.startsWith("feishu:"))
+            return null;
+        const messageId = traceId.slice("feishu:".length).trim();
+        return messageId.length > 0 ? messageId : null;
+    }
+    async function removeTypingReaction(messageId) {
+        const state = activeTypingReactions.get(messageId);
+        if (!state)
+            return;
+        activeTypingReactions.delete(messageId);
+        if (state.timer)
+            clearTimeout(state.timer);
+        if (!state.reactionId)
+            return;
+        try {
+            await callFeishu({
+                method: "DELETE",
+                url: `/open-apis/im/v1/messages/${encodeURIComponent(messageId)}/reactions/${encodeURIComponent(state.reactionId)}`,
+            });
+        }
+        catch (err) {
+            statusSnapshot.lastError = err instanceof Error ? err.message : String(err);
+        }
+    }
+    function scheduleTypingCleanup(messageId, state) {
+        if (state.timer)
+            clearTimeout(state.timer);
+        state.timer = setTimeout(() => {
+            void removeTypingReaction(messageId);
+        }, TYPING_REACTION_TTL_MS);
+        if (typeof state.timer.unref === "function")
+            state.timer.unref();
+    }
     function resultResourceKey(res, key) {
         const direct = res[key];
         if (typeof direct === "string")
@@ -422,14 +464,61 @@ export function createFeishuChannel(opts) {
                 replyInThread: Boolean(ctx.message.threadId),
             }) ?? providerMessageId;
         }
+        if (ctx.message.replyTo) {
+            void removeTypingReaction(ctx.message.replyTo);
+        }
+        if (ctx.message.threadId && ctx.message.threadId !== ctx.message.replyTo) {
+            void removeTypingReaction(ctx.message.threadId);
+        }
         markStatus({ lastSendAt: Date.now() });
         return { providerMessageId };
     }
     async function typing(ctx) {
-        ctx.log.debug("feishu typing ignored: no native bot typing API", {
-            channel: opts.id,
-            conversationId: ctx.conversationId,
-        });
+        const messageId = messageIdFromTrace(ctx.traceId);
+        if (!messageId) {
+            ctx.log.debug("feishu typing skipped: trace id has no message id", {
+                channel: opts.id,
+                conversationId: ctx.conversationId,
+                traceId: ctx.traceId,
+            });
+            return;
+        }
+        const existing = activeTypingReactions.get(messageId);
+        if (existing) {
+            scheduleTypingCleanup(messageId, existing);
+            return;
+        }
+        const state = { reactionId: null, timer: null };
+        activeTypingReactions.set(messageId, state);
+        scheduleTypingCleanup(messageId, state);
+        try {
+            const res = await callFeishu({
+                method: "POST",
+                url: `/open-apis/im/v1/messages/${encodeURIComponent(messageId)}/reactions`,
+                data: { reaction_type: { emoji_type: TYPING_EMOJI } },
+            });
+            const reactionId = resultReactionId(res);
+            if (activeTypingReactions.get(messageId) !== state) {
+                if (reactionId) {
+                    await callFeishu({
+                        method: "DELETE",
+                        url: `/open-apis/im/v1/messages/${encodeURIComponent(messageId)}/reactions/${encodeURIComponent(reactionId)}`,
+                    });
+                }
+                return;
+            }
+            state.reactionId = reactionId;
+        }
+        catch (err) {
+            activeTypingReactions.delete(messageId);
+            if (state.timer)
+                clearTimeout(state.timer);
+            ctx.log.warn("feishu typing reaction failed", {
+                channel: opts.id,
+                conversationId: ctx.conversationId,
+                err: err instanceof Error ? err.message : String(err),
+            });
+        }
     }
     async function stop(_ctx) {
         try {
@@ -439,6 +528,7 @@ export function createFeishuChannel(opts) {
             // best effort
         }
         wsClient = null;
+        await Promise.allSettled(Array.from(activeTypingReactions.keys()).map(removeTypingReaction));
         try {
             stateStore?.close();
         }

package/dist/gateway/dispatcher.d.ts

@@ -1,7 +1,7 @@
 import type { GatewayLogger } from "./log.js";
 import { type SessionStore } from "./session-store.js";
 import { type TranscriptWriter } from "./transcript.js";
-import type { ChannelAdapter, GatewayConfig, GatewayInboundEnvelope, GatewayInboundMessage, GatewayRoute, InboundObserver, OutboundObserver, RuntimeAdapter, SystemContextBuilder, TurnStatusSnapshot, UserTurnBuilder } from "./types.js";
+import type { ChannelAdapter, GatewayConfig, GatewayInboundEnvelope, GatewayInboundMessage, GatewayRoute, InboundObserver, MemoryContextBuilder, OutboundObserver, RuntimeAdapter, SystemContextBuilder, TurnStatusSnapshot, UserTurnBuilder } from "./types.js";
 /** Factory signature for building a runtime adapter at turn dispatch time. */
 export type RuntimeFactory = (runtimeId: string, extraArgs?: string[]) => RuntimeAdapter;
 /** Constructor options for `Dispatcher`. */
@@ -24,6 +24,13 @@ export interface DispatcherOptions {
      * swallowed and logged — they never abort the turn.
      */
     buildSystemContext?: SystemContextBuilder;
+    /**
+     * Optional hook returning the current working-memory snapshot/version. When
+     * a resumed runtime session last saw a different version, dispatcher injects
+     * the snapshot into the actual user prompt so resumed transcripts cannot
+     * keep following stale memory.
+     */
+    buildMemoryContext?: MemoryContextBuilder;
     /**
      * Optional side-effect hook invoked after ack, before the turn runs.
      * Intended for bookkeeping (e.g. activity tracking). Errors are logged
@@ -86,6 +93,7 @@ export declare class Dispatcher {
     private readonly log;
     private readonly turnTimeoutMs;
     private readonly buildSystemContext?;
+    private readonly buildMemoryContext?;
     private readonly onInbound?;
     private readonly onOutbound?;
     private readonly composeUserTurn?;
@@ -149,6 +157,7 @@ export declare class Dispatcher {
     private recomposeUserTurn;
     private runTurn;
     private sendReply;
+    private providerReplyTo;
     private emitInbound;
     private emitOutbound;
 }

package/dist/gateway/dispatcher.js

@@ -39,6 +39,18 @@ function transcriptBlocksVerbose() {
     return process.env.BOTCORD_TRANSCRIPT_BLOCKS === "verbose" ||
         process.env.BOTCORD_TRACE_VERBOSE === "1";
 }
+function buildMemoryUpdateNotice(args) {
+    return [
+        "[BotCord Memory Update Notice]",
+        `The persistent working memory changed since this runtime session last used it (previous: ${args.previousVersion ?? "none"}, current: ${args.currentVersion}).`,
+        "Before acting on the message below, retrieve the latest working memory through the available BotCord memory tool or CLI, then treat that latest memory as authoritative.",
+        "If using the local daemon CLI, run: botcord-daemon memory get",
+        "The latest memory supersedes older goals, monitoring rules, preferences, and task state in the resumed conversation.",
+        "",
+        "[Current Message]",
+        args.userTurn,
+    ].join("\n");
+}
 function summarizeStreamBlock(block) {
     const summary = { type: block.kind };
     const raw = block.raw;
@@ -126,6 +138,7 @@ export class Dispatcher {
     log;
     turnTimeoutMs;
     buildSystemContext;
+    buildMemoryContext;
     onInbound;
     onOutbound;
     composeUserTurn;
@@ -149,6 +162,7 @@ export class Dispatcher {
         this.log = opts.log;
         this.turnTimeoutMs = opts.turnTimeoutMs ?? DEFAULT_TURN_TIMEOUT_MS;
         this.buildSystemContext = opts.buildSystemContext;
+        this.buildMemoryContext = opts.buildMemoryContext;
         this.onInbound = opts.onInbound;
         this.onOutbound = opts.onOutbound;
         this.composeUserTurn = opts.composeUserTurn;
@@ -749,6 +763,8 @@ export class Dispatcher {
         });
         const entry = this.sessionStore.get(key);
         const sessionId = entry?.runtimeSessionId ?? null;
+        let currentMemoryVersion;
+        let runtimeText = text;
         const trustLevel = route.trustLevel ?? "trusted";
         const streamable = msg.trace?.streamable === true;
         const traceId = msg.trace?.id;
@@ -1008,13 +1024,45 @@ export class Dispatcher {
                 });
             }
         }
+        if (this.buildMemoryContext) {
+            try {
+                const snapshot = await this.buildMemoryContext(msg);
+                if (snapshot &&
+                    typeof snapshot.version === "string" &&
+                    snapshot.version.length > 0) {
+                    currentMemoryVersion = snapshot.version;
+                    const previousMemoryVersion = entry?.memoryVersion ?? null;
+                    if (sessionId && previousMemoryVersion !== currentMemoryVersion) {
+                        runtimeText = buildMemoryUpdateNotice({
+                            previousVersion: previousMemoryVersion,
+                            currentVersion: currentMemoryVersion,
+                            userTurn: text,
+                        });
+                        this.log.info("dispatcher: injected memory update notice", {
+                            agentId: msg.accountId,
+                            roomId: msg.conversation.id,
+                            topicId: msg.conversation.threadId ?? null,
+                            turnId,
+                            previousMemoryVersion,
+                            currentMemoryVersion,
+                        });
+                    }
+                }
+            }
+            catch (err) {
+                this.log.warn("buildMemoryContext threw — continuing without memory version check", {
+                    error: err instanceof Error ? err.message : String(err),
+                    messageId: msg.id,
+                });
+            }
+        }
         const runtime = this.runtimeFactory(route.runtime, route.extraArgs);
         let result;
         let threw;
         try {
             try {
                 result = await runtime.run({
-                    text,
+                    text: runtimeText,
                     sessionId,
                     cwd: route.cwd,
                     accountId: msg.accountId,
@@ -1098,7 +1146,7 @@ export class Dispatcher {
                         threadId: msg.conversation.threadId ?? null,
                         type: "error",
                         text: `⚠️ Runtime timeout after ${Math.round(this.turnTimeoutMs / 60000)} minute(s); aborted`,
-                        replyTo: msg.id,
+                        replyTo: this.providerReplyTo(msg),
                         traceId: msg.trace?.id ?? null,
                     }, turnId);
                 }
@@ -1144,7 +1192,7 @@ export class Dispatcher {
                         threadId: msg.conversation.threadId ?? null,
                         type: "error",
                         text: `⚠️ Runtime error: ${truncate(errMsg, 500)}`,
-                        replyTo: msg.id,
+                        replyTo: this.providerReplyTo(msg),
                         traceId: msg.trace?.id ?? null,
                     }, turnId);
                 }
@@ -1194,6 +1242,7 @@ export class Dispatcher {
                     key,
                     runtime: route.runtime,
                     runtimeSessionId: result.newSessionId,
+                    memoryVersion: currentMemoryVersion ?? entry?.memoryVersion ?? null,
                     channel: msg.channel,
                     accountId: msg.accountId,
                     conversationKind: msg.conversation.kind,
@@ -1252,7 +1301,7 @@ export class Dispatcher {
                             threadId: msg.conversation.threadId ?? null,
                             type: "error",
                             text: `⚠️ Runtime error: ${truncate(result.error, 500)}`,
-                            replyTo: msg.id,
+                            replyTo: this.providerReplyTo(msg),
                             traceId: msg.trace?.id ?? null,
                         }, turnId);
                         this.emitOutbound({
@@ -1323,7 +1372,7 @@ export class Dispatcher {
                 conversationId: msg.conversation.id,
                 threadId: msg.conversation.threadId ?? null,
                 text: replyText,
-                replyTo: msg.id,
+                replyTo: this.providerReplyTo(msg),
                 traceId: msg.trace?.id ?? null,
             }, turnId);
             this.emitOutbound({
@@ -1388,6 +1437,9 @@ export class Dispatcher {
         }
         return { ok: true };
     }
+    providerReplyTo(msg) {
+        return msg.replyTo ?? msg.id;
+    }
     emitInbound(turnId, msg) {
         if (!this.transcript.enabled)
             return;

package/dist/gateway/gateway.d.ts

@@ -2,7 +2,7 @@ import { type ChannelBackoffOptions } from "./channel-manager.js";
 import { type RuntimeFactory } from "./dispatcher.js";
 import { type GatewayLogger } from "./log.js";
 import { type TranscriptWriter } from "./transcript.js";
-import type { ChannelAdapter, GatewayChannelConfig, GatewayConfig, GatewayInboundMessage, GatewayOutboundMessage, GatewayRoute, GatewayRuntimeSnapshot, InboundObserver, OutboundObserver, SystemContextBuilder, UserTurnBuilder } from "./types.js";
+import type { ChannelAdapter, GatewayChannelConfig, GatewayConfig, GatewayInboundMessage, GatewayOutboundMessage, GatewayRoute, GatewayRuntimeSnapshot, InboundObserver, MemoryContextBuilder, OutboundObserver, SystemContextBuilder, UserTurnBuilder } from "./types.js";
 /** Constructor options for `Gateway`. */
 export interface GatewayBootOptions {
     config: GatewayConfig;
@@ -20,6 +20,11 @@ export interface GatewayBootOptions {
      * abort the turn.
      */
     buildSystemContext?: SystemContextBuilder;
+    /**
+     * Snapshot/version hook for working memory. Forwarded to dispatcher so
+     * resumed runtime sessions get an explicit prompt when memory changes.
+     */
+    buildMemoryContext?: MemoryContextBuilder;
     /**
      * Observer called after the dispatcher acks each inbound message. Useful
      * for activity tracking or metrics. Errors are logged and swallowed.

package/dist/gateway/gateway.js

@@ -68,6 +68,7 @@ export class Gateway {
             log: this.log,
             turnTimeoutMs: opts.turnTimeoutMs,
             buildSystemContext: opts.buildSystemContext,
+            buildMemoryContext: opts.buildMemoryContext,
             onInbound: opts.onInbound,
             composeUserTurn: opts.composeUserTurn,
             onOutbound: opts.onOutbound,

package/dist/gateway/types.d.ts

@@ -133,6 +133,10 @@ export type InboundObserver = (message: GatewayInboundMessage) => Promise<void>
  * a buggy composer never drops turns.
  */
 export type UserTurnBuilder = (message: GatewayInboundMessage) => string;
+export interface MemoryContextSnapshot {
+    version: string;
+}
+export type MemoryContextBuilder = (message: GatewayInboundMessage) => Promise<MemoryContextSnapshot | null | undefined> | MemoryContextSnapshot | null | undefined;
 /**
  * Optional hook fired after the dispatcher dispatches a reply to a channel.
  * Intended for outbound bookkeeping (loop-risk tracking, metrics). Errors
@@ -382,6 +386,8 @@ export interface GatewaySessionEntry {
     key: string;
     runtime: string;
     runtimeSessionId: string;
+    /** Version of working memory last injected into this runtime session. */
+    memoryVersion?: string | null;
     channel: string;
     accountId: string;
     conversationKind: "direct" | "group";

package/dist/working-memory.d.ts

@@ -4,6 +4,10 @@ export interface WorkingMemory {
     sections: Record<string, string>;
     updatedAt: string;
 }
+export interface WorkingMemorySnapshot {
+    memory: WorkingMemory | null;
+    version: string;
+}
 /** Characters per section; matches the plugin-side limit. */
 export declare const MAX_SECTION_CHARS = 10000;
 export declare const MAX_GOAL_CHARS = 500;
@@ -15,6 +19,8 @@ export declare const DEFAULT_SECTION = "notes";
  */
 export declare function resolveMemoryDir(agentId: string): string;
 export declare function readWorkingMemory(agentId: string): WorkingMemory | null;
+export declare function workingMemoryVersion(memory: WorkingMemory | null): string;
+export declare function readWorkingMemorySnapshot(agentId: string): WorkingMemorySnapshot;
 export declare function writeWorkingMemory(agentId: string, data: WorkingMemory): void;
 export interface SetSectionResult {
     memory: WorkingMemory;

package/dist/working-memory.js

@@ -9,6 +9,7 @@
  * branches) and plugin/src/memory-protocol.ts (prompt builder).
  */
 import { copyFileSync, existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync, } from "node:fs";
+import { createHash } from "node:crypto";
 import { homedir } from "node:os";
 import path from "node:path";
 import { agentStateDir } from "./agent-workspace.js";
@@ -171,6 +172,28 @@ export function readWorkingMemory(agentId) {
         return null;
     return normalize(readJson(p));
 }
+function canonicalizeWorkingMemory(memory) {
+    const sections = {};
+    for (const [key, value] of Object.entries(memory?.sections ?? {}).sort(([a], [b]) => a.localeCompare(b))) {
+        sections[key] = value;
+    }
+    return {
+        version: 2,
+        goal: memory?.goal ?? null,
+        sections,
+    };
+}
+export function workingMemoryVersion(memory) {
+    const canonical = JSON.stringify(canonicalizeWorkingMemory(memory));
+    return `wm-sha256:${createHash("sha256").update(canonical).digest("hex").slice(0, 16)}`;
+}
+export function readWorkingMemorySnapshot(agentId) {
+    const memory = readWorkingMemory(agentId);
+    return {
+        memory,
+        version: workingMemoryVersion(memory),
+    };
+}
 export function writeWorkingMemory(agentId, data) {
     writeJsonAtomic(workingMemoryPath(agentId), data);
 }

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@botcord/daemon",
-  "version": "0.2.70",
+  "version": "0.2.72",
   "description": "BotCord local daemon — bridges Hub inbox push to local Claude Code / Codex / Gemini CLIs",
   "type": "module",
   "bin": {
-    "botcord-daemon": "./dist/index.js"
+    "botcord-daemon": "dist/index.js"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/__tests__/working-memory.test.ts

@@ -274,3 +274,33 @@ describe("buildWorkingMemoryPrompt", () => {
     expect(p).toContain("‹current_memory›");
   });
 });
+
+describe("working-memory version", () => {
+  it("is stable for identical content regardless of section insertion order or updatedAt", () => {
+    const a = wm.workingMemoryVersion({
+      version: 2,
+      sections: { b: "two", a: "one" },
+      updatedAt: "2026-01-01T00:00:00.000Z",
+    });
+    const b = wm.workingMemoryVersion({
+      version: 2,
+      sections: { a: "one", b: "two" },
+      updatedAt: "2026-01-02T00:00:00.000Z",
+    });
+    expect(a).toBe(b);
+  });
+
+  it("changes when durable memory content changes", () => {
+    const a = wm.workingMemoryVersion({
+      version: 2,
+      sections: { notes: "old" },
+      updatedAt: "2026-01-01T00:00:00.000Z",
+    });
+    const b = wm.workingMemoryVersion({
+      version: 2,
+      sections: { notes: "new" },
+      updatedAt: "2026-01-01T00:00:00.000Z",
+    });
+    expect(a).not.toBe(b);
+  });
+});

package/src/daemon.ts

@@ -35,6 +35,7 @@ import {
 import { openclawAutoProvisionEnabled } from "./openclaw-discovery.js";
 import { SnapshotWriter } from "./snapshot-writer.js";
 import { createDaemonSystemContextBuilder } from "./system-context.js";
+import { readWorkingMemorySnapshot } from "./working-memory.js";
 import { createRoomStaticContextBuilder } from "./room-context.js";
 import { createRoomContextFetcher } from "./room-context-fetcher.js";
 import {
@@ -400,6 +401,8 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
     const fallback = scBuilders.get(first);
     return fallback ? fallback(message) : undefined;
   };
+  const buildMemoryContext = (message: GatewayInboundMessage) =>
+    readWorkingMemorySnapshot(message.accountId);
 
   // Observer runs after ack + before runtime.run. Keeping the side effect
   // outside the system-context builder (option A) means the builder stays
@@ -511,6 +514,7 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
     log: logger,
     turnTimeoutMs: DEFAULT_TURN_TIMEOUT_MS,
     buildSystemContext,
+    buildMemoryContext,
     onInbound,
     onOutbound,
     composeUserTurn: composeBotCordUserTurn,

package/src/gateway/__tests__/dispatcher.test.ts

@@ -293,6 +293,30 @@ describe("Dispatcher", () => {
     expect(store.all()[0].threadId).toBe("t_1");
   });
 
+  it("sends replies to the provider reply id when it differs from the internal message id", async () => {
+    const runtime = new FakeRuntime({ reply: "ok" });
+    const feishuChannel = new FakeChannel({ id: "gw_feishu_1", type: "feishu" });
+    const { dispatcher, channel } = await scaffold({
+      runtimeFactory: () => runtime,
+      channel: feishuChannel,
+      config: baseConfig({
+        channels: [{ id: "gw_feishu_1", type: "feishu", accountId: "ag_me" }],
+      }),
+    });
+
+    await dispatcher.handle(
+      makeEnvelope({
+        id: "feishu:om_internal_wrapped",
+        replyTo: "om_provider_raw",
+        channel: "gw_feishu_1",
+        conversation: { id: "feishu:user:oc_chat", kind: "direct" },
+      }),
+    );
+
+    expect(channel.sends.length).toBe(1);
+    expect(channel.sends[0].message.replyTo).toBe("om_provider_raw");
+  });
+
   it("reuses session id on second message with same queue key", async () => {
     const seen: Array<string | null> = [];
     const runtime = new FakeRuntime({
@@ -1581,6 +1605,71 @@ describe("Dispatcher", () => {
     ).toBe(true);
   });
 
+  it("injects a memory update notice into resumed sessions when memory version changes", async () => {
+    const seenText: string[] = [];
+    let memoryVersion = "wm-sha256:v1";
+    const runtime = new FakeRuntime({
+      newSessionId: (opts) => opts.sessionId ?? "sid-1",
+      observeRun: (opts) => seenText.push(opts.text),
+    });
+    const { store, dir } = await makeStore();
+    tempDirs.push(dir);
+    const channel = new FakeChannel();
+    const channels = new Map<string, ChannelAdapter>([[channel.id, channel]]);
+    const dispatcher = new Dispatcher({
+      config: baseConfig(),
+      channels,
+      runtime: () => runtime,
+      sessionStore: store,
+      log: silentLogger(),
+      buildMemoryContext: () => ({
+        version: memoryVersion,
+      }),
+    });
+
+    await dispatcher.handle(makeEnvelope({ id: "msg_1", text: "first" }));
+    expect(seenText[0]).toBe("first");
+    expect(store.all()[0].memoryVersion).toBe("wm-sha256:v1");
+
+    memoryVersion = "wm-sha256:v2";
+    await dispatcher.handle(makeEnvelope({ id: "msg_2", text: "second" }));
+    expect(seenText[1]).toContain("[BotCord Memory Update Notice]");
+    expect(seenText[1]).toContain("previous: wm-sha256:v1, current: wm-sha256:v2");
+    expect(seenText[1]).toContain("retrieve the latest working memory");
+    expect(seenText[1]).toContain("botcord-daemon memory get");
+    expect(seenText[1]).not.toContain("[BotCord Working Memory]\nversion wm-sha256:v2");
+    expect(seenText[1]).toContain("[Current Message]\nsecond");
+    expect(store.all()[0].memoryVersion).toBe("wm-sha256:v2");
+  });
+
+  it("does not inject a memory update notice when the resumed session already has the current memory version", async () => {
+    const seenText: string[] = [];
+    const runtime = new FakeRuntime({
+      newSessionId: (opts) => opts.sessionId ?? "sid-1",
+      observeRun: (opts) => seenText.push(opts.text),
+    });
+    const { store, dir } = await makeStore();
+    tempDirs.push(dir);
+    const channel = new FakeChannel();
+    const channels = new Map<string, ChannelAdapter>([[channel.id, channel]]);
+    const dispatcher = new Dispatcher({
+      config: baseConfig(),
+      channels,
+      runtime: () => runtime,
+      sessionStore: store,
+      log: silentLogger(),
+      buildMemoryContext: () => ({
+        version: "wm-sha256:same",
+      }),
+    });
+
+    await dispatcher.handle(makeEnvelope({ id: "msg_1", text: "first" }));
+    await dispatcher.handle(makeEnvelope({ id: "msg_2", text: "second" }));
+
+    expect(seenText).toEqual(["first", "second"]);
+    expect(store.all()[0].memoryVersion).toBe("wm-sha256:same");
+  });
+
   it("onInbound: observer is invoked with the message between ack and runtime.run", async () => {
     const order: string[] = [];
     const runtime = new FakeRuntime({
@@ -2009,7 +2098,8 @@ describe("Dispatcher", () => {
     });
     await dispatcher.handle(
       makeEnvelope({
-        id: "m_err",
+        id: "feishu:om_internal_err",
+        replyTo: "om_provider_err",
         conversation: { id: "rm_g_other", kind: "group" },
       }),
     );
@@ -2017,7 +2107,7 @@ describe("Dispatcher", () => {
     expect(channel.sends[0].message.type).toBe("error");
     expect(channel.sends[0].message.text).toContain("Runtime error: boom");
     expect(channel.sends[0].message.conversationId).toBe("rm_g_other");
-    expect(channel.sends[0].message.replyTo).toBe("m_err");
+    expect(channel.sends[0].message.replyTo).toBe("om_provider_err");
   });
 
   // ─────────────────────────────────────────────────────────────────────

package/src/gateway/__tests__/feishu-channel.test.ts

@@ -255,27 +255,80 @@ describe("createFeishuChannel", () => {
     expect(JSON.parse(send.data.content as string)).toEqual({ file_key: "file_v2_uploaded" });
   });
 
-  it("exposes typing as a safe no-op because Feishu has no bot typing API", async () => {
-    const debug = vi.fn();
+  it("adds a Typing reaction for typing and removes it when replying", async () => {
     const adapter = createFeishuChannel({
       id: "gw_fs",
       accountId: "ag_self",
       appId: "cli_a",
       appSecret: "sec",
     });
+    larkMock.responses.push(
+      { code: 0, data: { reaction_id: "react_typing_1" } },
+      { code: 0, data: { message_id: "om_reply" } },
+      { code: 0, data: {} },
+    );
 
     await adapter.typing?.({
       traceId: "feishu:om_1",
       accountId: "ag_self",
       conversationId: "feishu:chat:oc_chat",
-      log: { ...SILENT_LOG, debug },
+      log: SILENT_LOG,
     });
 
-    expect(larkMock.requests).toHaveLength(0);
-    expect(debug).toHaveBeenCalledWith(
-      "feishu typing ignored: no native bot typing API",
-      expect.objectContaining({ channel: "gw_fs" }),
-    );
+    expect(larkMock.requests).toHaveLength(1);
+    expect(larkMock.requests[0]).toEqual({
+      method: "POST",
+      url: "/open-apis/im/v1/messages/om_1/reactions",
+      data: { reaction_type: { emoji_type: "Typing" } },
+    });
+
+    await adapter.send({
+      message: {
+        channel: "gw_fs",
+        accountId: "ag_self",
+        conversationId: "feishu:chat:oc_chat",
+        text: "reply",
+        replyTo: "om_1",
+      },
+      log: SILENT_LOG,
+    });
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(larkMock.requests).toHaveLength(3);
+    expect(larkMock.requests[2]).toEqual({
+      method: "DELETE",
+      url: "/open-apis/im/v1/messages/om_1/reactions/react_typing_1",
+    });
+  });
+
+  it("refreshes an existing Feishu typing reaction without creating duplicates", async () => {
+    const adapter = createFeishuChannel({
+      id: "gw_fs",
+      accountId: "ag_self",
+      appId: "cli_a",
+      appSecret: "sec",
+    });
+    larkMock.responses.push({ code: 0, data: { reaction_id: "react_typing_1" } });
+
+    await adapter.typing?.({
+      traceId: "feishu:om_1",
+      accountId: "ag_self",
+      conversationId: "feishu:chat:oc_chat",
+      log: SILENT_LOG,
+    });
+    await adapter.typing?.({
+      traceId: "feishu:om_1",
+      accountId: "ag_self",
+      conversationId: "feishu:chat:oc_chat",
+      log: SILENT_LOG,
+    });
+
+    expect(larkMock.requests).toHaveLength(1);
+    expect(larkMock.requests[0]).toEqual({
+      method: "POST",
+      url: "/open-apis/im/v1/messages/om_1/reactions",
+      data: { reaction_type: { emoji_type: "Typing" } },
+    });
   });
 
   it("surfaces websocket start failures in channel status", async () => {

package/src/gateway/channels/feishu.ts

@@ -21,6 +21,8 @@ import type { FeishuDomain } from "./feishu-registration.js";
 const FEISHU_PROVIDER = "feishu" as const;
 const DEFAULT_SPLIT_AT = 4000;
 const MAX_SEEN_MESSAGES = 2048;
+const TYPING_EMOJI = "Typing";
+const TYPING_REACTION_TTL_MS = 20_000;
 
 export interface FeishuChannelOptions {
   id: string;
@@ -80,6 +82,10 @@ interface FeishuApiResponse {
 }
 
 type FeishuClient = { request(args: unknown): Promise<unknown> };
+type TypingReactionState = {
+  reactionId: string | null;
+  timer: ReturnType<typeof setTimeout> | null;
+};
 
 function sdkDomain(domain: FeishuDomain | undefined): unknown {
   const sdk = Lark as unknown as {
@@ -137,6 +143,7 @@ export function createFeishuChannel(opts: FeishuChannelOptions): ChannelAdapter
   let botOpenId: string | undefined;
   let botName: string | undefined;
   let liveSetStatus: ((patch: Partial<ChannelStatusSnapshot>) => void) | null = null;
+  const activeTypingReactions = new Map<string, TypingReactionState>();
 
   let statusSnapshot: ChannelStatusSnapshot = {
     channel: opts.id,
@@ -387,6 +394,44 @@ export function createFeishuChannel(opts: FeishuChannelOptions): ChannelAdapter
     );
   }
 
+  function resultReactionId(res: FeishuApiResponse): string | null {
+    return (
+      (typeof res.data?.reaction_id === "string" ? res.data.reaction_id : undefined) ??
+      (typeof res.reaction_id === "string" ? res.reaction_id : undefined) ??
+      null
+    );
+  }
+
+  function messageIdFromTrace(traceId: string): string | null {
+    if (!traceId.startsWith("feishu:")) return null;
+    const messageId = traceId.slice("feishu:".length).trim();
+    return messageId.length > 0 ? messageId : null;
+  }
+
+  async function removeTypingReaction(messageId: string): Promise<void> {
+    const state = activeTypingReactions.get(messageId);
+    if (!state) return;
+    activeTypingReactions.delete(messageId);
+    if (state.timer) clearTimeout(state.timer);
+    if (!state.reactionId) return;
+    try {
+      await callFeishu({
+        method: "DELETE",
+        url: `/open-apis/im/v1/messages/${encodeURIComponent(messageId)}/reactions/${encodeURIComponent(state.reactionId)}`,
+      });
+    } catch (err) {
+      statusSnapshot.lastError = err instanceof Error ? err.message : String(err);
+    }
+  }
+
+  function scheduleTypingCleanup(messageId: string, state: TypingReactionState): void {
+    if (state.timer) clearTimeout(state.timer);
+    state.timer = setTimeout(() => {
+      void removeTypingReaction(messageId);
+    }, TYPING_REACTION_TTL_MS);
+    if (typeof state.timer.unref === "function") state.timer.unref();
+  }
+
   function resultResourceKey(res: FeishuApiResponse, key: "image_key" | "file_key"): string {
     const direct = res[key];
     if (typeof direct === "string") return direct;
@@ -516,15 +561,61 @@ export function createFeishuChannel(opts: FeishuChannelOptions): ChannelAdapter
         replyInThread: Boolean(ctx.message.threadId),
       }) ?? providerMessageId;
     }
+    if (ctx.message.replyTo) {
+      void removeTypingReaction(ctx.message.replyTo);
+    }
+    if (ctx.message.threadId && ctx.message.threadId !== ctx.message.replyTo) {
+      void removeTypingReaction(ctx.message.threadId);
+    }
     markStatus({ lastSendAt: Date.now() });
     return { providerMessageId };
   }
 
   async function typing(ctx: ChannelTypingContext): Promise<void> {
-    ctx.log.debug("feishu typing ignored: no native bot typing API", {
-      channel: opts.id,
-      conversationId: ctx.conversationId,
-    });
+    const messageId = messageIdFromTrace(ctx.traceId);
+    if (!messageId) {
+      ctx.log.debug("feishu typing skipped: trace id has no message id", {
+        channel: opts.id,
+        conversationId: ctx.conversationId,
+        traceId: ctx.traceId,
+      });
+      return;
+    }
+    const existing = activeTypingReactions.get(messageId);
+    if (existing) {
+      scheduleTypingCleanup(messageId, existing);
+      return;
+    }
+
+    const state: TypingReactionState = { reactionId: null, timer: null };
+    activeTypingReactions.set(messageId, state);
+    scheduleTypingCleanup(messageId, state);
+    try {
+      const res = await callFeishu({
+        method: "POST",
+        url: `/open-apis/im/v1/messages/${encodeURIComponent(messageId)}/reactions`,
+        data: { reaction_type: { emoji_type: TYPING_EMOJI } },
+      });
+      const reactionId = resultReactionId(res);
+      if (activeTypingReactions.get(messageId) !== state) {
+        if (reactionId) {
+          await callFeishu({
+            method: "DELETE",
+            url: `/open-apis/im/v1/messages/${encodeURIComponent(messageId)}/reactions/${encodeURIComponent(reactionId)}`,
+          });
+        }
+        return;
+      }
+      state.reactionId = reactionId;
+    } catch (err) {
+      activeTypingReactions.delete(messageId);
+      if (state.timer) clearTimeout(state.timer);
+      ctx.log.warn("feishu typing reaction failed", {
+        channel: opts.id,
+        conversationId: ctx.conversationId,
+        err: err instanceof Error ? err.message : String(err),
+      });
+    }
   }
 
   async function stop(_ctx: ChannelStopContext): Promise<void> {
@@ -534,6 +625,7 @@ export function createFeishuChannel(opts: FeishuChannelOptions): ChannelAdapter
       // best effort
     }
     wsClient = null;
+    await Promise.allSettled(Array.from(activeTypingReactions.keys()).map(removeTypingReaction));
     try {
       stateStore?.close();
     } catch {

package/src/gateway/dispatcher.ts

@@ -18,6 +18,7 @@ import type {
   GatewayRoute,
   GatewaySessionEntry,
   InboundObserver,
+  MemoryContextBuilder,
   OutboundObserver,
   QueueMode,
   RuntimeAdapter,
@@ -73,6 +74,23 @@ function transcriptBlocksVerbose(): boolean {
     process.env.BOTCORD_TRACE_VERBOSE === "1";
 }
 
+function buildMemoryUpdateNotice(args: {
+  previousVersion: string | null;
+  currentVersion: string;
+  userTurn: string;
+}): string {
+  return [
+    "[BotCord Memory Update Notice]",
+    `The persistent working memory changed since this runtime session last used it (previous: ${args.previousVersion ?? "none"}, current: ${args.currentVersion}).`,
+    "Before acting on the message below, retrieve the latest working memory through the available BotCord memory tool or CLI, then treat that latest memory as authoritative.",
+    "If using the local daemon CLI, run: botcord-daemon memory get",
+    "The latest memory supersedes older goals, monitoring rules, preferences, and task state in the resumed conversation.",
+    "",
+    "[Current Message]",
+    args.userTurn,
+  ].join("\n");
+}
+
 function summarizeStreamBlock(block: StreamBlock): TranscriptBlockSummary {
   const summary: TranscriptBlockSummary = { type: block.kind };
   const raw = block.raw as {
@@ -150,6 +168,13 @@ export interface DispatcherOptions {
    * swallowed and logged — they never abort the turn.
    */
   buildSystemContext?: SystemContextBuilder;
+  /**
+   * Optional hook returning the current working-memory snapshot/version. When
+   * a resumed runtime session last saw a different version, dispatcher injects
+   * the snapshot into the actual user prompt so resumed transcripts cannot
+   * keep following stale memory.
+   */
+  buildMemoryContext?: MemoryContextBuilder;
   /**
    * Optional side-effect hook invoked after ack, before the turn runs.
    * Intended for bookkeeping (e.g. activity tracking). Errors are logged
@@ -285,6 +310,7 @@ export class Dispatcher {
   private readonly log: GatewayLogger;
   private readonly turnTimeoutMs: number;
   private readonly buildSystemContext?: SystemContextBuilder;
+  private readonly buildMemoryContext?: MemoryContextBuilder;
   private readonly onInbound?: InboundObserver;
   private readonly onOutbound?: OutboundObserver;
   private readonly composeUserTurn?: UserTurnBuilder;
@@ -311,6 +337,7 @@ export class Dispatcher {
     this.log = opts.log;
     this.turnTimeoutMs = opts.turnTimeoutMs ?? DEFAULT_TURN_TIMEOUT_MS;
     this.buildSystemContext = opts.buildSystemContext;
+    this.buildMemoryContext = opts.buildMemoryContext;
     this.onInbound = opts.onInbound;
     this.onOutbound = opts.onOutbound;
     this.composeUserTurn = opts.composeUserTurn;
@@ -990,6 +1017,8 @@ export class Dispatcher {
     });
     const entry = this.sessionStore.get(key);
     const sessionId = entry?.runtimeSessionId ?? null;
+    let currentMemoryVersion: string | undefined;
+    let runtimeText = text;
     const trustLevel = route.trustLevel ?? "trusted";
 
     const streamable = msg.trace?.streamable === true;
@@ -1252,13 +1281,47 @@ export class Dispatcher {
       }
     }
 
+    if (this.buildMemoryContext) {
+      try {
+        const snapshot = await this.buildMemoryContext(msg);
+        if (
+          snapshot &&
+          typeof snapshot.version === "string" &&
+          snapshot.version.length > 0
+        ) {
+          currentMemoryVersion = snapshot.version;
+          const previousMemoryVersion = entry?.memoryVersion ?? null;
+          if (sessionId && previousMemoryVersion !== currentMemoryVersion) {
+            runtimeText = buildMemoryUpdateNotice({
+              previousVersion: previousMemoryVersion,
+              currentVersion: currentMemoryVersion,
+              userTurn: text,
+            });
+            this.log.info("dispatcher: injected memory update notice", {
+              agentId: msg.accountId,
+              roomId: msg.conversation.id,
+              topicId: msg.conversation.threadId ?? null,
+              turnId,
+              previousMemoryVersion,
+              currentMemoryVersion,
+            });
+          }
+        }
+      } catch (err) {
+        this.log.warn("buildMemoryContext threw — continuing without memory version check", {
+          error: err instanceof Error ? err.message : String(err),
+          messageId: msg.id,
+        });
+      }
+    }
+
     const runtime = this.runtimeFactory(route.runtime, route.extraArgs);
     let result: { text: string; newSessionId: string; costUsd?: number; error?: string } | undefined;
     let threw: unknown;
     try {
       try {
         result = await runtime.run({
-          text,
+          text: runtimeText,
           sessionId,
           cwd: route.cwd,
           accountId: msg.accountId,
@@ -1343,7 +1406,7 @@ export class Dispatcher {
             threadId: msg.conversation.threadId ?? null,
             type: "error",
             text: `⚠️ Runtime timeout after ${Math.round(this.turnTimeoutMs / 60000)} minute(s); aborted`,
-            replyTo: msg.id,
+            replyTo: this.providerReplyTo(msg),
             traceId: msg.trace?.id ?? null,
           }, turnId);
         } else {
@@ -1389,7 +1452,7 @@ export class Dispatcher {
             threadId: msg.conversation.threadId ?? null,
             type: "error",
             text: `⚠️ Runtime error: ${truncate(errMsg, 500)}`,
-            replyTo: msg.id,
+            replyTo: this.providerReplyTo(msg),
             traceId: msg.trace?.id ?? null,
           }, turnId);
         } else {
@@ -1438,6 +1501,7 @@ export class Dispatcher {
           key,
           runtime: route.runtime,
           runtimeSessionId: result.newSessionId,
+          memoryVersion: currentMemoryVersion ?? entry?.memoryVersion ?? null,
           channel: msg.channel,
           accountId: msg.accountId,
           conversationKind: msg.conversation.kind,
@@ -1494,7 +1558,7 @@ export class Dispatcher {
               threadId: msg.conversation.threadId ?? null,
               type: "error",
               text: `⚠️ Runtime error: ${truncate(result.error, 500)}`,
-              replyTo: msg.id,
+              replyTo: this.providerReplyTo(msg),
               traceId: msg.trace?.id ?? null,
             }, turnId);
             this.emitOutbound({
@@ -1571,7 +1635,7 @@ export class Dispatcher {
         conversationId: msg.conversation.id,
         threadId: msg.conversation.threadId ?? null,
         text: replyText,
-        replyTo: msg.id,
+        replyTo: this.providerReplyTo(msg),
         traceId: msg.trace?.id ?? null,
       }, turnId);
       this.emitOutbound({
@@ -1638,6 +1702,10 @@ export class Dispatcher {
     return { ok: true };
   }
 
+  private providerReplyTo(msg: GatewayInboundMessage): string {
+    return msg.replyTo ?? msg.id;
+  }
+
   private emitInbound(turnId: string, msg: GatewayInboundEnvelope["message"]): void {
     if (!this.transcript.enabled) return;
     const rawText = typeof msg.text === "string" ? msg.text : "";

package/src/gateway/gateway.ts

@@ -17,6 +17,7 @@ import type {
   GatewayRoute,
   GatewayRuntimeSnapshot,
   InboundObserver,
+  MemoryContextBuilder,
   OutboundObserver,
   SystemContextBuilder,
   UserTurnBuilder,
@@ -39,6 +40,11 @@ export interface GatewayBootOptions {
    * abort the turn.
    */
   buildSystemContext?: SystemContextBuilder;
+  /**
+   * Snapshot/version hook for working memory. Forwarded to dispatcher so
+   * resumed runtime sessions get an explicit prompt when memory changes.
+   */
+  buildMemoryContext?: MemoryContextBuilder;
   /**
    * Observer called after the dispatcher acks each inbound message. Useful
    * for activity tracking or metrics. Errors are logged and swallowed.
@@ -159,6 +165,7 @@ export class Gateway {
       log: this.log,
       turnTimeoutMs: opts.turnTimeoutMs,
       buildSystemContext: opts.buildSystemContext,
+      buildMemoryContext: opts.buildMemoryContext,
       onInbound: opts.onInbound,
       composeUserTurn: opts.composeUserTurn,
       onOutbound: opts.onOutbound,

package/src/gateway/types.ts

@@ -162,6 +162,14 @@ export type InboundObserver = (
  */
 export type UserTurnBuilder = (message: GatewayInboundMessage) => string;
 
+export interface MemoryContextSnapshot {
+  version: string;
+}
+
+export type MemoryContextBuilder = (
+  message: GatewayInboundMessage,
+) => Promise<MemoryContextSnapshot | null | undefined> | MemoryContextSnapshot | null | undefined;
+
 /**
  * Optional hook fired after the dispatcher dispatches a reply to a channel.
  * Intended for outbound bookkeeping (loop-risk tracking, metrics). Errors
@@ -448,6 +456,8 @@ export interface GatewaySessionEntry {
   key: string;
   runtime: string;
   runtimeSessionId: string;
+  /** Version of working memory last injected into this runtime session. */
+  memoryVersion?: string | null;
   channel: string;
   accountId: string;
   conversationKind: "direct" | "group";

package/src/working-memory.ts

@@ -17,6 +17,7 @@ import {
   unlinkSync,
   writeFileSync,
 } from "node:fs";
+import { createHash } from "node:crypto";
 import { homedir } from "node:os";
 import path from "node:path";
 import { agentStateDir } from "./agent-workspace.js";
@@ -30,6 +31,11 @@ export interface WorkingMemory {
   updatedAt: string;
 }
 
+export interface WorkingMemorySnapshot {
+  memory: WorkingMemory | null;
+  version: string;
+}
+
 /** v1 shape kept only for one-way migration on read. */
 interface WorkingMemoryV1 {
   version: 1;
@@ -205,6 +211,33 @@ export function readWorkingMemory(agentId: string): WorkingMemory | null {
   return normalize(readJson<unknown>(p));
 }
 
+function canonicalizeWorkingMemory(memory: WorkingMemory | null): unknown {
+  const sections: Record<string, string> = {};
+  for (const [key, value] of Object.entries(memory?.sections ?? {}).sort(([a], [b]) =>
+    a.localeCompare(b),
+  )) {
+    sections[key] = value;
+  }
+  return {
+    version: 2,
+    goal: memory?.goal ?? null,
+    sections,
+  };
+}
+
+export function workingMemoryVersion(memory: WorkingMemory | null): string {
+  const canonical = JSON.stringify(canonicalizeWorkingMemory(memory));
+  return `wm-sha256:${createHash("sha256").update(canonical).digest("hex").slice(0, 16)}`;
+}
+
+export function readWorkingMemorySnapshot(agentId: string): WorkingMemorySnapshot {
+  const memory = readWorkingMemory(agentId);
+  return {
+    memory,
+    version: workingMemoryVersion(memory),
+  };
+}
+
 export function writeWorkingMemory(agentId: string, data: WorkingMemory): void {
   writeJsonAtomic(workingMemoryPath(agentId), data);
 }