@qwen-code/qwen-code 0.21.1-simplify-system-prompt.0 → 0.21.1

package/chunks/{chunk-ML52PL6O.js → chunk-7I5GTCT4.js}

@@ -12,6 +12,163 @@ import {
   __name
 } from "./chunk-J2S4EL5Y.js";
 
+// 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/sanitize.js
 init_esbuild_shims();
 var PROMPT_UNSAFE_INVISIBLES = new RegExp("[\\u0080-\\u009f\\p{Cf}\\u2028\\u2029]|\\p{Variation_Selector}", "gu");
@@ -294,166 +451,8 @@ import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 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 TODO_STOP_GUARD_CONTINUATION_CLAIM_METHOD = "craft/claimTodoStopGuardContinuation";
 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;
@@ -480,6 +479,8 @@ var AcpBridge = class extends EventEmitter {
   _availableCommands = [];
   channelLoopMcpServer;
   channelLoopToolHandlers = [];
+  knownSessionIds = /* @__PURE__ */ new Set();
+  sessionBindingTokens = /* @__PURE__ */ new Map();
   channelLoopMcpRegistered = false;
   channelLoopMcpRegistration = null;
   pendingPermissions = /* @__PURE__ */ new Map();
@@ -518,6 +519,8 @@ var AcpBridge = class extends EventEmitter {
       process.stderr.write(`[AcpBridge] Process exited (code=${code}, signal=${signal})
 `);
       this.resolvePendingPermissions();
+      this.knownSessionIds.clear();
+      this.sessionBindingTokens.clear();
       this.connection = null;
       this.child = null;
       this.emit("disconnected", code, signal);
@@ -556,21 +559,25 @@ var AcpBridge = class extends EventEmitter {
     });
     void this.registerChannelLoopMcpServer();
   }
