@cortexkit/aft 0.58.2 → 0.60.0

package/dist/index.js

@@ -109,8 +109,124 @@ var ACTIVE_LOGGER_SYMBOL;
 var init_active_logger = __esm(() => {
   ACTIVE_LOGGER_SYMBOL = Symbol.for("aft-bridge-active-logger");
 });
+// ../aft-bridge/dist/path-display.js
+import { homedir } from "node:os";
+import { posix, win32 } from "node:path";
+function shortenHomePath(path, home = homedir(), platform = process.platform) {
+  if (!home)
+    return path;
+  const normalize = (value) => platform === "win32" ? value.replace(/\\/g, "/").toLowerCase() : value;
+  const base = normalize(home).replace(/\/+$/, "");
+  const target = normalize(path);
+  if (target === normalize(home) || target === base)
+    return "~";
+  return target.startsWith(`${base}/`) ? `~${path.slice(base.length)}` : path;
+}
+function relativePathEscapesRoot(rel, platform = process.platform) {
+  return rel === ".." || rel.startsWith("../") || platform === "win32" && rel.startsWith("..\\") || (platform === "win32" ? win32.isAbsolute(rel) : posix.isAbsolute(rel));
+}
+var init_path_display = () => {};
+
 // ../aft-bridge/dist/bash-hints.js
-var init_bash_hints = () => {};
+var init_bash_hints = __esm(() => {
+  init_path_display();
+});
+
+// ../aft-bridge/dist/test-child-environment.js
+import { mkdirSync, realpathSync } from "node:fs";
+import { homedir as homedir2, tmpdir } from "node:os";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+function toolchainHomes(inherited) {
+  const global = globalThis;
+  if (!global[TOOLCHAINS]) {
+    const home = process.platform === "win32" ? inherited.USERPROFILE || inherited.HOME || homedir2() : inherited.HOME || homedir2();
+    global[TOOLCHAINS] = {
+      RUSTUP_HOME: inherited.RUSTUP_HOME || join(home, ".rustup"),
+      CARGO_HOME: inherited.CARGO_HOME || join(home, ".cargo")
+    };
+  }
+  return global[TOOLCHAINS];
+}
+function createdRoots() {
+  const global = globalThis;
+  return global[ROOTS] ??= new Set;
+}
+function isolatedAftEnvironment(root, inherited = process.env) {
+  const env = { ...inherited };
+  const toolchains = toolchainHomes(inherited);
+  env.RUSTUP_HOME ||= toolchains.RUSTUP_HOME;
+  env.CARGO_HOME ||= toolchains.CARGO_HOME;
+  const names = [
+    "home",
+    "home",
+    "local",
+    "config",
+    "data",
+    "state",
+    "cache",
+    "runtime",
+    "storage",
+    "aft-cache"
+  ];
+  for (const [index, key] of DIRECTORIES.entries()) {
+    env[key] = join(root, names[index]);
+    mkdirSync(env[key], { recursive: true });
+  }
+  delete env.AFT_ALLOW_PRODUCTION_MIGRATION;
+  createdRoots().add(resolve(root));
+  return env;
+}
+function canonical(path) {
+  let ancestor = resolve(path);
+  const tail = [];
+  while (true) {
+    try {
+      return join(realpathSync(ancestor), ...tail);
+    } catch {
+      const parent = dirname(ancestor);
+      if (parent === ancestor)
+        return resolve(path);
+      tail.unshift(relative(parent, ancestor));
+      ancestor = parent;
+    }
+  }
+}
+function within(path, root) {
+  const tail = relative(canonical(root), canonical(path));
+  return tail === "" || !tail.startsWith("..") && !isAbsolute(tail);
+}
+function testChildEnvironment(env) {
+  const root = process.env.AFT_TEST_ISOLATION_ROOT;
+  if (!root)
+    return env;
+  const fallback = isolatedAftEnvironment(root, env);
+  for (const key of DIRECTORIES) {
+    const value = env[key];
+    if (value && ([...createdRoots()].some((created) => within(value, created)) || within(value, tmpdir()))) {
+      mkdirSync(value, { recursive: true });
+      fallback[key] = value;
+    }
+  }
+  fallback.AFT_TEST_ISOLATION_ROOT = root;
+  return fallback;
+}
+var DIRECTORIES, ROOTS, TOOLCHAINS;
+var init_test_child_environment = __esm(() => {
+  DIRECTORIES = [
+    "HOME",
+    "USERPROFILE",
+    "LOCALAPPDATA",
+    "XDG_CONFIG_HOME",
+    "XDG_DATA_HOME",
+    "XDG_STATE_HOME",
+    "XDG_CACHE_HOME",
+    "XDG_RUNTIME_DIR",
+    "AFT_STORAGE_DIR",
+    "AFT_CACHE_DIR"
+  ];
+  ROOTS = Symbol.for("cortexkit.aft.created-test-child-roots");
+  TOOLCHAINS = Symbol.for("cortexkit.aft.test-child-toolchain-homes");
+});
 
 // ../aft-bridge/dist/child-process.js
 import { execFile as nodeExecFile, execFileSync as nodeExecFileSync, execSync as nodeExecSync, spawn as nodeSpawn, spawnSync as nodeSpawnSync } from "node:child_process";
