@qwen-code/qwen-code 0.21.0 → 0.21.1

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

@@ -12,90 +12,6 @@ import {
   __name
 } from "./chunk-J2S4EL5Y.js";
 
-// 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");
-function truncateCodePoints(str, max) {
-  const cp = Array.from(str);
-  return cp.length > max ? cp.slice(0, max).join("") : str;
-}
-__name(truncateCodePoints, "truncateCodePoints");
-function sanitizeSenderName(name) {
-  const cleaned = name.replace(PROMPT_UNSAFE_INVISIBLES, " ").replace(/[\u0000-\u001f\u007f]/g, " ").replace(/[[\]\r\n]/g, " ");
-  return truncateCodePoints(cleaned, 64).trim() || "unknown";
-}
-__name(sanitizeSenderName, "sanitizeSenderName");
-function sanitizeQuotedText(text, maxLen) {
-  const cleaned = text.replace(PROMPT_UNSAFE_INVISIBLES, " ").replace(/[\u0000-\u001f\u007f]/g, " ").replace(/["[\]]/g, " ");
-  const cp = Array.from(cleaned);
-  return cp.length > maxLen ? cp.slice(0, maxLen - 1).join("") + "\u2026" : cleaned;
-}
-__name(sanitizeQuotedText, "sanitizeQuotedText");
-function sanitizePromptText(text) {
-  return text.replace(PROMPT_UNSAFE_INVISIBLES, " ").replace(/^([ \t]*)\[([^\]\r\n]{1,64})\](:?)/gm, "$1$2$3").replace(/[\u0000-\u001f\u007f]/g, " ");
-}
-__name(sanitizePromptText, "sanitizePromptText");
-function sanitizePromptPath(path4) {
-  const cleaned = path4.replace(PROMPT_UNSAFE_INVISIBLES, " ").replace(/[\u0000-\u001f\u007f]/g, " ");
-  return truncateCodePoints(cleaned, 1024);
-}
-__name(sanitizePromptPath, "sanitizePromptPath");
-function sanitizeLogText(text, maxLen) {
-  return truncateCodePoints(text, maxLen).replace(/\n/g, "\\n").replace(PROMPT_UNSAFE_INVISIBLES, " ").replace(/[\u0000-\u001f\u007f]/g, " ");
-}
-__name(sanitizeLogText, "sanitizeLogText");
-
-// packages/channels/base/dist/index.js
-init_esbuild_shims();
-
-// packages/channels/base/dist/paths.js
-init_esbuild_shims();
-import * as crypto from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as os from "node:os";
-function resolvePath(dir) {
-  let resolved = dir;
-  if (resolved === "~" || resolved.startsWith("~/") || resolved.startsWith("~\\")) {
-    const relativeSegments = resolved === "~" ? [] : resolved.slice(2).split(/[/\\]+/).filter(Boolean);
-    resolved = path.join(os.homedir(), ...relativeSegments);
-  }
-  return path.resolve(resolved);
-}
-__name(resolvePath, "resolvePath");
-function getGlobalQwenDir() {
-  const envDir = process.env["QWEN_HOME"];
-  if (envDir) {
-    return resolvePath(envDir);
-  }
-  const homeDir = os.homedir();
-  return homeDir ? path.join(homeDir, ".qwen") : path.join(os.tmpdir(), ".qwen");
-}
-__name(getGlobalQwenDir, "getGlobalQwenDir");
-function canonicalizeWorkspacePath(workspaceCwd) {
-  const resolved = resolvePath(workspaceCwd);
-  try {
-    return fs.realpathSync.native(resolved);
-  } catch {
-    return resolved;
-  }
-}
-__name(canonicalizeWorkspacePath, "canonicalizeWorkspacePath");
-function getWorkspaceScopeDirName(workspaceCwd) {
-  const resolved = canonicalizeWorkspacePath(workspaceCwd);
-  const hash = crypto.createHash("sha256").update(resolved).digest("hex").slice(0, 12);
-  const base = path.basename(resolved).replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 32);
-  return base ? `${base}-${hash}` : hash;
-}
-__name(getWorkspaceScopeDirName, "getWorkspaceScopeDirName");
-
-// packages/channels/base/dist/AcpBridge.js
-init_esbuild_shims();
-import { spawn } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import { Readable, Writable } from "node:stream";
-import { EventEmitter } from "node:events";
-
 // packages/channels/base/dist/ChannelLoopTools.js
 init_esbuild_shims();
 var CHANNEL_LOOP_MCP_SERVER_NAME = "channel_loop";