-  async newSession(cwd) {
+  async newSession(cwd, _options, bindingToken) {
     const conn = this.ensureConnection();
     await this.registerChannelLoopMcpServer();
     const response = await conn.newSession({ cwd, mcpServers: [] });
+    this.knownSessionIds.add(response.sessionId);
+    this.sessionBindingTokens.set(response.sessionId, bindingToken);
     return response.sessionId;
   }
-  async loadSession(sessionId, cwd) {
+  async loadSession(sessionId, cwd, _options, bindingToken) {
     const conn = this.ensureConnection();
     await this.registerChannelLoopMcpServer();
-    const response = await conn.loadSession({
+    await conn.loadSession({
       sessionId,
       cwd,
       mcpServers: []
     });
-    return response.sessionId;
+    this.knownSessionIds.add(sessionId);
+    this.sessionBindingTokens.set(sessionId, bindingToken);
+    return sessionId;
   }
   async prompt(sessionId, text, options) {
     const conn = this.ensureConnection();
@@ -622,6 +629,19 @@ var AcpBridge = class extends EventEmitter {
       this.resolvePendingPermissions(sessionId);
     }
   }
+  async discardSession(sessionId, expectedBindingToken) {
+    if (expectedBindingToken !== void 0 && this.sessionBindingTokens.get(sessionId) !== expectedBindingToken) {
+      return;
+    }
+    if (!this.knownSessionIds.delete(sessionId))
+      return;
+    this.sessionBindingTokens.delete(sessionId);
+    this.resolvePendingPermissions(sessionId);
+    const conn = this.connection;
+    if (!conn || !this.isConnected)
+      return;
+    await conn.extMethod("qwen/control/session/close", { sessionId });
+  }
   async respondToPermission(requestId, response) {
     const pending = this.pendingPermissions.get(requestId);
     if (!pending) {
@@ -638,6 +658,8 @@ var AcpBridge = class extends EventEmitter {
   }
   stop() {
     this.resolvePendingPermissions();
+    this.knownSessionIds.clear();
+    this.sessionBindingTokens.clear();
     if (this.child) {
       this.child.kill();
       this.child = null;
@@ -814,7 +836,14 @@ var AcpBridge = class extends EventEmitter {
       return this.handleClientMcpMessage(params);
     }
     if (method === MID_TURN_QUEUE_DRAIN_METHOD) {
-      return { messages: [] };
+      return { messages: [], hasQueuedPrompt: false };
+    }
+    if (method === TODO_STOP_GUARD_CONTINUATION_CLAIM_METHOD) {
+      const sessionId = typeof params["sessionId"] === "string" ? params["sessionId"] : "";
+      return {
+        claimed: this.knownSessionIds.has(sessionId),
+        hasQueuedPrompt: false
+      };
     }
     throw new Error(`Method not found: ${method}`);
   }
@@ -948,6 +977,10 @@ var DaemonChannelBridge = class extends EventEmitter2 {
   activePromptControllers = /* @__PURE__ */ new Map();
   availableCommandsBySession = /* @__PURE__ */ new Map();
   turnBarriers = /* @__PURE__ */ new Map();
+  channelLoopToolHandlers = [];
+  registeredChannelLoopMcpSessions = /* @__PURE__ */ new Set();
+  channelLoopMcpRegistrations = /* @__PURE__ */ new Map();
+  channelLoopMcpServer;
   connected = false;
   lifecycleGeneration = 0;
   latestAvailableCommandsSessionId;
@@ -998,6 +1031,7 @@ var DaemonChannelBridge = class extends EventEmitter2 {
       await this.rejectStaleSession(session);
     }
     this.attachSession(session, bindingToken);
+    await this.registerChannelLoopMcpForSession(session.sessionId);
     return session.sessionId;
   }
   async loadSession(sessionId, cwd, options, bindingToken) {
@@ -1019,8 +1053,22 @@ var DaemonChannelBridge = class extends EventEmitter2 {
       throw new Error(`Daemon returned session ${session.sessionId} while loading ${sessionId}`);
     }
     this.attachSession(session, bindingToken);
+    await this.registerChannelLoopMcpForSession(session.sessionId);
     return session.sessionId;
   }
+  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")
+    });
+    for (const sessionId of this.sessions.keys()) {
+      void this.registerChannelLoopMcpForSession(sessionId);
+    }
+  }
   async prompt(sessionId, text, options) {
     const session = this.ensureSession(sessionId);
     if (this.activePrompts.has(sessionId)) {
@@ -1177,7 +1225,7 @@ var DaemonChannelBridge = class extends EventEmitter2 {
     return this.connected;
   }
   attachSession(session, bindingToken) {
-    const replacedSession = this.removeSessionBinding(session.sessionId);
+    const replacedSession = this.removeSessionBinding(session.sessionId, false);
     if (replacedSession) {
       void this.releaseSessionClient(replacedSession).catch((error) => {
         this.lastError = error;
@@ -1441,7 +1489,7 @@ var DaemonChannelBridge = class extends EventEmitter2 {
     }
     this.emit("sessionDied", { sessionId, reason });
   }
-  removeSessionBinding(sessionId) {
+  removeSessionBinding(sessionId, unregisterChannelLoopMcp = true) {
     const session = this.sessions.get(sessionId);
     if (!session)
       return void 0;
@@ -1466,8 +1514,51 @@ var DaemonChannelBridge = class extends EventEmitter2 {
         this.respondedRequestToSession.delete(requestId);
       }
     }
+    if (unregisterChannelLoopMcp) {
+      this.unregisterChannelLoopMcpForSession(sessionId);
+    }
     return session;
   }
+  async registerChannelLoopMcpForSession(sessionId) {
+    const host = this.options.channelLoopMcpHost;
+    const server = this.channelLoopMcpServer;
+    if (!host || !server || this.registeredChannelLoopMcpSessions.has(sessionId)) {
+      return;
+    }
+    const pending = this.channelLoopMcpRegistrations.get(sessionId);
+    if (pending) {
+      await pending;
+      return;
+    }
+    const registration = host.register(sessionId, (message) => server.handleMessage(message, { sessionId })).then(async () => {
+      if (this.sessions.has(sessionId)) {
+        this.registeredChannelLoopMcpSessions.add(sessionId);
+      } else {
+        await host.unregister(sessionId);
+      }
+    }).catch((error) => {
+      this.lastError = error;
+    }).finally(() => {
+      if (this.channelLoopMcpRegistrations.get(sessionId) === registration) {
+        this.channelLoopMcpRegistrations.delete(sessionId);
+      }
+    });
+    this.channelLoopMcpRegistrations.set(sessionId, registration);
+    await registration;
+  }
+  unregisterChannelLoopMcpForSession(sessionId) {
+    if (!this.registeredChannelLoopMcpSessions.delete(sessionId))
+      return;
+    void this.options.channelLoopMcpHost?.unregister(sessionId).catch((error) => {
+      this.lastError = error;
+    });
+  }
+  resolveChannelLoopToolHandler(sessionId) {
+    const handler = this.channelLoopToolHandlers.find((candidate) => candidate.canHandle?.(sessionId) === true || this.channelLoopToolHandlers.length === 1 && !candidate.canHandle);
+    if (handler)
+      return handler;
+    throw new Error(`No channel loop handler matched session ${sessionId}.`);
+  }
   getStringField(data, field, fallback) {
     return isRecord(data) && typeof data[field] === "string" ? data[field] : fallback;
   }
@@ -1963,6 +2054,9 @@ var SenderGate = class {
     this.allowedUsers = new Set(allowedUsers);
     this.pairingStore = pairingStore || null;
   }
+  replaceAllowedUsers(users) {
+    this.allowedUsers = new Set(users);
+  }
   isAllowed(senderId) {
     switch (this.policy) {
       case "open":
@@ -2051,6 +2145,8 @@ var SessionRouter = class {
     switch (scope) {
       case "thread":
         return `${channelName}:${threadId || chatId}`;
+      case "chat_thread":
+        return threadId ? `${channelName}:${chatId}:${threadId}` : `${channelName}:${chatId}`;
       case "single":
         return `${channelName}:__single__`;
       case "user":
@@ -3425,7 +3521,7 @@ var ChannelBase = class {
       if (target.threadId !== void 0 && this.supportsProactiveSend() && this.supportsProactiveTarget(target)) {
         await this.pushProactive(target, text);
       } else {
-        await this.sendMessage(target.chatId, text);
+        await this.sendThreadMessage(target.chatId, target.threadId, text);
       }
     } catch (err) {
       this.removePendingPermission(event.requestId);
@@ -3494,6 +3590,14 @@ var ChannelBase = class {
       this.attachBridgeEvents(bridge);
     }
   }
+  /**
+   * Thread-targeted delivery. Polling adapters override this to post comments
+   * on a specific issue/PR. The default falls through to sendMessage(chatId,
+   * text), ignoring threadId — existing IM adapters are behaviorally unchanged.
+   */
+  async sendThreadMessage(chatId, _threadId, text) {
+    await this.sendMessage(chatId, text);
+  }
   /**
    * Adapter hook for task lifecycle events — the canonical way to track task
    * state (onPromptStart/onPromptEnd are retained for back-compat). The prompt
@@ -3624,7 +3728,7 @@ var ChannelBase = class {
     if (target.threadId) {
       throw new Error("Channel does not support proactive loop messages for threaded targets.");
     }
-    await this.sendMessage(target.chatId, text);
+    await this.sendThreadMessage(target.chatId, target.threadId, text);
   }
   async pushProactiveDelivery(target, text) {
     try {
@@ -3807,6 +3911,7 @@ var ChannelBase = class {
       alreadyPrefixed: true,
       referencedText: void 0,
       attachments: void 0,
+      metadata: void 0,
       imageBase64: void 0,
       imageMimeType: void 0
     };
@@ -4274,6 +4379,7 @@ ${promptText}` : promptText;
         this.router.removeSessionId(sessionId);
         this.instructedSessions.delete(sessionId);
         this.unattendedMemorySessions.delete(sessionId);
+        this.discardRetiredSession(promptBridge, sessionId, `timed-out loop ${jobId}`);
         process.stderr.write(`[${this.name}] retired timed out loop ${jobId} session ${sessionId} after cancel did not settle
 `);
       }
@@ -4284,6 +4390,19 @@ ${promptText}` : promptText;
       clearTimeout(graceTimer);
     }
   }
+  discardRetiredSession(promptBridge, sessionId, reason) {
+    const safeSessionId = sanitizeLogText(sessionId, 64);
+    const safeReason = sanitizeLogText(reason, 128);
+    try {
+      void promptBridge.discardSession?.(sessionId).catch((err) => {
+        process.stderr.write(`[${this.name}] failed to discard ${safeReason} session ${safeSessionId}: ${this.lifecycleError(err)}
+`);
+      });
+    } catch (err) {
+      process.stderr.write(`[${this.name}] failed to discard ${safeReason} session ${safeSessionId}: ${this.lifecycleError(err)}
+`);
+    }
+  }
   requestActivePromptCancellation(sessionId, reason = "cancel_command") {
     const active = this.activePrompts.get(sessionId);
     if (!active) {
@@ -4422,8 +4541,11 @@ ${promptText}` : promptText;
    */
   onResponseBoundary(_chatId, _sessionId) {
   }
-  async sendResponseMessage(chatId, text, _sessionId) {
-    await this.sendMessage(chatId, text);
+  async sendResponseMessage(chatId, text, sessionId) {
+    const active = this.activePrompts.get(sessionId);
+    const target = this.router.getTarget(sessionId);
+    const threadId = active?.threadId ?? target?.threadId;
+    await this.sendThreadMessage(chatId, threadId, text);
   }
   /**
    * Called when the agent's full response is ready.
@@ -4444,21 +4566,21 @@ ${promptText}` : promptText;
   registerCancelCommand(name = "cancel") {
     this.registerCommand(name, async (envelope) => {
       if (!this.isAuthorizedForSharedSession(envelope)) {
-        await this.sendMessage(envelope.chatId, "Only authorized members can cancel requests in this shared session.");
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Only authorized members can cancel requests in this shared session.");
         return true;
       }
       const activeSessionId = this.findActiveSessionId(envelope);
       if (!activeSessionId) {
-        await this.sendMessage(envelope.chatId, "No request is currently running.");
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, "No request is currently running.");
         return true;
       }
       const active = this.activePrompts.get(activeSessionId);
       if (!active) {
-        await this.sendMessage(envelope.chatId, "No request is currently running.");
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, "No request is currently running.");
         return true;
       }
       const cancelSucceeded = await this.requestActivePromptCancellation(activeSessionId, "cancel_command");
-      await this.sendMessage(envelope.chatId, cancelSucceeded ? "Cancelled current request." : "Failed to cancel current request.");
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, cancelSucceeded ? "Cancelled current request." : "Failed to cancel current request.");
       return true;
     });
   }
@@ -4590,7 +4712,7 @@ ${promptText}` : promptText;
   }
   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.");
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Only authorized members can answer permission requests in this shared session.");
       return true;
     }
     const lookup = this.pendingPermissionForEnvelope(envelope, args);
@@ -4600,16 +4722,16 @@ ${promptText}` : promptText;
         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>.
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, `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.");
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, 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.");
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Permission relay is not available for this session.");
       return true;
     }
     const { pending } = lookup;
@@ -4621,7 +4743,7 @@ ${requestList}`);
       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.");
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, decision === "approve-always" ? "This permission request has no always-allow option." : "This permission request has no approvable option.");
       return true;
     }
     let accepted;
@@ -4631,11 +4753,11 @@ ${requestList}`);
       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.");
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, "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.");
+    await this.sendThreadMessage(envelope.chatId, envelope.threadId, 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. */
@@ -4685,19 +4807,20 @@ ${requestList}`);
           } else {
             this.sessionGenerations.delete(id);
           }
+          this.discardRetiredSession(this.bridge, id, "cleared");
         }
-        await this.sendMessage(envelope.chatId, "Session cleared. The next message starts a fresh conversation.");
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Session cleared. The next message starts a fresh conversation.");
       } else {
-        await this.sendMessage(envelope.chatId, "No active session to clear.");
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, "No active session to clear.");
       }
     }, "doClear");
     const clearHandler = /* @__PURE__ */ __name(async (envelope, args) => {
       if (!this.isAuthorizedForSharedSession(envelope)) {
-        await this.sendMessage(envelope.chatId, "Only authorized members can clear this shared session.");
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Only authorized members can clear this shared session.");
         return true;
       }
       if (this.isSharedSession(envelope) && args.toLowerCase() !== "confirm") {
-        await this.sendMessage(envelope.chatId, 'This clears the shared session for everyone who shares it. Re-send with "confirm" (e.g. /clear confirm) to proceed.');
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'This clears the shared session for everyone who shares it. Re-send with "confirm" (e.g. /clear confirm) to proceed.');
         return true;
       }
       await doClear(envelope);
@@ -4711,12 +4834,12 @@ ${requestList}`);
     this.registerCommand("deny", (envelope, args) => this.handlePermissionResponseCommand(envelope, args, "deny"));
     this.registerCommand("who", async (envelope) => {
       if (!this.isAuthorizedForSharedSession(envelope)) {
-        await this.sendMessage(envelope.chatId, "Only authorized members can view this shared session.");
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, "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, [
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, [
         `Channel: ${this.name}`,
         // Identity/memory lines only for channels that opted in — keep
         // unconfigured channels' output unchanged.
@@ -4770,12 +4893,12 @@ ${requestList}`);
         }
       }
       lines.push("", "Send any text to chat with the agent.");
-      await this.sendMessage(envelope.chatId, lines.join("\n"));
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, lines.join("\n"));
       return true;
     });
     this.registerCommand("status", async (envelope) => {
       if (!this.isAuthorizedForSharedSession(envelope)) {
-        await this.sendMessage(envelope.chatId, "Only authorized members can view this shared session.");
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Only authorized members can view this shared session.");
         return true;
       }
       const hasSession = this.router.hasSession(this.name, envelope.senderId, envelope.chatId, envelope.threadId);
@@ -4789,18 +4912,18 @@ ${requestList}`);
           `Memory: ${this.memoryScope.mode}`
         ] : []
       ];
-      await this.sendMessage(envelope.chatId, lines.join("\n"));
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, lines.join("\n"));
       return true;
     });
     this.registerCommand("loop", async (envelope, args) => this.handleLoopCommand(envelope, args));
   }
   async handleLoopCommand(envelope, args) {
     if (!this.loopController) {
-      await this.sendMessage(envelope.chatId, "Loops are not available.");
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Loops are not available.");
       return true;
     }
     if (!this.isAuthorizedForSharedSession(envelope)) {
-      await this.sendMessage(envelope.chatId, "Only authorized members can use loops in this shared session.");
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Only authorized members can use loops in this shared session.");
       return true;
     }
     const [subcommand = "", ...rest] = args.trim().split(/\s+/u);
@@ -4814,7 +4937,7 @@ ${requestList}`);
       case "cancel":
         return this.handleLoopCancel(envelope, rest[0]);
       default:
-        await this.sendMessage(envelope.chatId, 'Usage: /loop add "<cron>" <prompt> | /loop list | /loop inspect <id> | /loop cancel <id>');
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'Usage: /loop add "<cron>" <prompt> | /loop list | /loop inspect <id> | /loop cancel <id>');
         return true;
     }
   }
@@ -4822,32 +4945,32 @@ ${requestList}`);
     if (!this.loopController)
       return true;
     if (!this.supportsProactiveSend()) {
-      await this.sendMessage(envelope.chatId, "This channel does not support proactive loop messages.");
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, "This channel does not support proactive loop messages.");
       return true;
     }
     if (this.config.sessionScope === "single") {
-      await this.sendMessage(envelope.chatId, "Loops are not supported when sessionScope is single.");
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Loops are not supported when sessionScope is single.");
       return true;
     }
     const parsed = parseLoopAddArgs(args);
     if (!parsed) {
-      await this.sendMessage(envelope.chatId, 'Usage: /loop add "<cron>" <prompt>');
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'Usage: /loop add "<cron>" <prompt>');
       return true;
     }
     try {
       this.loopController.validateCron(parsed.cron);
     } catch (err) {
-      await this.sendMessage(envelope.chatId, `Invalid cron expression: ${err instanceof Error ? err.message : String(err)}`);
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Invalid cron expression: ${err instanceof Error ? err.message : String(err)}`);
       return true;
     }
     const target = this.loopTargetFromEnvelope(envelope);
     if (!this.supportsProactiveTarget(target)) {
-      await this.sendMessage(envelope.chatId, "This channel does not support proactive loop messages for this chat target.");
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, "This channel does not support proactive loop messages for this chat target.");
       return true;
     }
     const prompt = sanitizePromptText(parsed.prompt.trim());
     if (Array.from(prompt).length > MAX_LOOP_PROMPT_CHARS) {
-      await this.sendMessage(envelope.chatId, `Loop prompt is too long; keep it under ${MAX_LOOP_PROMPT_CHARS} characters.`);
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Loop prompt is too long; keep it under ${MAX_LOOP_PROMPT_CHARS} characters.`);
       return true;
     }
     const input = {
@@ -4870,10 +4993,10 @@ ${requestList}`);
       }
     }
     if (!job) {
-      await this.sendMessage(envelope.chatId, `Too many loops for this chat. Cancel an existing loop before adding another.`);
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Too many loops for this chat. Cancel an existing loop before adding another.`);
       return true;
     }
-    await this.sendMessage(envelope.chatId, `Loop ${job.id}: ${job.cron}`);
+    await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Loop ${job.id}: ${job.cron}`);
     return true;
   }
   async createLoopFromTool(sessionId, input) {
@@ -4975,23 +5098,23 @@ ${requestList}`);
       return true;
     const jobs = await this.loopController.listForTarget(this.name, this.loopTargetFromEnvelope(envelope));
     if (jobs.length === 0) {
-      await this.sendMessage(envelope.chatId, "No loops.");
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, "No loops.");
       return true;
     }
-    await this.sendMessage(envelope.chatId, jobs.map((job) => this.formatLoopListLine(job)).join("\n"));
+    await this.sendThreadMessage(envelope.chatId, envelope.threadId, jobs.map((job) => this.formatLoopListLine(job)).join("\n"));
     return true;
   }
   async handleLoopInspect(envelope, id) {
     if (!this.loopController)
       return true;
     if (!id) {
-      await this.sendMessage(envelope.chatId, "Usage: /loop inspect <id>");
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Usage: /loop inspect <id>");
       return true;
     }
     const jobs = await this.loopController.listForTarget(this.name, this.loopTargetFromEnvelope(envelope));
     const job = jobs.find((candidate) => candidate.id === id);
     if (!job) {
-      await this.sendMessage(envelope.chatId, `No loop ${id}.`);
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, `No loop ${id}.`);
       return true;
     }
     const lines = [
@@ -5013,7 +5136,7 @@ ${requestList}`);
       lines.push(`Last result: ${job.lastResultPreview}`);
     }
     lines.push(`Prompt: ${job.prompt}`);
-    await this.sendMessage(envelope.chatId, lines.join("\n"));
+    await this.sendThreadMessage(envelope.chatId, envelope.threadId, lines.join("\n"));
     return true;
   }
   formatLoopListLine(job) {
@@ -5045,17 +5168,17 @@ ${requestList}`);
     if (!this.loopController)
       return true;
     if (!id) {
-      await this.sendMessage(envelope.chatId, "Usage: /loop cancel <id>");
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Usage: /loop cancel <id>");
       return true;
     }
     const jobs = await this.loopController.listForTarget(this.name, this.loopTargetFromEnvelope(envelope));
     const match = jobs.find((job) => job.id === id);
     if (!match) {
-      await this.sendMessage(envelope.chatId, `No loop ${id}.`);
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, `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}.`);
+    await this.sendThreadMessage(envelope.chatId, envelope.threadId, disabled ? `Cancelled loop ${id}.` : `Failed to cancel loop ${id}.`);
     return true;
   }
   loopTargetFromEnvelope(envelope) {
@@ -5172,7 +5295,7 @@ ${requestList}`);
   }
   async getChannelMemory(envelope) {
     if (!this.channelMemory) {
-      await this.sendMessage(envelope.chatId, "Channel memory is not configured for this channel.");
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Channel memory is not configured for this channel.");
       return void 0;
     }
     return this.channelMemory;
@@ -5190,7 +5313,7 @@ ${requestList}`);
   }
   async handleChannelMemoryIntent(envelope, intent, options = {}) {
     if (intent.kind === "no_match") {
-      await this.sendMessage(envelope.chatId, "No matching channel memory entry.");
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, "No matching channel memory entry.");
       return;
     }
     if (intent.kind === "ambiguous") {
@@ -5202,11 +5325,11 @@ ${requestList}`);
         entries = await channelMemory2.listChannelMemoryEntries(this.channelMemoryTarget(envelope));
       } catch (error) {
         this.logChannelMemoryError("read", envelope, this.channelMemoryErrorMessage(error));
-        await this.sendMessage(envelope.chatId, `Failed to read channel memory: ${this.channelMemoryUserErrorMessage()}`);
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Failed to read channel memory: ${this.channelMemoryUserErrorMessage()}`);
         return;
       }
       const selected = this.entriesForChannelMemoryIds(entries, intent.ids);
