@qwen-code/qwen-code 0.19.6 → 0.19.7-nightly.20260708.394c1a289

package/chunks/{chunk-6BEOH4KK.js → chunk-2NPS2UDH.js}

@@ -79,6 +79,168 @@ init_esbuild_shims();
 import { spawn } from "node:child_process";
 import { Readable, Writable } from "node:stream";
 import { EventEmitter } from "node:events";
+
+// packages/channels/base/dist/ChannelLoopTools.js
+init_esbuild_shims();
+var CHANNEL_LOOP_MCP_SERVER_NAME = "channel_loop";
+var CLIENT_MCP_MESSAGE_METHOD = "qwen/control/client_mcp/message";
+var WORKSPACE_MCP_RUNTIME_ADD_METHOD = "qwen/control/workspace/mcp/runtime-add";
+var CLIENT_MCP_OVER_WS_CONFIG_FLAG = "__clientMcpOverWs";
+var createTool = {
+  name: "channel_loop_create",
+  description: "Create a recurring proactive reminder or scheduled prompt for the current channel chat. Use this in channel sessions instead of cron_create.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      cron: {
+        type: "string",
+        description: 'Standard 5-field cron expression in local time, for example "*/5 * * * *".'
+      },
+      prompt: {
+        type: "string",
+        description: "The message or instruction to run and proactively push to this channel chat."
+      },
+      recurring: {
+        type: "boolean",
+        description: "Whether the loop recurs. Defaults to true."
+      }
+    },
+    required: ["cron", "prompt"]
+  }
+};
+var listTool = {
+  name: "channel_loop_list",
+  description: "List proactive loops for the current channel chat.",
+  inputSchema: { type: "object", properties: {} }
+};
+var cancelTool = {
+  name: "channel_loop_cancel",
+  description: "Cancel a proactive loop for the current channel chat.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      id: { type: "string", description: "Loop id to cancel." }
+    },
+    required: ["id"]
+  }
+};
+var CHANNEL_LOOP_MCP_TOOLS = [createTool, listTool, cancelTool];
+var ChannelLoopMcpServer = class {
+  static {
+    __name(this, "ChannelLoopMcpServer");
+  }
+  handler;
+  constructor(handler) {
+    this.handler = handler;
+  }
+  async handleMessage(message, context) {
+    const id = message["id"];
+    if (id === void 0 || id === null) {
+      return void 0;
+    }
+    try {
+      const result = await this.dispatch(message, context);
+      return { jsonrpc: "2.0", id, result };
+    } catch (error) {
+      return {
+        jsonrpc: "2.0",
+        id,
+        error: {
+          code: -32603,
+          message: error instanceof Error ? error.message : String(error)
+        }
+      };
+    }
+  }
+  async dispatch(message, context) {
+    switch (message["method"]) {
+      case "initialize":
+        return {
+          protocolVersion: "2024-11-05",
+          capabilities: { tools: {} },
+          serverInfo: { name: CHANNEL_LOOP_MCP_SERVER_NAME, version: "0.0.1" }
+        };
+      case "tools/list":
+        return { tools: CHANNEL_LOOP_MCP_TOOLS };
+      case "tools/call":
+        return this.callTool(message["params"], context);
+      case "ping":
+        return {};
+      default:
+        throw new Error(`Method not found: ${String(message["method"])}`);
+    }
+  }
+  async callTool(rawParams, context) {
+    if (!context.sessionId) {
+      throw new Error("Missing channel session id.");
+    }
+    if (typeof rawParams !== "object" || rawParams === null) {
+      throw new Error("Invalid tools/call params.");
+    }
+    const params = rawParams;
+    const name = params["name"];
+    const args = typeof params["arguments"] === "object" && params["arguments"] !== null ? params["arguments"] : {};
+    let toolResult;
+    switch (name) {
+      case createTool.name:
+        toolResult = await this.handler.create(context.sessionId, readCreateInput(args));
+        break;
+      case listTool.name:
+        toolResult = await this.handler.list(context.sessionId);
+        break;
+      case cancelTool.name:
+        toolResult = await this.handler.cancel(context.sessionId, readId(args));
+        break;
+      default:
+        throw new Error(`Unknown channel loop tool: ${String(name)}`);
+    }
+    const result = typeof toolResult === "string" ? { text: toolResult } : toolResult;
+    return {
+      content: [{ type: "text", text: result.text }],
+      ...result.isError ? { isError: true } : {}
+    };
+  }
+};
+function readCreateInput(args) {
+  const cron = args["cron"];
+  const prompt = args["prompt"];
+  if (typeof cron !== "string" || cron.trim().length === 0) {
+    throw new Error("cron must be a non-empty string.");
+  }
+  if (typeof prompt !== "string" || prompt.trim().length === 0) {
+    throw new Error("prompt must be a non-empty string.");
+  }
+  const recurring = readRecurring(args["recurring"]);
+  return {
+    cron: cron.trim(),
+    prompt: prompt.trim(),
+    ...recurring !== void 0 ? { recurring } : {}
+  };
+}
+__name(readCreateInput, "readCreateInput");
+function readRecurring(value) {
+  if (typeof value === "boolean")
+    return value;
+  if (value === "false" || value === 0)
+    return false;
+  if (value === "true" || value === 1)
+    return true;
+  return void 0;
+}
+__name(readRecurring, "readRecurring");
+function readId(args) {
+  const id = args["id"];
+  if (typeof id !== "string" || id.trim().length === 0) {
+    throw new Error("id must be a non-empty string.");
+  }
+  return id.trim();
+}
+__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_EVENT_LOOP_STALL_RE = /^\[perf\] acp agent event loop stall: max=(\d+(?:\.\d+)?)ms/m;
 function readAvailableCommandAltNames(raw) {
   if (typeof raw !== "object" || raw === null)
     return void 0;
@@ -100,6 +262,10 @@ var AcpBridge = class extends EventEmitter {
   connection = null;
   options;
   _availableCommands = [];
+  channelLoopMcpServer;
+  channelLoopToolHandlers = [];
+  channelLoopMcpRegistered = false;
+  channelLoopMcpRegistration = null;
   constructor(options) {
     super();
     this.options = options;
@@ -120,7 +286,7 @@ var AcpBridge = class extends EventEmitter {
     this.child = spawn(process.execPath, args, {
       cwd,
       stdio: ["pipe", "pipe", "pipe"],
-      env: { ...process.env },
+      env: { ...process.env, QWEN_CODE_DISABLE_CRON: "1" },
       shell: false
     });
     this.child.stderr?.on("data", (data) => {
@@ -128,6 +294,7 @@ var AcpBridge = class extends EventEmitter {
       if (msg) {
         process.stderr.write(`[AcpBridge] ${msg}
 `);
+        this.maybeKillOnEventLoopStall(msg);
       }
     });
     this.child.on("exit", (code, signal) => {
@@ -154,6 +321,7 @@ var AcpBridge = class extends EventEmitter {
         const optionId = options.find((o) => o.optionId === "proceed_once")?.optionId || options[0]?.optionId || "proceed_once";
         return { outcome: { outcome: "selected", optionId } };
       }, "requestPermission"),
+      extMethod: /* @__PURE__ */ __name(async (method, params) => this.handleExtMethod(method, params), "extMethod"),
       extNotification: /* @__PURE__ */ __name(async () => {
       }, "extNotification")
     }), stream);
@@ -161,14 +329,28 @@ var AcpBridge = class extends EventEmitter {
       protocolVersion: PROTOCOL_VERSION,
       clientCapabilities: {}
     });
+    await this.registerChannelLoopMcpServer();
+  }
+  registerChannelLoopToolHandler(handler) {
+    if (!this.channelLoopToolHandlers.includes(handler)) {
+      this.channelLoopToolHandlers.push(handler);
+    }
+    this.channelLoopMcpServer ??= new ChannelLoopMcpServer({
+      create: /* @__PURE__ */ __name((sessionId, input) => this.resolveChannelLoopToolHandler(sessionId).create(sessionId, input), "create"),
+      list: /* @__PURE__ */ __name((sessionId) => this.resolveChannelLoopToolHandler(sessionId).list(sessionId), "list"),
+      cancel: /* @__PURE__ */ __name((sessionId, id) => this.resolveChannelLoopToolHandler(sessionId).cancel(sessionId, id), "cancel")
+    });
+    void this.registerChannelLoopMcpServer();
   }
   async newSession(cwd) {
     const conn = this.ensureConnection();
+    await this.registerChannelLoopMcpServer();
     const response = await conn.newSession({ cwd, mcpServers: [] });
     return response.sessionId;
   }
   async loadSession(sessionId, cwd) {
     const conn = this.ensureConnection();
+    await this.registerChannelLoopMcpServer();
     const response = await conn.loadSession({
       sessionId,
       cwd,
@@ -263,7 +445,103 @@ var AcpBridge = class extends EventEmitter {
     }
     return this.connection;
   }
+  maybeKillOnEventLoopStall(stderr) {
+    const match = ACP_EVENT_LOOP_STALL_RE.exec(stderr);
+    if (!match)
+      return;
+    const maxMs = Number(match[1]);
+    if (!Number.isFinite(maxMs) || maxMs < ACP_EVENT_LOOP_STALL_RESTART_MS) {
+      return;
+    }
+    const child = this.child;
+    if (!child || child.killed || child.exitCode !== null) {
+      return;
+    }
+    process.stderr.write(`[AcpBridge] ACP agent event loop stalled for ${Math.round(maxMs)}ms; killing child process to trigger restart
+`);
+    child.kill("SIGKILL");
+  }
+  async registerChannelLoopMcpServer() {
+    if (!this.connection || !this.channelLoopMcpServer || this.channelLoopMcpRegistered) {
+      return;
+    }
+    if (this.channelLoopMcpRegistration) {
+      await this.channelLoopMcpRegistration;
+      return;
+    }
+    this.channelLoopMcpRegistration = this.connection.extMethod(WORKSPACE_MCP_RUNTIME_ADD_METHOD, {
+      name: CHANNEL_LOOP_MCP_SERVER_NAME,
+      originatorClientId: "channel",
+      config: {
+        type: "sdk",
+        [CLIENT_MCP_OVER_WS_CONFIG_FLAG]: true
+      }
+    }).then((result) => {
+      if (isSkippedMcpRegistration(result)) {
+        this.channelLoopMcpRegistered = false;
+        process.stderr.write(`[AcpBridge] Channel loop MCP server registration skipped${formatSkippedRegistrationReason(result)}
+`);
+        return;
+      }
+      this.channelLoopMcpRegistered = true;
+    }).catch((error) => {
+      this.channelLoopMcpRegistered = false;
+      process.stderr.write(`[AcpBridge] Failed to register channel loop MCP server: ${error instanceof Error ? error.message : String(error)}
+`);
+    }).finally(() => {
+      this.channelLoopMcpRegistration = null;
+    });
+    await this.channelLoopMcpRegistration;
+  }
+  async handleExtMethod(method, params) {
+    if (method === CLIENT_MCP_MESSAGE_METHOD) {
+      return this.handleClientMcpMessage(params);
+    }
+    if (method === MID_TURN_QUEUE_DRAIN_METHOD) {
+      return { messages: [] };
+    }
+    throw new Error(`Method not found: ${method}`);
+  }
+  async handleClientMcpMessage(params) {
+    if (!this.channelLoopMcpServer) {
+      throw new Error("Channel loop MCP server is not registered.");
+    }
+    const server = params["server"];
+    if (server !== CHANNEL_LOOP_MCP_SERVER_NAME) {
+      throw new Error(`Unknown client MCP server: ${String(server)}`);
+    }
+    const payload = params["payload"];
+    if (typeof payload !== "object" || payload === null) {
+      throw new Error("Invalid client MCP payload.");
+    }
+    const sessionId = typeof params["sessionId"] === "string" ? params["sessionId"] : void 0;
+    const response = await this.channelLoopMcpServer.handleMessage(payload, { sessionId });
+    if (!response) {
+      return { payload: { jsonrpc: "2.0", id: 0, result: {} } };
+    }
+    return { payload: response };
+  }
+  resolveChannelLoopToolHandler(sessionId) {
+    if (this.channelLoopToolHandlers.length === 1 && !this.channelLoopToolHandlers[0].canHandle) {
+      return this.channelLoopToolHandlers[0];
+    }
+    const handler = this.channelLoopToolHandlers.find((candidate) => candidate.canHandle?.(sessionId) === true);
+    if (handler)
+      return handler;
+    throw new Error(this.channelLoopToolHandlers.length === 0 ? "No channel loop tool handler is registered." : `No channel loop handler matched session ${sessionId}.`);
+  }
 };
+function isSkippedMcpRegistration(result) {
+  return typeof result === "object" && result !== null && result.skipped === true;
+}
+__name(isSkippedMcpRegistration, "isSkippedMcpRegistration");
+function formatSkippedRegistrationReason(result) {
+  if (typeof result !== "object" || result === null)
+    return ".";
+  const reason = result.reason;
+  return typeof reason === "string" && reason.length > 0 ? `: ${sanitizeLogText(reason, 256)}` : ".";
+}
+__name(formatSkippedRegistrationReason, "formatSkippedRegistrationReason");
 
 // packages/channels/base/dist/DaemonChannelBridge.js
 init_esbuild_shims();
@@ -1404,18 +1682,21 @@ var SessionRouter = class {
         return `${channelName}:${senderId}:${chatId}`;
     }
   }
-  async resolve(channelName, senderId, chatId, threadId, cwd) {
+  async resolve(channelName, senderId, chatId, threadId, cwd, isGroup) {
     const key = this.routingKey(channelName, senderId, chatId, threadId);
     let failedCreateWaits = 0;
     for (; ; ) {
       const existing = this.toSession.get(key);
       if (existing) {
+        this.promoteTargetToGroup(existing, isGroup);
         return existing;
       }
       const creating = this.creatingSessions.get(key);
       if (creating) {
         try {
-          return await creating;
+          const sessionId = await creating;
+          this.promoteTargetToGroup(sessionId, isGroup);
+          return sessionId;
         } catch (err) {
           if (this.creatingSessions.get(key) === creating) {
             this.creatingSessions.delete(key);
@@ -1437,7 +1718,8 @@ var SessionRouter = class {
             channelName,
             senderId,
             chatId,
-            threadId
+            threadId,
+            isGroup
           });
           this.toCwd.set(sessionId, sessionCwd);
           this.persist();
@@ -1538,6 +1820,15 @@ var SessionRouter = class {
     this.toCwd.delete(sessionId);
     return sessionId;
   }
+  promoteTargetToGroup(sessionId, isGroup) {
+    const current = this.toTarget.get(sessionId);
+    if (!current)
+      return;
+    if (current.isGroup === true || isGroup !== true)
+      return;
+    this.toTarget.set(sessionId, { ...current, isGroup: true });
+    this.persist();
+  }
   /** Get all session entries for crash recovery. */
   getAll() {
     const entries = [];
@@ -1976,6 +2267,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]";
@@ -1983,6 +2334,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");
@@ -2015,6 +2368,7 @@ var ChannelBase = class {
   /** Resolved proxy URL, available to subclasses for adapter-specific clients. */
   proxy;
   channelMemory;
+  memoryIntentClassifier;
   groupHistory;
   loopController;
   instructedSessions = /* @__PURE__ */ new Set();
@@ -2028,16 +2382,24 @@ 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");
+  channelLoopToolHandler = {
+    canHandle: /* @__PURE__ */ __name((sessionId) => this.router.getTarget(sessionId)?.channelName === this.name, "canHandle"),
+    create: /* @__PURE__ */ __name((sessionId, input) => this.createLoopFromTool(sessionId, input), "create"),
+    list: /* @__PURE__ */ __name((sessionId) => this.listLoopsFromTool(sessionId), "list"),
+    cancel: /* @__PURE__ */ __name((sessionId, id) => this.cancelLoopFromTool(sessionId, id), "cancel")
+  };
   dispatchToolCall(event) {
     const target = this.router.getTarget(event.sessionId);
     const active = this.activePrompts.get(event.sessionId);
@@ -2069,6 +2431,7 @@ 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);
@@ -2076,6 +2439,9 @@ var ChannelBase = class {
     this.gate = new SenderGate(config.senderPolicy, config.allowedUsers, pairingStore);
     this.router = options?.router || new SessionRouter(bridge, config.cwd, config.sessionScope);
     this.registerSharedCommands();
+    if (this.loopController) {
+      bridge.registerChannelLoopToolHandler?.(this.channelLoopToolHandler);
+    }
     this.registerBridgeEvents = options?.registerBridgeEvents ?? !options?.router;
     if (this.registerBridgeEvents) {
       this.attachBridgeEvents(bridge);
@@ -2190,6 +2556,9 @@ var ChannelBase = class {
     }
     this.router.setBridge(bridge);
     this.bridge = bridge;
+    if (this.loopController) {
+      bridge.registerChannelLoopToolHandler?.(this.channelLoopToolHandler);
+    }
     if (this.registerBridgeEvents) {
       this.attachBridgeEvents(bridge);
     }
@@ -2212,7 +2581,7 @@ var ChannelBase = class {
       await this.loopController?.disable(job.id);
       throw new Error(`Loop ${job.id} target is no longer authorized.`);
     }
-    const sessionId = await this.router.resolve(this.name, job.target.senderId, job.target.chatId, job.target.threadId, job.cwd);
+    const sessionId = await this.router.resolve(this.name, job.target.senderId, job.target.chatId, job.target.threadId, job.cwd, job.target.isGroup);
     const label = sanitizeQuotedText(job.label || job.id, 80);
     const createdBy = sanitizeSenderName(job.createdBy || "unknown");
     let promptText = `[Loop "${label}" created by ${createdBy}] Scheduled task running unattended: no one is present to answer questions, and your final response is delivered to this chat automatically \u2014 do whatever work the task requires, then put the result in your final response instead of trying to deliver it to this chat yourself.
@@ -2286,6 +2655,8 @@ ${promptText}`;
         resolve: doneResolve,
         chatId: job.target.chatId,
         messageId: job.id,
+        senderId: job.target.senderId,
+        senderName: job.createdBy,
         loopPrompt: true
       };
       this.activePrompts.set(sessionId, promptState);
@@ -2396,6 +2767,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,
@@ -2405,7 +2777,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)}
 `);
           });
@@ -2495,11 +2868,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)}
 `);
@@ -2545,6 +2946,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.
@@ -2609,7 +3016,7 @@ ${promptText}`;
           }
           this.sessionGenerations.set(id, (this.sessionGenerations.get(id) ?? 0) + 1);
           const active = this.activePrompts.get(id);
-          this.collectBuffers.delete(id);
+          this.dropCollectBuffer(id);
           if (active) {
             const settled = await this.cancelAndAwaitActive(active, id);
             if (!settled) {
@@ -2661,77 +3068,20 @@ ${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("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) => {
@@ -2746,21 +3096,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) => {
@@ -2769,21 +3126,18 @@ ${promptText}`;
         "/help \u2014 Show this help",
         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"
+        "/status \u2014 Show session info"
       ];
       const sharedCmds = /* @__PURE__ */ new Set([
         "help",
         "clear",
         "reset",
         "new",
-        "who",
-        "status",
         "remember-channel",
         "channel-memory",
-        "forget-channel"
+        "forget-channel",
+        "who",
+        "status"
       ]);
       const platformCmds = [...this.commands.keys()].filter((c) => !sharedCmds.has(c));
       if (platformCmds.length > 0) {
@@ -2906,6 +3260,100 @@ ${promptText}`;
     await this.sendMessage(envelope.chatId, `Loop ${job.id}: ${job.cron}`);
     return true;
   }
+  async createLoopFromTool(sessionId, input) {
+    if (!this.loopController) {
+      return { text: "Channel loops are not configured.", isError: true };
+    }
+    if (!this.supportsProactiveSend()) {
+      return {
+        text: "This channel does not support proactive loop messages.",
+        isError: true
+      };
+    }
+    if (this.config.sessionScope === "single") {
+      return {
+        text: "Loops are not supported when sessionScope is single.",
+        isError: true
+      };
+    }
+    const target = this.loopToolTarget(sessionId);
+    if (typeof target === "string")
+      return { text: target, isError: true };
+    if (!this.supportsProactiveTarget(target)) {
+      return {
+        text: "This channel does not support proactive loop messages for this chat target.",
+        isError: true
+      };
+    }
+    const cron = input.cron.trim();
+    try {
+      this.loopController.validateCron(cron);
+    } catch (err) {
+      return {
+        text: `Invalid cron expression: ${err instanceof Error ? err.message : String(err)}`,
+        isError: true
+      };
+    }
+    const prompt = sanitizePromptText(input.prompt.trim());
+    if (Array.from(prompt).length > MAX_LOOP_PROMPT_CHARS) {
+      return {
+        text: `Loop prompt is too long; keep it under ${MAX_LOOP_PROMPT_CHARS} characters.`,
+        isError: true
+      };
+    }
+    const loopInput = {
+      channelName: this.name,
+      target,
+      cwd: this.config.cwd,
+      cron,
+      prompt,
+      label: truncateLoopLabel(prompt),
+      recurring: input.recurring !== false,
+      createdBy: sanitizeSenderName(this.toolCallerName(sessionId, target))
+    };
+    let job;
+    if (this.loopController.createForTarget) {
+      job = await this.loopController.createForTarget(loopInput, MAX_LOOP_JOBS_PER_TARGET);
+    } else {
+      const existingJobs = await this.loopController.listForTarget(this.name, target);
+      if (existingJobs.filter((existingJob) => existingJob.enabled).length < MAX_LOOP_JOBS_PER_TARGET) {
+        job = await this.loopController.create(loopInput);
+      }
+    }
+    if (!job) {
+      return {
+        text: "Too many loops for this chat. Cancel an existing loop before adding another.",
+        isError: true
+      };
+    }
+    return `Loop ${job.id}: ${job.cron}`;
+  }
+  async listLoopsFromTool(sessionId) {
+    if (!this.loopController) {
+      return { text: "Channel loops are not configured.", isError: true };
+    }
+    const target = this.loopToolTarget(sessionId);
+    if (typeof target === "string")
+      return { text: target, isError: true };
+    const jobs = await this.loopController.listForTarget(this.name, target);
+    if (jobs.length === 0)
+      return "No loops.";
+    return jobs.map((job) => this.formatLoopListLine(job)).join("\n");
+  }
+  async cancelLoopFromTool(sessionId, id) {
+    if (!this.loopController) {
+      return { text: "Channel loops are not configured.", isError: true };
+    }
+    const target = this.loopToolTarget(sessionId);
+    if (typeof target === "string")
+      return { text: target, isError: true };
+    const jobs = await this.loopController.listForTarget(this.name, target);
+    const match = jobs.find((job) => job.id === id);
+    if (!match)
+      return { text: `No loop ${id}.`, isError: true };
+    const disabled = await this.loopController.disable(id);
+    return disabled ? `Cancelled loop ${id}.` : { text: `Failed to cancel loop ${id}.`, isError: true };
+  }
   async handleLoopList(envelope) {
     if (!this.loopController)
       return true;
@@ -2986,35 +3434,55 @@ ${promptText}`;
     }
     const jobs = await this.loopController.listForTarget(this.name, this.loopTargetFromEnvelope(envelope));
     const match = jobs.find((job) => job.id === id);
-    const disabled = match ? await this.loopController.disable(id) : false;
-    await this.sendMessage(envelope.chatId, disabled ? `Cancelled loop ${id}.` : `No loop ${id}.`);
+    if (!match) {
+      await this.sendMessage(envelope.chatId, `No loop ${id}.`);
+      return true;
+    }
+    const disabled = await this.loopController.disable(id);
+    await this.sendMessage(envelope.chatId, disabled ? `Cancelled loop ${id}.` : `Failed to cancel loop ${id}.`);
     return true;
   }
   loopTargetFromEnvelope(envelope) {
-    return {
+    return this.normalizeLoopTarget({
       channelName: this.name,
       senderId: envelope.senderId,
       chatId: envelope.chatId,
       threadId: envelope.threadId,
       isGroup: envelope.isGroup === true
-    };
+    });
   }
-  isStoredLoopTargetAuthorized(target, senderName) {
-    if (target.isGroup === void 0) {
-      return false;
+  normalizeLoopTarget(target) {
+    return { ...target, isGroup: target.isGroup === true };
+  }
+  loopToolTarget(sessionId) {
+    const target = this.router.getTarget(sessionId);
+    if (!target || target.channelName !== this.name) {
+      return "No channel target is bound to this session.";
     }
+    if (!this.isAuthorizedForSharedSessionToolCall(target, sessionId)) {
+      return "Only authorized members can use loops in this shared session.";
+    }
+    const senderId = this.activePrompts.get(sessionId)?.senderId;
+    const normalizedTarget = this.normalizeLoopTarget(target);
+    if (senderId && this.isSharedSessionTarget(normalizedTarget)) {
+      return { ...normalizedTarget, senderId };
+    }
+    return normalizedTarget;
+  }
+  isStoredLoopTargetAuthorized(target, senderName) {
+    const normalizedTarget = this.normalizeLoopTarget(target);
     const envelope = {
       channelName: this.name,
-      senderId: target.senderId,
+      senderId: normalizedTarget.senderId,
       senderName,
-      chatId: target.chatId,
+      chatId: normalizedTarget.chatId,
       text: "",
-      threadId: target.threadId,
-      isGroup: target.isGroup === true,
+      threadId: normalizedTarget.threadId,
+      isGroup: normalizedTarget.isGroup,
       isMentioned: true,
       isReplyToBot: true
     };
-    return this.groupGate.check(envelope).allowed && this.gate.isAllowed(target.senderId) && this.isAuthorizedForSharedSession(envelope);
+    return this.groupGate.check(envelope).allowed && this.gate.isAllowed(normalizedTarget.senderId) && this.isAuthorizedForSharedSession(envelope);
   }
   /** Check if a message text matches a registered local command. */
   isLocalCommand(text) {
@@ -3067,6 +3535,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);
   }
@@ -3099,10 +3679,26 @@ ${promptText}`;
    * gate can't drift; each caller sends its own rejection wording.
    */
   isAuthorizedForSharedSession(envelope) {
-    if (!this.isSharedSession(envelope))
+    return this.isAuthorizedForSharedSessionTarget(envelope);
+  }
+  isAuthorizedForSharedSessionTarget(target) {
+    if (!this.isSharedSessionTarget(target))
       return true;
     const authorized = this.config.allowedUsers;
-    return authorized.length === 0 || authorized.includes(envelope.senderId);
+    return authorized.length === 0 || authorized.includes(target.senderId);
+  }
+  isAuthorizedForSharedSessionToolCall(target, sessionId) {
+    if (!this.isSharedSessionTarget(target))
+      return true;
+    const authorized = this.config.allowedUsers;
+    if (authorized.length === 0)
+      return true;
+    const senderId = this.activePrompts.get(sessionId)?.senderId;
+    return senderId !== void 0 && authorized.includes(senderId);
+  }
+  toolCallerName(sessionId, target) {
+    const active = this.activePrompts.get(sessionId);
+    return active?.senderName || active?.senderId || target.senderId || "agent";
   }
   stopActiveStreaming(active, sessionId, reason) {
     try {
@@ -3311,19 +3907,54 @@ ${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 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);
@@ -3351,20 +3982,20 @@ ${promptText}`;
         return;
       }
     }
-    const sessionId = await this.router.resolve(this.name, envelope.senderId, envelope.chatId, envelope.threadId, this.config.cwd);
+    const sessionId = await this.router.resolve(this.name, envelope.senderId, envelope.chatId, envelope.threadId, this.config.cwd, envelope.isGroup);
     if (bangText.startsWith("!")) {
       const cmd = bangText.slice(1).trim();
       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) {
@@ -3417,6 +4048,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": {
@@ -3516,7 +4153,9 @@ ${promptToSend}`;
         done,
         resolve: doneResolve,
         chatId: envelope.chatId,
-        messageId: envelope.messageId
+        messageId: envelope.messageId,
+        senderId: envelope.senderId,
+        senderName: envelope.senderName
       };
       this.activePrompts.set(sessionId, promptState);
       this.emitTaskLifecycle({
@@ -3627,6 +4266,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,
@@ -3638,7 +4278,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)}
 `);
           });
@@ -3664,6 +4305,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;
@@ -3809,7 +4454,7 @@ var ChannelLoopStore = class {
   }
 };
 function sameTarget(a, b) {
-  return a.channelName === b.channelName && a.senderId === b.senderId && a.chatId === b.chatId && a.threadId === b.threadId && a.isGroup === b.isGroup;
+  return a.channelName === b.channelName && a.senderId === b.senderId && a.chatId === b.chatId && a.threadId === b.threadId;
 }
 __name(sameTarget, "sameTarget");
 function normalizeTarget(target) {
@@ -3852,12 +4497,12 @@ __name(isTerminalTaskLifecycleType, "isTerminalTaskLifecycleType");
 export {
   resolvePath,
   getGlobalQwenDir,
-  AcpBridge,
-  DaemonChannelBridge,
-  PairingStore,
   sanitizeSenderName,
   sanitizePromptText,
   sanitizeLogText,
+  AcpBridge,
+  DaemonChannelBridge,
+  PairingStore,
   SessionRouter,
   ChannelLoopScheduler,
   ChannelBase,