@qwen-code/qwen-code 0.19.9 → 0.19.10-nightly.20260716.506ce0a1a

package/chunks/{chunk-34Z3U5RQ.js → chunk-ZQIYGQCG.js}

@@ -12,32 +12,6 @@ import {
   __name
 } from "./chunk-J2S4EL5Y.js";
 
-// packages/channels/base/dist/paths.js
-init_esbuild_shims();
-import * as path from "node:path";
-import * as os from "node:os";
-function resolvePath(dir) {
-  let resolved = dir;
-  if (resolved === "~" || resolved.startsWith("~/") || resolved.startsWith("~\\")) {
-    const relativeSegments = resolved === "~" ? [] : resolved.slice(2).split(/[/\\]+/).filter(Boolean);
-    resolved = path.join(os.homedir(), ...relativeSegments);
-  }
-  if (!path.isAbsolute(resolved)) {
-    resolved = path.resolve(resolved);
-  }
-  return resolved;
-}
-__name(resolvePath, "resolvePath");
-function getGlobalQwenDir() {
-  const envDir = process.env["QWEN_HOME"];
-  if (envDir) {
-    return resolvePath(envDir);
-  }
-  const homeDir = os.homedir();
-  return homeDir ? path.join(homeDir, ".qwen") : path.join(os.tmpdir(), ".qwen");
-}
-__name(getGlobalQwenDir, "getGlobalQwenDir");
-
 // packages/channels/base/dist/sanitize.js
 init_esbuild_shims();
 var PROMPT_UNSAFE_INVISIBLES = new RegExp("[\\u0080-\\u009f\\p{Cf}\\u2028\\u2029]|\\p{Variation_Selector}", "gu");
@@ -74,6 +48,32 @@ __name(sanitizeLogText, "sanitizeLogText");
 // packages/channels/base/dist/index.js
 init_esbuild_shims();
 
+// packages/channels/base/dist/paths.js
+init_esbuild_shims();
+import * as path from "node:path";
+import * as os from "node:os";
+function resolvePath(dir) {
+  let resolved = dir;
+  if (resolved === "~" || resolved.startsWith("~/") || resolved.startsWith("~\\")) {
+    const relativeSegments = resolved === "~" ? [] : resolved.slice(2).split(/[/\\]+/).filter(Boolean);
+    resolved = path.join(os.homedir(), ...relativeSegments);
+  }
+  if (!path.isAbsolute(resolved)) {
+    resolved = path.resolve(resolved);
+  }
+  return resolved;
+}
+__name(resolvePath, "resolvePath");
+function getGlobalQwenDir() {
+  const envDir = process.env["QWEN_HOME"];
+  if (envDir) {
+    return resolvePath(envDir);
+  }
+  const homeDir = os.homedir();
+  return homeDir ? path.join(homeDir, ".qwen") : path.join(os.tmpdir(), ".qwen");
+}
+__name(getGlobalQwenDir, "getGlobalQwenDir");
+
 // packages/channels/base/dist/AcpBridge.js
 init_esbuild_shims();
 import { spawn } from "node:child_process";
