@qwen-code/qwen-code 0.19.9 → 0.19.10-nightly.20260715.c538bd70d

package/chunks/{chunk-34Z3U5RQ.js → chunk-AU4R7ACM.js}

@@ -12,32 +12,6 @@ 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/sanitize.js
 init_esbuild_shims();
 var PROMPT_UNSAFE_INVISIBLES = new RegExp("[\\u0080-\\u009f\\p{Cf}\\u2028\\u2029]|\\p{Variation_Selector}", "gu");
@@ -74,6 +48,32 @@ __name(sanitizeLogText, "sanitizeLogText");
 // packages/channels/base/dist/index.js
 init_esbuild_shims();
 
+// 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/AcpBridge.js
 init_esbuild_shims();
 import { spawn } from "node:child_process";
@@ -361,15 +361,23 @@ var AcpBridge = class extends EventEmitter {
   async prompt(sessionId, text, options) {
     const conn = this.ensureConnection();
     const chunks = [];
+    let slashCommandOutput = "";
     const onChunk = /* @__PURE__ */ __name((sid, chunk) => {
       if (sid === sessionId)
         chunks.push(chunk);
     }, "onChunk");
-    const clearChunks = /* @__PURE__ */ __name((sid) => {
+    const onSlashCommandOutput = /* @__PURE__ */ __name((sid, chunk) => {
       if (sid === sessionId)
+        slashCommandOutput = chunk;
+    }, "onSlashCommandOutput");
+    const clearChunks = /* @__PURE__ */ __name((sid) => {
+      if (sid === sessionId) {
         chunks.length = 0;
+        slashCommandOutput = "";
+      }
     }, "clearChunks");
     this.on("textChunk", onChunk);
+    this.on("slashCommandOutput", onSlashCommandOutput);
     this.on("responseBoundary", clearChunks);
     const prompt = [];
     if (options?.imageBase64 && options.imageMimeType) {
@@ -387,9 +395,10 @@ var AcpBridge = class extends EventEmitter {
       });
     } finally {
       this.off("textChunk", onChunk);
+      this.off("slashCommandOutput", onSlashCommandOutput);
       this.off("responseBoundary", clearChunks);
     }
-    return chunks.join("");
+    return chunks.join("") || slashCommandOutput;
   }
   async cancelSession(sessionId) {
     const conn = this.ensureConnection();
@@ -432,9 +441,13 @@ var AcpBridge = class extends EventEmitter {
     const type = update["sessionUpdate"];
     switch (type) {
       case "agent_message_chunk": {
+        const meta = update["_meta"];
+        if (typeof meta?.["parentToolCallId"] === "string") {
+          break;
+        }
         const content = update["content"];
         if (content?.type === "text" && content.text) {
-          this.emit("textChunk", sessionId, content.text);
+          this.emit(meta?.["source"] === "slash_command" ? "slashCommandOutput" : "textChunk", sessionId, content.text);
         }
         break;
       }
@@ -707,6 +720,7 @@ var DaemonChannelBridge = class extends EventEmitter2 {
   }
   options;
   sessions = /* @__PURE__ */ new Map();
+  sessionBindingTokens = /* @__PURE__ */ new Map();
   eventControllers = /* @__PURE__ */ new Map();
   requestToSession = /* @__PURE__ */ new Map();
   respondedRequestToSession = /* @__PURE__ */ new Map();
@@ -715,6 +729,7 @@ var DaemonChannelBridge = class extends EventEmitter2 {
   availableCommandsBySession = /* @__PURE__ */ new Map();
   turnBarriers = /* @__PURE__ */ new Map();
   connected = false;
+  lifecycleGeneration = 0;
   latestAvailableCommandsSessionId;
   lastError;
   constructor(options) {
@@ -750,17 +765,22 @@ var DaemonChannelBridge = class extends EventEmitter2 {
   async start() {
     this.connected = true;
   }
-  async newSession(cwd, options) {
+  async newSession(cwd, options, bindingToken) {
+    const lifecycleGeneration = this.lifecycleGeneration;
     const session = await this.options.sessionFactory({
       workspaceCwd: cwd || this.options.cwd,
       modelServiceId: this.options.modelServiceId,
       sessionScope: this.options.sessionScope ?? "thread",
       ...options?.approvalMode ? { approvalMode: options.approvalMode } : {}
     });
-    this.attachSession(session);
+    if (lifecycleGeneration !== this.lifecycleGeneration) {
+      await this.rejectStaleSession(session);
+    }
+    this.attachSession(session, bindingToken);
     return session.sessionId;
   }
-  async loadSession(sessionId, cwd, options) {
+  async loadSession(sessionId, cwd, options, bindingToken) {
+    const lifecycleGeneration = this.lifecycleGeneration;
     const session = await this.options.sessionFactory({
       workspaceCwd: cwd || this.options.cwd,
       modelServiceId: this.options.modelServiceId,
@@ -768,10 +788,16 @@ var DaemonChannelBridge = class extends EventEmitter2 {
       sessionScope: this.options.sessionScope ?? "thread",
       ...options?.approvalMode ? { approvalMode: options.approvalMode } : {}
     });
+    if (lifecycleGeneration !== this.lifecycleGeneration) {
+      await this.rejectStaleSession(session);
+    }
     if (session.sessionId !== sessionId) {
+      void this.releaseSessionClient(session).catch((error) => {
+        this.lastError = error;
+      });
       throw new Error(`Daemon returned session ${session.sessionId} while loading ${sessionId}`);
     }
-    this.attachSession(session);
+    this.attachSession(session, bindingToken);
     return session.sessionId;
   }
   async prompt(sessionId, text, options) {
@@ -788,14 +814,21 @@ var DaemonChannelBridge = class extends EventEmitter2 {
     }
     controllers.add(controller);
     const chunks = [];
+    let slashCommandOutput = "";
     const onChunk = /* @__PURE__ */ __name((sid, chunk) => {
       if (sid === sessionId) {
         chunks.push(chunk);
       }
     }, "onChunk");
+    const onSlashCommandOutput = /* @__PURE__ */ __name((sid, chunk) => {
+      if (sid === sessionId) {
+        slashCommandOutput = chunk;
+      }
+    }, "onSlashCommandOutput");
     const clearChunks = /* @__PURE__ */ __name((sid) => {
       if (sid === sessionId) {
         chunks.length = 0;
+        slashCommandOutput = "";
       }
     }, "clearChunks");
     const onSessionDied = /* @__PURE__ */ __name((info) => {
@@ -804,6 +837,7 @@ var DaemonChannelBridge = class extends EventEmitter2 {
       }
     }, "onSessionDied");
     this.on("textChunk", onChunk);
+    this.on("slashCommandOutput", onSlashCommandOutput);
     this.on("responseBoundary", clearChunks);
     this.on("sessionDied", onSessionDied);
     const turnBarrier = this.createTurnBarrier(sessionId);
@@ -822,7 +856,7 @@ var DaemonChannelBridge = class extends EventEmitter2 {
         turnBarrier,
         new Promise((resolve2) => setTimeout(resolve2, 0))
       ]);
-      const textResult = chunks.join("");
+      const textResult = chunks.join("") || slashCommandOutput;
       this.emit("promptComplete", {
         sessionId,
         text: textResult,
@@ -832,6 +866,7 @@ var DaemonChannelBridge = class extends EventEmitter2 {
     } finally {
       this.clearTurnBarrier(sessionId);
       this.off("textChunk", onChunk);
+      this.off("slashCommandOutput", onSlashCommandOutput);
       this.off("responseBoundary", clearChunks);
       this.off("sessionDied", onSessionDied);
       this.activePrompts.delete(sessionId);
@@ -855,6 +890,25 @@ var DaemonChannelBridge = class extends EventEmitter2 {
     this.activePrompts.delete(sessionId);
     await session.cancel();
   }
+  async discardSession(sessionId, expectedBindingToken) {
+    if (expectedBindingToken !== void 0 && this.sessionBindingTokens.get(sessionId) !== expectedBindingToken) {
+      return;
+    }
+    const session = this.removeSessionBinding(sessionId);
+    if (!session)
+      return;
+    await this.releaseSessionClient(session);
+  }
+  async releaseSessionClient(session) {
+    if (session.detach) {
+      try {
+        await session.detach();
+        return;
+      } catch {
+      }
+    }
+    await session.cancel();
+  }
   async setSessionModel(sessionId, modelId) {
     return await this.ensureSession(sessionId).setModel(modelId);
   }
@@ -885,6 +939,7 @@ var DaemonChannelBridge = class extends EventEmitter2 {
     }
   }
   stop() {
+    this.lifecycleGeneration++;
     for (const sessionId of Array.from(this.sessions.keys())) {
       const session = this.sessions.get(sessionId);
       if (session) {
@@ -892,7 +947,7 @@ var DaemonChannelBridge = class extends EventEmitter2 {
           this.lastError = error;
         });
       }
-      this.dropSession(sessionId, "bridge_stopped");
+      this.dropSession(sessionId, "bridge_stopped", false);
     }
     this.latestAvailableCommandsSessionId = void 0;
     this.connected = false;
@@ -900,15 +955,29 @@ var DaemonChannelBridge = class extends EventEmitter2 {
   get isConnected() {
     return this.connected;
   }
-  attachSession(session) {
-    if (this.sessions.has(session.sessionId)) {
-      this.dropSession(session.sessionId, "session_replaced");
+  attachSession(session, bindingToken) {
+    const replacedSession = this.removeSessionBinding(session.sessionId);
+    if (replacedSession) {
+      void this.releaseSessionClient(replacedSession).catch((error) => {
+        this.lastError = error;
+      });
+      this.emit("sessionDied", {
+        sessionId: session.sessionId,
+        reason: "session_replaced"
+      });
     }
     this.sessions.set(session.sessionId, session);
+    this.sessionBindingTokens.set(session.sessionId, bindingToken);
     const controller = new AbortController();
     this.eventControllers.set(session.sessionId, controller);
     void this.pumpEvents(session, controller.signal);
   }
+  async rejectStaleSession(session) {
+    void this.releaseSessionClient(session).catch((error) => {
+      this.lastError = error;
+    });
+    throw new Error("Daemon channel bridge stopped during session creation");
+  }
   ensureSession(sessionId) {
     const session = this.sessions.get(sessionId);
     if (!session) {
@@ -944,6 +1013,9 @@ var DaemonChannelBridge = class extends EventEmitter2 {
   handleEvent(session, event) {
     switch (event.type) {
       case "session_update":
+        if (isRecord(event.data) && typeof event.data["sessionId"] === "string" && event.data["sessionId"] !== session.sessionId) {
+          break;
+        }
         this.handleSessionUpdate(session.sessionId, event.data);
         break;
       case "permission_request":
@@ -987,9 +1059,13 @@ var DaemonChannelBridge = class extends EventEmitter2 {
     const type = getString(update["sessionUpdate"]);
     switch (type) {
       case "agent_message_chunk": {
+        const meta = isRecord(update["_meta"]) ? update["_meta"] : void 0;
+        if (typeof meta?.["parentToolCallId"] === "string") {
+          break;
+        }
         const text = getTextContent(update["content"]);
         if (text) {
-          this.emit("textChunk", sessionId, text);
+          this.emit(meta?.["source"] === "slash_command" ? "slashCommandOutput" : "textChunk", sessionId, text);
         }
         break;
       }
@@ -1004,6 +1080,10 @@ var DaemonChannelBridge = class extends EventEmitter2 {
       case "tool_call_update": {
         const toolCallId = getString(update["toolCallId"]);
         const kind = getString(update["kind"]);
+        const meta = isRecord(update["_meta"]) ? update["_meta"] : void 0;
+        if (!kind && toolCallId && getString(update["status"]) === "in_progress" && meta?.["shellProgress"] !== void 0) {
+          break;
+        }
         if (!toolCallId || !kind) {
           this.emitProtocolError(`Malformed daemon ${type} event`, update);
           break;
@@ -1123,14 +1203,26 @@ var DaemonChannelBridge = class extends EventEmitter2 {
   handleSessionDied(sessionId, data) {
     this.dropSession(sessionId, this.getStringField(data, "reason", "session_died"));
   }
-  dropSession(sessionId, reason) {
-    if (!this.sessions.has(sessionId)) {
+  dropSession(sessionId, reason, releaseClient = true) {
+    const session = this.removeSessionBinding(sessionId);
+    if (!session)
       return;
+    if (releaseClient) {
+      void this.releaseSessionClient(session).catch((error) => {
+        this.lastError = error;
+      });
     }
+    this.emit("sessionDied", { sessionId, reason });
+  }
+  removeSessionBinding(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session)
+      return void 0;
     this.resolveTurnBarrier(sessionId);
     this.eventControllers.get(sessionId)?.abort();
     this.eventControllers.delete(sessionId);
     this.sessions.delete(sessionId);
+    this.sessionBindingTokens.delete(sessionId);
     this.abortActivePrompts(sessionId);
     this.activePrompts.delete(sessionId);
     this.availableCommandsBySession.delete(sessionId);
@@ -1147,7 +1239,7 @@ var DaemonChannelBridge = class extends EventEmitter2 {
         this.respondedRequestToSession.delete(requestId);
       }
     }
-    this.emit("sessionDied", { sessionId, reason });
+    return session;
   }
   getStringField(data, field, fallback) {
     return isRecord(data) && typeof data[field] === "string" ? data[field] : fallback;
@@ -1295,7 +1387,7 @@ var BlockStreamer = class {
 
 // packages/channels/base/dist/ChannelBase.js
 init_esbuild_shims();
-import { basename, join as join4 } from "node:path";
+import { basename, join as join5 } from "node:path";
 
 // packages/channels/base/dist/GroupGate.js
 init_esbuild_shims();
@@ -1770,7 +1862,8 @@ __name(generateCode, "generateCode");
 
 // packages/channels/base/dist/SessionRouter.js
 init_esbuild_shims();
-import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3, unlinkSync } from "node:fs";
+import { chmodSync as chmodSync2, existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync as renameSync2, rmSync, unlinkSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname2, join as join4 } from "node:path";
 import process2 from "node:process";
 var SessionRouter = class {
   static {
@@ -1784,17 +1877,22 @@ var SessionRouter = class {
   // session ID → cwd
   creatingSessions = /* @__PURE__ */ new Map();
   sessionLoadWindows = /* @__PURE__ */ new Set();
+  liveSessionIds = /* @__PURE__ */ new Set();
+  routeTokens = /* @__PURE__ */ new Map();
+  lifecycleGeneration = 0;
   bridge;
   defaultCwd;
   defaultScope;
   channelScopes = /* @__PURE__ */ new Map();
   channelApprovalModes = /* @__PURE__ */ new Map();
   persistPath;
-  constructor(bridge, defaultCwd, scope = "user", persistPath) {
+  recoveryMode;
+  constructor(bridge, defaultCwd, scope = "user", persistPath, options = {}) {
     this.bridge = bridge;
     this.defaultCwd = defaultCwd;
     this.defaultScope = scope;
     this.persistPath = persistPath;
+    this.recoveryMode = options.recoveryMode ?? "eager";
   }
   /** Replace the bridge instance (used after crash recovery restart). */
   setBridge(bridge) {
@@ -1829,60 +1927,168 @@ var SessionRouter = class {
   }
   async resolve(channelName, senderId, chatId, threadId, cwd, isGroup, options) {
     const key = this.routingKey(channelName, senderId, chatId, options?.routingThreadId ?? threadId);
-    let failedCreateWaits = 0;
+    const input = {
+      channelName,
+      senderId,
+      chatId,
+      threadId,
+      cwd: cwd || this.defaultCwd,
+      isGroup
+    };
+    let failedWaits = 0;
     for (; ; ) {
       const existing = this.toSession.get(key);
-      if (existing) {
+      if (existing && this.isLive(existing)) {
         this.promoteTargetToGroup(existing, isGroup);
         return existing;
       }
       const creating = this.creatingSessions.get(key);
       if (creating) {
         try {
-          const sessionId = await creating;
+          const sessionId = await creating.promise;
+          try {
+            this.assertOperationResultCurrent(key, sessionId, creating);
+          } catch (error) {
+            this.scheduleDiscardInvalidatedSession(sessionId, creating);
+            throw error;
+          }
           this.promoteTargetToGroup(sessionId, isGroup);
           return sessionId;
-        } catch (err) {
+        } catch (error) {
+          if (creating.invalidationError) {
+            throw creating.invalidationError;
+          }
           if (this.creatingSessions.get(key) === creating) {
             this.creatingSessions.delete(key);
           }
-          failedCreateWaits++;
-          if (failedCreateWaits > 3) {
-            throw err;
-          }
+          this.releaseRouteToken(key, creating);
+          failedWaits++;
+          if (failedWaits > 3)
+            throw error;
           continue;
         }
       }
-      const created = Promise.resolve().then(async () => {
-        const sessionCwd = cwd || this.defaultCwd;
-        const loadWindow = this.beginSessionLoad();
+      const operation = this.createSessionOperation(key, {
+        channelName: input.channelName,
+        senderId: input.senderId,
+        chatId: input.chatId,
+        threadId: input.threadId,
+        isGroup: input.isGroup
+      }, (currentOperation) => existing ? this.loadOrReplaceSession(key, existing, input, currentOperation) : this.createAndStoreSession(key, input, currentOperation));
+      this.creatingSessions.set(key, operation);
+      try {
+        const sessionId = await operation.promise;
         try {
-          const sessionId = await this.createLiveSession(sessionCwd, loadWindow, key, this.sessionOptions(channelName));
-          this.toSession.set(key, sessionId);
-          this.toTarget.set(sessionId, {
-            channelName,
-            senderId,
-            chatId,
-            threadId,
-            isGroup
-          });
-          this.toCwd.set(sessionId, sessionCwd);
-          this.persist();
-          return sessionId;
-        } finally {
-          this.endSessionLoad(loadWindow);
+          this.assertOperationResultCurrent(key, sessionId, operation);
+        } catch (error) {
+          this.scheduleDiscardInvalidatedSession(sessionId, operation);
+          throw error;
         }
-      });
-      this.creatingSessions.set(key, created);
-      try {
-        return await created;
+        this.promoteTargetToGroup(sessionId, isGroup);
+        return sessionId;
       } finally {
-        if (this.creatingSessions.get(key) === created) {
+        if (this.creatingSessions.get(key) === operation) {
           this.creatingSessions.delete(key);
         }
+        this.releaseRouteToken(key, operation);
       }
     }
   }
+  isLive(sessionId) {
+    return this.recoveryMode === "eager" || this.liveSessionIds.has(sessionId);
+  }
+  async createAndStoreSession(key, input, operation) {
+    const loadWindow = this.beginSessionLoad();
+    try {
+      const sessionId = await this.createLiveSession(input.cwd, loadWindow, key, this.sessionOptions(input.channelName), operation);
+      try {
+        this.assertOperationCurrent(operation);
+      } catch (error) {
+        this.scheduleDiscardInvalidatedSession(sessionId, operation);
+        throw error;
+      }
+      this.toSession.set(key, sessionId);
+      this.toTarget.set(sessionId, {
+        channelName: input.channelName,
+        senderId: input.senderId,
+        chatId: input.chatId,
+        threadId: input.threadId,
+        isGroup: input.isGroup
+      });
+      this.toCwd.set(sessionId, input.cwd);
+      this.liveSessionIds.add(sessionId);
+      this.persist();
+      return sessionId;
+    } finally {
+      this.endSessionLoad(loadWindow);
+    }
+  }
+  async loadOrReplaceSession(key, savedSessionId, input, operation) {
+    const savedCwd = this.toCwd.get(savedSessionId) ?? input.cwd;
+    const loadWindow = this.beginSessionLoad();
+    try {
+      try {
+        const loadedSessionId = await this.bridge.loadSession(savedSessionId, savedCwd, this.sessionOptions(input.channelName), operation);
+        try {
+          this.assertOperationCurrent(operation);
+          if (this.toSession.get(key) !== savedSessionId) {
+            this.invalidateOperation(operation);
+            this.assertOperationCurrent(operation);
+          }
+        } catch (error) {
+          this.scheduleDiscardInvalidatedSession(loadedSessionId, operation);
+          throw error;
+        }
+        if (typeof loadedSessionId !== "string" || loadedSessionId.length === 0 || loadWindow.delete(loadedSessionId)) {
+          throw new Error("Invalid or dead restored session ID");
+        }
+        if (loadedSessionId !== savedSessionId) {
+          const target = this.toTarget.get(savedSessionId);
+          this.deleteByKey(key);
+          this.toSession.set(key, loadedSessionId);
+          if (target)
+            this.toTarget.set(loadedSessionId, target);
+          this.toCwd.set(loadedSessionId, savedCwd);
+          this.persist();
+        }
+        this.liveSessionIds.add(loadedSessionId);
+        return loadedSessionId;
+      } catch (loadError) {
+        this.assertOperationCurrent(operation);
+        try {
+          const replacement = await this.createLiveSession(input.cwd, loadWindow, key, this.sessionOptions(input.channelName), operation);
+          try {
+            this.assertOperationCurrent(operation);
+          } catch (error) {
+            this.scheduleDiscardInvalidatedSession(replacement, operation);
+            throw error;
+          }
+          this.deleteByKey(key);
+          this.toSession.set(key, replacement);
+          this.toTarget.set(replacement, {
+            channelName: input.channelName,
+            senderId: input.senderId,
+            chatId: input.chatId,
+            threadId: input.threadId,
+            isGroup: input.isGroup
+          });
+          this.toCwd.set(replacement, input.cwd);
+          this.liveSessionIds.add(replacement);
+          this.persist();
+          process2.stderr.write(`[SessionRouter] Replaced unavailable session ${sanitizeLogText(savedSessionId, 128)} for key ${sanitizeLogText(key, 256)} after load failed: ${sanitizeLogText(loadError instanceof Error ? loadError.message : String(loadError), 512)}
+`);
+          return replacement;
+        } catch (createError) {
+          this.assertOperationCurrent(operation);
+          process2.stderr.write(`[SessionRouter] Failed to load session ${sanitizeLogText(savedSessionId, 128)} for key ${sanitizeLogText(key, 256)} (${sanitizeLogText(loadError instanceof Error ? loadError.message : String(loadError), 512)}) and failed to create a replacement (${sanitizeLogText(createError instanceof Error ? createError.message : String(createError), 512)})
+`);
+          throw createError;
+        }
+      }
+    } finally {
+      this.endSessionLoad(loadWindow);
+    }
+  }
   getTarget(sessionId) {
     return this.toTarget.get(sessionId);
   }
@@ -1912,6 +2118,7 @@ var SessionRouter = class {
     const scope = this.channelScopes.get(channelName) || this.defaultScope;
     if (chatId) {
       const key = this.routingKey(channelName, senderId, chatId, threadId);
+      this.invalidateRouteOperation(key);
       const sessionId = this.deleteByKey(key);
       if (sessionId)
         removedIds.push(sessionId);
@@ -1921,11 +2128,17 @@ var SessionRouter = class {
       for (const [k, mappedSessionId] of [...this.toSession.entries()]) {
         const target = this.toTarget.get(mappedSessionId);
         if (target?.channelName === channelName && target.senderId === senderId) {
+          this.invalidateRouteOperation(k);
           const sessionId = this.deleteByKey(k);
           if (sessionId)
             removedIds.push(sessionId);
         }
       }
+      for (const [key, operation] of [...this.creatingSessions]) {
+        if (operation.target.channelName === channelName && operation.target.senderId === senderId) {
+          this.invalidateRouteOperation(key);
+        }
+      }
     }
     if (removedIds.length > 0)
       this.persist();
@@ -1936,6 +2149,7 @@ var SessionRouter = class {
     let removed = false;
     for (const [key, mappedSessionId] of [...this.toSession.entries()]) {
       if (mappedSessionId === sessionId) {
+        this.invalidateRouteOperation(key);
         this.toSession.delete(key);
         removed = true;
       }
@@ -1946,6 +2160,7 @@ var SessionRouter = class {
     if (this.toCwd.delete(sessionId)) {
       removed = true;
     }
+    this.liveSessionIds.delete(sessionId);
     if (!removed && this.sessionLoadWindows.size > 0) {
       for (const loadWindow of this.sessionLoadWindows) {
         loadWindow.add(sessionId);
@@ -1956,6 +2171,17 @@ var SessionRouter = class {
     }
     return removed;
   }
+  handleSessionDied(sessionId) {
+    if (this.recoveryMode === "eager") {
+      return this.removeSessionId(sessionId);
+    }
+    const known = this.toTarget.has(sessionId);
+    this.liveSessionIds.delete(sessionId);
+    for (const loadWindow of this.sessionLoadWindows) {
+      loadWindow.add(sessionId);
+    }
+    return known;
+  }
   deleteByKey(key) {
     const sessionId = this.toSession.get(key);
     if (!sessionId)
@@ -1963,6 +2189,7 @@ var SessionRouter = class {
     this.toSession.delete(key);
     this.toTarget.delete(sessionId);
     this.toCwd.delete(sessionId);
+    this.liveSessionIds.delete(sessionId);
     return sessionId;
   }
   promoteTargetToGroup(sessionId, isGroup) {
@@ -1985,45 +2212,69 @@ var SessionRouter = class {
     }
     return entries;
   }
+  restoreRoutes() {
+    if (this.recoveryMode !== "lazy") {
+      throw new Error("restoreRoutes requires lazy recovery mode");
+    }
+    const persisted = this.readPersistedEntries();
+    if (!persisted)
+      return { restored: 0, dropped: 0 };
+    this.dispose();
+    let restored = 0;
+    for (const [key, entry] of Object.entries(persisted.entries)) {
+      this.toSession.set(key, entry.sessionId);
+      this.toTarget.set(entry.sessionId, entry.target);
+      this.toCwd.set(entry.sessionId, entry.cwd);
+      restored++;
+    }
+    if (persisted.dropped > 0)
+      this.persist();
+    return { restored, dropped: persisted.dropped };
+  }
   /**
    * Restore session mappings from a previous bridge.
    * Called after bridge restart — attempts loadSession for each saved mapping.
    * Failed loads are dropped (new session on next message).
    */
   async restoreSessions() {
-    const persistPath = this.persistPath;
-    if (!persistPath || !existsSync3(persistPath)) {
-      return { restored: 0, failed: 0 };
-    }
-    let entries;
-    try {
-      entries = JSON.parse(readFileSync3(persistPath, "utf-8"));
-    } catch (err) {
-      const reason = err instanceof Error ? err.message : String(err);
-      process2.stderr.write(`[SessionRouter] Corrupted persist file at ${sanitizeLogText(persistPath, 1024)}: ${sanitizeLogText(reason, 512)}
-`);
+    const persisted = this.readPersistedEntries();
+    if (!persisted)
       return { restored: 0, failed: 0 };
-    }
+    const entries = persisted.entries;
+    const restoreGeneration = this.lifecycleGeneration;
     let restored = 0;
     let failed = 0;
-    let changed = false;
+    let changed = persisted.dropped > 0;
     const reservations = /* @__PURE__ */ new Map();
+    for (const key of persisted.droppedKeys) {
+      this.deleteByKey(key);
+    }
     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 operation = this.createSessionOperation(key, entries[key].target, () => reservation.promise);
+      operation.promise.catch(() => void 0);
+      this.creatingSessions.set(key, operation);
+      reservations.set(key, { reservation, operation });
     }
     const loadWindow = this.beginSessionLoad();
     try {
       for (const [key, entry] of Object.entries(entries)) {
-        const reservation = reservations.get(key);
-        if (!reservation)
+        const reserved = reservations.get(key);
+        if (!reserved)
           continue;
+        const { reservation, operation } = reserved;
         try {
+          this.assertOperationCurrent(operation);
           const options = this.sessionOptions(entry.target.channelName);
-          const sessionId = options ? await this.bridge.loadSession(entry.sessionId, entry.cwd, options) : await this.bridge.loadSession(entry.sessionId, entry.cwd);
+          const sessionId = await this.bridge.loadSession(entry.sessionId, entry.cwd, options, operation);
+          try {
+            this.assertOperationCurrent(operation);
+          } catch (error) {
+            this.scheduleDiscardInvalidatedSession(sessionId, operation);
+            throw error;
+          }
           if (typeof sessionId !== "string" || sessionId.length === 0) {
             throw new Error("Invalid restored session ID");
           }
@@ -2046,26 +2297,36 @@ var SessionRouter = class {
           failed++;
           changed = true;
         } finally {
-          if (this.creatingSessions.get(key) === reservation.promise) {
+          if (this.creatingSessions.get(key) === operation) {
             this.creatingSessions.delete(key);
           }
+          this.releaseRouteToken(key, operation);
         }
       }
     } finally {
       this.endSessionLoad(loadWindow);
     }
-    if (changed) {
+    if (changed && restoreGeneration === this.lifecycleGeneration) {
       this.persist();
     }
     return { restored, failed };
   }
-  /** Clear in-memory state and delete persist file. Used on clean shutdown. */
-  clearAll() {
+  dispose() {
+    this.lifecycleGeneration++;
+    for (const operation of this.creatingSessions.values()) {
+      this.invalidateOperation(operation);
+    }
     this.toSession.clear();
     this.toTarget.clear();
     this.toCwd.clear();
     this.creatingSessions.clear();
     this.sessionLoadWindows.clear();
+    this.liveSessionIds.clear();
+    this.routeTokens.clear();
+  }
+  /** Clear in-memory state and delete persist file. Used on clean shutdown. */
+  clearAll() {
+    this.dispose();
     if (this.persistPath && existsSync3(this.persistPath)) {
       try {
         unlinkSync(this.persistPath);
@@ -2073,30 +2334,105 @@ var SessionRouter = class {
       }
     }
   }
+  readPersistedEntries() {
+    const persistPath = this.persistPath;
+    if (!persistPath || !existsSync3(persistPath))
+      return void 0;
+    let parsed;
+    try {
+      parsed = JSON.parse(readFileSync3(persistPath, "utf-8"));
+    } catch (error) {
+      const quarantinePath = `${persistPath}.corrupt-${Date.now()}`;
+      try {
+        renameSync2(persistPath, quarantinePath);
+      } catch {
+      }
+      process2.stderr.write(`[SessionRouter] Corrupted persist file at ${sanitizeLogText(persistPath, 1024)}: ${sanitizeLogText(error instanceof Error ? error.message : String(error), 512)}
+`);
+      return void 0;
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      const quarantinePath = `${persistPath}.corrupt-${Date.now()}`;
+      try {
+        renameSync2(persistPath, quarantinePath);
+      } catch {
+      }
+      process2.stderr.write(`[SessionRouter] Invalid route store at ${sanitizeLogText(persistPath, 1024)}: expected an object
+`);
+      return void 0;
+    }
+    const entries = {};
+    const droppedKeys = [];
+    for (const [key, value] of Object.entries(parsed)) {
+      if (this.isPersistedEntry(value))
+        entries[key] = value;
+      else
+        droppedKeys.push(key);
+    }
+    return { entries, dropped: droppedKeys.length, droppedKeys };
+  }
+  isPersistedEntry(value) {
+    if (typeof value !== "object" || value === null)
+      return false;
+    const entry = value;
+    const target = entry["target"];
+    if (typeof target !== "object" || target === null)
+      return false;
+    const typedTarget = target;
+    return typeof entry["sessionId"] === "string" && entry["sessionId"].length > 0 && typeof entry["cwd"] === "string" && entry["cwd"].length > 0 && typeof typedTarget["channelName"] === "string" && typeof typedTarget["senderId"] === "string" && typeof typedTarget["chatId"] === "string" && (typedTarget["threadId"] === void 0 || typeof typedTarget["threadId"] === "string") && (typedTarget["isGroup"] === void 0 || typeof typedTarget["isGroup"] === "boolean");
+  }
   persist() {
     if (!this.persistPath)
       return;
     const data = {};
     for (const [key, sessionId] of this.toSession) {
       const target = this.toTarget.get(sessionId);
-      if (target) {
-        data[key] = {
-          sessionId,
-          target,
-          cwd: this.toCwd.get(sessionId) || this.defaultCwd
-        };
-      }
+      if (!target)
+        continue;
+      data[key] = {
+        sessionId,
+        target,
+        cwd: this.toCwd.get(sessionId) ?? this.defaultCwd
+      };
     }
+    const dir = dirname2(this.persistPath);
+    const tempPath = join4(dir, `${Date.now()}-${process2.pid}-${Math.random().toString(16).slice(2)}.tmp`);
     try {
-      writeFileSync3(this.persistPath, JSON.stringify(data, null, 2), "utf-8");
-    } catch {
+      mkdirSync3(dir, { recursive: true, mode: 448 });
+      try {
+        chmodSync2(dir, 448);
+      } catch {
+      }
+      writeFileSync3(tempPath, JSON.stringify(data, null, 2), {
+        encoding: "utf-8",
+        mode: 384
+      });
+      renameSync2(tempPath, this.persistPath);
+      try {
+        chmodSync2(this.persistPath, 384);
+      } catch {
+      }
+    } catch (error) {
+      process2.stderr.write(`[SessionRouter] Failed to persist routes at ${sanitizeLogText(this.persistPath, 1024)}: ${sanitizeLogText(error instanceof Error ? error.message : String(error), 512)}
+`);
+    } finally {
+      try {
+        rmSync(tempPath, { force: true });
+      } catch {
+      }
     }
   }
-  async createLiveSession(cwd, loadWindow, routingKey, options) {
+  async createLiveSession(cwd, loadWindow, routingKey, options, operation) {
     const maxAttempts = 2;
     let lastDeadSessionId;
     for (let attempt = 0; attempt < maxAttempts; attempt++) {
-      const sessionId = options ? await this.bridge.newSession(cwd, options) : await this.bridge.newSession(cwd);
+      const sessionId = await this.bridge.newSession(cwd, options, operation);
+      try {
+        this.assertOperationCurrent(operation);
+      } catch (error) {
+        this.scheduleDiscardInvalidatedSession(sessionId, operation);
+        throw error;
+      }
       if (typeof sessionId !== "string" || sessionId.length === 0) {
         throw new Error("Invalid session ID from bridge");
       }
@@ -2112,6 +2448,65 @@ var SessionRouter = class {
     this.sessionLoadWindows.add(loadWindow);
     return loadWindow;
   }
+  createSessionOperation(key, target, run) {
+    let routeToken = this.routeTokens.get(key);
+    if (!routeToken) {
+      routeToken = {};
+      this.routeTokens.set(key, routeToken);
+    }
+    const operation = {
+      promise: Promise.resolve(""),
+      target,
+      lifecycleGeneration: this.lifecycleGeneration,
+      routeToken
+    };
+    operation.promise = Promise.resolve().then(() => run(operation)).catch((error) => {
+      this.assertOperationCurrent(operation);
+      throw error;
+    });
+    return operation;
+  }
+  invalidateRouteOperation(key) {
+    this.routeTokens.delete(key);
+    const operation = this.creatingSessions.get(key);
+    if (!operation)
+      return;
+    this.invalidateOperation(operation);
+    this.creatingSessions.delete(key);
+  }
+  invalidateOperation(operation) {
+    operation.invalidationError ??= new Error("Session route operation was invalidated");
+  }
+  assertOperationCurrent(operation) {
+    if (operation.lifecycleGeneration !== this.lifecycleGeneration) {
+      this.invalidateOperation(operation);
+    }
+    if (operation.invalidationError) {
+      throw operation.invalidationError;
+    }
+  }
+  assertOperationResultCurrent(key, sessionId, operation) {
+    if (operation.routeToken !== this.routeTokens.get(key)) {
+      this.invalidateOperation(operation);
+    }
+    if (this.toSession.get(key) !== sessionId) {
+      this.invalidateOperation(operation);
+    }
+    this.assertOperationCurrent(operation);
+  }
+  releaseRouteToken(key, operation) {
+    if (this.routeTokens.get(key) === operation.routeToken && !this.toSession.has(key) && !this.creatingSessions.has(key)) {
+      this.routeTokens.delete(key);
+    }
+  }
+  scheduleDiscardInvalidatedSession(sessionId, operation) {
+    if ([...this.toSession.values()].includes(sessionId))
+      return;
+    try {
+      void this.bridge.discardSession?.(sessionId, operation).catch(() => void 0);
+    } catch {
+    }
+  }
   createSessionReservation() {
     let resolveReservation;
     let rejectReservation;
@@ -2750,7 +3145,7 @@ var ChannelBase = class {
     this.memoryScope = Object.freeze(this.resolveMemoryScope(name, config));
     this.channelMemory = options?.channelMemory;
     this.memoryIntentClassifier = options?.memoryIntentClassifier;
-    this.groupHistory = new GroupHistoryStore(options?.groupHistoryPath ?? join4(getGlobalQwenDir(), "channels", `${encodeURIComponent(name)}-group-history.jsonl`));
+    this.groupHistory = new GroupHistoryStore(options?.groupHistoryPath ?? join5(getGlobalQwenDir(), "channels", `${encodeURIComponent(name)}-group-history.jsonl`));
     this.loopController = options?.loopController;
     this.groupGate = new GroupGate(config.groupPolicy, config.groups);
     this.dmGate = new DmGate(config.dmPolicy);
@@ -3444,7 +3839,7 @@ ${sanitizePromptText(job.prompt)}`;
   onToolCall(_chatId, _event) {
   }
   onSessionDied(sessionId) {
-    this.router.removeSessionId(sessionId);
+    this.router.handleSessionDied(sessionId);
     this.instructedSessions.delete(sessionId);
     this.removePendingPermissionsForSession(sessionId);
   }
@@ -3492,13 +3887,16 @@ ${sanitizePromptText(job.prompt)}`;
    */
   onResponseBoundary(_chatId, _sessionId) {
   }
+  async sendResponseMessage(chatId, text, _sessionId) {
+    await this.sendMessage(chatId, text);
+  }
   /**
    * 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.
+   * Default: sends the full response text.
    */
-  async onResponseComplete(chatId, fullText, _sessionId) {
-    await this.sendMessage(chatId, fullText);
+  async onResponseComplete(chatId, fullText, sessionId) {
+    await this.sendResponseMessage(chatId, fullText, sessionId);
   }
   /**
    * Register a slash command handler. Subclasses can call this to add
@@ -4909,12 +5307,14 @@ ${promptToSend}`;
         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")
+        send: /* @__PURE__ */ __name((text) => this.sendResponseMessage(envelope.chatId, text, sessionId), "send")
       }) : null;
       promptState.stopStreaming = () => streamer?.stop();
       const heldChunks = [];
+      let hasStreamedText = false;
       const releaseHeldChunks = /* @__PURE__ */ __name(() => {
         for (const held of heldChunks.splice(0)) {
+          hasStreamedText = true;
           this.emitTaskLifecycle({
             ...this.lifecycleBase(envelope.chatId, sessionId, envelope.messageId),
             type: "text_chunk",
@@ -4938,6 +5338,7 @@ ${promptToSend}`;
           return;
         }
         heldChunks.length = 0;
+        hasStreamedText = false;
         this.onResponseBoundary(envelope.chatId, sessionId);
         streamer?.stop();
       }, "onResponseBoundary");
@@ -4956,6 +5357,9 @@ ${promptToSend}`;
         if (!promptState.cancelled && response) {
           promptState.deliveryStarted = true;
           if (streamer) {
+            if (!hasStreamedText) {
+              streamer.push(response);
+            }
             await streamer.flush();
           } else {
             await this.onResponseComplete(envelope.chatId, response, sessionId);