-      await this.sendMessage(envelope.chatId, [
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, [
         "Multiple channel memory entries match:",
         ...this.renderChannelMemoryCandidates(selected)
       ].join("\n"));
@@ -5221,11 +5344,11 @@ ${requestList}`);
         entries = await channelMemory2.listChannelMemoryEntries(this.channelMemoryTarget(envelope));
       } catch (error) {
         this.logChannelMemoryError("read", envelope, this.channelMemoryErrorMessage(error));
-        await this.sendMessage(envelope.chatId, `Failed to read channel memory: ${this.channelMemoryUserErrorMessage()}`);
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Failed to read channel memory: ${this.channelMemoryUserErrorMessage()}`);
         return;
       }
       const selected = this.entriesForChannelMemoryIds(entries, intent.ids);
-      await this.sendMessage(envelope.chatId, [
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, [
         "Channel memory (page 1/1):",
         ...this.renderChannelMemoryCandidates(selected)
       ].join("\n"));
@@ -5238,7 +5361,7 @@ ${requestList}`);
     if (intent.kind === "update_confirm" || intent.kind === "remove_confirm") {
       const pending = intent.kind === "update_confirm" ? this.takePendingChannelMemoryMutation(envelope, "update") : this.takePendingChannelMemoryMutation(envelope, "remove");
       if (!pending) {
-        await this.sendMessage(envelope.chatId, intent.kind === "update_confirm" ? "No pending channel memory update. Start a new update request first." : "No pending channel memory removal. Start a new removal request first.");
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, intent.kind === "update_confirm" ? "No pending channel memory update. Start a new update request first." : "No pending channel memory removal. Start a new removal request first.");
         return;
       }
       const channelMemory2 = await this.getChannelMemory(envelope);
@@ -5262,15 +5385,15 @@ ${requestList}`);
       } catch (error) {
         const message = this.channelMemoryErrorMessage(error);
         this.logChannelMemoryError(isUpdate ? "update" : "remove", envelope, message);
-        await this.sendMessage(envelope.chatId, message === "Channel memory entry changed" ? "That channel memory entry changed since it was selected. View channel memory and start the operation again." : `Failed to ${isUpdate ? "update" : "remove"} channel memory: ${this.channelMemoryUserErrorMessage()}`);
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, message === "Channel memory entry changed" ? "That channel memory entry changed since it was selected. View channel memory and start the operation again." : `Failed to ${isUpdate ? "update" : "remove"} channel memory: ${this.channelMemoryUserErrorMessage()}`);
         return;
       }
       if (!changed) {
-        await this.sendMessage(envelope.chatId, `No channel memory entry ${pending.id}.`);
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, `No channel memory entry ${pending.id}.`);
         return;
       }
       this.invalidateUnattendedMemory(envelope);
