@cortexkit/aft-pi 0.59.0 → 0.60.0

package/dist/index.js

@@ -7964,11 +7964,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) {
@@ -8031,6 +8031,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.";
@@ -8765,8 +8769,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";
 }
@@ -9210,6 +9214,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";
@@ -9374,6 +9379,8 @@ class BinaryBridge {
   lastBinaryFingerprintCheckAt = 0;
   _retiringDueToBinaryChange = false;
   pending = new Map;
+  activeSendCalls = 0;
+  processLoopReferenced = true;
   outstandingBackgroundTaskIds = new Set;
   nextId = 1;
   processGeneration = 0;
@@ -9605,6 +9612,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 };
@@ -9642,11 +9675,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) {
@@ -9715,7 +9750,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];
@@ -10090,6 +10130,8 @@ class BinaryBridge {
     this.lastChildActivityAt = 0;
     this.consecutiveRequestTimeouts = 0;
     this.stderrTail = [];
+    this.processLoopReferenced = true;
+    this.syncEventLoopHold();
   }
   pushStderrLine(line) {
     this.stderrTail.push(line);
@@ -10216,6 +10258,7 @@ class BinaryBridge {
         const taskId = bashTaskIdFrom(response);
         if (taskId)
           this.outstandingBackgroundTaskIds.delete(taskId);
+        this.syncEventLoopHold();
         this.onBashCompletion?.(response, this);
         return;
       }
@@ -10329,7 +10372,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();
@@ -10338,6 +10381,7 @@ class BinaryBridge {
           }
         }
       }, delay);
+      restartTimer.unref?.();
       this.scheduleRestartCountReset();
     } else {
       this.errorVia(`Max restarts (${this.maxRestarts}) reached, giving up. Logs: ${this.getLogFilePathVia()}${tail}`);
@@ -10358,6 +10402,7 @@ class BinaryBridge {
       this._restartCount = 0;
       this.restartResetTimer = null;
     }, BinaryBridge.RESTART_RESET_MS);
