@qwen-code/qwen-code 0.23.1-preview.2 → 0.23.2-preview.0

package/chunks/{chunk-65GHQ4FX.js → chunk-XVTCSVBK.js}

@@ -698,6 +698,7 @@ var AcpBridge = class extends EventEmitter {
   channelLoopToolHandlers = [];
   knownSessionIds = /* @__PURE__ */ new Set();
   sessionBindingTokens = /* @__PURE__ */ new Map();
+  toolCallKindsBySession = /* @__PURE__ */ new Map();
   channelLoopMcpRegistered = false;
   channelLoopMcpRegistration = null;
   pendingPermissions = /* @__PURE__ */ new Map();
@@ -743,6 +744,7 @@ var AcpBridge = class extends EventEmitter {
       this.resolvePendingPermissions();
       this.knownSessionIds.clear();
       this.sessionBindingTokens.clear();
+      this.toolCallKindsBySession.clear();
       this.connection = null;
       this.child = null;
       this.emit("disconnected", code, signal);
@@ -906,6 +908,7 @@ var AcpBridge = class extends EventEmitter {
     if (!this.knownSessionIds.delete(sessionId))
       return;
     this.sessionBindingTokens.delete(sessionId);
+    this.toolCallKindsBySession.delete(sessionId);
     this.resolvePendingPermissions(sessionId);
     const conn = this.connection;
     if (!conn || !this.isConnected)
@@ -930,6 +933,7 @@ var AcpBridge = class extends EventEmitter {
     this.resolvePendingPermissions();
     this.knownSessionIds.clear();
     this.sessionBindingTokens.clear();
+    this.toolCallKindsBySession.clear();
     if (this.child) {
       this.child.kill();
       this.child = null;
@@ -968,19 +972,44 @@ var AcpBridge = class extends EventEmitter {
         }
         break;
       }
-      case "tool_call": {
+      case "tool_call":
+      case "tool_call_update": {
+        const toolCallId = update["toolCallId"] || "";
+        if (!toolCallId)
+          break;
+        const explicitKind = typeof update["kind"] === "string" ? update["kind"] : "";
+        const meta = update["_meta"];
+        if (type === "tool_call_update" && !explicitKind && update["status"] === "in_progress" && (meta?.["shellProgress"] !== void 0 || meta?.["subagentProgress"] === true)) {
+          break;
+        }
+        let sessionKinds = this.toolCallKindsBySession.get(sessionId);
+        const kind = explicitKind || sessionKinds?.get(toolCallId);
+        if (!kind)
+          break;
+        if (type === "tool_call" || explicitKind) {
+          const kinds = sessionKinds ?? /* @__PURE__ */ new Map();
+          kinds.set(toolCallId, kind);
+          this.toolCallKindsBySession.set(sessionId, kinds);
+          sessionKinds = kinds;
+        }
         const event = {
           sessionId,
-          toolCallId: update["toolCallId"],
-          kind: update["kind"] || "",
+          toolCallId,
+          kind,
           title: update["title"] || "",
           status: update["status"] || "pending",
           rawInput: update["rawInput"]
         };
-        if (event.status === "pending" || event.status === "in_progress") {
+        if (type === "tool_call" && (event.status === "pending" || event.status === "in_progress")) {
           this.emitResponseBoundary(sessionId);
         }
         this.emit("toolCall", event);
+        if (event.status === "completed" || event.status === "failed") {
+          sessionKinds?.delete(toolCallId);
+          if (sessionKinds?.size === 0) {
+            this.toolCallKindsBySession.delete(sessionId);
+          }
+        }
         break;
       }
       case "plan": {
@@ -1763,6 +1792,49 @@ init_esbuild_shims();
 import { chmodSync as chmodSync2, existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync as renameSync3, rmSync, unlinkSync, writeFileSync as writeFileSync3 } from "node:fs";
 import { dirname as dirname3, isAbsolute, join as join4 } from "node:path";
 import process2 from "node:process";
+function readDaemonHttpErrorCode(error) {
+  let current = error;
+  for (let depth = 0; depth < 5; depth++) {
+    if (typeof current !== "object" && typeof current !== "function" || current === null) {
+      return void 0;
+    }
+    const record = current;
+    if (record["name"] === "DaemonHttpError" && record["status"] === 409) {
+      const body = record["body"];
+      if (typeof body === "object" && body !== null && !Array.isArray(body)) {
+        const code = body["code"];
+        if (typeof code === "string" && code.length > 0)
+          return code;
+      }
+    }
+    current = record["cause"];
+  }
+  return void 0;
+}
+__name(readDaemonHttpErrorCode, "readDaemonHttpErrorCode");
+function readSupersededReplacementId(error) {
+  let current = error;
+  for (let depth = 0; depth < 5; depth++) {
+    if (typeof current !== "object" && typeof current !== "function" || current === null) {
+      return void 0;
+    }
+    const record = current;
+    if (record["name"] === "DaemonHttpError" && record["status"] === 409) {
+      const body = record["body"];
+      if (typeof body === "object" && body !== null && !Array.isArray(body)) {
+        const typedBody = body;
+        if (typedBody["code"] !== "worktree_session_superseded") {
+          return void 0;
+        }
+        const replacement = typedBody["replacementSessionId"];
+        return typeof replacement === "string" && replacement.length > 0 ? replacement : void 0;
+      }
+    }
+    current = record["cause"];
+  }
+  return void 0;
+}
+__name(readSupersededReplacementId, "readSupersededReplacementId");
 var SessionRouter = class {
   static {
     __name(this, "SessionRouter");
@@ -1773,9 +1845,11 @@ var SessionRouter = class {
   // session ID → target
   toCwd = /* @__PURE__ */ new Map();
   // session ID → cwd
+  toManagedMeta = /* @__PURE__ */ new Map();
   creatingSessions = /* @__PURE__ */ new Map();
   sessionLoadWindows = /* @__PURE__ */ new Set();
   liveSessionIds = /* @__PURE__ */ new Set();
+  staleBridgeBindings = /* @__PURE__ */ new Set();
   routeTokens = /* @__PURE__ */ new Map();
   lifecycleGeneration = 0;
   bridge;
@@ -1797,6 +1871,7 @@ var SessionRouter = class {
   setBridge(bridge) {
     this.bridge = bridge;
     this.liveSessionIds.clear();
+    this.staleBridgeBindings.clear();
   }
   /** Set scope override for a specific channel. */
   setChannelScope(channelName, scope) {
@@ -2072,12 +2147,12 @@ var SessionRouter = class {
       this.endSessionLoad(loadWindow);
     }
   }
-  async loadManagedSession(sessionId, target, workspaceCwd, expectedCwd = workspaceCwd, isolation = "shared") {
+  async loadManagedSession(sessionId, target, workspaceCwd, expectedCwd = workspaceCwd, isolation = "shared", allowSupersededRedirect = true) {
     if (this.liveSessionIds.has(sessionId)) {
       const actualCwd = this.validateManagedSessionIdentity(this.bridge, sessionId, workspaceCwd, expectedCwd, isolation);
       this.toTarget.set(sessionId, target);
       this.toCwd.set(sessionId, actualCwd);
-      return { loaded: false };
+      return { loaded: false, sessionId };
     }
     const loadWindow = this.beginSessionLoad();
     const lifecycleGeneration = this.lifecycleGeneration;
@@ -2085,6 +2160,9 @@ var SessionRouter = class {
     const bindingToken = {};
     let loadedSessionId;
     try {
+      if (this.staleBridgeBindings.delete(sessionId)) {
+        await bridge.discardSession?.(sessionId).catch(() => void 0);
+      }
       loadedSessionId = await bridge.loadSession(sessionId, workspaceCwd, this.sessionOptions(target.channelName), bindingToken);
       if (lifecycleGeneration !== this.lifecycleGeneration || bridge !== this.bridge) {
         this.scheduleManagedDiscard(bridge, loadedSessionId, bindingToken);
@@ -2104,16 +2182,105 @@ var SessionRouter = class {
       this.toTarget.set(sessionId, target);
       this.toCwd.set(sessionId, actualCwd);
       this.liveSessionIds.add(sessionId);
-      return { loaded: true };
+      return { loaded: true, sessionId };
     } catch (error) {
       if (loadedSessionId) {
         await bridge.discardSession?.(loadedSessionId, bindingToken).catch(() => void 0);
+        throw error;
+      }
+      const replacementId = readSupersededReplacementId(error);
+      if (allowSupersededRedirect && replacementId !== void 0 && replacementId !== sessionId) {
+        const redirected = await this.loadManagedSession(replacementId, target, workspaceCwd, expectedCwd, isolation, false);
+        this.healSupersededRoute(sessionId, redirected.sessionId);
+        return {
+          loaded: redirected.loaded,
+          sessionId: redirected.sessionId,
+          redirectedFrom: sessionId
+        };
       }
       throw error;
     } finally {
       this.endSessionLoad(loadWindow);
     }
   }
+  /**
+   * Remap every route that still points at a superseded session to its
+   * replacement, and drop the superseded id's bookkeeping. The manager's
+   * own task registry heals separately (it owns the task-name mapping).
+   */
+  healSupersededRoute(oldSessionId, newSessionId) {
+    let changed = false;
+    for (const [key, mappedSessionId] of this.toSession) {
+      if (mappedSessionId !== oldSessionId)
+        continue;
+      this.invalidateRouteOperation(key);
+      this.toSession.set(key, newSessionId);
+      changed = true;
+    }
+    changed = this.toTarget.delete(oldSessionId) || changed;
+    changed = this.toCwd.delete(oldSessionId) || changed;
+    const managedMeta = this.toManagedMeta.get(oldSessionId);
+    if (managedMeta !== void 0) {
+      this.toManagedMeta.set(newSessionId, managedMeta);
+      this.toManagedMeta.delete(oldSessionId);
+      changed = true;
+    }
+    this.liveSessionIds.delete(oldSessionId);
+    this.staleBridgeBindings.delete(oldSessionId);
+    if (changed)
+      this.persist();
+  }
+  /**
+   * Worktree reset: transfer the task session's checkout ownership to a
+   * fresh replacement session on the daemon, validate the replacement's
+   * attestation, and route it. The task registry itself is swapped by the
+   * named-session manager (it owns the task-name mapping); this call only
+   * wires the router's session bookkeeping.
+   *
+   * A failure past the daemon's marker flip rolls nothing back: the
+   * registry keeps pointing at the old id, and the next selection's load
+   * heals it through the superseded redirect — the failed reset drops the
+   * old id from the live set so that load consults the daemon again.
+   */
+  async replaceManagedWorktreeSession(sessionId, target, workspaceCwd, expectedCwd) {
+    const bridge = this.bridge;
+    if (!bridge.resetWorktreeSession) {
+      throw new Error("Worktree reset is not supported by this bridge");
+    }
+    const loadWindow = this.beginSessionLoad();
+    const lifecycleGeneration = this.lifecycleGeneration;
+    const bindingToken = {};
+    let replacementId;
+    try {
+      replacementId = await bridge.resetWorktreeSession(sessionId, workspaceCwd, this.sessionOptions(target.channelName), bindingToken);
+      if (lifecycleGeneration !== this.lifecycleGeneration || bridge !== this.bridge) {
+        this.scheduleManagedDiscard(bridge, replacementId, bindingToken);
+        throw new Error("Managed session reset was invalidated");
+      }
+      if (typeof replacementId !== "string" || replacementId.length === 0) {
+        throw new Error("Invalid session ID from bridge");
+      }
+      if (loadWindow.delete(replacementId)) {
+        await bridge.discardSession?.(replacementId, bindingToken);
+        throw new Error(`Managed session ${replacementId} died before reset completed`);
+      }
+      const actualCwd = this.validateManagedSessionIdentity(bridge, replacementId, workspaceCwd, expectedCwd, "worktree");
+      this.toTarget.set(replacementId, target);
+      this.toCwd.set(replacementId, actualCwd);
+      this.liveSessionIds.add(replacementId);
+      this.forgetManagedSession(sessionId);
+      return replacementId;
+    } catch (error) {
+      if (replacementId !== void 0) {
+        await bridge.discardSession?.(replacementId, bindingToken).catch(() => void 0);
+      }
+      this.staleBridgeBindings.add(sessionId);
+      this.liveSessionIds.delete(sessionId);
+      throw error;
+    } finally {
+      this.endSessionLoad(loadWindow);
+    }
+  }
   validateManagedSessionIdentity(bridge, sessionId, workspaceCwd, expectedCwd, isolation) {
     if (isolation === "shared") {
       return workspaceCwd;
@@ -2126,10 +2293,26 @@ var SessionRouter = class {
     }
     return canonicalWorktree;
   }
-  activateManagedSession(sessionId, target, cwd) {
+  activateManagedSession(sessionId, target, cwd, managed) {
+    if (managed?.isolation === "worktree" && !managed.workspaceCwd) {
+      throw new Error("A worktree managed session requires its workspace cwd.");
+    }
+    const previousMeta = this.toManagedMeta.get(sessionId);
+    if (managed?.isolation === "worktree") {
+      this.toManagedMeta.set(sessionId, {
+        isolation: "worktree",
+        workspaceCwd: managed.workspaceCwd
+      });
+    } else {
+      this.toManagedMeta.delete(sessionId);
+    }
+    const metaChanged = managed?.isolation === "worktree" ? previousMeta?.workspaceCwd !== managed.workspaceCwd : previousMeta !== void 0;
     const key = this.routingKey(target.channelName, target.senderId, target.chatId, target.threadId);
-    if (this.toSession.get(key) === sessionId)
+    if (this.toSession.get(key) === sessionId) {
+      if (metaChanged)
+        this.persist();
       return;
+    }
     this.invalidateRouteOperation(key);
     this.toSession.set(key, sessionId);
     this.toTarget.set(sessionId, target);
@@ -2147,17 +2330,18 @@ var SessionRouter = class {
     }
     changed = this.toTarget.delete(sessionId) || changed;
     changed = this.toCwd.delete(sessionId) || changed;
+    changed = this.toManagedMeta.delete(sessionId) || changed;
     changed = this.liveSessionIds.delete(sessionId) || changed;
+    this.staleBridgeBindings.delete(sessionId);
     if (changed)
       this.persist();
   }
   async detachManagedSession(sessionId) {
     try {
-      if (this.liveSessionIds.has(sessionId)) {
-        if (!this.bridge.discardSession) {
-          throw new Error("Managed session detach is not supported");
-        }
+      if (this.bridge.discardSession) {
         await this.bridge.discardSession(sessionId);
+      } else if (this.liveSessionIds.has(sessionId)) {
+        throw new Error("Managed session detach is not supported");
       }
     } finally {
       this.forgetManagedSession(sessionId);
@@ -2213,6 +2397,9 @@ var SessionRouter = class {
     if (this.toCwd.delete(sessionId)) {
       removed = true;
     }
+    if (this.toManagedMeta.delete(sessionId)) {
+      removed = true;
+    }
     this.liveSessionIds.delete(sessionId);
     if (!removed && this.sessionLoadWindows.size > 0) {
       for (const loadWindow of this.sessionLoadWindows) {
@@ -2242,6 +2429,7 @@ var SessionRouter = class {
     this.toSession.delete(key);
     this.toTarget.delete(sessionId);
     this.toCwd.delete(sessionId);
+    this.toManagedMeta.delete(sessionId);
     this.liveSessionIds.delete(sessionId);
     return sessionId;
   }
@@ -2278,6 +2466,12 @@ var SessionRouter = class {
       this.toSession.set(key, entry.sessionId);
       this.toTarget.set(entry.sessionId, entry.target);
       this.toCwd.set(entry.sessionId, entry.cwd);
+      if (entry.isolation === "worktree" && entry.workspaceCwd !== void 0) {
+        this.toManagedMeta.set(entry.sessionId, {
+          isolation: "worktree",
+          workspaceCwd: entry.workspaceCwd
+        });
+      }
       restored++;
     }
     if (persisted.dropped > 0)
@@ -2321,6 +2515,32 @@ var SessionRouter = class {
         try {
           this.assertOperationCurrent(operation);
           const options = this.sessionOptions(entry.target.channelName);
+          if (entry.isolation === "worktree" && entry.workspaceCwd !== void 0) {
+            const managed = await this.loadManagedSession(entry.sessionId, entry.target, entry.workspaceCwd, entry.cwd, "worktree");
+            try {
+              this.assertOperationCurrent(operation);
+            } catch (error) {
+              if (![...this.toSession.values()].includes(managed.sessionId)) {
+                void this.bridge.discardSession?.(managed.sessionId).catch(() => void 0);
+                this.toTarget.delete(managed.sessionId);
+                this.toCwd.delete(managed.sessionId);
+                this.toManagedMeta.delete(managed.sessionId);
+                this.liveSessionIds.delete(managed.sessionId);
+              }
+              throw error;
+            }
+            this.toSession.set(key, managed.sessionId);
+            this.toManagedMeta.set(managed.sessionId, {
+              isolation: "worktree",
+              workspaceCwd: entry.workspaceCwd
+            });
+            reservation.resolve(managed.sessionId);
+            if (managed.sessionId !== entry.sessionId) {
+              changed = true;
+            }
+            restored++;
+            continue;
+          }
           const sessionId = await this.bridge.loadSession(entry.sessionId, entry.cwd, options, operation);
           try {
             this.assertOperationCurrent(operation);
@@ -2373,9 +2593,11 @@ var SessionRouter = class {
     this.toSession.clear();
     this.toTarget.clear();
     this.toCwd.clear();
+    this.toManagedMeta.clear();
     this.creatingSessions.clear();
     this.sessionLoadWindows.clear();
     this.liveSessionIds.clear();
+    this.staleBridgeBindings.clear();
     this.routeTokens.clear();
   }
   /** Clear in-memory state and delete persist file. Used on clean shutdown. */
@@ -2433,7 +2655,12 @@ var SessionRouter = class {
     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");
+    const wellFormed = 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");
+    if (!wellFormed)
+      return false;
+    if (entry["isolation"] === void 0)
+      return true;
+    return entry["isolation"] === "worktree" && typeof entry["workspaceCwd"] === "string" && entry["workspaceCwd"].length > 0;
   }
   persist() {
     if (!this.persistPath)
@@ -2446,7 +2673,8 @@ var SessionRouter = class {
       data[key] = {
         sessionId,
         target,
-        cwd: this.toCwd.get(sessionId) ?? this.defaultCwd
+        cwd: this.toCwd.get(sessionId) ?? this.defaultCwd,
+        ...this.toManagedMeta.get(sessionId) ?? {}
       };
     }
     const dir = dirname3(this.persistPath);
@@ -2594,6 +2822,16 @@ import process3 from "node:process";
 var REGISTRY_VERSION = 1;
 var MAX_OPEN_TASKS = 8;
 var TASK_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]{0,31}$/;
+var NamedSessionTaskError = class extends Error {
+  static {
+    __name(this, "NamedSessionTaskError");
+  }
+  taskName;
+  constructor(message, taskName, options) {
+    super(message, options);
+    this.taskName = taskName;
+  }
+};
 var NamedSessionManager = class {
   static {
     __name(this, "NamedSessionManager");
@@ -2608,6 +2846,12 @@ var NamedSessionManager = class {
   registry;
   taskBySessionId;
   ownerOperations = /* @__PURE__ */ new Map();
+  /**
+   * Superseded session id → the replacement its task moved onto. A queued turn
+   * stays bound to the id it reserved, so the reservation lookup has to follow
+   * the task or every turn after the first one is stranded on the old id.
+   */
+  supersededSessionIds = /* @__PURE__ */ new Map();
   constructor(options) {
     this.channelName = options.channelName;
     this.cwd = options.cwd;
@@ -2706,14 +2950,20 @@ var NamedSessionManager = class {
       return task ? this.selection(owner, task) : void 0;
     });
   }
+  /**
+   * Reload a task a queued turn is already bound to. Resolves to the session
+   * id the caller must dispatch on — the healed replacement when a superseded
+   * redirect fired — or undefined when the task is no longer reservable.
+   */
   resumeReserved(input, sessionId) {
     return this.withOwnerLock(input, async () => {
       const owner = await this.ensureOwner(input, false);
-      const task = owner?.tasks.find((candidate) => candidate.sessionId === sessionId && candidate.status === "open");
+      const reservedSessionId = this.supersededSessionIds.get(sessionId) ?? sessionId;
+      const task = owner?.tasks.find((candidate) => candidate.sessionId === reservedSessionId && candidate.status === "open");
       if (!task)
-        return false;
-      await this.loadTask(task, `Could not reload reserved task "${task.name}".`);
-      return true;
+        return void 0;
+      const result = await this.loadTask(task, `Could not reload reserved task "${task.name}".`);
+      return result.sessionId;
     });
   }
   create(input, name, isolation = "shared") {
@@ -2757,7 +3007,10 @@ var NamedSessionManager = class {
         await this.router.detachManagedSession(sessionId).catch(() => void 0);
         throw error;
       }
-      this.router.activateManagedSession(sessionId, target, task.cwd);
+      this.router.activateManagedSession(sessionId, target, task.cwd, {
+        isolation: task.isolation,
+        workspaceCwd: this.cwd
+      });
       return this.selection(nextOwner, task);
     });
   }
@@ -2773,9 +3026,10 @@ var NamedSessionManager = class {
         throw new Error("You already have eight open tasks. Close one before reopening another.");
       }
       const timestamp = this.nextTimestamp(owner);
-      const loaded = await this.loadTask(task, `Could not load task "${task.name}". The current task was not changed.`);
+      const loadResult = await this.loadTask(task, `Could not load task "${task.name}". The current task was not changed.`);
       const updatedTask = {
         ...task,
+        sessionId: loadResult.sessionId,
         status: "open",
         updatedAt: timestamp,
         lastSelectedAt: timestamp
@@ -2784,12 +3038,12 @@ var NamedSessionManager = class {
       try {
         this.commitOwner(nextOwner);
       } catch (error) {
-        if (loaded) {
-          await this.router.detachManagedSession(task.sessionId).catch(() => void 0);
+        if (loadResult.loaded) {
+          await this.router.detachManagedSession(loadResult.sessionId).catch(() => void 0);
         }
         throw error;
       }
-      this.router.activateManagedSession(task.sessionId, task.target, task.cwd);
+      this.router.activateManagedSession(loadResult.sessionId, updatedTask.target, updatedTask.cwd, { isolation: updatedTask.isolation, workspaceCwd: this.cwd });
       return this.selection(nextOwner, updatedTask);
     });
   }
@@ -2811,8 +3065,11 @@ var NamedSessionManager = class {
       const timestamp = this.nextTimestamp(owner);
       const replacement = wasActive ? owner.tasks.filter((candidate) => candidate.status === "open" && !this.sameName(candidate.name, task.name)).sort((a, b) => b.lastSelectedAt - a.lastSelectedAt)[0] : void 0;
       let replacementLoaded = false;
+      let replacementSessionId;
       if (replacement) {
-        replacementLoaded = await this.loadTask(replacement, `Could not load fallback task "${replacement.name}". Task "${task.name}" was not closed.`);
+        const replacementLoad = await this.loadTask(replacement, `Could not load fallback task "${replacement.name}". Task "${task.name}" was not closed.`);
+        replacementLoaded = replacementLoad.loaded;
+        replacementSessionId = replacementLoad.sessionId;
       }
       const closedTask = {
         ...task,
@@ -2822,6 +3079,7 @@ var NamedSessionManager = class {
       let nextOwner = this.replaceTask(owner, closedTask, wasActive ? replacement?.name ?? null : owner.activeTaskName);
       const selectedReplacement = replacement ? {
         ...replacement,
+        sessionId: replacementSessionId ?? replacement.sessionId,
         updatedAt: timestamp,
         lastSelectedAt: timestamp
       } : void 0;
@@ -2832,21 +3090,22 @@ var NamedSessionManager = class {
         this.commitOwner(nextOwner);
       } catch (error) {
         if (replacement && replacementLoaded) {
-          await this.router.detachManagedSession(replacement.sessionId).catch(() => void 0);
+          await this.router.detachManagedSession(replacementSessionId ?? replacement.sessionId).catch(() => void 0);
         }
         throw error;
       }
       if (replacement) {
-        this.router.activateManagedSession(replacement.sessionId, replacement.target, replacement.cwd);
+        this.router.activateManagedSession(replacementSessionId ?? replacement.sessionId, replacement.target, replacement.cwd, { isolation: replacement.isolation, workspaceCwd: this.cwd });
       }
       try {
         await this.router.detachManagedSession(task.sessionId);
       } catch (error) {
-        this.commitOwner(owner);
+        const healedReplacement = replacement !== void 0 && replacementSessionId !== void 0 && replacementSessionId !== replacement.sessionId ? { ...replacement, sessionId: replacementSessionId } : void 0;
+        this.commitOwner(healedReplacement ? this.replaceTask(owner, healedReplacement, owner.activeTaskName) : owner);
         this.router.forgetManagedSession(task.sessionId);
-        await this.loadTask(task, `Task "${task.name}" could not be restored after close failed.`);
+        const restored = await this.loadTask(task, `Task "${task.name}" could not be restored after close failed.`);
         if (wasActive) {
-          this.router.activateManagedSession(task.sessionId, task.target, task.cwd);
+          this.router.activateManagedSession(restored.sessionId, task.target, task.cwd, { isolation: task.isolation, workspaceCwd: this.cwd });
         }
         throw new Error(`Failed to close task "${task.name}".`, {
           cause: error
@@ -2867,10 +3126,36 @@ var NamedSessionManager = class {
       const task = this.findTask(owner, owner.activeTaskName);
       if (!task || task.status !== "open")
         return void 0;
+      const timestamp = this.nextTimestamp(owner);
       if (task.isolation === "worktree") {
-        throw new Error(`Task "${task.name}" uses a worktree and cannot be cleared or reset yet. Continue using the task or close it. Its files were not changed.`);
+        if (this.isBusy(task.sessionId)) {
+          throw new Error(`Task "${task.name}" is busy. Wait for the running prompt to finish (or cancel it), then try again.`);
+        }
+        const sessionId2 = await this.resetWorktreeSession(task);
+        const updatedTask2 = {
+          ...task,
+          sessionId: sessionId2,
+          updatedAt: timestamp,
+          lastSelectedAt: timestamp
+        };
+        const nextOwner2 = this.replaceTask(owner, updatedTask2, task.name);
+        try {
+          this.commitOwner(nextOwner2);
+        } catch (error) {
+          await this.router.detachManagedSession(sessionId2).catch(() => void 0);
+          throw error;
+        }
+        this.router.activateManagedSession(sessionId2, updatedTask2.target, updatedTask2.cwd, { isolation: updatedTask2.isolation, workspaceCwd: this.cwd });
+        this.router.forgetManagedSession(task.sessionId);
+        this.repointSupersededSessionIds(task.sessionId, sessionId2);
+        this.supersededSessionIds.delete(task.sessionId);
+        return {
+          name: task.name,
+          previousSessionId: task.sessionId,
+          sessionId: sessionId2,
+          worktreeKept: true
+        };
       }
-      const timestamp = this.nextTimestamp(owner);
       const sessionId = await this.createSession(task.target, task.isolation, `Could not reset task "${task.name}".`);
       const updatedTask = {
         ...task,
@@ -2885,12 +3170,15 @@ var NamedSessionManager = class {
         await this.router.detachManagedSession(sessionId).catch(() => void 0);
         throw error;
       }
-      this.router.activateManagedSession(sessionId, updatedTask.target, updatedTask.cwd);
+      this.router.activateManagedSession(sessionId, updatedTask.target, updatedTask.cwd, { isolation: updatedTask.isolation, workspaceCwd: this.cwd });
       this.router.forgetManagedSession(task.sessionId);
+      this.repointSupersededSessionIds(task.sessionId, sessionId);
+      this.supersededSessionIds.delete(task.sessionId);
       return {
         name: task.name,
         previousSessionId: task.sessionId,
-        sessionId
+        sessionId,
+        worktreeKept: false
       };
     });
   }
@@ -2960,12 +3248,17 @@ var NamedSessionManager = class {
       throw new Error("The selected Channel task is unavailable.");
     }
     const release = reserve?.(task.sessionId);
+    let activeRelease = release;
     try {
-      await this.loadTask(task, `Could not load task "${task.name}". No replacement session was created.`);
-      this.router.activateManagedSession(task.sessionId, task.target, task.cwd);
-      return task.sessionId;
+      const result = await this.loadTask(task, `Could not load task "${task.name}". No replacement session was created.`);
+      if (result.sessionId !== task.sessionId && reserve) {
+        release?.();
+        activeRelease = reserve(result.sessionId);
+      }
+      this.router.activateManagedSession(result.sessionId, task.target, task.cwd, { isolation: task.isolation, workspaceCwd: this.cwd });
+      return result.sessionId;
     } catch (error) {
-      release?.();
+      activeRelease?.();
       throw error;
     }
   }
@@ -2998,9 +3291,55 @@ var NamedSessionManager = class {
   }
   async loadTask(task, failureMessage) {
     try {
-      return (await this.router.loadManagedSession(task.sessionId, task.target, this.cwd, task.cwd, task.isolation)).loaded;
+      const result = await this.router.loadManagedSession(task.sessionId, task.target, this.cwd, task.cwd, task.isolation);
+      if (result.redirectedFrom !== void 0 && result.sessionId !== task.sessionId) {
+        try {
+          this.healSupersededTask(task, result.sessionId);
+        } catch {
+        }
+      }
+      return result;
     } catch (error) {
-      throw new Error(failureMessage, { cause: error });
+      throw new NamedSessionTaskError(failureMessage, task.name, {
+        cause: error
+      });
+    }
+  }
+  /**
+   * Point a task at its replacement session after a superseded redirect
+   * healed the route. No-op when the registry entry already moved on (a
+   * concurrent reset under the same owner lock cannot interleave, but a
+   * stale in-memory snapshot could).
+   */
+  healSupersededTask(task, sessionId) {
+    const owner = this.getOwner(task.target);
+    if (!owner)
+      return;
+    const current = this.findTask(owner, task.name);
+    if (!current || current.sessionId !== task.sessionId)
+      return;
+    const timestamp = this.nextTimestamp(owner);
+    this.commitOwner(this.replaceTask(owner, { ...current, sessionId, updatedAt: timestamp }, owner.activeTaskName));
+    this.repointSupersededSessionIds(task.sessionId, sessionId);
+    this.supersededSessionIds.set(task.sessionId, sessionId);
+  }
+  /**
+   * Follow every id that still resolves to `oldSessionId` onto its
+   * replacement, so a task superseded more than once stays reachable from the
+   * oldest id a turn is bound to and the map does not grow once per reset.
+   */
+  repointSupersededSessionIds(oldSessionId, newSessionId) {
+    for (const boundSessionId of [...this.supersededSessionIds.keys()]) {
+      if (this.supersededSessionIds.get(boundSessionId) === oldSessionId) {
+        this.supersededSessionIds.set(boundSessionId, newSessionId);
+      }
+    }
+  }
+  async resetWorktreeSession(task) {
+    try {
+      return await this.router.replaceManagedWorktreeSession(task.sessionId, task.target, this.cwd, task.cwd);
+    } catch (error) {
+      throw new NamedSessionTaskError(`Could not reset task "${task.name}".`, task.name, { cause: error });
     }
   }
   async createSession(target, isolation, failureMessage) {
@@ -4088,6 +4427,9 @@ var ChannelBase = class {
   bridgeSessionDiedListener = /* @__PURE__ */ __name((event) => {
     this.onSessionDied(event.sessionId);
   }, "bridgeSessionDiedListener");
+  bridgeDisconnectedListener = /* @__PURE__ */ __name(() => {
+    this.onBridgeDisconnected();
+  }, "bridgeDisconnectedListener");
   bridgePermissionRequestListener = /* @__PURE__ */ __name((event) => {
     void this.dispatchPermissionRequest(event).catch((err) => {
       process.stderr.write(`[${this.name}] permission relay failed for request ${sanitizeLogText(event.requestId, 128)}: ${this.lifecycleError(err)}
@@ -5570,12 +5912,21 @@ ${promptText}` : promptText;
     this.unattendedMemorySessions.delete(sessionId);
     this.removePendingPermissionsForSession(sessionId);
   }
+  /**
+   * Called when the standalone ACP bridge process exits. Its in-flight turns
+   * never settle, but crash recovery restores the sessions on a fresh bridge,
+   * so overrides must clear only turn-scoped transient state (never session
+   * routing) and must not fabricate terminal outcomes for interrupted turns.
+   */
+  onBridgeDisconnected() {
+  }
   onSessionRetiring(_sessionId) {
   }
   attachBridgeEvents(bridge) {
     bridge.on("toolCall", this.bridgeToolCallListener);
     bridge.on("backgroundResponse", this.bridgeBackgroundResponseListener);
     bridge.on("sessionDied", this.bridgeSessionDiedListener);
+    bridge.on("disconnected", this.bridgeDisconnectedListener);
     bridge.on("permissionRequest", this.bridgePermissionRequestListener);
     bridge.on("permissionResolved", this.bridgePermissionResolvedListener);
   }
@@ -5583,6 +5934,7 @@ ${promptText}` : promptText;
     bridge.off("toolCall", this.bridgeToolCallListener);
     bridge.off("backgroundResponse", this.bridgeBackgroundResponseListener);
     bridge.off("sessionDied", this.bridgeSessionDiedListener);
+    bridge.off("disconnected", this.bridgeDisconnectedListener);
     bridge.off("permissionRequest", this.bridgePermissionRequestListener);
     bridge.off("permissionResolved", this.bridgePermissionResolvedListener);
   }
@@ -6020,6 +6372,21 @@ ${requestList}`);
     binding.released = true;
     this.releaseQueuedTurn(binding.sessionId);
   }
+  /**
+   * Follow a task onto the session its reload healed to (a superseded
+   * redirect). The queue reservation and the staleness generation are keyed
+   * by session id, so both must move with the binding: leaving them behind
+   * keeps the stale id "busy" forever and drops the turn on a generation the
+   * replacement never had.
+   */
+  moveNamedTurnBinding(binding, sessionId) {
+    if (binding.sessionId !== null) {
+      this.releaseQueuedTurn(binding.sessionId);
+    }
+    binding.sessionId = sessionId;
+    binding.generation = this.sessionGenerations.get(sessionId) ?? 0;
+    this.reserveQueuedTurn(sessionId);
+  }
   finishNamedTurnBinding(envelope) {
     const binding = this.namedTurnBindings.get(envelope);
     if (!binding)
@@ -6075,12 +6442,51 @@ ${requestList}`);
       return true;
     }
   }
+  /**
+   * The actionable recovery message for a worktree task whose ownership state
+   * the daemon refused to restore. Both codes come from the load/resume route
+   * — the reset route resumes an interrupted transfer itself and reports a
+   * broken marker as invalid state — so they surface on selection and on a
+   * message, wrapped in the manager's generic load failure.
+   *
+   * Clearing always acts on the *selected* task, so pointing the user at a
+   * clear is only safe when the task that failed is the selected one. Aimed at
+   * any other task it would run a full ownership transfer against a healthy
+   * one and destroy that conversation, so the alternative points at the close
+   * that works on the broken task without loading it. Both name that task.
+   */
+  async worktreeRecoveryMessage(envelope, error) {
+    const code = readDaemonHttpErrorCode(error);
+    if (code !== "worktree_reset_interrupted" && code !== "worktree_marker_missing") {
+      return void 0;
+    }
+    const interrupted = code === "worktree_reset_interrupted";
+    const failedTaskName = error instanceof NamedSessionTaskError ? error.taskName : void 0;
+    const safeTaskName = failedTaskName === void 0 ? void 0 : sanitizeDisplayText(failedTaskName, 32);
+    const subject = safeTaskName === void 0 ? "The task" : `Task "${safeTaskName}"`;
+    const problem = interrupted ? "was interrupted while being reset" : "cannot verify its worktree because its ownership marker is missing";
+    if (safeTaskName !== void 0 && failedTaskName === await this.selectedTaskName(envelope)) {
+      return `${subject} ${problem}. Its files were not changed. ${interrupted ? "Clear the task again to finish the reset." : "Clear the task to restart it in the same worktree, or close it."}`;
+    }
+    const remedy = safeTaskName === void 0 ? "select this task first or close it" : `select this task first or close it with ${this.prefixedCommand(`/session close ${safeTaskName}`)}`;
+    return `${subject} ${problem}. Its files were not changed. Clearing now would reset the selected task instead, so ${remedy}.`;
+  }
+  async selectedTaskName(envelope) {
+    const namedSessions = this.namedSessions;
+    if (!namedSessions)
+      return void 0;
+    try {
+      return (await namedSessions.current(this.namedSessionOwner(envelope)))?.name;
+    } catch {
+      return void 0;
+    }
+  }
   async sendNamedSessionError(envelope, error) {
     if (error instanceof Error && error.cause !== void 0) {
       process.stderr.write(`[${sanitizeLogText(this.name, 64)}] named-session operation failed: ${this.lifecycleError(error)} | cause: ${this.lifecycleError(error.cause)}
 `);
     }
-    const message = error instanceof Error ? sanitizeDisplayText(error.message, 500) : "Named-session operation failed.";
+    const message = await this.worktreeRecoveryMessage(envelope, error) ?? (error instanceof Error ? sanitizeDisplayText(error.message, 500) : "Named-session operation failed.");
     await this.sendThreadMessage(envelope.chatId, envelope.threadId, message || "Named-session operation failed.");
   }
   async handleNamedSessionsCommand(envelope, args) {
@@ -6125,7 +6531,7 @@ ${requestList}`);
         }
         case "new": {
           const isolation = parts.length === 2 && parts[1] === "--worktree" ? "worktree" : "shared";
-          if (isolation === "shared" && parts.length !== 1 || isolation === "worktree" && parts.length !== 2) {
+          if (isolation === "shared" && parts.length !== 1 || isolation === "worktree" && parts.length !== 2 || parts[0]?.startsWith("-")) {
             break;
           }
           const created = await namedSessions.create(owner, parts[0], isolation);
@@ -6186,6 +6592,7 @@ ${requestList}`);
   registerSharedCommands() {
     const doClear = /* @__PURE__ */ __name(async (envelope) => {
       let resetTaskName;
+      let resetWorktreeKept = false;
       let removedIds;
       const retiringSessionId = this.namedSessions ? void 0 : this.router.getSession(this.name, envelope.senderId, envelope.chatId, envelope.threadId);
       if (retiringSessionId)
@@ -6194,8 +6601,18 @@ ${requestList}`);
         try {
           const reset = await this.namedSessions.reset(this.namedSessionOwner(envelope));
           resetTaskName = reset?.name;
+          resetWorktreeKept = reset?.worktreeKept ?? false;
           removedIds = reset ? [reset.previousSessionId] : [];
         } catch (error) {
+          const code = readDaemonHttpErrorCode(error);
+          if (code !== void 0) {
+            process.stderr.write(`[${sanitizeLogText(this.name, 64)}] worktree reset failed (${sanitizeLogText(code, 64)}): ${this.lifecycleError(error)}
+`);
+          }
+          if (code === "worktree_reset_active") {
+            await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Task is busy. Wait for the running prompt to finish (or cancel it), then try again.");
+            return;
+          }
           await this.sendNamedSessionError(envelope, error);
           return;
         }
@@ -6250,7 +6667,7 @@ ${requestList}`);
           }
           this.discardRetiredSession(this.bridge, id, "cleared");
         }
-        await this.sendThreadMessage(envelope.chatId, envelope.threadId, resetTaskName ? `Task "${resetTaskName}" reset with a fresh conversation.` : "Session cleared. The next message starts a fresh conversation.");
+        await this.sendThreadMessage(envelope.chatId, envelope.threadId, resetTaskName ? resetWorktreeKept ? `Task "${resetTaskName}" reset with a fresh conversation; its worktree and files were kept.` : `Task "${resetTaskName}" reset with a fresh conversation.` : "Session cleared. The next message starts a fresh conversation.");
       } else {
         await this.sendThreadMessage(envelope.chatId, envelope.threadId, "No active session to clear.");
       }
@@ -7775,8 +8192,10 @@ ${text}`;
         return;
       }
       try {
-        const resumed = await this.namedSessions.resumeReserved(this.namedSessionOwner(envelope), namedTurn.sessionId);
-        sessionId = resumed ? namedTurn.sessionId : void 0;
+        sessionId = await this.namedSessions.resumeReserved(this.namedSessionOwner(envelope), namedTurn.sessionId);
+        if (sessionId && sessionId !== namedTurn.sessionId) {
+          this.moveNamedTurnBinding(namedTurn, sessionId);
+        }
       } catch (error) {
         await this.sendNamedSessionError(envelope, error);
         return;
@@ -8489,6 +8908,7 @@ var DaemonChannelBridge = class extends EventEmitter2 {
   activePrompts = /* @__PURE__ */ new Set();
   activePromptControllers = /* @__PURE__ */ new Map();
   availableCommandsBySession = /* @__PURE__ */ new Map();
+  toolCallKindsBySession = /* @__PURE__ */ new Map();
   turnBarriers = /* @__PURE__ */ new Map();
   channelLoopToolHandlers = [];
   channelLoopDisabledSessions = /* @__PURE__ */ new Set();
@@ -8595,6 +9015,38 @@ var DaemonChannelBridge = class extends EventEmitter2 {
     }
     return session.sessionId;
   }
+  /**
+   * Transfer a worktree session's checkout ownership to a fresh replacement
+   * session (daemon `session_worktree_reset_v1`). The returned id is the
+   * replacement's; the superseded session's clients stay bound to it (and
+   * are forgotten by the caller). Gated on the capability flag so a daemon
+   * without reset support fails before any session is created.
+   */
+  async resetWorktreeSession(sessionId, cwd, options, bindingToken) {
+    if (!this.options.sessionWorktreeReset) {
+      throw new Error("The daemon does not support worktree reset for Channel tasks.");
+    }
+    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 } : {},
+      ...options?.sourceId ? { sourceId: options.sourceId } : {},
+      worktreeReset: { sessionId }
+    });
+    if (lifecycleGeneration !== this.lifecycleGeneration) {
+      await this.rejectStaleSession(session);
+    }
+    this.attachSession(session, bindingToken);
+    if (options?.enableChannelLoops === false) {
+      this.channelLoopDisabledSessions.add(session.sessionId);
+      void this.reconcileChannelLoopMcpForSession(session.sessionId);
+    } else {
+      await this.reconcileChannelLoopMcpForSession(session.sessionId);
+    }
+    return session.sessionId;
+  }
   registerChannelLoopToolHandler(handler) {
     if (!this.channelLoopToolHandlers.includes(handler)) {
       this.channelLoopToolHandlers.push(handler);
@@ -9001,15 +9453,23 @@ var DaemonChannelBridge = class extends EventEmitter2 {
       case "tool_call":
       case "tool_call_update": {
         const toolCallId = getString(update["toolCallId"]);
-        const kind = getString(update["kind"]);
+        const explicitKind = getString(update["kind"]);
         const meta = isRecord3(update["_meta"]) ? update["_meta"] : void 0;
-        if (!kind && toolCallId && getString(update["status"]) === "in_progress" && (meta?.["shellProgress"] !== void 0 || meta?.["subagentProgress"] === true)) {
+        if (!explicitKind && toolCallId && getString(update["status"]) === "in_progress" && (meta?.["shellProgress"] !== void 0 || meta?.["subagentProgress"] === true)) {
           break;
         }
+        let sessionKinds = this.toolCallKindsBySession.get(sessionId);
+        const kind = explicitKind || sessionKinds?.get(toolCallId ?? "");
         if (!toolCallId || !kind) {
           this.emitProtocolError(`Malformed daemon ${type} event`, update);
           break;
         }
+        if (type === "tool_call" || explicitKind) {
+          const kinds = sessionKinds ?? /* @__PURE__ */ new Map();
+          kinds.set(toolCallId, kind);
+          this.toolCallKindsBySession.set(sessionId, kinds);
+          sessionKinds = kinds;
+        }
         const event = {
           sessionId,
           toolCallId,
@@ -9022,6 +9482,12 @@ var DaemonChannelBridge = class extends EventEmitter2 {
           this.emitResponseBoundary(sessionId);
         }
         this.emit("toolCall", event);
+        if (event.status === "completed" || event.status === "failed") {
+          sessionKinds?.delete(toolCallId);
+          if (sessionKinds?.size === 0) {
+            this.toolCallKindsBySession.delete(sessionId);
+          }
+        }
         break;
       }
       case "plan": {
@@ -9149,6 +9615,7 @@ var DaemonChannelBridge = class extends EventEmitter2 {
     this.abortActivePrompts(sessionId);
     this.activePrompts.delete(sessionId);
     this.availableCommandsBySession.delete(sessionId);
+    this.toolCallKindsBySession.delete(sessionId);
     if (this.latestAvailableCommandsSessionId === sessionId) {
       this.latestAvailableCommandsSessionId = Array.from(this.availableCommandsBySession.keys()).at(-1);
     }