@cortexkit/aft-pi 0.63.5 → 0.64.0

package/dist/index.js

@@ -7871,7 +7871,7 @@ var require_src2 = __commonJS(function(exports, module) {
 });
 
 // src/index.ts
-import { createRequire as createRequire2 } from "node:module";
+import { createRequire as createRequire3 } from "node:module";
 
 // ../aft-bridge/dist/active-logger.js
 var ACTIVE_LOGGER_SYMBOL = Symbol.for("aft-bridge-active-logger");
@@ -8923,9 +8923,10 @@ 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 module connection is down";
-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). `macos` sends the command to a macOS machine for builds and tests that need macOS (no vCPU or network options).';
-var BASH_RETURN_PATHS_DESCRIPTION = "With runon: up to 64 files to copy back from the build server after the command, as paths relative to workdir inside the project (10 MiB in total). Each verified file replaces the local file at the same path; the result lists every path as returned or not returned, with the reason.";
-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 this machine\'s own operating system or hardware (its sandbox, code signing, service manager, permission prompts or GUI frameworks) or runs a binary that already exists on this machine; a build or test that needs only macOS (its sandbox, code signing or file watching) can use runon: "macos" instead; building and testing still go remote, and 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.';
+var BASH_RUNON_MEMORY_DESCRIPTION = "On Linux, add `,Ngb` to ask for N GiB of memory, for example `linux,2c,16gb` for a Rust build.";
+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). `macos` sends the command to a macOS machine for builds and tests that need macOS (no vCPU or network options).' + ` ${BASH_RUNON_MEMORY_DESCRIPTION}`;
+var BASH_RETURN_PATHS_DESCRIPTION = "With runon: up to 64 files to copy back from the build server after the command, as paths relative to workdir inside the project (up to 128 MiB in total). Each verified file replaces the local file at the same path; the result lists every path as returned or not returned, with the reason.";
+var BASH_RUNON_GUIDANCE = 'When remote runs are available, put `runon: "linux"` on build and test lines (cargo, bun test), including chains and pipes. A runon job\'s file changes are not copied back; only output, the exit code and return_paths files return. Edit locally first; name a file in return_paths to regenerate it remotely. Keep git, gh, interactive and file-editing commands local, and keep a line local if it needs this machine\'s own operating system or hardware (its sandbox, code signing, service manager, permission prompts or GUI frameworks) or runs a binary that already exists on this machine; a build or test that needs only macOS (its sandbox, code signing or file watching) can use runon: "macos" instead; building and testing still go remote, and 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";
 }
@@ -9180,6 +9181,7 @@ function bashAcksConfirmed(response, targets) {
 }
 // ../aft-bridge/dist/bash-permissions.js
 var BASH_PERMISSION_NOT_SETTLED = "bash permission not settled after {rounds} rounds: still asking for {kind} {path} (operation: {operation}; granted already: {granted})";
+var BASH_PERMISSION_DENIED = "Permission denied for this shell command: {parts} ({host reason}). The parts are checked together, so one denied part denies the whole command; run the allowed parts in a separate call.";
 
 class BashPermissionLoopError extends Error {
 }