+    this.restartResetTimer.unref?.();
   }
   clearRestartResetTimer() {
     if (this.restartResetTimer) {
@@ -11235,10 +11280,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;
@@ -12065,17 +12112,17 @@ ${reflowText}`;
   }
   return " Auto-formatted.";
 }
-// ../../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;
@@ -12178,12 +12225,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) {
@@ -12217,12 +12264,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) {
@@ -12240,14 +12287,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 {
 }
 
@@ -12297,6 +12348,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) => {
@@ -12343,30 +12403,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();
     });
   }
@@ -12449,6 +12559,8 @@ class SubcSocket {
       this.waiter = null;
       if (w.timer)
         clearTimeout(w.timer);
+      if (w.immediate)
+        clearImmediate(w.immediate);
       w.resolve(out);
       return;
     }
@@ -12456,6 +12568,8 @@ class SubcSocket {
       this.waiter = null;
       if (w.timer)
         clearTimeout(w.timer);
+      if (w.immediate)
+        clearImmediate(w.immediate);
       w.reject(this.closedErr);
     }
   }
@@ -12480,7 +12594,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";
@@ -12554,7 +12668,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;
@@ -12587,18 +12701,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);
@@ -12632,7 +12757,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";
@@ -12821,7 +12946,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;
 
@@ -12914,7 +13039,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;
@@ -12971,6 +13096,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":
@@ -13113,14 +13244,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();
@@ -13130,7 +13263,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) => {
@@ -13333,7 +13467,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;
@@ -13429,13 +13563,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) {
@@ -13509,8 +13643,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) => {
@@ -13518,9 +13650,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");
@@ -13529,7 +13664,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 = {
@@ -13537,6 +13672,7 @@ class SubcClient {
         moduleId,
         target,
         identity,
+        scope,
         consumerIdentity,
         reverseRequests,
         handle: null,
@@ -13544,6 +13680,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();
@@ -13579,6 +13717,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) {
@@ -13593,6 +13733,7 @@ class SubcClient {
       try {
         outcome = {
           handle: await this.sendRouteOpen(cached.target, cached.identity, {
+            scope: cached.scope,
             consumerIdentity: cached.consumerIdentity ?? null,
             reverseRequests: cached.reverseRequests
           })
@@ -13760,10 +13901,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
         });
@@ -13791,11 +13933,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 {
@@ -13874,6 +14020,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);
@@ -13963,13 +14110,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);
       }
     }
   }
@@ -13992,6 +14155,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);
     }
@@ -14086,6 +14253,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) {
@@ -14143,6 +14314,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
   };
@@ -14166,10 +14338,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)
@@ -14686,6 +14876,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";
 }
@@ -14712,6 +14937,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) {
@@ -14754,6 +14981,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";
@@ -14832,7 +15065,7 @@ class BgSubscription {
   identity;
   acquireClient;
   dropClient;
-  consumerIdentity;
+  openRoute;
   onNudge;
   sleep;
   canAttach;
@@ -14843,21 +15076,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;
@@ -14868,11 +15105,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;
@@ -14997,7 +15238,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)
@@ -15055,6 +15296,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) {
@@ -15097,6 +15340,7 @@ class BgSubscription {
         stopDispatchProbe();
         this.current = null;
         this.attached = null;
+        this.route = null;
         safeCloseRoute(client, route);
       }
       await this.backoff(backoffAttempt++);
@@ -15112,7 +15356,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");
@@ -15239,6 +15483,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);
@@ -15250,10 +15496,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)
@@ -15276,6 +15524,10 @@ class SubcTransportPool {
   connectionFile;
   handshakeTimeoutMs;
   consumerIdentity;
+  hostScopes;
+  hostScopeCache = new Map;
+  hostScopeRefusals = new Set;
+  hostScopeOutcomes = new Map;
   connectFn;
   onBgEventsNudge;
   onBgEventsNudgeRef;
@@ -15297,6 +15549,7 @@ class SubcTransportPool {
   routeReopenRetry = null;
   routeReopenRetryMs = null;
   sessions = new Map;
+  sessionIndex = new Map;
   observedStarts = new Set;
   sessionSweep = null;
   rootIndex = new Map;
@@ -15316,6 +15569,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;
@@ -15535,7 +15789,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;
     }
@@ -15632,6 +15888,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;
@@ -15809,6 +16071,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;
@@ -15821,6 +16087,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);
@@ -15840,6 +16107,7 @@ class SubcTransportPool {
     record.routeEntry = null;
     if (routeEntry)
       routeEntry.closed = true;
+    this.stopUnusedHostScopeRetry(record.identity.session);
     return { record, bgSub, routeEntry };
   }
   async cleanupDetached(detached) {
@@ -15896,6 +16164,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;
@@ -16034,15 +16313,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,
@@ -16051,7 +16329,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)
@@ -16130,10 +16408,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;
@@ -16210,9 +16491,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) {
@@ -16222,6 +16508,7 @@ class SubcTransportPool {
         throw new SubcTransportShuttingDownError;
       }
       this.client = client;
+      owner = client;
       this.hadWorkingClient = true;
       this.transportFailures = 0;
       return client;
@@ -16251,9 +16538,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)
@@ -16263,6 +16548,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;
@@ -16270,6 +16561,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");
       }
@@ -16282,6 +16574,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;
@@ -16321,17 +16934,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;
@@ -16367,6 +16991,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();
@@ -16504,6 +17130,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;
@@ -16514,11 +17147,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();
@@ -16532,6 +17170,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);
   }
@@ -16572,6 +17217,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);
 }
@@ -16633,6 +17280,8 @@ function classifyBashHostFallbackError(error) {
     return;
   if (isRouteClosedMidCallError(error))
     return;
+  if (isSubcFrameReadTimeoutError(error))
+    return;
   if (error instanceof SubcTransportShuttingDownError)
     return "transport down";
   if (isSubcRouteTornDownError(error))
@@ -16656,6 +17305,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;
@@ -16737,7 +17394,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"],
@@ -16875,10 +17537,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")) {
@@ -16891,6 +17611,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);
   }
@@ -17349,11 +18071,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();
@@ -17559,7 +18283,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);
@@ -17594,7 +18320,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") {
@@ -17734,14 +18460,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);
   }
@@ -17819,7 +18553,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;
@@ -17854,8 +18588,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);
     };
@@ -17881,6 +18615,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,
@@ -17952,7 +18687,7 @@ import { homedir as homedir11, 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 homedir9 } from "node:os";
 import { dirname as dirname4, isAbsolute as isAbsolute5, join as join10, resolve as resolve7 } from "node:path";
 function homeDir3() {
@@ -17987,6 +18722,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(),
@@ -17994,15 +18746,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) {
@@ -19187,7 +19951,7 @@ function npmSpawnEnv(resolved, baseEnv = process.env, platform = process.platfor
   return withPathPrepended(baseEnv, resolved.binDir, platform);
 }
 // ../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;
@@ -19274,7 +20038,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,
@@ -19313,7 +20077,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";
@@ -19594,7 +20358,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 {}
@@ -19611,7 +20375,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;
@@ -19803,7 +20567,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);
@@ -19952,7 +20716,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 {
@@ -21156,7 +21920,7 @@ async function handlePushedBgLongRunning(drainContext, reminder) {
 async function appendToolResultBgCompletions(drainContext, content) {
   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);
   }
@@ -21288,7 +22052,8 @@ async function withBgHopTimeout(operation, label) {
 }
 async function triggerWakeIfPending(drainContext, skipDrain, includeDeferredCompletions = true, forceDrain = 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);
@@ -21409,8 +22174,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);
@@ -21840,7 +22610,7 @@ import {
 // package.json
 var package_default = {
   name: "@cortexkit/aft-pi",
-  version: "0.59.0",
+  version: "0.60.0",
   type: "module",
   description: "Pi coding agent extension for Agent File Tools (AFT) — tree-sitter and LSP-powered code analysis",
   main: "dist/index.js",
@@ -21864,18 +22634,18 @@ var package_default = {
     "test:e2e": "bun test src/__tests__/e2e/"
   },
   dependencies: {
-    "@cortexkit/aft-bridge": "0.59.0",
+    "@cortexkit/aft-bridge": "0.60.0",
     "comment-json": "^5.0.0",
     diff: "^8.0.4",
     zod: "^4.4.3"
   },
   optionalDependencies: {
-    "@cortexkit/aft-darwin-arm64": "0.59.0",
-    "@cortexkit/aft-darwin-x64": "0.59.0",
-    "@cortexkit/aft-linux-arm64": "0.59.0",
-    "@cortexkit/aft-linux-x64": "0.59.0",
-    "@cortexkit/aft-win32-arm64": "0.59.0",
-    "@cortexkit/aft-win32-x64": "0.59.0"
+    "@cortexkit/aft-darwin-arm64": "0.60.0",
+    "@cortexkit/aft-darwin-x64": "0.60.0",
+    "@cortexkit/aft-linux-arm64": "0.60.0",
+    "@cortexkit/aft-linux-x64": "0.60.0",
+    "@cortexkit/aft-win32-arm64": "0.60.0",
+    "@cortexkit/aft-win32-x64": "0.60.0"
   },
   devDependencies: {
     "@earendil-works/pi-coding-agent": "^0.80.2",
@@ -22613,7 +23383,7 @@ function registerStatusCommand(pi, ctx) {
 }
 
 // src/config.ts
-import { existsSync as existsSync12, readFileSync as readFileSync10, renameSync as renameSync7, unlinkSync as unlinkSync5, writeFileSync as writeFileSync6 } from "node:fs";
+import { existsSync as existsSync12, readFileSync as readFileSync10 } from "node:fs";
 import { homedir as homedir14 } from "node:os";
 import { isAbsolute as isAbsolute9 } from "node:path";
 var import_comment_json = __toESM(require_src2(), 1);
@@ -27723,154 +28493,6 @@ function applyActiveHarnessOverride(config, trusted) {
     merged.indexes = indexes;
   return merged;
 }
-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 (!existsSync12(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 preservedComments = extractCommentsForPreservation(content).filter((comment) => !serialized.includes(comment.trim()));
-    const nextContent = preservedComments.length > 0 ? `${preservedComments.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: [] };
-  }
-}
 var configLoadErrors = [];
 var configValidationErrors = [];
 var configLoadSources = [];
