@cortexkit/aft 0.53.0 → 0.55.0

package/dist/index.js

@@ -517,8 +517,65 @@ var CONFLICT_HINT = `
 [Hint] Use aft_conflicts to see all conflict regions across files in a single call.`, GREP_SEARCH_AFT_SEARCH_HINT = "DO NOT search code by running grep/rg in bash — it is unindexed, unranked, and serial. Use the `aft_search` tool instead (it auto-routes concepts, identifiers, regex, and literals).", GREP_SEARCH_GREP_HINT = "DO NOT search code by running grep/rg in bash — it is unindexed, unranked, and serial. Use the `grep` tool instead (indexed and ranked).", GREP_SEARCH_HINT_PREFIX = "DO NOT search code by running grep/rg in bash —", GREP_SEARCH_FRESHNESS_WINDOW_MS = 60000;
 var init_bash_hints = () => {};
 
+// ../aft-bridge/dist/storage-paths.js
+import { homedir as homedir2 } from "node:os";
+import { join as join2, resolve as resolve2 } from "node:path";
+function homeDir() {
+  if (process.platform === "win32")
+    return process.env.USERPROFILE || process.env.HOME || homedir2();
+  return process.env.HOME || homedir2();
+}
+function dataHome() {
+  const xdg = process.env.XDG_DATA_HOME;
+  if (xdg)
+    return xdg;
+  if (process.platform === "win32") {
+    return process.env.LOCALAPPDATA || process.env.APPDATA || join2(homeDir(), "AppData", "Local");
+  }
+  return join2(homeDir(), ".local", "share");
+}
+function resolveStoragePath(raw) {
+  let expanded = raw;
+  if (raw === "~") {
+    expanded = homeDir();
+  } else if (raw.startsWith("~/") || raw.startsWith("~\\")) {
+    expanded = join2(homeDir(), raw.slice(2));
+  }
+  return resolve2(expanded);
+}
+function resolveCortexKitStorageRoot() {
+  const override = process.env.AFT_STORAGE_DIR;
+  if (override)
+    return resolveStoragePath(override);
+  return resolveStoragePath(join2(dataHome(), "cortexkit", "aft"));
+}
+function resolveAftStorageRoot(configuredRoot) {
+  if (process.env.AFT_STORAGE_DIR)
+    return resolveCortexKitStorageRoot();
+  if (configuredRoot)
+    return configuredRoot;
+  return resolveCortexKitStorageRoot();
+}
+function resolveAftLogPath(filename, configuredRoot) {
+  return join2(resolveAftStorageRoot(configuredRoot), "logs", filename);
+}
+var init_storage_paths = () => {};
+
 // ../aft-bridge/dist/bash-host-fallback.js
 import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { delimiter, join as join3 } from "node:path";
+function hostFallbackPathWithShims(env) {
+  const storageRoot = env.AFT_STORAGE_DIR ? resolveStoragePath(env.AFT_STORAGE_DIR) : resolveCortexKitStorageRoot();
+  const shimsDir = join3(storageRoot, "shims");
+  if (!existsSync(join3(shimsDir, "gh")))
+    return env.PATH;
+  const inherited = env.PATH ?? "";
+  const entries = inherited.split(delimiter).filter((entry) => entry.length > 0);
+  if (entries[0] === shimsDir)
+    return inherited;
+  return [shimsDir, ...entries.filter((entry) => entry !== shimsDir)].join(delimiter);
+}
 function bashHostFallbackAskPattern(command, cwd) {
   return `AFT UNAVAILABLE - host fallback execution:
 
@@ -551,11 +608,17 @@ async function runBashHostFallback(options) {
   if (options.signal?.aborted) {
     throw new DOMException("The host fallback command was aborted", "AbortError");
   }
-  return await new Promise((resolve2, reject) => {
+  return await new Promise((resolve3, reject) => {
     const child = spawn(options.command, {
       cwd: options.projectRoot,
       shell: true,
-      env: { ...process.env, ...options.env },
+      env: (() => {
+        const merged = { ...process.env, ...options.env };
+        const path2 = hostFallbackPathWithShims(merged);
+        if (path2 !== undefined)
+          merged.PATH = path2;
+        return merged;
+      })(),
       stdio: ["ignore", "pipe", "pipe"],
       detached: process.platform !== "win32",
       windowsHide: true
@@ -618,7 +681,7 @@ async function runBashHostFallback(options) {
         return;
       }
       const exitCode = timedOut ? 124 : code ?? 1;
-      resolve2({
+      resolve3({
         success: true,
         output: renderOutput(Buffer.concat(chunks), exitCode),
         exit_code: exitCode,
@@ -629,6 +692,7 @@ async function runBashHostFallback(options) {
 }
 var BASH_HOST_FALLBACK_BANNER = "[AFT host fallback - module transport down; no rewrites/compression/background]", BASH_HOST_FALLBACK_MAX_OUTPUT_BYTES, BASH_HOST_FALLBACK_MAX_TIMEOUT_MS, BASH_HOST_FALLBACK_REFUSAL = "AFT transport is down; only foreground execution is available in host fallback";
 var init_bash_host_fallback = __esm(() => {
+  init_storage_paths();
   BASH_HOST_FALLBACK_MAX_OUTPUT_BYTES = 100 * 1024;
   BASH_HOST_FALLBACK_MAX_TIMEOUT_MS = 10 * 60 * 1000;
 });
@@ -670,8 +734,8 @@ var init_command_timeouts = __esm(() => {
 import { spawn as spawn2 } from "node:child_process";
 import { createHash } from "node:crypto";
 import { readFileSync } from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import { join as join2 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+import { join as join4 } from "node:path";
 import { StringDecoder } from "node:string_decoder";
 function isTerminalBashStatus(status) {
   return typeof status === "string" && TERMINAL_BASH_STATUSES.has(status);
@@ -1046,6 +1110,21 @@ var init_bridge = __esm(() => {
       }
       return this.sendWithVersionMismatchRetry(command, dispatchParams, options, true);
     }
+    listenForRequestAbort(requestId, signal) {
+      if (!signal)
+        return () => {};
+      let fired = false;
+      const onAbort = () => {
+        if (fired)
+          return;
+        fired = true;
+        this.send("cancel_request", { id: requestId }, { keepBridgeOnTimeout: true }).catch(() => {});
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+      if (signal.aborted)
+        onAbort();
+      return () => signal.removeEventListener("abort", onAbort);
+    }
     async toolCall(sessionId, name, rawArgs = {}, options) {
       const params = { name, arguments: rawArgs };
       if (sessionId)
@@ -1068,7 +1147,7 @@ var init_bridge = __esm(() => {
         if (this._shuttingDown) {
           throw new BridgeTransportUnavailableError(`${this.errorPrefix} Bridge is shutting down, cannot send "${command}"`);
         }
-        if (Object.hasOwn(params, "id")) {
+        if (Object.hasOwn(params, "id") && command !== "cancel_request") {
           throw new Error("params cannot contain reserved key 'id'");
         }
         const requestSessionId = typeof params.session_id === "string" && params.session_id.length > 0 ? params.session_id : undefined;
@@ -1122,7 +1201,7 @@ var init_bridge = __esm(() => {
         }
         const id = String(this.nextId++);
         let request;
-        if (Object.hasOwn(params, "command") || Object.hasOwn(params, "method")) {
+        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"]) {
@@ -1140,13 +1219,14 @@ var init_bridge = __esm(() => {
         const keepBridgeOnTimeout = passive || options?.keepBridgeOnTimeout === true;
         let requestSentAt = Date.now();
         const child = this.process;
-        const response = await new Promise((resolve2, reject) => {
+        const response = await new Promise((resolve3, reject) => {
           const timer = setTimeout(() => {
-            const entry = this.pending.get(id);
-            if (!entry)
+            const entry2 = this.pending.get(id);
+            if (!entry2)
               return;
             this.pending.delete(id);
-            clearTimeout(entry.timer);
+            clearTimeout(entry2.timer);
+            entry2.onSettled?.();
             if (keepBridgeOnTimeout) {
               const timeoutMsg2 = `Request "${command}" (id=${id}) timed out after ${effectiveTimeoutMs}ms`;
               if (requestSessionId) {
@@ -1154,7 +1234,7 @@ var init_bridge = __esm(() => {
               } else {
                 this.warnVia(timeoutMsg2);
               }
-              entry.reject(new BridgeTransportTimeoutError(command, effectiveTimeoutMs, `${this.errorPrefix} Request "${command}" (id=${id}) timed out after ${effectiveTimeoutMs}ms`));
+              entry2.reject(new BridgeTransportTimeoutError(command, effectiveTimeoutMs, `${this.errorPrefix} Request "${command}" (id=${id}) timed out after ${effectiveTimeoutMs}ms`));
               return;
             }
             const childActiveSinceRequest = this.lastChildActivityAt > requestSentAt;
@@ -1169,13 +1249,20 @@ 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`));
+              entry2.reject(new Error(`${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`));
+            entry2.reject(new Error(`${this.errorPrefix} Request "${command}" (id=${id}) timed out after ${effectiveTimeoutMs}ms`));
             this.handleTimeout(requestSessionId);
           }, effectiveTimeoutMs);