@@ -130,10 +246,19 @@ function withWindowsHidden(args, takesArgv) {
   return out;
 }
 function hidden(resolve, takesArgv) {
-  return (...args) => resolve()(...withWindowsHidden(args, takesArgv));
+  return (...args) => {
+    const out = withWindowsHidden(args, takesArgv);
+    if (process.env.AFT_TEST_ISOLATION_ROOT) {
+      const index = takesArgv && (Array.isArray(out[1]) || out[1] == null && out.length > 2) ? 2 : 1;
+      const options = out[index];
+      options.env = testChildEnvironment(options.env ?? process.env);
+    }
+    return resolve()(...out);
+  };
 }
 var HIDDEN, spawn, spawnSync, execFile, execFileSync, execSync;
 var init_child_process = __esm(() => {
+  init_test_child_environment();
   HIDDEN = { windowsHide: true };
   spawn = hidden(() => nodeSpawn, true);
   spawnSync = hidden(() => nodeSpawnSync, true);
@@ -165,8 +290,8 @@ function withPathPrepended(env, dir, platform = process.platform) {
 }
 
 // ../aft-bridge/dist/storage-paths.js
-import { homedir, tmpdir } from "node:os";
-import { join, resolve } from "node:path";
+import { homedir as homedir3, tmpdir as tmpdir2 } from "node:os";
+import { join as join2, resolve as resolve2 } from "node:path";
 function environmentValue(context, name) {
   const value = (context.lookup ?? ((key) => process.env[key]))(name);
   return value !== undefined && value.length > 0 ? value : undefined;
@@ -176,7 +301,7 @@ function storagePlatform(context) {
 }
 function homeDir(context) {
   const configured = storagePlatform(context) === "windows" ? environmentValue(context, "USERPROFILE") ?? environmentValue(context, "HOME") : environmentValue(context, "HOME") ?? environmentValue(context, "USERPROFILE");
-  return configured ?? context.fallbackHome ?? homedir();
+  return configured ?? context.fallbackHome ?? homedir3();
 }
 function resolveDataHome(context = {}) {
   const xdg = environmentValue(context, "XDG_DATA_HOME");
@@ -188,21 +313,21 @@ function resolveDataHome(context = {}) {
       return localAppData;
     const userProfile = environmentValue(context, "USERPROFILE");
     if (userProfile)
-      return join(userProfile, "AppData", "Local");
+      return join2(userProfile, "AppData", "Local");
   }
   const home = environmentValue(context, "HOME");
   if (home)
-    return join(home, ".local", "share");
-  return join(".local", "share");
+    return join2(home, ".local", "share");
+  return join2(".local", "share");
 }
 function resolveStoragePath(raw, context = {}) {
   let expanded = raw;
   if (raw === "~") {
     expanded = homeDir(context);
   } else if (raw.startsWith("~/") || raw.startsWith("~\\")) {
-    expanded = join(homeDir(context), raw.slice(2));
+    expanded = join2(homeDir(context), raw.slice(2));
   }
-  return resolve(context.currentDirectory ?? process.cwd(), expanded);
+  return resolve2(context.currentDirectory ?? process.cwd(), expanded);
 }
 function resolveCortexKitStorageRoot(context = {}) {
   const override = environmentValue(context, "AFT_STORAGE_DIR");
@@ -210,8 +335,8 @@ function resolveCortexKitStorageRoot(context = {}) {
     return resolveStoragePath(override, context);
   const legacyCache = environmentValue(context, "AFT_CACHE_DIR");
   if (legacyCache)
-    return join(resolveStoragePath(legacyCache, context), "aft");
-  return resolveStoragePath(join(resolveDataHome(context), "cortexkit", "aft"), context);
+    return join2(resolveStoragePath(legacyCache, context), "aft");
+  return resolveStoragePath(join2(resolveDataHome(context), "cortexkit", "aft"), context);
 }
 function resolveAftStorageRoot(configuredRoot, context = {}) {
   if (environmentValue(context, "AFT_STORAGE_DIR")) {
@@ -222,14 +347,14 @@ function resolveAftStorageRoot(configuredRoot, context = {}) {
   return resolveCortexKitStorageRoot(context);
 }
 function resolveAftLogPath(filename, configuredRoot, context = {}) {
-  return join(resolveAftStorageRoot(configuredRoot, context), "logs", filename);
+  return join2(resolveAftStorageRoot(configuredRoot, context), "logs", filename);
 }
 function isTestEnvironment(context = {}) {
   return environmentValue(context, "BUN_TEST") === "1" || environmentValue(context, "NODE_ENV") === "test";
 }
 function resolvePluginLogPath(context = {}) {
   if (isTestEnvironment(context)) {
-    return join(environmentValue(context, "TMPDIR") ?? tmpdir(), "aft-plugin-test.log");
+    return join2(environmentValue(context, "TMPDIR") ?? tmpdir2(), `aft-plugin-tests-${process.pid}`, "logs", "aft-plugin-test.log");
   }
   return resolveAftLogPath("aft-plugin.log", undefined, context);
 }
@@ -246,7 +371,7 @@ var init_bash_host_fallback = __esm(() => {
 
 // ../aft-bridge/dist/binary-identity.js
 import { createHash } from "node:crypto";
-import { createReadStream, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { closeSync, createReadStream, openSync, readFileSync, readSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 function bareVersion(version) {
   return version.startsWith("v") ? version.slice(1) : version;
 }
@@ -311,7 +436,7 @@ function writeSidecarAtomically(binaryPath, identity) {
   const tmp = `${sidecar}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`;
   try {
     writeFileSync(tmp, `${JSON.stringify(identity)}
-`, "utf8");
+`, { encoding: "utf8", mode: 384 });
     if (process.platform === "win32") {
       try {
         unlinkSync(sidecar);
@@ -428,12 +553,50 @@ function peekBinaryContentHash(binaryPath) {
   binaryContentHash(binaryPath);
   return null;
 }
-var SIDECAR_SCHEMA = 1, pendingIdentityWrites, contentHashCache, contentHashInFlight;
+function digestStamp(path) {
+  const s = statSync(path, { bigint: true });
+  return `${s.dev}:${s.ino}:${s.size}:${s.mtimeNs}:${s.ctimeNs}`;
+}
+function readStampedFileDigest(path) {
+  try {
+    const value = JSON.parse(readFileSync(`${path}.digest.json`, "utf8"));
+    return value.schema === 1 && value.stamp === digestStamp(path) && typeof value.sha256 === "string" && /^[a-f0-9]{64}$/.test(value.sha256) ? value.sha256 : null;
+  } catch {
+    return null;
+  }
+}
+function writeStampedFileDigest(path, sha256, verifiedStamp) {
+  const sidecar = `${path}.digest.json`;
+  const tmp = `${sidecar}.${process.pid}.${Math.random().toString(16).slice(2)}.tmp`;
+  try {
+    writeFileSync(tmp, JSON.stringify({ schema: 1, stamp: verifiedStamp ?? digestStamp(path), sha256 }), { mode: 384 });
+    renameSync(tmp, sidecar);
+  } catch {} finally {
+    try {
+      unlinkSync(tmp);
+    } catch {}
+  }
+}
+async function cachedFileSha256(path) {
+  const known = readStampedFileDigest(path);
+  if (known)
+    return known;
+  const before = digestStamp(path);
+  digestWork.asyncHashes += 1;
+  digestWork.bytesHashed += Number(statSync(path).size);
+  const digest = await sha256File(path);
+  if (digestStamp(path) !== before)
+    throw new Error(`File changed while hashing: ${path}`);
+  writeStampedFileDigest(path, digest, before);
+  return digest;
+}
+var SIDECAR_SCHEMA = 1, pendingIdentityWrites, contentHashCache, contentHashInFlight, digestWork;
 var init_binary_identity = __esm(() => {
   init_active_logger();
   pendingIdentityWrites = new Set;
   contentHashCache = new Map;
   contentHashInFlight = new Map;
+  digestWork = { syncHashes: 0, asyncHashes: 0, bytesHashed: 0 };
 });
 
 // ../aft-bridge/dist/command-timeouts.js
@@ -446,11 +609,11 @@ var init_command_timeouts = __esm(() => {
 });
 
 // ../aft-bridge/dist/transport.js
-var WORKER_SESSION_FIELD = "worker_session";
+var WORKER_SESSION_FIELD = "worker_session", HOST_TOOL_NAMES_FIELD = "host_tool_names";
 
 // ../aft-bridge/dist/bridge.js
-import { homedir as homedir2 } from "node:os";
-import { join as join2 } from "node:path";
+import { homedir as homedir4 } from "node:os";
+import { join as join3 } from "node:path";
 import { StringDecoder } from "node:string_decoder";
 function isTerminalBashStatus(status) {
   return typeof status === "string" && TERMINAL_BASH_STATUSES.has(status);
@@ -538,14 +701,13 @@ function coerceConfigureDroppedKeys(value) {
   }
   return dropped;
 }
-var DEFAULT_BRIDGE_TIMEOUT_MS = 30000, BRIDGE_HANG_TIMEOUT_THRESHOLD = 2, MAX_STDOUT_BUFFER, STDOUT_BUFFER_COMPACT_THRESHOLD, HASHLINE_REGISTRATION_LOG_INTERVAL_MS = 60000, HASHLINE_REGISTRATION_LOG_STATE_LIMIT = 256, TERMINAL_BASH_STATUSES, binaryFingerprintReader, binaryFingerprintAsyncReader, BENIGN_CPUINFO_PROC_CPUINFO_PARSE_FAILURE = "failed to parse processor information from /proc/cpuinfo", BridgeReplacedDuringVersionCheck, BridgeTransportTimeoutError, BridgeTransportUnavailableError, BridgeTransportUnknownOutcomeError, BinaryBridge;
+var DEFAULT_BRIDGE_TIMEOUT_MS = 30000, BRIDGE_HANG_TIMEOUT_THRESHOLD = 2, MAX_STDOUT_BUFFER, MALFORMED_STDOUT_LOG_CHARS = 512, HASHLINE_REGISTRATION_LOG_INTERVAL_MS = 60000, HASHLINE_REGISTRATION_LOG_STATE_LIMIT = 256, TERMINAL_BASH_STATUSES, binaryFingerprintReader, binaryFingerprintAsyncReader, BENIGN_CPUINFO_PROC_CPUINFO_PARSE_FAILURE = "failed to parse processor information from /proc/cpuinfo", BridgeReplacedDuringVersionCheck, BridgeTransportTimeoutError, BridgeTransportUnavailableError, BridgeTransportUnknownOutcomeError, BinaryBridge;
 var init_bridge = __esm(() => {
   init_active_logger();
   init_binary_identity();
   init_child_process();
   init_command_timeouts();
   MAX_STDOUT_BUFFER = 64 * 1024 * 1024;
-  STDOUT_BUFFER_COMPACT_THRESHOLD = 64 * 1024;
   TERMINAL_BASH_STATUSES = new Set([
     "completed",
     "failed",
@@ -599,11 +761,17 @@ var init_bridge = __esm(() => {
     lastBinaryFingerprintCheckAt = 0;
     _retiringDueToBinaryChange = false;
     pending = new Map;
+    activeSendCalls = 0;
+    processLoopReferenced = true;
     outstandingBackgroundTaskIds = new Set;
     nextId = 1;
     processGeneration = 0;
-    stdoutBuffer = "";
-    stdoutReadOffset = 0;
+    stdoutPending = [];
+    stdoutPendingLength = 0;
+    stdoutScannedChars = 0;
+    __stdoutScannedCharsForTests() {
+      return this.stdoutScannedChars;
+    }
     stderrBuffer = "";
     stderrTail = [];
     _restartCount = 0;
@@ -629,6 +797,7 @@ var init_bridge = __esm(() => {
     restartResetTimer = null;
     lastChildActivityAt = 0;
     consecutiveRequestTimeouts = 0;
+    timeoutRestartAwaitingRecovery = false;
     errorPrefix;
     logger;
     childEnv;
@@ -825,6 +994,32 @@ var init_bridge = __esm(() => {
       this.sessionLogVia(sessionId, `hashline registration carrier transport=ndjson phase=${phase} edit_slot_survives=${editSlotSurvives}${repeated}`);
     }
     async send(command, params = {}, options) {
+      this.activeSendCalls += 1;
+      this.syncEventLoopHold();
+      try {
+        return await this.dispatchSend(command, params, options);
+      } finally {
+        this.activeSendCalls -= 1;
+        this.syncEventLoopHold();
+      }
+    }
+    syncEventLoopHold() {
+      const child = this.process;
+      if (!child)
+        return;
+      const hold = this.activeSendCalls > 0 || this.outstandingBackgroundTaskIds.size > 0;
+      if (hold === this.processLoopReferenced)
+        return;
+      this.processLoopReferenced = hold;
+      const handles = [child, child.stdin, child.stdout, child.stderr];
+      for (const handle of handles) {
+        if (hold)
+          handle?.ref?.();
+        else
+          handle?.unref?.();
+      }
+    }
+    async dispatchSend(command, params, options) {
       let dispatchParams = params;
       if (command === "configure") {
         dispatchParams = { ...params };
@@ -862,17 +1057,19 @@ var init_bridge = __esm(() => {
         params.edit_slot_survives = editSlotSurvives;
         this.logHashlineRegistrationCarrier("tool_call", sessionId, editSlotSurvives);
       }
-      const { preview, workerSession, ...sendOptions } = options ?? {};
+      const { preview, workerSession, hostToolNames, ...sendOptions } = options ?? {};
       if (preview === true)
         params.preview = true;
       if (workerSession === true)
         params[WORKER_SESSION_FIELD] = true;
+      if (hostToolNames)
+        params[HOST_TOOL_NAMES_FIELD] = hostToolNames;
       return await this.send("tool_call", params, Object.keys(sendOptions).length > 0 ? sendOptions : undefined);
     }
     async sendWithVersionMismatchRetry(command, params, options, canRetryAfterVersionSwap) {
       try {
         if (this._retiringDueToBinaryChange) {
-          throw new Error(`${this.errorPrefix} Bridge is retiring after the on-disk binary changed; retry to respawn on the updated binary`);
+          throw new BridgeTransportUnavailableError(`${this.errorPrefix} Bridge is retiring after the on-disk binary changed; retry to respawn on the updated binary`);
         }
         if (this._shuttingDown) {
           throw new BridgeTransportUnavailableError(`${this.errorPrefix} Bridge is shutting down, cannot send "${command}"`);
@@ -935,7 +1132,12 @@ var init_bridge = __esm(() => {
         if (command === "cancel_request" || Object.hasOwn(params, "command") || Object.hasOwn(params, "method")) {
           const nested = { ...params };
           const reserved = {};
-          for (const key of ["session_id", "lsp_hints", WORKER_SESSION_FIELD]) {
+          for (const key of [
+            "session_id",
+            "lsp_hints",
+            WORKER_SESSION_FIELD,
+            HOST_TOOL_NAMES_FIELD
+          ]) {
             if (Object.hasOwn(nested, key)) {
               reserved[key] = nested[key];
               delete nested[key];
@@ -947,7 +1149,7 @@ var init_bridge = __esm(() => {
         }
         const line = `${JSON.stringify(request)}
 `;
-        const keepBridgeOnTimeout = passive || options?.keepBridgeOnTimeout === true;
+        const keepBridgeOnTimeout = passive || command === "bash_drain_completions" || options?.keepBridgeOnTimeout === true;
         let requestSentAt = Date.now();
         const child = this.process;
         const response = await new Promise((resolve, reject) => {
@@ -971,7 +1173,8 @@ var init_bridge = __esm(() => {
             const childActiveSinceRequest = this.lastChildActivityAt > requestSentAt;
             const consecutiveTimeouts = this.consecutiveRequestTimeouts + 1;
             this.consecutiveRequestTimeouts = consecutiveTimeouts;
-            const keepWarm = childActiveSinceRequest || consecutiveTimeouts < this.hangThreshold;
+            const restartSuppressed = this.timeoutRestartAwaitingRecovery;
+            const keepWarm = restartSuppressed || childActiveSinceRequest || consecutiveTimeouts < this.hangThreshold;
             const restartSuffix = keepWarm ? " — bridge kept warm" : " — restarting bridge";
             const timeoutMsg = `Request "${command}" (id=${id}) timed out after ${effectiveTimeoutMs}ms${restartSuffix}`;
             if (requestSessionId) {
@@ -980,7 +1183,7 @@ var init_bridge = __esm(() => {
               this.warnVia(timeoutMsg);
             }
             if (keepWarm) {
-              entry.reject(new Error(`${this.errorPrefix} request "${command}" timed out after ${effectiveTimeoutMs}ms (bridge busy/under load); bridge kept warm — retry`));
+              entry.reject(new Error(restartSuppressed ? `${this.errorPrefix} request "${command}" timed out after ${effectiveTimeoutMs}ms; automatic timeout restart already attempted; bridge kept warm to finish startup. Retry later or restart the host explicitly if it remains unresponsive. A timed-out mutation may still complete; inspect before repeating it.` : `${this.errorPrefix} request "${command}" timed out after ${effectiveTimeoutMs}ms (bridge busy/under load); bridge kept warm — retry`));
               return;
             }
             entry.reject(new Error(`${this.errorPrefix} Request "${command}" (id=${id}) timed out after ${effectiveTimeoutMs}ms`));
@@ -1117,7 +1320,7 @@ var init_bridge = __esm(() => {
       this.spawnedBinaryFingerprint = null;
       this.clearRestartResetTimer();
       this.configureWarningClients.clear();
-      this.rejectAllPending(new Error(`${this.errorPrefix} Bridge shutting down`));
+      this.rejectAllPending(new BridgeTransportUnknownOutcomeError(`${this.errorPrefix} Bridge shutting down`));
       if (this.process) {
         const proc = this.process;
         this.process = null;
@@ -1172,7 +1375,7 @@ var init_bridge = __esm(() => {
       this.lastBinaryFingerprintCheckAt = 0;
       this._retiringDueToBinaryChange = false;
       this.clearRestartResetTimer();
-      this.rejectAllPending(new Error(`${this.errorPrefix} Bridge restarting with updated binary: ${newBinaryPath}`));
+      this.rejectAllPending(new BridgeTransportUnknownOutcomeError(`${this.errorPrefix} Bridge restarting with updated binary: ${newBinaryPath}`));
       if (!this.process)
         return;
       const proc = this.process;
@@ -1215,11 +1418,11 @@ var init_bridge = __esm(() => {
       })();
       const useFastembedBackend = semanticBackend === undefined || semanticBackend === "fastembed" || semanticBackend === "";
       const ortDir = typeof this.configOverrides._ort_dylib_dir === "string" && useFastembedBackend ? this.configOverrides._ort_dylib_dir : null;
-      const ortLibraryPath = ortDir == null ? null : join2(ortDir, this.platform === "win32" ? "onnxruntime.dll" : this.platform === "darwin" ? "libonnxruntime.dylib" : "libonnxruntime.so");
+      const ortLibraryPath = ortDir == null ? null : join3(ortDir, this.platform === "win32" ? "onnxruntime.dll" : this.platform === "darwin" ? "libonnxruntime.dylib" : "libonnxruntime.so");
       const env = { ...process.env };
       this.logVia(`bridge.spawnProcess: useFastembedBackend=${useFastembedBackend}, ` + `parentORT=${process.env.ORT_DYLIB_PATH ?? "(unset)"}, ` + `ortLibraryPath=${ortLibraryPath ?? "(none)"}`);
       if (useFastembedBackend) {
-        env.FASTEMBED_CACHE_DIR = process.env.FASTEMBED_CACHE_DIR || (typeof this.configOverrides.storage_dir === "string" ? join2(this.configOverrides.storage_dir, "semantic", "models") : join2(homedir2() || "", ".cache", "fastembed"));
+        env.FASTEMBED_CACHE_DIR = process.env.FASTEMBED_CACHE_DIR || (typeof this.configOverrides.storage_dir === "string" ? join3(this.configOverrides.storage_dir, "semantic", "models") : join3(homedir4() || "", ".cache", "fastembed"));
         if (process.env.ORT_DYLIB_PATH) {
           this.logVia(`ORT_DYLIB_PATH inherited from parent env: ${process.env.ORT_DYLIB_PATH}`);
         } else if (ortLibraryPath) {
@@ -1303,12 +1506,14 @@ var init_bridge = __esm(() => {
       this.processGeneration += 1;
       this.recordSpawnedBinaryFingerprint();
       this.lastBinaryFingerprintCheckAt = Date.now();
-      this.stdoutBuffer = "";
-      this.stdoutReadOffset = 0;
+      this.stdoutPending = [];
+      this.stdoutPendingLength = 0;
       this.stderrBuffer = "";
       this.lastChildActivityAt = 0;
       this.consecutiveRequestTimeouts = 0;
       this.stderrTail = [];
+      this.processLoopReferenced = true;
+      this.syncEventLoopHold();
     }
     pushStderrLine(line) {
       this.stderrTail.push(line);
@@ -1362,41 +1567,43 @@ var init_bridge = __esm(() => {
   ${tail}`;
     }
     onStdoutData(data) {
-      if (this.stdoutReadOffset > STDOUT_BUFFER_COMPACT_THRESHOLD) {
-        this.compactStdoutBuffer();
-      }
-      this.stdoutBuffer += data;
-      if (this.stdoutBuffer.length - this.stdoutReadOffset > MAX_STDOUT_BUFFER) {
+      if (this.stdoutPendingLength + data.length > MAX_STDOUT_BUFFER) {
         this.handleCrash(new Error(`aft bridge stdout buffer exceeded ${MAX_STDOUT_BUFFER} bytes — killing bridge`));
         return;
       }
-      let newlineIdx;
-      while ((newlineIdx = this.stdoutBuffer.indexOf(`
-`, this.stdoutReadOffset)) !== -1) {
-        const line = this.stdoutBuffer.slice(this.stdoutReadOffset, newlineIdx).trim();
-        this.stdoutReadOffset = newlineIdx + 1;
+      this.stdoutScannedChars += data.length;
+      const generation = this.processGeneration;
+      let start = 0;
+      let newlineIdx = data.indexOf(`
+`);
+      while (newlineIdx !== -1) {
+        let line = data.slice(start, newlineIdx);
+        if (this.stdoutPending.length > 0) {
+          this.stdoutPending.push(line);
+          line = this.stdoutPending.join("");
+          this.stdoutPending = [];
+          this.stdoutPendingLength = 0;
+        }
+        start = newlineIdx + 1;
+        line = line.trim();
         if (line) {
           this.processStdoutLine(line);
+          if (this.processGeneration !== generation)
+            return;
         }
-        if (this.stdoutReadOffset > STDOUT_BUFFER_COMPACT_THRESHOLD && this.stdoutReadOffset > this.stdoutBuffer.length / 2) {
-          this.compactStdoutBuffer();
-        }
+        newlineIdx = data.indexOf(`
+`, start);
       }
-      if (this.stdoutReadOffset === this.stdoutBuffer.length) {
-        this.stdoutBuffer = "";
-        this.stdoutReadOffset = 0;
+      if (start < data.length) {
+        const rest = start === 0 ? data : data.slice(start);
+        this.stdoutPending.push(rest);
+        this.stdoutPendingLength += rest.length;
       }
     }
-    compactStdoutBuffer() {
-      if (this.stdoutReadOffset === 0)
-        return;
-      this.stdoutBuffer = this.stdoutBuffer.slice(this.stdoutReadOffset);
-      this.stdoutReadOffset = 0;
-    }
     flushStdoutBuffer() {
-      const line = this.stdoutBuffer.slice(this.stdoutReadOffset).trim();
-      this.stdoutBuffer = "";
-      this.stdoutReadOffset = 0;
+      const line = this.stdoutPending.join("").trim();
+      this.stdoutPending = [];
+      this.stdoutPendingLength = 0;
       if (!line)
         return;
       this.processStdoutLine(line);
@@ -1433,6 +1640,7 @@ var init_bridge = __esm(() => {
           const taskId = bashTaskIdFrom(response);
           if (taskId)
             this.outstandingBackgroundTaskIds.delete(taskId);
+          this.syncEventLoopHold();
           this.onBashCompletion?.(response, this);
           return;
         }
@@ -1463,6 +1671,17 @@ var init_bridge = __esm(() => {
           clearTimeout(entry.timer);
           entry.onSettled?.();
           this.consecutiveRequestTimeouts = 0;
+          if (response.success !== false && ![
+            "configure",
+            "version",
+            "status",
+            "ping",
+            "bash_drain_completions",
+            "bash_ack_completions",
+            "cancel_request"
+          ].includes(entry.command)) {
+            this.timeoutRestartAwaitingRecovery = false;
+          }
           this.scheduleRestartCountReset();
           this.accountForBashTaskResponse(entry.command, response);
           entry.resolve(response);
@@ -1470,7 +1689,8 @@ var init_bridge = __esm(() => {
           this.logVia(`Ignoring unknown stdout push frame type: ${response.type}`);
         }
       } catch (_err) {
-        this.warnVia(`Failed to parse stdout line: ${line}`);
+        const quoted = line.length > MALFORMED_STDOUT_LOG_CHARS ? `${line.slice(0, MALFORMED_STDOUT_LOG_CHARS)}… (${line.length} chars)` : line;
+        this.warnVia(`Failed to parse stdout line: ${quoted}`);
       }
     }
     accountForBashTaskResponse(command, response) {
@@ -1487,6 +1707,7 @@ var init_bridge = __esm(() => {
     }
     handleTimeout(trigger, triggeringSessionId) {
       this.consecutiveRequestTimeouts = 0;
+      this.timeoutRestartAwaitingRecovery = true;
       this.spawnedBinaryFingerprint = null;
       const abortedSiblings = Array.from(this.pending, ([requestId, entry]) => ({
         request_id: requestId,
@@ -1533,7 +1754,7 @@ var init_bridge = __esm(() => {
         const delay = 100 * 2 ** this._restartCount;
         this._restartCount++;
         this.logVia(`Auto-restart #${this._restartCount} in ${delay}ms`);
-        setTimeout(() => {
+        const restartTimer = setTimeout(() => {
           if (!this._shuttingDown && !this.isAlive()) {
             try {
               this.spawnProcess();
@@ -1542,6 +1763,7 @@ var init_bridge = __esm(() => {
             }
           }
         }, delay);
+        restartTimer.unref?.();
         this.scheduleRestartCountReset();
       } else {
         this.errorVia(`Max restarts (${this.maxRestarts}) reached, giving up. Logs: ${this.getLogFilePathVia()}${tail}`);
@@ -1562,6 +1784,7 @@ var init_bridge = __esm(() => {
         this._restartCount = 0;
         this.restartResetTimer = null;
       }, BinaryBridge.RESTART_RESET_MS);
+      this.restartResetTimer.unref?.();
     }
     clearRestartResetTimer() {
       if (this.restartResetTimer) {
@@ -1573,55 +1796,57 @@ var init_bridge = __esm(() => {
 });
 
 // ../aft-bridge/dist/cache-paths.js
-import { homedir as homedir3 } from "node:os";
-import { join as join3 } from "node:path";
+import { homedir as homedir5 } from "node:os";
+import { join as join4 } from "node:path";
 function homeDir2(env) {
-  return (process.platform === "win32" ? env.USERPROFILE || env.HOME : env.HOME) || homedir3();
+  return (process.platform === "win32" ? env.USERPROFILE || env.HOME : env.HOME) || homedir5();
 }
-function getOpenCodeCacheRoot(env = process.env, home = homedir3()) {
-  return join3(env.XDG_CACHE_HOME || join3(home, ".cache"), "opencode");
+function getOpenCodeCacheRoot(env = process.env, home = homedir5()) {
+  return join4(env.XDG_CACHE_HOME || join4(home, ".cache"), "opencode");
 }
-function getOpenCodeConfigRoot(env = process.env, home = homedir3()) {
-  return join3(env.XDG_CONFIG_HOME || join3(home, ".config"), "opencode");
+function getOpenCodeConfigRoot(env = process.env, home = homedir5()) {
+  return join4(env.XDG_CONFIG_HOME || join4(home, ".config"), "opencode");
 }
 function getAftCacheRoot(env = process.env) {
   if (env.AFT_CACHE_DIR)
     return env.AFT_CACHE_DIR;
   if (process.platform === "win32") {
-    const base = env.LOCALAPPDATA || env.APPDATA || join3(homeDir2(env), "AppData", "Local");
-    return join3(base, "aft");
+    const base = env.LOCALAPPDATA || env.APPDATA || join4(homeDir2(env), "AppData", "Local");
+    return join4(base, "aft");
   }
-  const base = env.XDG_CACHE_HOME || join3(homeDir2(env), ".cache");
-  return join3(base, "aft");
+  const base = env.XDG_CACHE_HOME || join4(homeDir2(env), ".cache");
+  return join4(base, "aft");
 }
 function getAftBinaryCacheDir(env = process.env) {
-  return join3(getAftCacheRoot(env), "bin");
+  return join4(getAftCacheRoot(env), "bin");
 }
 function getAftLspPackagesDir(env = process.env) {
-  return join3(getAftCacheRoot(env), "lsp-packages");
+  return join4(getAftCacheRoot(env), "lsp-packages");
 }
 function getAftLspBinariesDir(env = process.env) {
-  return join3(getAftCacheRoot(env), "lsp-binaries");
+  return join4(getAftCacheRoot(env), "lsp-binaries");
 }
 var init_cache_paths = () => {};
 
 // ../aft-bridge/dist/callgraph-format.js
-var init_callgraph_format = () => {};
+var init_callgraph_format = __esm(() => {
+  init_path_display();
+});
 // ../aft-bridge/dist/config-error.js
-import { homedir as homedir4 } from "node:os";
-import { isAbsolute, join as join4 } from "node:path";
+import { homedir as homedir6 } from "node:os";
+import { isAbsolute as isAbsolute2, join as join5 } from "node:path";
 function formatConfigErrorMessage(detail) {
   const trimmed = detail.trim();
   const sentence = /[.!?]$/.test(trimmed) ? trimmed : `${trimmed}.`;
   return `${sentence} ${CONFIG_ERROR_RESTART_NOTE}`;
 }
-function resolveSubcConnectionFilePath(raw, home = homedir4()) {
+function resolveSubcConnectionFilePath(raw, home = homedir6()) {
   const trimmed = raw.trim();
   if (trimmed.startsWith("~"))
-    return join4(home, trimmed.slice(1).replace(/^[/\\]/, ""));
-  if (isAbsolute(trimmed))
+    return join5(home, trimmed.slice(1).replace(/^[/\\]/, ""));
+  if (isAbsolute2(trimmed))
     return trimmed;
-  return join4(home, trimmed);
+  return join5(home, trimmed);
 }
 function formatSubcConnectionMissingMessage(raw, resolved) {
   return `subc.connection_file is set to "${raw.trim()}" (resolved: ${resolved}) but no subc ` + `connection file exists there. Start the Subconscious daemon, correct the path, ` + `or remove subc.connection_file from your user config to use the standalone bridge.`;
@@ -1637,7 +1862,7 @@ var init_config_keys = () => {};
 
 // ../aft-bridge/dist/config-tiers.js
 import { existsSync, readFileSync as readFileSync2 } from "node:fs";
-import { resolve as resolve2 } from "node:path";
+import { resolve as resolve3 } from "node:path";
 function readConfigTiers(opts) {
   const tiers = [];
   try {
@@ -1645,7 +1870,7 @@ function readConfigTiers(opts) {
       const doc = readFileSync2(opts.userConfigPath, "utf-8");
       tiers.push({
         tier: "user",
-        source: resolve2(opts.userConfigPath),
+        source: resolve3(opts.userConfigPath),
         doc
       });
     }
@@ -1655,7 +1880,7 @@ function readConfigTiers(opts) {
       const doc = readFileSync2(opts.projectConfigPath, "utf-8");
       tiers.push({
         tier: "project",
-        source: resolve2(opts.projectConfigPath),
+        source: resolve3(opts.projectConfigPath),
         doc
       });
     }
@@ -1757,9 +1982,9 @@ var init_version_probe = __esm(() => {
 
 // ../aft-bridge/dist/downloader.js
 import { createHash as createHash2, randomUUID } from "node:crypto";
-import { chmodSync, closeSync, copyFileSync, createWriteStream, existsSync as existsSync2, mkdirSync, openSync, readdirSync, readFileSync as readFileSync3, renameSync as renameSync2, rmSync, statSync as statSync2, unlinkSync as unlinkSync2, writeSync } from "node:fs";
+import { chmodSync, closeSync as closeSync2, copyFileSync, createWriteStream, existsSync as existsSync2, mkdirSync as mkdirSync2, openSync as openSync2, readdirSync, readFileSync as readFileSync3, renameSync as renameSync2, rmSync, statSync as statSync2, unlinkSync as unlinkSync2, writeSync } from "node:fs";
 import { hostname } from "node:os";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 function expectedVersionFromTag(tag) {
@@ -1783,7 +2008,7 @@ function getBinaryName() {
 function getCachedBinaryPath(version) {
   if (!version)
     return null;
-  const binaryPath = join5(getAftBinaryCacheDir(), version, getBinaryName());
+  const binaryPath = join6(getAftBinaryCacheDir(), version, getBinaryName());
   return existsSync2(binaryPath) ? binaryPath : null;
 }
 async function downloadBinary(version) {
@@ -1800,16 +2025,16 @@ async function downloadBinary(version) {
     return null;
   }
   const tag = rawTag.startsWith("v") ? rawTag : `v${rawTag}`;
-  const versionedCacheDir = join5(getAftBinaryCacheDir(), tag);
+  const versionedCacheDir = join6(getAftBinaryCacheDir(), tag);
   const binaryName = getBinaryName();
-  const binaryPath = join5(versionedCacheDir, binaryName);
+  const binaryPath = join6(versionedCacheDir, binaryName);
   if (existsSync2(binaryPath) && await isExpectedCachedBinary(binaryPath, tag)) {
     return binaryPath;
   }
   const downloadUrl = `https://github.com/${REPO}/releases/download/${tag}/${assetName}`;
   const checksumUrl = `https://github.com/${REPO}/releases/download/${tag}/checksums.sha256`;
   log(`Downloading AFT binary (${tag}) for ${platformKey}...`);
-  const lockPath = join5(versionedCacheDir, ".download.lock");
+  const lockPath = join6(versionedCacheDir, ".download.lock");
   let releaseLock = null;
   let binaryController = null;
   let checksumController = null;
@@ -1843,7 +2068,7 @@ async function downloadBinary(version) {
   process.once("exit", handleExit);
   try {
     if (!existsSync2(versionedCacheDir)) {
-      mkdirSync(versionedCacheDir, { recursive: true });
+      mkdirSync2(versionedCacheDir, { recursive: true });
     }
     releaseLock = await acquireDownloadLock(lockPath);
     sweepStaleDownloadTemps(versionedCacheDir, binaryName);
@@ -2033,7 +2258,7 @@ function sweepStaleDownloadTemps(versionedCacheDir, binaryName) {
       if (!entry.isFile() || !entry.name.startsWith(tempPrefix) || !entry.name.endsWith(".tmp")) {
         continue;
       }
-      const tempPath = join5(versionedCacheDir, entry.name);
+      const tempPath = join6(versionedCacheDir, entry.name);
       const ageMs = Date.now() - statSync2(tempPath).mtimeMs;
       if (Math.abs(ageMs) > DOWNLOAD_LOCK_STALE_MS)
         unlinkSync2(tempPath);
@@ -2048,11 +2273,11 @@ async function acquireDownloadLock(lockPath, timing = {}) {
   while (true) {
     try {
       const owner = createDownloadLockOwner();
-      const fd = openSync(lockPath, "wx");
+      const fd = openSync2(lockPath, "wx");
       try {
         writeSync(fd, owner);
       } finally {
-        closeSync(fd);
+        closeSync2(fd);
       }
       return () => {
         try {
@@ -2132,13 +2357,86 @@ var init_downloader = __esm(() => {
   ensureBinaryInFlight = new Map;
 });
 
+// ../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 isAbsolute3, join as join7, parse, relative as relative2, resolve as resolve4, sep } from "node:path";
+function privateMkdirSync(path, recursive = true) {
+  mkdirSync3(path, {
+    recursive,
+    ...process.platform === "win32" ? {} : { mode: PRIVATE_DIRECTORY_MODE }
+  });
+}
+function privateCopyFileSync(source, destination) {
+  if (process.platform === "win32") {
+    copyFileSync2(source, destination);
+    return;
+  }
+  const input = openSync3(source, "r");
+  let output;
+  try {
+    output = openSync3(destination, "wx", PRIVATE_FILE_MODE);
+    const buffer = Buffer.allocUnsafe(64 * 1024);
+    for (;; ) {
+      const bytes = readSync2(input, buffer);
+      if (bytes === 0)
+        break;
+      let offset = 0;
+      while (offset < bytes)
+        offset += writeSync2(output, buffer, offset, bytes - offset);
+    }
+  } finally {
+    closeSync3(input);
+    if (output !== undefined)
+      closeSync3(output);
+  }
+}
+function openPrivateStorageDir(root, path = root) {
+  const base = resolve4(root);
+  if (!root || base === parse(base).root) {
+    throw new Error(`refusing filesystem root as private storage: ${base}`);
+  }
+  const rel = relative2(base, resolve4(path));
+  if (rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute3(rel))
+    return;
+  privateMkdirSync(path);
+  if (process.platform === "win32")
+    return;
+  let current = base;
+  for (const component of ["", ...rel.split(sep).filter(Boolean)]) {
+    current = join7(current, component);
+    let fd;
+    try {
+      if (lstatSync(current).isSymbolicLink())
+        return;
+      fd = openSync3(current, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+      if ((fstatSync(fd).mode & 63) !== 0)
+        fchmodSync(fd, PRIVATE_DIRECTORY_MODE);
+    } catch (error) {
+      if (!warned.has(current)) {
+        warned.add(current);
+        process.stderr.write(`[aft] could not tighten private storage ${current}: ${String(error)}; continuing
+`);
+      }
+      return;
+    } finally {
+      if (fd !== undefined)
+        closeSync3(fd);
+    }
+  }
+}
+var PRIVATE_FILE_MODE = 384, PRIVATE_DIRECTORY_MODE = 448, warned;
+var init_private_storage = __esm(() => {
+  warned = new Set;
+});
+
 // ../aft-bridge/dist/durable-log.js
 var DEFAULT_LOG_BYTES;
 var init_durable_log = __esm(() => {
+  init_private_storage();
   init_storage_paths();
   DEFAULT_LOG_BYTES = 32 * 1024 * 1024;
 });
-// ../../node_modules/.bun/@cortexkit+subc-client@0.13.1/node_modules/@cortexkit/subc-client/dist/envelope.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.21.2/node_modules/@cortexkit/subc-client/dist/envelope.js
 var MAX_FRAME_BODY_LEN, FrameType, FRAME_TYPE_MAX, Priority, AdmissionClass;
 var init_envelope = __esm(() => {
   MAX_FRAME_BODY_LEN = 64 * 1024 * 1024;
@@ -2169,7 +2467,7 @@ var init_envelope = __esm(() => {
   })(AdmissionClass || (AdmissionClass = {}));
 });
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.13.1/node_modules/@cortexkit/subc-client/dist/socket.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.21.2/node_modules/@cortexkit/subc-client/dist/socket.js
 var WRITE_BORROWED, WRITE_TRACKED_BORROWED;
 var init_socket = __esm(() => {
   init_envelope();
@@ -2177,47 +2475,84 @@ var init_socket = __esm(() => {
   WRITE_TRACKED_BORROWED = Symbol("subc.socket.writeTrackedBorrowed");
 });
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.13.1/node_modules/@cortexkit/subc-client/dist/auth.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.21.2/node_modules/@cortexkit/subc-client/dist/auth.js
 var init_auth = __esm(() => {
   init_socket();
 });
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.13.1/node_modules/@cortexkit/subc-client/dist/connection-file.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.21.2/node_modules/@cortexkit/subc-client/dist/connection-file.js
 var init_connection_file = __esm(() => {
   init_envelope();
 });
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.13.1/node_modules/@cortexkit/subc-client/dist/route-handle.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.21.2/node_modules/@cortexkit/subc-client/dist/launch-nonce.js
+var PROCESS_CELL_KEY, U64_MAX, I32_MAX, RedactedLaunchNonce;
+var init_launch_nonce = __esm(() => {
+  PROCESS_CELL_KEY = Symbol.for("@cortexkit/subc-client/launch-nonce/v1");
+  U64_MAX = (1n << 64n) - 1n;
+  I32_MAX = 2 ** 31 - 1;
+  RedactedLaunchNonce = class RedactedLaunchNonce {
+    source;
+    #value;
+    constructor(value, source) {
+      this.#value = value;
+      this.source = source;
+      Object.freeze(this);
+    }
+    get value() {
+      return this.#value;
+    }
+    toJSON() {
+      return { source: this.source };
+    }
+    [Symbol.for("nodejs.util.inspect.custom")]() {
+      return `LaunchNonce { value: <${this.#value.length} bytes redacted>, source: "${this.source}" }`;
+    }
+  };
+});
+
+// ../../node_modules/.bun/@cortexkit+subc-client@0.21.2/node_modules/@cortexkit/subc-client/dist/route-handle.js
 var connectionToken, reverseRequests;
 var init_route_handle = __esm(() => {
   connectionToken = new WeakMap;
   reverseRequests = new WeakMap;
 });
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.13.1/node_modules/@cortexkit/subc-client/dist/client.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.21.2/node_modules/@cortexkit/subc-client/dist/client.js
 import { debuglog } from "node:util";
-var debug, EMPTY_BODY;
+var debug, EMPTY_BODY, errorFrameFlags, SCOPE_ROUTE_CLOSE_REASONS, ROUTE_OPEN_ADMISSION_PRESSURE_REASONS;
 var init_client = __esm(() => {
   init_auth();
   init_connection_file();
   init_envelope();
+  init_launch_nonce();
   init_route_handle();
   init_socket();
+  init_launch_nonce();
   debug = debuglog("subc-client");
   EMPTY_BODY = new Uint8Array(0);
+  errorFrameFlags = new WeakMap;
+  SCOPE_ROUTE_CLOSE_REASONS = new Set([
+    "scope_ended",
+    "scope_carrier_removed",
+    "scope_delegation_changed",
+    "scope_parent_ended"
+  ]);
+  ROUTE_OPEN_ADMISSION_PRESSURE_REASONS = new Set(["open_admission_full", "target_binds_full"]);
 });
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.13.1/node_modules/@cortexkit/subc-client/dist/provider.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.21.2/node_modules/@cortexkit/subc-client/dist/provider.js
 var init_provider = __esm(() => {
   init_auth();
   init_client();
   init_connection_file();
   init_envelope();
+  init_launch_nonce();
   init_route_handle();
   init_socket();
 });
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.13.1/node_modules/@cortexkit/subc-client/dist/index.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.21.2/node_modules/@cortexkit/subc-client/dist/index.js
 var init_dist = __esm(() => {
   init_client();
   init_route_handle();
@@ -2225,6 +2560,7 @@ var init_dist = __esm(() => {
   init_envelope();
   init_auth();
   init_socket();
+  init_launch_nonce();
   init_provider();
 });
 
@@ -2647,7 +2983,7 @@ var init_lifecycle_registry = __esm(() => {
 var init_project_identity = () => {};
 
 // ../aft-bridge/dist/subc-transport.js
-var CALL_DEADLINE_EXPIRED, LOCALLY_SATISFIED_COMMANDS;
+var CALL_DEADLINE_EXPIRED, LOCALLY_SATISFIED_COMMANDS, dispatchProbes;
 var init_subc_transport = __esm(() => {
   init_dist();
   init_active_logger();
@@ -2656,6 +2992,7 @@ var init_subc_transport = __esm(() => {
   init_project_identity();
   CALL_DEADLINE_EXPIRED = Symbol("call deadline expired");
   LOCALLY_SATISFIED_COMMANDS = new Set(["configure"]);
+  dispatchProbes = new Map;
 });
 
 // ../aft-bridge/dist/error-contract.js
@@ -2686,26 +3023,9 @@ function surfaceDisables(surface) {
       return;
   }
 }
-function parseMinor(version) {
-  const match = /^v?(\d+)\.(\d+)/.exec(version.trim());
-  if (!match)
-    return;
-  return [Number(match[1]), Number(match[2])];
-}
-function policyPhaseForVersion(version) {
-  const minor = parseMinor(version);
-  if (!minor)
-    return "window";
-  const [major, min] = minor;
-  const [rejectMajor, rejectMinor] = POLICY_REJECT_FROM_MINOR;
-  return major > rejectMajor || major === rejectMajor && min >= rejectMinor ? "rejecting" : "window";
-}
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function removed(old, replacement) {
-  return `removed_config_key:${old}:use:${replacement}`;
-}
 function hasPath(map, path) {
   const dot = path.indexOf(".");
   if (dot < 0)
@@ -2728,12 +3048,147 @@ function falseRuntimeGates(map) {
 function sortedUnique(names) {
   return [...new Set(names)].sort();
 }
-function translateBlock(map, userBase, phase, blockLabel, out) {
-  if (Object.hasOwn(map, "gh_read"))
-    out.errors.push(removed("gh_read", "github.read"));
-  if (isRecord(map.gh_shim) && Object.hasOwn(map.gh_shim, "enabled")) {
-    out.errors.push(removed("gh_shim", "github.shim"));
+function recordRetired(out, prefix, key) {
+  out.legacyInput = true;
+  out.retiredKeys.push(`${prefix}${key}`);
+}
+function superseded(out, key, message) {
+  out.warnings.push({ code: "superseded_legacy_config", key, message });
+}
+function nestedBool(map, container, leaf) {
+  const inner = map[container];
+  return isRecord(inner) && typeof inner[leaf] === "boolean" ? inner[leaf] : undefined;
+}
+function translateGithubAliases(map, prefix, out) {
+  const masterOff = nestedBool(map, "github", "enabled") === false;
+  for (const [alias, leaf, retiredKey] of [
+    ["gh_read", "read", "gh_read"],
+    ["gh_shim", "shim", "gh_shim.enabled"]
+  ]) {
+    const aliasBlock = map[alias];
+    const supplied = alias === "gh_read" ? Object.hasOwn(map, alias) : isRecord(aliasBlock) && Object.hasOwn(aliasBlock, "enabled");
+    if (!supplied)
+      continue;
+    recordRetired(out, prefix, retiredKey);
+    const aliasValue = isRecord(aliasBlock) && typeof aliasBlock.enabled === "boolean" ? aliasBlock.enabled : undefined;
+    if (aliasValue !== undefined) {
+      const canonical = nestedBool(map, "github", leaf);
+      if (canonical !== undefined) {
+        if (canonical !== aliasValue) {
+          superseded(out, `${prefix}${retiredKey}`, `${alias}.enabled=${aliasValue} is ignored because github.${leaf}=${canonical} is set`);
+        }
+      } else if (masterOff) {
+        if (aliasValue) {
+          superseded(out, `${prefix}${retiredKey}`, `${alias}.enabled=true is ignored because github.enabled=false switches github.${leaf} off`);
+        }
+      } else {
+        if (!Object.hasOwn(map, "github"))
+          map.github = {};
+        if (isRecord(map.github))
+          map.github[leaf] = aliasValue;
+      }
+    }
+    if (alias === "gh_read") {
+      delete map.gh_read;
+    } else if (isRecord(aliasBlock)) {
+      delete aliasBlock.enabled;
+      if (Object.keys(aliasBlock).length === 0)
+        delete map.gh_shim;
+    }
+  }
+}
+function takeNested(map, container, leaf) {
+  const inner = map[container];
+  if (!isRecord(inner) || !Object.hasOwn(inner, leaf))
+    return { found: false };
+  const value = inner[leaf];
+  delete inner[leaf];
+  if (Object.keys(inner).length === 0)
+    delete map[container];
+  return { found: true, value };
+}
+function translateInspectLspPaths(map, prefix, out) {
+  const ttl = takeNested(map, "idle", "lsp_ttl_minutes");
+  if (ttl.found) {
+    recordRetired(out, prefix, "idle.lsp_ttl_minutes");
+    if (isRecord(map.lsp) && map.lsp.idle_minutes !== undefined) {
+      superseded(out, `${prefix}idle.lsp_ttl_minutes`, "idle.lsp_ttl_minutes is ignored because lsp.idle_minutes is set");
+    } else {
+      const raw = typeof ttl.value === "number" && Number.isSafeInteger(ttl.value) ? ttl.value : LSP_IDLE_MINUTES_DEFAULT;
+      const minutes = Math.min(LSP_IDLE_MINUTES_MAX, Math.max(LSP_IDLE_MINUTES_MIN, raw));
+      if (!Object.hasOwn(map, "lsp"))
+        map.lsp = {};
+      if (isRecord(map.lsp))
+        map.lsp.idle_minutes = minutes;
+    }
   }
+  for (const leaf of ["tier2_soft_deadline_ms", "max_drill_down_items"]) {
+    if (takeNested(map, "inspect", leaf).found)
+      recordRetired(out, prefix, `inspect.${leaf}`);
+  }
+}
+function translateExperimentalPaths(map, prefix, out) {
+  for (const [oldKey, leaf] of [
+    ["experimental_lsp_ty", "lsp_ty"],
+    ["experimental_bash_rewrite", "rewrite"],
+    ["experimental_bash_compress", "compress"],
+    ["experimental_bash_background", "background"]
+  ]) {
+    if (!Object.hasOwn(map, oldKey))
+      continue;
+    recordRetired(out, prefix, oldKey);
+    const value = map[oldKey];
+    delete map[oldKey];
+    if (!isRecord(map.experimental))
+      map.experimental = {};
+    const experimental = map.experimental;
+    let destination = experimental;
+    if (leaf !== "lsp_ty") {
+      if (!isRecord(experimental.bash))
+        experimental.bash = {};
+      destination = experimental.bash;
+    }
+    if (Object.hasOwn(destination, leaf)) {
+      superseded(out, oldKey, `${oldKey} is ignored because experimental.${leaf === "lsp_ty" ? leaf : `bash.${leaf}`} is already set`);
+    } else {
+      destination[leaf] = value;
+    }
+  }
+  if (!isRecord(map.experimental) || !Object.hasOwn(map.experimental, "bash"))
+    return;
+  const experimental = map.experimental;
+  const legacy = experimental.bash;
+  if (isRecord(legacy)) {
+    if (!["rewrite", "compress", "background"].some((leaf) => Object.hasOwn(legacy, leaf)))
+      return;
+    for (const leaf of Object.keys(legacy))
+      recordRetired(out, prefix, `experimental.bash.${leaf}`);
+    if (Object.hasOwn(map, "bash")) {
+      superseded(out, "experimental.bash", 'experimental.bash is ignored because top-level "bash" is already set');
+    } else {
+      const bash = {
+        rewrite: legacy.rewrite === true,
+        compress: legacy.compress === true,
+        background: legacy.background === true
+      };
+      for (const leaf of ["long_running_reminder_enabled", "long_running_reminder_interval_ms"]) {
+        if (Object.hasOwn(legacy, leaf))
+          bash[leaf] = legacy[leaf];
+      }
+      map.bash = bash;
+    }
+  } else {
+    recordRetired(out, prefix, "experimental.bash");
+  }
+  delete experimental.bash;
+  if (Object.keys(experimental).length === 0)
+    delete map.experimental;
+}
+function translateBlock(map, userBase, blockLabel, out) {
+  const prefix = blockLabel === "base" ? "" : `${blockLabel}.`;
+  translateGithubAliases(map, prefix, out);
+  translateInspectLspPaths(map, prefix, out);
+  translateExperimentalPaths(map, prefix, out);
   let explicitList;
   const rawList = map.disabled_tools;
   if (Array.isArray(rawList) && rawList.every((entry) => typeof entry === "string")) {
@@ -2741,30 +3196,17 @@ function translateBlock(map, userBase, phase, blockLabel, out) {
       const host = LEGACY_TOOL_ALIASES[name];
       if (host === undefined)
         return name;
-      out.legacyInput = true;
-      if (phase === "rejecting")
-        out.errors.push(removed(name, host));
+      recordRetired(out, prefix, name);
       return host;
     });
   }
-  const suppliedPaths = RETIRED_PATHS.map(([path]) => path).filter((path) => hasPath(map, path));
-  if (suppliedPaths.length > 0)
-    out.legacyInput = true;
-  const gates = falseRuntimeGates(map);
-  if (phase === "rejecting") {
-    for (const path of suppliedPaths) {
-      const replacement = RETIRED_PATHS.find(([old]) => old === path)?.[1] ?? "disabled_tools";
-      out.errors.push(removed(path, replacement));
-    }
-    if (gates.length > 0 && explicitList === undefined) {
-      out.warnings.push({
-        code: "legacy_runtime_gate_runtime_only",
-        key: blockLabel,
-        message: `${gates.join(", ")} now restricts runtime behavior only and no longer removes tool registrations; list tools in disabled_tools to unregister them`
-      });
-    }
-    return;
+  for (const [path] of RETIRED_PATHS) {
+    if (path === "experimental.bash")
+      continue;
+    if (hasPath(map, path))
+      recordRetired(out, prefix, path);
   }
+  const gates = falseRuntimeGates(map);
   if (explicitList !== undefined)
     map.disabled_tools = explicitList;
   for (const [leaf, legacy, experimental] of INDEX_INPUTS) {
@@ -2791,19 +3233,11 @@ function translateBlock(map, userBase, phase, blockLabel, out) {
       }
       if (canonical !== undefined) {
         if (canonical !== value) {
-          out.warnings.push({
-            code: "superseded_legacy_config",
-            key,
-            message: `${key}=${value} is ignored because indexes.${leaf}=${canonical} is set`
-          });
+          superseded(out, key, `${key}=${value} is ignored because indexes.${leaf}=${canonical} is set`);
         }
       } else if (chosen !== undefined) {
         if (chosen !== value) {
-          out.warnings.push({
-            code: "superseded_legacy_config",
-            key,
-            message: `${key}=${value} is ignored because ${legacy}=${chosen} takes precedence`
-          });
+          superseded(out, key, `${key}=${value} is ignored because ${legacy}=${chosen} takes precedence`);
         }
       } else {
         chosen = value;
@@ -2825,11 +3259,7 @@ function translateBlock(map, userBase, phase, blockLabel, out) {
         if (!Object.hasOwn(github, leaf))
           github[leaf] = false;
         else if (github[leaf] === true) {
-          out.warnings.push({
-            code: "superseded_legacy_config",
-            key: "github.enabled",
-            message: `github.enabled=false is ignored for github.${leaf} because github.${leaf}=true is set`
-          });
+          superseded(out, "github.enabled", `github.enabled=false is ignored for github.${leaf} because github.${leaf}=true is set`);
         }
       }
     }
@@ -2870,21 +3300,19 @@ function translateBlock(map, userBase, phase, blockLabel, out) {
       message: RETIRED_ENABLED_FALSE_INDEXES_NOTE
     });
   }
-  for (const gate of gates) {
-    if (gate === "backup.enabled")
-      generated.add("aft_safety");
-    else if (gate === "inspect.enabled")
-      generated.add("aft_inspect");
-    else
-      for (const name of BASH_GATE_DISABLES)
-        generated.add(name);
+  if (gates.length > 0 && explicitList === undefined) {
+    out.warnings.push({
+      code: "legacy_runtime_gate_runtime_only",
+      key: blockLabel,
+      message: `${gates.join(", ")} now restricts runtime behavior only and no longer removes tool registrations; list tools in disabled_tools to unregister them`
+    });
   }
   if (explicitList !== undefined) {
     if (explicitSurface || generated.size > 0) {
       out.warnings.push({
         code: "superseded_legacy_config",
         key: blockLabel,
-        message: "disabled_tools is set explicitly, so legacy tool_surface/hoist_builtin_tools/enabled and runtime gates do not change registration",
+        message: "disabled_tools is set explicitly, so legacy tool_surface/hoist_builtin_tools/enabled do not change registration",
         once: true
       });
     }
@@ -2901,29 +3329,22 @@ function translateBlock(map, userBase, phase, blockLabel, out) {
   }
   if (list !== undefined)
     map.disabled_tools = list;
-  if (gates.length > 0) {
-    out.warnings.push({
-      code: "legacy_runtime_gate_requires_fix",
-      key: blockLabel,
-      message: `${gates.join(", ")} still removes tool registrations during this release only; run \`npx @cortexkit/aft doctor --fix\` to record the choice in disabled_tools`
-    });
-  }
 }
-function translateConfigDocument(map, phase, tier) {
+function translateConfigDocument(map, tier) {
   const out = {
-    errors: [],
     warnings: [],
     legacyInput: false,
+    retiredKeys: [],
     retiredEnabledFalse: false
   };
-  translateBlock(map, tier === "user", phase, "base", out);
+  translateBlock(map, tier === "user", "base", out);
   if (isRecord(map.harnesses)) {
     for (const [name, block] of Object.entries(map.harnesses)) {
       if (isRecord(block))
-        translateBlock(block, false, phase, `harnesses.${name}`, out);
+        translateBlock(block, false, `harnesses.${name}`, out);
     }
   }
-  out.errors = sortedUnique(out.errors);
+  out.retiredKeys = sortedUnique(out.retiredKeys);
   return out;
 }
 function canonicalJson(value) {
@@ -2950,7 +3371,7 @@ function mergeIndexes(base, override, restricted) {
   }
   return merged;
 }
-var CANONICAL_TOOLS, HOST_TOOL_NAMES, DEFAULT_DISABLED_TOOLS, LEGACY_TOOL_ALIASES, BASH_GATE_DISABLES, POLICY_REJECT_FROM_MINOR, RETIRED_PATHS, INDEX_INPUTS, RETIRED_ENABLED_FALSE_INDEXES_NOTE = "enabled: false no longer turns AFT off: it is translated to disabling every tool, but the trigram, semantic and callgraph indexes still build. To keep AFT from indexing this repository, also set indexes.trigram, indexes.semantic and indexes.callgraph to false.", SEMANTIC_COST_NOTICE_DIGEST, ConfigRejectedError;
+var CANONICAL_TOOLS, HOST_TOOL_NAMES, DEFAULT_DISABLED_TOOLS, LEGACY_TOOL_ALIASES, RETIRED_PATHS, INDEX_INPUTS, LSP_IDLE_MINUTES_DEFAULT = 60, LSP_IDLE_MINUTES_MIN = 5, LSP_IDLE_MINUTES_MAX = 1440, RETIRED_ENABLED_FALSE_INDEXES_NOTE = "enabled: false no longer turns AFT off: it is translated to disabling every tool, but the trigram, semantic and callgraph indexes still build. To keep AFT from indexing this repository, also set indexes.trigram, indexes.semantic and indexes.callgraph to false.", SEMANTIC_COST_NOTICE_DIGEST;
 var init_feature_config = __esm(() => {
   CANONICAL_TOOLS = [
     "aft_callgraph",
@@ -2996,14 +3417,6 @@ var init_feature_config = __esm(() => {
     aft_glob: "glob",
     aft_bash: "bash"
   };
-  BASH_GATE_DISABLES = [
-    "bash",
-    "bash_kill",
-    "bash_status",
-    "bash_watch",
-    "bash_write"
-  ];
-  POLICY_REJECT_FROM_MINOR = [0, 59];
   RETIRED_PATHS = [
     ["tool_surface", "disabled_tools"],
     ["hoist_builtin_tools", "disabled_tools"],
@@ -3013,7 +3426,12 @@ var init_feature_config = __esm(() => {
     ["semantic_search", "indexes.semantic"],
     ["experimental_semantic_search", "indexes.semantic"],
     ["callgraph_store", "indexes.callgraph"],
-    ["github.enabled", "github.read,github.write,github.shim"]
+    ["github.enabled", "github.read,github.write,github.shim"],
+    ["experimental_lsp_ty", "experimental.lsp_ty"],
+    ["experimental_bash_rewrite", "bash.rewrite"],
+    ["experimental_bash_compress", "bash.compress"],
+    ["experimental_bash_background", "bash.background"],
+    ["experimental.bash", "bash"]
   ];
   INDEX_INPUTS = [
     ["trigram", "search_index", "experimental_search_index"],
@@ -3021,20 +3439,13 @@ var init_feature_config = __esm(() => {
     ["callgraph", "callgraph_store", undefined]
   ];
   SEMANTIC_COST_NOTICE_DIGEST = noticeDigest({ notice: "semantic_default_cost_v1" });
-  ConfigRejectedError = class ConfigRejectedError extends Error {
-    errors;
-    constructor(errors, source) {
-      super(`AFT configuration${source ? ` at ${source}` : ""} was rejected: ${errors.join(", ")}. ` + "Run `npx @cortexkit/aft doctor --fix` to migrate removed keys.");
-      this.name = "ConfigRejectedError";
-      this.errors = errors;
-    }
-  };
 });
 // ../aft-bridge/dist/pool.js
 var DEFAULT_IDLE_TIMEOUT_MS, CLEANUP_INTERVAL_MS;
 var init_pool = __esm(() => {
   init_active_logger();
   init_bridge();
+  init_lifecycle_registry();
   init_project_identity();
   DEFAULT_IDLE_TIMEOUT_MS = 30 * 60 * 1000;
   CLEANUP_INTERVAL_MS = 60 * 1000;
@@ -3043,6 +3454,7 @@ var init_pool = __esm(() => {
 // ../aft-bridge/dist/revivable-transport.js
 var init_revivable_transport = __esm(() => {
   init_active_logger();
+  init_lifecycle_registry();
   init_project_identity();
 });
 
@@ -3058,6 +3470,7 @@ var init_transport_factory = __esm(() => {
 // ../aft-bridge/dist/location-lifecycle.js
 var LIFECYCLE_STATE, RELEASE_LOCATION;
 var init_location_lifecycle = __esm(() => {
+  init_bridge();
   init_project_identity();
   init_transport_factory();
   LIFECYCLE_STATE = Symbol.for("@cortexkit/aft-bridge/location-lifecycle/v1");
@@ -3073,35 +3486,37 @@ var init_message_detach = __esm(() => {
 });
 
 // ../aft-bridge/dist/paths.js
-import { homedir as homedir5 } from "node:os";
-import { dirname, isAbsolute as isAbsolute2, join as join6, resolve as resolve3 } from "node:path";
+import { homedir as homedir7 } from "node:os";
+import { dirname as dirname2, isAbsolute as isAbsolute4, join as join8, resolve as resolve5 } from "node:path";
 function homeDir3() {
   if (process.platform === "win32")
-    return process.env.USERPROFILE || process.env.HOME || homedir5();
-  return process.env.HOME || homedir5();
+    return process.env.USERPROFILE || process.env.HOME || homedir7();
+  return process.env.HOME || homedir7();
 }
 function configHome() {
   const xdg = process.env.XDG_CONFIG_HOME;
-  if (xdg && isAbsolute2(xdg))
+  if (xdg && isAbsolute4(xdg))
     return xdg;
-  return join6(homeDir3(), ".config");
+  return join8(homeDir3(), ".config");
 }
 function resolveCortexKitUserConfigPath() {
-  return join6(configHome(), "cortexkit", "aft.jsonc");
+  return join8(configHome(), "cortexkit", "aft.jsonc");
 }
 function resolveCortexKitProjectConfigPath(projectDirectory) {
-  return join6(projectDirectory, ".cortexkit", "aft.jsonc");
+  return join8(projectDirectory, ".cortexkit", "aft.jsonc");
 }
-var init_paths = () => {};
+var init_paths = __esm(() => {
+  init_private_storage();
+});
 
 // ../aft-bridge/dist/resolver.js
-import { closeSync as closeSync2, existsSync as existsSync3, promises as fsPromises, openSync as openSync2, readFileSync as readFileSync4, readSync } from "node:fs";
+import { closeSync as closeSync4, existsSync as existsSync3, promises as fsPromises, openSync as openSync4, readFileSync as readFileSync4, readSync as readSync3 } from "node:fs";
 function isNativeExecutable(binaryPath) {
   let fd = null;
   try {
-    fd = openSync2(binaryPath, "r");
+    fd = openSync4(binaryPath, "r");
     const buf = Buffer.alloc(4);
-    const read = readSync(fd, buf, 0, 4, 0);
+    const read = readSync3(fd, buf, 0, 4, 0);
     if (read < 2)
       return false;
     const b0 = buf[0];
@@ -3122,7 +3537,7 @@ function isNativeExecutable(binaryPath) {
   } finally {
     if (fd !== null) {
       try {
-        closeSync2(fd);
+        closeSync4(fd);
       } catch {}
     }
   }
@@ -3150,12 +3565,12 @@ var init_migration = __esm(() => {
 });
 
 // ../aft-bridge/dist/migration-notices.js
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync5, renameSync as renameSync3, rmdirSync, statSync as statSync3, writeFileSync as writeFileSync2 } from "node:fs";
-import { homedir as homedir6 } from "node:os";
-import { dirname as dirname2, join as join7, resolve as resolve4 } from "node:path";
+import { readFileSync as readFileSync5, renameSync as renameSync3, rmdirSync, statSync as statSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { homedir as homedir8 } from "node:os";
+import { dirname as dirname3, join as join9, resolve as resolve6 } from "node:path";
 function migrationNoticeStorePath(env = process.env) {
-  const stateHome = env.XDG_STATE_HOME && env.XDG_STATE_HOME.length > 0 ? env.XDG_STATE_HOME : join7(homedir6(), ".local", "state");
-  return join7(stateHome, "cortexkit", "aft", "migration-notices.json");
+  const stateHome = env.XDG_STATE_HOME && env.XDG_STATE_HOME.length > 0 ? env.XDG_STATE_HOME : join9(homedir8(), ".local", "state");
+  return join9(stateHome, "cortexkit", "aft", "migration-notices.json");
 }
 function readRecords(storePath) {
   try {
@@ -3167,11 +3582,11 @@ function readRecords(storePath) {
 }
 function withStoreLock(storePath, action) {
   const lockPath = `${storePath}.lock`;
-  mkdirSync2(dirname2(storePath), { recursive: true });
+  openPrivateStorageDir(dirname3(storePath));
   const deadline = Date.now() + 2000;
   for (;; ) {
     try {
-      mkdirSync2(lockPath);
+      privateMkdirSync(lockPath, false);
       break;
     } catch (error) {
       if (error.code !== "EEXIST")
@@ -3194,30 +3609,34 @@ function withStoreLock(storePath, action) {
   }
 }
 function clearMigrationNotices(configPath, storePath = migrationNoticeStorePath()) {
-  const prefix = `${resolve4(configPath)}|`;
+  const prefix = `${resolve6(configPath)}|`;
   withStoreLock(storePath, () => {
     const records = readRecords(storePath);
     for (const key of Object.keys(records))
       if (key.startsWith(prefix))
         delete records[key];
     writeFileSync2(storePath, `${JSON.stringify(records, null, 2)}
-`, "utf8");
+`, {
+      encoding: "utf8",
+      mode: PRIVATE_FILE_MODE
+    });
   });
 }
 var LOCK_STALE_MS = 1e4;
 var init_migration_notices = __esm(() => {
   init_feature_config();
+  init_private_storage();
 });
 
 // ../aft-bridge/dist/npm-resolver.js
 import { readdirSync as readdirSync2, statSync as statSync4 } from "node:fs";
-import { homedir as homedir7 } from "node:os";
-import { dirname as dirname3, isAbsolute as isAbsolute3, join as join8 } from "node:path";
+import { homedir as homedir9 } from "node:os";
+import { dirname as dirname4, isAbsolute as isAbsolute5, join as join10 } from "node:path";
 function defaultDeps() {
   return {
     platform: process.platform,
     env: process.env,
-    home: homedir7(),
+    home: homedir9(),
     execPath: process.execPath
   };
 }
@@ -3239,16 +3658,16 @@ function npmFromPath(deps) {
   const separator = deps.platform === "win32" ? ";" : ":";
   for (const entry of raw.split(separator)) {
     const dir = entry.trim().replace(/^"|"$/g, "");
-    if (!dir || !isAbsolute3(dir))
+    if (!dir || !isAbsolute5(dir))
       continue;
-    if (isFile(join8(dir, name)))
+    if (isFile(join10(dir, name)))
       return dir;
   }
   return null;
 }
 function npmAdjacentToNode(deps) {
-  const dir = dirname3(deps.execPath);
-  return isFile(join8(dir, npmBinaryName(deps.platform))) ? dir : null;
+  const dir = dirname4(deps.execPath);
+  return isFile(join10(dir, npmBinaryName(deps.platform))) ? dir : null;
 }
 function highestVersionedNodeBin(installsDir, name) {
   let entries;
@@ -3257,8 +3676,8 @@ function highestVersionedNodeBin(installsDir, name) {
   } catch {
     return null;
   }
-  const candidates = entries.filter((v) => isFile(join8(installsDir, v, "bin", name))).sort((a, b) => compareVersionsDesc(a, b));
-  return candidates.length > 0 ? join8(installsDir, candidates[0], "bin") : null;
+  const candidates = entries.filter((v) => isFile(join10(installsDir, v, "bin", name))).sort((a, b) => compareVersionsDesc(a, b));
+  return candidates.length > 0 ? join10(installsDir, candidates[0], "bin") : null;
 }
 function compareVersionsDesc(a, b) {
   const pa = a.replace(/^v/, "").split(".").map((n) => Number.parseInt(n, 10));
@@ -3283,22 +3702,22 @@ function wellKnownNpmDirs(deps) {
     const programFiles = env.ProgramFiles || "C:\\Program Files";
     const appData = env.APPDATA;
     const localAppData = env.LOCALAPPDATA;
-    push(join8(programFiles, "nodejs"));
+    push(join10(programFiles, "nodejs"));
     if (appData)
-      push(join8(appData, "npm"));
+      push(join10(appData, "npm"));
     if (localAppData)
-      push(join8(localAppData, "Volta", "bin"));
+      push(join10(localAppData, "Volta", "bin"));
     if (env.NVM_SYMLINK)
       push(env.NVM_SYMLINK);
   } else {
     if (env.NVM_BIN)
       push(env.NVM_BIN);
-    push(highestVersionedNodeBin(join8(home, ".nvm", "versions", "node"), name));
-    push(highestVersionedNodeBin(join8(home, ".local", "share", "mise", "installs", "node"), name));
-    push(highestVersionedNodeBin(join8(home, ".asdf", "installs", "nodejs"), name));
-    push(join8(home, ".volta", "bin"));
-    push(join8(home, ".asdf", "shims"));
-    const systemDirs = deps.systemNpmDirs ?? (platform === "darwin" ? ["/opt/homebrew/bin", "/usr/local/bin"] : ["/usr/local/bin", "/usr/bin", join8(home, ".local", "bin")]);
+    push(highestVersionedNodeBin(join10(home, ".nvm", "versions", "node"), name));
+    push(highestVersionedNodeBin(join10(home, ".local", "share", "mise", "installs", "node"), name));
+    push(highestVersionedNodeBin(join10(home, ".asdf", "installs", "nodejs"), name));
+    push(join10(home, ".volta", "bin"));
+    push(join10(home, ".asdf", "shims"));
+    const systemDirs = deps.systemNpmDirs ?? (platform === "darwin" ? ["/opt/homebrew/bin", "/usr/local/bin"] : ["/usr/local/bin", "/usr/bin", join10(home, ".local", "bin")]);
     for (const dir of systemDirs)
       push(dir);
   }
@@ -3308,12 +3727,12 @@ function resolveNpm(deps = defaultDeps()) {
   const name = npmBinaryName(deps.platform);
   const onPath = npmFromPath(deps);
   if (onPath)
-    return { command: join8(onPath, name), binDir: onPath };
+    return { command: join10(onPath, name), binDir: onPath };
   const adjacent = npmAdjacentToNode(deps);
   if (adjacent)
-    return { command: join8(adjacent, name), binDir: adjacent };
+    return { command: join10(adjacent, name), binDir: adjacent };
   for (const dir of wellKnownNpmDirs(deps)) {
-    const candidate = join8(dir, name);
+    const candidate = join10(dir, name);
     if (isFile(candidate))
       return { command: candidate, binDir: dir };
   }
@@ -3474,7 +3893,7 @@ function terminateNpmProcessTree(child, invocation, env = process.env, gracePeri
     };
     child.once("exit", onChildExit);
     const systemRoot = env.SystemRoot ?? env.SYSTEMROOT;
-    const taskkill = systemRoot ? join8(systemRoot, "System32", "taskkill.exe") : "taskkill.exe";
+    const taskkill = systemRoot ? join10(systemRoot, "System32", "taskkill.exe") : "taskkill.exe";
     try {
       killer = spawn(taskkill, ["/pid", String(child.pid), "/t", "/f"], {
         stdio: "ignore",
@@ -3510,10 +3929,10 @@ var init_npm_resolver = __esm(() => {
 });
 
 // ../aft-bridge/dist/onnx-probe.js
-import { closeSync as closeSync3, existsSync as existsSync4, openSync as openSync3, readSync as readSync2, realpathSync } from "node:fs";
+import { closeSync as closeSync5, existsSync as existsSync4, openSync as openSync5, readSync as readSync4, realpathSync as realpathSync2 } from "node:fs";
 function readAt(fd, offset, length) {
   const buffer = Buffer.alloc(length);
-  const read = readSync2(fd, buffer, 0, length, offset);
+  const read = readSync4(fd, buffer, 0, length, offset);
   return buffer.subarray(0, read);
 }
 function cpuTypeForArch(arch) {
@@ -3587,7 +4006,7 @@ function isUncheckableDependency(path) {
 function probeOnnxRuntimeLoadable(libPath, arch = process.arch) {
   let fd;
   try {
-    fd = openSync3(realpathSync(libPath), "r");
+    fd = openSync5(realpathSync2(libPath), "r");
   } catch (err) {
     return {
       loadable: false,
@@ -3621,7 +4040,7 @@ function probeOnnxRuntimeLoadable(libPath, arch = process.arch) {
   } catch {
     return UNCHECKED;
   } finally {
-    closeSync3(fd);
+    closeSync5(fd);
   }
 }
 var MH_MAGIC = 4277009102, MH_MAGIC_64 = 4277009103, FAT_MAGIC = 3405691582, LC_LOAD_DYLIB = 12, LC_REEXPORT_DYLIB = 2147483679, LC_LOAD_UPWARD_DYLIB = 2147483683, CPU_TYPE_X86_64 = 16777223, CPU_TYPE_ARM64 = 16777228, MAX_HEADER_BYTES, UNCHECKED;
@@ -3632,19 +4051,30 @@ var init_onnx_probe = __esm(() => {
 
 // ../aft-bridge/dist/tar-executable.js
 import { existsSync as existsSync5 } from "node:fs";
-import { join as join9 } from "node:path";
+import { join as join11 } from "node:path";
 function windowsTarExecutable(options = {}) {
   const platform = options.platform ?? process.platform;
   if (platform !== "win32")
     return "tar";
   const env = options.env ?? process.env;
-  const systemTar = join9(env.SystemRoot ?? "C:\\Windows", "System32", "tar.exe");
+  const systemTar = join11(env.SystemRoot ?? "C:\\Windows", "System32", "tar.exe");
   return (options.exists ?? existsSync5)(systemTar) ? systemTar : "tar";
 }
-function execTarExtractionSync(args, timeout) {
+function execTarExtractionSync(args, timeout, privateStorage = false) {
   const executable = windowsTarExecutable();
   try {
-    execFileSync(executable, args, { stdio: "pipe", timeout });
+    if (privateStorage && process.platform !== "win32") {
+      execFileSync("/bin/sh", [
+        "-c",
+        'umask 077; exec "$@"',
+        "aft-extract",
+        executable,
+        "--no-same-permissions",
+        ...args.map((arg, index) => index === 0 && !arg.startsWith("-") ? `-${arg}` : arg)
+      ], { stdio: "pipe", timeout });
+    } else {
+      execFileSync(executable, args, { stdio: "pipe", timeout });
+    }
   } catch (cause) {
     const detail = cause instanceof Error ? cause.message : String(cause);
     throw new Error(`tar extraction failed using ${executable}: ${detail}`, { cause });
@@ -3655,9 +4085,9 @@ var init_tar_executable = __esm(() => {
 });
 
 // ../aft-bridge/dist/onnx-runtime.js
-import { createHash as createHash4, randomBytes } from "node:crypto";
-import { chmodSync as chmodSync2, closeSync as closeSync4, copyFileSync as copyFileSync2, createWriteStream as createWriteStream2, existsSync as existsSync6, lstatSync, mkdirSync as mkdirSync3, openSync as openSync4, readdirSync as readdirSync3, readFileSync as readFileSync6, readlinkSync, realpathSync as realpathSync2, renameSync as renameSync4, rmSync as rmSync2, statSync as statSync5, symlinkSync, unlinkSync as unlinkSync3, writeFileSync as writeFileSync3 } from "node:fs";
-import { basename, dirname as dirname4, isAbsolute as isAbsolute4, join as join10, relative, resolve as resolve5, win32 } from "node:path";
+import { randomBytes } from "node:crypto";
+import { chmodSync as chmodSync2, closeSync as closeSync6, copyFileSync as copyFileSync3, createWriteStream as createWriteStream2, existsSync as existsSync6, lstatSync as lstatSync2, openSync as openSync6, readdirSync as readdirSync3, readFileSync as readFileSync6, readlinkSync, realpathSync as realpathSync3, renameSync as renameSync4, rmSync as rmSync2, statSync as statSync5, symlinkSync, unlinkSync as unlinkSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { basename, dirname as dirname5, isAbsolute as isAbsolute6, join as join12, relative as relative3, resolve as resolve7, win32 as win322 } from "node:path";
 import { Readable as Readable2 } from "node:stream";
 import { pipeline as pipeline2 } from "node:stream/promises";
 function getPlatformInfo() {
@@ -3694,14 +4124,14 @@ function resolveOnnxRuntime(storageDir, seams) {
   inflightResolutions.set(storageDir, resolution);
   return resolution;
 }
-function findCachedOnnxRuntime(ortVersionDir, libName) {
+async function findCachedOnnxRuntime(ortVersionDir, libName) {
   const resolvedOrtDir = resolveCachedOnnxRuntimeDir(ortVersionDir, libName);
-  const libPath = join10(resolvedOrtDir, libName);
+  const libPath = join12(resolvedOrtDir, libName);
   if (existsSync6(libPath)) {
     const meta = readOnnxInstalledMeta(ortVersionDir);
     if (meta?.sha256) {
       try {
-        const currentHash = sha256File2(libPath);
+        const currentHash = await cachedFileSha256(libPath);
         if (currentHash !== meta.sha256) {
           error(`ONNX Runtime at ${resolvedOrtDir}: TOFU sha256 mismatch — refusing to use ` + `tampered binary. Recorded ${meta.sha256}, current ${currentHash}. ` + `Run \`npx @cortexkit/aft doctor --clear\` to re-download from scratch.`);
         } else {
@@ -3721,9 +4151,9 @@ function findCachedOnnxRuntime(ortVersionDir, libName) {
 }
 async function resolveOnnxRuntimeUncoalesced(storageDir, seams) {
   const info = seams.platformInfo !== undefined ? seams.platformInfo : getPlatformInfo();
-  const ortVersionDir = join10(storageDir, "onnxruntime", ORT_VERSION);
+  const ortVersionDir = join12(storageDir, "onnxruntime", ORT_VERSION);
   const libName = info?.libName ?? "libonnxruntime.dylib";
-  const cached = findCachedOnnxRuntime(ortVersionDir, libName);
+  const cached = await findCachedOnnxRuntime(ortVersionDir, libName);
   if (cached)
     return cached;
   const systemPath = findSystemOnnxRuntime(info?.libName, seams.systemSearchPaths);
@@ -3735,9 +4165,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 = join10(storageDir, "onnxruntime");
-  mkdirSync3(onnxBaseDir, { recursive: true });
-  const lockPath = join10(onnxBaseDir, ONNX_LOCK_FILE);
+  const onnxBaseDir = join12(storageDir, "onnxruntime");
+  openPrivateStorageDir(storageDir, onnxBaseDir);
+  const lockPath = join12(onnxBaseDir, ONNX_LOCK_FILE);
   const pollMs = seams.lockPollMs ?? LOCK_POLL_MS;
   const deadline = Date.now() + LOCK_WAIT_MS;
   let announcedWait = false;
@@ -3752,14 +4182,14 @@ async function resolveOnnxRuntimeUncoalesced(storageDir, seams) {
       return null;
     }
     await new Promise((done) => setTimeout(done, pollMs));
-    const published = findCachedOnnxRuntime(ortVersionDir, libName);
+    const published = await findCachedOnnxRuntime(ortVersionDir, libName);
     if (published) {
       lastInstallFailure = null;
       return published;
     }
   }
   try {
-    const published = findCachedOnnxRuntime(ortVersionDir, libName);
+    const published = await findCachedOnnxRuntime(ortVersionDir, libName);
     if (published) {
       lastInstallFailure = null;
       return published;
@@ -3782,7 +4212,7 @@ function cleanupAbandonedStagingDirs(onnxBaseDir) {
     for (const entry of entries) {
       if (!entry.startsWith(`${ORT_VERSION}.tmp.`))
         continue;
-      const stagingDir = join10(onnxBaseDir, entry);
+      const stagingDir = join12(onnxBaseDir, entry);
       const parts = entry.split(".");
       const pidStr = parts[parts.length - 2];
       const pid = pidStr ? Number.parseInt(pidStr, 10) : NaN;
@@ -3819,7 +4249,7 @@ function cleanupAbandonedStagingDirs(onnxBaseDir) {
 }
 function cleanupIncompleteTargetIfUnowned(ortDir) {
   try {
-    if (existsSync6(ortDir) && !existsSync6(join10(ortDir, ONNX_INSTALLED_META_FILE))) {
+    if (existsSync6(ortDir) && !existsSync6(join12(ortDir, ONNX_INSTALLED_META_FILE))) {
       log(`[onnx] removing half-populated install dir ${ortDir} (no meta file)`);
       rmSync2(ortDir, { recursive: true, force: true });
     }
@@ -3844,14 +4274,14 @@ function parseOnnxVersionFromDirectoryPath(value) {
   return null;
 }
 function isPathInsideRoot(root, candidate) {
-  const rel = relative(root, candidate);
-  return rel === "" || !rel.startsWith("../") && !rel.startsWith("..\\") && rel !== ".." && !isAbsolute4(rel) && !win32.isAbsolute(rel);
+  const rel = relative3(root, candidate);
+  return rel === "" || !rel.startsWith("../") && !rel.startsWith("..\\") && rel !== ".." && !isAbsolute6(rel) && !win322.isAbsolute(rel);
 }
 function detectOnnxVersion(libDir, libName) {
   try {
     const entries = readdirSync3(libDir);
     try {
-      const resolved = parseOnnxVersionFromPath(realpathSync2(join10(libDir, libName)));
+      const resolved = parseOnnxVersionFromPath(realpathSync3(join12(libDir, libName)));
       if (resolved && resolved !== INVALID_ORT_VERSION)
         return resolved;
     } catch {}
@@ -3865,10 +4295,10 @@ function detectOnnxVersion(libDir, libName) {
       if (version)
         return version;
     }
-    const base = join10(libDir, libName);
+    const base = join12(libDir, libName);
     if (existsSync6(base)) {
       try {
-        const real = realpathSync2(base);
+        const real = realpathSync3(base);
         const version = parseOnnxVersionFromPath(real) ?? parseOnnxVersionFromDirectoryPath(real);
         if (version)
           return version;
@@ -3905,18 +4335,18 @@ function pathEntriesForPlatform() {
   return pathEnvValue().split(delimiter).map((entry) => entry.trim().replace(/^"|"$/g, "")).filter((entry) => {
     if (!entry || entry === "." || entry.includes("\x00"))
       return false;
-    return isAbsolute4(entry) || win32.isAbsolute(entry);
+    return isAbsolute6(entry) || win322.isAbsolute(entry);
   });
 }
 function isWindowsSystem32Directory(dir) {
   if (process.platform !== "win32")
     return false;
-  const normalizedDir = win32.resolve(dir).replace(/[\\/]+$/, "").toLowerCase();
+  const normalizedDir = win322.resolve(dir).replace(/[\\/]+$/, "").toLowerCase();
   const windowsRoots = [process.env.SystemRoot, process.env.windir, "C:\\Windows"];
   return windowsRoots.some((root) => {
     if (!root)
       return false;
-    return normalizedDir === win32.resolve(root, "System32").replace(/[\\/]+$/, "").toLowerCase();
+    return normalizedDir === win322.resolve(root, "System32").replace(/[\\/]+$/, "").toLowerCase();
   });
 }
 function directoryContainsLibrary(dir, libName) {
@@ -3932,10 +4362,10 @@ function directoryContainsLibrary(dir, libName) {
   }
 }
 function resolveCachedOnnxRuntimeDir(ortVersionDir, libName) {
-  if (existsSync6(join10(ortVersionDir, libName)))
+  if (existsSync6(join12(ortVersionDir, libName)))
     return ortVersionDir;
-  const libSubdir = join10(ortVersionDir, "lib");
-  if (existsSync6(join10(libSubdir, libName)))
+  const libSubdir = join12(ortVersionDir, "lib");
+  if (existsSync6(join12(libSubdir, libName)))
     return libSubdir;
   return ortVersionDir;
 }
@@ -3950,12 +4380,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(join10(programFiles, "onnxruntime", "lib"), join10(programFiles, "Microsoft ONNX Runtime", "lib"), join10(programFiles, "Microsoft Machine Learning", "lib"), join10(programFilesX86, "onnxruntime", "lib"), ...(() => {
+    searchPaths.push(join12(programFiles, "onnxruntime", "lib"), join12(programFiles, "Microsoft ONNX Runtime", "lib"), join12(programFiles, "Microsoft Machine Learning", "lib"), join12(programFilesX86, "onnxruntime", "lib"), ...(() => {
       const nugetPaths = [];
       const userProfile = process.env.USERPROFILE ?? "";
       if (!userProfile)
         return nugetPaths;
-      const nugetPackageDir = join10(userProfile, ".nuget", "packages", "microsoft.ml.onnxruntime");
+      const nugetPackageDir = join12(userProfile, ".nuget", "packages", "microsoft.ml.onnxruntime");
       if (!existsSync6(nugetPackageDir))
         return nugetPaths;
       try {
@@ -3964,7 +4394,7 @@ function findSystemOnnxRuntime(libName, searchPathsOverride) {
             continue;
           if (entry.name === "__globalPackagesFolder" || entry.name.startsWith("."))
             continue;
-          nugetPaths.push(join10(nugetPackageDir, entry.name, "runtimes", "win-x64", "native"), join10(nugetPackageDir, entry.name, "runtimes", "win-arm64", "native"));
+          nugetPaths.push(join12(nugetPackageDir, entry.name, "runtimes", "win-x64", "native"), join12(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)}`);
@@ -3976,7 +4406,7 @@ function findSystemOnnxRuntime(libName, searchPathsOverride) {
   const normalizeCase = process.platform === "win32" || process.platform === "darwin";
   const seen = new Set;
   const uniquePaths = searchPaths.filter((p) => {
-    let key = resolve5(p).replace(/[/\\]+$/, "");
+    let key = resolve7(p).replace(/[/\\]+$/, "");
     if (normalizeCase)
       key = key.toLowerCase();
     if (seen.has(key))
@@ -3986,7 +4416,7 @@ function findSystemOnnxRuntime(libName, searchPathsOverride) {
   });
   const unknownVersionPaths = [];
   for (const dir of uniquePaths) {
-    const libPath = join10(dir, libName);
+    const libPath = join12(dir, libName);
     if (process.platform === "win32") {
       if (!directoryContainsLibrary(dir, libName))
         continue;
@@ -4033,7 +4463,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}`);
     }
-    mkdirSync3(dirname4(destPath), { recursive: true });
+    privateMkdirSync(dirname5(destPath));
     let bytesWritten = 0;
     const guard = new TransformStream({
       transform(chunk, transformController) {
@@ -4047,7 +4477,9 @@ async function downloadFileWithCap(url, destPath) {
     });
     const guarded = res.body.pipeThrough(guard);
     const nodeStream = Readable2.fromWeb(guarded);
-    await pipeline2(nodeStream, createWriteStream2(destPath), { signal: controller.signal });
+    await pipeline2(nodeStream, createWriteStream2(destPath, { mode: PRIVATE_FILE_MODE }), {
+      signal: controller.signal
+    });
   } catch (err) {
     try {
       unlinkSync3(destPath);
@@ -4058,31 +4490,35 @@ async function downloadFileWithCap(url, destPath) {
   }
 }
 function validateExtractedTree(stagingRoot) {
-  const realRoot = realpathSync2(stagingRoot);
+  const realRoot = realpathSync3(stagingRoot);
   let totalBytes = 0;
   const walk = (dir) => {
     const entries = readdirSync3(dir);
     for (const entry of entries) {
-      const fullPath = join10(dir, entry);
-      const lst = lstatSync(fullPath);
+      const fullPath = join12(dir, entry);
+      const lst = lstatSync2(fullPath);
       if (lst.isSymbolicLink()) {
         const linkTarget = readlinkSync(fullPath);
-        const resolvedTarget = resolve5(dirname4(fullPath), linkTarget);
-        const rel = relative(realRoot, resolvedTarget);
-        if (rel.startsWith("..") || isAbsolute4(rel) || win32.isAbsolute(rel)) {
+        const resolvedTarget = resolve7(dirname5(fullPath), linkTarget);
+        const rel = relative3(realRoot, resolvedTarget);
+        if (relativePathEscapesRoot(rel) || win322.isAbsolute(rel)) {
           throw new Error(`extracted symlink ${fullPath} points outside staging root: ${linkTarget}`);
         }
         continue;
       }
-      const rel = relative(realRoot, fullPath);
-      if (rel.startsWith("..") || isAbsolute4(rel) || win32.isAbsolute(rel)) {
+      const rel = relative3(realRoot, fullPath);
+      if (relativePathEscapesRoot(rel) || win322.isAbsolute(rel)) {
         throw new Error(`extracted entry ${fullPath} escapes staging root`);
       }
       if (lst.isDirectory()) {
+        if (process.platform !== "win32")
+          chmodSync2(fullPath, PRIVATE_DIRECTORY_MODE);
         walk(fullPath);
         continue;
       }
       if (lst.isFile()) {
+        if (process.platform !== "win32")
+          chmodSync2(fullPath, PRIVATE_FILE_MODE);
         totalBytes += lst.size;
         if (totalBytes > MAX_EXTRACT_BYTES) {
           throw new Error(`extracted size ${totalBytes} exceeds max ${MAX_EXTRACT_BYTES} (decompression bomb defense)`);
@@ -4096,16 +4532,16 @@ 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)}${randomBytes(4).toString("hex")}`;
-  const extractionRoot = join10(tmpDir, "extract");
-  const stagedInstallDir = join10(tmpDir, "install");
+  const extractionRoot = join12(tmpDir, "extract");
+  const stagedInstallDir = join12(tmpDir, "install");
   try {
-    mkdirSync3(extractionRoot, { recursive: true });
-    const archivePath = join10(tmpDir, `onnxruntime.${info.archiveType}`);
+    privateMkdirSync(extractionRoot);
+    const archivePath = join12(tmpDir, `onnxruntime.${info.archiveType}`);
     await downloadFileWithCap(url, archivePath);
-    const archiveSha256 = sha256File2(archivePath);
+    const archiveSha256 = await sha256File(archivePath);
     log(`ONNX Runtime archive sha256=${archiveSha256}`);
     if (info.archiveType === "tgz") {
-      execTarExtractionSync(["xzf", archivePath, "-C", extractionRoot], 120000);
+      execTarExtractionSync(["xzf", archivePath, "-C", extractionRoot], 120000, true);
     } else {
       await extractZipArchive(archivePath, extractionRoot);
     }
@@ -4113,7 +4549,7 @@ async function downloadOnnxRuntime(info, targetDir) {
       unlinkSync3(archivePath);
     } catch {}
     validateExtractedTree(extractionRoot);
-    const extractedDir = join10(extractionRoot, info.assetName, "lib");
+    const extractedDir = join12(extractionRoot, info.assetName, "lib");
     if (!existsSync6(extractedDir)) {
       throw new Error(`Expected directory not found: ${extractedDir}`);
     }
@@ -4121,9 +4557,9 @@ async function downloadOnnxRuntime(info, targetDir) {
     const realFiles = [];
     const symlinks = [];
     for (const libFile of libFiles) {
-      const src = join10(extractedDir, libFile);
+      const src = join12(extractedDir, libFile);
       try {
-        const stat = lstatSync(src);
+        const stat = lstatSync2(src);
         log(`ORT extract: ${libFile} — isSymlink=${stat.isSymbolicLink()}, isFile=${stat.isFile()}, size=${stat.size}`);
         if (stat.isSymbolicLink()) {
           symlinks.push({ name: libFile, target: readlinkSync(src) });
@@ -4136,13 +4572,14 @@ async function downloadOnnxRuntime(info, targetDir) {
       }
     }
     copyOnnxLibraries(info, extractedDir, stagedInstallDir, realFiles, symlinks);
-    const libPath = join10(stagedInstallDir, info.libName);
-    const libHash = sha256File2(libPath);
+    const libPath = join12(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(join12(targetDir, info.libName), libHash);
     rmSync2(tmpDir, { recursive: true, force: true });
     log(`ONNX Runtime v${ORT_VERSION} installed to ${targetDir}`);
     return targetDir;
@@ -4180,16 +4617,19 @@ function publishOnnxRuntime(stagedInstallDir, targetDir) {
     }
   }
 }
-function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, copyFile = copyFileSync2) {
+function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, copyFile = copyFileSync3) {
   const requiredLibs = new Set([info.libName]);
-  mkdirSync3(targetDir, { recursive: true });
+  privateMkdirSync(targetDir);
   for (const libFile of realFiles) {
-    const src = join10(extractedDir, libFile);
-    const dst = join10(targetDir, libFile);
+    const src = join12(extractedDir, libFile);
+    const dst = join12(targetDir, libFile);
     try {
-      copyFile(src, dst);
+      if (copyFile === copyFileSync3)
+        privateCopyFileSync(src, dst);
+      else
+        copyFile(src, dst);
       if (process.platform !== "win32") {
-        chmodSync2(dst, 493);
+        chmodSync2(dst, PRIVATE_FILE_MODE);
       }
     } catch (copyErr) {
       if (requiredLibs.has(libFile)) {
@@ -4199,14 +4639,14 @@ function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, c
       log(`ORT extract: failed to copy optional ${libFile}: ${copyErr}`);
     }
   }
-  const targetRoot = realpathSync2(targetDir);
+  const targetRoot = realpathSync3(targetDir);
   for (const link of symlinks) {
-    const dst = join10(targetDir, link.name);
+    const dst = join12(targetDir, link.name);
     try {
       unlinkSync3(dst);
     } catch {}
-    const dstForContainment = join10(targetRoot, link.name);
-    const resolvedTarget = resolve5(dirname4(dstForContainment), link.target);
+    const dstForContainment = join12(targetRoot, link.name);
+    const resolvedTarget = resolve7(dirname5(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)) {
@@ -4226,7 +4666,7 @@ function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, c
       log(`ORT extract: failed to symlink optional ${link.name}: ${symlinkErr}`);
     }
   }
-  const requiredPath = join10(targetDir, info.libName);
+  const requiredPath = join12(targetDir, info.libName);
   if (!existsSync6(requiredPath)) {
     rmSync2(targetDir, { recursive: true, force: true });
     throw new Error(`Required ONNX Runtime library missing after install: ${requiredPath}`);
@@ -4250,13 +4690,16 @@ function writeOnnxInstalledMeta(installDir, version, sha256, archiveSha256) {
       ...sha256 ? { sha256 } : {},
       archiveSha256
     };
-    writeFileSync3(join10(installDir, ONNX_INSTALLED_META_FILE), JSON.stringify(meta), "utf8");
+    writeFileSync3(join12(installDir, ONNX_INSTALLED_META_FILE), JSON.stringify(meta), {
+      encoding: "utf8",
+      mode: PRIVATE_FILE_MODE
+    });
   } catch (err) {
     log(`[onnx] failed to write installed-meta in ${installDir}: ${err}`);
   }
 }
 function readOnnxInstalledMeta(installDir) {
-  const path = join10(installDir, ONNX_INSTALLED_META_FILE);
+  const path = join12(installDir, ONNX_INSTALLED_META_FILE);
   try {
     if (!statSync5(path).isFile())
       return null;
@@ -4274,21 +4717,16 @@ function readOnnxInstalledMeta(installDir) {
     return null;
   }
 }
-function sha256File2(path) {
-  const hash = createHash4("sha256");
-  hash.update(readFileSync6(path));
-  return hash.digest("hex");
-}
 function acquireLock(lockPath) {
   const tryClaim = () => {
     try {
-      const fd = openSync4(lockPath, "wx");
+      const fd = openSync6(lockPath, "wx", PRIVATE_FILE_MODE);
       try {
         writeFileSync3(fd, `${process.pid}
 ${new Date().toISOString()}
 `);
       } finally {
-        closeSync4(fd);
+        closeSync6(fd);
       }
       return true;
     } catch (err) {
@@ -4395,9 +4833,12 @@ function isProcessAlive2(pid) {
 var ORT_VERSION = "1.24.4", ORT_REPO = "microsoft/onnxruntime", MAX_DOWNLOAD_BYTES2, MAX_EXTRACT_BYTES, ONNX_LOCK_FILE = ".aft-onnx-installing", ONNX_INSTALLED_META_FILE = ".aft-onnx-installed", STALE_LOCK_MS, LOCK_WAIT_MS, LOCK_POLL_MS = 1000, ORT_PLATFORM_MAP, lastInstallFailure = null, inflightResolutions, REQUIRED_ORT_MAJOR = 1, REQUIRED_ORT_MIN_MINOR = 20, INVALID_ORT_VERSION = "<invalid>";
 var init_onnx_runtime = __esm(() => {
   init_active_logger();
+  init_binary_identity();
   init_child_process();
   init_onnx_probe();
+  init_path_display();
   init_platform();
+  init_private_storage();
   init_tar_executable();
   MAX_DOWNLOAD_BYTES2 = 256 * 1024 * 1024;
   MAX_EXTRACT_BYTES = 1 * 1024 * 1024 * 1024;
@@ -4468,8 +4909,8 @@ var init_path_aliases = __esm(() => {
 });
 
 // ../aft-bridge/dist/path-lookup.js
-import { accessSync, constants, statSync as statSync6 } from "node:fs";
-import { delimiter, resolve as resolve6 } from "node:path";
+import { accessSync, constants as constants2, statSync as statSync6 } from "node:fs";
+import { delimiter, resolve as resolve8 } from "node:path";
 function executableNames(name, platform) {
   if (platform !== "win32")
     return [name];
@@ -4485,12 +4926,12 @@ function findExecutablesOnPath(name, options = {}) {
     if (!directory)
       continue;
     for (const candidateName of executableNames(name, platform)) {
-      const candidate = resolve6(directory, candidateName);
+      const candidate = resolve8(directory, candidateName);
       if (seen.has(candidate))
         continue;
       seen.add(candidate);
       try {
-        accessSync(candidate, platform === "win32" ? constants.F_OK : constants.X_OK);
+        accessSync(candidate, platform === "win32" ? constants2.F_OK : constants2.X_OK);
         if (statSync6(candidate).isFile())
           hits.push(candidate);
       } catch {}
@@ -4528,6 +4969,7 @@ var init_dist2 = __esm(() => {
   init_downloader();
   init_durable_log();
   init_error_contract();
+  init_lifecycle_registry();
   init_location_lifecycle();
   init_message_detach();
   init_migration();
@@ -4536,6 +4978,7 @@ var init_dist2 = __esm(() => {
   init_onnx_probe();
   init_onnx_runtime();
   init_path_aliases();
+  init_path_display();
   init_path_lookup();
   init_paths();
   init_platform();
@@ -4566,8 +5009,8 @@ var init_paths2 = __esm(() => {
 // src/lib/binary-probe.ts
 import { existsSync as existsSync7, readdirSync as readdirSync4 } from "node:fs";
 import { createRequire } from "node:module";
-import { homedir as homedir8 } from "node:os";
-import { join as join11 } from "node:path";
+import { homedir as homedir10 } from "node:os";
+import { join as join13 } from "node:path";
 async function loadPluginVersion() {
   try {
     const bridge = await Promise.resolve().then(() => (init_dist2(), {}));
@@ -4697,7 +5140,7 @@ function newestCachedBinary(cacheDir, binaryName) {
     const version = entry.match(CACHE_VERSION_DIR)?.[1];
     if (!version)
       continue;
-    const path = join11(cacheDir, entry, binaryName);
+    const path = join13(cacheDir, entry, binaryName);
     try {
       if (!existsSync7(path))
         continue;
@@ -4718,7 +5161,7 @@ function cacheLocation(preferredVersion) {
     const tag = preferredVersion.startsWith("v") ? preferredVersion : `v${preferredVersion}`;
     return {
       label,
-      paths: [join11(cacheDir, tag, binaryName)],
+      paths: [join13(cacheDir, tag, binaryName)],
       emptyReason: `no ${tag}/${binaryName} under ${cacheDir} (${installedHere})`
     };
   }
@@ -4762,7 +5205,7 @@ function pathLocation() {
   };
 }
 function cargoLocation() {
-  const path = join11(homedir8(), ".cargo", "bin", getAftBinaryName());
+  const path = join13(homedir10(), ".cargo", "bin", getAftBinaryName());
   return { label: "cargo install", paths: [path], emptyReason: `no ${path}` };
 }
 function aftBinarySearchLocations(preferredVersion) {
@@ -4815,7 +5258,7 @@ var init_binary_probe = __esm(async () => {
 
 // src/lib/fs-util.ts
 import { existsSync as existsSync8, readdirSync as readdirSync5, statSync as statSync7 } from "node:fs";
-import { join as join12 } from "node:path";
+import { join as join14 } from "node:path";
 function dirSize(path) {
   if (!existsSync8(path)) {
     return 0;
@@ -4829,7 +5272,7 @@ function dirSize(path) {
   }
   let total = 0;
   for (const entry of readdirSync5(path)) {
-    total += dirSize(join12(path, entry));
+    total += dirSize(join14(path, entry));
   }
   return total;
 }
@@ -4847,27 +5290,27 @@ var init_fs_util = () => {};
 
 // src/lib/omp-paths.ts
 import { existsSync as existsSync9 } from "node:fs";
-import { homedir as homedir9 } from "node:os";
-import { join as join13, resolve as resolve7 } from "node:path";
+import { homedir as homedir11 } from "node:os";
+import { join as join15, resolve as resolve9 } from "node:path";
 function envFirstHomeDir() {
-  return process.env.HOME?.trim() || homedir9();
+  return process.env.HOME?.trim() || homedir11();
 }
 function resolveOmpPaths() {
   const normalizedProfile = (process.env.OMP_PROFILE ?? process.env.PI_PROFILE)?.trim();
   const profile = normalizedProfile && normalizedProfile !== "default" && /^[a-z0-9][a-z0-9._-]{0,63}$/.test(normalizedProfile) ? normalizedProfile : undefined;
   const configDirName = process.env.PI_CONFIG_DIR?.trim() || ".omp";
-  const baseConfigRoot = join13(envFirstHomeDir(), configDirName);
-  const configRoot = profile ? join13(baseConfigRoot, "profiles", profile) : baseConfigRoot;
-  const defaultAgentDir = join13(configRoot, "agent");
+  const baseConfigRoot = join15(envFirstHomeDir(), configDirName);
+  const configRoot = profile ? join15(baseConfigRoot, "profiles", profile) : baseConfigRoot;
+  const defaultAgentDir = join15(configRoot, "agent");
   const configuredAgentDir = profile ? undefined : process.env.PI_CODING_AGENT_DIR?.trim();
-  const agentDir = configuredAgentDir ? resolve7(configuredAgentDir) : defaultAgentDir;
+  const agentDir = configuredAgentDir ? resolve9(configuredAgentDir) : defaultAgentDir;
   const canUseXdg = (process.platform === "linux" || process.platform === "darwin") && agentDir === defaultAgentDir;
   let dataRoot = configRoot;
   if (canUseXdg) {
     const xdgDataHome = process.env.XDG_DATA_HOME?.trim();
     if (xdgDataHome) {
-      const appRoot = join13(xdgDataHome, "omp");
-      const candidate = profile ? join13(appRoot, "profiles", profile) : appRoot;
+      const appRoot = join15(xdgDataHome, "omp");
+      const candidate = profile ? join15(appRoot, "profiles", profile) : appRoot;
       if (existsSync9(candidate))
         dataRoot = candidate;
     }
@@ -4878,8 +5321,8 @@ function resolveOmpPaths() {
     agentDir,
     dataRoot,
     dataAgentRoot,
-    pluginsDir: join13(dataRoot, "plugins"),
-    sessionsRoot: join13(dataAgentRoot, "sessions")
+    pluginsDir: join15(dataRoot, "plugins"),
+    sessionsRoot: join15(dataAgentRoot, "sessions")
   };
 }
 function getOmpAgentDir() {
@@ -4889,7 +5332,7 @@ function getOmpPluginsDir() {
   return resolveOmpPaths().pluginsDir;
 }
 function getOmpPluginsLockPath() {
-  return join13(getOmpPluginsDir(), "omp-plugins.lock.json");
+  return join15(getOmpPluginsDir(), "omp-plugins.lock.json");
 }
 function getOmpSessionsRoot() {
   return resolveOmpPaths().sessionsRoot;
@@ -4901,21 +5344,21 @@ function getOmpPackageDir() {
   if (value === "~")
     return envFirstHomeDir();
   if (value.startsWith("~/") || value.startsWith("~\\")) {
-    return resolve7(envFirstHomeDir(), value.slice(2));
+    return resolve9(envFirstHomeDir(), value.slice(2));
   }
-  return resolve7(value);
+  return resolve9(value);
 }
 var init_omp_paths = () => {};
 
 // src/lib/omp-helpers.ts
-import { accessSync as accessSync2, constants as constants2, existsSync as existsSync10, readFileSync as readFileSync7, statSync as statSync8 } from "node:fs";
-import { homedir as homedir10 } from "node:os";
-import { delimiter as delimiter2, extname, join as join14, resolve as resolve8 } from "node:path";
+import { accessSync as accessSync2, constants as constants3, existsSync as existsSync10, readFileSync as readFileSync7, statSync as statSync8 } from "node:fs";
+import { homedir as homedir12 } from "node:os";
+import { delimiter as delimiter2, extname, join as join16, resolve as resolve10 } from "node:path";
 function isExecutableFile(path, platform = process.platform) {
   try {
     if (!existsSync10(path) || !statSync8(path).isFile())
       return false;
-    accessSync2(path, platform === "win32" ? constants2.F_OK : constants2.X_OK);
+    accessSync2(path, platform === "win32" ? constants3.F_OK : constants3.X_OK);
     return true;
   } catch {
     return false;
@@ -4930,7 +5373,7 @@ function findOnPath(name, pathValue = process.env.PATH ?? "", platform = process
     if (!directory)
       continue;
     for (const candidateName of executableNames2(name, platform)) {
-      const candidate = resolve8(directory, candidateName);
+      const candidate = resolve10(directory, candidateName);
       if (isExecutableFile(candidate, platform))
         return candidate;
     }
@@ -4942,10 +5385,10 @@ function detectOmpPackageCli() {
   if (!packageDir || !findOnPath("bun"))
     return null;
   try {
-    const manifest = JSON.parse(readFileSync7(join14(packageDir, "package.json"), "utf8"));
+    const manifest = JSON.parse(readFileSync7(join16(packageDir, "package.json"), "utf8"));
     if (manifest.name !== OMP_HOST_PACKAGE)
       return null;
-    const cli = join14(packageDir, "dist", "cli.js");
+    const cli = join16(packageDir, "dist", "cli.js");
     return existsSync10(cli) ? cli : null;
   } catch {
     return null;
@@ -4966,13 +5409,13 @@ function getOmpCommandInvocation(ompPath, args) {
 }
 function getOmpFallbackCandidates(platform, home, appData) {
   if (platform !== "win32") {
-    return [join14(home, ".bun", "bin", "omp"), join14(home, ".local", "bin", "omp")];
+    return [join16(home, ".bun", "bin", "omp"), join16(home, ".local", "bin", "omp")];
   }
   const npmRoot = appData?.trim();
   return [
-    ...npmRoot ? [join14(npmRoot, "npm", "omp.cmd"), join14(npmRoot, "npm", "omp.exe")] : [],
-    join14(home, ".bun", "bin", "omp.exe"),
-    join14(home, ".bun", "bin", "omp.cmd")
+    ...npmRoot ? [join16(npmRoot, "npm", "omp.cmd"), join16(npmRoot, "npm", "omp.exe")] : [],
+    join16(home, ".bun", "bin", "omp.exe"),
+    join16(home, ".bun", "bin", "omp.cmd")
   ];
 }
 function detectOmpBinary() {
@@ -4982,7 +5425,7 @@ function detectOmpBinary() {
   const fromPackage = detectOmpPackageCli();
   if (fromPackage)
     return { path: fromPackage, source: "package" };
-  const home = process.env.HOME?.trim() || homedir10();
+  const home = process.env.HOME?.trim() || homedir12();
   const candidate = getOmpFallbackCandidates(process.platform, home, process.env.APPDATA).find((path) => isExecutableFile(path));
   return candidate ? { path: candidate, source: "home" } : null;
 }
@@ -5055,7 +5498,7 @@ var init_omp_helpers = __esm(() => {
 
 // src/adapters/omp.ts
 import { existsSync as existsSync11, readFileSync as readFileSync8 } from "node:fs";
-import { join as join15 } from "node:path";
+import { join as join17 } from "node:path";
 
 class OmpAdapter {
   kind = "omp";
@@ -5197,12 +5640,12 @@ class OmpAdapter {
   describeStorageSubtrees() {
     const storage = this.getStorageDir();
     return {
-      index: dirSize(join15(storage, "index")),
-      semantic: dirSize(join15(storage, "semantic")),
-      backups: dirSize(join15(storage, "backups")),
-      url_cache: dirSize(join15(storage, "url_cache")),
-      onnxruntime: dirSize(join15(storage, "onnxruntime")),
-      logs: dirSize(join15(storage, "logs"))
+      index: dirSize(join17(storage, "index")),
+      semantic: dirSize(join17(storage, "semantic")),
+      backups: dirSize(join17(storage, "backups")),
+      url_cache: dirSize(join17(storage, "url_cache")),
+      onnxruntime: dirSize(join17(storage, "onnxruntime")),
+      logs: dirSize(join17(storage, "logs"))
     };
   }
   readRuntimeEnabled(configPath) {
@@ -5240,8 +5683,8 @@ var init_omp = __esm(() => {
 
 // src/lib/fs-errors.ts
 import { existsSync as existsSync12, statSync as statSync9 } from "node:fs";
-import { homedir as homedir11 } from "node:os";
-import { dirname as dirname5, resolve as resolve9, sep } from "node:path";
+import { homedir as homedir13 } from "node:os";
+import { dirname as dirname6, resolve as resolve11, sep as sep2 } from "node:path";
 function errorCode(error) {
   if (typeof error === "object" && error !== null && "code" in error) {
     const code = error.code;
@@ -5271,10 +5714,8 @@ function errorPath(error) {
   const native = message.match(/\b(?:write|update|create|open|read|mkdir|rename)\s+((?:[A-Za-z]:)?[\\/][^:\n]+?):\s/i);
   return native?.[1] ?? null;
 }
-function tildePath(path, home = homedir11()) {
-  if (path === home)
-    return "~";
-  return path.startsWith(home + sep) ? `~${path.slice(home.length)}` : path;
+function tildePath(path, home = homedir13()) {
+  return shortenHomePath(path, home);
 }
 function shellPath(path) {
   if (/^[\w@%+=:,./~-]+$/.test(path))
@@ -5284,10 +5725,10 @@ function shellPath(path) {
   return `'${path.replace(/'/g, "'\\''")}'`;
 }
 function describePermissionProblem(target, facts = defaultFacts) {
-  const home = resolve9(facts.home());
-  let existing = resolve9(target);
-  while (!facts.exists(existing) && dirname5(existing) !== existing)
-    existing = dirname5(existing);
+  const home = resolve11(facts.home());
+  let existing = resolve11(target);
+  while (!facts.exists(existing) && dirname6(existing) !== existing)
+    existing = dirname6(existing);
   const ownerUid = facts.ownerUid(existing);
   const me = facts.currentUid();
   const shownTarget = tildePath(target, home);
@@ -5301,8 +5742,8 @@ function describePermissionProblem(target, facts = defaultFacts) {
   }
   let widest = existing;
   while (true) {
-    const parent = dirname5(widest);
-    if (parent === widest || parent === home || !parent.startsWith(home + sep))
+    const parent = dirname6(widest);
+    if (parent === widest || parent === home || !parent.startsWith(home + sep2))
       break;
     if (facts.ownerUid(parent) !== ownerUid)
       break;
@@ -5352,7 +5793,7 @@ var init_fs_errors = __esm(() => {
         return false;
       }
     },
-    home: () => homedir11()
+    home: () => homedir13()
   };
 });
 
@@ -13115,7 +13556,7 @@ var require_src2 = __commonJS(function(exports, module) {
 
 // src/lib/jsonc.ts
 import { existsSync as existsSync13, mkdirSync as mkdirSync4, readFileSync as readFileSync9, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname6 } from "node:path";
+import { dirname as dirname7 } from "node:path";
 function detectJsoncFile(configDir, baseName) {
   const jsoncPath = `${configDir}/${baseName}.jsonc`;
   const jsonPath = `${configDir}/${baseName}.json`;
@@ -13143,7 +13584,7 @@ function readJsoncFile(path) {
   }
 }
 function writeJsoncFile(path, value, format = "json") {
-  mkdirSync4(dirname6(path), { recursive: true });
+  mkdirSync4(dirname7(path), { recursive: true });
   const serialized = format === "jsonc" ? import_comment_json.stringify(value, null, 2) : JSON.stringify(value, null, 2);
   writeFileSync4(path, `${serialized}
 `);
@@ -13359,15 +13800,16 @@ function pluginConfigNeedsUpdate(value, version, hasLocalAftEntry = () => false,
     return !pluginEntryFitsKey(list[local.index], key);
   return true;
 }
-function hostShellPluginDisabled(value) {
+function hostToolPluginDisabled(value, hostTool) {
   const list = value?.plugins;
-  return Array.isArray(list) && list.includes(OPENCODE_HOST_SHELL_DISABLE_ENTRY);
+  return Array.isArray(list) && list.includes(OPENCODE_HOST_TOOLS[hostTool].disableEntry);
 }
-function setHostShellPluginDisabled(value, disabled) {
+function setHostToolPluginDisabled(value, hostTool, disabled) {
+  const entry = OPENCODE_HOST_TOOLS[hostTool].disableEntry;
   const existing = Array.isArray(value.plugins) ? value.plugins : null;
   const indexes = [];
   existing?.forEach((entry, index) => {
-    if (entry === OPENCODE_HOST_SHELL_DISABLE_ENTRY)
+    if (entry === OPENCODE_HOST_TOOLS[hostTool].disableEntry)
       indexes.push(index);
   });
   if (disabled ? indexes.length === 1 : indexes.length === 0)
@@ -13380,17 +13822,19 @@ function setHostShellPluginDisabled(value, disabled) {
     list.splice(remove[index], 1);
   }
   if (disabled && indexes.length === 0)
-    list.push(OPENCODE_HOST_SHELL_DISABLE_ENTRY);
+    list.push(entry);
   return { changed: true };
 }
-function aftBashEnabled(userConfig) {
+function aftHostReplacementEnabled(userConfig, hostTool) {
   if (!userConfig)
     return true;
   if (userConfig.enabled === false)
     return false;
   const disabled = userConfig.disabled_tools;
-  if (Array.isArray(disabled) && disabled.includes("bash"))
+  if (Array.isArray(disabled) && disabled.includes(OPENCODE_HOST_TOOLS[hostTool].aftTool))
     return false;
+  if (hostTool !== "shell")
+    return true;
   const bash = userConfig.bash;
   if (bash === false)
     return false;
@@ -13399,30 +13843,35 @@ function aftBashEnabled(userConfig) {
   }
   return true;
 }
-var AFT_OPENCODE_PACKAGE = "@cortexkit/aft-opencode", MODERN_V1_VERSION, EXACT_VERSION, OPENCODE_HOST_SHELL_DISABLE_ENTRY = "-opencode.tool.shell";
+var AFT_OPENCODE_PACKAGE = "@cortexkit/aft-opencode", MODERN_V1_VERSION, EXACT_VERSION, OPENCODE_HOST_SHELL_DISABLE_ENTRY = "-opencode.tool.shell", OPENCODE_HOST_PATCH_DISABLE_ENTRY = "-opencode.tool.patch", OPENCODE_HOST_TOOLS, OPENCODE_HOST_TOOL_NAMES;
 var init_opencode_config = __esm(() => {
   init_opencode_version();
   MODERN_V1_VERSION = opencode_version_default.trim();
   EXACT_VERSION = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+  OPENCODE_HOST_TOOLS = {
+    shell: { aftTool: "bash", disableEntry: OPENCODE_HOST_SHELL_DISABLE_ENTRY },
+    patch: { aftTool: "apply_patch", disableEntry: OPENCODE_HOST_PATCH_DISABLE_ENTRY }
+  };
+  OPENCODE_HOST_TOOL_NAMES = Object.keys(OPENCODE_HOST_TOOLS);
 });
 
 // src/setup/host-generation.ts
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 import {
-  closeSync as closeSync5,
+  closeSync as closeSync7,
   existsSync as existsSync14,
   mkdirSync as mkdirSync5,
   mkdtempSync,
-  openSync as openSync5,
+  openSync as openSync7,
   readdirSync as readdirSync6,
   readFileSync as readFileSync10,
-  readSync as readSync3,
-  realpathSync as realpathSync3,
+  readSync as readSync5,
+  realpathSync as realpathSync4,
   rmSync as rmSync3,
   statSync as statSync10
 } from "node:fs";
-import { homedir as homedir12, tmpdir as tmpdir2 } from "node:os";
-import { dirname as dirname7, join as join16, parse } from "node:path";
+import { homedir as homedir14, tmpdir as tmpdir3 } from "node:os";
+import { dirname as dirname8, join as join18, parse as parse2 } from "node:path";
 function findExecutableOnPath2(name, pathValue = process.env.PATH ?? "", platform = process.platform) {
   return findExecutableOnPath(name, { pathValue, platform });
 }
@@ -13437,31 +13886,63 @@ function packageMetadataAt(path, expectedName) {
 function packageMetadataNearExecutable(executable, expectedName) {
   let current;
   try {
-    current = dirname7(realpathSync3(executable));
+    current = dirname8(realpathSync4(executable));
   } catch {
-    current = dirname7(executable);
+    current = dirname8(executable);
   }
   while (true) {
-    const direct = packageMetadataAt(join16(current, "package.json"), expectedName);
+    const direct = packageMetadataAt(join18(current, "package.json"), expectedName);
     if (direct)
       return direct;
-    const parent = dirname7(current);
-    if (parent === current || current === parse(current).root)
+    const parent = dirname8(current);
+    if (parent === current || current === parse2(current).root)
       return null;
     current = parent;
   }
 }
+function npmLauncherTarget(launcher) {
+  let source;
+  try {
+    if (statSync10(launcher).size > LAUNCHER_MAX_BYTES)
+      return null;
+    source = readFileSync10(launcher, "utf8");
+  } catch {
+    return null;
+  }
+  const operands = [...source.matchAll(CMD_LAUNCHER_PATH)];
+  if (operands.length === 0)
+    operands.push(...source.matchAll(SH_LAUNCHER_PATH));
+  const relativeTarget = operands.at(-1)?.[1];
+  if (!relativeTarget)
+    return null;
+  const target = join18(dirname8(launcher), ...relativeTarget.split(/[\\/]+/).filter(Boolean));
+  try {
+    return statSync10(target).isFile() ? target : null;
+  } catch {
+    return null;
+  }
+}
+function hostLaunchPath(executable, platform) {
+  const isBatch = BATCH_FILE.test(executable);
+  const isScript = isBatch || platform === "win32" && !/\.(?:exe|com)$/i.test(executable);
+  if (!isScript)
+    return executable;
+  const target = npmLauncherTarget(executable);
+  if (target)
+    return target;
+  return isBatch ? null : executable;
+}
 function packageVersion(metadata) {
   return typeof metadata?.version === "string" && metadata.version.length > 0 ? metadata.version : null;
 }
 function hashFileBytes(hash, path, size) {
   const buffer = Buffer.allocUnsafe(Math.min(Math.max(size, 1), PARTIAL_CONTENT_WINDOW_BYTES));
-  const descriptor = openSync5(path, "r");
+  const descriptor = openSync7(path, "r");
   try {
     if (size <= FULL_CONTENT_HASH_MAX_BYTES) {
       let position = 0;
       while (position < size) {
-        const read = readSync3(descriptor, buffer, 0, buffer.length, position);
+        const read = readSync5(descriptor, buffer, 0, buffer.length, position);
         if (read <= 0)
           break;
         hash.update(buffer.subarray(0, read));
@@ -13470,19 +13951,19 @@ function hashFileBytes(hash, path, size) {
       return;
     }
     hash.update("partial\x00");
-    const head = readSync3(descriptor, buffer, 0, buffer.length, 0);
+    const head = readSync5(descriptor, buffer, 0, buffer.length, 0);
     hash.update(buffer.subarray(0, Math.max(head, 0)));
     const tailStart = Math.max(size - PARTIAL_CONTENT_WINDOW_BYTES, 0);
-    const tail = readSync3(descriptor, buffer, 0, buffer.length, tailStart);
+    const tail = readSync5(descriptor, buffer, 0, buffer.length, tailStart);
     hash.update(buffer.subarray(0, Math.max(tail, 0)));
   } finally {
-    closeSync5(descriptor);
+    closeSync7(descriptor);
   }
 }
 function snapshotTree(path) {
   if (!existsSync14(path))
     return "missing";
-  const hash = createHash5("sha256");
+  const hash = createHash4("sha256");
   const visit = (current, relativePath) => {
     let info;
     try {
@@ -13494,7 +13975,7 @@ function snapshotTree(path) {
     hash.update(`${relativePath}\x00${info.mode}\x00${info.size}\x00${info.mtimeMs}\x00`);
     if (info.isDirectory()) {
       for (const entry of readdirSync6(current).sort()) {
-        visit(join16(current, entry), join16(relativePath, entry));
+        visit(join18(current, entry), join18(relativePath, entry));
       }
       return;
     }
@@ -13510,31 +13991,34 @@ function snapshotTree(path) {
   return hash.digest("hex");
 }
 function snapshotOperatorState(operatorHome) {
-  const database = join16(operatorHome, ".local", "share", "opencode", "opencode.db");
+  const database = join18(operatorHome, ".local", "share", "opencode", "opencode.db");
   return JSON.stringify({
     database: snapshotTree(database),
     databaseWal: snapshotTree(`${database}-wal`),
     databaseShm: snapshotTree(`${database}-shm`),
-    logs: snapshotTree(join16(operatorHome, ".local", "share", "opencode", "log"))
+    logs: snapshotTree(join18(operatorHome, ".local", "share", "opencode", "log"))
   });
 }
 function probeCreatedIsolatedState(dataRoot, stateRoot) {
   return [dataRoot, stateRoot].some((root) => {
-    const opencodeRoot = join16(root, "opencode");
-    const database = join16(opencodeRoot, "opencode.db");
-    return [database, `${database}-wal`, `${database}-shm`, join16(opencodeRoot, "log")].some(existsSync14);
+    const opencodeRoot = join18(root, "opencode");
+    const database = join18(opencodeRoot, "opencode.db");
+    return [database, `${database}-wal`, `${database}-shm`, join18(opencodeRoot, "log")].some(existsSync14);
   });
 }
 function probeOpenCodeV1Version(executable, options = {}) {
-  const operatorHome = options.operatorHome ?? homedir12();
+  const launchPath = hostLaunchPath(executable, options.platform ?? process.platform);
+  if (launchPath === null)
+    return null;
+  const operatorHome = options.operatorHome ?? homedir14();
   const before = snapshotOperatorState(operatorHome);
-  const root = mkdtempSync(join16(options.tempParent ?? tmpdir2(), "aft-opencode-probe-"));
-  const home = join16(root, "home");
-  const config = join16(root, "config");
-  const data = join16(root, "data");
-  const state = join16(root, "state");
-  const cache = join16(root, "cache");
-  const project = join16(root, "project");
+  const root = mkdtempSync(join18(options.tempParent ?? tmpdir3(), "aft-opencode-probe-"));
+  const home = join18(root, "home");
+  const config = join18(root, "config");
+  const data = join18(root, "data");
+  const state = join18(root, "state");
+  const cache = join18(root, "cache");
+  const project = join18(root, "project");
   for (const directory of [home, config, data, state, cache, project]) {
     mkdirSync5(directory, { recursive: true });
   }
@@ -13545,7 +14029,7 @@ function probeOpenCodeV1Version(executable, options = {}) {
     XDG_DATA_HOME: data,
     XDG_STATE_HOME: state,
     XDG_CACHE_HOME: cache,
-    TMPDIR: join16(root, "tmp")
+    TMPDIR: join18(root, "tmp")
   };
   mkdirSync5(env.TMPDIR, { recursive: true });
   delete env.OPENCODE_CONFIG;
@@ -13555,7 +14039,7 @@ function probeOpenCodeV1Version(executable, options = {}) {
   let result;
   let probeError;
   try {
-    result = (options.spawn ?? spawnSync)(executable, ["--standalone", "--version"], {
+    result = (options.spawn ?? spawnSync)(launchPath, ["--standalone", "--version"], {
       cwd: project,
       encoding: "utf8",
       env,
@@ -13605,7 +14089,7 @@ function isV2Version(version) {
 }
 function resolvedPath(executable) {
   try {
-    return realpathSync3(executable);
+    return realpathSync4(executable);
   } catch {
     return executable;
   }
@@ -13614,13 +14098,18 @@ function detectOpenCodeHostGeneration(dependencies = {}) {
   const findExecutable = dependencies.findExecutable ?? ((name) => findExecutableOnPath2(name, dependencies.path, dependencies.platform));
   const openCodeExecutable = findExecutable("opencode");
   const openCode2Executable = findExecutable("opencode2");
+  const platform = dependencies.platform ?? process.platform;
+  const hostOf = (executable) => executable === null ? null : hostLaunchPath(executable, platform) ?? executable;
+  const openCodeHost = hostOf(openCodeExecutable);
+  const openCode2Host = hostOf(openCode2Executable);
   const evidence = [];
-  const sharedExecutable = openCodeExecutable !== null && openCode2Executable !== null && resolvedPath(openCodeExecutable) === resolvedPath(openCode2Executable);
-  if (openCodeExecutable) {
-    const v1Metadata = packageMetadataNearExecutable(openCodeExecutable, "opencode-ai");
-    const v2Metadata = v2MetadataNearExecutable(openCodeExecutable);
+  const sharedExecutable = openCodeHost !== null && openCode2Host !== null && resolvedPath(openCodeHost) === resolvedPath(openCode2Host);
+  if (openCodeExecutable !== null && openCodeHost !== null) {
+    const v1Metadata = packageMetadataNearExecutable(openCodeHost, "opencode-ai");
+    const v2Metadata = v2MetadataNearExecutable(openCodeHost);
     const metadataVersion = packageVersion(v2Metadata) ?? packageVersion(v1Metadata);
-    const version = metadataVersion ?? (dependencies.probeV1Version ?? probeOpenCodeV1Version)(openCodeExecutable);
+    const probeVersion = dependencies.probeV1Version ?? ((executable) => probeOpenCodeV1Version(executable, { platform }));
+    const version = metadataVersion ?? probeVersion(openCodeExecutable);
     const isV2 = Boolean(v2Metadata) || sharedExecutable || isV2Version(version);
     evidence.push({
       generation: isV2 ? "v2" : "v1",
@@ -13630,8 +14119,8 @@ function detectOpenCodeHostGeneration(dependencies = {}) {
       modernV1: !isV2 && version === MODERN_V1_VERSION
     });
   }
-  if (openCode2Executable && !sharedExecutable) {
-    const version = packageVersion(v2MetadataNearExecutable(openCode2Executable));
+  if (openCode2Executable !== null && openCode2Host !== null && !sharedExecutable) {
+    const version = packageVersion(v2MetadataNearExecutable(openCode2Host));
     evidence.push({
       generation: "v2",
       executable: openCode2Executable,
@@ -13667,10 +14156,14 @@ function formatHostGenerations(detection) {
     return "V2";
   return "unknown";
 }
-var FULL_CONTENT_HASH_MAX_BYTES, PARTIAL_CONTENT_WINDOW_BYTES, V2_PACKAGE_NAMES;
+var LAUNCHER_MAX_BYTES, CMD_LAUNCHER_PATH, SH_LAUNCHER_PATH, BATCH_FILE, FULL_CONTENT_HASH_MAX_BYTES, PARTIAL_CONTENT_WINDOW_BYTES, V2_PACKAGE_NAMES;
 var init_host_generation = __esm(() => {
   init_dist2();
   init_opencode_config();
+  LAUNCHER_MAX_BYTES = 64 * 1024;
+  CMD_LAUNCHER_PATH = /"%~?dp0%?\\([^"%\r\n]+)"/g;
+  SH_LAUNCHER_PATH = /"\$basedir\/([^"$\r\n]+)"/g;
+  BATCH_FILE = /\.(?:cmd|bat)$/i;
   FULL_CONTENT_HASH_MAX_BYTES = 64 * 1024 * 1024;
   PARTIAL_CONTENT_WINDOW_BYTES = 1024 * 1024;
   V2_PACKAGE_NAMES = ["@opencode/cli", "@opencode-ai/cli"];
@@ -13678,21 +14171,21 @@ var init_host_generation = __esm(() => {
 
 // src/adapters/opencode.ts
 import { existsSync as existsSync15, readFileSync as readFileSync11, rmSync as rmSync4, statSync as statSync11 } from "node:fs";
-import { homedir as homedir13 } from "node:os";
-import { dirname as dirname8, join as join17, parse as parse2, resolve as resolve10 } from "node:path";
+import { homedir as homedir15 } from "node:os";
+import { dirname as dirname9, join as join19, parse as parse3, resolve as resolve12 } from "node:path";
 import { fileURLToPath } from "node:url";
 function getOpenCodeConfigDir() {
   const envDir = process.env.OPENCODE_CONFIG_DIR?.trim();
   if (envDir)
-    return resolve10(envDir);
+    return resolve12(envDir);
   return getOpenCodeConfigRoot();
 }
 function getLegacyOpenCodePluginCachePath(primaryPath) {
   if (process.platform !== "win32")
     return null;
-  const localAppData = process.env.LOCALAPPDATA ?? join17(homedir13(), "AppData", "Local");
-  const legacyPath = join17(localAppData, "opencode", "packages", LEGACY_PLUGIN_ENTRY);
-  return resolve10(legacyPath) === resolve10(primaryPath) ? null : legacyPath;
+  const localAppData = process.env.LOCALAPPDATA ?? join19(homedir15(), "AppData", "Local");
+  const legacyPath = join19(localAppData, "opencode", "packages", LEGACY_PLUGIN_ENTRY);
+  return resolve12(legacyPath) === resolve12(primaryPath) ? null : legacyPath;
 }
 function clearLegacyOpenCodePluginCache(primaryPath) {
   const legacyPath = getLegacyOpenCodePluginCachePath(primaryPath);
@@ -13714,12 +14207,12 @@ function hasOpenCodeCli() {
 function openCodeDesktopAppExists() {
   const candidates = [];
   if (process.platform === "darwin") {
-    candidates.push("/Applications/OpenCode.app", "/Applications/OpenCode Beta.app", join17(homedir13(), "Applications", "OpenCode.app"), join17(homedir13(), "Applications", "OpenCode Beta.app"));
+    candidates.push("/Applications/OpenCode.app", "/Applications/OpenCode Beta.app", join19(homedir15(), "Applications", "OpenCode.app"), join19(homedir15(), "Applications", "OpenCode Beta.app"));
   } else if (process.platform === "win32") {
-    const localAppData = process.env.LOCALAPPDATA ?? join17(homedir13(), "AppData", "Local");
-    candidates.push(join17(localAppData, "Programs", "opencode"), join17(localAppData, "opencode"));
+    const localAppData = process.env.LOCALAPPDATA ?? join19(homedir15(), "AppData", "Local");
+    candidates.push(join19(localAppData, "Programs", "opencode"), join19(localAppData, "opencode"));
   } else {
-    candidates.push("/opt/OpenCode", "/usr/lib/opencode", join17(homedir13(), ".local", "share", "applications", "opencode.desktop"));
+    candidates.push("/opt/OpenCode", "/usr/lib/opencode", join19(homedir15(), ".local", "share", "applications", "opencode.desktop"));
   }
   return candidates.some((p) => {
     try {
@@ -13748,16 +14241,16 @@ function pathPointsToOurPlugin(entry) {
   try {
     if (!existsSync15(fsPath))
       return false;
-    let searchDir = statSync11(fsPath).isDirectory() ? fsPath : dirname8(fsPath);
+    let searchDir = statSync11(fsPath).isDirectory() ? fsPath : dirname9(fsPath);
     let pkgJsonPath = null;
     while (true) {
-      const candidate = join17(searchDir, "package.json");
+      const candidate = join19(searchDir, "package.json");
       if (existsSync15(candidate)) {
         pkgJsonPath = candidate;
         break;
       }
-      const parent = dirname8(searchDir);
-      if (parent === searchDir || searchDir === parse2(searchDir).root)
+      const parent = dirname9(searchDir);
+      if (parent === searchDir || searchDir === parse3(searchDir).root)
         break;
       searchDir = parent;
     }
@@ -13925,23 +14418,33 @@ class OpenCodeAdapter {
     };
   }
   hostShellState() {
+    return this.hostToolState("shell");
+  }
+  hostToolState(hostTool) {
     if (this.configGeneration() !== "v2")
       return "not_applicable";
     const { value } = readJsoncFile(this.detectConfigPaths().harnessConfig);
-    return hostShellPluginDisabled(value) ? "disabled" : "enabled";
+    return hostToolPluginDisabled(value, hostTool) ? "disabled" : "enabled";
   }
   aftBashEnabled() {
+    return this.aftHostReplacementEnabled("shell");
+  }
+  aftHostReplacementEnabled(hostTool) {
     const { value } = readJsoncFile(this.detectConfigPaths().aftConfig);
-    return aftBashEnabled(value);
+    return aftHostReplacementEnabled(value, hostTool);
   }
   setHostShellDisabled(disabled) {
+    return this.setHostToolDisabled("shell", disabled);
+  }
+  setHostToolDisabled(hostTool, disabled) {
+    const { disableEntry, aftTool } = OPENCODE_HOST_TOOLS[hostTool];
     const configPath = this.detectConfigPaths().harnessConfig;
     const format = this.detectConfigPaths().harnessConfigFormat;
     if (this.configGeneration() !== "v2") {
       return {
         ok: false,
         action: "error",
-        message: "only OpenCode 2 has a built-in shell tool plugin to disable",
+        message: `only OpenCode 2 has a built-in ${hostTool} tool plugin to disable`,
         configPath
       };
     }
@@ -13949,13 +14452,13 @@ class OpenCodeAdapter {
       if (!disabled) {
         return { ok: true, action: "already_present", message: "no config to change", configPath };
       }
-      const failed = this.tryWrite(configPath, () => writeJsoncFile(configPath, { plugins: [OPENCODE_HOST_SHELL_DISABLE_ENTRY] }, "json"));
+      const failed = this.tryWrite(configPath, () => writeJsoncFile(configPath, { plugins: [disableEntry] }, "json"));
       if (failed)
         return failed;
       return {
         ok: true,
         action: "added",
-        message: `Created ${configPath} with ${OPENCODE_HOST_SHELL_DISABLE_ENTRY} under \`plugins\``,
+        message: `Created ${configPath} with ${disableEntry} under \`plugins\``,
         configPath
       };
     }
@@ -13968,12 +14471,12 @@ class OpenCodeAdapter {
         configPath
       };
     }
-    const { changed } = setHostShellPluginDisabled(value, disabled);
+    const { changed } = setHostToolPluginDisabled(value, hostTool, disabled);
     if (!changed) {
       return {
         ok: true,
         action: "already_present",
-        message: disabled ? `${OPENCODE_HOST_SHELL_DISABLE_ENTRY} is already set in ${configPath}` : `${OPENCODE_HOST_SHELL_DISABLE_ENTRY} is not set in ${configPath}`,
+        message: disabled ? `${disableEntry} is already set in ${configPath}` : `${disableEntry} is not set in ${configPath}`,
         configPath
       };
     }
@@ -13983,7 +14486,7 @@ class OpenCodeAdapter {
     return {
       ok: true,
       action: disabled ? "added" : "updated",
-      message: disabled ? `Added ${OPENCODE_HOST_SHELL_DISABLE_ENTRY} under \`plugins\` in ${configPath}: OpenCode's own shell tool is disabled, so agents use AFT's bash` : `Removed ${OPENCODE_HOST_SHELL_DISABLE_ENTRY} from ${configPath}: OpenCode's own shell tool is enabled again`,
+      message: disabled ? `Added ${disableEntry} under \`plugins\` in ${configPath}: OpenCode's own ${hostTool} tool is disabled, so agents use AFT's ${aftTool}` : `Removed ${disableEntry} from ${configPath}: OpenCode's own ${hostTool} tool is enabled again`,
       configPath
     };
   }
@@ -14007,10 +14510,10 @@ class OpenCodeAdapter {
     const configPath = this.detectConfigPaths().harnessConfig;
     const { value } = readJsoncFile(configPath);
     const configuredEntry = openCodePluginReadKeys(this.configGeneration()).flatMap((key) => Array.isArray(value?.[key]) ? value[key] : []).map(pluginEntryPackage).find(isAftNpmEntry);
-    const path = join17(getOpenCodeCacheDir(), "packages", configuredEntry ?? PLUGIN_ENTRY);
+    const path = join19(getOpenCodeCacheDir(), "packages", configuredEntry ?? PLUGIN_ENTRY);
     let cached;
     try {
-      const installedPkgPath = join17(path, "node_modules", "@cortexkit", "aft-opencode", "package.json");
+      const installedPkgPath = join19(path, "node_modules", "@cortexkit", "aft-opencode", "package.json");
       if (existsSync15(installedPkgPath)) {
         const pkg = JSON.parse(readFileSync11(installedPkgPath, "utf-8"));
         cached = typeof pkg.version === "string" ? pkg.version : undefined;
@@ -14086,12 +14589,12 @@ class OpenCodeAdapter {
   describeStorageSubtrees() {
     const storage = this.getStorageDir();
     return {
-      index: dirSize(join17(storage, "index")),
-      semantic: dirSize(join17(storage, "semantic")),
-      backups: dirSize(join17(storage, "backups")),
-      url_cache: dirSize(join17(storage, "url_cache")),
-      onnxruntime: dirSize(join17(storage, "onnxruntime")),
-      logs: dirSize(join17(storage, "logs"))
+      index: dirSize(join19(storage, "index")),
+      semantic: dirSize(join19(storage, "semantic")),
+      backups: dirSize(join19(storage, "backups")),
+      url_cache: dirSize(join19(storage, "url_cache")),
+      onnxruntime: dirSize(join19(storage, "onnxruntime")),
+      logs: dirSize(join19(storage, "logs"))
     };
   }
 }
@@ -14112,18 +14615,18 @@ var init_opencode = __esm(() => {
 
 // src/adapters/pi.ts
 import { existsSync as existsSync16, readFileSync as readFileSync12 } from "node:fs";
-import { homedir as homedir14 } from "node:os";
-import { join as join18, resolve as resolve11 } from "node:path";
+import { homedir as homedir16 } from "node:os";
+import { join as join20, resolve as resolve13 } from "node:path";
 function getPiAgentDir() {
   const configuredDir = process.env.PI_CODING_AGENT_DIR?.trim();
   if (configuredDir)
-    return resolve11(configuredDir);
+    return resolve13(configuredDir);
   const envHome = process.platform === "win32" ? process.env.USERPROFILE : process.env.HOME;
-  const home = envHome && envHome.length > 0 ? envHome : homedir14();
-  return join18(home, ".pi", "agent");
+  const home = envHome && envHome.length > 0 ? envHome : homedir16();
+  return join20(home, ".pi", "agent");
 }
 function readPiExtensionIndex() {
-  const settingsPath = join18(getPiAgentDir(), "settings.json");
+  const settingsPath = join20(getPiAgentDir(), "settings.json");
   if (existsSync16(settingsPath)) {
     try {
       const raw = readFileSync12(settingsPath, "utf-8");
@@ -14144,10 +14647,10 @@ function readPiExtensionIndex() {
     } catch {}
   }
   const candidates = [
-    join18(getPiAgentDir(), "extensions.json"),
-    join18(getPiAgentDir(), "extensions.jsonc"),
-    join18(getPiAgentDir(), "config.json"),
-    join18(getPiAgentDir(), "config.jsonc")
+    join20(getPiAgentDir(), "extensions.json"),
+    join20(getPiAgentDir(), "extensions.jsonc"),
+    join20(getPiAgentDir(), "config.json"),
+    join20(getPiAgentDir(), "config.jsonc")
   ];
   for (const path of candidates) {
     if (!existsSync16(path))
@@ -14183,14 +14686,14 @@ function piEntryMatchesAft(entry) {
   } else if (entry.startsWith("/")) {
     resolved = entry;
   } else if (entry.length > 0) {
-    resolved = join18(getPiAgentDir(), entry);
+    resolved = join20(getPiAgentDir(), entry);
   }
   if (!resolved)
     return false;
   try {
     if (!existsSync16(resolved))
       return false;
-    const pkgPath = join18(resolved, "package.json");
+    const pkgPath = join20(resolved, "package.json");
     if (!existsSync16(pkgPath))
       return false;
     const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
@@ -14242,7 +14745,7 @@ class PiAdapter {
     const aftConfigExists = existsSync16(aftConfigPath);
     return {
       configDir,
-      harnessConfig: index.path ?? join18(configDir, "extensions.json"),
+      harnessConfig: index.path ?? join20(configDir, "extensions.json"),
       harnessConfigFormat: index.path ? "json" : "none",
       aftConfig: aftConfigPath,
       aftConfigFormat: aftConfigExists ? "jsonc" : "none"
@@ -14287,9 +14790,9 @@ class PiAdapter {
   }
   getPluginCacheInfo() {
     const candidates = [
-      join18(getPiAgentDir(), "npm", "node_modules", "@cortexkit", "aft-pi", "package.json"),
-      join18(getPiAgentDir(), "node_modules", "@cortexkit", "aft-pi", "package.json"),
-      join18(getPiAgentDir(), "extensions", "node_modules", "@cortexkit", "aft-pi", "package.json")
+      join20(getPiAgentDir(), "npm", "node_modules", "@cortexkit", "aft-pi", "package.json"),
+      join20(getPiAgentDir(), "node_modules", "@cortexkit", "aft-pi", "package.json"),
+      join20(getPiAgentDir(), "extensions", "node_modules", "@cortexkit", "aft-pi", "package.json")
     ];
     for (const candidate of candidates) {
       if (!existsSync16(candidate))
@@ -14306,7 +14809,7 @@ class PiAdapter {
       } catch {}
     }
     return {
-      path: join18(getPiAgentDir(), "npm", "node_modules", "@cortexkit", "aft-pi", "package.json"),
+      path: join20(getPiAgentDir(), "npm", "node_modules", "@cortexkit", "aft-pi", "package.json"),
       exists: false
     };
   }
@@ -14328,12 +14831,12 @@ class PiAdapter {
   describeStorageSubtrees() {
     const storage = this.getStorageDir();
     return {
-      index: dirSize(join18(storage, "index")),
-      semantic: dirSize(join18(storage, "semantic")),
-      backups: dirSize(join18(storage, "backups")),
-      url_cache: dirSize(join18(storage, "url_cache")),
-      onnxruntime: dirSize(join18(storage, "onnxruntime")),
-      logs: dirSize(join18(storage, "logs"))
+      index: dirSize(join20(storage, "index")),
+      semantic: dirSize(join20(storage, "semantic")),
+      backups: dirSize(join20(storage, "backups")),
+      url_cache: dirSize(join20(storage, "url_cache")),
+      onnxruntime: dirSize(join20(storage, "onnxruntime")),
+      logs: dirSize(join20(storage, "logs"))
     };
   }
 }
@@ -15754,11 +16257,11 @@ var init_version = __esm(async () => {
 
 // src/lib/cli-logger.ts
 import { appendFileSync, mkdirSync as mkdirSync6 } from "node:fs";
-import { tmpdir as tmpdir3 } from "node:os";
-import { dirname as dirname9, join as join19 } from "node:path";
+import { tmpdir as tmpdir4 } from "node:os";
+import { dirname as dirname10, join as join21 } from "node:path";
 function cliLogPath() {
   if (isTestEnvironment())
-    return join19(tmpdir3(), "aft-cli-test.log");
+    return join21(tmpdir4(), "aft-cli-test.log");
   return resolveAftLogPath("aft-cli.log");
 }
 function write(level, message) {
@@ -15773,7 +16276,7 @@ function write(level, message) {
   }
   try {
     const path = cliLogPath();
-    mkdirSync6(dirname9(path), { recursive: true });
+    mkdirSync6(dirname10(path), { recursive: true });
     appendFileSync(path, `${new Date().toISOString()} ${level.toUpperCase()} ${message}
 `);
   } catch {}
@@ -15811,10 +16314,10 @@ var init_cli_logger = __esm(() => {
 
 // src/lib/binary-install.ts
 import { existsSync as existsSync17 } from "node:fs";
-import { join as join20 } from "node:path";
+import { join as join22 } from "node:path";
 function cachedBinaryFor(version) {
   const tag = version.startsWith("v") ? version : `v${version}`;
-  const path = join20(getAftBinaryCacheDir(), tag, getAftBinaryName());
+  const path = join22(getAftBinaryCacheDir(), tag, getAftBinaryName());
   try {
     return existsSync17(path) ? path : null;
   } catch {
@@ -15948,7 +16451,7 @@ function loadFeaturePlan(harness, run = runNative) {
     return {
       ok: false,
       error: withCliCommands(error),
-      configRejected: result.status === 1 && error.includes("aft doctor --fix"),
+      configRejected: result.status === 1 && error.includes("AFT cannot load this configuration"),
       missingBinary: result.missingBinary === true
     };
   }
@@ -16430,8 +16933,10 @@ async function runSetup(argv, options = {}) {
   for (const adapter of nextSteps) {
     if (!(adapter instanceof OpenCodeAdapter))
       continue;
-    if (await offerHostShellDisable(adapter, argv, options) === "failed")
-      anyFailure = true;
+    for (const hostTool of OPENCODE_HOST_TOOL_NAMES) {
+      if (await offerHostToolDisable(adapter, hostTool, argv, options) === "failed")
+        anyFailure = true;
+    }
   }
   for (const adapter of nextSteps)
     printNextSteps(adapter);
@@ -16501,19 +17006,20 @@ async function configureAdapter(adapter, options) {
   }
   return failed ? "failed" : "ok";
 }
-async function offerHostShellDisable(adapter, argv, options = {}) {
-  if (adapter.hostShellState() === "not_applicable")
+async function offerHostToolDisable(adapter, hostTool, argv, options = {}) {
+  if (adapter.hostToolState(hostTool) === "not_applicable")
     return "skipped";
-  const bashOn = adapter.aftBashEnabled();
+  const { aftTool } = OPENCODE_HOST_TOOLS[hostTool];
+  const replacementOn = adapter.aftHostReplacementEnabled(hostTool);
   const interactive = !argv.includes("--yes") && !argv.includes("-y") && (options.interactive ?? Boolean(process.stdin.isTTY));
-  const disable = interactive ? await (options.confirmHostShell ?? confirm2)(HOST_SHELL_QUESTION, bashOn) : bashOn;
-  const result = adapter.setHostShellDisabled(disable);
+  const disable = interactive ? await (options.confirmHostTool ?? (hostTool === "shell" ? options.confirmHostShell : undefined) ?? confirm2)(hostTool === "shell" ? HOST_SHELL_QUESTION : `OpenCode's own ${hostTool} tool: disable it so agents use AFT's ${aftTool}?`, replacementOn) : replacementOn;
+  const result = adapter.setHostToolDisabled(hostTool, disable);
   if (!result.ok) {
     log2.error(`${adapter.displayName}: ${result.message}`);
     return "failed";
   }
   if (result.action === "already_present") {
-    log2.info(`${adapter.displayName}: OpenCode's own shell tool is ${disable ? "already disabled" : "enabled"}${disable ? "; agents use AFT's bash" : bashOn ? "" : " (AFT's bash is disabled)"}`);
+    log2.info(`${adapter.displayName}: OpenCode's own ${hostTool} tool is ${disable ? "already disabled" : "enabled"}${disable ? `; agents use AFT's ${aftTool}` : replacementOn ? "" : ` (AFT's ${aftTool} is disabled)`}`);
   } else {
     log2.success(`${adapter.displayName}: ${result.message}`);
   }
@@ -16569,6 +17075,7 @@ var init_setup = __esm(async () => {
   init_prompts();
   init_self_version();
   init_host_generation();
+  init_opencode_config();
   await __promiseAll([
     init_binary_probe(),
     init_feature_plan(),
@@ -16620,6 +17127,28 @@ var init_backups = __esm(async () => {
   await init_binary_probe();
 });
 
+// src/commands/cache.ts
+function runCache(argv) {
+  const binary = findAftBinary();
+  if (!binary) {
+    console.error(missingAftBinaryMessage(`${CLI} cache`));
+    return 1;
+  }
+  const result = spawnSync(binary, ["cache", ...argv], {
+    stdio: "inherit",
+    env: process.env
+  });
+  if (result.error) {
+    console.error(`aft cache failed to start ${binary}: ${result.error.message}`);
+    return 1;
+  }
+  return result.status ?? 1;
+}
+var init_cache = __esm(async () => {
+  init_dist2();
+  await init_binary_probe();
+});
+
 // src/doctor/features.ts
 function isOn(feature) {
   return feature.effective !== "off";
@@ -16729,7 +17258,7 @@ var init_features = __esm(() => {
 
 // src/doctor/opencode.ts
 import { existsSync as existsSync18, readFileSync as readFileSync13 } from "node:fs";
-import { dirname as dirname10, join as join21 } from "node:path";
+import { dirname as dirname11, join as join23 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function isLoadPath(value) {
   return OPENCODE_LOAD_PATHS.includes(value);
@@ -16800,13 +17329,13 @@ function readManifest(path) {
 }
 function manifestFromLocalPath(path) {
   let current = path;
-  if (!existsSync18(join21(current, "package.json")))
-    current = dirname10(current);
+  if (!existsSync18(join23(current, "package.json")))
+    current = dirname11(current);
   while (true) {
-    const manifest = readManifest(join21(current, "package.json"));
+    const manifest = readManifest(join23(current, "package.json"));
     if (manifest)
       return manifest;
-    const parent = dirname10(current);
+    const parent = dirname11(current);
     if (parent === current)
       return null;
     current = parent;
@@ -16816,7 +17345,7 @@ function pluginManifest(entry, cachePath) {
   const localRoot = localPluginRoot(entry);
   if (localRoot)
     return manifestFromLocalPath(localRoot);
-  return readManifest(join21(cachePath, "node_modules", "@cortexkit", "aft-opencode", "package.json"));
+  return readManifest(join23(cachePath, "node_modules", "@cortexkit", "aft-opencode", "package.json"));
 }
 function pinProblem(entry, pinned) {
   return `the plugin entry ${entry} ${describePluginEntry(entry)}; run \`${CLI} doctor --fix\` to pin it to ${pinned}`;
@@ -16916,6 +17445,36 @@ function isResponseForRequest(parsed, expectedIds) {
     return false;
   return expectedIds.has(id);
 }
+function createNdjsonLineSplitter(onLine) {
+  let pending = [];
+  let scannedChars = 0;
+  return {
+    push(chunk) {
+      scannedChars += chunk.length;
+      let start = 0;
+      let newline = chunk.indexOf(`
+`);
+      while (newline !== -1) {
+        let line = chunk.slice(start, newline);
+        if (pending.length > 0) {
+          pending.push(line);
+          line = pending.join("");
+          pending = [];
+        }
+        start = newline + 1;
+        if (onLine(line.trim()) === true)
+          return;
+        newline = chunk.indexOf(`
+`, start);
+      }
+      if (start < chunk.length)
+        pending.push(start === 0 ? chunk : chunk.slice(start));
+    },
+    get scannedChars() {
+      return scannedChars;
+    }
+  };
+}
 async function sendAftRequest(binaryPath, request) {
   const responses = await sendAftRequests(binaryPath, [request]);
   const response = responses[0];
@@ -16930,7 +17489,7 @@ async function sendAftRequests(binaryPath, requests) {
     });
     const responses = [];
     const noiseLines = [];
-    let stdout = "";
+    let noiseLineCount = 0;
     let stderr = "";
     let settled = false;
     const finish = (fn) => {
@@ -16941,18 +17500,23 @@ async function sendAftRequests(binaryPath, requests) {
       fn();
     };
     const expectedIds = new Set(requests.map((req) => req.id));
+    const recordNoise = (line) => {
+      noiseLineCount += 1;
+      if (noiseLines.length < MAX_NOISE_LINES_IN_ERROR)
+        noiseLines.push(line);
+    };
     const handleLine = (line) => {
       if (!line)
         return;
       if (!line.startsWith("{")) {
-        noiseLines.push(line);
+        recordNoise(line);
         return;
       }
       let parsed;
       try {
         parsed = JSON.parse(line);
       } catch {
-        noiseLines.push(line);
+        recordNoise(line);
         return;
       }
       if (!isResponseForRequest(parsed, expectedIds)) {
@@ -16964,20 +17528,15 @@ async function sendAftRequests(binaryPath, requests) {
         finish(() => resolve(responses));
       }
     };
+    const stdoutLines = createNdjsonLineSplitter((line) => {
+      handleLine(line);
+      return settled;
+    });
     child.stdout.setEncoding("utf-8");
     child.stdout.on("data", (chunk) => {
-      stdout += chunk;
-      while (true) {
-        const newline = stdout.indexOf(`
-`);
-        if (newline === -1)
-          break;
-        const line = stdout.slice(0, newline).trim();
-        stdout = stdout.slice(newline + 1);
-        handleLine(line);
-        if (settled)
-          break;
-      }
+      if (settled)
+        return;
+      stdoutLines.push(chunk);
     });
     child.stderr.setEncoding("utf-8");
     child.stderr.on("data", (chunk) => {
@@ -16989,7 +17548,7 @@ async function sendAftRequests(binaryPath, requests) {
     child.on("close", (code) => {
       if (settled)
         return;
-      finish(() => reject(buildBridgeError({ binaryPath, code, stderr, noiseLines, responses })));
+      finish(() => reject(buildBridgeError({ binaryPath, code, stderr, noiseLines, noiseLineCount, responses })));
     });
     child.stdin.on("error", () => {});
     try {
@@ -17007,14 +17566,14 @@ function buildBridgeError(ctx) {
   if (ctx.responses.length > 0) {
     parts.push(`Got ${ctx.responses.length} valid response(s) before exit.`);
   }
-  if (ctx.noiseLines.length > 0) {
+  if (ctx.noiseLineCount > 0) {
     parts.push(`
-The binary printed ${ctx.noiseLines.length} non-JSON line(s) to stdout — this usually means ` + "the resolved binary isn't an AFT release binary (wrapper script, panic output, or unrelated tool):");
+The binary printed ${ctx.noiseLineCount} non-JSON line(s) to stdout — this usually means ` + "the resolved binary isn't an AFT release binary (wrapper script, panic output, or unrelated tool):");
     const sample = ctx.noiseLines.slice(0, MAX_NOISE_LINES_IN_ERROR).map((line) => `  | ${line}`);
     parts.push(sample.join(`
 `));
-    if (ctx.noiseLines.length > MAX_NOISE_LINES_IN_ERROR) {
-      parts.push(`  | (… ${ctx.noiseLines.length - MAX_NOISE_LINES_IN_ERROR} more line(s) omitted)`);
+    if (ctx.noiseLineCount > MAX_NOISE_LINES_IN_ERROR) {
+      parts.push(`  | (… ${ctx.noiseLineCount - MAX_NOISE_LINES_IN_ERROR} more line(s) omitted)`);
     }
     parts.push(`
 Try: ${CLI} doctor (full diagnostics) or check ~/.cache/aft/bin/ for the right binary.`);
@@ -17035,7 +17594,7 @@ var init_aft_bridge = __esm(() => {
 
 // src/lib/binary-cache.ts
 import { existsSync as existsSync19, readdirSync as readdirSync7, statSync as statSync12 } from "node:fs";
-import { join as join22 } from "node:path";
+import { join as join24 } from "node:path";
 function getBinaryCacheInfo(activeVersion) {
   const path = getAftBinaryCacheDir();
   if (!existsSync19(path)) {
@@ -17048,7 +17607,7 @@ function getBinaryCacheInfo(activeVersion) {
   }
   const versions = readdirSync7(path).filter((entry) => {
     try {
-      return statSync12(join22(path, entry)).isDirectory();
+      return statSync12(join24(path, entry)).isDirectory();
     } catch {
       return false;
     }
@@ -17068,14 +17627,14 @@ var init_binary_cache = __esm(() => {
 });
 
 // src/lib/sanitize.ts
-import { realpathSync as realpathSync4 } from "node:fs";
-import { homedir as homedir15, userInfo } from "node:os";
+import { realpathSync as realpathSync5 } from "node:fs";
+import { homedir as homedir17, userInfo } from "node:os";
 function escapeRegex(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function safeRealpath(p) {
   try {
-    return realpathSync4(p);
+    return realpathSync5(p);
   } catch {
     return null;
   }
@@ -17105,7 +17664,7 @@ function redactSecrets(content) {
 }
 function sanitizeContent(content) {
   const username = userInfo().username;
-  const home = homedir15();
+  const home = homedir17();
   let sanitized = redactSecrets(content);
   const cwd = process.cwd();
   for (const candidate of new Set([cwd, safeRealpath(cwd)])) {
@@ -17122,7 +17681,7 @@ function sanitizeContent(content) {
   sanitized = sanitized.replace(/([A-Za-z]:\\Users\\)[^\\"'\s]+/g, "$1<USER>");
   sanitized = sanitized.replace(/([A-Za-z]:\/Users\/)[^/\s"']+/g, "$1<USER>");
   if (username) {
-    sanitized = sanitized.replace(new RegExp(escapeRegex(username), "g"), "<USER>");
+    sanitized = redactUsername(sanitized, username);
   }
   return sanitized;
 }
@@ -17138,6 +17697,11 @@ function sanitizeValue(value) {
   }
   return value;
 }
+function redactUsername(content, username) {
+  if (!username)
+    return content;
+  return content.replace(new RegExp(`(?<![\\p{L}\\p{N}_])${escapeRegex(username)}(?![\\p{L}\\p{N}_])`, "gu"), "<USER>");
+}
 var SECRET_PLACEHOLDER = "<REDACTED_SECRET>", URL_CREDENTIAL_PLACEHOLDER = "***", KEY_NAME = "[A-Za-z_][A-Za-z0-9_.-]*", SENSITIVE_KEY_WORD, SEGMENTED_KEY_WORD, CAMEL_CASE_KEY_WORD, JWT_PATTERN, AWS_ACCESS_KEY_ID_PATTERN, CREDENTIAL_QUERY_PATTERN, KEY_QUERY_PATTERN, quotedSensitiveKeyValuePattern, unquotedSensitiveKeyValuePattern, bareSensitiveKeyValuePattern;
 var init_sanitize = __esm(() => {
   SENSITIVE_KEY_WORD = /(?:token|password|secret|api[_-]?key|passwd|pwd|credential)/i;
@@ -17153,7 +17717,7 @@ var init_sanitize = __esm(() => {
 });
 
 // src/lib/bridge-tool-failures.ts
-import { closeSync as closeSync6, existsSync as existsSync20, openSync as openSync6, readSync as readSync4, statSync as statSync13 } from "node:fs";
+import { closeSync as closeSync8, existsSync as existsSync20, openSync as openSync8, readSync as readSync6, statSync as statSync13 } from "node:fs";
 function resolveBridgePluginLogPath() {
   return resolvePluginLogPath();
 }
@@ -17167,16 +17731,16 @@ function tailLogFileBytes(path, maxBytes) {
       return "";
     const readLength = Math.min(size, maxBytes);
     const position = size - readLength;
-    fd = openSync6(path, "r");
+    fd = openSync8(path, "r");
     const buffer = Buffer.allocUnsafe(readLength);
-    const bytesRead = readSync4(fd, buffer, 0, readLength, position);
+    const bytesRead = readSync6(fd, buffer, 0, readLength, position);
     return buffer.subarray(0, bytesRead).toString("utf-8").trim();
   } catch {
     return "";
   } finally {
     if (fd !== null) {
       try {
-        closeSync6(fd);
+        closeSync8(fd);
       } catch {}
     }
   }
@@ -17296,7 +17860,7 @@ var init_bridge_tool_failures = __esm(() => {
 // src/lib/build-breaker.ts
 import { existsSync as existsSync21, readdirSync as readdirSync8 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
-import { join as join23 } from "node:path";
+import { join as join25 } from "node:path";
 function loadDatabaseSync() {
   const require2 = createRequire3(import.meta.url);
   try {
@@ -17310,11 +17874,11 @@ function loadDatabaseSync() {
   }
 }
 function buildBreakerDatabases(storageRoot) {
-  const callgraphRoot = join23(storageRoot, "callgraph");
+  const callgraphRoot = join25(storageRoot, "callgraph");
   if (!existsSync21(callgraphRoot))
     return [];
   try {
-    return readdirSync8(callgraphRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join23(callgraphRoot, entry.name, "build-breaker.sqlite")).filter((path) => existsSync21(path));
+    return readdirSync8(callgraphRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join25(callgraphRoot, entry.name, "build-breaker.sqlite")).filter((path) => existsSync21(path));
   } catch {
     return [];
   }
@@ -17450,21 +18014,10 @@ function previewConfigMigration(targets) {
     if (!raw)
       continue;
     const translated = structuredClone(raw);
-    const translation = translateConfigDocument(translated, "window", target.tier);
-    const retiredGithub = Object.hasOwn(raw, "gh_read") || isRecord2(raw.gh_shim) && "enabled" in raw.gh_shim;
-    if (!translation.legacyInput && translation.errors.length === 0 && !retiredGithub)
+    const translation = translateConfigDocument(translated, target.tier);
+    if (!translation.legacyInput)
       continue;
     const changes = diffConfig(raw, translated);
-    for (const code of translation.errors) {
-      const match = /^removed_config_key:([^:]+):use:(.+)$/.exec(code);
-      if (match)
-        changes.push({
-          kind: "changed",
-          key: match[1],
-          before: undefined,
-          after: `→ ${match[2]}`
-        });
-    }
     previews.push({ ...target, changes });
   }
   return previews;
@@ -17477,9 +18030,6 @@ function describeConfigChange(change) {
     return `removed ${change.key} (was ${show(change.before)})`;
   if (change.kind === "added")
     return `added ${change.key}: ${show(change.after)}`;
-  if (change.before === undefined && typeof change.after === "string" && change.after.startsWith("→ ")) {
-    return `replaced ${change.key} with ${change.after.slice(2)}`;
-  }
   return `changed ${change.key}: ${show(change.before)} → ${show(change.after)}`;
 }
 var import_comment_json2;
@@ -17490,19 +18040,19 @@ var init_config_migration = __esm(() => {
 
 // src/lib/legacy-storage.ts
 import { existsSync as existsSync23, readdirSync as readdirSync9, statSync as statSync14 } from "node:fs";
-import { join as join24 } from "node:path";
+import { join as join26 } from "node:path";
 function summarizeLegacyPartitionDuplication(storageRoot) {
   if (!existsSync23(storageRoot)) {
     return { totalPartitions: 0, totalBytes: 0, byHarness: [] };
   }
   const byHarness = [];
   for (const harness of safeReadDir(storageRoot)) {
-    const harnessPath = join24(storageRoot, harness);
+    const harnessPath = join26(storageRoot, harness);
     if (!isDirectory(harnessPath))
       continue;
     const partitions = new Map;
-    collectCallgraphPartitions(join24(harnessPath, "callgraph"), partitions);
-    collectInspectPartitions(join24(harnessPath, "inspect"), partitions);
+    collectCallgraphPartitions(join26(harnessPath, "callgraph"), partitions);
+    collectInspectPartitions(join26(harnessPath, "inspect"), partitions);
     if (partitions.size === 0)
       continue;
     let bytes = 0;
@@ -17521,7 +18071,7 @@ function collectCallgraphPartitions(domainPath, partitions) {
   if (!isDirectory(domainPath))
     return;
   for (const name of safeReadDir(domainPath)) {
-    const path = join24(domainPath, name);
+    const path = join26(domainPath, name);
     if (isDirectory(path)) {
       if (!looksLikePartitionKey(name))
         continue;
@@ -17538,7 +18088,7 @@ function collectInspectPartitions(domainPath, partitions) {
   if (!isDirectory(domainPath))
     return;
   for (const name of safeReadDir(domainPath)) {
-    const path = join24(domainPath, name);
+    const path = join26(domainPath, name);
     if (isDirectory(path)) {
       if (!looksLikePartitionKey(name))
         continue;
@@ -17614,7 +18164,7 @@ var init_legacy_storage = __esm(() => {
 
 // src/lib/lsp-cache.ts
 import { existsSync as existsSync24, readdirSync as readdirSync10, rmSync as rmSync5, statSync as statSync15 } from "node:fs";
-import { join as join25 } from "node:path";
+import { join as join27 } from "node:path";
 function inspectDir(path) {
   if (!existsSync24(path)) {
     return { entries: [], totalSize: 0 };
@@ -17628,7 +18178,7 @@ function inspectDir(path) {
     return { entries: [], totalSize: 0 };
   }
   for (const name of names) {
-    const full = join25(path, name);
+    const full = join27(path, name);
     try {
       if (!statSync15(full).isDirectory())
         continue;
@@ -17686,8 +18236,8 @@ var init_lsp_cache = __esm(() => {
 });
 
 // src/lib/onnx.ts
-import { existsSync as existsSync25, readdirSync as readdirSync11, readlinkSync as readlinkSync2, realpathSync as realpathSync5 } from "node:fs";
-import { basename as basename2, isAbsolute as isAbsolute5, join as join26, resolve as resolve12, win32 as win322 } from "node:path";
+import { existsSync as existsSync25, readdirSync as readdirSync11, readlinkSync as readlinkSync2, realpathSync as realpathSync6 } from "node:fs";
+import { basename as basename2, isAbsolute as isAbsolute7, join as join28, resolve as resolve14, win32 as win323 } from "node:path";
 function getOnnxLibraryName() {
   if (process.platform === "darwin")
     return "libonnxruntime.dylib";
@@ -17723,18 +18273,18 @@ function pathEntriesForPlatform2() {
   return pathEnvValue2().split(delimiter).map((entry) => entry.trim().replace(/^"|"$/g, "")).filter((entry) => {
     if (!entry || entry === "." || entry.includes("\x00"))
       return false;
-    return isAbsolute5(entry) || win322.isAbsolute(entry);
+    return isAbsolute7(entry) || win323.isAbsolute(entry);
   });
 }
 function isWindowsSystem32Directory2(dir) {
   if (process.platform !== "win32")
     return false;
-  const normalizedDir = win322.resolve(dir).replace(/[\\/]+$/, "").toLowerCase();
+  const normalizedDir = win323.resolve(dir).replace(/[\\/]+$/, "").toLowerCase();
   const windowsRoots = [process.env.SystemRoot, process.env.windir, "C:\\Windows"];
   return windowsRoots.some((root) => {
     if (!root)
       return false;
-    return normalizedDir === win322.resolve(root, "System32").replace(/[\\/]+$/, "").toLowerCase();
+    return normalizedDir === win323.resolve(root, "System32").replace(/[\\/]+$/, "").toLowerCase();
   });
 }
 function directoryContainsLibrary2(dir, libName) {
@@ -17757,8 +18307,8 @@ function findIgnoredWindowsSystemOnnxRuntime() {
   for (const root of windowsRoots) {
     if (!root)
       continue;
-    const systemDir = join26(root, "System32");
-    const key = win322.resolve(systemDir).toLowerCase();
+    const systemDir = join28(root, "System32");
+    const key = win323.resolve(systemDir).toLowerCase();
     if (seen.has(key))
       continue;
     seen.add(key);
@@ -17779,12 +18329,12 @@ function inspectSystemOnnxRuntime(searchPathsOverride) {
     searchPaths.push(...pathEntriesForPlatform2());
     const programFiles = process.env.ProgramFiles ?? "C:\\Program Files";
     const programFilesX86 = process.env["ProgramFiles(x86)"] ?? "C:\\Program Files (x86)";
-    searchPaths.push(join26(programFiles, "onnxruntime", "lib"), join26(programFiles, "Microsoft ONNX Runtime", "lib"), join26(programFiles, "Microsoft Machine Learning", "lib"), join26(programFilesX86, "onnxruntime", "lib"), ...(() => {
+    searchPaths.push(join28(programFiles, "onnxruntime", "lib"), join28(programFiles, "Microsoft ONNX Runtime", "lib"), join28(programFiles, "Microsoft Machine Learning", "lib"), join28(programFilesX86, "onnxruntime", "lib"), ...(() => {
       const nugetPaths = [];
       const userProfile = process.env.USERPROFILE ?? "";
       if (!userProfile)
         return nugetPaths;
-      const nugetPackageDir = join26(userProfile, ".nuget", "packages", "microsoft.ml.onnxruntime");
+      const nugetPackageDir = join28(userProfile, ".nuget", "packages", "microsoft.ml.onnxruntime");
       if (!existsSync25(nugetPackageDir))
         return nugetPaths;
       try {
@@ -17793,7 +18343,7 @@ function inspectSystemOnnxRuntime(searchPathsOverride) {
             continue;
           if (entry.name === "__globalPackagesFolder" || entry.name.startsWith("."))
             continue;
-          nugetPaths.push(join26(nugetPackageDir, entry.name, "runtimes", "win-x64", "native"), join26(nugetPackageDir, entry.name, "runtimes", "win-arm64", "native"));
+          nugetPaths.push(join28(nugetPackageDir, entry.name, "runtimes", "win-x64", "native"), join28(nugetPackageDir, entry.name, "runtimes", "win-arm64", "native"));
         }
       } catch {}
       return nugetPaths;
@@ -17803,7 +18353,7 @@ function inspectSystemOnnxRuntime(searchPathsOverride) {
   const seen = new Set;
   const unknownVersionPaths = [];
   for (const dir of searchPaths) {
-    let key = resolve12(dir).replace(/[/\\]+$/, "");
+    let key = resolve14(dir).replace(/[/\\]+$/, "");
     if (normalizeCase)
       key = key.toLowerCase();
     if (seen.has(key))
@@ -17812,7 +18362,7 @@ function inspectSystemOnnxRuntime(searchPathsOverride) {
     if (!directoryContainsLibrary2(dir, libName))
       continue;
     if (process.platform !== "win32") {
-      const probe = probeOnnxRuntimeLoadable(join26(dir, libName));
+      const probe = probeOnnxRuntimeLoadable(join28(dir, libName));
       if (!probe.loadable) {
         ignored ??= { path: dir, reason: `unloadable: ${probe.reason} — ignored` };
         continue;
@@ -17832,12 +18382,12 @@ function inspectSystemOnnxRuntime(searchPathsOverride) {
   return { path: unknownVersionPaths[0] ?? null, ignored };
 }
 function findCachedOnnxRuntime2(storageDir) {
-  const ortDir = join26(storageDir, "onnxruntime", ONNX_RUNTIME_VERSION);
+  const ortDir = join28(storageDir, "onnxruntime", ONNX_RUNTIME_VERSION);
   const libName = getOnnxLibraryName();
-  if (existsSync25(join26(ortDir, libName)))
+  if (existsSync25(join28(ortDir, libName)))
     return ortDir;
-  const libSubdir = join26(ortDir, "lib");
-  if (existsSync25(join26(libSubdir, libName)))
+  const libSubdir = join28(ortDir, "lib");
+  if (existsSync25(join28(libSubdir, libName)))
     return libSubdir;
   return null;
 }
@@ -17862,7 +18412,7 @@ function detectOrtVersion(libDir) {
     return null;
   const libName = getOnnxLibraryName();
   try {
-    const resolved = parseOrtVersionFromPath(realpathSync5(join26(libDir, libName)));
+    const resolved = parseOrtVersionFromPath(realpathSync6(join28(libDir, libName)));
     if (resolved && resolved !== INVALID_ORT_VERSION2)
       return resolved;
   } catch {}
@@ -17878,10 +18428,10 @@ function detectOrtVersion(libDir) {
       if (version)
         return version;
     }
-    const base = join26(libDir, libName);
+    const base = join28(libDir, libName);
     if (existsSync25(base)) {
       try {
-        const real = realpathSync5(base);
+        const real = realpathSync6(base);
         const version = parseOrtVersionFromPath(real) ?? parseOrtVersionFromDirectoryPath(real);
         if (version)
           return version;
@@ -17942,7 +18492,6 @@ function indexesOf(block) {
 }
 function evaluatePluginLoad(input) {
   const blockers = [];
-  const phase = policyPhaseForVersion(input.pluginVersion);
   const tiers = [
     { path: input.userConfigPath, tier: "user" }
   ];
@@ -17970,20 +18519,7 @@ function evaluatePluginLoad(input) {
     if (!value)
       continue;
     const translated = structuredClone(value);
-    const translation = translateConfigDocument(translated, phase, tier);
-    if (translation.errors.length > 0) {
-      const removed = translation.errors.map((code) => code.replace(/^removed_config_key:([^:]+):use:(.+)$/, "$1 → $2")).join(", ");
-      const scope = tier === "project" ? " in this project" : "";
-      const toolCallError = formatConfigErrorMessage(new ConfigRejectedError(translation.errors, path).message);
-      blockers.push({
-        code: "config_rejected",
-        path,
-        message: `${failsEveryToolCall(toolCallError, scope)} (removed keys: ${removed})`,
-        toolCallError,
-        remediation: `Run \`${CLI} doctor --fix\` to migrate the file, then restart the host.`,
-        fixable: true
-      });
-    }
+    translateConfigDocument(translated, tier);
     loaded[tier] = withHarness(translated, input.harness);
   }
   const subc = loaded.user && isRecord3(loaded.user.subc) ? loaded.user.subc : null;
@@ -18022,11 +18558,11 @@ var init_plugin_load = __esm(() => {
 // src/lib/diagnostics.ts
 import {
   accessSync as accessSync3,
-  closeSync as closeSync7,
-  constants as constants3,
+  closeSync as closeSync9,
+  constants as constants4,
   existsSync as existsSync27,
-  openSync as openSync7,
-  readSync as readSync5,
+  openSync as openSync9,
+  readSync as readSync7,
   statSync as statSync16
 } from "node:fs";
 async function collectDiagnostics(adapters) {
@@ -18066,7 +18602,7 @@ async function diagnoseHarness(adapter) {
     if (!existsSync27(storage))
       return false;
     try {
-      accessSync3(storage, constants3.R_OK | constants3.W_OK);
+      accessSync3(storage, constants4.R_OK | constants4.W_OK);
       return true;
     } catch {
       return false;
@@ -18077,8 +18613,7 @@ async function diagnoseHarness(adapter) {
   const pluginLoad = evaluatePluginLoad({
     userConfigPath: configPaths.aftConfig,
     projectDirectory: process.cwd(),
-    harness: adapter.kind === "opencode" ? "opencode" : "pi",
-    pluginVersion: pluginCache.cached ?? getSelfVersion()
+    harness: adapter.kind === "opencode" ? "opencode" : "pi"
   });
   const semanticEnabled = aftEnabled && pluginLoad.onnxRequired;
   const systemInspection = inspectSystemOnnxRuntime();
@@ -18370,7 +18905,7 @@ function tailLogFile(path, lines) {
   let fd = null;
   try {
     const size = statSync16(path).size;
-    fd = openSync7(path, "r");
+    fd = openSync9(path, "r");
     const chunks = [];
     let position = size;
     let newlineCount = 0;
@@ -18378,7 +18913,7 @@ function tailLogFile(path, lines) {
       const readLength = Math.min(chunkSize, position);
       position -= readLength;
       const buffer = Buffer.allocUnsafe(readLength);
-      const bytesRead = readSync5(fd, buffer, 0, readLength, position);
+      const bytesRead = readSync7(fd, buffer, 0, readLength, position);
       const chunk = bytesRead === readLength ? buffer : buffer.subarray(0, bytesRead);
       chunks.unshift(chunk);
       for (let i = chunk.length - 1;i >= 0; i -= 1) {
@@ -18393,7 +18928,7 @@ function tailLogFile(path, lines) {
   } finally {
     if (fd !== null) {
       try {
-        closeSync7(fd);
+        closeSync9(fd);
       } catch {}
     }
   }
@@ -18490,29 +19025,44 @@ function capBodyToGithubLimit(body, maxBytes = MAX_GITHUB_BODY_BYTES) {
   const head = body.slice(0, logBlockStart);
   const log = body.slice(logBlockStart, logBlockEnd);
   const tail = body.slice(logBlockEnd);
-  const overheadBytes = Buffer.byteLength(head, "utf8") + Buffer.byteLength(tail, "utf8");
   const truncationMarker = `[truncated for GitHub 64KB limit — older log lines dropped]
 `;
-  const markerBytes = Buffer.byteLength(truncationMarker, "utf8");
-  const logBudget = maxBytes - overheadBytes - markerBytes;
-  if (logBudget <= 0) {
-    return `${head}${truncationMarker}${tail}`;
-  }
   const lines = log.split(`
 `);
-  let keepLines = lines;
-  let kept = keepLines.join(`
-`);
-  while (Buffer.byteLength(kept, "utf8") > logBudget && keepLines.length > 1) {
-    const dropCount = Math.max(1, Math.floor(keepLines.length * 0.05));
-    keepLines = keepLines.slice(dropCount);
-    kept = keepLines.join(`
-`);
-  }
-  if (Buffer.byteLength(kept, "utf8") > logBudget) {
-    kept = truncateToByteBudget(kept, logBudget);
+  let inFence = false;
+  let fence = "";
+  const payload = [];
+  for (let i = 0;i < lines.length; i++) {
+    const delimiter = lines[i].match(/^\s*(`{3,}|~{3,})/);
+    if (delimiter) {
+      if (!inFence) {
+        inFence = true;
+        fence = delimiter[1];
+      } else if (delimiter[1][0] === fence[0] && delimiter[1].length >= fence.length)
+        inFence = false;
+    } else if (inFence || lines[i] && !/^#{1,6} /.test(lines[i])) {
+      payload.push(i);
+    }
+  }
+  const removed = new Set;
+  const render = () => `${head}${truncationMarker}${lines.filter((_, i) => !removed.has(i)).join(`
+`)}${tail}`;
+  let size = Buffer.byteLength(render(), "utf8");
+  for (const index of payload) {
+    if (size <= maxBytes)
+      break;
+    const excess = size - maxBytes;
+    const bytes = Buffer.byteLength(lines[index], "utf8");
+    if (index === payload.at(-1) && bytes > excess) {
+      const kept = truncateToByteBudget(lines[index], bytes - excess);
+      size -= bytes - Buffer.byteLength(kept, "utf8");
+      lines[index] = kept;
+    } else {
+      removed.add(index);
+      size -= bytes + 1;
+    }
   }
-  return `${head}${truncationMarker}${kept}${tail}`;
+  return render();
 }
 function findNextTopLevelHeading(body, startIdx) {
   const idx = body.indexOf(`
@@ -18548,13 +19098,13 @@ var init_issue_body = __esm(() => {
 // src/lib/onnx-fix.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
 import { existsSync as existsSync28, mkdirSync as mkdirSync7, renameSync as renameSync5, rmSync as rmSync6 } from "node:fs";
-import { isAbsolute as isAbsolute6, join as join27, relative as relative2 } from "node:path";
+import { isAbsolute as isAbsolute8, join as join29, relative as relative4 } from "node:path";
 function findOnnxFixCandidates(report) {
   const candidates = [];
   for (const harness of report.harnesses) {
     if (!harness.onnxRuntime.required)
       continue;
-    const storageOnnxDir = join27(harness.storageDir.path, "onnxruntime");
+    const storageOnnxDir = join29(harness.storageDir.path, "onnxruntime");
     const systemTooOld = harness.onnxRuntime.systemPath !== null && harness.onnxRuntime.systemCompatible === false;
     const cachedTooOld = harness.onnxRuntime.cachedPath !== null && harness.onnxRuntime.cachedCompatible === false;
     const hasCompatibleCached = harness.onnxRuntime.cachedCompatible === true;
@@ -18593,15 +19143,15 @@ function findOnnxFixCandidates(report) {
 async function installManagedReplacement(candidate, ensureFn, rmFn) {
   const suffix = `${process.pid}.${Date.now().toString(36)}.${randomBytes2(6).toString("hex")}`;
   const stagingStorageDir = `${candidate.harness.storageDir.path}.onnx-fix.tmp.${suffix}`;
-  const stagedOnnxDir = join27(stagingStorageDir, "onnxruntime");
+  const stagedOnnxDir = join29(stagingStorageDir, "onnxruntime");
   const backupDir = `${candidate.storageOnnxDir}.backup.${suffix}`;
   try {
     const stagedInstalledPath = await ensureFn(stagingStorageDir);
     if (!stagedInstalledPath || !existsSync28(stagedInstalledPath)) {
       throw new Error("managed ONNX Runtime download was unavailable");
     }
-    const installedRelativePath = relative2(stagedOnnxDir, stagedInstalledPath);
-    if (isAbsolute6(installedRelativePath) || installedRelativePath === ".." || installedRelativePath.startsWith("../") || installedRelativePath.startsWith("..\\")) {
+    const installedRelativePath = relative4(stagedOnnxDir, stagedInstalledPath);
+    if (isAbsolute8(installedRelativePath) || installedRelativePath === ".." || installedRelativePath.startsWith("../") || installedRelativePath.startsWith("..\\")) {
       throw new Error(`managed ONNX Runtime was installed outside staging: ${stagedInstalledPath}`);
     }
     mkdirSync7(candidate.harness.storageDir.path, { recursive: true });
@@ -18629,7 +19179,7 @@ async function installManagedReplacement(candidate, ensureFn, rmFn) {
       }
     }
     return {
-      installedPath: join27(candidate.storageOnnxDir, installedRelativePath),
+      installedPath: join29(candidate.storageOnnxDir, installedRelativePath),
       clearedPrevious: hadPrevious && cleanupError === undefined,
       cleanupError
     };
@@ -18696,7 +19246,7 @@ var init_onnx_fix = __esm(() => {
 });
 
 // src/lib/session-log.ts
-import { closeSync as closeSync8, openSync as openSync8, readSync as readSync6, statSync as statSync17 } from "node:fs";
+import { closeSync as closeSync10, openSync as openSync10, readSync as readSync8, statSync as statSync17 } from "node:fs";
 function readSessionLog(path, session, maxBytes = MAX_SCAN_BYTES) {
   const lines = [];
   const errors = [];
@@ -18734,7 +19284,7 @@ function readSessionLog(path, session, maxBytes = MAX_SCAN_BYTES) {
       break;
     let fd;
     try {
-      fd = openSync8(file, "r");
+      fd = openSync10(file, "r");
       let position = statSync17(file).size;
       let suffix = Buffer.alloc(0);
       while (position > 0 && remaining > 0 && (lines.length < 200 || errors.length < 20)) {
@@ -18742,7 +19292,7 @@ function readSessionLog(path, session, maxBytes = MAX_SCAN_BYTES) {
         position -= length;
         remaining -= length;
         const chunk = Buffer.allocUnsafe(length);
-        const count = readSync6(fd, chunk, 0, length, position);
+        const count = readSync8(fd, chunk, 0, length, position);
         const bytes = Buffer.concat([chunk.subarray(0, count), suffix]);
         let end = bytes.length;
         for (let i = bytes.length - 1;i >= 0; i -= 1) {
@@ -18761,7 +19311,7 @@ function readSessionLog(path, session, maxBytes = MAX_SCAN_BYTES) {
         boundHit = true;
     } catch {} finally {
       if (fd !== undefined)
-        closeSync8(fd);
+        closeSync10(fd);
     }
   }
   return { lines: lines.reverse(), errors: errors.reverse(), boundHit };
@@ -18777,8 +19327,8 @@ var init_session_log = __esm(() => {
 // src/lib/sessions.ts
 import { existsSync as existsSync29, readdirSync as readdirSync12, readFileSync as readFileSync16, statSync as statSync18 } from "node:fs";
 import { createRequire as createRequire4 } from "node:module";
-import { homedir as homedir16 } from "node:os";
-import { basename as basename3, join as join28 } from "node:path";
+import { homedir as homedir18 } from "node:os";
+import { basename as basename3, join as join30 } from "node:path";
 function listRecentSessions(adapter) {
   try {
     if (adapter.kind === "opencode")
@@ -18812,7 +19362,7 @@ function mapOpenCodeSessionRows(rows) {
   }).filter((session) => session !== null).sort((a, b) => b.lastActivity - a.lastActivity).slice(0, MAX_RECENT_SESSIONS);
 }
 function listRecentOpenCodeSessions() {
-  const dbPath = join28(getXdgDataHome(), "opencode", "opencode.db");
+  const dbPath = join30(getXdgDataHome(), "opencode", "opencode.db");
   if (!existsSync29(dbPath))
     return [];
   let db = null;
@@ -18832,14 +19382,14 @@ function listRecentOpenCodeSessions() {
 }
 function getXdgDataHome() {
   const xdgDataHome = process.env.XDG_DATA_HOME;
-  return xdgDataHome && xdgDataHome.length > 0 ? xdgDataHome : join28(homedir16(), ".local", "share");
+  return xdgDataHome && xdgDataHome.length > 0 ? xdgDataHome : join30(homedir18(), ".local", "share");
 }
 function listRecentPiSessions() {
-  return listPiSessionsFromDir(join28(getHomeDir(), ".pi", "agent", "sessions"));
+  return listPiSessionsFromDir(join30(getHomeDir(), ".pi", "agent", "sessions"));
 }
 function getHomeDir() {
   const envHome = process.platform === "win32" ? process.env.USERPROFILE : process.env.HOME;
-  return envHome && envHome.length > 0 ? envHome : homedir16();
+  return envHome && envHome.length > 0 ? envHome : homedir18();
 }
 function listPiSessionsFromDir(sessionsDir) {
   try {
@@ -18881,7 +19431,7 @@ function collectJsonlFiles(root) {
       continue;
     }
     for (const entry of entries) {
-      const path = join28(dir, entry.name);
+      const path = join30(dir, entry.name);
       if (entry.isDirectory()) {
         stack.push(path);
       } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
@@ -18986,13 +19536,13 @@ import {
   mkdirSync as mkdirSync8,
   mkdtempSync as mkdtempSync2,
   readFileSync as readFileSync17,
-  realpathSync as realpathSync6,
+  realpathSync as realpathSync7,
   rmSync as rmSync7,
   statSync as statSync19,
   writeFileSync as writeFileSync5
 } from "node:fs";
-import { tmpdir as tmpdir4 } from "node:os";
-import { join as join29 } from "node:path";
+import { tmpdir as tmpdir5 } from "node:os";
+import { join as join31 } from "node:path";
 function openCodeAdapter(adapters) {
   return adapters.find((adapter) => adapter.kind === "opencode");
 }
@@ -19132,9 +19682,11 @@ async function runDoctor(options) {
       }
       if (opencodeSkew)
         log2.error(`  ${opencodeSkew.message} ${opencodeSkew.remediation}`);
-      const hostShell = hostShellDoctorLine(opencodeAdapter);
-      if (hostShell)
-        log2[hostShell.level](`  ${hostShell.text}`);
+      for (const hostTool of OPENCODE_HOST_TOOL_NAMES) {
+        const line = hostToolDoctorLine(opencodeAdapter, hostTool);
+        if (line)
+          log2[line.level](`  ${line.text}`);
+      }
     }
     const blockers = h.pluginLoad?.blockers ?? [];
     if (h.pluginRegistered && blockers.length > 0) {
@@ -19411,7 +19963,7 @@ function clearOldBinaries() {
     return result;
   }
   for (const version of stale) {
-    const dir = join29(info.path, version);
+    const dir = join31(info.path, version);
     let bytes = 0;
     try {
       bytes = statSync19(dir).isDirectory() ? dirSize(dir) : 0;
@@ -19434,34 +19986,35 @@ function clearOldBinaries() {
   }
   return result;
 }
-function hostShellDoctorLine(adapter) {
+function hostToolDoctorLine(adapter, hostTool) {
   if (!(adapter instanceof OpenCodeAdapter))
     return null;
-  const state = adapter.hostShellState();
+  const { disableEntry, aftTool } = OPENCODE_HOST_TOOLS[hostTool];
+  const state = adapter.hostToolState(hostTool);
   if (state === "not_applicable")
     return null;
   if (state === "disabled") {
     return {
       level: "info",
-      text: `OpenCode's own shell tool: disabled (${OPENCODE_HOST_SHELL_DISABLE_ENTRY} is set); agents use AFT's bash`
+      text: `OpenCode's own ${hostTool} tool: disabled (${disableEntry} is set); agents use AFT's ${aftTool}`
     };
   }
-  if (!adapter.aftBashEnabled()) {
+  if (!adapter.aftHostReplacementEnabled(hostTool)) {
     return {
       level: "info",
-      text: "OpenCode's own shell tool: enabled (AFT's bash is disabled, so it stays)"
+      text: `OpenCode's own ${hostTool} tool: enabled (AFT's ${aftTool} is disabled, so it stays)`
     };
   }
   return {
     level: "warn",
-    text: `OpenCode's own shell tool: enabled beside AFT's bash — run \`${CLI} doctor --fix\` or \`${CLI} setup\` to disable it (${OPENCODE_HOST_SHELL_DISABLE_ENTRY})`
+    text: `OpenCode's own ${hostTool} tool: enabled beside AFT's ${aftTool} — run \`${CLI} doctor --fix\` or \`${CLI} setup\` to disable it (${disableEntry})`
   };
 }
-function hostShellFixTarget(adapters) {
+function hostToolFixTargets(adapters) {
   const adapter = openCodeAdapter(adapters);
   if (!(adapter instanceof OpenCodeAdapter))
-    return null;
-  return adapter.hostShellState() === "enabled" && adapter.aftBashEnabled() ? adapter : null;
+    return [];
+  return OPENCODE_HOST_TOOL_NAMES.filter((hostTool) => adapter.hostToolState(hostTool) === "enabled" && adapter.aftHostReplacementEnabled(hostTool)).map((hostTool) => ({ adapter, hostTool }));
 }
 function findPluginUpdateTargets(adapters, report) {
   const adaptersByKind = new Map(adapters.map((a) => [a.kind, a]));
@@ -19570,7 +20123,7 @@ async function runDoctorNpmInstall(npm, installDir) {
   });
 }
 function installedPluginVersion(installDir) {
-  const manifest = join29(installDir, "node_modules", ...AFT_OPENCODE_PACKAGE.split("/"), "package.json");
+  const manifest = join31(installDir, "node_modules", ...AFT_OPENCODE_PACKAGE.split("/"), "package.json");
   try {
     const pkg = JSON.parse(readFileSync17(manifest, "utf-8"));
     return typeof pkg.version === "string" ? pkg.version : null;
@@ -19692,11 +20245,11 @@ function buildDoctorFixPlan(adapters, report) {
       message: `Will ${hasTuiEntry ? "update" : "add"} ${adapter.pluginEntryWithVersion} ${hasTuiEntry ? "in" : "to"} ${harness.configPaths.tuiConfig} (TUI sidebar)`
     });
   }
-  const hostShellTarget = hostShellFixTarget(adapters);
-  if (hostShellTarget) {
+  for (const { adapter, hostTool } of hostToolFixTargets(adapters)) {
+    const { disableEntry, aftTool } = OPENCODE_HOST_TOOLS[hostTool];
     items.push({
       kind: "plugin",
-      message: `Will add ${OPENCODE_HOST_SHELL_DISABLE_ENTRY} to ${hostShellTarget.detectConfigPaths().harnessConfig} so agents use AFT's bash instead of OpenCode's own shell tool`
+      message: `Will add ${disableEntry} to ${adapter.detectConfigPaths().harnessConfig} so agents use AFT's ${aftTool} instead of OpenCode's own ${hostTool} tool`
     });
   }
   for (const target of findPluginUpdateTargets(adapters, report)) {
@@ -19844,9 +20397,8 @@ async function runFixFlow(argv, detectOpenCodeHost, resolveAdapters = resolveAda
     }
   }
   const pluginEntrySummary = configWritesRefused ? { changed: 0, errors: 0 } : await fixPluginEntries(adapters);
-  const hostShellTarget = configWritesRefused ? null : hostShellFixTarget(adapters);
-  if (hostShellTarget) {
-    const result = hostShellTarget.setHostShellDisabled(true);
+  for (const { adapter, hostTool } of configWritesRefused ? [] : hostToolFixTargets(adapters)) {
+    const result = adapter.setHostToolDisabled(hostTool, true);
     if (result.ok) {
       if (result.action !== "already_present")
         log2.success(`OpenCode: ${result.message}`);
@@ -20205,14 +20757,14 @@ function deriveIssueTitleFromBody(body) {
 function writeIssueReviewFile(body) {
   let reviewDir = null;
   try {
-    reviewDir = mkdtempSync2(join29(tmpdir4(), "aft-issue-"));
+    reviewDir = mkdtempSync2(join31(tmpdir5(), "aft-issue-"));
     if (process.platform !== "win32") {
       chmodSync3(reviewDir, 448);
     }
-    const outPath = join29(reviewDir, "issue.md");
+    const outPath = join31(reviewDir, "issue.md");
     writeFileSync5(outPath, `${body}
 `, { encoding: "utf8", mode: 384, flag: "wx" });
-    return { path: outPath, realPath: realpathSync6(outPath) };
+    return { path: outPath, realPath: realpathSync7(outPath) };
   } catch (err) {
     if (reviewDir) {
       try {
@@ -20225,7 +20777,7 @@ function writeIssueReviewFile(body) {
 }
 function readReviewedIssueFile(reviewFile) {
   try {
-    const realPath = realpathSync6(reviewFile.path);
+    const realPath = realpathSync7(reviewFile.path);
     if (realPath !== reviewFile.realPath) {
       log2.error(`Review file path changed before filing; refusing to read ${reviewFile.path}.`);
       return null;
@@ -20438,24 +20990,24 @@ var init_doctor = __esm(async () => {
 // src/commands/lsp.ts
 import { existsSync as existsSync31, readdirSync as readdirSync13, statSync as statSync20 } from "node:fs";
 import { createRequire as createRequire5 } from "node:module";
-import { dirname as dirname11, join as join30, resolve as resolve13 } from "node:path";
+import { dirname as dirname12, join as join32, resolve as resolve15 } from "node:path";
 function findProjectRootForFile(filePath, fallbackCwd = process.cwd()) {
-  const resolvedFile = resolve13(fallbackCwd, filePath);
-  let dir = dirname11(resolvedFile);
+  const resolvedFile = resolve15(fallbackCwd, filePath);
+  let dir = dirname12(resolvedFile);
   try {
     if (existsSync31(resolvedFile) && statSync20(resolvedFile).isDirectory()) {
       dir = resolvedFile;
     }
   } catch {
-    dir = dirname11(resolvedFile);
+    dir = dirname12(resolvedFile);
   }
   while (true) {
-    if (PROJECT_ROOT_MARKERS.some((marker) => existsSync31(join30(dir, marker)))) {
+    if (PROJECT_ROOT_MARKERS.some((marker) => existsSync31(join32(dir, marker)))) {
       return dir;
     }
-    const parent = dirname11(dir);
+    const parent = dirname12(dir);
     if (parent === dir)
-      return resolve13(fallbackCwd);
+      return resolve15(fallbackCwd);
     dir = parent;
   }
 }
@@ -20486,7 +21038,7 @@ async function runLspDoctor(options) {
     log2.error("Could not find the aft binary in the cache, platform package, PATH, or ~/.cargo/bin.");
     return 1;
   }
-  const resolvedFile = resolve13(file);
+  const resolvedFile = resolve15(file);
   const projectRoot = findProjectRootForFile(resolvedFile);
   const config = buildConfigureParams(adapter, projectRoot);
   const inspectRequest = {
@@ -20599,10 +21151,10 @@ function buildConfigureParams(adapter, projectRoot) {
 function inferLspPathsExtra(_lsp) {
   const paths = new Set;
   for (const entry of childDirs(getAftLspPackagesDir())) {
-    paths.add(join30(entry, "node_modules", ".bin"));
+    paths.add(join32(entry, "node_modules", ".bin"));
   }
   for (const entry of childDirs(getAftLspBinariesDir())) {
-    paths.add(join30(entry, "bin"));
+    paths.add(join32(entry, "bin"));
   }
   return [...paths];
 }
@@ -20610,7 +21162,7 @@ function childDirs(path) {
   if (!existsSync31(path))
     return [];
   try {
-    return readdirSync13(path).map((entry) => join30(path, entry)).filter((entry) => {
+    return readdirSync13(path).map((entry) => join32(path, entry)).filter((entry) => {
       try {
         return statSync20(entry).isDirectory();
       } catch {
@@ -20622,11 +21174,13 @@ function childDirs(path) {
   }
 }
 function formatBinary(server) {
+  const names = server.binary_names?.length ? server.binary_names : [server.binary_name];
+  const alternatives = names.length > 1 ? `; candidates: ${names.join(" or ")}` : "";
   if (!server.binary_path) {
     const locations = server.kind === "python" || server.kind === "ty" ? "workspace virtualenv, node_modules/.bin, lsp_paths_extra, or PATH" : "node_modules/.bin, lsp_paths_extra, or PATH";
-    return `${server.binary_name} (NOT FOUND in ${locations})`;
+    return `${names.join(" or ")} (NOT FOUND in ${locations})`;
   }
-  return `${server.binary_path} (found via ${server.binary_source})`;
+  return `${server.binary_path} (found via ${server.binary_source}${alternatives})`;
 }
 function formatWorkspaceRoot(server) {
   if (!server.workspace_root) {
@@ -20652,7 +21206,7 @@ function typescriptPackageWarning(response) {
   if (!typescriptServerSpawned || !response.project_root || diagnosticsCount > 0)
     return null;
   try {
-    createRequire5(join30(response.project_root, "package.json")).resolve("typescript");
+    createRequire5(join32(response.project_root, "package.json")).resolve("typescript");
     return null;
   } catch {
     return "typescript package not resolvable from project — server will produce no diagnostics";
@@ -20693,8 +21247,7 @@ var init_lsp = __esm(async () => {
 
 // src/commands/doctor-filters.ts
 import { existsSync as existsSync32 } from "node:fs";
-import { homedir as homedir17 } from "node:os";
-import { relative as relative3, resolve as resolve14 } from "node:path";
+import { relative as relative5, resolve as resolve16 } from "node:path";
 function printDoctorFiltersHelp() {
   console.log(`Usage: ${CLI} doctor filters [--show <name>] [trust|untrust]`);
   console.log("");
@@ -20729,7 +21282,7 @@ async function runDoctorFilters(options) {
     log2.error("Could not find the aft binary in the cache, platform package, PATH, or ~/.cargo/bin.");
     return 1;
   }
-  const projectRoot = resolve14(process.cwd());
+  const projectRoot = resolve16(process.cwd());
   const list = await listFilters(binary, adapter, projectRoot, options.sendRequests ?? sendAftRequests);
   if (!list.success) {
     log2.error(list.message ?? list.code ?? "list_filters failed");
@@ -20911,14 +21464,13 @@ function truncate(value) {
   return value.length <= 80 ? value : `${value.slice(0, 77)}…`;
 }
 function formatHome(path) {
-  const home = homedir17();
-  return path.startsWith(home) ? `~${path.slice(home.length)}` : path;
+  return shortenHomePath(path);
 }
 function formatProjectPath(path, projectRoot) {
   if (!path)
     return "";
-  const rel = relative3(projectRoot, path);
-  return rel.startsWith("..") || rel === "" ? path : `./${rel}`;
+  const rel = relative5(projectRoot, path);
+  return relativePathEscapesRoot(rel) || rel === "" ? path : `./${rel}`;
 }
 function formatSourcePath(path, projectRoot) {
   if (!path)
@@ -20926,6 +21478,7 @@ function formatSourcePath(path, projectRoot) {
   return formatProjectPath(path, projectRoot);
 }
 var init_doctor_filters = __esm(async () => {
+  init_dist2();
   init_aft_bridge();
   init_harness_select();
   init_prompts();
@@ -20949,6 +21502,7 @@ function printHelp() {
   console.log("    setup --answers <file>  Save feature choices from an answers file");
   console.log("    index            Build one configured index snapshot (no scheduler)");
   console.log("    backups purge    Remove undo backups by --path and/or --session (dry run unless --yes)");
+  console.log("    cache prune-legacy  Delete legacy index caches past their rollback window (dry run unless --yes)");
   console.log("    doctor           Check and fix configuration issues");
   console.log("    doctor --profile [seconds]  Profile a running AFT daemon");
   console.log("    doctor lsp <file> Inspect LSP setup for one file");
@@ -20969,6 +21523,7 @@ function printHelp() {
   console.log(`    ${CLI} setup`);
   console.log(`    ${CLI} index`);
   console.log(`    ${CLI} backups purge --path ./build --yes`);
+  console.log(`    ${CLI} cache prune-legacy`);
   console.log(`    ${CLI} doctor`);
   console.log(`    ${CLI} doctor --profile 4`);
   console.log(`    ${CLI} doctor lsp ./src/main.py`);
@@ -20994,6 +21549,10 @@ async function main() {
     await init_backups();
     return runBackups(args);
   }
+  if (command === "cache") {
+    await init_cache();
+    return runCache(args);
+  }
   if (command === "doctor") {
     if (args.includes("--profile")) {
       await init_doctor();