@@ -253,8 +169,290 @@ function readId(args) {
 }
 __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");
+function truncateCodePoints(str, max) {
+  const cp = Array.from(str);
+  return cp.length > max ? cp.slice(0, max).join("") : str;
+}
+__name(truncateCodePoints, "truncateCodePoints");
+function sanitizeSenderName(name) {
+  const cleaned = name.replace(PROMPT_UNSAFE_INVISIBLES, " ").replace(/[\u0000-\u001f\u007f]/g, " ").replace(/[[\]\r\n]/g, " ");
+  return truncateCodePoints(cleaned, 64).trim() || "unknown";
+}
+__name(sanitizeSenderName, "sanitizeSenderName");
+function sanitizeQuotedText(text, maxLen) {
+  const cleaned = text.replace(PROMPT_UNSAFE_INVISIBLES, " ").replace(/[\u0000-\u001f\u007f]/g, " ").replace(/["[\]]/g, " ");
+  const cp = Array.from(cleaned);
+  return cp.length > maxLen ? cp.slice(0, maxLen - 1).join("") + "\u2026" : cleaned;
+}
+__name(sanitizeQuotedText, "sanitizeQuotedText");
+function sanitizePromptText(text) {
+  return text.replace(PROMPT_UNSAFE_INVISIBLES, " ").replace(/^([ \t]*)\[([^\]\r\n]{1,64})\](:?)/gm, "$1$2$3").replace(/[\u0000-\u001f\u007f]/g, " ");
+}
+__name(sanitizePromptText, "sanitizePromptText");
+function sanitizePromptPath(path4) {
+  const cleaned = path4.replace(PROMPT_UNSAFE_INVISIBLES, " ").replace(/[\u0000-\u001f\u007f]/g, " ");
+  return truncateCodePoints(cleaned, 1024);
+}
+__name(sanitizePromptPath, "sanitizePromptPath");
+function sanitizeLogText(text, maxLen) {
+  return truncateCodePoints(text, maxLen).replace(/\n/g, "\\n").replace(PROMPT_UNSAFE_INVISIBLES, " ").replace(/[\u0000-\u001f\u007f]/g, " ");
+}
+__name(sanitizeLogText, "sanitizeLogText");
+
+// packages/channels/base/dist/PairingStore.js
+init_esbuild_shims();
+import * as crypto2 from "node:crypto";
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+
+// packages/channels/base/dist/paths.js
+init_esbuild_shims();
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+function resolvePath(dir) {
+  let resolved = dir;
+  if (resolved === "~" || resolved.startsWith("~/") || resolved.startsWith("~\\")) {
+    const relativeSegments = resolved === "~" ? [] : resolved.slice(2).split(/[/\\]+/).filter(Boolean);
+    resolved = path.join(os.homedir(), ...relativeSegments);
+  }
+  return path.resolve(resolved);
+}
+__name(resolvePath, "resolvePath");
+function getGlobalQwenDir() {
+  const envDir = process.env["QWEN_HOME"];
+  if (envDir) {
+    return resolvePath(envDir);
+  }
+  const homeDir = os.homedir();
+  return homeDir ? path.join(homeDir, ".qwen") : path.join(os.tmpdir(), ".qwen");
+}
+__name(getGlobalQwenDir, "getGlobalQwenDir");
+function canonicalizeWorkspacePath(workspaceCwd) {
+  const resolved = resolvePath(workspaceCwd);
+  try {
+    return fs.realpathSync.native(resolved);
+  } catch {
+    return resolved;
+  }
+}
+__name(canonicalizeWorkspacePath, "canonicalizeWorkspacePath");
+function getWorkspaceScopeDirName(workspaceCwd) {
+  const resolved = canonicalizeWorkspacePath(workspaceCwd);
+  const hash = crypto.createHash("sha256").update(resolved).digest("hex").slice(0, 12);
+  const base = path.basename(resolved).replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 32);
+  return base ? `${base}-${hash}` : hash;
+}
+__name(getWorkspaceScopeDirName, "getWorkspaceScopeDirName");
+
+// packages/channels/base/dist/PairingStore.js
+var SAFE_ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+var CODE_LENGTH = 8;
+var EXPIRY_MS = 60 * 60 * 1e3;
+var MAX_PENDING = 3;
+var PairingStore = class {
+  static {
+    __name(this, "PairingStore");
+  }
+  dir;
+  pendingPath;
+  allowlistPath;
+  migratedSentinelPath;
+  /**
+   * @param channelName Channel name the state is keyed by.
+   * @param workspaceCwd Workspace working directory to scope the state to.
+   *   When provided, files live under
+   *   `<qwen-home>/channels/<workspace-scope>/` so two workspaces using the
+   *   same channel name never share pairing requests or allowlist entries
+   *   (see #7017 — sharing them is an authorization-boundary violation in
+   *   multi-workspace daemon deployments). Omitting it preserves the legacy
+   *   global layout (`<qwen-home>/channels/`).
+   */
+  constructor(channelName, workspaceCwd) {
+    const channelsRoot = path2.join(getGlobalQwenDir(), "channels");
+    this.dir = workspaceCwd ? path2.join(channelsRoot, getWorkspaceScopeDirName(workspaceCwd)) : channelsRoot;
+    const safeChannelName = encodeURIComponent(channelName);
+    this.pendingPath = path2.join(this.dir, `${safeChannelName}-pairing.json`);
+    this.allowlistPath = path2.join(this.dir, `${safeChannelName}-allowlist.json`);
+    this.migratedSentinelPath = path2.join(this.dir, `${safeChannelName}.migrated`);
+    if (workspaceCwd) {
+      this.migrateLegacyState(channelsRoot, channelName);
+    }
+  }
+  /**
+   * One-time grandfathering of pre-scoping state: the first time this
+   * (workspace, channel) pair is constructed, copy the legacy GLOBAL files in
+   * so senders that were already approved stay approved after upgrading.
+   *
+   * Gated by a per-channel sentinel file inside the scope directory — NOT by
+   * the directory itself: one workspace can start several channels in turn,
+   * and a directory-level gate would let only the first channel ever migrate.
+   * The sentinel is written even when there was nothing to copy, so a legacy
+   * file written later (e.g. by an older version still running concurrently)
+   * is never absorbed into a scope that already went through this decision.
+   *
+   * Each file is copied independently and best-effort (an unreadable pairing
+   * file must not block the allowlist, and vice versa), via a
+   * uniquely-named temp file + atomic rename so a crash mid-copy cannot
+   * leave a truncated scoped file behind the closed gate. A file the scoped
+   * store already has is never overwritten.
+   *
+   * Copy, not move: another workspace upgrading later must be able to
+   * grandfather the same baseline, and an older qwen version running
+   * concurrently still reads the global files.
+   *
+   * Revocation therefore means REMOVING ENTRIES from the scoped allowlist
+   * (and from the legacy global file, while it exists) — not deleting files.
+   */
+  migrateLegacyState(channelsRoot, channelName) {
+    try {
+      if (fs2.existsSync(this.migratedSentinelPath)) {
+        return;
+      }
+      const legacyPairs = [
+        [
+          path2.join(channelsRoot, `${channelName}-pairing.json`),
+          this.pendingPath
+        ],
+        [
+          path2.join(channelsRoot, `${channelName}-allowlist.json`),
+          this.allowlistPath
+        ]
+      ];
+      this.ensureDir();
+      let allSucceeded = true;
+      for (const [legacyPath, scopedPath] of legacyPairs) {
+        try {
+          if (path2.dirname(path2.resolve(legacyPath)) !== channelsRoot) {
+            continue;
+          }
+          if (fs2.existsSync(scopedPath) || !fs2.existsSync(legacyPath)) {
+            continue;
+          }
+          const tmpPath = `${scopedPath}.${process.pid}.migrating`;
+          fs2.copyFileSync(legacyPath, tmpPath);
+          fs2.renameSync(tmpPath, scopedPath);
+        } catch (err) {
+          allSucceeded = false;
+          process.stderr.write(`[PairingStore] legacy migration of ${path2.basename(legacyPath)} failed for channel "${channelName}": ${err?.message}; will retry on next start
+`);
+        }
+      }
+      if (allSucceeded) {
+        fs2.writeFileSync(this.migratedSentinelPath, "");
+      }
+    } catch (err) {
+      process.stderr.write(`[PairingStore] legacy migration failed for channel "${channelName}": ${err?.message}; scoped store starts empty
+`);
+    }
+  }
+  isApproved(senderId) {
+    const list = this.readAllowlist();
+    return list.includes(senderId);
+  }
+  /**
+   * Create a pairing request for an unknown sender.
+   * Returns the code if created, or null if the pending cap is reached.
+   * If the sender already has a non-expired pending request, returns that code.
+   */
+  createRequest(senderId, senderName) {
+    const pending = this.readPending();
+    const now = Date.now();
+    const active = pending.filter((r) => now - r.createdAt < EXPIRY_MS);
+    const existing = active.find((r) => r.senderId === senderId);
+    if (existing) {
+      return existing.code;
+    }
+    if (active.length >= MAX_PENDING) {
+      return null;
+    }
+    const code = generateCode();
+    active.push({ senderId, senderName, code, createdAt: now });
+    this.writePending(active);
+    return code;
+  }
+  /**
+   * Approve a pairing request by code.
+   * Returns the sender ID if found, or null if not found / expired.
+   */
+  approve(code) {
+    const pending = this.readPending();
+    const now = Date.now();
+    const idx = pending.findIndex((r) => r.code === code.toUpperCase() && now - r.createdAt < EXPIRY_MS);
+    if (idx === -1)
+      return null;
+    const request = pending[idx];
+    pending.splice(idx, 1);
+    this.writePending(pending);
+    const list = this.readAllowlist();
+    if (!list.includes(request.senderId)) {
+      list.push(request.senderId);
+      this.writeAllowlist(list);
+    }
+    return request;
+  }
+  listPending() {
+    const pending = this.readPending();
+    const now = Date.now();
+    return pending.filter((r) => now - r.createdAt < EXPIRY_MS);
+  }
+  getAllowlist() {
+    return this.readAllowlist();
+  }
+  ensureDir() {
+    if (!fs2.existsSync(this.dir)) {
+      fs2.mkdirSync(this.dir, { recursive: true });
+    }
+  }
+  readPending() {
+    try {
+      const data = fs2.readFileSync(this.pendingPath, "utf-8");
+      return JSON.parse(data);
+    } catch {
+      return [];
+    }
+  }
+  writePending(requests) {
+    this.ensureDir();
+    fs2.writeFileSync(this.pendingPath, JSON.stringify(requests, null, 2));
+  }
+  readAllowlist() {
+    try {
+      const data = fs2.readFileSync(this.allowlistPath, "utf-8");
+      return JSON.parse(data);
+    } catch {
+      return [];
+    }
+  }
+  writeAllowlist(list) {
+    this.ensureDir();
+    fs2.writeFileSync(this.allowlistPath, JSON.stringify(list, null, 2));
+  }
+};
+function generateCode() {
+  let code = "";
+  for (let i = 0; i < CODE_LENGTH; i++) {
+    code += SAFE_ALPHABET[crypto2.randomInt(SAFE_ALPHABET.length)];
+  }
+  return code;
+}
+__name(generateCode, "generateCode");
+
+// packages/channels/base/dist/index.js
+init_esbuild_shims();
+
 // packages/channels/base/dist/AcpBridge.js