@@ -27919,7 +28541,6 @@ function loadConfigFromPath(configPath, tier) {
       recordConfigParseFailure(configPath, "root must be an object");
       return null;
     }
-    migrateRawConfig(rawConfig, configPath, { log: log2, warn: warn2 });
     cleanConfig = stripJsoncSymbols(rawConfig);
   } catch (err) {
     const errorMsg = err instanceof Error ? err.message : String(err);
@@ -28293,21 +28914,14 @@ function migrateAftConfigLocations(projectDirectory, logger = { log: log2, warn:
       legacySources: legacy.user,
       operatingHarness: "pi",
       logger
-    }),
-    migrateAftConfigFile({
-      scope: "project",
-      targetPath: paths.projectConfigPath,
-      legacySources: legacy.project,
-      operatingHarness: "pi",
-      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 buildConfigTierConfigureParams(projectDirectory, processState = {}) {
   const paths = resolveAftConfigPaths(projectDirectory);
@@ -28329,6 +28943,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]
   };
@@ -28371,7 +28994,7 @@ function loadAftConfig(projectDirectory) {
 }
 
 // src/lsp-auto-install.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync6, renameSync as renameSync9, rmSync as rmSync5, statSync as statSync11, writeFileSync as writeFileSync8 } from "node:fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync6, renameSync as renameSync8, rmSync as rmSync5, statSync as statSync11, writeFileSync as writeFileSync7 } from "node:fs";
 import { join as join19 } from "node:path";
 
 // src/lsp-cache.ts
@@ -28381,11 +29004,11 @@ import {
   mkdirSync as mkdirSync5,
   openSync as openSync8,
   readFileSync as readFileSync11,
-  renameSync as renameSync8,
+  renameSync as renameSync7,
   rmSync as rmSync4,
   statSync as statSync10,
-  unlinkSync as unlinkSync6,
-  writeFileSync as writeFileSync7
+  unlinkSync as unlinkSync5,
+  writeFileSync as writeFileSync6
 } from "node:fs";
 import { join as join17 } from "node:path";
 function aftCacheBase() {
@@ -28426,7 +29049,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}`);
   }
@@ -28467,7 +29090,7 @@ function acquireInstallLock(lockKey) {
     try {
       const fd = openSync8(lock, "wx");
       try {
-        writeFileSync7(fd, `${process.pid}
+        writeFileSync6(fd, `${process.pid}
 ${new Date().toISOString()}
 ${token}
 `);
@@ -28523,7 +29146,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();
 }
@@ -28562,7 +29185,7 @@ function releaseInstallLock(lockKey, acquisitionToken) {
       return;
     }
     try {
-      unlinkSync6(lock);
+      unlinkSync5(lock);
     } catch (unlinkErr) {
       const code = unlinkErr.code;
       if (code !== "ENOENT") {
@@ -28637,7 +29260,7 @@ function claimLspAutoInstallPass() {
     try {
       const fd = openSync8(lock, "wx");
       try {
-        writeFileSync7(fd, JSON.stringify(owner));
+        writeFileSync6(fd, JSON.stringify(owner));
       } finally {
         closeSync9(fd);
       }
@@ -28668,12 +29291,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) {
@@ -28710,7 +29333,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)
@@ -29091,7 +29714,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) {
@@ -29304,7 +29927,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}`);
   }
@@ -29407,12 +30030,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 statSync12,
-  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 resolve11 } from "node:path";
 import { Readable as Readable3 } from "node:stream";
@@ -29538,9 +30161,9 @@ function writeInstallFailureMarker(spec, release, sha256, installError) {
   const tempPath = `${path}.tmp-${process.pid}-${randomBytes3(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 });
@@ -29606,7 +30229,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}`);
   }
@@ -29846,7 +30469,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 {
@@ -29875,7 +30498,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;
@@ -29901,7 +30524,7 @@ function validateExtraction(stagingRoot) {
       }
       let realFull;
       try {
-        realFull = realpathSync5(full);
+        realFull = realpathSync6(full);
       } catch (err) {
         throw new Error(`failed to realpath ${full}: ${err}`);
       }
@@ -29929,14 +30552,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) {
@@ -29950,7 +30589,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")) {
@@ -29963,7 +30602,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)
@@ -29974,11 +30613,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)
@@ -30005,7 +30644,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 });
@@ -30020,7 +30659,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}`);
   }
