@qwen-code/qwen-code 0.19.2 → 0.19.3-nightly.20260630.e00fe6a27

package/chunks/{chunk-JXQ23SNT.js → chunk-2JKEQWDZ.js}

@@ -41,6 +41,7 @@ __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");
@@ -51,6 +52,8 @@ var SessionRouter = class {
   // session ID → target
   toCwd = /* @__PURE__ */ new Map();
   // session ID → cwd
+  creatingSessions = /* @__PURE__ */ new Map();
+  sessionLoadWindows = /* @__PURE__ */ new Set();
   bridge;
   defaultCwd;
   defaultScope;
@@ -82,57 +85,89 @@ var SessionRouter = class {
         return `${channelName}:${senderId}:${chatId}`;
     }
   }
-  /**
-   * Sender-scoped key prefix for by-sender (no chatId) scans. The trailing
-   * ':' delimiter ensures a sender id matches as a whole segment — without it
-   * sender "bob" would also match another sender "bobby"
-   * (key `${channelName}:bobby:${chatId}`).
-   */
-  senderPrefix(channelName, senderId) {
-    return `${channelName}:${senderId}:`;
-  }
   async resolve(channelName, senderId, chatId, threadId, cwd) {
     const key = this.routingKey(channelName, senderId, chatId, threadId);
-    const existing = this.toSession.get(key);
-    if (existing) {
-      return existing;
+    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);
+        }
+      }
     }
-    const sessionCwd = cwd || this.defaultCwd;
-    const sessionId = await this.bridge.newSession(sessionCwd);
-    this.toSession.set(key, sessionId);
-    this.toTarget.set(sessionId, { channelName, senderId, chatId, threadId });
-    this.toCwd.set(sessionId, sessionCwd);
-    this.persist();
-    return sessionId;
   }
   getTarget(sessionId) {
     return this.toTarget.get(sessionId);
   }
-  hasSession(channelName, senderId, chatId) {
+  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));
+      return this.toSession.has(this.routingKey(channelName, senderId, chatId, threadId));
     }
