@cortexkit/aft-opencode 0.56.1 → 0.57.0

package/dist/index.js

@@ -44,6 +44,17 @@ var __export = (target, all) => {
       set: __exportSetter.bind(all, name)
     });
 };
+var __esm = (fn, res, err) => () => {
+  if (fn)
+    try {
+      res = fn(fn = 0);
+    } catch (e) {
+      err = [e];
+    }
+  if (err)
+    throw err[0];
+  return res;
+};
 
 // ../../node_modules/.bun/esprima@4.0.1/node_modules/esprima/dist/esprima.js
 var require_esprima = __commonJS(function(exports, module) {
@@ -8677,6 +8688,7 @@ class BinaryBridge {
   pending = new Map;
   outstandingBackgroundTaskIds = new Set;
   nextId = 1;
+  processGeneration = 0;
   stdoutBuffer = "";
   stdoutReadOffset = 0;
   stderrBuffer = "";
@@ -8989,6 +9001,7 @@ class BinaryBridge {
         }
       }
       const id = String(this.nextId++);
+      const tool = command === "tool_call" && typeof params.name === "string" ? params.name : command;
       let request;
       if (command === "cancel_request" || Object.hasOwn(params, "command") || Object.hasOwn(params, "method")) {
         const nested = { ...params };
@@ -9042,14 +9055,20 @@ class BinaryBridge {
             return;
           }
           entry.reject(new Error(`${this.errorPrefix} Request "${command}" (id=${id}) timed out after ${effectiveTimeoutMs}ms`));
-          this.handleTimeout(requestSessionId);
+          this.handleTimeout({
+            requestId: id,
+            tool: entry.tool,
+            generation: entry.generation
+          }, requestSessionId);
         }, effectiveTimeoutMs);
         const entry = {
           resolve,
           reject,
           timer,
           onProgress: options?.onProgress,
-          command
+          command,
+          tool,
+          generation: this.processGeneration
         };
         this.pending.set(id, entry);
         if (!child?.stdin?.writable) {
@@ -9352,6 +9371,7 @@ class BinaryBridge {
       this.handleCrash();
     });
     this.process = child;
+    this.processGeneration += 1;
     this.spawnedBinaryFingerprint = readBinaryFingerprint(this.binaryPath);
     this.lastBinaryFingerprintCheckAt = Date.now();
     this.stdoutBuffer = "";
@@ -9523,10 +9543,15 @@ class BinaryBridge {
       this.outstandingBackgroundTaskIds.add(taskId);
     }
   }
