@qwen-code/qwen-code 0.23.1-preview.2 → 0.23.2-nightly.20260909.2e212144d3

package/chunks/{chunk-65GHQ4FX.js → chunk-WDVV3LRM.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": {
@@ -1216,118 +1245,6 @@ init_esbuild_shims();
 import { basename as basename3, join as join5 } from "node:path";
 import { randomUUID as randomUUID3 } from "node:crypto";
 
-// packages/channels/base/dist/BlockStreamer.js
-init_esbuild_shims();
-var BlockStreamer = class {
-  static {
-    __name(this, "BlockStreamer");
-  }
-  buffer = "";
-  idleTimer = null;
-  sending = Promise.resolve();
-  opts;
-  /** Number of blocks emitted so far. */
-  blockCount = 0;
-  constructor(opts) {
-    this.opts = opts;
-  }
-  /** Feed a new text chunk from the agent stream. */
-  push(chunk) {
-    this.buffer += chunk;
-    this.clearIdleTimer();
-    this.checkEmit();
-    if (this.buffer.length > 0 && this.opts.idleMs > 0) {
-      this.idleTimer = setTimeout(() => this.onIdle(), this.opts.idleMs);
-    }
-  }
-  /** Flush all remaining buffered text. Awaits all pending sends. */
-  async flush() {
-    this.clearIdleTimer();
-    if (this.buffer.length > 0) {
-      this.emitBlock(this.buffer);
-      this.buffer = "";
-    }
-    await this.sending;
-  }
-  /** Drop buffered text and cancel future idle emission. */
-  stop() {
-    this.clearIdleTimer();
-    this.buffer = "";
-  }
-  /** Await already-queued sends without emitting the buffered text. */
-  async drain() {
-    await this.sending;
-  }
-  // ---------------------------------------------------------------------------
-  // Internal
-  // ---------------------------------------------------------------------------
-  checkEmit() {
-    while (this.buffer.length >= this.opts.maxChars) {
-      const bp = this.findBreakPoint(this.buffer, this.opts.maxChars);
-      this.emitBlock(this.buffer.slice(0, bp));
-      this.buffer = this.buffer.slice(bp);
-    }
-    if (this.buffer.length >= this.opts.minChars) {
-      const bp = this.findBlockBoundary(this.buffer);
-      if (bp > 0) {
-        this.emitBlock(this.buffer.slice(0, bp));
-        this.buffer = this.buffer.slice(bp);
-      }
-    }
-  }
-  onIdle() {
-    this.idleTimer = null;
-    if (this.buffer.length >= this.opts.minChars) {
-      this.emitBlock(this.buffer);
-      this.buffer = "";
-    }
-  }
-  emitBlock(text) {
-    const trimmed = text.trim();
-    if (!trimmed)
-      return;
-    const block = /\n[^\S\n]*$/.test(text) ? `${trimmed}
-` : trimmed;
-    this.blockCount++;
-    this.sending = this.sending.then(() => this.opts.send(block)).catch(() => {
-    });
-  }
-  /**
-   * Find the last paragraph boundary (\n\n) in the buffer.
-   * Returns the position after the boundary, or -1 if no suitable boundary
-   * exists at or after minChars.
-   */
-  findBlockBoundary(text) {
-    const last = text.lastIndexOf("\n\n");
-    if (last < 0 || last < this.opts.minChars)
-      return -1;
-    return last + 2;
-  }
-  /**
-   * Find the best break point at or before maxPos.
-   * Prefers paragraph break > newline > space > maxPos.
-   */
-  findBreakPoint(text, maxPos) {
-    const sub = text.slice(0, maxPos);
-    const para = sub.lastIndexOf("\n\n");
-    if (para > 0)
-      return para + 2;
-    const nl = sub.lastIndexOf("\n");
-    if (nl > 0)
-      return nl + 1;
-    const sp = sub.lastIndexOf(" ");
-    if (sp > 0)
-      return sp + 1;
-    return maxPos;
-  }
-  clearIdleTimer() {
-    if (this.idleTimer !== null) {
-      clearTimeout(this.idleTimer);
-      this.idleTimer = null;
-    }
-  }
-};
-
 // packages/channels/base/dist/ChannelProactiveDeliveryError.js
 init_esbuild_shims();
 var CHANNEL_PROACTIVE_DELIVERY_ERROR_CODE = "channel_proactive_delivery_error";
@@ -1763,6 +1680,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 +1733,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 +1759,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 +2035,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 +2048,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,11 +2070,100 @@ 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);
@@ -2126,10 +2181,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 +2218,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 +2285,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 +2317,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 +2354,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 +2403,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 +2481,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 +2543,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 +2561,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 +2710,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 +2734,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 +2838,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 +2895,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 +2914,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 +2926,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 +2953,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 +2967,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 +2978,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 +3014,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 +3058,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 +3136,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 +3179,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) {
@@ -3991,6 +4218,45 @@ function isRecord2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 __name(isRecord2, "isRecord");
+var PERMISSION_COPY = {
+  en: {
+    toolUse: "Tool use",
+    allowOnce: "Allow once",
+    allowAlwaysProject: "always allow for this project",
+    allowAlwaysUser: "always allow for this user",
+    allowAlways: "always allow",
+    deny: "Deny",
+    required: "Permission required to run a tool",
+    request: "Request:",
+    tool: "Tool:",
+    action: "Action:",
+    parameters: "Parameters:",
+    replyWith: "Reply with:"
+  },
+  zh: {
+    toolUse: "\u5DE5\u5177\u8C03\u7528",
+    allowOnce: "\u4EC5\u5141\u8BB8\u672C\u6B21",
+    allowAlwaysProject: "\u59CB\u7EC8\u5141\u8BB8\u6B64\u9879\u76EE",
+    allowAlwaysUser: "\u59CB\u7EC8\u5141\u8BB8\u6B64\u7528\u6237",
+    allowAlways: "\u59CB\u7EC8\u5141\u8BB8",
+    deny: "\u62D2\u7EDD",
+    required: "\u8FD0\u884C\u5DE5\u5177\u9700\u8981\u6388\u6743",
+    request: "\u8BF7\u6C42\uFF1A",
+    tool: "\u5DE5\u5177\uFF1A",
+    action: "\u64CD\u4F5C\uFF1A",
+    parameters: "\u53C2\u6570\uFF1A",
+    replyWith: "\u56DE\u590D\u4EE5\u4E0B\u547D\u4EE4\uFF1A"
+  }
+};
+function localizedScopedAlwaysLabel(label, stockLabel, localizedLabel) {
+  if (label === stockLabel)
+    return localizedLabel;
+  const scopeSeparator = ": ";
+  if (!label.startsWith(stockLabel + scopeSeparator))
+    return void 0;
+  return `${localizedLabel}\uFF1A${label.slice(stockLabel.length + scopeSeparator.length)}`;
+}
+__name(localizedScopedAlwaysLabel, "localizedScopedAlwaysLabel");
 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+)?$`);
@@ -4034,6 +4300,7 @@ var ChannelBase = class {
   proxy;
   /** Adapter-owned persistent state directory, when supplied by the runtime. */
   stateDir;
+  locale;
   channelMemory;
   memoryIntentClassifier;
   channelMemoryRecallObserver;
@@ -4088,6 +4355,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)}
@@ -4364,6 +4634,10 @@ No answer is available from the current conversation context.`;
       if (presentation && await presentation) {
         return;
       }
