@qwen-code/qwen-code 0.19.10 → 0.19.11-nightly.20260718.767a32484

package/chunks/{chunk-SXU3KKNI.js → chunk-ATJ7H5AS.js}

@@ -771,7 +771,8 @@ var DaemonChannelBridge = class extends EventEmitter2 {
       workspaceCwd: cwd || this.options.cwd,
       modelServiceId: this.options.modelServiceId,
       sessionScope: this.options.sessionScope ?? "thread",
-      ...options?.approvalMode ? { approvalMode: options.approvalMode } : {}
+      ...options?.approvalMode ? { approvalMode: options.approvalMode } : {},
+      ...options?.sourceId ? { sourceId: options.sourceId } : {}
     });
     if (lifecycleGeneration !== this.lifecycleGeneration) {
       await this.rejectStaleSession(session);
@@ -1080,6 +1081,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;
@@ -1996,7 +2001,7 @@ var SessionRouter = class {
   async createAndStoreSession(key, input, operation) {
     const loadWindow = this.beginSessionLoad();
     try {
-      const sessionId = await this.createLiveSession(input.cwd, loadWindow, key, this.sessionOptions(input.channelName), operation);
+      const sessionId = await this.createLiveSession(input.cwd, loadWindow, key, this.sessionOptions(input.channelName), operation, input.channelName);
       try {
         this.assertOperationCurrent(operation);
       } catch (error) {
@@ -2052,7 +2057,7 @@ var SessionRouter = class {
       } catch (loadError) {
         this.assertOperationCurrent(operation);
         try {
-          const replacement = await this.createLiveSession(input.cwd, loadWindow, key, this.sessionOptions(input.channelName), operation);
+          const replacement = await this.createLiveSession(input.cwd, loadWindow, key, this.sessionOptions(input.channelName), operation, input.channelName);
           try {
             this.assertOperationCurrent(operation);
           } catch (error) {
@@ -2418,11 +2423,11 @@ var SessionRouter = class {
       }
     }
   }
-  async createLiveSession(cwd, loadWindow, routingKey, options, operation) {
+  async createLiveSession(cwd, loadWindow, routingKey, options, operation, sourceId) {
     const maxAttempts = 2;
     let lastDeadSessionId;
     for (let attempt = 0; attempt < maxAttempts; attempt++) {
-      const sessionId = await this.bridge.newSession(cwd, options, operation);
+      const sessionId = await this.bridge.newSession(cwd, { ...options, sourceId }, operation);
       try {
         this.assertOperationCurrent(operation);
       } catch (error) {
@@ -2879,6 +2884,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,
@@ -2891,31 +2919,76 @@ var CLEAR_CONFIRM_PATTERNS = [
   /^确认清除记忆$/u,
   /^confirm clear memory$/iu
 ];
+var UPDATE_CONFIRM_PATTERNS = [
+  /^确认更新记忆$/u,
+  /^confirm memory update$/iu
+];
+var REMOVE_CONFIRM_PATTERNS = [
+  /^确认删除记忆$/u,
+  /^confirm memory removal$/iu
+];
 function parseChannelMemoryIntent(text) {
   const trimmed = text.replace(PROMPT_UNSAFE_INVISIBLES, "").trim();
   if (!trimmed || trimmed.startsWith("/")) {
     return null;
   }
+  for (const pattern of UPDATE_CONFIRM_PATTERNS) {
+    if (pattern.test(trimmed)) {
+      return { kind: "update_confirm" };
+    }
+  }
+  for (const pattern of REMOVE_CONFIRM_PATTERNS) {
+    if (pattern.test(trimmed)) {
+      return { kind: "remove_confirm" };
+    }
+  }
   for (const pattern of CLEAR_CONFIRM_PATTERNS) {
     if (pattern.test(trimmed)) {
       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) {
     const match = trimmed.match(pattern);
     const remembered = match?.[1]?.replace(PROMPT_UNSAFE_INVISIBLES, "").trim();
     if (remembered) {
-      return { kind: "remember", text: remembered };
+      return { kind: "remember", texts: [remembered] };
     }
   }
   return null;
@@ -2930,8 +3003,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;
@@ -3008,7 +3083,8 @@ var ChannelBase = class {
    * so a cleared session can't be resurrected by an already-queued prompt.
    */
   sessionGenerations = /* @__PURE__ */ new Map();
-  pendingClears = /* @__PURE__ */ new Map();
+  pendingChannelMemoryMutations = /* @__PURE__ */ new Map();
+  pendingChannelMemoryMutationDeliveries = /* @__PURE__ */ new Map();
   /** Per-session active prompt tracking for dispatch modes. */
   activePrompts = /* @__PURE__ */ new Map();
   /** Per-session message buffer for collect mode. */
@@ -3253,6 +3329,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.");
@@ -3538,7 +3617,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;
@@ -4169,30 +4248,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.");
@@ -4647,10 +4702,126 @@ ${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.');
+      await this.deliverPendingChannelMemoryMutation(envelope, { kind: "clear" }, 'This clears channel memory for this chat. Say "\u786E\u8BA4\u6E05\u7A7A\u8BB0\u5FC6" or "confirm clear memory" to proceed.');
+      return;
+    }
+    if (intent.kind === "update_confirm" || intent.kind === "remove_confirm") {
+      const pending = intent.kind === "update_confirm" ? this.takePendingChannelMemoryMutation(envelope, "update") : this.takePendingChannelMemoryMutation(envelope, "remove");
+      if (!pending) {
+        await this.sendMessage(envelope.chatId, intent.kind === "update_confirm" ? "No pending channel memory update. Start a new update request first." : "No pending channel memory removal. Start a new removal request first.");
+        return;
+      }
+      const channelMemory2 = await this.getChannelMemory(envelope);
+      if (!channelMemory2)
+        return;
+      const isUpdate = pending.kind === "update";
+      let changed;
+      try {
+        if (isUpdate) {
+          ({ changed } = await channelMemory2.updateChannelMemoryEntry(this.channelMemoryTarget(envelope), {
+            id: pending.id,
+            text: pending.proposedText,
+            expectedText: pending.expectedText
+          }));
+        } else {
+          ({ changed } = await channelMemory2.removeChannelMemoryEntries(this.channelMemoryTarget(envelope), {
+            ids: [pending.id],
+            expectedTextById: { [pending.id]: pending.expectedText }
+          }));
+        }
+      } catch (error) {
+        const message = this.channelMemoryErrorMessage(error);
+        this.logChannelMemoryError(isUpdate ? "update" : "remove", envelope, message);
+        await this.sendMessage(envelope.chatId, message === "Channel memory entry changed" ? "That channel memory entry changed since it was selected. View channel memory and start the operation again." : `Failed to ${isUpdate ? "update" : "remove"} channel memory: ${this.channelMemoryUserErrorMessage()}`);
+        return;
+      }
+      if (!changed) {
+        await this.sendMessage(envelope.chatId, `No channel memory entry ${pending.id}.`);
+        return;
+      }
+      this.invalidateSessionContext(envelope);
+      await this.sendMessage(envelope.chatId, `Channel memory ${pending.id} ${isUpdate ? "updated" : "removed"}.`);
+      return;
+    }
+    if (intent.kind === "natural_update") {
+      await this.deliverPendingChannelMemoryMutation(envelope, {
+        kind: "update",
+        id: intent.id,
+        expectedText: intent.expectedText,
+        proposedText: intent.text
+      }, [
+        `Update channel memory ${intent.id}?`,
+        `Before: ${sanitizePromptText(intent.expectedText).trim()}`,
+        `After: ${sanitizePromptText(intent.text).trim()}`,
+        'Say "\u786E\u8BA4\u66F4\u65B0\u8BB0\u5FC6" or "confirm memory update" within 60 seconds.'
+      ].join("\n"));
+      return;
+    }
+    if (intent.kind === "natural_remove") {
+      await this.deliverPendingChannelMemoryMutation(envelope, {
+        kind: "remove",
+        id: intent.id,
+        expectedText: intent.expectedText
+      }, [
+        `Remove channel memory ${intent.id}?`,
+        sanitizePromptText(intent.expectedText).trim(),
+        'Say "\u786E\u8BA4\u5220\u9664\u8BB0\u5FC6" or "confirm memory removal" within 60 seconds.'
+      ].join("\n"));
       return;
     }
     const channelMemory = await this.getChannelMemory(envelope);
@@ -4658,40 +4829,87 @@ ${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.texts, 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, result.duplicateIds.length > 0 ? `Channel memory saved: ${ids.join(", ")}. Skipped duplicates: ${result.duplicateIds.join(", ")}.` : 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") {
+      let changed;
+      const isUpdate = intent.kind === "update";
+      const id = intent.id;
+      try {
+        if (isUpdate) {
+          ({ changed } = await channelMemory.updateChannelMemoryEntry(this.channelMemoryTarget(envelope), { id: intent.id, text: intent.text }));
+        } else {
+          ({ changed } = await channelMemory.removeChannelMemoryEntries(this.channelMemoryTarget(envelope), { 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 pending = this.takePendingChannelMemoryMutation(envelope, "clear");
+      if (!pending) {
+        await this.sendMessage(envelope.chatId, 'No pending clear request. Say "\u6E05\u7A7A\u8BB0\u5FC6" first.');
+        return;
       }
       let result;
       try {
@@ -4702,7 +4920,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;
     }
@@ -4713,44 +4933,164 @@ ${requestList}`);
     const normalized = text.replace(PROMPT_UNSAFE_INVISIBLES, "").trim();
     return this.channelMemory !== void 0 && this.memoryIntentClassifier !== void 0 && !normalized.startsWith("/") && CHANNEL_MEMORY_CLASSIFIER_TRIGGER_RE.test(normalized);
   }
-  clearPendingKey(envelope) {
-    return `${this.name}:${envelope.chatId}:${envelope.threadId ?? ""}:${envelope.senderId ?? ""}`;
+  channelMemoryPendingKey(envelope) {
+    return JSON.stringify([
+      this.name,
+      envelope.chatId,
+      envelope.threadId ?? null,
+      envelope.senderId ?? null
+    ]);
   }
-  setPendingClear(key) {
+  async deliverPendingChannelMemoryMutation(envelope, mutation, message) {
     const now = Date.now();
-    for (const [pendingKey, expiresAt] of this.pendingClears) {
-      if (expiresAt < now) {
-        this.pendingClears.delete(pendingKey);
+    for (const [pendingKey, pending] of this.pendingChannelMemoryMutations) {
+      if (pending.expiresAt < now) {
+        this.pendingChannelMemoryMutations.delete(pendingKey);
+      }
+    }
+    this.deletePendingChannelMemoryMutation(envelope);
+    const key = this.channelMemoryPendingKey(envelope);
+    this.pendingChannelMemoryMutationDeliveries.set(key, mutation);
+    try {
+      await this.sendMessage(envelope.chatId, message);
+    } catch (error) {
+      if (this.pendingChannelMemoryMutationDeliveries.get(key) === mutation) {
+        this.pendingChannelMemoryMutationDeliveries.delete(key);
       }
+      throw error;
+    }
+    if (this.pendingChannelMemoryMutationDeliveries.get(key) !== mutation) {
+      return;
+    }
+    this.pendingChannelMemoryMutationDeliveries.delete(key);
+    this.pendingChannelMemoryMutations.set(key, {
+      ...mutation,
+      expiresAt: Date.now() + 6e4
+    });
+  }
+  takePendingChannelMemoryMutation(envelope, kind) {
+    const key = this.channelMemoryPendingKey(envelope);
+    const pending = this.pendingChannelMemoryMutations.get(key);
+    if (!pending) {
+      return void 0;
     }
-    this.pendingClears.set(key, now + 6e4);
+    if (pending.expiresAt < Date.now()) {
+      this.pendingChannelMemoryMutations.delete(key);
+      return void 0;
+    }
+    if (pending.kind !== kind) {
+      return void 0;
+    }
+    this.pendingChannelMemoryMutations.delete(key);
+    return pending;
+  }
+  deletePendingChannelMemoryMutation(envelope) {
+    const key = this.channelMemoryPendingKey(envelope);
+    this.pendingChannelMemoryMutations.delete(key);
+    this.pendingChannelMemoryMutationDeliveries.delete(key);
   }
-  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) {
+    try {
+      if (typeof classified !== "object" || classified === null)
+        return null;
+      const result = classified;
+      const confidence = result.confidence;
+      if (typeof confidence !== "number" || !Number.isFinite(confidence) || confidence < 0 || confidence > 1 || confidence < CHANNEL_MEMORY_CLASSIFIER_MIN_CONFIDENCE) {
+        return null;
+      }
+      const intent = result.intent;
+      if (intent === "remember") {
+        const hasMemory = Object.prototype.hasOwnProperty.call(result, "memory");
+        const hasMemories = Object.prototype.hasOwnProperty.call(result, "memories");
+        if (hasMemory === hasMemories)
+          return null;
+        let texts = [];
+        if (hasMemory) {
+          const memory2 = result.memory;
+          texts = typeof memory2 === "string" ? [memory2.trim()] : [];
+        } else {
+          const memories = result.memories;
+          if (Array.isArray(memories)) {
+            const snapshot = Array.from(memories);
+            if (snapshot.every((memory2) => typeof memory2 === "string")) {
+              texts = snapshot.map((memory2) => memory2.trim());
+            }
+          }
+        }
+        return texts.length >= 1 && texts.length <= 10 && texts.every((text2) => text2.length > 0) ? { kind: "remember", texts } : null;
+      }
+      if (intent === "clear_all")
+        return { kind: "clear_request" };
+      if (intent !== "list" && intent !== "inspect" && intent !== "update" && intent !== "remove") {
+        return null;
+      }
+      const targetIds = result.targetIds;
+      if (intent === "list" && targetIds === void 0) {
+        return { kind: "list", page: 1 };
+      }
+      if (!Array.isArray(targetIds))
+        return null;
+      const targetIdSnapshot = Array.from(targetIds);
+      const entryById = new Map(entries.map((entry2) => [entry2.id, entry2]));
+      if (!targetIdSnapshot.every((id) => typeof id === "string" && entryById.has(id)) || new Set(targetIdSnapshot).size !== targetIdSnapshot.length) {
+        return null;
+      }
+      const resolvedEntries = this.entriesForChannelMemoryIds(entries, targetIdSnapshot);
+      if (intent === "list") {
+        return resolvedEntries.length === 0 ? { kind: "no_match" } : {
+          kind: "list_matches",
+          ids: resolvedEntries.map((entry2) => entry2.id)
+        };
+      }
+      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 (intent === "inspect")
+        return { kind: "inspect", id: entry.id };
+      if (intent === "remove") {
+        return {
+          kind: "natural_remove",
+          id: entry.id,
+          expectedText: entry.text
+        };
+      }
+      const memory = result.memory;
+      const text = typeof memory === "string" ? memory.trim() : "";
+      return text ? {
+        kind: "natural_update",
+        id: entry.id,
+        text,
+        expectedText: entry.text
+      } : null;
+    } catch (error) {
+      process.stderr.write(`[${this.name}] channel memory intent validation failed: ${sanitizeLogText(this.channelMemoryErrorMessage(error), 200)}
+`);
       return null;
     }
-    if (classified.intent === "remember") {
-      const memory = classified.memory?.trim();
-      return memory ? { kind: "remember", text: memory } : null;
-    }
-    if (classified.intent === "list") {
-      return { kind: "list" };
-    }
-    if (classified.intent === "clear_all") {
-      return { kind: "clear_request" };
-    }
-    return null;
   }
   channelMemoryErrorMessage(error) {
     return error instanceof Error ? error.message : String(error);
@@ -5080,8 +5420,11 @@ ${promptText}`;
       throw new Error("processInbound called without a successful preflightInbound check.");
     }
     let memoryIntent = parseChannelMemoryIntent(envelope.text);
+    if (memoryIntent?.kind === "update" || memoryIntent?.kind === "remove") {
+      this.deletePendingChannelMemoryMutation(envelope);
+    }
     if (!memoryIntent && this.shouldClassifyChannelMemoryIntent(envelope.text)) {
-      memoryIntent = await this.classifyChannelMemoryIntent(envelope.text);
+      memoryIntent = await this.classifyChannelMemoryIntent(envelope);
     }
     if (memoryIntent) {
       await this.handleChannelMemoryIntent(envelope, memoryIntent);