-  handleTimeout(triggeringSessionId) {
+  handleTimeout(trigger, triggeringSessionId) {
     this.consecutiveRequestTimeouts = 0;
     this.spawnedBinaryFingerprint = null;
-    this.rejectAllPending(new BridgeTransportUnknownOutcomeError(`${this.errorPrefix} bridge killed during sibling timeout — request aborted`));
+    const abortedSiblings = Array.from(this.pending, ([requestId, entry]) => ({
+      request_id: requestId,
+      tool: entry.tool
+    }));
+    const attribution = `triggering_request_id=${trigger.requestId} ` + `triggering_tool=${JSON.stringify(trigger.tool)} ` + `bridge_generation=${trigger.generation} ` + `aborted_siblings=${JSON.stringify(abortedSiblings)}`;
+    this.rejectAllPending(new BridgeTransportUnknownOutcomeError(`${this.errorPrefix} bridge killed during sibling timeout — request aborted; ${attribution}`));
     this.outstandingBackgroundTaskIds.clear();
     if (this.process) {
       this.process.kill("SIGKILL");
@@ -9536,17 +9561,11 @@ class BinaryBridge {
     this.configured = false;
     const tail = this.formatStderrTail();
     this.stderrTail = [];
-    const killedMsg = tail ? `Bridge killed after timeout.${tail}` : `Bridge killed after timeout (see ${this.getLogFilePathVia()})`;
-    if (tail) {
-      if (triggeringSessionId) {
-        this.sessionErrorVia(triggeringSessionId, killedMsg);
-      } else {
-        this.errorVia(killedMsg);
-      }
-    } else if (triggeringSessionId) {
-      this.sessionWarnVia(triggeringSessionId, killedMsg);
+    const killedMsg = tail ? `Bridge killed after timeout; ${attribution}.${tail}` : `Bridge killed after timeout; ${attribution} (see ${this.getLogFilePathVia()})`;
+    if (triggeringSessionId) {
+      this.sessionErrorVia(triggeringSessionId, killedMsg);
     } else {
-      this.warnVia(killedMsg);
+      this.errorVia(killedMsg);
     }
   }
   handleCrash(cause) {
@@ -15535,12 +15554,36 @@ function isNpmAvailable(deps = defaultDeps()) {
   return resolveNpm(deps) !== null;
 }
 // ../aft-bridge/dist/onnx-runtime.js
-import { execFileSync } from "node:child_process";
+import { execFileSync as execFileSync2 } from "node:child_process";
 import { createHash as createHash4 } from "node:crypto";
-import { chmodSync as chmodSync3, closeSync as closeSync4, copyFileSync as copyFileSync3, createWriteStream as createWriteStream2, existsSync as existsSync9, 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 isAbsolute5, join as join12, 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 existsSync10, lstatSync, mkdirSync as mkdirSync5, openSync as openSync4, readdirSync as readdirSync3, readFileSync as readFileSync6, readlinkSync, realpathSync as realpathSync2, renameSync as renameSync5, 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 isAbsolute5, join as join13, 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";
+
+// ../aft-bridge/dist/tar-executable.js
+import { execFileSync } from "node:child_process";
+import { existsSync as existsSync9 } from "node:fs";
+import { join as join12 } from "node:path";
+function windowsTarExecutable(options = {}) {
+  const platform = options.platform ?? process.platform;
+  if (platform !== "win32")
+    return "tar";
+  const env = options.env ?? process.env;
+  const systemTar = join12(env.SystemRoot ?? "C:\\Windows", "System32", "tar.exe");
+  return (options.exists ?? existsSync9)(systemTar) ? systemTar : "tar";
+}
+function execTarExtractionSync(args, timeout) {
+  const executable = windowsTarExecutable();
+  try {
+    execFileSync(executable, args, { stdio: "pipe", timeout });
+  } catch (cause) {
+    const detail = cause instanceof Error ? cause.message : String(cause);
+    throw new Error(`tar extraction failed using ${executable}: ${detail}`, { cause });
+  }
+}
+
+// ../aft-bridge/dist/onnx-runtime.js
 var ORT_VERSION = "1.24.4";
 var ORT_REPO = "microsoft/onnxruntime";
 var MAX_DOWNLOAD_BYTES2 = 256 * 1024 * 1024;
@@ -15604,11 +15647,11 @@ function getManualInstallHint() {
 }
 async function ensureOnnxRuntime(storageDir) {
   const info = getPlatformInfo();
-  const ortVersionDir = join12(storageDir, "onnxruntime", ORT_VERSION);
+  const ortVersionDir = join13(storageDir, "onnxruntime", ORT_VERSION);
   const libName = info?.libName ?? "libonnxruntime.dylib";
   const resolvedOrtDir = resolveCachedOnnxRuntimeDir(ortVersionDir, libName);
-  const libPath = join12(resolvedOrtDir, libName);
-  if (existsSync9(libPath)) {
+  const libPath = join13(resolvedOrtDir, libName);
+  if (existsSync10(libPath)) {
     const meta = readOnnxInstalledMeta(ortVersionDir);
     if (meta?.sha256) {
       try {
@@ -15637,9 +15680,9 @@ async function ensureOnnxRuntime(storageDir) {
     warn(`ONNX Runtime auto-download not available for ${process.platform}/${process.arch}. Install manually: ${getManualInstallHint()}`);
     return null;
   }
-  const onnxBaseDir = join12(storageDir, "onnxruntime");
+  const onnxBaseDir = join13(storageDir, "onnxruntime");
   mkdirSync5(onnxBaseDir, { recursive: true });
-  const lockPath = join12(onnxBaseDir, ONNX_LOCK_FILE);
+  const lockPath = join13(onnxBaseDir, ONNX_LOCK_FILE);
   cleanupAbandonedStagingDirs(onnxBaseDir);
   if (!acquireLock(lockPath)) {
     warn(`ONNX Runtime install already in progress in another process (lock: ${lockPath}). Skipping.`);
@@ -15658,7 +15701,7 @@ function cleanupAbandonedStagingDirs(onnxBaseDir) {
     for (const entry of entries) {
       if (!entry.startsWith(`${ORT_VERSION}.tmp.`))
         continue;
-      const stagingDir = join12(onnxBaseDir, entry);
+      const stagingDir = join13(onnxBaseDir, entry);
       const parts = entry.split(".");
       const pidStr = parts[parts.length - 2];
       const pid = pidStr ? Number.parseInt(pidStr, 10) : NaN;
@@ -15695,7 +15738,7 @@ function cleanupAbandonedStagingDirs(onnxBaseDir) {
 }
 function cleanupIncompleteTargetIfUnowned(ortDir) {
   try {
-    if (existsSync9(ortDir) && !existsSync9(join12(ortDir, ONNX_INSTALLED_META_FILE))) {
+    if (existsSync10(ortDir) && !existsSync10(join13(ortDir, ONNX_INSTALLED_META_FILE))) {
       log(`[onnx] removing half-populated install dir ${ortDir} (no meta file)`);
       rmSync3(ortDir, { recursive: true, force: true });
     }
@@ -15739,8 +15782,8 @@ function detectOnnxVersion(libDir, libName) {
       if (version)
         return version;
     }
-    const base = join12(libDir, libName);
-    if (existsSync9(base)) {
+    const base = join13(libDir, libName);
+    if (existsSync10(base)) {
       try {
         const real = realpathSync2(base);
         const version = parseOnnxVersionFromPath(real) ?? parseOnnxVersionFromDirectoryPath(real);
@@ -15806,10 +15849,10 @@ function directoryContainsLibrary(dir, libName) {
   }
 }
 function resolveCachedOnnxRuntimeDir(ortVersionDir, libName) {
-  if (existsSync9(join12(ortVersionDir, libName)))
+  if (existsSync10(join13(ortVersionDir, libName)))
     return ortVersionDir;
-  const libSubdir = join12(ortVersionDir, "lib");
-  if (existsSync9(join12(libSubdir, libName)))
+  const libSubdir = join13(ortVersionDir, "lib");
+  if (existsSync10(join13(libSubdir, libName)))
     return libSubdir;
   return ortVersionDir;
 }
@@ -15824,13 +15867,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(join12(programFiles, "onnxruntime", "lib"), join12(programFiles, "Microsoft ONNX Runtime", "lib"), join12(programFiles, "Microsoft Machine Learning", "lib"), join12(programFilesX86, "onnxruntime", "lib"), ...(() => {
+    searchPaths.push(join13(programFiles, "onnxruntime", "lib"), join13(programFiles, "Microsoft ONNX Runtime", "lib"), join13(programFiles, "Microsoft Machine Learning", "lib"), join13(programFilesX86, "onnxruntime", "lib"), ...(() => {
       const nugetPaths = [];
       const userProfile = process.env.USERPROFILE ?? "";
       if (!userProfile)
         return nugetPaths;
-      const nugetPackageDir = join12(userProfile, ".nuget", "packages", "microsoft.ml.onnxruntime");
-      if (!existsSync9(nugetPackageDir))
+      const nugetPackageDir = join13(userProfile, ".nuget", "packages", "microsoft.ml.onnxruntime");
+      if (!existsSync10(nugetPackageDir))
         return nugetPaths;
       try {
         for (const entry of readdirSync3(nugetPackageDir, { withFileTypes: true })) {
@@ -15838,7 +15881,7 @@ function findSystemOnnxRuntime(libName) {
             continue;
           if (entry.name === "__globalPackagesFolder" || entry.name.startsWith("."))
             continue;
-          nugetPaths.push(join12(nugetPackageDir, entry.name, "runtimes", "win-x64", "native"), join12(nugetPackageDir, entry.name, "runtimes", "win-arm64", "native"));
+          nugetPaths.push(join13(nugetPackageDir, entry.name, "runtimes", "win-x64", "native"), join13(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)}`);
@@ -15860,11 +15903,11 @@ function findSystemOnnxRuntime(libName) {
   });
   const unknownVersionPaths = [];
   for (const dir of uniquePaths) {
-    const libPath = join12(dir, libName);
+    const libPath = join13(dir, libName);
     if (process.platform === "win32") {
       if (!directoryContainsLibrary(dir, libName))
         continue;
-    } else if (!existsSync9(libPath)) {
+    } else if (!existsSync10(libPath)) {
       continue;
     }
     const version = detectOnnxVersion(dir, libName);
@@ -15930,7 +15973,7 @@ function validateExtractedTree(stagingRoot) {
   const walk = (dir) => {
     const entries = readdirSync3(dir);
     for (const entry of entries) {
-      const fullPath = join12(dir, entry);
+      const fullPath = join13(dir, entry);
       const lst = lstatSync(fullPath);
       if (lst.isSymbolicLink()) {
         const linkTarget = readlinkSync(fullPath);
@@ -15963,34 +16006,32 @@ async function downloadOnnxRuntime(info, targetDir) {
   const url = `https://github.com/${ORT_REPO}/releases/download/v${ORT_VERSION}/${info.assetName}.${info.archiveType === "tgz" ? "tgz" : "zip"}`;
   log(`Downloading ONNX Runtime v${ORT_VERSION} for ${process.platform}/${process.arch}...`);
   const tmpDir = `${targetDir}.tmp.${process.pid}.${Date.now().toString(36)}`;
+  const extractionRoot = join13(tmpDir, "extract");
+  const stagedInstallDir = join13(tmpDir, "install");
   try {
-    mkdirSync5(tmpDir, { recursive: true });
-    const archivePath = join12(tmpDir, `onnxruntime.${info.archiveType}`);
+    mkdirSync5(extractionRoot, { recursive: true });
+    const archivePath = join13(tmpDir, `onnxruntime.${info.archiveType}`);
     await downloadFileWithCap(url, archivePath);
     const archiveSha256 = sha256File(archivePath);
     log(`ONNX Runtime archive sha256=${archiveSha256}`);
     if (info.archiveType === "tgz") {
-      execFileSync("tar", ["xzf", archivePath, "-C", tmpDir], {
-        stdio: "pipe",
-        timeout: 120000
-      });
+      execTarExtractionSync(["xzf", archivePath, "-C", extractionRoot], 120000);
     } else {
-      await extractZipArchive(archivePath, tmpDir);
+      await extractZipArchive(archivePath, extractionRoot);
     }
     try {
       unlinkSync4(archivePath);
     } catch {}
-    validateExtractedTree(tmpDir);
-    const extractedDir = join12(tmpDir, info.assetName, "lib");
-    if (!existsSync9(extractedDir)) {
+    validateExtractedTree(extractionRoot);
+    const extractedDir = join13(extractionRoot, info.assetName, "lib");
+    if (!existsSync10(extractedDir)) {
       throw new Error(`Expected directory not found: ${extractedDir}`);
     }
-    mkdirSync5(targetDir, { recursive: true });
     const libFiles = readdirSync3(extractedDir).filter((f) => f.startsWith("libonnxruntime") || f.startsWith("onnxruntime"));
     const realFiles = [];
     const symlinks = [];
     for (const libFile of libFiles) {
-      const src = join12(extractedDir, libFile);
+      const src = join13(extractedDir, libFile);
       try {
         const stat = lstatSync(src);
         log(`ORT extract: ${libFile} — isSymlink=${stat.isSymbolicLink()}, isFile=${stat.isFile()}, size=${stat.size}`);
@@ -16004,15 +16045,11 @@ async function downloadOnnxRuntime(info, targetDir) {
         realFiles.push(libFile);
       }
     }
-    copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks);
-    const libPath = join12(targetDir, info.libName);
-    let libHash = null;
-    try {
-      libHash = sha256File(libPath);
-    } catch (err) {
-      warn(`Could not hash newly-installed ONNX library at ${libPath}: ${err}`);
-    }
-    writeOnnxInstalledMeta(targetDir, ORT_VERSION, libHash, archiveSha256);
+    copyOnnxLibraries(info, extractedDir, stagedInstallDir, realFiles, symlinks);
+    const libPath = join13(stagedInstallDir, info.libName);
+    const libHash = sha256File(libPath);
+    writeOnnxInstalledMeta(stagedInstallDir, ORT_VERSION, libHash, archiveSha256);
+    publishOnnxRuntime(stagedInstallDir, targetDir);
     rmSync3(tmpDir, { recursive: true, force: true });
     log(`ONNX Runtime v${ORT_VERSION} installed to ${targetDir}`);
     return targetDir;
@@ -16021,17 +16058,39 @@ async function downloadOnnxRuntime(info, targetDir) {
     try {
       rmSync3(tmpDir, { recursive: true, force: true });
     } catch {}
-    try {
-      rmSync3(targetDir, { recursive: true, force: true });
-    } catch {}
     return null;
   }
 }
+function publishOnnxRuntime(stagedInstallDir, targetDir) {
+  const backupDir = `${targetDir}.backup.${process.pid}.${Date.now().toString(36)}`;
+  const hadTarget = existsSync10(targetDir);
+  if (hadTarget)
+    renameSync5(targetDir, backupDir);
+  try {
+    renameSync5(stagedInstallDir, targetDir);
+  } catch (installError) {
+    if (hadTarget) {
+      try {
+        renameSync5(backupDir, targetDir);
+      } catch (restoreError) {
+        throw new Error(`ONNX Runtime replacement failed and the previous runtime could not be restored from ${backupDir}: ${restoreError}`, { cause: installError });
+      }
+    }
+    throw installError;
+  }
+  if (hadTarget) {
+    try {
+      rmSync3(backupDir, { recursive: true, force: true });
+    } catch (err) {
+      warn(`Could not remove replaced ONNX Runtime backup at ${backupDir}: ${err}`);
+    }
+  }
+}
 function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, copyFile = copyFileSync3) {
   const requiredLibs = new Set([info.libName]);
   for (const libFile of realFiles) {
-    const src = join12(extractedDir, libFile);
-    const dst = join12(targetDir, libFile);
+    const src = join13(extractedDir, libFile);
+    const dst = join13(targetDir, libFile);
     try {
       copyFile(src, dst);
       if (process.platform !== "win32") {
@@ -16047,11 +16106,11 @@ function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, c
   }
   const targetRoot = realpathSync2(targetDir);
   for (const link of symlinks) {
-    const dst = join12(targetDir, link.name);
+    const dst = join13(targetDir, link.name);
     try {
       unlinkSync4(dst);
     } catch {}
-    const dstForContainment = join12(targetRoot, link.name);
+    const dstForContainment = join13(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}`;
@@ -16072,21 +16131,18 @@ function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, c
       log(`ORT extract: failed to symlink optional ${link.name}: ${symlinkErr}`);
     }
   }
-  const requiredPath = join12(targetDir, info.libName);
-  if (!existsSync9(requiredPath)) {
+  const requiredPath = join13(targetDir, info.libName);
+  if (!existsSync10(requiredPath)) {
     rmSync3(targetDir, { recursive: true, force: true });
     throw new Error(`Required ONNX Runtime library missing after install: ${requiredPath}`);
   }
 }
 async function extractZipArchive(archivePath, destinationDir) {
   if (process.platform === "win32") {
-    execFileSync("tar.exe", ["-xf", archivePath, "-C", destinationDir], {
-      stdio: "pipe",
-      timeout: 120000
-    });
+    execTarExtractionSync(["-xf", archivePath, "-C", destinationDir], 120000);
     return;
   }
-  execFileSync("unzip", ["-q", archivePath, "-d", destinationDir], {
+  execFileSync2("unzip", ["-q", archivePath, "-d", destinationDir], {
     stdio: "pipe",
     timeout: 120000
   });
@@ -16099,13 +16155,13 @@ function writeOnnxInstalledMeta(installDir, version, sha256, archiveSha256) {
       ...sha256 ? { sha256 } : {},
       archiveSha256
     };
-    writeFileSync3(join12(installDir, ONNX_INSTALLED_META_FILE), JSON.stringify(meta), "utf8");
+    writeFileSync3(join13(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 path = join12(installDir, ONNX_INSTALLED_META_FILE);
+  const path = join13(installDir, ONNX_INSTALLED_META_FILE);
   try {
     if (!statSync6(path).isFile())
       return null;
@@ -16217,7 +16273,7 @@ function isWindowsProcessAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0)
     return false;
   try {
-    const output = execFileSync("tasklist.exe", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], {
+    const output = execFileSync2("tasklist.exe", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], {
       encoding: "utf8",
       timeout: 2000,
       windowsHide: true
@@ -16438,10 +16494,8 @@ function prepareCanonicalEditArguments(toolName, rawArguments) {
   if (unknownRootKeys.length > 0) {
     throw new InvalidRequestError(formatUnknownKeys(unknownRootKeys));
   }
+  validateSymbolModePair(record);
   const modes = editModesPresent(record);
-  if (hasOrphanedSymbolContent(record)) {
-    throw new InvalidRequestError("edit: 'content' requires a non-empty string 'symbol' when symbol mode is selected");
-  }
   if (modes.length > 1) {
     throw new InvalidRequestError(`edit: conflicting modes: ${modes.join(", ")}. ${OMIT_OPTIONAL_FIELDS_STEERING}`);
   }
@@ -16461,7 +16515,7 @@ function prepareCanonicalEditArguments(toolName, rawArguments) {
       throw new InvalidRequestError("edit: 'symbol' must be a string when symbol mode is selected");
     }
     if (!hasOwn(record, "content") || typeof record.content !== "string") {
-      throw new InvalidRequestError("edit: symbol mode requires both 'symbol' and 'content' string properties");
+      throw new InvalidRequestError("edit: incomplete symbol mode: property 'content' must be a string. " + "Retry with `symbol` + `content`, or use `edits[]`.");
     }
   } else {
     const item = {};
@@ -16514,6 +16568,29 @@ function validateEditPath(record) {
 function formatUnknownKeys(keys) {
   return `Unrecognized keys: ${keys.map((key) => `"${key}"`).join(", ")}`;
 }
+function validateSymbolModePair(record) {
+  const completeShapes = "Retry with `symbol` + `content`, or use `edits[]`.";
+  const hasSymbol = isNonEmptyString(record.symbol);
+  const hasContent = isNonEmptyString(record.content);
+  if (hasSymbol) {
+    if (!hasOwn(record, "content")) {
+      throw new InvalidRequestError(`edit: incomplete symbol mode: missing property 'content'. ${completeShapes}`);
+    }
+    if (record.content === null) {
+      throw new InvalidRequestError(`edit: incomplete symbol mode: property 'content' is null. ${completeShapes}`);
+    }
+    return;
+  }
+  if (!hasContent)
+    return;
+  if (!hasOwn(record, "symbol")) {
+    throw new InvalidRequestError(`edit: incomplete symbol mode: missing property 'symbol'. ${completeShapes}`);
+  }
+  if (record.symbol === null) {
+    throw new InvalidRequestError(`edit: incomplete symbol mode: property 'symbol' is null. ${completeShapes}`);
+  }
+  throw new InvalidRequestError(`edit: incomplete symbol mode: property 'symbol' must be a non-empty string. ${completeShapes}`);
+}
 function editModesPresent(record) {
   const hasAppendContent = isNonEmptyString(record.appendContent);
   if (!hasAppendContent)
@@ -16599,9 +16676,6 @@ function normalizeEditArraySentinels(record) {
     return true;
   }
 }
-function hasOrphanedSymbolContent(record) {
-  return isNonEmptyString(record.content) && !isNonEmptyString(record.symbol);
-}
 function parseEditArray(value) {
   if (typeof value === "string") {
     let parsed;
@@ -16784,8 +16858,50 @@ function copyOwnProperties(source) {
     copy[key] = source[key];
   return copy;
 }
+// ../aft-bridge/dist/semantic-status.js
+var MISSING_ONNX_RUNTIME_MARKER = "ONNX Runtime not found.";
+var MISSING_ONNX_RUNTIME_LABEL = "unavailable — ONNX Runtime missing (npx @cortexkit/aft doctor --fix)";
+var REBUILDING_LABEL = "Rebuilding (model changed)";
+var SEMANTIC_PROGRESS_STATUSES = new Set(["building", "loading"]);
+var SEMANTIC_READY_STATUSES = new Set(["ready", "empty"]);
+var SEMANTIC_INACTIVE_STATUSES = new Set(["disabled", "busy"]);
+var SEMANTIC_FAILURE_LABELS = {
+  backend_unavailable: "backend unavailable",
+  degraded: "degraded",
+  error: "error",
+  failed: "failed",
+  unavailable: "unavailable"
+};
+function semanticIndexStatusKind(status) {
+  if (SEMANTIC_READY_STATUSES.has(status))
+    return "ready";
+  if (SEMANTIC_PROGRESS_STATUSES.has(status))
+    return "progress";
+  if (status in SEMANTIC_FAILURE_LABELS)
+    return "failure";
+  if (SEMANTIC_INACTIVE_STATUSES.has(status))
+    return "inactive";
+  return "unrecognized";
+}
+function mentionsMissingOnnxRuntime(...values) {
+  return values.some((value) => typeof value === "string" && value.includes(MISSING_ONNX_RUNTIME_MARKER));
+}
+function semanticFailureLabel(status, stage, error) {
+  if (mentionsMissingOnnxRuntime(error, stage))
+    return MISSING_ONNX_RUNTIME_LABEL;
+  return SEMANTIC_FAILURE_LABELS[status] ?? null;
+}
+function formatSemanticIndexStatus(status, stage, error) {
+  const failure = semanticFailureLabel(status, stage, error);
+  if (failure)
+    return failure;
+  if (semanticIndexStatusKind(status) === "progress" && stage === "fingerprint_change") {
+    return REBUILDING_LABEL;
+  }
+  return status;
+}
 // 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 renameSync6, unlinkSync as unlinkSync5, writeFileSync as writeFileSync4 } from "node:fs";
 import { homedir as homedir10 } from "node:os";
 import { isAbsolute as isAbsolute6, parse as parsePath, resolve as resolvePath } from "node:path";
 var import_comment_json = __toESM(require_src2(), 1);
@@ -21492,6 +21608,9 @@ function write(level, message, data, sessionId) {
 function log2(message, data) {
   write("INFO", message, data);
 }
+function debug2(message, data) {
+  write("DEBUG", message, data);
+}
 function warn2(message, data) {
   write("WARN", message, data);
 }
@@ -21690,6 +21809,7 @@ var InspectConfigSchema = object({
   enabled: boolean2().optional(),
   diagnostics_timeout_ms: number2().int().positive().optional().transform((value) => value === undefined ? undefined : clampInspectDiagnosticsTimeoutMs(value)),
   tier2_idle_minutes: number2().min(0).optional(),
+  tier2_pass_timeout_ms: number2().int().positive().optional(),
   categories: record(string2(), boolean2()).optional(),
   tier2_soft_deadline_ms: number2().int().positive().optional(),
   max_drill_down_items: number2().int().positive().max(100).optional(),
@@ -22012,7 +22132,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;
@@ -22036,7 +22156,7 @@ function migrateAftConfigFile2(configPath, logger = { log: log2, warn: warn2 })
 ${serialized}` : serialized;
     tmpPath = `${configPath}.tmp.${process.pid}`;
     writeFileSync4(tmpPath, nextContent, "utf-8");
-    renameSync5(tmpPath, configPath);
+    renameSync6(tmpPath, configPath);
     logger.log(`Migrated config at ${configPath}: removed ${oldKeys.join(", ")}`);
     return { migrated: true, oldKeys };
   } catch (err) {
@@ -22097,7 +22217,7 @@ function recordConfigParseFailure(configPath, errorMessage) {
 }
 function loadConfigFromPath(configPath) {
   try {
-    if (!existsSync10(configPath)) {
+    if (!existsSync11(configPath)) {
       return null;
     }
     const content = readFileSync7(configPath, "utf-8");
@@ -22437,7 +22557,7 @@ function loadAftConfig(projectDirectory) {
 }
 
 // src/tools/_shared.ts
-import { existsSync as existsSync11 } from "node:fs";
+import { existsSync as existsSync12 } from "node:fs";
 import * as os2 from "node:os";
 import * as path2 from "node:path";
 
@@ -34850,6 +34970,7 @@ var DEBOUNCE_STEP_MS = 200;
 var DEBOUNCE_CAP_MS = 1000;
 var MAX_WAKE_SEND_ATTEMPTS = 5;
 var DEFAULT_WAKE_CONFIRMATION_WINDOW_MS = 5000;
+var BUSY_WAKE_DEFER_CEILING_MS = 60000;
 var UNKNOWN_COMPLETION_TTL_MS = 5000;
 var UNKNOWN_COMPLETION_CAP = 32;
 var DEFAULT_SESSION_ID2 = "__default__";
@@ -34881,10 +35002,12 @@ function logDroppedForeignSessionFrame(drainContext, droppedSessionId, liveSessi
 var DEFAULT_BG_HOP_TIMEOUT_MS = 15000;
 var bgHopTimeoutMs = DEFAULT_BG_HOP_TIMEOUT_MS;
 var wakeConfirmationWindowMs = DEFAULT_WAKE_CONFIRMATION_WINDOW_MS;
+var busyWakeDeferCeilingMs = BUSY_WAKE_DEFER_CEILING_MS;
 var lastWakeMessageTimestamp = 0;
 var wakeMessageCounter = 0;
 var subcNudgesInFlight = new Map;
 var subcNudgeLogState = new Map;
+var deferredBusyWakes = new Map;
 function consumeBgCompletion(sessionID, taskId) {
   const state = stateFor(sessionID);
   state.pendingCompletions = state.pendingCompletions.filter((c) => c.task_id !== taskId);
@@ -34899,6 +35022,9 @@ function consumeBgCompletion(sessionID, taskId) {
     }
   }
   clearWakeTimerIfNoPending(state);
+  if (state.pendingCompletions.length === 0 && state.pendingLongRunning.length === 0 && state.pendingPatternMatches.length === 0) {
+    clearDeferredBusyWake(sessionID || DEFAULT_SESSION_ID2);
+  }
 }
 async function markBgCompletionDelivered(drainContext, taskId) {
   const state = stateFor(drainContext.sessionID);
@@ -35004,7 +35130,7 @@ async function handlePushedPatternMatch(drainContext, frame) {
   }
   const state = stateFor(drainContext.sessionID);
   queuePendingPatternMatch(state, { ...frame, ackCompletionOnDelivery: true });
-  await triggerWakeIfPending(drainContext, true);
+  await triggerWakeIfPending(drainContext, true, true, false, true);
 }
 function ingestBgCompletions(sessionID, completions) {
   if (!Array.isArray(completions) || completions.length === 0)
@@ -35042,11 +35168,11 @@ function ingestBgCompletions(sessionID, completions) {
 }
 async function handlePushedBgCompletion(drainContext, completion) {
   ingestBgCompletions(drainContext.sessionID, [completion]);
-  await triggerWakeIfPending(drainContext, true, false);
+  await triggerWakeIfPending(drainContext, true, false, false, true);
 }
 async function handlePushedBgLongRunning(drainContext, reminder) {
   stateFor(drainContext.sessionID).pendingLongRunning.push(reminder);
-  await triggerWakeIfPending(drainContext, true);
+  await triggerWakeIfPending(drainContext, true, true, false, true);
 }
 async function appendInTurnBgCompletions(drainContext, output) {
   if (!output)
@@ -35091,6 +35217,7 @@ async function appendInTurnBgCompletions(drainContext, output) {
   if (inTurnAcked)
     confirmAcked(state, inTurnAckIds);
   clearWakeTimerIfNoPending(state);
+  clearDeferredBusyWake(drainContext.sessionID);
 }
 async function handleIdleBgCompletions(drainContext) {
   stateFor(drainContext.sessionID).wakeDeferredTaskIds.clear();
@@ -35118,7 +35245,7 @@ async function handleSubcBgEventsNudgeOnce(drainContext) {
   const state = stateFor(drainContext.sessionID);
   state.wakeDeferredTaskIds.clear();
   rearmHardStoppedWake(state, drainContext);
-  await triggerWakeIfPending(drainContext, false, true, true);
+  await triggerWakeIfPending(drainContext, false, true, true, true);
 }
 function logSubcNudgeLifecycle(drainContext, kind, message) {
   logDeliveryHop(drainContext, kind, message, {
@@ -35333,6 +35460,42 @@ function registerWakeAdmission(state, admission) {
   }, wakeConfirmationWindowMs);
   tracked.confirmationTimer.unref?.();
 }
+function clearDeferredBusyWake(sessionID) {
+  const deferred = deferredBusyWakes.get(sessionID);
+  if (!deferred)
+    return;
+  deferredBusyWakes.delete(sessionID);
+  clearTimeout(deferred.timer);
+  return deferred;
+}
+function deferBusyWake(drainContext) {
+  const existing = deferredBusyWakes.get(drainContext.sessionID);
+  if (existing) {
+    existing.context = drainContext;
+    return;
+  }
+  const deferredAt = Date.now();
+  const deferred = {
+    context: drainContext,
+    deferredAt,
+    timer: setTimeout(() => {
+      if (deferredBusyWakes.get(drainContext.sessionID) !== deferred)
+        return;
+      deferredBusyWakes.delete(drainContext.sessionID);
+      const waitMs = Math.max(0, Date.now() - deferredAt);
+      sessionLog(drainContext.sessionID, `${LOG_PREFIX} busy wake defer ceiling reached`, {
+        event: "bash_completion_wake_deferred_ceiling",
+        wait_ms: waitMs,
+        ceiling_ms: busyWakeDeferCeilingMs
+      });
+      triggerWakeIfPending(deferred.context, true).catch(() => {
+        return;
+      });
+    }, busyWakeDeferCeilingMs)
+  };
+  deferred.timer.unref?.();
+  deferredBusyWakes.set(drainContext.sessionID, deferred);
+}
 function observeOpenCodeBgNotificationEvent(event) {
   try {
     if (!event || typeof event !== "object")
@@ -35381,12 +35544,17 @@ function observeOpenCodeBgNotificationEvent(event) {
       return;
     }
     if (nextStatus === "idle") {
+      const deferred = clearDeferredBusyWake(sessionID);
+      if (deferred)
+        triggerWakeIfPending(deferred.context, true).catch(() => {
+          return;
+        });
       for (const admission of state.wakeAdmissions.values())
         queueWakeRefire(state, admission);
     }
   } catch {}
 }
-async function triggerWakeIfPending(drainContext, skipDrain, includeDeferredCompletions = true, forceDrain = false) {
+async function triggerWakeIfPending(drainContext, skipDrain, includeDeferredCompletions = true, forceDrain = false, deferWhileBusy = false) {
   const state = stateFor(drainContext.sessionID);
   if (!skipDrain && (forceDrain || state.outstandingTaskIds.size > 0 || !state.forcedDrainCompleted)) {
     await drainCompletions(drainContext);
@@ -35394,6 +35562,10 @@ async function triggerWakeIfPending(drainContext, skipDrain, includeDeferredComp
   routeExplicitControlCompletions(state);
   if (!hasWakeEligiblePending(state, includeDeferredCompletions))
     return;
+  if (deferWhileBusy && state.hostStatus === "busy") {
+    deferBusyWake(drainContext);
+    return;
+  }
   scheduleWake(state, async (reminder, deliveredCompletions, deliveredPatternMatches) => {
     const liveSession = getActiveSessionId() ?? drainContext.sessionID;
     if (liveSession && drainContext.sessionID && drainContext.sessionID !== liveSession) {
@@ -36235,7 +36407,7 @@ function bridgeFor(ctx, runtime) {
   if (ctx.isProjectEnabled?.(projectRoot) === false) {
     throw new Error(`AFT disabled by config for ${projectRoot}`);
   }
-  if (!existsSync11(projectRoot)) {
+  if (!existsSync12(projectRoot)) {
     throw new Error(`project directory no longer exists: ${projectRoot} (stale restored session?)`);
   }
   return ctx.pool.getBridge(projectRoot);
@@ -36392,9 +36564,9 @@ async function signalBashWaitDetachForProject(pool, projectRoot, sessionID) {
 }
 
 // src/notifications.ts
-import { existsSync as existsSync12, readFileSync as readFileSync8 } from "node:fs";
+import { existsSync as existsSync13, readFileSync as readFileSync8 } from "node:fs";
 import { homedir as homedir12, platform } from "node:os";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 function isTuiMode() {
   return process.env.OPENCODE_CLIENT === "cli";
 }
@@ -36416,21 +36588,21 @@ function getDesktopStatePath() {
   const os = platform();
   const home = homedir12();
   if (os === "darwin") {
-    return join13(home, "Library", "Application Support", "ai.opencode.desktop", "opencode.global.dat");
+    return join14(home, "Library", "Application Support", "ai.opencode.desktop", "opencode.global.dat");
   }
   if (os === "linux") {
-    const xdgConfig = process.env.XDG_CONFIG_HOME || join13(home, ".config");
-    return join13(xdgConfig, "ai.opencode.desktop", "opencode.global.dat");
+    const xdgConfig = process.env.XDG_CONFIG_HOME || join14(home, ".config");
+    return join14(xdgConfig, "ai.opencode.desktop", "opencode.global.dat");
   }
   if (os === "win32") {
-    const appData = process.env.APPDATA || join13(home, "AppData", "Roaming");
-    return join13(appData, "ai.opencode.desktop", "opencode.global.dat");
+    const appData = process.env.APPDATA || join14(home, "AppData", "Roaming");
+    return join14(appData, "ai.opencode.desktop", "opencode.global.dat");
   }
   return null;
 }
 function readDesktopState() {
   const statePath = getDesktopStatePath();
-  if (!statePath || !existsSync12(statePath)) {
+  if (!statePath || !existsSync13(statePath)) {
     return { serverUrl: null };
   }
   try {
@@ -36930,11 +37102,11 @@ async function flushConfigureWarningsOnIdle(sessionId) {
 // src/hooks/auto-update-checker/index.ts
 import {
   closeSync as closeSync5,
-  existsSync as existsSync15,
+  existsSync as existsSync16,
   mkdirSync as mkdirSync6,
   openSync as openSync5,
   readFileSync as readFileSync11,
-  renameSync as renameSync6,
+  renameSync as renameSync7,
   rmSync as rmSync5,
   statSync as statSync8,
   writeFileSync as writeFileSync7
@@ -36943,30 +37115,30 @@ import { dirname as dirname8 } from "node:path";
 
 // src/hooks/auto-update-checker/cache.ts
 import { spawn as spawn4 } from "node:child_process";
-import { cpSync, existsSync as existsSync14, mkdtempSync, readFileSync as readFileSync10, rmSync as rmSync4, writeFileSync as writeFileSync6 } from "node:fs";
+import { cpSync, existsSync as existsSync15, mkdtempSync, readFileSync as readFileSync10, rmSync as rmSync4, writeFileSync as writeFileSync6 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { basename as basename3, dirname as dirname7, join as join16 } from "node:path";
+import { basename as basename3, dirname as dirname7, join as join17 } from "node:path";
 var import_comment_json3 = __toESM(require_src2(), 1);
 
 // src/hooks/auto-update-checker/checker.ts
-import { existsSync as existsSync13, readFileSync as readFileSync9, statSync as statSync7, writeFileSync as writeFileSync5 } from "node:fs";
-import { dirname as dirname6, isAbsolute as isAbsolute8, join as join15, resolve as resolve9 } from "node:path";
+import { existsSync as existsSync14, readFileSync as readFileSync9, statSync as statSync7, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname6, isAbsolute as isAbsolute8, join as join16, resolve as resolve9 } from "node:path";
 import { fileURLToPath } from "node:url";
 var import_comment_json2 = __toESM(require_src2(), 1);
 
 // src/hooks/auto-update-checker/constants.ts
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 var PACKAGE_NAME = "@cortexkit/aft-opencode";
 var NPM_REGISTRY_URL = "https://registry.npmjs.org";
 var NPM_FETCH_TIMEOUT = 1e4;
 function cacheDir() {
-  return join14(getOpenCodeCacheRoot(), "packages");
+  return join15(getOpenCodeCacheRoot(), "packages");
 }
 function userOpenCodeConfig() {
-  return join14(getOpenCodeConfigRoot(), "opencode.json");
+  return join15(getOpenCodeConfigRoot(), "opencode.json");
 }
 function userOpenCodeConfigJsonc() {
-  return join14(getOpenCodeConfigRoot(), "opencode.jsonc");
+  return join15(getOpenCodeConfigRoot(), "opencode.jsonc");
 }
 
 // src/hooks/auto-update-checker/types.ts
@@ -37025,8 +37197,8 @@ function extractChannel(version) {
 }
 function getConfigPaths(directory) {
   return [
-    join15(directory, ".opencode", "opencode.json"),
-    join15(directory, ".opencode", "opencode.jsonc"),
+    join16(directory, ".opencode", "opencode.json"),
+    join16(directory, ".opencode", "opencode.jsonc"),
     userOpenCodeConfig(),
     userOpenCodeConfigJsonc()
   ];
@@ -37046,7 +37218,7 @@ function resolvePathPluginSpec(spec, configPath) {
 function getLocalDevPath(directory) {
   for (const configPath of getConfigPaths(directory)) {
     try {
-      if (!existsSync13(configPath))
+      if (!existsSync14(configPath))
         continue;
       const rawConfig = parseJsonConfig(readFileSync9(configPath, "utf-8"));
       const plugins = getPluginEntries(rawConfig);
@@ -37072,8 +37244,8 @@ function findPackageJsonUp(startPath) {
     const stat = statSync7(startPath);
     let dir = stat.isDirectory() ? startPath : dirname6(startPath);
     for (let i = 0;i < 10; i++) {
-      const pkgPath = join15(dir, "package.json");
-      if (existsSync13(pkgPath)) {
+      const pkgPath = join16(dir, "package.json");
+      if (existsSync14(pkgPath)) {
         try {
           const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync9(pkgPath, "utf-8")));
           if (pkg.success && pkg.data.name === PACKAGE_NAME)
@@ -37113,7 +37285,7 @@ function getCurrentRuntimePackageJsonPath(currentModuleUrl = import.meta.url) {
 function findPluginEntry(directory) {
   for (const configPath of getConfigPaths(directory)) {
     try {
-      if (!existsSync13(configPath))
+      if (!existsSync14(configPath))
         continue;
       const rawConfig = parseJsonConfig(readFileSync9(configPath, "utf-8"));
       const plugins = getPluginEntries(rawConfig);
@@ -37133,7 +37305,7 @@ function findPluginEntry(directory) {
 }
 var cachedPackageVersion = null;
 function getSpecCachePackageJsonPath(spec) {
-  return join15(cacheDir(), spec, "node_modules", PACKAGE_NAME, "package.json");
+  return join16(cacheDir(), spec, "node_modules", PACKAGE_NAME, "package.json");
 }
 function getCachedVersion(spec) {
   if (!spec && cachedPackageVersion)
@@ -37142,11 +37314,11 @@ function getCachedVersion(spec) {
     getCurrentRuntimePackageJsonPath(),
     spec ? getSpecCachePackageJsonPath(spec) : null,
     getSpecCachePackageJsonPath(`${PACKAGE_NAME}@latest`),
-    join15(getOpenCodeCacheRoot(), "node_modules", PACKAGE_NAME, "package.json")
+    join16(getOpenCodeCacheRoot(), "node_modules", PACKAGE_NAME, "package.json")
   ].filter(isString);
   for (const packageJsonPath of candidates) {
     try {
-      if (!existsSync13(packageJsonPath))
+      if (!existsSync14(packageJsonPath))
         continue;
       const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync9(packageJsonPath, "utf-8")));
       if (pkg.success && pkg.data.version) {
@@ -37191,17 +37363,17 @@ async function getLatestVersion(channel = "latest", options = {}) {
 var pendingSnapshots = new Map;
 var quarantinedInstallDirs = new Set;
 function createAutoUpdateSnapshot(installDir, packageJsonPath, packageName) {
-  const packageDir = join16(installDir, "node_modules", packageName);
-  const lockfilePath = join16(installDir, "package-lock.json");
-  const tempDir = mkdtempSync(join16(tmpdir2(), "aft-auto-update-"));
-  const stagedPackageDir = existsSync14(packageDir) ? join16(tempDir, "package") : null;
+  const packageDir = join17(installDir, "node_modules", packageName);
+  const lockfilePath = join17(installDir, "package-lock.json");
+  const tempDir = mkdtempSync(join17(tmpdir2(), "aft-auto-update-"));
+  const stagedPackageDir = existsSync15(packageDir) ? join17(tempDir, "package") : null;
   if (stagedPackageDir)
     cpSync(packageDir, stagedPackageDir, { recursive: true });
   return {
     packageJsonPath,
-    packageJson: existsSync14(packageJsonPath) ? readFileSync10(packageJsonPath, "utf-8") : null,
+    packageJson: existsSync15(packageJsonPath) ? readFileSync10(packageJsonPath, "utf-8") : null,
     lockfilePath,
-    lockfile: existsSync14(lockfilePath) ? readFileSync10(lockfilePath, "utf-8") : null,
+    lockfile: existsSync15(lockfilePath) ? readFileSync10(lockfilePath, "utf-8") : null,
     packageDir,
     stagedPackageDir,
     tempDir
@@ -37235,8 +37407,8 @@ function stripPackageNameFromPath(pathValue, packageName) {
   return current;
 }
 function removeFromPackageLock(installDir, packageName) {
-  const lockPath = join16(installDir, "package-lock.json");
-  if (!existsSync14(lockPath))
+  const lockPath = join17(installDir, "package-lock.json");
+  if (!existsSync15(lockPath))
     return false;
   try {
     const lock = import_comment_json3.parse(readFileSync10(lockPath, "utf-8"));
@@ -37262,7 +37434,7 @@ function removeFromPackageLock(installDir, packageName) {
   }
 }
 function ensureDependencyVersion(packageJsonPath, packageName, version) {
-  if (!existsSync14(packageJsonPath))
+  if (!existsSync15(packageJsonPath))
     return false;
   try {
     const raw = import_comment_json3.parse(readFileSync10(packageJsonPath, "utf-8"));
@@ -37291,8 +37463,8 @@ function restorePendingSnapshot(installDir) {
   restoreAutoUpdateSnapshot(snapshot);
 }
 function removeInstalledPackage(installDir, packageName) {
-  const packageDir = join16(installDir, "node_modules", packageName);
-  if (!existsSync14(packageDir))
+  const packageDir = join17(installDir, "node_modules", packageName);
+  if (!existsSync15(packageDir))
     return false;
   rmSync4(packageDir, { recursive: true, force: true });
   log2(`[auto-update-checker] Package removed: ${packageDir}`);
@@ -37304,15 +37476,15 @@ function resolveInstallContext(runtimePackageJsonPath = getCurrentRuntimePackage
     const nodeModulesDir = stripPackageNameFromPath(packageDir, PACKAGE_NAME);
     if (nodeModulesDir && basename3(nodeModulesDir) === "node_modules") {
       const installDir = dirname7(nodeModulesDir);
-      const packageJsonPath = join16(installDir, "package.json");
-      if (existsSync14(packageJsonPath))
+      const packageJsonPath = join17(installDir, "package.json");
+      if (existsSync15(packageJsonPath))
         return { installDir, packageJsonPath };
     }
     return null;
   }
   const cacheRoot = dirname7(cacheDir());
-  const legacyPackageJsonPath = join16(cacheRoot, "package.json");
-  if (existsSync14(legacyPackageJsonPath)) {
+  const legacyPackageJsonPath = join17(cacheRoot, "package.json");
+  if (existsSync15(legacyPackageJsonPath)) {
     return { installDir: cacheRoot, packageJsonPath: legacyPackageJsonPath };
   }
   return null;
@@ -37535,7 +37707,7 @@ function claimCheckSlot(storageDir, intervalMs) {
       const replacementPath = `${lockPath}.tmp.${process.pid}`;
       writeFileSync7(replacementPath, JSON.stringify(owner), { encoding: "utf-8", mode: 384 });
       try {
-        renameSync6(replacementPath, lockPath);
+        renameSync7(replacementPath, lockPath);
       } catch (replaceError) {
         rmSync5(replacementPath, { force: true });
         throw replaceError;
@@ -37603,7 +37775,7 @@ function checkLockIsOwnedBy(lockPath, owner) {
   }
 }
 function hasRecentCheckTimestamp(file, intervalMs) {
-  if (!existsSync15(file))
+  if (!existsSync16(file))
     return false;
   try {
     const raw = JSON.parse(readFileSync11(file, "utf-8"));
@@ -37616,7 +37788,7 @@ function hasRecentCheckTimestamp(file, intervalMs) {
 function writeCheckTimestamp(file) {
   const tmp = `${file}.tmp.${process.pid}`;
   writeFileSync7(tmp, JSON.stringify({ lastCheckedMs: Date.now() }), "utf-8");
-  renameSync6(tmp, file);
+  renameSync7(tmp, file);
 }
 async function runStartupCheck(ctx, options) {
   if (options.signal.aborted)
@@ -37713,15 +37885,15 @@ import { spawn as spawn5 } from "node:child_process";
 import { createHash as createHash6 } from "node:crypto";
 import {
   createReadStream,
-  existsSync as existsSync17,
+  existsSync as existsSync18,
   mkdirSync as mkdirSync8,
   readFileSync as readFileSync14,
-  renameSync as renameSync8,
+  renameSync as renameSync9,
   rmSync as rmSync7,
   statSync as statSync10,
   writeFileSync as writeFileSync9
 } from "node:fs";
-import { join as join19 } from "node:path";
+import { join as join20 } from "node:path";
 
 // src/lsp-cache.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
@@ -37730,13 +37902,13 @@ import {
   mkdirSync as mkdirSync7,
   openSync as openSync6,
   readFileSync as readFileSync12,
-  renameSync as renameSync7,
+  renameSync as renameSync8,
   rmSync as rmSync6,
   statSync as statSync9,
   unlinkSync as unlinkSync6,
   writeFileSync as writeFileSync8
 } from "node:fs";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 function aftCacheBase() {
   return getAftCacheRoot();
 }
@@ -37744,18 +37916,18 @@ function lspCacheRoot() {
   return getAftLspPackagesDir();
 }
 function lspPackageDir(npmPackage) {
-  return join17(lspCacheRoot(), encodeURIComponent(npmPackage));
+  return join18(lspCacheRoot(), encodeURIComponent(npmPackage));
 }
 function lspBinaryPath(npmPackage, binary) {
-  return join17(lspPackageDir(npmPackage), "node_modules", ".bin", binary);
+  return join18(lspPackageDir(npmPackage), "node_modules", ".bin", binary);
 }
 function lspBinDir(npmPackage) {
-  return join17(lspPackageDir(npmPackage), "node_modules", ".bin");
+  return join18(lspPackageDir(npmPackage), "node_modules", ".bin");
 }
 function isInstalled(npmPackage, binary) {
   for (const candidate of lspBinaryCandidates(binary)) {
     try {
-      if (statSync9(join17(lspBinDir(npmPackage), candidate)).isFile())
+      if (statSync9(join18(lspBinDir(npmPackage), candidate)).isFile())
         return true;
     } catch {}
   }
@@ -37775,13 +37947,13 @@ function writeInstalledMetaIn(installDir, version, sha256) {
       installedAt: new Date().toISOString(),
       ...sha256 ? { sha256 } : {}
     };
-    writeFileSync8(join17(installDir, INSTALLED_META_FILE), JSON.stringify(meta), "utf8");
+    writeFileSync8(join18(installDir, INSTALLED_META_FILE), JSON.stringify(meta), "utf8");
   } catch (err) {
     log2(`[lsp-cache] failed to write installed-meta in ${installDir}: ${err}`);
   }
 }
 function readInstalledMetaIn(installDir) {
-  const path = join17(installDir, INSTALLED_META_FILE);
+  const path = join18(installDir, INSTALLED_META_FILE);
   try {
     if (!statSync9(path).isFile())
       return null;
@@ -37805,7 +37977,7 @@ function readInstalledMeta(packageKey) {
   return readInstalledMetaIn(lspPackageDir(packageKey));
 }
 function lockPath(npmPackage) {
-  return join17(lspPackageDir(npmPackage), ".aft-installing");
+  return join18(lspPackageDir(npmPackage), ".aft-installing");
 }
 var STALE_LOCK_MS2 = 30 * 60 * 1000;
 function acquireInstallLock(lockKey) {
@@ -37936,7 +38108,7 @@ var AUTO_INSTALL_STAMP_FILE = "last-lsp-autoinstall.json";
 var AUTO_INSTALL_WINDOW_MS = 60 * 1000;
 var AUTO_INSTALL_LOCK_STALE_MS = 30 * 60 * 1000;
 function autoInstallStampPath() {
-  return join17(aftCacheBase(), AUTO_INSTALL_STAMP_FILE);
+  return join18(aftCacheBase(), AUTO_INSTALL_STAMP_FILE);
 }
 function hasRecentAutoInstallStamp(path) {
   try {
@@ -38022,7 +38194,7 @@ function claimLspAutoInstallPass() {
       encoding: "utf8",
       mode: 384
     });
-    renameSync7(tempPath, stampPath);
+    renameSync8(tempPath, stampPath);
     return { release };
   } catch (err) {
     if (claimed) {
@@ -38037,7 +38209,7 @@ function claimLspAutoInstallPass() {
 }
 var VERSION_CHECK_FILE = ".aft-version-check";
 function readVersionCheck(npmPackage) {
-  const file = join17(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
+  const file = join18(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
   try {
     const raw = readFileSync12(file, "utf8");
     const parsed = JSON.parse(raw);
@@ -38054,7 +38226,7 @@ function readVersionCheck(npmPackage) {
 }
 function writeVersionCheck(npmPackage, latest) {
   mkdirSync7(lspPackageDir(npmPackage), { recursive: true });
-  const file = join17(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
+  const file = join18(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
   const record = {
     last_checked: new Date().toISOString(),
     latest_eligible: latest
@@ -38216,8 +38388,8 @@ var NPM_LSP_TABLE = [
 ];
 
 // src/lsp-project-relevance.ts
-import { existsSync as existsSync16, readdirSync as readdirSync4, readFileSync as readFileSync13 } from "node:fs";
-import { join as join18 } from "node:path";
+import { existsSync as existsSync17, readdirSync as readdirSync4, readFileSync as readFileSync13 } from "node:fs";
+import { join as join19 } from "node:path";
 var MAX_WALK_DIRS = 200;
 var MAX_WALK_DEPTH = 4;
 var NOISE_DIRS = new Set([
@@ -38234,7 +38406,7 @@ function hasRootMarker(projectRoot, rootMarkers) {
   if (!rootMarkers)
     return false;
   for (const marker of rootMarkers) {
-    if (existsSync16(join18(projectRoot, marker)))
+    if (existsSync17(join19(projectRoot, marker)))
       return true;
   }
   return false;
@@ -38258,7 +38430,7 @@ function hasPackageJsonDep(projectRoot, depNames) {
 }
 function readPackageJson(projectRoot) {
   try {
-    const raw = readFileSync13(join18(projectRoot, "package.json"), "utf8");
+    const raw = readFileSync13(join19(projectRoot, "package.json"), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null)
       return null;
@@ -38288,7 +38460,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: join18(current.dir, entry.name), depth: current.depth + 1 });
+          queue.push({ dir: join19(current.dir, entry.name), depth: current.depth + 1 });
         }
         continue;
       }
@@ -38416,8 +38588,8 @@ async function resolveTargetVersion(spec, config, fetchImpl = fetch) {
 }
 function ensureInstallAnchor(cwd) {
   try {
-    const stub = join19(cwd, "package.json");
-    if (!existsSync17(stub)) {
+    const stub = join20(cwd, "package.json");
+    if (!existsSync18(stub)) {
       writeFileSync9(stub, `${JSON.stringify({ name: "aft-lsp-cache", version: "0.0.0", private: true })}
 `);
     }
@@ -38643,12 +38815,12 @@ function sha256OfFileSync(path) {
 }
 function quarantineCachedNpmInstall(spec, reason) {
   const packageDir = lspPackageDir(spec.npm);
-  const dest = join19(packageDir, "..", ".quarantine", encodeURIComponent(spec.npm), `${Date.now()}`);
+  const dest = join20(packageDir, "..", ".quarantine", encodeURIComponent(spec.npm), `${Date.now()}`);
   warn2(`[lsp] tofu_mismatch ${spec.npm}: ${reason}; quarantining ${packageDir} -> ${dest}`);
   try {
-    mkdirSync8(join19(dest, ".."), { recursive: true });
+    mkdirSync8(join20(dest, ".."), { recursive: true });
     rmSync7(dest, { recursive: true, force: true });
-    renameSync8(packageDir, dest);
+    renameSync9(packageDir, dest);
   } catch (err) {
     warn2(`[lsp] tofu_mismatch ${spec.npm}: failed to quarantine cache entry: ${err}`);
   }
@@ -38729,26 +38901,26 @@ async function pushLspPathsAfterAutoInstall(pool, projectRoot, cachedBinDirs) {
 }
 
 // src/lsp-github-install.ts
-import { execFileSync as execFileSync2 } from "node:child_process";
+import { execFileSync as execFileSync3 } from "node:child_process";
 import { createHash as createHash7, randomBytes as randomBytes3 } from "node:crypto";
 import {
   copyFileSync as copyFileSync4,
   createReadStream as createReadStream2,
   createWriteStream as createWriteStream3,
-  existsSync as existsSync18,
+  existsSync as existsSync19,
   lstatSync as lstatSync2,
   mkdirSync as mkdirSync9,
   readdirSync as readdirSync5,
   readFileSync as readFileSync15,
   readlinkSync as readlinkSync2,
   realpathSync as realpathSync3,
-  renameSync as renameSync9,
+  renameSync as renameSync10,
   rmSync as rmSync8,
   statSync as statSync11,
   unlinkSync as unlinkSync7,
   writeFileSync as writeFileSync10
 } from "node:fs";
-import { dirname as dirname9, join as join20, relative as relative3, resolve as resolve10 } from "node:path";
+import { dirname as dirname9, join as join21, relative as relative3, resolve as resolve10 } from "node:path";
 import { Readable as Readable3 } from "node:stream";
 import { pipeline as pipeline3 } from "node:stream/promises";
 
@@ -38841,19 +39013,19 @@ function ghCacheRoot() {
   return getAftLspBinariesDir();
 }
 function ghPackageDir(spec) {
-  return join20(ghCacheRoot(), spec.id);
+  return join21(ghCacheRoot(), spec.id);
 }
 function ghBinDir(spec) {
-  return join20(ghPackageDir(spec), "bin");
+  return join21(ghPackageDir(spec), "bin");
 }
 function ghExtractDir(spec) {
-  return join20(ghPackageDir(spec), "extracted");
+  return join21(ghPackageDir(spec), "extracted");
 }
 var INSTALLED_META_FILE2 = ".aft-installed";
 var INSTALL_FAILED_FILE = ".aft-install-failed.json";
 var INSTALL_FAILURE_BACKOFF_MS = 6 * 60 * 60 * 1000;
 function installFailureMarkerPath(spec) {
-  return join20(ghPackageDir(spec), INSTALL_FAILED_FILE);
+  return join21(ghPackageDir(spec), INSTALL_FAILED_FILE);
 }
 function readInstallFailureMarker(spec) {
   try {
@@ -38874,7 +39046,7 @@ function writeInstallFailureMarker(spec, release, sha256, installError) {
     mkdirSync9(dirname9(path), { recursive: true });
     writeFileSync10(tempPath, `${JSON.stringify({ release, sha256, error: markerError, at: new Date().toISOString() })}
 `, { encoding: "utf8", mode: 384 });
-    renameSync9(tempPath, path);
+    renameSync10(tempPath, path);
   } catch (err) {
     try {
       rmSync8(tempPath, { force: true });
@@ -38895,12 +39067,12 @@ function isFreshInstallFailure(marker) {
 }
 function ghBinaryPath(spec, platform) {
   const ext = platform === "win32" ? ".exe" : "";
-  return join20(ghBinDir(spec), `${spec.binary}${ext}`);
+  return join21(ghBinDir(spec), `${spec.binary}${ext}`);
 }
 function isGithubInstalled(spec, platform) {
   for (const candidate of ghBinaryCandidates(spec, platform)) {
     try {
-      if (statSync11(join20(ghBinDir(spec), candidate)).isFile())
+      if (statSync11(join21(ghBinDir(spec), candidate)).isFile())
         return true;
     } catch {}
   }
@@ -38913,7 +39085,7 @@ function ghBinaryCandidates(spec, platform) {
 }
 function readGithubInstalledMetaIn(installDir) {
   try {
-    const path = join20(installDir, INSTALLED_META_FILE2);
+    const path = join21(installDir, INSTALLED_META_FILE2);
     if (!statSync11(path).isFile())
       return null;
     const parsed = JSON.parse(readFileSync15(path, "utf8"));
@@ -38940,7 +39112,7 @@ function writeGithubInstalledMetaIn(installDir, version, binarySha256, archiveSh
       binarySha256,
       ...archiveSha256 ? { archiveSha256 } : {}
     };
-    writeFileSync10(join20(installDir, INSTALLED_META_FILE2), JSON.stringify(meta), "utf8");
+    writeFileSync10(join21(installDir, INSTALLED_META_FILE2), JSON.stringify(meta), "utf8");
   } catch (err) {
     warn2(`[lsp] failed to write github installed metadata in ${installDir}: ${err}`);
   }
@@ -39189,7 +39361,7 @@ function validateExtraction(stagingRoot) {
       throw new Error(`failed to read staging dir ${dir}: ${err}`);
     }
     for (const entry of entries) {
-      const full = join20(dir, entry);
+      const full = join21(dir, entry);
       let lst;
       try {
         lst = lstatSync2(full);
@@ -39235,7 +39407,7 @@ function assertArchiveEntryPath(entry) {
 }
 function precheckWithTar(archivePath, command) {
   let totalBytes = 0;
-  const verbose = execFileSync2(command, ["-tvf", archivePath], { encoding: "utf8" });
+  const verbose = execFileSync3(command, ["-tvf", archivePath], { encoding: "utf8" });
   for (const line of verbose.split(`
 `)) {
     if (line.startsWith("h")) {
@@ -39248,7 +39420,7 @@ function precheckWithTar(archivePath, command) {
         totalBytes += Math.max(...numeric);
     }
   }
-  const names = execFileSync2(command, ["-tf", archivePath], { encoding: "utf8" });
+  const names = execFileSync3(command, ["-tf", archivePath], { encoding: "utf8" });
   for (const entry of names.split(`
 `)) {
     if (entry.length > 0)
@@ -39259,19 +39431,18 @@ function precheckWithTar(archivePath, command) {
 function precheckArchiveContents(archivePath, archiveType, zipListingMode = "platform") {
   let totalBytes = 0;
   if (archiveType === "zip" && zipListingMode === "platform" && process.platform !== "win32") {
-    const out = execFileSync2("unzip", ["-l", archivePath], { encoding: "utf8" });
+    const out = execFileSync3("unzip", ["-l", archivePath], { encoding: "utf8" });
     const match = out.match(/^\s*(\d+)\s+\d+\s+files?\s*$/m);
     if (match)
       totalBytes = Number.parseInt(match[1] ?? "0", 10);
-    const names = execFileSync2("unzip", ["-Z1", archivePath], { encoding: "utf8" });
+    const names = execFileSync3("unzip", ["-Z1", archivePath], { encoding: "utf8" });
     for (const entry of names.split(`
 `)) {
       if (entry.length > 0)
         assertArchiveEntryPath(entry);
     }
   } else {
-    const command = process.platform === "win32" ? "tar.exe" : "tar";
-    totalBytes = precheckWithTar(archivePath, command);
+    totalBytes = precheckWithTar(archivePath, windowsTarExecutable());
   }
   if (totalBytes > MAX_EXTRACT_BYTES2) {
     throw new Error(`archive uncompressed size ${totalBytes} exceeds ${MAX_EXTRACT_BYTES2}`);
@@ -39291,7 +39462,7 @@ function extractArchiveSafely(archivePath, destDir, archiveType) {
     try {
       rmSync8(destDir, { recursive: true, force: true });
     } catch {}
-    renameSync9(stagingDir, destDir);
+    renameSync10(stagingDir, destDir);
   } catch (err) {
     try {
       rmSync8(stagingDir, { recursive: true, force: true });
@@ -39301,12 +39472,12 @@ function extractArchiveSafely(archivePath, destDir, archiveType) {
 }
 function quarantineCachedGithubInstall(spec, reason) {
   const packageDir = ghPackageDir(spec);
-  const dest = join20(ghCacheRoot(), ".quarantine", encodeURIComponent(spec.id), `${Date.now()}`);
+  const dest = join21(ghCacheRoot(), ".quarantine", encodeURIComponent(spec.id), `${Date.now()}`);
   warn2(`[lsp] tofu_mismatch ${spec.id}: ${reason}; quarantining ${packageDir} -> ${dest}`);
   try {
     mkdirSync9(dirname9(dest), { recursive: true });
     rmSync8(dest, { recursive: true, force: true });
-    renameSync9(packageDir, dest);
+    renameSync10(packageDir, dest);
   } catch (err) {
     warn2(`[lsp] tofu_mismatch ${spec.id}: failed to quarantine cache entry: ${err}`);
   }
@@ -39314,7 +39485,7 @@ function quarantineCachedGithubInstall(spec, reason) {
 function validateCachedGithubInstall(spec, platform) {
   const packageDir = ghPackageDir(spec);
   const meta = readGithubInstalledMetaIn(packageDir);
-  const binaryPath = ghBinaryCandidates(spec, platform).map((candidate) => join20(ghBinDir(spec), candidate)).find((candidate) => {
+  const binaryPath = ghBinaryCandidates(spec, platform).map((candidate) => join21(ghBinDir(spec), candidate)).find((candidate) => {
     try {
       return statSync11(candidate).isFile();
     } catch {
@@ -39350,30 +39521,21 @@ function validateCachedGithubInstall(spec, platform) {
 function runPlatformExtractor(archivePath, destDir, archiveType) {
   if (archiveType === "zip") {
     if (process.platform === "win32") {
-      execFileSync2("tar.exe", ["-xf", archivePath, "-C", destDir], {
-        stdio: "pipe",
-        timeout: 180000
-      });
+      execTarExtractionSync(["-xf", archivePath, "-C", destDir], 180000);
       return;
     }
-    execFileSync2("unzip", ["-q", "-o", archivePath, "-d", destDir], {
+    execFileSync3("unzip", ["-q", "-o", archivePath, "-d", destDir], {
       stdio: "pipe",
       timeout: 180000
     });
     return;
   }
   if (archiveType === "tar.gz") {
-    execFileSync2("tar", ["-xzf", archivePath, "-C", destDir], {
-      stdio: "pipe",
-      timeout: 180000
-    });
+    execTarExtractionSync(["-xzf", archivePath, "-C", destDir], 180000);
     return;
   }
   if (archiveType === "tar.xz") {
-    execFileSync2("tar", ["-xf", archivePath, "-C", destDir], {
-      stdio: "pipe",
-      timeout: 180000
-    });
+    execTarExtractionSync(["-xf", archivePath, "-C", destDir], 180000);
     return;
   }
   throw new Error(`unsupported archive type: ${archiveType}`);
@@ -39394,7 +39556,7 @@ async function downloadAndInstall(spec, tag, assets, platform, arch, fetchImpl,
   }
   const pkgDir = ghPackageDir(spec);
   const extractDir = ghExtractDir(spec);
-  const archivePath = join20(pkgDir, expected.name);
+  const archivePath = join21(pkgDir, expected.name);
   log2(`[lsp] downloading ${spec.id} ${tag} → ${matchingAsset.url}`);
   try {
     await downloadFile(matchingAsset.url, archivePath, fetchImpl, matchingAsset.size, signal);
@@ -39436,8 +39598,8 @@ async function downloadAndInstall(spec, tag, assets, platform, arch, fetchImpl,
       unlinkSync7(archivePath);
     } catch {}
   }
-  const innerBinaryPath = join20(extractDir, spec.binaryPathInArchive(platform, arch, version));
-  if (!existsSync18(innerBinaryPath)) {
+  const innerBinaryPath = join21(extractDir, spec.binaryPathInArchive(platform, arch, version));
+  if (!existsSync19(innerBinaryPath)) {
     const message = `extracted binary not found at ${innerBinaryPath}`;
     error2(`[lsp] ${spec.id}: ${message}`);
     return { ok: false, sha256: archiveSha256, error: message };
@@ -39542,7 +39704,7 @@ function runGithubAutoInstall(relevantServers, config, fetchImpl = fetch) {
   if (!host) {
     for (const spec of GITHUB_LSP_TABLE) {
       try {
-        if (existsSync18(ghBinDir(spec))) {
+        if (existsSync19(ghBinDir(spec))) {
           cachedBinDirs.push(ghBinDir(spec));
         }
       } catch {}
@@ -39859,25 +40021,25 @@ function isTuiConnected(sessionId) {
 // src/shared/rpc-server.ts
 import { randomBytes as randomBytes4, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
 import {
-  existsSync as existsSync19,
+  existsSync as existsSync20,
   mkdirSync as mkdirSync10,
   readdirSync as readdirSync6,
   readFileSync as readFileSync16,
-  renameSync as renameSync10,
+  renameSync as renameSync11,
   unlinkSync as unlinkSync8,
   writeFileSync as writeFileSync11
 } from "node:fs";
 import { createServer } from "node:http";
-import { dirname as dirname10, join as join22 } from "node:path";
+import { dirname as dirname10, join as join23 } from "node:path";
 
 // src/shared/rpc-utils.ts
-import { join as join21 } from "node:path";
+import { join as join22 } from "node:path";
 function projectHash(directory) {
   return projectRootKeyHash(directory);
 }
 function rpcPortFileDir(storageDir, directory) {
   const hash = projectHash(directory);
-  return join21(storageDir, "rpc", hash, "ports");
+  return join22(storageDir, "rpc", hash, "ports");
 }
 function isPidAlive(pid) {
   if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0)
@@ -39951,7 +40113,7 @@ class AftRpcServer {
   constructor(storageDir, directory) {
     this.portsDir = rpcPortFileDir(storageDir, directory);
     this.instanceId = randomBytes4(8).toString("hex");
-    this.portFilePath = join22(this.portsDir, `${this.instanceId}.json`);
+    this.portFilePath = join23(this.portsDir, `${this.instanceId}.json`);
   }
   handle(method, handler) {
     this.handlers.set(method, handler);
@@ -39981,6 +40143,7 @@ class AftRpcServer {
     });
     this.bunServer = server;
     this.port = server.port ?? 0;
+    server.unref?.();
     this.afterServerStarted();
     return this.port;
   }
@@ -40026,7 +40189,7 @@ class AftRpcServer {
       pid: process.pid,
       started_at: Date.now()
     }), { encoding: "utf-8", mode: 384 });
-    renameSync10(tmpPath, this.portFilePath);
+    renameSync11(tmpPath, this.portFilePath);
   }
   sweepDeadPortFiles() {
     let entries;
@@ -40038,7 +40201,7 @@ class AftRpcServer {
     for (const entry of entries) {
       if (!entry.endsWith(".json"))
         continue;
-      const filePath = join22(this.portsDir, entry);
+      const filePath = join23(this.portsDir, entry);
       if (filePath === this.portFilePath)
         continue;
       try {
@@ -40057,7 +40220,7 @@ class AftRpcServer {
     if (!this.nodeServer && !this.bunServer || this.port <= 0)
       return;
     try {
-      if (existsSync19(this.portFilePath))
+      if (existsSync20(this.portFilePath))
         return;
       this.writePortFile();
       log2(`RPC port file was missing; rewrote ${this.portFilePath}`);
@@ -40324,12 +40487,6 @@ function formatCacheRoleLabel(role) {
   }
   return role;
 }
-function formatSemanticIndexStatus(status, stage) {
-  if ((status === "loading" || status === "building") && stage === "fingerprint_change") {
-    return "Rebuilding (model changed)";
-  }
-  return status;
-}
 function formatSemanticRefreshing(refreshingCount) {
   if (!Number.isFinite(refreshingCount) || refreshingCount <= 0)
     return null;
@@ -40441,7 +40598,7 @@ function formatStatusMarkdown(status) {
     `- **Cache role:** \`${formatCacheRoleLabel(status.cache_role)}\``
   ];
   appendDegradedStatus(lines, status, true);
-  lines.push("", "### Enabled features", `- \`format_on_edit\`: ${formatFlag(status.features.format_on_edit)}`, `- \`search_index\`: ${formatFlag(status.features.search_index)}`, `- \`semantic_search\`: ${formatFlag(status.features.semantic_search)}`, `- \`callgraph_store\`: ${formatFlag(status.features.callgraph_store)}`, "", "### Search index", `- **Status:** \`${status.search_index.status}\``, `- **Files:** ${formatCount(status.search_index.files)}`, `- **Trigrams:** ${formatCount(status.search_index.trigrams)}`, "", "### Semantic index", `- **Status:** \`${formatSemanticIndexStatus(status.semantic_index.status, status.semantic_index.stage)}\``);
+  lines.push("", "### Enabled features", `- \`format_on_edit\`: ${formatFlag(status.features.format_on_edit)}`, `- \`search_index\`: ${formatFlag(status.features.search_index)}`, `- \`semantic_search\`: ${formatFlag(status.features.semantic_search)}`, `- \`callgraph_store\`: ${formatFlag(status.features.callgraph_store)}`, "", "### Search index", `- **Status:** \`${status.search_index.status}\``, `- **Files:** ${formatCount(status.search_index.files)}`, `- **Trigrams:** ${formatCount(status.search_index.trigrams)}`, "", "### Semantic index", `- **Status:** \`${formatSemanticIndexStatus(status.semantic_index.status, status.semantic_index.stage, status.semantic_index.error)}\``);
   const refreshing = formatSemanticRefreshing(status.semantic_index.refreshing_count);
   if (refreshing) {
     lines.push(`- **Refresh:** ${refreshing}`);
@@ -40610,7 +40767,7 @@ function isSyncWatchAborted(sessionID) {
 }
 
 // src/tools/permissions.ts
-import { execFileSync as execFileSync3 } from "node:child_process";
+import { execFileSync as execFileSync4 } from "node:child_process";
 import * as fs4 from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
 import * as path3 from "node:path";
@@ -40865,7 +41022,7 @@ function gitRootForNearestExistingParent(resolved) {
       cwd = path3.dirname(nearest);
   } catch {}
   try {
-    const out = execFileSync3("git", ["rev-parse", "--show-toplevel"], {
+    const out = execFileSync4("git", ["rev-parse", "--show-toplevel"], {
       cwd,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
@@ -41178,6 +41335,26 @@ function failure(error) {
   })();
   return new Error(`V2 tool execution rejected with a non-Error value: ${detail}`);
 }
+function isPlainObject3(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function jsonSafeMetadata(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => entry === undefined ? null : jsonSafeMetadata(entry));
+  }
+  if (!isPlainObject3(value))
+    return value;
+  const cleaned = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (entry === undefined)
+      continue;
+    cleaned[key] = jsonSafeMetadata(entry);
+  }
+  return cleaned;
+}
 function resultContent(result) {
   if (typeof result === "string")
     return { content: result };
@@ -41188,15 +41365,39 @@ function resultContent(result) {
     ...attachment.filename ? { name: attachment.filename } : {}
   }));
   const content = attachments.length ? [{ type: "text", text: result.output }, ...attachments] : result.output;
-  const metadata = {
+  const metadata = jsonSafeMetadata({
     ...result.metadata ?? {},
     ...result.title ? { title: result.title } : {}
-  };
+  });
   return {
     content,
     ...Object.keys(metadata).length ? { metadata } : {}
   };
 }
+function failureEnvelopeMessage(result) {
+  const output = typeof result === "string" ? result : result.output;
+  if (typeof output !== "string")
+    return;
+  const trimmed = output.trim();
+  if (!trimmed.startsWith("{") || !trimmed.includes('"success"'))
+    return;
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+    return;
+  const envelope = parsed;
+  if (envelope.success !== false)
+    return;
+  for (const field of [envelope.message, envelope.error, envelope.code]) {
+    if (typeof field === "string" && field.length > 0)
+      return field;
+  }
+  return "The tool call failed.";
+}
 function bareToolName3(name) {
   return name.startsWith("aft_") ? name.slice(4) : name;
 }
@@ -41259,15 +41460,15 @@ function runtimeFor(location, context, signal, consumers) {
     abort: signal,
     effectAbort: signal,
     metadata: (update) => {
-      Effect.runPromise(context.progress({
+      Effect.runPromise(context.progress(jsonSafeMetadata({
         ...update.metadata ?? {},
         ...update.title ? { title: update.title } : {}
-      }));
+      })));
     },
     ask: (request) => {
       if (consumers.requestPermission)
         return consumers.requestPermission(request, context);
-      return Promise.reject(new Error(`The "${request.permission}" operation was refused because the OpenCode V2 host did not provide a permission request endpoint.`));
+      return Promise.reject(new Error(`The "${request.permission}" operation was refused because this AFT runtime has no permission evaluator bound, so the host's permission rules for it could not be consulted.`));
     },
     progress: context.progress
   };
@@ -41296,6 +41497,9 @@ function projectV2Tool(name, definition, location, consumers = {}) {
           context: runtime,
           definition
         }) : await definition.execute(input, runtime);
+        const refusal = failureEnvelopeMessage(result);
+        if (refusal)
+          throw new Error(refusal);
         return resultContent(result);
       },
       catch: failure
@@ -42390,7 +42594,7 @@ function createReadTool(ctx) {
         try {
           await runAsk(context.ask({
             permission: "read",
-            patterns: [filePath],
+            patterns: [permissionPath(context, filePath)],
             always: ["*"],
             metadata: {}
           }));
@@ -42551,7 +42755,7 @@ function getEditDescription(ctx, writeToolName) {
 
 **Modes** (determined by which parameters you provide):
 
-Provide exactly one mode per call: appendContent, edits[], or symbol plus content. Mixing modes or providing none is rejected — there is no implicit "write" fallback. To edit multiple files, make parallel \`edit\` calls in one response.
+Provide exactly one mode per call: appendContent, edits[], or symbol plus content. \`symbol\` and \`content\` are only meaningful together; a call carrying one without the other is incomplete. Mixing modes or providing none is rejected — there is no implicit "write" fallback. To edit multiple files, make parallel \`edit\` calls in one response.
 
 1. **Append** — pass \`path\` + \`appendContent\`
    Appends text to the end of a file, creating it if it does not exist.
@@ -42652,8 +42856,8 @@ function createEditTool(ctx, writeToolName = "write") {
     description: getEditDescription(ctx, writeToolName),
     args: {
       filePath: z7.string().describe("Path to the file to edit (absolute or relative to project root)"),
-      symbol: z7.string().optional().describe("Named symbol to replace (function, class, type)"),
-      content: z7.string().optional().describe("Replacement content for symbol mode. For whole-file writes, use the `write` tool."),
+      symbol: z7.string().optional().describe("Named symbol to replace; only meaningful together with `content`. A call carrying one without the other is incomplete."),
+      content: z7.string().optional().describe("Replacement content for symbol mode; only meaningful together with `symbol`. A call carrying one without the other is incomplete. For whole-file writes, use the `write` tool."),
       appendContent: z7.string().optional().describe("Text to append to the end of path; creates the file if needed"),
       edits: z7.array(z7.object({
         oldString: z7.string().optional().describe("Text to find for a batch find/replace edit"),
@@ -42895,7 +43099,7 @@ function createDeleteTool(ctx) {
       }
       await runAsk(context.ask({
         permission: "edit",
-        patterns: absolutePaths,
+        patterns: resolveRelativePatterns(context, absolutePaths),
         always: ["*"],
         metadata: { action: "delete", count: absolutePaths.length }
       }));
@@ -42948,7 +43152,7 @@ function createMoveTool(ctx) {
       }
       await runAsk(context.ask({
         permission: "edit",
-        patterns: [filePath, destPath],
+        patterns: resolveRelativePatterns(context, [filePath, destPath]),
         always: ["*"],
         metadata: { action: "move" }
       }));
@@ -43278,7 +43482,7 @@ function inspectTools(ctx) {
 ` + "Treat `dead_code` as a hint, not proof: reachability is call-based, so symbols reached only via method dispatch or referenced only in type position may be false positives — verify before deleting.\n\n" + "When a list is cut, the reply ends with `shown N of M <unit> (<reason>) · narrow: <knobs>`; absence of that line means the list is complete.",
     args: {
       sections: arg(z9.union([z9.string(), z9.array(z9.string())]).optional().describe("Categories to include in detailed drill-down (e.g. 'todos' or ['todos', 'dead_code', 'cycles']). Use 'all' for every active category. Omit for summary-only mode. `sections` changes detail, not the categories verified.")),
-      scope: arg(z9.union([z9.string(), z9.array(z9.string())]).optional().describe("Restrict returned results to paths under this scope (file or directory, absolute or relative to project root). `scope=` narrows results and limits Rust LSP startup to owning Cargo workspaces; it does not trigger per-file diagnostic collection. Scoped files no producer has authoritatively analyzed are reported as named gaps (complete: false), never as a clean empty result.")),
+      scope: arg(z9.union([z9.string(), z9.array(z9.string())]).optional().describe("Restrict returned results to paths under this scope (one path, or an array of paths — not a space-separated list; file or directory; absolute or relative to project root). `scope=` narrows results and limits Rust LSP startup to owning Cargo workspaces; it does not trigger per-file diagnostic collection. Scoped files no producer has authoritatively analyzed are reported as named gaps (complete: false), never as a clean empty result.")),
       topK: arg(z9.number().int().positive().max(100).optional().describe("Max drill-down items per category. Default 20, max 100."))
     },
     execute: async (args, context) => {
@@ -43671,7 +43875,7 @@ function safetyTools(ctx) {
 ` + `- 'undo': Undo the entire last tool call when 'path' is omitted (typical), or undo the last edit to one file when 'path' is provided. Note: pops from the undo stack (irreversible, no redo). Use 'history' to inspect per-file history before undoing.
 ` + `- 'history': List all edit snapshots for a file. Requires 'path'.
 ` + `- 'checkpoint': Save a named snapshot. Explicit 'files' may be untracked or gitignored; omit them to snapshot backup-tracked files. Checkpoints are session-scoped and lost on bridge or daemon restart. Requires 'name'.
-` + `- 'restore': Restore files to a previously saved checkpoint. Requires 'name'.
+` + `- 'restore': Restore files to a previously saved checkpoint. Optional 'path'/'files' scopes the restore; omitted scope restores the whole checkpoint. Requires 'name'.
 ` + `- 'list': List all available named checkpoints. No extra params needed.
 
 ` + `Each op requires specific parameters — see parameter descriptions for requirements.
@@ -43679,9 +43883,9 @@ function safetyTools(ctx) {
 ` + "Use checkpoint before risky multi-file changes. Use undo for quick single-file rollback.",
       args: {
         op: z12.enum(["undo", "history", "checkpoint", "restore", "list"]).describe("Safety operation"),
-        path: z12.string().optional().describe("File path (required for history, optional for undo). Absolute or relative to project root"),
+        path: z12.string().optional().describe("File path (required for history, optional for undo, optional for restore — restores only that file). Absolute or relative to project root"),
         name: z12.string().optional().describe("Checkpoint name (required for checkpoint, restore)"),
-        files: z12.array(z12.string()).optional().describe("Specific files to include in checkpoint (optional, defaults to backup-tracked files; explicit files may be untracked or gitignored)")
+        files: z12.array(z12.string()).optional().describe("Specific files to include in checkpoint, or to restore from a checkpoint (optional; restore without path/files restores the whole checkpoint; explicit checkpoint files may be untracked or gitignored)")
       },
       execute: async (args, context) => {
         const op = args.op;
@@ -44000,7 +44204,7 @@ function semanticTools(ctx) {
 `),
     args: {
       query: arg3(z13.string().describe("Concept, regex, literal text, filename, or capability to find. Examples: 'fuzzy match with whitespace tolerance', '^export', 'Cargo.lock'.")),
-      topK: arg3(optionalInt(1, 100).describe("Number of results (default: 10, max: 100)")),
+      topK: arg3(optionalInt(1, 50).describe("Number of results (default: 10, max: 50)")),
       offset: arg3(optionalInt(0, 1e5).describe("Zero-based result offset (default: 0, max: 100000).")),
       includeTests: arg3(z13.boolean().optional().describe("Include test files (*.test.*, *_test.rs, __tests__/, …) plus test-support, fixture, mock, snapshot, and corpus files. Defaults to false.")),
       path: arg3(z13.string().optional().describe("Only set this to search a different Git project (absolute or ~ path). Omit it for the current configured workspace, including non-Git workspace roots; this is not a subdirectory filter. Unindexed external projects use a bounded lexical fallback."))
@@ -44016,9 +44220,9 @@ function semanticTools(ctx) {
       if (denied)
         return permissionDeniedResponse(denied);
       const rawArgs = { query };
-      const topK = coerceOptionalInt(args.topK, "topK", 1, 100);
+      const topK = coerceOptionalInt(args.topK, "topK", 1, 50);
       const offset = coerceOptionalInt(args.offset, "offset", 0, 1e5);
-      const includeTests = typeof args.includeTests === "boolean" ? args.includeTests : undefined;
+      const includeTests = !isEmptyParam(args.includeTests) ? coerceBoolean(args.includeTests) : undefined;
       if (topK !== undefined)
         rawArgs.topK = topK;
       if (offset !== undefined)
@@ -44258,11 +44462,11 @@ function throwSentinel(command) {
   throw sentinel;
 }
 var PLUGIN_VERSION = resolvePluginVersion(import.meta.url);
-var ANNOUNCEMENT_VERSION = "0.56.0";
+var ANNOUNCEMENT_VERSION = "0.57.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).",
-  "Disk hygiene: stale per-checkout inspect caches from old worktrees are now swept automatically — one machine reclaimed 21 GB."
+  "OpenCode 2 is supported: tools, permission prompts, the sidebar and cancellation all work on the GA host, and an end-to-end matrix guards them.",
+  "`doctor` configures a machine that has only OpenCode 2 installed, and `--fix` no longer skips unrelated repairs when it cannot decide the generation.",
+  "A code-health scan no longer starts while the same project is still building its call graph, which cost about 90 MB of peak memory on large repositories."
 ];
 var ANNOUNCEMENT_FOOTER = "Join us on Discord: https://discord.gg/DSa65w8wuf";
 var plugin = async (input) => initializePluginForDirectory(input);