@cortexkit/aft-opencode 0.63.4 → 0.64.0

package/dist/index.js

@@ -9542,9 +9542,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";
 }
@@ -9799,6 +9800,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 {
 }
@@ -9833,6 +9835,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) => {
@@ -9854,20 +9860,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))
@@ -12111,8 +12119,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) {
@@ -12166,7 +12175,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",
@@ -12238,6 +12246,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 });
@@ -12253,6 +12284,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;
@@ -12266,6 +12304,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 = () => {
@@ -12319,8 +12359,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();
@@ -12359,6 +12425,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();
@@ -12515,8 +12592,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";
@@ -12734,7 +12811,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) {
@@ -12901,11 +12978,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 {
@@ -12976,8 +13053,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) {
@@ -12991,13 +13068,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;
@@ -13005,18 +13082,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);
@@ -13029,8 +13106,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)) {
@@ -13041,7 +13118,7 @@ function openPrivateStorageDir(root, path = root) {
       return;
     } finally {
       if (fd !== undefined)
-        closeSync3(fd);
+        closeSync4(fd);
     }
   }
 }
@@ -13864,7 +13941,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 {
@@ -13911,7 +13988,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;
@@ -13959,7 +14036,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);
@@ -13971,7 +14048,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)));
@@ -14048,7 +14125,7 @@ function errnoOf(error) {
 }
 function closeQuietly(fd) {
   try {
-    closeSync4(fd);
+    closeSync5(fd);
   } catch {}
 }
 
@@ -15923,16 +16000,16 @@ function getLifecycleRegistry() {
 }
 
 // ../aft-bridge/dist/project-identity.js
-import { createHash as createHash3 } from "node:crypto";
-import { realpathSync as realpathSync2 } from "node:fs";
-import { posix as posix2, resolve as resolve6, win32 as win322 } from "node:path";
+import { createHash as createHash4 } from "node:crypto";
+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);
 }
@@ -15972,7 +16049,7 @@ function hasDotComponent(path) {
   return path.split(/[\\/]/).some((component) => component === "." || component === "..");
 }
 function projectRootKeyHash(dir) {
-  return createHash3("sha256").update(canonicalizeProjectRoot(dir)).digest("hex").slice(0, 16);
+  return createHash4("sha256").update(canonicalizeProjectRoot(dir)).digest("hex").slice(0, 16);
 }
 
 // ../aft-bridge/dist/subc-transport.js
@@ -17915,7 +17992,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"}`);
@@ -18083,12 +18162,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);
@@ -18720,7 +18805,8 @@ function taskIdFromError(error) {
   return;
 }
 // ../aft-bridge/dist/feature-config.js
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
+import { createRequire } from "node:module";
 var CANONICAL_TOOLS = [
   "aft_callgraph",
   "aft_conflicts",
@@ -18770,23 +18856,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"],
@@ -18935,7 +19112,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(".");
@@ -18944,6 +19124,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"],
@@ -18976,23 +19179,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");
@@ -19005,6 +19210,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")) {
@@ -19043,8 +19249,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);
   }
@@ -19180,13 +19384,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);
@@ -19196,11 +19444,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) {
@@ -19208,6 +19462,7 @@ function translateConfigDocument(map, tier) {
     warnings: [],
     legacyInput: false,
     retiredKeys: [],
+    removedKeys: [],
     retiredEnabledFalse: false
   };
   translateBlock(map, tier === "user", "base", out);
@@ -19218,6 +19473,7 @@ function translateConfigDocument(map, tier) {
     }
   }
   out.retiredKeys = sortedUnique(out.retiredKeys);
+  out.removedKeys = sortedUnique(out.removedKeys);
   return out;
 }
 function unknownDisabledTools(disabled) {
@@ -19253,7 +19509,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))
@@ -19332,7 +19592,7 @@ function canonicalJson(value) {
   return JSON.stringify(value);
 }
 function noticeDigest(projection) {
-  return createHash4("sha256").update(canonicalJson(projection), "utf8").digest("hex");
+  return createHash5("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" });
@@ -20370,9 +20630,9 @@ async function releaseBridge(pool) {
   await pool.shutdown();
 }
 // ../aft-bridge/dist/lsp-github-install.js
-import { createHash as createHash5, 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 createHash6, 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";
 
@@ -20769,7 +21029,7 @@ function createGithubInstaller(services) {
   const MAX_EXTRACT_BYTES = 1024 * 1024 * 1024;
   function sha256OfFile(path) {
     return new Promise((resolve, reject) => {
-      const hash = createHash5("sha256");
+      const hash = createHash6("sha256");
       const stream = createReadStream2(path);
       stream.on("error", reject);
       stream.on("data", (chunk) => hash.update(chunk));
@@ -20777,17 +21037,17 @@ function createGithubInstaller(services) {
     });
   }
   function sha256OfFileSync(path) {
-    const hash = createHash5("sha256");
-    const fd = openSync4(path, "r");
+    const hash = createHash6("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");
   }
@@ -20995,7 +21255,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;
@@ -21021,12 +21281,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()) {
@@ -21789,6 +22049,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)}`);
@@ -21796,6 +22071,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] };
   }
@@ -22051,10 +22328,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)
@@ -22065,7 +22343,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()) {
@@ -22083,6 +22361,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}_])`;
@@ -22132,14 +22483,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 homedir10, 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 homedir8 } 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 || homedir8();
@@ -22149,16 +22500,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 [
@@ -22167,10 +22518,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);
@@ -22197,14 +22548,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([
@@ -22213,22 +22564,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;
@@ -22249,7 +22600,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;
@@ -22261,7 +22612,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 {}
 }
@@ -22310,18 +22661,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 homedir9 } 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);
@@ -22367,7 +22718,7 @@ function homeDirFromEnv(env) {
   return (process.platform === "win32" ? env.USERPROFILE || env.HOME : env.HOME) || homedir9();
 }
 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) {
@@ -22389,7 +22740,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);
@@ -22401,9 +22752,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];
@@ -22424,7 +22775,7 @@ function isNativeExecutable(binaryPath) {
   } finally {
     if (fd !== null) {
       try {
-        closeSync6(fd);
+        closeSync7(fd);
       } catch {}
     }
   }
@@ -22454,7 +22805,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;
@@ -22464,10 +22815,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) };
@@ -22534,7 +22885,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)
@@ -22633,9 +22984,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")
@@ -22644,8 +22995,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 = "";
@@ -22774,19 +23125,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 {
@@ -22796,19 +23147,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 {
@@ -22916,13 +23267,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) => ({
@@ -22979,13 +23330,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;
   }
 }
@@ -23044,13 +23395,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 homedir11 } 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(homedir11(), ".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(homedir11(), ".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 {
@@ -23063,7 +23414,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 {
@@ -23117,7 +23468,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;
@@ -23130,7 +23481,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) {
@@ -23204,7 +23555,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,
@@ -23238,13 +23589,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";
@@ -23335,7 +23686,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) {
@@ -23360,7 +23711,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)
@@ -23374,9 +23725,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;
@@ -23421,7 +23772,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;
@@ -23458,7 +23809,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 });
     }