@@ -30112,7 +30751,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 };
   }
@@ -30123,7 +30762,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.`);
     try {
-      unlinkSync7(archivePath);
+      unlinkSync6(archivePath);
     } catch {}
     return { ok: false, sha256: archiveSha256, error: message };
   }
@@ -30135,7 +30774,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));
@@ -31571,11 +32210,6 @@ PDFs aren't supported on the Pi harness yet.`, response);
             restrictToProjectRoot: surface.restrictToProjectRoot
           });
         }
-        const preview = await callToolCallForSession(bridge, "edit", rawArgs, sessionId, extCtx, {
-          preview: true
-        });
-        if (preview.success === false)
-          throw toolErrorFromResponse("edit", preview);
         const response = await callToolCallForSession(bridge, "edit", rawArgs, sessionId, extCtx);
         if (response.success === false)
           throw toolErrorFromResponse("edit", response);
@@ -31718,7 +32352,7 @@ function buildMutationResult(response) {
   let text = response.text;
   if (typeof text !== "string") {
     text = formatEditSummary(response);
-    if (noOp) {
+    if (noOp && response.rolled_back !== true) {
       text += `
 
 Note: no net file change — the match was found and applied, but the file content is byte-identical to before. Likely causes: oldString and newString are identical, or a formatter normalized the change away.`;
@@ -32190,7 +32824,7 @@ var BashBackgroundTimeoutParam = {
 };
 var BashWaitParam = {
   wait: Type5.Optional(Type5.Boolean({
-    description: "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); any new message detaches by default, while `bash.detach_on_user_message: false` keeps it blocking unless the message contains the literal `&detach`. The token is stripped before delivery; the rest of the message is preserved, and a token-only message becomes `(requested background detach)`. Use only when you know the result is required before doing anything else."
+    description: "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); any new message detaches by default, while `bash.detach_on_user_message: false` keeps it blocking unless the message contains the literal `&detach`. The token is stripped before delivery; the rest of the message is preserved, and a token-only message becomes `(requested background detach)`. Use only when you know the result is required before doing anything else."
   }))
 };
 var BashSandboxParam = {
@@ -32453,7 +33087,7 @@ function registerBashTool(pi, ctx, aftSearchRegistered = false, registeredName =
     "PTY mode"
   ].join(", ") : bashCfg.compress ? "workdir and compressed output" : "workdir";
   const detachSentence = bashCfg.detach_on_user_message ? "Any new message detaches this wait. Set `bash.detach_on_user_message: false` to keep it blocking; even then, a message containing the literal `&detach` forces detachment, and the token is stripped before delivery; the rest of the message is preserved, while a token-only message becomes `(requested background detach)`." : "Because `bash.detach_on_user_message` is false, a new message leaves this wait blocking; include the literal `&detach` anywhere to force detachment, and the token is stripped before delivery; the rest of the message is preserved, while a token-only message becomes `(requested background detach)`.";
-  const tasksSentence = bashCfg.background ? ` 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); ${detachSentence} Use it when you need the result before doing anything else; keep it off otherwise so auto-promote can remind you while you work. Use \`background: true\` yourself ONLY when you have other useful work to do while it runs; ${backgroundWaitSentence(companions)} 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(companions)}.` : " Commands run in the foreground to completion; `timeout` is the hard kill cap (default 30 minutes).";
+  const tasksSentence = bashCfg.background ? ` 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); ${detachSentence} Use it when you need the result before doing anything else; keep it off otherwise so auto-promote can remind you while you work. Use \`background: true\` yourself ONLY when you have other useful work to do while it runs; ${backgroundWaitSentence(companions)} 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(companions)}.` : " Commands run in the foreground to completion; `timeout` is the hard kill cap (default 30 minutes).";
   const remoteRuns = () => !isPowerShell && remoteRunsOffered(ctx.config);
   pi.registerTool({
     name: registeredName,
@@ -32509,7 +33143,7 @@ DO NOT use bash for code search or code exploration. If you are about to run gre
       const blockToCompletion = backgroundDisabled || requestedWait || workerForcedForeground;
       const effectiveBackground = !blockToCompletion && (rawRequestedBackground || requestedPty);
       const isWorker = isPiWorkerSession(extCtx);
-      const workerWaitMaxMs = isWorker ? bashCfg.worker_wait_max_ms : undefined;
+      const workerWaitMaxMs = bashCfg.worker_wait_max_ms;
       let spawnContext = {
         command: params.command,
         cwd: params.workdir
@@ -33064,7 +33698,10 @@ async function formatBashStatus(extCtx, taskId, details, requestedOutputMode, wa
   if (details.live_descendants_summary) {
     text += ` · ${details.live_descendants_summary}`;
   }
-  if (details.output_incomplete) {
+  if (details.remote_phase_note && !details.waited) {
+    text += ` · ${details.remote_phase_note}`;
+  }
+  if (details.output_incomplete || details.status === "failed" && details.status_reason) {
     text += `
 [${details.status_reason || "PTY output may be incomplete"}]`;
   }
@@ -33570,10 +34207,16 @@ import { Type as Type9 } from "typebox";
 var INSPECT_TRANSPORT_HEADROOM_MS = 30000;
 var InspectParams = Type9.Object({
   sections: Type9.Optional(Type9.Union([Type9.String(), Type9.Array(Type9.String())], {
-    description: "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."
+    description: "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: Type9.Optional(Type9.Union([Type9.String(), Type9.Array(Type9.String())], {
-    description: "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."
+    description: "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: Type9.Optional(Type9.Integer({
+    minimum: 0,
+    maximum: Number.MAX_SAFE_INTEGER,
+    default: 0,
+    description: "Rows to skip independently in each drill-down list. Default 0; follow next_offset in each list envelope."
   })),
   topK: Type9.Optional(Type9.Integer({
     minimum: 1,
@@ -33885,7 +34528,7 @@ function registerInspectTool(pi, ctx) {
   pi.registerTool({
     name: "aft_inspect",
     label: "inspect",
-    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.",
     parameters: InspectParams,
@@ -33901,6 +34544,8 @@ function registerInspectTool(pi, ctx) {
         rawArgs.scope = scope;
       if (topK !== undefined)
         rawArgs.topK = topK;
+      if (params.offset !== undefined)
+        rawArgs.offset = params.offset;
       const response = await callToolCall(bridge, "inspect", rawArgs, extCtx, {
         transportTimeoutMs: resolveInspectDiagnosticsTimeoutMs(ctx.config) + INSPECT_TRANSPORT_HEADROOM_MS
       });
@@ -35115,6 +35760,7 @@ function startPiLiveConfigReload(options) {
   const { userConfigPath, projectConfigPath } = resolveCortexKitConfigPaths(options.directory);
   return startLiveConfigReload({
     paths: [userConfigPath, projectConfigPath],
+    projectPath: projectConfigPath,
     load: () => loadPiConfigForLiveReload(options.directory),
     initialSources: options.initialSources,
     initialProjectText: options.initialSourceTexts?.[projectConfigPath] ?? null,
@@ -35411,11 +36057,11 @@ var PLUGIN_VERSION = (() => {
     return "0.0.0";
   }
 })();
-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 pendingEagerWarnings = new Map;