@@ -9197,6 +9199,10 @@ ${ask.command ?? ""}
 Working directory:
 ${ask.cwd ?? ""}`;
 }
+function permissionAskPath(ask) {
+  const paths = ask.patterns?.length ? ask.patterns : bashPermissionRetryGrants(ask);
+  return ask.kind === "escalation" && ask.command ? `${ask.command}${ask.cwd ? ` @ ${ask.cwd}` : ""}` : paths.length ? paths.join(", ") : "<no asks returned>";
+}
 async function withBashPermissionLoop(options) {
   const granted = new Set;
   const alreadyGranted = (ask) => {
@@ -9218,20 +9224,22 @@ async function withBashPermissionLoop(options) {
         already_granted: alreadyGranted(ask)
       }))
     });
-    const unsettled = (cause) => {
+    const unsettled = () => {
       const message = (asks.length ? asks : [{}]).map((ask) => {
-        const paths = ask.patterns?.length ? ask.patterns : bashPermissionRetryGrants(ask);
-        const path = ask.kind === "escalation" && ask.command ? `${ask.command}${ask.cwd ? ` @ ${ask.cwd}` : ""}` : paths.length ? paths.join(", ") : "<no asks returned>";
-        return BASH_PERMISSION_NOT_SETTLED.replace("{rounds}", String(round)).replace("{kind}", ask.kind ?? "unknown").replace("{operation}", ask.operation ?? options.operation ?? "bash").replace("{granted}", alreadyGranted(ask) ? "yes" : "no").replace("{path}", () => path);
+        return BASH_PERMISSION_NOT_SETTLED.replace("{rounds}", String(round)).replace("{kind}", ask.kind ?? "unknown").replace("{operation}", ask.operation ?? options.operation ?? "bash").replace("{granted}", alreadyGranted(ask) ? "yes" : "no").replace("{path}", () => permissionAskPath(ask));
       }).join("; ");
-      return new BashPermissionLoopError(cause instanceof Error ? `${message}: ${cause.message}` : message, { cause });
+      return new BashPermissionLoopError(message);
     };
     if (asks.length === 0 || asks.every(alreadyGranted) || round >= 8)
       throw unsettled();
+    const pendingAsks = asks.filter((ask) => !alreadyGranted(ask));
     try {
-      await options.approve(asks.filter((ask) => !alreadyGranted(ask)));
+      await options.approve(pendingAsks);
     } catch (error) {
-      throw unsettled(error);
+      const parts = pendingAsks.map(permissionAskPath).join(", ");
+      const reason = error instanceof Error && error.message ? error.message.trim().replace(/\.$/, "") : "";
+      const message = reason ? BASH_PERMISSION_DENIED.replace("{host reason}", () => reason) : BASH_PERMISSION_DENIED.replace(" ({host reason})", "");
+      throw new BashPermissionLoopError(message.replace("{parts}", () => parts), { cause: error });
     }
     for (const ask of asks) {
       for (const grant of bashPermissionRetryGrants(ask))
@@ -11309,15 +11317,57 @@ function hubSummaryLine(response, theme) {
   const message = summary ? asString(summary.message) : undefined;
   return message ? theme.fg("warning", message) : undefined;
 }
+var ROOT_KINDS = ["main", "test", "attribute", "public_api", "no_caller_found"];
+var ROOT_LABELS = {
+  main: "main",
+  test: "test",
+  attribute: "attribute",
+  public_api: "public API",
+  no_caller_found: "no caller found"
+};
+function rootCounted(kind, count) {
+  const plural = count === 1 ? "" : "s";
+  switch (kind) {
+    case "main":
+      return count === 1 ? "main" : `${count} main functions`;
+    case "test":
+      return `${count} test${plural}`;
+    case "attribute":
+      return `${count} function${plural} with an entry attribute`;
+    case "public_api":
+      return `${count} public API function${plural}`;
+    default:
+      return `${count} function${plural} with no caller found`;
+  }
+}
+function rootSummary(record) {
+  const counts = asRecord(record.root_counts);
+  if (!counts)
+    return;
+  const parts = ROOT_KINDS.flatMap((kind) => {
+    const count = asNumber(counts[kind]);
+    return count && count > 0 ? [rootCounted(kind, count)] : [];
+  });
+  return parts.length > 0 ? parts.join(", ") : undefined;
+}
+function rootTag(record) {
+  const kind = asString(record.root);
+  const label = kind ? ROOT_LABELS[kind] : undefined;
+  if (!kind || !label)
+    return;
+  const attribute = asString(record.attribute);
+  return kind === "attribute" && attribute ? `[root: attribute ${attribute}]` : `[root: ${label}]`;
+}
 function renderTracePath(path, index, lines, theme) {
   lines.push(`Path ${index + 1}`);
+  const root = rootTag(path);
   asRecords(path.hops).forEach((hop, hopIndex) => {
     const symbol = asString(hop.symbol) ?? "(unknown)";
     const file = shortenHomePath(asString(hop.file) ?? "(unknown file)");
     const line = asNumber(hop.line);
-    const entry = hop.is_entry_point === true ? " [entry]" : "";
+    const tag = hopIndex === 0 ? root ? ` ${theme.fg("warning", root)}` : "" : hop.exported === true ? " [exported]" : "";
     const nameMatch = nameMatchEdgeMarker(hop, theme);
-    lines.push(treeLine(hopIndex + 1, `${symbol}${entry} ${line !== undefined ? `[${file}:${line}]` : `[${file}]`}${nameMatch}`));
+    lines.push(treeLine(hopIndex + 1, `${symbol}${tag} ${line !== undefined ? `[${file}:${line}]` : `[${file}]`}${nameMatch}`));
   });
 }
 function renderCallersGroupLines(group, theme, callbackLabel) {
@@ -11422,18 +11472,18 @@ function formatCallgraphSections(op, response, theme = PLAIN_CALLGRAPH_THEME, op
     const hubSummary = hubSummaryLine(record, theme);
     const totalPaths = asNumber(record.total_paths) ?? paths.length;
     const totalPathsIsLowerBound = asBoolean(record.total_paths_is_lower_bound) ?? false;
-    const entryPoints = asNumber(record.entry_points_found) ?? 0;
+    const roots = rootSummary(record);
     const sections = [
       joinNonEmpty([
         theme.fg("success", `${totalPathsIsLowerBound ? "at least " : ""}${totalPaths} path${totalPaths === 1 ? "" : "s"}`),
-        theme.fg("muted", `${entryPoints} entry point${entryPoints === 1 ? "" : "s"}`),
+        roots ? theme.fg("muted", `roots: ${roots}`) : undefined,
         warning
       ])
     ];
     if (hubSummary)
       sections.push(hubSummary);
     if (paths.length === 0)
-      sections.push(theme.fg("muted", "No entry paths found."));
+      sections.push(theme.fg("muted", "No paths found."));
     paths.forEach((path, index) => {
       const lines = [];
       renderTracePath(path, index, lines, theme);
@@ -11466,13 +11516,17 @@ function formatCallgraphSections(op, response, theme = PLAIN_CALLGRAPH_THEME, op
       sections.unshift(theme.fg("warning", testFilterNote));
     if (hubSummary)
       sections.push(hubSummary);
+    const roots = rootSummary(record);
+    if (roots)
+      sections.push(theme.fg("muted", `Reaches ${roots}`));
     if (callers.length === 0)
       sections.push(theme.fg("muted", "No impacted callers found."));
     callers.forEach((caller) => {
       const file = shortenHomePath(asString(caller.caller_file) ?? "(unknown file)");
       const symbol = asString(caller.caller_symbol) ?? "(unknown)";
       const line = asNumber(caller.line) ?? 0;
-      const entry = caller.is_entry_point === true ? ` ${theme.fg("warning", "[entry]")}` : "";
+      const root = rootTag(caller);
+      const entry = root ? ` ${theme.fg("warning", root)}` : "";
       const nameMatch = nameMatchEdgeMarker(caller, theme);
       const reference = caller.relation === "callback_reference" ? asString(record.callback_reference_label) ?? "" : "";
       const expression = asString(caller.call_expression);
@@ -11758,8 +11812,9 @@ function formatDroppedKeyWarnings(dropped) {
   return dropped.map((item) => `Ignoring ${item.key} from ${item.tier} config (${item.reason})`);
 }
 // ../aft-bridge/dist/config-watch.js
-import { readFileSync as readFileSync3, statSync as statSync3, watch } from "node:fs";
-import { basename, dirname as dirname2 } from "node:path";
+import { createHash as createHash2 } from "node:crypto";
+import { closeSync as closeSync2, fstatSync, openSync as openSync2, readFileSync as readFileSync3, readSync as readSync2, realpathSync as realpathSync2, statSync as statSync3, watch } from "node:fs";
+import { basename, dirname as dirname2, resolve as resolve5 } from "node:path";
 var CONFIG_WATCH_DEBOUNCE_MS = 150;
 var CONFIG_LIVE_KEEP_NOTE = "AFT keeps using the last valid configuration until the file is fixed.";
 function pathKey(name) {
@@ -11813,7 +11868,6 @@ function aftLiveConfigKeys(resolveBash) {
     pathKey("restrict_to_project_root"),
     pathKey("revision_reads"),
     pathKey("inspect.diagnostics_timeout_ms"),
-    pathKey("inspect.tier2_idle_minutes"),
     pathKey("lsp.idle_minutes"),
     ...[
       "diagnostics",
@@ -11885,6 +11939,29 @@ function readTextOrNull(path) {
 var CONFIG_WATCH_REVALIDATE_MS = 2000;
 var CONFIG_WATCH_REJECTED_RETRIES = 3;
 var CONFIG_WATCH_MAX_DELAY_MS = 1000;
+var CONFIG_READ_LIMIT = 1024 * 1024;
+function contentFingerprint(path) {
+  let fd;
+  try {
+    fd = openSync2(path, "r");
+    const metadata = fstatSync(fd, { bigint: true });
+    const bytes = Buffer.alloc(Math.min(Number(metadata.size), CONFIG_READ_LIMIT));
+    let offset = 0;
+    while (offset < bytes.length) {
+      const read = readSync2(fd, bytes, offset, bytes.length - offset, null);
+      if (read === 0)
+        break;
+      offset += read;
+    }
+    const hash = createHash2("sha256").update(bytes.subarray(0, offset)).digest("hex");
+    return `${metadata.size}:${metadata.mtimeNs}:${hash}`;
+  } catch {
+    return null;
+  } finally {
+    if (fd !== undefined)
+      closeSync2(fd);
+  }
+}
 function identityOf(dir) {
   try {
     const stat = statSync3(dir, { bigint: true });
@@ -11900,6 +11977,13 @@ function watchDirFor(file) {
     dir = dirname2(dir);
   return dir;
 }
+function canonicalDirectory(dir) {
+  try {
+    return realpathSync2(dir);
+  } catch {
+    return resolve5(dir);
+  }
+}
 function watchAftConfigFiles(options) {
   const debounceMs = options.debounceMs ?? CONFIG_WATCH_DEBOUNCE_MS;
   const lastSeen = new Map;
@@ -11913,6 +11997,8 @@ function watchAftConfigFiles(options) {
   let firstPendingAt = null;
   let stopped = false;
   const watchers = new Map;
+  const targets = new Map;
+  const fallbackSeen = new Map;
   const watchImpl = options.watchImpl ?? watch;
   let rejectedRetries = 0;
   const check = () => {
@@ -11966,8 +12052,34 @@ function watchAftConfigFiles(options) {
     timer.unref?.();
   };
   function revalidate() {
-    const wanted = new Set(options.paths.map(watchDirFor));
+    const wanted = new Set;
+    const wantedCanonical = new Set;
+    const wantDirectory = (dir) => {
+      const canonical = canonicalDirectory(dir);
+      if (wantedCanonical.has(canonical))
+        return;
+      wantedCanonical.add(canonical);
+      wanted.add(dir);
+    };
+    for (const path of options.paths)
+      wantDirectory(watchDirFor(path));
     let moved = false;
+    for (const path of options.paths) {
+      try {
+        const resolved = realpathSync2(path);
+        const target = resolved === resolve5(path) ? undefined : resolved;
+        if (targets.get(path) !== target) {
+          if (target)
+            targets.set(path, target);
+          else
+            targets.delete(path);
+          fallbackSeen.delete(path);
+          moved = true;
+        }
+      } catch {}
+    }
+    for (const target of targets.values())
+      wantDirectory(watchDirFor(target));
     for (const [dir, entry] of watchers) {
       if (!wanted.has(dir) || entry.stale || identityOf(dir) !== entry.identity) {
         entry.watcher.close();
@@ -12006,6 +12118,17 @@ function watchAftConfigFiles(options) {
         moved = true;
       } catch {}
     }
+    const watchedCanonical = new Set(Array.from(watchers.keys(), canonicalDirectory));
+    for (const [path, target] of targets) {
+      if (watchedCanonical.has(canonicalDirectory(dirname2(target)))) {
+        fallbackSeen.delete(path);
+        continue;
+      }
+      const fingerprint = contentFingerprint(path);
+      if (!fallbackSeen.has(path) || fallbackSeen.get(path) !== fingerprint)
+        moved = true;
+      fallbackSeen.set(path, fingerprint);
+    }
     return moved;
   }
   revalidate();
@@ -12162,8 +12285,8 @@ function startLiveConfigReload(options) {
   return { reload, stop };
 }
 // ../aft-bridge/dist/downloader.js
-import { createHash as createHash2, randomUUID } from "node:crypto";
-import { chmodSync, closeSync as closeSync2, copyFileSync, createWriteStream, existsSync as existsSync3, mkdirSync as mkdirSync2, openSync as openSync2, readdirSync, readFileSync as readFileSync4, renameSync as renameSync2, rmSync, statSync as statSync4, unlinkSync as unlinkSync2, writeSync } from "node:fs";
+import { createHash as createHash3, randomUUID } from "node:crypto";
+import { chmodSync, closeSync as closeSync3, copyFileSync, createWriteStream, existsSync as existsSync3, mkdirSync as mkdirSync2, openSync as openSync3, readdirSync, readFileSync as readFileSync4, renameSync as renameSync2, rmSync, statSync as statSync4, unlinkSync as unlinkSync2, writeSync } from "node:fs";
 import { hostname } from "node:os";
 import { join as join8 } from "node:path";
 import { Readable } from "node:stream";
@@ -12381,7 +12504,7 @@ async function downloadBinary(version) {
       warn(`Checksum verification failed: checksums.sha256 found but no entry for ${assetName}. ` + "Binary download aborted for security reasons.");
       return null;
     }
-    const hash = createHash2("sha256");
+    const hash = createHash3("sha256");
     let bytesWritten = 0;
     const guard = new TransformStream({
       transform(chunk, controller) {
@@ -12548,11 +12671,11 @@ async function acquireDownloadLock(lockPath, timing = {}) {
   while (true) {
     try {
       const owner = createDownloadLockOwner();
-      const fd = openSync2(lockPath, "wx");
+      const fd = openSync3(lockPath, "wx");
       try {
         writeSync(fd, owner);
       } finally {
-        closeSync2(fd);
+        closeSync3(fd);
       }
       return () => {
         try {
@@ -12623,8 +12746,8 @@ import { appendFile, lstat, mkdir, open, rename, rm, stat } from "node:fs/promis
 import { dirname as dirname3 } from "node:path";
 
 // ../aft-bridge/dist/private-storage.js
-import { closeSync as closeSync3, constants, copyFileSync as copyFileSync2, fchmodSync, fstatSync, lstatSync, mkdirSync as mkdirSync3, openSync as openSync3, readSync as readSync2, writeSync as writeSync2 } from "node:fs";
-import { isAbsolute as isAbsolute4, join as join9, parse, relative as relative3, resolve as resolve5, sep } from "node:path";
+import { closeSync as closeSync4, constants, copyFileSync as copyFileSync2, fchmodSync, fstatSync as fstatSync2, lstatSync, mkdirSync as mkdirSync3, openSync as openSync4, readSync as readSync3, writeSync as writeSync2 } from "node:fs";
+import { isAbsolute as isAbsolute4, join as join9, parse, relative as relative3, resolve as resolve6, sep } from "node:path";
 var PRIVATE_FILE_MODE = 384;
 var PRIVATE_DIRECTORY_MODE = 448;
 function privateMkdirSync(path, recursive = true) {
@@ -12638,13 +12761,13 @@ function privateCopyFileSync(source, destination) {
     copyFileSync2(source, destination);
     return;
   }
-  const input = openSync3(source, "r");
+  const input = openSync4(source, "r");
   let output;
   try {
-    output = openSync3(destination, "wx", PRIVATE_FILE_MODE);
+    output = openSync4(destination, "wx", PRIVATE_FILE_MODE);
     const buffer = Buffer.allocUnsafe(64 * 1024);
     for (;; ) {
-      const bytes = readSync2(input, buffer);
+      const bytes = readSync3(input, buffer);
       if (bytes === 0)
         break;
       let offset = 0;
@@ -12652,18 +12775,18 @@ function privateCopyFileSync(source, destination) {
         offset += writeSync2(output, buffer, offset, bytes - offset);
     }
   } finally {
-    closeSync3(input);
+    closeSync4(input);
     if (output !== undefined)
-      closeSync3(output);
+      closeSync4(output);
   }
 }
 var warned = new Set;
 function openPrivateStorageDir(root, path = root) {
-  const base = resolve5(root);
+  const base = resolve6(root);
   if (!root || base === parse(base).root) {
     throw new Error(`refusing filesystem root as private storage: ${base}`);
   }
-  const rel = relative3(base, resolve5(path));
+  const rel = relative3(base, resolve6(path));
   if (rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute4(rel))
     return;
   privateMkdirSync(path);
@@ -12676,8 +12799,8 @@ function openPrivateStorageDir(root, path = root) {
     try {
       if (lstatSync(current).isSymbolicLink())
         return;
-      fd = openSync3(current, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
-      if ((fstatSync(fd).mode & 63) !== 0)
+      fd = openSync4(current, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+      if ((fstatSync2(fd).mode & 63) !== 0)
         fchmodSync(fd, PRIVATE_DIRECTORY_MODE);
     } catch (error) {
       if (!warned.has(current)) {
@@ -12688,7 +12811,7 @@ function openPrivateStorageDir(root, path = root) {
       return;
     } finally {
       if (fd !== undefined)
-        closeSync3(fd);
+        closeSync4(fd);
     }
   }
 }
@@ -13570,7 +13693,7 @@ async function readConnectionFileForUid(path, expectedUid) {
 }
 
 // ../../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";
+import { closeSync as closeSync5, fstatSync as fstatSync3, readSync as readSync4 } from "node:fs";
 var SUBC_LAUNCH_NONCE_ENV = "SUBC_LAUNCH_NONCE";
 var SUBC_LAUNCH_NONCE_FD_ENV = "SUBC_LAUNCH_NONCE_FD";
 class LaunchNonceError extends Error {
@@ -13617,7 +13740,7 @@ class LaunchNonceCell {
   lookup;
   platform;
   stat;
-  constructor(lookup, platform = process.platform, stat = (fd) => fstatSync2(fd, { bigint: true })) {
+  constructor(lookup, platform = process.platform, stat = (fd) => fstatSync3(fd, { bigint: true })) {
     this.lookup = lookup;
     this.platform = platform;
     this.stat = stat;
@@ -13665,7 +13788,7 @@ class LaunchNonceCell {
     const chunk = Buffer.alloc(256);
     let got;
     try {
-      got = readSync3(fd, chunk, 0, chunk.length, null);
+      got = readSync4(fd, chunk, 0, chunk.length, null);
     } catch (error) {
       if (isWouldBlock(error))
         throw emptyError(fd);
@@ -13677,7 +13800,7 @@ class LaunchNonceCell {
     const parts = [Buffer.from(chunk.subarray(0, got))];
     try {
       for (;; ) {
-        const n = readSync3(fd, chunk, 0, chunk.length, null);
+        const n = readSync4(fd, chunk, 0, chunk.length, null);
         if (n === 0)
           break;
         parts.push(Buffer.from(chunk.subarray(0, n)));
@@ -13754,7 +13877,7 @@ function errnoOf(error) {
 }
 function closeQuietly(fd) {
   try {
-    closeSync4(fd);
+    closeSync5(fd);
   } catch {}
 }
 
@@ -15629,15 +15752,15 @@ function getLifecycleRegistry() {
 }
 
 // ../aft-bridge/dist/project-identity.js
-import { realpathSync as realpathSync2 } from "node:fs";
-import { posix as posix2, resolve as resolve6, win32 as win322 } from "node:path";
+import { realpathSync as realpathSync3 } from "node:fs";
+import { posix as posix2, resolve as resolve7, win32 as win322 } from "node:path";
 function canonicalizeProjectRoot(dir) {
   const trimmed = trimProjectRootSeparators(dir);
   let canonical;
   try {
-    canonical = realpathSync2(trimmed);
+    canonical = realpathSync3(trimmed);
   } catch {
-    canonical = resolve6(trimmed);
+    canonical = resolve7(trimmed);
   }
   return normalizeWindowsRoot(canonical);
 }
@@ -17617,7 +17740,9 @@ class SubcTransportPool {
         });
         retry = state.bindPending;
       } else {
-        retry = this.hostScope(client, record.identity);
+        retry = this.hostScope(client, record.identity).finally(() => {
+          this.scheduleHostScopeRetry(session, state);
+        });
       }
       retry.catch((error) => {
         warn(`subc head scope: session=${session} background retry failed code=${error instanceof Error ? error.name : "Error"}`);
@@ -17785,12 +17910,18 @@ class SubcTransportPool {
     }
     return this.openScopedHostToolRoute(client, identity, record, entry, channel);
   }
-  bindHostToolRoute(client, identity, channel, reason, scope) {
+  async bindHostToolRoute(client, identity, channel, reason, scope) {
     log(`subc head scope: session=${identity.session} bind=${scope ? "scoped" : "unscoped"} channel=${channel} root=${identity.project_root} reason=${reason}` + (scope ? ` ref=${scope.ref.slice(0, 8)} epoch=${scope.scopeEpoch}` : ""));
-    return client.routeOpen({ kind: "tool_provider", module_id: AFT_MODULE_ID }, identity, {
+    const route = await client.routeOpen({ kind: "tool_provider", module_id: AFT_MODULE_ID }, identity, {
       consumerIdentity: this.consumerIdentity,
       ...scope ? { scope } : {}
     });
+    const state = this.hostScopeCache.get(identity.session);
+    if (scope && state?.unscopedReason && state.answer?.result === "scope" && state.answer.scope === scope) {
+      log(`subc head scope: session=${identity.session} route=upgraded from=unscoped ref=${scope.ref.slice(0, 8)} epoch=${scope.scopeEpoch}`);
+      state.unscopedReason = undefined;
+    }
+    return route;
   }
   async openScopedHostToolRoute(client, identity, record, entry, channel = "tool") {
     const decision = await this.hostScope(client, identity);
@@ -18422,7 +18553,8 @@ function taskIdFromError(error) {
   return;
 }
 // ../aft-bridge/dist/feature-config.js
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
+import { createRequire } from "node:module";
 var CANONICAL_TOOLS = [
   "aft_callgraph",
   "aft_conflicts",
@@ -18472,23 +18604,114 @@ var REMOVED_OPENCODE_PATHS = [
   "opencode.server_url",
   "opencode.server_password_env"
 ];
-function removedConfigKeyErrors(value) {
+var REMOVED_DATA_LAYER_PATHS = [
+  "views.callgraph_copies",
+  "views.enabled",
+  "worktree.ram_overlay"
+];
+var RETIRED_IDLE_CHECKOUT_HOURS = [
+  "views.idle_checkout_hours",
+  "idle.checkout_hours"
+];
+var DATA_LAYER_KEYS_REFUSED_FROM = [0, 65];
+var DATA_LAYER_RETIRED_PATHS = [
+  "views.callgraph_copies",
+  "views.enabled",
+  "views.idle_checkout_hours",
+  "worktree.ram_overlay"
+];
+var IDLE_CHECKOUT_HOURS_DEFAULT = 168;
+var IDLE_CHECKOUT_HOURS_MIN = 1;
+var IDLE_CHECKOUT_HOURS_MAX = 24 * 365;
+function parseRelease(version) {
+  const match = /^(\d+)\.(\d+)(?:\.|$)/.exec(version);
+  return match ? [Number(match[1]), Number(match[2])] : undefined;
+}
+var AFT_PACKAGE_NAMES = new Set([
+  "@cortexkit/aft-bridge",
+  "@cortexkit/aft-opencode",
+  "@cortexkit/aft-pi",
+  "@cortexkit/aft"
+]);
+function readRunningRelease() {
+  const req = createRequire(import.meta.url);
+  for (const candidate of ["../package.json", "../../package.json", "../../../package.json"]) {
+    try {
+      const manifest = req(candidate);
+      if (manifest.name && AFT_PACKAGE_NAMES.has(manifest.name) && manifest.version) {
+        return parseRelease(manifest.version) ?? [0, 0];
+      }
+    } catch {}
+  }
+  return [0, 0];
+}
+var runningRelease;
+function getRunningRelease() {
+  runningRelease ??= readRunningRelease();
+  return runningRelease;
+}
+function releaseAtLeast(release, floor) {
+  return release[0] !== floor[0] ? release[0] > floor[0] : release[1] >= floor[1];
+}
+function refusedFromVersion() {
+  return `${DATA_LAYER_KEYS_REFUSED_FROM[0]}.${DATA_LAYER_KEYS_REFUSED_FROM[1]}.0`;
+}
+function removedConfigKeyErrors(value, release = getRunningRelease(), refuseRetired = true) {
   if (!isRecord2(value))
     return [];
-  const errors = removedOpencodeKeyErrors(value);
+  const errors = removedBlockKeyErrors(value, release, refuseRetired);
   if (isRecord2(value.harnesses)) {
     for (const [name, block] of Object.entries(value.harnesses)) {
       if (!isRecord2(block))
         continue;
-      for (const error of removedOpencodeKeyErrors(block)) {
+      for (const error of removedBlockKeyErrors(block, release, refuseRetired)) {
         errors.push(error.replace("removed_config_key:", `removed_config_key:harnesses.${name}.`));
       }
     }
   }
   return errors;
 }
-function removedOpencodeKeyErrors(value) {
-  return REMOVED_OPENCODE_PATHS.filter((path) => hasPath(value, path)).map((path) => `removed_config_key:${path}; run aft doctor --fix`);
+function removedBlockKeyErrors(value, release, refuseRetired) {
+  const paths = REMOVED_OPENCODE_PATHS.filter((path) => hasPath(value, path));
+  if (refuseRetired)
+    paths.push(...refusedRetiredNames(value));
+  if (releaseAtLeast(release, DATA_LAYER_KEYS_REFUSED_FROM))
+    paths.push(...DATA_LAYER_RETIRED_PATHS.filter((path) => hasPath(value, path)));
+  return paths.map((path) => `removed_config_key:${path}; run npx @cortexkit/aft doctor --fix`);
+}
+var REFUSED_RETIRED_PATHS = [
+  "sandbox.enabled",
+  "tool_surface",
+  "hoist_builtin_tools",
+  "enabled",
+  "search_index",
+  "experimental_search_index",
+  "semantic_search",
+  "experimental_semantic_search",
+  "callgraph_store",
+  "github.enabled",
+  "gh_read",
+  "gh_shim.enabled",
+  "experimental_lsp_ty",
+  "experimental_bash_rewrite",
+  "experimental_bash_compress",
+  "experimental_bash_background",
+  "experimental.bash",
+  "idle.lsp_ttl_minutes",
+  "inspect.tier2_soft_deadline_ms",
+  "inspect.max_drill_down_items"
+];
+function refusedRetiredNames(block) {
+  const names = REFUSED_RETIRED_PATHS.filter((path) => hasPath(block, path));
+  if (Array.isArray(block.disabled_tools)) {
+    for (const name of block.disabled_tools) {
+      if (typeof name !== "string" || !Object.hasOwn(LEGACY_TOOL_ALIASES, name))
+        continue;
+      if (!names.includes(name))
+        names.push(name);
+    }
+  }
+  return names;
 }
 var RETIRED_PATHS = [
   ["sandbox.enabled", "sandbox.profile"],
@@ -18643,7 +18866,10 @@ function translateInspectLspPaths(map, prefix, out) {
       recordRetired(out, prefix, `inspect.${leaf}`);
   }
 }
-var REMOVED_NO_EFFECT_PATHS = ["bridge.hang_threshold"];
+var REMOVED_NO_EFFECT_PATHS = [
+  "bridge.hang_threshold",
+  "inspect.tier2_idle_minutes"
+];
 function dropNoEffectPaths(map, prefix, out) {
   for (const path of REMOVED_NO_EFFECT_PATHS) {
     const [container, leaf] = path.split(".");
@@ -18652,6 +18878,29 @@ function dropNoEffectPaths(map, prefix, out) {
     }
   }
 }
+function retiredIdleCheckoutHours(value) {
+  const raw = typeof value === "number" && Number.isSafeInteger(value) ? value : IDLE_CHECKOUT_HOURS_DEFAULT;
+  return Math.min(IDLE_CHECKOUT_HOURS_MAX, Math.max(IDLE_CHECKOUT_HOURS_MIN, raw));
+}
+function translateDataLayerPaths(map, prefix, out) {
+  const [retired, replacement] = RETIRED_IDLE_CHECKOUT_HOURS;
+  const hours = takeNested(map, "views", "idle_checkout_hours");
+  if (hours.found) {
+    recordRetired(out, prefix, retired);
+    if (isRecord2(map.idle) && map.idle.checkout_hours !== undefined) {
+      superseded(out, `${prefix}${retired}`, `${retired} is ignored because ${replacement} is set`);
+    } else {
+      if (!Object.hasOwn(map, "idle"))
+        map.idle = {};
+      if (isRecord2(map.idle))
+        map.idle.checkout_hours = retiredIdleCheckoutHours(hours.value);
+    }
+  }
+  for (const path of REMOVED_DATA_LAYER_PATHS) {
+    if (hasPath(map, path))
+      out.removedKeys.push(`${prefix}${path}`);
+  }
+}
 function translateExperimentalPaths(map, prefix, out) {
   for (const [oldKey, leaf] of [
     ["experimental_lsp_ty", "lsp_ty"],
@@ -18684,23 +18933,25 @@ function translateExperimentalPaths(map, prefix, out) {
   const experimental = map.experimental;
   const legacy = experimental.bash;
   if (isRecord2(legacy)) {
-    if (!["rewrite", "compress", "background"].some((leaf) => Object.hasOwn(legacy, leaf)))
-      return;
+    if (Object.keys(legacy).length === 0)
+      recordRetired(out, prefix, "experimental.bash");
     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
-      };
+      const bash = {};
+      if (["rewrite", "compress", "background"].some((leaf) => Object.hasOwn(legacy, leaf))) {
+        bash.rewrite = legacy.rewrite === true;
+        bash.compress = legacy.compress === true;
+        bash.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;
+      if (Object.keys(bash).length > 0)
+        map.bash = bash;
     }
   } else {
     recordRetired(out, prefix, "experimental.bash");
@@ -18713,6 +18964,7 @@ function translateBlock(map, userBase, blockLabel, out) {
   const prefix = blockLabel === "base" ? "" : `${blockLabel}.`;
   translateGithubAliases(map, prefix, out);
   translateInspectLspPaths(map, prefix, out);
+  translateDataLayerPaths(map, prefix, out);
   dropNoEffectPaths(map, prefix, out);
   translateExperimentalPaths(map, prefix, out);
   if (isRecord2(map.sandbox) && Object.hasOwn(map.sandbox, "enabled")) {
@@ -18751,8 +19003,6 @@ 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);
   }
@@ -18888,13 +19138,57 @@ var NO_EFFECT_RETIRED_NOTES = [
     "inspect.max_drill_down_items",
     "inspect.max_drill_down_items never had an effect, so the setting can be removed."
   ],
+  [
+    "inspect.tier2_idle_minutes",
+    "inspect.tier2_idle_minutes no longer does anything: AFT runs whole-repository analyses only when aft_inspect is called, so the setting can be removed."
+  ],
   [
     "inspect.tier2_soft_deadline_ms",
     "inspect.tier2_soft_deadline_ms never had an effect, so the setting can be removed."
   ]
 ];
 function noEffectNote(key) {
-  return NO_EFFECT_RETIRED_NOTES.find(([path]) => key === path || key.endsWith(`.${path}`))?.[1];
+  return NO_EFFECT_RETIRED_NOTES.find(([path]) => namesPath(key, path))?.[1];
+}
+function namesPath(key, path) {
+  return key === path || key.endsWith(`.${path}`);
+}
+var REMOVED_DATA_LAYER_NOTES = [
+  [
+    "views.callgraph_copies",
+    "views.callgraph_copies is gone because no checkout borrows another checkout's call graph any more."
+  ],
+  [
+    "views.enabled",
+    "views.enabled is gone because AFT now keeps one index store per repository and always uses it."
+  ],
+  [
+    "worktree.ram_overlay",
+    "worktree.ram_overlay is gone because every worktree now has its own index state, so there is no borrowed index to patch in memory."
+  ]
+];
+function retiredIdleCheckoutHoursNote() {
+  const [retired, replacement] = RETIRED_IDLE_CHECKOUT_HOURS;
+  return `${retired} is now ${replacement}; from ${refusedFromVersion()} AFT refuses a config file that still sets ${retired}.`;
+}
+function removedConfigKeysNoticeMessage(configPath, translation) {
+  const removed = translation.removedKeys ?? [];
+  if (removed.length === 0)
+    return "";
+  const parts = [
+    `${configPath} sets removed keys (${removed.join(", ")}); AFT ignores them, and from ${refusedFromVersion()} it refuses a config file that sets them. Run \`npx @cortexkit/aft doctor --fix\` to remove them.`
+  ];
+  for (const [path, note] of REMOVED_DATA_LAYER_NOTES) {
+    if (removed.some((key) => namesPath(key, path)))
+      parts.push(note);
+  }
+  return parts.join(" ");
+}
+function removedConfigKeysNoticeDigest(translation) {
+  return noticeDigest({
+    notice: "removed_data_layer_keys_v1",
+    keys: sortedUnique(translation.removedKeys)
+  });
 }
 function legacyConfigNoticeMessage(configPath, translation) {
   const equivalents = translation.retiredKeys.filter((key) => noEffectNote(key) === undefined);
@@ -18904,11 +19198,17 @@ function legacyConfigNoticeMessage(configPath, translation) {
     parts.push(`${configPath} uses retired keys (${equivalents.join(", ")}); AFT applied their current equivalents, with the same limits a project config has for those keys. Run \`npx @cortexkit/aft doctor --fix\` to update the file.`);
     if (translation.retiredEnabledFalse)
       parts.push(RETIRED_ENABLED_FALSE_INDEXES_NOTE);
+    if (equivalents.some((key) => namesPath(key, RETIRED_IDLE_CHECKOUT_HOURS[0]))) {
+      parts.push(retiredIdleCheckoutHoursNote());
+    }
   }
   for (const [, note] of NO_EFFECT_RETIRED_NOTES) {
     if (noEffect.has(note))
       parts.push(note);
   }
+  const removed = removedConfigKeysNoticeMessage(configPath, translation);
+  if (removed)
+    parts.push(removed);
   return parts.join(" ");
 }
 function translateConfigDocument(map, tier) {
@@ -18916,6 +19216,7 @@ function translateConfigDocument(map, tier) {
     warnings: [],
     legacyInput: false,
     retiredKeys: [],
+    removedKeys: [],
     retiredEnabledFalse: false
   };
   translateBlock(map, tier === "user", "base", out);
@@ -18926,6 +19227,7 @@ function translateConfigDocument(map, tier) {
     }
   }
   out.retiredKeys = sortedUnique(out.retiredKeys);