@@ -23493,7 +23844,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 {}
@@ -23507,10 +23858,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;
@@ -23574,10 +23925,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;
 }
@@ -23592,12 +23943,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 {
@@ -23606,7 +23957,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)}`);
@@ -23618,7 +23969,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))
@@ -23628,7 +23979,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;
@@ -23675,7 +24026,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) {
@@ -23702,16 +24053,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}`);
@@ -23744,11 +24095,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}`);
@@ -23761,7 +24112,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}`);
     }
@@ -23769,7 +24120,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}`);
@@ -23784,14 +24135,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;
@@ -23833,8 +24184,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);
@@ -23851,14 +24202,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)) {
@@ -23878,7 +24229,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}`);
@@ -23906,7 +24257,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
     });
@@ -23915,7 +24266,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;
@@ -23936,13 +24287,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) {
@@ -29678,13 +30029,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) => {
@@ -29784,7 +30128,6 @@ function clampInspectDiagnosticsTimeoutMs(value) {
 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(),
@@ -29802,11 +30145,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()
@@ -29910,6 +30258,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 };
@@ -29934,9 +30287,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 topSubagentBg = typeof top === "object" && top !== null ? top.subagent_background !== false : true;
   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;
@@ -29983,19 +30335,6 @@ function resolveBashConfig(config) {
       powershell_tool: top.powershell_tool ?? false
     };
   }
-  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 };
 }
 function parseConfigPartially(rawConfig) {
@@ -30132,7 +30471,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);
   }