@@ -361,15 +361,23 @@ var AcpBridge = class extends EventEmitter {
   async prompt(sessionId, text, options) {
     const conn = this.ensureConnection();
     const chunks = [];
+    let slashCommandOutput = "";
     const onChunk = /* @__PURE__ */ __name((sid, chunk) => {
       if (sid === sessionId)
         chunks.push(chunk);
     }, "onChunk");
-    const clearChunks = /* @__PURE__ */ __name((sid) => {
+    const onSlashCommandOutput = /* @__PURE__ */ __name((sid, chunk) => {
       if (sid === sessionId)
+        slashCommandOutput = chunk;
+    }, "onSlashCommandOutput");
+    const clearChunks = /* @__PURE__ */ __name((sid) => {
+      if (sid === sessionId) {
         chunks.length = 0;
+        slashCommandOutput = "";
+      }
     }, "clearChunks");
     this.on("textChunk", onChunk);
+    this.on("slashCommandOutput", onSlashCommandOutput);
     this.on("responseBoundary", clearChunks);
     const prompt = [];
     if (options?.imageBase64 && options.imageMimeType) {
@@ -387,9 +395,10 @@ var AcpBridge = class extends EventEmitter {
       });
     } finally {
       this.off("textChunk", onChunk);
+      this.off("slashCommandOutput", onSlashCommandOutput);
       this.off("responseBoundary", clearChunks);
     }
-    return chunks.join("");
+    return chunks.join("") || slashCommandOutput;
   }
   async cancelSession(sessionId) {
     const conn = this.ensureConnection();
@@ -432,9 +441,13 @@ var AcpBridge = class extends EventEmitter {
     const type = update["sessionUpdate"];
     switch (type) {
       case "agent_message_chunk": {
+        const meta = update["_meta"];
+        if (typeof meta?.["parentToolCallId"] === "string") {
+          break;
+        }
         const content = update["content"];
         if (content?.type === "text" && content.text) {
-          this.emit("textChunk", sessionId, content.text);
+          this.emit(meta?.["source"] === "slash_command" ? "slashCommandOutput" : "textChunk", sessionId, content.text);
         }
         break;
       }
@@ -707,6 +720,7 @@ var DaemonChannelBridge = class extends EventEmitter2 {
   }
   options;
   sessions = /* @__PURE__ */ new Map();
+  sessionBindingTokens = /* @__PURE__ */ new Map();
   eventControllers = /* @__PURE__ */ new Map();
   requestToSession = /* @__PURE__ */ new Map();
   respondedRequestToSession = /* @__PURE__ */ new Map();
@@ -715,6 +729,7 @@ var DaemonChannelBridge = class extends EventEmitter2 {
   availableCommandsBySession = /* @__PURE__ */ new Map();
   turnBarriers = /* @__PURE__ */ new Map();
   connected = false;
+  lifecycleGeneration = 0;
   latestAvailableCommandsSessionId;
   lastError;
   constructor(options) {
@@ -750,17 +765,22 @@ var DaemonChannelBridge = class extends EventEmitter2 {
   async start() {
     this.connected = true;
   }
-  async newSession(cwd, options) {
+  async newSession(cwd, options, bindingToken) {
+    const lifecycleGeneration = this.lifecycleGeneration;
     const session = await this.options.sessionFactory({
       workspaceCwd: cwd || this.options.cwd,
       modelServiceId: this.options.modelServiceId,
       sessionScope: this.options.sessionScope ?? "thread",
       ...options?.approvalMode ? { approvalMode: options.approvalMode } : {}
     });
-    this.attachSession(session);
+    if (lifecycleGeneration !== this.lifecycleGeneration) {
+      await this.rejectStaleSession(session);
+    }
+    this.attachSession(session, bindingToken);
     return session.sessionId;
   }
-  async loadSession(sessionId, cwd, options) {
+  async loadSession(sessionId, cwd, options, bindingToken) {
+    const lifecycleGeneration = this.lifecycleGeneration;
     const session = await this.options.sessionFactory({
       workspaceCwd: cwd || this.options.cwd,
       modelServiceId: this.options.modelServiceId,
@@ -768,10 +788,16 @@ var DaemonChannelBridge = class extends EventEmitter2 {
       sessionScope: this.options.sessionScope ?? "thread",
       ...options?.approvalMode ? { approvalMode: options.approvalMode } : {}
     });
+    if (lifecycleGeneration !== this.lifecycleGeneration) {
+      await this.rejectStaleSession(session);
+    }
     if (session.sessionId !== sessionId) {
+      void this.releaseSessionClient(session).catch((error) => {
+        this.lastError = error;
+      });
       throw new Error(`Daemon returned session ${session.sessionId} while loading ${sessionId}`);
     }
-    this.attachSession(session);
+    this.attachSession(session, bindingToken);
     return session.sessionId;
   }
   async prompt(sessionId, text, options) {
@@ -788,14 +814,21 @@ var DaemonChannelBridge = class extends EventEmitter2 {
     }
     controllers.add(controller);
     const chunks = [];
+    let slashCommandOutput = "";
     const onChunk = /* @__PURE__ */ __name((sid, chunk) => {
       if (sid === sessionId) {
         chunks.push(chunk);
       }
     }, "onChunk");
+    const onSlashCommandOutput = /* @__PURE__ */ __name((sid, chunk) => {
+      if (sid === sessionId) {
+        slashCommandOutput = chunk;
+      }
+    }, "onSlashCommandOutput");
     const clearChunks = /* @__PURE__ */ __name((sid) => {
       if (sid === sessionId) {
         chunks.length = 0;
+        slashCommandOutput = "";
       }
     }, "clearChunks");
     const onSessionDied = /* @__PURE__ */ __name((info) => {
@@ -804,6 +837,7 @@ var DaemonChannelBridge = class extends EventEmitter2 {
       }
     }, "onSessionDied");
     this.on("textChunk", onChunk);
+    this.on("slashCommandOutput", onSlashCommandOutput);
     this.on("responseBoundary", clearChunks);
     this.on("sessionDied", onSessionDied);
     const turnBarrier = this.createTurnBarrier(sessionId);
@@ -822,7 +856,7 @@ var DaemonChannelBridge = class extends EventEmitter2 {
         turnBarrier,
         new Promise((resolve2) => setTimeout(resolve2, 0))
       ]);
-      const textResult = chunks.join("");
+      const textResult = chunks.join("") || slashCommandOutput;
       this.emit("promptComplete", {
         sessionId,
         text: textResult,
@@ -832,6 +866,7 @@ var DaemonChannelBridge = class extends EventEmitter2 {
     } finally {
       this.clearTurnBarrier(sessionId);
       this.off("textChunk", onChunk);
+      this.off("slashCommandOutput", onSlashCommandOutput);
       this.off("responseBoundary", clearChunks);
       this.off("sessionDied", onSessionDied);
       this.activePrompts.delete(sessionId);
@@ -855,6 +890,25 @@ var DaemonChannelBridge = class extends EventEmitter2 {
     this.activePrompts.delete(sessionId);
     await session.cancel();
   }
+  async discardSession(sessionId, expectedBindingToken) {
+    if (expectedBindingToken !== void 0 && this.sessionBindingTokens.get(sessionId) !== expectedBindingToken) {
+      return;
+    }
+    const session = this.removeSessionBinding(sessionId);
+    if (!session)
+      return;
+    await this.releaseSessionClient(session);
+  }
+  async releaseSessionClient(session) {
+    if (session.detach) {
+      try {
+        await session.detach();
+        return;
+      } catch {
+      }
+    }
+    await session.cancel();
+  }
   async setSessionModel(sessionId, modelId) {
     return await this.ensureSession(sessionId).setModel(modelId);
   }
@@ -885,6 +939,7 @@ var DaemonChannelBridge = class extends EventEmitter2 {
     }
   }
   stop() {
+    this.lifecycleGeneration++;
     for (const sessionId of Array.from(this.sessions.keys())) {
       const session = this.sessions.get(sessionId);
       if (session) {
@@ -892,7 +947,7 @@ var DaemonChannelBridge = class extends EventEmitter2 {
           this.lastError = error;
         });
       }
-      this.dropSession(sessionId, "bridge_stopped");
+      this.dropSession(sessionId, "bridge_stopped", false);
     }
     this.latestAvailableCommandsSessionId = void 0;
     this.connected = false;
@@ -900,15 +955,29 @@ var DaemonChannelBridge = class extends EventEmitter2 {
   get isConnected() {
     return this.connected;
   }
-  attachSession(session) {
-    if (this.sessions.has(session.sessionId)) {
-      this.dropSession(session.sessionId, "session_replaced");
+  attachSession(session, bindingToken) {
+    const replacedSession = this.removeSessionBinding(session.sessionId);
+    if (replacedSession) {
+      void this.releaseSessionClient(replacedSession).catch((error) => {
+        this.lastError = error;
+      });
+      this.emit("sessionDied", {
+        sessionId: session.sessionId,
+        reason: "session_replaced"
+      });
     }
     this.sessions.set(session.sessionId, session);
+    this.sessionBindingTokens.set(session.sessionId, bindingToken);
     const controller = new AbortController();
     this.eventControllers.set(session.sessionId, controller);
     void this.pumpEvents(session, controller.signal);
   }
+  async rejectStaleSession(session) {
+    void this.releaseSessionClient(session).catch((error) => {
+      this.lastError = error;
+    });
+    throw new Error("Daemon channel bridge stopped during session creation");
+  }
   ensureSession(sessionId) {
     const session = this.sessions.get(sessionId);
     if (!session) {
@@ -944,6 +1013,9 @@ var DaemonChannelBridge = class extends EventEmitter2 {
   handleEvent(session, event) {
     switch (event.type) {
       case "session_update":
+        if (isRecord(event.data) && typeof event.data["sessionId"] === "string" && event.data["sessionId"] !== session.sessionId) {
+          break;
+        }
         this.handleSessionUpdate(session.sessionId, event.data);
         break;
       case "permission_request":
@@ -987,9 +1059,13 @@ var DaemonChannelBridge = class extends EventEmitter2 {
     const type = getString(update["sessionUpdate"]);
     switch (type) {
       case "agent_message_chunk": {
+        const meta = isRecord(update["_meta"]) ? update["_meta"] : void 0;
+        if (typeof meta?.["parentToolCallId"] === "string") {
+          break;
+        }
         const text = getTextContent(update["content"]);
         if (text) {
-          this.emit("textChunk", sessionId, text);
+          this.emit(meta?.["source"] === "slash_command" ? "slashCommandOutput" : "textChunk", sessionId, text);
         }
         break;
       }
@@ -1004,6 +1080,10 @@ var DaemonChannelBridge = class extends EventEmitter2 {
       case "tool_call_update": {
         const toolCallId = getString(update["toolCallId"]);
         const kind = getString(update["kind"]);
+        const meta = isRecord(update["_meta"]) ? update["_meta"] : void 0;
+        if (!kind && toolCallId && getString(update["status"]) === "in_progress" && meta?.["shellProgress"] !== void 0) {
+          break;
+        }
         if (!toolCallId || !kind) {
           this.emitProtocolError(`Malformed daemon ${type} event`, update);
           break;
@@ -1123,14 +1203,26 @@ var DaemonChannelBridge = class extends EventEmitter2 {
   handleSessionDied(sessionId, data) {
     this.dropSession(sessionId, this.getStringField(data, "reason", "session_died"));
   }
-  dropSession(sessionId, reason) {
-    if (!this.sessions.has(sessionId)) {
+  dropSession(sessionId, reason, releaseClient = true) {
+    const session = this.removeSessionBinding(sessionId);
+    if (!session)
       return;
+    if (releaseClient) {
+      void this.releaseSessionClient(session).catch((error) => {
+        this.lastError = error;
+      });
     }
+    this.emit("sessionDied", { sessionId, reason });
+  }
+  removeSessionBinding(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session)
+      return void 0;
     this.resolveTurnBarrier(sessionId);
     this.eventControllers.get(sessionId)?.abort();
     this.eventControllers.delete(sessionId);
     this.sessions.delete(sessionId);
+    this.sessionBindingTokens.delete(sessionId);
     this.abortActivePrompts(sessionId);
     this.activePrompts.delete(sessionId);
     this.availableCommandsBySession.delete(sessionId);
@@ -1147,7 +1239,7 @@ var DaemonChannelBridge = class extends EventEmitter2 {
         this.respondedRequestToSession.delete(requestId);
       }
     }
-    this.emit("sessionDied", { sessionId, reason });
+    return session;
   }
   getStringField(data, field, fallback) {
     return isRecord(data) && typeof data[field] === "string" ? data[field] : fallback;
@@ -1295,7 +1387,7 @@ var BlockStreamer = class {
 
 // packages/channels/base/dist/ChannelBase.js
 init_esbuild_shims();
-import { basename, join as join4 } from "node:path";
+import { basename, join as join5 } from "node:path";
 
 // packages/channels/base/dist/GroupGate.js
 init_esbuild_shims();
@@ -1770,7 +1862,8 @@ __name(generateCode, "generateCode");
 
 // packages/channels/base/dist/SessionRouter.js
 init_esbuild_shims();
-import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3, unlinkSync } from "node:fs";
+import { chmodSync as chmodSync2, existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync as renameSync2, rmSync, unlinkSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname2, join as join4 } from "node:path";
 import process2 from "node:process";
 var SessionRouter = class {
   static {
@@ -1784,17 +1877,22 @@ var SessionRouter = class {
   // session ID → cwd
   creatingSessions = /* @__PURE__ */ new Map();
   sessionLoadWindows = /* @__PURE__ */ new Set();
+  liveSessionIds = /* @__PURE__ */ new Set();
+  routeTokens = /* @__PURE__ */ new Map();
+  lifecycleGeneration = 0;
   bridge;
   defaultCwd;
   defaultScope;
   channelScopes = /* @__PURE__ */ new Map();
   channelApprovalModes = /* @__PURE__ */ new Map();
   persistPath;
-  constructor(bridge, defaultCwd, scope = "user", persistPath) {
+  recoveryMode;
+  constructor(bridge, defaultCwd, scope = "user", persistPath, options = {}) {
     this.bridge = bridge;
     this.defaultCwd = defaultCwd;
     this.defaultScope = scope;
     this.persistPath = persistPath;
+    this.recoveryMode = options.recoveryMode ?? "eager";
   }
   /** Replace the bridge instance (used after crash recovery restart). */
   setBridge(bridge) {
@@ -1829,58 +1927,166 @@ var SessionRouter = class {
   }
   async resolve(channelName, senderId, chatId, threadId, cwd, isGroup, options) {
     const key = this.routingKey(channelName, senderId, chatId, options?.routingThreadId ?? threadId);
-    let failedCreateWaits = 0;
+    const input = {
+      channelName,
+      senderId,
+      chatId,
+      threadId,
+      cwd: cwd || this.defaultCwd,
+      isGroup
+    };
+    let failedWaits = 0;
     for (; ; ) {
       const existing = this.toSession.get(key);
-      if (existing) {
+      if (existing && this.isLive(existing)) {
         this.promoteTargetToGroup(existing, isGroup);
         return existing;
       }
       const creating = this.creatingSessions.get(key);
       if (creating) {
         try {
-          const sessionId = await creating;
+          const sessionId = await creating.promise;
+          try {
+            this.assertOperationResultCurrent(key, sessionId, creating);
+          } catch (error) {
+            this.scheduleDiscardInvalidatedSession(sessionId, creating);
+            throw error;
+          }
           this.promoteTargetToGroup(sessionId, isGroup);
           return sessionId;
-        } catch (err) {
+        } catch (error) {
+          if (creating.invalidationError) {
+            throw creating.invalidationError;
+          }
           if (this.creatingSessions.get(key) === creating) {
             this.creatingSessions.delete(key);
           }
-          failedCreateWaits++;
-          if (failedCreateWaits > 3) {
-            throw err;
-          }
+          this.releaseRouteToken(key, creating);
+          failedWaits++;
+          if (failedWaits > 3)
+            throw error;
           continue;
         }
       }
-      const created = Promise.resolve().then(async () => {
-        const sessionCwd = cwd || this.defaultCwd;
-        const loadWindow = this.beginSessionLoad();
+      const operation = this.createSessionOperation(key, {
+        channelName: input.channelName,
+        senderId: input.senderId,
+        chatId: input.chatId,
+        threadId: input.threadId,
+        isGroup: input.isGroup
+      }, (currentOperation) => existing ? this.loadOrReplaceSession(key, existing, input, currentOperation) : this.createAndStoreSession(key, input, currentOperation));
+      this.creatingSessions.set(key, operation);
+      try {
+        const sessionId = await operation.promise;
         try {
-          const sessionId = await this.createLiveSession(sessionCwd, loadWindow, key, this.sessionOptions(channelName));
-          this.toSession.set(key, sessionId);
-          this.toTarget.set(sessionId, {
-            channelName,
-            senderId,
-            chatId,
-            threadId,
-            isGroup
-          });
-          this.toCwd.set(sessionId, sessionCwd);
-          this.persist();
-          return sessionId;
-        } finally {
-          this.endSessionLoad(loadWindow);
+          this.assertOperationResultCurrent(key, sessionId, operation);
+        } catch (error) {
+          this.scheduleDiscardInvalidatedSession(sessionId, operation);
+          throw error;
         }
-      });
-      this.creatingSessions.set(key, created);
-      try {
-        return await created;
+        this.promoteTargetToGroup(sessionId, isGroup);
+        return sessionId;
       } finally {
-        if (this.creatingSessions.get(key) === created) {
+        if (this.creatingSessions.get(key) === operation) {
           this.creatingSessions.delete(key);
         }
+        this.releaseRouteToken(key, operation);
+      }
+    }
+  }
+  isLive(sessionId) {
+    return this.recoveryMode === "eager" || this.liveSessionIds.has(sessionId);
+  }
+  async createAndStoreSession(key, input, operation) {
+    const loadWindow = this.beginSessionLoad();
+    try {
+      const sessionId = await this.createLiveSession(input.cwd, loadWindow, key, this.sessionOptions(input.channelName), operation);
+      try {
+        this.assertOperationCurrent(operation);
+      } catch (error) {
+        this.scheduleDiscardInvalidatedSession(sessionId, operation);
+        throw error;
+      }
+      this.toSession.set(key, sessionId);
+      this.toTarget.set(sessionId, {
+        channelName: input.channelName,
+        senderId: input.senderId,
+        chatId: input.chatId,
+        threadId: input.threadId,
+        isGroup: input.isGroup
+      });
+      this.toCwd.set(sessionId, input.cwd);
+      this.liveSessionIds.add(sessionId);
+      this.persist();
+      return sessionId;
+    } finally {
+      this.endSessionLoad(loadWindow);
+    }
+  }
+  async loadOrReplaceSession(key, savedSessionId, input, operation) {
+    const savedCwd = this.toCwd.get(savedSessionId) ?? input.cwd;
+    const loadWindow = this.beginSessionLoad();
+    try {
+      try {
+        const loadedSessionId = await this.bridge.loadSession(savedSessionId, savedCwd, this.sessionOptions(input.channelName), operation);
+        try {
+          this.assertOperationCurrent(operation);
+          if (this.toSession.get(key) !== savedSessionId) {
+            this.invalidateOperation(operation);
+            this.assertOperationCurrent(operation);
+          }
+        } catch (error) {
+          this.scheduleDiscardInvalidatedSession(loadedSessionId, operation);
+          throw error;
+        }
+        if (typeof loadedSessionId !== "string" || loadedSessionId.length === 0 || loadWindow.delete(loadedSessionId)) {
+          throw new Error("Invalid or dead restored session ID");
+        }
+        if (loadedSessionId !== savedSessionId) {
+          const target = this.toTarget.get(savedSessionId);
+          this.deleteByKey(key);
+          this.toSession.set(key, loadedSessionId);
+          if (target)
+            this.toTarget.set(loadedSessionId, target);
+          this.toCwd.set(loadedSessionId, savedCwd);
+          this.persist();
+        }
+        this.liveSessionIds.add(loadedSessionId);
+        return loadedSessionId;
+      } catch (loadError) {
+        this.assertOperationCurrent(operation);
+        try {
+          const replacement = await this.createLiveSession(input.cwd, loadWindow, key, this.sessionOptions(input.channelName), operation);
+          try {
+            this.assertOperationCurrent(operation);
+          } catch (error) {
+            this.scheduleDiscardInvalidatedSession(replacement, operation);
+            throw error;
+          }
+          this.deleteByKey(key);
+          this.toSession.set(key, replacement);
+          this.toTarget.set(replacement, {
+            channelName: input.channelName,
+            senderId: input.senderId,
+            chatId: input.chatId,
+            threadId: input.threadId,
+            isGroup: input.isGroup
+          });
+          this.toCwd.set(replacement, input.cwd);
+          this.liveSessionIds.add(replacement);
+          this.persist();
+          process2.stderr.write(`[SessionRouter] Replaced unavailable session ${sanitizeLogText(savedSessionId, 128)} for key ${sanitizeLogText(key, 256)} after load failed: ${sanitizeLogText(loadError instanceof Error ? loadError.message : String(loadError), 512)}
+`);
+          return replacement;
+        } catch (createError) {
+          this.assertOperationCurrent(operation);
+          process2.stderr.write(`[SessionRouter] Failed to load session ${sanitizeLogText(savedSessionId, 128)} for key ${sanitizeLogText(key, 256)} (${sanitizeLogText(loadError instanceof Error ? loadError.message : String(loadError), 512)}) and failed to create a replacement (${sanitizeLogText(createError instanceof Error ? createError.message : String(createError), 512)})
+`);
+          throw createError;
+        }
       }
+    } finally {
+      this.endSessionLoad(loadWindow);
     }
   }
   getTarget(sessionId) {
@@ -1912,6 +2118,7 @@ var SessionRouter = class {
     const scope = this.channelScopes.get(channelName) || this.defaultScope;
     if (chatId) {
       const key = this.routingKey(channelName, senderId, chatId, threadId);
+      this.invalidateRouteOperation(key);
       const sessionId = this.deleteByKey(key);
       if (sessionId)
         removedIds.push(sessionId);
@@ -1921,11 +2128,17 @@ var SessionRouter = class {
       for (const [k, mappedSessionId] of [...this.toSession.entries()]) {
         const target = this.toTarget.get(mappedSessionId);
         if (target?.channelName === channelName && target.senderId === senderId) {
+          this.invalidateRouteOperation(k);
           const sessionId = this.deleteByKey(k);
           if (sessionId)
             removedIds.push(sessionId);
         }
       }
+      for (const [key, operation] of [...this.creatingSessions]) {
+        if (operation.target.channelName === channelName && operation.target.senderId === senderId) {
+          this.invalidateRouteOperation(key);
+        }
+      }
     }
     if (removedIds.length > 0)
       this.persist();
@@ -1936,6 +2149,7 @@ var SessionRouter = class {
     let removed = false;
     for (const [key, mappedSessionId] of [...this.toSession.entries()]) {
       if (mappedSessionId === sessionId) {
+        this.invalidateRouteOperation(key);
         this.toSession.delete(key);
         removed = true;
       }
@@ -1946,6 +2160,7 @@ var SessionRouter = class {
     if (this.toCwd.delete(sessionId)) {
       removed = true;
     }
+    this.liveSessionIds.delete(sessionId);
     if (!removed && this.sessionLoadWindows.size > 0) {
       for (const loadWindow of this.sessionLoadWindows) {
         loadWindow.add(sessionId);
@@ -1956,6 +2171,17 @@ var SessionRouter = class {
     }
     return removed;
   }
+  handleSessionDied(sessionId) {
+    if (this.recoveryMode === "eager") {
+      return this.removeSessionId(sessionId);
+    }
+    const known = this.toTarget.has(sessionId);
+    this.liveSessionIds.delete(sessionId);
+    for (const loadWindow of this.sessionLoadWindows) {
+      loadWindow.add(sessionId);
+    }
+    return known;
+  }
   deleteByKey(key) {
     const sessionId = this.toSession.get(key);
     if (!sessionId)
@@ -1963,6 +2189,7 @@ var SessionRouter = class {
     this.toSession.delete(key);
     this.toTarget.delete(sessionId);
     this.toCwd.delete(sessionId);
+    this.liveSessionIds.delete(sessionId);
     return sessionId;
   }
   promoteTargetToGroup(sessionId, isGroup) {
@@ -1985,45 +2212,69 @@ var SessionRouter = class {
     }
     return entries;
   }
+  restoreRoutes() {
+    if (this.recoveryMode !== "lazy") {
+      throw new Error("restoreRoutes requires lazy recovery mode");
+    }
+    const persisted = this.readPersistedEntries();
+    if (!persisted)
+      return { restored: 0, dropped: 0 };
+    this.dispose();
+    let restored = 0;
+    for (const [key, entry] of Object.entries(persisted.entries)) {
+      this.toSession.set(key, entry.sessionId);
+      this.toTarget.set(entry.sessionId, entry.target);
+      this.toCwd.set(entry.sessionId, entry.cwd);
+      restored++;
+    }
+    if (persisted.dropped > 0)
+      this.persist();
+    return { restored, dropped: persisted.dropped };
+  }
   /**
    * Restore session mappings from a previous bridge.
    * Called after bridge restart — attempts loadSession for each saved mapping.
    * Failed loads are dropped (new session on next message).
    */
   async restoreSessions() {
-    const persistPath = this.persistPath;
-    if (!persistPath || !existsSync3(persistPath)) {
-      return { restored: 0, failed: 0 };
-    }
-    let entries;
-    try {
-      entries = JSON.parse(readFileSync3(persistPath, "utf-8"));
-    } catch (err) {
-      const reason = err instanceof Error ? err.message : String(err);
-      process2.stderr.write(`[SessionRouter] Corrupted persist file at ${sanitizeLogText(persistPath, 1024)}: ${sanitizeLogText(reason, 512)}
-`);
+    const persisted = this.readPersistedEntries();
+    if (!persisted)
       return { restored: 0, failed: 0 };
-    }
+    const entries = persisted.entries;
+    const restoreGeneration = this.lifecycleGeneration;
     let restored = 0;
     let failed = 0;
-    let changed = false;
+    let changed = persisted.dropped > 0;
     const reservations = /* @__PURE__ */ new Map();
+    for (const key of persisted.droppedKeys) {
+      this.deleteByKey(key);
+    }
     for (const key of Object.keys(entries)) {
       this.deleteByKey(key);
       const reservation = this.createSessionReservation();
       reservation.promise.catch(() => void 0);
-      this.creatingSessions.set(key, reservation.promise);
-      reservations.set(key, reservation);
+      const operation = this.createSessionOperation(key, entries[key].target, () => reservation.promise);
+      operation.promise.catch(() => void 0);
+      this.creatingSessions.set(key, operation);
+      reservations.set(key, { reservation, operation });
     }
     const loadWindow = this.beginSessionLoad();
     try {
       for (const [key, entry] of Object.entries(entries)) {
-        const reservation = reservations.get(key);
-        if (!reservation)
+        const reserved = reservations.get(key);
+        if (!reserved)
           continue;
+        const { reservation, operation } = reserved;
         try {
+          this.assertOperationCurrent(operation);
           const options = this.sessionOptions(entry.target.channelName);
-          const sessionId = options ? await this.bridge.loadSession(entry.sessionId, entry.cwd, options) : await this.bridge.loadSession(entry.sessionId, entry.cwd);
+          const sessionId = await this.bridge.loadSession(entry.sessionId, entry.cwd, options, operation);
+          try {
+            this.assertOperationCurrent(operation);
+          } catch (error) {
+            this.scheduleDiscardInvalidatedSession(sessionId, operation);
+            throw error;
+          }
           if (typeof sessionId !== "string" || sessionId.length === 0) {
             throw new Error("Invalid restored session ID");
           }
@@ -2046,26 +2297,36 @@ var SessionRouter = class {
           failed++;
           changed = true;
         } finally {
-          if (this.creatingSessions.get(key) === reservation.promise) {
+          if (this.creatingSessions.get(key) === operation) {
             this.creatingSessions.delete(key);
           }
+          this.releaseRouteToken(key, operation);
         }
       }
     } finally {
       this.endSessionLoad(loadWindow);
     }
-    if (changed) {
+    if (changed && restoreGeneration === this.lifecycleGeneration) {
       this.persist();
     }
     return { restored, failed };
   }
-  /** Clear in-memory state and delete persist file. Used on clean shutdown. */
-  clearAll() {
+  dispose() {
+    this.lifecycleGeneration++;
+    for (const operation of this.creatingSessions.values()) {
+      this.invalidateOperation(operation);
+    }
     this.toSession.clear();
     this.toTarget.clear();
     this.toCwd.clear();
     this.creatingSessions.clear();
     this.sessionLoadWindows.clear();
+    this.liveSessionIds.clear();
+    this.routeTokens.clear();
+  }
+  /** Clear in-memory state and delete persist file. Used on clean shutdown. */
+  clearAll() {
+    this.dispose();
     if (this.persistPath && existsSync3(this.persistPath)) {
       try {
         unlinkSync(this.persistPath);
@@ -2073,30 +2334,105 @@ var SessionRouter = class {
       }
     }
   }
+  readPersistedEntries() {
+    const persistPath = this.persistPath;
+    if (!persistPath || !existsSync3(persistPath))
+      return void 0;
+    let parsed;
+    try {
+      parsed = JSON.parse(readFileSync3(persistPath, "utf-8"));
+    } catch (error) {
+      const quarantinePath = `${persistPath}.corrupt-${Date.now()}`;
+      try {
+        renameSync2(persistPath, quarantinePath);
+      } catch {
+      }
+      process2.stderr.write(`[SessionRouter] Corrupted persist file at ${sanitizeLogText(persistPath, 1024)}: ${sanitizeLogText(error instanceof Error ? error.message : String(error), 512)}
+`);
+      return void 0;
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      const quarantinePath = `${persistPath}.corrupt-${Date.now()}`;
+      try {
+        renameSync2(persistPath, quarantinePath);
+      } catch {
+      }
+      process2.stderr.write(`[SessionRouter] Invalid route store at ${sanitizeLogText(persistPath, 1024)}: expected an object
+`);
+      return void 0;
+    }
+    const entries = {};
+    const droppedKeys = [];
+    for (const [key, value] of Object.entries(parsed)) {
+      if (this.isPersistedEntry(value))
+        entries[key] = value;
+      else
+        droppedKeys.push(key);
+    }
+    return { entries, dropped: droppedKeys.length, droppedKeys };
+  }
+  isPersistedEntry(value) {
+    if (typeof value !== "object" || value === null)
+      return false;
+    const entry = value;
+    const target = entry["target"];
+    if (typeof target !== "object" || target === null)
+      return false;
+    const typedTarget = target;
+    return typeof entry["sessionId"] === "string" && entry["sessionId"].length > 0 && typeof entry["cwd"] === "string" && entry["cwd"].length > 0 && typeof typedTarget["channelName"] === "string" && typeof typedTarget["senderId"] === "string" && typeof typedTarget["chatId"] === "string" && (typedTarget["threadId"] === void 0 || typeof typedTarget["threadId"] === "string") && (typedTarget["isGroup"] === void 0 || typeof typedTarget["isGroup"] === "boolean");
+  }
   persist() {
     if (!this.persistPath)
       return;
     const data = {};
     for (const [key, sessionId] of this.toSession) {
       const target = this.toTarget.get(sessionId);
-      if (target) {
-        data[key] = {
-          sessionId,
-          target,
-          cwd: this.toCwd.get(sessionId) || this.defaultCwd
-        };
-      }
+      if (!target)
+        continue;
+      data[key] = {
+        sessionId,
+        target,
+        cwd: this.toCwd.get(sessionId) ?? this.defaultCwd
+      };
     }
+    const dir = dirname2(this.persistPath);
+    const tempPath = join4(dir, `${Date.now()}-${process2.pid}-${Math.random().toString(16).slice(2)}.tmp`);
     try {
-      writeFileSync3(this.persistPath, JSON.stringify(data, null, 2), "utf-8");
-    } catch {
+      mkdirSync3(dir, { recursive: true, mode: 448 });
+      try {
+        chmodSync2(dir, 448);
+      } catch {
+      }
+      writeFileSync3(tempPath, JSON.stringify(data, null, 2), {
+        encoding: "utf-8",
+        mode: 384
+      });
+      renameSync2(tempPath, this.persistPath);
+      try {
+        chmodSync2(this.persistPath, 384);
+      } catch {
+      }
+    } catch (error) {
+      process2.stderr.write(`[SessionRouter] Failed to persist routes at ${sanitizeLogText(this.persistPath, 1024)}: ${sanitizeLogText(error instanceof Error ? error.message : String(error), 512)}
+`);
+    } finally {
+      try {
+        rmSync(tempPath, { force: true });
+      } catch {
+      }
     }
   }
-  async createLiveSession(cwd, loadWindow, routingKey, options) {
+  async createLiveSession(cwd, loadWindow, routingKey, options, operation) {
     const maxAttempts = 2;
     let lastDeadSessionId;
     for (let attempt = 0; attempt < maxAttempts; attempt++) {
-      const sessionId = options ? await this.bridge.newSession(cwd, options) : await this.bridge.newSession(cwd);
+      const sessionId = await this.bridge.newSession(cwd, options, operation);
+      try {
+        this.assertOperationCurrent(operation);
+      } catch (error) {
+        this.scheduleDiscardInvalidatedSession(sessionId, operation);
+        throw error;
+      }
       if (typeof sessionId !== "string" || sessionId.length === 0) {
         throw new Error("Invalid session ID from bridge");
       }
@@ -2112,6 +2448,65 @@ var SessionRouter = class {
     this.sessionLoadWindows.add(loadWindow);
     return loadWindow;
   }
+  createSessionOperation(key, target, run) {
+    let routeToken = this.routeTokens.get(key);
+    if (!routeToken) {
+      routeToken = {};
+      this.routeTokens.set(key, routeToken);
+    }
+    const operation = {
+      promise: Promise.resolve(""),
+      target,
+      lifecycleGeneration: this.lifecycleGeneration,
+      routeToken
+    };
+    operation.promise = Promise.resolve().then(() => run(operation)).catch((error) => {
+      this.assertOperationCurrent(operation);
+      throw error;
+    });
+    return operation;
+  }
+  invalidateRouteOperation(key) {
+    this.routeTokens.delete(key);
+    const operation = this.creatingSessions.get(key);
+    if (!operation)
+      return;
+    this.invalidateOperation(operation);
+    this.creatingSessions.delete(key);
+  }
+  invalidateOperation(operation) {
+    operation.invalidationError ??= new Error("Session route operation was invalidated");
+  }
+  assertOperationCurrent(operation) {
+    if (operation.lifecycleGeneration !== this.lifecycleGeneration) {
+      this.invalidateOperation(operation);
+    }
+    if (operation.invalidationError) {
+      throw operation.invalidationError;
+    }
+  }
+  assertOperationResultCurrent(key, sessionId, operation) {
+    if (operation.routeToken !== this.routeTokens.get(key)) {
+      this.invalidateOperation(operation);
+    }
+    if (this.toSession.get(key) !== sessionId) {
+      this.invalidateOperation(operation);
+    }
+    this.assertOperationCurrent(operation);
+  }
+  releaseRouteToken(key, operation) {
+    if (this.routeTokens.get(key) === operation.routeToken && !this.toSession.has(key) && !this.creatingSessions.has(key)) {
+      this.routeTokens.delete(key);
+    }
+  }
+  scheduleDiscardInvalidatedSession(sessionId, operation) {
+    if ([...this.toSession.values()].includes(sessionId))
+      return;
+    try {
+      void this.bridge.discardSession?.(sessionId, operation).catch(() => void 0);
+    } catch {
+    }
+  }
   createSessionReservation() {
     let resolveReservation;
     let rejectReservation;
@@ -2488,6 +2883,29 @@ var LIST_PATTERNS = [
   /^这个聊天你记住了什么[?？]?$/u,
   /^what do you remember[?？]?$/iu
 ];
+var LIST_PAGE_PATTERNS = [
+  /^查看第\s*(\d+)\s*页记忆$/u,
+  /^show memory page\s+(\d+)$/iu
+];
+var INSPECT_PATTERNS = [
+  /^查看记忆\s+(\S+)$/u,
+  /^show memory\s+(\S+)$/iu
+];
+var REMOVE_PATTERNS = [
+  /^忘掉\s+(\S+)$/u,
+  /^删除\s+(\S+)$/u,
+  /^删掉\s+(\S+)$/u,
+  /^forget\s+(\S+)$/iu,
+  /^delete\s+(\S+)$/iu,
+  /^remove\s+(\S+)$/iu
+];
+var UPDATE_PATTERNS = [
+  /^把\s+(\S+)\s+改成\s*(.+)$/su,
+  /^更新\s+(\S+)\s+为\s*(.+)$/su,
+  /^update\s+(\S+)\s+to\s+(.+)$/isu,
+  /^change\s+(\S+)\s+to\s+(.+)$/isu
+];
+var MEMORY_ID_PATTERN = /^m-[a-f0-9]{12}$/u;
 var CLEAR_REQUEST_PATTERNS = [
   /^清空记忆$/u,
   /^清除记忆$/u,
@@ -2510,14 +2928,41 @@ function parseChannelMemoryIntent(text) {
       return { kind: "clear_confirm" };
     }
   }
+  for (const pattern of REMOVE_PATTERNS) {
+    const match = trimmed.match(pattern);
+    if (match?.[1] && MEMORY_ID_PATTERN.test(match[1])) {
+      return { kind: "remove", id: match[1] };
+    }
+  }
+  for (const pattern of UPDATE_PATTERNS) {
+    const match = trimmed.match(pattern);
+    const id = match?.[1];
+    const updated = match?.[2]?.trim();
+    if (id && updated && MEMORY_ID_PATTERN.test(id)) {
+      return { kind: "update", id, text: updated };
+    }
+  }
   for (const pattern of CLEAR_REQUEST_PATTERNS) {
     if (pattern.test(trimmed)) {
       return { kind: "clear_request" };
     }
   }
+  for (const pattern of INSPECT_PATTERNS) {
+    const match = trimmed.match(pattern);
+    if (match?.[1] && MEMORY_ID_PATTERN.test(match[1])) {
+      return { kind: "inspect", id: match[1] };
+    }
+  }
+  for (const pattern of LIST_PAGE_PATTERNS) {
+    const match = trimmed.match(pattern);
+    if (match?.[1]) {
+      const page = Number(match[1]);
+      return Number.isSafeInteger(page) && page > 0 ? { kind: "list", page } : null;
+    }
+  }
   for (const pattern of LIST_PATTERNS) {
     if (pattern.test(trimmed)) {
-      return { kind: "list" };
+      return { kind: "list", page: 1 };
     }
   }
   for (const pattern of REMEMBER_PATTERNS) {
@@ -2539,8 +2984,10 @@ var GROUP_HISTORY_ENTRY_TEXT_LIMIT = 1e3;
 var GROUP_HISTORY_ENTRY_METADATA_LIMIT = 256;
 var LOOP_CANCEL_GRACE_MS = 5e3;
 var CHANNEL_MEMORY_PROMPT_CODE_POINT_LIMIT = 12e3;
+var CHANNEL_MEMORY_PAGE_SIZE = 20;
+var CHANNEL_MEMORY_PREVIEW_CODE_POINT_LIMIT = 160;
 var CHANNEL_MEMORY_CLASSIFIER_MIN_CONFIDENCE = 0.7;
-var CHANNEL_MEMORY_CLASSIFIER_TRIGGER_RE = /(记住|记得|记一下|记忆|忘掉|忘记|清空|清除|删除|保存|remember|memory|forget)/iu;
+var CHANNEL_MEMORY_CLASSIFIER_TRIGGER_RE = /(?:记住|记得|记一下|记忆|忘掉|忘记|清空|清除|删除|删掉|改成|更新|刚才那条|保存|(?:只|仅)(?:看|列出)[\p{Script=Han}\s]{0,12}(?:偏好|习惯)|\b(?:remember|memory|forget|delete|remove|update|change)\b)/iu;
 var LOOP_TIMED_OUT_MESSAGE = "loop timed out";
 var DEBUG_PAYLOAD_ENV = "QWEN_CHANNEL_DEBUG_PAYLOAD";
 var DEBUG_PAYLOAD_LIMIT = 12e3;
@@ -2750,7 +3197,7 @@ var ChannelBase = class {
     this.memoryScope = Object.freeze(this.resolveMemoryScope(name, config));
     this.channelMemory = options?.channelMemory;
     this.memoryIntentClassifier = options?.memoryIntentClassifier;
-    this.groupHistory = new GroupHistoryStore(options?.groupHistoryPath ?? join4(getGlobalQwenDir(), "channels", `${encodeURIComponent(name)}-group-history.jsonl`));
+    this.groupHistory = new GroupHistoryStore(options?.groupHistoryPath ?? join5(getGlobalQwenDir(), "channels", `${encodeURIComponent(name)}-group-history.jsonl`));
     this.loopController = options?.loopController;
     this.groupGate = new GroupGate(config.groupPolicy, config.groups);
     this.dmGate = new DmGate(config.dmPolicy);
@@ -2862,6 +3309,9 @@ var ChannelBase = class {
   supportsProactiveTarget(target) {
     return target.threadId === void 0;
   }
+  supportsProactiveWebhookTarget(target) {
+    return this.supportsProactiveTarget(target);
+  }
   async pushProactive(target, text) {
     if (target.threadId) {
       throw new Error("Channel does not support proactive loop messages for threaded targets.");
@@ -3147,7 +3597,7 @@ ${sanitizePromptText(job.prompt)}`;
       throw new Error(`Unknown webhook source "${task.source}".`);
     }
     const target = resolveChannelWebhookTarget(this.name, this.config.webhooks, task.source, task.targetRef);
-    if (!this.supportsProactiveTarget(target)) {
+    if (!this.supportsProactiveWebhookTarget(target)) {
       throw new Error("Channel does not support proactive webhook messages for this chat target.");
     }
     return target;
@@ -3444,7 +3894,7 @@ ${sanitizePromptText(job.prompt)}`;
   onToolCall(_chatId, _event) {
   }
   onSessionDied(sessionId) {
-    this.router.removeSessionId(sessionId);
+    this.router.handleSessionDied(sessionId);
     this.instructedSessions.delete(sessionId);
     this.removePendingPermissionsForSession(sessionId);
   }
@@ -3492,13 +3942,16 @@ ${sanitizePromptText(job.prompt)}`;
    */
   onResponseBoundary(_chatId, _sessionId) {
   }
+  async sendResponseMessage(chatId, text, _sessionId) {
+    await this.sendMessage(chatId, text);
+  }
   /**
    * Called when the agent's full response is ready.
    * Override to customize delivery (e.g., finalize an AI card).
-   * Default: calls sendMessage() with the full response text.
+   * Default: sends the full response text.
    */
-  async onResponseComplete(chatId, fullText, _sessionId) {
-    await this.sendMessage(chatId, fullText);
+  async onResponseComplete(chatId, fullText, sessionId) {
+    await this.sendResponseMessage(chatId, fullText, sessionId);
   }
   /**
    * Register a slash command handler. Subclasses can call this to add
@@ -3775,30 +4228,6 @@ ${requestList}`);
     this.registerCommand("approve", (envelope, args) => this.handlePermissionResponseCommand(envelope, args, "approve"));
     this.registerCommand("approve-always", (envelope, args) => this.handlePermissionResponseCommand(envelope, args, "approve-always"));
     this.registerCommand("deny", (envelope, args) => this.handlePermissionResponseCommand(envelope, args, "deny"));
-    this.registerCommand("remember-channel", async (envelope, args) => {
-      const text = args.trim();
-      if (text === "") {
-        await this.sendMessage(envelope.chatId, "Usage: /remember-channel <text>");
-        return true;
-      }
-      await this.handleChannelMemoryIntent(envelope, {
-        kind: "remember",
-        text
-      });
-      return true;
-    });
-    this.registerCommand("channel-memory", async (envelope) => {
-      await this.handleChannelMemoryIntent(envelope, { kind: "list" });
-      return true;
-    });
-    this.registerCommand("forget-channel", async (envelope, args) => {
-      if (args.toLowerCase() !== "confirm") {
-        await this.sendMessage(envelope.chatId, 'This clears channel memory for this chat. Re-send with "confirm" (e.g. /forget-channel confirm) to proceed.');
-        return true;
-      }
-      await this.handleChannelMemoryIntent(envelope, { kind: "clear_confirm" }, { skipPendingClear: true });
-      return true;
-    });
     this.registerCommand("who", async (envelope) => {
       if (!this.isAuthorizedForSharedSession(envelope)) {
         await this.sendMessage(envelope.chatId, "Only authorized members can view this shared session.");
@@ -4253,7 +4682,60 @@ ${requestList}`);
     }
     return this.channelMemory;
   }
-  async handleChannelMemoryIntent(envelope, intent, options = {}) {
+  entriesForChannelMemoryIds(entries, ids) {
+    const selected = new Set(ids);
+    return entries.filter((entry) => selected.has(entry.id));
+  }
+  renderChannelMemoryCandidate(entry) {
+    const preview = truncateCodePoints(sanitizePromptText(entry.text).replace(/[\r\n]+/gu, " ").trim(), CHANNEL_MEMORY_PREVIEW_CODE_POINT_LIMIT);
+    return `${entry.id}  ${preview}`;
+  }
+  renderChannelMemoryCandidates(entries) {
+    return entries.map((entry) => this.renderChannelMemoryCandidate(entry));
+  }
+  async handleChannelMemoryIntent(envelope, intent) {
+    if (intent.kind === "no_match") {
+      await this.sendMessage(envelope.chatId, "No matching channel memory entry.");
+      return;
+    }
+    if (intent.kind === "ambiguous") {
+      const channelMemory2 = await this.getChannelMemory(envelope);
+      if (!channelMemory2)
+        return;
+      let entries;
+      try {
+        entries = await channelMemory2.listChannelMemoryEntries(this.channelMemoryTarget(envelope));
+      } catch (error) {
+        this.logChannelMemoryError("read", envelope, this.channelMemoryErrorMessage(error));
+        await this.sendMessage(envelope.chatId, `Failed to read channel memory: ${this.channelMemoryUserErrorMessage()}`);
+        return;
+      }
+      const selected = this.entriesForChannelMemoryIds(entries, intent.ids);
+      await this.sendMessage(envelope.chatId, [
+        "Multiple channel memory entries match:",
+        ...this.renderChannelMemoryCandidates(selected)
+      ].join("\n"));
+      return;
+    }
+    if (intent.kind === "list_matches") {
+      const channelMemory2 = await this.getChannelMemory(envelope);
+      if (!channelMemory2)
+        return;
+      let entries;
+      try {
+        entries = await channelMemory2.listChannelMemoryEntries(this.channelMemoryTarget(envelope));
+      } catch (error) {
+        this.logChannelMemoryError("read", envelope, this.channelMemoryErrorMessage(error));
+        await this.sendMessage(envelope.chatId, `Failed to read channel memory: ${this.channelMemoryUserErrorMessage()}`);
+        return;
+      }
+      const selected = this.entriesForChannelMemoryIds(entries, intent.ids);
+      await this.sendMessage(envelope.chatId, [
+        "Channel memory (page 1/1):",
+        ...this.renderChannelMemoryCandidates(selected)
+      ].join("\n"));
+      return;
+    }
     if (intent.kind === "clear_request") {
       this.setPendingClear(this.clearPendingKey(envelope));
       await this.sendMessage(envelope.chatId, 'This clears channel memory for this chat. Say "\u786E\u8BA4\u6E05\u7A7A\u8BB0\u5FC6" or "confirm clear memory" to proceed.');
@@ -4264,40 +4746,96 @@ ${requestList}`);
       return;
     }
     if (intent.kind === "remember") {
+      let result;
       try {
-        await channelMemory.appendChannelMemory(this.channelMemoryTarget(envelope), intent.text);
+        result = await channelMemory.addChannelMemoryEntries(this.channelMemoryTarget(envelope), [intent.text], envelope.senderId);
       } catch (error) {
         const message = this.channelMemoryErrorMessage(error);
         this.logChannelMemoryError("save", envelope, message);
         await this.sendMessage(envelope.chatId, `Failed to save channel memory: ${this.channelMemoryUserErrorMessage()}`);
         return;
       }
-      this.invalidateSessionContext(envelope);
-      await this.sendMessage(envelope.chatId, "Channel memory updated.");
+      if (result.changed) {
+        this.invalidateSessionContext(envelope);
+      }
+      if (result.added.length > 0) {
+        const ids = result.added.map((entry) => entry.id);
+        await this.sendMessage(envelope.chatId, ids.length === 1 ? `Channel memory ${ids[0]} saved.` : `Channel memory saved: ${ids.join(", ")}.`);
+      } else if (result.duplicateIds.length > 0) {
+        await this.sendMessage(envelope.chatId, `Channel memory already contains ${result.duplicateIds.join(", ")}.`);
+      } else {
+        await this.sendMessage(envelope.chatId, "Channel memory updated.");
+      }
       return;
     }
-    if (intent.kind === "list") {
-      let text;
+    if (intent.kind === "list" || intent.kind === "inspect") {
+      let entries;
       try {
-        text = (await channelMemory.readChannelMemory(this.channelMemoryTarget(envelope))).trim();
+        entries = await channelMemory.listChannelMemoryEntries(this.channelMemoryTarget(envelope));
       } catch (error) {
         const message = this.channelMemoryErrorMessage(error);
         this.logChannelMemoryError("read", envelope, message);
         await this.sendMessage(envelope.chatId, `Failed to read channel memory: ${this.channelMemoryUserErrorMessage()}`);
         return;
       }
-      await this.sendMessage(envelope.chatId, text === "" ? "No channel memory saved." : sanitizePromptText(text));
+      if (intent.kind === "inspect") {
+        const entry = entries.find((candidate) => candidate.id === intent.id);
+        await this.sendMessage(envelope.chatId, entry ? `Channel memory ${entry.id}:
+${sanitizePromptText(entry.text).trim()}` : `No channel memory entry ${intent.id}.`);
+        return;
+      }
+      const totalPages = Math.max(1, Math.ceil(entries.length / CHANNEL_MEMORY_PAGE_SIZE));
+      if (intent.page > totalPages) {
+        await this.sendMessage(envelope.chatId, `Channel memory page ${intent.page} does not exist.`);
+        return;
+      }
+      if (entries.length === 0) {
+        await this.sendMessage(envelope.chatId, "No channel memory saved.");
+        return;
+      }
+      const pageStart = (intent.page - 1) * CHANNEL_MEMORY_PAGE_SIZE;
+      const lines = entries.slice(pageStart, pageStart + CHANNEL_MEMORY_PAGE_SIZE).map((entry) => this.renderChannelMemoryCandidate(entry));
+      await this.sendMessage(envelope.chatId, [`Channel memory (page ${intent.page}/${totalPages}):`, ...lines].join("\n"));
       return;
     }
-    if (intent.kind === "clear_confirm") {
-      if (!options.skipPendingClear) {
-        const pendingKey = this.clearPendingKey(envelope);
-        const expiresAt = this.pendingClears.get(pendingKey);
-        this.pendingClears.delete(pendingKey);
-        if (expiresAt === void 0 || expiresAt < Date.now()) {
-          await this.sendMessage(envelope.chatId, 'No pending clear request. Say "\u6E05\u7A7A\u8BB0\u5FC6" first.');
-          return;
+    if (intent.kind === "update" || intent.kind === "remove" || intent.kind === "natural_update" || intent.kind === "natural_remove") {
+      let changed;
+      const isUpdate = intent.kind === "update" || intent.kind === "natural_update";
+      const id = intent.id;
+      try {
+        if (isUpdate) {
+          ({ changed } = await channelMemory.updateChannelMemoryEntry(this.channelMemoryTarget(envelope), intent.kind === "natural_update" ? {
+            id: intent.id,
+            text: intent.text,
+            expectedText: intent.expectedText
+          } : { id: intent.id, text: intent.text }));
+        } else {
+          ({ changed } = await channelMemory.removeChannelMemoryEntries(this.channelMemoryTarget(envelope), intent.kind === "natural_remove" ? {
+            ids: [intent.id],
+            expectedTextById: { [intent.id]: intent.expectedText }
+          } : { ids: [intent.id] }));
         }
+      } catch (error) {
+        const message = this.channelMemoryErrorMessage(error);
+        this.logChannelMemoryError(isUpdate ? "update" : "remove", envelope, message);
+        await this.sendMessage(envelope.chatId, `Failed to ${isUpdate ? "update" : "remove"} channel memory: ${this.channelMemoryUserErrorMessage()}`);
+        return;
+      }
+      if (!changed) {
+        await this.sendMessage(envelope.chatId, `No channel memory entry ${id}.`);
+        return;
+      }
+      this.invalidateSessionContext(envelope);
+      await this.sendMessage(envelope.chatId, `Channel memory ${id} ${isUpdate ? "updated" : "removed"}.`);
+      return;
+    }
+    if (intent.kind === "clear_confirm") {
+      const pendingKey = this.clearPendingKey(envelope);
+      const expiresAt = this.pendingClears.get(pendingKey);
+      this.pendingClears.delete(pendingKey);
+      if (expiresAt === void 0 || expiresAt < Date.now()) {
+        await this.sendMessage(envelope.chatId, 'No pending clear request. Say "\u6E05\u7A7A\u8BB0\u5FC6" first.');
+        return;
       }
       let result;
       try {
@@ -4308,7 +4846,9 @@ ${requestList}`);
         await this.sendMessage(envelope.chatId, `Failed to clear channel memory: ${this.channelMemoryUserErrorMessage()}`);
         return;
       }
-      this.invalidateSessionContext(envelope);
+      if (result.changed) {
+        this.invalidateSessionContext(envelope);
+      }
       await this.sendMessage(envelope.chatId, result.changed ? "Channel memory cleared." : "No channel memory saved.");
       return;
     }
@@ -4331,31 +4871,82 @@ ${requestList}`);
     }
     this.pendingClears.set(key, now + 6e4);
   }
-  async classifyChannelMemoryIntent(text) {
-    if (!this.memoryIntentClassifier) {
+  async classifyChannelMemoryIntent(envelope) {
+    if (!this.memoryIntentClassifier || !this.channelMemory) {
+      return null;
+    }
+    let entries;
+    try {
+      entries = await this.channelMemory.listChannelMemoryEntries(this.channelMemoryTarget(envelope));
+    } catch (error) {
+      this.logChannelMemoryError("read", envelope, this.channelMemoryErrorMessage(error));
       return null;
     }
     let classified;
     try {
-      classified = await this.memoryIntentClassifier.classifyChannelMemoryIntent(text);
+      classified = await this.memoryIntentClassifier.classifyChannelMemoryIntent(envelope.text, entries);
     } catch (error) {
       process.stderr.write(`[${this.name}] channel memory intent classifier failed: ${sanitizeLogText(this.channelMemoryErrorMessage(error), 200)}
 `);
       return null;
     }
-    if (classified.confidence < CHANNEL_MEMORY_CLASSIFIER_MIN_CONFIDENCE) {
+    const confidence = classified && typeof classified === "object" ? classified.confidence : void 0;
+    if (typeof confidence !== "number" || !Number.isFinite(confidence) || confidence < 0 || confidence > 1 || confidence < CHANNEL_MEMORY_CLASSIFIER_MIN_CONFIDENCE) {
       return null;
     }
-    if (classified.intent === "remember") {
-      const memory = classified.memory?.trim();
+    const result = classified;
+    const targetIds = result.targetIds;
+    const entryById = new Map(entries.map((entry2) => [entry2.id, entry2]));
+    const resolvedEntries = targetIds === void 0 ? void 0 : Array.isArray(targetIds) && targetIds.every((id) => typeof id === "string" && entryById.has(id)) && new Set(targetIds).size === targetIds.length ? this.entriesForChannelMemoryIds(entries, targetIds) : null;
+    if (result.intent === "remember") {
+      const memory = typeof result.memory === "string" ? result.memory.trim() : "";
       return memory ? { kind: "remember", text: memory } : null;
     }
-    if (classified.intent === "list") {
-      return { kind: "list" };
+    if (result.intent === "list") {
+      if (resolvedEntries === void 0)
+        return { kind: "list", page: 1 };
+      if (resolvedEntries === null)
+        return null;
+      return resolvedEntries.length === 0 ? { kind: "no_match" } : {
+        kind: "list_matches",
+        ids: resolvedEntries.map((entry2) => entry2.id)
+      };
     }
-    if (classified.intent === "clear_all") {
+    if (result.intent === "clear_all") {
       return { kind: "clear_request" };
     }
+    if (result.intent !== "inspect" && result.intent !== "update" && result.intent !== "remove") {
+      return null;
+    }
+    if (resolvedEntries === null || resolvedEntries === void 0)
+      return null;
+    if (resolvedEntries.length === 0)
+      return { kind: "no_match" };
+    if (resolvedEntries.length > 1) {
+      return {
+        kind: "ambiguous",
+        ids: resolvedEntries.map((entry2) => entry2.id)
+      };
+    }
+    const entry = resolvedEntries[0];
+    if (result.intent === "inspect")
+      return { kind: "inspect", id: entry.id };
+    if (result.intent === "remove") {
+      return {
+        kind: "natural_remove",
+        id: entry.id,
+        expectedText: entry.text
+      };
+    }
+    const text = typeof result.memory === "string" ? result.memory.trim() : "";
+    if (text) {
+      return {
+        kind: "natural_update",
+        id: entry.id,
+        text,
+        expectedText: entry.text
+      };
+    }
     return null;
   }
   channelMemoryErrorMessage(error) {
@@ -4687,7 +5278,7 @@ ${promptText}`;
     }
     let memoryIntent = parseChannelMemoryIntent(envelope.text);
     if (!memoryIntent && this.shouldClassifyChannelMemoryIntent(envelope.text)) {
-      memoryIntent = await this.classifyChannelMemoryIntent(envelope.text);
+      memoryIntent = await this.classifyChannelMemoryIntent(envelope);
     }
     if (memoryIntent) {
       await this.handleChannelMemoryIntent(envelope, memoryIntent);
@@ -4909,12 +5500,14 @@ ${promptToSend}`;
         minChars: this.config.blockStreamingChunk?.minChars ?? 400,
         maxChars: this.config.blockStreamingChunk?.maxChars ?? 1e3,
         idleMs: this.config.blockStreamingCoalesce?.idleMs ?? 1500,
-        send: /* @__PURE__ */ __name((text) => this.sendMessage(envelope.chatId, text), "send")
+        send: /* @__PURE__ */ __name((text) => this.sendResponseMessage(envelope.chatId, text, sessionId), "send")
       }) : null;
       promptState.stopStreaming = () => streamer?.stop();
       const heldChunks = [];
+      let hasStreamedText = false;
       const releaseHeldChunks = /* @__PURE__ */ __name(() => {
         for (const held of heldChunks.splice(0)) {
+          hasStreamedText = true;
           this.emitTaskLifecycle({
             ...this.lifecycleBase(envelope.chatId, sessionId, envelope.messageId),
             type: "text_chunk",
@@ -4938,6 +5531,7 @@ ${promptToSend}`;
           return;
         }
         heldChunks.length = 0;
+        hasStreamedText = false;
         this.onResponseBoundary(envelope.chatId, sessionId);
         streamer?.stop();
       }, "onResponseBoundary");
@@ -4956,6 +5550,9 @@ ${promptToSend}`;
         if (!promptState.cancelled && response) {
           promptState.deliveryStarted = true;
           if (streamer) {
+            if (!hasStreamedText) {
+              streamer.push(response);
+            }
             await streamer.flush();
           } else {
             await this.onResponseComplete(envelope.chatId, response, sessionId);