+init_esbuild_shims();
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { Readable, Writable } from "node:stream";
+import { EventEmitter } from "node:events";
 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;
@@ -281,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();
@@ -319,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);
@@ -357,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();
@@ -423,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) {
@@ -439,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;
@@ -615,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}`);
   }
@@ -749,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;
@@ -799,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) {
@@ -820,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)) {
@@ -978,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;
@@ -1242,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;
@@ -1266,8 +1513,51 @@ var DaemonChannelBridge = class extends EventEmitter2 {
       if (mappedSessionId === sessionId) {
         this.respondedRequestToSession.delete(requestId);
       }
-    }
-    return session;
+    }
+    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;
@@ -1515,8 +1805,8 @@ var DmGate = class {
 
 // packages/channels/base/dist/group-history-store.js
 init_esbuild_shims();
-import { appendFileSync, chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
-import { dirname, join as join2 } from "node:path";
+import { appendFileSync, chmodSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2, join as join3 } from "node:path";
 var DEFAULT_MAX_KEYS = 1e3;
 var DEFAULT_COMPACT_AFTER_RECORDS = 1e3;
 var GroupHistoryStore = class {
@@ -1628,12 +1918,12 @@ var GroupHistoryStore = class {
     };
   }
   readRecords() {
-    if (!existsSync(this.filePath)) {
+    if (!existsSync2(this.filePath)) {
       return { records: [], hadInvalidRecords: false };
     }
     let data;
     try {
-      data = readFileSync(this.filePath, "utf-8");
+      data = readFileSync2(this.filePath, "utf-8");
     } catch (err) {
       if (isErrnoCode(err, "ENOENT")) {
         return { records: [], hadInvalidRecords: false };
@@ -1660,8 +1950,8 @@ var GroupHistoryStore = class {
     return { records, hadInvalidRecords };
   }
   append(record) {
-    const dir = dirname(this.filePath);
-    mkdirSync(dir, { recursive: true, mode: 448 });
+    const dir = dirname2(this.filePath);
+    mkdirSync2(dir, { recursive: true, mode: 448 });
     chmodPrivate(dir, 448);
     appendFileSync(this.filePath, `${JSON.stringify(record)}
 `, {
@@ -1671,8 +1961,8 @@ var GroupHistoryStore = class {
     chmodPrivate(this.filePath, 384);
   }
   compact(state, limits) {
-    const dir = dirname(this.filePath);
-    mkdirSync(dir, { recursive: true, mode: 448 });
+    const dir = dirname2(this.filePath);
+    mkdirSync2(dir, { recursive: true, mode: 448 });
     chmodPrivate(dir, 448);
     const records = [];
     const recordedAt = Date.now();
@@ -1689,10 +1979,10 @@ var GroupHistoryStore = class {
     }
     const data = records.length > 0 ? `${records.map((record) => JSON.stringify(record)).join("\n")}
 ` : "";
-    const tempPath = join2(dir, `${Date.now()}-${process.pid}-${Math.random().toString(16).slice(2)}.tmp`);
-    writeFileSync(tempPath, data, { encoding: "utf-8", mode: 384 });
+    const tempPath = join3(dir, `${Date.now()}-${process.pid}-${Math.random().toString(16).slice(2)}.tmp`);
+    writeFileSync2(tempPath, data, { encoding: "utf-8", mode: 384 });
     chmodPrivate(tempPath, 384);
-    renameSync(tempPath, this.filePath);
+    renameSync2(tempPath, this.filePath);
     chmodPrivate(this.filePath, 384);
   }
 };
@@ -1764,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":
@@ -1798,203 +2091,6 @@ var SenderGate = class {
   }
 };
 
-// packages/channels/base/dist/PairingStore.js
-init_esbuild_shims();
-import * as crypto2 from "node:crypto";
-import * as fs2 from "node:fs";
-import * as path2 from "node:path";
-var SAFE_ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
-var CODE_LENGTH = 8;
-var EXPIRY_MS = 60 * 60 * 1e3;
-var MAX_PENDING = 3;
-var PairingStore = class {
-  static {
-    __name(this, "PairingStore");
-  }
-  dir;
-  pendingPath;
-  allowlistPath;
-  migratedSentinelPath;
-  /**
-   * @param channelName Channel name the state is keyed by.
-   * @param workspaceCwd Workspace working directory to scope the state to.
-   *   When provided, files live under
-   *   `<qwen-home>/channels/<workspace-scope>/` so two workspaces using the
-   *   same channel name never share pairing requests or allowlist entries
-   *   (see #7017 — sharing them is an authorization-boundary violation in
-   *   multi-workspace daemon deployments). Omitting it preserves the legacy
-   *   global layout (`<qwen-home>/channels/`).
-   */
-  constructor(channelName, workspaceCwd) {
-    const channelsRoot = path2.join(getGlobalQwenDir(), "channels");
-    this.dir = workspaceCwd ? path2.join(channelsRoot, getWorkspaceScopeDirName(workspaceCwd)) : channelsRoot;
-    const safeChannelName = encodeURIComponent(channelName);
-    this.pendingPath = path2.join(this.dir, `${safeChannelName}-pairing.json`);
-    this.allowlistPath = path2.join(this.dir, `${safeChannelName}-allowlist.json`);
-    this.migratedSentinelPath = path2.join(this.dir, `${safeChannelName}.migrated`);
-    if (workspaceCwd) {
-      this.migrateLegacyState(channelsRoot, channelName);
-    }
-  }
-  /**
-   * One-time grandfathering of pre-scoping state: the first time this
-   * (workspace, channel) pair is constructed, copy the legacy GLOBAL files in
-   * so senders that were already approved stay approved after upgrading.
-   *
-   * Gated by a per-channel sentinel file inside the scope directory — NOT by
-   * the directory itself: one workspace can start several channels in turn,
-   * and a directory-level gate would let only the first channel ever migrate.
-   * The sentinel is written even when there was nothing to copy, so a legacy
-   * file written later (e.g. by an older version still running concurrently)
-   * is never absorbed into a scope that already went through this decision.
-   *
-   * Each file is copied independently and best-effort (an unreadable pairing
-   * file must not block the allowlist, and vice versa), via a
-   * uniquely-named temp file + atomic rename so a crash mid-copy cannot
-   * leave a truncated scoped file behind the closed gate. A file the scoped
-   * store already has is never overwritten.
-   *
-   * Copy, not move: another workspace upgrading later must be able to
-   * grandfather the same baseline, and an older qwen version running
-   * concurrently still reads the global files.
-   *
-   * Revocation therefore means REMOVING ENTRIES from the scoped allowlist
-   * (and from the legacy global file, while it exists) — not deleting files.
-   */
-  migrateLegacyState(channelsRoot, channelName) {
-    try {
-      if (fs2.existsSync(this.migratedSentinelPath)) {
-        return;
-      }
-      const legacyPairs = [
-        [
-          path2.join(channelsRoot, `${channelName}-pairing.json`),
-          this.pendingPath
-        ],
-        [
-          path2.join(channelsRoot, `${channelName}-allowlist.json`),
-          this.allowlistPath
-        ]
-      ];
-      this.ensureDir();
-      let allSucceeded = true;
-      for (const [legacyPath, scopedPath] of legacyPairs) {
-        try {
-          if (path2.dirname(path2.resolve(legacyPath)) !== channelsRoot) {
-            continue;
-          }
-          if (fs2.existsSync(scopedPath) || !fs2.existsSync(legacyPath)) {
-            continue;
-          }
-          const tmpPath = `${scopedPath}.${process.pid}.migrating`;
-          fs2.copyFileSync(legacyPath, tmpPath);
-          fs2.renameSync(tmpPath, scopedPath);
-        } catch (err) {
-          allSucceeded = false;
-          process.stderr.write(`[PairingStore] legacy migration of ${path2.basename(legacyPath)} failed for channel "${channelName}": ${err?.message}; will retry on next start
-`);
-        }
-      }
-      if (allSucceeded) {
-        fs2.writeFileSync(this.migratedSentinelPath, "");
-      }
-    } catch (err) {
-      process.stderr.write(`[PairingStore] legacy migration failed for channel "${channelName}": ${err?.message}; scoped store starts empty
-`);
-    }
-  }
-  isApproved(senderId) {
-    const list = this.readAllowlist();
-    return list.includes(senderId);
-  }
-  /**
-   * Create a pairing request for an unknown sender.
-   * Returns the code if created, or null if the pending cap is reached.
-   * If the sender already has a non-expired pending request, returns that code.
-   */
-  createRequest(senderId, senderName) {
-    const pending = this.readPending();
-    const now = Date.now();
-    const active = pending.filter((r) => now - r.createdAt < EXPIRY_MS);
-    const existing = active.find((r) => r.senderId === senderId);
-    if (existing) {
-      return existing.code;
-    }
-    if (active.length >= MAX_PENDING) {
-      return null;
-    }
-    const code = generateCode();
-    active.push({ senderId, senderName, code, createdAt: now });
-    this.writePending(active);
-    return code;
-  }
-  /**
-   * Approve a pairing request by code.
-   * Returns the sender ID if found, or null if not found / expired.
-   */
-  approve(code) {
-    const pending = this.readPending();
-    const now = Date.now();
-    const idx = pending.findIndex((r) => r.code === code.toUpperCase() && now - r.createdAt < EXPIRY_MS);
-    if (idx === -1)
-      return null;
-    const request = pending[idx];
-    pending.splice(idx, 1);
-    this.writePending(pending);
-    const list = this.readAllowlist();
-    if (!list.includes(request.senderId)) {
-      list.push(request.senderId);
-      this.writeAllowlist(list);
-    }
-    return request;
-  }
-  listPending() {
-    const pending = this.readPending();
-    const now = Date.now();
-    return pending.filter((r) => now - r.createdAt < EXPIRY_MS);
-  }
-  getAllowlist() {
-    return this.readAllowlist();
-  }
-  ensureDir() {
-    if (!fs2.existsSync(this.dir)) {
-      fs2.mkdirSync(this.dir, { recursive: true });
-    }
-  }
-  readPending() {
-    try {
-      const data = fs2.readFileSync(this.pendingPath, "utf-8");
-      return JSON.parse(data);
-    } catch {
-      return [];
-    }
-  }
-  writePending(requests) {
-    this.ensureDir();
-    fs2.writeFileSync(this.pendingPath, JSON.stringify(requests, null, 2));
-  }
-  readAllowlist() {
-    try {
-      const data = fs2.readFileSync(this.allowlistPath, "utf-8");
-      return JSON.parse(data);
-    } catch {
-      return [];
-    }
-  }
-  writeAllowlist(list) {
-    this.ensureDir();
-    fs2.writeFileSync(this.allowlistPath, JSON.stringify(list, null, 2));
-  }
-};
-function generateCode() {
-  let code = "";
-  for (let i = 0; i < CODE_LENGTH; i++) {
-    code += SAFE_ALPHABET[crypto2.randomInt(SAFE_ALPHABET.length)];
-  }
-  return code;
-}
-__name(generateCode, "generateCode");
-
 // packages/channels/base/dist/SessionRouter.js
 init_esbuild_shims();
 import { chmodSync as chmodSync2, existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync as renameSync3, rmSync, unlinkSync, writeFileSync as writeFileSync3 } from "node:fs";
@@ -2049,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":
@@ -3423,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);
@@ -3492,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
@@ -3622,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 {
@@ -3805,6 +3911,7 @@ var ChannelBase = class {
       alreadyPrefixed: true,
       referencedText: void 0,
       attachments: void 0,
+      metadata: void 0,
       imageBase64: void 0,
       imageMimeType: void 0
     };
@@ -4272,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
 `);
       }