@@ -30155,9 +30494,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),
@@ -30242,6 +30590,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));
@@ -30339,19 +30694,10 @@ function mergeBashEnvMaps(base, override) {
   return Object.fromEntries(merged.values());
 }
 function mergeExperimentalConfig(baseExperimental, overrideExperimental) {
-  const bash = {
-    ...baseExperimental?.bash,
-    ...overrideExperimental?.bash
-  };
   const experimental = {
     ...baseExperimental,
     ...overrideExperimental
   };
-  if (Object.values(bash).some((value) => value !== undefined)) {
-    experimental.bash = bash;
-  } else {
-    delete experimental.bash;
-  }
   if (Object.values(experimental).every((value) => value === undefined)) {
     return;
   }
@@ -30502,17 +30848,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,
@@ -30522,10 +30872,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,
@@ -30929,7 +31281,7 @@ async function signalActiveBridges(pool, projectRoot, sessionID, request) {
 }
 
 // src/bg-notifications.ts
-import { createHash as createHash6, randomBytes as randomBytes4, randomUUID as randomUUID2 } from "node:crypto";
+import { createHash as createHash7, randomBytes as randomBytes4, randomUUID as randomUUID2 } from "node:crypto";
 
 // src/shared/last-assistant-model.ts
 function isRecord3(value) {
@@ -31253,7 +31605,7 @@ async function awaitWakeAdmission(options) {
 
 // src/bg-notifications.ts
 function hashReminder(text) {
-  return createHash6("sha256").update(text).digest("hex").slice(0, 16);
+  return createHash7("sha256").update(text).digest("hex").slice(0, 16);
 }
 var CONSUMED_TASKIDS_CAP = 256;
 var DELIVERED_AWAITING_ACK_CAP = 4096;
@@ -32809,14 +33161,14 @@ async function runDetachedBgHandler(work, onError) {
 
 // src/lsp-auto-install.ts
 import { existsSync as existsSync14, mkdirSync as mkdirSync7, renameSync as renameSync9, rmSync as rmSync6, statSync as statSync13, writeFileSync as writeFileSync8 } from "node:fs";
-import { join as join20 } from "node:path";
+import { join as join21 } 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 renameSync8,
   rmSync as rmSync5,
@@ -32824,7 +33176,7 @@ import {
   unlinkSync as unlinkSync6,
   writeFileSync as writeFileSync7
 } from "node:fs";
-import { join as join18 } from "node:path";
+import { join as join19 } from "node:path";
 function aftCacheBase() {
   return getAftCacheRoot();
 }
@@ -32832,18 +33184,18 @@ function lspCacheRoot() {
   return getAftLspPackagesDir();
 }
 function lspPackageDir(npmPackage) {
-  return join18(lspCacheRoot(), encodeURIComponent(npmPackage));
+  return join19(lspCacheRoot(), encodeURIComponent(npmPackage));
 }
 function lspBinaryPath(npmPackage, binary) {
-  return join18(lspPackageDir(npmPackage), "node_modules", ".bin", binary);
+  return join19(lspPackageDir(npmPackage), "node_modules", ".bin", binary);
 }
 function lspBinDir(npmPackage) {
-  return join18(lspPackageDir(npmPackage), "node_modules", ".bin");
+  return join19(lspPackageDir(npmPackage), "node_modules", ".bin");
 }
 function isInstalled(npmPackage, binary) {
   for (const candidate of lspBinaryCandidates(binary)) {
     try {
-      if (statSync12(join18(lspBinDir(npmPackage), candidate)).isFile())
+      if (statSync12(join19(lspBinDir(npmPackage), candidate)).isFile())
         return true;
     } catch {}
   }
@@ -32863,13 +33215,13 @@ function writeInstalledMetaIn(installDir, version, sha256) {
       installedAt: new Date().toISOString(),
       ...sha256 ? { sha256 } : {}
     };
-    writeFileSync7(join18(installDir, INSTALLED_META_FILE), JSON.stringify(meta), "utf8");
+    writeFileSync7(join19(installDir, INSTALLED_META_FILE), JSON.stringify(meta), "utf8");
   } catch (err) {
     log2(`[lsp-cache] failed to write installed-meta in ${installDir}: ${err}`);
   }
 }
 function readInstalledMetaIn(installDir) {
-  const path = join18(installDir, INSTALLED_META_FILE);
+  const path = join19(installDir, INSTALLED_META_FILE);
   try {
     if (!statSync12(path).isFile())
       return null;
@@ -32893,7 +33245,7 @@ function readInstalledMeta(packageKey) {
   return readInstalledMetaIn(lspPackageDir(packageKey));
 }
 function lockPath(npmPackage) {
-  return join18(lspPackageDir(npmPackage), ".aft-installing");
+  return join19(lspPackageDir(npmPackage), ".aft-installing");
 }
 var STALE_LOCK_MS2 = 30 * 60 * 1000;
 function acquireInstallLock(lockKey) {
@@ -32902,14 +33254,14 @@ function acquireInstallLock(lockKey) {
   const token = randomUUID3();
   const tryClaim = () => {
     try {
-      const fd = openSync9(lock, "wx");
+      const fd = openSync10(lock, "wx");
       try {
         writeFileSync7(fd, `${process.pid}
 ${new Date().toISOString()}
 ${token}
 `);
       } finally {
-        closeSync10(fd);
+        closeSync11(fd);
       }
       let retained = false;
       let released = false;
@@ -33024,7 +33376,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 join18(aftCacheBase(), AUTO_INSTALL_STAMP_FILE);
+  return join19(aftCacheBase(), AUTO_INSTALL_STAMP_FILE);
 }
 function hasRecentAutoInstallStamp(path) {
   try {
@@ -33072,11 +33424,11 @@ function claimLspAutoInstallPass() {
   };
   const tryClaim = () => {
     try {
-      const fd = openSync9(lock, "wx");
+      const fd = openSync10(lock, "wx");
       try {
         writeFileSync7(fd, JSON.stringify(owner));
       } finally {
-        closeSync10(fd);
+        closeSync11(fd);
       }
       return true;
     } catch (err) {
@@ -33125,7 +33477,7 @@ function claimLspAutoInstallPass() {
 }
 var VERSION_CHECK_FILE = ".aft-version-check";
 function readVersionCheck(npmPackage) {
-  const file = join18(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
+  const file = join19(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
   try {
     const raw = readFileSync12(file, "utf8");
     const parsed = JSON.parse(raw);
@@ -33142,7 +33494,7 @@ function readVersionCheck(npmPackage) {
 }
 function writeVersionCheck(npmPackage, latest) {
   mkdirSync6(lspPackageDir(npmPackage), { recursive: true });
-  const file = join18(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
+  const file = join19(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
   const record = {
     last_checked: new Date().toISOString(),
     latest_eligible: latest
@@ -33259,7 +33611,7 @@ function isVersionSupported(spec, version) {
 
 // src/lsp-project-relevance.ts
 import { existsSync as existsSync13, readdirSync as readdirSync5, readFileSync as readFileSync13 } from "node:fs";
-import { join as join19 } from "node:path";
+import { join as join20 } from "node:path";
 var MAX_WALK_DIRS = 200;
 var MAX_WALK_DEPTH = 4;
 var NOISE_DIRS = new Set([
@@ -33276,7 +33628,7 @@ function hasRootMarker(projectRoot, rootMarkers) {
   if (!rootMarkers)
     return false;
   for (const marker of rootMarkers) {
-    if (existsSync13(join19(projectRoot, marker)))
+    if (existsSync13(join20(projectRoot, marker)))
       return true;
   }
   return false;
@@ -33300,7 +33652,7 @@ function hasPackageJsonDep(projectRoot, depNames) {
 }
 function readPackageJson(projectRoot) {
   try {
-    const raw = readFileSync13(join19(projectRoot, "package.json"), "utf8");
+    const raw = readFileSync13(join20(projectRoot, "package.json"), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null)
       return null;
@@ -33330,7 +33682,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: join19(current.dir, entry.name), depth: current.depth + 1 });
+          queue.push({ dir: join20(current.dir, entry.name), depth: current.depth + 1 });
         }
         continue;
       }
@@ -33463,7 +33815,7 @@ async function resolveTargetVersion(spec, config, fetchImpl = fetch) {
 }
 function ensureInstallAnchor(cwd) {
   try {
-    const stub = join20(cwd, "package.json");
+    const stub = join21(cwd, "package.json");
     if (!existsSync14(stub)) {
       writeFileSync8(stub, `${JSON.stringify({ name: "aft-lsp-cache", version: "0.0.0", private: true })}
 `);
@@ -33479,18 +33831,26 @@ async function runInstall(spec, version, cwd, installLock, before, signal) {
     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);
@@ -33567,6 +33927,9 @@ async function runInstall(spec, version, cwd, installLock, before, signal) {
         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);
@@ -33673,10 +34036,10 @@ function sha256OfFileSync(path) {
 }
 function quarantineCachedNpmInstall(spec, reason) {
   const packageDir = lspPackageDir(spec.npm);
-  const dest = join20(packageDir, "..", ".quarantine", encodeURIComponent(spec.npm), `${Date.now()}`);
+  const dest = join21(packageDir, "..", ".quarantine", encodeURIComponent(spec.npm), `${Date.now()}`);
   warn2(`[lsp] tofu_mismatch ${spec.npm}: ${reason}; quarantining ${packageDir} -> ${dest}`);
   try {
-    mkdirSync7(join20(dest, ".."), { recursive: true });
+    mkdirSync7(join21(dest, ".."), { recursive: true });
     rmSync6(dest, { recursive: true, force: true });
     renameSync9(packageDir, dest);
   } catch (err) {
@@ -45690,13 +46053,16 @@ async function boundedVerification(client, sessionId) {
     setCache(sessionId, dir);
   return dir;
 }
+function clearSessionDirectory(sessionId) {
+  cache.delete(sessionId);
+  lookupGenerations.delete(sessionId);
+  verifyCache.delete(sessionId);
+}
 async function closeDeletedSessionRoutes(pool, sessionId, fallbackDirectory) {
   const roots = new Set(pool.activeBridges().map((bridge) => bridge.getCwd()));
   roots.add(getSessionDirectoryCached(sessionId) ?? fallbackDirectory);
   await Promise.allSettled([...roots].map((root) => pool.closeSession(root, sessionId)));
-  cache.delete(sessionId);
-  lookupGenerations.delete(sessionId);
-  verifyCache.delete(sessionId);
+  clearSessionDirectory(sessionId);
 }
 
 // src/shared/subagent-detect.ts
@@ -46515,6 +46881,9 @@ function canonicalizeDirectory(dir) {
   return canonicalizeProjectRoot(dir);
 }
 function projectRootFor(runtime) {
+  if (runtime.directoryIsSessionRoot && runtime.directory) {
+    return canonicalizeDirectory(runtime.directory);
+  }
   const cached = getSessionDirectoryCached(runtime.sessionID);
   if (typeof cached === "string" && cached.length > 0) {
     return canonicalizeDirectory(cached);
@@ -46965,6 +47334,10 @@ function registerV2SessionLifecycle(context, ctx) {
       const sessionID = event.data.sessionID;
       if (!sessionID)
         return;
+      if (event.type === "session.moved") {
+        clearSessionDirectory(sessionID);
+        return;
+      }
       if (event.type === "session.deleted") {
         const state = sessions.get(sessionID);
         const kills = killStoppedBackgroundTasks(context, sessionID, ctx);
@@ -47162,7 +47535,7 @@ function backgroundWaitDescription(watchToolRegistered, statusRegistered, role =
   }
   if (watchToolRegistered) {
     const noPolling = statusRegistered ? ", 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 statusRegistered ? "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.";
 }
@@ -47189,7 +47562,7 @@ function bashToolDescription(aftSearchRegistered, compressionOn, backgroundOn, d
   ].join(", ");
   const searchSteer = `use ${steerTools}${zoomEnabled ? ", or aft_zoom" : ""} instead`;
   const compression = compressionOn ? " Output is compressed by default; pass compressed: false for raw output. Piped commands run verbatim and show the pipeline's output; for AFT's test/build summary, run the runner without | head, | tail, or | grep. Pipeline-failure notes cover single top-level pipelines only; multi-statement commands (`a; b | c; d`) are not instrumented, so masked failures inside them still need explicit exit-code checks." : "";
-  const tasks = backgroundOn ? ` Commands run in the foreground and return inline; wait: true blocks until a long command finishes instead of auto-promoting (it blocks up to bash.worker_wait_max_ms, 30 minutes by default, then reports the command is still running; watch again to keep waiting); ${userMessageDetachDescription(detachOnUserMessage)} Use it when you need the result before doing anything else; ${autoPromote}. Use background: true yourself ONLY when you have other useful work to do while it runs; ${backgroundWaitDescription(watchToolRegistered, status, role)} 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(status, write)}.` : " Commands run in the foreground to completion; timeout is the hard kill cap (default 30 minutes).";
+  const tasks = backgroundOn ? ` Commands run in the foreground and return inline; wait: true blocks until a long command finishes instead of auto-promoting (it blocks up to bash.worker_wait_max_ms, 30 minutes by default, then reports the command is still running; watch again to keep waiting); ${userMessageDetachDescription(detachOnUserMessage)} Use it when you need the result before doing anything else; ${autoPromote}. Use background: true yourself ONLY when you have other work to do while it runs, and any work that doesn't need this command's result counts; ${backgroundWaitDescription(watchToolRegistered, status, role)} 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(status, write)}.` : " Commands run in the foreground to completion; timeout is the hard kill cap (default 30 minutes).";
   const outputRules = backgroundOn ? " Finished output expires after the task is 24 hours old and its completion has been delivered; under project-root restrictions, only the starting session can read output outside the project—copy cited lines into your report." : "";
   const timeoutRules = " `timeout` starts after spawn and kills the Unix process group (exit 124; Windows uses taskkill /T /F); processes that leave the group survive.";
   const remoteRuns = surface.remoteRuns ? ` ${BASH_RUNON_GUIDANCE}` : "";
@@ -47665,6 +48038,55 @@ function failure(error) {
   })();
   return new Error(`V2 tool execution rejected with a non-Error value: ${detail}`);
 }
+function tagOf(value) {
+  return typeof value === "object" && value !== null ? value._tag : undefined;
+}
+function hostPermissionRefusal(error) {
+  if (!(error instanceof BashPermissionLoopError) || !error.message)
+    return error;
+  const hostError = error.cause;
+  if (!(hostError instanceof Error) || tagOf(hostError) !== "Tool.Error")
+    return error;
+  const inner = hostError.error;
+  if (!(inner instanceof Error))
+    return error;
+  const text = error.message;
+  try {
+    const InnerClass = inner.constructor;
+    let rebuilt;
+    let shown;
+    switch (tagOf(inner)) {
+      case "Permission.BlockedError": {
+        const { rules, permission, resources } = inner;
+        rebuilt = new InnerClass({ rules, permission, resources, reason: text });
+        shown = rebuilt.message;
+        break;
+      }
+      case "Permission.CorrectedError":
+        rebuilt = new InnerClass({ feedback: text });
+        shown = rebuilt.feedback;
+        break;
+      default:
+        return error;
+    }
+    if (!(rebuilt instanceof InnerClass) || tagOf(rebuilt) !== tagOf(inner) || shown !== text) {
+      return error;
+    }
+    const ToolErrorClass = hostError.constructor;
+    const metadata = hostError.metadata;
+    const refusal = new ToolErrorClass({
+      message: text,
+      error: rebuilt,
+      ...metadata === undefined ? {} : { metadata }
+    });
+    if (!(refusal instanceof ToolErrorClass) || tagOf(refusal) !== "Tool.Error" || refusal.message !== text || refusal.error !== rebuilt) {
+      return error;
+    }
+    return refusal;
+  } catch {
+    return error;
+  }
+}
 function isPlainObject3(value) {
   if (typeof value !== "object" || value === null)
     return false;
@@ -47875,7 +48297,7 @@ function projectV2Tool(name, definition, location, consumers = {}) {
         } catch (error) {
           if (stepAbort)
             throw new PermissionStepAbort(stepAbort.error);
-          throw error;
+          throw hostPermissionRefusal(error);
         } finally {
           signal.removeEventListener("abort", onAbort);
         }
@@ -47886,7 +48308,7 @@ function projectV2Tool(name, definition, location, consumers = {}) {
 }
 
 // src/tools/hoisted.ts
-import { stat as stat3 } from "node:fs/promises";
+import { stat as stat4 } from "node:fs/promises";
 import * as path4 from "node:path";
 
 // src/hashline-tag-sources.ts
@@ -48005,19 +48427,22 @@ function coerceConfiguredWatchTimeout(value, role, cap) {
     throw new Error(`${message} (bash.watch_sync_max_ms)`);
   }
 }
-function bashWatchDescription(role, statusRegistered) {
+var PRIMARY_ASYNC_WATCH_SENTENCES = " 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.";
+function bashWatchDescription(role, statusRegistered, asyncWatches = true) {
   const noPolling = statusRegistered ? " Never loop bash_status to wait." : "";
   if (role === "worker") {
     return `Watch a background bash task and wait until it exits or prints a pattern. ${WATCH_SYNC_DEFAULTS_DESCRIPTION}. A background task never wakes you, so wait on it before you report a result. ${WORKER_KEEP_WAITING}${noPolling}`;
   }
-  return `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.${noPolling}`;
+  const asyncSentences = asyncWatches ? PRIMARY_ASYNC_WATCH_SENTENCES : "";
+  return `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.${asyncSentences}${noPolling}`;
 }
+var WATCH_PATTERN_MODES_SENTENCE = " Optional in sync mode; required with background:true.";
 function createBashWatchTool(ctx) {
   return {
     description: bashWatchDescription("primary", bashCompanionRegistered(ctx.config, "bash_status")),
     args: {
       taskId: z5.string().describe("Background task ID returned by bash({ background: true })."),
-      pattern: z5.union([z5.string(), z5.object({ regex: z5.string() })]).optional().describe("Substring or regex pattern. Optional in sync mode; required with background:true. Sync substring watches keep only the overlap tail needed for boundary matches; sync regex watches use a 64 KB rolling output window."),
+      pattern: z5.union([z5.string(), z5.object({ regex: z5.string() })]).optional().describe(`Substring or regex pattern.${WATCH_PATTERN_MODES_SENTENCE} Sync substring watches keep only the overlap tail needed for boundary matches; sync regex watches use a 64 KB rolling output window.`),
       background: z5.boolean().optional().describe("When true, register an async watch and return immediately. Defaults to false (sync wait)."),
       timeoutMs: optionalInt(1, 1800000).describe(WATCH_TIMEOUT_PARAM_DESCRIPTION),
       deliver: z5.literal("each_line").optional().describe("Async-only: batch every matching complete line, fold consecutive duplicates, and report cap drops with byte offsets."),
@@ -48900,7 +49325,7 @@ function createReadTool(ctx) {
         const ref = revisionRefArg(args.ref);
         if (ref !== undefined)
           rawArgs.ref = ref;
-        const mediaCandidate = isGithubResourcePath(file) || /\.(png|jpe?g|gif|webp|pdf)$/i.test(filePath) && await stat3(filePath).then((info) => info.isFile(), () => false);
+        const mediaCandidate = isGithubResourcePath(file) || /\.(png|jpe?g|gif|webp|pdf)$/i.test(filePath) && await stat4(filePath).then((info) => info.isFile(), () => false);
         const visionCapability = mediaCandidate ? await measurePreStage("capability", () => currentSessionVisionCapability(ctx.client, context.sessionID)) : undefined;
         if (visionCapability !== undefined)
           rawArgs.vision_capability = visionCapability;
@@ -49571,7 +49996,7 @@ function importTools(ctx) {
 }
 
 // src/tools/inspect.ts
-import { stat as stat4 } from "node:fs/promises";
+import { stat as stat5 } from "node:fs/promises";
 var z9 = tool.schema;
 var INSPECT_TRANSPORT_HEADROOM_MS = 30000;
 function arg(schema) {
@@ -49595,7 +50020,7 @@ async function resolveAndGateScope(ctx, context, scope) {
     });
     if (denial)
       return { scope: undefined, denial };
-    if (!await stat4(target).then((entry) => entry.isDirectory(), () => false)) {
+    if (!await stat5(target).then((entry) => entry.isDirectory(), () => false)) {
       const readDenial = await assertV2ReadPermission(context, target);
       if (readDenial)
         return { scope: undefined, denial: readDenial };
@@ -49732,39 +50157,6 @@ function compactTerminalField(value, fallback) {
     compact = compact?.replaceAll(internal, plain);
   return compact || fallback;
 }
-function createInspectTier2IdleScheduler(options) {
-  const timers = new Map;
-  const setTimer = options.setTimer ?? ((callback, delayMs) => setTimeout(callback, delayMs));
-  const clearTimer = options.clearTimer ?? ((timer) => clearTimeout(timer));
-  const clear = (sessionID) => {
-    const timer = timers.get(sessionID);
-    if (!timer)
-      return;
-    clearTimer(timer);
-    timers.delete(sessionID);
-  };
-  const clearAll = () => {
-    for (const timer of timers.values())
-      clearTimer(timer);
-    timers.clear();
-  };
-  const schedule = (sessionID) => {
-    if (!options.isEnabled())
-      return;
-    clear(sessionID);
-    const idleMinutes = options.idleMinutes() ?? 4;
-    const delayMs = Math.max(0, idleMinutes * 60 * 1000);
-    const timer = setTimer(() => {
-      timers.delete(sessionID);
-      options.run(sessionID).catch((err) => {
-        options.warn?.(`inspect_tier2_run failed: ${err instanceof Error ? err.message : String(err)}`);
-      });
-    }, delayMs);
-    timer.unref?.();
-    timers.set(sessionID, timer);
-  };
-  return { schedule, clear, clearAll };
-}
 function inspectTools(ctx) {
   const inspectTool = {
     description: "Codebase health inspection that waits for current analysis. FRESH means the reported analysis is current. PARTIAL means some diagnostics are unknown; the header names the analyzer, reason, and retry guidance. INTERRUPTED means the request stopped without a fresh snapshot; retry aft_inspect. PHASE-FAILED means inspection could not finish; address the reported reason and retry, or narrow the scope. `sections` selects drill-down detail. Scoped requests collect diagnostics when sections is omitted or includes 'diagnostics' or 'all'; sections that leave diagnostics out skip diagnostics work. Unscoped requests keep warm diagnostics. Categories switched off in `inspect.categories` are not computed or refreshed, render as off, and never make the header PARTIAL.\n\n" + "Use `scope=` to narrow all findings, counts, and examples to those paths. Cross-boundary duplicates are labeled as groups touching the scope. Scope also limits Rust analyzer startup to the Cargo workspaces owning those paths when diagnostics are requested. Files without an authoritative diagnostic report remain named gaps (complete: false), not a clean result.\n\n" + `Use when: starting work on unfamiliar code, after multi-edit batches to check diagnostics, before a refactor, before review, or to verify cleanup completeness.
@@ -49819,7 +50211,7 @@ function navigationTools(ctx) {
 ` + `- 'callers': Find all call sites of a symbol. Use before renaming or changing a function's signature.
 ` + `- 'impact': What breaks if a symbol changes — affected callers with signatures and entry-point status (blast radius). Use before a risky edit.
 ` + `- 'call_tree': What a function calls (forward traversal). Use to understand a function's dependencies before modifying it.
-` + `- 'trace_to': How execution reaches a function from entry points (routes, exports, main). Use to understand context around deeply-nested code.
+` + `- 'trace_to': How execution reaches a function: each path of callers runs back to a root, labelled main, test, attribute, public API, or no caller found. Use to understand context around deeply-nested code.
 ` + `- 'trace_to_symbol': Shortest call path from one symbol to another. Requires 'toSymbol'. If multiple targets match, the error returns candidate files; retry with 'toPath' to disambiguate.
 ` + `- 'trace_data': Follow a value through variable assignments and function parameters across files. Requires 'symbol' (scope to trace from) and 'expression'.
 
@@ -51280,7 +51672,7 @@ function startOpenCodeLiveConfigReload(options) {
 // src/notifications.ts
 import { existsSync as existsSync17, readFileSync as readFileSync14 } from "node:fs";
 import { homedir as homedir14, platform } from "node:os";
-import { join as join23 } from "node:path";
+import { join as join24 } from "node:path";
 function isTuiMode() {
   return process.env.OPENCODE_CLIENT === "cli";
 }
@@ -51302,15 +51694,15 @@ function getDesktopStatePath() {
   const os = platform();
   const home = homedir14();
   if (os === "darwin") {
-    return join23(home, "Library", "Application Support", "ai.opencode.desktop", "opencode.global.dat");
+    return join24(home, "Library", "Application Support", "ai.opencode.desktop", "opencode.global.dat");
   }
   if (os === "linux") {
-    const xdgConfig = process.env.XDG_CONFIG_HOME || join23(home, ".config");
-    return join23(xdgConfig, "ai.opencode.desktop", "opencode.global.dat");
+    const xdgConfig = process.env.XDG_CONFIG_HOME || join24(home, ".config");
+    return join24(xdgConfig, "ai.opencode.desktop", "opencode.global.dat");
   }
   if (os === "win32") {
-    const appData = process.env.APPDATA || join23(home, "AppData", "Roaming");
-    return join23(appData, "ai.opencode.desktop", "opencode.global.dat");
+    const appData = process.env.APPDATA || join24(home, "AppData", "Roaming");
+    return join24(appData, "ai.opencode.desktop", "opencode.global.dat");
   }
   return null;
 }
@@ -51822,47 +52214,47 @@ async function flushConfigureWarningsOnIdle(sessionId) {
 // src/hooks/auto-update-checker/index.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
 import {
-  closeSync as closeSync12,
+  closeSync as closeSync13,
   existsSync as existsSync20,
-  fstatSync as fstatSync3,
+  fstatSync as fstatSync4,
   linkSync,
   mkdirSync as mkdirSync8,
-  openSync as openSync11,
+  openSync as openSync12,
   readFileSync as readFileSync17,
   renameSync as renameSync10,
   rmSync as rmSync8,
   statSync as statSync17,
   writeFileSync as writeFileSync11
 } from "node:fs";
-import { dirname as dirname15 } from "node:path";
+import { dirname as dirname16 } from "node:path";
 
 // src/hooks/auto-update-checker/cache.ts
 import { cpSync, existsSync as existsSync19, mkdtempSync, readFileSync as readFileSync16, rmSync as rmSync7, writeFileSync as writeFileSync10 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { basename as basename5, dirname as dirname14, join as join26 } from "node:path";
+import { basename as basename5, dirname as dirname15, join as join27 } from "node:path";
 var import_comment_json3 = __toESM(require_src2(), 1);
 
 // src/hooks/auto-update-checker/checker.ts
 import { existsSync as existsSync18, readFileSync as readFileSync15, statSync as statSync16, writeFileSync as writeFileSync9 } from "node:fs";
-import { readFile } from "node:fs/promises";
+import { readFile as readFile2 } from "node:fs/promises";
 import { homedir as homedir15 } from "node:os";
-import { dirname as dirname13, isAbsolute as isAbsolute14, join as join25, resolve as resolve15 } from "node:path";
+import { dirname as dirname14, isAbsolute as isAbsolute14, join as join26, resolve as resolve17 } from "node:path";
 import { fileURLToPath } from "node:url";
 var import_comment_json2 = __toESM(require_src2(), 1);
 
 // src/hooks/auto-update-checker/constants.ts
-import { join as join24 } from "node:path";
+import { join as join25 } from "node:path";
 var PACKAGE_NAME = "@cortexkit/aft-opencode";
 var NPM_REGISTRY_URL = "https://registry.npmjs.org";
 var NPM_FETCH_TIMEOUT = 1e4;
 function cacheDir() {
-  return join24(getOpenCodeCacheRoot(), "packages");
+  return join25(getOpenCodeCacheRoot(), "packages");
 }
 function userOpenCodeConfig() {
-  return join24(getOpenCodeConfigRoot(), "opencode.json");
+  return join25(getOpenCodeConfigRoot(), "opencode.json");
 }
 function userOpenCodeConfigJsonc() {
-  return join24(getOpenCodeConfigRoot(), "opencode.jsonc");
+  return join25(getOpenCodeConfigRoot(), "opencode.jsonc");
 }
 
 // src/hooks/auto-update-checker/types.ts
@@ -51921,8 +52313,8 @@ function extractChannel(version) {
 }
 function getConfigPaths(directory) {
   return [
-    join25(directory, ".opencode", "opencode.json"),
-    join25(directory, ".opencode", "opencode.jsonc"),
+    join26(directory, ".opencode", "opencode.json"),
+    join26(directory, ".opencode", "opencode.jsonc"),
     userOpenCodeConfig(),
     userOpenCodeConfigJsonc()
   ];
@@ -51937,7 +52329,7 @@ function resolvePathPluginSpec(spec, configPath) {
   }
   if (isAbsolute14(spec) || /^[A-Za-z]:[\\/]/.test(spec))
     return spec;
-  return resolve15(dirname13(configPath), spec);
+  return resolve17(dirname14(configPath), spec);
 }
 function getLocalDevPath(directory) {
   for (const configPath of getConfigPaths(directory)) {
@@ -51966,9 +52358,9 @@ function getLocalDevPath(directory) {
 function findPackageJsonUp(startPath) {
   try {
     const stat = statSync16(startPath);
-    let dir = stat.isDirectory() ? startPath : dirname13(startPath);
+    let dir = stat.isDirectory() ? startPath : dirname14(startPath);
     for (let i = 0;i < 10; i++) {
-      const pkgPath = join25(dir, "package.json");
+      const pkgPath = join26(dir, "package.json");
       if (existsSync18(pkgPath)) {
         try {
           const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync15(pkgPath, "utf-8")));
@@ -51976,7 +52368,7 @@ function findPackageJsonUp(startPath) {
             return pkgPath;
         } catch {}
       }
-      const parent = dirname13(dir);
+      const parent = dirname14(dir);
       if (parent === dir)
         break;
       dir = parent;
@@ -52000,7 +52392,7 @@ function getLocalDevVersion(directory) {
 }
 function getCurrentRuntimePackageJsonPath(currentModuleUrl = import.meta.url) {
   try {
-    return findPackageJsonUp(dirname13(fileURLToPath(currentModuleUrl)));
+    return findPackageJsonUp(dirname14(fileURLToPath(currentModuleUrl)));
   } catch (err) {
     warn2(`[auto-update-checker] Failed to resolve runtime package path: ${String(err)}`);
     return null;
@@ -52034,7 +52426,7 @@ function findPluginEntry(directory) {
 }
 var cachedPackageVersion = null;
 function getSpecCachePackageJsonPath(spec) {
-  return join25(cacheDir(), spec, "node_modules", PACKAGE_NAME, "package.json");
+  return join26(cacheDir(), spec, "node_modules", PACKAGE_NAME, "package.json");
 }
 function getCachedVersion(spec) {
   if (!spec && cachedPackageVersion)
@@ -52043,7 +52435,7 @@ function getCachedVersion(spec) {
     getCurrentRuntimePackageJsonPath(),
     spec ? getSpecCachePackageJsonPath(spec) : null,
     getSpecCachePackageJsonPath(`${PACKAGE_NAME}@latest`),
-    join25(getOpenCodeCacheRoot(), "node_modules", PACKAGE_NAME, "package.json")
+    join26(getOpenCodeCacheRoot(), "node_modules", PACKAGE_NAME, "package.json")
   ].filter(isString);
   for (const packageJsonPath of candidates) {
     try {
@@ -52081,7 +52473,7 @@ function configuredRegistry(value) {
 async function readRegistrySettings(path, required = false) {
   let text;
   try {
-    text = await readFile(path, "utf8");
+    text = await readFile2(path, "utf8");
   } catch (error) {
     if (!required && error.code === "ENOENT")
       return {};
@@ -52111,20 +52503,20 @@ async function registryWithoutNpm(directory) {
   let scoped = registryEnvironment("@cortexkit:registry");
   let registry = registryEnvironment("registry");
   const visited = new Set;
-  for (let current = directory;; current = dirname13(current)) {
+  for (let current = directory;; current = dirname14(current)) {
     if (scoped)
       break;
-    const path = join25(current, ".npmrc");
+    const path = join26(current, ".npmrc");
     visited.add(path);
     const settings = await readRegistrySettings(path);
     scoped ??= settings["@cortexkit:registry"];
     registry ??= settings.registry;
-    if (dirname13(current) === current)
+    if (dirname14(current) === current)
       break;
   }
   const explicitUserConfig = process.env.npm_config_userconfig ?? process.env.NPM_CONFIG_USERCONFIG;
   const home = (process.platform === "win32" ? process.env.USERPROFILE : process.env.HOME) ?? homedir15();
-  const userConfig = explicitUserConfig ?? join25(home, ".npmrc");
+  const userConfig = explicitUserConfig ?? join26(home, ".npmrc");
   if (!scoped && !visited.has(userConfig)) {
     const settings = await readRegistrySettings(userConfig, explicitUserConfig !== undefined);
     scoped = settings["@cortexkit:registry"];
@@ -52146,14 +52538,14 @@ function validateRegistry(registry) {
 }
 var reportedRegistryFailures = new Set;
 function reportRegistryFailure(directory) {
-  const key = resolve15(directory);
+  const key = resolve17(directory);
   if (reportedRegistryFailures.has(key))
     return;
   reportedRegistryFailures.add(key);
   debug2("[auto-update-checker] Configured npm registry could not be resolved or used; skipping update check.");
 }
 function resolveRegistry(directory) {
-  const key = resolve15(directory);
+  const key = resolve17(directory);
   let pending = registryCache.get(key);
   if (!pending) {
     pending = (async () => {
@@ -52210,10 +52602,10 @@ async function getLatestVersion(channel = "latest", options = {}) {
 var pendingSnapshots = new Map;
 var quarantinedInstallDirs = new Set;
 function createAutoUpdateSnapshot(installDir, packageJsonPath, packageName) {
-  const packageDir = join26(installDir, "node_modules", packageName);
-  const lockfilePath = join26(installDir, "package-lock.json");
-  const tempDir = mkdtempSync(join26(tmpdir4(), "aft-auto-update-"));
-  const stagedPackageDir = existsSync19(packageDir) ? join26(tempDir, "package") : null;
+  const packageDir = join27(installDir, "node_modules", packageName);
+  const lockfilePath = join27(installDir, "package-lock.json");
+  const tempDir = mkdtempSync(join27(tmpdir4(), "aft-auto-update-"));
+  const stagedPackageDir = existsSync19(packageDir) ? join27(tempDir, "package") : null;
   if (stagedPackageDir)
     cpSync(packageDir, stagedPackageDir, { recursive: true });
   return {
@@ -52249,12 +52641,12 @@ function stripPackageNameFromPath(pathValue, packageName) {
   for (const segment of [...packageName.split("/")].reverse()) {
     if (basename5(current) !== segment)
       return null;
-    current = dirname14(current);
+    current = dirname15(current);
   }
   return current;
 }
 function removeFromPackageLock(installDir, packageName) {
-  const lockPath = join26(installDir, "package-lock.json");
+  const lockPath = join27(installDir, "package-lock.json");
   if (!existsSync19(lockPath))
     return false;
   try {
@@ -52310,7 +52702,7 @@ function restorePendingSnapshot(installDir) {
   restoreAutoUpdateSnapshot(snapshot);
 }
 function removeInstalledPackage(installDir, packageName) {
-  const packageDir = join26(installDir, "node_modules", packageName);
+  const packageDir = join27(installDir, "node_modules", packageName);
   if (!existsSync19(packageDir))
     return false;
   rmSync7(packageDir, { recursive: true, force: true });
@@ -52319,18 +52711,18 @@ function removeInstalledPackage(installDir, packageName) {
 }
 function resolveInstallContext(runtimePackageJsonPath = getCurrentRuntimePackageJsonPath()) {
   if (runtimePackageJsonPath) {
-    const packageDir = dirname14(runtimePackageJsonPath);
+    const packageDir = dirname15(runtimePackageJsonPath);
     const nodeModulesDir = stripPackageNameFromPath(packageDir, PACKAGE_NAME);
     if (nodeModulesDir && basename5(nodeModulesDir) === "node_modules") {
-      const installDir = dirname14(nodeModulesDir);
-      const packageJsonPath = join26(installDir, "package.json");
+      const installDir = dirname15(nodeModulesDir);
+      const packageJsonPath = join27(installDir, "package.json");
       if (existsSync19(packageJsonPath))
         return { installDir, packageJsonPath };
     }
     return null;
   }
-  const cacheRoot = dirname14(cacheDir());
-  const legacyPackageJsonPath = join26(cacheRoot, "package.json");
+  const cacheRoot = dirname15(cacheDir());
+  const legacyPackageJsonPath = join27(cacheRoot, "package.json");
   if (existsSync19(legacyPackageJsonPath)) {
     return { installDir: cacheRoot, packageJsonPath: legacyPackageJsonPath };
   }
@@ -52532,19 +52924,19 @@ function claimCheckSlot(storageDir, intervalMs, testHooks = {}) {
   try {
     if (hasRecentCheckTimestamp(file, intervalMs))
       return null;
-    mkdirSync8(dirname15(file), { recursive: true });
+    mkdirSync8(dirname16(file), { recursive: true });
     const lockPath = `${file}.lock`;
     const owner = { pid: process.pid, startedMs: Date.now(), token: randomUUID4() };
     let lockFd = null;
     try {
-      lockFd = openSync11(lockPath, "wx");
+      lockFd = openSync12(lockPath, "wx");
       writeFileSync11(lockFd, JSON.stringify(owner));
-      closeSync12(lockFd);
+      closeSync13(lockFd);
       lockFd = null;
     } catch (err) {
       if (lockFd !== null) {
         try {
-          closeSync12(lockFd);
+          closeSync13(lockFd);
         } catch {}
       }
       if (err.code !== "EEXIST")
@@ -52562,7 +52954,7 @@ function claimCheckSlot(storageDir, intervalMs, testHooks = {}) {
             return null;
         }
         try {
-          lockFd = openSync11(lockPath, "wx");
+          lockFd = openSync12(lockPath, "wx");
         } catch (claimError) {
           if (claimError.code === "EEXIST")
             return null;
@@ -52571,11 +52963,11 @@ function claimCheckSlot(storageDir, intervalMs, testHooks = {}) {
         try {
           writeFileSync11(lockFd, JSON.stringify(owner));
         } finally {
-          closeSync12(lockFd);
+          closeSync13(lockFd);
           lockFd = null;
         }
       } finally {
-        closeSync12(reclaimFd);
+        closeSync13(reclaimFd);
         releaseCheckLock(reclaimPath, owner);
       }
     }
@@ -52658,12 +53050,12 @@ function claimObservedCheckLock(lockPath, observed, testHooks = {}) {
   return true;
 }
 function writeReclaimGuard(reclaimPath, owner) {
-  const fd = openSync11(reclaimPath, "wx");
+  const fd = openSync12(reclaimPath, "wx");
   try {
     writeFileSync11(fd, JSON.stringify(owner));
     return fd;
   } catch (error) {
-    closeSync12(fd);
+    closeSync13(fd);
     throw error;
   }
 }
@@ -52690,14 +53082,14 @@ function readCheckLockState(lockPath) {
   let content;
   try {
     const observed = statSync17(lockPath, { bigint: true });
-    const fd = openSync11(lockPath, "r");
+    const fd = openSync12(lockPath, "r");
     try {
-      info = fstatSync3(fd, { bigint: true });
+      info = fstatSync4(fd, { bigint: true });
       if (info.dev !== observed.dev || info.ino !== observed.ino)
         return null;
       content = readFileSync17(fd, "utf-8");
     } finally {
-      closeSync12(fd);
+      closeSync13(fd);
     }
   } catch (error) {
     if (error.code === "ENOENT")
@@ -52847,10 +53239,10 @@ function showToast(ctx, title, message, variant = "info", duration = 3000) {
 }
 
 // src/plugin-version.ts
-import { createRequire as createRequire2 } from "node:module";
+import { createRequire as createRequire3 } from "node:module";
 var PLUGIN_PACKAGE_NAME = "@cortexkit/aft-opencode";
 function resolvePluginVersion(importMetaUrl) {
-  const req = createRequire2(importMetaUrl);
+  const req = createRequire3(importMetaUrl);
   for (const candidate of ["../package.json", "../../package.json", "../../../package.json"]) {
     try {
       const manifest = req(candidate);
@@ -52956,16 +53348,16 @@ import {
   writeFileSync as writeFileSync12
 } from "node:fs";
 import { createServer } from "node:http";
-import { dirname as dirname16, join as join28 } from "node:path";
+import { dirname as dirname17, join as join29 } from "node:path";
 
 // src/shared/rpc-utils.ts
-import { join as join27 } from "node:path";
+import { join as join28 } from "node:path";
 function projectHash(directory) {
   return projectRootKeyHash(directory);
 }
 function rpcPortFileDir(storageDir, directory) {
   const hash = projectHash(directory);
-  return join27(storageDir, "rpc", hash, "ports");
+  return join28(storageDir, "rpc", hash, "ports");
 }
 function isPidAlive(pid) {
   if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0)
@@ -53042,7 +53434,7 @@ class AftRpcServer {
   constructor(storageDir, directory) {
     this.portsDir = rpcPortFileDir(storageDir, directory);
     this.instanceId = randomBytes5(8).toString("hex");
-    this.portFilePath = join28(this.portsDir, `${this.instanceId}.json`);
+    this.portFilePath = join29(this.portsDir, `${this.instanceId}.json`);
   }
   handle(method, handler) {
     this.handlers.set(method, handler);
@@ -53119,7 +53511,7 @@ class AftRpcServer {
     }
   }
   writePortFile() {
-    const dir = dirname16(this.portFilePath);
+    const dir = dirname17(this.portFilePath);
     mkdirSync9(dir, { recursive: true, mode: 448 });
     const tmpPath = `${this.portFilePath}.tmp`;
     writeFileSync12(tmpPath, JSON.stringify({
@@ -53141,13 +53533,13 @@ class AftRpcServer {
       const temporary = entry.endsWith(".json.tmp");
       if (!temporary && !entry.endsWith(".json"))
         continue;
-      const filePath = join28(this.portsDir, entry);
+      const filePath = join29(this.portsDir, entry);
       if (filePath === this.portFilePath)
         continue;
       try {
         const record = parseRpcPortRecord(readFileSync18(filePath, "utf-8"));
         if (record === null) {
-          if (!temporary || Date.now() - statSync18(join28(this.portsDir, entry)).mtimeMs >= UNREADABLE_TMP_MAX_AGE_MS) {
+          if (!temporary || Date.now() - statSync18(join29(this.portsDir, entry)).mtimeMs >= UNREADABLE_TMP_MAX_AGE_MS) {
             unlinkSync7(filePath);
           }
           continue;
@@ -53455,9 +53847,6 @@ 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);
   const noLanguageServer = bar.diagnostics === "no_language_server";
   const producerMissing = bar.diagnostics === "producer_missing";
@@ -53466,18 +53855,14 @@ function readStatusBar(value) {
     producer: gap.producer,
     root: gap.root
   })) : [];
-  if (errors === null && warnings === null && deadCode === null && unusedExports === null && duplicates === null && todos === null && !noLanguageServer && !producerMissing && disabled.length === 0) {
+  if (errors === null && warnings === null && todos === null && !noLanguageServer && !producerMissing && 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 } : {},
     ...noLanguageServer ? { diagnostics: "no_language_server" } : {},
     ...producerMissing ? { diagnostics: "producer_missing", diagnostics_gaps: diagnosticsGaps } : {}
   };
@@ -53671,13 +54056,10 @@ function formatStatusMarkdown(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)}`);
     }
@@ -53848,15 +54230,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(`
@@ -53948,12 +54330,12 @@ function throwSentinel(command) {
   throw sentinel;
 }
 var PLUGIN_VERSION = resolvePluginVersion(import.meta.url);
-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 plugin = async (input) => initializePluginForDirectory(input);
@@ -54164,13 +54546,11 @@ async function initializePluginForDirectory(input) {
     return result;
   };
   const rpcServer = new AftRpcServer(configOverrides.storage_dir, input.directory);
-  let clearInspectTier2Idle = () => {};
   let clearAnnouncementTimer = () => {};
   const shutdownCleanup = registerShutdownCleanup(async (reason) => {
     cancelPendingWakesForContext(ctx);
     autoUpdateAbort.abort();
     liveConfigReload.stop();
-    clearInspectTier2Idle();
     clearAnnouncementTimer();
     for (const unsubscribe of statusUnsubscribes) {
       try {
@@ -54304,22 +54684,6 @@ Install: ${getManualInstallHint()}`);
   if (hintsBlock) {
     log2(`Workflow hints injected (${hintsBlock.length} chars)`);
   }
-  const inspectTier2Idle = createInspectTier2IdleScheduler({
-    isEnabled: () => registeredTools.has("aft_inspect"),
-    idleMinutes: () => ctx.config.inspect?.tier2_idle_minutes,
-    warn: warn2,
-    run: async (sessionID) => {
-      const sessionDir = await getSessionDirectory(input.client, sessionID, input.directory) ?? input.directory;
-      if (!isProjectEnabled(sessionDir))
-        return;
-      const bridge = ctx.pool.getActiveBridgeForRoot(sessionDir) ?? ctx.pool.getBridge(sessionDir);
-      const response = await bridge.send("inspect_tier2_run", { session_id: sessionID });
-      if (response.success === false) {
-        warn2(response.message || "inspect_tier2_run failed");
-      }
-    }
-  });
-  clearInspectTier2Idle = () => inspectTier2Idle.clearAll();
   return {
     tool: allTools,
     "experimental.chat.system.transform": async (systemInput, output) => {
@@ -54343,13 +54707,16 @@ Install: ${getManualInstallHint()}`);
       const eventType = eventInput.event.type;
       observeOpenCodeBgNotificationEvent(eventInput.event);
       const sessionID = extractSessionID(eventInput.event.properties);
+      if (eventType === "session.moved" && sessionID) {
+        clearSessionDirectory(sessionID);
+        return;
+      }
       if (eventType === "session.created" && sessionID) {
         const sessionDir = await getSessionDirectory(input.client, sessionID, input.directory) ?? input.directory;
         observeFreshSessionStart(pool, sessionDir, sessionID, "new");
       }
       if (eventType === "session.deleted" && sessionID) {
         releaseSessionState(sessionID);
-        inspectTier2Idle.clear(sessionID);
         closeDeletedSessionRoutes(pool, sessionID, input.worktree ?? input.directory).catch(() => {});
         return;
       }
@@ -54357,7 +54724,6 @@ Install: ${getManualInstallHint()}`);
         return;
       if (!sessionID)
         return;
-      inspectTier2Idle.schedule(sessionID);
       const sessionDir = await getSessionDirectory(input.client, sessionID, input.directory) ?? input.directory;
       if (!isProjectEnabled(sessionDir))
         return;
@@ -54405,8 +54771,6 @@ Install: ${getManualInstallHint()}`);
       output.args = prepareOpenCodeArguments(toolInput.tool, output.args, {
         hashlineEffective: ctx.hashlineEffective
       });
-      if (toolInput.sessionID)
-        inspectTier2Idle.clear(toolInput.sessionID);
     },
     "command.execute.before": async (commandInput, _output) => {
       if (commandInput.command !== STATUS_COMMAND) {