+  out.removedKeys = sortedUnique(out.removedKeys);
   return out;
 }
 function unknownDisabledTools(disabled) {
@@ -18961,7 +19263,11 @@ function validateResolvedConfig(value) {
 var ABSENT = { absent: true };
 function projectBlock(block) {
   const legacyPaths = {};
-  for (const path of [...RETIRED_PATHS.map(([retired]) => retired), ...REMOVED_NO_EFFECT_PATHS]) {
+  for (const path of [
+    ...RETIRED_PATHS.map(([retired]) => retired),
+    ...REMOVED_NO_EFFECT_PATHS,
+    ...DATA_LAYER_RETIRED_PATHS
+  ]) {
     const dot = path.indexOf(".");
     if (dot < 0) {
       if (Object.hasOwn(block, path))
@@ -19040,7 +19346,7 @@ function canonicalJson(value) {
   return JSON.stringify(value);
 }
 function noticeDigest(projection) {
-  return createHash3("sha256").update(canonicalJson(projection), "utf8").digest("hex");
+  return createHash4("sha256").update(canonicalJson(projection), "utf8").digest("hex");
 }
 var SEMANTIC_COST_NOTICE = "AFT indexes now default on; the local semantic backend may download an ONNX runtime and model and use CPU. Run npx @cortexkit/aft setup to change indexes.semantic.";
 var SEMANTIC_COST_NOTICE_DIGEST = noticeDigest({ notice: "semantic_default_cost_v1" });
@@ -19913,9 +20219,9 @@ async function createConcreteAftTransportPool(opts) {
 var LIFECYCLE_STATE = Symbol.for("@cortexkit/aft-bridge/location-lifecycle/v1");
 var RELEASE_LOCATION = Symbol.for("@cortexkit/aft-bridge/location-release/v1");
 // ../aft-bridge/dist/lsp-github-install.js
-import { createHash as createHash4, randomBytes as randomBytes2 } from "node:crypto";
-import { closeSync as closeSync5, copyFileSync as copyFileSync3, createReadStream as createReadStream2, createWriteStream as createWriteStream2, existsSync as existsSync6, lstatSync as lstatSync2, mkdirSync as mkdirSync4, openSync as openSync4, readdirSync as readdirSync2, readFileSync as readFileSync5, readlinkSync, readSync as readSync4, realpathSync as realpathSync3, renameSync as renameSync3, rmSync as rmSync2, statSync as statSync6, unlinkSync as unlinkSync3, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname4, join as join11, relative as relative4, resolve as resolve7 } from "node:path";
+import { createHash as createHash5, randomBytes as randomBytes2 } from "node:crypto";
+import { closeSync as closeSync6, copyFileSync as copyFileSync3, createReadStream as createReadStream2, createWriteStream as createWriteStream2, existsSync as existsSync6, lstatSync as lstatSync2, mkdirSync as mkdirSync4, openSync as openSync5, readdirSync as readdirSync2, readFileSync as readFileSync5, readlinkSync, readSync as readSync5, realpathSync as realpathSync4, renameSync as renameSync3, rmSync as rmSync2, statSync as statSync6, unlinkSync as unlinkSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname4, join as join11, relative as relative4, resolve as resolve8 } from "node:path";
 import { Readable as Readable2 } from "node:stream";
 import { pipeline as pipeline2 } from "node:stream/promises";
 
@@ -20312,7 +20618,7 @@ function createGithubInstaller(services) {
   const MAX_EXTRACT_BYTES = 1024 * 1024 * 1024;
   function sha256OfFile(path) {
     return new Promise((resolve, reject) => {
-      const hash = createHash4("sha256");
+      const hash = createHash5("sha256");
       const stream = createReadStream2(path);
       stream.on("error", reject);
       stream.on("data", (chunk) => hash.update(chunk));
@@ -20320,17 +20626,17 @@ function createGithubInstaller(services) {
     });
   }
   function sha256OfFileSync(path) {
-    const hash = createHash4("sha256");
-    const fd = openSync4(path, "r");
+    const hash = createHash5("sha256");
+    const fd = openSync5(path, "r");
     try {
       const buffer = Buffer.allocUnsafe(1024 * 1024);
-      let read = readSync4(fd, buffer, 0, buffer.length, null);
+      let read = readSync5(fd, buffer, 0, buffer.length, null);
       while (read > 0) {
         hash.update(buffer.subarray(0, read));
-        read = readSync4(fd, buffer, 0, buffer.length, null);
+        read = readSync5(fd, buffer, 0, buffer.length, null);
       }
     } finally {
-      closeSync5(fd);
+      closeSync6(fd);
     }
     return hash.digest("hex");
   }
@@ -20538,7 +20844,7 @@ function createGithubInstaller(services) {
     throw new Error(`too many redirects (>${maxRedirects})`);
   }
   function validateExtraction(stagingRoot) {
-    const realStagingRoot = realpathSync3(stagingRoot);
+    const realStagingRoot = realpathSync4(stagingRoot);
     let totalBytes = 0;
     const walk = (dir) => {
       let entries;
@@ -20564,12 +20870,12 @@ function createGithubInstaller(services) {
         }
         let realFull;
         try {
-          realFull = realpathSync3(full);
+          realFull = realpathSync4(full);
         } catch (err) {
           throw new Error(`failed to realpath ${full}: ${err}`);
         }
         const rel = relative4(realStagingRoot, realFull);
-        if (relativePathEscapesRoot(rel) || resolve7(realStagingRoot, rel) !== realFull) {
+        if (relativePathEscapesRoot(rel) || resolve8(realStagingRoot, rel) !== realFull) {
           throw new Error(`archive entry escapes staging root: ${full} → ${realFull} (zip-slip defense)`);
         }
         if (lst.isDirectory()) {
@@ -21332,6 +21638,21 @@ function resolveNpm(deps = defaultDeps()) {
   }
   return null;
 }
+function npmCandidates(deps = defaultDeps()) {
+  const name = npmBinaryName(deps.platform);
+  const dirs = [
+    ...(deps.env.PATH ?? "").split(deps.platform === "win32" ? ";" : ":").filter(isAbsolute5),
+    dirname5(deps.execPath),
+    ...wellKnownNpmDirs(deps)
+  ];
+  return [...new Set(dirs)].flatMap((binDir) => {
+    return [
+      join12(binDir, name),
+      join12(binDir, "node_modules", "npm", "bin", "npm-cli.js"),
+      join12(binDir, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js")
+    ].filter(isFile).map((command) => ({ command, binDir }));
+  });
+}
 function quoteCmdArgument(value) {
   if (/[\0\r\n"%]/.test(value)) {
     throw new Error(`npm argument cannot be represented safely for cmd.exe: ${JSON.stringify(value)}`);
@@ -21339,6 +21660,8 @@ function quoteCmdArgument(value) {
   return `"${value}"`;
 }
 function npmInvocation(resolved, npmArgs, platform = process.platform, env = process.env) {
+  if (resolved.cliPath)
+    return { command: resolved.command, args: [resolved.cliPath, ...npmArgs] };
   if (platform !== "win32" || !/\.(?:cmd|bat)$/i.test(resolved.command)) {
     return { command: resolved.command, args: [...npmArgs] };
   }
@@ -21591,10 +21914,11 @@ function probeNpmCutoffSupport(npm, clock) {
   });
 }
 async function npmSupportsCutoff(npm, clock) {
-  const identity = await stat2(npm.command).then(({ size, mtimeMs }) => ({ size, mtimeMs })).catch(() => {
+  const key = npm.cliPath ? `${npm.command}\x00${npm.cliPath}` : npm.command;
+  const identity = await stat2(npm.cliPath ?? npm.command).then(({ size, mtimeMs }) => ({ size, mtimeMs })).catch(() => {
     return;
   });
-  const existing = npmCutoffSupport.get(npm.command);
+  const existing = npmCutoffSupport.get(key);
   const sameIdentity = existing && existing.identity?.size === identity?.size && existing.identity?.mtimeMs === identity?.mtimeMs;
   if (existing && sameIdentity) {
     if (!existing.settled || identity !== undefined && existing.settled.outcome !== "transient" || clock.now() < existing.settled.retryAt)
@@ -21605,7 +21929,7 @@ async function npmSupportsCutoff(npm, clock) {
     return outcome;
   });
   const entry = { identity, pending };
-  npmCutoffSupport.set(npm.command, entry);
+  npmCutoffSupport.set(key, entry);
   return pending;
 }
 function lspPublicationCutoff(graceDays, pinned, now = Date.now()) {
@@ -21623,6 +21947,79 @@ async function lspNpmInstallInvocation(npm, target, before, clock = SYSTEM_CLOCK
     target
   ]);
 }
+// ../aft-bridge/dist/lsp-npm-selection.js
+import { readFile, realpath, stat as stat3 } from "node:fs/promises";
+import { dirname as dirname6, join as join13, resolve as resolve9 } from "node:path";
+var LSP_NPM_REFUSAL = "AFT can't install language servers with the npm at <path> (<reason>). Put a real npm 7 or newer first on PATH; pinning a server version won't help.";
+function lspNpmRefusal(path, reason) {
+  return LSP_NPM_REFUSAL.replace("<path>", path).replace("<reason>", reason);
+}
+async function genuineNpm(candidate) {
+  let executable;
+  try {
+    executable = await realpath(candidate.command);
+  } catch (error) {
+    return { reason: `probe failed: ${String(error)}` };
+  }
+  const windowsShim = /\.(?:cmd|bat)$/i.test(executable);
+  let current = dirname6(executable);
+  if (windowsShim)
+    current = join13(current, "node_modules", "npm");
+  for (;; ) {
+    try {
+      const pkg = JSON.parse(await readFile(join13(current, "package.json"), "utf8"));
+      const bin = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.npm;
+      if (pkg.name === "npm" && typeof bin === "string") {
+        const cli = await realpath(resolve9(current, bin));
+        if (!windowsShim && cli !== executable)
+          return { reason: "not npm: command is not npm's declared CLI" };
+        const major = /^(\d+)\.\d+\.\d+$/.exec(pkg.version)?.[1];
+        if (!major)
+          return { reason: "probe failed: npm manifest has an unknown version" };
+        if (Number(major) < 7)
+          return { reason: `old npm: ${pkg.version} (requires npm 7 or newer)` };
+        if (windowsShim || process.platform === "win32" && /\.[cm]?js$/i.test(cli)) {
+          const node = join13(candidate.binDir ?? dirname6(executable), "node.exe");
+          if (!(await stat3(node)).isFile())
+            return { reason: "probe failed: adjacent Node is missing" };
+          return { npm: { command: node, binDir: dirname6(node), cliPath: cli }, reason: "" };
+        }
+        return { npm: { command: cli, binDir: candidate.binDir }, reason: "" };
+      }
+    } catch {}
+    const parent = dirname6(current);
+    if (parent === current || windowsShim)
+      break;
+    current = parent;
+  }
+  return { reason: "not npm: no matching npm package manifest and CLI" };
+}
+async function selectLspNpm(preferred, candidates, signal) {
+  const aborted = () => ({
+    refusal: lspNpmRefusal(preferred.command, "probe failed: installation aborted")
+  });
+  if (signal?.aborted)
+    return aborted();
+  const first = await genuineNpm(preferred);
+  if (signal?.aborted)
+    return aborted();
+  if (first.npm)
+    return { npm: first.npm };
+  const seen = new Set([preferred.command]);
+  for (const candidate of candidates ?? npmCandidates()) {
+    if (signal?.aborted)
+      return aborted();
+    if (seen.has(candidate.command))
+      continue;
+    seen.add(candidate.command);
+    const result = await genuineNpm(candidate);
+    if (signal?.aborted)
+      return aborted();
+    if (result.npm)
+      return { npm: result.npm };
+  }
+  return { refusal: lspNpmRefusal(preferred.command, first.reason) };
+}
 // ../aft-bridge/dist/message-detach.js
 var BASH_WAIT_DETACH_MAGIC_KEYWORD = "&detach";
 var STANDALONE_DETACH_KEYWORD_SOURCE = `(^|[^\\p{L}\\p{N}_])${BASH_WAIT_DETACH_MAGIC_KEYWORD}(?![\\p{L}\\p{N}_])`;
@@ -21672,14 +22069,14 @@ function shouldInterruptWaitsForMessage(detachOnUserMessage, operatorText) {
   return detachOnUserMessage || containsStandaloneDetachKeyword(operatorText);
 }
 // ../aft-bridge/dist/migration.js
-import { closeSync as closeSync7, existsSync as existsSync9, mkdirSync as mkdirSync5, openSync as openSync6, readFileSync as readFileSync8, renameSync as renameSync5, rmSync as rmSync3, statSync as statSync8, unlinkSync as unlinkSync4, writeFileSync as writeFileSync4 } from "node:fs";
+import { closeSync as closeSync8, existsSync as existsSync9, mkdirSync as mkdirSync5, openSync as openSync7, readFileSync as readFileSync8, renameSync as renameSync5, rmSync as rmSync3, statSync as statSync8, unlinkSync as unlinkSync4, writeFileSync as writeFileSync4 } from "node:fs";
 import { homedir as homedir12, tmpdir as tmpdir3 } from "node:os";
-import { basename as basename2, dirname as dirname8, join as join15, resolve as resolve9 } from "node:path";
+import { basename as basename2, dirname as dirname9, join as join16, resolve as resolve11 } from "node:path";
 
 // ../aft-bridge/dist/paths.js
-import { existsSync as existsSync7, readFileSync as readFileSync6, realpathSync as realpathSync4, renameSync as renameSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync7, readFileSync as readFileSync6, realpathSync as realpathSync5, renameSync as renameSync4, writeFileSync as writeFileSync3 } from "node:fs";
 import { homedir as homedir10 } from "node:os";
-import { dirname as dirname6, isAbsolute as isAbsolute6, join as join13, resolve as resolve8 } from "node:path";
+import { dirname as dirname7, isAbsolute as isAbsolute6, join as join14, resolve as resolve10 } from "node:path";
 function homeDir3() {
   if (process.platform === "win32")
     return process.env.USERPROFILE || process.env.HOME || homedir10();
@@ -21689,16 +22086,16 @@ function configHome() {
   const xdg = process.env.XDG_CONFIG_HOME;
   if (xdg && isAbsolute6(xdg))
     return xdg;
-  return join13(homeDir3(), ".config");
+  return join14(homeDir3(), ".config");
 }
 function legacyOpenCodeConfigDir() {
   const envDir = process.env.OPENCODE_CONFIG_DIR?.trim();
   if (envDir)
-    return resolve8(envDir);
-  return join13(configHome(), "opencode");
+    return resolve10(envDir);
+  return join14(configHome(), "opencode");
 }
 function legacyPiAgentDir() {
-  return join13(homeDir3(), ".pi", "agent");
+  return join14(homeDir3(), ".pi", "agent");
 }
 function legacySources(basePath, label, harness) {
   return [
@@ -21707,10 +22104,10 @@ function legacySources(basePath, label, harness) {
   ];
 }
 function resolveCortexKitUserConfigPath() {
-  return join13(configHome(), "cortexkit", "aft.jsonc");
+  return join14(configHome(), "cortexkit", "aft.jsonc");
 }
 function resolveCortexKitProjectConfigPath(projectDirectory) {
-  return join13(projectDirectory, ".cortexkit", "aft.jsonc");
+  return join14(projectDirectory, ".cortexkit", "aft.jsonc");
 }
 function resolveProjectConfigReadPath(projectDirectory, operatingHarness) {
   const canonical = resolveCortexKitProjectConfigPath(projectDirectory);
@@ -21737,14 +22134,14 @@ function resolveCortexKitConfigPaths(projectDirectory) {
 }
 function resolveLegacyAftConfigSources(projectDirectory) {
   const project = [
-    ...legacySources(join13(projectDirectory, ".opencode", "aft"), "OpenCode project", "opencode"),
-    ...legacySources(join13(projectDirectory, ".pi", "aft"), "Pi project", "pi")
+    ...legacySources(join14(projectDirectory, ".opencode", "aft"), "OpenCode project", "opencode"),
+    ...legacySources(join14(projectDirectory, ".pi", "aft"), "Pi project", "pi")
   ];
   const identity = (path) => {
     try {
-      return realpathSync4(path);
+      return realpathSync5(path);
     } catch {
-      return resolve8(path);
+      return resolve10(path);
     }
   };
   const protectedPaths = new Set([
@@ -21753,22 +22150,22 @@ function resolveLegacyAftConfigSources(projectDirectory) {
   ].map(identity));
   return {
     user: [
-      ...legacySources(join13(legacyOpenCodeConfigDir(), "aft"), "OpenCode user", "opencode"),
-      ...legacySources(join13(legacyPiAgentDir(), "aft"), "Pi user", "pi")
+      ...legacySources(join14(legacyOpenCodeConfigDir(), "aft"), "OpenCode user", "opencode"),
+      ...legacySources(join14(legacyPiAgentDir(), "aft"), "Pi user", "pi")
     ].filter((source) => !protectedPaths.has(identity(source.path))),
     project
   };
 }
 function resolveHarnessStoragePath(storageRoot, harness, ...segments) {
-  return join13(storageRoot, harness, ...segments);
+  return join14(storageRoot, harness, ...segments);
 }
 function repairRootScopedStorageFile(storageRoot, harness, fileName) {
   const harnessPath = resolveHarnessStoragePath(storageRoot, harness, fileName);
-  const rootPath = join13(storageRoot, fileName);
+  const rootPath = join14(storageRoot, fileName);
   if (existsSync7(harnessPath) || !existsSync7(rootPath))
     return harnessPath;
   try {
-    openPrivateStorageDir(storageRoot, dirname6(harnessPath));
+    openPrivateStorageDir(storageRoot, dirname7(harnessPath));
     renameSync4(rootPath, harnessPath);
   } catch {}
   return harnessPath;
@@ -21789,7 +22186,7 @@ function shouldShowAnnouncement(storageRoot, harness, currentVersion) {
     return false;
   if (!lastVersion) {
     try {
-      openPrivateStorageDir(storageRoot, dirname6(versionFile));
+      openPrivateStorageDir(storageRoot, dirname7(versionFile));
       writeFileSync3(versionFile, currentVersion, { mode: PRIVATE_FILE_MODE });
     } catch {}
     return false;
@@ -21801,7 +22198,7 @@ function markAnnouncementSeen(storageRoot, harness, currentVersion) {
     return;
   const versionFile = repairRootScopedStorageFile(storageRoot, harness, "last_announced_version");
   try {
-    openPrivateStorageDir(storageRoot, dirname6(versionFile));
+    openPrivateStorageDir(storageRoot, dirname7(versionFile));
     writeFileSync3(versionFile, currentVersion, { mode: PRIVATE_FILE_MODE });
   } catch {}
 }
@@ -21850,18 +22247,18 @@ function decodeFileUrl(target) {
 }
 
 // ../aft-bridge/dist/resolver.js
-import { closeSync as closeSync6, existsSync as existsSync8, promises as fsPromises, openSync as openSync5, readFileSync as readFileSync7, readSync as readSync5 } from "node:fs";
-import { createRequire } from "node:module";
+import { closeSync as closeSync7, existsSync as existsSync8, promises as fsPromises, openSync as openSync6, readFileSync as readFileSync7, readSync as readSync6 } from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
 import { homedir as homedir11 } from "node:os";
-import { delimiter, dirname as dirname7, isAbsolute as isAbsolute7, join as join14 } from "node:path";
+import { delimiter, dirname as dirname8, isAbsolute as isAbsolute7, join as join15 } from "node:path";
 var ensureBinaryForResolver = ensureBinary;
 var npmPlatformPackageReader = null;
 var cacheCopiesInFlight = new Map;
 function copyToVersionedCache(npmBinaryPath, version) {
   const tag = version.startsWith("v") ? version : `v${version}`;
   const ext = process.platform === "win32" ? ".exe" : "";
-  const versionedDir = join14(getAftBinaryCacheDir(), tag);
-  const cachedPath = join14(versionedDir, `aft${ext}`);
+  const versionedDir = join15(getAftBinaryCacheDir(), tag);
+  const cachedPath = join15(versionedDir, `aft${ext}`);
   if (existsSync8(cachedPath) && isTrustedCachedBinary(cachedPath, version))
     return { cachedPath };
   const existing = cacheCopiesInFlight.get(cachedPath);
@@ -21907,7 +22304,7 @@ function homeDirFromEnv(env) {
   return (process.platform === "win32" ? env.USERPROFILE || env.HOME : env.HOME) || homedir11();
 }
 function cachedBinaryPathFromEnv(version, env, ext) {
-  const binaryPath = join14(getAftBinaryCacheDir(env), version, `aft${ext}`);
+  const binaryPath = join15(getAftBinaryCacheDir(env), version, `aft${ext}`);
   return existsSync8(binaryPath) ? binaryPath : null;
 }
 async function probeBinaryCandidateOffThread(binaryPath, source, expectedVersion) {
@@ -21929,7 +22326,7 @@ function pathCandidates(env, ext) {
   for (const dir of rawPath.split(delimiter)) {
     if (!dir || !isAbsolute7(dir))
       continue;
-    const candidate = join14(dir, `aft${ext}`);
+    const candidate = join15(dir, `aft${ext}`);
     if (seen.has(candidate))
       continue;
     seen.add(candidate);
@@ -21941,9 +22338,9 @@ function pathCandidates(env, ext) {
 function isNativeExecutable(binaryPath) {
   let fd = null;
   try {
-    fd = openSync5(binaryPath, "r");
+    fd = openSync6(binaryPath, "r");
     const buf = Buffer.alloc(4);
-    const read = readSync5(fd, buf, 0, 4, 0);
+    const read = readSync6(fd, buf, 0, 4, 0);
     if (read < 2)
       return false;
     const b0 = buf[0];
@@ -21964,7 +22361,7 @@ function isNativeExecutable(binaryPath) {
   } finally {
     if (fd !== null) {
       try {
-        closeSync6(fd);
+        closeSync7(fd);
       } catch {}
     }
   }
@@ -21994,7 +22391,7 @@ function explicitBinaryOverride(env) {
 }
 function ownPackageVersion() {
   try {
-    const req = createRequire(import.meta.url);
+    const req = createRequire2(import.meta.url);
     return req("../package.json").version;
   } catch {
     return null;
@@ -22004,10 +22401,10 @@ function npmPlatformPackage(ext) {
   if (npmPlatformPackageReader)
     return npmPlatformPackageReader(ext);
   try {
-    const req = createRequire(import.meta.url);
+    const req = createRequire2(import.meta.url);
     const manifestPath = req.resolve(`@cortexkit/aft-${platformKey()}/package.json`);
     const manifest = JSON.parse(readFileSync7(manifestPath, "utf8"));
-    const binaryPath = join14(dirname7(manifestPath), "bin", `aft${ext}`);
+    const binaryPath = join15(dirname8(manifestPath), "bin", `aft${ext}`);
     if (typeof manifest.version !== "string" || !existsSync8(binaryPath))
       return null;
     return { binaryPath, version: normalizeBareVersion(manifest.version) };
@@ -22074,7 +22471,7 @@ async function findProbedBinary(expectedVersion, env) {
     if (usable)
       return { path: usable, source: "PATH" };
   }
-  const cargoPath = join14(homeDirFromEnv(env), ".cargo", "bin", `aft${ext}`);
+  const cargoPath = join15(homeDirFromEnv(env), ".cargo", "bin", `aft${ext}`);
   if (existsSync8(cargoPath)) {
     const usable = await probeBinaryCandidateOffThread(cargoPath, "cargo", pluginVersion);
     if (usable)
@@ -22173,9 +22570,9 @@ function dataHome() {
   if (process.env.XDG_DATA_HOME)
     return process.env.XDG_DATA_HOME;
   if (process.platform === "win32") {
-    return process.env.LOCALAPPDATA || process.env.APPDATA || join15(homeDir4(), "AppData", "Local");
+    return process.env.LOCALAPPDATA || process.env.APPDATA || join16(homeDir4(), "AppData", "Local");
   }
-  return join15(homeDir4(), ".local", "share");
+  return join16(homeDir4(), ".local", "share");
 }
 function homeDir4() {
   if (process.platform === "win32")
@@ -22184,8 +22581,8 @@ function homeDir4() {
 }
 function resolveLegacyStorageRoot(harness) {
   if (harness === "pi")
-    return join15(homeDir4(), ".pi", "agent", "aft");
-  return join15(dataHome(), "opencode", "storage", "plugin", "aft");
+    return join16(homeDir4(), ".pi", "agent", "aft");
+  return join16(dataHome(), "opencode", "storage", "plugin", "aft");
 }
 function stripJsoncForParse(input) {
   let out = "";
@@ -22314,19 +22711,19 @@ function acquireConfigMigrationLock(lockDir) {
   }
 }
 function atomicCopyConfigFile(sourcePath, targetPath) {
-  mkdirSync5(dirname8(targetPath), { recursive: true });
-  const tmpPath = join15(dirname8(targetPath), `.${basename2(targetPath)}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`);
+  mkdirSync5(dirname9(targetPath), { recursive: true });
+  const tmpPath = join16(dirname9(targetPath), `.${basename2(targetPath)}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`);
   let fd = null;
   try {
-    fd = openSync6(tmpPath, "wx", 384);
+    fd = openSync7(tmpPath, "wx", 384);
     writeFileSync4(fd, readFileSync8(sourcePath));
-    closeSync7(fd);
+    closeSync8(fd);
     fd = null;
     renameSync5(tmpPath, targetPath);
   } catch (err) {
     if (fd !== null) {
       try {
-        closeSync7(fd);
+        closeSync8(fd);
       } catch {}
     }
     try {
@@ -22336,19 +22733,19 @@ function atomicCopyConfigFile(sourcePath, targetPath) {
   }
 }
 function atomicWriteConfigFile(targetPath, content) {
-  mkdirSync5(dirname8(targetPath), { recursive: true });
-  const tmpPath = join15(dirname8(targetPath), `.${basename2(targetPath)}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`);
+  mkdirSync5(dirname9(targetPath), { recursive: true });
+  const tmpPath = join16(dirname9(targetPath), `.${basename2(targetPath)}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`);
   let fd = null;
   try {
-    fd = openSync6(tmpPath, "wx", 384);
+    fd = openSync7(tmpPath, "wx", 384);
     writeFileSync4(fd, content);
-    closeSync7(fd);
+    closeSync8(fd);
     fd = null;
     renameSync5(tmpPath, targetPath);
   } catch (err) {
     if (fd !== null) {
       try {
-        closeSync7(fd);
+        closeSync8(fd);
       } catch {}
     }
     try {
@@ -22456,13 +22853,13 @@ function visibleConfigMigrationWarning(scope, targetPath, paths, reason) {
 }
 function migrateAftConfigFile(opts) {
   const warnings = [];
-  const resolvedTarget = resolve9(opts.targetPath);
-  const existingSources = opts.legacySources.filter((source) => existsSync9(source.path) && resolve9(source.path) !== resolvedTarget);
+  const resolvedTarget = resolve11(opts.targetPath);
+  const existingSources = opts.legacySources.filter((source) => existsSync9(source.path) && resolve11(source.path) !== resolvedTarget);
   const info = opts.logger?.info ?? opts.logger?.log;
   if (existingSources.length === 0) {
     return { migrated: false, conflict: false, targetPath: opts.targetPath, warnings };
   }
-  mkdirSync5(dirname8(opts.targetPath), { recursive: true });
+  mkdirSync5(dirname9(opts.targetPath), { recursive: true });
   const release = acquireConfigMigrationLock(`${opts.targetPath}.lock`);
   try {
     const sources = existingSources.map((source) => ({
@@ -22519,13 +22916,13 @@ function spawnErrorLabel(error) {
   return [code, error.message].filter(Boolean).join(": ");
 }
 function migrationLogPath(newRoot, harness, logger) {
-  const desired = join15(newRoot, "logs", "migration", `${harness}-${Date.now()}.jsonl`);
+  const desired = join16(newRoot, "logs", "migration", `${harness}-${Date.now()}.jsonl`);
   try {
-    mkdirSync5(dirname8(desired), { recursive: true });
+    mkdirSync5(dirname9(desired), { recursive: true });
     return desired;
   } catch (err) {
-    const fallback = join15(tmpdir3(), `aft-migration-${harness}-${Date.now()}.jsonl`);
-    logger?.warn?.(`Failed to create AFT migration log directory ${dirname8(desired)}: ${err instanceof Error ? err.message : String(err)}. ` + `Using fallback log path ${fallback}.`);
+    const fallback = join16(tmpdir3(), `aft-migration-${harness}-${Date.now()}.jsonl`);
+    logger?.warn?.(`Failed to create AFT migration log directory ${dirname9(desired)}: ${err instanceof Error ? err.message : String(err)}. ` + `Using fallback log path ${fallback}.`);
     return fallback;
   }
 }
@@ -22584,13 +22981,13 @@ async function ensureStorageMigrated(opts) {
 // ../aft-bridge/dist/migration-notices.js
 import { readFileSync as readFileSync9, renameSync as renameSync6, rmdirSync, statSync as statSync9, writeFileSync as writeFileSync5 } from "node:fs";
 import { homedir as homedir13 } from "node:os";
-import { dirname as dirname9, join as join16, resolve as resolve10 } from "node:path";
+import { dirname as dirname10, join as join17, resolve as resolve12 } from "node:path";
 function migrationNoticeStorePath(env = process.env) {
-  const stateHome = env.XDG_STATE_HOME && env.XDG_STATE_HOME.length > 0 ? env.XDG_STATE_HOME : join16(homedir13(), ".local", "state");
-  return join16(stateHome, "cortexkit", "aft", "migration-notices.json");
+  const stateHome = env.XDG_STATE_HOME && env.XDG_STATE_HOME.length > 0 ? env.XDG_STATE_HOME : join17(homedir13(), ".local", "state");
+  return join17(stateHome, "cortexkit", "aft", "migration-notices.json");
 }
 function noticeKey(configPath, digest) {
-  return `${resolve10(configPath)}|${MIGRATION_POLICY_ID}|${digest}`;
+  return `${resolve12(configPath)}|${MIGRATION_POLICY_ID}|${digest}`;
 }
 function readRecords(storePath) {
   try {
@@ -22603,7 +23000,7 @@ function readRecords(storePath) {
 var LOCK_STALE_MS = 1e4;
 function withStoreLock(storePath, action) {
   const lockPath = `${storePath}.lock`;
-  openPrivateStorageDir(dirname9(storePath));
+  openPrivateStorageDir(dirname10(storePath));
   const deadline = Date.now() + 2000;
   for (;; ) {
     try {
@@ -22657,7 +23054,7 @@ function deliverMigrationNoticeOnce(options) {
   }
 }
 // ../aft-bridge/dist/onnx-probe.js
-import { closeSync as closeSync8, existsSync as existsSync10, openSync as openSync7, readSync as readSync6, realpathSync as realpathSync5 } from "node:fs";
+import { closeSync as closeSync9, existsSync as existsSync10, openSync as openSync8, readSync as readSync7, realpathSync as realpathSync6 } from "node:fs";
 var MH_MAGIC = 4277009102;
 var MH_MAGIC_64 = 4277009103;
 var FAT_MAGIC = 3405691582;
@@ -22670,7 +23067,7 @@ var MAX_HEADER_BYTES = 4 * 1024 * 1024;
 var UNCHECKED = { loadable: true, checked: false };
 function readAt(fd, offset, length) {
   const buffer = Buffer.alloc(length);
-  const read = readSync6(fd, buffer, 0, length, offset);
+  const read = readSync7(fd, buffer, 0, length, offset);
   return buffer.subarray(0, read);
 }
 function cpuTypeForArch(arch) {
@@ -22744,7 +23141,7 @@ function isUncheckableDependency(path) {
 function probeOnnxRuntimeLoadable(libPath, arch = process.arch) {
   let fd;
   try {
-    fd = openSync7(realpathSync5(libPath), "r");
+    fd = openSync8(realpathSync6(libPath), "r");
   } catch (err) {
     return {
       loadable: false,
@@ -22778,13 +23175,13 @@ function probeOnnxRuntimeLoadable(libPath, arch = process.arch) {
   } catch {
     return UNCHECKED;
   } finally {
-    closeSync8(fd);
+    closeSync9(fd);
   }
 }
 // ../aft-bridge/dist/onnx-runtime.js
 import { randomBytes as randomBytes3 } from "node:crypto";
-import { chmodSync as chmodSync2, closeSync as closeSync9, copyFileSync as copyFileSync4, createWriteStream as createWriteStream3, existsSync as existsSync11, lstatSync as lstatSync3, openSync as openSync8, readdirSync as readdirSync4, readFileSync as readFileSync10, readlinkSync as readlinkSync2, realpathSync as realpathSync6, renameSync as renameSync7, rmSync as rmSync4, statSync as statSync10, symlinkSync, unlinkSync as unlinkSync5, writeFileSync as writeFileSync6 } from "node:fs";
-import { basename as basename3, dirname as dirname10, isAbsolute as isAbsolute8, join as join17, relative as relative5, resolve as resolve11, win32 as win323 } from "node:path";
+import { chmodSync as chmodSync2, closeSync as closeSync10, copyFileSync as copyFileSync4, createWriteStream as createWriteStream3, existsSync as existsSync11, lstatSync as lstatSync3, openSync as openSync9, readdirSync as readdirSync4, readFileSync as readFileSync10, readlinkSync as readlinkSync2, realpathSync as realpathSync7, renameSync as renameSync7, rmSync as rmSync4, statSync as statSync10, symlinkSync, unlinkSync as unlinkSync5, writeFileSync as writeFileSync6 } from "node:fs";
+import { basename as basename3, dirname as dirname11, isAbsolute as isAbsolute8, join as join18, relative as relative5, resolve as resolve13, win32 as win323 } from "node:path";
 import { Readable as Readable3 } from "node:stream";
 import { pipeline as pipeline3 } from "node:stream/promises";
 var ORT_VERSION = "1.24.4";
@@ -22872,7 +23269,7 @@ function resolveOnnxRuntime(storageDir, seams) {
 }
 async function findCachedOnnxRuntime(ortVersionDir, libName) {
   const resolvedOrtDir = resolveCachedOnnxRuntimeDir(ortVersionDir, libName);
-  const libPath = join17(resolvedOrtDir, libName);
+  const libPath = join18(resolvedOrtDir, libName);
   if (existsSync11(libPath)) {
     const meta = readOnnxInstalledMeta(ortVersionDir);
     if (meta?.sha256) {
@@ -22897,7 +23294,7 @@ async function findCachedOnnxRuntime(ortVersionDir, libName) {
 }
 async function resolveOnnxRuntimeUncoalesced(storageDir, seams) {
   const info = seams.platformInfo !== undefined ? seams.platformInfo : getPlatformInfo();
-  const ortVersionDir = join17(storageDir, "onnxruntime", ORT_VERSION);
+  const ortVersionDir = join18(storageDir, "onnxruntime", ORT_VERSION);
   const libName = info?.libName ?? "libonnxruntime.dylib";
   const cached = await findCachedOnnxRuntime(ortVersionDir, libName);
   if (cached)
@@ -22911,9 +23308,9 @@ async function resolveOnnxRuntimeUncoalesced(storageDir, seams) {
     warn(`ONNX Runtime auto-download not available for ${process.platform}/${process.arch}. Install manually: ${getManualInstallHint()}`);
     return null;
   }
-  const onnxBaseDir = join17(storageDir, "onnxruntime");
+  const onnxBaseDir = join18(storageDir, "onnxruntime");
   openPrivateStorageDir(storageDir, onnxBaseDir);
-  const lockPath = join17(onnxBaseDir, ONNX_LOCK_FILE);
+  const lockPath = join18(onnxBaseDir, ONNX_LOCK_FILE);
   const pollMs = seams.lockPollMs ?? LOCK_POLL_MS;
   const deadline = Date.now() + LOCK_WAIT_MS;
   let announcedWait = false;
@@ -22958,7 +23355,7 @@ function cleanupAbandonedStagingDirs(onnxBaseDir) {
     for (const entry of entries) {
       if (!entry.startsWith(`${ORT_VERSION}.tmp.`))
         continue;
-      const stagingDir = join17(onnxBaseDir, entry);
+      const stagingDir = join18(onnxBaseDir, entry);
       const parts = entry.split(".");
       const pidStr = parts[parts.length - 2];
       const pid = pidStr ? Number.parseInt(pidStr, 10) : NaN;
@@ -22995,7 +23392,7 @@ function cleanupAbandonedStagingDirs(onnxBaseDir) {
 }
 function cleanupIncompleteTargetIfUnowned(ortDir) {
   try {
-    if (existsSync11(ortDir) && !existsSync11(join17(ortDir, ONNX_INSTALLED_META_FILE))) {
+    if (existsSync11(ortDir) && !existsSync11(join18(ortDir, ONNX_INSTALLED_META_FILE))) {
       log(`[onnx] removing half-populated install dir ${ortDir} (no meta file)`);
       rmSync4(ortDir, { recursive: true, force: true });
     }
@@ -23030,7 +23427,7 @@ function detectOnnxVersion(libDir, libName) {
   try {
     const entries = readdirSync4(libDir);
     try {
-      const resolved = parseOnnxVersionFromPath(realpathSync6(join17(libDir, libName)));
+      const resolved = parseOnnxVersionFromPath(realpathSync7(join18(libDir, libName)));
       if (resolved && resolved !== INVALID_ORT_VERSION)
         return resolved;
     } catch {}
@@ -23044,10 +23441,10 @@ function detectOnnxVersion(libDir, libName) {
       if (version)
         return version;
     }
-    const base = join17(libDir, libName);
+    const base = join18(libDir, libName);
     if (existsSync11(base)) {
       try {
-        const real = realpathSync6(base);
+        const real = realpathSync7(base);
         const version = parseOnnxVersionFromPath(real) ?? parseOnnxVersionFromDirectoryPath(real);
         if (version)
           return version;
@@ -23111,10 +23508,10 @@ function directoryContainsLibrary(dir, libName) {
   }
 }
 function resolveCachedOnnxRuntimeDir(ortVersionDir, libName) {
-  if (existsSync11(join17(ortVersionDir, libName)))
+  if (existsSync11(join18(ortVersionDir, libName)))
     return ortVersionDir;
-  const libSubdir = join17(ortVersionDir, "lib");
-  if (existsSync11(join17(libSubdir, libName)))
+  const libSubdir = join18(ortVersionDir, "lib");
+  if (existsSync11(join18(libSubdir, libName)))
     return libSubdir;
   return ortVersionDir;
 }
@@ -23129,12 +23526,12 @@ function findSystemOnnxRuntime(libName, searchPathsOverride) {
   } else if (process.platform === "win32") {
     const programFiles = process.env.ProgramFiles ?? "C:\\Program Files";
     const programFilesX86 = process.env["ProgramFiles(x86)"] ?? "C:\\Program Files (x86)";
-    searchPaths.push(join17(programFiles, "onnxruntime", "lib"), join17(programFiles, "Microsoft ONNX Runtime", "lib"), join17(programFiles, "Microsoft Machine Learning", "lib"), join17(programFilesX86, "onnxruntime", "lib"), ...(() => {
+    searchPaths.push(join18(programFiles, "onnxruntime", "lib"), join18(programFiles, "Microsoft ONNX Runtime", "lib"), join18(programFiles, "Microsoft Machine Learning", "lib"), join18(programFilesX86, "onnxruntime", "lib"), ...(() => {
       const nugetPaths = [];
       const userProfile = process.env.USERPROFILE ?? "";
       if (!userProfile)
         return nugetPaths;
-      const nugetPackageDir = join17(userProfile, ".nuget", "packages", "microsoft.ml.onnxruntime");
+      const nugetPackageDir = join18(userProfile, ".nuget", "packages", "microsoft.ml.onnxruntime");
       if (!existsSync11(nugetPackageDir))
         return nugetPaths;
       try {
@@ -23143,7 +23540,7 @@ function findSystemOnnxRuntime(libName, searchPathsOverride) {
             continue;
           if (entry.name === "__globalPackagesFolder" || entry.name.startsWith("."))
             continue;
-          nugetPaths.push(join17(nugetPackageDir, entry.name, "runtimes", "win-x64", "native"), join17(nugetPackageDir, entry.name, "runtimes", "win-arm64", "native"));
+          nugetPaths.push(join18(nugetPackageDir, entry.name, "runtimes", "win-x64", "native"), join18(nugetPackageDir, entry.name, "runtimes", "win-arm64", "native"));
         }
       } catch (err) {
         warn(`Failed to scan NuGet ONNX Runtime cache ${nugetPackageDir}: ${err instanceof Error ? err.message : String(err)}`);
@@ -23155,7 +23552,7 @@ function findSystemOnnxRuntime(libName, searchPathsOverride) {
   const normalizeCase = process.platform === "win32" || process.platform === "darwin";
   const seen = new Set;
   const uniquePaths = searchPaths.filter((p) => {
-    let key = resolve11(p).replace(/[/\\]+$/, "");
+    let key = resolve13(p).replace(/[/\\]+$/, "");
     if (normalizeCase)
       key = key.toLowerCase();
     if (seen.has(key))
@@ -23165,7 +23562,7 @@ function findSystemOnnxRuntime(libName, searchPathsOverride) {
   });
   const unknownVersionPaths = [];
   for (const dir of uniquePaths) {
-    const libPath = join17(dir, libName);
+    const libPath = join18(dir, libName);
     if (process.platform === "win32") {
       if (!directoryContainsLibrary(dir, libName))
         continue;
@@ -23212,7 +23609,7 @@ async function downloadFileWithCap(url, destPath) {
     if (Number.isFinite(advertised) && advertised > MAX_DOWNLOAD_BYTES2) {
       throw new Error(`Content-Length ${advertised} exceeds max ${MAX_DOWNLOAD_BYTES2}`);
     }
-    privateMkdirSync(dirname10(destPath));
+    privateMkdirSync(dirname11(destPath));
     let bytesWritten = 0;
     const guard = new TransformStream({
       transform(chunk, transformController) {
@@ -23239,16 +23636,16 @@ async function downloadFileWithCap(url, destPath) {
   }
 }
 function validateExtractedTree(stagingRoot) {
-  const realRoot = realpathSync6(stagingRoot);
+  const realRoot = realpathSync7(stagingRoot);
   let totalBytes = 0;
   const walk = (dir) => {
     const entries = readdirSync4(dir);
     for (const entry of entries) {
-      const fullPath = join17(dir, entry);
+      const fullPath = join18(dir, entry);
       const lst = lstatSync3(fullPath);
       if (lst.isSymbolicLink()) {
         const linkTarget = readlinkSync2(fullPath);
-        const resolvedTarget = resolve11(dirname10(fullPath), linkTarget);
+        const resolvedTarget = resolve13(dirname11(fullPath), linkTarget);
         const rel = relative5(realRoot, resolvedTarget);
         if (relativePathEscapesRoot(rel) || win323.isAbsolute(rel)) {
           throw new Error(`extracted symlink ${fullPath} points outside staging root: ${linkTarget}`);
@@ -23281,11 +23678,11 @@ async function downloadOnnxRuntime(info, targetDir) {
   const url = `https://github.com/${ORT_REPO}/releases/download/v${ORT_VERSION}/${info.assetName}.${info.archiveType === "tgz" ? "tgz" : "zip"}`;
   log(`Downloading ONNX Runtime v${ORT_VERSION} for ${process.platform}/${process.arch}...`);
   const tmpDir = `${targetDir}.tmp.${process.pid}.${Date.now().toString(36)}${randomBytes3(4).toString("hex")}`;
-  const extractionRoot = join17(tmpDir, "extract");
-  const stagedInstallDir = join17(tmpDir, "install");
+  const extractionRoot = join18(tmpDir, "extract");
+  const stagedInstallDir = join18(tmpDir, "install");
   try {
     privateMkdirSync(extractionRoot);
-    const archivePath = join17(tmpDir, `onnxruntime.${info.archiveType}`);
+    const archivePath = join18(tmpDir, `onnxruntime.${info.archiveType}`);
     await downloadFileWithCap(url, archivePath);
     const archiveSha256 = await sha256File(archivePath);
     log(`ONNX Runtime archive sha256=${archiveSha256}`);
@@ -23298,7 +23695,7 @@ async function downloadOnnxRuntime(info, targetDir) {
       unlinkSync5(archivePath);
     } catch {}
     validateExtractedTree(extractionRoot);
-    const extractedDir = join17(extractionRoot, info.assetName, "lib");
+    const extractedDir = join18(extractionRoot, info.assetName, "lib");
     if (!existsSync11(extractedDir)) {
       throw new Error(`Expected directory not found: ${extractedDir}`);
     }
@@ -23306,7 +23703,7 @@ async function downloadOnnxRuntime(info, targetDir) {
     const realFiles = [];
     const symlinks = [];
     for (const libFile of libFiles) {
-      const src = join17(extractedDir, libFile);
+      const src = join18(extractedDir, libFile);
       try {
         const stat = lstatSync3(src);
         log(`ORT extract: ${libFile} — isSymlink=${stat.isSymbolicLink()}, isFile=${stat.isFile()}, size=${stat.size}`);
@@ -23321,14 +23718,14 @@ async function downloadOnnxRuntime(info, targetDir) {
       }
     }
     copyOnnxLibraries(info, extractedDir, stagedInstallDir, realFiles, symlinks);
-    const libPath = join17(stagedInstallDir, info.libName);
+    const libPath = join18(stagedInstallDir, info.libName);
     const libHash = await sha256File(libPath);
     if (libHash !== info.librarySha256) {
       throw new Error(`onnx runtime library hash mismatch at ${libPath}: sha256 ${libHash}, ` + `expected the pinned ${info.librarySha256} for ${info.assetName}`);
     }
     writeOnnxInstalledMeta(stagedInstallDir, ORT_VERSION, libHash, archiveSha256);
     publishOnnxRuntime(stagedInstallDir, targetDir);
-    writeStampedFileDigest(join17(targetDir, info.libName), libHash);
+    writeStampedFileDigest(join18(targetDir, info.libName), libHash);
     rmSync4(tmpDir, { recursive: true, force: true });
     log(`ONNX Runtime v${ORT_VERSION} installed to ${targetDir}`);
     return targetDir;
@@ -23370,8 +23767,8 @@ function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, c
   const requiredLibs = new Set([info.libName]);
   privateMkdirSync(targetDir);
   for (const libFile of realFiles) {
-    const src = join17(extractedDir, libFile);
-    const dst = join17(targetDir, libFile);
+    const src = join18(extractedDir, libFile);
+    const dst = join18(targetDir, libFile);
     try {
       if (copyFile === copyFileSync4)
         privateCopyFileSync(src, dst);
@@ -23388,14 +23785,14 @@ function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, c
       log(`ORT extract: failed to copy optional ${libFile}: ${copyErr}`);
     }
   }
-  const targetRoot = realpathSync6(targetDir);
+  const targetRoot = realpathSync7(targetDir);
   for (const link of symlinks) {
-    const dst = join17(targetDir, link.name);
+    const dst = join18(targetDir, link.name);
     try {
       unlinkSync5(dst);
     } catch {}
-    const dstForContainment = join17(targetRoot, link.name);
-    const resolvedTarget = resolve11(dirname10(dstForContainment), link.target);
+    const dstForContainment = join18(targetRoot, link.name);
+    const resolvedTarget = resolve13(dirname11(dstForContainment), link.target);
     if (!isPathInsideRoot(targetRoot, resolvedTarget)) {
       const message = `ONNX Runtime symlink ${link.name} points outside install dir: ${link.target}`;
       if (requiredLibs.has(link.name)) {
@@ -23415,7 +23812,7 @@ function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, c
       log(`ORT extract: failed to symlink optional ${link.name}: ${symlinkErr}`);
     }
   }
-  const requiredPath = join17(targetDir, info.libName);
+  const requiredPath = join18(targetDir, info.libName);
   if (!existsSync11(requiredPath)) {
     rmSync4(targetDir, { recursive: true, force: true });
     throw new Error(`Required ONNX Runtime library missing after install: ${requiredPath}`);
@@ -23443,7 +23840,7 @@ function writeOnnxInstalledMeta(installDir, version, sha256, archiveSha256) {
       ...sha256 ? { sha256 } : {},
       archiveSha256
     };
-    writeFileSync6(join17(installDir, ONNX_INSTALLED_META_FILE), JSON.stringify(meta), {
+    writeFileSync6(join18(installDir, ONNX_INSTALLED_META_FILE), JSON.stringify(meta), {
       encoding: "utf8",
       mode: PRIVATE_FILE_MODE
     });
@@ -23452,7 +23849,7 @@ function writeOnnxInstalledMeta(installDir, version, sha256, archiveSha256) {
   }
 }
 function readOnnxInstalledMeta(installDir) {
-  const path = join17(installDir, ONNX_INSTALLED_META_FILE);
+  const path = join18(installDir, ONNX_INSTALLED_META_FILE);
   try {
     if (!statSync10(path).isFile())
       return null;
@@ -23473,13 +23870,13 @@ function readOnnxInstalledMeta(installDir) {
 function acquireLock(lockPath) {
   const tryClaim = () => {
     try {
-      const fd = openSync8(lockPath, "wx", PRIVATE_FILE_MODE);
+      const fd = openSync9(lockPath, "wx", PRIVATE_FILE_MODE);
       try {
         writeFileSync6(fd, `${process.pid}
 ${new Date().toISOString()}
 `);
       } finally {
-        closeSync9(fd);
+        closeSync10(fd);
       }
       return true;
     } catch (err) {
@@ -25375,7 +25772,7 @@ import {
 // package.json
 var package_default = {
   name: "@cortexkit/aft-pi",
-  version: "0.63.5",
+  version: "0.64.0",
   type: "module",
   description: "Pi coding agent extension for Agent File Tools (AFT) — tree-sitter and LSP-powered code analysis",
   main: "dist/index.js",
@@ -25399,18 +25796,18 @@ var package_default = {
     "test:e2e": "bun test src/__tests__/e2e/"
   },
   dependencies: {
-    "@cortexkit/aft-bridge": "0.63.5",
+    "@cortexkit/aft-bridge": "0.64.0",
     "comment-json": "^5.0.0",
     diff: "^8.0.4",
     zod: "^4.4.3"
   },
   optionalDependencies: {
-    "@cortexkit/aft-darwin-arm64": "0.63.5",
-    "@cortexkit/aft-darwin-x64": "0.63.5",
-    "@cortexkit/aft-linux-arm64": "0.63.5",
-    "@cortexkit/aft-linux-x64": "0.63.5",
-    "@cortexkit/aft-win32-arm64": "0.63.5",
-    "@cortexkit/aft-win32-x64": "0.63.5"
+    "@cortexkit/aft-darwin-arm64": "0.64.0",
+    "@cortexkit/aft-darwin-x64": "0.64.0",
+    "@cortexkit/aft-linux-arm64": "0.64.0",
+    "@cortexkit/aft-linux-x64": "0.64.0",
+    "@cortexkit/aft-win32-arm64": "0.64.0",
+    "@cortexkit/aft-win32-x64": "0.64.0"
   },
   devDependencies: {
     "@earendil-works/pi-coding-agent": "^0.80.2",
@@ -25490,22 +25887,15 @@ function readStatusBar(value) {
   const disabled = Array.isArray(bar.disabled_categories) ? bar.disabled_categories.filter((key) => typeof key === "string") : [];
   const errors = readOptionalNumber(bar.errors);
   const warnings = readOptionalNumber(bar.warnings);
-  const deadCode = readOptionalNumber(bar.dead_code);
-  const unusedExports = readOptionalNumber(bar.unused_exports);
-  const duplicates = readOptionalNumber(bar.duplicates);
   const todos = readOptionalNumber(bar.todos);
-  if (errors === null && warnings === null && deadCode === null && unusedExports === null && duplicates === null && todos === null && disabled.length === 0) {
+  if (errors === null && warnings === null && todos === null && disabled.length === 0) {
     return;
   }
   return {
     ...disabled.length > 0 ? { disabled_categories: disabled } : {},
     ...errors !== null ? { errors } : {},
     ...warnings !== null ? { warnings } : {},
-    ...deadCode !== null ? { dead_code: deadCode } : {},
-    ...unusedExports !== null ? { unused_exports: unusedExports } : {},
-    ...duplicates !== null ? { duplicates } : {},
-    ...todos !== null ? { todos } : {},
-    ...bar.tier2_stale === true ? { tier2_stale: true } : {}
+    ...todos !== null ? { todos } : {}
   };
 }
 function formatFlag(enabled) {
@@ -25661,13 +26051,10 @@ function formatStatusDialogMessage(status) {
     const rows = [
       ["errors", sb.errors],
       ["warnings", sb.warnings],
-      ["dead code", sb.dead_code],
-      ["unused exports", sb.unused_exports],
-      ["duplicates", sb.duplicates],
       ["todos", sb.todos]
     ].filter((row) => typeof row[1] === "number");
     if (rows.length > 0) {
-      lines.push("", `Code Health${sb.tier2_stale ? " (~ stale)" : ""}`);
+      lines.push("", "Code Health");
       for (const [label, value] of rows)
         lines.push(`- ${label}: ${formatCount(value)}`);
     }
@@ -30505,9 +30892,8 @@ function clampBashWatchSyncMaxMs(value) {
 }
 function resolveBashConfig(config) {
   const top = config.bash;
-  const legacy = config.experimental?.bash;
-  const reminderEnabled = (typeof top === "object" && top !== null ? top.long_running_reminder_enabled : undefined) ?? legacy?.long_running_reminder_enabled;
-  const reminderInterval = (typeof top === "object" && top !== null ? top.long_running_reminder_interval_ms : undefined) ?? legacy?.long_running_reminder_interval_ms;
+  const reminderEnabled = typeof top === "object" && top !== null ? top.long_running_reminder_enabled : undefined;
+  const reminderInterval = typeof top === "object" && top !== null ? top.long_running_reminder_interval_ms : undefined;
   const topDetachOnUserMessage = typeof top === "object" && top !== null ? top.detach_on_user_message ?? true : true;
   const rawForegroundWait = typeof top === "object" && top !== null ? top.foreground_wait_window_ms : undefined;
   const foregroundWaitWindowMs = Math.max(FOREGROUND_WAIT_WINDOW_MIN_MS, rawForegroundWait ?? FOREGROUND_WAIT_WINDOW_DEFAULT_MS);
@@ -30551,13 +30937,6 @@ function resolveBashConfig(config) {
       detach_on_user_message: topDetachOnUserMessage
     };
   }
-  const hasLegacyFeatureFlag = legacy && (legacy.rewrite !== undefined || legacy.compress !== undefined || legacy.background !== undefined);
-  if (hasLegacyFeatureFlag) {
-    const rewrite = legacy.rewrite === true;
-    const compress = legacy.compress === true;
-    const background = legacy.background === true;
-    return { ...base, enabled: true, rewrite, compress, background };
-  }
   return { ...base, enabled: true, rewrite: true, compress: true, background: true };
 }
 var FormatterEnum = _enum([
@@ -30659,13 +31038,6 @@ var LspConfigSchema = object({
   versions: record(string2().trim().min(1), string2().trim().min(1)).optional()
 });
 var ExperimentalConfigSchema = object({
-  bash: object({
-    rewrite: boolean2().optional(),
-    compress: boolean2().optional(),
-    background: boolean2().optional(),
-    long_running_reminder_enabled: boolean2().optional(),
-    long_running_reminder_interval_ms: number2().int().positive().optional()
-  }).optional(),
   lsp_ty: boolean2().optional()
 });
 var BashEnvSchema = record(string2(), string2()).superRefine((env, context) => {
@@ -30763,7 +31135,6 @@ var PiConfigSchema = object({
 var InspectConfigSchema = object({
   enabled: boolean2().optional(),
   diagnostics_timeout_ms: number2().int().positive().optional().transform((value) => value === undefined ? undefined : clampInspectDiagnosticsTimeoutMs(value)),
-  tier2_idle_minutes: number2().min(0).optional(),
   tier2_pass_timeout_ms: number2().int().positive().optional(),
   categories: object({
     diagnostics: boolean2().optional(),
@@ -30781,11 +31152,16 @@ var InspectConfigSchema = object({
 function clampIdleRootTtlMinutes(value) {
   return Math.min(30, Math.max(5, value));
 }
+function clampIdleCheckoutHours(value) {
+  return Math.min(IDLE_CHECKOUT_HOURS_MAX, Math.max(IDLE_CHECKOUT_HOURS_MIN, value));
+}
 var IdleConfigSchema = object({
-  root_ttl_minutes: number2().int().optional().transform((value) => value === undefined ? undefined : clampIdleRootTtlMinutes(value))
+  root_ttl_minutes: number2().int().optional().transform((value) => value === undefined ? undefined : clampIdleRootTtlMinutes(value)),
+  checkout_hours: number2().int().optional().transform((value) => value === undefined ? undefined : clampIdleCheckoutHours(value))
 });
 var ViewsConfigSchema = object({
-  enabled: boolean2().optional()
+  enabled: boolean2().optional(),
+  callgraph_copies: number2().int().optional()
 });
 var WorktreeConfigSchema = object({
   ram_overlay: boolean2().optional()
@@ -30863,6 +31239,11 @@ function applyActiveHarnessOverride(config, trusted) {
     delete merged.indexes;
   else
     merged.indexes = indexes;
+  const idle = mergeIdleConfig(base.idle, override.idle);
+  if (idle === undefined)
+    delete merged.idle;
+  else
+    merged.idle = idle;
   merged.sandbox = mergeSandboxConfig(base.sandbox, override.sandbox, true);
   if (!trusted && override.sandbox?.write_allow !== undefined) {
     merged.sandbox = { ...merged.sandbox, write_allow: override.sandbox.write_allow };
@@ -30965,7 +31346,7 @@ function loadConfigFromPath(configPath, tier) {
     recordConfigParseFailure(configPath, errorMsg);
     throw new ConfigRejectedError(["invalid_config_document"], configPath);
   }
-  const removed = removedConfigKeyErrors(cleanConfig);
+  const removed = removedConfigKeyErrors(cleanConfig, undefined, false);
   if (removed.length) {
     throw new ConfigRejectedError(removed);
   }
@@ -30988,9 +31369,18 @@ function loadConfigFromPath(configPath, tier) {
       warn2(text);
     }
   }
-  if (translation.legacyInput && tier === "user") {
-    log2(`Config ${configPath} uses retired keys (${translation.retiredKeys.join(", ")}); applied their current equivalents in memory`);
-  } else if (translation.legacyInput) {
+  if (tier === "user") {
+    if (translation.legacyInput) {
+      log2(`Config ${configPath} uses retired keys (${translation.retiredKeys.join(", ")}); applied their current equivalents in memory`);
+    }
+    if (translation.removedKeys.length > 0) {
+      configLoadNotices.push({
+        configPath,
+        digest: removedConfigKeysNoticeDigest(translation),
+        message: removedConfigKeysNoticeMessage(configPath, translation)
+      });
+    }
+  } else if (translation.legacyInput || translation.removedKeys.length > 0) {
     configLoadNotices.push({
       configPath,
       digest: noticeDigest(projection),
@@ -31104,6 +31494,13 @@ function mergeWorktreeConfig(baseWorktree, overrideWorktree) {
     return overrideWorktree;
   return { ...baseWorktree, ...overrideWorktree };
 }
+function mergeIdleConfig(baseIdle, overrideIdle) {
+  const merged = {
+    root_ttl_minutes: overrideIdle?.root_ttl_minutes ?? baseIdle?.root_ttl_minutes,
+    checkout_hours: overrideIdle?.checkout_hours ?? baseIdle?.checkout_hours
+  };
+  return merged.root_ttl_minutes === undefined && merged.checkout_hours === undefined ? undefined : merged;
+}
 function mergeInspectConfig(baseInspect, overrideInspect) {
   const diagnosticsTimeoutConfigured = baseInspect?.diagnostics_timeout_ms !== undefined || overrideInspect?.diagnostics_timeout_ms !== undefined;
   const diagnosticsTimeoutMs = Math.max(clampInspectDiagnosticsTimeoutMs(baseInspect?.diagnostics_timeout_ms ?? DEFAULT_INSPECT_DIAGNOSTICS_TIMEOUT_MS), clampInspectDiagnosticsTimeoutMs(overrideInspect?.diagnostics_timeout_ms ?? DEFAULT_INSPECT_DIAGNOSTICS_TIMEOUT_MS));
@@ -31182,19 +31579,10 @@ function mergeBashConfig(baseBash, overrideBash, mode = "tier") {
   return merged;
 }
 function mergeExperimentalConfig(base, override) {
-  const bash = {
-    ...base?.bash,
-    ...override?.bash
-  };
   const experimental = {
     ...base,
     ...override
   };
-  if (Object.values(bash).some((value) => value !== undefined)) {
-    experimental.bash = bash;
-  } else {
-    delete experimental.bash;
-  }
   if (Object.values(experimental).every((value) => value === undefined))
     return;
   return Object.fromEntries(Object.entries(experimental).filter(([, value]) => value !== undefined));
@@ -31341,17 +31729,21 @@ function mergeConfigs(base, override) {
   }
   const inspect = mergeInspectConfig(base.inspect, override.inspect);
   const worktree = mergeWorktreeConfig(base.worktree, override.worktree);
+  const idle = mergeIdleConfig(base.idle, override.idle);
   const sandbox = mergeSandboxConfig(base.sandbox, override.sandbox);
   const remoteExec = mergeRemoteExecConfig(base.remote_exec, override.remote_exec);
   const backup = mergeProjectBackupConfig(base.backup, override.backup);
   const pi = mergePiConfig(base.pi, override.pi);
+  const views = base.views !== undefined || override.views !== undefined ? { ...base.views, ...override.views } : undefined;
   const bridge = base.bridge;
   const safeOverride = pickProjectSafeFields(override);
   delete safeOverride.indexes;
   delete safeOverride.bash;
   delete safeOverride.inspect;
   delete safeOverride.worktree;
+  delete safeOverride.idle;
   delete safeOverride.pi;
+  delete safeOverride.views;
   return {
     ...base,
     ...safeOverride,
@@ -31361,10 +31753,12 @@ function mergeConfigs(base, override) {
     ...bash !== undefined ? { bash } : {},
     ...inspect !== undefined ? { inspect } : {},
     ...worktree !== undefined ? { worktree } : {},
+    ...idle !== undefined ? { idle } : {},
     ...sandbox !== undefined ? { sandbox } : {},
     ...remoteExec !== undefined ? { remote_exec: remoteExec } : {},
     ...backup !== undefined ? { backup } : {},
     ...pi !== undefined ? { pi } : {},
+    ...views !== undefined ? { views } : {},
     experimental,
     semantic,
     search,
@@ -31680,9 +32074,9 @@ function detectPiHarness(api) {
 }
 
 // src/omp-approval.ts
-import { realpathSync as realpathSync7 } from "node:fs";
+import { realpathSync as realpathSync8 } from "node:fs";
 import { homedir as homedir15 } from "node:os";
-import { basename as basename4, dirname as dirname11, isAbsolute as isAbsolute10, join as join18, relative as relative6, resolve as resolve12, sep as sep2 } from "node:path";
+import { basename as basename4, dirname as dirname12, isAbsolute as isAbsolute10, join as join19, relative as relative6, resolve as resolve14, sep as sep2 } from "node:path";
 var OMP_TOOL_TIERS = {
   read: "read",
   grep: "read",
@@ -31727,7 +32121,7 @@ function expandPath(value) {
   if (decoded === "~")
     return homedir15();
   if (decoded.startsWith("~/") || decoded.startsWith(`~${sep2}`))
-    return resolve12(homedir15(), decoded.slice(2));
+    return resolve14(homedir15(), decoded.slice(2));
   return decoded;
 }
 function realLocation(path) {
@@ -31735,12 +32129,12 @@ function realLocation(path) {
   let current = path;
   for (;; ) {
     try {
-      return missing.length > 0 ? join18(realpathSync7(current), ...missing) : realpathSync7(current);
+      return missing.length > 0 ? join19(realpathSync8(current), ...missing) : realpathSync8(current);
     } catch (error) {
       if (error.code !== "ENOENT")
         throw error;
     }
-    const parent = dirname11(current);
+    const parent = dirname12(current);
     if (parent === current)
       return path;
     missing.unshift(basename4(current));
@@ -31755,7 +32149,7 @@ function namesOutsidePath(root, value) {
   const expanded = expandPath(value);
   if (expanded.startsWith("file:"))
     return false;
-  const absolute = isAbsolute10(expanded) ? expanded : resolve12(root, expanded);
+  const absolute = isAbsolute10(expanded) ? expanded : resolve14(root, expanded);
   if (relativePathEscapesRoot(relative6(root, absolute)))
     return true;
   try {
@@ -31791,11 +32185,10 @@ function unquote(value) {
   const first = value[0];
   return value.length >= 2 && (first === '"' || first === "'") && value.endsWith(first) ? value.slice(1, -1) : value;
 }
-function hashlinePatchPaths(patch) {
+function hashlinePatchSections(patch) {
   if (patch.trim().length === 0)
     return;
-  const paths = [];
-  let sections = 0;
+  const sections = [];
   const rows = patch.split(`
 `);
   for (let index = 0;index < rows.length; index++) {
@@ -31811,28 +32204,31 @@ function hashlinePatchPaths(patch) {
       const hash = inner.indexOf("#");
       if (hash <= 0)
         return;
-      paths.push(inner.slice(0, hash));
-      sections++;
+      sections.push({ path: inner.slice(0, hash), moves: [] });
       continue;
     }
     const directive = /^(PUT|CUT|REM|MV)(?:\s|$)/.exec(line);
     if (directive) {
-      if (sections === 0)
+      const current = sections[sections.length - 1];
+      if (current === undefined)
         return;
       if (directive[1] === "MV") {
         const destination = line.slice(2).trim();
         if (destination.length === 0 || /\s/.test(destination))
           return;
-        paths.push(unquote(destination));
+        current.moves.push(unquote(destination));
       }
       continue;
     }
-    if (trimmed.length === 0 && sections === 0)
+    if (trimmed.length === 0 && sections.length === 0)
       continue;
-    if (sections === 0 || !line.startsWith("+"))
+    if (sections.length === 0 || !line.startsWith("+"))
       return;
   }
-  return sections > 0 ? paths : undefined;
+  return sections.length > 0 ? sections : undefined;
+}
+function hashlinePatchPaths(patch) {
+  return hashlinePatchSections(patch)?.flatMap((section) => [section.path, ...section.moves]);
 }
 var APPLY_PATCH_TARGETS = [
   "*** Add File:",
@@ -32492,14 +32888,14 @@ function registerStatusCommand(pi, ctx) {
 
 // src/lsp-auto-install.ts
 import { existsSync as existsSync15, mkdirSync as mkdirSync7, renameSync as renameSync10, rmSync as rmSync7, statSync as statSync12, writeFileSync as writeFileSync9 } from "node:fs";
-import { join as join21 } from "node:path";
+import { join as join22 } from "node:path";
 
 // src/lsp-cache.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
 import {
-  closeSync as closeSync10,
+  closeSync as closeSync11,
   mkdirSync as mkdirSync6,
-  openSync as openSync9,
+  openSync as openSync10,
   readFileSync as readFileSync12,
   renameSync as renameSync9,
   rmSync as rmSync6,
@@ -32507,7 +32903,7 @@ import {
   unlinkSync as unlinkSync6,
   writeFileSync as writeFileSync8
 } from "node:fs";
-import { join as join19 } from "node:path";
+import { join as join20 } from "node:path";
 
 // src/atomic-file.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
@@ -32530,18 +32926,18 @@ function lspCacheRoot() {
   return getAftLspPackagesDir();
 }
 function lspPackageDir(npmPackage) {
-  return join19(lspCacheRoot(), encodeURIComponent(npmPackage));
+  return join20(lspCacheRoot(), encodeURIComponent(npmPackage));
 }
 function lspBinaryPath(npmPackage, binary) {
-  return join19(lspPackageDir(npmPackage), "node_modules", ".bin", binary);
+  return join20(lspPackageDir(npmPackage), "node_modules", ".bin", binary);
 }
 function lspBinDir(npmPackage) {
-  return join19(lspPackageDir(npmPackage), "node_modules", ".bin");
+  return join20(lspPackageDir(npmPackage), "node_modules", ".bin");
 }
 function isInstalled(npmPackage, binary) {
   for (const candidate of lspBinaryCandidates(binary)) {
     try {
-      if (statSync11(join19(lspBinDir(npmPackage), candidate)).isFile())
+      if (statSync11(join20(lspBinDir(npmPackage), candidate)).isFile())
         return true;
     } catch {}
   }
@@ -32561,13 +32957,13 @@ function writeInstalledMetaIn(installDir, version, sha256) {
       installedAt: new Date().toISOString(),
       ...sha256 ? { sha256 } : {}
     };
-    writeAtomicFile(join19(installDir, INSTALLED_META_FILE), JSON.stringify(meta));
+    writeAtomicFile(join20(installDir, INSTALLED_META_FILE), JSON.stringify(meta));
   } catch (err) {
     log2(`[lsp-cache] failed to write installed-meta in ${installDir}: ${err}`);
   }
 }
 function readInstalledMetaIn(installDir) {
-  const path = join19(installDir, INSTALLED_META_FILE);
+  const path = join20(installDir, INSTALLED_META_FILE);
   try {
     if (!statSync11(path).isFile())
       return null;
@@ -32591,7 +32987,7 @@ function readInstalledMeta(packageKey) {
   return readInstalledMetaIn(lspPackageDir(packageKey));
 }
 function lockPath(npmPackage) {
-  return join19(lspPackageDir(npmPackage), ".aft-installing");
+  return join20(lspPackageDir(npmPackage), ".aft-installing");
 }
 var STALE_LOCK_MS2 = 30 * 60 * 1000;
 function acquireInstallLock(lockKey) {
@@ -32600,14 +32996,14 @@ function acquireInstallLock(lockKey) {
   const token = randomUUID3();
   const tryClaim = () => {
     try {
-      const fd = openSync9(lock, "wx");
+      const fd = openSync10(lock, "wx");
       try {
         writeFileSync8(fd, `${process.pid}
 ${new Date().toISOString()}
 ${token}
 `);
       } finally {
-        closeSync10(fd);
+        closeSync11(fd);
       }
       let retained = false;
       let released = false;
@@ -32722,7 +33118,7 @@ var AUTO_INSTALL_STAMP_FILE = "last-lsp-autoinstall.json";
 var AUTO_INSTALL_WINDOW_MS = 60 * 1000;
 var AUTO_INSTALL_LOCK_STALE_MS = 30 * 60 * 1000;
 function autoInstallStampPath() {
-  return join19(aftCacheBase(), AUTO_INSTALL_STAMP_FILE);
+  return join20(aftCacheBase(), AUTO_INSTALL_STAMP_FILE);
 }
 function hasRecentAutoInstallStamp(path) {
   try {
@@ -32770,11 +33166,11 @@ function claimLspAutoInstallPass() {
   };
   const tryClaim = () => {
     try {
-      const fd = openSync9(lock, "wx");
+      const fd = openSync10(lock, "wx");
       try {
         writeFileSync8(fd, JSON.stringify(owner));
       } finally {
-        closeSync10(fd);
+        closeSync11(fd);
       }
       return true;
     } catch (err) {
@@ -32823,7 +33219,7 @@ function claimLspAutoInstallPass() {
 }
 var VERSION_CHECK_FILE = ".aft-version-check";
 function readVersionCheck(npmPackage) {
-  const file = join19(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
+  const file = join20(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
   try {
     const raw = readFileSync12(file, "utf8");
     const parsed = JSON.parse(raw);
@@ -32840,7 +33236,7 @@ function readVersionCheck(npmPackage) {
 }
 function writeVersionCheck(npmPackage, latest) {
   mkdirSync6(lspPackageDir(npmPackage), { recursive: true });
-  const file = join19(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
+  const file = join20(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
   const record = {
     last_checked: new Date().toISOString(),
     latest_eligible: latest
@@ -32957,7 +33353,7 @@ function isVersionSupported(spec, version) {
 
 // src/lsp-project-relevance.ts
 import { existsSync as existsSync14, readdirSync as readdirSync5, readFileSync as readFileSync13 } from "node:fs";
-import { join as join20 } from "node:path";
+import { join as join21 } from "node:path";
 var MAX_WALK_DIRS = 200;
 var MAX_WALK_DEPTH = 4;
 var NOISE_DIRS = new Set([
@@ -32974,7 +33370,7 @@ function hasRootMarker(projectRoot, rootMarkers) {
   if (!rootMarkers)
     return false;
   for (const marker of rootMarkers) {
-    if (existsSync14(join20(projectRoot, marker)))
+    if (existsSync14(join21(projectRoot, marker)))
       return true;
   }
   return false;
@@ -32998,7 +33394,7 @@ function hasPackageJsonDep(projectRoot, depNames) {
 }
 function readPackageJson(projectRoot) {
   try {
-    const raw = readFileSync13(join20(projectRoot, "package.json"), "utf8");
+    const raw = readFileSync13(join21(projectRoot, "package.json"), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null)
       return null;
@@ -33028,7 +33424,7 @@ function relevantExtensionsInProject(projectRoot, extToServer) {
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (current.depth < MAX_WALK_DEPTH && !NOISE_DIRS.has(entry.name.toLowerCase())) {
-          queue.push({ dir: join20(current.dir, entry.name), depth: current.depth + 1 });
+          queue.push({ dir: join21(current.dir, entry.name), depth: current.depth + 1 });
         }
         continue;
       }
@@ -33161,7 +33557,7 @@ async function resolveTargetVersion(spec, config, fetchImpl = fetch) {
 }
 function ensureInstallAnchor(cwd) {
   try {
-    const stub = join21(cwd, "package.json");
+    const stub = join22(cwd, "package.json");
     if (!existsSync15(stub)) {
       writeFileSync9(stub, `${JSON.stringify({ name: "aft-lsp-cache", version: "0.0.0", private: true })}
 `);
@@ -33178,18 +33574,26 @@ async function runInstall(spec, version, cwd, installLock, before, signal, deadl
     warn2(`[lsp] install ${target} aborted before spawn`);
     return false;
   }
-  const npm = resolveNpm();
-  if (!npm) {
+  const preferredNpm = resolveNpm();
+  if (!preferredNpm) {
     warn2(`[lsp] npm not found on PATH or known locations; cannot install ${target}`);
     return false;
   }
+  const selected = await selectLspNpm(preferredNpm, undefined, signal);
+  if (signal?.aborted)
+    return false;
+  if (!selected.npm) {
+    warn2(`[lsp] ${selected.refusal}`);
+    return false;
+  }
+  const npm = selected.npm;
   const invocation = await lspNpmInstallInvocation(npm, target, before);
   if (signal?.aborted) {
     warn2(`[lsp] install ${target} aborted during npm capability probe`);
     return false;
   }
   if (!invocation) {
-    warn2(`[lsp] npm cannot enforce the publication cutoff; cannot install ${target}`);
+    warn2(`[lsp] ${lspNpmRefusal(npm.command, "probe failed: cannot verify publication-cutoff support")}`);
     return false;
   }
   ensureInstallAnchor(cwd);
@@ -33271,6 +33675,9 @@ async function runInstall(spec, version, cwd, installLock, before, signal, deadl
         log2(`[lsp] installed ${target}`);
         finish(true);
       } else {
+        const rejectedOption = /--(?:no-save|before|ignore-scripts)\b/.exec(stderrBuf)?.[0];
+        if (rejectedOption)
+          warn2(`[lsp] ${lspNpmRefusal(npm.command, `rejected option: ${rejectedOption}`)}`);
         error2(`[lsp] install ${target} exited with code ${code}; last stderr:
 ${stderrBuf.trim()}`);
         finish(false);
@@ -33377,10 +33784,10 @@ function sha256OfFileSync(path) {
 }
 function quarantineCachedNpmInstall(spec, reason) {
   const packageDir = lspPackageDir(spec.npm);
-  const dest = join21(packageDir, "..", ".quarantine", encodeURIComponent(spec.npm), `${Date.now()}`);
+  const dest = join22(packageDir, "..", ".quarantine", encodeURIComponent(spec.npm), `${Date.now()}`);
   warn2(`[lsp] tofu_mismatch ${spec.npm}: ${reason}; quarantining ${packageDir} -> ${dest}`);
   try {
-    mkdirSync7(join21(dest, ".."), { recursive: true });
+    mkdirSync7(join22(dest, ".."), { recursive: true });
     rmSync7(dest, { recursive: true, force: true });
     renameSync10(packageDir, dest);
   } catch (err) {
@@ -34113,9 +34520,9 @@ import { StringEnum } from "@earendil-works/pi-ai";
 import { Type as Type4 } from "typebox";
 
 // src/tools/hoisted.ts
-import { stat as stat3 } from "node:fs/promises";
+import { stat as stat4 } from "node:fs/promises";
 import { homedir as homedir16 } from "node:os";
-import { isAbsolute as isAbsolute11, relative as relative7, resolve as resolve13, sep as sep3 } from "node:path";
+import { isAbsolute as isAbsolute11, relative as relative7, resolve as resolve15, sep as sep3 } from "node:path";
 import {
   renderDiff as renderDiff2
 } from "@earendil-works/pi-coding-agent";
@@ -34303,17 +34710,17 @@ function normalizePathInput(path) {
   if (decoded === "~")
     return homedir16();
   if (decoded.startsWith(`~${sep3}`) || decoded.startsWith("~/")) {
-    return resolve13(homedir16(), decoded.slice(2));
+    return resolve15(homedir16(), decoded.slice(2));
   }
   return decoded;
 }
 function absoluteSearchPath(cwd, target) {
   const expanded = normalizePathInput(target);
-  return isAbsolute11(expanded) ? expanded : resolve13(cwd, expanded);
+  return isAbsolute11(expanded) ? expanded : resolve15(cwd, expanded);
 }
 async function searchPathExists(cwd, target) {
   try {
-    await stat3(absoluteSearchPath(cwd, target));
+    await stat4(absoluteSearchPath(cwd, target));
     return true;
   } catch {
     return false;
@@ -34365,7 +34772,7 @@ async function assertExternalDirectoryPermission(extCtx, target, options = {}) {
   if (!target)
     return;
   const expanded = normalizePathInput(target);
-  const absoluteTarget = isAbsolute11(expanded) ? expanded : resolve13(extCtx.cwd, expanded);
+  const absoluteTarget = isAbsolute11(expanded) ? expanded : resolve15(extCtx.cwd, expanded);
   if (containsPath(extCtx.cwd, absoluteTarget))
     return;
   if (options.restrictToProjectRoot === false)
@@ -34374,7 +34781,7 @@ async function assertExternalDirectoryPermission(extCtx, target, options = {}) {
 }
 async function assertExternalReadPermission(ctx, extCtx, target, restrictToProjectRoot = ctx.config.restrict_to_project_root ?? false) {
   const expanded = normalizePathInput(target);
-  const absoluteTarget = isAbsolute11(expanded) ? expanded : resolve13(extCtx.cwd, expanded);
+  const absoluteTarget = isAbsolute11(expanded) ? expanded : resolve15(extCtx.cwd, expanded);
   if (!restrictToProjectRoot || containsPath(extCtx.cwd, absoluteTarget))
     return;
   try {
@@ -34707,7 +35114,13 @@ PDFs aren't supported on the Pi harness yet.`, response);
         const response = await callToolCallForSession(bridge, "edit", rawArgs, sessionId, extCtx);
         if (response.success === false)
           throw toolErrorFromResponse("edit", response);
-        return buildMutationResult(response);
+        return buildHashlineMutationResult(response);
+      },
+      renderCall(args, theme, context) {
+        return renderHashlineEditCall(args, theme, context);
+      },
+      renderResult(result, options = { expanded: false, isPartial: false }, theme, context) {
+        return renderMutationResult(result, theme, context, options);
       }
     });
   }
@@ -34883,6 +35296,71 @@ ${formatDiagnosticsText(diagnostics)}`;
     }
   };
 }
+function buildHashlineMutationResult(response) {
+  const result = buildMutationResult(response);
+  const rows = asRecords2(asRecord3(response.metadata)?.files);
+  const files = rows.map(hashlineFileDetails);
+  if (files.length === 0)
+    return result;
+  const changed = files.filter((file) => file.diff !== undefined);
+  const diff = changed.length === 0 ? undefined : files.length === 1 ? files[0]?.diff : files.map((file) => file.diff === undefined ? mutationFileHeader(file) : `${mutationFileHeader(file)}
+${file.diff}`).join(`
+`);
+  const firstChangedLine = rows.map((row) => firstChangedLineOfPatch(asString2(row.patch) ?? "")).find((line) => line !== undefined);
+  return {
+    ...result,
+    details: {
+      ...result.details,
+      diff,
+      firstChangedLine,
+      additions: files.reduce((sum, file) => sum + file.additions, 0),
+      deletions: files.reduce((sum, file) => sum + file.deletions, 0),
+      files
+    }
+  };
+}
+function hashlineFileDetails(row) {
+  const patch = asString2(row.patch) ?? "";
+  const diff = formatUnifiedDiffForPi(patch);
+  return {
+    path: asString2(row.relativePath) ?? "",
+    sourcePath: asString2(row.sourcePath) ?? asString2(row.movePath),
+    diff: diff.length > 0 ? diff : undefined,
+    additions: asNumber2(row.additions) ?? 0,
+    deletions: asNumber2(row.deletions) ?? 0
+  };
+}
+function firstChangedLineOfPatch(patch) {
+  let newLine;
+  for (const line of patch.split(`
+`)) {
+    const hunk = /^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/.exec(line);
+    if (hunk) {
+      newLine = Number(hunk[1]);
+      continue;
+    }
+    if (newLine === undefined)
+      continue;
+    if (line.startsWith("+") || line.startsWith("-"))
+      return Math.max(1, newLine);
+    if (line.startsWith(" "))
+      newLine++;
+  }
+  return;
+}
+function mutationFileName(file) {
+  return file.sourcePath ? `${shortenHomePath(file.sourcePath)} → ${shortenHomePath(file.path)}` : shortenHomePath(file.path);
+}
+function mutationFileHeader(file) {
+  return `${mutationFileName(file)} (+${file.additions}/-${file.deletions})`;
+}
+function mutationFilesLabel(files) {
+  const first = files?.[0];
+  if (!first || !files)
+    return;
+  const name = mutationFileName(first);
+  return files.length > 1 ? `${name} and ${files.length - 1} more` : name;
+}
 function formatGlobSkipReasonsNote(reasons) {
   if (!Array.isArray(reasons))
     return;
@@ -34934,6 +35412,29 @@ function renderMutationCall(toolName, filePath, theme, context) {
   text.setText(`${theme.fg("toolTitle", theme.bold(toolName))} ${pathDisplay}`);
   return text;
 }
+function renderHashlineEditCall(args, theme, context) {
+  const text = reuseText2(context.lastComponent);
+  const target = hashlinePatchTarget(asString2(asRecord3(args)?.patch));
+  const targetDisplay = target ? `${theme.fg("accent", target.name)}${target.more > 0 ? theme.fg("muted", ` and ${target.more} more`) : ""}` : theme.fg("toolOutput", "...");
+  text.setText(`${theme.fg("toolTitle", theme.bold("edit"))} ${targetDisplay}`);
+  return text;
+}
+function hashlinePatchTarget(patch) {
+  if (!patch)
+    return;
+  const sections = hashlinePatchSections(patch) ?? hashlinePatchSections(patch.slice(0, patch.lastIndexOf(`
+`) + 1));
+  const first = sections?.[0];
+  if (!sections || !first)
+    return;
+  const destination = first.moves[first.moves.length - 1];
+  const name = destination ? `${shortenHomePath(first.path)} → ${shortenHomePath(destination)}` : shortenHomePath(first.path);
+  const others = new Set(sections.flatMap((section) => [section.path, ...section.moves]));
+  others.delete(first.path);
+  if (destination)
+    others.delete(destination);
+  return { name, more: others.size };
+}
 function renderMutationResult(result, theme, context, options = { expanded: true }) {
   if (context.isError) {
     const errorText = result.content.filter((c) => c.type === "text").map((c) => c.text ?? "").join(`
@@ -34969,15 +35470,21 @@ ${summary}${suffix}`);
   const container = reuseContainer2(context.lastComponent);
   container.clear();
   container.addChild(new Spacer2(1));
-  let renderedDiff;
-  try {
-    renderedDiff = renderDiff2(diff);
-  } catch {
-    renderedDiff = diff;
+  const files = details?.files ?? [];
+  if (files.length > 1) {
+    for (const file of files) {
+      const counts = theme.fg("muted", ` (+${file.additions}/-${file.deletions})`);
+      container.addChild(new Text3(`${theme.fg("accent", mutationFileName(file))}${counts}`, 1, 0));
+      if (file.diff !== undefined) {
+        container.addChild(new Text3(renderTerminalDiff(file.diff), 1, 0));
+      }
+    }
+  } else {
+    container.addChild(new Text3(renderTerminalDiff(diff), 1, 0));
   }
-  container.addChild(new Text3(normalizeTerminalText(renderedDiff), 1, 0));
   const rawPath = context.args && typeof context.args === "object" && typeof context.args.path === "string" ? context.args.path : undefined;
-  const summaryPath = rawPath ? ` ${shortenHomePath(rawPath)}` : "";
+  const summaryLabel = rawPath ? shortenHomePath(rawPath) : mutationFilesLabel(details?.files);
+  const summaryPath = summaryLabel ? ` ${summaryLabel}` : "";
   const summary = `edited${summaryPath} (+${details?.additions ?? 0}/-${details?.deletions ?? 0})`;
   return collapsibleResult({
     summary,
@@ -34986,11 +35493,20 @@ ${summary}${suffix}`);
     context
   });
 }
+function renderTerminalDiff(diff) {
+  let renderedDiff;
+  try {
+    renderedDiff = renderDiff2(diff);
+  } catch {
+    renderedDiff = diff;
+  }
+  return normalizeTerminalText(renderedDiff);
+}
 async function resolvePathArg(cwd, path) {
   const expanded = normalizePathInput(path);
   const abs = absoluteSearchPath(cwd, path);
   try {
-    await stat3(abs);
+    await stat4(abs);
     return abs;
   } catch {
     return expanded;
@@ -35565,7 +36081,7 @@ function getBashSpawnHook(pi) {
 function backgroundWaitSentence(c) {
   if (c.watch) {
     const noPolling = c.status ? ", and never loop `bash_status` to wait" : "";
-    return `then \`bash_watch\` handles only a short remaining wait (in a main session a watch defaults to 30s, max bash.watch_sync_max_ms, 120s by default; in a delegated session a watch 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); for anything longer end the turn and let the completion reminder wake you, or use bash({wait:true}) when the result is needed before anything else — never background a command and immediately \`bash_watch\` it (that wastes a turn for what foreground returns in one)${noPolling}.`;
+    return `then \`bash_watch\` handles only a short remaining wait (in a main session a watch defaults to 30s, max bash.watch_sync_max_ms, 120s by default; in a delegated session a watch 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); for anything longer, first do the work that doesn't need this result, end the turn only when everything left needs it, and let the completion reminder wake you, or use bash({wait:true}) when the result is needed before anything else — never background a command and immediately \`bash_watch\` it (that wastes a turn for what foreground returns in one)${noPolling}.`;
   }
   return c.status ? "the task keeps running after the call returns, a completion reminder arrives when it exits, and `bash_status` reports its state and output. Use bash({wait:true}) instead when the result is needed before anything else." : "the task keeps running after the call returns and a completion reminder arrives when it exits. Use bash({wait:true}) instead when the result is needed before anything else.";
 }
@@ -35602,7 +36118,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 (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)} Do not change or delete files a background command uses until it finishes. 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 work to do while it runs, and any work that doesn't need this command's result counts; ${backgroundWaitSentence(companions)} Do not change or delete files a background command uses until it finishes. 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,
@@ -35833,7 +36349,7 @@ function createBashWatchTool(ctx) {
   return {
     name: "bash_watch",
     label: "bash_watch",
-    description: `Watch a background bash task. ${WATCH_SYNC_DEFAULTS_DESCRIPTION}. In a main session sync waits are for a short remaining wait on a task; for anything longer end the turn on \`bash({background:true})\` and let the completion reminder wake you, or use \`bash({wait:true})\` when the result is needed before anything else. The user can interrupt anytime; the wait auto-converts to an async notification. Async (background:true, requires pattern) registers a non-blocking notification and returns immediately — use when you have parallel work or want to end your turn.${bashCompanionRegistered(ctx.config, "bash_status") ? " Never loop bash_status to wait." : ""}`,
+    description: `Watch a background bash task. ${WATCH_SYNC_DEFAULTS_DESCRIPTION}. In a main session sync waits are for a short remaining wait on a task; for anything longer, first do the work that doesn't need the result, end the turn only when everything left needs it, and let the completion reminder wake you, or use \`bash({wait:true})\` when the result is needed before anything else. The user can interrupt anytime; the wait auto-converts to an async notification. Async (background:true, requires pattern) registers a non-blocking notification and returns immediately — use when you have parallel work or want to end your turn.${bashCompanionRegistered(ctx.config, "bash_status") ? " Never loop bash_status to wait." : ""}`,
     promptSnippet: "Wait for or watch a background bash task",
     parameters: BashWatchParams,
     async execute(_toolCallId, params, signal, _onUpdate, extCtx) {
@@ -37244,7 +37760,7 @@ function registerNavigateTool(pi, ctx) {
   const navigateTool = withPathAliasPreparation({
     name: "aft_callgraph",
     label: "callgraph",
-    description: `Answer code-relationship questions from a real call graph — instead of grep + read chains. Reach for this whenever the question is about how symbols connect. ${zoomEnabled ? "Use aft_zoom with `callgraph:true` for one-level forward calls-out while reading source; use aft_callgraph only for reverse callers or multi-level traces so you do not double-fetch the same relationships." : "Use aft_callgraph call_tree (depth 1) for one-level forward calls-out; use it for reverse callers or multi-level traces."} All ops require both \`path\` and \`symbol\`. Use \`callers\` for call sites (before renaming/signature changes), \`impact\` for blast radius (what breaks if a symbol changes), \`call_tree\` for what a function calls, \`trace_to\` for how execution reaches a symbol from entry points, \`trace_to_symbol\` for the shortest path from one symbol to another (requires \`toSymbol\`; if ambiguous, the error returns candidate files — retry with \`toPath\`), \`trace_data\` to follow a value across assignments/params. Markers: ~ = edge resolved by name only (may point at the wrong same-named symbol); [unresolved] = callee not resolved to a definition, so the location shown is the call site. Unmarked edges are resolved exactly. By default, unresolved external/stdlib leaf calls in call_tree are collapsed into one summary per parent; pass includeUnresolved=true to show every unresolved edge individually. 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.`,
+    description: `Answer code-relationship questions from a real call graph — instead of grep + read chains. Reach for this whenever the question is about how symbols connect. ${zoomEnabled ? "Use aft_zoom with `callgraph:true` for one-level forward calls-out while reading source; use aft_callgraph only for reverse callers or multi-level traces so you do not double-fetch the same relationships." : "Use aft_callgraph call_tree (depth 1) for one-level forward calls-out; use it for reverse callers or multi-level traces."} All ops require both \`path\` and \`symbol\`. Use \`callers\` for call sites (before renaming/signature changes), \`impact\` for blast radius (what breaks if a symbol changes), \`call_tree\` for what a function calls, \`trace_to\` for how execution reaches a symbol (each path runs back to a root labelled main, test, attribute, public API, or no caller found), \`trace_to_symbol\` for the shortest path from one symbol to another (requires \`toSymbol\`; if ambiguous, the error returns candidate files — retry with \`toPath\`), \`trace_data\` to follow a value across assignments/params. Markers: ~ = edge resolved by name only (may point at the wrong same-named symbol); [unresolved] = callee not resolved to a definition, so the location shown is the call site. Unmarked edges are resolved exactly. By default, unresolved external/stdlib leaf calls in call_tree are collapsed into one summary per parent; pass includeUnresolved=true to show every unresolved edge individually. 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: navigateParamsSchema(),
     async execute(_toolCallId, params, _signal, _onUpdate, extCtx) {
       if (isEmptyParam(params.path)) {
@@ -37882,7 +38398,7 @@ function registerSafetyTool(pi, ctx) {
 
 // src/tools/semantic.ts
 import { homedir as homedir17 } from "node:os";
-import { isAbsolute as isAbsolute12, resolve as resolve14 } from "node:path";
+import { isAbsolute as isAbsolute12, resolve as resolve16 } from "node:path";
 import { Type as Type13 } from "typebox";
 var FILESYSTEM_SCAN_STATUS = "answered by a filesystem scan";
 function semanticHonestyNote(response, theme) {
@@ -37905,8 +38421,8 @@ function selectedProjectRoot(cwd, pathArg) {
   const target = pathArg?.trim();
   if (!target)
     return canonicalizeProjectRoot(cwd);
-  const expanded = target === "~" ? homedir17() : /^~[/\\]/u.test(target) ? resolve14(homedir17(), target.slice(2)) : target;
-  return canonicalizeProjectRoot(isAbsolute12(expanded) ? expanded : resolve14(cwd, expanded));
+  const expanded = target === "~" ? homedir17() : /^~[/\\]/u.test(target) ? resolve16(homedir17(), target.slice(2)) : target;
+  return canonicalizeProjectRoot(isAbsolute12(expanded) ? expanded : resolve16(cwd, expanded));
 }
 function continuityKey(projectRoot, query, includeTests, topK) {
   return JSON.stringify([
@@ -38551,15 +39067,15 @@ function buildWorkflowHints(opts) {
 `));
   }
   if (hasInspect) {
-    sections.push("**Codebase health & diagnostics**: AFT does not surface compile/type errors automatically after edits — pull them with `aft_inspect`. Run it after a batch of edits and before you run tests or commit, when starting in unfamiliar code, or before a refactor/review. One call summarizes diagnostics (compile/type errors), TODOs, metrics, dead code, unused exports, and duplicates; pass `sections` for focused drill-down and `scope` to actively pull diagnostics for a specific file or directory. Its diagnostics are a fast checkpoint, not the authority — a clean `tsc` / `cargo check` / `pyright` run is the real gate. Treat stale_categories/pending_categories as stale or incomplete cache state. AFT schedules a Tier-2 refresh after its next idle or inspect-triggered background run; use one later normal aft_inspect after that refresh, not a polling loop.");
-    sections.push("**AFT status bar**: tool results may end with a one-line health bar `[AFT E<errors> W<warnings> | D<dead-code> U<unused-exports> C<clone/dup-groups> | T<todos>]` — an IDE-style glance that appears when a count changes. `E`/`W` are live LSP diagnostics for files touched this session (your universal compile-error signal across every language with an LSP). A `~` before `D` means the dead-code/unused/dup counts predate your latest edit — run `aft_inspect` for current numbers and detail. A `?` in place of a number means that count has no value yet (not zero). When `E>0`, you likely just introduced errors; investigate before moving on.");
+    sections.push("**Codebase health & diagnostics**: AFT does not surface compile/type errors automatically after edits — pull them with `aft_inspect`. Run it after a batch of edits and before you run tests or commit, when starting in unfamiliar code, or before a refactor/review. One call summarizes diagnostics (compile/type errors), TODOs, metrics, dead code, unused exports, and duplicates; pass `sections` for focused drill-down and `scope` to actively pull diagnostics for a specific file or directory. Its diagnostics are a fast checkpoint, not the authority — a clean `tsc` / `cargo check` / `pyright` run is the real gate. Dead code, unused exports, duplicates, cycles and complexity are computed only when you call aft_inspect, and the call waits until they are current; nothing refreshes them in the background, so run it again after further edits instead of polling.");
+    sections.push("**AFT status bar**: tool results may end with a one-line health bar `[AFT E<errors> W<warnings> | T<todos>]` — an IDE-style glance that appears when a count changes. `E`/`W` are live LSP diagnostics for files touched this session (your universal compile-error signal across every language with an LSP). Dead code, unused exports and duplicates are not on the bar; run `aft_inspect` for them. A `?` in place of a number means that count has no value yet (not zero). When `E>0`, you likely just introduced errors; investigate before moving on.");
   }
   if (hasNavigate) {
     sections.push([
       "Use `aft_callgraph` for code-relationship questions instead of grep + read chains:",
       "- `callers` — find all call sites before changing a function signature",
       "- `impact` — blast radius (which functions/files will need updates)",
-      "- `trace_to` — how execution reaches this code from entry points (routes, exports, main)",
+      "- `trace_to` — how execution reaches this code; each path runs back to a root labelled main, test, attribute, public API, or no caller found",
       "- `trace_to_symbol` — shortest call path from one symbol to another",
       "- `trace_data` — follow a value through assignments and parameters across files"
     ].join(`
@@ -38694,18 +39210,18 @@ function createVersionMismatchHandler(getPool, ensureCompatibleBinary = ensureBi
 }
 var PLUGIN_VERSION = (() => {
   try {
-    const req = createRequire2(import.meta.url);
+    const req = createRequire3(import.meta.url);
     return req("../package.json").version;
   } catch {
     return "0.0.0";
   }
 })();
-var ANNOUNCEMENT_VERSION = "0.63.0";
+var ANNOUNCEMENT_VERSION = "0.64.0";
 var ANNOUNCEMENT_FEATURES = [
-  "Cap a shell command's total memory, background and terminal commands included, with `bash.memory_limit_mib`.",
-  "Shell results can list or diff the files a command changed: set `bash.changed_files` to `list` or `diff`.",
-  "Put rebuildable caches on another disk with `storage.cache_dir`.",
-  "Call graphs mark callback references and link constructors, Python edits keep their indentation, and many reported issues are fixed."
+  "A new index store makes AFT much faster: call graphs build 26x faster, edits reach the call graph about 9x faster, dead-code checks run 4x faster, and the index takes 4x less disk and 3x less memory.",
+  "All worktrees of a repository share one index, so a new worktree is ready in under a second. `npx @cortexkit/aft cache prune-legacy` lists the old index folders and can remove them.",
+  "`trace_to` labels each root it reaches: main, test, attribute, public API, or no caller found.",
+  "Dead code, unused exports, duplicates, cycles and complexity run only when `aft_inspect` is called; the status bar shows errors, warnings and TODOs."
 ];
 var ANNOUNCEMENT_FOOTER = "Join us on Discord: https://discord.gg/DSa65w8wuf";
 var pendingEagerWarnings = new Map;