@cortexkit/aft-pi 0.53.0 → 0.55.0

package/dist/index.js

@@ -7711,9 +7711,9 @@ var require_stringify = __commonJS(function(exports, module) {
         value
       } = comment;
       const line_breaks_before = blank_lines > 0 ? blank_lines + (inline ? 0 : 1) : null;
-      const delimiter2 = line_breaks_before > 0 ? repeat_line_breaks(line_breaks_before, deeper_gap) : inline ? SPACE : i === 0 && symbol_tag === PREFIX_BEFORE_ALL && deeper_gap === EMPTY ? EMPTY : LF + deeper_gap;
+      const delimiter3 = line_breaks_before > 0 ? repeat_line_breaks(line_breaks_before, deeper_gap) : inline ? SPACE : i === 0 && symbol_tag === PREFIX_BEFORE_ALL && deeper_gap === EMPTY ? 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);
       blank_lines = 0;
       last_comment = comment;
     });
@@ -7730,10 +7730,10 @@ var require_stringify = __commonJS(function(exports, module) {
     replacer = null;
     indent = EMPTY;
   };
-  var join12 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(one)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two)), gap) : EMPTY;
+  var join13 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(one)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two)), gap) : EMPTY;
   var join_content = (inside, value, gap) => {
     const comment = process_comments(value, PREFIX_BEFORE, gap + indent, true);
-    return join12(comment, inside, gap);
+    return join13(comment, inside, gap);
   };
   var stringify_string = (holder, key, value) => {
     const raw = get_raw_string_literal(holder, key);
@@ -7755,13 +7755,13 @@ var require_stringify = __commonJS(function(exports, module) {
       if (i !== 0) {
         inside += COMMA;
       }
-      const before = join12(after_comma, process_comments(value, BEFORE(i), deeper_gap), deeper_gap);
+      const before = join13(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 += join12(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join13(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) => {
@@ -7782,13 +7782,13 @@ var require_stringify = __commonJS(function(exports, module) {
         inside += COMMA;
       }
       first = false;
-      const before = join12(after_comma, process_comments(value, BEFORE(key), deeper_gap), deeper_gap);
+      const before = join13(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 += join12(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join13(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) {
@@ -8329,10 +8329,68 @@ function skipSpaces(input, start) {
 }
 // ../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";
+
+// ../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);
+}
+
+// ../aft-bridge/dist/bash-host-fallback.js
 var BASH_HOST_FALLBACK_BANNER = "[AFT host fallback - module transport down; no rewrites/compression/background]";
 var BASH_HOST_FALLBACK_MAX_OUTPUT_BYTES = 100 * 1024;
 var BASH_HOST_FALLBACK_MAX_TIMEOUT_MS = 10 * 60 * 1000;
 var BASH_HOST_FALLBACK_REFUSAL = "AFT transport is down; only foreground execution is available in host fallback";
+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:
 
@@ -8365,11 +8423,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
@@ -8432,7 +8496,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,
@@ -8452,8 +8516,8 @@ function resolveBashKillTimeout(modelTimeout, foregroundWaitMs) {
 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";
 
 // ../aft-bridge/dist/command-timeouts.js
@@ -8859,6 +8923,21 @@ class BinaryBridge {
     }
     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)
@@ -8881,7 +8960,7 @@ class BinaryBridge {
       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;
@@ -8935,7 +9014,7 @@ class BinaryBridge {
       }
       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"]) {
@@ -8953,13 +9032,14 @@ class BinaryBridge {
       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) {
@@ -8967,7 +9047,7 @@ class BinaryBridge {
             } 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;
@@ -8982,13 +9062,20 @@ class BinaryBridge {
             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);
@@ -9002,11 +9089,12 @@ class BinaryBridge {
         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);
@@ -9019,6 +9107,9 @@ class BinaryBridge {
         } 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;
@@ -9106,15 +9197,15 @@ class BinaryBridge {
     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");
       });
@@ -9162,15 +9253,15 @@ class BinaryBridge {
       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");
     });
@@ -9200,7 +9291,7 @@ class BinaryBridge {
     })();
     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,
@@ -9208,7 +9299,7 @@ class BinaryBridge {
     };
     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) {
@@ -9387,6 +9478,7 @@ class BinaryBridge {
         if (requestId && entry) {
           this.pending.delete(requestId);
           clearTimeout(entry.timer);
+          entry.onSettled?.();
           entry.resolve({
             success: false,
             code: "permission_required",
@@ -9428,6 +9520,7 @@ class BinaryBridge {
           return;
         this.pending.delete(id);
         clearTimeout(entry.timer);
+        entry.onSettled?.();
         this.consecutiveRequestTimeouts = 0;
         this.scheduleRestartCountReset();
         this.accountForBashTaskResponse(entry.command, response);
@@ -9518,6 +9611,7 @@ class BinaryBridge {
   rejectAllPending(error2) {
     for (const [_id, entry] of this.pending) {
       clearTimeout(entry.timer);
+      entry.onSettled?.();
       entry.reject(error2);
     }
     this.pending.clear();
@@ -9537,32 +9631,32 @@ class BinaryBridge {
   }
 }
 // ../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 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");
 }
 // ../aft-bridge/dist/callgraph-format.js
-import { homedir as homedir4 } from "node:os";
+import { homedir as homedir5 } from "node:os";
 var UNRESOLVED_SUMMARY_NAME_LIMIT = 10;
 var PLAIN_CALLGRAPH_THEME = {
   fg: (_role, text) => text
@@ -9585,7 +9679,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;
@@ -9932,26 +10026,26 @@ function stripHarnessSpecificConfigKeys(value, keys) {
   return stripped;
 }
 // ../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
       });
     }
@@ -9967,9 +10061,9 @@ function formatDroppedKeyWarnings(dropped) {
 // ../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";
 
@@ -10029,8 +10123,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] ?? {};
@@ -10046,16 +10140,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;
@@ -10064,7 +10158,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 {}
   };
@@ -10088,12 +10182,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;
@@ -10158,7 +10252,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.`);
@@ -10274,7 +10368,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);
@@ -10323,7 +10417,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));
     }
   }
 }
@@ -10361,51 +10455,6 @@ async function fetchLatestTag() {
 // ../aft-bridge/dist/durable-log.js
 import { appendFile, mkdir, rename, rm, stat } from "node:fs/promises";
 import { dirname } from "node:path";
-
-// ../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);
-}
-
-// ../aft-bridge/dist/durable-log.js
 var DEFAULT_LOG_BYTES = 32 * 1024 * 1024;
 var DEFAULT_LOG_GENERATIONS = 1;
 class RotatingLogSink {
@@ -12040,7 +12089,7 @@ function pendingKey(handle, corr) {
   return handle ? `${handle.channel}:${handle.epoch}:${corr}` : `0:0:${corr}`;
 }
 // ../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";
 
 // ../aft-bridge/dist/lifecycle-registry.js
 import { lstat } from "node:fs/promises";
@@ -13049,7 +13098,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;
@@ -13881,14 +13930,14 @@ function stripJsoncSymbols(value) {
 }
 // ../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";
 
 // ../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();
@@ -13898,16 +13947,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 [
@@ -13916,10 +13965,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 {
@@ -13930,22 +13979,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 });
@@ -13959,7 +14008,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 {
@@ -14031,10 +14080,10 @@ function decodeFileUrl(target) {
 
 // ../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 as createRequire2 } from "node:module";
 import { homedir as homedir7 } from "node:os";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 var ensureBinaryForResolver = ensureBinary;
 function copyToVersionedCache(npmBinaryPath, knownVersion) {
   try {
@@ -14043,10 +14092,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;
@@ -14058,7 +14107,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 {}
@@ -14078,8 +14127,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);
@@ -14178,7 +14227,7 @@ function findBinarySyncInner(expectedVersion) {
     const packageBin = `@cortexkit/aft-${key}/bin/aft${ext}`;
     const req = createRequire2(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)`);
@@ -14207,8 +14256,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" };
@@ -14254,9 +14303,9 @@ 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")
@@ -14265,8 +14314,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 = "";
@@ -14396,7 +14445,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);
@@ -14418,7 +14467,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);
@@ -14440,11 +14489,11 @@ function atomicWriteConfigFile(targetPath, content) {
 }
 var MOVED_MARKER_SUFFIX = ".MOVED_READPLEASE";
 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}`);
@@ -14538,7 +14587,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 };
@@ -14550,7 +14599,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))
@@ -14600,12 +14649,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;
   }
@@ -14615,11 +14664,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;
   }
@@ -14667,9 +14716,10 @@ async function ensureStorageMigrated(opts) {
   throw new Error(`AFT storage migration failed (${detail}). ` + `Harness: ${opts.harness}. Legacy: ${legacyRoot}. Target: ${newRoot}. ` + `See log: ${logPath}. ` + `Plugin load aborted to prevent legacy/new state divergence.` + (stderrTail ? ` Stderr tail: ${stderrTail}` : "") + (stdoutTail ? ` Stdout tail: ${stdoutTail}` : ""));
 }
 // ../aft-bridge/dist/npm-resolver.js
+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,
@@ -14691,18 +14741,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;
@@ -14711,8 +14761,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));
@@ -14737,22 +14787,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);
   }
@@ -14762,29 +14812,212 @@ 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
+  };
+}
+
+class NpmTerminationUnknownError extends Error {
+  code = "npm_termination_unknown";
+  constructor(detail) {
+    super(`npm process-tree termination could not be confirmed: ${detail}`);
+    this.name = "NpmTerminationUnknownError";
+  }
+}
+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 };
 }
 // ../aft-bridge/dist/onnx-runtime.js
 import { execFileSync } from "node:child_process";
 import { createHash as createHash3 } 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";
 var ORT_VERSION = "1.24.4";
@@ -14847,11 +15080,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 {
@@ -14880,9 +15113,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.`);
@@ -14901,7 +15134,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;
@@ -14938,7 +15171,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 });
     }
@@ -14982,8 +15215,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);
@@ -15014,8 +15247,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);
@@ -15045,10 +15278,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;
 }