+      const permissionPresentation = this.tryPresentPermission(pending);
+      if (permissionPresentation && await permissionPresentation) {
+        return;
+      }
       const text = this.formatPermissionRequest(pending);
       if (target.threadId !== void 0 && this.supportsProactiveSend() && this.supportsProactiveTarget(target)) {
         await this.pushProactive(target, text, pending.sourceLabel);
@@ -4444,6 +4718,103 @@ No answer is available from the current conversation context.`;
       }
     })();
   }
+  tryPresentPermission(pending) {
+    const active = this.activePrompts.get(pending.sessionId);
+    const toolCall = pending.request.toolCall;
+    const meta = isRecord2(toolCall["_meta"]) ? toolCall["_meta"] : void 0;
+    const isUserQuestion = meta?.["qwenInteractionKind"] === "user_question" || meta?.["toolName"] === "ask_user_question" || toolCall["kind"] === "ask_user_question";
+    const decisions = this.permissionPresentationDecisions(pending);
+    if (!active || active.loopPrompt || !active.owner || isUserQuestion || !decisions) {
+      return void 0;
+    }
+    const precedingSegment = this.closeOutputSegment(pending.sessionId, active, pending.target);
+    let respondInvoked = false;
+    const context = {
+      requestId: pending.requestId,
+      sessionId: pending.sessionId,
+      runId: active.runId,
+      owner: active.owner,
+      target: pending.target,
+      ...precedingSegment ? { precedingSegmentId: precedingSegment.segmentId } : {},
+      title: this.permissionTitle(pending.request.toolCall),
+      decisions,
+      onSettled: /* @__PURE__ */ __name((listener) => {
+        if (pending.settled) {
+          listener(pending.settled);
+          return () => {
+          };
+        }
+        pending.settlementListeners.add(listener);
+        return () => {
+          pending.settlementListeners.delete(listener);
+        };
+      }, "onSettled"),
+      respond: /* @__PURE__ */ __name((decision) => {
+        const response = this.permissionPresentationResponse(pending, decision);
+        if (!response)
+          return Promise.resolve(false);
+        respondInvoked = true;
+        return this.respondToUserInput(pending, response);
+      }, "respond")
+    };
+    pending.permissionPresented = true;
+    return (async () => {
+      try {
+        if (precedingSegment) {
+          await this.notifyOutputSegmentEnd(pending.target.chatId, pending.sessionId, precedingSegment, "input_requested");
+        }
+        if (this.pendingPermissions.get(pending.requestId) !== pending) {
+          return true;
+        }
+        const result = await this.presentPermissionRequest(context);
+        if (this.pendingPermissions.get(pending.requestId) !== pending) {
+          return true;
+        }
+        if (result.kind === "presented" || result.kind === "handled" && respondInvoked) {
+          return true;
+        }
+        pending.permissionPresented = false;
+        return false;
+      } catch (err) {
+        process.stderr.write(`[${this.name}] permission presentation failed for request ${sanitizeLogText(pending.requestId, 128)}: ${this.lifecycleError(err)}
+`);
+        if (this.pendingPermissions.get(pending.requestId) !== pending) {
+          return true;
+        }
+        pending.permissionPresented = false;
+        return false;
+      }
+    })();
+  }
+  permissionPresentationDecisions(pending) {
+    const allowOnce = this.approvalOption(pending);
+    if (!allowOnce)
+      return void 0;
+    const copy = PERMISSION_COPY[this.locale];
+    const allowAlways = this.approvalAlwaysOption(pending);
+    return [
+      {
+        kind: "allow_once",
+        label: sanitizeQuotedText(this.permissionOptionLabel(allowOnce, copy.allowOnce), 80)
+      },
+      ...allowAlways ? [
+        {
+          kind: "allow_always",
+          label: sanitizeQuotedText(allowAlways.label, 80)
+        }
+      ] : [],
+      {
+        kind: "deny",
+        label: sanitizeQuotedText(this.permissionOptionLabel(this.denialOption(pending), copy.deny), 80)
+      }
+    ];
+  }
+  permissionPresentationResponse(pending, decision) {
+    if (decision === "deny")
+      return this.denialResponse(pending);
+    const optionId = decision === "allow_once" ? this.approvalOptionId(pending) : this.approvalAlwaysOption(pending)?.optionId;
+    return optionId ? { outcome: { outcome: "selected", optionId } } : void 0;
+  }
   normalizeUserQuestions(pending) {
     const toolCall = pending.request.toolCall;
     const meta = isRecord2(toolCall["_meta"]) ? toolCall["_meta"] : void 0;
@@ -4488,7 +4859,8 @@ No answer is available from the current conversation context.`;
   }
   async respondToUserInput(pending, response) {
     if (pending.responsePromise) {
-      return pending.responsePromise;
+      await pending.responsePromise;
+      return false;
     }
     if (this.pendingPermissions.get(pending.requestId) !== pending || !this.bridge.respondToPermission) {
       return false;
@@ -4541,6 +4913,7 @@ No answer is available from the current conversation context.`;
     this.config = config;
     this.messagePrefix = config.messagePrefix?.trim() || void 0;
     this.bridge = bridge;
+    this.locale = options?.locale ?? "en";
     this.proxy = options?.proxy;
     this.stateDir = options?.stateDir;
     this.identity = Object.freeze(this.resolveIdentity(name, config));
@@ -4603,6 +4976,9 @@ No answer is available from the current conversation context.`;
   async presentUserInputRequest(_context) {
     return { kind: "unsupported" };
   }
+  async presentPermissionRequest(_context) {
+    return { kind: "unsupported" };
+  }
   emitTaskLifecycle(event) {
     try {
       const result = this.onTaskLifecycle(event);
@@ -5495,7 +5871,6 @@ ${promptText}` : promptText;
         return false;
       }
       active.cancelled = true;
-      this.stopActiveStreaming(active, sessionId, reason);
       this.dropCollectBuffer(sessionId);
       this.removePendingPermissionsForSession(sessionId, "run_cancelled");
       this.emitTaskCancellation(active, sessionId, reason);
@@ -5570,12 +5945,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 +5967,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);
   }
@@ -5792,14 +6177,15 @@ ${promptText}` : promptText;
     return { kind: "found", pending: matching[0] };
   }
   canEnvelopeAnswerPendingPermission(envelope, pending) {
-    return pending.target.chatId === envelope.chatId && pending.target.threadId === envelope.threadId && (!pending.userInputPresented || pending.target.senderId === envelope.senderId) && (this.isSharedSessionTarget(pending.target) || pending.target.senderId === envelope.senderId);
+    return pending.target.chatId === envelope.chatId && pending.target.threadId === envelope.threadId && (!pending.userInputPresented && !pending.permissionPresented || pending.target.senderId === envelope.senderId) && (this.isSharedSessionTarget(pending.target) || pending.target.senderId === envelope.senderId);
   }
   formatPermissionRequest(pending) {
     const { toolCall } = pending.request;
+    const copy = PERMISSION_COPY[this.locale];
     const parameters = this.permissionParameterSummary(toolCall);
-    const approveLabel = this.permissionOptionLabel(this.approvalOption(pending), "allow once");
+    const approveLabel = this.permissionOptionLabel(this.approvalOption(pending), copy.allowOnce.toLocaleLowerCase(this.locale));
     const alwaysOption = this.approvalAlwaysOption(pending);
-    const denyLabel = this.permissionOptionLabel(this.denialOption(pending), "deny");
+    const denyLabel = this.permissionOptionLabel(this.denialOption(pending), copy.deny.toLocaleLowerCase(this.locale));
     const requestSuffix = pending.taskName ? ` ${pending.requestId}` : "";
     const replyPadding = pending.taskName ? { approve: "          ", always: "   ", deny: "             " } : { approve: "        ", always: " ", deny: "           " };
     const replies = [
@@ -5810,14 +6196,14 @@ ${promptText}` : promptText;
       `${this.prefixedCommand(`/deny${requestSuffix}`)}${replyPadding.deny}${denyLabel}`
     ];
     return [
-      "Permission required to run a tool",
-      ...pending.taskName ? [`Request: ${pending.requestId}`] : [],
+      copy.required,
+      ...pending.taskName ? [`${copy.request} ${pending.requestId}`] : [],
       "",
-      `Tool: ${this.permissionToolName(toolCall)}`,
-      `Action: ${this.permissionTitle(toolCall)}`,
-      ...parameters ? [`Parameters: ${parameters}`] : [],
+      `${copy.tool} ${this.permissionToolName(toolCall)}`,
+      `${copy.action} ${this.permissionTitle(toolCall)}`,
+      ...parameters ? [`${copy.parameters} ${parameters}`] : [],
       "",
-      "Reply with:",
+      copy.replyWith,
       ...replies
     ].join("\n");
   }
@@ -5829,7 +6215,7 @@ ${promptText}` : promptText;
   }
   permissionTitle(toolCall) {
     const rawTitle = typeof toolCall.title === "string" ? toolCall.title : void 0;
-    return sanitizeQuotedText(rawTitle || "", 160).trim() || "Tool use";
+    return sanitizeQuotedText(rawTitle || "", 160).trim() || PERMISSION_COPY[this.locale].toolUse;
   }
   permissionToolName(toolCall) {
     const rawToolCall = toolCall;
@@ -5869,7 +6255,31 @@ ${promptText}` : promptText;
   permissionOptionLabel(option, fallback) {
     const rawLabel = typeof option?.name === "string" ? option.name : "";
     const label = sanitizeQuotedText(rawLabel, 160).trim();
-    return label || fallback;
+    if (!label)
+      return fallback;
+    return this.localizedPermissionOptionLabel(option, label) ?? label;
+  }
+  localizedPermissionOptionLabel(option, label) {
+    if (this.locale !== "zh")
+      return void 0;
+    const copy = PERMISSION_COPY[this.locale];
+    if (option?.kind === "allow_always") {
+      if (option.optionId === "proceed_always_project") {
+        return localizedScopedAlwaysLabel(label, "Always Allow in project", copy.allowAlwaysProject);
+      }
+      if (option.optionId === "proceed_always_user") {
+        return localizedScopedAlwaysLabel(label, "Always Allow for user", copy.allowAlwaysUser);
+      }
+      if (option.optionId === "proceed_always" && label === "Allow All Edits") {
+        return copy.allowAlways;
+      }
+      return void 0;
+    }
+    if (label === "Allow" || label === "Allow once")
+      return copy.allowOnce;
+    if (label === "Deny" || label === "Reject")
+      return copy.deny;
+    return void 0;
   }
   approvalOption(pending) {
     const options = pending.request.options;
@@ -5893,13 +6303,14 @@ ${promptText}` : promptText;
     return options.find((option) => option.optionId === `proceed_always_${scope}`);
   }
   approvalAlwaysLabel(option) {
+    const copy = PERMISSION_COPY[this.locale];
     if (option.optionId === "proceed_always_project") {
-      return "always allow for this project";
+      return copy.allowAlwaysProject;
     }
     if (option.optionId === "proceed_always_user") {
-      return "always allow for this user";
+      return copy.allowAlwaysUser;
     }
-    return "always allow";
+    return copy.allowAlways;
   }
   denialResponse(pending) {
     const option = this.denialOption(pending);
@@ -5965,7 +6376,7 @@ ${requestList}`);
     }
     let accepted;
     try {
-      accepted = pending.userInputPresented ? await this.respondToUserInput(pending, response) : await this.bridge.respondToPermission(pending.requestId, response);
+      accepted = pending.userInputPresented || pending.permissionPresented ? await this.respondToUserInput(pending, response) : await this.bridge.respondToPermission(pending.requestId, response);
     } catch (err) {
       this.removePendingPermission(pending.requestId);
       process.stderr.write(`[${this.name}] permission response failed for request ${sanitizeLogText(pending.requestId, 128)}: ${this.lifecycleError(err)}
@@ -6020,6 +6431,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 +6501,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 +6590,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 +6651,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 +6660,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 +6726,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.");
       }
@@ -7212,17 +7688,8 @@ ${sanitizePromptText(entry.text).trim()}` : `No channel memory entry ${intent.id
     const active = this.activePrompts.get(sessionId);
     return active?.senderName || active?.senderId || target.senderId || "agent";
   }
-  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
+   * Cancel the active turn and wait (bounded) for it to wind down. 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
@@ -7233,7 +7700,6 @@ ${sanitizePromptText(entry.text).trim()}` : `No channel memory entry ${intent.id
    */
   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}
 `);
@@ -7775,8 +8241,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;
@@ -7921,7 +8389,6 @@ ${promptText}`;
           if (firstCancellation) {
             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}
 `);
@@ -7956,7 +8423,6 @@ ${promptText}`;
     }
     const prev = this.sessionQueues.get(sessionId) ?? Promise.resolve();
     const generation = namedTurn?.generation ?? this.sessionGenerations.get(sessionId) ?? 0;
-    const useBlockStreaming = this.config.blockStreaming === "on";
     if (namedTurn) {
       namedTurn.claimed = true;
     } else {
@@ -8059,18 +8525,9 @@ ${promptToSend}`;
         process.stderr.write(`[${this.name}] onPromptStart threw for session ${sessionId}: ${this.lifecycleError(err)}
 `);
       }
-      const streamer = useBlockStreaming ? new BlockStreamer({
-        minChars: this.config.blockStreamingChunk?.minChars ?? 400,
-        maxChars: this.config.blockStreamingChunk?.maxChars ?? 1e3,
-        idleMs: this.config.blockStreamingCoalesce?.idleMs ?? 1500,
-        send: /* @__PURE__ */ __name((text) => this.sendResponseMessage(envelope.chatId, text, sessionId, sourceLabel), "send")
-      }) : null;
-      promptState.stopStreaming = () => streamer?.stop();
       const heldChunks = [];
-      let hasStreamedText = false;
       const releaseHeldChunks = /* @__PURE__ */ __name(() => {
         for (const held of heldChunks.splice(0)) {
-          hasStreamedText = true;
           const segment = this.ensureOutputSegment(sessionId, promptState);
           this.emitTaskLifecycle({
             ...this.lifecycleBase(envelope.chatId, sessionId, envelope.messageId),
@@ -8078,7 +8535,6 @@ ${promptToSend}`;
             chunk: held
           });
           this.onResponseChunk(envelope.chatId, held, sessionId, segment);
-          streamer?.push(held);
         }
       }, "releaseHeldChunks");
       const onChunk = /* @__PURE__ */ __name((sid, chunk) => {
@@ -8095,10 +8551,8 @@ ${promptToSend}`;
           return;
         }
         heldChunks.length = 0;
-        hasStreamedText = false;
         const segment = this.closeOutputSegment(sessionId, promptState);
         void this.notifyOutputSegmentEnd(envelope.chatId, sessionId, segment, "response_boundary");
-        streamer?.stop();
       }, "onResponseBoundary");
       await this.waitForBridgeRecovery();
       const promptBridge = this.bridge;
@@ -8117,17 +8571,10 @@ ${promptToSend}`;
         }
         if (!promptState.cancelled && response) {
           promptState.deliveryStarted = true;
-          if (streamer) {
-            if (!hasStreamedText) {
-              streamer.push(response);
-            }
-            await streamer.flush();
-          } else {
-            const segment = this.ensureOutputSegment(sessionId, promptState);
-            await this.onResponseComplete(envelope.chatId, response, sessionId, segment);
-            if (segment && promptState.activeSegmentId === segment.segmentId) {
-              promptState.activeSegmentId = void 0;
-            }
+          const segment = this.ensureOutputSegment(sessionId, promptState);
+          await this.onResponseComplete(envelope.chatId, response, sessionId, segment);
+          if (segment && promptState.activeSegmentId === segment.segmentId) {
+            promptState.activeSegmentId = void 0;
           }
         }
         if (!promptState.deliveryStarted) {
@@ -8172,10 +8619,6 @@ ${promptToSend}`;
       } finally {
         promptBridge.off("textChunk", onChunk);
         promptBridge.off("responseBoundary", onResponseBoundary);
-        if (streamer) {
-          streamer.stop();
-          await streamer.drain();
-        }
         const stillCurrent = this.activePrompts.get(sessionId) === promptState;
         if (!promptState.clearEvicted) {
           try {
@@ -8489,6 +8932,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 +9039,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 +9477,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 +9506,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 +9639,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);
     }