-          this.pending.set(id, { resolve: resolve2, reject, timer, onProgress: options?.onProgress, command });
+          const entry = {
+            resolve: resolve3,
+            reject,
+            timer,
+            onProgress: options?.onProgress,
+            command
+          };
+          this.pending.set(id, entry);
           if (!child?.stdin?.writable) {
             this.pending.delete(id);
             clearTimeout(timer);
@@ -1189,11 +1276,12 @@ var init_bridge = __esm(() => {
           const handleWriteFailure = (cause) => {
             const writeError = cause instanceof Error ? cause : new Error(String(cause));
             const error2 = new BridgeTransportUnknownOutcomeError(`${this.errorPrefix} Failed to write to stdin: ${writeError.message}`, { cause: writeError });
-            const entry = this.pending.get(id);
-            if (entry) {
+            const entry2 = this.pending.get(id);
+            if (entry2) {
               this.pending.delete(id);
-              clearTimeout(entry.timer);
-              entry.reject(error2);
+              clearTimeout(entry2.timer);
+              entry2.onSettled?.();
+              entry2.reject(error2);
             }
             if (this.process === child)
               this.invalidateTransportProcess(error2);
@@ -1206,6 +1294,9 @@ var init_bridge = __esm(() => {
           } catch (err) {
             handleWriteFailure(err);
           }
+          if (this.pending.has(id)) {
+            entry.onSettled = this.listenForRequestAbort(id, options?.abortSignal);
+          }
         });
         if (command === "configure" && response.success === true && options?.markConfiguredOnSuccess !== false) {
           this.configured = true;
@@ -1293,15 +1384,15 @@ var init_bridge = __esm(() => {
       if (this.process) {
         const proc = this.process;
         this.process = null;
-        return new Promise((resolve2) => {
+        return new Promise((resolve3) => {
           const forceKillTimer = setTimeout(() => {
             proc.kill("SIGKILL");
-            resolve2();
+            resolve3();
           }, 5000);
           proc.once("exit", () => {
             clearTimeout(forceKillTimer);
             this.logVia("Process exited during shutdown");
-            resolve2();
+            resolve3();
           });
           proc.kill("SIGTERM");
         });
@@ -1349,15 +1440,15 @@ var init_bridge = __esm(() => {
         return;
       const proc = this.process;
       this.process = null;
-      await new Promise((resolve2) => {
+      await new Promise((resolve3) => {
         const forceKillTimer = setTimeout(() => {
           proc.kill("SIGKILL");
-          resolve2();
+          resolve3();
         }, 5000);
         proc.once("exit", () => {
           clearTimeout(forceKillTimer);
           this.logVia("Process exited during coordinated binary replacement");
-          resolve2();
+          resolve3();
         });
         proc.kill("SIGTERM");
       });
@@ -1387,7 +1478,7 @@ 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, process.platform === "win32" ? "onnxruntime.dll" : process.platform === "darwin" ? "libonnxruntime.dylib" : "libonnxruntime.so");
+      const ortLibraryPath = ortDir == null ? null : join4(ortDir, process.platform === "win32" ? "onnxruntime.dll" : process.platform === "darwin" ? "libonnxruntime.dylib" : "libonnxruntime.so");
       const envPath = process.platform === "win32" && ortDir ? `${ortDir};${process.env.PATH ?? ""}` : process.env.PATH;
       const env = {
         ...process.env,
@@ -1395,7 +1486,7 @@ var init_bridge = __esm(() => {
       };
       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" ? join4(this.configOverrides.storage_dir, "semantic", "models") : join4(homedir3() || "", ".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) {
@@ -1574,6 +1665,7 @@ var init_bridge = __esm(() => {
           if (requestId && entry) {
             this.pending.delete(requestId);
             clearTimeout(entry.timer);
+            entry.onSettled?.();
             entry.resolve({
               success: false,
               code: "permission_required",
@@ -1615,6 +1707,7 @@ var init_bridge = __esm(() => {
             return;
           this.pending.delete(id);
           clearTimeout(entry.timer);
+          entry.onSettled?.();
           this.consecutiveRequestTimeouts = 0;
           this.scheduleRestartCountReset();
           this.accountForBashTaskResponse(entry.command, response);
@@ -1705,6 +1798,7 @@ var init_bridge = __esm(() => {
     rejectAllPending(error2) {
       for (const [_id, entry] of this.pending) {
         clearTimeout(entry.timer);
+        entry.onSettled?.();
         entry.reject(error2);
       }
       this.pending.clear();
@@ -1726,34 +1820,40 @@ var init_bridge = __esm(() => {
 });
 
 // ../aft-bridge/dist/cache-paths.js
-import { homedir as homedir3 } from "node:os";
-import { join as join3 } from "node:path";
-function homeDir(env) {
-  return (process.platform === "win32" ? env.USERPROFILE || env.HOME : env.HOME) || homedir3();
+import { homedir as homedir4 } from "node:os";
+import { join as join5 } from "node:path";
+function homeDir2(env) {
+  return (process.platform === "win32" ? env.USERPROFILE || env.HOME : env.HOME) || homedir4();
+}
+function getOpenCodeCacheRoot(env = process.env, home = homedir4()) {
+  return join5(env.XDG_CACHE_HOME || join5(home, ".cache"), "opencode");
+}
+function getOpenCodeConfigRoot(env = process.env, home = homedir4()) {
+  return join5(env.XDG_CONFIG_HOME || join5(home, ".config"), "opencode");
 }
 function getAftCacheRoot(env = process.env) {
   if (env.AFT_CACHE_DIR)
     return env.AFT_CACHE_DIR;
   if (process.platform === "win32") {
-    const base2 = env.LOCALAPPDATA || env.APPDATA || join3(homeDir(env), "AppData", "Local");
-    return join3(base2, "aft");
+    const base2 = env.LOCALAPPDATA || env.APPDATA || join5(homeDir2(env), "AppData", "Local");
+    return join5(base2, "aft");
   }
-  const base = env.XDG_CACHE_HOME || join3(homeDir(env), ".cache");
-  return join3(base, "aft");
+  const base = env.XDG_CACHE_HOME || join5(homeDir2(env), ".cache");
+  return join5(base, "aft");
 }
 function getAftBinaryCacheDir(env = process.env) {
-  return join3(getAftCacheRoot(env), "bin");
+  return join5(getAftCacheRoot(env), "bin");
 }
 function getAftLspPackagesDir(env = process.env) {
-  return join3(getAftCacheRoot(env), "lsp-packages");
+  return join5(getAftCacheRoot(env), "lsp-packages");
 }
 function getAftLspBinariesDir(env = process.env) {
-  return join3(getAftCacheRoot(env), "lsp-binaries");
+  return join5(getAftCacheRoot(env), "lsp-binaries");
 }
 var init_cache_paths = () => {};
 
 // ../aft-bridge/dist/callgraph-format.js
-import { homedir as homedir4 } from "node:os";
+import { homedir as homedir5 } from "node:os";
 function asRecord(value) {
   if (!value || typeof value !== "object" || Array.isArray(value))
     return;
@@ -1772,7 +1872,7 @@ function asBoolean(value) {
   return typeof value === "boolean" ? value : undefined;
 }
 function shortenPath(path2) {
-  const home = homedir4();
+  const home = homedir5();
   if (path2.startsWith(home))
     return `~${path2.slice(home.length)}`;
   return path2;
@@ -2140,26 +2240,26 @@ var init_config_keys = __esm(() => {
 });
 
 // ../aft-bridge/dist/config-tiers.js
-import { existsSync, readFileSync as readFileSync2 } from "node:fs";
-import { resolve as resolve2 } from "node:path";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { resolve as resolve3 } from "node:path";
 function readConfigTiers(opts) {
   const tiers = [];
   try {
-    if (existsSync(opts.userConfigPath)) {
+    if (existsSync2(opts.userConfigPath)) {
       const doc = readFileSync2(opts.userConfigPath, "utf-8");
       tiers.push({
         tier: "user",
-        source: resolve2(opts.userConfigPath),
+        source: resolve3(opts.userConfigPath),
         doc
       });
     }
   } catch {}
   try {
-    if (existsSync(opts.projectConfigPath)) {
+    if (existsSync2(opts.projectConfigPath)) {
       const doc = readFileSync2(opts.projectConfigPath, "utf-8");
       tiers.push({
         tier: "project",
-        source: resolve2(opts.projectConfigPath),
+        source: resolve3(opts.projectConfigPath),
         doc
       });
     }
@@ -2198,9 +2298,9 @@ var init_platform = __esm(() => {
 // ../aft-bridge/dist/downloader.js
 import { spawnSync } from "node:child_process";
 import { createHash as createHash2, randomUUID } from "node:crypto";
-import { chmodSync, closeSync, copyFileSync, createWriteStream, existsSync as existsSync2, mkdirSync, openSync, readdirSync, readFileSync as readFileSync3, renameSync, rmSync, statSync as statSync2, unlinkSync, writeSync } from "node:fs";
+import { chmodSync, closeSync, copyFileSync, createWriteStream, existsSync as existsSync3, mkdirSync, openSync, readdirSync, readFileSync as readFileSync3, renameSync, rmSync, statSync as statSync2, unlinkSync, writeSync } from "node:fs";
 import { hostname } from "node:os";
-import { join as join4 } from "node:path";
+import { join as join6 } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 function readBinaryVersion(binaryPath) {
@@ -2237,8 +2337,8 @@ function getBinaryName() {
 function getCachedBinaryPath(version) {
   if (!version)
     return null;
-  const binaryPath = join4(getAftBinaryCacheDir(), version, getBinaryName());
-  return existsSync2(binaryPath) ? binaryPath : null;
+  const binaryPath = join6(getAftBinaryCacheDir(), version, getBinaryName());
+  return existsSync3(binaryPath) ? binaryPath : null;
 }
 async function downloadBinary(version) {
   const archMap = PLATFORM_ARCH_MAP[process.platform] ?? {};
@@ -2254,16 +2354,16 @@ async function downloadBinary(version) {
     return null;
   }
   const tag = rawTag.startsWith("v") ? rawTag : `v${rawTag}`;
-  const versionedCacheDir = join4(getAftBinaryCacheDir(), tag);
+  const versionedCacheDir = join6(getAftBinaryCacheDir(), tag);
   const binaryName = getBinaryName();
-  const binaryPath = join4(versionedCacheDir, binaryName);
-  if (existsSync2(binaryPath) && isExpectedCachedBinary(binaryPath, tag)) {
+  const binaryPath = join6(versionedCacheDir, binaryName);
+  if (existsSync3(binaryPath) && 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 = join4(versionedCacheDir, ".download.lock");
+  const lockPath = join6(versionedCacheDir, ".download.lock");
   let releaseLock = null;
   let binaryController = null;
   let checksumController = null;
@@ -2272,7 +2372,7 @@ async function downloadBinary(version) {
   const tmpPath = `${binaryPath}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`;
   const cleanUpPartialDownload = () => {
     try {
-      if (existsSync2(tmpPath))
+      if (existsSync3(tmpPath))
         unlinkSync(tmpPath);
     } catch {}
   };
@@ -2296,12 +2396,12 @@ async function downloadBinary(version) {
   process.once("SIGINT", handleSigint);
   process.once("exit", handleExit);
   try {
-    if (!existsSync2(versionedCacheDir)) {
+    if (!existsSync3(versionedCacheDir)) {
       mkdirSync(versionedCacheDir, { recursive: true });
     }
     releaseLock = await acquireDownloadLock(lockPath);
     sweepStaleDownloadTemps(versionedCacheDir, binaryName);
-    if (existsSync2(binaryPath) && isExpectedCachedBinary(binaryPath, tag)) {
+    if (existsSync3(binaryPath) && isExpectedCachedBinary(binaryPath, tag)) {
       return binaryPath;
     }
     binaryController = new AbortController;
@@ -2366,7 +2466,7 @@ async function downloadBinary(version) {
       renameSync(tmpPath, binaryPath);
     }
     try {
-      if (existsSync2(tmpPath))
+      if (existsSync3(tmpPath))
         unlinkSync(tmpPath);
     } catch {
       warn(`Could not clean up temporary download file ${tmpPath} — it can be removed manually.`);
@@ -2481,7 +2581,7 @@ function sweepStaleDownloadTemps(versionedCacheDir, binaryName) {
       if (!entry.isFile() || !entry.name.startsWith(tempPrefix) || !entry.name.endsWith(".tmp")) {
         continue;
       }
-      const tempPath = join4(versionedCacheDir, entry.name);
+      const tempPath = join6(versionedCacheDir, entry.name);
       const ageMs = Date.now() - statSync2(tempPath).mtimeMs;
       if (Math.abs(ageMs) > DOWNLOAD_LOCK_STALE_MS)
         unlinkSync(tempPath);
@@ -2530,7 +2630,7 @@ async function acquireDownloadLock(lockPath, timing = {}) {
       if (Date.now() - startedAt > timeoutMs) {
         throw new Error(`Timed out waiting for download lock: ${lockPath}`);
       }
-      await new Promise((resolve3) => setTimeout(resolve3, pollIntervalMs));
+      await new Promise((resolve4) => setTimeout(resolve4, pollIntervalMs));
     }
   }
 }
@@ -2577,50 +2677,6 @@ var init_downloader = __esm(() => {
   ensureBinaryInFlight = new Map;
 });
 
-// ../aft-bridge/dist/storage-paths.js
-import { homedir as homedir5 } from "node:os";
-import { join as join5, resolve as resolve3 } from "node:path";
-function homeDir2() {
-  if (process.platform === "win32")
-    return process.env.USERPROFILE || process.env.HOME || homedir5();
-  return process.env.HOME || homedir5();
-}
-function dataHome() {
-  const xdg = process.env.XDG_DATA_HOME;
-  if (xdg)
-    return xdg;
-  if (process.platform === "win32") {
-    return process.env.LOCALAPPDATA || process.env.APPDATA || join5(homeDir2(), "AppData", "Local");
-  }
-  return join5(homeDir2(), ".local", "share");
-}
-function resolveStoragePath(raw) {
-  let expanded = raw;
-  if (raw === "~") {
-    expanded = homeDir2();
-  } else if (raw.startsWith("~/") || raw.startsWith("~\\")) {
-    expanded = join5(homeDir2(), raw.slice(2));
-  }
-  return resolve3(expanded);
-}
-function resolveCortexKitStorageRoot() {
-  const override = process.env.AFT_STORAGE_DIR;
-  if (override)
-    return resolveStoragePath(override);
-  return resolveStoragePath(join5(dataHome(), "cortexkit", "aft"));
-}
-function resolveAftStorageRoot(configuredRoot) {
-  if (process.env.AFT_STORAGE_DIR)
-    return resolveCortexKitStorageRoot();
-  if (configuredRoot)
-    return configuredRoot;
-  return resolveCortexKitStorageRoot();
-}
-function resolveAftLogPath(filename, configuredRoot) {
-  return join5(resolveAftStorageRoot(configuredRoot), "logs", filename);
-}
-var init_storage_paths = () => {};
-
 // ../aft-bridge/dist/durable-log.js
 import { appendFile, mkdir, rename, rm, stat } from "node:fs/promises";
 import { dirname } from "node:path";
@@ -4720,7 +4776,7 @@ function projectRootKeyHash(dir) {
 var init_project_identity = () => {};
 
 // ../aft-bridge/dist/subc-transport.js
-import { existsSync as existsSync3, statSync as statSync3 } from "node:fs";
+import { existsSync as existsSync4, statSync as statSync3 } from "node:fs";
 function reconnectBackoffMs(attempt) {
   return Math.min(RECONNECT_RETRY_FLOOR_MS * 2 ** Math.min(attempt, 6), RECONNECT_RETRY_CAP_MS);
 }
@@ -5211,7 +5267,7 @@ class SubcTransportPool {
       this.dormantRoots.delete(root);
       return true;
     }
-    const reclaimedMarkerPresent = existsSync3(`${root}.reclaimed`);
+    const reclaimedMarkerPresent = existsSync4(`${root}.reclaimed`);
     if (reclaimedMarkerPresent) {
       this.markRootDormant(root);
       return false;
@@ -6121,9 +6177,9 @@ function stripJsoncSymbols(value) {
 }
 
 // ../aft-bridge/dist/paths.js
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync4, renameSync as renameSync2, writeFileSync } from "node:fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync4, renameSync as renameSync2, writeFileSync } from "node:fs";
 import { homedir as homedir6 } from "node:os";
-import { dirname as dirname2, isAbsolute as isAbsolute2, join as join6, resolve as resolve5 } from "node:path";
+import { dirname as dirname2, isAbsolute as isAbsolute2, join as join7, resolve as resolve5 } from "node:path";
 function homeDir3() {
   if (process.platform === "win32")
     return process.env.USERPROFILE || process.env.HOME || homedir6();
@@ -6133,16 +6189,16 @@ function configHome() {
   const xdg = process.env.XDG_CONFIG_HOME;
   if (xdg && isAbsolute2(xdg))
     return xdg;
-  return join6(homeDir3(), ".config");
+  return join7(homeDir3(), ".config");
 }
 function legacyOpenCodeConfigDir() {
   const envDir = process.env.OPENCODE_CONFIG_DIR?.trim();
   if (envDir)
     return resolve5(envDir);
-  return join6(configHome(), "opencode");
+  return join7(configHome(), "opencode");
 }
 function legacyPiAgentDir() {
-  return join6(homeDir3(), ".pi", "agent");
+  return join7(homeDir3(), ".pi", "agent");
 }
 function legacySources(basePath, label, harness) {
   return [
@@ -6151,10 +6207,10 @@ function legacySources(basePath, label, harness) {
   ];
 }
 function resolveCortexKitUserConfigPath() {
-  return join6(configHome(), "cortexkit", "aft.jsonc");
+  return join7(configHome(), "cortexkit", "aft.jsonc");
 }
 function resolveCortexKitProjectConfigPath(projectDirectory) {
-  return join6(projectDirectory, ".cortexkit", "aft.jsonc");
+  return join7(projectDirectory, ".cortexkit", "aft.jsonc");
 }
 function resolveCortexKitConfigPaths(projectDirectory) {
   return {
@@ -6165,22 +6221,22 @@ function resolveCortexKitConfigPaths(projectDirectory) {
 function resolveLegacyAftConfigSources(projectDirectory) {
   return {
     user: [
-      ...legacySources(join6(legacyOpenCodeConfigDir(), "aft"), "OpenCode user", "opencode"),
-      ...legacySources(join6(legacyPiAgentDir(), "aft"), "Pi user", "pi")
+      ...legacySources(join7(legacyOpenCodeConfigDir(), "aft"), "OpenCode user", "opencode"),
+      ...legacySources(join7(legacyPiAgentDir(), "aft"), "Pi user", "pi")
     ],
     project: [
-      ...legacySources(join6(projectDirectory, ".opencode", "aft"), "OpenCode project", "opencode"),
-      ...legacySources(join6(projectDirectory, ".pi", "aft"), "Pi project", "pi")
+      ...legacySources(join7(projectDirectory, ".opencode", "aft"), "OpenCode project", "opencode"),
+      ...legacySources(join7(projectDirectory, ".pi", "aft"), "Pi project", "pi")
     ]
   };
 }
 function resolveHarnessStoragePath(storageRoot, harness, ...segments) {
-  return join6(storageRoot, harness, ...segments);
+  return join7(storageRoot, harness, ...segments);
 }
 function repairRootScopedStorageFile(storageRoot, harness, fileName) {
   const harnessPath = resolveHarnessStoragePath(storageRoot, harness, fileName);
-  const rootPath = join6(storageRoot, fileName);
-  if (existsSync4(harnessPath) || !existsSync4(rootPath))
+  const rootPath = join7(storageRoot, fileName);
+  if (existsSync5(harnessPath) || !existsSync5(rootPath))
     return harnessPath;
   try {
     mkdirSync2(dirname2(harnessPath), { recursive: true });
@@ -6194,7 +6250,7 @@ function shouldShowAnnouncement(storageRoot, harness, currentVersion) {
   const versionFile = repairRootScopedStorageFile(storageRoot, harness, "last_announced_version");
   let lastVersion = "";
   try {
-    if (existsSync4(versionFile)) {
+    if (existsSync5(versionFile)) {
       lastVersion = readFileSync4(versionFile, "utf-8").trim();
     }
   } catch {
@@ -6267,10 +6323,10 @@ var init_paths = () => {};
 
 // ../aft-bridge/dist/resolver.js
 import { execSync } from "node:child_process";
-import { chmodSync as chmodSync2, closeSync as closeSync2, copyFileSync as copyFileSync2, existsSync as existsSync5, mkdirSync as mkdirSync3, openSync as openSync2, readSync, renameSync as renameSync3, unlinkSync as unlinkSync2 } from "node:fs";
+import { chmodSync as chmodSync2, closeSync as closeSync2, copyFileSync as copyFileSync2, existsSync as existsSync6, mkdirSync as mkdirSync3, openSync as openSync2, readSync, renameSync as renameSync3, unlinkSync as unlinkSync2 } from "node:fs";
 import { createRequire } from "node:module";
 import { homedir as homedir7 } from "node:os";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 function copyToVersionedCache(npmBinaryPath, knownVersion) {
   try {
     const version = knownVersion ?? readBinaryVersion(npmBinaryPath);
@@ -6278,10 +6334,10 @@ function copyToVersionedCache(npmBinaryPath, knownVersion) {
       return null;
     const tag = version.startsWith("v") ? version : `v${version}`;
     const cacheDir = getAftBinaryCacheDir();
-    const versionedDir = join7(cacheDir, tag);
+    const versionedDir = join8(cacheDir, tag);
     const ext = process.platform === "win32" ? ".exe" : "";
-    const cachedPath = join7(versionedDir, `aft${ext}`);
-    if (existsSync5(cachedPath)) {
+    const cachedPath = join8(versionedDir, `aft${ext}`);
+    if (existsSync6(cachedPath)) {
       const cachedVersion = readBinaryVersion(cachedPath);
       if (cachedVersion === version)
         return cachedPath;
@@ -6293,7 +6349,7 @@ function copyToVersionedCache(npmBinaryPath, knownVersion) {
     if (process.platform !== "win32") {
       chmodSync2(tmpPath, 493);
     }
-    if (process.platform === "win32" && existsSync5(cachedPath)) {
+    if (process.platform === "win32" && existsSync6(cachedPath)) {
       try {
         unlinkSync2(cachedPath);
       } catch {}
@@ -6313,8 +6369,8 @@ function homeDirFromEnv(env) {
   return (process.platform === "win32" ? env.USERPROFILE || env.HOME : env.HOME) || homedir7();
 }
 function cachedBinaryPathFromEnv(version, env, ext) {
-  const binaryPath = join7(getAftBinaryCacheDir(env), version, `aft${ext}`);
-  return existsSync5(binaryPath) ? binaryPath : null;
+  const binaryPath = join8(getAftBinaryCacheDir(env), version, `aft${ext}`);
+  return existsSync6(binaryPath) ? binaryPath : null;
 }
 function isExpectedCachedBinary2(binaryPath, expectedVersion) {
   const expected = normalizeBareVersion(expectedVersion);
@@ -6413,7 +6469,7 @@ function findBinarySyncInner(expectedVersion) {
     const packageBin = `@cortexkit/aft-${key}/bin/aft${ext}`;
     const req = createRequire(import.meta.url);
     const resolved = req.resolve(packageBin);
-    if (existsSync5(resolved)) {
+    if (existsSync6(resolved)) {
       const npmVersion = readBinaryVersion(resolved);
       if (npmVersion === null) {
         warn(`npm platform package binary at ${resolved} did not report a version; skipping (continuing to PATH lookup)`);
@@ -6442,8 +6498,8 @@ function findBinarySyncInner(expectedVersion) {
         return { path: usable, source: "PATH" };
     }
   } catch {}
-  const cargoPath = join7(homeDirFromEnv(env), ".cargo", "bin", `aft${ext}`);
-  if (existsSync5(cargoPath)) {
+  const cargoPath = join8(homeDirFromEnv(env), ".cargo", "bin", `aft${ext}`);
+  if (existsSync6(cargoPath)) {
     const usable = probeBinaryCandidate(cargoPath, "cargo", expectedVersion);
     if (usable)
       return { path: usable, source: "cargo" };
@@ -6491,16 +6547,16 @@ var init_resolver = __esm(() => {
 
 // ../aft-bridge/dist/migration.js
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { closeSync as closeSync3, existsSync as existsSync6, mkdirSync as mkdirSync4, openSync as openSync3, readFileSync as readFileSync5, renameSync as renameSync4, rmSync as rmSync2, statSync as statSync4, unlinkSync as unlinkSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { closeSync as closeSync3, existsSync as existsSync7, mkdirSync as mkdirSync4, openSync as openSync3, readFileSync as readFileSync5, renameSync as renameSync4, rmSync as rmSync2, statSync as statSync4, unlinkSync as unlinkSync3, writeFileSync as writeFileSync2 } from "node:fs";
 import { homedir as homedir8, tmpdir } from "node:os";
-import { basename, dirname as dirname3, join as join8, resolve as resolve6 } from "node:path";
+import { basename, dirname as dirname3, join as join9, resolve as resolve6 } from "node:path";
 function dataHome2() {
   if (process.env.XDG_DATA_HOME)
     return process.env.XDG_DATA_HOME;
   if (process.platform === "win32") {
-    return process.env.LOCALAPPDATA || process.env.APPDATA || join8(homeDir4(), "AppData", "Local");
+    return process.env.LOCALAPPDATA || process.env.APPDATA || join9(homeDir4(), "AppData", "Local");
   }
-  return join8(homeDir4(), ".local", "share");
+  return join9(homeDir4(), ".local", "share");
 }
 function homeDir4() {
   if (process.platform === "win32")
@@ -6509,8 +6565,8 @@ function homeDir4() {
 }
 function resolveLegacyStorageRoot(harness) {
   if (harness === "pi")
-    return join8(homeDir4(), ".pi", "agent", "aft");
-  return join8(dataHome2(), "opencode", "storage", "plugin", "aft");
+    return join9(homeDir4(), ".pi", "agent", "aft");
+  return join9(dataHome2(), "opencode", "storage", "plugin", "aft");
 }
 function stripJsoncForParse(input) {
   let out = "";
@@ -6640,7 +6696,7 @@ function acquireConfigMigrationLock(lockDir) {
 }
 function atomicCopyConfigFile(sourcePath, targetPath) {
   mkdirSync4(dirname3(targetPath), { recursive: true });
-  const tmpPath = join8(dirname3(targetPath), `.${basename(targetPath)}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`);
+  const tmpPath = join9(dirname3(targetPath), `.${basename(targetPath)}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`);
   let fd = null;
   try {
     fd = openSync3(tmpPath, "wx", 384);
@@ -6662,7 +6718,7 @@ function atomicCopyConfigFile(sourcePath, targetPath) {
 }
 function atomicWriteConfigFile(targetPath, content) {
   mkdirSync4(dirname3(targetPath), { recursive: true });
-  const tmpPath = join8(dirname3(targetPath), `.${basename(targetPath)}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`);
+  const tmpPath = join9(dirname3(targetPath), `.${basename(targetPath)}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`);
   let fd = null;
   try {
     fd = openSync3(tmpPath, "wx", 384);
@@ -6683,11 +6739,11 @@ function atomicWriteConfigFile(targetPath, content) {
   }
 }
 function nonClobberingSidecarPath(desiredPath) {
-  if (!existsSync6(desiredPath))
+  if (!existsSync7(desiredPath))
     return desiredPath;
   for (let index = 1;index < Number.MAX_SAFE_INTEGER; index++) {
     const candidate = `${desiredPath}.${index}`;
-    if (!existsSync6(candidate))
+    if (!existsSync7(candidate))
       return candidate;
   }
   throw new Error(`could not find available preservation sidecar path for ${desiredPath}`);
@@ -6780,7 +6836,7 @@ function visibleConfigMigrationWarning(scope, targetPath, paths, reason) {
 function migrateAftConfigFile(opts) {
   const warnings = [];
   const resolvedTarget = resolve6(opts.targetPath);
-  const existingSources = opts.legacySources.filter((source) => existsSync6(source.path) && resolve6(source.path) !== resolvedTarget);
+  const existingSources = opts.legacySources.filter((source) => existsSync7(source.path) && resolve6(source.path) !== resolvedTarget);
   const info = opts.logger?.info ?? opts.logger?.log;
   if (existingSources.length === 0) {
     return { migrated: false, conflict: false, targetPath: opts.targetPath, warnings };
@@ -6792,7 +6848,7 @@ function migrateAftConfigFile(opts) {
       ...source,
       content: readFileSync5(source.path, "utf-8")
     }));
-    if (existsSync6(opts.targetPath)) {
+    if (existsSync7(opts.targetPath)) {
       const targetContent = readFileSync5(opts.targetPath, "utf-8");
       for (const source of sources) {
         if (fileSemanticsMatch(source.content, targetContent))
@@ -6842,12 +6898,12 @@ function spawnErrorLabel(error2) {
   return [code, error2.message].filter(Boolean).join(": ");
 }
 function migrationLogPath(newRoot, harness, logger) {
-  const desired = join8(newRoot, "logs", "migration", `${harness}-${Date.now()}.jsonl`);
+  const desired = join9(newRoot, "logs", "migration", `${harness}-${Date.now()}.jsonl`);
   try {
     mkdirSync4(dirname3(desired), { recursive: true });
     return desired;
   } catch (err) {
-    const fallback = join8(tmpdir(), `aft-migration-${harness}-${Date.now()}.jsonl`);
+    const fallback = join9(tmpdir(), `aft-migration-${harness}-${Date.now()}.jsonl`);
     logger?.warn?.(`Failed to create AFT migration log directory ${dirname3(desired)}: ${err instanceof Error ? err.message : String(err)}. ` + `Using fallback log path ${fallback}.`);
     return fallback;
   }
@@ -6857,11 +6913,11 @@ async function ensureStorageMigrated(opts) {
   const newRoot = resolveCortexKitStorageRoot();
   const targetMarker = resolveHarnessStoragePath(newRoot, opts.harness, TARGET_MARKER);
   const info = opts.logger?.info ?? opts.logger?.log;
-  if (existsSync6(targetMarker)) {
+  if (existsSync7(targetMarker)) {
     info?.(`AFT storage already migrated for ${opts.harness}; using ${newRoot}`);
     return;
   }
-  if (!existsSync6(legacyRoot)) {
+  if (!existsSync7(legacyRoot)) {
     info?.(`AFT storage migration skipped for ${opts.harness}: no legacy data at ${legacyRoot}; ` + `using ${newRoot} for fresh install`);
     return;
   }
@@ -6949,10 +7005,10 @@ var init_migration = __esm(() => {
 });
 
 // ../aft-bridge/dist/npm-resolver.js
-import { execFileSync } from "node:child_process";
+import { spawn as spawn3, spawnSync as spawnSync3 } from "node:child_process";
 import { readdirSync as readdirSync2, statSync as statSync5 } from "node:fs";
 import { homedir as homedir9 } from "node:os";
-import { delimiter, dirname as dirname4, isAbsolute as isAbsolute3, join as join9 } from "node:path";
+import { delimiter as delimiter2, dirname as dirname4, isAbsolute as isAbsolute3, join as join10 } from "node:path";
 function defaultDeps() {
   return {
     platform: process.platform,
@@ -6974,18 +7030,18 @@ function isFile(p) {
 function npmFromPath(deps) {
   const name = npmBinaryName(deps.platform);
   const raw = deps.env.PATH ?? deps.env.Path ?? "";
-  for (const entry of raw.split(delimiter)) {
+  for (const entry of raw.split(delimiter2)) {
     const dir = entry.trim().replace(/^"|"$/g, "");
     if (!dir || !isAbsolute3(dir))
       continue;
-    if (isFile(join9(dir, name)))
+    if (isFile(join10(dir, name)))
       return dir;
   }
   return null;
 }
 function npmAdjacentToNode(deps) {
   const dir = dirname4(deps.execPath);
-  return isFile(join9(dir, npmBinaryName(deps.platform))) ? dir : null;
+  return isFile(join10(dir, npmBinaryName(deps.platform))) ? dir : null;
 }
 function highestVersionedNodeBin(installsDir, name) {
   let entries;
@@ -6994,8 +7050,8 @@ function highestVersionedNodeBin(installsDir, name) {
   } catch {
     return null;
   }
-  const candidates = entries.filter((v) => isFile(join9(installsDir, v, "bin", name))).sort((a, b) => compareVersionsDesc(a, b));
-  return candidates.length > 0 ? join9(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));
@@ -7020,22 +7076,22 @@ function wellKnownNpmDirs(deps) {
     const programFiles = env.ProgramFiles || "C:\\Program Files";
     const appData = env.APPDATA;
     const localAppData = env.LOCALAPPDATA;
-    push(join9(programFiles, "nodejs"));
+    push(join10(programFiles, "nodejs"));
     if (appData)
-      push(join9(appData, "npm"));
+      push(join10(appData, "npm"));
     if (localAppData)
-      push(join9(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(join9(home, ".nvm", "versions", "node"), name));
-    push(highestVersionedNodeBin(join9(home, ".local", "share", "mise", "installs", "node"), name));
-    push(highestVersionedNodeBin(join9(home, ".asdf", "installs", "nodejs"), name));
-    push(join9(home, ".volta", "bin"));
-    push(join9(home, ".asdf", "shims"));
-    const systemDirs = deps.systemNpmDirs ?? (platform === "darwin" ? ["/opt/homebrew/bin", "/usr/local/bin"] : ["/usr/local/bin", "/usr/bin", join9(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);
   }
@@ -7045,22 +7101,197 @@ function resolveNpm(deps = defaultDeps()) {
   const name = npmBinaryName(deps.platform);
   const onPath = npmFromPath(deps);
   if (onPath)
-    return { command: join9(onPath, name), binDir: onPath };
+    return { command: join10(onPath, name), binDir: onPath };
   const adjacent = npmAdjacentToNode(deps);
   if (adjacent)
-    return { command: join9(adjacent, name), binDir: adjacent };
+    return { command: join10(adjacent, name), binDir: adjacent };
   for (const dir of wellKnownNpmDirs(deps)) {
-    const candidate = join9(dir, name);
+    const candidate = join10(dir, name);
     if (isFile(candidate))
       return { command: candidate, binDir: dir };
   }
   return null;
 }
+function quoteCmdArgument(value) {
+  if (/[\0\r\n"%]/.test(value)) {
+    throw new Error(`npm argument cannot be represented safely for cmd.exe: ${JSON.stringify(value)}`);
+  }
+  return `"${value}"`;
+}
+function npmInvocation(resolved, npmArgs, platform = process.platform, env = process.env) {
+  if (platform !== "win32" || !/\.(?:cmd|bat)$/i.test(resolved.command)) {
+    return { command: resolved.command, args: [...npmArgs] };
+  }
+  if (/[\0\r\n"]/.test(resolved.command)) {
+    throw new Error(`npm command cannot be represented safely for cmd.exe: ${JSON.stringify(resolved.command)}`);
+  }
+  const commandEnvName = "AFT_NPM_COMMAND";
+  const quotedArgs = npmArgs.map(quoteCmdArgument);
+  const commandLine = `""%${commandEnvName}%"${quotedArgs.length > 0 ? ` ${quotedArgs.join(" ")}` : ""}"`;
+  return {
+    command: env.ComSpec ?? env.COMSPEC ?? "cmd.exe",
+    args: ["/d", "/s", "/v:off", "/c", commandLine],
+    env: { [commandEnvName]: resolved.command },
+    windowsVerbatimArguments: true,
+    windowsCmdShim: true
+  };
+}
+function terminateDirectNpmChild(child, gracePeriodMs) {
+  if (child.exitCode !== null || child.signalCode !== null)
+    return Promise.resolve();
+  return new Promise((resolve7, reject) => {
+    let settled = false;
+    let forceTimer = null;
+    let confirmationTimer = null;
+    let signalFailure = null;
+    const cleanup = () => {
+      if (forceTimer)
+        clearTimeout(forceTimer);
+      if (confirmationTimer)
+        clearTimeout(confirmationTimer);
+      child.removeListener("exit", finish);
+      child.removeListener("error", onChildError);
+    };
+    const finish = () => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      resolve7();
+    };
+    const fail = () => {
+      if (settled)
+        return;
+      if (child.exitCode !== null || child.signalCode !== null) {
+        finish();
+        return;
+      }
+      settled = true;
+      cleanup();
+      reject(new NpmTerminationUnknownError(signalFailure ?? `direct npm child did not exit after SIGKILL within ${gracePeriodMs}ms`));
+    };
+    const onChildError = (error2) => {
+      signalFailure = `direct npm child error during termination: ${String(error2)}`;
+    };
+    const signal = (value) => {
+      try {
+        if (!child.kill(value)) {
+          signalFailure = `direct npm child rejected ${value ?? "SIGTERM"}`;
+        }
+      } catch (error2) {
+        signalFailure = `direct npm child ${value ?? "SIGTERM"} failed: ${String(error2)}`;
+      }
+    };
+    child.once("exit", finish);
+    child.on("error", onChildError);
+    forceTimer = setTimeout(() => {
+      signal("SIGKILL");
+      confirmationTimer = setTimeout(fail, gracePeriodMs);
+    }, gracePeriodMs);
+    signal();
+    if (child.exitCode !== null || child.signalCode !== null)
+      finish();
+  });
+}
+function terminateNpmProcessTree(child, invocation, env = process.env, gracePeriodMs = 5000) {
+  if (!invocation.windowsCmdShim)
+    return terminateDirectNpmChild(child, gracePeriodMs);
+  const exitedSuccessfully = () => child.exitCode === 0 && child.signalCode === null;
+  if (exitedSuccessfully())
+    return Promise.resolve();
+  if (child.pid === undefined) {
+    return Promise.reject(new NpmTerminationUnknownError("cmd.exe child has no process ID"));
+  }
+  return new Promise((resolve7, reject) => {
+    let settled = false;
+    let childExited = child.exitCode !== null || child.signalCode !== null;
+    let treeKillConfirmed = false;
+    let treeKillFailure = null;
+    let killer = null;
+    const timeout = setTimeout(() => {
+      try {
+        killer?.kill();
+      } catch {}
+      if (treeKillConfirmed || exitedSuccessfully()) {
+        settled = true;
+        cleanup();
+        resolve7();
+        return;
+      }
+      fail(treeKillFailure ?? `taskkill.exe did not finish within ${gracePeriodMs}ms`);
+    }, gracePeriodMs);
+    const cleanup = () => {
+      clearTimeout(timeout);
+      child.removeListener("exit", onChildExit);
+    };
+    const succeedIfConfirmed = () => {
+      if (settled || !childExited || !treeKillConfirmed)
+        return;
+      settled = true;
+      cleanup();
+      resolve7();
+    };
+    const fail = (detail) => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      reject(new NpmTerminationUnknownError(detail));
+    };
+    function onChildExit() {
+      childExited = true;
+      if (treeKillFailure !== null) {
+        if (exitedSuccessfully()) {
+          settled = true;
+          cleanup();
+          resolve7();
+        } else {
+          fail(treeKillFailure);
+        }
+        return;
+      }
+      succeedIfConfirmed();
+    }
+    const recordTreeKillFailure = (detail) => {
+      if (settled)
+        return;
+      if (exitedSuccessfully()) {
+        settled = true;
+        cleanup();
+        resolve7();
+        return;
+      }
+      treeKillFailure = detail;
+      if (childExited)
+        fail(detail);
+    };
+    child.once("exit", onChildExit);
+    const systemRoot = env.SystemRoot ?? env.SYSTEMROOT;
+    const taskkill = systemRoot ? join10(systemRoot, "System32", "taskkill.exe") : "taskkill.exe";
+    try {
+      killer = spawn3(taskkill, ["/pid", String(child.pid), "/t", "/f"], {
+        stdio: "ignore",
+        windowsHide: true
+      });
+      killer.once("error", (error2) => recordTreeKillFailure(`taskkill.exe failed to start: ${String(error2)}`));
+      killer.once("exit", (code) => {
+        if (code !== 0) {
+          recordTreeKillFailure(`taskkill.exe exited with code ${code ?? "unknown"}`);
+          return;
+        }
+        treeKillConfirmed = true;
+        succeedIfConfirmed();
+      });
+    } catch (error2) {
+      recordTreeKillFailure(`taskkill.exe failed to start: ${String(error2)}`);
+    }
+  });
+}
 function npmSpawnEnv(resolved, baseEnv = process.env) {
   if (!resolved.binDir)
     return { ...baseEnv };
   const existing = baseEnv.PATH ?? baseEnv.Path ?? "";
-  const next = existing ? `${resolved.binDir}${delimiter}${existing}` : resolved.binDir;
+  const next = existing ? `${resolved.binDir}${delimiter2}${existing}` : resolved.binDir;
   return { ...baseEnv, PATH: next };
 }
 function isNpmAvailable(deps = defaultDeps()) {
@@ -7068,25 +7299,38 @@ function isNpmAvailable(deps = defaultDeps()) {
 }
 function probeNpmVersion(resolved) {
   try {
-    const out = execFileSync(resolved.command, ["--version"], {
-      env: npmSpawnEnv(resolved),
+    const invocation = npmInvocation(resolved, ["--version"]);
+    const result = spawnSync3(invocation.command, invocation.args, {
+      env: { ...npmSpawnEnv(resolved), ...invocation.env },
       encoding: "utf-8",
       timeout: 5000,
-      stdio: ["ignore", "pipe", "ignore"]
+      stdio: ["ignore", "pipe", "ignore"],
+      windowsVerbatimArguments: invocation.windowsVerbatimArguments
     });
-    const v = out.trim();
-    return /^\d+\.\d+\.\d+/.test(v) ? v : null;
+    if (result.error || result.status !== 0)
+      return null;
+    const version = result.stdout.trim();
+    return /^\d+\.\d+\.\d+/.test(version) ? version : null;
   } catch {
     return null;
   }
 }
-var init_npm_resolver = () => {};
+var NpmTerminationUnknownError;
+var init_npm_resolver = __esm(() => {
+  NpmTerminationUnknownError = class NpmTerminationUnknownError extends Error {
+    code = "npm_termination_unknown";
+    constructor(detail) {
+      super(`npm process-tree termination could not be confirmed: ${detail}`);
+      this.name = "NpmTerminationUnknownError";
+    }
+  };
+});
 
 // ../aft-bridge/dist/onnx-runtime.js
-import { execFileSync as execFileSync2 } from "node:child_process";
+import { execFileSync } from "node:child_process";
 import { createHash as createHash4 } from "node:crypto";
-import { chmodSync as chmodSync3, closeSync as closeSync4, copyFileSync as copyFileSync3, createWriteStream as createWriteStream2, existsSync as existsSync7, lstatSync, mkdirSync as mkdirSync5, openSync as openSync4, readdirSync as readdirSync3, readFileSync as readFileSync6, readlinkSync, realpathSync as realpathSync2, rmSync as rmSync3, statSync as statSync6, symlinkSync, unlinkSync as unlinkSync4, writeFileSync as writeFileSync3 } from "node:fs";
-import { basename as basename2, dirname as dirname5, isAbsolute as isAbsolute4, join as join10, relative as relative2, resolve as resolve7, win32 } from "node:path";
+import { chmodSync as chmodSync3, closeSync as closeSync4, copyFileSync as copyFileSync3, createWriteStream as createWriteStream2, existsSync as existsSync8, lstatSync, mkdirSync as mkdirSync5, openSync as openSync4, readdirSync as readdirSync3, readFileSync as readFileSync6, readlinkSync, realpathSync as realpathSync2, rmSync as rmSync3, statSync as statSync6, symlinkSync, unlinkSync as unlinkSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { basename as basename2, dirname as dirname5, isAbsolute as isAbsolute4, join as join11, relative as relative2, resolve as resolve7, win32 } from "node:path";
 import { Readable as Readable2 } from "node:stream";
 import { pipeline as pipeline2 } from "node:stream/promises";
 function getPlatformInfo() {
@@ -7112,11 +7356,11 @@ function getManualInstallHint() {
 }
 async function ensureOnnxRuntime(storageDir) {
   const info = getPlatformInfo();
-  const ortVersionDir = join10(storageDir, "onnxruntime", ORT_VERSION);
+  const ortVersionDir = join11(storageDir, "onnxruntime", ORT_VERSION);
   const libName = info?.libName ?? "libonnxruntime.dylib";
   const resolvedOrtDir = resolveCachedOnnxRuntimeDir(ortVersionDir, libName);
-  const libPath = join10(resolvedOrtDir, libName);
-  if (existsSync7(libPath)) {
+  const libPath = join11(resolvedOrtDir, libName);
+  if (existsSync8(libPath)) {
     const meta = readOnnxInstalledMeta(ortVersionDir);
     if (meta?.sha256) {
       try {
@@ -7145,9 +7389,9 @@ async function ensureOnnxRuntime(storageDir) {
     warn(`ONNX Runtime auto-download not available for ${process.platform}/${process.arch}. Install manually: ${getManualInstallHint()}`);
     return null;
   }
-  const onnxBaseDir = join10(storageDir, "onnxruntime");
+  const onnxBaseDir = join11(storageDir, "onnxruntime");
   mkdirSync5(onnxBaseDir, { recursive: true });
-  const lockPath = join10(onnxBaseDir, ONNX_LOCK_FILE);
+  const lockPath = join11(onnxBaseDir, ONNX_LOCK_FILE);
   cleanupAbandonedStagingDirs(onnxBaseDir);
   if (!acquireLock(lockPath)) {
     warn(`ONNX Runtime install already in progress in another process (lock: ${lockPath}). Skipping.`);
@@ -7166,7 +7410,7 @@ function cleanupAbandonedStagingDirs(onnxBaseDir) {
     for (const entry of entries) {
       if (!entry.startsWith(`${ORT_VERSION}.tmp.`))
         continue;
-      const stagingDir = join10(onnxBaseDir, entry);
+      const stagingDir = join11(onnxBaseDir, entry);
       const parts = entry.split(".");
       const pidStr = parts[parts.length - 2];
       const pid = pidStr ? Number.parseInt(pidStr, 10) : NaN;
@@ -7203,7 +7447,7 @@ function cleanupAbandonedStagingDirs(onnxBaseDir) {
 }
 function cleanupIncompleteTargetIfUnowned(ortDir) {
   try {
-    if (existsSync7(ortDir) && !existsSync7(join10(ortDir, ONNX_INSTALLED_META_FILE))) {
+    if (existsSync8(ortDir) && !existsSync8(join11(ortDir, ONNX_INSTALLED_META_FILE))) {
       log(`[onnx] removing half-populated install dir ${ortDir} (no meta file)`);
       rmSync3(ortDir, { recursive: true, force: true });
     }
@@ -7248,8 +7492,8 @@ function detectOnnxVersion(libDir, libName) {
       if (version)
         return version;
     }
-    const base = join10(libDir, libName);
-    if (existsSync7(base)) {
+    const base = join11(libDir, libName);
+    if (existsSync8(base)) {
       try {
         const real = realpathSync2(base);
         const version = parseOnnxVersionFromPath(real) ?? parseOnnxVersionFromDirectoryPath(real);
@@ -7280,8 +7524,8 @@ function pathEnvValue() {
   return process.env.PATH ?? process.env.Path ?? process.env.path ?? "";
 }
 function pathEntriesForPlatform() {
-  const delimiter2 = process.platform === "win32" ? ";" : ":";
-  return pathEnvValue().split(delimiter2).map((entry) => entry.trim().replace(/^"|"$/g, "")).filter((entry) => {
+  const delimiter3 = process.platform === "win32" ? ";" : ":";
+  return pathEnvValue().split(delimiter3).map((entry) => entry.trim().replace(/^"|"$/g, "")).filter((entry) => {
     if (!entry || entry === "." || entry.includes("\x00"))
       return false;
     return isAbsolute4(entry) || win32.isAbsolute(entry);
@@ -7311,10 +7555,10 @@ function directoryContainsLibrary(dir, libName) {
   }
 }
 function resolveCachedOnnxRuntimeDir(ortVersionDir, libName) {
-  if (existsSync7(join10(ortVersionDir, libName)))
+  if (existsSync8(join11(ortVersionDir, libName)))
     return ortVersionDir;
-  const libSubdir = join10(ortVersionDir, "lib");
-  if (existsSync7(join10(libSubdir, libName)))
+  const libSubdir = join11(ortVersionDir, "lib");
+  if (existsSync8(join11(libSubdir, libName)))
     return libSubdir;
   return ortVersionDir;
 }
@@ -7329,13 +7573,13 @@ function findSystemOnnxRuntime(libName) {
   } 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(join11(programFiles, "onnxruntime", "lib"), join11(programFiles, "Microsoft ONNX Runtime", "lib"), join11(programFiles, "Microsoft Machine Learning", "lib"), join11(programFilesX86, "onnxruntime", "lib"), ...(() => {
       const nugetPaths = [];
       const userProfile = process.env.USERPROFILE ?? "";
       if (!userProfile)
         return nugetPaths;
-      const nugetPackageDir = join10(userProfile, ".nuget", "packages", "microsoft.ml.onnxruntime");
-      if (!existsSync7(nugetPackageDir))
+      const nugetPackageDir = join11(userProfile, ".nuget", "packages", "microsoft.ml.onnxruntime");
+      if (!existsSync8(nugetPackageDir))
         return nugetPaths;
       try {
         for (const entry of readdirSync3(nugetPackageDir, { withFileTypes: true })) {
@@ -7343,7 +7587,7 @@ function findSystemOnnxRuntime(libName) {
             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(join11(nugetPackageDir, entry.name, "runtimes", "win-x64", "native"), join11(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)}`);
@@ -7365,11 +7609,11 @@ function findSystemOnnxRuntime(libName) {
   });
   const unknownVersionPaths = [];
   for (const dir of uniquePaths) {
-    const libPath = join10(dir, libName);
+    const libPath = join11(dir, libName);
     if (process.platform === "win32") {
       if (!directoryContainsLibrary(dir, libName))
         continue;
-    } else if (!existsSync7(libPath)) {
+    } else if (!existsSync8(libPath)) {
       continue;
     }
     const version = detectOnnxVersion(dir, libName);
@@ -7435,7 +7679,7 @@ function validateExtractedTree(stagingRoot) {
   const walk = (dir) => {
     const entries = readdirSync3(dir);
     for (const entry of entries) {
-      const fullPath = join10(dir, entry);
+      const fullPath = join11(dir, entry);
       const lst = lstatSync(fullPath);
       if (lst.isSymbolicLink()) {
         const linkTarget = readlinkSync(fullPath);
@@ -7470,12 +7714,12 @@ async function downloadOnnxRuntime(info, targetDir) {
   const tmpDir = `${targetDir}.tmp.${process.pid}.${Date.now().toString(36)}`;
   try {
     mkdirSync5(tmpDir, { recursive: true });
-    const archivePath = join10(tmpDir, `onnxruntime.${info.archiveType}`);
+    const archivePath = join11(tmpDir, `onnxruntime.${info.archiveType}`);
     await downloadFileWithCap(url, archivePath);
     const archiveSha256 = sha256File(archivePath);
     log(`ONNX Runtime archive sha256=${archiveSha256}`);
     if (info.archiveType === "tgz") {
-      execFileSync2("tar", ["xzf", archivePath, "-C", tmpDir], {
+      execFileSync("tar", ["xzf", archivePath, "-C", tmpDir], {
         stdio: "pipe",
         timeout: 120000
       });
@@ -7486,8 +7730,8 @@ async function downloadOnnxRuntime(info, targetDir) {
       unlinkSync4(archivePath);
     } catch {}
     validateExtractedTree(tmpDir);
-    const extractedDir = join10(tmpDir, info.assetName, "lib");
-    if (!existsSync7(extractedDir)) {
+    const extractedDir = join11(tmpDir, info.assetName, "lib");
+    if (!existsSync8(extractedDir)) {
       throw new Error(`Expected directory not found: ${extractedDir}`);
     }
     mkdirSync5(targetDir, { recursive: true });
@@ -7495,7 +7739,7 @@ async function downloadOnnxRuntime(info, targetDir) {
     const realFiles = [];
     const symlinks = [];
     for (const libFile of libFiles) {
-      const src = join10(extractedDir, libFile);
+      const src = join11(extractedDir, libFile);
       try {
         const stat2 = lstatSync(src);
         log(`ORT extract: ${libFile} — isSymlink=${stat2.isSymbolicLink()}, isFile=${stat2.isFile()}, size=${stat2.size}`);
@@ -7510,7 +7754,7 @@ async function downloadOnnxRuntime(info, targetDir) {
       }
     }
     copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks);
-    const libPath = join10(targetDir, info.libName);
+    const libPath = join11(targetDir, info.libName);
     let libHash = null;
     try {
       libHash = sha256File(libPath);
@@ -7535,8 +7779,8 @@ async function downloadOnnxRuntime(info, targetDir) {
 function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, copyFile = copyFileSync3) {
   const requiredLibs = new Set([info.libName]);
   for (const libFile of realFiles) {
-    const src = join10(extractedDir, libFile);
-    const dst = join10(targetDir, libFile);
+    const src = join11(extractedDir, libFile);
+    const dst = join11(targetDir, libFile);
     try {
       copyFile(src, dst);
       if (process.platform !== "win32") {
@@ -7552,11 +7796,11 @@ function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, c
   }
   const targetRoot = realpathSync2(targetDir);
   for (const link of symlinks) {
-    const dst = join10(targetDir, link.name);
+    const dst = join11(targetDir, link.name);
     try {
       unlinkSync4(dst);
     } catch {}
-    const dstForContainment = join10(targetRoot, link.name);
+    const dstForContainment = join11(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}`;
@@ -7577,21 +7821,21 @@ function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, c
       log(`ORT extract: failed to symlink optional ${link.name}: ${symlinkErr}`);
     }
   }
-  const requiredPath = join10(targetDir, info.libName);
-  if (!existsSync7(requiredPath)) {
+  const requiredPath = join11(targetDir, info.libName);
+  if (!existsSync8(requiredPath)) {
     rmSync3(targetDir, { recursive: true, force: true });
     throw new Error(`Required ONNX Runtime library missing after install: ${requiredPath}`);
   }
 }
 async function extractZipArchive(archivePath, destinationDir) {
   if (process.platform === "win32") {
-    execFileSync2("tar.exe", ["-xf", archivePath, "-C", destinationDir], {
+    execFileSync("tar.exe", ["-xf", archivePath, "-C", destinationDir], {
       stdio: "pipe",
       timeout: 120000
     });
     return;
   }
-  execFileSync2("unzip", ["-q", archivePath, "-d", destinationDir], {
+  execFileSync("unzip", ["-q", archivePath, "-d", destinationDir], {
     stdio: "pipe",
     timeout: 120000
   });
@@ -7604,13 +7848,13 @@ function writeOnnxInstalledMeta(installDir, version, sha256, archiveSha256) {
       ...sha256 ? { sha256 } : {},
       archiveSha256
     };
-    writeFileSync3(join10(installDir, ONNX_INSTALLED_META_FILE), JSON.stringify(meta), "utf8");
+    writeFileSync3(join11(installDir, ONNX_INSTALLED_META_FILE), JSON.stringify(meta), "utf8");
   } catch (err) {
     log(`[onnx] failed to write installed-meta in ${installDir}: ${err}`);
   }
 }
 function readOnnxInstalledMeta(installDir) {
-  const path2 = join10(installDir, ONNX_INSTALLED_META_FILE);
+  const path2 = join11(installDir, ONNX_INSTALLED_META_FILE);
   try {
     if (!statSync6(path2).isFile())
       return null;
@@ -7722,7 +7966,7 @@ function isWindowsProcessAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0)
     return false;
   try {
-    const output = execFileSync2("tasklist.exe", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], {
+    const output = execFileSync("tasklist.exe", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], {
       encoding: "utf8",
       timeout: 2000,
       windowsHide: true
@@ -7748,8 +7992,8 @@ function isProcessAlive2(pid) {
 }
 function cleanupOnnxRuntime(storageDir) {
   try {
-    const ortBase = join10(storageDir, "onnxruntime");
-    if (existsSync7(ortBase)) {
+    const ortBase = join11(storageDir, "onnxruntime");
+    if (existsSync8(ortBase)) {
       rmSync3(ortBase, { recursive: true, force: true });
     }
   } catch {}
@@ -8054,7 +8298,7 @@ function editModesPresent(record) {
   const hasSymbol = isNonEmptyString(record.symbol);
   if (!hasSymbol) {
     delete record.symbol;
-    if (record.content === null || record.content === "")
+    if (isNullOrEmptyString(record.content))
       delete record.content;
   } else if (record.content === null) {
     delete record.content;
@@ -8083,16 +8327,26 @@ function editModesPresent(record) {
 function isNonEmptyString(value) {
   return typeof value === "string" && value.length > 0;
 }
+function isNullOrEmptyString(value) {
+  return value === null || value === "";
+}
 function isEditSentinelItem(item) {
   if (!item || typeof item !== "object" || Array.isArray(item))
     return false;
   const record = item;
-  if (record.oldString !== "")
+  const oldStringEmpty = hasOwn(record, "oldString") && isNullOrEmptyString(record.oldString);
+  if (!oldStringEmpty)
     return false;
-  const newStringEmpty = !hasOwn(record, "newString") || record.newString === "" || record.newString === null;
-  if (!newStringEmpty)
+  if (record.oldString === null && ["startLine", "endLine"].some((key) => hasOwn(record, key) && record[key] !== null)) {
     return false;
-  return !hasOwn(record, "content") || record.content === "" || record.content === null;
+  }
+  return (!hasOwn(record, "newString") || isNullOrEmptyString(record.newString)) && (!hasOwn(record, "content") || isNullOrEmptyString(record.content)) && (!hasOwn(record, "replaceAll") || record.replaceAll === null || record.replaceAll === false) && isDefaultOccurrence(record.occurrence);
+}
+function hasMeaningfulFindPayload(item) {
+  return isNonEmptyString(item.oldString);
+}
+function isDefaultOccurrence(value) {
+  return value === undefined || value === null || value === 1;
 }
 function normalizeEditArraySentinels(record) {
   const value = record.edits;
@@ -8145,9 +8399,33 @@ function parseEditArray(value) {
   }
   return value;
 }
-function stripLineRangeSentinels(item) {
-  const hasRangeField = ["startLine", "endLine", "content"].some((key) => hasOwn(item, key));
-  if (!hasRangeField)
+function normalizeEditItemSentinels(item) {
+  const hadRangeFields = ["startLine", "endLine", "content"].some((key) => hasOwn(item, key));
+  for (const key of [
+    "oldString",
+    "newString",
+    "replaceAll",
+    "occurrence",
+    "startLine",
+    "endLine",
+    "content"
+  ]) {
+    if (item[key] === null)
+      delete item[key];
+  }
+  const contentIsEmpty = item.content === "";
+  if (hasMeaningfulFindPayload(item) && (!hasOwn(item, "content") || contentIsEmpty)) {
+    for (const key of ["startLine", "endLine", "content"])
+      delete item[key];
+    if (hadRangeFields) {
+      if (item.replaceAll === false)
+        delete item.replaceAll;
+      if (hasOwn(item, "occurrence") && isDefaultOccurrence(item.occurrence))
+        delete item.occurrence;
+    }
+    return;
+  }
+  if (!isNonEmptyString(item.content))
     return;
   if (item.oldString === "")
     delete item.oldString;
@@ -8155,7 +8433,7 @@ function stripLineRangeSentinels(item) {
     delete item.newString;
   if (item.replaceAll === false)
     delete item.replaceAll;
-  if (item.occurrence === 1)
+  if (hasOwn(item, "occurrence") && isDefaultOccurrence(item.occurrence))
     delete item.occurrence;
 }
 function normalizeEditItem(value, index) {
@@ -8166,7 +8444,7 @@ function normalizeEditItem(value, index) {
   const item = copyOwnProperties(source);
   normalizeItemAlias(item, "oldString", "oldText");
   normalizeItemAlias(item, "newString", "newText");
-  stripLineRangeSentinels(item);
+  normalizeEditItemSentinels(item);
   const hasFindField = ["oldString", "newString", "replaceAll", "occurrence"].some((key) => hasOwn(item, key));
   const hasRangeField = ["startLine", "endLine", "content"].some((key) => hasOwn(item, key));
   if (hasFindField && hasRangeField) {
@@ -8925,17 +9203,17 @@ function formatReadFooter(agentSpecifiedRange, data, options) {
 }
 
 // ../aft-bridge/dist/transport-factory.js
-import { existsSync as existsSync8 } from "node:fs";
+import { existsSync as existsSync9 } from "node:fs";
 import { homedir as homedir11 } from "node:os";
-import { isAbsolute as isAbsolute5, join as join11 } from "node:path";
+import { isAbsolute as isAbsolute5, join as join12 } from "node:path";
 function resolveConnectionFilePath(raw) {
   const trimmed = raw.trim();
   if (trimmed.startsWith("~")) {
-    return join11(homedir11(), trimmed.slice(1).replace(/^[/\\]/, ""));
+    return join12(homedir11(), trimmed.slice(1).replace(/^[/\\]/, ""));
   }
   if (isAbsolute5(trimmed))
     return trimmed;
-  return join11(homedir11(), trimmed);
+  return join12(homedir11(), trimmed);
 }
 function booleanOption(value) {
   return typeof value === "boolean" ? value : undefined;
@@ -9008,7 +9286,7 @@ async function createConcreteAftTransportPool(opts) {
       consumerIdentity: opts.subcConsumerIdentity,
       onBgEventsNudge: opts.onBgEventsNudge,
       onBgEventsNudgeRef: opts.onBgEventsNudgeRef,
-      lifecycleDemandCheck: opts.subcLifecycleDemandCheck ?? ((root) => existsSync8(root))
+      lifecycleDemandCheck: opts.subcLifecycleDemandCheck ?? ((root) => existsSync9(root))
     });
   }
   return new BridgePool(opts.binaryPath, opts.poolOptions, opts.configOverrides);
@@ -9148,6 +9426,7 @@ __export(exports_dist, {
   HomeProjectRootError: () => HomeProjectRootError,
   InvalidRequestError: () => InvalidRequestError,
   LONG_RUNNING_COMMAND_TIMEOUT_MS: () => LONG_RUNNING_COMMAND_TIMEOUT_MS,
+  NpmTerminationUnknownError: () => NpmTerminationUnknownError,
   OPENCODE_ONLY_KEYS: () => OPENCODE_ONLY_KEYS,
   PI_ONLY_KEYS: () => PI_ONLY_KEYS,
   PLAIN_CALLGRAPH_THEME: () => PLAIN_CALLGRAPH_THEME,
@@ -9197,6 +9476,8 @@ __export(exports_dist, {
   getCachedBinaryPath: () => getCachedBinaryPath,
   getManualInstallHint: () => getManualInstallHint,
   getMigrationStatus: () => getMigrationStatus,
+  getOpenCodeCacheRoot: () => getOpenCodeCacheRoot,
+  getOpenCodeConfigRoot: () => getOpenCodeConfigRoot,
   inlineUserConfigTier: () => inlineUserConfigTier,
   isBashTransportDeadError: () => isBashTransportDeadError,
   isBridgeTransportTimeout: () => isBridgeTransportTimeout,
@@ -9212,6 +9493,7 @@ __export(exports_dist, {
   maybeAppendConflictsHint: () => maybeAppendConflictsHint,
   maybeAppendGrepSearchHint: () => maybeAppendGrepSearchHint,
   migrateAftConfigFile: () => migrateAftConfigFile,
+  npmInvocation: () => npmInvocation,
   npmSpawnEnv: () => npmSpawnEnv,
   platformKey: () => platformKey,
   prepareCanonicalEditArguments: () => prepareCanonicalEditArguments,
@@ -9239,6 +9521,7 @@ __export(exports_dist, {
   stripHarnessSpecificConfigKeys: () => stripHarnessSpecificConfigKeys,
   stripJsoncSymbols: () => stripJsoncSymbols,
   tagStderrLine: () => tagStderrLine,
+  terminateNpmProcessTree: () => terminateNpmProcessTree,
   timeoutForCommand: () => timeoutForCommand,
   toolErrorFromResponse: () => toolErrorFromResponse,
   unwrapRustZoomBatchEnvelope: () => unwrapRustZoomBatchEnvelope
@@ -9273,7 +9556,7 @@ var init_dist2 = __esm(() => {
 
 // src/lib/paths.ts
 import { homedir as homedir12 } from "node:os";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 function getAftBinaryName() {
   return process.platform === "win32" ? "aft.exe" : "aft";
 }
@@ -9286,25 +9569,25 @@ function dataHome3() {
   if (process.env.XDG_DATA_HOME)
     return process.env.XDG_DATA_HOME;
   if (process.platform === "win32") {
-    return process.env.LOCALAPPDATA || process.env.APPDATA || join12(homeDir5(), "AppData", "Local");
+    return process.env.LOCALAPPDATA || process.env.APPDATA || join13(homeDir5(), "AppData", "Local");
   }
-  return join12(homeDir5(), ".local", "share");
+  return join13(homeDir5(), ".local", "share");
 }
 function getCortexKitStorageRoot() {
   if (process.env.AFT_CACHE_DIR)
-    return join12(process.env.AFT_CACHE_DIR, "aft");
-  return join12(dataHome3(), "cortexkit", "aft");
+    return join13(process.env.AFT_CACHE_DIR, "aft");
+  return join13(dataHome3(), "cortexkit", "aft");
 }
 var init_paths2 = __esm(() => {
   init_dist2();
 });
 
 // src/lib/binary-probe.ts
-import { execSync as execSync2, spawnSync as spawnSync3 } from "node:child_process";
-import { existsSync as existsSync9 } from "node:fs";
+import { execSync as execSync2, spawnSync as spawnSync4 } from "node:child_process";
+import { existsSync as existsSync10 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
 import { homedir as homedir13 } from "node:os";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 async function loadPluginVersion() {
   try {
     const bridge = await Promise.resolve().then(() => (init_dist2(), exports_dist));
@@ -9356,9 +9639,9 @@ function probeAftBinary(preferredVersion) {
   const candidates = [];
   for (const candidate of aftBinaryCandidates(preferredVersion)) {
     try {
-      if (!existsSync9(candidate))
+      if (!existsSync10(candidate))
         continue;
-      const result = spawnSync3(candidate, ["--version"], {
+      const result = spawnSync4(candidate, ["--version"], {
         stdio: ["ignore", "pipe", "pipe"],
         encoding: "utf-8",
         timeout: 5000,
@@ -9407,7 +9690,7 @@ function pushCandidate(candidates, candidate) {
 function firstExisting(candidates) {
   for (const candidate of candidates) {
     try {
-      if (!existsSync9(candidate))
+      if (!existsSync10(candidate))
         continue;
       return candidate;
     } catch {}
@@ -9426,7 +9709,7 @@ function aftBinaryCandidates(preferredVersion) {
   const candidates = [];
   if (preferredVersion) {
     const tag = preferredVersion.startsWith("v") ? preferredVersion : `v${preferredVersion}`;
-    pushCandidate(candidates, join13(getAftBinaryCacheDir(), tag, getAftBinaryName()));
+    pushCandidate(candidates, join14(getAftBinaryCacheDir(), tag, getAftBinaryName()));
   }
   const key = platformKey2();
   if (key) {
@@ -9449,7 +9732,7 @@ function aftBinaryCandidates(preferredVersion) {
       }
     }
   } catch {}
-  pushCandidate(candidates, join13(homedir13(), ".cargo", "bin", getAftBinaryName()));
+  pushCandidate(candidates, join14(homedir13(), ".cargo", "bin", getAftBinaryName()));
   return candidates;
 }
 function findAftBinary(preferredVersion) {
@@ -9464,10 +9747,10 @@ var init_binary_probe = __esm(async () => {
 });
 
 // src/lib/fs-util.ts
-import { existsSync as existsSync10, readdirSync as readdirSync4, statSync as statSync7 } from "node:fs";
-import { join as join14 } from "node:path";
+import { existsSync as existsSync11, readdirSync as readdirSync4, statSync as statSync7 } from "node:fs";
+import { join as join15 } from "node:path";
 function dirSize(path2) {
-  if (!existsSync10(path2)) {
+  if (!existsSync11(path2)) {
     return 0;
   }
   const stat2 = statSync7(path2);
@@ -9479,7 +9762,7 @@ function dirSize(path2) {
   }
   let total = 0;
   for (const entry of readdirSync4(path2)) {
-    total += dirSize(join14(path2, entry));
+    total += dirSize(join15(path2, entry));
   }
   return total;
 }
@@ -17087,9 +17370,9 @@ var require_stringify = __commonJS(function(exports, module) {
       if (line_breaks_before === null) {
         line_breaks_before = inline ? 0 : 1;
       }
-      const delimiter2 = line_breaks_before > 0 ? repeat_line_breaks(line_breaks_before, deeper_gap) : inline ? SPACE : i === 0 ? EMPTY : LF + deeper_gap;
+      const delimiter3 = line_breaks_before > 0 ? repeat_line_breaks(line_breaks_before, deeper_gap) : inline ? SPACE : i === 0 ? EMPTY : LF + deeper_gap;
       const is_line_comment = type === "LineComment";
-      str += delimiter2 + comment_stringify(value, is_line_comment);
+      str += delimiter3 + comment_stringify(value, is_line_comment);
       last_comment = comment;
     });
     const default_line_breaks_after = display_block || last_comment.type === "LineComment" ? 1 : 0;
@@ -17102,10 +17385,10 @@ var require_stringify = __commonJS(function(exports, module) {
     replacer = null;
     indent = EMPTY;
   };
-  var join15 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(one, gap)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two, gap)), gap) : EMPTY;
+  var join16 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(one, gap)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two, gap)), gap) : EMPTY;
   var join_content = (inside, value, gap) => {
     const comment = process_comments(value, PREFIX_BEFORE, gap + indent, true);
-    return join15(comment, inside, gap);
+    return join16(comment, inside, gap);
   };
   var stringify_string = (holder, key, value) => {
     const raw = get_raw_string_literal(holder, key);
@@ -17127,13 +17410,13 @@ var require_stringify = __commonJS(function(exports, module) {
       if (i !== 0) {
         inside += COMMA;
       }
-      const before = join15(after_comma, process_comments(value, BEFORE(i), deeper_gap), deeper_gap);
+      const before = join16(after_comma, process_comments(value, BEFORE(i), deeper_gap), deeper_gap);
       inside += before || LF + deeper_gap;
       inside += stringify(i, value, deeper_gap) || STR_NULL;
       inside += process_comments(value, AFTER_VALUE(i), deeper_gap);
       after_comma = process_comments(value, AFTER(i), deeper_gap);
     }
-    inside += join15(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join16(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
     return BRACKET_OPEN + join_content(inside, value, gap) + BRACKET_CLOSE;
   };
   var object_stringify = (value, gap) => {
@@ -17154,13 +17437,13 @@ var require_stringify = __commonJS(function(exports, module) {
         inside += COMMA;
       }
       first = false;
-      const before = join15(after_comma, process_comments(value, BEFORE(key), deeper_gap), deeper_gap);
+      const before = join16(after_comma, process_comments(value, BEFORE(key), deeper_gap), deeper_gap);
       inside += before || LF + deeper_gap;
       inside += quote(key) + process_comments(value, AFTER_PROP(key), deeper_gap) + COLON + process_comments(value, AFTER_COLON(key), deeper_gap) + SPACE + sv + process_comments(value, AFTER_VALUE(key), deeper_gap);
       after_comma = process_comments(value, AFTER(key), deeper_gap);
     };
     keys.forEach(iteratee);
-    inside += join15(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join16(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
     return CURLY_BRACKET_OPEN + join_content(inside, value, gap) + CURLY_BRACKET_CLOSE;
   };
   function stringify(key, holder, gap) {
@@ -17253,21 +17536,21 @@ var require_src2 = __commonJS(function(exports, module) {
 });
 
 // src/lib/jsonc.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync6, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "node:fs";
 import { dirname as dirname6 } from "node:path";
 function detectJsoncFile(configDir, baseName) {
   const jsoncPath = `${configDir}/${baseName}.jsonc`;
   const jsonPath = `${configDir}/${baseName}.json`;
-  if (existsSync11(jsoncPath)) {
+  if (existsSync12(jsoncPath)) {
     return { path: jsoncPath, format: "jsonc" };
   }
-  if (existsSync11(jsonPath)) {
+  if (existsSync12(jsonPath)) {
     return { path: jsonPath, format: "json" };
   }
   return { path: jsonPath, format: "none" };
 }
 function readJsoncFile(path2) {
-  if (!existsSync11(path2)) {
+  if (!existsSync12(path2)) {
     return { value: null };
   }
   try {
@@ -17288,7 +17571,7 @@ function writeJsoncFile(path2, value, format = "json") {
 `);
 }
 function ensureAftSchemaUrl(path2, format) {
-  const existed = existsSync11(path2);
+  const existed = existsSync12(path2);
   if (!existed) {
     const writeFormat = format === "jsonc" ? "jsonc" : "json";
     writeJsoncFile(path2, { $schema: AFT_SCHEMA_URL }, writeFormat);
@@ -17341,26 +17624,36 @@ var init_self_version = () => {};
 
 // src/adapters/opencode.ts
 import { execSync as execSync3 } from "node:child_process";
-import { existsSync as existsSync12, readFileSync as readFileSync8, rmSync as rmSync4, statSync as statSync8 } from "node:fs";
+import { existsSync as existsSync13, readFileSync as readFileSync8, rmSync as rmSync4, statSync as statSync8 } from "node:fs";
 import { homedir as homedir14 } from "node:os";
-import { dirname as dirname7, join as join15, parse, resolve as resolve8 } from "node:path";
+import { dirname as dirname7, join as join16, parse, resolve as resolve8 } from "node:path";
 import { fileURLToPath } from "node:url";
 function getOpenCodeConfigDir() {
   const envDir = process.env.OPENCODE_CONFIG_DIR?.trim();
   if (envDir)
     return resolve8(envDir);
-  const xdg = process.env.XDG_CONFIG_HOME || join15(homedir14(), ".config");
-  return join15(xdg, "opencode");
+  return getOpenCodeConfigRoot();
 }
-function getOpenCodeCacheDir() {
-  const xdg = process.env.XDG_CACHE_HOME;
-  if (xdg)
-    return join15(xdg, "opencode");
-  if (process.platform === "win32") {
-    const localAppData = process.env.LOCALAPPDATA ?? join15(homedir14(), "AppData", "Local");
-    return join15(localAppData, "opencode");
+function getLegacyOpenCodePluginCachePath(primaryPath) {
+  if (process.platform !== "win32")
+    return null;
+  const localAppData = process.env.LOCALAPPDATA ?? join16(homedir14(), "AppData", "Local");
+  const legacyPath = join16(localAppData, "opencode", "packages", PLUGIN_ENTRY);
+  return resolve8(legacyPath) === resolve8(primaryPath) ? null : legacyPath;
+}
+function clearLegacyOpenCodePluginCache(primaryPath) {
+  const legacyPath = getLegacyOpenCodePluginCachePath(primaryPath);
+  if (!legacyPath || !existsSync13(legacyPath))
+    return { clearedPath: null };
+  try {
+    rmSync4(legacyPath, { recursive: true, force: true });
+    return { clearedPath: legacyPath };
+  } catch (error2) {
+    return { clearedPath: null, error: error2 instanceof Error ? error2.message : String(error2) };
   }
-  return join15(homedir14(), ".cache", "opencode");
+}
+function getOpenCodeCacheDir() {
+  return getOpenCodeCacheRoot();
 }
 function hasOpenCodeCli() {
   try {
@@ -17373,16 +17666,16 @@ function hasOpenCodeCli() {
 function openCodeDesktopAppExists() {
   const candidates = [];
   if (process.platform === "darwin") {
-    candidates.push("/Applications/OpenCode.app", "/Applications/OpenCode Beta.app", join15(homedir14(), "Applications", "OpenCode.app"), join15(homedir14(), "Applications", "OpenCode Beta.app"));
+    candidates.push("/Applications/OpenCode.app", "/Applications/OpenCode Beta.app", join16(homedir14(), "Applications", "OpenCode.app"), join16(homedir14(), "Applications", "OpenCode Beta.app"));
   } else if (process.platform === "win32") {
-    const localAppData = process.env.LOCALAPPDATA ?? join15(homedir14(), "AppData", "Local");
-    candidates.push(join15(localAppData, "Programs", "opencode"), join15(localAppData, "opencode"));
+    const localAppData = process.env.LOCALAPPDATA ?? join16(homedir14(), "AppData", "Local");
+    candidates.push(join16(localAppData, "Programs", "opencode"), join16(localAppData, "opencode"));
   } else {
-    candidates.push("/opt/OpenCode", "/usr/lib/opencode", join15(homedir14(), ".local", "share", "applications", "opencode.desktop"));
+    candidates.push("/opt/OpenCode", "/usr/lib/opencode", join16(homedir14(), ".local", "share", "applications", "opencode.desktop"));
   }
   return candidates.some((p) => {
     try {
-      return existsSync12(p);
+      return existsSync13(p);
     } catch {
       return false;
     }
@@ -17405,13 +17698,13 @@ function pathPointsToOurPlugin(entry) {
   if (!fsPath)
     return false;
   try {
-    if (!existsSync12(fsPath))
+    if (!existsSync13(fsPath))
       return false;
     let searchDir = statSync8(fsPath).isDirectory() ? fsPath : dirname7(fsPath);
     let pkgJsonPath = null;
     while (true) {
-      const candidate = join15(searchDir, "package.json");
-      if (existsSync12(candidate)) {
+      const candidate = join16(searchDir, "package.json");
+      if (existsSync13(candidate)) {
         pkgJsonPath = candidate;
         break;
       }
@@ -17442,7 +17735,7 @@ class OpenCodeAdapter {
   pluginPackageName = PLUGIN_NAME;
   pluginEntryWithVersion = PLUGIN_ENTRY;
   isInstalled() {
-    if (existsSync12(getOpenCodeConfigDir()))
+    if (existsSync13(getOpenCodeConfigDir()))
       return true;
     if (openCodeDesktopAppExists())
       return true;
@@ -17463,7 +17756,7 @@ class OpenCodeAdapter {
     const configDir = getOpenCodeConfigDir();
     const harness = detectJsoncFile(configDir, "opencode");
     const aftConfigPath = resolveCortexKitUserConfigPath();
-    const aftConfigExists = existsSync12(aftConfigPath);
+    const aftConfigExists = existsSync13(aftConfigPath);
     const tui = detectJsoncFile(configDir, "tui");
     return {
       configDir,
@@ -17581,11 +17874,11 @@ class OpenCodeAdapter {
     };
   }
   getPluginCacheInfo() {
-    const path2 = join15(getOpenCodeCacheDir(), "packages", PLUGIN_ENTRY);
+    const path2 = join16(getOpenCodeCacheDir(), "packages", PLUGIN_ENTRY);
     let cached;
     try {
-      const installedPkgPath = join15(path2, "node_modules", "@cortexkit", "aft-opencode", "package.json");
-      if (existsSync12(installedPkgPath)) {
+      const installedPkgPath = join16(path2, "node_modules", "@cortexkit", "aft-opencode", "package.json");
+      if (existsSync13(installedPkgPath)) {
         const pkg = JSON.parse(readFileSync8(installedPkgPath, "utf-8"));
         cached = typeof pkg.version === "string" ? pkg.version : undefined;
       }
@@ -17596,7 +17889,7 @@ class OpenCodeAdapter {
       path: path2,
       cached,
       latest: getSelfVersion(),
-      exists: existsSync12(path2)
+      exists: existsSync13(path2)
     };
   }
   getStorageDir() {
@@ -17610,8 +17903,21 @@ class OpenCodeAdapter {
   }
   async clearPluginCache(force) {
     const info = this.getPluginCacheInfo();
+    const clearLegacy = force ? clearLegacyOpenCodePluginCache(info.path) : { clearedPath: null };
+    if (clearLegacy.error) {
+      return {
+        action: "error",
+        path: info.path,
+        error: `Could not clear legacy OpenCode cache: ${clearLegacy.error}`,
+        ...clearLegacy.clearedPath ? { legacy_path_cleared: clearLegacy.clearedPath } : {}
+      };
+    }
     if (!info.exists) {
-      return { action: "not_found", path: info.path };
+      return clearLegacy.clearedPath ? {
+        action: "legacy_path_cleared",
+        path: clearLegacy.clearedPath,
+        legacy_path_cleared: clearLegacy.clearedPath
+      } : { action: "not_found", path: info.path };
     }
     if (!force && info.cached && info.cached === info.latest) {
       return {
@@ -17627,7 +17933,8 @@ class OpenCodeAdapter {
         action: "cleared",
         path: info.path,
         cached: info.cached,
-        latest: info.latest
+        latest: info.latest,
+        ...clearLegacy.clearedPath ? { legacy_path_cleared: clearLegacy.clearedPath } : {}
       };
     } catch (error2) {
       return {
@@ -17645,12 +17952,12 @@ class OpenCodeAdapter {
   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(join16(storage, "index")),
+      semantic: dirSize(join16(storage, "semantic")),
+      backups: dirSize(join16(storage, "backups")),
+      url_cache: dirSize(join16(storage, "url_cache")),
+      onnxruntime: dirSize(join16(storage, "onnxruntime")),
+      logs: dirSize(join16(storage, "logs"))
     };
   }
 }
@@ -17665,21 +17972,21 @@ var init_opencode = __esm(() => {
 });
 
 // src/adapters/pi.ts
-import { execSync as execSync4, spawnSync as spawnSync4 } from "node:child_process";
-import { existsSync as existsSync13, readFileSync as readFileSync9 } from "node:fs";
+import { execSync as execSync4, spawnSync as spawnSync5 } from "node:child_process";
+import { existsSync as existsSync14, readFileSync as readFileSync9 } from "node:fs";
 import { homedir as homedir15 } from "node:os";
-import { join as join16, resolve as resolve9 } from "node:path";
+import { join as join17, resolve as resolve9 } from "node:path";
 function getPiAgentDir() {
   const configuredDir = process.env.PI_CODING_AGENT_DIR?.trim();
   if (configuredDir)
     return resolve9(configuredDir);
   const envHome = process.platform === "win32" ? process.env.USERPROFILE : process.env.HOME;
   const home = envHome && envHome.length > 0 ? envHome : homedir15();
-  return join16(home, ".pi", "agent");
+  return join17(home, ".pi", "agent");
 }
 function readPiExtensionIndex() {
-  const settingsPath = join16(getPiAgentDir(), "settings.json");
-  if (existsSync13(settingsPath)) {
+  const settingsPath = join17(getPiAgentDir(), "settings.json");
+  if (existsSync14(settingsPath)) {
     try {
       const raw = readFileSync9(settingsPath, "utf-8");
       const trimmed = raw.replace(/^\uFEFF/, "");
@@ -17699,13 +18006,13 @@ function readPiExtensionIndex() {
     } catch {}
   }
   const candidates = [
-    join16(getPiAgentDir(), "extensions.json"),
-    join16(getPiAgentDir(), "extensions.jsonc"),
-    join16(getPiAgentDir(), "config.json"),
-    join16(getPiAgentDir(), "config.jsonc")
+    join17(getPiAgentDir(), "extensions.json"),
+    join17(getPiAgentDir(), "extensions.jsonc"),
+    join17(getPiAgentDir(), "config.json"),
+    join17(getPiAgentDir(), "config.jsonc")
   ];
   for (const path2 of candidates) {
-    if (!existsSync13(path2))
+    if (!existsSync14(path2))
       continue;
     try {
       const { value } = readJsoncFile(path2);
@@ -17738,15 +18045,15 @@ function piEntryMatchesAft(entry) {
   } else if (entry.startsWith("/")) {
     resolved = entry;
   } else if (entry.length > 0) {
-    resolved = join16(getPiAgentDir(), entry);
+    resolved = join17(getPiAgentDir(), entry);
   }
   if (!resolved)
     return false;
   try {
-    if (!existsSync13(resolved))
+    if (!existsSync14(resolved))
       return false;
-    const pkgPath = join16(resolved, "package.json");
-    if (!existsSync13(pkgPath))
+    const pkgPath = join17(resolved, "package.json");
+    if (!existsSync14(pkgPath))
       return false;
     const pkg = JSON.parse(readFileSync9(pkgPath, "utf-8"));
     return pkg.name === PLUGIN_NAME2;
@@ -17774,7 +18081,7 @@ class PiAdapter {
   }
   getHostVersion() {
     try {
-      const result = spawnSync4("pi", ["--version"], {
+      const result = spawnSync5("pi", ["--version"], {
         stdio: ["ignore", "pipe", "pipe"],
         encoding: "utf-8",
         timeout: 5000
@@ -17794,10 +18101,10 @@ class PiAdapter {
     const configDir = getPiAgentDir();
     const index = readPiExtensionIndex();
     const aftConfigPath = resolveCortexKitUserConfigPath();
-    const aftConfigExists = existsSync13(aftConfigPath);
+    const aftConfigExists = existsSync14(aftConfigPath);
     return {
       configDir,
-      harnessConfig: index.path ?? join16(configDir, "extensions.json"),
+      harnessConfig: index.path ?? join17(configDir, "extensions.json"),
       harnessConfigFormat: index.path ? "json" : "none",
       aftConfig: aftConfigPath,
       aftConfigFormat: aftConfigExists ? "jsonc" : "none"
@@ -17842,12 +18149,12 @@ class PiAdapter {
   }
   getPluginCacheInfo() {
     const candidates = [
-      join16(getPiAgentDir(), "npm", "node_modules", "@cortexkit", "aft-pi", "package.json"),
-      join16(getPiAgentDir(), "node_modules", "@cortexkit", "aft-pi", "package.json"),
-      join16(getPiAgentDir(), "extensions", "node_modules", "@cortexkit", "aft-pi", "package.json")
+      join17(getPiAgentDir(), "npm", "node_modules", "@cortexkit", "aft-pi", "package.json"),
+      join17(getPiAgentDir(), "node_modules", "@cortexkit", "aft-pi", "package.json"),
+      join17(getPiAgentDir(), "extensions", "node_modules", "@cortexkit", "aft-pi", "package.json")
     ];
     for (const candidate of candidates) {
-      if (!existsSync13(candidate))
+      if (!existsSync14(candidate))
         continue;
       try {
         const pkg = JSON.parse(readFileSync9(candidate, "utf-8"));
@@ -17861,7 +18168,7 @@ class PiAdapter {
       } catch {}
     }
     return {
-      path: join16(getPiAgentDir(), "npm", "node_modules", "@cortexkit", "aft-pi", "package.json"),
+      path: join17(getPiAgentDir(), "npm", "node_modules", "@cortexkit", "aft-pi", "package.json"),
       exists: false
     };
   }
@@ -17883,12 +18190,12 @@ class PiAdapter {
   describeStorageSubtrees() {
     const storage = this.getStorageDir();
     return {
-      index: dirSize(join16(storage, "index")),
-      semantic: dirSize(join16(storage, "semantic")),
-      backups: dirSize(join16(storage, "backups")),
-      url_cache: dirSize(join16(storage, "url_cache")),
-      onnxruntime: dirSize(join16(storage, "onnxruntime")),
-      logs: dirSize(join16(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"))
     };
   }
 }
@@ -19345,14 +19652,14 @@ var exports_commands = {};
 __export(exports_commands, {
   runIndex: () => runIndex
 });
-import { spawnSync as spawnSync5 } from "node:child_process";
+import { spawnSync as spawnSync6 } from "node:child_process";
 function runIndex(argv) {
   const binary = findAftBinary();
   if (!binary) {
     console.error("aft index requires a native AFT binary; run `aft doctor` to install or repair it.");
     return 1;
   }
-  const result = spawnSync5(binary, ["index", ...argv], {
+  const result = spawnSync6(binary, ["index", ...argv], {
     stdio: "inherit",
     env: process.env
   });
@@ -19367,7 +19674,7 @@ var init_commands = __esm(async () => {
 });
 
 // src/lib/aft-bridge.ts
-import { spawn as spawn3 } from "node:child_process";
+import { spawn as spawn4 } from "node:child_process";
 function isResponseForRequest(parsed, expectedIds) {
   if (!parsed || typeof parsed !== "object")
     return false;
@@ -19386,7 +19693,7 @@ async function sendAftRequest(binaryPath, request) {
 }
 async function sendAftRequests(binaryPath, requests) {
   return new Promise((resolve10, reject) => {
-    const child = spawn3(binaryPath, [], {
+    const child = spawn4(binaryPath, [], {
       stdio: ["pipe", "pipe", "pipe"]
     });
     const responses = [];
@@ -19501,21 +19808,21 @@ __export(exports_lsp, {
   runLspDoctor: () => runLspDoctor,
   typescriptPackageWarning: () => typescriptPackageWarning
 });
-import { existsSync as existsSync14, readdirSync as readdirSync5, statSync as statSync9 } from "node:fs";
+import { existsSync as existsSync15, readdirSync as readdirSync5, statSync as statSync9 } from "node:fs";
 import { createRequire as createRequire4 } from "node:module";
-import { dirname as dirname8, join as join17, resolve as resolve10 } from "node:path";
+import { dirname as dirname8, join as join18, resolve as resolve10 } from "node:path";
 function findProjectRootForFile(filePath, fallbackCwd = process.cwd()) {
   const resolvedFile = resolve10(fallbackCwd, filePath);
   let dir = dirname8(resolvedFile);
   try {
-    if (existsSync14(resolvedFile) && statSync9(resolvedFile).isDirectory()) {
+    if (existsSync15(resolvedFile) && statSync9(resolvedFile).isDirectory()) {
       dir = resolvedFile;
     }
   } catch {
     dir = dirname8(resolvedFile);
   }
   while (true) {
-    if (PROJECT_ROOT_MARKERS.some((marker) => existsSync14(join17(dir, marker)))) {
+    if (PROJECT_ROOT_MARKERS.some((marker) => existsSync15(join18(dir, marker)))) {
       return dir;
     }
     const parent = dirname8(dir);
@@ -19652,9 +19959,9 @@ function parseFileArg(argv) {
 function buildConfigureParams(adapter, projectRoot) {
   const userConfigPath = adapter.detectConfigPaths().aftConfig;
   const dir = adapter.kind === "pi" ? ".pi" : ".opencode";
-  const projectJsonc = join17(projectRoot, dir, "aft.jsonc");
-  const projectJson = join17(projectRoot, dir, "aft.json");
-  const projectConfigPath = existsSync14(projectJsonc) ? projectJsonc : projectJson;
+  const projectJsonc = join18(projectRoot, dir, "aft.jsonc");
+  const projectJson = join18(projectRoot, dir, "aft.json");
+  const projectConfigPath = existsSync15(projectJsonc) ? projectJsonc : projectJson;
   return {
     id: "doctor-lsp-configure",
     command: "configure",
@@ -19667,18 +19974,18 @@ function buildConfigureParams(adapter, projectRoot) {
 function inferLspPathsExtra(_lsp) {
   const paths = new Set;
   for (const entry of childDirs(getAftLspPackagesDir())) {
-    paths.add(join17(entry, "node_modules", ".bin"));
+    paths.add(join18(entry, "node_modules", ".bin"));
   }
   for (const entry of childDirs(getAftLspBinariesDir())) {
-    paths.add(join17(entry, "bin"));
+    paths.add(join18(entry, "bin"));
   }
   return [...paths];
 }
 function childDirs(path2) {
-  if (!existsSync14(path2))
+  if (!existsSync15(path2))
     return [];
   try {
-    return readdirSync5(path2).map((entry) => join17(path2, entry)).filter((entry) => {
+    return readdirSync5(path2).map((entry) => join18(path2, entry)).filter((entry) => {
       try {
         return statSync9(entry).isDirectory();
       } catch {
@@ -19720,7 +20027,7 @@ function typescriptPackageWarning(response) {
   if (!typescriptServerSpawned || !response.project_root || diagnosticsCount > 0)
     return null;
   try {
-    createRequire4(join17(response.project_root, "package.json")).resolve("typescript");
+    createRequire4(join18(response.project_root, "package.json")).resolve("typescript");
     return null;
   } catch {
     return "typescript package not resolvable from project — server will produce no diagnostics";
@@ -19768,7 +20075,7 @@ __export(exports_doctor_filters, {
   renderTrustedProjects: () => renderTrustedProjects,
   runDoctorFilters: () => runDoctorFilters
 });
-import { existsSync as existsSync15 } from "node:fs";
+import { existsSync as existsSync16 } from "node:fs";
 import { homedir as homedir16 } from "node:os";
 import { relative as relative3, resolve as resolve11 } from "node:path";
 function printDoctorFiltersHelp() {
@@ -19811,7 +20118,7 @@ async function runDoctorFilters(options) {
     log2.error(list.message ?? list.code ?? "list_filters failed");
     return 1;
   }
-  list.project_dir_exists = list.project_dir ? existsSync15(list.project_dir) : false;
+  list.project_dir_exists = list.project_dir ? existsSync16(list.project_dir) : false;
   if (mode.kind === "list") {
     console.log(renderFilterList(list, projectRoot));
     return 0;
@@ -20010,11 +20317,11 @@ var init_doctor_filters = __esm(async () => {
 });
 
 // src/lib/binary-cache.ts
-import { existsSync as existsSync16, readdirSync as readdirSync6, statSync as statSync10 } from "node:fs";
-import { join as join18 } from "node:path";
+import { existsSync as existsSync17, readdirSync as readdirSync6, statSync as statSync10 } from "node:fs";
+import { join as join19 } from "node:path";
 function getBinaryCacheInfo(activeVersion) {
   const path2 = getAftBinaryCacheDir();
-  if (!existsSync16(path2)) {
+  if (!existsSync17(path2)) {
     return {
       versions: [],
       activeVersion: null,
@@ -20024,7 +20331,7 @@ function getBinaryCacheInfo(activeVersion) {
   }
   const versions = readdirSync6(path2).filter((entry) => {
     try {
-      return statSync10(join18(path2, entry)).isDirectory();
+      return statSync10(join19(path2, entry)).isDirectory();
     } catch {
       return false;
     }
@@ -20122,13 +20429,13 @@ var init_sanitize = __esm(() => {
 });
 
 // src/lib/bridge-tool-failures.ts
-import { closeSync as closeSync5, existsSync as existsSync17, openSync as openSync5, readSync as readSync2, statSync as statSync11 } from "node:fs";
+import { closeSync as closeSync5, existsSync as existsSync18, openSync as openSync5, readSync as readSync2, statSync as statSync11 } from "node:fs";
 function resolveBridgePluginLogPath() {
   const isTestEnv = process.env.BUN_TEST === "1" || false;
   return resolveAftLogPath(isTestEnv ? "aft-plugin-test.log" : "aft-plugin.log");
 }
 function tailLogFileBytes(path2, maxBytes) {
-  if (!existsSync17(path2) || maxBytes <= 0)
+  if (!existsSync18(path2) || maxBytes <= 0)
     return "";
   let fd = null;
   try {
@@ -20264,15 +20571,15 @@ var init_bridge_tool_failures = __esm(() => {
 });
 
 // src/lib/build-breaker.ts
-import { existsSync as existsSync18, readdirSync as readdirSync7 } from "node:fs";
-import { join as join19 } from "node:path";
+import { existsSync as existsSync19, readdirSync as readdirSync7 } from "node:fs";
+import { join as join20 } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 function buildBreakerDatabases(storageRoot) {
-  const callgraphRoot = join19(storageRoot, "callgraph");
-  if (!existsSync18(callgraphRoot))
+  const callgraphRoot = join20(storageRoot, "callgraph");
+  if (!existsSync19(callgraphRoot))
     return [];
   try {
-    return readdirSync7(callgraphRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join19(callgraphRoot, entry.name, "build-breaker.sqlite")).filter((path2) => existsSync18(path2));
+    return readdirSync7(callgraphRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join20(callgraphRoot, entry.name, "build-breaker.sqlite")).filter((path2) => existsSync19(path2));
   } catch {
     return [];
   }
@@ -20348,20 +20655,20 @@ var init_build_breaker = __esm(() => {
 });
 
 // src/lib/legacy-storage.ts
-import { existsSync as existsSync19, readdirSync as readdirSync8, statSync as statSync12 } from "node:fs";
-import { join as join20 } from "node:path";
+import { existsSync as existsSync20, readdirSync as readdirSync8, statSync as statSync12 } from "node:fs";
+import { join as join21 } from "node:path";
 function summarizeLegacyPartitionDuplication(storageRoot) {
-  if (!existsSync19(storageRoot)) {
+  if (!existsSync20(storageRoot)) {
     return { totalPartitions: 0, totalBytes: 0, byHarness: [] };
   }
   const byHarness = [];
   for (const harness of safeReadDir(storageRoot)) {
-    const harnessPath = join20(storageRoot, harness);
+    const harnessPath = join21(storageRoot, harness);
     if (!isDirectory(harnessPath))
       continue;
     const partitions = new Map;
-    collectCallgraphPartitions(join20(harnessPath, "callgraph"), partitions);
-    collectInspectPartitions(join20(harnessPath, "inspect"), partitions);
+    collectCallgraphPartitions(join21(harnessPath, "callgraph"), partitions);
+    collectInspectPartitions(join21(harnessPath, "inspect"), partitions);
     if (partitions.size === 0)
       continue;
     let bytes = 0;
@@ -20380,7 +20687,7 @@ function collectCallgraphPartitions(domainPath, partitions) {
   if (!isDirectory(domainPath))
     return;
   for (const name of safeReadDir(domainPath)) {
-    const path2 = join20(domainPath, name);
+    const path2 = join21(domainPath, name);
     if (isDirectory(path2)) {
       if (!looksLikePartitionKey(name))
         continue;
@@ -20397,7 +20704,7 @@ function collectInspectPartitions(domainPath, partitions) {
   if (!isDirectory(domainPath))
     return;
   for (const name of safeReadDir(domainPath)) {
-    const path2 = join20(domainPath, name);
+    const path2 = join21(domainPath, name);
     if (isDirectory(path2)) {
       if (!looksLikePartitionKey(name))
         continue;
@@ -20472,10 +20779,10 @@ var init_legacy_storage = __esm(() => {
 });
 
 // src/lib/lsp-cache.ts
-import { existsSync as existsSync20, readdirSync as readdirSync9, rmSync as rmSync5, statSync as statSync13 } from "node:fs";
-import { join as join21 } from "node:path";
+import { existsSync as existsSync21, readdirSync as readdirSync9, rmSync as rmSync5, statSync as statSync13 } from "node:fs";
+import { join as join22 } from "node:path";
 function inspectDir(path2) {
-  if (!existsSync20(path2)) {
+  if (!existsSync21(path2)) {
     return { entries: [], totalSize: 0 };
   }
   const entries = [];
@@ -20487,7 +20794,7 @@ function inspectDir(path2) {
     return { entries: [], totalSize: 0 };
   }
   for (const name of names) {
-    const full = join21(path2, name);
+    const full = join22(path2, name);
     try {
       if (!statSync13(full).isDirectory())
         continue;
@@ -20545,8 +20852,8 @@ var init_lsp_cache = __esm(() => {
 });
 
 // src/lib/onnx.ts
-import { existsSync as existsSync21, readdirSync as readdirSync10, readlinkSync as readlinkSync2, realpathSync as realpathSync4 } from "node:fs";
-import { basename as basename3, isAbsolute as isAbsolute6, join as join22, resolve as resolve12, win32 as win322 } from "node:path";
+import { existsSync as existsSync22, readdirSync as readdirSync10, readlinkSync as readlinkSync2, realpathSync as realpathSync4 } from "node:fs";
+import { basename as basename3, isAbsolute as isAbsolute6, join as join23, resolve as resolve12, win32 as win322 } from "node:path";
 function getOnnxLibraryName() {
   if (process.platform === "darwin")
     return "libonnxruntime.dylib";
@@ -20579,8 +20886,8 @@ function pathEnvValue2() {
   return process.env.PATH ?? process.env.Path ?? process.env.path ?? "";
 }
 function pathEntriesForPlatform2() {
-  const delimiter2 = process.platform === "win32" ? ";" : ":";
-  return pathEnvValue2().split(delimiter2).map((entry) => entry.trim().replace(/^"|"$/g, "")).filter((entry) => {
+  const delimiter3 = process.platform === "win32" ? ";" : ":";
+  return pathEnvValue2().split(delimiter3).map((entry) => entry.trim().replace(/^"|"$/g, "")).filter((entry) => {
     if (!entry || entry === "." || entry.includes("\x00"))
       return false;
     return isAbsolute6(entry) || win322.isAbsolute(entry);
@@ -20617,7 +20924,7 @@ function findIgnoredWindowsSystemOnnxRuntime() {
   for (const root of windowsRoots) {
     if (!root)
       continue;
-    const systemDir = join22(root, "System32");
+    const systemDir = join23(root, "System32");
     const key = win322.resolve(systemDir).toLowerCase();
     if (seen.has(key))
       continue;
@@ -20638,13 +20945,13 @@ function findSystemOnnxRuntime2() {
     searchPaths.push(...pathEntriesForPlatform2());
     const programFiles = process.env.ProgramFiles ?? "C:\\Program Files";
     const programFilesX86 = process.env["ProgramFiles(x86)"] ?? "C:\\Program Files (x86)";
-    searchPaths.push(join22(programFiles, "onnxruntime", "lib"), join22(programFiles, "Microsoft ONNX Runtime", "lib"), join22(programFiles, "Microsoft Machine Learning", "lib"), join22(programFilesX86, "onnxruntime", "lib"), ...(() => {
+    searchPaths.push(join23(programFiles, "onnxruntime", "lib"), join23(programFiles, "Microsoft ONNX Runtime", "lib"), join23(programFiles, "Microsoft Machine Learning", "lib"), join23(programFilesX86, "onnxruntime", "lib"), ...(() => {
       const nugetPaths = [];
       const userProfile = process.env.USERPROFILE ?? "";
       if (!userProfile)
         return nugetPaths;
-      const nugetPackageDir = join22(userProfile, ".nuget", "packages", "microsoft.ml.onnxruntime");
-      if (!existsSync21(nugetPackageDir))
+      const nugetPackageDir = join23(userProfile, ".nuget", "packages", "microsoft.ml.onnxruntime");
+      if (!existsSync22(nugetPackageDir))
         return nugetPaths;
       try {
         for (const entry of readdirSync10(nugetPackageDir, { withFileTypes: true })) {
@@ -20652,7 +20959,7 @@ function findSystemOnnxRuntime2() {
             continue;
           if (entry.name === "__globalPackagesFolder" || entry.name.startsWith("."))
             continue;
-          nugetPaths.push(join22(nugetPackageDir, entry.name, "runtimes", "win-x64", "native"), join22(nugetPackageDir, entry.name, "runtimes", "win-arm64", "native"));
+          nugetPaths.push(join23(nugetPackageDir, entry.name, "runtimes", "win-x64", "native"), join23(nugetPackageDir, entry.name, "runtimes", "win-arm64", "native"));
         }
       } catch {}
       return nugetPaths;
@@ -20684,12 +20991,12 @@ function findSystemOnnxRuntime2() {
   return unknownVersionPaths[0] ?? null;
 }
 function findCachedOnnxRuntime(storageDir) {
-  const ortDir = join22(storageDir, "onnxruntime", ONNX_RUNTIME_VERSION);
+  const ortDir = join23(storageDir, "onnxruntime", ONNX_RUNTIME_VERSION);
   const libName = getOnnxLibraryName();
-  if (existsSync21(join22(ortDir, libName)))
+  if (existsSync22(join23(ortDir, libName)))
     return ortDir;
-  const libSubdir = join22(ortDir, "lib");
-  if (existsSync21(join22(libSubdir, libName)))
+  const libSubdir = join23(ortDir, "lib");
+  if (existsSync22(join23(libSubdir, libName)))
     return libSubdir;
   return null;
 }
@@ -20710,7 +21017,7 @@ function parseOrtVersionFromDirectoryPath(value) {
   return null;
 }
 function detectOrtVersion(libDir) {
-  if (!existsSync21(libDir))
+  if (!existsSync22(libDir))
     return null;
   const libName = getOnnxLibraryName();
   try {
@@ -20725,8 +21032,8 @@ function detectOrtVersion(libDir) {
       if (version)
         return version;
     }
-    const base = join22(libDir, libName);
-    if (existsSync21(base)) {
+    const base = join23(libDir, libName);
+    if (existsSync22(base)) {
       try {
         const real = realpathSync4(base);
         const version = parseOrtVersionFromPath(real) ?? parseOrtVersionFromDirectoryPath(real);
@@ -20761,7 +21068,7 @@ import {
   accessSync,
   closeSync as closeSync6,
   constants,
-  existsSync as existsSync22,
+  existsSync as existsSync23,
   openSync as openSync6,
   readSync as readSync3,
   statSync as statSync14
@@ -20800,7 +21107,7 @@ async function diagnoseHarness(adapter) {
   const logPath = adapter.getLogFile();
   const pluginCache = adapter.getPluginCacheInfo();
   const storageAccessible = (() => {
-    if (!existsSync22(storage))
+    if (!existsSync23(storage))
       return false;
     try {
       accessSync(storage, constants.R_OK | constants.W_OK);
@@ -20825,7 +21132,7 @@ async function diagnoseHarness(adapter) {
     pluginRegistered: adapter.hasPluginEntry(),
     configPaths,
     aftConfig: {
-      exists: existsSync22(configPaths.aftConfig),
+      exists: existsSync23(configPaths.aftConfig),
       ...aftConfigRead.error ? { parseError: aftConfigRead.error } : {},
       enabled: aftEnabled,
       ...aftEnabledSource ? { enabledSource: aftEnabledSource } : {},
@@ -20834,7 +21141,7 @@ async function diagnoseHarness(adapter) {
     pluginCache,
     storageDir: {
       path: storage,
-      exists: existsSync22(storage),
+      exists: existsSync23(storage),
       accessible: storageAccessible,
       sizesByKey: describeStorage,
       ...legacyDuplication.totalPartitions > 0 ? { legacyDuplication } : {}
@@ -20855,8 +21162,8 @@ async function diagnoseHarness(adapter) {
     },
     logFile: {
       path: logPath,
-      exists: existsSync22(logPath),
-      sizeKb: existsSync22(logPath) ? Math.round(statSync14(logPath).size / 1024) : 0
+      exists: existsSync23(logPath),
+      sizeKb: existsSync23(logPath) ? Math.round(statSync14(logPath).size / 1024) : 0
     }
   };
 }
@@ -21053,7 +21360,7 @@ function formatDiagnosticIssuesSection(report) {
   return lines;
 }
 function tailLogFile(path2, lines) {
-  if (!existsSync22(path2))
+  if (!existsSync23(path2))
     return "";
   if (lines <= 0)
     return "";
@@ -21103,7 +21410,7 @@ var init_diagnostics = __esm(async () => {
 });
 
 // src/lib/github.ts
-import { execSync as execSync5, spawnSync as spawnSync6 } from "node:child_process";
+import { execSync as execSync5, spawnSync as spawnSync7 } from "node:child_process";
 function isGhInstalled() {
   try {
     execSync5("gh --version", { stdio: "ignore" });
@@ -21119,14 +21426,14 @@ function openBrowser(url) {
   const commands = getOpenBrowserCommand(url);
   try {
     const [cmd, args] = commands;
-    spawnSync6(cmd, args, { stdio: "ignore" });
+    spawnSync7(cmd, args, { stdio: "ignore" });
   } catch {}
 }
 function createGitHubIssue(repo, title, body) {
   if (!isGhInstalled()) {
     return { url: null, stderr: "gh CLI not installed" };
   }
-  const result = spawnSync6("gh", ["issue", "create", "--repo", repo, "--title", title, "--body-file", "-"], {
+  const result = spawnSync7("gh", ["issue", "create", "--repo", repo, "--title", title, "--body-file", "-"], {
     input: body,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -21242,14 +21549,14 @@ var init_issue_body = __esm(() => {
 });
 
 // src/lib/onnx-fix.ts
-import { existsSync as existsSync23, rmSync as rmSync6 } from "node:fs";
-import { join as join23 } from "node:path";
+import { existsSync as existsSync24, rmSync as rmSync6 } from "node:fs";
+import { join as join24 } from "node:path";
 function findOnnxFixCandidates(report) {
   const candidates = [];
   for (const harness of report.harnesses) {
     if (!harness.onnxRuntime.required)
       continue;
-    const storageOnnxDir = join23(harness.storageDir.path, "onnxruntime");
+    const storageOnnxDir = join24(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;
@@ -21258,7 +21565,7 @@ function findOnnxFixCandidates(report) {
         harness,
         reason: `cached ONNX Runtime at ${harness.onnxRuntime.cachedPath} is v${harness.onnxRuntime.cachedVersion}, but AFT requires ${harness.onnxRuntime.requirement}. Clearing it allows an immediate managed download.`,
         storageOnnxDir,
-        storageOnnxBytes: existsSync23(storageOnnxDir) ? dirSize(storageOnnxDir) : 0
+        storageOnnxBytes: existsSync24(storageOnnxDir) ? dirSize(storageOnnxDir) : 0
       });
       continue;
     }
@@ -21267,7 +21574,7 @@ function findOnnxFixCandidates(report) {
         harness,
         reason: `system ONNX Runtime at ${harness.onnxRuntime.systemPath} is v${harness.onnxRuntime.systemVersion}, but AFT requires ${harness.onnxRuntime.requirement}, and no AFT-managed install is present. AFT will leave the system copy untouched and download v1.24 into managed storage.`,
         storageOnnxDir,
-        storageOnnxBytes: existsSync23(storageOnnxDir) ? dirSize(storageOnnxDir) : 0
+        storageOnnxBytes: existsSync24(storageOnnxDir) ? dirSize(storageOnnxDir) : 0
       });
       continue;
     }
@@ -21277,7 +21584,7 @@ function findOnnxFixCandidates(report) {
         harness,
         reason: `no compatible ONNX Runtime is installed.${ignoredCopy} AFT will download v1.24 into managed storage.`,
         storageOnnxDir,
-        storageOnnxBytes: existsSync23(storageOnnxDir) ? dirSize(storageOnnxDir) : 0
+        storageOnnxBytes: existsSync24(storageOnnxDir) ? dirSize(storageOnnxDir) : 0
       });
     }
   }
@@ -21307,7 +21614,7 @@ async function runOnnxFix(adapters, report, options = {}) {
   const rmFn = options.rmFn ?? rmSync6;
   const ensureFn = options.ensureFn ?? ensureOnnxRuntime;
   for (const candidate of candidates) {
-    if (existsSync23(candidate.storageOnnxDir)) {
+    if (existsSync24(candidate.storageOnnxDir)) {
       try {
         rmFn(candidate.storageOnnxDir, { recursive: true, force: true });
         result.cleared += 1;
@@ -21349,10 +21656,10 @@ var init_onnx_fix = __esm(() => {
 });
 
 // src/lib/sessions.ts
-import { existsSync as existsSync24, readdirSync as readdirSync11, readFileSync as readFileSync10, statSync as statSync15 } from "node:fs";
+import { existsSync as existsSync25, readdirSync as readdirSync11, readFileSync as readFileSync10, statSync as statSync15 } from "node:fs";
 import { createRequire as createRequire5 } from "node:module";
 import { homedir as homedir18 } from "node:os";
-import { basename as basename4, join as join24 } from "node:path";
+import { basename as basename4, join as join25 } from "node:path";
 function listRecentSessions(adapter) {
   try {
     if (adapter.kind === "opencode")
@@ -21381,8 +21688,8 @@ function mapOpenCodeSessionRows(rows) {
   }).filter((session) => session !== null).sort((a3, b) => b.lastActivity - a3.lastActivity).slice(0, MAX_RECENT_SESSIONS);
 }
 function listRecentOpenCodeSessions() {
-  const dbPath = join24(getXdgDataHome(), "opencode", "opencode.db");
-  if (!existsSync24(dbPath))
+  const dbPath = join25(getXdgDataHome(), "opencode", "opencode.db");
+  if (!existsSync25(dbPath))
     return [];
   let db = null;
   try {
@@ -21401,10 +21708,10 @@ function listRecentOpenCodeSessions() {
 }
 function getXdgDataHome() {
   const xdgDataHome = process.env.XDG_DATA_HOME;
-  return xdgDataHome && xdgDataHome.length > 0 ? xdgDataHome : join24(homedir18(), ".local", "share");
+  return xdgDataHome && xdgDataHome.length > 0 ? xdgDataHome : join25(homedir18(), ".local", "share");
 }
 function listRecentPiSessions() {
-  return listPiSessionsFromDir(join24(getHomeDir(), ".pi", "agent", "sessions"));
+  return listPiSessionsFromDir(join25(getHomeDir(), ".pi", "agent", "sessions"));
 }
 function getHomeDir() {
   const envHome = process.platform === "win32" ? process.env.USERPROFILE : process.env.HOME;
@@ -21412,7 +21719,7 @@ function getHomeDir() {
 }
 function listPiSessionsFromDir(sessionsDir) {
   try {
-    if (!existsSync24(sessionsDir))
+    if (!existsSync25(sessionsDir))
       return [];
     const files = collectJsonlFiles(sessionsDir).map((filePath) => {
       try {
@@ -21450,7 +21757,7 @@ function collectJsonlFiles(root) {
       continue;
     }
     for (const entry of entries) {
-      const path2 = join24(dir, entry.name);
+      const path2 = join25(dir, entry.name);
       if (entry.isDirectory()) {
         stack.push(path2);
       } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
@@ -21550,10 +21857,10 @@ __export(exports_doctor, {
   runDoctorBuildBreakerReset: () => runDoctorBuildBreakerReset,
   shouldSkipDoctorFixConfirmation: () => shouldSkipDoctorFixConfirmation
 });
-import { execFileSync as execFileSync3 } from "node:child_process";
+import { spawn as spawn5 } from "node:child_process";
 import {
   chmodSync as chmodSync4,
-  existsSync as existsSync25,
+  existsSync as existsSync26,
   mkdirSync as mkdirSync7,
   mkdtempSync,
   readFileSync as readFileSync11,
@@ -21563,7 +21870,7 @@ import {
   writeFileSync as writeFileSync5
 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join25 } from "node:path";
+import { join as join26 } from "node:path";
 async function runDoctor(options) {
   if (options.issue) {
     return runIssueFlow(options.argv);
@@ -21852,7 +22159,7 @@ function clearOldBinaries() {
     errors: [],
     keptVersion: keepTag
   };
-  if (!existsSync25(info.path)) {
+  if (!existsSync26(info.path)) {
     log2.info(`Binary cache: nothing to clear at ${info.path}`);
     return result;
   }
@@ -21862,7 +22169,7 @@ function clearOldBinaries() {
     return result;
   }
   for (const version of stale) {
-    const dir = join25(info.path, version);
+    const dir = join26(info.path, version);
     let bytes = 0;
     try {
       bytes = statSync16(dir).isDirectory() ? dirSize(dir) : 0;
@@ -21931,6 +22238,64 @@ function findSchemaFixTargets(adapters) {
   }
   return targets;
 }
+async function runDoctorNpmInstall(npm, installDir) {
+  const invocation = npmInvocation(npm, [
+    "install",
+    "--no-audit",
+    "--no-fund",
+    "--no-progress",
+    "--ignore-scripts"
+  ]);
+  await new Promise((resolve13, reject) => {
+    const child = spawn5(invocation.command, invocation.args, {
+      cwd: installDir,
+      env: { ...npmSpawnEnv(npm), ...invocation.env },
+      stdio: ["ignore", "ignore", "pipe"],
+      windowsVerbatimArguments: invocation.windowsVerbatimArguments
+    });
+    let stderr = "";
+    let settled = false;
+    let terminating = false;
+    let timeout = null;
+    const finish = (error2) => {
+      if (settled)
+        return;
+      settled = true;
+      if (timeout)
+        clearTimeout(timeout);
+      if (error2)
+        reject(error2);
+      else
+        resolve13();
+    };
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+      if (stderr.length > 16 * 1024)
+        stderr = stderr.slice(-16 * 1024);
+    });
+    child.once("error", (error2) => {
+      if (terminating)
+        return;
+      finish(error2);
+    });
+    child.once("exit", (code) => {
+      if (terminating)
+        return;
+      const detail = stderr.trim();
+      if (code !== 0) {
+        finish(new Error(`npm install exited with code ${code}${detail ? `: ${detail}` : ""}`));
+      } else {
+        finish();
+      }
+    });
+    timeout = setTimeout(() => {
+      if (settled)
+        return;
+      terminating = true;
+      terminateNpmProcessTree(child, invocation).then(() => finish(new Error("npm install timed out after 120000ms")), (error2) => finish(new Error(`npm install timed out and termination outcome is unknown: ${String(error2)}`)));
+    }, 120000);
+  });
+}
 async function applyPluginUpdates(targets) {
   let updated = 0;
   let errors = 0;
@@ -21944,12 +22309,7 @@ async function applyPluginUpdates(targets) {
   }
   for (const target of targets) {
     try {
-      execFileSync3(npm.command, ["install", "--no-audit", "--no-fund", "--no-progress", "--ignore-scripts"], {
-        cwd: target.installDir,
-        env: npmSpawnEnv(npm),
-        stdio: ["ignore", "pipe", "pipe"],
-        timeout: 120000
-      });
+      await runDoctorNpmInstall(npm, target.installDir);
       updated += 1;
       log2.success(`${target.adapter.displayName}: plugin updated ${target.cached} → ${target.latest} (restart ${target.adapter.displayName} to apply)`);
     } catch (err) {
@@ -22209,7 +22569,7 @@ function ensureStorageDirsForRegisteredPlugins(adapters) {
       if (!adapter.isInstalled() || !adapter.hasPluginEntry())
         continue;
       const storageDir = adapter.getStorageDir();
-      if (existsSync25(storageDir))
+      if (existsSync26(storageDir))
         continue;
       mkdirSync7(storageDir, { recursive: true });
       summary.created += 1;
@@ -22225,7 +22585,10 @@ async function clearPluginCache(adapter, includeBytes) {
   const info = adapter.getPluginCacheInfo();
   const bytes = info.exists ? dirSize(info.path) : 0;
   const result = await adapter.clearPluginCache(true);
-  if (result.action === "cleared") {
+  if (result.legacy_path_cleared) {
+    log2.success(`${adapter.displayName}: legacy_path_cleared at ${result.legacy_path_cleared}`);
+  }
+  if (result.action === "cleared" || result.action === "legacy_path_cleared") {
     const suffix = includeBytes ? `, reclaimed ${formatBytes(bytes)}` : "";
     log2.success(`${adapter.displayName}: cleared plugin cache at ${result.path}${suffix}`);
     return { action: "cleared", bytes };
@@ -22334,11 +22697,11 @@ function deriveIssueTitleFromBody(body) {
 function writeIssueReviewFile(body) {
   let reviewDir = null;
   try {
-    reviewDir = mkdtempSync(join25(tmpdir2(), "aft-issue-"));
+    reviewDir = mkdtempSync(join26(tmpdir2(), "aft-issue-"));
     if (process.platform !== "win32") {
       chmodSync4(reviewDir, 448);
     }
-    const outPath = join25(reviewDir, "issue.md");
+    const outPath = join26(reviewDir, "issue.md");
     writeFileSync5(outPath, `${body}
 `, { encoding: "utf8", mode: 384, flag: "wx" });
     return { path: outPath, realPath: realpathSync5(outPath) };