@@ -15063,13 +15296,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 })) {
@@ -15077,7 +15310,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)}`);
@@ -15099,11 +15332,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);
@@ -15169,7 +15402,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);
@@ -15204,7 +15437,7 @@ 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}`);
@@ -15220,8 +15453,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 });
@@ -15229,7 +15462,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}`);
@@ -15244,7 +15477,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);
@@ -15269,8 +15502,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") {
@@ -15286,11 +15519,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}`;
@@ -15311,8 +15544,8 @@ 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}`);
   }
@@ -15338,13 +15571,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;
@@ -15750,7 +15983,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;
@@ -15779,17 +16012,27 @@ function editModesPresent(record) {
 function isNonEmptyString(value) {
   return typeof value === "string" && value.length > 0;
 }
+function isNullOrEmptyString(value) {
+  return value === null || value === "";
+}
 var OMIT_OPTIONAL_FIELDS_STEERING = "Omit unused optional fields entirely; do not send empty strings or empty arrays for them.";
 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;
@@ -15842,9 +16085,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;
@@ -15852,7 +16119,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) {
@@ -15863,7 +16130,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) {
@@ -16556,17 +16823,17 @@ function collectStructuredExtras(response) {
   return stringifyData(extras);
 }
 // ../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);
 }
 var SUBC_CLIENT_REAPER_PROCESS_KEY = "subc_client_reaper";
 function booleanOption(value) {
@@ -16640,7 +16907,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);
@@ -16751,6 +17018,8 @@ var UNKNOWN_COMPLETION_CAP = 32;
 var DEFAULT_SESSION_ID2 = "__default__";
 var LOG_PREFIX = "[aft-pi] bg-notifications:";
 var SUBC_NUDGE_LOG_INTERVAL_MS = 60000;
+var DEFAULT_BG_HOP_TIMEOUT_MS = 15000;
+var bgHopTimeoutMs = DEFAULT_BG_HOP_TIMEOUT_MS;
 var subcNudgesInFlight = new Map;
 var subcNudgeLogState = new Map;
 function normalizeSessionID(sessionID) {
@@ -16974,11 +17243,21 @@ function handleSubcBgEventsNudge(drainContext) {
 }
 async function handleSubcBgEventsNudgeOnce(drainContext) {
   bridgeForDrain(drainContext);
-  stateFor(drainContext.sessionID).wakeDeferredTaskIds.clear();
+  const state = stateFor(drainContext.sessionID);
+  state.wakeDeferredTaskIds.clear();
+  rearmHardStoppedWake(state, drainContext);
   await triggerWakeIfPending(drainContext, false, true, true);
 }
 function logSubcNudgeLifecycle(drainContext, kind, message) {
-  const key = `${kind}\x00${drainContext.directory}\x00${drainContext.sessionID}`;
+  logDeliveryHop(drainContext, kind, message, {
+    event: "subc_bg_nudge_delivery",
+    cause: kind
+  });
+}
+function logDeliveryHop(drainContext, kind, message, data, level = "info") {
+  const sessionID = normalizeSessionID(drainContext.sessionID);
+  const taskKey = typeof data.task_id === "string" ? data.task_id : Array.isArray(data.task_ids) ? data.task_ids.join(",") : "";
+  const key = `${kind}\x00${taskKey}\x00${drainContext.directory}\x00${sessionID}`;
   const now = Date.now();
   const state = subcNudgeLogState.get(key);
   if (state && now - state.lastEmittedAt < SUBC_NUDGE_LOG_INTERVAL_MS) {
@@ -16987,13 +17266,48 @@ function logSubcNudgeLifecycle(drainContext, kind, message) {
   }
   const suppressed = state?.suppressed ?? 0;
   subcNudgeLogState.set(key, { lastEmittedAt: now, suppressed: 0 });
-  sessionLog(drainContext.sessionID, `${LOG_PREFIX} ${message}`, {
-    event: "subc_bg_nudge_delivery",
-    cause: kind,
+  const payload = {
+    ...data,
     canonical_root: drainContext.directory,
     suppressed
+  };
+  if (level === "warn") {
+    sessionWarn(sessionID, `${LOG_PREFIX} ${message}`, payload);
+  } else {
+    sessionLog(sessionID, `${LOG_PREFIX} ${message}`, payload);
+  }
+}
+function logPerTaskDeliveryHop(drainContext, kind, message, taskIDs, data, level = "info") {
+  for (const taskID of taskIDs) {
+    logDeliveryHop(drainContext, kind, message, { ...data, task_id: taskID, task_ids: taskIDs }, level);
+  }
+}
+function rearmHardStoppedWake(state, drainContext) {
+  if (!state.wakeHardStopped)
+    return;
+  state.wakeHardStopped = false;
+  state.wakeRetryAttempts = 0;
+  state.retryDelayMs = null;
+  logDeliveryHop(drainContext, "inject-rearmed", "delivery retry re-armed", {
+    event: "bash_completion_inject_rearmed",
+    task_ids: state.pendingCompletions.map((completion) => completion.task_id)
   });
 }
+async function withBgHopTimeout(operation, label) {
+  let timer;
+  try {
+    return await Promise.race([
+      operation,
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(`${label} timed out after ${bgHopTimeoutMs}ms`)), bgHopTimeoutMs);
+        timer.unref?.();
+      })
+    ]);
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+  }
+}
 async function triggerWakeIfPending(drainContext, skipDrain, includeDeferredCompletions = true, forceDrain = false) {
   const state = stateFor(drainContext.sessionID);
   if (!skipDrain && (forceDrain || state.outstandingTaskIds.size > 0 || !state.forcedDrainCompleted)) {
@@ -17003,8 +17317,25 @@ async function triggerWakeIfPending(drainContext, skipDrain, includeDeferredComp
   if (!hasWakeEligiblePending(state, includeDeferredCompletions))
     return;
   scheduleWake(state, async (reminder, deliveredCompletions) => {
-    drainContext.runtime.sendUserMessage(reminder, { deliverAs: "steer" });
     const ackTargetIds = deliveredCompletions.map((completion) => completion.task_id);
+    logPerTaskDeliveryHop(drainContext, "inject-start", "session inject start", ackTargetIds, {
+      event: "bash_completion_wake_send_user_message_start",
+      attempt: state.wakeRetryAttempts + 1
+    });
+    try {
+      drainContext.runtime.sendUserMessage(reminder, { deliverAs: "steer" });
+    } catch (err) {
+      logPerTaskDeliveryHop(drainContext, "inject-error", "session inject failed", ackTargetIds, {
+        event: "bash_completion_wake_send_user_message_error",
+        attempt: state.wakeRetryAttempts + 1,
+        cause: err instanceof Error ? err.message : String(err)
+      }, "warn");
+      throw err;
+    }
+    logPerTaskDeliveryHop(drainContext, "inject-ok", "session inject ok", ackTargetIds, {
+      event: "bash_completion_wake_send_user_message_ok",
+      attempt: state.wakeRetryAttempts + 1
+    });
     markDeliveredAwaitingAck(state, ackTargetIds);
     const acked = await ackCompletions(drainContext, deliveredCompletions);
     if (acked)
@@ -17020,7 +17351,12 @@ async function triggerWakeIfPending(drainContext, skipDrain, includeDeferredComp
       });
       return;
     }
-    sessionWarn(drainContext.sessionID ?? "", hardStopped ? `${LOG_PREFIX} wake send failed ${MAX_WAKE_SEND_ATTEMPTS} times; stopping retries: ${err instanceof Error ? err.message : String(err)}` : `${LOG_PREFIX} wake send failed: ${err instanceof Error ? err.message : String(err)}`);
+    if (hardStopped) {
+      logDeliveryHop(drainContext, "inject-hard-stopped", "delivery retries paused", {
+        event: "bash_completion_inject_hard_stopped",
+        cause: err instanceof Error ? err.message : String(err)
+      });
+    }
   }, includeDeferredCompletions);
 }
 function formatSystemReminder(completions) {
@@ -17090,12 +17426,21 @@ async function drainCompletions(drainContext) {
     const bridge = bridgeForDrain(drainContext);
     const state = stateFor(drainContext.sessionID);
     const params = drainContext.sessionID ? { session_id: drainContext.sessionID } : {};
-    const response = await bridge.send("bash_drain_completions", params);
+    const response = await withBgHopTimeout(bridge.send("bash_drain_completions", params, { timeoutMs: bgHopTimeoutMs }), "bash_drain_completions");
     if (response.success === false) {
-      sessionWarn(drainContext.sessionID ?? "", `${LOG_PREFIX} drain failed: ${String(response.message ?? "unknown error")}`);
+      logDeliveryHop(drainContext, "drain-error", "drain failed", {
+        event: "bash_completion_drain_error",
+        cause: String(response.message ?? "unknown error")
+      }, "warn");
       return;
     }
     state.forcedDrainCompleted = true;
+    const drainedTaskIds = Array.isArray(response.bg_completions) ? response.bg_completions.filter(isBgCompletion).map((completion) => completion.task_id) : [];
+    logDeliveryHop(drainContext, "drain-ok", "drain ok", {
+      event: "bash_completion_drain_ok",
+      count: drainedTaskIds.length,
+      task_ids: drainedTaskIds
+    });
     const reackTaskIds = reconcileAwaitingAck(state, response.bg_completions);
     ingestDrainedBgCompletions(drainContext.sessionID, response.bg_completions);
     if (reackTaskIds.length > 0) {
@@ -17111,7 +17456,10 @@ async function drainCompletions(drainContext) {
   } catch (err) {
     if (drainContext.nudgeRef && isTerminalNudgeError(err))
       throw err;
-    sessionWarn(drainContext.sessionID ?? "", `${LOG_PREFIX} drain failed: ${err instanceof Error ? err.message : String(err)}`);
+    logDeliveryHop(drainContext, "drain-error", "drain failed", {
+      event: "bash_completion_drain_error",
+      cause: err instanceof Error ? err.message : String(err)
+    }, "warn");
   }
 }
 async function ackCompletions(drainContext, completions) {
@@ -17121,16 +17469,25 @@ async function ackCompletions(drainContext, completions) {
   try {
     const bridge = bridgeForDrain(drainContext);
     const params = drainContext.sessionID ? { session_id: drainContext.sessionID, task_ids: taskIds } : { task_ids: taskIds };
-    const response = await bridge.send("bash_ack_completions", params);
+    const response = await withBgHopTimeout(bridge.send("bash_ack_completions", params, { timeoutMs: bgHopTimeoutMs }), "bash_ack_completions");
     if (response.success === false) {
-      sessionWarn(drainContext.sessionID ?? "", `${LOG_PREFIX} ack failed: ${String(response.message ?? "unknown error")}`);
+      logPerTaskDeliveryHop(drainContext, "ack-error", "ack failed", taskIds, {
+        event: "bash_completion_ack_error",
+        cause: String(response.message ?? "unknown error")
+      }, "warn");
       return false;
     }
+    logPerTaskDeliveryHop(drainContext, "ack-ok", "ack ok", taskIds, {
+      event: "bash_completion_ack_ok"
+    });
     return true;
   } catch (err) {
     if (drainContext.nudgeRef && isTerminalNudgeError(err))
       throw err;
-    sessionWarn(drainContext.sessionID ?? "", `${LOG_PREFIX} ack failed: ${err instanceof Error ? err.message : String(err)}`);
+    logPerTaskDeliveryHop(drainContext, "ack-error", "ack failed", taskIds, {
+      event: "bash_completion_ack_error",
+      cause: err instanceof Error ? err.message : String(err)
+    }, "warn");
     return false;
   }
 }
@@ -17461,7 +17818,7 @@ import {
 // package.json
 var package_default = {
   name: "@cortexkit/aft-pi",
-  version: "0.53.0",
+  version: "0.55.0",
   type: "module",
   description: "Pi coding agent extension for Agent File Tools (AFT) — tree-sitter and LSP-powered code analysis",
   main: "dist/index.js",
@@ -17484,19 +17841,19 @@ var package_default = {
     "test:unit": "bun test src/__tests__ --path-ignore-patterns 'src/__tests__/e2e/**'"
   },
   dependencies: {
-    "@cortexkit/aft-bridge": "0.53.0",
+    "@cortexkit/aft-bridge": "0.55.0",
     "comment-json": "^5.0.0",
     diff: "^8.0.4",
     typebox: "1.1.38",
     zod: "^4.4.3"
   },
   optionalDependencies: {
-    "@cortexkit/aft-darwin-arm64": "0.53.0",
-    "@cortexkit/aft-darwin-x64": "0.53.0",
-    "@cortexkit/aft-linux-arm64": "0.53.0",
-    "@cortexkit/aft-linux-x64": "0.53.0",
-    "@cortexkit/aft-win32-arm64": "0.53.0",
-    "@cortexkit/aft-win32-x64": "0.53.0"
+    "@cortexkit/aft-darwin-arm64": "0.55.0",
+    "@cortexkit/aft-darwin-x64": "0.55.0",
+    "@cortexkit/aft-linux-arm64": "0.55.0",
+    "@cortexkit/aft-linux-x64": "0.55.0",
+    "@cortexkit/aft-win32-arm64": "0.55.0",
+    "@cortexkit/aft-win32-x64": "0.55.0"
   },
   devDependencies: {
     "@earendil-works/pi-coding-agent": "^0.80.2",
@@ -17764,7 +18121,7 @@ function appendDegradedStatus(lines, status, markdown) {
 }
 
 // src/tools/_shared.ts
-import { existsSync as existsSync9 } from "node:fs";
+import { existsSync as existsSync10 } from "node:fs";
 import { Type } from "typebox";
 var optionalInt = (min, max, description = "(integer)") => Type.Optional(Type.Union([Type.Integer({ minimum: min, maximum: max }), Type.String()], {
   description
@@ -17785,7 +18142,7 @@ function withPathAliasPreparation(tool) {
   };
 }
 function bridgeFor(ctx, cwd) {
-  if (!existsSync9(cwd)) {
+  if (!existsSync10(cwd)) {
     throw new Error(`project directory no longer exists: ${cwd} (stale restored session?)`);
   }
   return ctx.pool.getBridge(cwd);
@@ -17833,8 +18190,10 @@ async function callBridge(bridge, command, params = {}, extCtx, options) {
   return response;
 }
 async function callToolCall(bridge, name, rawArgs = {}, extCtx, options) {
+  return callToolCallForSession(bridge, name, rawArgs, extCtx ? resolveSessionId(extCtx) : undefined, extCtx, options);
+}
+async function callToolCallForSession(bridge, name, rawArgs, sessionId, extCtx, options) {
   const timeoutMs = timeoutForCommand(name);
-  const sessionId = extCtx ? resolveSessionId(extCtx) : undefined;
   const sendOptions = {
     ...timeoutMs !== undefined ? { timeoutMs } : {},
     configureWarningClient: extCtx,
@@ -18157,7 +18516,7 @@ function registerStatusCommand(pi, ctx) {
 }
 
 // src/config.ts
-import { existsSync as existsSync10, readFileSync as readFileSync7, renameSync as renameSync5, unlinkSync as unlinkSync5, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync11, readFileSync as readFileSync7, renameSync as renameSync5, unlinkSync as unlinkSync5, writeFileSync as writeFileSync4 } from "node:fs";
 import { homedir as homedir12 } from "node:os";
 import { isAbsolute as isAbsolute6 } from "node:path";
 var import_comment_json = __toESM(require_src2(), 1);
@@ -19773,8 +20132,8 @@ function emoji() {
 }
 var ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
 var ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;
-var mac = (delimiter2) => {
-  const escapedDelim = escapeRegex(delimiter2 ?? ":");
+var mac = (delimiter3) => {
+  const escapedDelim = escapeRegex(delimiter3 ?? ":");
   return new RegExp(`^(?:[0-9A-F]{2}${escapedDelim}){5}[0-9A-F]{2}$|^(?:[0-9a-f]{2}${escapedDelim}){5}[0-9a-f]{2}$`);
 };
 var cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
@@ -32439,6 +32798,26 @@ function date4(params) {
 // ../../node_modules/.bun/zod@4.4.3/node_modules/zod/v4/classic/external.js
 config(en_default());
 // src/config.ts
+var ACTIVE_HARNESS = "pi";
+function isConfigRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeConfigForActiveHarness(value) {
+  const config2 = stripHarnessSpecificConfigKeys(value, OPENCODE_ONLY_KEYS);
+  if (!isConfigRecord(config2) || !isConfigRecord(config2.harnesses))
+    return config2;
+  const override = config2.harnesses[ACTIVE_HARNESS];
+  return {
+    ...config2,
+    harnesses: override === undefined ? {} : { [ACTIVE_HARNESS]: stripHarnessSpecificConfigKeys(override, OPENCODE_ONLY_KEYS) }
+  };
+}
+function warnIgnoredNestedHarnesses(rawConfig, configPath) {
+  const override = isConfigRecord(rawConfig.harnesses) ? rawConfig.harnesses[ACTIVE_HARNESS] : undefined;
+  if (isConfigRecord(override) && Object.hasOwn(override, "harnesses")) {
+    warn2(`Ignoring nested harnesses in harnesses.${ACTIVE_HARNESS} from ${configPath}; harness overrides cannot recurse`);
+  }
+}
 var DEFAULT_INSPECT_DIAGNOSTICS_TIMEOUT_MS = 120000;
 var MIN_INSPECT_DIAGNOSTICS_TIMEOUT_MS = 1e4;
 var MAX_INSPECT_DIAGNOSTICS_TIMEOUT_MS = 600000;
@@ -32457,6 +32836,7 @@ function resolveBashConfig(config2) {
   const surfaceDefaultEnabled = surface !== "minimal";
   const reminderEnabled = (typeof top === "object" && top !== null ? top.long_running_reminder_enabled : undefined) ?? legacy?.long_running_reminder_enabled;
   const reminderInterval = (typeof top === "object" && top !== null ? top.long_running_reminder_interval_ms : undefined) ?? legacy?.long_running_reminder_interval_ms;
+  const topDetachOnUserMessage = typeof top === "object" && top !== null ? top.detach_on_user_message ?? true : true;
   const rawForegroundWait = typeof top === "object" && top !== null ? top.foreground_wait_window_ms : undefined;
   const foregroundWaitWindowMs = Math.max(FOREGROUND_WAIT_WINDOW_MIN_MS, rawForegroundWait ?? FOREGROUND_WAIT_WINDOW_DEFAULT_MS);
   const base = {
@@ -32465,9 +32845,11 @@ function resolveBashConfig(config2) {
     compress: false,
     background: false,
     host_fallback: false,
+    detach_on_user_message: true,
     long_running_reminder_enabled: reminderEnabled,
     long_running_reminder_interval_ms: reminderInterval,
-    foreground_wait_window_ms: foregroundWaitWindowMs
+    foreground_wait_window_ms: foregroundWaitWindowMs,
+    powershell_tool: typeof top === "object" && top !== null ? top.powershell_tool ?? false : false
   };
   if (top === false)
     return base;
@@ -32481,7 +32863,8 @@ function resolveBashConfig(config2) {
       rewrite: top.rewrite ?? true,
       compress: top.compress ?? true,
       background: top.background ?? true,
-      host_fallback: top.host_fallback ?? false
+      host_fallback: top.host_fallback ?? false,
+      detach_on_user_message: topDetachOnUserMessage
     };
   }
   const hasLegacyFeatureFlag = legacy && (legacy.rewrite !== undefined || legacy.compress !== undefined || legacy.background !== undefined);
@@ -32595,9 +32978,11 @@ var BashFeaturesSchema = exports_external.object({
   compress: exports_external.boolean().optional(),
   background: exports_external.boolean().optional(),
   host_fallback: exports_external.boolean().optional(),
+  detach_on_user_message: exports_external.boolean().optional(),
   long_running_reminder_enabled: exports_external.boolean().optional(),
   long_running_reminder_interval_ms: exports_external.number().int().positive().optional(),
-  foreground_wait_window_ms: exports_external.number().int().positive().optional()
+  foreground_wait_window_ms: exports_external.number().int().positive().optional(),
+  powershell_tool: exports_external.boolean().optional()
 });
 var BashConfigSchema = exports_external.union([exports_external.boolean(), BashFeaturesSchema]);
 var SandboxConfigSchema = exports_external.object({
@@ -32617,6 +33002,9 @@ var GhShimConfigSchema = exports_external.object({
   enabled: exports_external.boolean().optional(),
   binary_path: exports_external.string().trim().refine(isAbsolute6, "gh_shim.binary_path must be absolute").optional()
 });
+var GhReadConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().optional()
+});
 var GitCoAuthorSchema = exports_external.string().trim().refine((value) => value === "off" || value === "auto" || /^[^<>\r\n]+\s+<[^<>\s@]+@[^<>\s@]+>$/.test(value), "git.co_author must be 'off', 'auto', or an explicit 'Name <email>' identity");
 var GitConfigSchema = exports_external.object({
   co_author: GitCoAuthorSchema.optional()
@@ -32640,7 +33028,7 @@ var BackupConfigSchema = exports_external.object({
   max_depth: exports_external.number().int().positive().optional(),
   max_file_size: exports_external.number().int().positive().optional()
 });
-var AftConfigSchema = exports_external.preprocess((value) => stripHarnessSpecificConfigKeys(value, OPENCODE_ONLY_KEYS), exports_external.object({
+var AftConfigFieldsSchema = exports_external.object({
   $schema: exports_external.string().optional(),
   enabled: exports_external.boolean().optional(),
   edit_mode: exports_external.enum(["default", "hashline"]).optional(),
@@ -32671,8 +33059,22 @@ var AftConfigSchema = exports_external.preprocess((value) => stripHarnessSpecifi
   bridge: BridgeConfigSchema.optional(),
   subc: SubcConfigSchema.optional(),
   gh_shim: GhShimConfigSchema.optional(),
+  gh_read: GhReadConfigSchema.optional(),
   git: GitConfigSchema.optional()
+});
+var HarnessOverrideSchema = exports_external.preprocess((value) => {
+  if (!isConfigRecord(value) || !Object.hasOwn(value, "harnesses"))
+    return value;
+  const { harnesses: _nestedHarnesses, ...override } = value;
+  return override;
+}, AftConfigFieldsSchema.strict());
+var AftConfigSchema = exports_external.preprocess(normalizeConfigForActiveHarness, AftConfigFieldsSchema.extend({
+  harnesses: exports_external.record(exports_external.string(), HarnessOverrideSchema).optional()
 }).strict());
+function applyActiveHarnessOverride(config2) {
+  const { harnesses: _harnesses, ...base } = config2;
+  return { ...base, ...config2.harnesses?.[ACTIVE_HARNESS] };
+}
 var CONFIG_MIGRATIONS = [
   { oldKey: "experimental_search_index", newPath: ["search_index"] },
   { oldKey: "experimental_semantic_search", newPath: ["semantic_search"] },
@@ -32783,7 +33185,7 @@ function migrateExperimentalBashBlock(rawConfig, configPath, logger) {
   return movedKeys;
 }
 function migrateAftConfigFile2(configPath, logger = { log: log2, warn: warn2 }) {
-  if (!existsSync10(configPath)) {
+  if (!existsSync11(configPath)) {
     return { migrated: false, oldKeys: [] };
   }
   let tmpPath = null;
@@ -32842,7 +33244,7 @@ function warnIgnoredHarnessSpecificConfigKeys(config2, configPath) {
 }
 function loadConfigFromPath(configPath) {
   try {
-    if (!existsSync10(configPath))
+    if (!existsSync11(configPath))
       return null;
     const content = readFileSync7(configPath, "utf-8");
     const rawConfig = import_comment_json.parse(content);
@@ -32853,14 +33255,15 @@ function loadConfigFromPath(configPath) {
     migrateRawConfig(rawConfig, configPath, { log: log2, warn: warn2 });
     const cleanConfig = stripJsoncSymbols(rawConfig);
     warnIgnoredHarnessSpecificConfigKeys(cleanConfig, configPath);
+    warnIgnoredNestedHarnesses(cleanConfig, configPath);
     const result = AftConfigSchema.safeParse(cleanConfig);
     if (result.success) {
       log2(`Config loaded from ${configPath}`);
-      return result.data;
+      return applyActiveHarnessOverride(result.data);
     }
     const errorMsg = result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", ");
     warn2(`Config validation error in ${configPath}: ${errorMsg}`);
-    return parseConfigPartially(cleanConfig);
+    return applyActiveHarnessOverride(parseConfigPartially(cleanConfig));
   } catch (err) {
     const errorMsg = err instanceof Error ? err.message : String(err);
     error2(`Error loading config from ${configPath}: ${errorMsg}`);
@@ -33059,6 +33462,8 @@ function getStrippedTopLevelKeys(override) {
     stripped.push("subc");
   if (override.gh_shim !== undefined)
     stripped.push("gh_shim");
+  if (override.gh_read !== undefined)
+    stripped.push("gh_read");
   if (override.disabled_tools?.includes("aft_safety"))
     stripped.push("disabled_tools.aft_safety");
   return stripped;
@@ -33172,11 +33577,11 @@ function loadAftConfig(projectDirectory) {
 }
 
 // src/lsp-auto-install.ts
-import { spawn as spawn3 } from "node:child_process";
+import { spawn as spawn4 } from "node:child_process";
 import { createHash as createHash4 } from "node:crypto";
 import {
   createReadStream,
-  existsSync as existsSync12,
+  existsSync as existsSync13,
   mkdirSync as mkdirSync7,
   readFileSync as readFileSync10,
   renameSync as renameSync6,
@@ -33184,9 +33589,10 @@ import {
   statSync as statSync8,
   writeFileSync as writeFileSync6
 } from "node:fs";
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 
 // src/lsp-cache.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
 import {
   closeSync as closeSync5,
   mkdirSync as mkdirSync6,
@@ -33196,23 +33602,23 @@ import {
   unlinkSync as unlinkSync6,
   writeFileSync as writeFileSync5
 } from "node:fs";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 function lspCacheRoot() {
   return getAftLspPackagesDir();
 }
 function lspPackageDir(npmPackage) {
-  return join12(lspCacheRoot(), encodeURIComponent(npmPackage));
+  return join13(lspCacheRoot(), encodeURIComponent(npmPackage));
 }
 function lspBinaryPath(npmPackage, binary) {
-  return join12(lspPackageDir(npmPackage), "node_modules", ".bin", binary);
+  return join13(lspPackageDir(npmPackage), "node_modules", ".bin", binary);
 }
 function lspBinDir(npmPackage) {
-  return join12(lspPackageDir(npmPackage), "node_modules", ".bin");
+  return join13(lspPackageDir(npmPackage), "node_modules", ".bin");
 }
 function isInstalled(npmPackage, binary) {
   for (const candidate of lspBinaryCandidates(binary)) {
     try {
-      if (statSync7(join12(lspBinDir(npmPackage), candidate)).isFile())
+      if (statSync7(join13(lspBinDir(npmPackage), candidate)).isFile())
         return true;
     } catch {}
   }
@@ -33232,13 +33638,13 @@ function writeInstalledMetaIn(installDir, version2, sha256) {
       installedAt: new Date().toISOString(),
       ...sha256 ? { sha256 } : {}
     };
-    writeFileSync5(join12(installDir, INSTALLED_META_FILE), JSON.stringify(meta3), "utf8");
+    writeFileSync5(join13(installDir, INSTALLED_META_FILE), JSON.stringify(meta3), "utf8");
   } catch (err) {
     log2(`[lsp-cache] failed to write installed-meta in ${installDir}: ${err}`);
   }
 }
 function readInstalledMetaIn(installDir) {
-  const path2 = join12(installDir, INSTALLED_META_FILE);
+  const path2 = join13(installDir, INSTALLED_META_FILE);
   try {
     if (!statSync7(path2).isFile())
       return null;
@@ -33262,33 +33668,52 @@ function readInstalledMeta(packageKey) {
   return readInstalledMetaIn(lspPackageDir(packageKey));
 }
 function lockPath(npmPackage) {
-  return join12(lspPackageDir(npmPackage), ".aft-installing");
+  return join13(lspPackageDir(npmPackage), ".aft-installing");
 }
 var STALE_LOCK_MS2 = 30 * 60 * 1000;
 function acquireInstallLock(lockKey) {
   mkdirSync6(lspPackageDir(lockKey), { recursive: true });
   const lock = lockPath(lockKey);
+  const token = randomUUID2();
   const tryClaim = () => {
     try {
       const fd = openSync5(lock, "wx");
       try {
         writeFileSync5(fd, `${process.pid}
 ${new Date().toISOString()}