-      await this.sendMessage(envelope.chatId, `Channel memory ${pending.id} ${isUpdate ? "updated" : "removed"}.`);
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Channel memory ${pending.id} ${isUpdate ? "updated" : "removed"}.`);
       return;
     }
     if (intent.kind === "natural_update") {
@@ -5310,7 +5433,7 @@ ${requestList}`);
       } catch (error) {
         const message = this.channelMemoryErrorMessage(error);
         this.logChannelMemoryError("save", envelope, message);
-        await this.sendMessage(envelope.chatId, `Failed to save channel memory: ${this.channelMemoryUserErrorMessage()}`);
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Failed to save channel memory: ${this.channelMemoryUserErrorMessage()}`);
         return;
       }
       if (result.changed) {
@@ -5321,11 +5444,11 @@ ${requestList}`);
       }
       if (result.added.length > 0) {
         const ids = result.added.map((entry) => entry.id);
-        await this.sendMessage(envelope.chatId, result.duplicateIds.length > 0 ? `Channel memory saved: ${ids.join(", ")}. Skipped duplicates: ${result.duplicateIds.join(", ")}.` : ids.length === 1 ? `Channel memory ${ids[0]} saved.` : `Channel memory saved: ${ids.join(", ")}.`);
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, result.duplicateIds.length > 0 ? `Channel memory saved: ${ids.join(", ")}. Skipped duplicates: ${result.duplicateIds.join(", ")}.` : ids.length === 1 ? `Channel memory ${ids[0]} saved.` : `Channel memory saved: ${ids.join(", ")}.`);
       } else if (result.duplicateIds.length > 0) {
-        await this.sendMessage(envelope.chatId, `Channel memory already contains ${result.duplicateIds.join(", ")}.`);
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Channel memory already contains ${result.duplicateIds.join(", ")}.`);
       } else {
-        await this.sendMessage(envelope.chatId, "Channel memory updated.");
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Channel memory updated.");
       }
       return;
     }
@@ -5336,27 +5459,27 @@ ${requestList}`);
       } catch (error) {
         const message = this.channelMemoryErrorMessage(error);
         this.logChannelMemoryError("read", envelope, message);
-        await this.sendMessage(envelope.chatId, `Failed to read channel memory: ${this.channelMemoryUserErrorMessage()}`);
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Failed to read channel memory: ${this.channelMemoryUserErrorMessage()}`);
         return;
       }
       if (intent.kind === "inspect") {
         const entry = entries.find((candidate) => candidate.id === intent.id);
-        await this.sendMessage(envelope.chatId, entry ? `Channel memory ${entry.id}:
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, entry ? `Channel memory ${entry.id}:
 ${sanitizePromptText(entry.text).trim()}` : `No channel memory entry ${intent.id}.`);
         return;
       }
       const totalPages = Math.max(1, Math.ceil(entries.length / CHANNEL_MEMORY_PAGE_SIZE));
       if (intent.page > totalPages) {
-        await this.sendMessage(envelope.chatId, `Channel memory page ${intent.page} does not exist.`);
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Channel memory page ${intent.page} does not exist.`);
         return;
       }
       if (entries.length === 0) {
-        await this.sendMessage(envelope.chatId, "No channel memory saved.");
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, "No channel memory saved.");
         return;
       }
       const pageStart = (intent.page - 1) * CHANNEL_MEMORY_PAGE_SIZE;
       const lines = entries.slice(pageStart, pageStart + CHANNEL_MEMORY_PAGE_SIZE).map((entry) => this.renderChannelMemoryCandidate(entry));
-      await this.sendMessage(envelope.chatId, [`Channel memory (page ${intent.page}/${totalPages}):`, ...lines].join("\n"));
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, [`Channel memory (page ${intent.page}/${totalPages}):`, ...lines].join("\n"));
       return;
     }
     if (intent.kind === "update" || intent.kind === "remove") {
@@ -5372,21 +5495,21 @@ ${sanitizePromptText(entry.text).trim()}` : `No channel memory entry ${intent.id
       } catch (error) {
         const message = this.channelMemoryErrorMessage(error);
         this.logChannelMemoryError(isUpdate ? "update" : "remove", envelope, message);
-        await this.sendMessage(envelope.chatId, `Failed to ${isUpdate ? "update" : "remove"} channel memory: ${this.channelMemoryUserErrorMessage()}`);
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Failed to ${isUpdate ? "update" : "remove"} channel memory: ${this.channelMemoryUserErrorMessage()}`);
         return;
       }
       if (!changed) {
-        await this.sendMessage(envelope.chatId, `No channel memory entry ${id}.`);
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, `No channel memory entry ${id}.`);
         return;
       }
       this.invalidateUnattendedMemory(envelope);
