@qwen-code/qwen-code 0.19.3-nightly.20260701.a974594d7 → 0.19.4

package/chunks/chunk-2JKEQWDZ.js

@@ -1,1596 +0,0 @@
-// Force strict mode and setup for ESM
-"use strict";
-import {
-  ClientSideConnection,
-  PROTOCOL_VERSION,
-  ndJsonStream
-} from "./chunk-UFC57OYT.js";
-import {
-  init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
-import {
-  __name
-} from "./chunk-J2S4EL5Y.js";
-
-// packages/channels/base/dist/paths.js
-init_esbuild_shims();
-import * as path from "node:path";
-import * as os from "node:os";
-function resolvePath(dir) {
-  let resolved = dir;
-  if (resolved === "~" || resolved.startsWith("~/") || resolved.startsWith("~\\")) {
-    const relativeSegments = resolved === "~" ? [] : resolved.slice(2).split(/[/\\]+/).filter(Boolean);
-    resolved = path.join(os.homedir(), ...relativeSegments);
-  }
-  if (!path.isAbsolute(resolved)) {
-    resolved = path.resolve(resolved);
-  }
-  return resolved;
-}
-__name(resolvePath, "resolvePath");
-function getGlobalQwenDir() {
-  const envDir = process.env["QWEN_HOME"];
-  if (envDir) {
-    return resolvePath(envDir);
-  }
-  const homeDir = os.homedir();
-  return homeDir ? path.join(homeDir, ".qwen") : path.join(os.tmpdir(), ".qwen");
-}
-__name(getGlobalQwenDir, "getGlobalQwenDir");
-
-// packages/channels/base/dist/SessionRouter.js
-init_esbuild_shims();
-import { existsSync, readFileSync, writeFileSync, unlinkSync } from "node:fs";
-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();
-  bridge;
-  defaultCwd;
-  defaultScope;
-  channelScopes = /* @__PURE__ */ new Map();
-  persistPath;
-  constructor(bridge, defaultCwd, scope = "user", persistPath) {
-    this.bridge = bridge;
-    this.defaultCwd = defaultCwd;
-    this.defaultScope = scope;
-    this.persistPath = persistPath;
-  }
-  /** 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);
-  }
-  routingKey(channelName, senderId, chatId, threadId) {
-    const scope = this.channelScopes.get(channelName) || this.defaultScope;
-    switch (scope) {
-      case "thread":
-        return `${channelName}:${threadId || chatId}`;
-      case "single":
-        return `${channelName}:__single__`;
-      case "user":
-      default:
-        return `${channelName}:${senderId}:${chatId}`;
-    }
-  }
-  async resolve(channelName, senderId, chatId, threadId, cwd) {
-    const key = this.routingKey(channelName, senderId, chatId, threadId);
-    let failedCreateWaits = 0;
-    for (; ; ) {
-      const existing = this.toSession.get(key);
-      if (existing) {
-        return existing;
-      }
-      const creating = this.creatingSessions.get(key);
-      if (creating) {
-        try {
-          return await creating;
-        } catch (err) {
-          if (this.creatingSessions.get(key) === creating) {
-            this.creatingSessions.delete(key);
-          }
-          failedCreateWaits++;
-          if (failedCreateWaits > 3) {
-            throw err;
-          }
-          continue;
-        }
-      }
-      const created = Promise.resolve().then(async () => {
-        const sessionCwd = cwd || this.defaultCwd;
-        const loadWindow = this.beginSessionLoad();
-        try {
-          const sessionId = await this.createLiveSession(sessionCwd, loadWindow, key);
-          this.toSession.set(key, sessionId);
-          this.toTarget.set(sessionId, {
-            channelName,
-            senderId,
-            chatId,
-            threadId
-          });
-          this.toCwd.set(sessionId, sessionCwd);
-          this.persist();
-          return sessionId;
-        } finally {
-          this.endSessionLoad(loadWindow);
-        }
-      });
-      this.creatingSessions.set(key, created);
-      try {
-        return await created;
-      } finally {
-        if (this.creatingSessions.get(key) === created) {
-          this.creatingSessions.delete(key);
-        }
-      }
-    }
-  }
-  getTarget(sessionId) {
-    return this.toTarget.get(sessionId);
-  }
-  getSession(channelName, senderId, chatId, threadId) {
-    return this.toSession.get(this.routingKey(channelName, senderId, chatId, threadId));
-  }
-  hasSession(channelName, senderId, chatId, threadId) {
-    if (chatId) {
-      return this.toSession.has(this.routingKey(channelName, senderId, chatId, threadId));
-    }
-    for (const target of this.toTarget.values()) {
-      if (target.channelName === channelName && target.senderId === senderId) {
-        return true;
-      }
-    }
-    return false;
-  }
-  /**
-   * Remove session(s) for the given sender. Returns the removed session IDs.
-   */
-  removeSession(channelName, senderId, chatId, threadId) {
-    const removedIds = [];
-    if (chatId) {
-      const key = this.routingKey(channelName, senderId, chatId, threadId);
-      const sessionId = this.deleteByKey(key);
-      if (sessionId)
-        removedIds.push(sessionId);
-    } else {
-      for (const [k, mappedSessionId] of [...this.toSession.entries()]) {
-        const target = this.toTarget.get(mappedSessionId);
-        if (target?.channelName === channelName && target.senderId === senderId) {
-          const sessionId = this.deleteByKey(k);
-          if (sessionId)
-            removedIds.push(sessionId);
-        }
-      }
-    }
-    if (removedIds.length > 0)
-      this.persist();
-    return removedIds;
-  }
-  /** 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.toSession.delete(key);
-        removed = true;
-      }
-    }
-    if (this.toTarget.delete(sessionId)) {
-      removed = true;
-    }
-    if (this.toCwd.delete(sessionId)) {
-      removed = true;
-    }
-    if (!removed && this.sessionLoadWindows.size > 0) {
-      for (const loadWindow of this.sessionLoadWindows) {
-        loadWindow.add(sessionId);
-      }
-    }
-    if (removed) {
-      this.persist();
-    }
-    return removed;
-  }
-  deleteByKey(key) {
-    const sessionId = this.toSession.get(key);
-    if (!sessionId)
-      return null;
-    this.toSession.delete(key);
-    this.toTarget.delete(sessionId);
-    this.toCwd.delete(sessionId);
-    return sessionId;
-  }
-  /** 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;
-  }
-  /**
-   * 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() {
-    if (!this.persistPath || !existsSync(this.persistPath)) {
-      return { restored: 0, failed: 0 };
-    }
-    let entries;
-    try {
-      entries = JSON.parse(readFileSync(this.persistPath, "utf-8"));
-    } catch {
-      return { restored: 0, failed: 0 };
-    }
-    let restored = 0;
-    let failed = 0;
-    let changed = false;
-    const reservations = /* @__PURE__ */ new Map();
-    for (const key of Object.keys(entries)) {
-      this.deleteByKey(key);
-      const reservation = this.createSessionReservation();
-      reservation.promise.catch(() => void 0);
-      this.creatingSessions.set(key, reservation.promise);
-      reservations.set(key, reservation);
-    }
-    const loadWindow = this.beginSessionLoad();
-    try {
-      for (const [key, entry] of Object.entries(entries)) {
-        const reservation = reservations.get(key);
-        if (!reservation)
-          continue;
-        try {
-          const sessionId = await this.bridge.loadSession(entry.sessionId, entry.cwd);
-          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 ${entry.sessionId} for key ${key}: ${reason}
-`);
-          reservation.reject(new Error("Session restore failed", { cause: err }));
-          failed++;
-          changed = true;
-        } finally {
-          if (this.creatingSessions.get(key) === reservation.promise) {
-            this.creatingSessions.delete(key);
-          }
-        }
-      }
-    } finally {
-      this.endSessionLoad(loadWindow);
-    }
-    if (changed) {
-      this.persist();
-    }
-    return { restored, failed };
-  }
-  /** Clear in-memory state and delete persist file. Used on clean shutdown. */
-  clearAll() {
-    this.toSession.clear();
-    this.toTarget.clear();
-    this.toCwd.clear();
-    this.creatingSessions.clear();
-    this.sessionLoadWindows.clear();
-    if (this.persistPath && existsSync(this.persistPath)) {
-      try {
-        unlinkSync(this.persistPath);
-      } catch {
-      }
-    }
-  }
-  persist() {
-    if (!this.persistPath)
-      return;
-    const data = {};
-    for (const [key, sessionId] of this.toSession) {
-      const target = this.toTarget.get(sessionId);
-      if (target) {
-        data[key] = {
-          sessionId,
-          target,
-          cwd: this.toCwd.get(sessionId) || this.defaultCwd
-        };
-      }
-    }
-    try {
-      writeFileSync(this.persistPath, JSON.stringify(data, null, 2), "utf-8");
-    } catch {
-    }
-  }
-  async createLiveSession(cwd, loadWindow, routingKey) {
-    const maxAttempts = 2;
-    let lastDeadSessionId;
-    for (let attempt = 0; attempt < maxAttempts; attempt++) {
-      const sessionId = await this.bridge.newSession(cwd);
-      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;
-  }
-  createSessionReservation() {
-    let resolveReservation;
-    let rejectReservation;
-    const promise = new Promise((resolve2, reject) => {
-      resolveReservation = resolve2;
-      rejectReservation = reject;
-    });
-    return {
-      promise,
-      resolve: resolveReservation,
-      reject: rejectReservation
-    };
-  }
-  endSessionLoad(loadWindow) {
-    this.sessionLoadWindows.delete(loadWindow);
-  }
-};
-
-// packages/channels/base/dist/sanitize.js
-init_esbuild_shims();
-var PROMPT_UNSAFE_INVISIBLES = /[\u0080-\u009f\u200b-\u200d\u2028\u2029\u202a-\u202e\u2060\u2066-\u2069\ufeff]/g;
-function truncateCodePoints(str, max) {
-  const cp = Array.from(str);
-  return cp.length > max ? cp.slice(0, max).join("") : str;
-}
-__name(truncateCodePoints, "truncateCodePoints");
-function sanitizeSenderName(name) {
-  const cleaned = name.replace(PROMPT_UNSAFE_INVISIBLES, " ").replace(/[\u0000-\u001f\u007f]/g, " ").replace(/[[\]\r\n]/g, " ");
-  return truncateCodePoints(cleaned, 64).trim() || "unknown";
-}
-__name(sanitizeSenderName, "sanitizeSenderName");
-function sanitizeQuotedText(text, maxLen) {
-  const cleaned = text.replace(PROMPT_UNSAFE_INVISIBLES, " ").replace(/[\u0000-\u001f\u007f]/g, " ").replace(/["[\]]/g, " ");
-  const cp = Array.from(cleaned);
-  return cp.length > maxLen ? cp.slice(0, maxLen - 1).join("") + "\u2026" : cleaned;
-}
-__name(sanitizeQuotedText, "sanitizeQuotedText");
-function sanitizePromptText(text) {
-  return text.replace(PROMPT_UNSAFE_INVISIBLES, " ").replace(/^([ \t]*)\[([^\]\r\n]{1,64})\](:?)/gm, "$1$2$3").replace(/[\u0000-\u001f\u007f]/g, " ");
-}
-__name(sanitizePromptText, "sanitizePromptText");
-function sanitizePromptPath(path3) {
-  const cleaned = path3.replace(PROMPT_UNSAFE_INVISIBLES, " ").replace(/[\u0000-\u001f\u007f]/g, " ");
-  return truncateCodePoints(cleaned, 1024);
-}
-__name(sanitizePromptPath, "sanitizePromptPath");
-function sanitizeLogText(text, maxLen) {
-  return truncateCodePoints(text, maxLen).replace(/\n/g, "\\n").replace(PROMPT_UNSAFE_INVISIBLES, " ").replace(/[\u0000-\u001f\u007f]/g, " ");
-}
-__name(sanitizeLogText, "sanitizeLogText");
-
-// packages/channels/base/dist/ChannelBase.js
-init_esbuild_shims();
-import { basename } from "node:path";
-
-// packages/channels/base/dist/BlockStreamer.js
-init_esbuild_shims();
-var BlockStreamer = class {
-  static {
-    __name(this, "BlockStreamer");
-  }
-  buffer = "";
-  idleTimer = null;
-  sending = Promise.resolve();
-  opts;
-  /** Number of blocks emitted so far. */
-  blockCount = 0;
-  constructor(opts) {
-    this.opts = opts;
-  }
-  /** 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);
-    }
-  }
-  /** 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;
-  }
-  /** 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);
-      }
-    }
-  }
-  onIdle() {
-    this.idleTimer = null;
-    if (this.buffer.length >= this.opts.minChars) {
-      this.emitBlock(this.buffer);
-      this.buffer = "";
-    }
-  }
-  emitBlock(text) {
-    const trimmed = text.trim();
-    if (!trimmed)
-      return;
-    this.blockCount++;
-    this.sending = this.sending.then(() => this.opts.send(trimmed)).catch(() => {
-    });
-  }
-  /**
-   * 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;
-    }
-  }
-};
-
-// packages/channels/base/dist/GroupGate.js
-init_esbuild_shims();
-var GroupGate = class {
-  static {
-    __name(this, "GroupGate");
-  }
-  policy;
-  groups;
-  constructor(policy = "disabled", groups = {}) {
-    this.policy = policy;
-    this.groups = groups;
-  }
-  /**
-   * 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" };
-      }
-    }
-    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 };
-  }
-};
-
-// 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;
-  }
-  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/PairingStore.js
-init_esbuild_shims();
-import * as crypto from "node:crypto";
-import * as fs from "node:fs";
-import * as path2 from "node:path";
-var SAFE_ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
-var CODE_LENGTH = 8;
-var EXPIRY_MS = 60 * 60 * 1e3;
-var MAX_PENDING = 3;
-var PairingStore = class {
-  static {
-    __name(this, "PairingStore");
-  }
-  dir;
-  pendingPath;
-  allowlistPath;
-  constructor(channelName) {
-    this.dir = path2.join(getGlobalQwenDir(), "channels");
-    this.pendingPath = path2.join(this.dir, `${channelName}-pairing.json`);
-    this.allowlistPath = path2.join(this.dir, `${channelName}-allowlist.json`);
-  }
-  isApproved(senderId) {
-    const list = this.readAllowlist();
-    return list.includes(senderId);
-  }
-  /**
-   * Create a pairing request for an unknown sender.
-   * Returns the code if created, or null if the pending cap is reached.
-   * If the sender already has a non-expired pending request, returns that code.
-   */
-  createRequest(senderId, senderName) {
-    const pending = this.readPending();
-    const now = Date.now();
-    const active = pending.filter((r) => now - r.createdAt < EXPIRY_MS);
-    const existing = active.find((r) => r.senderId === senderId);
-    if (existing) {
-      return existing.code;
-    }
-    if (active.length >= MAX_PENDING) {
-      return null;
-    }
-    const code = generateCode();
-    active.push({ senderId, senderName, code, createdAt: now });
-    this.writePending(active);
-    return code;
-  }
-  /**
-   * Approve a pairing request by code.
-   * Returns the sender ID if found, or null if not found / expired.
-   */
-  approve(code) {
-    const pending = this.readPending();
-    const now = Date.now();
-    const idx = pending.findIndex((r) => r.code === code.toUpperCase() && now - r.createdAt < EXPIRY_MS);
-    if (idx === -1)
-      return null;
-    const request = pending[idx];
-    pending.splice(idx, 1);
-    this.writePending(pending);
-    const list = this.readAllowlist();
-    if (!list.includes(request.senderId)) {
-      list.push(request.senderId);
-      this.writeAllowlist(list);
-    }
-    return request;
-  }
-  listPending() {
-    const pending = this.readPending();
-    const now = Date.now();
-    return pending.filter((r) => now - r.createdAt < EXPIRY_MS);
-  }
-  getAllowlist() {
-    return this.readAllowlist();
-  }
-  ensureDir() {
-    if (!fs.existsSync(this.dir)) {
-      fs.mkdirSync(this.dir, { recursive: true });
-    }
-  }
-  readPending() {
-    try {
-      const data = fs.readFileSync(this.pendingPath, "utf-8");
-      return JSON.parse(data);
-    } catch {
-      return [];
-    }
-  }
-  writePending(requests) {
-    this.ensureDir();
-    fs.writeFileSync(this.pendingPath, JSON.stringify(requests, null, 2));
-  }
-  readAllowlist() {
-    try {
-      const data = fs.readFileSync(this.allowlistPath, "utf-8");
-      return JSON.parse(data);
-    } catch {
-      return [];
-    }
-  }
-  writeAllowlist(list) {
-    this.ensureDir();
-    fs.writeFileSync(this.allowlistPath, JSON.stringify(list, null, 2));
-  }
-};
-function generateCode() {
-  let code = "";
-  for (let i = 0; i < CODE_LENGTH; i++) {
-    code += SAFE_ALPHABET[crypto.randomInt(SAFE_ALPHABET.length)];
-  }
-  return code;
-}
-__name(generateCode, "generateCode");
-
-// packages/channels/base/dist/ChannelBase.js
-var CLEAR_CANCEL_TIMEOUT_MS = 3e3;
-var COMMAND_TOKEN_CHARS = "a-zA-Z0-9_:-";
-var PARSE_COMMAND_RE = new RegExp(`^\\/([${COMMAND_TOKEN_CHARS}]+)(?:@\\S+)?\\s*(.*)`, "s");
-var COMMAND_TOKEN_RE = new RegExp(`^[${COMMAND_TOKEN_CHARS}]+(?:@\\S+)?$`);
-var ChannelBase = class {
-  static {
-    __name(this, "ChannelBase");
-  }
-  config;
-  bridge;
-  groupGate;
-  gate;
-  router;
-  name;
-  /** Resolved proxy URL, available to subclasses for adapter-specific clients. */
-  proxy;
-  instructedSessions = /* @__PURE__ */ new Set();
-  commands = /* @__PURE__ */ new Map();
-  /** Per-session promise chain to serialize prompt + send (followup mode). */
-  sessionQueues = /* @__PURE__ */ new Map();
-  registerBridgeEvents;
-  /**
-   * 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,
-   * so a cleared session can't be resurrected by an already-queued prompt.
-   */
-  sessionGenerations = /* @__PURE__ */ new Map();
-  /** Per-session active prompt tracking for dispatch modes. */
-  activePrompts = /* @__PURE__ */ new Map();
-  /** Per-session message buffer for collect mode. */
-  collectBuffers = /* @__PURE__ */ new Map();
-  bridgeToolCallListener = /* @__PURE__ */ __name((event) => {
-    const target = this.router.getTarget(event.sessionId);
-    if (target) {
-      this.onToolCall(target.chatId, event);
-    }
-  }, "bridgeToolCallListener");
-  bridgeSessionDiedListener = /* @__PURE__ */ __name((event) => {
-    this.onSessionDied(event.sessionId);
-  }, "bridgeSessionDiedListener");
-  constructor(name, config, bridge, options) {
-    this.name = name;
-    this.config = config;
-    this.bridge = bridge;
-    this.proxy = options?.proxy;
-    this.groupGate = new GroupGate(config.groupPolicy, config.groups);
-    const pairingStore = config.senderPolicy === "pairing" ? new PairingStore(name) : void 0;
-    this.gate = new SenderGate(config.senderPolicy, config.allowedUsers, pairingStore);
-    this.router = options?.router || new SessionRouter(bridge, config.cwd, config.sessionScope);
-    this.registerSharedCommands();
-    this.registerBridgeEvents = options?.registerBridgeEvents ?? !options?.router;
-    if (this.registerBridgeEvents) {
-      this.attachBridgeEvents(bridge);
-    }
-  }
-  /** Replace the bridge instance (used after crash recovery restart). */
-  setBridge(bridge) {
-    if (this.registerBridgeEvents) {
-      this.detachBridgeEvents(this.bridge);
-    }
-    this.router.setBridge(bridge);
-    this.bridge = bridge;
-    if (this.registerBridgeEvents) {
-      this.attachBridgeEvents(bridge);
-    }
-  }
-  onToolCall(_chatId, _event) {
-  }
-  onSessionDied(sessionId) {
-    this.router.removeSessionId(sessionId);
-    this.instructedSessions.delete(sessionId);
-  }
-  attachBridgeEvents(bridge) {
-    bridge.on("toolCall", this.bridgeToolCallListener);
-    bridge.on("sessionDied", this.bridgeSessionDiedListener);
-  }
-  detachBridgeEvents(bridge) {
-    bridge.off("toolCall", this.bridgeToolCallListener);
-    bridge.off("sessionDied", this.bridgeSessionDiedListener);
-  }
-  /**
-   * Called when a prompt actually begins processing (inside the session queue).
-   * Override to show a platform-specific working indicator (e.g., typing, reaction).
-   * Not called for buffered messages (collect mode) or gated/blocked messages.
-   */
-  onPromptStart(_chatId, _sessionId, _messageId) {
-  }
-  /**
-   * Called when a prompt finishes (response sent or cancelled).
-   * Override to hide the working indicator.
-   */
-  onPromptEnd(_chatId, _sessionId, _messageId) {
-  }
-  /**
-   * Called for each text chunk as the agent streams its response.
-   * Override to implement progressive display (e.g., updating an AI card in-place).
-   * Default: no-op (chunks are collected internally and delivered via onResponseComplete).
-   */
-  onResponseChunk(_chatId, _chunk, _sessionId) {
-  }
-  /**
-   * Called when the agent's full response is ready.
-   * Override to customize delivery (e.g., finalize an AI card).
-   * Default: calls sendMessage() with the full response text.
-   */
-  async onResponseComplete(chatId, fullText, _sessionId) {
-    await this.sendMessage(chatId, fullText);
-  }
-  /**
-   * Register a slash command handler. Subclasses can call this to add
-   * platform-specific commands (e.g., /start for Telegram).
-   * Overrides shared commands if the same name is registered.
-   */
-  registerCommand(name, handler) {
-    this.commands.set(name.toLowerCase(), handler);
-  }
-  registerCancelCommand(name = "cancel") {
-    this.registerCommand(name, async (envelope) => {
-      if (!this.isAuthorizedForSharedSession(envelope)) {
-        await this.sendMessage(envelope.chatId, "Only authorized members can cancel requests in this shared session.");
-        return true;
-      }
-      const activeSessionId = this.findActiveSessionId(envelope);
-      if (!activeSessionId) {
-        await this.sendMessage(envelope.chatId, "No request is currently running.");
-        return true;
-      }
-      const active = this.activePrompts.get(activeSessionId);
-      if (!active) {
-        await this.sendMessage(envelope.chatId, "No request is currently running.");
-        return true;
-      }
-      const cancelRequested = active.cancelRequested ?? this.bridge.cancelSession(activeSessionId).then(() => true, (err) => {
-        process.stderr.write(`[${this.name}] cancelSession failed for session=${activeSessionId}: ${err instanceof Error ? err.message : err}
-`);
-        active.cancelRequested = void 0;
-        return false;
-      });
-      active.cancelRequested = cancelRequested;
-      const cancelSucceeded = await cancelRequested;
-      if (!cancelSucceeded) {
-        await this.sendMessage(envelope.chatId, "Failed to cancel current request.");
-        return true;
-      }
-      active.cancelled = true;
-      active.stopStreaming?.();
-      this.collectBuffers.delete(activeSessionId);
-      await this.sendMessage(envelope.chatId, "Cancelled current request.");
-      return true;
-    });
-  }
-  /** Register shared slash commands. Called from constructor. */
-  registerSharedCommands() {
-    const doClear = /* @__PURE__ */ __name(async (envelope) => {
-      const removedIds = this.router.removeSession(this.name, envelope.senderId, envelope.chatId, envelope.threadId);
-      if (removedIds.length > 0) {
-        for (const id of removedIds) {
-          if (this.isSharedSession(envelope)) {
-            const who = sanitizeSenderName(envelope.senderName || envelope.senderId || "unknown");
-            process.stderr.write(`[${this.name}] shared session ${id} cleared by ${who} (sender ${envelope.senderId})
-`);
-          }
-          this.sessionGenerations.set(id, (this.sessionGenerations.get(id) ?? 0) + 1);
-          const active = this.activePrompts.get(id);
-          this.collectBuffers.delete(id);
-          if (active) {
-            const settled = await this.cancelAndAwaitActive(active, id);
-            if (!settled) {
-              const wedgedChat = active.chatId ? sanitizeLogText(active.chatId, 64) : "unknown";
-              const wedgedMessage = active.messageId ? `, message ${sanitizeLogText(active.messageId, 64)}` : "";
-              process.stderr.write(`[${this.name}] /clear abandoned a wedged turn for session ${id} (chat ${wedgedChat}${wedgedMessage}): it did not wind down within ${CLEAR_CANCEL_TIMEOUT_MS}ms
-`);
-              active.clearEvicted = true;
-              try {
-                this.onPromptEnd(active.chatId, id, active.messageId);
-              } catch (err) {
-                process.stderr.write(`[${this.name}] onPromptEnd threw during /clear eviction for session ${id}: ${err instanceof Error ? err.message : err}
-`);
-              }
-            }
-          }
-          this.instructedSessions.delete(id);
-          const drained = this.sessionQueues.get(id);
-          const bumpedGeneration = this.sessionGenerations.get(id);
-          this.sessionQueues.delete(id);
-          this.activePrompts.delete(id);
-          if (drained) {
-            void drained.then(() => {
-              if (!this.sessionQueues.has(id) && this.sessionGenerations.get(id) === bumpedGeneration) {
-                this.sessionGenerations.delete(id);
-              }
-            });
-          } else {
-            this.sessionGenerations.delete(id);
-          }
-        }
-        await this.sendMessage(envelope.chatId, "Session cleared. The next message starts a fresh conversation.");
-      } else {
-        await this.sendMessage(envelope.chatId, "No active session to clear.");
-      }
-    }, "doClear");
-    const clearHandler = /* @__PURE__ */ __name(async (envelope, args) => {
-      if (!this.isAuthorizedForSharedSession(envelope)) {
-        await this.sendMessage(envelope.chatId, "Only authorized members can clear this shared session.");
-        return true;
-      }
-      if (this.isSharedSession(envelope) && args.toLowerCase() !== "confirm") {
-        await this.sendMessage(envelope.chatId, 'This clears the shared session for everyone who shares it. Re-send with "confirm" (e.g. /clear confirm) to proceed.');
-        return true;
-      }
-      await doClear(envelope);
-      return true;
-    }, "clearHandler");
-    this.registerCommand("clear", clearHandler);
-    this.registerCommand("reset", clearHandler);
-    this.registerCommand("new", clearHandler);
-    this.registerCommand("who", async (envelope) => {
-      if (!this.isAuthorizedForSharedSession(envelope)) {
-        await this.sendMessage(envelope.chatId, "Only authorized members can view this shared session.");
-        return true;
-      }
-      const active = this.router.hasSession(this.name, envelope.senderId, envelope.chatId, envelope.threadId);
-      const scopeNote = this.config.sessionScope === "single" ? " (shared channel-wide)" : this.isSharedSession(envelope) ? envelope.isGroup ? " (shared by this group)" : "" : envelope.isGroup ? " (private to you)" : "";
-      await this.sendMessage(envelope.chatId, [
-        `Channel: ${this.name}`,
-        // Only the basename — don't leak the absolute cwd to group members.
-        `Workspace: ${basename(this.config.cwd)}`,
-        `Session: ${active ? "active" : "none"}${scopeNote}`
-      ].join("\n"));
-      return true;
-    });
-    this.registerCommand("help", async (envelope) => {
-      const lines = [
-        "Commands:",
-        "/help \u2014 Show this help",
-        this.isSharedSession(envelope) ? "/clear confirm \u2014 Clear the shared session (aliases: /reset, /new)" : "/clear \u2014 Clear your session (aliases: /reset, /new)",
-        "/who \u2014 Show current session & workspace",
-        "/status \u2014 Show session info"
-      ];
-      const sharedCmds = /* @__PURE__ */ new Set([
-        "help",
-        "clear",
-        "reset",
-        "new",
-        "who",
-        "status"
-      ]);
-      const platformCmds = [...this.commands.keys()].filter((c) => !sharedCmds.has(c));
-      if (platformCmds.length > 0) {
-        for (const cmd of platformCmds) {
-          lines.push(`/${cmd}`);
-        }
-      }
-      const sessionId = this.router.getSession(this.name, envelope.senderId, envelope.chatId, envelope.threadId);
-      const agentCommands = sessionId ? this.getAgentCommandsForSession(sessionId) : this.bridge.availableCommands;
-      if (agentCommands.length > 0) {
-        lines.push("", "Agent commands (forwarded to Qwen Code):");
-        for (const cmd of agentCommands) {
-          lines.push(`/${cmd.name} \u2014 ${cmd.description}`);
-        }
-      }
-      lines.push("", "Send any text to chat with the agent.");
-      await this.sendMessage(envelope.chatId, lines.join("\n"));
-      return true;
-    });
-    this.registerCommand("status", async (envelope) => {
-      if (!this.isAuthorizedForSharedSession(envelope)) {
-        await this.sendMessage(envelope.chatId, "Only authorized members can view this shared session.");
-        return true;
-      }
-      const hasSession = this.router.hasSession(this.name, envelope.senderId, envelope.chatId, envelope.threadId);
-      const policy = this.config.senderPolicy;
-      const lines = [
-        `Session: ${hasSession ? "active" : "none"}`,
-        `Access: ${policy}`,
-        `Channel: ${this.name}`
-      ];
-      await this.sendMessage(envelope.chatId, lines.join("\n"));
-      return true;
-    });
-  }
-  /** Check if a message text matches a registered local command. */
-  isLocalCommand(text) {
-    const parsed = this.parseCommand(text);
-    return parsed !== null && this.commands.has(parsed.command);
-  }
-  findActiveSessionId(envelope) {
-    const sessionId = this.router.getSession(this.name, envelope.senderId, envelope.chatId, envelope.threadId);
-    return sessionId && this.activePrompts.has(sessionId) ? sessionId : void 0;
-  }
-  /**
-   * Whether the resolved session is SHARED across senders. `single` collapses
-   * the whole channel to one `__single__` session for EVERY sender — group OR
-   * DM — so it is ALWAYS shared (even a DM maps to `__single__`). `thread` is
-   * shared only in a group (a DM maps to the lone caller's own chat). `user` is
-   * per-sender, never shared. Drives both the destructive-/clear confirm gate
-   * and the host-shell (`!`) gate.
-   */
-  isSharedSession(envelope) {
-    return this.config.sessionScope === "single" || envelope.isGroup && this.config.sessionScope === "thread";
-  }
-  /**
-   * Whether `envelope.senderId` may act on the resolved session's destructive or
-   * workspace-leaking commands (/clear, /who). A SHARED session with a non-empty
-   * allowedUsers list is restricted to those members; a per-user session, or one
-   * with no allowlist, is unrestricted. Shared verbatim by /clear and /who so the
-   * gate can't drift; each caller sends its own rejection wording.
-   */
-  isAuthorizedForSharedSession(envelope) {
-    if (!this.isSharedSession(envelope))
-      return true;
-    const authorized = this.config.allowedUsers;
-    return authorized.length === 0 || authorized.includes(envelope.senderId);
-  }
-  stopActiveStreaming(active, sessionId, reason) {
-    try {
-      active.stopStreaming?.();
-    } catch (err) {
-      process.stderr.write(`[${this.name}] stopStreaming threw during ${reason} for session ${sessionId}: ${err instanceof Error ? err.message : err}
-`);
-    }
-  }
-  /**
-   * Cancel the active turn and wait (bounded) for it to wind down. Stops the
-   * BlockStreamer so buffered text can't leak via the idle timer, then fires a
-   * best-effort cancelSession (NOT awaited — a wedged child/daemon can leave the
-   * request pending forever). Returns true if active.done settled first, false
-   * if the CLEAR_CANCEL_TIMEOUT_MS bound won (the turn never wound down). Used by
-   * /clear, which genuinely EVICTS the session and so must proceed even when the
-   * turn is wedged. Steer no longer uses this: it best-effort cancels then chains
-   * the new turn behind the old one (see handleInbound), so it never needs to
-   * proceed past a still-active turn.
-   */
-  async cancelAndAwaitActive(active, sessionId) {
-    active.cancelled = true;
-    this.stopActiveStreaming(active, sessionId, "cancel");
-    void this.bridge.cancelSession(sessionId).catch((err) => {
-      process.stderr.write(`[${this.name}] cancelSession failed for session=${sessionId} (clear/await): ${err instanceof Error ? err.message : err}
-`);
-    });
-    let timer;
-    const settled = await Promise.race([
-      active.done.then(() => true),
-      new Promise((resolve2) => {
-        timer = setTimeout(() => resolve2(false), CLEAR_CANCEL_TIMEOUT_MS);
-      })
-    ]);
-    clearTimeout(timer);
-    return settled;
-  }
-  /**
-   * Parse a slash command from message text.
-   * Returns { command, raw, args } or null if not a slash command. `command` is
-   * lowercased for case-insensitive LOCAL dispatch (registerCommand lowercases the
-   * names it stores); `raw` keeps the typed case so agent-command matching can be
-   * CASE-SENSITIVE, mirroring the CLI's parseSlashCommand (`cmd.name === part`).
-   */
-  parseCommand(text) {
-    const trimmed = text.trim();
-    if (!trimmed.startsWith("/"))
-      return null;
-    const match = trimmed.match(PARSE_COMMAND_RE);
-    if (!match)
-      return null;
-    return {
-      command: match[1].toLowerCase(),
-      raw: match[1],
-      args: match[2].trim()
-    };
-  }
-  /**
-   * Whether `text` is a real slash command rather than prose that merely starts
-   * with `/`. A command's first whitespace-delimited token must match
-   * parseCommand()'s charset — `[a-zA-Z0-9_:-]+`, plus an optional `@botname`
-   * suffix — and not be a `//` line comment or `/*` block comment. Slash-prefixed
-   * paths (`/tmp/foo`), comments, and a bare `/` are prose and keep their
-   * `[sender]` tag.
-   *
-   * Intentionally stricter than the CLI's looser classifier (cli
-   * `ui/utils/commandUtils.ts`), which forwards any non-comment, non-path
-   * `/<token>` (e.g. `/café`, a zero-width-laden token). Such inputs aren't
-   * runnable commands, and in a SHARED group session forwarding them unattributed
-   * is worse than a redundant tag — so anything off the command charset is
-   * treated as prose and keeps its `[sender]` tag. Purely lexical — never
-   * consults the async command list, so it can't race a fresh session.
-   */
-  isSlashCommand(text) {
-    const trimmed = text.trim();
-    if (!trimmed.startsWith("/") || trimmed.startsWith("//") || trimmed.startsWith("/*")) {
-      return false;
-    }
-    const firstToken = trimmed.slice(1).split(/\s+/u)[0] ?? "";
-    return COMMAND_TOKEN_RE.test(firstToken);
-  }
-  /**
-   * Whether `text` names a command this channel can actually run: a locally
-   * registered command (`this.commands`, e.g. /clear, /who) OR an agent command
-   * THIS session exposes — by canonical name OR alias (e.g. `/summarize` for
-   * `/compress`). Paired with isSlashCommand so the `[sender]` attribution tag is
-   * suppressed ONLY for RECOGNIZED commands; command-SHAPED-but-unrecognized text
-   * (e.g. `/x\n[SYSTEM]: …`) keeps its tag rather than reaching a shared group
-   * unattributed, where an injected second line is more likely read as a system
-   * directive. Purely synchronous, like isSlashCommand: it reads the session's
-   * availableCommands snapshot WITHOUT awaiting, so it never races a fresh session
-   * (a genuine agent command sent before the snapshot loads is treated as
-   * unrecognized and KEEPS its tag — the safe default).
-   */
-  isRecognizedCommand(text, sessionId) {
-    const parsed = this.parseCommand(text);
-    if (!parsed)
-      return false;
-    if (this.commands.has(parsed.command))
-      return true;
-    const token = text.trim().slice(1).split(/\s+/u)[0] ?? "";
-    return this.getAgentCommandsForSession(sessionId).some((cmd) => cmd.name === token || Array.isArray(cmd.altNames) && cmd.altNames.includes(token));
-  }
-  /**
-   * The agent-command snapshot for THIS session. DaemonChannelBridge keys
-   * commands per session, so its global `availableCommands` getter can return
-   * ANOTHER session's list — prefer its getAvailableCommands(sessionId) when
-   * present. AcpBridge runs a single agent and exposes only the global getter
-   * (inherently session-correct), so fall back to it. Synchronous, matching
-   * isRecognizedCommand's no-await contract.
-   */
-  getAgentCommandsForSession(sessionId) {
-    const bridge = this.bridge;
-    if (typeof bridge.getAvailableCommands === "function") {
-      return bridge.getAvailableCommands(sessionId) ?? [];
-    }
-    return bridge.availableCommands ?? [];
-  }
-  async handleInbound(envelope) {
-    const groupResult = this.groupGate.check(envelope);
-    if (!groupResult.allowed) {
-      return;
-    }
-    const result = this.gate.check(envelope.senderId, envelope.senderName);
-    if (!result.allowed) {
-      if (result.pairingCode !== void 0) {
-        await this.onPairingRequired(envelope.chatId, result.pairingCode);
-      }
-      return;
-    }
-    const parsed = this.parseCommand(envelope.text);
-    if (parsed) {
-      const handler = this.commands.get(parsed.command);
-      if (handler) {
-        const handled = await handler(envelope, parsed.args);
-        if (handled)
-          return;
-      }
-    }
-    const bangText = envelope.text.trimStart();
-    if (bangText.startsWith("!")) {
-      if (envelope.isGroup || this.isSharedSession(envelope)) {
-        const who = sanitizeSenderName(envelope.senderName || envelope.senderId || "unknown");
-        process.stderr.write(`[${this.name}] blocked ! shell command from ${who} (sender ${envelope.senderId}) in chat ${sanitizeLogText(envelope.chatId, 64)}
-`);
-      }
-      if (envelope.isGroup) {
-        await this.sendMessage(envelope.chatId, "Shell commands (`!`) are disabled in group chats.");
-        return;
-      }
-      if (this.isSharedSession(envelope)) {
-        await this.sendMessage(envelope.chatId, "Shell commands (`!`) are disabled in shared sessions.");
-        return;
-      }
-    }
-    const sessionId = await this.router.resolve(this.name, envelope.senderId, envelope.chatId, envelope.threadId, this.config.cwd);
-    if (bangText.startsWith("!")) {
-      const cmd = bangText.slice(1).trim();
-      const bridgeShellCommand = this.bridge.shellCommand;
-      if (cmd && bridgeShellCommand) {
-        try {
-          const result2 = await this.bridge.shellCommand(sessionId, cmd);
-          const longestRun = Math.max(0, ...Array.from((result2.output || "").matchAll(/`+/g), (m) => m[0].length));
-          const fence = "`".repeat(Math.max(3, longestRun + 1));
-          const output = result2.output ? `${fence}
-${result2.output}
-${fence}` : "(no output)";
-          const exitLine = result2.exitCode !== null && result2.exitCode !== 0 ? `
-Exit code: ${result2.exitCode}` : "";
-          await this.sendMessage(envelope.chatId, `$ ${cmd}
-${output}${exitLine}`);
-        } catch (error) {
-          await this.sendMessage(envelope.chatId, `Shell command failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        return;
-      }
-    }
-    let promptText = envelope.text;
-    if ((envelope.isGroup || this.config.sessionScope === "single") && !envelope.alreadyPrefixed && !(this.isSlashCommand(envelope.text) && this.isRecognizedCommand(envelope.text, sessionId))) {
-      const who = sanitizeSenderName(envelope.senderName || envelope.senderId || "unknown");
-      promptText = `[${who}] ${sanitizePromptText(promptText)}`;
-    }
-    if (envelope.referencedText) {
-      const quoted = sanitizeQuotedText(envelope.referencedText, 500);
-      promptText = `[Replying to: "${quoted}"]
-
-${promptText}`;
-    }
-    let imageBase64 = envelope.imageBase64;
-    let imageMimeType = envelope.imageMimeType;
-    if (envelope.attachments?.length) {
-      const filePaths = [];
-      for (const att of envelope.attachments) {
-        if (att.type === "image" && att.data && !imageBase64) {
-          imageBase64 = att.data;
-          imageMimeType = att.mimeType;
-        } else if (att.filePath) {
-          const label = att.type === "file" ? "file" : att.type;
-          const name = att.fileName ? ` "${sanitizeQuotedText(att.fileName, 128)}"` : "";
-          const renderedPath = sanitizePromptPath(att.filePath);
-          filePaths.push(`User sent a ${label}${name}. It has been saved to: ${renderedPath}`);
-        }
-      }
-      if (filePaths.length > 0) {
-        promptText = promptText + "\n\n" + filePaths.join("\n");
-      }
-    }
-    if (this.config.instructions && !this.instructedSessions.has(sessionId)) {
-      promptText = `${this.config.instructions}
-
-${promptText}`;
-      this.instructedSessions.add(sessionId);
-    }
-    const groupCfg = envelope.isGroup ? this.config.groups[envelope.chatId] || this.config.groups["*"] : void 0;
-    const mode = groupCfg?.dispatchMode || this.config.dispatchMode || "steer";
-    const active = this.activePrompts.get(sessionId);
-    let steerWatchdog;
-    if (active) {
-      switch (mode) {
-        case "collect": {
-          let buffer = this.collectBuffers.get(sessionId);
-          if (!buffer) {
-            buffer = [];
-            this.collectBuffers.set(sessionId, buffer);
-          }
-          buffer.push({ text: promptText, envelope });
-          return;
-        }
-        case "steer": {
-          if (!this.isAuthorizedForSharedSession(envelope)) {
-            process.stderr.write(`[${this.name}] steer denied for ${envelope.senderId} in shared session (chat=${sanitizeLogText(envelope.chatId, 64)}); queuing instead
-`);
-            break;
-          }
-          active.cancelled = true;
-          process.stderr.write(`[${this.name}] steer: cancelled active turn for ${envelope.senderId} in session ${sessionId}
-`);
-          this.stopActiveStreaming(active, sessionId, "steer");
-          void this.bridge.cancelSession(sessionId).catch((err) => {
-            process.stderr.write(`[${this.name}] cancelSession failed for session=${sessionId} (steer): ${err instanceof Error ? err.message : err}
-`);
-          });
-          steerWatchdog = setTimeout(() => {
-            if (this.activePrompts.get(sessionId) === active) {
-              process.stderr.write(`[${this.name}] steer queued behind active turn for session ${sessionId}: still waiting after ${CLEAR_CANCEL_TIMEOUT_MS}ms (use /clear to recover)
-`);
-            }
-          }, CLEAR_CANCEL_TIMEOUT_MS);
-          steerWatchdog.unref?.();
-          promptText = `[The user sent a new message while you were working. Their previous request has been cancelled.]
-
-${promptText}`;
-          break;
-        }
-        case "followup": {
-          break;
-        }
-        default: {
-          const _exhaustive = mode;
-          throw new Error(`Unknown dispatch mode: ${_exhaustive}`);
-        }
-      }
-    }
-    const prev = this.sessionQueues.get(sessionId) ?? Promise.resolve();
-    const generation = this.sessionGenerations.get(sessionId) ?? 0;
-    const useBlockStreaming = this.config.blockStreaming === "on";
-    const current = prev.then(async () => {
-      clearTimeout(steerWatchdog);
-      if ((this.sessionGenerations.get(sessionId) ?? 0) !== generation) {
-        const loggedText = sanitizeLogText(envelope.text, 80);
-        process.stderr.write(`[${this.name}] dropped queued turn from ${envelope.senderId} for session ${sessionId}: session was cleared before it ran (text: ${loggedText})
-`);
-        return;
-      }
-      let doneResolve = /* @__PURE__ */ __name(() => {
-      }, "doneResolve");
-      const done = new Promise((r) => {
-        doneResolve = r;
-      });
-      const promptState = {
-        cancelled: false,
-        done,
-        resolve: doneResolve,
-        chatId: envelope.chatId,
-        messageId: envelope.messageId
-      };
-      this.activePrompts.set(sessionId, promptState);
-      this.onPromptStart(envelope.chatId, sessionId, envelope.messageId);
-      const streamer = useBlockStreaming ? new BlockStreamer({
-        minChars: this.config.blockStreamingChunk?.minChars ?? 400,
-        maxChars: this.config.blockStreamingChunk?.maxChars ?? 1e3,
-        idleMs: this.config.blockStreamingCoalesce?.idleMs ?? 1500,
-        send: /* @__PURE__ */ __name((text) => this.sendMessage(envelope.chatId, text), "send")
-      }) : null;
-      promptState.stopStreaming = () => streamer?.stop();
-      const onChunk = /* @__PURE__ */ __name((sid, chunk) => {
-        if (sid === sessionId && !promptState.cancelled) {
-          this.onResponseChunk(envelope.chatId, chunk, sessionId);
-          streamer?.push(chunk);
-        }
-      }, "onChunk");
-      const promptBridge = this.bridge;
-      promptBridge.on("textChunk", onChunk);
-      try {
-        const response = await promptBridge.prompt(sessionId, promptText, {
-          imageBase64,
-          imageMimeType
-        });
-        if (promptState.cancelRequested && !promptState.cancelled) {
-          promptState.cancelled = await promptState.cancelRequested;
-        }
-        if (!promptState.cancelled && response) {
-          if (streamer) {
-            await streamer.flush();
-          } else {
-            await this.onResponseComplete(envelope.chatId, response, sessionId);
-          }
-        }
-      } finally {
-        promptBridge.off("textChunk", onChunk);
-        streamer?.stop();
-        const stillCurrent = this.activePrompts.get(sessionId) === promptState;
-        if (!promptState.clearEvicted) {
-          try {
-            this.onPromptEnd(envelope.chatId, sessionId, envelope.messageId);
-          } catch (err) {
-            process.stderr.write(`[${this.name}] onPromptEnd threw in finally for session ${sessionId}: ${err instanceof Error ? err.message : err}
-`);
-          }
-        }
-        if (stillCurrent) {
-          this.activePrompts.delete(sessionId);
-        }
-        promptState.resolve();
-        const buffer = this.collectBuffers.get(sessionId);
-        if (stillCurrent && buffer && buffer.length > 0) {
-          this.collectBuffers.delete(sessionId);
-          const lost = buffer.length;
-          const coalesced = buffer.map((b) => b.text).join("\n\n");
-          const lastEnvelope = buffer[buffer.length - 1].envelope;
-          const syntheticEnvelope = {
-            ...lastEnvelope,
-            text: coalesced,
-            // Coalesced text already carries each message's [sender] prefix.
-            alreadyPrefixed: true,
-            // Clear attachments/references — already resolved in original text
-            referencedText: void 0,
-            attachments: void 0,
-            imageBase64: void 0,
-            imageMimeType: void 0
-          };
-          this.handleInbound(syntheticEnvelope).catch((err) => {
-            process.stderr.write(`[${this.name}] dropped ${lost} buffered message(s) on collect re-entry for session ${sessionId} (last sender ${lastEnvelope.senderId}): ${err instanceof Error ? err.message : String(err)}
-`);
-          });
-        }
-      }
-    });
-    this.sessionQueues.set(sessionId, current.catch(() => {
-    }));
-    await current;
-  }
-  async onPairingRequired(chatId, code) {
-    if (code) {
-      await this.sendMessage(chatId, `Your pairing code is: ${code}
-
-Ask the bot operator to approve you with:
-  qwen channel pairing approve ${this.name} ${code}`);
-    } else {
-      await this.sendMessage(chatId, "Too many pending pairing requests. Please try again later.");
-    }
-  }
-};
-
-// packages/channels/base/dist/index.js
-init_esbuild_shims();
-
-// packages/channels/base/dist/AcpBridge.js
-init_esbuild_shims();
-import { spawn } from "node:child_process";
-import { Readable, Writable } from "node:stream";
-import { EventEmitter } from "node:events";
-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 = [];
-  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 },
-      shell: false
-    });
-    this.child.stderr?.on("data", (data) => {
-      const msg = data.toString().trim();
-      if (msg) {
-        process.stderr.write(`[AcpBridge] ${msg}
-`);
-      }
-    });
-    this.child.on("exit", (code, signal) => {
-      process.stderr.write(`[AcpBridge] Process exited (code=${code}, signal=${signal})
-`);
-      this.connection = null;
-      this.child = null;
-      this.emit("disconnected", code, signal);
-    });
-    await new Promise((resolve2) => setTimeout(resolve2, 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) => {
-        const options = Array.isArray(params.options) ? params.options : [];
-        const optionId = options.find((o) => o.optionId === "proceed_once")?.optionId || options[0]?.optionId || "proceed_once";
-        return { outcome: { outcome: "selected", optionId } };
-      }, "requestPermission"),
-      extNotification: /* @__PURE__ */ __name(async () => {
-      }, "extNotification")
-    }), stream);
-    await this.connection.initialize({
-      protocolVersion: PROTOCOL_VERSION,
-      clientCapabilities: {}
-    });
-  }
-  async newSession(cwd) {
-    const conn = this.ensureConnection();
-    const response = await conn.newSession({ cwd, mcpServers: [] });
-    return response.sessionId;
-  }
-  async loadSession(sessionId, cwd) {
-    const conn = this.ensureConnection();
-    const response = await conn.loadSession({
-      sessionId,
-      cwd,
-      mcpServers: []
-    });
-    return response.sessionId;
-  }
-  async prompt(sessionId, text, options) {
-    const conn = this.ensureConnection();
-    const chunks = [];
-    const onChunk = /* @__PURE__ */ __name((sid, chunk) => {
-      if (sid === sessionId)
-        chunks.push(chunk);
-    }, "onChunk");
-    this.on("textChunk", onChunk);
-    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);
-    }
-    return chunks.join("");
-  }
-  async cancelSession(sessionId) {
-    const conn = this.ensureConnection();
-    await conn.cancel({ sessionId });
-  }
-  stop() {
-    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 content = update["content"];
-        if (content?.type === "text" && content.text) {
-          this.emit("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"]
-        };
-        this.emit("toolCall", event);
-        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;
-  }
-};
-
-// packages/channels/base/dist/DaemonChannelBridge.js
-init_esbuild_shims();
-
-export {
-  resolvePath,
-  getGlobalQwenDir,
-  AcpBridge,
-  PairingStore,
-  SessionRouter,
-  sanitizeSenderName,
-  sanitizePromptText,
-  sanitizeLogText,
-  ChannelBase
-};