@zubriq/code 0.19.8-1 → 0.19.9-1

package/dist/chunks/{chunk-WSVZFWN4.js → chunk-IBY3Q3HG.js}

@@ -77,6 +77,7 @@ __name(getGlobalQwenDir, "getGlobalQwenDir");
 // packages/channels/base/dist/AcpBridge.js
 init_esbuild_shims();
 import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
 import { Readable, Writable } from "node:stream";
 import { EventEmitter } from "node:events";
 
@@ -240,6 +241,7 @@ __name(readId, "readId");
 // packages/channels/base/dist/AcpBridge.js
 var MID_TURN_QUEUE_DRAIN_METHOD = "craft/drainMidTurnQueue";
 var ACP_EVENT_LOOP_STALL_RESTART_MS = 5 * 60 * 1e3;
+var ACP_PERMISSION_RESPONSE_TIMEOUT_MS = 5 * 60 * 1e3;
 var ACP_EVENT_LOOP_STALL_RE = /^\[perf\] acp agent event loop stall: max=(\d+(?:\.\d+)?)ms/m;
 function readAvailableCommandAltNames(raw) {
   if (typeof raw !== "object" || raw === null)
@@ -266,6 +268,7 @@ var AcpBridge = class extends EventEmitter {
   channelLoopToolHandlers = [];
   channelLoopMcpRegistered = false;
   channelLoopMcpRegistration = null;
+  pendingPermissions = /* @__PURE__ */ new Map();
   constructor(options) {
     super();
     this.options = options;
@@ -292,7 +295,7 @@ var AcpBridge = class extends EventEmitter {
     this.child.stderr?.on("data", (data) => {
       const msg = data.toString().trim();
       if (msg) {
-        process.stderr.write(`[AcpBridge] ${msg}
+        process.stderr.write(`[AcpBridge] ${sanitizeLogText(msg, 4096)}
 `);
         this.maybeKillOnEventLoopStall(msg);
       }
@@ -300,6 +303,7 @@ var AcpBridge = class extends EventEmitter {
     this.child.on("exit", (code, signal) => {
       process.stderr.write(`[AcpBridge] Process exited (code=${code}, signal=${signal})
 `);
+      this.resolvePendingPermissions();
       this.connection = null;
       this.child = null;
       this.emit("disconnected", code, signal);
@@ -316,11 +320,7 @@ var AcpBridge = class extends EventEmitter {
         this.handleSessionUpdate(params);
         return Promise.resolve();
       }, "sessionUpdate"),
-      requestPermission: /* @__PURE__ */ __name(async (params) => {
-        const options = Array.isArray(params.options) ? params.options : [];
-        const optionId = options.find((o) => o.optionId === "proceed_once")?.optionId || options[0]?.optionId || "proceed_once";
-        return { outcome: { outcome: "selected", optionId } };
-      }, "requestPermission"),
+      requestPermission: /* @__PURE__ */ __name(async (params) => this.requestPermission(params), "requestPermission"),
       extMethod: /* @__PURE__ */ __name(async (method, params) => this.handleExtMethod(method, params), "extMethod"),
       extNotification: /* @__PURE__ */ __name(async () => {
       }, "extNotification")
@@ -387,9 +387,28 @@ var AcpBridge = class extends EventEmitter {
   }
   async cancelSession(sessionId) {
     const conn = this.ensureConnection();
-    await conn.cancel({ sessionId });
+    try {
+      await conn.cancel({ sessionId });
+    } finally {
+      this.resolvePendingPermissions(sessionId);
+    }
+  }
+  async respondToPermission(requestId, response) {
+    const pending = this.pendingPermissions.get(requestId);
+    if (!pending) {
+      return false;
+    }
+    clearTimeout(pending.timeout);
+    this.pendingPermissions.delete(requestId);
+    pending.resolve(response);
+    this.emit("permissionResolved", {
+      requestId,
+      outcome: response.outcome
+    });
+    return true;
   }
   stop() {
+    this.resolvePendingPermissions();
     if (this.child) {
       this.child.kill();
       this.child = null;
@@ -445,6 +464,53 @@ var AcpBridge = class extends EventEmitter {
     }
     return this.connection;
   }
+  requestPermission(request) {
+    const requestId = `acp-permission-${randomUUID()}`;
+    const sessionId = typeof request.sessionId === "string" && request.sessionId.length > 0 ? request.sessionId : request.toolCall.toolCallId;
+    return new Promise((resolve2) => {
+      const timeout = setTimeout(() => {
+        const pending = this.pendingPermissions.get(requestId);
+        if (!pending) {
+          return;
+        }
+        process.stderr.write(`[AcpBridge] permission request ${sanitizeLogText(requestId, 128)} timed out after ${ACP_PERMISSION_RESPONSE_TIMEOUT_MS}ms (session=${sanitizeLogText(pending.sessionId, 128)})
+`);
+        this.pendingPermissions.delete(requestId);
+        const response = {
+          outcome: { outcome: "cancelled" }
+        };
+        pending.resolve(response);
+        this.emit("permissionResolved", {
+          requestId,
+          outcome: response.outcome
+        });
+      }, ACP_PERMISSION_RESPONSE_TIMEOUT_MS);
+      timeout.unref?.();
+      this.pendingPermissions.set(requestId, { sessionId, resolve: resolve2, timeout });
+      this.emit("permissionRequest", {
+        requestId,
+        sessionId,
+        request
+      });
+    });
+  }
+  resolvePendingPermissions(sessionId) {
+    const response = {
+      outcome: { outcome: "cancelled" }
+    };
+    for (const [requestId, pending] of this.pendingPermissions) {
+      if (sessionId !== void 0 && pending.sessionId !== sessionId) {
+        continue;
+      }
+      clearTimeout(pending.timeout);
+      this.pendingPermissions.delete(requestId);
+      pending.resolve(response);
+      this.emit("permissionResolved", {
+        requestId,
+        outcome: response.outcome
+      });
+    }
+  }
   maybeKillOnEventLoopStall(stderr) {
     const match = ACP_EVENT_LOOP_STALL_RE.exec(stderr);
     if (!match)
@@ -1237,6 +1303,36 @@ var GroupGate = class {
   }
 };
 
+// packages/channels/base/dist/DmGate.js
+init_esbuild_shims();
+var DmGate = class {
+  static {
+    __name(this, "DmGate");
+  }
+  policy;
+  constructor(policy = "open") {
+    this.policy = policy;
+  }
+  /**
+   * DM check: policy gating for private/non-group messages.
+   * Evaluation order:
+   *   1. Group messages bypass this gate (handled by GroupGate)
+   *   2. dmPolicy (disabled → drop)
+   *
+   * Symmetric with GroupGate — GroupGate owns group messages,
+   * DmGate owns DM messages.
+   */
+  check(envelope) {
+    if (envelope.isGroup) {
+      return { allowed: true };
+    }
+    if (this.policy === "disabled") {
+      return { allowed: false, reason: "disabled" };
+    }
+    return { allowed: true };
+  }
+};
+
 // packages/channels/base/dist/group-history-store.js
 init_esbuild_shims();
 import { appendFileSync, chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
@@ -2267,6 +2363,66 @@ function truncateError(message) {
 }
 __name(truncateError, "truncateError");
 
+// packages/channels/base/dist/channel-memory-intent.js
+init_esbuild_shims();
+var REMEMBER_PATTERNS = [
+  /^记住[:：]\s*(.+)$/su,
+  /^记一下[:：,，]?\s*(.+)$/su,
+  /^帮我记一下[:：,，]?\s*(.+)$/su,
+  /^帮我记住[:：,，]?\s*(.+)$/su,
+  /^以后记住[:：,，]?\s*(.+)$/su,
+  /^remember:\s*(.+)$/isu
+];
+var LIST_PATTERNS = [
+  /^你现在记住了什么[?？]?$/u,
+  /^查看记忆$/u,
+  /^当前记忆$/u,
+  /^这个聊天你记住了什么[?？]?$/u,
+  /^what do you remember[?？]?$/iu
+];
+var CLEAR_REQUEST_PATTERNS = [
+  /^清空记忆$/u,
+  /^清除记忆$/u,
+  /^忘掉这个聊天的所有记忆$/u,
+  /^把.+的?记忆清空$/u,
+  /^clear memory$/iu
+];
+var CLEAR_CONFIRM_PATTERNS = [
+  /^确认清空记忆$/u,
+  /^确认清除记忆$/u,
+  /^confirm clear memory$/iu
+];
+function parseChannelMemoryIntent(text) {
+  const trimmed = text.replace(PROMPT_UNSAFE_INVISIBLES, "").trim();
+  if (!trimmed || trimmed.startsWith("/")) {
+    return null;
+  }
+  for (const pattern of CLEAR_CONFIRM_PATTERNS) {
+    if (pattern.test(trimmed)) {
+      return { kind: "clear_confirm" };
+    }
+  }
+  for (const pattern of CLEAR_REQUEST_PATTERNS) {
+    if (pattern.test(trimmed)) {
+      return { kind: "clear_request" };
+    }
+  }
+  for (const pattern of LIST_PATTERNS) {
+    if (pattern.test(trimmed)) {
+      return { kind: "list" };
+    }
+  }
+  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 null;
+}
+__name(parseChannelMemoryIntent, "parseChannelMemoryIntent");
+
 // packages/channels/base/dist/ChannelBase.js
 var CLEAR_CANCEL_TIMEOUT_MS = 3e3;
 var GROUP_HISTORY_CONTEXT_MARKER = "[Chat messages since your last reply - for context]";
@@ -2274,6 +2430,8 @@ var CURRENT_MESSAGE_MARKER = "[Current message - respond to this]";
 var GROUP_HISTORY_ENTRY_TEXT_LIMIT = 1e3;
 var GROUP_HISTORY_ENTRY_METADATA_LIMIT = 256;
 var LOOP_CANCEL_GRACE_MS = 5e3;
+var CHANNEL_MEMORY_CLASSIFIER_MIN_CONFIDENCE = 0.7;
+var CHANNEL_MEMORY_CLASSIFIER_TRIGGER_RE = /(记住|记得|记一下|记忆|忘掉|忘记|清空|清除|删除|保存|remember|memory|forget)/iu;
 var LOOP_TIMED_OUT_MESSAGE = "loop timed out";
 var COMMAND_TOKEN_CHARS = "a-zA-Z0-9_:-";
 var PARSE_COMMAND_RE = new RegExp(`^\\/([${COMMAND_TOKEN_CHARS}]+)(?:@\\S+)?\\s*(.*)`, "s");
@@ -2297,6 +2455,7 @@ var ChannelBase = class {
   config;
   bridge;
   groupGate;
+  dmGate;
   gate;
   router;
   name;
@@ -2306,6 +2465,7 @@ var ChannelBase = class {
   /** Resolved proxy URL, available to subclasses for adapter-specific clients. */
   proxy;
   channelMemory;
+  memoryIntentClassifier;
   groupHistory;
   loopController;
   instructedSessions = /* @__PURE__ */ new Set();
@@ -2319,16 +2479,29 @@ var ChannelBase = class {
    * so a cleared session can't be resurrected by an already-queued prompt.
    */
   sessionGenerations = /* @__PURE__ */ new Map();
+  pendingClears = /* @__PURE__ */ new Map();
   /** Per-session active prompt tracking for dispatch modes. */
   activePrompts = /* @__PURE__ */ new Map();
   /** Per-session message buffer for collect mode. */
   collectBuffers = /* @__PURE__ */ new Map();
+  preflightedEnvelopes = /* @__PURE__ */ new WeakSet();
   bridgeToolCallListener = /* @__PURE__ */ __name((event) => {
     this.dispatchToolCall(event);
   }, "bridgeToolCallListener");
   bridgeSessionDiedListener = /* @__PURE__ */ __name((event) => {
     this.onSessionDied(event.sessionId);
   }, "bridgeSessionDiedListener");
+  bridgePermissionRequestListener = /* @__PURE__ */ __name((event) => {
+    void this.dispatchPermissionRequest(event).catch((err) => {
+      process.stderr.write(`[${this.name}] permission relay failed for request ${sanitizeLogText(event.requestId, 128)}: ${this.lifecycleError(err)}
+`);
+    });
+  }, "bridgePermissionRequestListener");
+  bridgePermissionResolvedListener = /* @__PURE__ */ __name((event) => {
+    this.dispatchPermissionResolved(event);
+  }, "bridgePermissionResolvedListener");
+  pendingPermissions = /* @__PURE__ */ new Map();
+  pendingPermissionsByChat = /* @__PURE__ */ new Map();
   channelLoopToolHandler = {
     canHandle: /* @__PURE__ */ __name((sessionId) => this.router.getTarget(sessionId)?.channelName === this.name, "canHandle"),
     create: /* @__PURE__ */ __name((sessionId, input) => this.createLoopFromTool(sessionId, input), "create"),
@@ -2358,6 +2531,78 @@ var ChannelBase = class {
     }
     this.onToolCall(chatId, event);
   }
+  async dispatchPermissionRequest(event) {
+    const target = this.permissionTargetForEvent(event);
+    if (!target) {
+      try {
+        await this.bridge.respondToPermission?.(event.requestId, {
+          outcome: { outcome: "cancelled" }
+        });
+      } catch (respondErr) {
+        process.stderr.write(`[${this.name}] permission cancellation failed for request ${sanitizeLogText(event.requestId, 128)}: ${this.lifecycleError(respondErr)}
+`);
+      }
+      return;
+    }
+    this.removePendingPermission(event.requestId);
+    const pending = {
+      requestId: event.requestId,
+      sessionId: event.sessionId,
+      target,
+      request: event.request
+    };
+    this.pendingPermissions.set(event.requestId, pending);
+    const chatKey = this.permissionChatKey(target);
+    const requestIds = this.pendingPermissionsByChat.get(chatKey) ?? [];
+    requestIds.push(event.requestId);
+    this.pendingPermissionsByChat.set(chatKey, requestIds);
+    try {
+      const text = this.formatPermissionRequest(pending);
+      if (target.threadId !== void 0 && this.supportsProactiveSend() && this.supportsProactiveTarget(target)) {
+        await this.pushProactive(target, text);
+      } else {
+        await this.sendMessage(target.chatId, text);
+      }
+    } catch (err) {
+      this.removePendingPermission(event.requestId);
+      try {
+        await this.bridge.respondToPermission?.(event.requestId, {
+          outcome: { outcome: "cancelled" }
+        });
+      } catch (respondErr) {
+        process.stderr.write(`[${this.name}] permission cancellation failed for request ${sanitizeLogText(event.requestId, 128)}: ${this.lifecycleError(respondErr)}
+`);
+      }
+      throw err;
+    }
+  }
+  permissionTargetForEvent(event) {
+    const routeTarget = this.router.getTarget(event.sessionId);
+    if (!routeTarget || routeTarget.channelName !== this.name) {
+      return void 0;
+    }
+    const active = this.activePrompts.get(event.sessionId);
+    if (!active) {
+      return routeTarget;
+    }
+    const target = {
+      channelName: routeTarget.channelName,
+      senderId: active.senderId ?? routeTarget.senderId,
+      chatId: active.chatId
+    };
+    if (active.threadId !== void 0) {
+      target.threadId = active.threadId;
+    }
+    if (active.isGroup !== void 0) {
+      target.isGroup = active.isGroup;
+    } else if (routeTarget.isGroup !== void 0) {
+      target.isGroup = routeTarget.isGroup;
+    }
+    return target;
+  }
+  dispatchPermissionResolved(event) {
+    this.removePendingPermission(event.requestId);
+  }
   constructor(name, config, bridge, options) {
     this.name = name;
     this.config = config;
@@ -2366,9 +2611,11 @@ var ChannelBase = class {
     this.identity = Object.freeze(this.resolveIdentity(name, config));
     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.loopController = options?.loopController;
     this.groupGate = new GroupGate(config.groupPolicy, config.groups);
+    this.dmGate = new DmGate(config.dmPolicy);
     const pairingStore = config.senderPolicy === "pairing" ? new PairingStore(name) : void 0;
     this.gate = new SenderGate(config.senderPolicy, config.allowedUsers, pairingStore);
     this.router = options?.router || new SessionRouter(bridge, config.cwd, config.sessionScope);
@@ -2488,6 +2735,7 @@ var ChannelBase = class {
     if (this.registerBridgeEvents) {
       this.detachBridgeEvents(this.bridge);
     }
+    this.clearPendingPermissions();
     this.router.setBridge(bridge);
     this.bridge = bridge;
     if (this.loopController) {
@@ -2588,6 +2836,8 @@ ${promptText}`;
         done,
         resolve: doneResolve,
         chatId: job.target.chatId,
+        threadId: job.target.threadId,
+        isGroup: job.target.isGroup,
         messageId: job.id,
         senderId: job.target.senderId,
         senderName: job.createdBy,
@@ -2701,6 +2951,7 @@ ${promptText}`;
           const lost = buffer.length;
           const coalesced = buffer.map((b) => b.text).join("\n\n");
           const lastEnvelope = buffer[buffer.length - 1].envelope;
+          this.notifyPromptBufferDrained(lastEnvelope.chatId, sessionId, buffer);
           const syntheticEnvelope = {
             ...lastEnvelope,
             text: coalesced,
@@ -2710,7 +2961,8 @@ ${promptText}`;
             imageBase64: void 0,
             imageMimeType: void 0
           };
-          this.handleInbound(syntheticEnvelope).catch((err) => {
+          this.markPreflighted(syntheticEnvelope);
+          this.processInbound(syntheticEnvelope).catch((err) => {
             process.stderr.write(`[${this.name}] dropped ${lost} buffered message(s) after loop ${job.id} for session ${sessionId} (last sender ${lastEnvelope.senderId}): ${err instanceof Error ? err.message : String(err)}
 `);
           });
@@ -2800,11 +3052,39 @@ ${promptText}`;
       }
       active.cancelled = true;
       this.stopActiveStreaming(active, sessionId, reason);
-      this.collectBuffers.delete(sessionId);
+      this.dropCollectBuffer(sessionId);
       this.emitTaskCancellation(active, sessionId, reason);
       return true;
     });
   }
+  dropCollectBuffer(sessionId) {
+    const buffer = this.collectBuffers.get(sessionId);
+    if (!buffer)
+      return;
+    this.collectBuffers.delete(sessionId);
+    const chatId = buffer[0]?.envelope.chatId ?? "";
+    const messageIds = this.collectBufferMessageIds(buffer);
+    try {
+      this.onPromptBufferDropped(chatId, sessionId, messageIds);
+    } catch (err) {
+      process.stderr.write(`[${this.name}] onPromptBufferDropped threw for session ${sessionId}: ${err instanceof Error ? err.message : err}
+`);
+    }
+  }
+  notifyPromptBufferDrained(chatId, sessionId, buffer) {
+    const messageIds = this.collectBufferMessageIds(buffer);
+    if (messageIds.length === 0)
+      return;
+    try {
+      this.onPromptBufferDrained(chatId, sessionId, messageIds);
+    } catch (err) {
+      process.stderr.write(`[${this.name}] onPromptBufferDrained threw for session ${sessionId}: ${err instanceof Error ? err.message : err}
+`);
+    }
+  }
+  collectBufferMessageIds(buffer) {
+    return buffer.map((entry) => entry.envelope.messageId).filter((id) => typeof id === "string" && id.length > 0);
+  }
   logCancelSessionFailure(sessionId, err) {
     process.stderr.write(`[${sanitizeLogText(this.name, 64)}] cancelSession failed for session=${sanitizeLogText(sessionId, 64)}: ${this.lifecycleError(err)}
 `);
@@ -2834,14 +3114,19 @@ ${promptText}`;
   onSessionDied(sessionId) {
     this.router.removeSessionId(sessionId);
     this.instructedSessions.delete(sessionId);
+    this.removePendingPermissionsForSession(sessionId);
   }
   attachBridgeEvents(bridge) {
     bridge.on("toolCall", this.bridgeToolCallListener);
     bridge.on("sessionDied", this.bridgeSessionDiedListener);
+    bridge.on("permissionRequest", this.bridgePermissionRequestListener);
+    bridge.on("permissionResolved", this.bridgePermissionResolvedListener);
   }
   detachBridgeEvents(bridge) {
     bridge.off("toolCall", this.bridgeToolCallListener);
     bridge.off("sessionDied", this.bridgeSessionDiedListener);
+    bridge.off("permissionRequest", this.bridgePermissionRequestListener);
+    bridge.off("permissionResolved", this.bridgePermissionResolvedListener);
   }
   /**
    * Called when a prompt actually begins processing (inside the session queue).
@@ -2850,6 +3135,12 @@ ${promptText}`;
    */
   onPromptStart(_chatId, _sessionId, _messageId) {
   }
+  onPromptBuffered(_chatId, _sessionId, _messageId) {
+  }
+  onPromptBufferDrained(_chatId, _sessionId, _messageIds) {
+  }
+  onPromptBufferDropped(_chatId, _sessionId, _messageIds) {
+  }
   /**
    * Called when a prompt finishes (response sent or cancelled).
    * Override to hide the working indicator.
@@ -2900,6 +3191,182 @@ ${promptText}`;
       return true;
     });
   }
+  permissionChatKey(target) {
+    return `${target.chatId}\0${target.threadId ?? ""}`;
+  }
+  pendingPermissionIdsForChatKey(chatKey) {
+    const requestIds = this.pendingPermissionsByChat.get(chatKey);
+    if (!requestIds) {
+      return [];
+    }
+    const live = requestIds.filter((id) => this.pendingPermissions.has(id));
+    if (live.length === 0) {
+      this.pendingPermissionsByChat.delete(chatKey);
+    } else if (live.length !== requestIds.length) {
+      this.pendingPermissionsByChat.set(chatKey, live);
+    }
+    return live;
+  }
+  removePendingPermission(requestId) {
+    const pending = this.pendingPermissions.get(requestId);
+    if (!pending) {
+      return;
+    }
+    this.pendingPermissions.delete(requestId);
+    const chatKey = this.permissionChatKey(pending.target);
+    const requestIds = this.pendingPermissionsByChat.get(chatKey);
+    if (!requestIds) {
+      return;
+    }
+    const remaining = requestIds.filter((id) => id !== requestId);
+    if (remaining.length === 0) {
+      this.pendingPermissionsByChat.delete(chatKey);
+    } else {
+      this.pendingPermissionsByChat.set(chatKey, remaining);
+    }
+  }
+  removePendingPermissionsForSession(sessionId) {
+    const requestIds = Array.from(this.pendingPermissions).filter(([, pending]) => pending.sessionId === sessionId).map(([requestId]) => requestId);
+    for (const requestId of requestIds) {
+      this.removePendingPermission(requestId);
+    }
+  }
+  clearPendingPermissions() {
+    this.pendingPermissions.clear();
+    this.pendingPermissionsByChat.clear();
+  }
+  pendingPermissionForEnvelope(envelope, args) {
+    const trimmed = args.trim();
+    if (trimmed) {
+      const explicit = this.pendingPermissions.get(trimmed);
+      if (explicit && this.canEnvelopeAnswerPendingPermission(envelope, explicit)) {
+        return { kind: "found", pending: explicit };
+      }
+      return { kind: "none", explicit: true };
+    }
+    const requestIds = this.pendingPermissionIdsForChatKey(this.permissionChatKey(envelope));
+    if (requestIds.length === 0) {
+      return { kind: "none", explicit: false };
+    }
+    const matching = requestIds.map((id) => this.pendingPermissions.get(id)).filter((pending) => pending !== void 0 && this.canEnvelopeAnswerPendingPermission(envelope, pending));
+    if (matching.length === 0) {
+      return { kind: "none", explicit: false };
+    }
+    if (matching.length > 1) {
+      return {
+        kind: "ambiguous",
+        requestIds: matching.map((pending) => pending.requestId)
+      };
+    }
+    return { kind: "found", pending: matching[0] };
+  }
+  canEnvelopeAnswerPendingPermission(envelope, pending) {
+    return pending.target.chatId === envelope.chatId && pending.target.threadId === envelope.threadId && (this.isSharedSessionTarget(pending.target) || pending.target.senderId === envelope.senderId);
+  }
+  formatPermissionRequest(pending) {
+    const { toolCall } = pending.request;
+    const title = sanitizeQuotedText(toolCall.title || "Tool use", 160);
+    const alwaysOption = this.approvalAlwaysOption(pending);
+    const replies = [
+      "/approve        allow once",
+      ...alwaysOption ? [`/approve-always ${alwaysOption.label}`] : [],
+      "/deny           deny"
+    ];
+    const lines = [
+      "Permission required to run a tool",
+      "",
+      "Command:",
+      title,
+      "",
+      "Reply with:",
+      ...replies
+    ];
+    return lines.join("\n");
+  }
+  approvalOptionId(pending) {
+    const options = pending.request.options;
+    return options.find((option) => option.kind === "allow_once")?.optionId ?? options.find((option) => option.optionId === "proceed_once" && option.kind === void 0)?.optionId;
+  }
+  approvalAlwaysOption(pending) {
+    const options = pending.request.options.filter((option2) => option2.kind === "allow_always");
+    const option = this.findScopedAlwaysOption(options, "project") ?? this.findScopedAlwaysOption(options, "user") ?? options[0];
+    if (!option) {
+      return void 0;
+    }
+    return {
+      optionId: option.optionId,
+      label: this.approvalAlwaysLabel(option)
+    };
+  }
+  findScopedAlwaysOption(options, scope) {
+    return options.find((option) => option.optionId === `proceed_always_${scope}`);
+  }
+  approvalAlwaysLabel(option) {
+    if (option.optionId === "proceed_always_project") {
+      return "always allow for this project";
+    }
+    if (option.optionId === "proceed_always_user") {
+      return "always allow for this user";
+    }
+    return "always allow";
+  }
+  denialResponse(pending) {
+    const option = pending.request.options.find((candidate) => candidate.kind === "reject_once") ?? pending.request.options.find((candidate) => candidate.optionId === "cancel" && candidate.kind === void 0);
+    if (option) {
+      return { outcome: { outcome: "selected", optionId: option.optionId } };
+    }
+    return { outcome: { outcome: "cancelled" } };
+  }
+  async handlePermissionResponseCommand(envelope, args, decision) {
+    if (!this.isAuthorizedForSharedSession(envelope)) {
+      await this.sendMessage(envelope.chatId, "Only authorized members can answer permission requests in this shared session.");
+      return true;
+    }
+    const lookup = this.pendingPermissionForEnvelope(envelope, args);
+    if (lookup.kind === "ambiguous") {
+      const requestList = lookup.requestIds.slice(0, 6).map((id) => {
+        const pending2 = this.pendingPermissions.get(id);
+        const title = pending2 ? `: ${sanitizeQuotedText(pending2.request.toolCall.title || "Tool use", 160)}` : "";
+        return `- ${sanitizeQuotedText(id, 128)}${title}`;
+      }).join("\n");
+      await this.sendMessage(envelope.chatId, `Multiple permission requests are pending for this chat. Reply with /${decision} <request-id>.
+${requestList}`);
+      return true;
+    }
+    if (lookup.kind === "none") {
+      await this.sendMessage(envelope.chatId, lookup.explicit ? "No pending permission request with that id for this chat." : "No pending permission request for this chat.");
+      return true;
+    }
+    if (!this.bridge.respondToPermission) {
+      await this.sendMessage(envelope.chatId, "Permission relay is not available for this session.");
+      return true;
+    }
+    const { pending } = lookup;
+    const response = (() => {
+      if (decision === "deny") {
+        return this.denialResponse(pending);
+      }
+      const optionId = decision === "approve" ? this.approvalOptionId(pending) : this.approvalAlwaysOption(pending)?.optionId;
+      return optionId ? { outcome: { outcome: "selected", optionId } } : void 0;
+    })();
+    if (!response) {
+      await this.sendMessage(envelope.chatId, decision === "approve-always" ? "This permission request has no always-allow option." : "This permission request has no approvable option.");
+      return true;
+    }
+    let accepted;
+    try {
+      accepted = await this.bridge.respondToPermission(pending.requestId, response);
+    } catch (err) {
+      this.removePendingPermission(pending.requestId);
+      process.stderr.write(`[${this.name}] permission response failed for request ${sanitizeLogText(pending.requestId, 128)}: ${this.lifecycleError(err)}
+`);
+      await this.sendMessage(envelope.chatId, "Failed to answer the permission request.");
+      return true;
+    }
+    this.removePendingPermission(pending.requestId);
+    await this.sendMessage(envelope.chatId, accepted ? decision === "approve" ? "Permission approved." : decision === "approve-always" ? "Permission approved always." : "Permission denied." : "Permission request is no longer pending.");
+    return true;
+  }
   /** Register shared slash commands. Called from constructor. */
   registerSharedCommands() {
     const doClear = /* @__PURE__ */ __name(async (envelope) => {
@@ -2913,8 +3380,9 @@ ${promptText}`;
 `);
           }
           this.sessionGenerations.set(id, (this.sessionGenerations.get(id) ?? 0) + 1);
+          this.removePendingPermissionsForSession(id);
           const active = this.activePrompts.get(id);
-          this.collectBuffers.delete(id);
+          this.dropCollectBuffer(id);
           if (active) {
             const settled = await this.cancelAndAwaitActive(active, id);
             if (!settled) {
@@ -2966,77 +3434,23 @@ ${promptText}`;
     this.registerCommand("clear", clearHandler);
     this.registerCommand("reset", clearHandler);
     this.registerCommand("new", clearHandler);
-    this.registerCommand("who", async (envelope) => {
-      if (!this.isAuthorizedForSharedSession(envelope)) {
-        await this.sendMessage(envelope.chatId, "Only authorized members can view this shared session.");
-        return true;
-      }
-      const active = this.router.hasSession(this.name, envelope.senderId, envelope.chatId, envelope.threadId);
-      const scopeNote = this.config.sessionScope === "single" ? " (shared channel-wide)" : this.isSharedSession(envelope) ? envelope.isGroup ? " (shared by this group)" : "" : envelope.isGroup ? " (private to you)" : "";
-      await this.sendMessage(envelope.chatId, [
-        `Channel: ${this.name}`,
-        // Identity/memory lines only for channels that opted in — keep
-        // unconfigured channels' output unchanged.
-        ...this.shouldPrependChannelBoundaryPrompt() ? [
-          `Identity: ${sanitizeQuotedText(this.identity.displayName, 128)}`,
-          `Memory: ${sanitizeQuotedText(this.memoryScope.namespace, 128)}`
-        ] : [],
-        // Only the basename — don't leak the absolute cwd to group members.
-        `Workspace: ${basename(this.config.cwd)}`,
-        `Session: ${active ? "active" : "none"}${scopeNote}`
-      ].join("\n"));
-      return true;
-    });
+    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) => {
-      if (!await this.ensureChannelMemoryAuthorized(envelope)) {
-        return true;
-      }
-      if (envelope.isGroup) {
-        await this.sendMessage(envelope.chatId, "Channel memory cannot be changed in group chats.");
-        return true;
-      }
-      if (args.trim() === "") {
+      const text = args.trim();
+      if (text === "") {
         await this.sendMessage(envelope.chatId, "Usage: /remember-channel <text>");
         return true;
       }
-      const channelMemory = await this.getChannelMemory(envelope);
-      if (!channelMemory) {
-        return true;
-      }
-      try {
-        await channelMemory.appendChannelMemory(this.channelMemoryTarget(envelope), args.trim());
-      } 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 true;
-      }
-      this.invalidateSessionContext(envelope);
-      await this.sendMessage(envelope.chatId, "Channel memory updated.");
+      await this.handleChannelMemoryIntent(envelope, {
+        kind: "remember",
+        text
+      });
       return true;
     });
     this.registerCommand("channel-memory", async (envelope) => {
-      if (!await this.ensureChannelMemoryAuthorized(envelope)) {
-        return true;
-      }
-      if (envelope.isGroup) {
-        await this.sendMessage(envelope.chatId, "Channel memory cannot be shown in group chats.");
-        return true;
-      }
-      const channelMemory = await this.getChannelMemory(envelope);
-      if (!channelMemory) {
-        return true;
-      }
-      let text;
-      try {
-        text = (await channelMemory.readChannelMemory(this.channelMemoryTarget(envelope))).trim();
-      } 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 true;
-      }
-      await this.sendMessage(envelope.chatId, text === "" ? "No channel memory saved." : sanitizePromptText(text));
+      await this.handleChannelMemoryIntent(envelope, { kind: "list" });
       return true;
     });
     this.registerCommand("forget-channel", async (envelope, args) => {
@@ -3051,21 +3465,28 @@ ${promptText}`;
         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;
       }
-      const channelMemory = await this.getChannelMemory(envelope);
-      if (!channelMemory) {
-        return true;
-      }
-      let result;
-      try {
-        result = await channelMemory.clearChannelMemory(this.channelMemoryTarget(envelope));
-      } catch (error) {
-        const message = this.channelMemoryErrorMessage(error);
-        this.logChannelMemoryError("clear", envelope, message);
-        await this.sendMessage(envelope.chatId, `Failed to clear channel memory: ${this.channelMemoryUserErrorMessage()}`);
+      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.");
         return true;
       }
-      this.invalidateSessionContext(envelope);
-      await this.sendMessage(envelope.chatId, result.changed ? "Channel memory cleared." : "No channel memory saved.");
+      const active = this.router.hasSession(this.name, envelope.senderId, envelope.chatId, envelope.threadId);
+      const scopeNote = this.config.sessionScope === "single" ? " (shared channel-wide)" : this.isSharedSession(envelope) ? envelope.isGroup ? " (shared by this group)" : "" : envelope.isGroup ? " (private to you)" : "";
+      await this.sendMessage(envelope.chatId, [
+        `Channel: ${this.name}`,
+        // Identity/memory lines only for channels that opted in — keep
+        // unconfigured channels' output unchanged.
+        ...this.shouldPrependChannelBoundaryPrompt() ? [
+          `Identity: ${sanitizeQuotedText(this.identity.displayName, 128)}`,
+          `Memory: ${sanitizeQuotedText(this.memoryScope.namespace, 128)}`
+        ] : [],
+        // Only the basename — don't leak the absolute cwd to group members.
+        `Workspace: ${basename(this.config.cwd)}`,
+        `Session: ${active ? "active" : "none"}${scopeNote}`
+      ].join("\n"));
       return true;
     });
     this.registerCommand("help", async (envelope) => {
@@ -3075,20 +3496,23 @@ ${promptText}`;
         this.isSharedSession(envelope) ? "/clear confirm \u2014 Clear the shared session (aliases: /reset, /new)" : "/clear \u2014 Clear your session (aliases: /reset, /new)",
         "/who \u2014 Show current session & workspace",
         "/status \u2014 Show session info",
-        "/remember-channel <text> \u2014 Save memory for this chat",
-        "/channel-memory \u2014 Show memory for this chat",
-        "/forget-channel confirm \u2014 Clear memory for this chat"
+        "/approve [request-id] \u2014 Approve a pending permission request",
+        "/approve-always [request-id] \u2014 Always approve a pending permission request",
+        "/deny [request-id] \u2014 Deny a pending permission request"
       ];
       const sharedCmds = /* @__PURE__ */ new Set([
         "help",
         "clear",
         "reset",
         "new",
-        "who",
-        "status",
+        "approve",
+        "approve-always",
+        "deny",
         "remember-channel",
         "channel-memory",
-        "forget-channel"
+        "forget-channel",
+        "who",
+        "status"
       ]);
       const platformCmds = [...this.commands.keys()].filter((c) => !sharedCmds.has(c));
       if (platformCmds.length > 0) {
@@ -3433,7 +3857,7 @@ ${promptText}`;
       isMentioned: true,
       isReplyToBot: true
     };
-    return this.groupGate.check(envelope).allowed && this.gate.isAllowed(normalizedTarget.senderId) && this.isAuthorizedForSharedSession(envelope);
+    return this.groupGate.check(envelope).allowed && this.dmGate.check(envelope).allowed && this.gate.isAllowed(normalizedTarget.senderId) && this.isAuthorizedForSharedSession(envelope);
   }
   /** Check if a message text matches a registered local command. */
   isLocalCommand(text) {
@@ -3486,6 +3910,118 @@ ${promptText}`;
     }
     return this.channelMemory;
   }
+  async handleChannelMemoryIntent(envelope, intent, options = {}) {
+    if (!await this.ensureChannelMemoryAuthorized(envelope)) {
+      return;
+    }
+    if (envelope.isGroup && intent.kind !== "list") {
+      await this.sendMessage(envelope.chatId, "Channel memory cannot be changed in group chats.");
+      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.');
+      return;
+    }
+    const channelMemory = await this.getChannelMemory(envelope);
+    if (!channelMemory) {
+      return;
+    }
+    if (intent.kind === "remember") {
+      try {
+        await channelMemory.appendChannelMemory(this.channelMemoryTarget(envelope), intent.text);
+      } 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.");
+      return;
+    }
+    if (intent.kind === "list") {
+      let text;
+      try {
+        text = (await channelMemory.readChannelMemory(this.channelMemoryTarget(envelope))).trim();
+      } 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));
+      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;
+        }
+      }
+      let result;
+      try {
+        result = await channelMemory.clearChannelMemory(this.channelMemoryTarget(envelope));
+      } catch (error) {
+        const message = this.channelMemoryErrorMessage(error);
+        this.logChannelMemoryError("clear", envelope, message);
+        await this.sendMessage(envelope.chatId, `Failed to clear channel memory: ${this.channelMemoryUserErrorMessage()}`);
+        return;
+      }
+      this.invalidateSessionContext(envelope);
+      await this.sendMessage(envelope.chatId, result.changed ? "Channel memory cleared." : "No channel memory saved.");
+      return;
+    }
+    const unhandled = intent;
+    throw new Error(`Unhandled channel memory intent: ${JSON.stringify(unhandled)}`);
+  }
+  shouldClassifyChannelMemoryIntent(text) {
+    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 ?? ""}`;
+  }
+  setPendingClear(key) {
+    const now = Date.now();
+    for (const [pendingKey, expiresAt] of this.pendingClears) {
+      if (expiresAt < now) {
+        this.pendingClears.delete(pendingKey);
+      }
+    }
+    this.pendingClears.set(key, now + 6e4);
+  }
+  async classifyChannelMemoryIntent(text) {
+    if (!this.memoryIntentClassifier) {
+      return null;
+    }
+    let classified;
+    try {
+      classified = await this.memoryIntentClassifier.classifyChannelMemoryIntent(text);
+    } 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) {
+      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);
   }
@@ -3746,19 +4282,58 @@ ${formatted.join("\n")}
 ${CURRENT_MESSAGE_MARKER}
 ${promptText}`;
   }
-  async handleInbound(envelope) {
+  preflightInbound(envelope) {
     const groupResult = this.groupGate.check(envelope);
     if (!groupResult.allowed) {
       if (groupResult.reason === "mention_required") {
         this.recordPendingGroupHistory(envelope);
       }
-      return;
+      return false;
+    }
+    const dmResult = this.dmGate.check(envelope);
+    if (!dmResult.allowed) {
+      return false;
     }
     const result = this.gate.check(envelope.senderId, envelope.senderName);
     if (!result.allowed) {
       if (result.pairingCode !== void 0) {
-        await this.onPairingRequired(envelope.chatId, result.pairingCode);
+        return this.onPairingRequired(envelope.chatId, result.pairingCode).then(() => false).catch((err) => {
+          process.stderr.write(`[Channel:${this.name}] pairing notification failed: ${sanitizeLogText(err instanceof Error ? err.message : String(err), 200)}
+`);
+          return false;
+        });
       }
+      return false;
+    }
+    this.markPreflighted(envelope);
+    return true;
+  }
+  async handleInbound(envelope) {
+    const preflight = this.preflightInbound(envelope);
+    if (!(isPromiseLike(preflight) ? await preflight : preflight))
+      return;
+    await this.processInbound(envelope);
+  }
+  markPreflighted(envelope) {
+    this.preflightedEnvelopes.add(envelope);
+  }
+  /**
+   * Process an inbound message after preflight gates have passed.
+   *
+   * This method does not run group gating, sender allowlisting, or pairing
+   * checks. Callers must run preflightInbound() first unless the envelope was
+   * already preflighted, such as during collect-buffer drain.
+   */
+  async processInbound(envelope) {
+    if (!this.preflightedEnvelopes.delete(envelope)) {
+      throw new Error("processInbound called without a successful preflightInbound check.");
+    }
+    let memoryIntent = parseChannelMemoryIntent(envelope.text);
+    if (!memoryIntent && this.shouldClassifyChannelMemoryIntent(envelope.text)) {
+      memoryIntent = await this.classifyChannelMemoryIntent(envelope.text);
+    }
+    if (memoryIntent) {
+      await this.handleChannelMemoryIntent(envelope, memoryIntent);
       return;
     }
     const parsed = this.parseCommand(envelope.text);
@@ -3792,14 +4367,14 @@ ${promptText}`;
       const bridgeShellCommand = this.bridge.shellCommand;
       if (cmd && bridgeShellCommand) {
         try {
-          const result2 = await bridgeShellCommand(sessionId, cmd);
-          const longestRun = Math.max(0, ...Array.from((result2.output || "").matchAll(/`+/g), (m) => m[0].length));
+          const result = await bridgeShellCommand(sessionId, cmd);
+          const longestRun = Math.max(0, ...Array.from((result.output || "").matchAll(/`+/g), (m) => m[0].length));
           const fence = "`".repeat(Math.max(3, longestRun + 1));
-          const output = result2.output ? `${fence}
-${result2.output}
+          const output = result.output ? `${fence}
+${result.output}
 ${fence}` : "(no output)";
-          const exitLine = result2.exitCode !== null && result2.exitCode !== 0 ? `
-Exit code: ${result2.exitCode}` : "";
+          const exitLine = result.exitCode !== null && result.exitCode !== 0 ? `
+Exit code: ${result.exitCode}` : "";
           await this.sendMessage(envelope.chatId, `$ ${cmd}
 ${output}${exitLine}`);
         } catch (error) {
@@ -3852,6 +4427,12 @@ ${promptText}`;
             this.collectBuffers.set(sessionId, buffer);
           }
           buffer.push({ text: promptText, envelope });
+          try {
+            this.onPromptBuffered(envelope.chatId, sessionId, envelope.messageId);
+          } catch (err) {
+            process.stderr.write(`[${this.name}] onPromptBuffered threw for session ${sessionId}: ${err instanceof Error ? err.message : err}
+`);
+          }
           return;
         }
         case "steer": {
@@ -3951,6 +4532,8 @@ ${promptToSend}`;
         done,
         resolve: doneResolve,
         chatId: envelope.chatId,
+        threadId: envelope.threadId,
+        isGroup: envelope.isGroup,
         messageId: envelope.messageId,
         senderId: envelope.senderId,
         senderName: envelope.senderName
@@ -4064,6 +4647,7 @@ ${promptToSend}`;
           const lost = buffer.length;
           const coalesced = buffer.map((b) => b.text).join("\n\n");
           const lastEnvelope = buffer[buffer.length - 1].envelope;
+          this.notifyPromptBufferDrained(lastEnvelope.chatId, sessionId, buffer);
           const syntheticEnvelope = {
             ...lastEnvelope,
             text: coalesced,
@@ -4075,7 +4659,8 @@ ${promptToSend}`;
             imageBase64: void 0,
             imageMimeType: void 0
           };
-          this.handleInbound(syntheticEnvelope).catch((err) => {
+          this.markPreflighted(syntheticEnvelope);
+          this.processInbound(syntheticEnvelope).catch((err) => {
             process.stderr.write(`[${this.name}] dropped ${lost} buffered message(s) on collect re-entry for session ${sessionId} (last sender ${lastEnvelope.senderId}): ${err instanceof Error ? err.message : String(err)}
 `);
           });
@@ -4101,6 +4686,10 @@ function truncateGroupHistoryField(value) {
   return value.slice(0, GROUP_HISTORY_ENTRY_METADATA_LIMIT);
 }
 __name(truncateGroupHistoryField, "truncateGroupHistoryField");
+function isPromiseLike(value) {
+  return value !== null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+}
+__name(isPromiseLike, "isPromiseLike");
 function truncateLoopLabel(prompt) {
   const chars = Array.from(prompt);
   return chars.length > 60 ? `${chars.slice(0, 57).join("")}...` : prompt;