-      await this.sendMessage(envelope.chatId, `Channel memory ${id} ${isUpdate ? "updated" : "removed"}.`);
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Channel memory ${id} ${isUpdate ? "updated" : "removed"}.`);
       return;
     }
     if (intent.kind === "clear_confirm") {
       const pending = this.takePendingChannelMemoryMutation(envelope, "clear");
       if (!pending) {
-        await this.sendMessage(envelope.chatId, 'No pending clear request. Say "\u6E05\u7A7A\u8BB0\u5FC6" first.');
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, 'No pending clear request. Say "\u6E05\u7A7A\u8BB0\u5FC6" first.');
         return;
       }
       let result;
@@ -5395,13 +5518,13 @@ ${sanitizePromptText(entry.text).trim()}` : `No channel memory entry ${intent.id
       } 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.sendThreadMessage(envelope.chatId, envelope.threadId, `Failed to clear channel memory: ${this.channelMemoryUserErrorMessage()}`);
         return;
       }
       if (result.changed) {
         this.invalidateUnattendedMemory(envelope);
       }
-      await this.sendMessage(envelope.chatId, result.changed ? "Channel memory cleared." : "No channel memory saved.");
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, result.changed ? "Channel memory cleared." : "No channel memory saved.");
       return;
     }
     const unhandled = intent;
@@ -5430,7 +5553,7 @@ ${sanitizePromptText(entry.text).trim()}` : `No channel memory entry ${intent.id
     const key = this.channelMemoryPendingKey(envelope);
     this.pendingChannelMemoryMutationDeliveries.set(key, mutation);
     try {
-      await this.sendMessage(envelope.chatId, message);
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, message);
     } catch (error) {
       if (this.pendingChannelMemoryMutationDeliveries.get(key) === mutation) {
         this.pendingChannelMemoryMutationDeliveries.delete(key);
@@ -5584,15 +5707,17 @@ ${sanitizePromptText(entry.text).trim()}` : `No channel memory entry ${intent.id
    * Whether the resolved session is SHARED across senders. `single` collapses
    * the whole channel to one `__single__` session for EVERY sender — group OR
    * DM — so it is ALWAYS shared (even a DM maps to `__single__`). `thread` is
-   * shared only in a group (a DM maps to the lone caller's own chat). `user` is
-   * per-sender, never shared. Drives both the destructive-/clear confirm gate
-   * and the host-shell (`!`) gate.
+   * shared only in a group (a DM maps to the lone caller's own chat).
+   * `chat_thread` is always shared: it scopes by chat+thread, and a thread
+   * (issue/PR discussion) can carry multiple participants even outside a
+   * group. `user` is per-sender, never shared. Drives both the
+   * destructive-/clear confirm gate and the host-shell (`!`) gate.
    */
   isSharedSession(envelope) {
     return this.isSharedSessionTarget(envelope);
   }
   isSharedSessionTarget(target) {
-    return this.config.sessionScope === "single" || target.isGroup === true && this.config.sessionScope === "thread";
+    return this.config.sessionScope === "single" || this.config.sessionScope === "chat_thread" || target.isGroup === true && this.config.sessionScope === "thread";
   }
   /**
    * Whether `envelope.senderId` may act on the resolved session's destructive or
@@ -5849,7 +5974,7 @@ ${promptText}`;
     if (!result.allowed) {
       if (result.pairingCode !== void 0) {
         this.logPreflightRejected("sender_pairing_required");
-        return this.onPairingRequired(envelope.chatId, result.pairingCode).then(() => false).catch((err) => {
+        return this.onPairingRequired(envelope.chatId, result.pairingCode, envelope.threadId).then(() => false).catch((err) => {
           process.stderr.write(`[Channel:${this.name}] pairing notification failed: ${sanitizeLogText(err instanceof Error ? err.message : String(err), 200)}
 `);
           return false;
@@ -5962,11 +6087,11 @@ ${promptText}`;
 `);
       }
       if (envelope.isGroup) {
-        await this.sendMessage(envelope.chatId, "Shell commands (`!`) are disabled in group chats.");
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Shell commands (`!`) are disabled in group chats.");
         return;
       }
       if (this.isSharedSession(envelope)) {
-        await this.sendMessage(envelope.chatId, "Shell commands (`!`) are disabled in shared sessions.");
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Shell commands (`!`) are disabled in shared sessions.");
         return;
       }
     }
@@ -5984,10 +6109,10 @@ ${result.output}
 ${fence}` : "(no output)";
           const exitLine = result.exitCode !== null && result.exitCode !== 0 ? `
 Exit code: ${result.exitCode}` : "";
-          await this.sendMessage(envelope.chatId, `$ ${cmd}
+          await this.sendThreadMessage(envelope.chatId, envelope.threadId, `$ ${cmd}
 ${output}${exitLine}`);
         } catch (error) {
-          await this.sendMessage(envelope.chatId, `Shell command failed: ${error instanceof Error ? error.message : String(error)}`);
+          await this.sendThreadMessage(envelope.chatId, envelope.threadId, `Shell command failed: ${error instanceof Error ? error.message : String(error)}`);
         }
         return;
       }
@@ -6023,6 +6148,9 @@ ${promptText}`;
         promptText = promptText + "\n\n" + filePaths.join("\n");
       }
     }
+    if (envelope.metadata) {
+      promptText = promptText + "\n\n" + sanitizePromptText(envelope.metadata);
+    }
     const groupCfg = envelope.isGroup ? this.config.groups[envelope.chatId] || this.config.groups["*"] : void 0;
     const mode = groupCfg?.dispatchMode || this.config.dispatchMode || "steer";
     const active = this.activePrompts.get(sessionId);
@@ -6300,6 +6428,7 @@ ${promptToSend}`;
             // Clear attachments/references — already resolved in original text
             referencedText: void 0,
             attachments: void 0,
+            metadata: void 0,
             imageBase64: void 0,
             imageMimeType: void 0
           };
