@qwen-code/qwen-code 0.21.2 → 0.21.3

package/chunks/{chunk-JCJ7LKNA.js → chunk-DIEFUBV6.js}

@@ -451,1167 +451,1630 @@ function readId(args) {
 }
 __name(readId, "readId");
 
-// packages/channels/base/dist/index.js
-init_esbuild_shims();
-
-// 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";
-
-// packages/channels/base/dist/ChannelBase.js
+// packages/channels/base/dist/AcpBridge.js
 init_esbuild_shims();
-import { basename as basename3, join as join5 } from "node:path";
+import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
-
-// packages/channels/base/dist/BlockStreamer.js
-init_esbuild_shims();
-var BlockStreamer = class {
+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_START_TIMEOUT_MS = 30 * 1e3;
+var ACP_PERMISSION_RESPONSE_TIMEOUT_MS = 5 * 60 * 1e3;
+var ACP_EVENT_LOOP_STALL_RE = /^\[perf\] acp agent event loop stall: max=(\d+(?:\.\d+)?)ms/m;
+function readAvailableCommandAltNames(raw) {
+  if (typeof raw !== "object" || raw === null)
+    return void 0;
+  const record = raw;
+  const meta = record["_meta"];
+  const fromMeta = typeof meta === "object" && meta !== null ? meta["altNames"] : void 0;
+  const source = Array.isArray(record["altNames"]) ? record["altNames"] : Array.isArray(fromMeta) ? fromMeta : void 0;
+  if (!source)
+    return void 0;
+  const names = source.filter((n) => typeof n === "string");
+  return names.length > 0 ? names : void 0;
+}
+__name(readAvailableCommandAltNames, "readAvailableCommandAltNames");
+var AcpBridge = class extends EventEmitter {
   static {
-    __name(this, "BlockStreamer");
+    __name(this, "AcpBridge");
   }
-  buffer = "";
-  idleTimer = null;
-  sending = Promise.resolve();
-  opts;
-  /** Number of blocks emitted so far. */
-  blockCount = 0;
-  constructor(opts) {
-    this.opts = opts;
+  child = null;
+  connection = null;
+  options;
+  _availableCommands = [];
+  channelLoopMcpServer;
+  channelLoopToolHandlers = [];
+  knownSessionIds = /* @__PURE__ */ new Set();
+  sessionBindingTokens = /* @__PURE__ */ new Map();
+  channelLoopMcpRegistered = false;
+  channelLoopMcpRegistration = null;
+  pendingPermissions = /* @__PURE__ */ new Map();
+  constructor(options) {
+    super();
+    this.options = options;
   }
-  /** Feed a new text chunk from the agent stream. */
-  push(chunk) {
-    this.buffer += chunk;
-    this.clearIdleTimer();
-    this.checkEmit();
-    if (this.buffer.length > 0 && this.opts.idleMs > 0) {
-      this.idleTimer = setTimeout(() => this.onIdle(), this.opts.idleMs);
+  get availableCommands() {
+    return this._availableCommands;
+  }
+  async start() {
+    const { cliEntryPath, cwd } = this.options;
+    const args = [
+      ...process.execArgv.filter((a) => !/^--inspect(-brk)?($|=)/.test(a)),
+      cliEntryPath,
+      "--acp"
+    ];
+    if (this.options.model) {
+      args.push("--model", this.options.model);
+    }
+    this.child = spawn(process.execPath, args, {
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env, QWEN_CODE_DISABLE_CRON: "1" },
+      shell: false
+    });
+    this.child.stderr?.on("data", (data) => {
+      const msg = data.toString().trim();
+      if (msg) {
+        process.stderr.write(`[AcpBridge] ${sanitizeLogText(msg, 4096)}
+`);
+        this.maybeKillOnEventLoopStall(msg);
+      }
+    });
+    this.child.on("exit", (code, signal) => {
+      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);
+    });
+    await new Promise((resolve3) => setTimeout(resolve3, 1e3));
+    if (!this.child || this.child.killed) {
+      throw new Error("ACP process failed to start");
+    }
+    const stdout = Readable.toWeb(this.child.stdout);
+    const stdin = Writable.toWeb(this.child.stdin);
+    const stream = ndJsonStream(stdin, stdout);
+    this.connection = new ClientSideConnection(() => ({
+      sessionUpdate: /* @__PURE__ */ __name((params) => {
+        this.handleSessionUpdate(params);
+        return Promise.resolve();
+      }, "sessionUpdate"),
+      requestPermission: /* @__PURE__ */ __name(async (params) => this.requestPermission(params), "requestPermission"),
+      extMethod: /* @__PURE__ */ __name(async (method, params) => this.handleExtMethod(method, params), "extMethod"),
+      extNotification: /* @__PURE__ */ __name(async () => {
+      }, "extNotification")
+    }), stream);
+    try {
+      await withTimeout(this.connection.initialize({
+        protocolVersion: PROTOCOL_VERSION,
+        clientCapabilities: {}
+      }), ACP_START_TIMEOUT_MS, `ACP initialization timed out after ${ACP_START_TIMEOUT_MS}ms`);
+      await this.registerChannelLoopMcpServer();
+    } catch (error) {
+      this.stop();
+      throw error;
     }
   }
-  /** Flush all remaining buffered text. Awaits all pending sends. */
-  async flush() {
-    this.clearIdleTimer();
-    if (this.buffer.length > 0) {
-      this.emitBlock(this.buffer);
-      this.buffer = "";
+  registerChannelLoopToolHandler(handler) {
+    if (!this.channelLoopToolHandlers.includes(handler)) {
+      this.channelLoopToolHandlers.push(handler);
     }
-    await this.sending;
+    this.channelLoopMcpServer ??= new ChannelLoopMcpServer({
+      create: /* @__PURE__ */ __name((sessionId, input) => this.resolveChannelLoopToolHandler(sessionId).create(sessionId, input), "create"),
+      list: /* @__PURE__ */ __name((sessionId) => this.resolveChannelLoopToolHandler(sessionId).list(sessionId), "list"),
+      cancel: /* @__PURE__ */ __name((sessionId, id) => this.resolveChannelLoopToolHandler(sessionId).cancel(sessionId, id), "cancel")
+    });
+    void this.registerChannelLoopMcpServer();
   }
-  /** Drop buffered text and cancel future idle emission. */
-  stop() {
-    this.clearIdleTimer();
-    this.buffer = "";
+  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;
   }
-  // ---------------------------------------------------------------------------
-  // Internal
-  // ---------------------------------------------------------------------------
-  checkEmit() {
-    while (this.buffer.length >= this.opts.maxChars) {
-      const bp = this.findBreakPoint(this.buffer, this.opts.maxChars);
-      this.emitBlock(this.buffer.slice(0, bp));
-      this.buffer = this.buffer.slice(bp);
-    }
-    if (this.buffer.length >= this.opts.minChars) {
-      const bp = this.findBlockBoundary(this.buffer);
-      if (bp > 0) {
-        this.emitBlock(this.buffer.slice(0, bp));
-        this.buffer = this.buffer.slice(bp);
+  async loadSession(sessionId, cwd, _options, bindingToken) {
+    const conn = this.ensureConnection();
+    await this.registerChannelLoopMcpServer();
+    await conn.loadSession({
+      sessionId,
+      cwd,
+      mcpServers: []
+    });
+    this.knownSessionIds.add(sessionId);
+    this.sessionBindingTokens.set(sessionId, bindingToken);
+    return sessionId;
+  }
+  async prompt(sessionId, text, options) {
+    const conn = this.ensureConnection();
+    const chunks = [];
+    let slashCommandOutput = "";
+    const onChunk = /* @__PURE__ */ __name((sid, chunk) => {
+      if (sid === sessionId)
+        chunks.push(chunk);
+    }, "onChunk");
+    const onSlashCommandOutput = /* @__PURE__ */ __name((sid, chunk) => {
+      if (sid === sessionId)
+        slashCommandOutput = chunk;
+    }, "onSlashCommandOutput");
+    const clearChunks = /* @__PURE__ */ __name((sid) => {
+      if (sid === sessionId) {
+        chunks.length = 0;
+        slashCommandOutput = "";
       }
+    }, "clearChunks");
+    this.on("textChunk", onChunk);
+    this.on("slashCommandOutput", onSlashCommandOutput);
+    this.on("responseBoundary", clearChunks);
+    const prompt = [];
+    if (options?.imageBase64 && options.imageMimeType) {
+      prompt.push({
+        type: "image",
+        data: options.imageBase64,
+        mimeType: options.imageMimeType
+      });
+    }
+    prompt.push({ type: "text", text });
+    try {
+      await conn.prompt({
+        sessionId,
+        prompt
+      });
+    } finally {
+      this.off("textChunk", onChunk);
+      this.off("slashCommandOutput", onSlashCommandOutput);
+      this.off("responseBoundary", clearChunks);
     }
+    return chunks.join("") || slashCommandOutput;
   }
-  onIdle() {
-    this.idleTimer = null;
-    if (this.buffer.length >= this.opts.minChars) {
-      this.emitBlock(this.buffer);
-      this.buffer = "";
+  async cancelSession(sessionId) {
+    const conn = this.ensureConnection();
+    try {
+      await conn.cancel({ sessionId });
+    } finally {
+      this.resolvePendingPermissions(sessionId);
     }
   }
-  emitBlock(text) {
-    const trimmed = text.trim();
-    if (!trimmed)
+  async discardSession(sessionId, expectedBindingToken) {
+    if (expectedBindingToken !== void 0 && this.sessionBindingTokens.get(sessionId) !== expectedBindingToken) {
       return;
-    this.blockCount++;
-    this.sending = this.sending.then(() => this.opts.send(trimmed)).catch(() => {
-    });
+    }
+    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 });
   }
-  /**
-   * Find the last paragraph boundary (\n\n) in the buffer.
-   * Returns the position after the boundary, or -1 if no suitable boundary
-   * exists at or after minChars.
-   */
-  findBlockBoundary(text) {
-    const last = text.lastIndexOf("\n\n");
-    if (last < 0 || last < this.opts.minChars)
-      return -1;
-    return last + 2;
-  }
-  /**
-   * Find the best break point at or before maxPos.
-   * Prefers paragraph break > newline > space > maxPos.
-   */
-  findBreakPoint(text, maxPos) {
-    const sub = text.slice(0, maxPos);
-    const para = sub.lastIndexOf("\n\n");
-    if (para > 0)
-      return para + 2;
-    const nl = sub.lastIndexOf("\n");
-    if (nl > 0)
-      return nl + 1;
-    const sp = sub.lastIndexOf(" ");
-    if (sp > 0)
-      return sp + 1;
-    return maxPos;
-  }
-  clearIdleTimer() {
-    if (this.idleTimer !== null) {
-      clearTimeout(this.idleTimer);
-      this.idleTimer = null;
+  async respondToPermission(requestId, response) {
+    const pending = this.pendingPermissions.get(requestId);
+    if (!pending) {
+      return false;
     }
+    clearTimeout(pending.timeout);
+    this.pendingPermissions.delete(requestId);
+    pending.resolve(response);
+    this.emit("permissionResolved", {
+      requestId,
+      outcome: response.outcome
+    });
+    return true;
   }
-};
-
-// packages/channels/base/dist/ChannelProactiveDeliveryError.js
-init_esbuild_shims();
-var CHANNEL_PROACTIVE_DELIVERY_ERROR_CODE = "channel_proactive_delivery_error";
-var ChannelProactiveDeliveryError = class extends Error {
-  static {
-    __name(this, "ChannelProactiveDeliveryError");
-  }
-  disposition;
-  code = CHANNEL_PROACTIVE_DELIVERY_ERROR_CODE;
-  constructor(disposition, message, options) {
-    super(message, options);
-    this.disposition = disposition;
-    this.name = "ChannelProactiveDeliveryError";
-  }
-};
-function isChannelProactiveDeliveryError(error) {
-  if (typeof error !== "object" || error === null)
-    return false;
-  const candidate = error;
-  return candidate.code === CHANNEL_PROACTIVE_DELIVERY_ERROR_CODE && (candidate.disposition === "permanent" || candidate.disposition === "transient") && typeof candidate.message === "string";
-}
-__name(isChannelProactiveDeliveryError, "isChannelProactiveDeliveryError");
-
-// packages/channels/base/dist/GroupGate.js
-init_esbuild_shims();
-var GroupGate = class {
-  static {
-    __name(this, "GroupGate");
+  stop() {
+    this.resolvePendingPermissions();
+    this.knownSessionIds.clear();
+    this.sessionBindingTokens.clear();
+    if (this.child) {
+      this.child.kill();
+      this.child = null;
+    }
+    this.connection = null;
   }
-  policy;
-  groups;
-  constructor(policy = "disabled", groups = {}) {
-    this.policy = policy;
-    this.groups = groups;
+  get isConnected() {
+    return this.child !== null && !this.child.killed && this.child.exitCode === null;
   }
-  /**
-   * Full group check: policy + allowlist + mention gating.
-   * Evaluation order:
-   *   1. groupPolicy (disabled → drop)
-   *   2. group allowlist (allowlist mode, no match → drop)
-   *   3. mention gating (requireMention + not mentioned → drop silently)
-   *
-   * Mention gating runs before sender gate so that unmentioned messages
-   * in groups don't trigger pairing flows.
-   */
-  check(envelope) {
-    if (!envelope.isGroup) {
-      return { allowed: true };
-    }
-    if (this.policy === "disabled") {
-      return { allowed: false, reason: "disabled" };
-    }
-    if (this.policy === "allowlist") {
-      if (!this.groups[envelope.chatId]) {
-        return { allowed: false, reason: "not_allowlisted" };
+  handleSessionUpdate(params) {
+    const { sessionId } = params;
+    const update = params["update"];
+    if (!update)
+      return;
+    const type = update["sessionUpdate"];
+    switch (type) {
+      case "agent_message_chunk": {
+        const meta = update["_meta"];
+        if (typeof meta?.["parentToolCallId"] === "string") {
+          break;
+        }
+        const content = update["content"];
+        if (meta?.["qwenDiscreteMessage"] === true) {
+          if (meta["source"] === "background_notification_response" && meta["rewritten"] !== true && content?.type === "text" && content.text) {
+            this.emit("backgroundResponse", sessionId, content.text);
+          }
+          break;
+        }
+        if (content?.type === "text" && content.text) {
+          this.emit(meta?.["source"] === "slash_command" ? "slashCommandOutput" : "textChunk", sessionId, content.text);
+        }
+        break;
+      }
+      case "tool_call": {
+        const event = {
+          sessionId,
+          toolCallId: update["toolCallId"],
+          kind: update["kind"] || "",
+          title: update["title"] || "",
+          status: update["status"] || "pending",
+          rawInput: update["rawInput"]
+        };
+        if (event.status === "pending" || event.status === "in_progress") {
+          this.emitResponseBoundary(sessionId);
+        }
+        this.emit("toolCall", event);
+        break;
+      }
+      case "plan": {
+        this.emitResponseBoundary(sessionId);
+        break;
+      }
+      case "available_commands_update": {
+        if (Array.isArray(update["availableCommands"])) {
+          this._availableCommands = update["availableCommands"].map((cmd) => {
+            const altNames = readAvailableCommandAltNames(cmd);
+            return altNames ? { ...cmd, altNames } : cmd;
+          });
+        }
+        break;
       }
+      default:
+        break;
     }
-    const groupConfig = this.groups[envelope.chatId] || this.groups["*"] || {};
-    const requireMention = groupConfig.requireMention ?? true;
-    if (requireMention && !envelope.isMentioned && !envelope.isReplyToBot) {
-      return { allowed: false, reason: "mention_required" };
+    this.emit("sessionUpdate", params);
+  }
+  ensureConnection() {
+    if (!this.connection || !this.isConnected) {
+      throw new Error("Not connected to ACP agent");
     }
-    return { allowed: true };
+    return this.connection;
   }
-};
-
-// packages/channels/base/dist/DmGate.js
-init_esbuild_shims();
-var DmGate = class {
-  static {
-    __name(this, "DmGate");
+  requestPermission(request) {
+    const requestId = `acp-permission-${randomUUID()}`;
+    const sessionId = typeof request.sessionId === "string" && request.sessionId.length > 0 ? request.sessionId : request.toolCall.toolCallId;
+    return new Promise((resolve3) => {
+      const timeout = setTimeout(() => {
+        const pending = this.pendingPermissions.get(requestId);
+        if (!pending) {
+          return;
+        }
+        process.stderr.write(`[AcpBridge] permission request ${sanitizeLogText(requestId, 128)} timed out after ${ACP_PERMISSION_RESPONSE_TIMEOUT_MS}ms (session=${sanitizeLogText(pending.sessionId, 128)})
+`);
+        this.pendingPermissions.delete(requestId);
+        const response = {
+          outcome: { outcome: "cancelled" }
+        };
+        pending.resolve(response);
+        this.emit("permissionResolved", {
+          requestId,
+          outcome: response.outcome
+        });
+      }, ACP_PERMISSION_RESPONSE_TIMEOUT_MS);
+      timeout.unref?.();
+      this.pendingPermissions.set(requestId, { sessionId, resolve: resolve3, timeout });
+      this.emitResponseBoundary(sessionId);
+      this.emit("permissionRequest", {
+        requestId,
+        sessionId,
+        request
+      });
+    });
   }
-  policy;
-  constructor(policy = "open") {
-    this.policy = policy;
+  emitResponseBoundary(sessionId) {
+    this.emit("responseBoundary", sessionId);
   }
-  /**
-   * DM check: policy gating for private/non-group messages.
-   * Evaluation order:
-   *   1. Group messages bypass this gate (handled by GroupGate)
-   *   2. dmPolicy (disabled → drop)
-   *
-   * Symmetric with GroupGate — GroupGate owns group messages,
-   * DmGate owns DM messages.
-   */
-  check(envelope) {
-    if (envelope.isGroup) {
-      return { allowed: true };
+  resolvePendingPermissions(sessionId) {
+    const response = {
+      outcome: { outcome: "cancelled" }
+    };
+    for (const [requestId, pending] of this.pendingPermissions) {
+      if (sessionId !== void 0 && pending.sessionId !== sessionId) {
+        continue;
+      }
+      clearTimeout(pending.timeout);
+      this.pendingPermissions.delete(requestId);
+      pending.resolve(response);
+      this.emit("permissionResolved", {
+        requestId,
+        outcome: response.outcome
+      });
     }
-    if (this.policy === "disabled") {
-      return { allowed: false, reason: "disabled" };
+  }
+  maybeKillOnEventLoopStall(stderr) {
+    const match = ACP_EVENT_LOOP_STALL_RE.exec(stderr);
+    if (!match)
+      return;
+    const maxMs = Number(match[1]);
+    if (!Number.isFinite(maxMs) || maxMs < ACP_EVENT_LOOP_STALL_RESTART_MS) {
+      return;
     }
-    return { allowed: true };
+    const child = this.child;
+    if (!child || child.killed || child.exitCode !== null) {
+      return;
+    }
+    process.stderr.write(`[AcpBridge] ACP agent event loop stalled for ${Math.round(maxMs)}ms; killing child process to trigger restart
+`);
+    child.kill("SIGKILL");
   }
-};
-
-// packages/channels/base/dist/group-history-store.js
-init_esbuild_shims();
-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 {
-  static {
-    __name(this, "GroupHistoryStore");
-  }
-  filePath;
-  maxKeys;
-  compactAfterRecords;
-  constructor(filePath, options = {}) {
-    this.filePath = filePath;
-    this.maxKeys = options.maxKeys ?? DEFAULT_MAX_KEYS;
-    this.compactAfterRecords = options.compactAfterRecords ?? DEFAULT_COMPACT_AFTER_RECORDS;
-  }
-  record(key, entry, limit) {
-    const normalizedLimit = normalizeLimit(limit);
-    if (normalizedLimit <= 0) {
+  async registerChannelLoopMcpServer() {
+    if (!this.connection || !this.channelLoopMcpServer || this.channelLoopMcpRegistered) {
       return;
     }
-    const loaded = this.loadState();
-    const state = loaded.entries;
-    const limits = loaded.limits;
-    const current = state.get(key) ?? [];
-    current.push(entry);
-    if (current.length > normalizedLimit) {
-      current.splice(0, current.length - normalizedLimit);
-    }
-    state.delete(key);
-    state.set(key, current);
-    limits.set(key, normalizedLimit);
-    const evicted = evictOldKeys(state, this.maxKeys, limits);
-    this.append({
-      type: "message",
-      key,
-      limit: normalizedLimit,
-      entry,
-      recordedAt: Date.now()
-    });
-    if (evicted || loaded.hadInvalidRecords || loaded.recordCount + 1 >= this.compactAfterRecords) {
-      this.compact(state, limits);
-    }
-  }
-  drain(key, limit) {
-    const normalizedLimit = normalizeLimit(limit);
-    const loaded = this.loadState();
-    const state = loaded.entries;
-    const entries = normalizedLimit > 0 ? (state.get(key) ?? []).slice(-normalizedLimit) : [];
-    if (state.has(key)) {
-      state.delete(key);
-      loaded.limits.delete(key);
-      this.append({ type: "clear", key, recordedAt: Date.now() });
-    }
-    return entries;
-  }
-  clear(key) {
-    const loaded = this.loadState();
-    const state = loaded.entries;
-    if (!state.has(key)) {
+    if (this.channelLoopMcpRegistration) {
+      await this.channelLoopMcpRegistration;
       return;
     }
-    state.delete(key);
-    loaded.limits.delete(key);
-    this.append({ type: "clear", key, recordedAt: Date.now() });
-    this.compact(state, loaded.limits);
+    this.channelLoopMcpRegistration = this.connection.extMethod(WORKSPACE_MCP_RUNTIME_ADD_METHOD, {
+      name: CHANNEL_LOOP_MCP_SERVER_NAME,
+      originatorClientId: "channel",
+      config: {
+        type: "sdk",
+        [CLIENT_MCP_OVER_WS_CONFIG_FLAG]: true
+      }
+    }).then((result) => {
+      if (isSkippedMcpRegistration(result)) {
+        this.channelLoopMcpRegistered = false;
+        process.stderr.write(`[AcpBridge] Channel loop MCP server registration skipped${formatSkippedRegistrationReason(result)}
+`);
+        return;
+      }
+      this.channelLoopMcpRegistered = true;
+    }).catch((error) => {
+      this.channelLoopMcpRegistered = false;
+      process.stderr.write(`[AcpBridge] Failed to register channel loop MCP server: ${error instanceof Error ? error.message : String(error)}
+`);
+    }).finally(() => {
+      this.channelLoopMcpRegistration = null;
+    });
+    await this.channelLoopMcpRegistration;
   }
-  clearAll() {
-    const loaded = this.loadState();
-    if (loaded.entries.size === 0) {
-      return;
+  async handleExtMethod(method, params) {
+    if (method === CLIENT_MCP_MESSAGE_METHOD) {
+      return this.handleClientMcpMessage(params);
     }
-    const recordedAt = Date.now();
-    for (const key of loaded.entries.keys()) {
-      this.append({ type: "clear", key, recordedAt });
+    if (method === MID_TURN_QUEUE_DRAIN_METHOD) {
+      return { messages: [], hasQueuedPrompt: false };
     }
-    this.compact(/* @__PURE__ */ new Map(), /* @__PURE__ */ new Map());
-  }
-  size(key) {
-    const state = this.loadState().entries;
-    if (key !== void 0) {
-      return state.get(key)?.length ?? 0;
+    if (method === TODO_STOP_GUARD_CONTINUATION_CLAIM_METHOD) {
+      const sessionId = typeof params["sessionId"] === "string" ? params["sessionId"] : "";
+      return {
+        claimed: this.knownSessionIds.has(sessionId),
+        hasQueuedPrompt: false
+      };
     }
-    return state.size;
+    throw new Error(`Method not found: ${method}`);
   }
-  loadState() {
-    const state = /* @__PURE__ */ new Map();
-    const limits = /* @__PURE__ */ new Map();
-    const read = this.readRecords();
-    for (const record of read.records) {
-      if (record.type === "clear") {
-        state.delete(record.key);
-        limits.delete(record.key);
-        continue;
-      }
-      const current = state.get(record.key) ?? [];
-      current.push(record.entry);
-      if (current.length > record.limit) {
-        current.splice(0, current.length - record.limit);
-      }
-      state.delete(record.key);
-      state.set(record.key, current);
-      limits.set(record.key, record.limit);
-      evictOldKeys(state, this.maxKeys, limits);
+  async handleClientMcpMessage(params) {
+    if (!this.channelLoopMcpServer) {
+      throw new Error("Channel loop MCP server is not registered.");
     }
-    return {
-      entries: state,
-      limits,
-      recordCount: read.records.length,
-      hadInvalidRecords: read.hadInvalidRecords
-    };
-  }
-  readRecords() {
-    if (!existsSync2(this.filePath)) {
-      return { records: [], hadInvalidRecords: false };
+    const server = params["server"];
+    if (server !== CHANNEL_LOOP_MCP_SERVER_NAME) {
+      throw new Error(`Unknown client MCP server: ${String(server)}`);
     }
-    let data;
-    try {
-      data = readFileSync2(this.filePath, "utf-8");
-    } catch (err) {
-      if (isErrnoCode(err, "ENOENT")) {
-        return { records: [], hadInvalidRecords: false };
-      }
-      throw err;
+    const payload = params["payload"];
+    if (typeof payload !== "object" || payload === null) {
+      throw new Error("Invalid client MCP payload.");
     }
-    const records = [];
-    let hadInvalidRecords = false;
-    for (const line of data.split("\n")) {
-      if (line.trim().length === 0) {
-        continue;
-      }
-      try {
-        const parsed = JSON.parse(line);
-        if (isGroupHistoryRecord(parsed)) {
-          records.push(parsed);
-        } else {
-          hadInvalidRecords = true;
-        }
-      } catch {
-        hadInvalidRecords = true;
-      }
+    const sessionId = typeof params["sessionId"] === "string" ? params["sessionId"] : void 0;
+    const response = await this.channelLoopMcpServer.handleMessage(payload, { sessionId });
+    if (!response) {
+      return { payload: { jsonrpc: "2.0", id: 0, result: {} } };
     }
-    return { records, hadInvalidRecords };
-  }
-  append(record) {
-    const dir = dirname2(this.filePath);
-    mkdirSync2(dir, { recursive: true, mode: 448 });
-    chmodPrivate(dir, 448);
-    appendFileSync(this.filePath, `${JSON.stringify(record)}
-`, {
-      encoding: "utf-8",
-      mode: 384
-    });
-    chmodPrivate(this.filePath, 384);
+    return { payload: response };
   }
-  compact(state, limits) {
-    const dir = dirname2(this.filePath);
-    mkdirSync2(dir, { recursive: true, mode: 448 });
-    chmodPrivate(dir, 448);
-    const records = [];
-    const recordedAt = Date.now();
-    for (const [key, entries] of state) {
-      for (const entry of entries) {
-        records.push({
-          type: "message",
-          key,
-          limit: limits.get(key) ?? entries.length,
-          entry,
-          recordedAt
-        });
-      }
+  resolveChannelLoopToolHandler(sessionId) {
+    if (this.channelLoopToolHandlers.length === 1 && !this.channelLoopToolHandlers[0].canHandle) {
+      return this.channelLoopToolHandlers[0];
     }
-    const data = records.length > 0 ? `${records.map((record) => JSON.stringify(record)).join("\n")}
-` : "";
-    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);
-    renameSync2(tempPath, this.filePath);
-    chmodPrivate(this.filePath, 384);
+    const handler = this.channelLoopToolHandlers.find((candidate) => candidate.canHandle?.(sessionId) === true);
+    if (handler)
+      return handler;
+    throw new Error(this.channelLoopToolHandlers.length === 0 ? "No channel loop tool handler is registered." : `No channel loop handler matched session ${sessionId}.`);
   }
 };
-function normalizeLimit(limit) {
-  if (!Number.isFinite(limit) || limit <= 0) {
-    return 0;
+async function withTimeout(operation, timeoutMs, message) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error(message)), timeoutMs);
+    timer.unref?.();
+  });
+  try {
+    return await Promise.race([operation, timeout]);
+  } finally {
+    if (timer)
+      clearTimeout(timer);
   }
-  return Math.floor(limit);
 }
-__name(normalizeLimit, "normalizeLimit");
-function evictOldKeys(state, maxKeys, limits) {
-  let evicted = false;
-  while (state.size > maxKeys) {
-    const oldest = state.keys().next().value;
-    if (oldest === void 0) {
-      return evicted;
-    }
-    state.delete(oldest);
-    limits?.delete(oldest);
-    evicted = true;
-  }
-  return evicted;
+__name(withTimeout, "withTimeout");
+function isSkippedMcpRegistration(result) {
+  return typeof result === "object" && result !== null && result.skipped === true;
 }
-__name(evictOldKeys, "evictOldKeys");
-function isGroupHistoryRecord(value) {
-  if (!isRecord(value)) {
-    return false;
-  }
-  if (value["type"] === "clear") {
-    return typeof value["key"] === "string";
-  }
-  if (value["type"] !== "message") {
-    return false;
-  }
-  return typeof value["key"] === "string" && typeof value["limit"] === "number" && isGroupHistoryEntry(value["entry"]);
-}
-__name(isGroupHistoryRecord, "isGroupHistoryRecord");
-function isGroupHistoryEntry(value) {
-  return isRecord(value) && typeof value["senderId"] === "string" && typeof value["senderName"] === "string" && typeof value["text"] === "string" && typeof value["timestamp"] === "number";
-}
-__name(isGroupHistoryEntry, "isGroupHistoryEntry");
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-__name(isRecord, "isRecord");
-function isErrnoCode(err, code) {
-  return err instanceof Error && "code" in err && err.code === code;
-}
-__name(isErrnoCode, "isErrnoCode");
-function chmodPrivate(path4, mode) {
-  try {
-    chmodSync(path4, mode);
-  } catch {
-  }
+__name(isSkippedMcpRegistration, "isSkippedMcpRegistration");
+function formatSkippedRegistrationReason(result) {
+  if (typeof result !== "object" || result === null)
+    return ".";
+  const reason = result.reason;
+  return typeof reason === "string" && reason.length > 0 ? `: ${sanitizeLogText(reason, 256)}` : ".";
 }
-__name(chmodPrivate, "chmodPrivate");
+__name(formatSkippedRegistrationReason, "formatSkippedRegistrationReason");
 
-// packages/channels/base/dist/SenderGate.js
+// packages/channels/base/dist/index.js
 init_esbuild_shims();
-var SenderGate = class {
+
+// 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";
+
+// packages/channels/base/dist/ChannelBase.js
+init_esbuild_shims();
+import { basename as basename3, join as join5 } from "node:path";
+import { randomUUID as randomUUID2 } from "node:crypto";
+
+// packages/channels/base/dist/BlockStreamer.js
+init_esbuild_shims();
+var BlockStreamer = class {
   static {
-    __name(this, "SenderGate");
+    __name(this, "BlockStreamer");
   }
-  policy;
-  allowedUsers;
-  pairingStore;
-  constructor(policy, allowedUsers = [], pairingStore) {
-    this.policy = policy;
-    this.allowedUsers = new Set(allowedUsers);
-    this.pairingStore = pairingStore || null;
+  buffer = "";
+  idleTimer = null;
+  sending = Promise.resolve();
+  opts;
+  /** Number of blocks emitted so far. */
+  blockCount = 0;
+  constructor(opts) {
+    this.opts = opts;
   }
-  replaceAllowedUsers(users) {
-    this.allowedUsers = new Set(users);
+  /** Feed a new text chunk from the agent stream. */
+  push(chunk) {
+    this.buffer += chunk;
+    this.clearIdleTimer();
+    this.checkEmit();
+    if (this.buffer.length > 0 && this.opts.idleMs > 0) {
+      this.idleTimer = setTimeout(() => this.onIdle(), this.opts.idleMs);
+    }
   }
-  isAllowed(senderId) {
-    switch (this.policy) {
-      case "open":
-        return true;
-      case "allowlist":
-        return this.allowedUsers.has(senderId);
-      case "pairing":
-        return this.allowedUsers.has(senderId) || this.pairingStore?.isApproved(senderId) === true;
-      default:
-        throw new Error(`Unknown sender policy: ${this.policy}`);
+  /** Flush all remaining buffered text. Awaits all pending sends. */
+  async flush() {
+    this.clearIdleTimer();
+    if (this.buffer.length > 0) {
+      this.emitBlock(this.buffer);
+      this.buffer = "";
     }
+    await this.sending;
   }
-  check(senderId, senderName) {
-    switch (this.policy) {
-      case "open":
-        return { allowed: true };
-      case "allowlist":
-        return { allowed: this.allowedUsers.has(senderId) };
-      case "pairing": {
-        if (this.allowedUsers.has(senderId)) {
-          return { allowed: true };
-        }
-        if (this.pairingStore?.isApproved(senderId)) {
-          return { allowed: true };
-        }
-        const code = this.pairingStore?.createRequest(senderId, senderName || senderId);
-        return { allowed: false, pairingCode: code ?? null };
+  /** Drop buffered text and cancel future idle emission. */
+  stop() {
+    this.clearIdleTimer();
+    this.buffer = "";
+  }
+  // ---------------------------------------------------------------------------
+  // Internal
+  // ---------------------------------------------------------------------------
+  checkEmit() {
+    while (this.buffer.length >= this.opts.maxChars) {
+      const bp = this.findBreakPoint(this.buffer, this.opts.maxChars);
+      this.emitBlock(this.buffer.slice(0, bp));
+      this.buffer = this.buffer.slice(bp);
+    }
+    if (this.buffer.length >= this.opts.minChars) {
+      const bp = this.findBlockBoundary(this.buffer);
+      if (bp > 0) {
+        this.emitBlock(this.buffer.slice(0, bp));
+        this.buffer = this.buffer.slice(bp);
       }
-      default:
-        throw new Error(`Unknown sender policy: ${this.policy}`);
     }
   }
-};
-
-// 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";
-import { dirname as dirname3, join as join4 } from "node:path";
-import process2 from "node:process";
-var SessionRouter = class {
-  static {
-    __name(this, "SessionRouter");
+  onIdle() {
+    this.idleTimer = null;
+    if (this.buffer.length >= this.opts.minChars) {
+      this.emitBlock(this.buffer);
+      this.buffer = "";
+    }
   }
-  toSession = /* @__PURE__ */ new Map();
-  // routing key → session ID
-  toTarget = /* @__PURE__ */ new Map();
-  // session ID → target
-  toCwd = /* @__PURE__ */ new Map();
-  // session ID → cwd
-  creatingSessions = /* @__PURE__ */ new Map();
-  sessionLoadWindows = /* @__PURE__ */ new Set();
-  liveSessionIds = /* @__PURE__ */ new Set();
-  routeTokens = /* @__PURE__ */ new Map();
-  lifecycleGeneration = 0;
-  bridge;
-  defaultCwd;
-  defaultScope;
-  channelScopes = /* @__PURE__ */ new Map();
-  channelApprovalModes = /* @__PURE__ */ new Map();
-  persistPath;
-  recoveryMode;
-  constructor(bridge, defaultCwd, scope = "user", persistPath, options = {}) {
-    this.bridge = bridge;
-    this.defaultCwd = defaultCwd;
-    this.defaultScope = scope;
-    this.persistPath = persistPath;
-    this.recoveryMode = options.recoveryMode ?? "eager";
+  emitBlock(text) {
+    const trimmed = text.trim();
+    if (!trimmed)
+      return;
+    this.blockCount++;
+    this.sending = this.sending.then(() => this.opts.send(trimmed)).catch(() => {
+    });
   }
-  /** Replace the bridge instance (used after crash recovery restart). */
-  setBridge(bridge) {
-    this.bridge = bridge;
+  /**
+   * Find the last paragraph boundary (\n\n) in the buffer.
+   * Returns the position after the boundary, or -1 if no suitable boundary
+   * exists at or after minChars.
+   */
+  findBlockBoundary(text) {
+    const last = text.lastIndexOf("\n\n");
+    if (last < 0 || last < this.opts.minChars)
+      return -1;
+    return last + 2;
   }
-  /** Set scope override for a specific channel. */
-  setChannelScope(channelName, scope) {
-    this.channelScopes.set(channelName, scope);
+  /**
+   * Find the best break point at or before maxPos.
+   * Prefers paragraph break > newline > space > maxPos.
+   */
+  findBreakPoint(text, maxPos) {
+    const sub = text.slice(0, maxPos);
+    const para = sub.lastIndexOf("\n\n");
+    if (para > 0)
+      return para + 2;
+    const nl = sub.lastIndexOf("\n");
+    if (nl > 0)
+      return nl + 1;
+    const sp = sub.lastIndexOf(" ");
+    if (sp > 0)
+      return sp + 1;
+    return maxPos;
   }
-  setChannelApprovalMode(channelName, approvalMode) {
-    if (approvalMode) {
-      this.channelApprovalModes.set(channelName, approvalMode);
-    } else {
-      this.channelApprovalModes.delete(channelName);
+  clearIdleTimer() {
+    if (this.idleTimer !== null) {
+      clearTimeout(this.idleTimer);
+      this.idleTimer = null;
     }
   }
-  routingKey(channelName, senderId, chatId, threadId) {
-    const scope = this.channelScopes.get(channelName) || this.defaultScope;
-    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":
-      default:
-        return `${channelName}:${senderId}:${chatId}`;
-    }
+};
+
+// packages/channels/base/dist/ChannelProactiveDeliveryError.js
+init_esbuild_shims();
+var CHANNEL_PROACTIVE_DELIVERY_ERROR_CODE = "channel_proactive_delivery_error";
+var ChannelProactiveDeliveryError = class extends Error {
+  static {
+    __name(this, "ChannelProactiveDeliveryError");
   }
-  sessionOptions(channelName) {
-    const approvalMode = this.channelApprovalModes.get(channelName);
-    return approvalMode ? { approvalMode } : void 0;
+  disposition;
+  code = CHANNEL_PROACTIVE_DELIVERY_ERROR_CODE;
+  constructor(disposition, message, options) {
+    super(message, options);
+    this.disposition = disposition;
+    this.name = "ChannelProactiveDeliveryError";
   }
-  async resolve(channelName, senderId, chatId, threadId, cwd, isGroup, options) {
-    const key = this.routingKey(channelName, senderId, chatId, options?.routingThreadId ?? threadId);
-    const input = {
-      channelName,
-      senderId,
-      chatId,
-      threadId,
-      cwd: cwd || this.defaultCwd,
-      isGroup
-    };
-    let failedWaits = 0;
-    for (; ; ) {
-      const existing = this.toSession.get(key);
-      if (existing && this.isLive(existing)) {
-        this.promoteTargetToGroup(existing, isGroup);
-        return existing;
-      }
-      const creating = this.creatingSessions.get(key);
-      if (creating) {
-        try {
-          const sessionId = await creating.promise;
-          try {
-            this.assertOperationResultCurrent(key, sessionId, creating);
-          } catch (error) {
-            this.scheduleDiscardInvalidatedSession(sessionId, creating);
-            throw error;
-          }
-          this.promoteTargetToGroup(sessionId, isGroup);
-          return sessionId;
-        } catch (error) {
-          if (creating.invalidationError) {
-            throw creating.invalidationError;
-          }
-          if (this.creatingSessions.get(key) === creating) {
-            this.creatingSessions.delete(key);
-          }
-          this.releaseRouteToken(key, creating);
-          failedWaits++;
-          if (failedWaits > 3)
-            throw error;
-          continue;
-        }
-      }
-      const operation = this.createSessionOperation(key, {
-        channelName: input.channelName,
-        senderId: input.senderId,
-        chatId: input.chatId,
-        threadId: input.threadId,
-        isGroup: input.isGroup
-      }, (currentOperation) => existing ? this.loadOrReplaceSession(key, existing, input, currentOperation) : this.createAndStoreSession(key, input, currentOperation));
-      this.creatingSessions.set(key, operation);
-      try {
-        const sessionId = await operation.promise;
-        try {
-          this.assertOperationResultCurrent(key, sessionId, operation);
-        } catch (error) {
-          this.scheduleDiscardInvalidatedSession(sessionId, operation);
-          throw error;
-        }
-        this.promoteTargetToGroup(sessionId, isGroup);
-        return sessionId;
-      } finally {
-        if (this.creatingSessions.get(key) === operation) {
-          this.creatingSessions.delete(key);
-        }
-        this.releaseRouteToken(key, operation);
-      }
-    }
+};
+function isChannelProactiveDeliveryError(error) {
+  if (typeof error !== "object" || error === null)
+    return false;
+  const candidate = error;
+  return candidate.code === CHANNEL_PROACTIVE_DELIVERY_ERROR_CODE && (candidate.disposition === "permanent" || candidate.disposition === "transient") && typeof candidate.message === "string";
+}
+__name(isChannelProactiveDeliveryError, "isChannelProactiveDeliveryError");
+
+// packages/channels/base/dist/GroupGate.js
+init_esbuild_shims();
+var GroupGate = class {
+  static {
+    __name(this, "GroupGate");
   }
-  isLive(sessionId) {
-    return this.recoveryMode === "eager" || this.liveSessionIds.has(sessionId);
+  policy;
+  groups;
+  constructor(policy = "disabled", groups = {}) {
+    this.policy = policy;
+    this.groups = groups;
   }
-  async createAndStoreSession(key, input, operation) {
-    const loadWindow = this.beginSessionLoad();
-    try {
-      const sessionId = await this.createLiveSession(input.cwd, loadWindow, key, this.sessionOptions(input.channelName), operation, input.channelName);
-      try {
-        this.assertOperationCurrent(operation);
-      } catch (error) {
-        this.scheduleDiscardInvalidatedSession(sessionId, operation);
-        throw error;
-      }
-      this.toSession.set(key, sessionId);
-      this.toTarget.set(sessionId, {
-        channelName: input.channelName,
-        senderId: input.senderId,
-        chatId: input.chatId,
-        threadId: input.threadId,
-        isGroup: input.isGroup
-      });
-      this.toCwd.set(sessionId, input.cwd);
-      this.liveSessionIds.add(sessionId);
-      this.persist();
-      return sessionId;
-    } finally {
-      this.endSessionLoad(loadWindow);
+  /**
+   * Full group check: policy + allowlist + mention gating.
+   * Evaluation order:
+   *   1. groupPolicy (disabled → drop)
+   *   2. group allowlist (allowlist mode, no match → drop)
+   *   3. mention gating (requireMention + not mentioned → drop silently)
+   *
+   * Mention gating runs before sender gate so that unmentioned messages
+   * in groups don't trigger pairing flows.
+   */
+  check(envelope) {
+    if (!envelope.isGroup) {
+      return { allowed: true };
     }
-  }
-  async loadOrReplaceSession(key, savedSessionId, input, operation) {
-    const savedCwd = this.toCwd.get(savedSessionId) ?? input.cwd;
-    const loadWindow = this.beginSessionLoad();
-    try {
-      try {
-        const loadedSessionId = await this.bridge.loadSession(savedSessionId, savedCwd, this.sessionOptions(input.channelName), operation);
-        try {
-          this.assertOperationCurrent(operation);
-          if (this.toSession.get(key) !== savedSessionId) {
-            this.invalidateOperation(operation);
-            this.assertOperationCurrent(operation);
-          }
-        } catch (error) {
-          this.scheduleDiscardInvalidatedSession(loadedSessionId, operation);
-          throw error;
-        }
-        if (typeof loadedSessionId !== "string" || loadedSessionId.length === 0 || loadWindow.delete(loadedSessionId)) {
-          throw new Error("Invalid or dead restored session ID");
-        }
-        if (loadedSessionId !== savedSessionId) {
-          const target = this.toTarget.get(savedSessionId);
-          this.deleteByKey(key);
-          this.toSession.set(key, loadedSessionId);
-          if (target)
-            this.toTarget.set(loadedSessionId, target);
-          this.toCwd.set(loadedSessionId, savedCwd);
-          this.persist();
-        }
-        this.liveSessionIds.add(loadedSessionId);
-        return loadedSessionId;
-      } catch (loadError) {
-        this.assertOperationCurrent(operation);
-        try {
-          const replacement = await this.createLiveSession(input.cwd, loadWindow, key, this.sessionOptions(input.channelName), operation, input.channelName);
-          try {
-            this.assertOperationCurrent(operation);
-          } catch (error) {
-            this.scheduleDiscardInvalidatedSession(replacement, operation);
-            throw error;
-          }
-          this.deleteByKey(key);
-          this.toSession.set(key, replacement);
-          this.toTarget.set(replacement, {
-            channelName: input.channelName,
-            senderId: input.senderId,
-            chatId: input.chatId,
-            threadId: input.threadId,
-            isGroup: input.isGroup
-          });
-          this.toCwd.set(replacement, input.cwd);
-          this.liveSessionIds.add(replacement);
-          this.persist();
-          process2.stderr.write(`[SessionRouter] Replaced unavailable session ${sanitizeLogText(savedSessionId, 128)} for key ${sanitizeLogText(key, 256)} after load failed: ${sanitizeLogText(loadError instanceof Error ? loadError.message : String(loadError), 512)}
-`);
-          return replacement;
-        } catch (createError) {
-          this.assertOperationCurrent(operation);
-          process2.stderr.write(`[SessionRouter] Failed to load session ${sanitizeLogText(savedSessionId, 128)} for key ${sanitizeLogText(key, 256)} (${sanitizeLogText(loadError instanceof Error ? loadError.message : String(loadError), 512)}) and failed to create a replacement (${sanitizeLogText(createError instanceof Error ? createError.message : String(createError), 512)})
-`);
-          throw createError;
-        }
+    if (this.policy === "disabled") {
+      return { allowed: false, reason: "disabled" };
+    }
+    if (this.policy === "allowlist") {
+      if (!this.groups[envelope.chatId]) {
+        return { allowed: false, reason: "not_allowlisted" };
       }
-    } finally {
-      this.endSessionLoad(loadWindow);
     }
+    const groupConfig = this.groups[envelope.chatId] || this.groups["*"] || {};
+    const requireMention = groupConfig.requireMention ?? true;
+    if (requireMention && !envelope.isMentioned && !envelope.isReplyToBot) {
+      return { allowed: false, reason: "mention_required" };
+    }
+    return { allowed: true };
   }
-  getTarget(sessionId) {
-    return this.toTarget.get(sessionId);
-  }
-  getSession(channelName, senderId, chatId, threadId) {
-    return this.toSession.get(this.routingKey(channelName, senderId, chatId, threadId));
+};
+
+// packages/channels/base/dist/DmGate.js
+init_esbuild_shims();
+var DmGate = class {
+  static {
+    __name(this, "DmGate");
   }
-  hasSession(channelName, senderId, chatId, threadId) {
-    const scope = this.channelScopes.get(channelName) || this.defaultScope;
-    if (chatId) {
-      return this.toSession.has(this.routingKey(channelName, senderId, chatId, threadId));
-    }
-    if (scope === "single") {
-      return false;
-    }
-    for (const target of this.toTarget.values()) {
-      if (target.channelName === channelName && target.senderId === senderId) {
-        return true;
-      }
-    }
-    return false;
+  policy;
+  constructor(policy = "open") {
+    this.policy = policy;
   }
   /**
-   * Remove session(s) for the given sender. Returns the removed session IDs.
+   * DM check: policy gating for private/non-group messages.
+   * Evaluation order:
+   *   1. Group messages bypass this gate (handled by GroupGate)
+   *   2. dmPolicy (disabled → drop)
+   *
+   * Symmetric with GroupGate — GroupGate owns group messages,
+   * DmGate owns DM messages.
    */
-  removeSession(channelName, senderId, chatId, threadId) {
-    const removedIds = [];
-    const scope = this.channelScopes.get(channelName) || this.defaultScope;
-    if (chatId) {
-      const key = this.routingKey(channelName, senderId, chatId, threadId);
-      this.invalidateRouteOperation(key);
-      const sessionId = this.deleteByKey(key);
-      if (sessionId)
-        removedIds.push(sessionId);
-    } else if (scope === "single") {
-      return removedIds;
-    } else {
-      for (const [k, mappedSessionId] of [...this.toSession.entries()]) {
-        const target = this.toTarget.get(mappedSessionId);
-        if (target?.channelName === channelName && target.senderId === senderId) {
-          this.invalidateRouteOperation(k);
-          const sessionId = this.deleteByKey(k);
-          if (sessionId)
-            removedIds.push(sessionId);
-        }
-      }
-      for (const [key, operation] of [...this.creatingSessions]) {
-        if (operation.target.channelName === channelName && operation.target.senderId === senderId) {
-          this.invalidateRouteOperation(key);
-        }
-      }
+  check(envelope) {
+    if (envelope.isGroup) {
+      return { allowed: true };
     }
-    if (removedIds.length > 0)
-      this.persist();
-    return removedIds;
+    if (this.policy === "disabled") {
+      return { allowed: false, reason: "disabled" };
+    }
+    return { allowed: true };
   }
-  /** Remove a session mapping by daemon/ACP session ID. */
-  removeSessionId(sessionId) {
-    let removed = false;
-    for (const [key, mappedSessionId] of [...this.toSession.entries()]) {
-      if (mappedSessionId === sessionId) {
-        this.invalidateRouteOperation(key);
-        this.toSession.delete(key);
-        removed = true;
-      }
+};
+
+// packages/channels/base/dist/group-history-store.js
+init_esbuild_shims();
+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 {
+  static {
+    __name(this, "GroupHistoryStore");
+  }
+  filePath;
+  maxKeys;
+  compactAfterRecords;
+  constructor(filePath, options = {}) {
+    this.filePath = filePath;
+    this.maxKeys = options.maxKeys ?? DEFAULT_MAX_KEYS;
+    this.compactAfterRecords = options.compactAfterRecords ?? DEFAULT_COMPACT_AFTER_RECORDS;
+  }
+  record(key, entry, limit) {
+    const normalizedLimit = normalizeLimit(limit);
+    if (normalizedLimit <= 0) {
+      return;
     }
-    if (this.toTarget.delete(sessionId)) {
-      removed = true;
+    const loaded = this.loadState();
+    const state = loaded.entries;
+    const limits = loaded.limits;
+    const current = state.get(key) ?? [];
+    current.push(entry);
+    if (current.length > normalizedLimit) {
+      current.splice(0, current.length - normalizedLimit);
     }
-    if (this.toCwd.delete(sessionId)) {
-      removed = true;
+    state.delete(key);
+    state.set(key, current);
+    limits.set(key, normalizedLimit);
+    const evicted = evictOldKeys(state, this.maxKeys, limits);
+    this.append({
+      type: "message",
+      key,
+      limit: normalizedLimit,
+      entry,
+      recordedAt: Date.now()
+    });
+    if (evicted || loaded.hadInvalidRecords || loaded.recordCount + 1 >= this.compactAfterRecords) {
+      this.compact(state, limits);
     }
-    this.liveSessionIds.delete(sessionId);
-    if (!removed && this.sessionLoadWindows.size > 0) {
-      for (const loadWindow of this.sessionLoadWindows) {
-        loadWindow.add(sessionId);
-      }
+  }
+  drain(key, limit) {
+    const normalizedLimit = normalizeLimit(limit);
+    const loaded = this.loadState();
+    const state = loaded.entries;
+    const entries = normalizedLimit > 0 ? (state.get(key) ?? []).slice(-normalizedLimit) : [];
+    if (state.has(key)) {
+      state.delete(key);
+      loaded.limits.delete(key);
+      this.append({ type: "clear", key, recordedAt: Date.now() });
     }
-    if (removed) {
-      this.persist();
+    return entries;
+  }
+  clear(key) {
+    const loaded = this.loadState();
+    const state = loaded.entries;
+    if (!state.has(key)) {
+      return;
     }
-    return removed;
+    state.delete(key);
+    loaded.limits.delete(key);
+    this.append({ type: "clear", key, recordedAt: Date.now() });
+    this.compact(state, loaded.limits);
   }
-  handleSessionDied(sessionId) {
-    if (this.recoveryMode === "eager") {
-      return this.removeSessionId(sessionId);
+  clearAll() {
+    const loaded = this.loadState();
+    if (loaded.entries.size === 0) {
+      return;
     }
-    const known = this.toTarget.has(sessionId);
-    this.liveSessionIds.delete(sessionId);
-    for (const loadWindow of this.sessionLoadWindows) {
-      loadWindow.add(sessionId);
+    const recordedAt = Date.now();
+    for (const key of loaded.entries.keys()) {
+      this.append({ type: "clear", key, recordedAt });
     }
-    return known;
-  }
-  deleteByKey(key) {
-    const sessionId = this.toSession.get(key);
-    if (!sessionId)
-      return null;
-    this.toSession.delete(key);
-    this.toTarget.delete(sessionId);
-    this.toCwd.delete(sessionId);
-    this.liveSessionIds.delete(sessionId);
-    return sessionId;
+    this.compact(/* @__PURE__ */ new Map(), /* @__PURE__ */ new Map());
   }
-  promoteTargetToGroup(sessionId, isGroup) {
-    const current = this.toTarget.get(sessionId);
-    if (!current)
-      return;
-    if (current.isGroup === true || isGroup !== true)
-      return;
-    this.toTarget.set(sessionId, { ...current, isGroup: true });
-    this.persist();
+  size(key) {
+    const state = this.loadState().entries;
+    if (key !== void 0) {
+      return state.get(key)?.length ?? 0;
+    }
+    return state.size;
   }
-  /** Get all session entries for crash recovery. */
-  getAll() {
-    const entries = [];
-    for (const [key, sessionId] of this.toSession) {
-      const target = this.toTarget.get(sessionId);
-      if (target) {
-        entries.push({ key, sessionId, target });
+  loadState() {
+    const state = /* @__PURE__ */ new Map();
+    const limits = /* @__PURE__ */ new Map();
+    const read = this.readRecords();
+    for (const record of read.records) {
+      if (record.type === "clear") {
+        state.delete(record.key);
+        limits.delete(record.key);
+        continue;
+      }
+      const current = state.get(record.key) ?? [];
+      current.push(record.entry);
+      if (current.length > record.limit) {
+        current.splice(0, current.length - record.limit);
       }
+      state.delete(record.key);
+      state.set(record.key, current);
+      limits.set(record.key, record.limit);
+      evictOldKeys(state, this.maxKeys, limits);
     }
-    return entries;
+    return {
+      entries: state,
+      limits,
+      recordCount: read.records.length,
+      hadInvalidRecords: read.hadInvalidRecords
+    };
   }
-  restoreRoutes() {
-    if (this.recoveryMode !== "lazy") {
-      throw new Error("restoreRoutes requires lazy recovery mode");
+  readRecords() {
+    if (!existsSync2(this.filePath)) {
+      return { records: [], hadInvalidRecords: false };
     }
-    const persisted = this.readPersistedEntries();
-    if (!persisted)
-      return { restored: 0, dropped: 0 };
-    this.dispose();
-    let restored = 0;
-    for (const [key, entry] of Object.entries(persisted.entries)) {
-      this.toSession.set(key, entry.sessionId);
-      this.toTarget.set(entry.sessionId, entry.target);
-      this.toCwd.set(entry.sessionId, entry.cwd);
-      restored++;
+    let data;
+    try {
+      data = readFileSync2(this.filePath, "utf-8");
+    } catch (err) {
+      if (isErrnoCode(err, "ENOENT")) {
+        return { records: [], hadInvalidRecords: false };
+      }
+      throw err;
     }
-    if (persisted.dropped > 0)
-      this.persist();
-    return { restored, dropped: persisted.dropped };
+    const records = [];
+    let hadInvalidRecords = false;
+    for (const line of data.split("\n")) {
+      if (line.trim().length === 0) {
+        continue;
+      }
+      try {
+        const parsed = JSON.parse(line);
+        if (isGroupHistoryRecord(parsed)) {
+          records.push(parsed);
+        } else {
+          hadInvalidRecords = true;
+        }
+      } catch {
+        hadInvalidRecords = true;
+      }
+    }
+    return { records, hadInvalidRecords };
   }
-  /**
-   * Restore session mappings from a previous bridge.
-   * Called after bridge restart — attempts loadSession for each saved mapping.
-   * Failed loads are dropped (new session on next message).
-   */
-  async restoreSessions() {
-    const persisted = this.readPersistedEntries();
-    if (!persisted)
-      return { restored: 0, failed: 0 };
-    const entries = persisted.entries;
-    const restoreGeneration = this.lifecycleGeneration;
-    let restored = 0;
-    let failed = 0;
-    let changed = persisted.dropped > 0;
-    const reservations = /* @__PURE__ */ new Map();
-    for (const key of persisted.droppedKeys) {
-      this.deleteByKey(key);
+  append(record) {
+    const dir = dirname2(this.filePath);
+    mkdirSync2(dir, { recursive: true, mode: 448 });
+    chmodPrivate(dir, 448);
+    appendFileSync(this.filePath, `${JSON.stringify(record)}
+`, {
+      encoding: "utf-8",
+      mode: 384
+    });
+    chmodPrivate(this.filePath, 384);
+  }
+  compact(state, limits) {
+    const dir = dirname2(this.filePath);
+    mkdirSync2(dir, { recursive: true, mode: 448 });
+    chmodPrivate(dir, 448);
+    const records = [];
+    const recordedAt = Date.now();
+    for (const [key, entries] of state) {
+      for (const entry of entries) {
+        records.push({
+          type: "message",
+          key,
+          limit: limits.get(key) ?? entries.length,
+          entry,
+          recordedAt
+        });
+      }
     }
-    for (const key of Object.keys(entries)) {
-      this.deleteByKey(key);
-      const reservation = this.createSessionReservation();
-      reservation.promise.catch(() => void 0);
-      const operation = this.createSessionOperation(key, entries[key].target, () => reservation.promise);
-      operation.promise.catch(() => void 0);
-      this.creatingSessions.set(key, operation);
-      reservations.set(key, { reservation, operation });
+    const data = records.length > 0 ? `${records.map((record) => JSON.stringify(record)).join("\n")}
+` : "";
+    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);
+    renameSync2(tempPath, this.filePath);
+    chmodPrivate(this.filePath, 384);
+  }
+};
+function normalizeLimit(limit) {
+  if (!Number.isFinite(limit) || limit <= 0) {
+    return 0;
+  }
+  return Math.floor(limit);
+}
+__name(normalizeLimit, "normalizeLimit");
+function evictOldKeys(state, maxKeys, limits) {
+  let evicted = false;
+  while (state.size > maxKeys) {
+    const oldest = state.keys().next().value;
+    if (oldest === void 0) {
+      return evicted;
     }
-    const loadWindow = this.beginSessionLoad();
-    try {
-      for (const [key, entry] of Object.entries(entries)) {
-        const reserved = reservations.get(key);
-        if (!reserved)
-          continue;
-        const { reservation, operation } = reserved;
+    state.delete(oldest);
+    limits?.delete(oldest);
+    evicted = true;
+  }
+  return evicted;
+}
+__name(evictOldKeys, "evictOldKeys");
+function isGroupHistoryRecord(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  if (value["type"] === "clear") {
+    return typeof value["key"] === "string";
+  }
+  if (value["type"] !== "message") {
+    return false;
+  }
+  return typeof value["key"] === "string" && typeof value["limit"] === "number" && isGroupHistoryEntry(value["entry"]);
+}
+__name(isGroupHistoryRecord, "isGroupHistoryRecord");
+function isGroupHistoryEntry(value) {
+  return isRecord(value) && typeof value["senderId"] === "string" && typeof value["senderName"] === "string" && typeof value["text"] === "string" && typeof value["timestamp"] === "number";
+}
+__name(isGroupHistoryEntry, "isGroupHistoryEntry");
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+__name(isRecord, "isRecord");
+function isErrnoCode(err, code) {
+  return err instanceof Error && "code" in err && err.code === code;
+}
+__name(isErrnoCode, "isErrnoCode");
+function chmodPrivate(path4, mode) {
+  try {
+    chmodSync(path4, mode);
+  } catch {
+  }
+}
+__name(chmodPrivate, "chmodPrivate");
+
+// packages/channels/base/dist/SenderGate.js
+init_esbuild_shims();
+var SenderGate = class {
+  static {
+    __name(this, "SenderGate");
+  }
+  policy;
+  allowedUsers;
+  pairingStore;
+  constructor(policy, allowedUsers = [], pairingStore) {
+    this.policy = policy;
+    this.allowedUsers = new Set(allowedUsers);
+    this.pairingStore = pairingStore || null;
+  }
+  replaceAllowedUsers(users) {
+    this.allowedUsers = new Set(users);
+  }
+  isAllowed(senderId) {
+    switch (this.policy) {
+      case "open":
+        return true;
+      case "allowlist":
+        return this.allowedUsers.has(senderId);
+      case "pairing":
+        return this.allowedUsers.has(senderId) || this.pairingStore?.isApproved(senderId) === true;
+      default:
+        throw new Error(`Unknown sender policy: ${this.policy}`);
+    }
+  }
+  check(senderId, senderName) {
+    switch (this.policy) {
+      case "open":
+        return { allowed: true };
+      case "allowlist":
+        return { allowed: this.allowedUsers.has(senderId) };
+      case "pairing": {
+        if (this.allowedUsers.has(senderId)) {
+          return { allowed: true };
+        }
+        if (this.pairingStore?.isApproved(senderId)) {
+          return { allowed: true };
+        }
+        const code = this.pairingStore?.createRequest(senderId, senderName || senderId);
+        return { allowed: false, pairingCode: code ?? null };
+      }
+      default:
+        throw new Error(`Unknown sender policy: ${this.policy}`);
+    }
+  }
+};
+
+// 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";
+import { dirname as dirname3, join as join4 } from "node:path";
+import process2 from "node:process";
+var SessionRouter = class {
+  static {
+    __name(this, "SessionRouter");
+  }
+  toSession = /* @__PURE__ */ new Map();
+  // routing key → session ID
+  toTarget = /* @__PURE__ */ new Map();
+  // session ID → target
+  toCwd = /* @__PURE__ */ new Map();
+  // session ID → cwd
+  creatingSessions = /* @__PURE__ */ new Map();
+  sessionLoadWindows = /* @__PURE__ */ new Set();
+  liveSessionIds = /* @__PURE__ */ new Set();
+  routeTokens = /* @__PURE__ */ new Map();
+  lifecycleGeneration = 0;
+  bridge;
+  defaultCwd;
+  defaultScope;
+  channelScopes = /* @__PURE__ */ new Map();
+  channelApprovalModes = /* @__PURE__ */ new Map();
+  persistPath;
+  recoveryMode;
+  constructor(bridge, defaultCwd, scope = "user", persistPath, options = {}) {
+    this.bridge = bridge;
+    this.defaultCwd = defaultCwd;
+    this.defaultScope = scope;
+    this.persistPath = persistPath;
+    this.recoveryMode = options.recoveryMode ?? "eager";
+  }
+  /** Replace the bridge instance (used after crash recovery restart). */
+  setBridge(bridge) {
+    this.bridge = bridge;
+  }
+  /** Set scope override for a specific channel. */
+  setChannelScope(channelName, scope) {
+    this.channelScopes.set(channelName, scope);
+  }
+  setChannelApprovalMode(channelName, approvalMode) {
+    if (approvalMode) {
+      this.channelApprovalModes.set(channelName, approvalMode);
+    } else {
+      this.channelApprovalModes.delete(channelName);
+    }
+  }
+  routingKey(channelName, senderId, chatId, threadId) {
+    const scope = this.channelScopes.get(channelName) || this.defaultScope;
+    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":
+      default:
+        return `${channelName}:${senderId}:${chatId}`;
+    }
+  }
+  sessionOptions(channelName) {
+    const approvalMode = this.channelApprovalModes.get(channelName);
+    return approvalMode ? { approvalMode } : void 0;
+  }
+  async resolve(channelName, senderId, chatId, threadId, cwd, isGroup, options) {
+    const key = this.routingKey(channelName, senderId, chatId, options?.routingThreadId ?? threadId);
+    const input = {
+      channelName,
+      senderId,
+      chatId,
+      threadId,
+      cwd: cwd || this.defaultCwd,
+      isGroup
+    };
+    let failedWaits = 0;
+    for (; ; ) {
+      const existing = this.toSession.get(key);
+      if (existing && this.isLive(existing)) {
+        this.promoteTargetToGroup(existing, isGroup);
+        return existing;
+      }
+      const creating = this.creatingSessions.get(key);
+      if (creating) {
         try {
-          this.assertOperationCurrent(operation);
-          const options = this.sessionOptions(entry.target.channelName);
-          const sessionId = await this.bridge.loadSession(entry.sessionId, entry.cwd, options, operation);
+          const sessionId = await creating.promise;
           try {
-            this.assertOperationCurrent(operation);
+            this.assertOperationResultCurrent(key, sessionId, creating);
           } catch (error) {
-            this.scheduleDiscardInvalidatedSession(sessionId, operation);
+            this.scheduleDiscardInvalidatedSession(sessionId, creating);
             throw error;
           }
-          if (typeof sessionId !== "string" || sessionId.length === 0) {
-            throw new Error("Invalid restored session ID");
-          }
-          if (loadWindow.delete(sessionId)) {
-            throw new Error("Restored session died before routing completed");
-          }
-          this.toSession.set(key, sessionId);
-          this.toTarget.set(sessionId, entry.target);
-          this.toCwd.set(sessionId, entry.cwd);
-          reservation.resolve(sessionId);
-          if (sessionId !== entry.sessionId) {
-            changed = true;
+          this.promoteTargetToGroup(sessionId, isGroup);
+          return sessionId;
+        } catch (error) {
+          if (creating.invalidationError) {
+            throw creating.invalidationError;
           }
-          restored++;
-        } catch (err) {
-          const reason = err instanceof Error ? err.message : String(err);
-          process2.stderr.write(`[SessionRouter] Failed to restore session ${sanitizeLogText(entry.sessionId, 128)} for key ${sanitizeLogText(key, 256)}: ${sanitizeLogText(reason, 512)}
-`);
-          reservation.reject(new Error("Session restore failed", { cause: err }));
-          failed++;
-          changed = true;
-        } finally {
-          if (this.creatingSessions.get(key) === operation) {
+          if (this.creatingSessions.get(key) === creating) {
             this.creatingSessions.delete(key);
           }
-          this.releaseRouteToken(key, operation);
+          this.releaseRouteToken(key, creating);
+          failedWaits++;
+          if (failedWaits > 3)
+            throw error;
+          continue;
         }
       }
-    } finally {
-      this.endSessionLoad(loadWindow);
-    }
-    if (changed && restoreGeneration === this.lifecycleGeneration) {
-      this.persist();
+      const operation = this.createSessionOperation(key, {
+        channelName: input.channelName,
+        senderId: input.senderId,
+        chatId: input.chatId,
+        threadId: input.threadId,
+        isGroup: input.isGroup
+      }, (currentOperation) => existing ? this.loadOrReplaceSession(key, existing, input, currentOperation) : this.createAndStoreSession(key, input, currentOperation));
+      this.creatingSessions.set(key, operation);
+      try {
+        const sessionId = await operation.promise;
+        try {
+          this.assertOperationResultCurrent(key, sessionId, operation);
+        } catch (error) {
+          this.scheduleDiscardInvalidatedSession(sessionId, operation);
+          throw error;
+        }
+        this.promoteTargetToGroup(sessionId, isGroup);
+        return sessionId;
+      } finally {
+        if (this.creatingSessions.get(key) === operation) {
+          this.creatingSessions.delete(key);
+        }
+        this.releaseRouteToken(key, operation);
+      }
     }
-    return { restored, failed };
   }
-  dispose() {
-    this.lifecycleGeneration++;
-    for (const operation of this.creatingSessions.values()) {
-      this.invalidateOperation(operation);
-    }
-    this.toSession.clear();
-    this.toTarget.clear();
-    this.toCwd.clear();
-    this.creatingSessions.clear();
-    this.sessionLoadWindows.clear();
-    this.liveSessionIds.clear();
-    this.routeTokens.clear();
+  isLive(sessionId) {
+    return this.recoveryMode === "eager" || this.liveSessionIds.has(sessionId);
   }
-  /** Clear in-memory state and delete persist file. Used on clean shutdown. */
-  clearAll() {
-    this.dispose();
-    if (this.persistPath && existsSync3(this.persistPath)) {
+  async createAndStoreSession(key, input, operation) {
+    const loadWindow = this.beginSessionLoad();
+    try {
+      const sessionId = await this.createLiveSession(input.cwd, loadWindow, key, this.sessionOptions(input.channelName), operation, input.channelName);
       try {
-        unlinkSync(this.persistPath);
-      } catch {
+        this.assertOperationCurrent(operation);
+      } catch (error) {
+        this.scheduleDiscardInvalidatedSession(sessionId, operation);
+        throw error;
       }
+      this.toSession.set(key, sessionId);
+      this.toTarget.set(sessionId, {
+        channelName: input.channelName,
+        senderId: input.senderId,
+        chatId: input.chatId,
+        threadId: input.threadId,
+        isGroup: input.isGroup
+      });
+      this.toCwd.set(sessionId, input.cwd);
+      this.liveSessionIds.add(sessionId);
+      this.persist();
+      return sessionId;
+    } finally {
+      this.endSessionLoad(loadWindow);
     }
   }
-  readPersistedEntries() {
-    const persistPath = this.persistPath;
-    if (!persistPath || !existsSync3(persistPath))
-      return void 0;
-    let parsed;
+  async loadOrReplaceSession(key, savedSessionId, input, operation) {
+    const savedCwd = this.toCwd.get(savedSessionId) ?? input.cwd;
+    const loadWindow = this.beginSessionLoad();
     try {
-      parsed = JSON.parse(readFileSync3(persistPath, "utf-8"));
-    } catch (error) {
-      const quarantinePath = `${persistPath}.corrupt-${Date.now()}`;
       try {
-        renameSync3(persistPath, quarantinePath);
-      } catch {
-      }
-      process2.stderr.write(`[SessionRouter] Corrupted persist file at ${sanitizeLogText(persistPath, 1024)}: ${sanitizeLogText(error instanceof Error ? error.message : String(error), 512)}
+        const loadedSessionId = await this.bridge.loadSession(savedSessionId, savedCwd, this.sessionOptions(input.channelName), operation);
+        try {
+          this.assertOperationCurrent(operation);
+          if (this.toSession.get(key) !== savedSessionId) {
+            this.invalidateOperation(operation);
+            this.assertOperationCurrent(operation);
+          }
+        } catch (error) {
+          this.scheduleDiscardInvalidatedSession(loadedSessionId, operation);
+          throw error;
+        }
+        if (typeof loadedSessionId !== "string" || loadedSessionId.length === 0 || loadWindow.delete(loadedSessionId)) {
+          throw new Error("Invalid or dead restored session ID");
+        }
+        if (loadedSessionId !== savedSessionId) {
+          const target = this.toTarget.get(savedSessionId);
+          this.deleteByKey(key);
+          this.toSession.set(key, loadedSessionId);
+          if (target)
+            this.toTarget.set(loadedSessionId, target);
+          this.toCwd.set(loadedSessionId, savedCwd);
+          this.persist();
+        }
+        this.liveSessionIds.add(loadedSessionId);
+        return loadedSessionId;
+      } catch (loadError) {
+        this.assertOperationCurrent(operation);
+        try {
+          const replacement = await this.createLiveSession(input.cwd, loadWindow, key, this.sessionOptions(input.channelName), operation, input.channelName);
+          try {
+            this.assertOperationCurrent(operation);
+          } catch (error) {
+            this.scheduleDiscardInvalidatedSession(replacement, operation);
+            throw error;
+          }
+          this.deleteByKey(key);
+          this.toSession.set(key, replacement);
+          this.toTarget.set(replacement, {
+            channelName: input.channelName,
+            senderId: input.senderId,
+            chatId: input.chatId,
+            threadId: input.threadId,
+            isGroup: input.isGroup
+          });
+          this.toCwd.set(replacement, input.cwd);
+          this.liveSessionIds.add(replacement);
+          this.persist();
+          process2.stderr.write(`[SessionRouter] Replaced unavailable session ${sanitizeLogText(savedSessionId, 128)} for key ${sanitizeLogText(key, 256)} after load failed: ${sanitizeLogText(loadError instanceof Error ? loadError.message : String(loadError), 512)}
 `);
-      return void 0;
-    }
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-      const quarantinePath = `${persistPath}.corrupt-${Date.now()}`;
-      try {
-        renameSync3(persistPath, quarantinePath);
-      } catch {
-      }
-      process2.stderr.write(`[SessionRouter] Invalid route store at ${sanitizeLogText(persistPath, 1024)}: expected an object
+          return replacement;
+        } catch (createError) {
+          this.assertOperationCurrent(operation);
+          process2.stderr.write(`[SessionRouter] Failed to load session ${sanitizeLogText(savedSessionId, 128)} for key ${sanitizeLogText(key, 256)} (${sanitizeLogText(loadError instanceof Error ? loadError.message : String(loadError), 512)}) and failed to create a replacement (${sanitizeLogText(createError instanceof Error ? createError.message : String(createError), 512)})
 `);
-      return void 0;
-    }
-    const entries = {};
-    const droppedKeys = [];
-    for (const [key, value] of Object.entries(parsed)) {
-      if (this.isPersistedEntry(value))
-        entries[key] = value;
-      else
-        droppedKeys.push(key);
+          throw createError;
+        }
+      }
+    } finally {
+      this.endSessionLoad(loadWindow);
     }
-    return { entries, dropped: droppedKeys.length, droppedKeys };
   }
-  isPersistedEntry(value) {
-    if (typeof value !== "object" || value === null)
-      return false;
-    const entry = value;
-    const target = entry["target"];
-    if (typeof target !== "object" || target === null)
-      return false;
-    const typedTarget = target;
-    return typeof entry["sessionId"] === "string" && entry["sessionId"].length > 0 && typeof entry["cwd"] === "string" && entry["cwd"].length > 0 && typeof typedTarget["channelName"] === "string" && typeof typedTarget["senderId"] === "string" && typeof typedTarget["chatId"] === "string" && (typedTarget["threadId"] === void 0 || typeof typedTarget["threadId"] === "string") && (typedTarget["isGroup"] === void 0 || typeof typedTarget["isGroup"] === "boolean");
+  getTarget(sessionId) {
+    return this.toTarget.get(sessionId);
   }
-  persist() {
-    if (!this.persistPath)
-      return;
-    const data = {};
-    for (const [key, sessionId] of this.toSession) {
-      const target = this.toTarget.get(sessionId);
-      if (!target)
-        continue;
-      data[key] = {
-        sessionId,
-        target,
-        cwd: this.toCwd.get(sessionId) ?? this.defaultCwd
-      };
+  getSession(channelName, senderId, chatId, threadId) {
+    return this.toSession.get(this.routingKey(channelName, senderId, chatId, threadId));
+  }
+  hasSession(channelName, senderId, chatId, threadId) {
+    const scope = this.channelScopes.get(channelName) || this.defaultScope;
+    if (chatId) {
+      return this.toSession.has(this.routingKey(channelName, senderId, chatId, threadId));
     }
-    const dir = dirname3(this.persistPath);
-    const tempPath = join4(dir, `${Date.now()}-${process2.pid}-${Math.random().toString(16).slice(2)}.tmp`);
-    try {
-      mkdirSync3(dir, { recursive: true, mode: 448 });
-      try {
-        chmodSync2(dir, 448);
-      } catch {
+    if (scope === "single") {
+      return false;
+    }
+    for (const target of this.toTarget.values()) {
+      if (target.channelName === channelName && target.senderId === senderId) {
+        return true;
       }
-      writeFileSync3(tempPath, JSON.stringify(data, null, 2), {
-        encoding: "utf-8",
-        mode: 384
-      });
-      renameSync3(tempPath, this.persistPath);
-      try {
-        chmodSync2(this.persistPath, 384);
-      } catch {
+    }
+    return false;
+  }
+  /**
+   * Remove session(s) for the given sender. Returns the removed session IDs.
+   */
+  removeSession(channelName, senderId, chatId, threadId) {
+    const removedIds = [];
+    const scope = this.channelScopes.get(channelName) || this.defaultScope;
+    if (chatId) {
+      const key = this.routingKey(channelName, senderId, chatId, threadId);
+      this.invalidateRouteOperation(key);
+      const sessionId = this.deleteByKey(key);
+      if (sessionId)
+        removedIds.push(sessionId);
+    } else if (scope === "single") {
+      return removedIds;
+    } else {
+      for (const [k, mappedSessionId] of [...this.toSession.entries()]) {
+        const target = this.toTarget.get(mappedSessionId);
+        if (target?.channelName === channelName && target.senderId === senderId) {
+          this.invalidateRouteOperation(k);
+          const sessionId = this.deleteByKey(k);
+          if (sessionId)
+            removedIds.push(sessionId);
+        }
       }
-    } catch (error) {
-      process2.stderr.write(`[SessionRouter] Failed to persist routes at ${sanitizeLogText(this.persistPath, 1024)}: ${sanitizeLogText(error instanceof Error ? error.message : String(error), 512)}
-`);
-    } finally {
-      try {
-        rmSync(tempPath, { force: true });
-      } catch {
+      for (const [key, operation] of [...this.creatingSessions]) {
+        if (operation.target.channelName === channelName && operation.target.senderId === senderId) {
+          this.invalidateRouteOperation(key);
+        }
       }
     }
+    if (removedIds.length > 0)
+      this.persist();
+    return removedIds;
   }
-  async createLiveSession(cwd, loadWindow, routingKey, options, operation, sourceId) {
-    const maxAttempts = 2;
-    let lastDeadSessionId;
-    for (let attempt = 0; attempt < maxAttempts; attempt++) {
-      const sessionId = await this.bridge.newSession(cwd, { ...options, sourceId }, operation);
-      try {
-        this.assertOperationCurrent(operation);
-      } catch (error) {
-        this.scheduleDiscardInvalidatedSession(sessionId, operation);
-        throw error;
-      }
-      if (typeof sessionId !== "string" || sessionId.length === 0) {
-        throw new Error("Invalid session ID from bridge");
+  /** Remove a session mapping by daemon/ACP session ID. */
+  removeSessionId(sessionId) {
+    let removed = false;
+    for (const [key, mappedSessionId] of [...this.toSession.entries()]) {
+      if (mappedSessionId === sessionId) {
+        this.invalidateRouteOperation(key);
+        this.toSession.delete(key);
+        removed = true;
       }
-      if (!loadWindow.delete(sessionId)) {
-        return sessionId;
+    }
+    if (this.toTarget.delete(sessionId)) {
+      removed = true;
+    }
+    if (this.toCwd.delete(sessionId)) {
+      removed = true;
+    }
+    this.liveSessionIds.delete(sessionId);
+    if (!removed && this.sessionLoadWindows.size > 0) {
+      for (const loadWindow of this.sessionLoadWindows) {
+        loadWindow.add(sessionId);
       }
-      lastDeadSessionId = sessionId;
     }
-    throw new Error(`Session ${lastDeadSessionId ?? "unknown"} died before routing completed (${maxAttempts}/${maxAttempts} attempts, key ${routingKey})`);
-  }
-  beginSessionLoad() {
-    const loadWindow = /* @__PURE__ */ new Set();
-    this.sessionLoadWindows.add(loadWindow);
-    return loadWindow;
+    if (removed) {
+      this.persist();
+    }
+    return removed;
   }
-  createSessionOperation(key, target, run) {
-    let routeToken = this.routeTokens.get(key);
-    if (!routeToken) {
-      routeToken = {};
-      this.routeTokens.set(key, routeToken);
+  handleSessionDied(sessionId) {
+    if (this.recoveryMode === "eager") {
+      return this.removeSessionId(sessionId);
     }
-    const operation = {
-      promise: Promise.resolve(""),
-      target,
-      lifecycleGeneration: this.lifecycleGeneration,
-      routeToken
-    };
-    operation.promise = Promise.resolve().then(() => run(operation)).catch((error) => {
-      this.assertOperationCurrent(operation);
-      throw error;
-    });
-    return operation;
+    const known = this.toTarget.has(sessionId);
+    this.liveSessionIds.delete(sessionId);
+    for (const loadWindow of this.sessionLoadWindows) {
+      loadWindow.add(sessionId);
+    }
+    return known;
   }
-  invalidateRouteOperation(key) {
-    this.routeTokens.delete(key);
-    const operation = this.creatingSessions.get(key);
-    if (!operation)
+  deleteByKey(key) {
+    const sessionId = this.toSession.get(key);
+    if (!sessionId)
+      return null;
+    this.toSession.delete(key);
+    this.toTarget.delete(sessionId);
+    this.toCwd.delete(sessionId);
+    this.liveSessionIds.delete(sessionId);
+    return sessionId;
+  }
+  promoteTargetToGroup(sessionId, isGroup) {
+    const current = this.toTarget.get(sessionId);
+    if (!current)
       return;
-    this.invalidateOperation(operation);
-    this.creatingSessions.delete(key);
+    if (current.isGroup === true || isGroup !== true)
+      return;
+    this.toTarget.set(sessionId, { ...current, isGroup: true });
+    this.persist();
   }
-  invalidateOperation(operation) {
-    operation.invalidationError ??= new Error("Session route operation was invalidated");
+  /** Get all session entries for crash recovery. */
+  getAll() {
+    const entries = [];
+    for (const [key, sessionId] of this.toSession) {
+      const target = this.toTarget.get(sessionId);
+      if (target) {
+        entries.push({ key, sessionId, target });
+      }
+    }
+    return entries;
   }
-  assertOperationCurrent(operation) {
-    if (operation.lifecycleGeneration !== this.lifecycleGeneration) {
-      this.invalidateOperation(operation);
+  restoreRoutes() {
+    if (this.recoveryMode !== "lazy") {
+      throw new Error("restoreRoutes requires lazy recovery mode");
     }
-    if (operation.invalidationError) {
-      throw operation.invalidationError;
+    const persisted = this.readPersistedEntries();
+    if (!persisted)
+      return { restored: 0, dropped: 0 };
+    this.dispose();
+    let restored = 0;
+    for (const [key, entry] of Object.entries(persisted.entries)) {
+      this.toSession.set(key, entry.sessionId);
+      this.toTarget.set(entry.sessionId, entry.target);
+      this.toCwd.set(entry.sessionId, entry.cwd);
+      restored++;
     }
+    if (persisted.dropped > 0)
+      this.persist();
+    return { restored, dropped: persisted.dropped };
   }
-  assertOperationResultCurrent(key, sessionId, operation) {
-    if (operation.routeToken !== this.routeTokens.get(key)) {
-      this.invalidateOperation(operation);
+  /**
+   * Restore session mappings from a previous bridge.
+   * Called after bridge restart — attempts loadSession for each saved mapping.
+   * Failed loads are dropped (new session on next message).
+   */
+  async restoreSessions() {
+    const persisted = this.readPersistedEntries();
+    if (!persisted)
+      return { restored: 0, failed: 0 };
+    const entries = persisted.entries;
+    const restoreGeneration = this.lifecycleGeneration;
+    let restored = 0;
+    let failed = 0;
+    let changed = persisted.dropped > 0;
+    const reservations = /* @__PURE__ */ new Map();
+    for (const key of persisted.droppedKeys) {
+      this.deleteByKey(key);
     }
-    if (this.toSession.get(key) !== sessionId) {
+    for (const key of Object.keys(entries)) {
+      this.deleteByKey(key);
+      const reservation = this.createSessionReservation();
+      reservation.promise.catch(() => void 0);
+      const operation = this.createSessionOperation(key, entries[key].target, () => reservation.promise);
+      operation.promise.catch(() => void 0);
+      this.creatingSessions.set(key, operation);
+      reservations.set(key, { reservation, operation });
+    }
+    const loadWindow = this.beginSessionLoad();
+    try {
+      for (const [key, entry] of Object.entries(entries)) {
+        const reserved = reservations.get(key);
+        if (!reserved)
+          continue;
+        const { reservation, operation } = reserved;
+        try {
+          this.assertOperationCurrent(operation);
+          const options = this.sessionOptions(entry.target.channelName);
+          const sessionId = await this.bridge.loadSession(entry.sessionId, entry.cwd, options, operation);
+          try {
+            this.assertOperationCurrent(operation);
+          } catch (error) {
+            this.scheduleDiscardInvalidatedSession(sessionId, operation);
+            throw error;
+          }
+          if (typeof sessionId !== "string" || sessionId.length === 0) {
+            throw new Error("Invalid restored session ID");
+          }
+          if (loadWindow.delete(sessionId)) {
+            throw new Error("Restored session died before routing completed");
+          }
+          this.toSession.set(key, sessionId);
+          this.toTarget.set(sessionId, entry.target);
+          this.toCwd.set(sessionId, entry.cwd);
+          reservation.resolve(sessionId);
+          if (sessionId !== entry.sessionId) {
+            changed = true;
+          }
+          restored++;
+        } catch (err) {
+          const reason = err instanceof Error ? err.message : String(err);
+          process2.stderr.write(`[SessionRouter] Failed to restore session ${sanitizeLogText(entry.sessionId, 128)} for key ${sanitizeLogText(key, 256)}: ${sanitizeLogText(reason, 512)}
+`);
+          reservation.reject(new Error("Session restore failed", { cause: err }));
+          failed++;
+          changed = true;
+        } finally {
+          if (this.creatingSessions.get(key) === operation) {
+            this.creatingSessions.delete(key);
+          }
+          this.releaseRouteToken(key, operation);
+        }
+      }
+    } finally {
+      this.endSessionLoad(loadWindow);
+    }
+    if (changed && restoreGeneration === this.lifecycleGeneration) {
+      this.persist();
+    }
+    return { restored, failed };
+  }
+  dispose() {
+    this.lifecycleGeneration++;
+    for (const operation of this.creatingSessions.values()) {
       this.invalidateOperation(operation);
     }
-    this.assertOperationCurrent(operation);
+    this.toSession.clear();
+    this.toTarget.clear();
+    this.toCwd.clear();
+    this.creatingSessions.clear();
+    this.sessionLoadWindows.clear();
+    this.liveSessionIds.clear();
+    this.routeTokens.clear();
   }
-  releaseRouteToken(key, operation) {
-    if (this.routeTokens.get(key) === operation.routeToken && !this.toSession.has(key) && !this.creatingSessions.has(key)) {
-      this.routeTokens.delete(key);
+  /** Clear in-memory state and delete persist file. Used on clean shutdown. */
+  clearAll() {
+    this.dispose();
+    if (this.persistPath && existsSync3(this.persistPath)) {
+      try {
+        unlinkSync(this.persistPath);
+      } catch {
+      }
     }
   }
-  scheduleDiscardInvalidatedSession(sessionId, operation) {
-    if ([...this.toSession.values()].includes(sessionId))
-      return;
+  readPersistedEntries() {
+    const persistPath = this.persistPath;
+    if (!persistPath || !existsSync3(persistPath))
+      return void 0;
+    let parsed;
     try {
-      void this.bridge.discardSession?.(sessionId, operation).catch(() => void 0);
-    } catch {
+      parsed = JSON.parse(readFileSync3(persistPath, "utf-8"));
+    } catch (error) {
+      const quarantinePath = `${persistPath}.corrupt-${Date.now()}`;
+      try {
+        renameSync3(persistPath, quarantinePath);
+      } catch {
+      }
+      process2.stderr.write(`[SessionRouter] Corrupted persist file at ${sanitizeLogText(persistPath, 1024)}: ${sanitizeLogText(error instanceof Error ? error.message : String(error), 512)}
+`);
+      return void 0;
     }
-  }
-  createSessionReservation() {
-    let resolveReservation;
-    let rejectReservation;
-    const promise = new Promise((resolve3, reject) => {
-      resolveReservation = resolve3;
-      rejectReservation = reject;
-    });
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      const quarantinePath = `${persistPath}.corrupt-${Date.now()}`;
+      try {
+        renameSync3(persistPath, quarantinePath);
+      } catch {
+      }
+      process2.stderr.write(`[SessionRouter] Invalid route store at ${sanitizeLogText(persistPath, 1024)}: expected an object
+`);
+      return void 0;
+    }
+    const entries = {};
+    const droppedKeys = [];
+    for (const [key, value] of Object.entries(parsed)) {
+      if (this.isPersistedEntry(value))
+        entries[key] = value;
+      else
+        droppedKeys.push(key);
+    }
+    return { entries, dropped: droppedKeys.length, droppedKeys };
+  }
+  isPersistedEntry(value) {
+    if (typeof value !== "object" || value === null)
+      return false;
+    const entry = value;
+    const target = entry["target"];
+    if (typeof target !== "object" || target === null)
+      return false;
+    const typedTarget = target;
+    return typeof entry["sessionId"] === "string" && entry["sessionId"].length > 0 && typeof entry["cwd"] === "string" && entry["cwd"].length > 0 && typeof typedTarget["channelName"] === "string" && typeof typedTarget["senderId"] === "string" && typeof typedTarget["chatId"] === "string" && (typedTarget["threadId"] === void 0 || typeof typedTarget["threadId"] === "string") && (typedTarget["isGroup"] === void 0 || typeof typedTarget["isGroup"] === "boolean");
+  }
+  persist() {
+    if (!this.persistPath)
+      return;
+    const data = {};
+    for (const [key, sessionId] of this.toSession) {
+      const target = this.toTarget.get(sessionId);
+      if (!target)
+        continue;
+      data[key] = {
+        sessionId,
+        target,
+        cwd: this.toCwd.get(sessionId) ?? this.defaultCwd
+      };
+    }
+    const dir = dirname3(this.persistPath);
+    const tempPath = join4(dir, `${Date.now()}-${process2.pid}-${Math.random().toString(16).slice(2)}.tmp`);
+    try {
+      mkdirSync3(dir, { recursive: true, mode: 448 });
+      try {
+        chmodSync2(dir, 448);
+      } catch {
+      }
+      writeFileSync3(tempPath, JSON.stringify(data, null, 2), {
+        encoding: "utf-8",
+        mode: 384
+      });
+      renameSync3(tempPath, this.persistPath);
+      try {
+        chmodSync2(this.persistPath, 384);
+      } catch {
+      }
+    } catch (error) {
+      process2.stderr.write(`[SessionRouter] Failed to persist routes at ${sanitizeLogText(this.persistPath, 1024)}: ${sanitizeLogText(error instanceof Error ? error.message : String(error), 512)}
+`);
+    } finally {
+      try {
+        rmSync(tempPath, { force: true });
+      } catch {
+      }
+    }
+  }
+  async createLiveSession(cwd, loadWindow, routingKey, options, operation, sourceId) {
+    const maxAttempts = 2;
+    let lastDeadSessionId;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const sessionId = await this.bridge.newSession(cwd, { ...options, sourceId }, operation);
+      try {
+        this.assertOperationCurrent(operation);
+      } catch (error) {
+        this.scheduleDiscardInvalidatedSession(sessionId, operation);
+        throw error;
+      }
+      if (typeof sessionId !== "string" || sessionId.length === 0) {
+        throw new Error("Invalid session ID from bridge");
+      }
+      if (!loadWindow.delete(sessionId)) {
+        return sessionId;
+      }
+      lastDeadSessionId = sessionId;
+    }
+    throw new Error(`Session ${lastDeadSessionId ?? "unknown"} died before routing completed (${maxAttempts}/${maxAttempts} attempts, key ${routingKey})`);
+  }
+  beginSessionLoad() {
+    const loadWindow = /* @__PURE__ */ new Set();
+    this.sessionLoadWindows.add(loadWindow);
+    return loadWindow;
+  }
+  createSessionOperation(key, target, run) {
+    let routeToken = this.routeTokens.get(key);
+    if (!routeToken) {
+      routeToken = {};
+      this.routeTokens.set(key, routeToken);
+    }
+    const operation = {
+      promise: Promise.resolve(""),
+      target,
+      lifecycleGeneration: this.lifecycleGeneration,
+      routeToken
+    };
+    operation.promise = Promise.resolve().then(() => run(operation)).catch((error) => {
+      this.assertOperationCurrent(operation);
+      throw error;
+    });
+    return operation;
+  }
+  invalidateRouteOperation(key) {
+    this.routeTokens.delete(key);
+    const operation = this.creatingSessions.get(key);
+    if (!operation)
+      return;
+    this.invalidateOperation(operation);
+    this.creatingSessions.delete(key);
+  }
+  invalidateOperation(operation) {
+    operation.invalidationError ??= new Error("Session route operation was invalidated");
+  }
+  assertOperationCurrent(operation) {
+    if (operation.lifecycleGeneration !== this.lifecycleGeneration) {
+      this.invalidateOperation(operation);
+    }
+    if (operation.invalidationError) {
+      throw operation.invalidationError;
+    }
+  }
+  assertOperationResultCurrent(key, sessionId, operation) {
+    if (operation.routeToken !== this.routeTokens.get(key)) {
+      this.invalidateOperation(operation);
+    }
+    if (this.toSession.get(key) !== sessionId) {
+      this.invalidateOperation(operation);
+    }
+    this.assertOperationCurrent(operation);
+  }
+  releaseRouteToken(key, operation) {
+    if (this.routeTokens.get(key) === operation.routeToken && !this.toSession.has(key) && !this.creatingSessions.has(key)) {
+      this.routeTokens.delete(key);
+    }
+  }
+  scheduleDiscardInvalidatedSession(sessionId, operation) {
+    if ([...this.toSession.values()].includes(sessionId))
+      return;
+    try {
+      void this.bridge.discardSession?.(sessionId, operation).catch(() => void 0);
+    } catch {
+    }
+  }
+  createSessionReservation() {
+    let resolveReservation;
+    let rejectReservation;
+    const promise = new Promise((resolve3, reject) => {
+      resolveReservation = resolve3;
+      rejectReservation = reject;
+    });
     return {
       promise,
       resolve: resolveReservation,
@@ -1652,6 +2115,7 @@ var ChannelLoopScheduler = class {
   runningTick;
   inFlightJobs = /* @__PURE__ */ new Map();
   generation = 0;
+  recoveryEpoch = 0;
   constructor(options) {
     this.store = options.store;
     this.channels = options.channels;
@@ -1691,6 +2155,14 @@ var ChannelLoopScheduler = class {
     this.generation++;
     this.inFlightJobs.clear();
   }
+  /**
+   * Mark that a bridge recovery started. Loop prompts already in flight that
+   * the bridge replacement aborts are cleared instead of counted as agent
+   * failures, so a crash-restart cannot auto-disable a loop.
+   */
+  markBridgeRecovery() {
+    this.recoveryEpoch++;
+  }
   async reconcileStartupState() {
     const jobs = await this.store.list();
     const staleRunning = jobs.filter((job) => job.runningSince);
@@ -1761,6 +2233,7 @@ var ChannelLoopScheduler = class {
       return;
     if (this.generation !== generation)
       return;
+    let recoveryEpoch = this.recoveryEpoch;
     const runningSince = now.toISOString();
     let resultPreview;
     try {
@@ -1772,6 +2245,7 @@ var ChannelLoopScheduler = class {
         await this.clearRunningSince(latestJob.id, runningSince);
         return;
       }
+      recoveryEpoch = this.recoveryEpoch;
       resultPreview = await channel.runLoopPrompt(latestJob, {
         timeoutMs: this.loopTimeoutMs,
         shouldContinue: /* @__PURE__ */ __name(async () => {
@@ -1800,6 +2274,19 @@ var ChannelLoopScheduler = class {
         await this.clearRunningSince(latestJob.id, runningSince);
         return;
       }
+      if (recoveryEpoch !== this.recoveryEpoch) {
+        try {
+          await this.store.update(latestJob.id, {
+            lastFinishedAt: this.now().toISOString(),
+            lastStatus: "error",
+            lastError: truncateError(err instanceof Error ? err.message : String(err)),
+            runningSince: void 0
+          });
+        } catch {
+          await this.clearRunningSince(latestJob.id, runningSince);
+        }
+        return;
+      }
       await this.recordFailure(currentJob2, now, err instanceof Error ? err.message : String(err));
       return;
     }
@@ -2258,6 +2745,10 @@ var ChannelBase = class {
     __name(this, "ChannelBase");
   }
   config;
+  /**
+   * Recovery invariant: session-resolution and prompt-capture paths must await
+   * waitForBridgeRecovery() immediately before that operation.
+   */
   bridge;
   groupGate;
   dmGate;
@@ -2269,6 +2760,8 @@ var ChannelBase = class {
   memoryScope;
   /** Resolved proxy URL, available to subclasses for adapter-specific clients. */
   proxy;
+  /** Adapter-owned persistent state directory, when supplied by the runtime. */
+  stateDir;
   channelMemory;
   memoryIntentClassifier;
   channelMemoryRecallObserver;
@@ -2284,6 +2777,7 @@ var ChannelBase = class {
   /** Per-session promise chain to serialize prompt + send (followup mode). */
   sessionQueues = /* @__PURE__ */ new Map();
   registerBridgeEvents;
+  bridgeRecovery;
   /**
    * Per-session generation, bumped by /clear. A queued followup turn captures the
    * generation when it enqueues and bails if /clear bumped it before the turn ran,
@@ -2564,6 +3058,7 @@ var ChannelBase = class {
     this.config = config;
     this.bridge = bridge;
     this.proxy = options?.proxy;
+    this.stateDir = options?.stateDir;
     this.identity = Object.freeze(this.resolveIdentity(name, config));
     this.memoryScope = Object.freeze(this.resolveMemoryScope(name, config));
     this.channelMemory = options?.channelMemory;
@@ -2572,6 +3067,7 @@ var ChannelBase = class {
     this.groupHistory = new GroupHistoryStore(options?.groupHistoryPath ?? join5(getGlobalQwenDir(), "channels", `${encodeURIComponent(name)}-group-history.jsonl`));
     this.loopController = options?.loopController;
     this.observedContacts = options?.observedContacts;
+    this.bridgeRecovery = options?.bridgeRecovery;
     this.groupGate = new GroupGate(config.groupPolicy, config.groups);
     this.dmGate = new DmGate(config.dmPolicy);
     const pairingStore = config.senderPolicy === "pairing" ? new PairingStore(name, config.cwd) : void 0;
@@ -2740,7 +3236,7 @@ var ChannelBase = class {
   ensureOutputSegment(sessionId, active) {
     if (!active.owner)
       return void 0;
-    const segmentId = active.activeSegmentId ?? randomUUID();
+    const segmentId = active.activeSegmentId ?? randomUUID2();
     const context = this.outputSegmentContext(sessionId, active, segmentId);
     if (context)
       active.activeSegmentId = segmentId;
@@ -3005,6 +3501,7 @@ var ChannelBase = class {
       await this.loopController?.disable(job.id);
       throw new Error(`Loop ${job.id} target is no longer authorized.`);
     }
+    await this.waitForBridgeRecovery();
     const sessionId = await this.router.resolve(this.name, job.target.senderId, job.target.chatId, job.target.threadId, job.cwd, job.target.isGroup);
     const label = sanitizeQuotedText(job.label || job.id, 80);
     const createdBy = sanitizeSenderName(job.createdBy || "unknown");
@@ -3062,7 +3559,7 @@ ${promptText}` : promptText;
         doneResolve = resolve3;
       });
       const promptState = {
-        runId: randomUUID(),
+        runId: randomUUID2(),
         cancelled: false,
         done,
         resolve: doneResolve,
@@ -3112,6 +3609,7 @@ ${promptText}` : promptText;
         heldChunks.length = 0;
         this.onResponseBoundary(job.target.chatId, sessionId);
       }, "onResponseBoundary");
+      await this.waitForBridgeRecovery();
       const promptBridge = this.bridge;
       promptBridge.on("textChunk", onChunk);
       promptBridge.on("responseBoundary", onResponseBoundary);
@@ -3219,6 +3717,7 @@ ${promptText}` : promptText;
   }
   async runWebhookTask(task, options = {}) {
     const target = this.resolveWebhookTaskTarget(task);
+    await this.waitForBridgeRecovery();
     const sessionId = await this.router.resolve(this.name, target.senderId, target.chatId, target.threadId, this.config.cwd, target.isGroup, {
       routingThreadId: this.webhookRoutingThreadId(task, target)
     });
@@ -3275,7 +3774,7 @@ ${promptText}` : promptText;
         doneResolve = resolve3;
       });
       const promptState = {
-        runId: randomUUID(),
+        runId: randomUUID2(),
         cancelled: false,
         done,
         resolve: doneResolve,
@@ -3318,6 +3817,7 @@ ${promptText}` : promptText;
           releaseHeldChunks();
         }
       }, "onChunk");
+      await this.waitForBridgeRecovery();
       const promptBridge = this.bridge;
       promptBridge.on("textChunk", onChunk);
       try {
@@ -5157,6 +5657,17 @@ ${promptText}`;
   markPreflighted(envelope) {
     this.preflightedEnvelopes.add(envelope);
   }
+  /** Wait until the currently active bridge recovery, if any, has completed. */
+  async waitForBridgeRecovery() {
+    let completedRecovery;
+    while (true) {
+      const bridgeRecovery = this.bridgeRecovery?.();
+      if (!bridgeRecovery || bridgeRecovery === completedRecovery)
+        return;
+      await bridgeRecovery;
+      completedRecovery = bridgeRecovery;
+    }
+  }
   /**
    * Process an inbound message after preflight gates have passed.
    *
@@ -5165,6 +5676,7 @@ ${promptText}`;
    * already preflighted, such as during collect-buffer drain.
    */
   async processInbound(envelope) {
+    await this.waitForBridgeRecovery();
     if (!this.preflightedEnvelopes.delete(envelope)) {
       throw new Error("processInbound called without a successful preflightInbound check.");
     }
@@ -5215,6 +5727,7 @@ ${promptText}`;
         return;
       }
     }
+    await this.waitForBridgeRecovery();
     const sessionId = await this.router.resolve(this.name, envelope.senderId, envelope.chatId, envelope.threadId, this.config.cwd, envelope.isGroup);
     if (bangText.startsWith("!")) {
       const cmd = bangText.slice(1).trim();
@@ -5405,7 +5918,7 @@ ${promptToSend}`;
         doneResolve = r;
       });
       const promptState = {
-        runId: randomUUID(),
+        runId: randomUUID2(),
         owner: {
           kind: "channel_user",
           id: envelope.senderId
@@ -5473,6 +5986,7 @@ ${promptToSend}`;
         void this.notifyOutputSegmentEnd(envelope.chatId, sessionId, segment, "response_boundary");
         streamer?.stop();
       }, "onResponseBoundary");
+      await this.waitForBridgeRecovery();
       const promptBridge = this.bridge;
       promptBridge.on("textChunk", onChunk);
       promptBridge.on("responseBoundary", onResponseBoundary);
@@ -5594,578 +6108,135 @@ Ask the bot operator to approve you with:
       await this.sendThreadMessage(chatId, threadId, "Too many pending pairing requests. Please try again later.");
     }
   }
-};
-function truncateGroupHistoryField(value) {
-  return value.slice(0, GROUP_HISTORY_ENTRY_METADATA_LIMIT);
-}
-__name(truncateGroupHistoryField, "truncateGroupHistoryField");
-function isPromiseLike(value) {
-  return value !== null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
-}
-__name(isPromiseLike, "isPromiseLike");
-function isDebugPayloadEnabled(channelName) {
-  const raw = process.env[DEBUG_PAYLOAD_ENV]?.trim();
-  if (!raw)
-    return false;
-  if (["1", "true", "yes", "all", "*"].includes(raw.toLowerCase())) {
-    return true;
-  }
-  return raw.split(",").map((value) => value.trim()).filter(Boolean).includes(channelName);
-}
-__name(isDebugPayloadEnabled, "isDebugPayloadEnabled");
-function redactPayloadValue(key, value) {
-  if (!key)
-    return value;
-  return SENSITIVE_PAYLOAD_KEY_PATTERN.test(key) ? "[redacted]" : value;
-}
-__name(redactPayloadValue, "redactPayloadValue");
-function truncateLoopLabel(prompt) {
-  const chars = Array.from(prompt);
-  return chars.length > 60 ? `${chars.slice(0, 57).join("")}...` : prompt;
-}
-__name(truncateLoopLabel, "truncateLoopLabel");
-
-// packages/channels/base/dist/PollingChannelBase.js
-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`);
-  }
-};
-
-// packages/channels/base/dist/AcpBridge.js
-init_esbuild_shims();
-import { spawn } from "node:child_process";
-import { randomUUID as randomUUID2 } 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;
-function readAvailableCommandAltNames(raw) {
-  if (typeof raw !== "object" || raw === null)
-    return void 0;
-  const record = raw;
-  const meta = record["_meta"];
-  const fromMeta = typeof meta === "object" && meta !== null ? meta["altNames"] : void 0;
-  const source = Array.isArray(record["altNames"]) ? record["altNames"] : Array.isArray(fromMeta) ? fromMeta : void 0;
-  if (!source)
-    return void 0;
-  const names = source.filter((n) => typeof n === "string");
-  return names.length > 0 ? names : void 0;
-}
-__name(readAvailableCommandAltNames, "readAvailableCommandAltNames");
-var AcpBridge = class extends EventEmitter {
-  static {
-    __name(this, "AcpBridge");
-  }
-  child = null;
-  connection = null;
-  options;
-  _availableCommands = [];
-  channelLoopMcpServer;
-  channelLoopToolHandlers = [];
-  knownSessionIds = /* @__PURE__ */ new Set();
-  sessionBindingTokens = /* @__PURE__ */ new Map();
-  channelLoopMcpRegistered = false;
-  channelLoopMcpRegistration = null;
-  pendingPermissions = /* @__PURE__ */ new Map();
-  constructor(options) {
-    super();
-    this.options = options;
-  }
-  get availableCommands() {
-    return this._availableCommands;
-  }
-  async start() {
-    const { cliEntryPath, cwd } = this.options;
-    const args = [
-      ...process.execArgv.filter((a) => !/^--inspect(-brk)?($|=)/.test(a)),
-      cliEntryPath,
-      "--acp"
-    ];
-    if (this.options.model) {
-      args.push("--model", this.options.model);
-    }
-    this.child = spawn(process.execPath, args, {
-      cwd,
-      stdio: ["pipe", "pipe", "pipe"],
-      env: { ...process.env, QWEN_CODE_DISABLE_CRON: "1" },
-      shell: false
-    });
-    this.child.stderr?.on("data", (data) => {
-      const msg = data.toString().trim();
-      if (msg) {
-        process.stderr.write(`[AcpBridge] ${sanitizeLogText(msg, 4096)}
-`);
-        this.maybeKillOnEventLoopStall(msg);
-      }
-    });
-    this.child.on("exit", (code, signal) => {
-      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);
-    });
-    await new Promise((resolve3) => setTimeout(resolve3, 1e3));
-    if (!this.child || this.child.killed) {
-      throw new Error("ACP process failed to start");
-    }
-    const stdout = Readable.toWeb(this.child.stdout);
-    const stdin = Writable.toWeb(this.child.stdin);
-    const stream = ndJsonStream(stdin, stdout);
-    this.connection = new ClientSideConnection(() => ({
-      sessionUpdate: /* @__PURE__ */ __name((params) => {
-        this.handleSessionUpdate(params);
-        return Promise.resolve();
-      }, "sessionUpdate"),
-      requestPermission: /* @__PURE__ */ __name(async (params) => this.requestPermission(params), "requestPermission"),
-      extMethod: /* @__PURE__ */ __name(async (method, params) => this.handleExtMethod(method, params), "extMethod"),
-      extNotification: /* @__PURE__ */ __name(async () => {
-      }, "extNotification")
-    }), stream);
-    await this.connection.initialize({
-      protocolVersion: PROTOCOL_VERSION,
-      clientCapabilities: {}
-    });
-    await this.registerChannelLoopMcpServer();
-  }
-  registerChannelLoopToolHandler(handler) {
-    if (!this.channelLoopToolHandlers.includes(handler)) {
-      this.channelLoopToolHandlers.push(handler);
-    }
-    this.channelLoopMcpServer ??= new ChannelLoopMcpServer({
-      create: /* @__PURE__ */ __name((sessionId, input) => this.resolveChannelLoopToolHandler(sessionId).create(sessionId, input), "create"),
-      list: /* @__PURE__ */ __name((sessionId) => this.resolveChannelLoopToolHandler(sessionId).list(sessionId), "list"),
-      cancel: /* @__PURE__ */ __name((sessionId, id) => this.resolveChannelLoopToolHandler(sessionId).cancel(sessionId, id), "cancel")
-    });
-    void this.registerChannelLoopMcpServer();
-  }
-  async newSession(cwd, _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, _options, bindingToken) {
-    const conn = this.ensureConnection();
-    await this.registerChannelLoopMcpServer();
-    await conn.loadSession({
-      sessionId,
-      cwd,
-      mcpServers: []
-    });
-    this.knownSessionIds.add(sessionId);
-    this.sessionBindingTokens.set(sessionId, bindingToken);
-    return sessionId;
-  }
-  async prompt(sessionId, text, options) {
-    const conn = this.ensureConnection();
-    const chunks = [];
-    let slashCommandOutput = "";
-    const onChunk = /* @__PURE__ */ __name((sid, chunk) => {
-      if (sid === sessionId)
-        chunks.push(chunk);
-    }, "onChunk");
-    const onSlashCommandOutput = /* @__PURE__ */ __name((sid, chunk) => {
-      if (sid === sessionId)
-        slashCommandOutput = chunk;
-    }, "onSlashCommandOutput");
-    const clearChunks = /* @__PURE__ */ __name((sid) => {
-      if (sid === sessionId) {
-        chunks.length = 0;
-        slashCommandOutput = "";
-      }
-    }, "clearChunks");
-    this.on("textChunk", onChunk);
-    this.on("slashCommandOutput", onSlashCommandOutput);
-    this.on("responseBoundary", clearChunks);
-    const prompt = [];
-    if (options?.imageBase64 && options.imageMimeType) {
-      prompt.push({
-        type: "image",
-        data: options.imageBase64,
-        mimeType: options.imageMimeType
-      });
-    }
-    prompt.push({ type: "text", text });
-    try {
-      await conn.prompt({
-        sessionId,
-        prompt
-      });
-    } finally {
-      this.off("textChunk", onChunk);
-      this.off("slashCommandOutput", onSlashCommandOutput);
-      this.off("responseBoundary", clearChunks);
-    }
-    return chunks.join("") || slashCommandOutput;
-  }
-  async cancelSession(sessionId) {
-    const conn = this.ensureConnection();
-    try {
-      await conn.cancel({ sessionId });
-    } finally {
-      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) {
-      return false;
-    }
-    clearTimeout(pending.timeout);
-    this.pendingPermissions.delete(requestId);
-    pending.resolve(response);
-    this.emit("permissionResolved", {
-      requestId,
-      outcome: response.outcome
-    });
-    return true;
-  }
-  stop() {
-    this.resolvePendingPermissions();
-    this.knownSessionIds.clear();
-    this.sessionBindingTokens.clear();
-    if (this.child) {
-      this.child.kill();
-      this.child = null;
-    }
-    this.connection = null;
-  }
-  get isConnected() {
-    return this.child !== null && !this.child.killed && this.child.exitCode === null;
-  }
-  handleSessionUpdate(params) {
-    const { sessionId } = params;
-    const update = params["update"];
-    if (!update)
-      return;
-    const type = update["sessionUpdate"];
-    switch (type) {
-      case "agent_message_chunk": {
-        const meta = update["_meta"];
-        if (typeof meta?.["parentToolCallId"] === "string") {
-          break;
-        }
-        const content = update["content"];
-        if (meta?.["qwenDiscreteMessage"] === true) {
-          if (meta["source"] === "background_notification_response" && meta["rewritten"] !== true && content?.type === "text" && content.text) {
-            this.emit("backgroundResponse", sessionId, content.text);
-          }
-          break;
-        }
-        if (content?.type === "text" && content.text) {
-          this.emit(meta?.["source"] === "slash_command" ? "slashCommandOutput" : "textChunk", sessionId, content.text);
-        }
-        break;
-      }
-      case "tool_call": {
-        const event = {
-          sessionId,
-          toolCallId: update["toolCallId"],
-          kind: update["kind"] || "",
-          title: update["title"] || "",
-          status: update["status"] || "pending",
-          rawInput: update["rawInput"]
-        };
-        if (event.status === "pending" || event.status === "in_progress") {
-          this.emitResponseBoundary(sessionId);
-        }
-        this.emit("toolCall", event);
-        break;
-      }
-      case "plan": {
-        this.emitResponseBoundary(sessionId);
-        break;
-      }
-      case "available_commands_update": {
-        if (Array.isArray(update["availableCommands"])) {
-          this._availableCommands = update["availableCommands"].map((cmd) => {
-            const altNames = readAvailableCommandAltNames(cmd);
-            return altNames ? { ...cmd, altNames } : cmd;
-          });
-        }
-        break;
-      }
-      default:
-        break;
-    }
-    this.emit("sessionUpdate", params);
-  }
-  ensureConnection() {
-    if (!this.connection || !this.isConnected) {
-      throw new Error("Not connected to ACP agent");
-    }
-    return this.connection;
+};
+function truncateGroupHistoryField(value) {
+  return value.slice(0, GROUP_HISTORY_ENTRY_METADATA_LIMIT);
+}
+__name(truncateGroupHistoryField, "truncateGroupHistoryField");
+function isPromiseLike(value) {
+  return value !== null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+}
+__name(isPromiseLike, "isPromiseLike");
+function isDebugPayloadEnabled(channelName) {
+  const raw = process.env[DEBUG_PAYLOAD_ENV]?.trim();
+  if (!raw)
+    return false;
+  if (["1", "true", "yes", "all", "*"].includes(raw.toLowerCase())) {
+    return true;
   }
-  requestPermission(request) {
-    const requestId = `acp-permission-${randomUUID2()}`;
-    const sessionId = typeof request.sessionId === "string" && request.sessionId.length > 0 ? request.sessionId : request.toolCall.toolCallId;
+  return raw.split(",").map((value) => value.trim()).filter(Boolean).includes(channelName);
+}
+__name(isDebugPayloadEnabled, "isDebugPayloadEnabled");
+function redactPayloadValue(key, value) {
+  if (!key)
+    return value;
+  return SENSITIVE_PAYLOAD_KEY_PATTERN.test(key) ? "[redacted]" : value;
+}
+__name(redactPayloadValue, "redactPayloadValue");
+function truncateLoopLabel(prompt) {
+  const chars = Array.from(prompt);
+  return chars.length > 60 ? `${chars.slice(0, 57).join("")}...` : prompt;
+}
+__name(truncateLoopLabel, "truncateLoopLabel");
+
+// packages/channels/base/dist/PollingChannelBase.js
+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) => {
-      const timeout = setTimeout(() => {
-        const pending = this.pendingPermissions.get(requestId);
-        if (!pending) {
-          return;
-        }
-        process.stderr.write(`[AcpBridge] permission request ${sanitizeLogText(requestId, 128)} timed out after ${ACP_PERMISSION_RESPONSE_TIMEOUT_MS}ms (session=${sanitizeLogText(pending.sessionId, 128)})
-`);
-        this.pendingPermissions.delete(requestId);
-        const response = {
-          outcome: { outcome: "cancelled" }
-        };
-        pending.resolve(response);
-        this.emit("permissionResolved", {
-          requestId,
-          outcome: response.outcome
-        });
-      }, ACP_PERMISSION_RESPONSE_TIMEOUT_MS);
-      timeout.unref?.();
-      this.pendingPermissions.set(requestId, { sessionId, resolve: resolve3, timeout });
-      this.emitResponseBoundary(sessionId);
-      this.emit("permissionRequest", {
-        requestId,
-        sessionId,
-        request
-      });
+      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 });
     });
   }
-  emitResponseBoundary(sessionId) {
-    this.emit("responseBoundary", sessionId);
+  constructor(name, config, bridge, options) {
+    super(name, config, bridge, options);
+    this.cursor = this.loadCursorFromDisk() ?? this.createInitialCursor();
   }
-  resolvePendingPermissions(sessionId) {
-    const response = {
-      outcome: { outcome: "cancelled" }
-    };
-    for (const [requestId, pending] of this.pendingPermissions) {
-      if (sessionId !== void 0 && pending.sessionId !== sessionId) {
-        continue;
-      }
-      clearTimeout(pending.timeout);
-      this.pendingPermissions.delete(requestId);
-      pending.resolve(response);
-      this.emit("permissionResolved", {
-        requestId,
-        outcome: response.outcome
-      });
-    }
+  validateCursor(parsed) {
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+      return null;
+    return parsed;
   }
-  maybeKillOnEventLoopStall(stderr) {
-    const match = ACP_EVENT_LOOP_STALL_RE.exec(stderr);
-    if (!match)
-      return;
-    const maxMs = Number(match[1]);
-    if (!Number.isFinite(maxMs) || maxMs < ACP_EVENT_LOOP_STALL_RESTART_MS) {
-      return;
-    }
-    const child = this.child;
-    if (!child || child.killed || child.exitCode !== null) {
-      return;
+  get pollInterval() {
+    const configured = this.config.pollInterval;
+    if (typeof configured === "number" && Number.isFinite(configured) && configured > 0) {
+      return configured;
     }
-    process.stderr.write(`[AcpBridge] ACP agent event loop stalled for ${Math.round(maxMs)}ms; killing child process to trigger restart
-`);
-    child.kill("SIGKILL");
+    return 6e4;
   }
-  async registerChannelLoopMcpServer() {
-    if (!this.connection || !this.channelLoopMcpServer || this.channelLoopMcpRegistered) {
-      return;
-    }
-    if (this.channelLoopMcpRegistration) {
-      await this.channelLoopMcpRegistration;
+  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.channelLoopMcpRegistration = this.connection.extMethod(WORKSPACE_MCP_RUNTIME_ADD_METHOD, {
-      name: CHANNEL_LOOP_MCP_SERVER_NAME,
-      originatorClientId: "channel",
-      config: {
-        type: "sdk",
-        [CLIENT_MCP_OVER_WS_CONFIG_FLAG]: true
-      }
-    }).then((result) => {
-      if (isSkippedMcpRegistration(result)) {
-        this.channelLoopMcpRegistered = false;
-        process.stderr.write(`[AcpBridge] Channel loop MCP server registration skipped${formatSkippedRegistrationReason(result)}
+    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}
 `);
-        return;
+        await this.abortableSleep(backoff);
+        continue;
       }
-      this.channelLoopMcpRegistered = true;
-    }).catch((error) => {
-      this.channelLoopMcpRegistered = false;
-      process.stderr.write(`[AcpBridge] Failed to register channel loop MCP server: ${error instanceof Error ? error.message : String(error)}
-`);
-    }).finally(() => {
-      this.channelLoopMcpRegistration = null;
-    });
-    await this.channelLoopMcpRegistration;
-  }
-  async handleExtMethod(method, params) {
-    if (method === CLIENT_MCP_MESSAGE_METHOD) {
-      return this.handleClientMcpMessage(params);
-    }
-    if (method === MID_TURN_QUEUE_DRAIN_METHOD) {
-      return { messages: [], 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
-      };
+      await this.abortableSleep(this.pollInterval);
     }
-    throw new Error(`Method not found: ${method}`);
   }
-  async handleClientMcpMessage(params) {
-    if (!this.channelLoopMcpServer) {
-      throw new Error("Channel loop MCP server is not registered.");
-    }
-    const server = params["server"];
-    if (server !== CHANNEL_LOOP_MCP_SERVER_NAME) {
-      throw new Error(`Unknown client MCP server: ${String(server)}`);
-    }
-    const payload = params["payload"];
-    if (typeof payload !== "object" || payload === null) {
-      throw new Error("Invalid client MCP payload.");
-    }
-    const sessionId = typeof params["sessionId"] === "string" ? params["sessionId"] : void 0;
-    const response = await this.channelLoopMcpServer.handleMessage(payload, { sessionId });
-    if (!response) {
-      return { payload: { jsonrpc: "2.0", id: 0, result: {} } };
+  loadCursorFromDisk() {
+    try {
+      const raw = readFileSync4(this.cursorPath(), "utf-8").trim();
+      if (!raw)
+        return null;
+      return this.validateCursor(JSON.parse(raw));
+    } catch {
+      return null;
     }
-    return { payload: response };
   }
-  resolveChannelLoopToolHandler(sessionId) {
-    if (this.channelLoopToolHandlers.length === 1 && !this.channelLoopToolHandlers[0].canHandle) {
-      return this.channelLoopToolHandlers[0];
-    }
-    const handler = this.channelLoopToolHandlers.find((candidate) => candidate.canHandle?.(sessionId) === true);
-    if (handler)
-      return handler;
-    throw new Error(this.channelLoopToolHandlers.length === 0 ? "No channel loop tool handler is registered." : `No channel loop handler matched session ${sessionId}.`);
+  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`);
   }
 };
-function isSkippedMcpRegistration(result) {
-  return typeof result === "object" && result !== null && result.skipped === true;
-}
-__name(isSkippedMcpRegistration, "isSkippedMcpRegistration");
-function formatSkippedRegistrationReason(result) {
-  if (typeof result !== "object" || result === null)
-    return ".";
-  const reason = result.reason;
-  return typeof reason === "string" && reason.length > 0 ? `: ${sanitizeLogText(reason, 256)}` : ".";
-}
-__name(formatSkippedRegistrationReason, "formatSkippedRegistrationReason");
 
 // packages/channels/base/dist/DaemonChannelBridge.js
 init_esbuild_shims();
@@ -7058,9 +7129,11 @@ __name(isTerminalTaskLifecycleType, "isTerminalTaskLifecycleType");
 export {
   resolvePath,
   getGlobalQwenDir,
+  getWorkspaceScopeDirName,
   ChannelProactiveDeliveryError,
   isChannelProactiveDeliveryError,
   PairingStore,
+  truncateCodePoints,
   sanitizeSenderName,
   sanitizePromptText,
   sanitizeLogText,
@@ -7069,6 +7142,7 @@ export {
   ChannelBase,
   PollingChannelBase,
   CHANNEL_LOOP_MCP_SERVER_NAME,
+  ACP_EVENT_LOOP_STALL_RESTART_MS,
   AcpBridge,
   DaemonChannelBridge,
   ChannelLoopStore,