@cortexkit/aft-pi 0.56.1 → 0.57.0

package/dist/index.js

@@ -8748,6 +8748,7 @@ class BinaryBridge {
   pending = new Map;
   outstandingBackgroundTaskIds = new Set;
   nextId = 1;
+  processGeneration = 0;
   stdoutBuffer = "";
   stdoutReadOffset = 0;
   stderrBuffer = "";
@@ -9060,6 +9061,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 };
@@ -9113,14 +9115,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) {
@@ -9423,6 +9431,7 @@ class BinaryBridge {
       this.handleCrash();
     });
     this.process = child;
+    this.processGeneration += 1;
     this.spawnedBinaryFingerprint = readBinaryFingerprint(this.binaryPath);
     this.lastBinaryFingerprintCheckAt = Date.now();
     this.stdoutBuffer = "";
@@ -9594,10 +9603,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");
@@ -9607,17 +9621,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) {
@@ -15760,12 +15768,36 @@ function npmSpawnEnv(resolved, baseEnv = process.env, platform = process.platfor
   return withPathPrepended(baseEnv, resolved.binDir, platform);
 }
 // ../aft-bridge/dist/onnx-runtime.js
-import { execFileSync } from "node:child_process";
+import { execFileSync as execFileSync2 } 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 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;
@@ -15826,11 +15858,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 {
@@ -15859,9 +15891,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.`);
@@ -15880,7 +15912,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;
@@ -15917,7 +15949,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 });
     }
@@ -15961,8 +15993,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);
@@ -16028,10 +16060,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;
 }
@@ -16046,13 +16078,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 })) {
@@ -16060,7 +16092,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)}`);
@@ -16082,11 +16114,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);
@@ -16152,7 +16184,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);
@@ -16185,34 +16217,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}`);
@@ -16226,15 +16256,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;
@@ -16243,17 +16269,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") {
@@ -16269,11 +16317,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}`;
@@ -16294,21 +16342,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
   });
