@cortexkit/aft-opencode 0.59.0 → 0.60.0

package/dist/entry/server.js

@@ -10290,11 +10290,11 @@ var DEFAULT_WORKER_WAIT_MAX_MS = 1800000;
 var MIN_WORKER_WAIT_MAX_MS = 60000;
 var LONGEST_TIMER_DELAY_MS = 2147483647;
 var WORKER_WAIT_LIMIT_PHRASE = "the worker wait limit (`bash.worker_wait_max_ms`, 30 minutes by default)";
-var WATCH_SYNC_DEFAULTS_DESCRIPTION = "Sync waits default to 30s in a main session (max `bash.watch_sync_max_ms`, 120s by default); in a delegated session a sync wait without a timeout waits up to the worker wait limit (`bash.worker_wait_max_ms`, 30 minutes by default), then reports it is still running; watch again to keep waiting";
-var WATCH_TIMEOUT_PARAM_DESCRIPTION = "Sync-only timeout in milliseconds. In a main session: default 30000, max `bash.watch_sync_max_ms` (120000 by default). In a delegated session: omit it to wait up to the worker wait limit (`bash.worker_wait_max_ms`, 30 minutes by default), after which the watch reports the command is still running; a value you pass is used as given.";
+var WATCH_SYNC_DEFAULTS_DESCRIPTION = "Sync waits default to 30s in a main session (max `bash.watch_sync_max_ms`, 120s by default); in a delegated session a sync wait without a timeout waits up to the worker wait limit (`bash.worker_wait_max_ms`, 30 minutes by default), then reports it is still running; watch again to keep waiting. An explicit timeout never exceeds that worker limit";
+var WATCH_TIMEOUT_PARAM_DESCRIPTION = "Sync-only timeout in milliseconds. In a main session: default 30000, max `bash.watch_sync_max_ms` (120000 by default). In a delegated session: omit it to wait up to the worker wait limit (`bash.worker_wait_max_ms`, 30 minutes by default), after which the watch reports the command is still running; a value you pass is clamped to that worker limit.";
 function resolveWatchTimeoutMs(requestedMs, role, capMs, workerWaitMaxMs) {
   if (role === "worker")
-    return requestedMs ?? workerWaitMaxMs;
+    return Math.min(requestedMs ?? workerWaitMaxMs, workerWaitMaxMs);
   return Math.min(requestedMs ?? DEFAULT_PRIMARY_WATCH_TIMEOUT_MS, capMs);
 }
 function maxWatchTimeoutMs(role, capMs) {
@@ -10357,6 +10357,10 @@ function taskKillDeadlineText(data, role, nowMs = Date.now()) {
     return "";
   if (data.status === "unknown")
     return "";
+  if (typeof data.remote_phase_note === "string" && data.remote_phase_note !== "") {
+    const note = data.remote_phase_note;
+    return `${note.charAt(0).toUpperCase()}${note.slice(1)}.`;
+  }
   const hardKill = data.hard_kill;
   if (!hardKill || typeof hardKill.limit_ms !== "number") {
     return "This task has no kill deadline.";
@@ -11091,8 +11095,8 @@ var BASH_HOST_FALLBACK_BANNER = "[AFT host fallback - module transport down; no
 var BASH_HOST_FALLBACK_MAX_OUTPUT_BYTES = 100 * 1024;
 var BASH_HOST_FALLBACK_MAX_TIMEOUT_MS = 10 * 60 * 1000;
 var BASH_HOST_FALLBACK_REFUSAL = "AFT transport is down; only foreground execution is available in host fallback";
-var BASH_RUNON_DESCRIPTION = 'Run this command on the remote Linux build server instead of this machine; the only value is "linux".';
-var BASH_RUNON_GUIDANCE = 'When remote runs are available, put `runon: "linux"` on build and test lines (cargo, bun test), including chains and pipes. Keep git, gh, interactive and file-editing commands local, and keep a line local if it needs macOS (Seatbelt, codesign, launchd, TCC, AppKit) or runs binaries built on this machine: a remote build leaves no binaries or target/ output here.';
+var BASH_RUNON_DESCRIPTION = 'Run on a remote build server: `linux` (2 vCPUs), or `linux,Nc` for N vCPUs such as `linux,8c`; add ",net" for outbound internet (offline by default). `windows` runs the command in Git Bash on a Windows build machine (no vCPU or network options).';
+var BASH_RUNON_GUIDANCE = 'When remote runs are available, put `runon: "linux"` on build and test lines (cargo, bun test), including chains and pipes. Keep git, gh, interactive and file-editing commands local, and keep a line local if it needs macOS (Seatbelt, codesign, launchd, TCC, AppKit) or runs binaries built on this machine: a remote build leaves no binaries or target/ output in the local worktree. Add `,Nc` to request N vCPUs (`linux,4c`); without it the job gets 2 vCPUs. The job sees exactly the CPUs it gets, so ask for what the command uses: 2c (the default) for a single test binary or script, 4c for `cargo check`/clippy on one crate, 8c for a workspace test suite, and 16c for a large release build.';
 function pathKeyForPlatform(env, platform) {
   return platform === "win32" ? Object.keys(env).find((key) => key.toLowerCase() === "path") : "PATH";
 }
@@ -11536,6 +11540,7 @@ function isPassiveCommand(command) {
 
 // ../aft-bridge/dist/transport.js
 var WORKER_SESSION_FIELD = "worker_session";
+var HOST_TOOL_NAMES_FIELD = "host_tool_names";
 var PRESET_FIELD = "preset";
 function callPresetFor(workerSession) {
   return workerSession ? "worker" : "head";
@@ -11700,6 +11705,8 @@ class BinaryBridge {
   lastBinaryFingerprintCheckAt = 0;
   _retiringDueToBinaryChange = false;
   pending = new Map;
+  activeSendCalls = 0;
+  processLoopReferenced = true;
   outstandingBackgroundTaskIds = new Set;
   nextId = 1;
   processGeneration = 0;
@@ -11931,6 +11938,32 @@ class BinaryBridge {
     this.sessionLogVia(sessionId, `hashline registration carrier transport=ndjson phase=${phase} edit_slot_survives=${editSlotSurvives}${repeated}`);
   }
   async send(command, params = {}, options) {
+    this.activeSendCalls += 1;
+    this.syncEventLoopHold();
+    try {
+      return await this.dispatchSend(command, params, options);
+    } finally {
+      this.activeSendCalls -= 1;
+      this.syncEventLoopHold();
+    }
+  }
+  syncEventLoopHold() {
+    const child = this.process;
+    if (!child)
+      return;
+    const hold = this.activeSendCalls > 0 || this.outstandingBackgroundTaskIds.size > 0;
+    if (hold === this.processLoopReferenced)
+      return;
+    this.processLoopReferenced = hold;
+    const handles = [child, child.stdin, child.stdout, child.stderr];
+    for (const handle of handles) {
+      if (hold)
+        handle?.ref?.();
+      else
+        handle?.unref?.();
+    }
+  }
+  async dispatchSend(command, params, options) {
     let dispatchParams = params;
     if (command === "configure") {
       dispatchParams = { ...params };
@@ -11968,11 +12001,13 @@ class BinaryBridge {
       params.edit_slot_survives = editSlotSurvives;
       this.logHashlineRegistrationCarrier("tool_call", sessionId, editSlotSurvives);
     }
-    const { preview, workerSession, ...sendOptions } = options ?? {};
+    const { preview, workerSession, hostToolNames, ...sendOptions } = options ?? {};
     if (preview === true)
       params.preview = true;
     if (workerSession === true)
       params[WORKER_SESSION_FIELD] = true;
+    if (hostToolNames)
+      params[HOST_TOOL_NAMES_FIELD] = hostToolNames;
     return await this.send("tool_call", params, Object.keys(sendOptions).length > 0 ? sendOptions : undefined);
   }
   async sendWithVersionMismatchRetry(command, params, options, canRetryAfterVersionSwap) {
@@ -12041,7 +12076,12 @@ class BinaryBridge {
       if (command === "cancel_request" || Object.hasOwn(params, "command") || Object.hasOwn(params, "method")) {
         const nested = { ...params };
         const reserved = {};
-        for (const key of ["session_id", "lsp_hints", WORKER_SESSION_FIELD]) {
+        for (const key of [
+          "session_id",
+          "lsp_hints",
+          WORKER_SESSION_FIELD,
+          HOST_TOOL_NAMES_FIELD
+        ]) {
           if (Object.hasOwn(nested, key)) {
             reserved[key] = nested[key];
             delete nested[key];
@@ -12416,6 +12456,8 @@ class BinaryBridge {
     this.lastChildActivityAt = 0;
     this.consecutiveRequestTimeouts = 0;
     this.stderrTail = [];
+    this.processLoopReferenced = true;
+    this.syncEventLoopHold();
   }
   pushStderrLine(line) {
     this.stderrTail.push(line);
@@ -12542,6 +12584,7 @@ class BinaryBridge {
         const taskId = bashTaskIdFrom(response);
         if (taskId)
           this.outstandingBackgroundTaskIds.delete(taskId);
+        this.syncEventLoopHold();
         this.onBashCompletion?.(response, this);
         return;
       }
@@ -12655,7 +12698,7 @@ class BinaryBridge {
       const delay = 100 * 2 ** this._restartCount;
       this._restartCount++;
       this.logVia(`Auto-restart #${this._restartCount} in ${delay}ms`);
-      setTimeout(() => {
+      const restartTimer = setTimeout(() => {
         if (!this._shuttingDown && !this.isAlive()) {
           try {
             this.spawnProcess();
@@ -12664,6 +12707,7 @@ class BinaryBridge {
           }
         }
       }, delay);
+      restartTimer.unref?.();
       this.scheduleRestartCountReset();
     } else {
       this.errorVia(`Max restarts (${this.maxRestarts}) reached, giving up. Logs: ${this.getLogFilePathVia()}${tail}`);
@@ -12684,6 +12728,7 @@ class BinaryBridge {
       this._restartCount = 0;
       this.restartResetTimer = null;
     }, BinaryBridge.RESTART_RESET_MS);
+    this.restartResetTimer.unref?.();
   }
   clearRestartResetTimer() {
     if (this.restartResetTimer) {
@@ -13300,10 +13345,12 @@ function startLiveConfigReload(options) {
   let acceptedTexts;
   const reload = () => {
     let loaded = options.load();
+    let deletedProjectConfig = false;
     if (loaded.ok) {
       const read = new Set(loaded.sources);
       const deleted = [...acceptedSources].find((path) => !read.has(path));
-      if (deleted !== undefined) {
+      deletedProjectConfig = deleted === options.projectPath && loaded.projectText === null;
+      if (deleted !== undefined && !deletedProjectConfig) {
         loaded = { ok: false, message: `AFT config at ${deleted} was deleted` };
       } else {
         acceptedSources = read;
@@ -14075,17 +14122,17 @@ async function renameIfPresent(from, to) {
       throw error;
   }
 }
-// ../../node_modules/.bun/@cortexkit+subc-client@0.20.0/node_modules/@cortexkit/subc-client/dist/client.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.21.2/node_modules/@cortexkit/subc-client/dist/client.js
 import { promises as fs3 } from "node:fs";
 import { debuglog } from "node:util";
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.20.0/node_modules/@cortexkit/subc-client/dist/auth.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.21.2/node_modules/@cortexkit/subc-client/dist/auth.js
 import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.20.0/node_modules/@cortexkit/subc-client/dist/socket.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.21.2/node_modules/@cortexkit/subc-client/dist/socket.js
 import net from "node:net";
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.20.0/node_modules/@cortexkit/subc-client/dist/envelope.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.21.2/node_modules/@cortexkit/subc-client/dist/envelope.js
 var PROTOCOL_VERSION = 2;
 var HEADER_LEN = 21;
 var FROZEN_PREFIX_LEN = 5;
@@ -14188,12 +14235,12 @@ function validateHeaderFields(header) {
   if (admission === AdmissionClass.Sheddable && ty !== FrameType.Push && ty !== FrameType.StreamData) {
     throw new DecodeError(`SHEDDABLE admission class is illegal on ${FrameType[ty]} in flags 0b${flags.toString(2).padStart(8, "0")}`, "sheddable_illegal_frame_type");
   }
-  if (channel === 0 && epoch !== 0) {
-    throw new DecodeError(`control channel carried nonzero epoch ${epoch}`, "nonzero_epoch_on_control_channel");
-  }
   if (isPureHeader(ty) && len !== 0) {
     throw new DecodeError(`pure-header frame ${FrameType[ty]} declared non-zero body length ${len}`, "pure_header_frame_with_body");
   }
+  if (channel === 0 && epoch !== 0) {
+    throw new DecodeError(`control channel carried nonzero epoch ${epoch}`, "nonzero_epoch_on_control_channel");
+  }
 }
 function decodeHeader(bytes) {
   if (bytes.length < FROZEN_PREFIX_LEN) {
@@ -14227,12 +14274,12 @@ function decodeHeader(bytes) {
   }
   const channel = view.getUint16(7, true);
   const epoch = view.getUint32(9, true);
-  if (channel === 0 && epoch !== 0) {
-    throw new DecodeError(`control channel carried nonzero epoch ${epoch}`, "nonzero_epoch_on_control_channel");
-  }
   if (isPureHeader(ty) && len !== 0) {
     throw new DecodeError(`pure-header frame ${FrameType[ty]} declared non-zero body length ${len}`, "pure_header_frame_with_body");
   }
+  if (channel === 0 && epoch !== 0) {
+    throw new DecodeError(`control channel carried nonzero epoch ${epoch}`, "nonzero_epoch_on_control_channel");
+  }
   return { len, ver, ty, flags, channel, epoch, corr: view.getBigUint64(13, true) };
 }
 function buildFrame(ty, flags, channel, epoch, corr, body) {
@@ -14250,14 +14297,18 @@ function encodeFrame(frame) {
   if (frame.header.len !== frame.body.length) {
     throw new DecodeError(`frame header length ${frame.header.len} does not match body length ${frame.body.length}`, "frame_length_mismatch");
   }
+  if (frame.body.length > MAX_FRAME_BODY_LEN) {
+    throw new DecodeError(`frame body ${frame.body.length} exceeds max ${MAX_FRAME_BODY_LEN}`, "frame_body_too_large");
+  }
   const header = encodeHeader(frame.header);
+  decodeHeader(header);
   const output = new Uint8Array(header.length + frame.body.length);
   output.set(header, 0);
   output.set(frame.body, header.length);
   return output;
 }
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.20.0/node_modules/@cortexkit/subc-client/dist/socket.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.21.2/node_modules/@cortexkit/subc-client/dist/socket.js
 class SocketClosedError extends Error {
 }
 
@@ -14307,6 +14358,15 @@ class SubcSocket {
     sock.on("data", (chunk) => {
       this.chunks.push(chunk);
       this.buffered += chunk.length;
+      if (this.waiter) {
+        if (this.waiter.immediate) {
+          clearImmediate(this.waiter.immediate);
+          this.waiter.immediate = null;
+        }
+        if (this.waiter.extendOnProgress && this.buffered < this.waiter.need) {
+          this.armWaiterTimer(this.waiter);
+        }
+      }
       this.tryServe();
     });
     const fail = (err) => {
@@ -14353,30 +14413,80 @@ class SubcSocket {
       throw new DecodeError(`frame body ${header.len} exceeds max ${MAX_FRAME_BODY_LEN}`, "frame_body_too_large");
     }
     onHeader?.();
-    const bodyDeadlineMs = typeof bodyDeadline === "number" ? bodyDeadline : Date.now() + bodyDeadline.afterHeaderMs;
-    const body = header.len === 0 ? new Uint8Array(0) : await this.readExact(header.len, bodyDeadlineMs);
+    const bodyDeadlineArg = typeof bodyDeadline === "number" ? bodyDeadline : { idleTimeoutMs: bodyDeadline.afterHeaderMs };
+    const body = header.len === 0 ? new Uint8Array(0) : await this.readExact(header.len, bodyDeadlineArg);
     return { header, body };
   }
-  readExact(n, deadlineMs) {
+  armWaiterTimer(w) {
+    if (!Number.isFinite(w.budget))
+      return;
+    if (w.timer) {
+      clearTimeout(w.timer);
+      w.timer = null;
+    }
+    w.timer = setTimeout(() => {
+      w.timer = null;
+      const bufferedAtTimeout = this.buffered;
+      const verifyTimeout = () => {
+        if (this.waiter !== w)
+          return;
+        if (w.extendOnProgress && this.buffered > bufferedAtTimeout) {
+          this.armWaiterTimer(w);
+          return;
+        }
+        this.waiter = null;
+        w.reject(new SocketTimeoutError(`timed out waiting for ${w.need} bytes`));
+      };
+      w.immediate = setImmediate(() => {
+        if (this.waiter !== w)
+          return;
+        if (this.buffered > bufferedAtTimeout) {
+          verifyTimeout();
+        } else {
+          w.immediate = setImmediate(() => {
+            w.immediate = null;
+            verifyTimeout();
+          });
+        }
+      });
+    }, w.budget);
+  }
+  readExact(n, deadline) {
     if (this.waiter) {
       return Promise.reject(new Error("concurrent readExact is not supported"));
     }
     if (n === 0)
       return Promise.resolve(new Uint8Array(0));
     return new Promise((resolve, reject) => {
-      let timer = null;
-      if (Number.isFinite(deadlineMs)) {
-        const remaining = deadlineMs - Date.now();
-        if (remaining <= 0) {
+      let budget;
+      const extendOnProgress = typeof deadline === "object";
+      if (typeof deadline === "object") {
+        budget = deadline.idleTimeoutMs;
+        if (budget <= 0) {
           reject(new SocketTimeoutError(`timed out waiting for ${n} bytes`));
           return;
         }
-        timer = setTimeout(() => {
-          this.waiter = null;
+      } else if (Number.isFinite(deadline)) {
+        const remaining = deadline - Date.now();
+        if (remaining <= 0) {
           reject(new SocketTimeoutError(`timed out waiting for ${n} bytes`));
-        }, remaining);
+          return;
+        }
+        budget = remaining;
+      } else {
+        budget = Number.POSITIVE_INFINITY;
       }
-      this.waiter = { need: n, resolve, reject, timer };
+      const waiter = {
+        need: n,
+        resolve,
+        reject,
+        timer: null,
+        immediate: null,
+        budget,
+        extendOnProgress
+      };
+      this.waiter = waiter;
+      this.armWaiterTimer(waiter);
       this.tryServe();
     });
   }
@@ -14459,6 +14569,8 @@ class SubcSocket {
       this.waiter = null;
       if (w.timer)
         clearTimeout(w.timer);
+      if (w.immediate)
+        clearImmediate(w.immediate);
       w.resolve(out);
       return;
     }
@@ -14466,6 +14578,8 @@ class SubcSocket {
       this.waiter = null;
       if (w.timer)
         clearTimeout(w.timer);
+      if (w.immediate)
+        clearImmediate(w.immediate);
       w.reject(this.closedErr);
     }
   }
@@ -14490,7 +14604,7 @@ class SubcSocket {
   }
 }
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.20.0/node_modules/@cortexkit/subc-client/dist/auth.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.21.2/node_modules/@cortexkit/subc-client/dist/auth.js
 var NONCE_LEN = 32;
 var MAX_AUTH_MESSAGE_LEN = 4096;
 var SERVER_PROOF_DOMAIN = "subc-server-v1";
@@ -14564,7 +14678,7 @@ async function authenticateClient(sock, conn, deadlineMs) {
   await writeMessage(sock, { client_auth: Array.from(clientAuth) }, deadlineMs);
 }
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.20.0/node_modules/@cortexkit/subc-client/dist/connection-file.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.21.2/node_modules/@cortexkit/subc-client/dist/connection-file.js
 import { promises as fs2 } from "node:fs";
 var SCHEMA_VERSION = 1;
 var MIN_KEY_LEN = 32;
@@ -14597,18 +14711,29 @@ function validate(info) {
     throw new ConnectionFileError(`connection file daemon_id must be ${DAEMON_ID_LEN} bytes, got ${info.daemonId.length}`);
   }
 }
-async function verifyOwnerOnly(path) {
+function verifyOwnerOnly(path, stat, expectedUid) {
   if (process.platform === "win32")
     return;
-  const stat = await fs2.stat(path);
+  if (expectedUid !== undefined && stat.uid !== expectedUid) {
+    throw new ConnectionFileError(`connection file ${path} is owned by uid ${stat.uid}, expected effective uid ${expectedUid}`);
+  }
   const mode = stat.mode & 511;
   if ((mode & 63) !== 0) {
     throw new ConnectionFileError(`connection file ${path} has insecure permissions 0o${mode.toString(8)}; expected owner-only 0600`);
   }
 }
 async function readConnectionFile(path) {
-  await verifyOwnerOnly(path);
-  const raw = await fs2.readFile(path, "utf8");
+  return readConnectionFileForUid(path, process.geteuid?.());
+}
+async function readConnectionFileForUid(path, expectedUid) {
+  const handle = await fs2.open(path, "r");
+  let raw;
+  try {
+    verifyOwnerOnly(path, await handle.stat(), expectedUid);
+    raw = await handle.readFile({ encoding: "utf8" });
+  } finally {
+    await handle.close();
+  }
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -14642,7 +14767,7 @@ async function readConnectionFile(path) {
   return info;
 }
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.20.0/node_modules/@cortexkit/subc-client/dist/launch-nonce.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.21.2/node_modules/@cortexkit/subc-client/dist/launch-nonce.js
 import { closeSync as closeSync4, fstatSync as fstatSync2, readSync as readSync3 } from "node:fs";
 var SUBC_LAUNCH_NONCE_ENV = "SUBC_LAUNCH_NONCE";
 var SUBC_LAUNCH_NONCE_FD_ENV = "SUBC_LAUNCH_NONCE_FD";
@@ -14831,7 +14956,7 @@ function closeQuietly(fd) {
   } catch {}
 }
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.20.0/node_modules/@cortexkit/subc-client/dist/route-handle.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.21.2/node_modules/@cortexkit/subc-client/dist/route-handle.js
 var connectionToken = new WeakMap;
 var reverseRequests = new WeakMap;
 
@@ -14924,7 +15049,7 @@ function sameRouteHandle(left, right) {
   return left === right;
 }
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.20.0/node_modules/@cortexkit/subc-client/dist/client.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.21.2/node_modules/@cortexkit/subc-client/dist/client.js
 var debug = debuglog("subc-client");
 var DEFAULT_HANDSHAKE_TIMEOUT_MS = 1e4;
 var DEFAULT_REQUEST_TIMEOUT_MS = 30000;
@@ -14981,6 +15106,12 @@ function requireBinaryBody(body) {
   const type = body === null ? "null" : Array.isArray(body) ? "array" : typeof body;
   throw new SubcError(`binary request body must be a Uint8Array; got ${type}`, "binary_body_required");
 }
+var SCOPE_ROUTE_CLOSE_REASONS = new Set([
+  "scope_ended",
+  "scope_carrier_removed",
+  "scope_delegation_changed",
+  "scope_parent_ended"
+]);
 function parseRouteCloseReason(reason) {
   switch (reason) {
     case "reload":
@@ -15123,14 +15254,16 @@ class SubcClient {
     return modules.filter((module) => module.capabilities?.provides.includes(capability) ?? false).map((module) => module.module_id).sort();
   }
   async routeOpen(target, identity, opts = {}) {
+    const scope = validatedRouteScope(opts.scope);
     const release = await this.routeOpenGate.acquire();
     try {
-      return await this.sendRouteOpen(target, identity, opts);
+      return await this.sendRouteOpen(target, identity, { ...opts, scope });
     } finally {
       release();
     }
   }
   async sendRouteOpen(target, identity, opts = {}) {
+    const scope = validatedRouteScope(opts.scope);
     const consumerIdentity = routeOpenConsumerIdentity(opts);
     const reverseRequests = opts.reverseRequests ?? new ReverseRequestRegistry;
     reverseRequests.seal();
@@ -15140,7 +15273,8 @@ class SubcClient {
       target,
       identity,
       ...consumerIdentity ? { consumer_identity: consumerIdentity } : {},
-      ...consumerCapabilities.length > 0 ? { consumer_capabilities: consumerCapabilities } : {}
+      ...consumerCapabilities.length > 0 ? { consumer_capabilities: consumerCapabilities } : {},
+      ...scope ? { scope: { owner: scope.owner, ref: scope.ref, scope_epoch: scope.scopeEpoch } } : {}
     });
     let installed = null;
     const install = (frame) => {
@@ -15343,7 +15477,7 @@ class SubcClient {
     this.sendRouteGoodbye(handle);
   }
   async closeManagedRoute(target, identity, opts = {}) {
-    const key = routeCacheKey(target, identity, routeOpenConsumerIdentity(opts), (opts.reverseRequests ?? new ReverseRequestRegistry).capabilities());
+    const key = routeCacheKey(target, identity, routeOpenConsumerIdentity(opts), (opts.reverseRequests ?? new ReverseRequestRegistry).capabilities(), validatedRouteScope(opts.scope));
     const cached = this.routes.get(key);
     if (!cached)
       return;
@@ -15439,13 +15573,13 @@ class SubcClient {
       };
       pending.timer = setTimeout(() => this.arbitrateTimeout(key, pending, channel, corr, ms), ms);
       this.pending.set(key, pending);
-      if (signal)
-        this.attachCancelSignal(signal, key, handle, corr, priority);
       writeBorrowed(this.sock, encodeFrame(frame), Date.now() + ms).catch((error) => {
         const current = this.pending.get(key);
         if (current)
           this.rejectPending(key, current, error instanceof Error ? error : new SubcError(String(error)));
       });
+      if (signal)
+        this.attachCancelSignal(signal, key, handle, corr, priority);
     });
   }
   arbitrateTimeout(key, pending, channel, corr, ms) {
@@ -15519,8 +15653,6 @@ class SubcClient {
       };
       pending.timer = setTimeout(() => this.arbitrateTimeout(key, pending, handle.channel, corr, ms), ms);
       this.pending.set(key, pending);
-      if (signal)
-        this.attachCancelSignal(signal, key, handle, corr, priority);
       const write = writeTrackedBorrowed(this.sock, encodeFrame(frame), Date.now() + ms);
       handedToSocket = write.queued;
       write.completed.catch((error) => {
@@ -15528,9 +15660,12 @@ class SubcClient {
         if (current)
           this.rejectPending(key, current, error instanceof Error ? error : new SubcError(String(error)));
       });
+      if (signal && write.queued)
+        this.attachCancelSignal(signal, key, handle, corr, priority);
     });
   }
   async cachedRouteHandle(moduleId, opts) {
+    const scope = validatedRouteScope(opts.scope);
     const identity = opts.identity ?? this.opts.identity;
     if (!identity) {
       throw new SubcCallError("terminal", "managed call requires a BindIdentity in SubcClient.connect({ identity }) or call(..., { identity })", "missing_identity");
@@ -15539,7 +15674,7 @@ class SubcClient {
     const consumerIdentity = routeOpenConsumerIdentity(opts);
     const reverseRequests = opts.reverseRequests ?? new ReverseRequestRegistry;
     reverseRequests.seal();
-    const key = routeCacheKey(target, identity, consumerIdentity, reverseRequests.capabilities());
+    const key = routeCacheKey(target, identity, consumerIdentity, reverseRequests.capabilities(), scope);
     let cached = this.routes.get(key);
     if (!cached) {
       cached = {
@@ -15547,6 +15682,7 @@ class SubcClient {
         moduleId,
         target,
         identity,
+        scope,
         consumerIdentity,
         reverseRequests,
         handle: null,
@@ -15554,6 +15690,8 @@ class SubcClient {
       };
       this.routes.set(key, cached);
     }
+    if (cached.endReason !== undefined)
+      throw this.endedCachedRoute(cached.endReason);
     if (cached.handle && this.isLiveHandle(cached.handle))
       return cached.handle;
     const startedAt = this.opts.now();
@@ -15589,6 +15727,8 @@ class SubcClient {
     for (;; ) {
       if (cached.closed)
         throw this.routeClosedDuringOpen();
+      if (cached.endReason !== undefined)
+        throw this.endedCachedRoute(cached.endReason);
       try {
         await this.ensureConnectedForManaged();
       } catch (error) {
@@ -15603,6 +15743,7 @@ class SubcClient {
       try {
         outcome = {
           handle: await this.sendRouteOpen(cached.target, cached.identity, {
+            scope: cached.scope,
             consumerIdentity: cached.consumerIdentity ?? null,
             reverseRequests: cached.reverseRequests
           })
@@ -15770,10 +15911,11 @@ class SubcClient {
     }
     for (const key of routeKeys) {
       const cached = this.routes.get(key);
-      if (!cached || cached.closed)
+      if (!cached || cached.closed || cached.endReason !== undefined)
         continue;
       try {
         const handle = await this.routeOpen(cached.target, cached.identity, {
+          scope: cached.scope,
           consumerIdentity: cached.consumerIdentity ?? null,
           reverseRequests: cached.reverseRequests
         });
@@ -15801,11 +15943,15 @@ class SubcClient {
     const cause = new SubcError("route was closed before route.open completed", "route_closed", undefined, "closed_by_caller");
     return new SubcCallError("not_sent", cause.message, cause.code, cause);
   }
+  endedCachedRoute(reason) {
+    const cause = new SubcError(`cached route closed by subc (${reason}); must not reopen`, "route_closed", undefined, reason);
+    return this.terminalCallError(cause.message, cause);
+  }
   async readLoop(sock, generation) {
     try {
       for (;; ) {
         this.readerActive = false;
-        const frame = await sock.readFrame(Number.POSITIVE_INFINITY, { afterHeaderMs: BODY_READ_TIMEOUT_MS }, () => {
+        const frame = await sock.readFrame(Number.POSITIVE_INFINITY, { afterHeaderMs: this.opts.bodyReadTimeoutMs ?? BODY_READ_TIMEOUT_MS }, () => {
           this.readerActive = true;
         });
         try {
@@ -15884,6 +16030,7 @@ class SubcClient {
     }
     if (frame.header.ty === FrameType.Goodbye && handle) {
       this.failHandle(handle, new SubcError("route closed by subc (GOODBYE)", "route_closed", undefined, this.routeEndReason(handle.channel)));
+      this.handleCachedRouteClose(handle.channel, this.routeEndReason(handle.channel));
       if (this.liveRoutes.get(handle.channel) === handle)
         this.liveRoutes.delete(handle.channel);
       this.evictRouteHandle(handle);
@@ -15973,13 +16120,29 @@ class SubcClient {
           const final = push.op === "route.closed";
           if (final || !this.routeEndReasons.get(channel)?.final) {
             this.routeEndReasons.set(channel, { reason, final });
+            if (final)
+              this.handleCachedRouteClose(channel, reason);
           }
         }
       }
     } else if (typeof push.body.module_id === "string") {
       for (const [channel, module] of this.routeModules) {
-        if (module === push.body.module_id)
+        if (module === push.body.module_id) {
           this.legacyChannelReasons.set(channel, reason);
+          if (push.op === "route.closed")
+            this.handleCachedRouteClose(channel, reason);
+        }
+      }
+    }
+  }
+  handleCachedRouteClose(channel, reason) {
+    for (const [key, cached] of this.routes) {
+      if (cached.handle?.channel !== channel)
+        continue;
+      if (SCOPE_ROUTE_CLOSE_REASONS.has(reason)) {
+        cached.endReason = reason;
+      } else {
+        this.routes.delete(key);
       }
     }
   }
@@ -16002,6 +16165,10 @@ class SubcClient {
     this.routeEndReasons.clear();
     this.legacyChannelReasons.clear();
     this.routeModules.clear();
+    for (const [key, cached] of this.routes) {
+      if (cached.endReason === undefined)
+        this.routes.delete(key);
+    }
     for (const [key, pending] of this.pending) {
       this.rejectPending(key, pending, pending.handle ? routeError : err);
     }
@@ -16096,6 +16263,10 @@ function isRouteOpenRefusal(err) {
 function isRetryableRouteOpenCode(code) {
   if (code === "capability_forbidden")
     return false;
+  if (code === "target_flow_unsupported")
+    return false;
+  if (code === "target_agent_run_unsupported")
+    return false;
   return code === "module_reloading" || code === "module_warming" || code === "target_unavailable" || code === "module_timeout" || code === "scope_not_synced" || code === "scope_changed";
 }
 function equalJitter(delayMs, random) {
@@ -16153,6 +16324,7 @@ function normalizeConnectOptions(opts) {
     random: opts.random ?? Math.random,
     routeOpenRetryDeadlineMs: opts.routeOpenRetryDeadlineMs ?? ROUTE_OPEN_RETRY_DEADLINE_MS,
     timeoutArbitrationGraceMs: opts.timeoutArbitrationGraceMs ?? TIMEOUT_ARBITRATION_GRACE_MS,
+    bodyReadTimeoutMs: opts.bodyReadTimeoutMs,
     livenessProbeWindowMs: opts.livenessProbeWindowMs ?? LIVENESS_PROBE_WINDOW_MS,
     onControlPush: opts.onControlPush
   };
@@ -16176,10 +16348,28 @@ function isValidCapabilityIdentifier(identifier) {
   const numericVersion = Number(version);
   return Number.isSafeInteger(numericVersion) && numericVersion >= 1 && numericVersion <= 4294967295;
 }
-function routeCacheKey(target, identity, consumerIdentity, consumerCapabilities) {
+function routeCacheKey(target, identity, consumerIdentity, consumerCapabilities, scope) {
   const consumerPart = consumerIdentity ? `${consumerIdentity.module_id}\x00${consumerIdentity.launch_nonce}` : "";
   const capabilitiesPart = [...consumerCapabilities].sort().join("\x00");
-  return `${target.kind}\x00${target.module_id}\x00${identity.project_root}\x00${identity.harness}\x00${identity.session}\x00${consumerPart}\x00${capabilitiesPart}`;
+  const scopePart = scope ? JSON.stringify([scope.owner.kind, scope.owner.kind === "reserved" ? scope.owner.module_id : null, scope.ref, scope.scopeEpoch]) : "";
+  return `${target.kind}\x00${target.module_id}\x00${identity.project_root}\x00${identity.harness}\x00${identity.session}\x00${consumerPart}\x00${capabilitiesPart}\x00${scopePart}`;
+}
+function validatedRouteScope(scope) {
+  if (scope === undefined)
+    return;
+  if (!scope || typeof scope.owner !== "object" || !scope.owner || !["reserved", "direct", "unverified"].includes(scope.owner.kind) || scope.owner.kind === "reserved" && (typeof scope.owner.module_id !== "string" || scope.owner.module_id.length === 0)) {
+    throw new SubcError("scope.owner must be a Principal with a non-empty reserved module_id", "invalid_scope");
+  }
+  if (typeof scope.ref !== "string" || scope.ref.length === 0) {
+    throw new SubcError("scope.ref must be a non-empty string", "invalid_scope");
+  }
+  if (scope.scopeEpoch === undefined) {
+    throw new SubcError("scope.scopeEpoch is required", "scope_epoch_required");
+  }
+  if (!Number.isSafeInteger(scope.scopeEpoch) || scope.scopeEpoch < 0) {
+    throw new SubcError("scope.scopeEpoch must be a safe non-negative integer", "invalid_scope");
+  }
+  return { owner: { ...scope.owner }, ref: scope.ref, scopeEpoch: scope.scopeEpoch };
 }
 function routeOpenConsumerIdentity(opts = {}) {
   if (opts.consumerIdentity !== undefined)
@@ -16700,6 +16890,41 @@ class SubcRouteClosedMidCallError extends SubcCallError {
     this.reason = reason;
   }
 }
+
+class SubcFrameReadTimeoutError extends SubcCallError {
+  constructor(cause) {
+    super("outcome_unknown", "the command may have run; timed out waiting for frame body bytes from the AFT daemon", "frame_read_timeout", cause);
+    this.name = "SubcFrameReadTimeoutError";
+  }
+}
+function isFrameBodyReadTimeoutMessage(message) {
+  return typeof message === "string" && (/timed out waiting for \d+ bytes/i.test(message) || message.includes("timed out waiting for frame body bytes"));
+}
+function isSubcFrameReadTimeoutError(error) {
+  if (error instanceof SubcFrameReadTimeoutError)
+    return true;
+  if (error instanceof SocketTimeoutError && isFrameBodyReadTimeoutMessage(error.message)) {
+    return true;
+  }
+  if (error instanceof SubcError && isFrameBodyReadTimeoutMessage(error.message)) {
+    return true;
+  }
+  if (error instanceof SubcCallError) {
+    if (error.code === "frame_read_timeout")
+      return true;
+    if (error.cause !== undefined && error.cause !== error && isSubcFrameReadTimeoutError(error.cause)) {
+      return true;
+    }
+    if (isFrameBodyReadTimeoutMessage(error.message))
+      return true;
+  }
+  return false;
+}
+function frameReadTimeoutError(error) {
+  if (!isSubcFrameReadTimeoutError(error))
+    return error;
+  return error instanceof SubcFrameReadTimeoutError ? error : new SubcFrameReadTimeoutError(error);
+}
 function isLocalRouteCloseRejection(error) {
   return error instanceof SubcError && error.closeReason === "closed_by_caller";
 }
@@ -16726,6 +16951,8 @@ function isSubcClientClosedError(error) {
   return error instanceof SubcError && error.message === "client closed";
 }
 function isSocketDeathError(error, depth = 0) {
+  if (isSubcFrameReadTimeoutError(error))
+    return true;
   if (error instanceof SubcError && error.closeReason === "connection_lost")
     return true;
   if (error instanceof SubcCallError) {
@@ -16768,6 +16995,12 @@ class SubcLivenessProbeTimeoutError extends Error {
   }
 }
 var AFT_MODULE_ID = "aft";
+var HOST_SCOPE_LOOKUP_TIMEOUT_MS = 2000;
+var HOST_SCOPE_RETRY_FLOOR_MS = 5000;
+var HOST_SCOPE_RETRY_CAP_MS = 300000;
+function isHostScopeSyncRefusal(code) {
+  return code === "scope_not_live" || code === "scope_not_synced" || code === "scope_changed";
+}
 var MAX_CONSECUTIVE_TRANSPORT_FAILURES = 3;
 var LIVENESS_PROBE_TIMEOUT_MS = 15000;
 var REQUEST_DEADLINE_CODE = "request_deadline";
@@ -16846,7 +17079,7 @@ class BgSubscription {
   identity;
   acquireClient;
   dropClient;
-  consumerIdentity;
+  openRoute;
   onNudge;
   sleep;
   canAttach;
@@ -16857,21 +17090,25 @@ class BgSubscription {
   isCurrent;
   noteClientAlive;
   noteUnansweredCall;
+  onRouteAttached;
   stopped = false;
   current = null;
   attached = null;
+  route = null;
   loop;
   lifecycleLogState = new Map;
   nudgeReceiptLogState = null;
-  constructor(identity, acquireClient, dropClient, consumerIdentity, onNudge, sleep, canAttach, onRootAttachFailure, onDormant, dispatchProbeIntervalMs, nudgeRef, isCurrent = () => true, noteClientAlive = () => {
+  constructor(identity, acquireClient, dropClient, openRoute, onNudge, sleep, canAttach, onRootAttachFailure, onDormant, dispatchProbeIntervalMs, nudgeRef, isCurrent = () => true, noteClientAlive = () => {
     return;
   }, noteUnansweredCall = () => {
     return;
+  }, onRouteAttached = () => {
+    return;
   }) {
     this.identity = identity;
     this.acquireClient = acquireClient;
     this.dropClient = dropClient;
-    this.consumerIdentity = consumerIdentity;
+    this.openRoute = openRoute;
     this.onNudge = onNudge;
     this.sleep = sleep;
     this.canAttach = canAttach;
@@ -16882,11 +17119,15 @@ class BgSubscription {
     this.isCurrent = isCurrent;
     this.noteClientAlive = noteClientAlive;
     this.noteUnansweredCall = noteUnansweredCall;
+    this.onRouteAttached = onRouteAttached;
     this.loop = this.run();
   }
   get attachedClient() {
     return this.attached;
   }
+  get attachedRoute() {
+    return this.route;
+  }
   async stop() {
     this.stopped = true;
     const sub = this.current;
@@ -17011,7 +17252,7 @@ class BgSubscription {
       }
       let route;
       try {
-        route = await client.routeOpen({ kind: "tool_provider", module_id: AFT_MODULE_ID }, this.identity, { consumerIdentity: this.consumerIdentity });
+        route = await this.openRoute(client);
       } catch (err) {
         if (this.isCurrent() && this.onRootAttachFailure(err)) {
           if (reconnecting)
@@ -17069,6 +17310,8 @@ class BgSubscription {
         });
         this.current = sub;
         this.attached = client;
+        this.route = route;
+        this.onRouteAttached();
         stopDispatchProbe = this.startDispatchProbe(client, routeId);
         this.info("subscription-open", `subscription open channel=${routeId}`);
         if (reconnecting) {
@@ -17111,6 +17354,7 @@ class BgSubscription {
         stopDispatchProbe();
         this.current = null;
         this.attached = null;
+        this.route = null;
         safeCloseRoute(client, route);
       }
       await this.backoff(backoffAttempt++);
@@ -17126,7 +17370,7 @@ function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isRouteProvenAbsentError(err) {
-  return err instanceof SubcError && err.code === "unknown_channel" || err instanceof StaleRouteHandleError;
+  return err instanceof SubcError && (err.code === "unknown_channel" || err.code === "stale_route_epoch") || err instanceof StaleRouteHandleError;
 }
 function isAbsentRootRouteError(err) {
   return isRecord(err) && err.code === "config_divergence" && typeof err.message === "string" && err.message.includes("project root does not exist");
@@ -17253,6 +17497,8 @@ class SubcTransport {
       body.preview = true;
     if (options?.workerSession === true)
       body[WORKER_SESSION_FIELD] = true;
+    if (options?.hostToolNames)
+      body[HOST_TOOL_NAMES_FIELD] = options.hostToolNames;
     body[PRESET_FIELD] = callPresetFor(options?.workerSession === true);
     const reply = await this.pool.routeRequest(this.identityFor(sessionId), body, timeoutMs, onProgress, this.generation, abortSignal);
     return reliftReply(reply);
@@ -17264,10 +17510,12 @@ class SubcTransport {
     }
     const { timeoutMs, onProgress, abortSignal } = this.splitOptions(options);
     const session = typeof params.session_id === "string" ? params.session_id : undefined;
-    const { [WORKER_SESSION_FIELD]: workerSession, ...args } = params;
+    const { [WORKER_SESSION_FIELD]: workerSession, [HOST_TOOL_NAMES_FIELD]: hostToolNames, ...args } = params;
     const body = { name: command, arguments: args };
     if (workerSession === true)
       body[WORKER_SESSION_FIELD] = true;
+    if (hostToolNames !== undefined)
+      body[HOST_TOOL_NAMES_FIELD] = hostToolNames;
     body[PRESET_FIELD] = callPresetFor(workerSession === true);
     const editSlotSurvives = this.pool.getEditSlotSurvives();
     if (editSlotSurvives !== undefined)
@@ -17290,6 +17538,10 @@ class SubcTransportPool {
   connectionFile;
   handshakeTimeoutMs;
   consumerIdentity;
+  hostScopes;
+  hostScopeCache = new Map;
+  hostScopeRefusals = new Set;
+  hostScopeOutcomes = new Map;
   connectFn;
   onBgEventsNudge;
   onBgEventsNudgeRef;
@@ -17311,6 +17563,7 @@ class SubcTransportPool {
   routeReopenRetry = null;
   routeReopenRetryMs = null;
   sessions = new Map;
+  sessionIndex = new Map;
   observedStarts = new Set;
   sessionSweep = null;
   rootIndex = new Map;
@@ -17330,6 +17583,7 @@ class SubcTransportPool {
     this.harness = options.harness;
     this.handshakeTimeoutMs = options.handshakeTimeoutMs;
     this.consumerIdentity = options.consumerIdentity;
+    this.hostScopes = options.hostScopes ?? false;
     this.connectFn = options.connect ?? ((opts) => SubcClient.connect(opts));
     this.onBgEventsNudge = options.onBgEventsNudge;
     this.onBgEventsNudgeRef = options.onBgEventsNudgeRef;
@@ -17549,7 +17803,9 @@ class SubcTransportPool {
     return transport;
   }
   getBridge(projectRoot) {
-    const root = this.canonicalRoot(projectRoot);
+    return this.getBridgeForCanonicalRoot(this.canonicalRoot(projectRoot));
+  }
+  getBridgeForCanonicalRoot(root) {
     if (this.shuttingDown && this.lifecycleEnabled()) {
       throw new SubcTransportShuttingDownError;
     }
@@ -17646,6 +17902,12 @@ class SubcTransportPool {
       pendingDetach: false
     };
     this.sessions.set(key, record);
+    let records = this.sessionIndex.get(identity.session);
+    if (!records) {
+      records = new Set;
+      this.sessionIndex.set(identity.session, records);
+    }
+    records.add(record);
     let keys = this.rootIndex.get(root);
     if (!keys) {
       keys = new Set;
@@ -17823,6 +18085,10 @@ class SubcTransportPool {
     log(`subc bg_events: ${message}${suffix}`, { sessionId: record.identity.session });
   }
   removeIndexMembership(record) {
+    const records = this.sessionIndex.get(record.identity.session);
+    records?.delete(record);
+    if (records?.size === 0)
+      this.sessionIndex.delete(record.identity.session);
     const keys = this.rootIndex.get(record.canonicalRoot);
     if (!keys)
       return;
@@ -17835,6 +18101,7 @@ class SubcTransportPool {
       this.sessions.delete(record.identityKey);
       this.removeIndexMembership(record);
     }
+    this.stopUnusedHostScopeRetry(record.identity.session);
   }
   detachSession(key, reason) {
     const record = this.sessions.get(key);
@@ -17854,6 +18121,7 @@ class SubcTransportPool {
     record.routeEntry = null;
     if (routeEntry)
       routeEntry.closed = true;
+    this.stopUnusedHostScopeRetry(record.identity.session);
     return { record, bgSub, routeEntry };
   }
   async cleanupDetached(detached) {
@@ -17910,6 +18178,17 @@ class SubcTransportPool {
     entry.inflight -= 1;
     this.closeRetiredRoute(record, entry);
   }
+  retireHostToolRoute(record) {
+    const entry = record.routeEntry;
+    if (!entry)
+      return;
+    entry.closed = true;
+    entry.closedBy ??= "route replaced";
+    record.routeEntry = null;
+    record.retiredRoutes.add(entry);
+    this.closeRetiredRoute(record, entry);
+    this.stopUnusedHostScopeRetry(record.identity.session);
+  }
   async routeRequest(identity, body, timeoutMs, onProgress, expectedGeneration, abortSignal) {
     const callStartedAt = performance.now();
     const callDeadlineMs = timeoutMs ?? SUBC_DEFAULT_REQUEST_TIMEOUT_MS;
@@ -18048,15 +18327,14 @@ class SubcTransportPool {
       const clearRouteEntry = (entry) => {
         if (record.routeEntry !== entry)
           return;
-        entry.closed = true;
-        entry.closedBy ??= "route replaced";
-        record.routeEntry = null;
-        record.retiredRoutes.add(entry);
-        this.closeRetiredRoute(record, entry);
+        this.retireHostToolRoute(record);
       };
       const handleRequestFailure = (error, entry) => {
         const aborted = error instanceof Error && error.name === "AbortError";
         const ownsClient = this.isCurrentSession(key, record) && this.client === client && !this.isReapInduced(record);
+        if (ownsClient && error instanceof SubcError && error.closeReason?.startsWith("scope_")) {
+          this.invalidateHostScope(identity.session);
+        }
         if (!aborted && ownsClient && isSocketDeathError(error)) {
           this.dropClient(client, {
             error,
@@ -18065,7 +18343,7 @@ class SubcTransportPool {
             route: routeLabel(entry.handle)
           });
         }
-        if (aborted || isRouteProvenAbsentError(error) || error instanceof SubcError && error.closeReason !== undefined) {
+        if (aborted || isRouteProvenAbsentError(error) || error instanceof SubcError && error.closeReason !== undefined || isSubcFrameReadTimeoutError(error)) {
           clearRouteEntry(entry);
         }
         if (aborted || !ownsClient || this.client !== client)
@@ -18144,10 +18422,13 @@ class SubcTransportPool {
             this.resetRouteReopenBackoff();
           return reply;
         } catch (requestError) {
-          const error = routeClosedMidCallError(requestError, routeAndEntry.entry, record);
+          const error = frameReadTimeoutError(routeClosedMidCallError(requestError, routeAndEntry.entry, record));
           if (this.isReapInduced(record))
             throw this.annotateReapError(error, record);
           const ownsRoute = this.isCurrentSession(key, record) && this.client === client;
+          if (ownsRoute && (error instanceof SubcError && error.code === "stale_route_epoch" || error instanceof StaleRouteHandleError)) {
+            this.invalidateHostScope(identity.session);
+          }
           if (ownsRoute && isRouteRequestReloadRefusal(error)) {
             clearRouteEntry(routeAndEntry.entry);
             lastRefusal = error;
@@ -18224,9 +18505,14 @@ class SubcTransportPool {
       return this.client;
     if (this.connecting)
       return this.connecting;
+    let owner;
     this.connecting = this.connectFn({
       connectionFile: this.connectionFile,
-      handshakeTimeoutMs: this.handshakeTimeoutMs
+      handshakeTimeoutMs: this.handshakeTimeoutMs,
+      onControlPush: (push) => {
+        if (owner && this.client === owner)
+          this.onScopeRouteClose(push);
+      }
     }).then((client) => {
       this.connecting = null;
       if (this.shuttingDown) {
@@ -18236,6 +18522,7 @@ class SubcTransportPool {
         throw new SubcTransportShuttingDownError;
       }
       this.client = client;
+      owner = client;
       this.hadWorkingClient = true;
       this.transportFailures = 0;
       return client;
@@ -18265,9 +18552,7 @@ class SubcTransportPool {
       closedBy: null
     };
     this.assertRootCanAttach(record.canonicalRoot);
-    const opening = client.routeOpen({ kind: "tool_provider", module_id: AFT_MODULE_ID }, identity, {
-      consumerIdentity: this.consumerIdentity
-    }).then((route) => {
+    const opening = this.openHostToolRoute(client, identity, record, entry).then((route) => {
       if (!this.isCurrentSession(record.identityKey, record) || record.routeEntry !== entry || entry.closed || this.client !== client || this.lifecycleEnabled() && !this.isCurrentLiveGeneration(record.canonicalRoot, record.generation)) {
         safeCloseRoute(client, route);
         if (record.routeEntry === entry)
@@ -18277,6 +18562,12 @@ class SubcTransportPool {
       entry.handle = route;
       entry.opening = null;
       this.noteClientAlive(client);
+      const state = this.hostScopeCache.get(identity.session);
+      if (state)
+        this.scheduleHostScopeRetry(identity.session, state);
+      if (state?.answer?.result === "scope" && !state.scopeBindPending && !entry.hostScope && !this.hostScopeRefusals.has(identity.session)) {
+        this.promoteHostScope(identity.session);
+      }
       return route;
     }).catch((error) => {
       const currentEntry = this.isCurrentSession(record.identityKey, record) && record.routeEntry === entry;
@@ -18284,6 +18575,7 @@ class SubcTransportPool {
         entry.closed = true;
         record.routeEntry = null;
       }
+      this.stopUnusedHostScopeRetry(identity.session);
       if (!this.isCurrentSession(record.identityKey, record) && !(error instanceof RouteTornDownError)) {
         throw new RouteTornDownError("subc route opened after session closed");
       }
@@ -18296,6 +18588,327 @@ class SubcTransportPool {
     record.routeEntry = entry;
     return { route: await opening, entry };
   }
+  hostScope(client, identity) {
+    if (this.hostScopeRefusals.has(identity.session))
+      return Promise.resolve(undefined);
+    let state = this.hostScopeCache.get(identity.session);
+    if (!state) {
+      state = { retryAt: 0, retryMs: HOST_SCOPE_RETRY_FLOOR_MS };
+      this.hostScopeCache.set(identity.session, state);
+    }
+    if (state.answer) {
+      return Promise.resolve(state.answer.result === "scope" && !state.scopeBindPending ? state.answer.scope : undefined);
+    }
+    if (state.pending)
+      return state.pending;
+    if (Date.now() < state.retryAt)
+      return Promise.resolve(undefined);
+    const current = state;
+    clearTimeout(current.retryTimer);
+    current.retryTimer = undefined;
+    const abort = new AbortController;
+    current.lookupAbort = abort;
+    const lookup = this.readHostScope(client, identity, abort.signal).then((outcome) => {
+      if (this.hostScopeCache.get(identity.session) !== current)
+        return;
+      current.pending = undefined;
+      current.lookupAbort = undefined;
+      if (abort.signal.aborted)
+        return;
+      this.logHostScopeOutcome(identity.session, outcome);
+      if (outcome.result === "scope" || outcome.result === "no_scope") {
+        current.answer = outcome;
+        current.retryAt = 0;
+        current.retryMs = HOST_SCOPE_RETRY_FLOOR_MS;
+        if (outcome.result === "scope")
+          this.promoteHostScope(identity.session);
+      } else {
+        current.retryAt = Date.now() + current.retryMs;
+        current.retryMs = Math.min(current.retryMs * 2, HOST_SCOPE_RETRY_CAP_MS);
+        this.scheduleHostScopeRetry(identity.session, current);
+      }
+      return outcome.result === "scope" ? outcome.scope : undefined;
+    });
+    current.pending = lookup;
+    return lookup;
+  }
+  unscopedHostRecord(session) {
+    for (const record of this.sessionIndex.get(session) ?? []) {
+      const entry = record.routeEntry;
+      if (record.identity.session === session && !record.closed && (entry && !entry.closed && !entry.hostScope && entry.client === this.client && (entry.handle || entry.opening) || record.bgSub?.attachedClient === this.client && record.bgSub?.attachedRoute))
+        return record;
+    }
+    return;
+  }
+  cancelHostScopeRetry(state) {
+    clearTimeout(state.retryTimer);
+    state.retryTimer = undefined;
+    state.lookupAbort?.abort();
+  }
+  stopUnusedHostScopeRetry(session) {
+    const state = this.hostScopeCache.get(session);
+    if (state && !this.unscopedHostRecord(session)) {
+      if (state.retryTimer || state.scopeBindPending && state.bindPending)
+        log(`subc head scope: session=${session} retry stopped reason=route_closed`);
+      this.cancelHostScopeRetry(state);
+      state.scopeBindPending = false;
+    }
+  }
+  scheduleHostScopeRetry(session, state) {
+    if (this.shuttingDown || this.hostScopeCache.get(session) !== state || state.answer && !state.scopeBindPending || state.pending || state.bindPending || state.retryTimer || this.hostScopeRefusals.has(session) || !this.unscopedHostRecord(session))
+      return;
+    state.retryTimer = setTimeout(() => {
+      state.retryTimer = undefined;
+      const record = this.unscopedHostRecord(session);
+      const client = record?.routeEntry?.client ?? record?.bgSub?.attachedClient;
+      if (this.shuttingDown || this.hostScopeCache.get(session) !== state || !record || !client)
+        return;
+      let retry;
+      if (state.scopeBindPending && state.answer?.result === "scope") {
+        state.bindPending = this.retryHostScopeBind(client, record.identity, state, state.answer.scope).finally(() => {
+          state.bindPending = undefined;
+          this.scheduleHostScopeRetry(session, state);
+        });
+        retry = state.bindPending;
+      } else {
+        retry = this.hostScope(client, record.identity);
+      }
+      retry.catch((error) => {
+        warn(`subc head scope: background retry failed code=${error instanceof Error ? error.name : "Error"}`);
+      });
+    }, Math.max(0, state.retryAt - Date.now()));
+    state.retryTimer.unref();
+  }
+  deferHostScopeBind(session, state, code) {
+    state.scopeBindPending = true;
+    if (Date.now() >= state.retryAt) {
+      state.retryAt = Date.now() + state.retryMs;
+      state.retryMs = Math.min(state.retryMs * 2, HOST_SCOPE_RETRY_CAP_MS);
+    }
+    warn(`subc head scope: session=${session} scoped bind refused code=${code}; binding unscoped; retry in=${Math.max(0, state.retryAt - Date.now())}ms`);
+    this.scheduleHostScopeRetry(session, state);
+  }
+  refuseHostScopeBind(session, state, code) {
+    if (!this.hostScopeRefusals.has(session)) {
+      this.hostScopeRefusals.add(session);
+      warn(`subc head scope: session=${session} scoped bind refused code=${code}; binding unscoped; retry stopped`);
+    }
+    if (state) {
+      state.scopeBindPending = false;
+      this.cancelHostScopeRetry(state);
+    }
+  }
+  async retryHostScopeBind(client, identity, state, scope) {
+    try {
+      const route = await client.routeOpen({ kind: "tool_provider", module_id: AFT_MODULE_ID }, identity, { consumerIdentity: this.consumerIdentity, scope });
+      safeCloseRoute(client, route);
+      if (this.hostScopeCache.get(identity.session) !== state || !state.scopeBindPending || this.shuttingDown || client !== this.client || !this.unscopedHostRecord(identity.session))
+        return;
+      state.scopeBindPending = false;
+      state.retryAt = 0;
+      state.retryMs = HOST_SCOPE_RETRY_FLOOR_MS;
+      log(`subc head scope: session=${identity.session} scoped bind recovered ref=${scope.ref.slice(0, 8)} epoch=${scope.scopeEpoch}`);
+      this.promoteHostScope(identity.session);
+    } catch (error) {
+      if (this.hostScopeCache.get(identity.session) !== state || !state.scopeBindPending || this.shuttingDown || !this.unscopedHostRecord(identity.session))
+        return;
+      if (error instanceof SubcError && error.code && !isSocketDeathError(error) && !isRouteOpenReloadWindowError(error) && !isHostScopeSyncRefusal(error.code)) {
+        this.refuseHostScopeBind(identity.session, state, error.code);
+      } else {
+        this.deferHostScopeBind(identity.session, state, error instanceof SubcError ? error.code ?? error.name : "Error");
+      }
+    }
+  }
+  promoteHostScope(session) {
+    for (const record of this.sessions.values()) {
+      const entry = record.routeEntry;
+      if (record.identity.session !== session)
+        continue;
+      if (entry?.handle && !entry.hostScope)
+        this.retireHostToolRoute(record);
+      const sub = record.bgSub;
+      if (!sub?.attachedRoute)
+        continue;
+      sub.stop().then(() => {
+        if (record.bgSub !== sub)
+          return;
+        record.bgSub = null;
+        this.ensureBgSubscription(record.identity, record);
+      });
+    }
+  }
+  logHostScopeOutcome(session, outcome) {
+    let key;
+    let detail;
+    switch (outcome.result) {
+      case "scope":
+        key = JSON.stringify([outcome.result, outcome.scope.ref, outcome.scope.scopeEpoch]);
+        detail = `scope ref=${outcome.scope.ref.slice(0, 8)} epoch=${outcome.scope.scopeEpoch}`;
+        break;
+      case "error":
+        key = JSON.stringify([outcome.result, outcome.code]);
+        detail = `error code=${outcome.code} after=${outcome.afterMs}`;
+        break;
+      case "timeout":
+        key = outcome.result;
+        detail = `timeout after=${outcome.afterMs}`;
+        break;
+      default:
+        key = outcome.result;
+        detail = outcome.result;
+    }
+    if (this.hostScopeOutcomes.get(session) === key)
+      return;
+    this.hostScopeOutcomes.set(session, key);
+    log(`subc head scope: session=${session} result=${detail}`);
+  }
+  async readHostScope(client, identity, signal) {
+    const startedAt = Date.now();
+    const timeout = () => ({ result: "timeout", afterMs: Date.now() - startedAt });
+    let expired = false;
+    let timer;
+    const abort = new AbortController;
+    let cancel;
+    const cancelled = new Promise((resolve) => {
+      cancel = () => {
+        expired = true;
+        abort.abort();
+        resolve({ result: "error", code: "AbortError", afterMs: Date.now() - startedAt });
+      };
+      signal.addEventListener("abort", cancel, { once: true });
+    });
+    const read = async () => {
+      let route;
+      try {
+        route = await client.routeOpen({ kind: "management_surface", module_id: "prefrontal-core" }, identity, { consumerIdentity: this.consumerIdentity });
+        if (expired)
+          return timeout();
+        const envelope = await client.request(route, {
+          method: "session.scope_identity",
+          params: { harness: identity.harness, session: identity.session }
+        }, { timeoutMs: HOST_SCOPE_LOOKUP_TIMEOUT_MS, signal: abort.signal });
+        const reply = isRecord(envelope) ? envelope.result : undefined;
+        if (isRecord(reply) && reply.answer === "no_scope")
+          return { result: "no_scope" };
+        if (!isRecord(reply) || !isRecord(reply.owner) || reply.owner.kind !== "reserved" || reply.owner.module_id !== "prefrontal-core" || typeof reply.ref !== "string" || reply.ref.length === 0 || !Number.isSafeInteger(reply.scope_epoch) || reply.scope_epoch < 0)
+          return { result: "malformed" };
+        return {
+          result: "scope",
+          scope: {
+            owner: { kind: "reserved", module_id: "prefrontal-core" },
+            ref: reply.ref,
+            scopeEpoch: reply.scope_epoch
+          }
+        };
+      } catch (error) {
+        if (expired)
+          return timeout();
+        return {
+          result: "error",
+          code: error instanceof SubcError && error.code ? error.code : error instanceof Error ? error.name : "Error",
+          afterMs: Date.now() - startedAt
+        };
+      } finally {
+        if (route)
+          safeCloseRoute(client, route);
+      }
+    };
+    try {
+      return await Promise.race([
+        read(),
+        cancelled,
+        new Promise((resolve) => {
+          timer = setTimeout(() => {
+            expired = true;
+            abort.abort();
+            resolve(timeout());
+          }, HOST_SCOPE_LOOKUP_TIMEOUT_MS);
+        })
+      ]);
+    } finally {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", cancel);
+    }
+  }
+  openHostToolRoute(client, identity, record, entry) {
+    if (!this.hostScopes || !["opencode", "pi"].includes(identity.harness) || identity.session === DEFAULT_SESSION_ID) {
+      return client.routeOpen({ kind: "tool_provider", module_id: AFT_MODULE_ID }, identity, {
+        consumerIdentity: this.consumerIdentity
+      });
+    }
+    return this.openScopedHostToolRoute(client, identity, record, entry);
+  }
+  async openScopedHostToolRoute(client, identity, record, entry) {
+    const scope = await this.hostScope(client, identity);
+    this.assertRecordLive(record);
+    if (scope) {
+      try {
+        const route = await client.routeOpen({ kind: "tool_provider", module_id: AFT_MODULE_ID }, identity, { consumerIdentity: this.consumerIdentity, scope });
+        if (entry)
+          entry.hostScope = scope;
+        return route;
+      } catch (error) {
+        if (!(error instanceof SubcError) || !error.code || isSocketDeathError(error))
+          throw error;
+        if (isRouteOpenReloadWindowError(error))
+          throw error;
+        this.assertRecordLive(record);
+        const state = this.hostScopeCache.get(identity.session);
+        if (state && isHostScopeSyncRefusal(error.code)) {
+          this.deferHostScopeBind(identity.session, state, error.code);
+        } else {
+          this.refuseHostScopeBind(identity.session, state, error.code);
+        }
+      }
+    }
+    this.assertRecordLive(record);
+    const route = await client.routeOpen({ kind: "tool_provider", module_id: AFT_MODULE_ID }, identity, {
+      consumerIdentity: this.consumerIdentity
+    });
+    if (this.hostScopeCache.get(identity.session)?.answer?.result === "scope" && !this.hostScopeCache.get(identity.session)?.scopeBindPending && !this.hostScopeRefusals.has(identity.session)) {
+      safeCloseRoute(client, route);
+      return this.openScopedHostToolRoute(client, identity, record, entry);
+    }
+    return route;
+  }
+  invalidateHostScope(session) {
+    const state = this.hostScopeCache.get(session);
+    if (state) {
+      if (state.scopeBindPending)
+        log(`subc head scope: session=${session} retry stopped reason=scope_route_closed`);
+      this.cancelHostScopeRetry(state);
+    }
+    this.hostScopeCache.delete(session);
+    this.hostScopeRefusals.delete(session);
+    for (const record of this.sessions.values()) {
+      if (record.identity.session !== session || !record.routeEntry)
+        continue;
+      this.retireHostToolRoute(record);
+    }
+  }
+  onScopeRouteClose(push) {
+    if (push.op !== "route.closed")
+      return;
+    const reason = routeCloseReason(push);
+    if (!reason?.startsWith("scope_")) {
+      for (const record of this.sessions.values()) {
+        const route = record.routeEntry?.handle;
+        if (!route)
+          continue;
+        if (Array.isArray(push.body.channels) && push.body.channels.includes(route.channel) || !Array.isArray(push.body.channels) && push.body.module_id === AFT_MODULE_ID)
+          this.retireHostToolRoute(record);
+      }
+      return;
+    }
+    const sessions = new Set;
+    for (const record of this.sessions.values()) {
+      const routes = [record.routeEntry?.handle, record.bgSub?.attachedRoute].filter((route) => route != null);
+      if (Array.isArray(push.body.channels) && routes.some((route) => push.body.channels.includes(route.channel)) || !Array.isArray(push.body.channels) && push.body.module_id === AFT_MODULE_ID)
+        sessions.add(record.identity.session);
+    }
+    for (const session of sessions)
+      this.invalidateHostScope(session);
+  }
   ensureBgSubscription(identity, record) {
     if (this.shuttingDown || !this.onBgEventsNudge && !this.onBgEventsNudgeRef)
       return;
@@ -18335,17 +18948,28 @@ class SubcTransportPool {
         return;
       this.logNudgeDelivery("drop-no-compatible-handler", currentRecord, `nudge dropped cause=generation-provenance-unavailable-and-root-session-handler-unwired root=${currentRecord.canonicalRoot}`);
     };
+    const binding = {};
     let sub = null;
     const clearDormantSubscription = () => {
       if (sub && record.bgSub === sub)
         record.bgSub = null;
     };
-    sub = new BgSubscription(identity, () => this.ensureClient(), (client, cause) => this.dropClient(client, cause), this.consumerIdentity, onNudge, this.bgBackoffSleep, () => this.rootCanAttach(record.canonicalRoot), (error) => {
+    sub = new BgSubscription(identity, () => this.ensureClient(), (client, cause) => this.dropClient(client, cause), (client) => {
+      binding.hostScope = undefined;
+      return this.openHostToolRoute(client, identity, record, binding);
+    }, onNudge, this.bgBackoffSleep, () => this.rootCanAttach(record.canonicalRoot), (error) => {
       if (!isAbsentRootRouteError(error))
         return false;
       this.markRootDormant(record.canonicalRoot, error);
       return true;
-    }, clearDormantSubscription, this.bgDispatchProbeIntervalMs, nudgeRef, () => this.isCurrentSession(record.identityKey, record) && this.isCurrentLiveGeneration(record.canonicalRoot, record.generation), (client) => this.noteClientAlive(client), (client, cause) => this.noteUnansweredCall(client, cause));
+    }, clearDormantSubscription, this.bgDispatchProbeIntervalMs, nudgeRef, () => this.isCurrentSession(record.identityKey, record) && this.isCurrentLiveGeneration(record.canonicalRoot, record.generation), (client) => this.noteClientAlive(client), (client, cause) => this.noteUnansweredCall(client, cause), () => {
+      const state = this.hostScopeCache.get(identity.session);
+      if (state)
+        this.scheduleHostScopeRetry(identity.session, state);
+      if (state?.answer?.result === "scope" && !state.scopeBindPending && !binding.hostScope && !this.hostScopeRefusals.has(identity.session)) {
+        this.promoteHostScope(identity.session);
+      }
+    });
     record.bgSub = sub;
     if (!this.rootCanAttach(record.canonicalRoot)) {
       record.bgSub = null;
@@ -18381,6 +19005,8 @@ class SubcTransportPool {
       record.routeEntry = null;
       this.deleteSessionIfEmpty(record.identityKey, record);
     }
+    for (const session of this.hostScopeCache.keys())
+      this.stopUnusedHostScopeRetry(session);
     this.transportFailures = 0;
     try {
       client.close();
@@ -18518,6 +19144,13 @@ class SubcTransportPool {
     this.generationRejections.clear();
     this.observedStarts.clear();
     this.dormantRoots.clear();
+    const scopeLookups = [...this.hostScopeCache.values()].flatMap((state) => {
+      this.cancelHostScopeRetry(state);
+      return state.pending ? [state.pending] : [];
+    });
+    this.hostScopeCache.clear();
+    this.hostScopeRefusals.clear();
+    this.hostScopeOutcomes.clear();
     const registration = this.lifecycleRegistration;
     registration?.deregister();
     this.lifecycleRegistration = null;
@@ -18528,11 +19161,16 @@ class SubcTransportPool {
         detached.push(owner);
     }
     this.rootIndex.clear();
+    this.sessionIndex.clear();
     this.transports.clear();
     const client = this.client;
     this.client = null;
     const pending = [...this.pendingRootCleanups];
-    await Promise.allSettled([...detached.map((owner) => this.cleanupDetached(owner)), ...pending]);
+    await Promise.allSettled([
+      ...detached.map((owner) => this.cleanupDetached(owner)),
+      ...pending,
+      ...scopeLookups
+    ]);
     if (client) {
       try {
         client.close();
@@ -18546,6 +19184,13 @@ class SubcTransportPool {
       session: session && session.length > 0 ? session : DEFAULT_SESSION_ID
     };
     const owner = this.detachSession(identityKey(identity), "session_closed");
+    if (!this.sessionIndex.has(identity.session)) {
+      const state = this.hostScopeCache.get(identity.session);
+      if (state)
+        this.cancelHostScopeRetry(state);
+      this.hostScopeCache.delete(identity.session);
+      this.hostScopeRefusals.delete(identity.session);
+    }
     if (owner)
       await this.cleanupDetached(owner);
   }
@@ -18586,6 +19231,8 @@ var BASH_TRANSPORT_DISPOSITION = "The transport to the AFT daemon was interrupte
 var SUBC_MODULE_RESTART_DISPOSITION = "The AFT daemon module restarted while this call was in flight, so its outcome is UNKNOWN: it may or may not have executed. Verify actual state before re-running, and never blind-retry a mutation.";
 var BRIDGE_TRANSPORT_UNKNOWN_OUTCOME_DISPOSITION = "The standalone AFT transport failed after this call may have been sent, so its outcome is UNKNOWN: it may or may not have executed. Verify actual state before re-running, and never blind-retry a mutation.";
 var SUBC_ROUTE_CLOSED_MID_CALL_DISPOSITION = "The plugin closed this call's route while the call was in flight, so its outcome is UNKNOWN: it may or may not have executed. Verify actual state before re-running, and never blind-retry a mutation.";
+var BASH_FRAME_READ_TIMEOUT_DISPOSITION = "The command's state is UNKNOWN: the transport timed out while reading the response frame, so it may or may not have executed. Check bash_status if a task ID could have been assigned, and do not re-run side-effecting commands blindly.";
+var SUBC_FRAME_READ_TIMEOUT_DISPOSITION = "The transport timed out while reading the response frame for this call, so its outcome is UNKNOWN: it may or may not have executed. Verify actual state before re-running, and never blind-retry a mutation.";
 function isRouteClosedMidCallError(error) {
   return error instanceof SubcRouteClosedMidCallError || isLocalRouteCloseRejection(error);
 }
@@ -18647,6 +19294,8 @@ function classifyBashHostFallbackError(error) {
     return;
   if (isRouteClosedMidCallError(error))
     return;
+  if (isSubcFrameReadTimeoutError(error))
+    return;
   if (error instanceof SubcTransportShuttingDownError)
     return "transport down";
   if (isSubcRouteTornDownError(error))
@@ -18670,6 +19319,14 @@ function isTransportClassError(error) {
 function adaptToolError(command, error) {
   if (!(error instanceof Error))
     return error;
+  if (isSubcFrameReadTimeoutError(error)) {
+    const typedError = error instanceof SubcFrameReadTimeoutError ? error : new SubcFrameReadTimeoutError(error);
+    const disposition = command === "bash" ? BASH_FRAME_READ_TIMEOUT_DISPOSITION : SUBC_FRAME_READ_TIMEOUT_DISPOSITION;
+    if (typedError.message.includes(disposition))
+      return typedError;
+    typedError.message = typedError.message ? `${typedError.message} ${disposition}` : disposition;
+    return typedError;
+  }
   if (error instanceof BridgeTransportUnknownOutcomeError) {
     if (error.message.includes(BRIDGE_TRANSPORT_UNKNOWN_OUTCOME_DISPOSITION))
       return error;
@@ -18751,7 +19408,12 @@ var RETIRED_PATHS = [
   ["semantic_search", "indexes.semantic"],
   ["experimental_semantic_search", "indexes.semantic"],
   ["callgraph_store", "indexes.callgraph"],
-  ["github.enabled", "github.read,github.write,github.shim"]
+  ["github.enabled", "github.read,github.write,github.shim"],
+  ["experimental_lsp_ty", "experimental.lsp_ty"],
+  ["experimental_bash_rewrite", "bash.rewrite"],
+  ["experimental_bash_compress", "bash.compress"],
+  ["experimental_bash_background", "bash.background"],
+  ["experimental.bash", "bash"]
 ];
 var INDEX_INPUTS = [
   ["trigram", "search_index", "experimental_search_index"],
@@ -18883,10 +19545,68 @@ function translateInspectLspPaths(map, prefix, out) {
       recordRetired(out, prefix, `inspect.${leaf}`);
   }
 }
+function translateExperimentalPaths(map, prefix, out) {
+  for (const [oldKey, leaf] of [
+    ["experimental_lsp_ty", "lsp_ty"],
+    ["experimental_bash_rewrite", "rewrite"],
+    ["experimental_bash_compress", "compress"],
+    ["experimental_bash_background", "background"]
+  ]) {
+    if (!Object.hasOwn(map, oldKey))
+      continue;
+    recordRetired(out, prefix, oldKey);
+    const value = map[oldKey];
+    delete map[oldKey];
+    if (!isRecord2(map.experimental))
+      map.experimental = {};
+    const experimental = map.experimental;
+    let destination = experimental;
+    if (leaf !== "lsp_ty") {
+      if (!isRecord2(experimental.bash))
+        experimental.bash = {};
+      destination = experimental.bash;
+    }
+    if (Object.hasOwn(destination, leaf)) {
+      superseded(out, oldKey, `${oldKey} is ignored because experimental.${leaf === "lsp_ty" ? leaf : `bash.${leaf}`} is already set`);
+    } else {
+      destination[leaf] = value;
+    }
+  }
+  if (!isRecord2(map.experimental) || !Object.hasOwn(map.experimental, "bash"))
+    return;
+  const experimental = map.experimental;
+  const legacy = experimental.bash;
+  if (isRecord2(legacy)) {
+    if (!["rewrite", "compress", "background"].some((leaf) => Object.hasOwn(legacy, leaf)))
+      return;
+    for (const leaf of Object.keys(legacy))
+      recordRetired(out, prefix, `experimental.bash.${leaf}`);
+    if (Object.hasOwn(map, "bash")) {
+      superseded(out, "experimental.bash", 'experimental.bash is ignored because top-level "bash" is already set');
+    } else {
+      const bash = {
+        rewrite: legacy.rewrite === true,
+        compress: legacy.compress === true,
+        background: legacy.background === true
+      };
+      for (const leaf of ["long_running_reminder_enabled", "long_running_reminder_interval_ms"]) {
+        if (Object.hasOwn(legacy, leaf))
+          bash[leaf] = legacy[leaf];
+      }
+      map.bash = bash;
+    }
+  } else {
+    recordRetired(out, prefix, "experimental.bash");
+  }
+  delete experimental.bash;
+  if (Object.keys(experimental).length === 0)
+    delete map.experimental;
+}
 function translateBlock(map, userBase, blockLabel, out) {
   const prefix = blockLabel === "base" ? "" : `${blockLabel}.`;
   translateGithubAliases(map, prefix, out);
   translateInspectLspPaths(map, prefix, out);
+  translateExperimentalPaths(map, prefix, out);
   let explicitList;
   const rawList = map.disabled_tools;
   if (Array.isArray(rawList) && rawList.every((entry) => typeof entry === "string")) {
@@ -18899,6 +19619,8 @@ function translateBlock(map, userBase, blockLabel, out) {
     });
   }
   for (const [path] of RETIRED_PATHS) {
+    if (path === "experimental.bash")
+      continue;
     if (hasPath(map, path))
       recordRetired(out, prefix, path);
   }
@@ -19332,11 +20054,13 @@ class BridgePool {
     return alive;
   }
   getBridge(projectRoot) {
+    return this.getBridgeForCanonicalRoot(asCanonicalRootPath(normalizeKey(projectRoot)));
+  }
+  getBridgeForCanonicalRoot(key) {
     if (this.shutdownCalled) {
       this.shutdownCalled = false;
       this.startCleanupTimer();
     }
-    const key = normalizeKey(projectRoot);
     const existing = this.bridges.get(key);
     if (existing) {
       existing.lastUsed = Date.now();
@@ -19542,7 +20266,9 @@ class RevivableTransportPool {
     this.activePool = initialPool;
   }
   getBridge(projectRoot) {
-    const key = canonicalizeProjectRoot(projectRoot);
+    return this.getBridgeForCanonicalRoot(asCanonicalRootPath(canonicalizeProjectRoot(projectRoot)));
+  }
+  getBridgeForCanonicalRoot(key) {
     let transport = this.transports.get(key);
     if (!transport) {
       transport = new RevivableProjectTransport(this, key);
@@ -19577,7 +20303,7 @@ class RevivableTransportPool {
     return transport;
   }
   async toolCall(projectRoot, runtime, name, rawArgs = {}, options) {
-    return this.getBridge(projectRoot).toolCall(runtime.sessionID, name, rawArgs, options);
+    return this.toolCallForCanonicalRoot(asCanonicalRootPath(canonicalizeProjectRoot(projectRoot)), runtime.sessionID, name, rawArgs, options);
   }
   setConfigureOverride(key, value) {
     if (key === "edit_slot_survives") {
@@ -19717,14 +20443,22 @@ class RevivableTransportPool {
     return this.activePool?.getActiveBridgeForRoot(projectRoot) ?? null;
   }
   async send(projectRoot, command, params, options) {
+    return this.sendForCanonicalRoot(asCanonicalRootPath(canonicalizeProjectRoot(projectRoot)), command, params, options);
+  }
+  async sendForCanonicalRoot(projectRoot, command, params, options) {
+    this.getBridgeForCanonicalRoot(projectRoot);
     const pool = await this.ensureActivePool();
-    const bridge = pool.getBridge(projectRoot);
+    const bridge = pool.getBridgeForCanonicalRoot?.(projectRoot) ?? pool.getBridge(projectRoot);
     this.transports.get(projectRoot)?.refreshStatusSubscription(bridge);
     return bridge.send(command, params, options);
   }
   async toolCallOnProject(projectRoot, sessionId, name, rawArgs, options) {
+    return this.toolCallForCanonicalRoot(asCanonicalRootPath(canonicalizeProjectRoot(projectRoot)), sessionId, name, rawArgs, options);
+  }
+  async toolCallForCanonicalRoot(projectRoot, sessionId, name, rawArgs, options) {
+    this.getBridgeForCanonicalRoot(projectRoot);
     const pool = await this.ensureActivePool();
-    const bridge = pool.getBridge(projectRoot);
+    const bridge = pool.getBridgeForCanonicalRoot?.(projectRoot) ?? pool.getBridge(projectRoot);
     this.transports.get(projectRoot)?.refreshStatusSubscription(bridge);
     return bridge.toolCall(sessionId, name, rawArgs, options);
   }
@@ -19802,7 +20536,7 @@ function satisfyLifecycleDemand(wrapper, projectRoot) {
   const activePool = wrapper.activePool;
   if (activePool.isShutdown() || !(activePool instanceof SubcTransportPool))
     return;
-  activePool.getBridge(projectRoot);
+  activePool.getBridgeForCanonicalRoot(asCanonicalRootPath(projectRoot));
 }
 async function createAftTransportPool(opts) {
   let binaryPath = opts.binaryPath;
@@ -19837,8 +20571,8 @@ async function createAftTransportPool(opts) {
   });
   if (reapingEnabled) {
     const owner = wrapper;
-    const getBridge = owner.getBridge.bind(owner);
-    owner.getBridge = (projectRoot) => {
+    const getBridge = owner.getBridgeForCanonicalRoot.bind(owner);
+    owner.getBridgeForCanonicalRoot = (projectRoot) => {
       satisfyLifecycleDemand(owner, projectRoot);
       return getBridge(projectRoot);
     };
@@ -19864,6 +20598,7 @@ async function createConcreteAftTransportPool(opts) {
       throw new Error(missing);
     }
     return new SubcTransportPool({
+      hostScopes: opts.harness === "opencode" || opts.harness === "pi",
       connectionFile,
       harness: opts.harness,
       consumerIdentity: opts.subcConsumerIdentity,
@@ -20125,7 +20860,7 @@ import { homedir as homedir9, tmpdir as tmpdir3 } from "node:os";
 import { basename as basename2, dirname as dirname6, join as join12, resolve as resolve8 } from "node:path";
 
 // ../aft-bridge/dist/paths.js
-import { existsSync as existsSync5, readFileSync as readFileSync5, renameSync as renameSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { existsSync as existsSync5, readFileSync as readFileSync5, realpathSync as realpathSync3, renameSync as renameSync3, writeFileSync as writeFileSync2 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
 import { dirname as dirname4, isAbsolute as isAbsolute5, join as join10, resolve as resolve7 } from "node:path";
 function homeDir3() {
@@ -20160,6 +20895,23 @@ function resolveCortexKitUserConfigPath() {
 function resolveCortexKitProjectConfigPath(projectDirectory) {
   return join10(projectDirectory, ".cortexkit", "aft.jsonc");
 }
+function resolveProjectConfigReadPath(projectDirectory, operatingHarness) {
+  const canonical = resolveCortexKitProjectConfigPath(projectDirectory);
+  if (existsSync5(canonical))
+    return canonical;
+  const sources = resolveLegacyAftConfigSources(projectDirectory).project;
+  const ordered = operatingHarness ? [
+    ...sources.filter((source) => source.harness === operatingHarness),
+    ...sources.filter((source) => source.harness !== operatingHarness)
+  ] : sources;
+  return ordered.find((source) => existsSync5(source.path))?.path ?? canonical;
+}
+function legacyProjectConfigLocationNotice(projectDirectory, path) {
+  const canonical = resolveCortexKitProjectConfigPath(projectDirectory);
+  if (path === canonical)
+    return null;
+  return `Legacy project config ${path} is read in place; move it to ${canonical} yourself, and use aft doctor --fix to update retired keys.`;
+}
 function resolveCortexKitConfigPaths(projectDirectory) {
   return {
     userConfigPath: resolveCortexKitUserConfigPath(),
@@ -20167,15 +20919,27 @@ function resolveCortexKitConfigPaths(projectDirectory) {
   };
 }
 function resolveLegacyAftConfigSources(projectDirectory) {
+  const project = [
+    ...legacySources(join10(projectDirectory, ".opencode", "aft"), "OpenCode project", "opencode"),
+    ...legacySources(join10(projectDirectory, ".pi", "aft"), "Pi project", "pi")
+  ];
+  const identity = (path) => {
+    try {
+      return realpathSync3(path);
+    } catch {
+      return resolve7(path);
+    }
+  };
+  const protectedPaths = new Set([
+    resolveCortexKitProjectConfigPath(projectDirectory),
+    ...project.map((source) => source.path)
+  ].map(identity));
   return {
     user: [
       ...legacySources(join10(legacyOpenCodeConfigDir(), "aft"), "OpenCode user", "opencode"),
       ...legacySources(join10(legacyPiAgentDir(), "aft"), "Pi user", "pi")
-    ],
-    project: [
-      ...legacySources(join10(projectDirectory, ".opencode", "aft"), "OpenCode project", "opencode"),
-      ...legacySources(join10(projectDirectory, ".pi", "aft"), "Pi project", "pi")
-    ]
+    ].filter((source) => !protectedPaths.has(identity(source.path))),
+    project
   };
 }
 function resolveHarnessStoragePath(storageRoot, harness, ...segments) {
@@ -21363,7 +22127,7 @@ function isNpmAvailable(deps = defaultDeps()) {
   return resolveNpm(deps) !== null;
 }
 // ../aft-bridge/dist/onnx-probe.js
-import { closeSync as closeSync7, existsSync as existsSync8, openSync as openSync6, readSync as readSync5, realpathSync as realpathSync3 } from "node:fs";
+import { closeSync as closeSync7, existsSync as existsSync8, openSync as openSync6, readSync as readSync5, realpathSync as realpathSync4 } from "node:fs";
 var MH_MAGIC = 4277009102;
 var MH_MAGIC_64 = 4277009103;
 var FAT_MAGIC = 3405691582;
@@ -21450,7 +22214,7 @@ function isUncheckableDependency(path) {
 function probeOnnxRuntimeLoadable(libPath, arch = process.arch) {
   let fd;
   try {
-    fd = openSync6(realpathSync3(libPath), "r");
+    fd = openSync6(realpathSync4(libPath), "r");
   } catch (err) {
     return {
       loadable: false,
@@ -21489,7 +22253,7 @@ function probeOnnxRuntimeLoadable(libPath, arch = process.arch) {
 }
 // ../aft-bridge/dist/onnx-runtime.js
 import { randomBytes as randomBytes2 } from "node:crypto";
-import { chmodSync as chmodSync2, closeSync as closeSync8, copyFileSync as copyFileSync3, createWriteStream as createWriteStream2, existsSync as existsSync10, lstatSync as lstatSync2, openSync as openSync7, readdirSync as readdirSync3, readFileSync as readFileSync9, readlinkSync, realpathSync as realpathSync4, renameSync as renameSync6, rmSync as rmSync3, statSync as statSync9, symlinkSync, unlinkSync as unlinkSync4, writeFileSync as writeFileSync5 } from "node:fs";
+import { chmodSync as chmodSync2, closeSync as closeSync8, copyFileSync as copyFileSync3, createWriteStream as createWriteStream2, existsSync as existsSync10, lstatSync as lstatSync2, openSync as openSync7, readdirSync as readdirSync3, readFileSync as readFileSync9, readlinkSync, realpathSync as realpathSync5, renameSync as renameSync6, rmSync as rmSync3, statSync as statSync9, symlinkSync, unlinkSync as unlinkSync4, writeFileSync as writeFileSync5 } from "node:fs";
 import { basename as basename3, dirname as dirname9, isAbsolute as isAbsolute8, join as join16, relative as relative4, resolve as resolve10, win32 as win322 } from "node:path";
 import { Readable as Readable2 } from "node:stream";
 import { pipeline as pipeline2 } from "node:stream/promises";
@@ -21773,7 +22537,7 @@ function detectOnnxVersion(libDir, libName) {
   try {
     const entries = readdirSync3(libDir);
     try {
-      const resolved = parseOnnxVersionFromPath(realpathSync4(join16(libDir, libName)));
+      const resolved = parseOnnxVersionFromPath(realpathSync5(join16(libDir, libName)));
       if (resolved && resolved !== INVALID_ORT_VERSION)
         return resolved;
     } catch {}
@@ -21790,7 +22554,7 @@ function detectOnnxVersion(libDir, libName) {
     const base = join16(libDir, libName);
     if (existsSync10(base)) {
       try {
-        const real = realpathSync4(base);
+        const real = realpathSync5(base);
         const version = parseOnnxVersionFromPath(real) ?? parseOnnxVersionFromDirectoryPath(real);
         if (version)
           return version;
@@ -21982,7 +22746,7 @@ async function downloadFileWithCap(url, destPath) {
   }
 }
 function validateExtractedTree(stagingRoot) {
-  const realRoot = realpathSync4(stagingRoot);
+  const realRoot = realpathSync5(stagingRoot);
   let totalBytes = 0;
   const walk = (dir) => {
     const entries = readdirSync3(dir);
@@ -22131,7 +22895,7 @@ function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, c
       log(`ORT extract: failed to copy optional ${libFile}: ${copyErr}`);
     }
   }
-  const targetRoot = realpathSync4(targetDir);
+  const targetRoot = realpathSync5(targetDir);
   for (const link of symlinks) {
     const dst = join16(targetDir, link.name);
     try {
@@ -22951,7 +23715,7 @@ function formatSemanticIndexStatus(status, stage, error, backend) {
   return status;
 }
 // src/config.ts
-import { existsSync as existsSync11, readFileSync as readFileSync10, renameSync as renameSync7, statSync as statSync10, unlinkSync as unlinkSync5, writeFileSync as writeFileSync6 } from "node:fs";
+import { existsSync as existsSync11, readFileSync as readFileSync10, statSync as statSync10 } from "node:fs";
 import { homedir as homedir12 } from "node:os";
 import { isAbsolute as isAbsolute9, parse as parsePath, resolve as resolvePath } from "node:path";
 var import_comment_json = __toESM(require_src2(), 1);
@@ -28173,155 +28937,6 @@ function resolveBashConfig(config) {
   }
   return { ...base, enabled: true, rewrite: true, compress: true, background: true };
 }
-var CONFIG_MIGRATIONS = [
-  { oldKey: "experimental_lsp_ty", newPath: ["experimental", "lsp_ty"] },
-  { oldKey: "experimental_bash_rewrite", newPath: ["experimental", "bash", "rewrite"] },
-  { oldKey: "experimental_bash_compress", newPath: ["experimental", "bash", "compress"] },
-  { oldKey: "experimental_bash_background", newPath: ["experimental", "bash", "background"] }
-];
-function isWritableMigrationError(errorValue) {
-  const code = errorValue?.code;
-  return code === "EROFS" || code === "EACCES" || code === "EPERM";
-}
-function extractCommentsForPreservation(content) {
-  const comments = [];
-  const linePattern = /\/\/[^\n]*/g;
-  for (const match of content.match(linePattern) ?? []) {
-    comments.push(match.trim());
-  }
-  const blockPattern = /\/\*[\s\S]*?\*\//g;
-  for (const match of content.match(blockPattern) ?? []) {
-    comments.push(match.replace(/\s+/g, " ").trim());
-  }
-  return comments;
-}
-function ensureRecordAtPath(root, path) {
-  let current = root;
-  for (const segment of path) {
-    const existing = current[segment];
-    if (!existing || typeof existing !== "object" || Array.isArray(existing)) {
-      current[segment] = {};
-    }
-    current = current[segment];
-  }
-  return current;
-}
-function hasPath2(root, path) {
-  let current = root;
-  for (const segment of path) {
-    if (!current || typeof current !== "object" || Array.isArray(current))
-      return false;
-    const record2 = current;
-    if (!Object.hasOwn(record2, segment))
-      return false;
-    current = record2[segment];
-  }
-  return true;
-}
-function setPath(root, path, value) {
-  const parent = ensureRecordAtPath(root, path.slice(0, -1));
-  parent[path[path.length - 1]] = value;
-}
-function migrateRawConfig(rawConfig, configPath, logger) {
-  const oldKeys = [];
-  for (const migration of CONFIG_MIGRATIONS) {
-    if (!Object.hasOwn(rawConfig, migration.oldKey))
-      continue;
-    if (hasPath2(rawConfig, migration.newPath)) {
-      logger?.warn(`Config migration conflict at ${configPath}: ${migration.oldKey} ignored because ${migration.newPath.join(".")} is already set`);
-    } else {
-      setPath(rawConfig, migration.newPath, rawConfig[migration.oldKey]);
-    }
-    delete rawConfig[migration.oldKey];
-    oldKeys.push(migration.oldKey);
-  }
-  oldKeys.push(...migrateExperimentalBashBlock(rawConfig, configPath, logger));
-  return oldKeys;
-}
-function migrateExperimentalBashBlock(rawConfig, configPath, logger) {
-  const experimental = rawConfig.experimental;
-  if (typeof experimental !== "object" || experimental === null || Array.isArray(experimental)) {
-    return [];
-  }
-  const expRecord = experimental;
-  if (!Object.hasOwn(expRecord, "bash"))
-    return [];
-  const legacyBash = expRecord.bash;
-  if (typeof legacyBash !== "object" || legacyBash === null || Array.isArray(legacyBash)) {
-    delete expRecord.bash;
-    if (Object.keys(expRecord).length === 0)
-      delete rawConfig.experimental;
-    return ["experimental.bash"];
-  }
-  const bashRecord = legacyBash;
-  const hasFeatureFlag = "rewrite" in bashRecord || "compress" in bashRecord || "background" in bashRecord;
-  if (!hasFeatureFlag)
-    return [];
-  const movedKeys = Object.keys(bashRecord).map((k) => `experimental.bash.${k}`);
-  if (Object.hasOwn(rawConfig, "bash")) {
-    logger?.warn(`Config migration conflict at ${configPath}: experimental.bash dropped because top-level "bash" is already set`);
-  } else {
-    const migrated = {
-      rewrite: bashRecord.rewrite === true,
-      compress: bashRecord.compress === true,
-      background: bashRecord.background === true
-    };
-    if (bashRecord.long_running_reminder_enabled !== undefined) {
-      migrated.long_running_reminder_enabled = bashRecord.long_running_reminder_enabled;
-    }
-    if (bashRecord.long_running_reminder_interval_ms !== undefined) {
-      migrated.long_running_reminder_interval_ms = bashRecord.long_running_reminder_interval_ms;
-    }
-    rawConfig.bash = migrated;
-  }
-  delete expRecord.bash;
-  if (Object.keys(expRecord).length === 0) {
-    delete rawConfig.experimental;
-  }
-  return movedKeys;
-}
-function migrateAftConfigFile2(configPath, logger = { log: log2, warn: warn2 }) {
-  if (!existsSync11(configPath)) {
-    return { migrated: false, oldKeys: [] };
-  }
-  let tmpPath = null;
-  let oldKeys = [];
-  try {
-    const content = readFileSync10(configPath, "utf-8");
-    const rawConfig = import_comment_json.parse(content);
-    if (!rawConfig || typeof rawConfig !== "object" || Array.isArray(rawConfig)) {
-      return { migrated: false, oldKeys: [] };
-    }
-    oldKeys = migrateRawConfig(rawConfig, configPath, logger);
-    if (oldKeys.length === 0) {
-      return { migrated: false, oldKeys: [] };
-    }
-    const serialized = `${import_comment_json.stringify(rawConfig, null, 2)}
-`;
-    const originalComments = extractCommentsForPreservation(content);
-    const droppedComments = originalComments.filter((comment) => !serialized.includes(comment.trim()));
-    const nextContent = droppedComments.length > 0 ? `${droppedComments.join(`
-`)}
-${serialized}` : serialized;
-    tmpPath = `${configPath}.tmp.${process.pid}`;
-    writeFileSync6(tmpPath, nextContent, "utf-8");
-    renameSync7(tmpPath, configPath);
-    logger.log(`Migrated config at ${configPath}: removed ${oldKeys.join(", ")}`);
-    return { migrated: true, oldKeys };
-  } catch (err) {
-    if (tmpPath) {
-      try {
-        unlinkSync5(tmpPath);
-      } catch {}
-    }
-    if (isWritableMigrationError(err)) {
-      const errorMsg = err instanceof Error ? err.message : String(err);
-      logger.warn(`Config migration could not write ${configPath} (${errorMsg}); using migrated config in memory`);
-      return { migrated: oldKeys.length > 0, oldKeys };
-    }
-    return { migrated: false, oldKeys: [] };
-  }
-}
 function parseConfigPartially(rawConfig) {
   let configForParsing = rawConfig;
   if (Object.hasOwn(rawConfig, "edit_mode") && rawConfig.edit_mode !== "default" && rawConfig.edit_mode !== "hashline") {
@@ -28396,7 +29011,6 @@ function loadConfigFromPath(configPath, tier) {
     configLoadSources.push(configPath);
     configLoadTexts.set(configPath, content);
     const rawConfig = import_comment_json.parse(content);
-    migrateRawConfig(rawConfig, configPath, { log: log2, warn: warn2 });
     cleanConfig = stripJsoncSymbols(rawConfig);
   } catch (err) {
     const errorMsg = err instanceof Error ? err.message : String(err);
@@ -28756,21 +29370,14 @@ function migrateAftConfigLocations(projectDirectory, logger = { log: log2, warn:
       legacySources: legacy.user,
       operatingHarness: "opencode",
       logger
-    }),
-    migrateAftConfigFile({
-      scope: "project",
-      targetPath: paths.projectConfigPath,
-      legacySources: legacy.project,
-      operatingHarness: "opencode",
-      logger
     })
   ];
 }
 function resolveAftConfigPaths(projectDirectory) {
-  const paths = resolveCortexKitConfigPaths(projectDirectory);
-  migrateAftConfigFile2(paths.userConfigPath);
-  migrateAftConfigFile2(paths.projectConfigPath);
-  return paths;
+  return {
+    ...resolveCortexKitConfigPaths(projectDirectory),
+    projectConfigPath: resolveProjectConfigReadPath(projectDirectory, ACTIVE_HARNESS)
+  };
 }
 function resolveOpenCodeRegistrationRoot(directory, worktree) {
   if (!worktree)
@@ -28798,6 +29405,15 @@ function loadAftConfig(projectDirectory) {
   configLoadNotices = [];
   semanticInputSupplied = false;
   const { userConfigPath, projectConfigPath } = resolveAftConfigPaths(projectDirectory);
+  const locationNotice = legacyProjectConfigLocationNotice(projectDirectory, projectConfigPath);
+  if (locationNotice) {
+    log2(locationNotice);
+    configLoadNotices.push({
+      configPath: projectConfigPath,
+      digest: "legacy-project-config-location",
+      message: locationNotice
+    });
+  }
   let config = loadConfigFromPath(userConfigPath, "user") ?? {
     disabled_tools: [...DEFAULT_DISABLED_TOOLS]
   };
@@ -40726,6 +41342,24 @@ function markExplicitControl(sessionID, taskId, trackOutstanding = true) {
 function unmarkExplicitControl(sessionID, taskId) {
   stateFor(sessionID).explicitControlTasks.delete(taskId);
 }
+function holdBgCompletion(sessionID, completion, stopped = false) {
+  const state = stateFor(sessionID);
+  if (!stopped && state.consumedTaskIds.has(completion.task_id))
+    return;
+  state.heldWorkerCompletions = true;
+  state.explicitControlTasks.delete(completion.task_id);
+  state.outstandingTaskIds.delete(completion.task_id);
+  if (!state.pendingCompletions.some((pending) => pending.task_id === completion.task_id)) {
+    state.pendingCompletions.push(completion);
+  }
+}
+function hasHeldBgCompletions(sessionID) {
+  const state = stateFor(sessionID);
+  return state.heldWorkerCompletions === true && (state.pendingCompletions.length > 0 || state.pendingPatternMatches.length > 0);
+}
+function markHeldBgCompletions(sessionID) {
+  stateFor(sessionID).heldWorkerCompletions = true;
+}
 function queuePendingPatternMatch(state, entry) {
   const normalized = entry.reason ? entry : { ...entry, reason: "pattern_match" };
   const existingIdx = state.pendingPatternMatches.findIndex((match) => match.task_id === normalized.task_id);
@@ -40811,7 +41445,7 @@ async function appendInTurnBgCompletions(drainContext, output) {
     return;
   const state = stateFor(drainContext.sessionID);
   if (state.outstandingTaskIds.size === 0 && state.pendingCompletions.length === 0 && state.pendingLongRunning.length === 0 && state.pendingPatternMatches.length === 0) {
-    if (!idleDrainMayFindWork(state))
+    if (!idleDrainMayFindWork(state, drainContext))
       return;
     await drainCompletions(drainContext);
     if (state.outstandingTaskIds.size === 0 && state.pendingCompletions.length === 0 && state.pendingLongRunning.length === 0 && state.pendingPatternMatches.length === 0) {
@@ -40837,6 +41471,7 @@ async function appendInTurnBgCompletions(drainContext, output) {
     reminder_chars: reminder.length
   });
   state.pendingCompletions = [];
+  state.heldWorkerCompletions = false;
   for (const completion of deliveredCompletions) {
     state.wakeDeferredTaskIds.delete(completion.task_id);
   }
@@ -41190,7 +41825,8 @@ function observeOpenCodeBgNotificationEvent(event) {
 }
 async function triggerWakeIfPending(drainContext, skipDrain, includeDeferredCompletions = true, forceDrain = false, deferWhileBusy = false) {
   const state = stateFor(drainContext.sessionID);
-  if (!skipDrain && (forceDrain || state.outstandingTaskIds.size > 0 || !state.forcedDrainCompleted)) {
+  const hasTrackedOrPendingWork = state.outstandingTaskIds.size > 0 || state.pendingCompletions.length > 0 || state.pendingLongRunning.length > 0 || state.pendingPatternMatches.length > 0;
+  if (!skipDrain && (forceDrain || state.outstandingTaskIds.size > 0 || !state.forcedDrainCompleted) && (forceDrain || hasTrackedOrPendingWork || idleDrainMayFindWork(state, drainContext))) {
     await drainCompletions(drainContext);
   }
   routeExplicitControlCompletions(state);
@@ -41425,8 +42061,13 @@ function bridgeForDrain(drainContext) {
 function isTerminalNudgeError(error) {
   return error instanceof Error && error.code === "root_generation_expired";
 }
-function idleDrainMayFindWork(state) {
-  return !state.forcedDrainCompleted || state.untrackedCompletionSinceDrain || state.deliveredAwaitingAckTaskIds.size > 0;
+function idleDrainMayFindWork(state, drainContext) {
+  if (state.untrackedCompletionSinceDrain || state.deliveredAwaitingAckTaskIds.size > 0) {
+    return true;
+  }
+  if (state.forcedDrainCompleted)
+    return false;
+  return Boolean(drainContext.resolvedBridge ?? drainContext.ctx.pool.getActiveBridgeForRoot(drainContext.directory));
 }
 async function drainCompletions(drainContext) {
   const state = stateFor(drainContext.sessionID);
@@ -42226,7 +42867,7 @@ function resolvePathFromProjectRoot(projectRoot, target) {
 async function resolvePathArg(ctx, runtime, target) {
   return resolvePathFromProjectRoot(await resolveProjectRoot(ctx, runtime), target);
 }
-function bridgeFor(ctx, runtime) {
+function checkedProjectRoot(ctx, runtime) {
   const projectRoot = projectRootFor(runtime);
   if (ctx.isProjectEnabled?.(projectRoot) === false) {
     throw new Error(`AFT disabled by config for ${projectRoot}`);
@@ -42234,7 +42875,7 @@ function bridgeFor(ctx, runtime) {
   if (!existsSync12(projectRoot)) {
     throw new Error(`project directory no longer exists: ${projectRoot} (stale restored session?)`);
   }
-  return ctx.pool.getBridge(projectRoot);
+  return projectRoot;
 }
 async function isWorkerRuntime(ctx, runtime) {
   if (!runtime.sessionID)
@@ -42253,6 +42894,9 @@ async function callBridge(ctx, runtime, command, params = {}, options) {
   if (workerSession) {
     merged[WORKER_SESSION_FIELD] = true;
   }
+  if (ctx.hostToolNames) {
+    merged[HOST_TOOL_NAMES_FIELD] = ctx.hostToolNames;
+  }
   const timeoutMs = timeoutForCommand(command);
   const sendOptions = {
     ...timeoutMs !== undefined ? { timeoutMs } : {},
@@ -42263,7 +42907,9 @@ async function callBridge(ctx, runtime, command, params = {}, options) {
   markBridgeStart();
   let response;
   try {
-    response = await bridgeFor(ctx, runtime).send(command, merged, Object.keys(sendOptions).length > 0 ? sendOptions : undefined);
+    const root = asCanonicalRootPath(checkedProjectRoot(ctx, runtime));
+    const opts = Object.keys(sendOptions).length > 0 ? sendOptions : undefined;
+    response = ctx.pool.sendForCanonicalRoot ? await ctx.pool.sendForCanonicalRoot(root, command, merged, opts) : await ctx.pool.getBridge(root).send(command, merged, opts);
   } catch (error) {
     if (command === "bash" && isBashTransportDeadError(error))
       throw error;
@@ -42285,12 +42931,15 @@ async function callToolCall(ctx, runtime, name, rawArgs = {}, options) {
     configureWarningClient: ctx.client,
     ...runtime.effectAbort ? { abortSignal: runtime.effectAbort } : {},
     ...workerSession ? { workerSession: true } : {},
+    ...ctx.hostToolNames ? { hostToolNames: ctx.hostToolNames } : {},
     ...options
   };
   markBridgeStart();
   let response;
   try {
-    response = await bridgeFor(ctx, runtime).toolCall(runtime.sessionID, name, rawArgs, Object.keys(sendOptions).length > 0 ? sendOptions : undefined);
+    const root = asCanonicalRootPath(checkedProjectRoot(ctx, runtime));
+    const opts = Object.keys(sendOptions).length > 0 ? sendOptions : undefined;
+    response = ctx.pool.toolCallForCanonicalRoot ? await ctx.pool.toolCallForCanonicalRoot(root, runtime.sessionID, name, rawArgs, opts) : await ctx.pool.getBridge(root).toolCall(runtime.sessionID, name, rawArgs, opts);
   } catch (error) {
     throw adaptToolError(name, error);
   } finally {
@@ -42398,7 +43047,7 @@ async function signalBashWaitDetachForProject(pool, projectRoot, sessionID) {
 }
 
 // src/lsp-auto-install.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync6, renameSync as renameSync9, rmSync as rmSync5, statSync as statSync12, writeFileSync as writeFileSync8 } from "node:fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync6, renameSync as renameSync8, rmSync as rmSync5, statSync as statSync12, writeFileSync as writeFileSync7 } from "node:fs";
 import { join as join19 } from "node:path";
 
 // src/lsp-cache.ts
@@ -42408,11 +43057,11 @@ import {
   mkdirSync as mkdirSync5,
   openSync as openSync8,
   readFileSync as readFileSync11,
-  renameSync as renameSync8,
+  renameSync as renameSync7,
   rmSync as rmSync4,
   statSync as statSync11,
-  unlinkSync as unlinkSync6,
-  writeFileSync as writeFileSync7
+  unlinkSync as unlinkSync5,
+  writeFileSync as writeFileSync6
 } from "node:fs";
 import { join as join17 } from "node:path";
 function aftCacheBase() {
@@ -42453,7 +43102,7 @@ function writeInstalledMetaIn(installDir, version, sha256) {
       installedAt: new Date().toISOString(),
       ...sha256 ? { sha256 } : {}
     };
-    writeFileSync7(join17(installDir, INSTALLED_META_FILE), JSON.stringify(meta), "utf8");
+    writeFileSync6(join17(installDir, INSTALLED_META_FILE), JSON.stringify(meta), "utf8");
   } catch (err) {
     log2(`[lsp-cache] failed to write installed-meta in ${installDir}: ${err}`);
   }
@@ -42494,7 +43143,7 @@ function acquireInstallLock(lockKey) {
     try {
       const fd = openSync8(lock, "wx");
       try {
-        writeFileSync7(fd, `${process.pid}
+        writeFileSync6(fd, `${process.pid}
 ${new Date().toISOString()}
 ${token}
 `);
@@ -42550,7 +43199,7 @@ ${token}
   }
   log2(`[lsp] reclaiming install lock for ${lockKey} (owner_pid=${owningPid ?? "unknown"}, alive=${ownerAlive}, age_ms=${age})`);
   try {
-    unlinkSync6(lock);
+    unlinkSync5(lock);
   } catch {}
   return tryClaim();
 }
@@ -42589,7 +43238,7 @@ function releaseInstallLock(lockKey, acquisitionToken) {
       return;
     }
     try {
-      unlinkSync6(lock);
+      unlinkSync5(lock);
     } catch (unlinkErr) {
       const code = unlinkErr.code;
       if (code !== "ENOENT") {
@@ -42664,7 +43313,7 @@ function claimLspAutoInstallPass() {
     try {
       const fd = openSync8(lock, "wx");
       try {
-        writeFileSync7(fd, JSON.stringify(owner));
+        writeFileSync6(fd, JSON.stringify(owner));
       } finally {
         closeSync9(fd);
       }
@@ -42695,12 +43344,12 @@ function claimLspAutoInstallPass() {
       return null;
     }
     const tempPath = `${stampPath}.tmp-${process.pid}-${owner.token}`;
-    writeFileSync7(tempPath, `${JSON.stringify({ lastRunMs: Date.now() })}
+    writeFileSync6(tempPath, `${JSON.stringify({ lastRunMs: Date.now() })}
 `, {
       encoding: "utf8",
       mode: 384
     });
-    renameSync8(tempPath, stampPath);
+    renameSync7(tempPath, stampPath);
     return { release };
   } catch (err) {
     if (claimed) {
@@ -42737,7 +43386,7 @@ function writeVersionCheck(npmPackage, latest) {
     last_checked: new Date().toISOString(),
     latest_eligible: latest
   };
-  writeFileSync7(file, JSON.stringify(record, null, 2));
+  writeFileSync6(file, JSON.stringify(record, null, 2));
 }
 function shouldRecheckVersion(record, weeklyCheckIntervalMs = 7 * 24 * 60 * 60 * 1000) {
   if (!record)
@@ -43118,7 +43767,7 @@ function ensureInstallAnchor(cwd) {
   try {
     const stub = join19(cwd, "package.json");
     if (!existsSync14(stub)) {
-      writeFileSync8(stub, `${JSON.stringify({ name: "aft-lsp-cache", version: "0.0.0", private: true })}
+      writeFileSync7(stub, `${JSON.stringify({ name: "aft-lsp-cache", version: "0.0.0", private: true })}
 `);
     }
   } catch (err) {
@@ -43331,7 +43980,7 @@ function quarantineCachedNpmInstall(spec, reason) {
   try {
     mkdirSync6(join19(dest, ".."), { recursive: true });
     rmSync5(dest, { recursive: true, force: true });
-    renameSync9(packageDir, dest);
+    renameSync8(packageDir, dest);
   } catch (err) {
     warn2(`[lsp] tofu_mismatch ${spec.npm}: failed to quarantine cache entry: ${err}`);
   }
@@ -43435,12 +44084,12 @@ import {
   readFileSync as readFileSync13,
   readlinkSync as readlinkSync2,
   readSync as readSync6,
-  realpathSync as realpathSync5,
-  renameSync as renameSync10,
+  realpathSync as realpathSync6,
+  renameSync as renameSync9,
   rmSync as rmSync6,
   statSync as statSync13,
-  unlinkSync as unlinkSync7,
-  writeFileSync as writeFileSync9
+  unlinkSync as unlinkSync6,
+  writeFileSync as writeFileSync8
 } from "node:fs";
 import { dirname as dirname10, join as join20, relative as relative5, resolve as resolve12 } from "node:path";
 import { Readable as Readable3 } from "node:stream";
@@ -43566,9 +44215,9 @@ function writeInstallFailureMarker(spec, release, sha256, installError) {
   const tempPath = `${path}.tmp-${process.pid}-${randomBytes4(6).toString("hex")}`;
   try {
     mkdirSync7(dirname10(path), { recursive: true });
-    writeFileSync9(tempPath, `${JSON.stringify({ release, sha256, error: markerError, at: new Date().toISOString() })}
+    writeFileSync8(tempPath, `${JSON.stringify({ release, sha256, error: markerError, at: new Date().toISOString() })}
 `, { encoding: "utf8", mode: 384 });
-    renameSync10(tempPath, path);
+    renameSync9(tempPath, path);
   } catch (err) {
     try {
       rmSync6(tempPath, { force: true });
@@ -43634,7 +44283,7 @@ function writeGithubInstalledMetaIn(installDir, version, binarySha256, archiveSh
       binarySha256,
       ...archiveSha256 ? { archiveSha256 } : {}
     };
-    writeFileSync9(join20(installDir, INSTALLED_META_FILE2), JSON.stringify(meta), "utf8");
+    writeFileSync8(join20(installDir, INSTALLED_META_FILE2), JSON.stringify(meta), "utf8");
   } catch (err) {
     warn2(`[lsp] failed to write github installed metadata in ${installDir}: ${err}`);
   }
@@ -43874,7 +44523,7 @@ async function downloadFile(url, destPath, fetchImpl, assetSize, signal) {
     await pipeline3(nodeStream, createWriteStream3(destPath), { signal: timeout.signal });
   } catch (err) {
     try {
-      unlinkSync7(destPath);
+      unlinkSync6(destPath);
     } catch {}
     throw err;
   } finally {
@@ -43903,7 +44552,7 @@ async function fetchFollowingRedirects(url, fetchImpl, signal) {
   throw new Error(`too many redirects (>${maxRedirects})`);
 }
 function validateExtraction(stagingRoot) {
-  const realStagingRoot = realpathSync5(stagingRoot);
+  const realStagingRoot = realpathSync6(stagingRoot);
   let totalBytes = 0;
   const walk = (dir) => {
     let entries;
@@ -43929,7 +44578,7 @@ function validateExtraction(stagingRoot) {
       }
       let realFull;
       try {
-        realFull = realpathSync5(full);
+        realFull = realpathSync6(full);
       } catch (err) {
         throw new Error(`failed to realpath ${full}: ${err}`);
       }
@@ -43957,14 +44606,30 @@ function assertArchiveEntryPath(entry) {
     throw new Error(`archive entry escapes archive root: ${entry}`);
   }
 }
+var ARCHIVE_LIST_TIMEOUT_MS = 30000;
 function runArchiveTool(command, args, timeout) {
   return new Promise((resolvePromise, reject) => {
-    execFile(command, args, { encoding: "utf8", ...timeout !== undefined ? { timeout } : {} }, (err, stdout) => {
-      if (err)
-        reject(err);
-      else
-        resolvePromise(stdout);
-    });
+    let child;
+    const deadline = setTimeout(() => {
+      reject(new Error(`${command} ${args[0]} timed out after ${timeout} ms`));
+      child?.kill("SIGKILL");
+      child?.stdin?.destroy();
+      child?.stdout?.destroy();
+      child?.stderr?.destroy();
+    }, timeout);
+    try {
+      child = execFile(command, args, { encoding: "utf8", timeout, killSignal: "SIGKILL" }, (err, stdout) => {
+        clearTimeout(deadline);
+        if (err)
+          reject(err);
+        else
+          resolvePromise(stdout);
+      });
+      child.stdin?.end();
+    } catch (error) {
+      clearTimeout(deadline);
+      reject(error);
+    }
   });
 }
 async function runTarExtraction(args, timeout) {
@@ -43978,7 +44643,7 @@ async function runTarExtraction(args, timeout) {
 }
 async function precheckWithTar(archivePath, command) {
   let totalBytes = 0;
-  const verbose = await runArchiveTool(command, ["-tvf", archivePath]);
+  const verbose = await runArchiveTool(command, ["-tvf", archivePath], ARCHIVE_LIST_TIMEOUT_MS);
   for (const line of verbose.split(`
 `)) {
     if (line.startsWith("h")) {
@@ -43991,7 +44656,7 @@ async function precheckWithTar(archivePath, command) {
         totalBytes += Math.max(...numeric);
     }
   }
-  const names = await runArchiveTool(command, ["-tf", archivePath]);
+  const names = await runArchiveTool(command, ["-tf", archivePath], ARCHIVE_LIST_TIMEOUT_MS);
   for (const entry of names.split(`
 `)) {
     if (entry.length > 0)
@@ -44002,11 +44667,11 @@ async function precheckWithTar(archivePath, command) {
 async function precheckArchiveContents(archivePath, archiveType, zipListingMode = "platform") {
   let totalBytes = 0;
   if (archiveType === "zip" && zipListingMode === "platform" && process.platform !== "win32") {
-    const out = await runArchiveTool("unzip", ["-l", archivePath]);
+    const out = await runArchiveTool("unzip", ["-l", archivePath], ARCHIVE_LIST_TIMEOUT_MS);
     const match = out.match(/^\s*(\d+)\s+\d+\s+files?\s*$/m);
     if (match)
       totalBytes = Number.parseInt(match[1] ?? "0", 10);
-    const names = await runArchiveTool("unzip", ["-Z1", archivePath]);
+    const names = await runArchiveTool("unzip", ["-Z1", archivePath], ARCHIVE_LIST_TIMEOUT_MS);
     for (const entry of names.split(`
 `)) {
       if (entry.length > 0)
@@ -44033,7 +44698,7 @@ async function extractArchiveSafely(archivePath, destDir, archiveType) {
     try {
       rmSync6(destDir, { recursive: true, force: true });
     } catch {}
-    renameSync10(stagingDir, destDir);
+    renameSync9(stagingDir, destDir);
   } catch (err) {
     try {
       rmSync6(stagingDir, { recursive: true, force: true });
@@ -44048,7 +44713,7 @@ function quarantineCachedGithubInstall(spec, reason) {
   try {
     mkdirSync7(dirname10(dest), { recursive: true });
     rmSync6(dest, { recursive: true, force: true });
-    renameSync10(packageDir, dest);
+    renameSync9(packageDir, dest);
   } catch (err) {
     warn2(`[lsp] tofu_mismatch ${spec.id}: failed to quarantine cache entry: ${err}`);
   }
@@ -44140,7 +44805,7 @@ async function downloadAndInstall(spec, tag, assets, platform, arch, fetchImpl,
     const message = `hash failed: ${err instanceof Error ? err.message : String(err)}`;
     error2(`[lsp] hash ${spec.id} failed: ${err}`);
     try {
-      unlinkSync7(archivePath);
+      unlinkSync6(archivePath);
     } catch {}
     return { ok: false, sha256: "", error: message };
   }
@@ -44151,7 +44816,7 @@ async function downloadAndInstall(spec, tag, assets, platform, arch, fetchImpl,
     const message = `TOFU sha256 mismatch: previously installed archive sha256=${previousArchiveSha256}, ` + `downloaded sha256=${archiveSha256}`;
     error2(`[lsp] ${spec.id} ${tag}: ${message}. ` + `This means the published release for tag ${tag} changed. Investigate before proceeding. ` + `Run \`npx @cortexkit/aft doctor --clear\` to wipe the cache and force a fresh install if you've verified the change.`);
     try {
-      unlinkSync7(archivePath);
+      unlinkSync6(archivePath);
     } catch {}
     return { ok: false, sha256: archiveSha256, error: message };
   }
@@ -44163,7 +44828,7 @@ async function downloadAndInstall(spec, tag, assets, platform, arch, fetchImpl,
     return { ok: false, sha256: archiveSha256, error: message };
   } finally {
     try {
-      unlinkSync7(archivePath);
+      unlinkSync6(archivePath);
     } catch {}
   }
   const innerBinaryPath = join20(extractDir, spec.binaryPathInArchive(platform, arch, version));
@@ -45060,6 +45725,190 @@ function astTools(ctx) {
   };
 }
 
+// src/v2-session-lifecycle.ts
+import { Effect as Effect4, Stream } from "effect";
+function noteV2ToolAbort(client, sessionID) {
+  const state = stateFor2(client, sessionID);
+  if (!state || state.settling)
+    return;
+  let resolve = () => {};
+  const promise = new Promise((done) => {
+    resolve = done;
+  });
+  state.settling = { promise, resolve };
+}
+async function awaitV2ExecutionSettlement(client, sessionID) {
+  await stateFor2(client, sessionID)?.settling?.promise;
+}
+var locations = new WeakMap;
+function stateFor2(client, sessionID) {
+  if (!client || typeof client !== "object")
+    return;
+  const sessions = locations.get(client);
+  if (!sessions)
+    return;
+  let state = sessions.get(sessionID);
+  if (!state) {
+    state = {
+      stopped: false,
+      stopEpoch: 0,
+      tasks: new Map,
+      wakes: new Set,
+      watches: new Map
+    };
+    sessions.set(sessionID, state);
+  }
+  return state;
+}
+function v2SubagentStopped(client, sessionID) {
+  return stateFor2(client, sessionID)?.stopped === true;
+}
+function v2StopEpoch(client, sessionID) {
+  return stateFor2(client, sessionID)?.stopEpoch ?? 0;
+}
+async function killBackgroundTask(ctx, runtime, taskId) {
+  const result = await callBashBridge(ctx, runtime, "bash_kill", { task_id: taskId }, { abortSignal: undefined });
+  if (result.success === false)
+    throw new Error(String(result.message ?? "bash_kill failed"));
+  markHeldBgCompletions(runtime.sessionID);
+}
+async function trackV2BackgroundTask(ctx, runtime, taskId, startedEpoch) {
+  const state = stateFor2(ctx.client, runtime.sessionID);
+  if (!state)
+    return;
+  const kill = () => killBackgroundTask(ctx, runtime, taskId);
+  if (state.stopped || state.stopEpoch !== startedEpoch) {
+    await kill();
+    return;
+  }
+  state.tasks.set(taskId, kill);
+}
+async function killStoppedBackgroundTasks(client, sessionID, ctx, startedBeforeMs) {
+  const kills = [];
+  const visited = new Set;
+  const dispatch = (taskId, kill) => {
+    if (visited.has(taskId))
+      return;
+    visited.add(taskId);
+    kills.push(kill().catch((error) => {
+      warn2(`[bash] failed to kill stopped session ${sessionID}'s task ${taskId}: ${String(error)}`);
+    }));
+  };
+  for (const [owner, state] of locations.get(client) ?? []) {
+    if (owner !== sessionID)
+      continue;
+    const tasks = [...state.tasks];
+    state.tasks.clear();
+    for (const [taskId, kill] of tasks) {
+      dispatch(taskId, kill);
+    }
+  }
+  if (ctx) {
+    const runtime = {
+      sessionID,
+      directory: client.location.directory,
+      directoryIsSessionRoot: true
+    };
+    try {
+      const result = await callBashBridge(ctx, runtime, "bash_owned_tasks", { started_before_ms: startedBeforeMs }, { abortSignal: undefined });
+      if (result.success === false)
+        throw new Error(String(result.message ?? "bash_owned_tasks failed"));
+      for (const taskId of Array.isArray(result.task_ids) ? result.task_ids : []) {
+        if (typeof taskId === "string")
+          dispatch(taskId, () => killBackgroundTask(ctx, runtime, taskId));
+      }
+    } catch (error) {
+      warn2(`[bash] failed to enumerate stopped session ${sessionID}'s tasks: ${String(error)}`);
+    }
+  }
+  await Promise.all(kills);
+}
+function allowV2WatchWake(client, sessionID, taskId) {
+  const state = stateFor2(client, sessionID);
+  if (state && !state.stopped)
+    state.wakes.add(taskId);
+}
+function v2WatchWakeAllowed(client, sessionID, taskId) {
+  const state = stateFor2(client, sessionID);
+  return state !== undefined && !state.stopped && state.wakes.has(taskId);
+}
+function forgetV2Watch(client, sessionID, taskId) {
+  const state = stateFor2(client, sessionID);
+  if (!state)
+    return;
+  state.wakes.delete(taskId);
+  state.tasks.delete(taskId);
+  for (const [watchId, watch] of state.watches) {
+    if (watch.taskId === taskId)
+      state.watches.delete(watchId);
+  }
+}
+async function trackV2Watch(ctx, runtime, taskId, watchId) {
+  const state = stateFor2(ctx.client, runtime.sessionID);
+  if (!state || typeof watchId !== "string")
+    return;
+  const cancel = () => callBashBridge(ctx, runtime, "bash_unnotify", { task_id: taskId, watch_id: watchId }, { abortSignal: undefined });
+  if (state.stopped) {
+    await cancel();
+    return;
+  }
+  state.wakes.add(taskId);
+  state.watches.set(watchId, { taskId, cancel });
+}
+function registerV2SessionLifecycle(context, ctx) {
+  const host = context;
+  return Effect4.gen(function* () {
+    if (!host.event?.subscribe || !context || typeof context !== "object")
+      return;
+    const sessions = new Map;
+    locations.set(context, sessions);
+    yield* Effect4.addFinalizer(() => Effect4.sync(() => {
+      for (const state of sessions.values())
+        state.settling?.resolve();
+      locations.delete(context);
+    }));
+    const pull = yield* Stream.toPull(host.event.subscribe());
+    yield* Effect4.forkScoped(Effect4.forever(pull.pipe(Effect4.flatMap((events) => Effect4.forEach(events, (event) => Effect4.promise(async () => {
+      const sessionID = event.data.sessionID;
+      if (!sessionID)
+        return;
+      const state = stateFor2(context, sessionID);
+      if (!state)
+        return;
+      if (event.type === "session.execution.started") {
+        state.stopped = false;
+        return;
+      }
+      const deliberateStop = event.type === "session.execution.interrupted" && (event.data.reason === "user" || event.data.reason === "inactivity");
+      if (!deliberateStop) {
+        if (event.type === "session.execution.failed" || event.type === "session.execution.succeeded" || event.type === "session.execution.interrupted") {
+          state.settling?.resolve();
+          state.settling = undefined;
+        }
+        return;
+      }
+      if (!await resolveIsSubagent(context, sessionID)) {
+        state.settling?.resolve();
+        state.settling = undefined;
+        return;
+      }
+      state.stopped = true;
+      state.stopEpoch += 1;
+      state.wakes.clear();
+      state.settling?.resolve();
+      state.settling = undefined;
+      const watches = [...state.watches.values()];
+      state.watches.clear();
+      Promise.all([
+        killStoppedBackgroundTasks(context, sessionID, ctx, event.created),
+        ...watches.map((watch) => watch.cancel().catch((error) => {
+          warn2(`[bash_watch] failed to cancel stopped session ${sessionID}'s watch on ${watch.taskId}: ${String(error)}`);
+        }))
+      ]);
+    }), { discard: true })))), { startImmediately: true });
+  });
+}
+
 // src/tools/bash.ts
 var z3 = tool.schema;
 var METADATA_PREVIEW_LIMIT = 30 * 1024;
@@ -45195,7 +46044,7 @@ function bashToolDescription(aftSearchRegistered, compressionOn, backgroundOn, d
   ].join(", ");
   const searchSteer = `use ${steerTools}${zoomEnabled ? ", or aft_zoom" : ""} instead`;
   const compression = compressionOn ? " Output is compressed by default; pass compressed: false for raw output. Piped commands run verbatim and show the pipeline's output; for AFT's test/build summary, run the runner without | head, | tail, or | grep. Pipeline-failure notes cover single top-level pipelines only; multi-statement commands (`a; b | c; d`) are not instrumented, so masked failures inside them still need explicit exit-code checks." : "";
-  const tasks = backgroundOn ? ` Commands run in the foreground and return inline; wait: true blocks until a long command finishes instead of auto-promoting (in a delegated session it blocks up to the worker wait limit, bash.worker_wait_max_ms, 30 minutes by default, then reports the command is still running; watch again to keep waiting); ${userMessageDetachDescription(detachOnUserMessage)} Use it when you need the result before doing anything else; ${autoPromote}. Use background: true yourself ONLY when you have other useful work to do while it runs; ${backgroundWaitDescription(watchToolRegistered, status, role)} A \`nohup … &\` launch still holds the call if the child keeps stdout/stderr; redirect both or use background:true. pty: true runs interactive programs (REPLs, TUIs), implies background${ptyDriveClause(status, write)}.` : " Commands run in the foreground to completion; timeout is the hard kill cap (default 30 minutes).";
+  const tasks = backgroundOn ? ` Commands run in the foreground and return inline; wait: true blocks until a long command finishes instead of auto-promoting (it blocks up to bash.worker_wait_max_ms, 30 minutes by default, then reports the command is still running; watch again to keep waiting); ${userMessageDetachDescription(detachOnUserMessage)} Use it when you need the result before doing anything else; ${autoPromote}. Use background: true yourself ONLY when you have other useful work to do while it runs; ${backgroundWaitDescription(watchToolRegistered, status, role)} A \`nohup … &\` launch still holds the call if the child keeps stdout/stderr; redirect both or use background:true. pty: true runs interactive programs (REPLs, TUIs), implies background${ptyDriveClause(status, write)}.` : " Commands run in the foreground to completion; timeout is the hard kill cap (default 30 minutes).";
   const outputRules = backgroundOn ? " Finished output expires after the task is 24 hours old and its completion has been delivered; under project-root restrictions, only the starting session can read output outside the project—copy cited lines into your report." : "";
   const timeoutRules = " `timeout` starts after spawn and kills the Unix process group (exit 124; Windows uses taskkill /T /F); processes that leave the group survive.";
   const remoteRuns = surface.remoteRuns ? ` ${BASH_RUNON_GUIDANCE}` : "";
@@ -45293,7 +46142,7 @@ function bashTimeoutDescription(backgroundOn, role = "primary") {
   if (!backgroundOn) {
     return "Hard kill cap in milliseconds (positive integer). When omitted, the foreground command can run up to 30 minutes and returns inline when it finishes.";
   }
-  const promoted = role === "worker" ? "moves to the background as a task that won't wake you, so wait on it with bash_watch; wait:true disables promotion and remains inline until completion, the timeout, or the worker wait limit" : "is promoted to background and gets a completion reminder when it exits; wait:true disables promotion and remains inline until completion or timeout";
+  const promoted = role === "worker" ? "moves to the background as a task that won't wake you, so wait on it with bash_watch; wait:true disables promotion and remains inline until completion, the timeout, or the worker wait limit" : "is promoted to background and gets a completion reminder when it exits; wait:true disables promotion and remains inline until completion, timeout, or bash.worker_wait_max_ms";
   return `Hard kill cap in milliseconds (positive integer). In the default foreground mode when wait is false, a command that exceeds the configured wait window ${promoted}. A background task with no timeout is killed after 30 minutes; pass a longer timeout for long jobs.`;
 }
 function createBashTool(ctx, aftSearchRegisteredOverride) {
@@ -45305,7 +46154,7 @@ function createBashTool(ctx, aftSearchRegisteredOverride) {
     ...bashCompanionRegistered(ctx.config, "bash_kill") ? ["bash_kill"] : []
   ];
   const waitArg = initialBashCfg.background ? {
-    wait: z3.boolean().optional().describe(`When true, run in the foreground without auto-promoting and wait until the command finishes or reaches its timeout (in a delegated session at most the worker wait limit, 30 minutes by default; the command then keeps running in the background and the reply says how to keep waiting); ${userMessageDetachDescription(initialBashCfg.detach_on_user_message)} Use only when you know the result is required before doing anything else.`)
+    wait: z3.boolean().optional().describe(`When true, run in the foreground without auto-promoting and wait until the command finishes or reaches its timeout (at most bash.worker_wait_max_ms, 30 minutes by default; the command then keeps running in the background and the reply says how to keep waiting); ${userMessageDetachDescription(initialBashCfg.detach_on_user_message)} Use only when you know the result is required before doing anything else.`)
   } : {};
   const sandboxArg = nativeSandboxEnabled(ctx.config) ? {
     sandbox: z3.literal("host").optional().describe("Request one-command approval to run unsandboxed on the host; use only when native sandboxing blocks required work, and note that it is a no-op when sandboxing is disabled.")
@@ -45360,6 +46209,7 @@ ${BASH_RUNON_GUIDANCE}`, "");
     },
     execute: async (args, context) => {
       const bashCfg = resolveBashConfig(ctx.config);
+      const startedEpoch = v2StopEpoch(ctx.client, context.sessionID);
       const ctxAftSearchRegistered = ctx.aftSearchRegistered === true;
       const aftSearchRegistered = aftSearchRegisteredOverride ?? ctxAftSearchRegistered;
       let accumulatedOutput = "";
@@ -45389,7 +46239,7 @@ ${BASH_RUNON_GUIDANCE}`, "");
       const blockToCompletion = subagentForcedForeground || backgroundDisabled || requestedWait;
       const effectiveBackground = blockToCompletion ? false : requestedBackground;
       const rawTimeout = coerceOptionalInt(args.timeout, "timeout", 1, Number.MAX_SAFE_INTEGER);
-      const workerWaitMaxMs = isSubagent ? bashCfg.worker_wait_max_ms : undefined;
+      const workerWaitMaxMs = bashCfg.worker_wait_max_ms;
       const ptyRows = coerceOptionalInt(args.ptyRows, "ptyRows", 1, 60);
       const ptyCols = coerceOptionalInt(args.ptyCols, "ptyCols", 1, 140);
       const compressed = coerceBoolean(args.compressed, true);
@@ -45473,6 +46323,7 @@ ${BASH_RUNON_GUIDANCE}`, "");
       if (data.status === "running" && typeof data.task_id === "string") {
         const taskId = data.task_id;
         trackBgTask(context.sessionID, taskId);
+        await trackV2BackgroundTask(ctx, context, taskId, startedEpoch);
         let rendered = data.output ?? "";
         if (isSubagent) {
           rendered += workerBackgroundTaskNote(taskId);
@@ -45545,7 +46396,10 @@ async function formatBashStatusText(runtime, taskId, data, requestedOutputMode,
   if (typeof data.live_descendants_summary === "string") {
     text += ` · ${data.live_descendants_summary}`;
   }
-  if (data.output_incomplete === true) {
+  if (typeof data.remote_phase_note === "string") {
+    text += ` · ${data.remote_phase_note}`;
+  }
+  if (data.output_incomplete === true || status === "failed" && data.status_reason) {
     const reason = typeof data.status_reason === "string" && data.status_reason ? data.status_reason : "PTY output may be incomplete";
     text += `
 [${reason}]`;
@@ -45642,7 +46496,25 @@ function conflictTools(ctx) {
 }
 
 // src/tools/definitions/v2.ts
-import { Effect as Effect4 } from "effect";
+import { Effect as Effect5 } from "effect";
+
+// src/v2-host-tool-names.ts
+var V2_HOST_TOOL_NAMES = Object.freeze({
+  bash: "shell",
+  apply_patch: "patch"
+});
+var AFT_TOOL_FOR_V2_HOST = Object.freeze(Object.fromEntries(Object.entries(V2_HOST_TOOL_NAMES).map(([aft, host]) => [host, aft])));
+function v2HostToolName(aftName) {
+  return V2_HOST_TOOL_NAMES[aftName] ?? aftName;
+}
+function aftToolNameForV2Host(hostName) {
+  return AFT_TOOL_FOR_V2_HOST[hostName] ?? hostName;
+}
+function renameV2ToolReferences(text) {
+  return text.replace(/(?<![\w./-])bash(?![\w-]|\.\w|\s+(?:itself|REPLs|syntax)\b)/g, "shell").replace(/(?<![\w./-])apply_patch(?![\w-]|\.\w)/g, "patch");
+}
+
+// src/tools/definitions/v2.ts
 var V2_TOOL_NAME = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/;
 var V2_PATH_HEADER_TOOLS = new Set(["read", "write", "edit"]);
 var V2_BASH_TOOLS = new Set(["bash"]);
@@ -45727,12 +46599,23 @@ function bareToolName3(name) {
   return name.startsWith("aft_") ? name.slice(4) : name;
 }
 function projectArguments(name, definition) {
-  if (!V2_PATH_HEADER_TOOLS.has(bareToolName3(name)) || !("filePath" in definition.args)) {
-    return { ...definition.args };
+  const args = renameArgumentDescriptions(definition.args);
+  if (!V2_PATH_HEADER_TOOLS.has(bareToolName3(name)) || !("filePath" in args)) {
+    return args;
   }
-  const { filePath, ...rest } = definition.args;
+  const { filePath, ...rest } = args;
   return { path: filePath, ...rest };
 }
+function renameArgumentDescriptions(args) {
+  const renamed = {};
+  for (const [key, schema] of Object.entries(args)) {
+    const described = schema;
+    const description = described.description;
+    const next = description === undefined ? undefined : renameV2ToolReferences(description);
+    renamed[key] = next === undefined || next === description ? schema : described.describe(next);
+  }
+  return renamed;
+}
 function executionArguments(name, input) {
   if (!V2_PATH_HEADER_TOOLS.has(bareToolName3(name)) || !("path" in input))
     return input;
@@ -45791,7 +46674,7 @@ function runtimeFor(name, location, context, signal, consumers) {
     abort: signal,
     effectAbort: signal,
     metadata: (update) => {
-      Effect4.runPromise(context.progress(jsonSafeMetadata({
+      Effect5.runPromise(context.progress(jsonSafeMetadata({
         ...update.metadata ?? {},
         ...update.title ? { title: update.title } : {}
       })));
@@ -45806,36 +46689,46 @@ function runtimeFor(name, location, context, signal, consumers) {
   };
 }
 function projectV2Tool(name, definition, location, consumers = {}) {
+  const hostName = v2HostToolName(name);
   const input = tool.schema.object(projectArguments(name, definition));
-  assertV2Contract(name, input);
+  assertV2Contract(hostName, input);
   const sharedOptions = definition.options;
   const permission = hostPermission(name);
   return {
-    name,
-    description: definition.description,
+    name: hostName,
+    description: renameV2ToolReferences(definition.description),
     input,
     options: {
       ...sharedOptions,
       ...permission ? { permission } : {},
       codemode: false
     },
-    execute: (rawInput, context) => Effect4.tryPromise({
+    execute: (rawInput, context) => Effect5.tryPromise({
       try: async (signal) => {
-        if (name === "bash_status" || name === "bash_watch") {
-          consumers.registerSession?.(context.sessionID);
+        const onAbort = () => {
+          if (context.sessionID)
+            consumers.onToolAbort?.(context.sessionID);
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        try {
+          if (name === "bash_status" || name === "bash_watch") {
+            consumers.registerSession?.(context.sessionID);
+          }
+          const runtime = runtimeFor(name, location, context, signal, consumers);
+          const input = executionArguments(name, rawInput);
+          const result = consumers.executeBash && V2_BASH_TOOLS.has(name) ? await consumers.executeBash({
+            name,
+            input,
+            context: runtime,
+            definition
+          }) : await definition.execute(input, runtime);
+          const refusal = failureEnvelopeMessage(result);
+          if (refusal)
+            throw new Error(refusal);
+          return resultContent(result);
+        } finally {
+          signal.removeEventListener("abort", onAbort);
         }
-        const runtime = runtimeFor(name, location, context, signal, consumers);
-        const input = executionArguments(name, rawInput);
-        const result = consumers.executeBash && V2_BASH_TOOLS.has(name) ? await consumers.executeBash({
-          name,
-          input,
-          context: runtime,
-          definition
-        }) : await definition.execute(input, runtime);
-        const refusal = failureEnvelopeMessage(result);
-        if (refusal)
-          throw new Error(refusal);
-        return resultContent(result);
       },
       catch: failure
     })
@@ -45864,10 +46757,10 @@ function joinList(items) {
 }
 
 // src/shared/read-vision.ts
-import { Effect as Effect5 } from "effect";
+import { Effect as Effect6 } from "effect";
 var VISION_HOST_TIMEOUT_MS = 1500;
 var states = new WeakMap;
-function stateFor2(client) {
+function stateFor3(client) {
   let state = states.get(client);
   if (!state) {
     state = { models: new Map, history: new Map, capabilities: new Map };
@@ -45876,7 +46769,7 @@ function stateFor2(client) {
   return state;
 }
 function rememberReadModel(client, sessionID, model) {
-  stateFor2(client).models.set(sessionID, model);
+  stateFor3(client).models.set(sessionID, model);
 }
 async function bounded(call) {
   let timer;
@@ -45899,7 +46792,7 @@ function record3(value) {
 async function currentSessionVisionCapability(client, sessionID) {
   if (!sessionID)
     return;
-  const state = stateFor2(client);
+  const state = stateFor3(client);
   let model = state.models.get(sessionID);
   if (!model) {
     let pending = state.history.get(sessionID);
@@ -45923,7 +46816,7 @@ async function currentSessionVisionCapability(client, sessionID) {
         return;
       const list = async () => {
         const result = api.list?.();
-        return isV2PluginContext3(client) ? Effect5.runPromise(result) : await result;
+        return isV2PluginContext3(client) ? Effect6.runPromise(result) : await result;
       };
       const listed = record3(await bounded(list));
       const catalog = record3(listed?.data) ?? listed;
@@ -46014,6 +46907,7 @@ function createBashWatchTool(ctx) {
             throw new Error(`invalid_request: ${message}`);
           throw new Error(`${code}: ${message}`);
         }
+        await trackV2Watch(ctx, context, taskId, registered.watch_id);
         const metadata = context.metadata;
         metadata?.({ taskId, registered: true, watchId: registered.watch_id });
         return `Watch registered: ${registered.watch_id} on task ${taskId}
@@ -46023,6 +46917,11 @@ A notification will fire when the pattern matches or the task exits.`;
       const role = isSubagent ? "worker" : "primary";
       const effectiveWaitMs = subagentForcedSync ? bashCfg.worker_wait_max_ms : resolveWatchTimeoutMs(coerceConfiguredWatchTimeout(args.timeoutMs, role, syncWaitCap), role, syncWaitCap, bashCfg.worker_wait_max_ms);
       const data = await waitForBashStatus(ctx, context, taskId, undefined, waitFor, effectiveWaitMs, role);
+      if (isSubagent && context.abort.aborted)
+        await awaitV2ExecutionSettlement(ctx.client, context.sessionID);
+      const stopped = isSubagent && v2SubagentStopped(ctx.client, context.sessionID);
+      if (stopped && data.waited?.reason === "user_message")
+        data.waited.reason = "aborted";
       const waited = data.waited;
       if (waited?.reason === "user_message") {
         const convertedText = await convertToAsyncWatchOnAbort(ctx, context, taskId, waitFor, coerceBoolean(args.once, true), waited.elapsed_ms, role);
@@ -46041,6 +46940,7 @@ async function convertToAsyncWatchOnAbort(ctx, context, taskId, waitFor, once, e
   const interrupted = `Sync watch for task ${taskId} was interrupted because you sent a message after ${elapsedMs}ms of waiting. `;
   const reminderFallback = interruptedWatchTail(role, `The task is still running in the background. A completion reminder will be ` + `delivered automatically when the task exits.`);
   if (!waitFor) {
+    allowV2WatchWake(ctx.client, context.sessionID, taskId);
     return interrupted + interruptedWatchTail(role, `The task is still running in the background. A completion reminder will be ` + `delivered automatically when the task exits; don't poll bash_status.`);
   }
   const notifyParams = {
@@ -46058,6 +46958,7 @@ async function convertToAsyncWatchOnAbort(ctx, context, taskId, waitFor, once, e
       unmarkExplicitControl(context.sessionID, taskId);
       return interrupted + `Auto-registering an async watch failed (${String(registered.message ?? "unknown error")}). ` + reminderFallback;
     }
+    await trackV2Watch(ctx, context, taskId, registered.watch_id);
     return interrupted + `The wait has been converted to an async watch (${registered.watch_id}). ` + interruptedWatchTail(role, `A notification will fire when the pattern matches or the task exits.`);
   } catch (err) {
     unmarkExplicitControl(context.sessionID, taskId);
@@ -46174,6 +47075,9 @@ async function waitForBashStatus(ctx, runtime, taskId, outputMode, waitFor, effe
       }
       busySince = undefined;
       lastData = data;
+      if (role === "worker" && abortSignal?.aborted) {
+        return withWaited(data, waited("aborted"));
+      }
       const terminal = isTerminalStatus(data.status);
       if (waitFor) {
         const scan = await readNewTaskOutput(data, spillCursor);
@@ -46862,9 +47766,6 @@ function createHashlineEditTool(ctx) {
       });
       if (denial)
         return permissionDeniedResponse(denial);
-      const preview = await callToolCall(ctx, context, "edit", rawArgs, { preview: true });
-      if (preview.success === false)
-        throw toolErrorFromResponse("edit", preview);
       const data = await callToolCall(ctx, context, "edit", rawArgs);
       if (data.success === false)
         throw toolErrorFromResponse("edit", data);
@@ -47493,12 +48394,13 @@ function createInspectTier2IdleScheduler(options) {
 }
 function inspectTools(ctx) {
   const inspectTool = {
-    description: "Codebase health inspection that waits for current analysis. FRESH means the reported analysis is current. PARTIAL means some diagnostics are unknown; the header names the analyzer, reason, and retry guidance. INTERRUPTED means the request stopped without a fresh snapshot; retry aft_inspect. PHASE-FAILED means inspection could not finish; address the reported reason and retry, or narrow the scope. `sections` selects drill-down detail, not the categories verified. Categories switched off in `inspect.categories` are not computed or refreshed, render as off, and never make the header PARTIAL.\n\n" + "Use `scope=` to narrow all findings, counts, and examples to those paths. Cross-boundary duplicates are labeled as groups touching the scope. Scope also limits Rust analyzer startup to the Cargo workspaces owning those paths. Files without an authoritative diagnostic report remain named gaps (complete: false), not a clean result.\n\n" + `Use when: starting work on unfamiliar code, after multi-edit batches to check diagnostics, before a refactor, before review, or to verify cleanup completeness.
+    description: "Codebase health inspection that waits for current analysis. FRESH means the reported analysis is current. PARTIAL means some diagnostics are unknown; the header names the analyzer, reason, and retry guidance. INTERRUPTED means the request stopped without a fresh snapshot; retry aft_inspect. PHASE-FAILED means inspection could not finish; address the reported reason and retry, or narrow the scope. `sections` selects drill-down detail. Scoped requests collect diagnostics when sections is omitted or includes 'diagnostics' or 'all'; sections that leave diagnostics out skip diagnostics work. Unscoped requests keep warm diagnostics. Categories switched off in `inspect.categories` are not computed or refreshed, render as off, and never make the header PARTIAL.\n\n" + "Use `scope=` to narrow all findings, counts, and examples to those paths. Cross-boundary duplicates are labeled as groups touching the scope. Scope also limits Rust analyzer startup to the Cargo workspaces owning those paths when diagnostics are requested. Files without an authoritative diagnostic report remain named gaps (complete: false), not a clean result.\n\n" + `Use when: starting work on unfamiliar code, after multi-edit batches to check diagnostics, before a refactor, before review, or to verify cleanup completeness.
 
 ` + "Treat `dead_code` as a hint, not proof: reachability is call-based, so symbols reached only via method dispatch or referenced only in type position may be false positives — verify before deleting.\n\n" + "When a list is cut, the reply ends with `shown N of M <unit> (<reason>) · narrow: <knobs>`; absence of that line means the list is complete.",
     args: {
-      sections: arg(z9.union([z9.string(), z9.array(z9.string())]).optional().describe("Categories to include in detailed drill-down (e.g. 'todos' or ['todos', 'dead_code', 'cycles']). Use 'all' for every active category. Omit for summary-only mode. `sections` changes detail, not the categories verified.")),
-      scope: arg(z9.union([z9.string(), z9.array(z9.string())]).optional().describe("Restrict returned results to paths under this scope (one path, or an array of paths — not a space-separated list; file or directory; absolute or relative to project root). `scope=` narrows results and limits Rust LSP startup to owning Cargo workspaces; it does not trigger per-file diagnostic collection. Scoped files no producer has authoritatively analyzed are reported as named gaps (complete: false), never as a clean empty result.")),
+      sections: arg(z9.union([z9.string(), z9.array(z9.string())]).optional().describe("Categories to include in detailed drill-down (e.g. 'todos' or ['todos', 'dead_code', 'cycles']). Use 'all' for every active category. Omit for summary-only mode. With scope, listing sections without 'diagnostics' (or 'all') skips diagnostics work; omitting sections keeps diagnostics. Other categories are verified regardless of sections.")),
+      scope: arg(z9.union([z9.string(), z9.array(z9.string())]).optional().describe("Restrict returned results to paths under this scope (one path, or an array of paths — not a space-separated list; file or directory; absolute or relative to project root). `scope=` narrows results. Scoped requests collect diagnostics for the scoped files and report coverage gaps, unless sections lists other categories and leaves out 'diagnostics'.")),
+      offset: arg(z9.number().int().nonnegative().optional().describe("Rows to skip independently in each drill-down list. Default 0; follow next_offset in each list envelope.")),
       topK: arg(z9.number().int().positive().max(100).optional().describe("Max drill-down items per category. Default 20, max 100."))
     },
     execute: async (args, context) => {
@@ -47513,6 +48415,8 @@ function inspectTools(ctx) {
         rawArgs.scope = scoped.scope;
       if (args.topK !== undefined && args.topK !== null)
         rawArgs.topK = args.topK;
+      if (args.offset !== undefined && args.offset !== null)
+        rawArgs.offset = args.offset;
       const response = await callToolCall(ctx, context, "inspect", rawArgs, {
         transportTimeoutMs: resolveInspectDiagnosticsTimeoutMs(ctx.config) + INSPECT_TRANSPORT_HEADROOM_MS
       });
@@ -48392,11 +49296,11 @@ function describeBashForRegisteredSurface(allTools, config) {
 }
 function registerAftTools(context, location, definitions, consumers = {}) {
   return context.tool.transform((editor) => {
-    const projected = Object.entries(definitions).map(([name, definition]) => projectV2Tool(name, definition, location, consumers));
-    for (const definition of projected) {
-      if (V2_BUILTIN_REPLACEMENTS.has(definition.name))
-        editor.remove(definition.name);
-      editor.add(definition);
+    for (const [name, definition] of Object.entries(definitions)) {
+      const projected = projectV2Tool(name, definition, location, consumers);
+      if (V2_BUILTIN_REPLACEMENTS.has(name))
+        editor.remove(projected.name);
+      editor.add(projected);
     }
   });
 }
@@ -48797,6 +49701,7 @@ function startOpenCodeLiveConfigReload(options) {
   const { userConfigPath, projectConfigPath } = resolveCortexKitConfigPaths(options.directory);
   return startLiveConfigReload({
     paths: [userConfigPath, projectConfigPath],
+    projectPath: projectConfigPath,
     load: () => loadOpenCodeConfigForLiveReload(options.directory),
     initialSources: options.initialSources,
     initialProjectText: options.initialSourceTexts?.[projectConfigPath] ?? null,
@@ -49363,21 +50268,21 @@ import {
   mkdirSync as mkdirSync8,
   openSync as openSync11,
   readFileSync as readFileSync17,
-  renameSync as renameSync11,
+  renameSync as renameSync10,
   rmSync as rmSync8,
   statSync as statSync16,
-  writeFileSync as writeFileSync12
+  writeFileSync as writeFileSync11
 } from "node:fs";
 import { dirname as dirname16 } from "node:path";
 
 // src/hooks/auto-update-checker/cache.ts
-import { cpSync, existsSync as existsSync19, mkdtempSync, readFileSync as readFileSync16, rmSync as rmSync7, writeFileSync as writeFileSync11 } from "node:fs";
+import { cpSync, existsSync as existsSync19, mkdtempSync, readFileSync as readFileSync16, rmSync as rmSync7, writeFileSync as writeFileSync10 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
 import { basename as basename6, dirname as dirname15, join as join25 } from "node:path";
 var import_comment_json3 = __toESM(require_src2(), 1);
 
 // src/hooks/auto-update-checker/checker.ts
-import { existsSync as existsSync18, readFileSync as readFileSync15, statSync as statSync15, writeFileSync as writeFileSync10 } from "node:fs";
+import { existsSync as existsSync18, readFileSync as readFileSync15, statSync as statSync15, writeFileSync as writeFileSync9 } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { homedir as homedir15 } from "node:os";
 import { dirname as dirname14, isAbsolute as isAbsolute13, join as join24, resolve as resolve15 } from "node:path";
@@ -49765,11 +50670,11 @@ function restoreAutoUpdateSnapshot(snapshot) {
     if (snapshot.packageJson === null)
       rmSync7(snapshot.packageJsonPath, { force: true });
     else
-      writeFileSync11(snapshot.packageJsonPath, snapshot.packageJson);
+      writeFileSync10(snapshot.packageJsonPath, snapshot.packageJson);
     if (snapshot.lockfile === null)
       rmSync7(snapshot.lockfilePath, { force: true });
     else
-      writeFileSync11(snapshot.lockfilePath, snapshot.lockfile);
+      writeFileSync10(snapshot.lockfilePath, snapshot.lockfile);
     rmSync7(snapshot.packageDir, { recursive: true, force: true });
     if (snapshot.stagedPackageDir) {
       cpSync(snapshot.stagedPackageDir, snapshot.packageDir, { recursive: true });
@@ -49806,7 +50711,7 @@ function removeFromPackageLock(installDir, packageName) {
       modified = true;
     }
     if (modified) {
-      writeFileSync11(lockPath, JSON.stringify(lock, null, 2));
+      writeFileSync10(lockPath, JSON.stringify(lock, null, 2));
       log2(`[auto-update-checker] Removed from package-lock.json: ${packageName}`);
     }
     return modified;
@@ -49828,7 +50733,7 @@ function ensureDependencyVersion(packageJsonPath, packageName, version) {
       return true;
     dependencies[packageName] = version;
     nextPackageJson.dependencies = dependencies;
-    writeFileSync11(packageJsonPath, JSON.stringify(nextPackageJson, null, 2));
+    writeFileSync10(packageJsonPath, JSON.stringify(nextPackageJson, null, 2));
     log2(`[auto-update-checker] Updated dependency in package.json: ${packageName} → ${version}`);
     return true;
   } catch (err) {
@@ -50072,7 +50977,7 @@ function claimCheckSlot(storageDir, intervalMs) {
     let lockFd = null;
     try {
       lockFd = openSync11(lockPath, "wx");
-      writeFileSync12(lockFd, JSON.stringify(owner));
+      writeFileSync11(lockFd, JSON.stringify(owner));
       closeSync12(lockFd);
       lockFd = null;
     } catch (err) {
@@ -50086,9 +50991,9 @@ function claimCheckSlot(storageDir, intervalMs) {
       if (!isOrphanedCheckLock(lockPath))
         return null;
       const replacementPath = `${lockPath}.tmp.${process.pid}`;
-      writeFileSync12(replacementPath, JSON.stringify(owner), { encoding: "utf-8", mode: 384 });
+      writeFileSync11(replacementPath, JSON.stringify(owner), { encoding: "utf-8", mode: 384 });
       try {
-        renameSync11(replacementPath, lockPath);
+        renameSync10(replacementPath, lockPath);
       } catch (replaceError) {
         rmSync8(replacementPath, { force: true });
         throw replaceError;
@@ -50168,8 +51073,8 @@ function hasRecentCheckTimestamp(file, intervalMs) {
 }
 function writeCheckTimestamp(file) {
   const tmp = `${file}.tmp.${process.pid}`;
-  writeFileSync12(tmp, JSON.stringify({ lastCheckedMs: Date.now() }), "utf-8");
-  renameSync11(tmp, file);
+  writeFileSync11(tmp, JSON.stringify({ lastCheckedMs: Date.now() }), "utf-8");
+  renameSync10(tmp, file);
 }
 function isNewerVersion(candidate, installed) {
   const semver = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
@@ -50373,9 +51278,9 @@ import {
   mkdirSync as mkdirSync9,
   readdirSync as readdirSync6,
   readFileSync as readFileSync18,
-  renameSync as renameSync12,
-  unlinkSync as unlinkSync8,
-  writeFileSync as writeFileSync13
+  renameSync as renameSync11,
+  unlinkSync as unlinkSync7,
+  writeFileSync as writeFileSync12
 } from "node:fs";
 import { createServer } from "node:http";
 import { dirname as dirname17, join as join27 } from "node:path";
@@ -50531,13 +51436,13 @@ class AftRpcServer {
     const dir = dirname17(this.portFilePath);
     mkdirSync9(dir, { recursive: true, mode: 448 });
     const tmpPath = `${this.portFilePath}.tmp`;
-    writeFileSync13(tmpPath, JSON.stringify({
+    writeFileSync12(tmpPath, JSON.stringify({
       port: this.port,
       token: this.token,
       pid: process.pid,
       started_at: Date.now()
     }), { encoding: "utf-8", mode: 384 });
-    renameSync12(tmpPath, this.portFilePath);
+    renameSync11(tmpPath, this.portFilePath);
   }
   sweepDeadPortFiles() {
     let entries;
@@ -50555,11 +51460,11 @@ class AftRpcServer {
       try {
         const record = parseRpcPortRecord(readFileSync18(filePath, "utf-8"));
         if (record === null) {
-          unlinkSync8(filePath);
+          unlinkSync7(filePath);
           continue;
         }
         if (record.pid !== undefined && !isPidAlive(record.pid)) {
-          unlinkSync8(filePath);
+          unlinkSync7(filePath);
         }
       } catch {}
     }
@@ -50595,7 +51500,7 @@ class AftRpcServer {
       this.bunServer = null;
     }
     try {
-      unlinkSync8(this.portFilePath);
+      unlinkSync7(this.portFilePath);
     } catch {}
   }
   async handleFetch(req, srv) {
@@ -50824,7 +51729,13 @@ function readStatusBar(value) {
   const duplicates = readOptionalNumber(bar.duplicates);
   const todos = readOptionalNumber(bar.todos);
   const noLanguageServer = bar.diagnostics === "no_language_server";
-  if (errors === null && warnings === null && deadCode === null && unusedExports === null && duplicates === null && todos === null && !noLanguageServer && disabled.length === 0) {
+  const producerMissing = bar.diagnostics === "producer_missing";
+  const diagnosticsGaps = Array.isArray(bar.diagnostics_gaps) ? bar.diagnostics_gaps.map(asRecord3).filter((gap) => typeof gap.language === "string" && typeof gap.producer === "string" && typeof gap.root === "string").map((gap) => ({
+    language: gap.language,
+    producer: gap.producer,
+    root: gap.root
+  })) : [];
+  if (errors === null && warnings === null && deadCode === null && unusedExports === null && duplicates === null && todos === null && !noLanguageServer && !producerMissing && disabled.length === 0) {
     return;
   }
   return {
@@ -50836,7 +51747,8 @@ function readStatusBar(value) {
     ...duplicates !== null ? { duplicates } : {},
     ...todos !== null ? { todos } : {},
     ...bar.tier2_stale === true ? { tier2_stale: true } : {},
-    ...noLanguageServer ? { diagnostics: "no_language_server" } : {}
+    ...noLanguageServer ? { diagnostics: "no_language_server" } : {},
+    ...producerMissing ? { diagnostics: "producer_missing", diagnostics_gaps: diagnosticsGaps } : {}
   };
 }
 function formatFlag(enabled) {
@@ -51288,11 +52200,11 @@ function throwSentinel(command) {
   throw sentinel;
 }
 var PLUGIN_VERSION = resolvePluginVersion(import.meta.url);
-var ANNOUNCEMENT_VERSION = "0.59.0";
+var ANNOUNCEMENT_VERSION = "0.60.0";
 var ANNOUNCEMENT_FEATURES = [
-  "Config keys retired in 0.58 keep working: AFT updates your user config file to the current keys (keeping a backup) and translates a project's in memory; `npx @cortexkit/aft doctor --fix` updates a project file.",
-  "New: live pull-request diffs with `read` on `pr://N/diff`, a `pattern` argument for `aft_search`, and per-category switches for `aft_inspect`.",
-  "Fixes for issues reported on OpenCode 2, Pi and OMP, and much less repeated indexing and disk work."
+  "Call graphs stay current cheaply: a one-file edit updates a project's graph in seconds instead of minutes, and linked worktrees reuse their main checkout's graph until they change.",
+  "`aft_inspect` dead-code and unused-export results are more accurate on Rust, Go and TypeScript, and inspect uses far less memory on large projects.",
+  "OpenCode 2 gets native `shell` and `patch` tools, and stopped subagents are no longer woken by their own background commands."
 ];
 var ANNOUNCEMENT_FOOTER = "Join us on Discord: https://discord.gg/DSa65w8wuf";
 var plugin = async (input) => initializePluginForDirectory(input);
@@ -51785,7 +52697,7 @@ var src_default = plugin;
 import { Effect as Effect14 } from "effect";
 
 // src/rpc/register.ts
-import { Effect as Effect6 } from "effect";
+import { Effect as Effect7 } from "effect";
 
 // src/tui/aft-rpc.ts
 import { Schema } from "effect";
@@ -51885,7 +52797,7 @@ function restoreOwnProperty(target, key, descriptor) {
     Reflect.deleteProperty(target, key);
 }
 function registerAftRpc(context, location, pool) {
-  return Effect6.gen(function* () {
+  return Effect7.gen(function* () {
     const root = locationRoot(location);
     const bridgeUnsubscribes = new Map;
     let disposed = false;
@@ -51893,7 +52805,7 @@ function registerAftRpc(context, location, pool) {
     const emit = async (name, payload) => {
       if (disposed)
         return;
-      await Effect6.runPromise(registration.events.emit(name, payload));
+      await Effect7.runPromise(registration.events.emit(name, payload));
     };
     const publishStatus = (snapshot) => {
       const sessionID = sessionFromSnapshot(snapshot);
@@ -51907,21 +52819,21 @@ function registerAftRpc(context, location, pool) {
         return;
       bridgeUnsubscribes.set(bridge, bridge.subscribeStatus(publishStatus));
     };
-    const getStatus = (input) => Effect6.suspend(() => {
+    const getStatus = (input) => Effect7.suspend(() => {
       const sessionID = input.sessionID || "rpc";
       const bridge = pool.getActiveBridgeForRoot(root);
       if (!bridge)
-        return Effect6.succeed(placeholderStatus());
+        return Effect7.succeed(placeholderStatus());
       observeBridge(bridge);
       const cached = bridge.getCachedStatus();
       const cachedSessionID = cached ? sessionFromSnapshot(cached) : undefined;
       if (cached && cachedSessionID === sessionID) {
-        return Effect6.succeed({ success: true, ...cached });
+        return Effect7.succeed({ success: true, ...cached });
       }
-      return Effect6.tryPromise({
+      return Effect7.tryPromise({
         try: (signal) => bridge.send("status", { session_id: sessionID }, { abortSignal: signal }),
         catch: (error) => error
-      }).pipe(Effect6.tap((response) => Effect6.sync(() => {
+      }).pipe(Effect7.tap((response) => Effect7.sync(() => {
         if (response.success !== false)
           bridge.cacheStatusSnapshot(response);
       })));
@@ -51983,21 +52895,21 @@ function registerAftRpc(context, location, pool) {
         bridgeUnsubscribes.clear();
         restoreOwnProperty(pool, "getBridge", ownGetBridge);
         restoreOwnProperty(pool, "toolCall", ownToolCall);
-        await Effect6.runPromise(registration.dispose);
+        await Effect7.runPromise(registration.dispose);
       }
     };
   });
 }
 function registerAftConfigErrorRpc(context, message) {
-  return Effect6.gen(function* () {
+  return Effect7.gen(function* () {
     let disposed = false;
     const registration = yield* context.rpc.register(AftRpc, {
-      getStatus: () => Effect6.succeed(configErrorStatusSnapshot(message))
+      getStatus: () => Effect7.succeed(configErrorStatusSnapshot(message))
     });
     const emit = async (name, payload) => {
       if (disposed)
         return;
-      await Effect6.runPromise(registration.events.emit(name, payload));
+      await Effect7.runPromise(registration.events.emit(name, payload));
     };
     return {
       emitStatusInvalidated: (payload = {}) => emit("statusInvalidated", payload),
@@ -52008,14 +52920,14 @@ function registerAftConfigErrorRpc(context, message) {
         if (disposed)
           return;
         disposed = true;
-        await Effect6.runPromise(registration.dispose);
+        await Effect7.runPromise(registration.dispose);
       }
     };
   });
 }
 
 // src/permissions/v2.ts
-import { Effect as Effect7 } from "effect";
+import { Effect as Effect8 } from "effect";
 
 class PermissionDeniedError extends Error {
   name = "PermissionDeniedError";
@@ -52071,7 +52983,7 @@ function detail(error) {
   return error instanceof Error ? error.message : String(error);
 }
 async function runHostEffect(effect) {
-  return await Effect7.runPromise(effect);
+  return await Effect8.runPromise(effect);
 }
 async function sessionRecord(host, sessionID) {
   if (!sessionID)
@@ -52848,11 +53760,11 @@ function v2PromptChannelFor(settings) {
   return createV2PromptChannel(() => discoverPromptServer(settings));
 }
 
-// src/v2-host-tool-overlap.ts
-import { Effect as Effect9 } from "effect";
+// src/v2-prompt-detach.ts
+import { Effect as Effect10 } from "effect";
 
 // src/wakes/session-delivery.ts
-import { Effect as Effect8, Exit } from "effect";
+import { Effect as Effect9, Exit } from "effect";
 var AFT_PROMPT_SOURCE = "aft";
 function isAftOriginatedPrompt(metadata) {
   return typeof metadata === "object" && metadata !== null && metadata.source === AFT_PROMPT_SOURCE;
@@ -52866,43 +53778,49 @@ class V2SessionDelivery {
     this.session = session;
   }
   completion(input) {
-    return Effect8.suspend(() => {
+    return Effect9.suspend(() => {
       if (this.disposed)
-        return Effect8.succeed(false);
+        return Effect9.succeed(false);
       const keys = [...new Set(input.taskIDs)].map((taskID) => `${input.sessionID}\x00${taskID}`);
       if (keys.length === 0 || keys.every((key) => this.admittedCompletions.has(key))) {
-        return Effect8.succeed(false);
+        return Effect9.succeed(false);
       }
       const reserved = keys.filter((key) => !this.admittedCompletions.has(key));
       for (const key of reserved)
         this.admittedCompletions.add(key);
-      return Effect8.suspend(() => this.session.prompt({
-        sessionID: input.sessionID,
-        text: input.text,
-        delivery: "steer",
-        metadata: {
-          ...input.metadata,
-          source: AFT_PROMPT_SOURCE,
-          task_ids: [...new Set(input.taskIDs)]
-        }
-      })).pipe(Effect8.onExit((exit) => Effect8.sync(() => {
+      return Effect9.suspend(() => this.session.get({ sessionID: input.sessionID }).pipe(Effect9.flatMap((session) => {
+        if (session.revert) {
+          return Effect9.fail(new Error("Background bash completion deferred: session has a staged revert"));
+        }
+        return this.session.synthetic({
+          sessionID: input.sessionID,
+          text: input.text,
+          description: "Background bash completed",
+          delivery: "steer",
+          metadata: {
+            ...input.metadata,
+            source: AFT_PROMPT_SOURCE,
+            task_ids: [...new Set(input.taskIDs)]
+          }
+        });
+      }))).pipe(Effect9.onExit((exit) => Effect9.sync(() => {
         if (Exit.isFailure(exit))
           for (const key of reserved)
             this.admittedCompletions.delete(key);
-      })), Effect8.map(() => true));
+      })), Effect9.map(() => true));
     });
   }
   status(input) {
-    return Effect8.suspend(() => {
+    return Effect9.suspend(() => {
       if (this.disposed)
-        return Effect8.succeed(undefined);
+        return Effect9.succeed(undefined);
       return this.session.synthetic({
         sessionID: input.sessionID,
         text: input.text,
         description: input.description,
         metadata: input.metadata,
         resume: false
-      }).pipe(Effect8.asVoid);
+      }).pipe(Effect9.asVoid);
     });
   }
   dispose() {
@@ -52913,117 +53831,7 @@ class V2SessionDelivery {
   }
 }
 
-// src/v2-host-tool-overlap.ts
-var OVERLAPS = [
-  { aft: "apply_patch", host: "patch" },
-  { aft: "bash", host: "shell" }
-];
-var FIX_COMMAND = "`npx @cortexkit/aft doctor --fix`";
-function findHostToolOverlaps(hostToolNames, registeredAftTools) {
-  return OVERLAPS.filter((pair) => registeredAftTools.has(pair.aft) && hostToolNames.has(pair.host) && !registeredAftTools.has(pair.host));
-}
-function hostToolOverlapNotice(overlaps) {
-  const patch = overlaps.some((pair) => pair.host === "patch");
-  const shell = overlaps.some((pair) => pair.host === "shell");
-  if (patch && shell) {
-    return `OpenCode's built-in patch and shell tools are still enabled beside AFT's apply_patch and bash, so the model sees two editing tools and two shells. Run ${FIX_COMMAND} to turn the built-in ones off.`;
-  }
-  if (patch) {
-    return `OpenCode's built-in patch tool is still enabled beside AFT's apply_patch, so the model sees two editing tools. Run ${FIX_COMMAND} to turn the built-in one off.`;
-  }
-  if (shell) {
-    return `OpenCode's built-in shell tool is still enabled beside AFT's bash, so the model sees two shells. Run ${FIX_COMMAND} to turn the built-in one off.`;
-  }
-  return null;
-}
-var noticeClaimed = false;
-var loggedUnavailableReasons = new Set;
-function logDetectionUnavailable(reason) {
-  if (loggedUnavailableReasons.has(reason))
-    return;
-  loggedUnavailableReasons.add(reason);
-  debug2(`Built-in tool overlap check skipped: ${reason}; no notice shown`);
-}
-function reasonOf(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-async function hostToolNames(context) {
-  const tool = context.tool;
-  const list = tool?.list;
-  if (typeof list !== "function") {
-    logDetectionUnavailable("the host context has no tool.list()");
-    return null;
-  }
-  let entries;
-  try {
-    entries = await Effect9.runPromise(list.call(tool));
-  } catch (error) {
-    logDetectionUnavailable(`tool.list() failed: ${reasonOf(error)}`);
-    return null;
-  }
-  if (!Array.isArray(entries)) {
-    logDetectionUnavailable("tool.list() did not return a list");
-    return null;
-  }
-  const names = new Set;
-  for (const entry of entries) {
-    const name = typeof entry?.id === "string" ? entry.id : entry?.name;
-    if (typeof name === "string")
-      names.add(name);
-  }
-  return names;
-}
-async function checkAndNotify(context, registeredAftTools, deliver) {
-  const names = await hostToolNames(context);
-  if (!names)
-    return;
-  const overlaps = findHostToolOverlaps(names, registeredAftTools);
-  const text = hostToolOverlapNotice(overlaps);
-  if (!text)
-    return;
-  if (noticeClaimed)
-    return;
-  noticeClaimed = true;
-  try {
-    await deliver(text);
-    debug2(`Built-in tool overlap notice sent to the TUI: ${overlaps.map((pair) => `${pair.host} beside ${pair.aft}`).join(", ")}`);
-  } catch (error) {
-    noticeClaimed = false;
-    warn2(`Built-in tool overlap notice could not be delivered: ${reasonOf(error)}`);
-  }
-}
-function createHostToolOverlapPromptHook(context, registeredAftTools, deliver, onChecked) {
-  const host = context;
-  let checked = false;
-  return (event) => Effect9.sync(() => {
-    if (checked || noticeClaimed)
-      return;
-    if (isAftOriginatedPrompt(event?.metadata))
-      return;
-    if (typeof event?.sessionID !== "string" || event.sessionID.length === 0)
-      return;
-    checked = true;
-    const done = checkAndNotify(host, registeredAftTools, deliver).catch((error) => {
-      warn2(`Built-in tool overlap check failed: ${reasonOf(error)}`);
-    });
-    onChecked?.(done);
-  });
-}
-function registerV2HostToolOverlapNotice(context, registeredAftTools, deliver, onChecked) {
-  if (findHostToolOverlaps(new Set(["patch", "shell"]), registeredAftTools).length === 0) {
-    return Effect9.succeed(false);
-  }
-  const session = context?.session;
-  const hook = session?.hook;
-  if (typeof hook !== "function") {
-    logDetectionUnavailable("the host context has no session prompt hook to check from");
-    return Effect9.succeed(false);
-  }
-  return hook.call(session, "prompt", createHostToolOverlapPromptHook(context, registeredAftTools, deliver, onChecked)).pipe(Effect9.as(true));
-}
-
 // src/v2-prompt-detach.ts
-import { Effect as Effect10 } from "effect";
 function mapOffset(offset, edits) {
   let shift = 0;
   for (const edit of edits) {
@@ -53102,25 +53910,55 @@ function gateEditingTools(event, registeredTools) {
   const prefersPatch = id.includes("gpt-") && !id.includes("oss") && !id.includes("gpt-4");
   for (const name of prefersPatch ? ["edit", "write"] : ["apply_patch"]) {
     if (registeredTools.has(name))
-      delete event.tools[name];
+      delete event.tools[v2HostToolName(name)];
   }
 }
-function registerV2ToolHooks(context, runtime, registeredTools) {
+var HOST_SHELL_DESCRIPTION = /^Execute a shell command\b/;
+function restoreShellDescription(event, registeredTools, shellDescription) {
+  if (shellDescription === undefined || !registeredTools.has("bash"))
+    return;
+  const shell = event.tools[v2HostToolName("bash")];
+  if (!shell || shell.description === shellDescription)
+    return;
+  if (!HOST_SHELL_DESCRIPTION.test(shell.description))
+    return;
+  shell.description = shellDescription;
+}
+function registerV2ToolHooks(context, runtime, registeredTools, bashDescription) {
   const host = context;
+  const shellDescription = bashDescription === undefined ? undefined : renameV2ToolReferences(bashDescription);
   return Effect11.gen(function* () {
     if (typeof host.tool?.hook === "function") {
+      yield* host.tool.hook("execute.after", (event) => Effect11.promise(async () => {
+        if (!runtime.pool || event.status !== "completed" || !hasHeldBgCompletions(event.sessionID))
+          return;
+        const content = event.result.content;
+        const output = { output: "" };
+        await appendInTurnBgCompletions({
+          ctx: runtime,
+          directory: context.location.directory,
+          sessionID: event.sessionID
+        }, output);
+        if (!output.output)
+          return;
+        event.result = {
+          ...event.result,
+          content: typeof content === "string" ? content + output.output : [...content ?? [], { type: "text", text: output.output }]
+        };
+      }));
       yield* host.tool.hook("execute.before", (event) => Effect11.try({
         try: () => {
-          if (!registeredTools.has(event.tool))
+          const name = aftToolNameForV2Host(event.tool);
+          if (!registeredTools.has(name))
             return;
-          event.input = prepareOpenCodeArguments(event.tool, event.input, {
+          event.input = prepareOpenCodeArguments(name, event.input, {
             hashlineEffective: runtime.hashlineEffective
           });
         },
         catch: (error) => new ArgumentError({ message: error instanceof Error ? error.message : String(error) })
       }));
       yield* host.tool.hook("execute.after", (event) => Effect11.sync(() => {
-        if (event.tool !== "bash" || event.status !== "completed" || !registeredTools.has("bash") || !registeredTools.has("aft_conflicts"))
+        if (aftToolNameForV2Host(event.tool) !== "bash" || event.status !== "completed" || !registeredTools.has("bash") || !registeredTools.has("aft_conflicts"))
           return;
         const content = event.result.content;
         event.result = {
@@ -53131,10 +53969,14 @@ function registerV2ToolHooks(context, runtime, registeredTools) {
     }
     if (typeof host.session?.hook === "function") {
       for (const name of ["compaction", "generate"]) {
-        yield* host.session.hook(name, (event) => Effect11.sync(() => gateEditingTools(event, registeredTools)));
+        yield* host.session.hook(name, (event) => Effect11.sync(() => {
+          gateEditingTools(event, registeredTools);
+          restoreShellDescription(event, registeredTools, shellDescription);
+        }));
       }
       yield* host.session.hook("context", (event) => Effect11.sync(() => {
         gateEditingTools(event, registeredTools);
+        restoreShellDescription(event, registeredTools, shellDescription);
         rememberReadModel(context, event.sessionID, {
           providerID: event.model.providerID,
           modelID: event.model.id
@@ -53279,15 +54121,33 @@ var sharedBridgeOptions = {
   onBashCompletion: routeCompletion,
   onBashLongRunning: routeLongRunning
 };
-function createV2RuntimeConsumer(context) {
+function detachWaitsForCompletion(sessionID, text, bridge, config) {
+  const onlyThisBridge = {
+    getActiveBridgeForRoot: () => bridge,
+    activeBridges: () => [bridge]
+  };
+  interruptBashWaitsForChatMessage(onlyThisBridge, config, "", sessionID, {
+    parts: [{ type: "text", text, synthetic: true }]
+  });
+}
+function createV2RuntimeConsumer(context, getConfig = () => ({})) {
   const delivery = new V2SessionDelivery(context.session);
   const sessions = new Set;
   const route = {
     completion: async (completion, bridge) => {
+      if (await resolveIsSubagent(context, completion.session_id)) {
+        await awaitV2ExecutionSettlement(context, completion.session_id);
+      }
+      if (await resolveIsSubagent(context, completion.session_id) && !v2WatchWakeAllowed(context, completion.session_id, completion.task_id)) {
+        holdBgCompletion(completion.session_id, completion, v2SubagentStopped(context, completion.session_id));
+        forgetV2Watch(context, completion.session_id, completion.task_id);
+        return;
+      }
+      const text = formatSystemReminder([completion]);
       const admitted = await Effect13.runPromise(delivery.completion({
         sessionID: completion.session_id,
         taskIDs: [completion.task_id],
-        text: formatSystemReminder([completion]),
+        text,
         metadata: {
           source: "aft",
           kind: "bash_completion",
@@ -53297,10 +54157,12 @@ function createV2RuntimeConsumer(context) {
       }));
       if (!admitted)
         return;
+      detachWaitsForCompletion(completion.session_id, text, bridge, getConfig());
       await bridge.send("bash_ack_completions", {
         session_id: completion.session_id,
         task_ids: [completion.task_id]
       });
+      forgetV2Watch(context, completion.session_id, completion.task_id);
     },
     longRunning: (reminder) => Effect13.runPromise(delivery.status({
       sessionID: reminder.session_id,
@@ -53324,6 +54186,7 @@ function createV2RuntimeConsumer(context) {
   return {
     bridgeOptions: sharedBridgeOptions,
     registerSession,
+    onToolAbort: (sessionID) => noteV2ToolAbort(context, sessionID),
     executeBash: (execution) => {
       registerSession(execution.context.sessionID);
       return executeV2Bash(execution);
@@ -53350,10 +54213,9 @@ var defaults = {
   registerPromptHook: registerV2PromptDetachHook,
   registerToolHooks: registerV2ToolHooks,
   registerWorkflowHints: registerV2WorkflowHints,
-  registerHostToolOverlapNotice: registerV2HostToolOverlapNotice,
-  toolConsumers: (context, config) => ({
+  toolConsumers: (context, config, getConfig = () => config) => ({
     ...hoistedV2ToolConsumers(context, v2PromptChannelFor(config?.opencode)),
-    ...createV2RuntimeConsumer(context)
+    ...createV2RuntimeConsumer(context, getConfig)
   }),
   acquireBridge,
   releaseBridge,
@@ -53378,7 +54240,8 @@ async function bootLocation(context, location, dependencies) {
   const pluginVersion = dependencies.resolveVersion();
   const environment = await prepareBridgeEnvironment({ configRoot: directory, lspDirectory: directory, config, pluginVersion, notify }, dependencies);
   const canonicalDirectory = location.project?.canonical ?? directory;
-  const consumers = dependencies.toolConsumers(context, config);
+  let liveConfig = config;
+  const consumers = dependencies.toolConsumers(context, config, () => liveConfig);
   const isProjectEnabled = createProjectAcceptance(directory, dependencies);
   const pool = await dependencies.acquireBridge(canonicalDirectory, {
     harness: "opencode",
@@ -53403,6 +54266,7 @@ async function bootLocation(context, location, dependencies) {
     client: context,
     config,
     hashlineEffective: openCodeHashlineEffective(config),
+    hostToolNames: V2_HOST_TOOL_NAMES,
     storageDir: environment.storageDir,
     isProjectEnabled
   };
@@ -53411,7 +54275,8 @@ async function bootLocation(context, location, dependencies) {
   const { hashlineEditRegistered } = applyToolSurfaceOverrides(pool, config, registeredTools);
   reportHashlineDowngrade(config, registeredTools, notify);
   toolContext.hashlineEffective = hashlineEditRegistered;
-  const hintsBlock = buildHintsForRegisteredTools(config, registeredTools, hashlineEditRegistered);
+  const hints = buildHintsForRegisteredTools(config, registeredTools, hashlineEditRegistered);
+  const hintsBlock = hints === null ? null : renameV2ToolReferences(hints);
   const liveConfigReload = dependencies.startLiveConfigReload({
     directory,
     initialSources: bootstrap.sources ?? [],
@@ -53419,6 +54284,7 @@ async function bootLocation(context, location, dependencies) {
     getConfig: () => toolContext.config,
     setConfig: (next) => {
       toolContext.config = next;
+      liveConfig = next;
     },
     notify
   });
@@ -53470,6 +54336,7 @@ function makeServerEffect(overrides = {}) {
       }));
       const rpc = yield* dependencies.registerRpc(context, location, runtime.pool);
       yield* Effect14.addFinalizer(() => Effect14.promise(() => rpc.dispose()));
+      yield* registerV2SessionLifecycle(context, runtime.toolContext);
       yield* dependencies.registerPromptHook(context, {
         pool: runtime.pool,
         projectRoot: runtime.directory,
@@ -53477,9 +54344,8 @@ function makeServerEffect(overrides = {}) {
         registerSession: runtime.consumers.registerSession
       });
       yield* dependencies.registerTools(context, location, runtime.tools, runtime.consumers);
-      yield* dependencies.registerToolHooks(context, runtime.toolContext, new Set(Object.keys(runtime.tools)));
+      yield* dependencies.registerToolHooks(context, runtime.toolContext, new Set(Object.keys(runtime.tools)), runtime.tools.bash?.description);
       yield* dependencies.registerWorkflowHints(context, runtime.hintsBlock);
-      yield* dependencies.registerHostToolOverlapNotice(context, new Set(Object.keys(runtime.tools)), (message) => rpc.emitHostToolOverlap({ message }));
     });
   };
 }