-    const prefix = this.senderPrefix(channelName, senderId);
-    for (const k of this.toSession.keys()) {
-      if (k.startsWith(prefix))
+    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) {
+  removeSession(channelName, senderId, chatId, threadId) {
     const removedIds = [];
     if (chatId) {
-      const key = this.routingKey(channelName, senderId, chatId);
+      const key = this.routingKey(channelName, senderId, chatId, threadId);
       const sessionId = this.deleteByKey(key);
       if (sessionId)
         removedIds.push(sessionId);
     } else {
-      const prefix = this.senderPrefix(channelName, senderId);
-      for (const k of [...this.toSession.keys()]) {
-        if (k.startsWith(prefix)) {
+      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);
@@ -143,6 +178,31 @@ var SessionRouter = class {
       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)
@@ -166,7 +226,7 @@ var SessionRouter = class {
   /**
    * Restore session mappings from a previous bridge.
    * Called after bridge restart — attempts loadSession for each saved mapping.
-   * Failed loads are silently dropped (new session on next message).
+   * Failed loads are dropped (new session on next message).
    */
   async restoreSessions() {
     if (!this.persistPath || !existsSync(this.persistPath)) {
@@ -180,18 +240,54 @@ var SessionRouter = class {
     }
     let restored = 0;
     let failed = 0;
-    for (const [key, entry] of Object.entries(entries)) {
-      try {
-        const sessionId = await this.bridge.loadSession(entry.sessionId, entry.cwd);
-        this.toSession.set(key, sessionId);
-        this.toTarget.set(sessionId, entry.target);
-        this.toCwd.set(sessionId, entry.cwd);
-        restored++;
-      } catch {
-        failed++;
+    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 (failed > 0) {
+    if (changed) {
       this.persist();
     }
     return { restored, failed };
@@ -201,6 +297,8 @@ var SessionRouter = class {
     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);
@@ -227,10 +325,80 @@ var SessionRouter = class {
     } 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();
@@ -265,6 +433,11 @@ var BlockStreamer = class {
     }
     await this.sending;
   }
+  /** Drop buffered text and cancel future idle emission. */
+  stop() {
+    this.clearIdleTimer();
+    this.buffer = "";
+  }
   // ---------------------------------------------------------------------------
   // Internal
   // ---------------------------------------------------------------------------
@@ -526,6 +699,10 @@ function generateCode() {
 __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");
@@ -542,10 +719,26 @@ var ChannelBase = class {
   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;
@@ -556,21 +749,36 @@ var ChannelBase = class {
     this.gate = new SenderGate(config.senderPolicy, config.allowedUsers, pairingStore);
     this.router = options?.router || new SessionRouter(bridge, config.cwd, config.sessionScope);
     this.registerSharedCommands();
-    if (!options?.router) {
-      bridge.on("toolCall", (event) => {
-        const target = this.router.getTarget(event.sessionId);
-        if (target) {
-          this.onToolCall(target.chatId, event);
-        }
-      });
+    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).
@@ -607,38 +815,145 @@ var ChannelBase = class {
   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 clearHandler = /* @__PURE__ */ __name(async (envelope) => {
-      const removedIds = this.router.removeSession(this.name, envelope.senderId, envelope.chatId);
+    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. Your next message will start a fresh conversation.");
+        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",
-        "/clear \u2014 Clear your session (aliases: /reset, /new)",
+        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", "status"]);
+      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 agentCommands = this.bridge.availableCommands;
+      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) {
@@ -650,7 +965,11 @@ var ChannelBase = class {
       return true;
     });
     this.registerCommand("status", async (envelope) => {
-      const hasSession = this.router.hasSession(this.name, envelope.senderId, envelope.chatId);
+      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"}`,
@@ -666,17 +985,150 @@ var ChannelBase = class {
     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, args } or null if not a slash command.
+   * 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) {
-    if (!text.startsWith("/"))
+    const trimmed = text.trim();
+    if (!trimmed.startsWith("/"))
       return null;
-    const match = text.match(/^\/([a-zA-Z0-9_]+)(?:@\S+)?\s*(.*)/s);
+    const match = trimmed.match(PARSE_COMMAND_RE);
     if (!match)
       return null;
-    return { command: match[1].toLowerCase(), args: match[2].trim() };
+    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);
@@ -699,13 +1151,29 @@ var ChannelBase = class {
           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 (envelope.text.startsWith("!")) {
-      const cmd = envelope.text.slice(1).trim();
-      const bridgeShellCommand = this.bridge["shellCommand"];
-      if (cmd && typeof bridgeShellCommand === "function") {
+    if (bangText.startsWith("!")) {
+      const cmd = bangText.slice(1).trim();
+      const bridgeShellCommand = this.bridge.shellCommand;
+      if (cmd && bridgeShellCommand) {
         try {
-          const result2 = await bridgeShellCommand(sessionId, cmd);
+          const 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}
@@ -722,8 +1190,13 @@ ${output}${exitLine}`);
       }
     }
     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) {
-      promptText = `[Replying to: "${envelope.referencedText}"]
+      const quoted = sanitizeQuotedText(envelope.referencedText, 500);
+      promptText = `[Replying to: "${quoted}"]
 
 ${promptText}`;
     }
@@ -737,8 +1210,9 @@ ${promptText}`;
           imageMimeType = att.mimeType;
         } else if (att.filePath) {
           const label = att.type === "file" ? "file" : att.type;
-          const name = att.fileName ? ` "${att.fileName}"` : "";
-          filePaths.push(`User sent a ${label}${name}. It has been saved to: ${att.filePath}`);
+          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) {
@@ -754,6 +1228,7 @@ ${promptText}`;
     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": {
@@ -766,10 +1241,26 @@ ${promptText}`;
           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;
-          await this.bridge.cancelSession(sessionId).catch(() => {
+          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}
+`);
           });
-          await active.done;
+          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}`;
@@ -785,14 +1276,28 @@ ${promptText}`;
       }
     }
     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 };
+      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({
@@ -801,18 +1306,23 @@ ${promptText}`;
         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) {
+        if (sid === sessionId && !promptState.cancelled) {
           this.onResponseChunk(envelope.chatId, chunk, sessionId);
           streamer?.push(chunk);
         }
       }, "onChunk");
-      this.bridge.on("textChunk", onChunk);
+      const promptBridge = this.bridge;
+      promptBridge.on("textChunk", onChunk);
       try {
-        const response = await this.bridge.prompt(sessionId, promptText, {
+        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();
@@ -821,25 +1331,41 @@ ${promptText}`;
           }
         }
       } finally {
-        this.bridge.off("textChunk", onChunk);
-        this.onPromptEnd(envelope.chatId, sessionId, envelope.messageId);
-        this.activePrompts.delete(sessionId);
+        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 (buffer && buffer.length > 0) {
+        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(() => {
+          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)}
+`);
           });
         }
       }
@@ -868,6 +1394,19 @@ 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");
@@ -1021,7 +1560,10 @@ var AcpBridge = class extends EventEmitter {
       }
       case "available_commands_update": {
         if (Array.isArray(update["availableCommands"])) {
-          this._availableCommands = update["availableCommands"];
+          this._availableCommands = update["availableCommands"].map((cmd) => {
+            const altNames = readAvailableCommandAltNames(cmd);
+            return altNames ? { ...cmd, altNames } : cmd;
+          });
         }
         break;
       }
@@ -1047,5 +1589,8 @@ export {
   AcpBridge,
   PairingStore,
   SessionRouter,
+  sanitizeSenderName,
+  sanitizePromptText,
+  sanitizeLogText,
   ChannelBase
 };