+${token}
 `);
       } finally {
         closeSync5(fd);
       }
-      return true;
+      let retained = false;
+      let released = false;
+      return {
+        retain() {
+          retained = true;
+        },
+        release() {
+          if (released)
+            return;
+          released = true;
+          if (retained) {
+            warn2(`[lsp] retaining install lock for ${lockKey} after unconfirmed npm termination; ` + `cross-process retries remain blocked until stale-lock recovery`);
+            return;
+          }
+          releaseInstallLock(lockKey, token);
+        }
+      };
     } catch (err) {
       const code = err.code;
       if (code === "EEXIST")
-        return false;
+        return null;
       warn2(`[lsp] unexpected error acquiring install lock for ${lockKey}: ${err}`);
-      return false;
+      return null;
     }
   };
-  if (tryClaim())
-    return true;
+  const claimed = tryClaim();
+  if (claimed)
+    return claimed;
   let owningPid = null;
   let lockMtimeMs = 0;
   try {
@@ -33306,7 +33731,7 @@ ${new Date().toISOString()}
   const skipLiveness = process.platform === "win32";
   const ownerAlive = !skipLiveness && owningPid !== null && isProcessAlive3(owningPid);
   if (skipLiveness ? ageWithinFresh : ownerAlive && ageWithinFresh) {
-    return false;
+    return null;
   }
   log2(`[lsp] reclaiming install lock for ${lockKey} (owner_pid=${owningPid ?? "unknown"}, alive=${ownerAlive}, age_ms=${age})`);
   try {
@@ -33325,16 +33750,18 @@ function isProcessAlive3(pid) {
     return true;
   }
 }
-function releaseInstallLock(lockKey) {
+function releaseInstallLock(lockKey, acquisitionToken) {
   const lock = lockPath(lockKey);
   try {
     let owningPid = null;
+    let owningToken = "";
     try {
       const raw = readFileSync8(lock, "utf8");
-      const firstLine = raw.split(/\r?\n/, 1)[0]?.trim() ?? "";
-      const parsed = Number.parseInt(firstLine, 10);
+      const lines = raw.split(/\r?\n/);
+      const parsed = Number.parseInt(lines[0]?.trim() ?? "", 10);
       if (Number.isFinite(parsed) && parsed > 0)
         owningPid = parsed;
+      owningToken = lines[2]?.trim() ?? "";
     } catch (readErr) {
       const code = readErr.code;
       if (code === "ENOENT")
@@ -33342,8 +33769,8 @@ function releaseInstallLock(lockKey) {
       warn2(`[lsp] could not read install lock for ${lockKey} during release: ${readErr}`);
       return;
     }
-    if (owningPid !== process.pid) {
-      log2(`[lsp] not releasing install lock for ${lockKey}: owned by pid ${owningPid ?? "unknown"} (we are ${process.pid})`);
+    if (owningPid !== process.pid || owningToken !== acquisitionToken) {
+      log2(`[lsp] not releasing install lock for ${lockKey}: acquisition ownership changed`);
       return;
     }
     try {
@@ -33359,17 +33786,18 @@ function releaseInstallLock(lockKey) {
   }
 }
 async function withInstallLock(lockKey, task) {
-  if (!acquireInstallLock(lockKey))
+  const lease = acquireInstallLock(lockKey);
+  if (!lease)
     return null;
   try {
-    return await task();
+    return await task(lease);
   } finally {
-    releaseInstallLock(lockKey);
+    lease.release();
   }
 }
 var VERSION_CHECK_FILE = ".aft-version-check";
 function readVersionCheck(npmPackage) {
-  const file2 = join12(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
+  const file2 = join13(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
   try {
     const raw = readFileSync8(file2, "utf8");
     const parsed = JSON.parse(raw);
@@ -33386,7 +33814,7 @@ function readVersionCheck(npmPackage) {
 }
 function writeVersionCheck(npmPackage, latest) {
   mkdirSync6(lspPackageDir(npmPackage), { recursive: true });
-  const file2 = join12(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
+  const file2 = join13(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
   const record2 = {
     last_checked: new Date().toISOString(),
     latest_eligible: latest
@@ -33548,8 +33976,8 @@ var NPM_LSP_TABLE = [
 ];
 
 // src/lsp-project-relevance.ts
-import { existsSync as existsSync11, readdirSync as readdirSync4, readFileSync as readFileSync9 } from "node:fs";
-import { join as join13 } from "node:path";
+import { existsSync as existsSync12, readdirSync as readdirSync4, readFileSync as readFileSync9 } from "node:fs";
+import { join as join14 } from "node:path";
 var MAX_WALK_DIRS = 200;
 var MAX_WALK_DEPTH = 4;
 var NOISE_DIRS = new Set([
@@ -33566,7 +33994,7 @@ function hasRootMarker(projectRoot, rootMarkers) {
   if (!rootMarkers)
     return false;
   for (const marker of rootMarkers) {
-    if (existsSync11(join13(projectRoot, marker)))
+    if (existsSync12(join14(projectRoot, marker)))
       return true;
   }
   return false;
@@ -33590,7 +34018,7 @@ function hasPackageJsonDep(projectRoot, depNames) {
 }
 function readPackageJson(projectRoot) {
   try {
-    const raw = readFileSync9(join13(projectRoot, "package.json"), "utf8");
+    const raw = readFileSync9(join14(projectRoot, "package.json"), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null)
       return null;
@@ -33620,7 +34048,7 @@ function relevantExtensionsInProject(projectRoot, extToServer) {
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (current.depth < MAX_WALK_DEPTH && !NOISE_DIRS.has(entry.name.toLowerCase())) {
-          queue.push({ dir: join13(current.dir, entry.name), depth: current.depth + 1 });
+          queue.push({ dir: join14(current.dir, entry.name), depth: current.depth + 1 });
         }
         continue;
       }
@@ -33709,6 +34137,7 @@ function buildExtensionMap(specs) {
   return byExt;
 }
 var inFlightAutoInstalls = new Set;
+var quarantinedNpmInstalls = new Set;
 function trackInFlightAutoInstall(controller, promise2) {
   const entry = { controller, promise: promise2 };
   inFlightAutoInstalls.add(entry);
@@ -33747,8 +34176,8 @@ async function resolveTargetVersion(spec, config2, fetchImpl = fetch) {
 }
 function ensureInstallAnchor(cwd) {
   try {
-    const stub = join14(cwd, "package.json");
-    if (!existsSync12(stub)) {
+    const stub = join15(cwd, "package.json");
+    if (!existsSync13(stub)) {
       writeFileSync6(stub, `${JSON.stringify({ name: "aft-lsp-cache", version: "0.0.0", private: true })}
 `);
     }
@@ -33756,7 +34185,7 @@ function ensureInstallAnchor(cwd) {
     warn2(`[lsp] could not write package.json stub in ${cwd}: ${err}`);
   }
 }
-function runInstall(spec, version2, cwd, signal) {
+function runInstall(spec, version2, cwd, installLock, signal) {
   return new Promise((resolve8) => {
     const target = `${spec.npm}@${version2}`;
     log2(`[lsp] installing ${target} to ${cwd}`);
@@ -33772,19 +34201,25 @@ function runInstall(spec, version2, cwd, signal) {
       return;
     }
     ensureInstallAnchor(cwd);
-    const child = spawn3(npm.command, ["install", "--no-save", "--ignore-scripts", "--silent", target], {
+    const invocation = npmInvocation(npm, [
+      "install",
+      "--no-save",
+      "--ignore-scripts",
+      "--silent",
+      target
+    ]);
+    const child = spawn4(invocation.command, invocation.args, {
       stdio: ["ignore", "pipe", "pipe"],
       cwd,
-      env: npmSpawnEnv(npm)
+      env: { ...npmSpawnEnv(npm), ...invocation.env },
+      windowsVerbatimArguments: invocation.windowsVerbatimArguments
     });
     child.unref();
     let stderrBuf = "";
     let settled = false;
-    let killTimer = null;
+    let terminationPromise = null;
     const cleanup = () => {
       signal?.removeEventListener("abort", onAbort);
-      if (killTimer)
-        clearTimeout(killTimer);
     };
     const finish = (ok) => {
       if (settled)
@@ -33793,14 +34228,31 @@ function runInstall(spec, version2, cwd, signal) {
       cleanup();
       resolve8(ok);
     };
+    const childCompletedSuccessfully = () => child.exitCode === 0 && child.signalCode === null;
+    const finishAfterConfirmedTermination = () => {
+      const completedSuccessfully = childCompletedSuccessfully();
+      if (completedSuccessfully)
+        log2(`[lsp] installed ${target}`);
+      finish(completedSuccessfully);
+    };
     const onAbort = () => {
+      if (childCompletedSuccessfully()) {
+        finishAfterConfirmedTermination();
+        return;
+      }
       warn2(`[lsp] install ${target} aborted during shutdown`);
-      child.kill("SIGTERM");
-      killTimer = setTimeout(() => {
-        if (!settled)
-          child.kill("SIGKILL");
-      }, 5000);
-      killTimer.unref?.();
+      terminationPromise ??= terminateNpmProcessTree(child, invocation);
+      terminationPromise.then(finishAfterConfirmedTermination, (terminationError) => {
+        if (child.pid === undefined) {
+          error2(`[lsp] install ${target} failed to spawn during shutdown: ${terminationError}`);
+          finish(false);
+          return;
+        }
+        quarantinedNpmInstalls.add(spec.npm);
+        installLock.retain();
+        error2(`[lsp] install ${target} termination outcome unknown; quarantining retries for this session: ${String(terminationError)}`);
+        finish(false);
+      });
     };
     signal?.addEventListener("abort", onAbort, { once: true });
     if (signal?.aborted)
@@ -33814,10 +34266,16 @@ function runInstall(spec, version2, cwd, signal) {
       }
     });
     child.on("error", (err) => {
-      error2(`[lsp] install ${target} failed to spawn: ${err}`);
+      if (settled)
+        return;
+      error2(`[lsp] install ${target} child-process error: ${err}`);
+      if (terminationPromise && child.pid !== undefined)
+        return;
       finish(false);
     });
     child.on("exit", (code) => {
+      if (settled || terminationPromise)
+        return;
       if (code === 0) {
         log2(`[lsp] installed ${target}`);
         finish(true);
@@ -33830,7 +34288,13 @@ ${stderrBuf.trim()}`);
   });
 }
 async function ensureServerInstalled(spec, config2, fetchImpl, signal) {
-  const outcome = await withInstallLock(spec.npm, async () => {
+  if (quarantinedNpmInstalls.has(spec.npm)) {
+    return {
+      started: false,
+      reason: "install blocked after unconfirmed npm termination; restart the host to retry"
+    };
+  }
+  const outcome = await withInstallLock(spec.npm, async (installLock) => {
     const { version: version2, probe } = await resolveTargetVersion(spec, config2, fetchImpl);
     if (!version2) {
       const installed = isInstalled(spec.npm, spec.binary);
@@ -33866,7 +34330,7 @@ async function ensureServerInstalled(spec, config2, fetchImpl, signal) {
         log2(`[lsp] reinstalling ${spec.npm}@${version2}: no installed-version metadata recorded`);
       }
     }
-    const ok = await runInstall(spec, version2, cachedPackageDir(spec.npm), signal).catch((err) => {
+    const ok = await runInstall(spec, version2, cachedPackageDir(spec.npm), installLock, signal).catch((err) => {
       error2(`[lsp] background install ${spec.npm} crashed: ${err}`);
       return false;
     });
@@ -33939,10 +34403,10 @@ function sha256OfFileSync(path2) {
 }
 function quarantineCachedNpmInstall(spec, reason) {
   const packageDir = lspPackageDir(spec.npm);
-  const dest = join14(packageDir, "..", ".quarantine", encodeURIComponent(spec.npm), `${Date.now()}`);
+  const dest = join15(packageDir, "..", ".quarantine", encodeURIComponent(spec.npm), `${Date.now()}`);
   warn2(`[lsp] tofu_mismatch ${spec.npm}: ${reason}; quarantining ${packageDir} -> ${dest}`);
   try {
-    mkdirSync7(join14(dest, ".."), { recursive: true });
+    mkdirSync7(join15(dest, ".."), { recursive: true });
     rmSync4(dest, { recursive: true, force: true });
     renameSync6(packageDir, dest);
   } catch (err) {
@@ -34030,7 +34494,7 @@ import {
   copyFileSync as copyFileSync4,
   createReadStream as createReadStream2,
   createWriteStream as createWriteStream3,
-  existsSync as existsSync13,
+  existsSync as existsSync14,
   lstatSync as lstatSync2,
   mkdirSync as mkdirSync8,
   readdirSync as readdirSync5,
@@ -34043,7 +34507,7 @@ import {
   unlinkSync as unlinkSync7,
   writeFileSync as writeFileSync7
 } from "node:fs";
-import { dirname as dirname6, join as join15, relative as relative3, resolve as resolve8 } from "node:path";
+import { dirname as dirname6, join as join16, relative as relative3, resolve as resolve8 } from "node:path";
 import { Readable as Readable3 } from "node:stream";
 import { pipeline as pipeline3 } from "node:stream/promises";
 
@@ -34136,23 +34600,23 @@ function ghCacheRoot() {
   return getAftLspBinariesDir();
 }
 function ghPackageDir(spec) {
-  return join15(ghCacheRoot(), spec.id);
+  return join16(ghCacheRoot(), spec.id);
 }
 function ghBinDir(spec) {
-  return join15(ghPackageDir(spec), "bin");
+  return join16(ghPackageDir(spec), "bin");
 }
 function ghExtractDir(spec) {
-  return join15(ghPackageDir(spec), "extracted");
+  return join16(ghPackageDir(spec), "extracted");
 }
 var INSTALLED_META_FILE2 = ".aft-installed";
 function ghBinaryPath(spec, platform) {
   const ext = platform === "win32" ? ".exe" : "";
-  return join15(ghBinDir(spec), `${spec.binary}${ext}`);
+  return join16(ghBinDir(spec), `${spec.binary}${ext}`);
 }
 function isGithubInstalled(spec, platform) {
   for (const candidate of ghBinaryCandidates(spec, platform)) {
     try {
-      if (statSync9(join15(ghBinDir(spec), candidate)).isFile())
+      if (statSync9(join16(ghBinDir(spec), candidate)).isFile())
         return true;
     } catch {}
   }
@@ -34165,7 +34629,7 @@ function ghBinaryCandidates(spec, platform) {
 }
 function readGithubInstalledMetaIn(installDir) {
   try {
-    const path2 = join15(installDir, INSTALLED_META_FILE2);
+    const path2 = join16(installDir, INSTALLED_META_FILE2);
     if (!statSync9(path2).isFile())
       return null;
     const parsed = JSON.parse(readFileSync11(path2, "utf8"));
@@ -34192,7 +34656,7 @@ function writeGithubInstalledMetaIn(installDir, version2, binarySha256, archiveS
       binarySha256,
       ...archiveSha256 ? { archiveSha256 } : {}
     };
-    writeFileSync7(join15(installDir, INSTALLED_META_FILE2), JSON.stringify(meta3), "utf8");
+    writeFileSync7(join16(installDir, INSTALLED_META_FILE2), JSON.stringify(meta3), "utf8");
   } catch (err) {
     warn2(`[lsp] failed to write github installed metadata in ${installDir}: ${err}`);
   }
@@ -34441,7 +34905,7 @@ function validateExtraction(stagingRoot) {
       throw new Error(`failed to read staging dir ${dir}: ${err}`);
     }
     for (const entry of entries) {
-      const full = join15(dir, entry);
+      const full = join16(dir, entry);
       let lst;
       try {
         lst = lstatSync2(full);
@@ -34529,7 +34993,7 @@ function extractArchiveSafely(archivePath, destDir, archiveType) {
 }
 function quarantineCachedGithubInstall(spec, reason) {
   const packageDir = ghPackageDir(spec);
-  const dest = join15(ghCacheRoot(), ".quarantine", encodeURIComponent(spec.id), `${Date.now()}`);
+  const dest = join16(ghCacheRoot(), ".quarantine", encodeURIComponent(spec.id), `${Date.now()}`);
   warn2(`[lsp] tofu_mismatch ${spec.id}: ${reason}; quarantining ${packageDir} -> ${dest}`);
   try {
     mkdirSync8(dirname6(dest), { recursive: true });
@@ -34542,7 +35006,7 @@ function quarantineCachedGithubInstall(spec, reason) {
 function validateCachedGithubInstall(spec, platform) {
   const packageDir = ghPackageDir(spec);
   const meta3 = readGithubInstalledMetaIn(packageDir);
-  const binaryPath = ghBinaryCandidates(spec, platform).map((candidate) => join15(ghBinDir(spec), candidate)).find((candidate) => {
+  const binaryPath = ghBinaryCandidates(spec, platform).map((candidate) => join16(ghBinDir(spec), candidate)).find((candidate) => {
     try {
       return statSync9(candidate).isFile();
     } catch {
@@ -34620,7 +35084,7 @@ async function downloadAndInstall(spec, tag, assets, platform, arch, fetchImpl,
   }
   const pkgDir = ghPackageDir(spec);
   const extractDir = ghExtractDir(spec);
-  const archivePath = join15(pkgDir, expected.name);
+  const archivePath = join16(pkgDir, expected.name);
   log2(`[lsp] downloading ${spec.id} ${tag} → ${matchingAsset.url}`);
   try {
     await downloadFile(matchingAsset.url, archivePath, fetchImpl, matchingAsset.size, signal);
@@ -34660,8 +35124,8 @@ async function downloadAndInstall(spec, tag, assets, platform, arch, fetchImpl,
       unlinkSync7(archivePath);
     } catch {}
   }
-  const innerBinaryPath = join15(extractDir, spec.binaryPathInArchive(platform, arch, version2));
-  if (!existsSync13(innerBinaryPath)) {
+  const innerBinaryPath = join16(extractDir, spec.binaryPathInArchive(platform, arch, version2));
+  if (!existsSync14(innerBinaryPath)) {
     error2(`[lsp] ${spec.id}: extracted binary not found at ${innerBinaryPath}`);
     return null;
   }
@@ -34745,7 +35209,7 @@ function runGithubAutoInstall(relevantServers, config2, fetchImpl = fetch) {
   if (!host) {
     for (const spec of GITHUB_LSP_TABLE) {
       try {
-        if (existsSync13(ghBinDir(spec))) {
+        if (existsSync14(ghBinDir(spec))) {
           cachedBinDirs.push(ghBinDir(spec));
         }
       } catch {}
@@ -34972,6 +35436,26 @@ function sendFeatureAnnouncement(version2, features, footer, storageDir) {
 
 // src/bash-wait-detach.ts
 var BASH_TRANSPORT_TIMEOUT_MS = 30000;
+var BASH_WAIT_DETACH_MAGIC_KEYWORD = "&detach";
+var EMPTY_DETACH_MESSAGE = "(requested background detach)";
+var STANDALONE_DETACH_KEYWORD_SOURCE = `(^|[^\\p{L}\\p{N}_])${BASH_WAIT_DETACH_MAGIC_KEYWORD}(?![\\p{L}\\p{N}_])`;
+var STANDALONE_DETACH_KEYWORD_PATTERN = new RegExp(STANDALONE_DETACH_KEYWORD_SOURCE, "u");
+var STANDALONE_DETACH_KEYWORDS_PATTERN = new RegExp(STANDALONE_DETACH_KEYWORD_SOURCE, "gu");
+function containsStandaloneDetachKeyword(messageText) {
+  return STANDALONE_DETACH_KEYWORD_PATTERN.test(messageText);
+}
+function stripStandaloneDetachKeywords(messageText) {
+  return messageText.replace(STANDALONE_DETACH_KEYWORDS_PATTERN, "$1");
+}
+function stripUserMessageDetachKeyword(messageText) {
+  if (!containsStandaloneDetachKeyword(messageText))
+    return messageText;
+  const stripped = stripStandaloneDetachKeywords(messageText).replace(/[ \t]{2,}/g, " ");
+  return stripped.trim() === "" ? EMPTY_DETACH_MESSAGE : stripped;
+}
+function shouldDetachBashWaitOnUserMessage(config2, messageText) {
+  return resolveBashConfig(config2).detach_on_user_message || containsStandaloneDetachKeyword(messageText);
+}
 async function sendBashWaitDetach(bridge, sessionID) {
   const response = await bridge.send("bash_wait_detach", { session_id: sessionID }, { keepBridgeOnTimeout: true, transportTimeoutMs: BASH_TRANSPORT_TIMEOUT_MS });
   if (response.success === false) {
@@ -35433,8 +35917,16 @@ function formatReadAttachmentText(attachment) {
   }
   return `Read attachment [${mime}]${size ? ` ${size}` : ""}`;
 }
+var ISSUE_AND_PR_READ_DESCRIPTION = "GitHub issues and pull requests can be read with `issue://NUMBER` and `pr://NUMBER` (or `issue://OWNER/REPO/NUMBER` and `pr://OWNER/REPO/NUMBER`).";
+var READ_DESCRIPTION = "Read file contents with line numbers. Backed by AFT's indexed Rust reader — faster than the built-in `read` on large repos. Images are returned as attachments on vision-capable models; PDFs and non-vision models are not yet supported.";
+function readDescription(ghReadEnabled) {
+  return ghReadEnabled ? `${READ_DESCRIPTION} ${ISSUE_AND_PR_READ_DESCRIPTION}` : READ_DESCRIPTION;
+}
+function visionCapabilityForPiModel(extCtx) {
+  return Array.isArray(extCtx.model?.input) ? extCtx.model.input.includes("image") : undefined;
+}
 function modelSupportsImages(extCtx) {
-  return Array.isArray(extCtx.model?.input) && extCtx.model.input.includes("image");
+  return visionCapabilityForPiModel(extCtx) === true;
 }
 var NON_VISION_IMAGE_NOTE = "[Current model does not support images. The image will be omitted from this request.]";
 function containsPath(parent, child) {
@@ -35652,7 +36144,7 @@ function registerHoistedTools(pi, ctx, surface) {
     pi.registerTool(withPathAliasPreparation({
       name: readName,
       label: readName,
-      description: "Read file contents with line numbers. Backed by AFT's indexed Rust reader — faster than the built-in `read` on large repos. Images are returned as attachments on vision-capable models; PDFs and non-vision models are not yet supported.",
+      description: readDescription(ctx.config.gh_read?.enabled === true),
       promptSnippet: "Read file contents (supports offset/limit for large files)",
       promptGuidelines: [`Use ${readName} to examine files instead of cat or sed.`],
       parameters: ReadParams,
@@ -35680,6 +36172,9 @@ function registerHoistedTools(pi, ctx, surface) {
           rawArgs.offset = offset;
         if (limit !== undefined)
           rawArgs.limit = limit;
+        const visionCapability = visionCapabilityForPiModel(extCtx);
+        if (visionCapability !== undefined)
+          rawArgs.vision_capability = visionCapability;
         const response = await callToolCall(bridge, "read", rawArgs, extCtx);
         if (response.success === false) {
           throw new Error(response.text || response.message || "read failed");
@@ -35763,8 +36258,9 @@ PDFs aren't supported on the Pi harness yet.`, response);
       parameters: HashlineEditParams,
       async execute(_toolCallId, params, _signal, _onUpdate, extCtx) {
         const bridge = bridgeFor(ctx, extCtx.cwd);
+        const sessionId = resolveSessionId(extCtx);
         const rawArgs = { patch: params.patch };
-        const preflight = await callToolCall(bridge, "hashline_preflight", rawArgs, extCtx);
+        const preflight = await callToolCallForSession(bridge, "hashline_preflight", rawArgs, sessionId, extCtx);
         if (preflight.success === false)
           throw toolErrorFromResponse("edit", preflight);
         for (const target of [
@@ -35775,10 +36271,12 @@ PDFs aren't supported on the Pi harness yet.`, response);
             restrictToProjectRoot: surface.restrictToProjectRoot
           });
         }
-        const preview = await callToolCall(bridge, "edit", rawArgs, extCtx, { preview: true });
+        const preview = await callToolCallForSession(bridge, "edit", rawArgs, sessionId, extCtx, {
+          preview: true
+        });
         if (preview.success === false)
           throw toolErrorFromResponse("edit", preview);
-        const response = await callToolCall(bridge, "edit", rawArgs, extCtx);
+        const response = await callToolCallForSession(bridge, "edit", rawArgs, sessionId, extCtx);
         if (response.success === false)
           throw toolErrorFromResponse("edit", response);
         return buildMutationResult(response);
@@ -36328,7 +36826,7 @@ var BashBaseParams = {
     description: "Human-readable description shown in UI logs. Helps users understand what the command does without reading shell syntax."
   })),
   wait: Type4.Optional(Type4.Boolean({
-    description: "When true, run in the foreground without auto-promoting and wait until the command finishes or reaches its timeout; if you send a new message, the wait detaches to background. Use only when you know the result is required before doing anything else."
+    description: "When true, run in the foreground without auto-promoting and wait until the command finishes or reaches its timeout; a new user message detaches by default, while `bash.detach_on_user_message: false` keeps it blocking unless the message contains the literal `&detach`. The token is stripped before delivery; the rest of the message is preserved, and a token-only message becomes `(requested background detach)`. Use only when you know the result is required before doing anything else."
   })),
   sandbox: Type4.Optional(Type4.Literal("host", {
     description: "Request one-command approval to run unsandboxed on the host; use only when native sandboxing blocks required work, and note that it is a no-op when sandboxing is disabled."
@@ -36423,11 +36921,17 @@ ${ask.command ?? ""}
 Working directory:
 ${ask.cwd ?? ""}`;
 }
-async function callBashWithPermissionLoop(bridge, params, extCtx, options) {
+function piPowerShellAskText(command) {
+  return `PowerShell commands are conservatively approved one at a time because AFT's POSIX shell scanner cannot safely interpret PowerShell syntax.
+
+Exact command:
+${command}`;
+}
+async function callBashWithPermissionLoop(bridge, params, extCtx, options, bridgeCommand = "bash") {
   const granted = Array.isArray(params.permissions_granted) ? params.permissions_granted.filter((value) => typeof value === "string") : [];
   for (let round = 0;round < 8; round++) {
     try {
-      return await callBashBridge(bridge, "bash", { ...params, ...granted.length > 0 ? { permissions_granted: granted } : {} }, extCtx, options);
+      return await callBashBridge(bridge, bridgeCommand, { ...params, ...granted.length > 0 ? { permissions_granted: granted } : {} }, extCtx, options);
     } catch (error53) {
       if (!(error53 instanceof BridgeError)) {
         if (error53 instanceof Error && error53.message.includes("permission_required")) {
@@ -36438,19 +36942,30 @@ async function callBashWithPermissionLoop(bridge, params, extCtx, options) {
       if (error53.code !== "permission_required")
         throw error53;
       const asks = Array.isArray(error53.response?.asks) ? error53.response.asks : [];
-      if (asks.length === 0 || asks.some((ask) => ask.kind !== "escalation")) {
-        throw new Error("Permission ask reached Pi adapter without a host escalation grant — this is a bug.");
-      }
-      if (!extCtx.hasUI || typeof extCtx.ui?.confirm !== "function") {
-        throw new BridgeError("Permission denied: host escalation approval requires an interactive UI.", "permission_denied");
+      if (asks.length === 0 || !extCtx.hasUI || typeof extCtx.ui?.confirm !== "function") {
+        throw new BridgeError("Permission denied: command approval requires an interactive UI.", "permission_denied");
       }
       for (const ask of asks) {
-        const approved = await extCtx.ui.confirm("Run command unsandboxed on host?", piEscalationAskText(ask), { signal: extCtx.signal });
+        if (ask.kind === "escalation") {
+          const approved2 = await extCtx.ui.confirm("Run command unsandboxed on host?", piEscalationAskText(ask), { signal: extCtx.signal });
+          if (!approved2) {
+            throw new BridgeError("Permission denied: unsandboxed host execution was denied.", "permission_denied");
+          }
+          if (ask.grant_id && !granted.includes(ask.grant_id))
+            granted.push(ask.grant_id);
+          continue;
+        }
+        if (bridgeCommand !== "powershell") {
+          throw new Error("Permission ask reached Pi adapter without a host escalation grant — this is a bug.");
+        }
+        const approved = await extCtx.ui.confirm("Allow PowerShell command?", piPowerShellAskText(String(params.command ?? "")), { signal: extCtx.signal });
         if (!approved) {
-          throw new BridgeError("Permission denied: unsandboxed host execution was denied.", "permission_denied");
+          throw new BridgeError("Permission denied: PowerShell command was denied.", "permission_denied");
+        }
+        for (const grant of [...ask.always ?? [], ...ask.patterns ?? []]) {
+          if (!granted.includes(grant))
+            granted.push(grant);
         }
-        if (ask.grant_id && !granted.includes(ask.grant_id))
-          granted.push(ask.grant_id);
       }
     }
   }
@@ -36477,23 +36992,27 @@ function getBashSpawnHook(pi) {
   }
   return api2.hooks?.bashSpawn;
 }
-function registerBashTool(pi, ctx, aftSearchRegistered = false, registeredName = "bash", registerCompanions = true) {
-  const spawnHook = getBashSpawnHook(pi);
+function registerBashTool(pi, ctx, aftSearchRegistered = false, registeredName = "bash", registerCompanions = true, shell = "bash") {
+  const isPowerShell = shell === "powershell";
+  const spawnHook = isPowerShell ? undefined : getBashSpawnHook(pi);
   const readToolName = registeredName === "bash" ? "read" : "aft_read";
   const grepToolName = registeredName === "bash" ? "grep" : "aft_grep";
   const searchSteer = aftSearchRegistered ? `use \`aft_search\` (concepts, identifiers, regex, literals), \`${readToolName}\`, \`aft_outline\`, or \`aft_zoom\` instead` : `use the \`${grepToolName}\` tool, \`${readToolName}\`, \`aft_outline\`, or \`aft_zoom\` instead`;
   const bashCfg = resolveBashConfig(ctx.config);
   let hostFallbackActive = false;
   const compressionSentence = bashCfg.compress ? " Output is compressed by default; pass `compressed: false` for raw output. Piped commands run verbatim and show the pipeline's output; for AFT's test/build summary, run the runner without `| head`, `| tail`, or `| grep`." : "";
-  const tasksSentence = bashCfg.background ? ' Commands run in the foreground and return inline; `wait: true` blocks until a long command finishes instead of auto-promoting, but detaches to background if you send a new message — use it when you need the result before doing anything else; keep it off otherwise so auto-promote can remind you while you work. Use `background: true` yourself ONLY when you have other useful work to do while it runs; then `bash_watch` waits on the task (sync blocks until exit/pattern, async notifies) and `bash_status` peeks at it — never background a command and immediately `bash_watch` it (that wastes a turn for what foreground returns in one), and never loop `bash_status` to wait. `pty: true` runs interactive programs (REPLs, TUIs), implies background, and is driven with `bash_status({ output_mode: "screen" })` plus `bash_write`.' : " Commands run in the foreground to completion; `timeout` is the hard kill cap (default 30 minutes).";
+  const detachSentence = bashCfg.detach_on_user_message ? "A new user message detaches this wait. Set `bash.detach_on_user_message: false` to keep it blocking; even then, a message containing the literal `&detach` forces detachment, and the token is stripped before delivery; the rest of the message is preserved, while a token-only message becomes `(requested background detach)`." : "Because `bash.detach_on_user_message` is false, a new user message leaves this wait blocking; include the literal `&detach` anywhere to force detachment, and the token is stripped before delivery; the rest of the message is preserved, while a token-only message becomes `(requested background detach)`.";
+  const tasksSentence = bashCfg.background ? ` Commands run in the foreground and return inline; \`wait: true\` blocks until a long command finishes instead of auto-promoting; ${detachSentence} Use it when you need the result before doing anything else; keep it off otherwise so auto-promote can remind you while you work. Use \`background: true\` yourself ONLY when you have other useful work to do while it runs; then \`bash_watch\` waits on the task (sync blocks until exit/pattern, async notifies) and \`bash_status\` peeks at it — never background a command and immediately \`bash_watch\` it (that wastes a turn for what foreground returns in one), and never loop \`bash_status\` to wait. \`pty: true\` runs interactive programs (REPLs, TUIs), implies background, and is driven with \`bash_status({ output_mode: "screen" })\` plus \`bash_write\`.` : " Commands run in the foreground to completion; `timeout` is the hard kill cap (default 30 minutes).";
   pi.registerTool({
     name: registeredName,
     label: registeredName,
-    description: `Execute shell commands.${compressionSentence}${tasksSentence}
+    description: isPowerShell ? `Execute PowerShell commands through AFT.${compressionSentence}${tasksSentence}
+
+PowerShell syntax is not analyzed as POSIX shell. Each command requires explicit approval so syntax AFT cannot safely interpret is never auto-allowed.` : `Execute shell commands.${compressionSentence}${tasksSentence}
 
 DO NOT use bash for code search or code exploration. If you are about to run grep, rg, sed, awk, find, or cat through bash to locate or read code: STOP — ${searchSteer}.`,
-    promptSnippet: bashCfg.background ? "Run shell commands (timeout in milliseconds; supports workdir, background tasks, compressed output, PTY mode)" : "Run shell commands (timeout in milliseconds; supports workdir and compressed output)",
-    promptGuidelines: [
+    promptSnippet: isPowerShell ? "Run PowerShell commands (timeout in milliseconds; supports workdir, background tasks, compressed output, PTY mode)" : bashCfg.background ? "Run shell commands (timeout in milliseconds; supports workdir, background tasks, compressed output, PTY mode)" : "Run shell commands (timeout in milliseconds; supports workdir and compressed output)",
+    promptGuidelines: isPowerShell ? ["Use PowerShell syntax. Every command requires explicit approval."] : [
       `DO NOT use bash for code search or exploration — ${searchSteer}.`,
       "Set compressed: false when you need ANSI color codes in the output.",
       "Piped commands run verbatim and show the pipeline's output; run test/build tools without pipes when you need AFT's summary."
@@ -36552,7 +37071,8 @@ DO NOT use bash for code search or code exploration. If you are about to run gre
           foreground_orchestrate: true,
           block_to_completion: blockToCompletion,
           wait: requestedWait,
-          sandbox: params.sandbox
+          sandbox: params.sandbox,
+          ...isPowerShell ? { shell: "powershell" } : {}
         }, extCtx, {
           transportTimeoutMs: orchestratedTransportTimeoutMs(blockToCompletion, requestedWait, effectiveTimeout, foregroundWaitMs),
           onProgress: ({ text }) => {
@@ -36560,9 +37080,9 @@ DO NOT use bash for code search or code exploration. If you are about to run gre
             const displayText = truncateToVisualLines(streamed, 100);
             onUpdate?.(bashResult(displayText, { streaming: true }));
           }
-        });
+        }, isPowerShell ? "powershell" : "bash");
       } catch (error53) {
-        if (!bashCfg2.host_fallback || !isBashTransportDeadError(error53))
+        if (isPowerShell || !bashCfg2.host_fallback || !isBashTransportDeadError(error53))
           throw error53;
         if (rawRequestedBackground) {
           throw new Error(`${BASH_HOST_FALLBACK_REFUSAL}; background:true is unsupported.`);
@@ -36609,7 +37129,7 @@ DO NOT use bash for code search or code exploration. If you are about to run gre
         task_id: taskId
       };
       const output = response.output ?? "";
-      return bashResult(usedHostFallback ? output : withBashHints(output, bridgeCommand, aftSearchRegistered, extCtx.cwd), details);
+      return bashResult(usedHostFallback || isPowerShell ? output : withBashHints(output, bridgeCommand, aftSearchRegistered, extCtx.cwd), details);
     },
     renderCall(args, theme, context) {
       return renderBashCall(args?.command, args?.description, theme, context);
@@ -37622,25 +38142,39 @@ function formatPhase(entry) {
   return details.length > 0 ? `${entry.id} (${details.join("; ")})` : entry.id;
 }
 function renderInspectTerminal(terminal, serverText) {
-  const lines = [terminal.kind];
   if (terminal.kind === "FRESH") {
-    lines.push(`wait-stamp: ${terminal.waitStampText ?? "not supplied"}`);
+    const lines = [
+      terminal.kind,
+      `wait-stamp: ${terminal.waitStampText ?? "not supplied"}`
+    ];
+    lines.push(terminal.phases.length > 0 ? `completed phases:
+${terminal.phases.map((phase) => `- ${formatPhase(phase)}`).join(`
+`)}` : "completed phases: none");
+    if (serverText?.trim())
+      lines.push(serverText);
+    return lines.join(`
+`);
   }
   if (terminal.kind === "PHASE-FAILED") {
-    if (terminal.failedPhase)
-      lines.push(`failed phase: ${formatPhase(terminal.failedPhase)}`);
-    lines.push(`failure reason: ${terminal.failureReason ?? "not supplied"}`);
-    if (terminal.failureDetail)
-      lines.push(`failure detail: ${terminal.failureDetail}`);
+    const detail = compactTerminalField(terminal.failureDetail, "not supplied");
+    const reason = compactTerminalField(terminal.failureReason, "not supplied");
+    return [
+      `inspect could not complete: ${detail} (${reason}).`,
+      `Completed phases: ${terminal.phases.length}. Retry, or narrow with sections=...`
+    ].join(`
+`);
   }
-  lines.push(terminal.phases.length > 0 ? `completed phases:
-${terminal.phases.map((phase) => `- ${formatPhase(phase)}`).join(`
-`)}` : "completed phases: none");
-  if (serverText?.trim())
-    lines.push(serverText);
-  return lines.join(`
+  const phaseLabel = terminal.phases.length === 1 ? "phase" : "phases";
+  return [
+    `inspect was interrupted before it could complete (after ${terminal.phases.length} completed ${phaseLabel}); no fresh snapshot was produced.`,
+    "Retry is safe; retry inspect, or narrow with sections=..."
+  ].join(`
 `);
 }
+function compactTerminalField(value, fallback) {
+  const compact = value?.trim().replace(/\s+/g, " ");
+  return compact || fallback;
+}
 function diagnosticsSummaryPart(summary) {
   const section = asRecord3(summary?.diagnostics);
   if (!section)
@@ -37762,9 +38296,19 @@ function renderInspectCall(args, theme, context) {
 function renderInspectResult(result, theme, context, options = { expanded: true }) {
   const payload = extractStructuredPayload(result);
   const terminal = parseInspectTerminal(payload);
+  if (terminal) {
+    const sections2 = [renderInspectTerminal(terminal, asString2(asRecord3(payload)?.text))];
+    return collapsibleResult({
+      summary: sections2[0]?.split(`
+`)[0] ?? "inspect",
+      full: renderSections(sections2, context),
+      expanded: options.expanded,
+      context
+    });
+  }
   if (context.isError)
     return renderErrorResult(result, "inspect failed", theme, context);
-  const sections = terminal ? [renderInspectTerminal(terminal, asString2(asRecord3(payload)?.text))] : buildInspectSections(payload, theme);
+  const sections = buildInspectSections(payload, theme);
   return collapsibleResult({
     summary: sections[0] ?? "inspect completed",
     full: renderSections(sections, context),
@@ -38429,7 +38973,7 @@ var SafetyParams = Type12.Object({
   })),
   name: Type12.Optional(Type12.String({ description: "Checkpoint name (required for checkpoint, restore)" })),
   files: Type12.Optional(Type12.Array(Type12.String(), {
-    description: "Specific files for checkpoint (optional, defaults to all tracked)"
+    description: "Specific files for checkpoint (optional, defaults to all backup-tracked files; explicit files may be untracked or gitignored)"
   }))
 });
 function buildSafetySections(args, payload, theme) {
@@ -38474,14 +39018,16 @@ function buildSafetySections(args, payload, theme) {
       `${theme.fg("muted", "files")} ${asNumber2(response.file_count) ?? 0}`,
       skipped.length > 0 ? `${theme.fg("warning", "skipped")}
 ${skipped.map((entry) => `  ↳ ${shortenPath2(asString2(entry.file) ?? "(file)")}: ${asString2(entry.error) ?? "unknown error"}`).join(`
-`)}` : theme.fg("muted", "No skipped files.")
-    ];
+`)}` : theme.fg("muted", "No skipped files."),
+      asString2(response.durability)
+    ].filter((section) => Boolean(section));
   }
   if (args.op === "restore") {
     return [
       `${theme.fg("success", "checkpoint restored")} ${theme.fg("accent", asString2(response.name) ?? args.name ?? "(checkpoint)")}`,
-      `${theme.fg("muted", "files")} ${asNumber2(response.file_count) ?? 0}`
-    ];
+      `${theme.fg("muted", "files")} ${asNumber2(response.file_count) ?? 0}`,
+      asString2(response.durability)
+    ].filter((section) => Boolean(section));
   }
   const checkpoints = asRecords2(response.checkpoints);
   const sections = [
@@ -38489,6 +39035,9 @@ ${skipped.map((entry) => `  ↳ ${shortenPath2(asString2(entry.file) ?? "(file)"
   ];
   if (checkpoints.length === 0) {
     sections.push(theme.fg("muted", "No checkpoints saved."));
+    const durability2 = asString2(response.durability);
+    if (durability2)
+      sections.push(theme.fg("muted", durability2));
     return sections;
   }
   sections.push(checkpoints.map((checkpoint, index) => {
@@ -38498,6 +39047,9 @@ ${skipped.map((entry) => `  ↳ ${shortenPath2(asString2(entry.file) ?? "(file)"
     return `${index + 1}. ${name} ${theme.fg("muted", `${count} file${count === 1 ? "" : "s"} · ${created}`)}`;
   }).join(`
 `));
+  const durability = asString2(response.durability);
+  if (durability)
+    sections.push(theme.fg("muted", durability));
   return sections;
 }
 function renderSafetyCall(args, theme, context) {
@@ -38718,7 +39270,7 @@ function registerSemanticTool(pi, ctx) {
     ].join(`
 `),
     parameters: SearchParams2,
-    async execute(_toolCallId, params, _signal, _onUpdate, extCtx) {
+    async execute(_toolCallId, params, signal, _onUpdate, extCtx) {
       if (isEmptyParam(params.query) || typeof params.query !== "string" || params.query.trim().length === 0) {
         throw new Error("semantic_search: invalid params: `query` must be a non-empty string");
       }
@@ -38730,7 +39282,7 @@ function registerSemanticTool(pi, ctx) {
         req.includeTests = params.includeTests;
       if (params.path !== undefined)
         req.path = params.path;
-      const response = await callToolCall(bridge, "search", req, extCtx);
+      const response = await callToolCall(bridge, "search", req, extCtx, signal ? { abortSignal: signal } : undefined);
       if (response.success === false) {
         throw new Error(response.text || response.message || "search failed");
       }
@@ -38747,7 +39299,25 @@ function registerSemanticTool(pi, ctx) {
 
 // src/tool-registration.ts
 var ALL_ONLY_TOOLS = new Set(["aft_callgraph", "aft_delete", "aft_move", "aft_refactor"]);
-function resolvePiToolSurface(config2) {
+function resolvePiPowerShellFallback(config2) {
+  return resolveBashConfig(config2).powershell_tool;
+}
+function piPowerShellEnabledFromHost(pi) {
+  const api2 = pi;
+  if (typeof api2.getActiveTools !== "function" || typeof api2.getAllTools !== "function") {
+    return;
+  }
+  try {
+    const tool = api2.getAllTools().find((candidate) => candidate.name === "powershell");
+    const source = tool?.sourceInfo?.source ?? tool?.source;
+    if (!tool || source === undefined)
+      return;
+    return source === "builtin" && api2.getActiveTools().some((active) => (typeof active === "string" ? active : active.name) === "powershell");
+  } catch {
+    return;
+  }
+}
+function resolvePiToolSurface(config2, pi) {
   const surface = config2.tool_surface ?? "recommended";
   const disabled = new Set(config2.disabled_tools ?? []);
   const hoistBuiltinTools = config2.hoist_builtin_tools !== false;
@@ -38755,10 +39325,12 @@ function resolvePiToolSurface(config2) {
   const builtinToolEnabled = (bareName) => ok(hoistBuiltinTools ? bareName : `aft_${bareName}`);
   const allOnly = (name) => ALL_ONLY_TOOLS.has(name) && ok(name);
   const restrictToProjectRoot = config2.restrict_to_project_root ?? false;
+  const powershellEnabled = (pi ? piPowerShellEnabledFromHost(pi) : undefined) ?? resolvePiPowerShellFallback(config2);
   if (surface === "minimal") {
     return {
       hoistBuiltinTools,
       hoistBash: builtinToolEnabled("bash"),
+      hoistPowershell: powershellEnabled && builtinToolEnabled("powershell"),
       hoistRead: false,
       hoistWrite: false,
       hoistEdit: false,
@@ -38782,6 +39354,7 @@ function resolvePiToolSurface(config2) {
   const base = {
     hoistBuiltinTools,
     hoistBash: builtinToolEnabled("bash"),
+    hoistPowershell: powershellEnabled && builtinToolEnabled("powershell"),
     hoistRead: builtinToolEnabled("read"),
     hoistWrite: builtinToolEnabled("write"),
     hoistEdit: builtinToolEnabled("edit"),
@@ -38813,14 +39386,20 @@ function resolvePiToolSurface(config2) {
   return base;
 }
 function registerPiToolSurface(pi, ctx, surface) {
-  if (surface.hoistBash && resolveBashConfig(ctx.config).enabled) {
+  const bashCfg = resolveBashConfig(ctx.config);
+  const bashRegistered = surface.hoistBash && bashCfg.enabled;
+  const powershellRegistered = surface.hoistPowershell && bashCfg.enabled;
+  if (bashRegistered) {
     registerBashTool(pi, ctx, surface.semantic, surface.hoistBuiltinTools ? "bash" : "aft_bash", false);
-    registerBashCompanionTools(pi, ctx);
   }
+  if (powershellRegistered) {
+    registerBashTool(pi, ctx, surface.semantic, surface.hoistBuiltinTools ? "powershell" : "aft_powershell", false, "powershell");
+  }
+  if (bashRegistered || powershellRegistered)
+    registerBashCompanionTools(pi, ctx);
   registerHoistedTools(pi, ctx, surface);
-  if (surface.outline || surface.zoom) {
+  if (surface.outline || surface.zoom)
     registerReadingTools(pi, ctx, surface);
-  }
   if (surface.semantic)
     registerSemanticTool(pi, ctx);
   if (surface.inspect)
@@ -39003,7 +39582,7 @@ var PLUGIN_VERSION = (() => {
     return "0.0.0";
   }
 })();
-var ANNOUNCEMENT_VERSION = "0.53.0";
+var ANNOUNCEMENT_VERSION = "0.55.0";
 var ANNOUNCEMENT_FEATURES = [
   "Callgraph stays consistent under load: edits arriving mid-rebuild can no longer be silently lost from navigation results.",
   "aft_zoom handles real-world .jsonc: files with comment banners above the opening brace now resolve, and not-found errors point at the segment that actually failed (thanks @iceteaSA).",
@@ -39322,7 +39901,7 @@ ${lines}
     });
   }
   pool.setConfigureOverride("harness", "pi");
-  const surface = resolvePiToolSurface(config2);
+  const surface = resolvePiToolSurface(config2, pi);
   const hashlineEditRegistered = config2.edit_mode === "hashline" && surface.hoistEdit;
   pool.setConfigureOverride("edit_slot_survives", hashlineEditRegistered);
   pool.setConfigureOverride("aft_search_registered", surface.semantic);
@@ -39370,6 +39949,17 @@ ${lines}
     sendFeatureAnnouncement(ANNOUNCEMENT_VERSION, ANNOUNCEMENT_FEATURES, ANNOUNCEMENT_FOOTER, storageDir);
   }
   registerPiToolSurface(pi, ctx, surface);
+  let powershellRegistered = surface.hoistPowershell && resolveBashConfig(config2).enabled;
+  pi.on("session_start", () => {
+    if (powershellRegistered)
+      return;
+    const liveSurface = resolvePiToolSurface(config2, pi);
+    if (!liveSurface.hoistPowershell || !resolveBashConfig(config2).enabled)
+      return;
+    registerBashTool(pi, ctx, liveSurface.semantic, liveSurface.hoistBuiltinTools ? "powershell" : "aft_powershell", false, "powershell");
+    registerBashCompanionTools(pi, ctx);
+    powershellRegistered = true;
+  });
   registerWorkflowHints(pi, config2, surface);
   registerStatusCommand(pi, ctx);
   pi.on("tool_result", async (event, extCtx) => {
@@ -39401,10 +39991,18 @@ ${lines}
       });
     }
   });
-  pi.on("input", (_event, extCtx) => {
+  pi.on("input", (event, extCtx) => {
     const sessionId = resolveSessionId(extCtx);
     signalSyncWatchAbort(sessionId);
-    signalBashWaitDetachForProject(pool, extCtx.cwd, sessionId);
+    const originalText = event.text;
+    const transformedText = stripUserMessageDetachKeyword(originalText);
+    const shouldDetach = shouldDetachBashWaitOnUserMessage(config2, originalText);
+    if (shouldDetach) {
+      signalBashWaitDetachForProject(pool, extCtx.cwd, sessionId);
+    }
+    if (transformedText !== originalText) {
+      return { action: "transform", text: transformedText };
+    }
   });
   const unregisterShutdownCleanup = registerShutdownCleanup(async () => {
     try {