@@ -16321,13 +16366,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;
@@ -16439,7 +16484,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
@@ -16660,10 +16705,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}`);
   }
@@ -16683,7 +16726,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 = {};
@@ -16736,6 +16779,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)
@@ -16821,9 +16887,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;
@@ -17006,6 +17069,48 @@ 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;
+}
 // ../aft-bridge/dist/tool-format.js
 function asPlainObject(value) {
   if (!value || typeof value !== "object" || Array.isArray(value))
@@ -18049,7 +18154,7 @@ import {
 // package.json
 var package_default = {
   name: "@cortexkit/aft-pi",
-  version: "0.56.1",
+  version: "0.57.0",
   type: "module",
   description: "Pi coding agent extension for Agent File Tools (AFT) — tree-sitter and LSP-powered code analysis",
   main: "dist/index.js",
@@ -18072,19 +18177,19 @@ var package_default = {
     "test:unit": "bun test src/__tests__ --path-ignore-patterns 'src/__tests__/e2e/**'"
   },
   dependencies: {
-    "@cortexkit/aft-bridge": "0.56.1",
+    "@cortexkit/aft-bridge": "0.57.0",
     "comment-json": "^5.0.0",
     diff: "^8.0.4",
     typebox: "1.1.38",
     zod: "^4.4.3"
   },
   optionalDependencies: {
-    "@cortexkit/aft-darwin-arm64": "0.56.1",
-    "@cortexkit/aft-darwin-x64": "0.56.1",
-    "@cortexkit/aft-linux-arm64": "0.56.1",
-    "@cortexkit/aft-linux-x64": "0.56.1",
-    "@cortexkit/aft-win32-arm64": "0.56.1",
-    "@cortexkit/aft-win32-x64": "0.56.1"
+    "@cortexkit/aft-darwin-arm64": "0.57.0",
+    "@cortexkit/aft-darwin-x64": "0.57.0",
+    "@cortexkit/aft-linux-arm64": "0.57.0",
+    "@cortexkit/aft-linux-x64": "0.57.0",
+    "@cortexkit/aft-win32-arm64": "0.57.0",
+    "@cortexkit/aft-win32-x64": "0.57.0"
   },
   devDependencies: {
     "@earendil-works/pi-coding-agent": "^0.80.2",
@@ -18185,12 +18290,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;
@@ -18291,7 +18390,7 @@ function formatStatusDialogMessage(status) {
     `Cache role: ${formatCacheRoleLabel(status.cache_role)}`
   ];
   appendDegradedStatus(lines, status, false);
-  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(`- ${refreshing}`);
@@ -18352,7 +18451,7 @@ function appendDegradedStatus(lines, status, markdown) {
 }
 
 // src/tools/_shared.ts
-import { existsSync as existsSync10 } from "node:fs";
+import { existsSync as existsSync11 } 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
@@ -18411,7 +18510,7 @@ function prepareToolDefinitionForRegistration(tool, harness = "pi", presentation
   };
 }
 function bridgeFor(ctx, cwd) {
-  if (!existsSync10(cwd)) {
+  if (!existsSync11(cwd)) {
     throw new Error(`project directory no longer exists: ${cwd} (stale restored session?)`);
   }
   return ctx.pool.getBridge(cwd);
@@ -18785,7 +18884,7 @@ function registerStatusCommand(pi, ctx) {
 }
 
 // src/config.ts
-import { existsSync as existsSync11, readFileSync as readFileSync7, renameSync as renameSync5, unlinkSync as unlinkSync5, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync12, readFileSync as readFileSync7, renameSync as renameSync6, 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);
@@ -23692,6 +23791,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(),
@@ -23912,7 +24012,7 @@ function migrateExperimentalBashBlock(rawConfig, configPath, logger) {
   return movedKeys;
 }
 function migrateAftConfigFile2(configPath, logger = { log: log2, warn: warn2 }) {
-  if (!existsSync11(configPath)) {
+  if (!existsSync12(configPath)) {
     return { migrated: false, oldKeys: [] };
   }
   let tmpPath = null;
@@ -23935,7 +24035,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) {
@@ -23971,7 +24071,7 @@ function warnIgnoredHarnessSpecificConfigKeys(config, configPath) {
 }
 function loadConfigFromPath(configPath) {
   try {
-    if (!existsSync11(configPath))
+    if (!existsSync12(configPath))
       return null;
     const content = readFileSync7(configPath, "utf-8");
     const rawConfig = import_comment_json.parse(content);
@@ -24328,15 +24428,15 @@ import { spawn as spawn4 } from "node:child_process";
 import { createHash as createHash4 } from "node:crypto";
 import {
   createReadStream,
-  existsSync as existsSync13,
+  existsSync as existsSync14,
   mkdirSync as mkdirSync7,
   readFileSync as readFileSync10,
-  renameSync as renameSync7,
+  renameSync as renameSync8,
   rmSync as rmSync5,
   statSync as statSync8,
   writeFileSync as writeFileSync6
 } from "node:fs";
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 
 // src/lsp-cache.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
@@ -24345,13 +24445,13 @@ import {
   mkdirSync as mkdirSync6,
   openSync as openSync5,
   readFileSync as readFileSync8,
-  renameSync as renameSync6,
+  renameSync as renameSync7,
   rmSync as rmSync4,
   statSync as statSync7,
   unlinkSync as unlinkSync6,
   writeFileSync as writeFileSync5
 } from "node:fs";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 function aftCacheBase() {
   return getAftCacheRoot();
 }
@@ -24359,18 +24459,18 @@ function lspCacheRoot() {
   return getAftLspPackagesDir();
 }
 function lspPackageDir(npmPackage) {
-  return join13(lspCacheRoot(), encodeURIComponent(npmPackage));
+  return join14(lspCacheRoot(), encodeURIComponent(npmPackage));
 }
 function lspBinaryPath(npmPackage, binary) {
-  return join13(lspPackageDir(npmPackage), "node_modules", ".bin", binary);
+  return join14(lspPackageDir(npmPackage), "node_modules", ".bin", binary);
 }
 function lspBinDir(npmPackage) {
-  return join13(lspPackageDir(npmPackage), "node_modules", ".bin");
+  return join14(lspPackageDir(npmPackage), "node_modules", ".bin");
 }
 function isInstalled(npmPackage, binary) {
   for (const candidate of lspBinaryCandidates(binary)) {
     try {
-      if (statSync7(join13(lspBinDir(npmPackage), candidate)).isFile())
+      if (statSync7(join14(lspBinDir(npmPackage), candidate)).isFile())
         return true;
     } catch {}
   }
@@ -24390,13 +24490,13 @@ function writeInstalledMetaIn(installDir, version, sha256) {
       installedAt: new Date().toISOString(),
       ...sha256 ? { sha256 } : {}
     };
-    writeFileSync5(join13(installDir, INSTALLED_META_FILE), JSON.stringify(meta), "utf8");
+    writeFileSync5(join14(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 = join13(installDir, INSTALLED_META_FILE);
+  const path = join14(installDir, INSTALLED_META_FILE);
   try {
     if (!statSync7(path).isFile())
       return null;
@@ -24420,7 +24520,7 @@ function readInstalledMeta(packageKey) {
   return readInstalledMetaIn(lspPackageDir(packageKey));
 }
 function lockPath(npmPackage) {
-  return join13(lspPackageDir(npmPackage), ".aft-installing");
+  return join14(lspPackageDir(npmPackage), ".aft-installing");
 }
 var STALE_LOCK_MS2 = 30 * 60 * 1000;
 function acquireInstallLock(lockKey) {
@@ -24551,7 +24651,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 join13(aftCacheBase(), AUTO_INSTALL_STAMP_FILE);
+  return join14(aftCacheBase(), AUTO_INSTALL_STAMP_FILE);
 }
 function hasRecentAutoInstallStamp(path) {
   try {
@@ -24637,7 +24737,7 @@ function claimLspAutoInstallPass() {
       encoding: "utf8",
       mode: 384
     });
-    renameSync6(tempPath, stampPath);
+    renameSync7(tempPath, stampPath);
     return { release };
   } catch (err) {
     if (claimed) {
@@ -24652,7 +24752,7 @@ function claimLspAutoInstallPass() {
 }
 var VERSION_CHECK_FILE = ".aft-version-check";
 function readVersionCheck(npmPackage) {
-  const file = join13(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
+  const file = join14(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
   try {
     const raw = readFileSync8(file, "utf8");
     const parsed = JSON.parse(raw);
@@ -24669,7 +24769,7 @@ function readVersionCheck(npmPackage) {
 }
 function writeVersionCheck(npmPackage, latest) {
   mkdirSync6(lspPackageDir(npmPackage), { recursive: true });
-  const file = join13(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
+  const file = join14(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
   const record = {
     last_checked: new Date().toISOString(),
     latest_eligible: latest
@@ -24831,8 +24931,8 @@ var NPM_LSP_TABLE = [
 ];
 
 // src/lsp-project-relevance.ts
-import { existsSync as existsSync12, readdirSync as readdirSync4, readFileSync as readFileSync9 } from "node:fs";
-import { join as join14 } from "node:path";
+import { existsSync as existsSync13, readdirSync as readdirSync4, readFileSync as readFileSync9 } from "node:fs";
+import { join as join15 } from "node:path";
 var MAX_WALK_DIRS = 200;
 var MAX_WALK_DEPTH = 4;
 var NOISE_DIRS = new Set([
@@ -24849,7 +24949,7 @@ function hasRootMarker(projectRoot, rootMarkers) {
   if (!rootMarkers)
     return false;
   for (const marker of rootMarkers) {
-    if (existsSync12(join14(projectRoot, marker)))
+    if (existsSync13(join15(projectRoot, marker)))
       return true;
   }
   return false;
@@ -24873,7 +24973,7 @@ function hasPackageJsonDep(projectRoot, depNames) {
 }
 function readPackageJson(projectRoot) {
   try {
-    const raw = readFileSync9(join14(projectRoot, "package.json"), "utf8");
+    const raw = readFileSync9(join15(projectRoot, "package.json"), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null)
       return null;
@@ -24903,7 +25003,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: join14(current.dir, entry.name), depth: current.depth + 1 });
+          queue.push({ dir: join15(current.dir, entry.name), depth: current.depth + 1 });
         }
         continue;
       }
@@ -25031,8 +25131,8 @@ async function resolveTargetVersion(spec, config, fetchImpl = fetch) {
 }
 function ensureInstallAnchor(cwd) {
   try {
-    const stub = join15(cwd, "package.json");
-    if (!existsSync13(stub)) {
+    const stub = join16(cwd, "package.json");
+    if (!existsSync14(stub)) {
       writeFileSync6(stub, `${JSON.stringify({ name: "aft-lsp-cache", version: "0.0.0", private: true })}
 `);
     }
@@ -25258,12 +25358,12 @@ function sha256OfFileSync(path) {
 }
 function quarantineCachedNpmInstall(spec, reason) {
   const packageDir = lspPackageDir(spec.npm);
-  const dest = join15(packageDir, "..", ".quarantine", encodeURIComponent(spec.npm), `${Date.now()}`);
+  const dest = join16(packageDir, "..", ".quarantine", encodeURIComponent(spec.npm), `${Date.now()}`);
   warn2(`[lsp] tofu_mismatch ${spec.npm}: ${reason}; quarantining ${packageDir} -> ${dest}`);
   try {
-    mkdirSync7(join15(dest, ".."), { recursive: true });
+    mkdirSync7(join16(dest, ".."), { recursive: true });
     rmSync5(dest, { recursive: true, force: true });
-    renameSync7(packageDir, dest);
+    renameSync8(packageDir, dest);
   } catch (err) {
     warn2(`[lsp] tofu_mismatch ${spec.npm}: failed to quarantine cache entry: ${err}`);
   }
@@ -25343,26 +25443,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 createHash5, randomBytes as randomBytes2 } from "node:crypto";
 import {
   copyFileSync as copyFileSync4,
   createReadStream as createReadStream2,
   createWriteStream as createWriteStream3,
-  existsSync as existsSync14,
+  existsSync as existsSync15,
   lstatSync as lstatSync2,
   mkdirSync as mkdirSync8,
   readdirSync as readdirSync5,
   readFileSync as readFileSync11,
   readlinkSync as readlinkSync2,
   realpathSync as realpathSync3,
-  renameSync as renameSync8,
+  renameSync as renameSync9,
   rmSync as rmSync6,
   statSync as statSync9,
   unlinkSync as unlinkSync7,
   writeFileSync as writeFileSync7
 } from "node:fs";
-import { dirname as dirname6, join as join16, relative as relative3, resolve as resolve8 } from "node:path";
+import { dirname as dirname6, join as join17, relative as relative3, resolve as resolve8 } from "node:path";
 import { Readable as Readable3 } from "node:stream";
 import { pipeline as pipeline3 } from "node:stream/promises";
 
@@ -25455,19 +25555,19 @@ function ghCacheRoot() {
   return getAftLspBinariesDir();
 }
 function ghPackageDir(spec) {
-  return join16(ghCacheRoot(), spec.id);
+  return join17(ghCacheRoot(), spec.id);
 }
 function ghBinDir(spec) {
-  return join16(ghPackageDir(spec), "bin");
+  return join17(ghPackageDir(spec), "bin");
 }
 function ghExtractDir(spec) {
-  return join16(ghPackageDir(spec), "extracted");
+  return join17(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 join16(ghPackageDir(spec), INSTALL_FAILED_FILE);
+  return join17(ghPackageDir(spec), INSTALL_FAILED_FILE);
 }
 function readInstallFailureMarker(spec) {
   try {
@@ -25488,7 +25588,7 @@ function writeInstallFailureMarker(spec, release, sha256, installError) {
     mkdirSync8(dirname6(path), { recursive: true });
     writeFileSync7(tempPath, `${JSON.stringify({ release, sha256, error: markerError, at: new Date().toISOString() })}
 `, { encoding: "utf8", mode: 384 });
-    renameSync8(tempPath, path);
+    renameSync9(tempPath, path);
   } catch (err) {
     try {
       rmSync6(tempPath, { force: true });
@@ -25509,12 +25609,12 @@ function isFreshInstallFailure(marker) {
 }
 function ghBinaryPath(spec, platform) {
   const ext = platform === "win32" ? ".exe" : "";
-  return join16(ghBinDir(spec), `${spec.binary}${ext}`);
+  return join17(ghBinDir(spec), `${spec.binary}${ext}`);
 }
 function isGithubInstalled(spec, platform) {
   for (const candidate of ghBinaryCandidates(spec, platform)) {
     try {
-      if (statSync9(join16(ghBinDir(spec), candidate)).isFile())
+      if (statSync9(join17(ghBinDir(spec), candidate)).isFile())
         return true;
     } catch {}
   }
@@ -25527,7 +25627,7 @@ function ghBinaryCandidates(spec, platform) {
 }
 function readGithubInstalledMetaIn(installDir) {
   try {
-    const path = join16(installDir, INSTALLED_META_FILE2);
+    const path = join17(installDir, INSTALLED_META_FILE2);
     if (!statSync9(path).isFile())
       return null;
     const parsed = JSON.parse(readFileSync11(path, "utf8"));
@@ -25554,7 +25654,7 @@ function writeGithubInstalledMetaIn(installDir, version, binarySha256, archiveSh
       binarySha256,
       ...archiveSha256 ? { archiveSha256 } : {}
     };
-    writeFileSync7(join16(installDir, INSTALLED_META_FILE2), JSON.stringify(meta), "utf8");
+    writeFileSync7(join17(installDir, INSTALLED_META_FILE2), JSON.stringify(meta), "utf8");
   } catch (err) {
     warn2(`[lsp] failed to write github installed metadata in ${installDir}: ${err}`);
   }
@@ -25803,7 +25903,7 @@ function validateExtraction(stagingRoot) {
       throw new Error(`failed to read staging dir ${dir}: ${err}`);
     }
     for (const entry of entries) {
-      const full = join16(dir, entry);
+      const full = join17(dir, entry);
       let lst;
       try {
         lst = lstatSync2(full);
@@ -25849,7 +25949,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")) {
@@ -25862,7 +25962,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)
@@ -25873,19 +25973,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}`);
@@ -25905,7 +26004,7 @@ function extractArchiveSafely(archivePath, destDir, archiveType) {
     try {
       rmSync6(destDir, { recursive: true, force: true });
     } catch {}
-    renameSync8(stagingDir, destDir);
+    renameSync9(stagingDir, destDir);
   } catch (err) {
     try {
       rmSync6(stagingDir, { recursive: true, force: true });
@@ -25915,12 +26014,12 @@ function extractArchiveSafely(archivePath, destDir, archiveType) {
 }
 function quarantineCachedGithubInstall(spec, reason) {
   const packageDir = ghPackageDir(spec);
-  const dest = join16(ghCacheRoot(), ".quarantine", encodeURIComponent(spec.id), `${Date.now()}`);
+  const dest = join17(ghCacheRoot(), ".quarantine", encodeURIComponent(spec.id), `${Date.now()}`);
   warn2(`[lsp] tofu_mismatch ${spec.id}: ${reason}; quarantining ${packageDir} -> ${dest}`);
   try {
     mkdirSync8(dirname6(dest), { recursive: true });
     rmSync6(dest, { recursive: true, force: true });
-    renameSync8(packageDir, dest);
+    renameSync9(packageDir, dest);
   } catch (err) {
     warn2(`[lsp] tofu_mismatch ${spec.id}: failed to quarantine cache entry: ${err}`);
   }
@@ -25928,7 +26027,7 @@ function quarantineCachedGithubInstall(spec, reason) {
 function validateCachedGithubInstall(spec, platform) {
   const packageDir = ghPackageDir(spec);
   const meta = readGithubInstalledMetaIn(packageDir);
-  const binaryPath = ghBinaryCandidates(spec, platform).map((candidate) => join16(ghBinDir(spec), candidate)).find((candidate) => {
+  const binaryPath = ghBinaryCandidates(spec, platform).map((candidate) => join17(ghBinDir(spec), candidate)).find((candidate) => {
     try {
       return statSync9(candidate).isFile();
     } catch {
@@ -25964,30 +26063,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}`);
@@ -26008,7 +26098,7 @@ async function downloadAndInstall(spec, tag, assets, platform, arch, fetchImpl,
   }
   const pkgDir = ghPackageDir(spec);
   const extractDir = ghExtractDir(spec);
-  const archivePath = join16(pkgDir, expected.name);
+  const archivePath = join17(pkgDir, expected.name);
   log2(`[lsp] downloading ${spec.id} ${tag} → ${matchingAsset.url}`);
   try {
     await downloadFile(matchingAsset.url, archivePath, fetchImpl, matchingAsset.size, signal);
@@ -26050,8 +26140,8 @@ async function downloadAndInstall(spec, tag, assets, platform, arch, fetchImpl,
       unlinkSync7(archivePath);
     } catch {}
   }
-  const innerBinaryPath = join16(extractDir, spec.binaryPathInArchive(platform, arch, version));
-  if (!existsSync14(innerBinaryPath)) {
+  const innerBinaryPath = join17(extractDir, spec.binaryPathInArchive(platform, arch, version));
+  if (!existsSync15(innerBinaryPath)) {
     const message = `extracted binary not found at ${innerBinaryPath}`;
     error2(`[lsp] ${spec.id}: ${message}`);
     return { ok: false, sha256: archiveSha256, error: message };
@@ -26156,7 +26246,7 @@ function runGithubAutoInstall(relevantServers, config, fetchImpl = fetch) {
   if (!host) {
     for (const spec of GITHUB_LSP_TABLE) {
       try {
-        if (existsSync14(ghBinDir(spec))) {
+        if (existsSync15(ghBinDir(spec))) {
           cachedBinDirs.push(ghBinDir(spec));
         }
       } catch {}
@@ -27022,9 +27112,11 @@ var EditParams = Type2.Object({
   path: Type2.String({
     description: "Path to the file to edit (absolute or relative to project root)"
   }),
-  symbol: Type2.Optional(Type2.String({ description: "Named symbol to replace (function, class, type)" })),
+  symbol: Type2.Optional(Type2.String({
+    description: "Named symbol to replace; only meaningful together with `content`. A call carrying one without the other is incomplete."
+  })),
   content: Type2.Optional(Type2.String({
-    description: "Replacement content for symbol mode. For whole-file writes, use the `write` tool."
+    description: "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: Type2.Optional(Type2.String({
     description: "Append text to the end of the file (creates the file if missing, parent dirs auto-created). When set, other edit modes are ignored."
@@ -27293,7 +27385,7 @@ PDFs aren't supported on the Pi harness yet.`, response);
     pi.registerTool(withPathAliasPreparation({
       name: editName,
       label: editName,
-      description: "Edit part of a file via `appendContent`, batch `edits[]`, or symbol plus `content`. Batch `{ oldString, newString, replaceAll: true }` replaces every match. Provide exactly one mode per call: appendContent, edits[], or symbol plus content (mixing modes is rejected)." + (resolveGithubConfig(ctx.config).write ? ' GitHub conversation comments can be edited with `edit("issue://N/comments/K", edits=[{oldString, newString}])` or the equivalent `pr://` path.' : ""),
+      description: "Edit part of a file via `appendContent`, batch `edits[]`, or symbol plus `content`. `symbol` and `content` are only meaningful together; a call carrying one without the other is incomplete. Batch `{ oldString, newString, replaceAll: true }` replaces every match. Provide exactly one mode per call: appendContent, edits[], or symbol plus content (mixing modes is rejected)." + (resolveGithubConfig(ctx.config).write ? ' GitHub conversation comments can be edited with `edit("issue://N/comments/K", edits=[{oldString, newString}])` or the equivalent `pr://` path.' : ""),
       promptSnippet: "Partial file edits via appendContent, edits[], or symbol plus content (exactly one mode per call).",
       promptGuidelines: [
         `Prefer ${editName} over ${writeName} when changing part of an existing file.`,
@@ -29068,7 +29160,7 @@ var InspectParams = Type8.Object({
     description: "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: Type8.Optional(Type8.Union([Type8.String(), Type8.Array(Type8.String())], {
-    description: "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."
+    description: "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: Type8.Optional(Type8.Integer({
     minimum: 1,
@@ -29911,11 +30003,11 @@ var SafetyParams = Type11.Object({
     description: "Safety operation"
   }),
   path: Type11.Optional(Type11.String({
-    description: "File path (required for history, optional for undo). Absolute or relative to project root."
+    description: "File path (required for history, optional for undo, optional for restore — restores only that file). Absolute or relative to project root."
   })),
   name: Type11.Optional(Type11.String({ description: "Checkpoint name (required for checkpoint, restore)" })),
   files: Type11.Optional(Type11.Array(Type11.String(), {
-    description: "Specific files for checkpoint (optional, defaults to all backup-tracked files; explicit files may be untracked or gitignored)"
+    description: "Specific files for checkpoint, or to restore from a checkpoint (optional; restore without path/files restores the whole checkpoint; explicit checkpoint files may be untracked or gitignored)"
   }))
 });
 function buildSafetySections(args, payload, theme) {
@@ -30014,7 +30106,7 @@ function registerSafetyTool(pi, ctx) {
   pi.registerTool(withPathAliasPreparation({
     name: "aft_safety",
     label: "safety",
-    description: "File safety and recovery operations. Ops: `undo` (omit path to undo the entire last tool call; pass path to pop latest snapshot for one file — irreversible), `history` (list snapshots for a file), `checkpoint` (save named snapshot), `restore` (restore named checkpoint), `list` (list checkpoints). Per-file undo stack is capped at 20.",
+    description: "File safety and recovery operations. Ops: `undo` (omit path to undo the entire last tool call; pass path to pop latest snapshot for one file — irreversible), `history` (list snapshots for a file), `checkpoint` (save named snapshot), `restore` (restore named checkpoint; optional path/files scopes it), `list` (list checkpoints). Per-file undo stack is capped at 20.",
     parameters: SafetyParams,
     async execute(_toolCallId, params, _signal, _onUpdate, extCtx) {
       if (params.op === "history" && !params.path) {
@@ -30144,9 +30236,9 @@ var SearchParams2 = Type12.Object({
   }),
   topK: Type12.Optional(Type12.Integer({
     minimum: 1,
-    maximum: 100,
+    maximum: 50,
     default: 10,
-    description: "Maximum number of results (default: 10, max: 100)"
+    description: "Maximum number of results (default: 10, max: 50)"
   })),
   offset: Type12.Optional(Type12.Integer({
     minimum: 0,
@@ -30274,19 +30366,20 @@ function registerSemanticTool(pi, ctx) {
       }
       const bridge = bridgeFor(ctx, extCtx.cwd);
       const req = { query: params.query };
+      const includeTests = !isEmptyParam(params.includeTests) ? coerceBoolean(params.includeTests) : undefined;
       if (params.topK !== undefined)
         req.topK = params.topK;
       if (params.offset !== undefined)
         req.offset = params.offset;
-      if (params.includeTests !== undefined)
-        req.includeTests = params.includeTests;
+      if (includeTests !== undefined)
+        req.includeTests = includeTests;
       if (params.path !== undefined)
         req.path = params.path;
       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");
       }
-      const text = surfaceSearchText(response, continuity, resolveSessionId(extCtx) ?? "unknown-session", continuityKey(selectedProjectRoot(extCtx.cwd, params.path), params.query, params.includeTests, params.topK));
+      const text = surfaceSearchText(response, continuity, resolveSessionId(extCtx) ?? "unknown-session", continuityKey(selectedProjectRoot(extCtx.cwd, params.path), params.query, includeTests, params.topK));
       return textResult(text, text === response.text ? response : { ...response, text });
     },
     renderCall(args, theme, context) {
@@ -30625,11 +30718,11 @@ var PLUGIN_VERSION = (() => {
     return "0.0.0";
   }
 })();
-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 pendingEagerWarnings = new Map;