@@ -6315,14 +6444,14 @@ ${promptToSend}`;
     }));
     await current;
   }
-  async onPairingRequired(chatId, code) {
+  async onPairingRequired(chatId, code, threadId) {
     if (code) {
-      await this.sendMessage(chatId, `Your pairing code is: ${code}
+      await this.sendThreadMessage(chatId, threadId, `Your pairing code is: ${code}
 
 Ask the bot operator to approve you with:
   qwen channel pairing approve ${this.name} ${code}`);
     } else {
-      await this.sendMessage(chatId, "Too many pending pairing requests. Please try again later.");
+      await this.sendThreadMessage(chatId, threadId, "Too many pending pairing requests. Please try again later.");
     }
   }
 };
@@ -6535,9 +6664,114 @@ function isTerminalTaskLifecycleType(type) {
 }
 __name(isTerminalTaskLifecycleType, "isTerminalTaskLifecycleType");
 
+// packages/channels/base/dist/PollingChannelBase.js
+init_esbuild_shims();
+import { createHash as createHash2 } from "node:crypto";
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync4, renameSync as renameSync4, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join6 } from "node:path";
+import process3 from "node:process";
+var INITIAL_BACKOFF = 2e3;
+var MAX_BACKOFF = 3e4;
+var PollingChannelBase = class extends ChannelBase {
+  static {
+    __name(this, "PollingChannelBase");
+  }
+  cursor;
+  abortController = new AbortController();
+  running = false;
+  consecutiveErrors = 0;
+  abortableSleep(ms) {
+    const signal = this.abortController.signal;
+    return new Promise((resolve3) => {
+      if (signal.aborted) {
+        resolve3();
+        return;
+      }
+      const timer = setTimeout(() => {
+        signal.removeEventListener("abort", onAbort);
+        resolve3();
+      }, ms);
+      const onAbort = /* @__PURE__ */ __name(() => {
+        clearTimeout(timer);
+        resolve3();
+      }, "onAbort");
+      signal.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+  constructor(name, config, bridge, options) {
+    super(name, config, bridge, options);
+    this.cursor = this.loadCursorFromDisk() ?? this.createInitialCursor();
+  }
+  validateCursor(parsed) {
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+      return null;
+    return parsed;
+  }
+  get pollInterval() {
+    const configured = this.config.pollInterval;
+    if (typeof configured === "number" && Number.isFinite(configured) && configured > 0) {
+      return configured;
+    }
+    return 6e4;
+  }
+  saveCursor() {
+    const path4 = this.cursorPath();
+    mkdirSync4(join6(getGlobalQwenDir(), "channels"), { recursive: true });
+    const tmp = `${path4}.tmp`;
+    writeFileSync4(tmp, JSON.stringify(this.cursor) + "\n", "utf-8");
+    renameSync4(tmp, path4);
+  }
+  startPollLoop() {
+    if (this.running)
+      return;
+    this.running = true;
+    this.consecutiveErrors = 0;
+    this.abortController = new AbortController();
+    this.runLoop();
+  }
+  stopPollLoop() {
+    this.running = false;
+    this.abortController.abort();
+  }
+  async runLoop() {
+    const signal = this.abortController.signal;
+    while (this.running && !signal.aborted) {
+      try {
+        await this.pollOnce();
+        this.saveCursor();
+        this.consecutiveErrors = 0;
+      } catch (err) {
+        this.consecutiveErrors++;
+        const backoff = Math.min(INITIAL_BACKOFF * 2 ** (this.consecutiveErrors - 1), MAX_BACKOFF);
+        process3.stderr.write(`[Channel:${this.name}] poll error (attempt ${this.consecutiveErrors}), backing off ${backoff}ms: ${err}
+`);
+        await this.abortableSleep(backoff);
+        continue;
+      }
+      await this.abortableSleep(this.pollInterval);
+    }
+  }
+  loadCursorFromDisk() {
+    try {
+      const raw = readFileSync4(this.cursorPath(), "utf-8").trim();
+      if (!raw)
+        return null;
+      return this.validateCursor(JSON.parse(raw));
+    } catch {
+      return null;
+    }
+  }
+  cursorPath() {
+    const encoded = this.name.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 200);
+    const hash = createHash2("sha256").update(this.name).digest("hex").slice(0, 16);
+    return join6(getGlobalQwenDir(), "channels", `${encoded}-${hash}-poll-cursor.json`);
+  }
+};
+
 export {
   resolvePath,
   getGlobalQwenDir,
+  CHANNEL_LOOP_MCP_SERVER_NAME,
   sanitizeSenderName,
   sanitizePromptText,
   sanitizeLogText,
@@ -6550,7 +6784,8 @@ export {
   ChannelLoopScheduler,
   ChannelBase,
   ChannelLoopStore,
-  isTerminalTaskLifecycleType
+  isTerminalTaskLifecycleType,
+  PollingChannelBase
 };
 /**
  * @license