@@ -4282,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) {
@@ -4420,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.
@@ -4442,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;
     });
   }
@@ -4588,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);
@@ -4598,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;
@@ -4619,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;
@@ -4629,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. */
@@ -4683,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);
@@ -4709,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.
@@ -4768,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);
@@ -4787,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);
@@ -4812,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;
     }
   }
@@ -4820,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 = {
@@ -4868,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) {
@@ -4973,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 = [
@@ -5011,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) {
@@ -5043,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) {
@@ -5170,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;
@@ -5188,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") {
@@ -5200,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"));
@@ -5219,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"));
@@ -5236,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);
@@ -5260,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") {
@@ -5308,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) {
@@ -5319,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;
     }
@@ -5334,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") {
@@ -5370,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;
@@ -5393,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;
@@ -5428,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);
@@ -5582,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
@@ -5847,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;
@@ -5960,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;
       }
     }
@@ -5982,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;
       }
@@ -6021,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);
@@ -6298,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
           };
@@ -6313,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.");
     }
   }
 };
@@ -6533,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,
@@ -6548,7 +6784,8 @@ export {
   ChannelLoopScheduler,
   ChannelBase,
   ChannelLoopStore,
-  isTerminalTaskLifecycleType
+  isTerminalTaskLifecycleType,
+  PollingChannelBase
 };
 /**
  * @license