@cortexkit/aft-pi 0.38.0 → 0.39.1

package/dist/index.js

@@ -7728,10 +7728,10 @@ var require_stringify = __commonJS((exports, module) => {
     replacer = null;
     indent = EMPTY;
   };
-  var join9 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(one)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two)), gap) : EMPTY;
+  var join10 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(one)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two)), gap) : EMPTY;
   var join_content = (inside, value, gap) => {
     const comment = process_comments(value, PREFIX_BEFORE, gap + indent, true);
-    return join9(comment, inside, gap);
+    return join10(comment, inside, gap);
   };
   var stringify_string = (holder, key, value) => {
     const raw = get_raw_string_literal(holder, key);
@@ -7753,13 +7753,13 @@ var require_stringify = __commonJS((exports, module) => {
       if (i !== 0) {
         inside += COMMA;
       }
-      const before = join9(after_comma, process_comments(value, BEFORE(i), deeper_gap), deeper_gap);
+      const before = join10(after_comma, process_comments(value, BEFORE(i), deeper_gap), deeper_gap);
       inside += before || LF + deeper_gap;
       inside += stringify(i, value, deeper_gap) || STR_NULL;
       inside += process_comments(value, AFTER_VALUE(i), deeper_gap);
       after_comma = process_comments(value, AFTER(i), deeper_gap);
     }
-    inside += join9(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join10(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
     return BRACKET_OPEN + join_content(inside, value, gap) + BRACKET_CLOSE;
   };
   var object_stringify = (value, gap) => {
@@ -7780,13 +7780,13 @@ var require_stringify = __commonJS((exports, module) => {
         inside += COMMA;
       }
       first = false;
-      const before = join9(after_comma, process_comments(value, BEFORE(key), deeper_gap), deeper_gap);
+      const before = join10(after_comma, process_comments(value, BEFORE(key), deeper_gap), deeper_gap);
       inside += before || LF + deeper_gap;
       inside += quote(key) + process_comments(value, AFTER_PROP(key), deeper_gap) + COLON + process_comments(value, AFTER_COLON(key), deeper_gap) + SPACE + sv + process_comments(value, AFTER_VALUE(key), deeper_gap);
       after_comma = process_comments(value, AFTER(key), deeper_gap);
     };
     keys.forEach(iteratee);
-    inside += join9(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join10(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
     return CURLY_BRACKET_OPEN + join_content(inside, value, gap) + CURLY_BRACKET_CLOSE;
   };
   function stringify(key, holder, gap) {
@@ -11674,7 +11674,45 @@ function error(message, meta) {
     console.error(`[aft-bridge] ERROR: ${message}`);
   }
 }
+// ../aft-bridge/dist/bash-format.js
+function appendPipeStripNote(output, note) {
+  return note ? `${output}
+
+${note}` : output;
+}
+function formatSeconds(ms) {
+  return `${Number((ms / 1000).toFixed(1))}s`;
+}
+function formatForegroundResult(data) {
+  const output = data.output_preview ?? "";
+  const outputPath = data.output_path;
+  const truncated = data.output_truncated === true;
+  const status = data.status;
+  const exit = data.exit_code;
+  let rendered = output;
+  if (truncated && outputPath) {
+    rendered += `
+[output truncated; full output at ${outputPath}]`;
+  }
+  if (status === "timed_out") {
+    rendered += `
+[command timed out]`;
+  }
+  if (typeof exit === "number" && exit !== 0) {
+    rendered += `
+[exit code: ${exit}]`;
+  }
+  return rendered;
+}
+function isTerminalStatus(status) {
+  return status === "completed" || status === "failed" || status === "killed" || status === "timed_out";
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 // ../aft-bridge/dist/bash-hints.js
+import * as os from "node:os";
+import * as path from "node:path";
 var CONFLICT_HINT = `
 
 [Hint] Use aft_conflicts to see all conflict regions across files in a single call.`;
@@ -11688,48 +11726,175 @@ function maybeAppendConflictsHint(output) {
     return output;
   return output + CONFLICT_HINT;
 }
-function commandLeadsWithCodeSearch(command) {
-  const trimmed = command.trim();
-  if (!trimmed)
-    return false;
-  const afterCd = peelLeadingCdAnd(trimmed);
-  if (afterCd === null)
-    return false;
-  const firstStage = firstPipelineStage(afterCd);
-  if (firstStage === null)
+function commandInvokesCodeSearch(command) {
+  const statements = splitTopLevelStatements(command);
+  if (statements === null)
     return false;
-  const firstToken = readShellToken(firstStage, skipSpaces(firstStage, 0));
-  if (firstToken === null)
-    return false;
-  return firstToken.token === "grep" || firstToken.token === "rg";
+  for (const statement of statements) {
+    const firstStage = firstPipelineStage(statement);
+    if (firstStage === null)
+      continue;
+    const firstToken = readShellToken(firstStage, skipSpaces(firstStage, 0));
+    if (firstToken === null)
+      continue;
+    if (firstToken.token === "grep" || firstToken.token === "rg")
+      return true;
+  }
+  return false;
 }
-function maybeAppendGrepSearchHint(output, command, aftSearchRegistered) {
+function maybeAppendGrepSearchHint(output, command, aftSearchRegistered, projectRoot) {
   if (output === "")
     return output;
-  if (!commandLeadsWithCodeSearch(command))
+  if (!commandInvokesCodeSearch(command))
     return output;
   if (output.includes(GREP_SEARCH_HINT_PREFIX))
     return output;
+  if (shouldSuppressGrepSearchHint(command, projectRoot))
+    return output;
   const hint = aftSearchRegistered ? GREP_SEARCH_AFT_SEARCH_HINT : GREP_SEARCH_GREP_HINT;
   return `${output}
 
 ${hint}`;
 }
-function peelLeadingCdAnd(command) {
-  const first = readShellToken(command, skipSpaces(command, 0));
-  if (first === null)
-    return null;
-  if (first.token !== "cd")
-    return command;
-  const dir = readShellToken(command, skipSpaces(command, first.end));
-  if (dir === null)
+function shouldSuppressGrepSearchHint(command, projectRoot) {
+  const root = projectRoot?.trim();
+  if (!root)
+    return false;
+  const statements = splitTopLevelStatements(command);
+  if (statements === null)
+    return false;
+  let sawCodeSearchStatement = false;
+  for (const statement of statements) {
+    const firstStage = firstPipelineStage(statement);
+    if (firstStage === null)
+      continue;
+    const firstToken = readShellToken(firstStage, skipSpaces(firstStage, 0));
+    if (firstToken === null)
+      continue;
+    if (firstToken.token !== "grep" && firstToken.token !== "rg")
+      continue;
+    sawCodeSearchStatement = true;
+    const operands = collectPathOperands(firstStage, firstToken.end);
+    if (operands.length === 0)
+      return false;
+    for (const operand of operands) {
+      if (isPathInsideProject(root, operand))
+        return false;
+    }
+  }
+  return sawCodeSearchStatement;
+}
+function collectPathOperands(firstStage, startAfterCommand) {
+  const operands = [];
+  let index = skipSpaces(firstStage, startAfterCommand);
+  while (index < firstStage.length) {
+    const tokenResult = readShellToken(firstStage, index);
+    if (tokenResult === null)
+      break;
+    const { token, end } = tokenResult;
+    if (end <= index)
+      break;
+    index = skipSpaces(firstStage, end);
+    if (token.startsWith("-"))
+      continue;
+    if (looksLikePathOperand(token))
+      operands.push(token);
+  }
+  return operands;
+}
+function looksLikePathOperand(token) {
+  return token.includes("/") || token.startsWith("~") || token.startsWith("./") || token.startsWith("../");
+}
+function expandTilde(target) {
+  if (!target.startsWith("~"))
+    return target;
+  if (target === "~" || target.startsWith("~/")) {
+    return path.join(os.homedir(), target.slice(1));
+  }
+  return target;
+}
+function resolvePathOperand(projectRoot, operand) {
+  const expanded = expandTilde(operand);
+  return path.isAbsolute(expanded) ? path.resolve(expanded) : path.resolve(projectRoot, expanded);
+}
+function isPathInsideProject(projectRoot, operand) {
+  const root = path.resolve(projectRoot);
+  const resolved = resolvePathOperand(root, operand);
+  const rel = path.relative(root, resolved);
+  return rel === "" || !rel.startsWith("..") && !path.isAbsolute(rel);
+}
+function splitTopLevelStatements(command) {
+  const statements = [];
+  let start = 0;
+  let quote = "none";
+  let escaped = false;
+  let inBacktick = false;
+  let parenDepth = 0;
+  for (let index = 0;index < command.length; index++) {
+    const ch = command[index];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (quote === "single") {
+      if (ch === "'")
+        quote = "none";
+      continue;
+    }
+    if (quote === "double") {
+      if (ch === "\\")
+        escaped = true;
+      else if (ch === '"')
+        quote = "none";
+      continue;
+    }
+    if (inBacktick) {
+      if (ch === "`")
+        inBacktick = false;
+      continue;
+    }
+    if (ch === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (ch === "'") {
+      quote = "single";
+      continue;
+    }
+    if (ch === '"') {
+      quote = "double";
+      continue;
+    }
+    if (ch === "`") {
+      inBacktick = true;
+      continue;
+    }
+    if (ch === "(") {
+      parenDepth++;
+      continue;
+    }
+    if (ch === ")") {
+      if (parenDepth > 0)
+        parenDepth--;
+      continue;
+    }
+    if (parenDepth > 0)
+      continue;
+    const next = command[index + 1];
+    if (ch === "&" && next === "&" || ch === "|" && next === "|") {
+      statements.push(command.slice(start, index));
+      index++;
+      start = index + 1;
+    } else if (ch === ";" || ch === `
+` || ch === "&") {
+      statements.push(command.slice(start, index));
+      start = index + 1;
+    }
+  }
+  if (quote !== "none" || inBacktick || escaped)
     return null;
-  if (!dir.token)
-    return command;
-  const afterDir = skipSpaces(command, dir.end);
-  if (!command.startsWith("&&", afterDir))
-    return command;
-  return command.slice(afterDir + 2).trim();
+  statements.push(command.slice(start));
+  return statements;
 }
 function firstPipelineStage(command) {
   let quote = "none";
@@ -11837,8 +12002,8 @@ function resolveBashKillTimeout(modelTimeout, foregroundWaitMs) {
 }
 // ../aft-bridge/dist/bridge.js
 import { spawn } from "node:child_process";
-import { homedir } from "node:os";
-import { join } from "node:path";
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
 import { StringDecoder } from "node:string_decoder";
 
 // ../aft-bridge/dist/command-timeouts.js
@@ -12211,7 +12376,7 @@ class BinaryBridge {
 `;
       const keepBridgeOnTimeout = options?.keepBridgeOnTimeout === true;
       let requestSentAt = Date.now();
-      const response = await new Promise((resolve, reject) => {
+      const response = await new Promise((resolve2, reject) => {
         const timer = setTimeout(() => {
           const entry = this.pending.get(id);
           if (!entry)
@@ -12246,7 +12411,7 @@ class BinaryBridge {
           entry.reject(new Error(`${this.errorPrefix} Request "${command}" (id=${id}) timed out after ${effectiveTimeoutMs}ms`));
           this.handleTimeout(requestSessionId);
         }, effectiveTimeoutMs);
-        this.pending.set(id, { resolve, reject, timer, onProgress: options?.onProgress, command });
+        this.pending.set(id, { resolve: resolve2, reject, timer, onProgress: options?.onProgress, command });
         if (!this.process?.stdin?.writable) {
           this.pending.delete(id);
           clearTimeout(timer);
@@ -12344,15 +12509,15 @@ class BinaryBridge {
     if (this.process) {
       const proc = this.process;
       this.process = null;
-      return new Promise((resolve) => {
+      return new Promise((resolve2) => {
         const forceKillTimer = setTimeout(() => {
           proc.kill("SIGKILL");
-          resolve();
+          resolve2();
         }, 5000);
         proc.once("exit", () => {
           clearTimeout(forceKillTimer);
           this.logVia("Process exited during shutdown");
-          resolve();
+          resolve2();
         });
         proc.kill("SIGTERM");
       });
@@ -12397,15 +12562,15 @@ class BinaryBridge {
       return;
     const proc = this.process;
     this.process = null;
-    await new Promise((resolve) => {
+    await new Promise((resolve2) => {
       const forceKillTimer = setTimeout(() => {
         proc.kill("SIGKILL");
-        resolve();
+        resolve2();
       }, 5000);
       proc.once("exit", () => {
         clearTimeout(forceKillTimer);
         this.logVia("Process exited during coordinated binary replacement");
-        resolve();
+        resolve2();
       });
       proc.kill("SIGTERM");
     });
@@ -12432,7 +12597,7 @@ class BinaryBridge {
     })();
     const useFastembedBackend = semanticBackend === undefined || semanticBackend === "fastembed" || semanticBackend === "";
     const ortDir = typeof this.configOverrides._ort_dylib_dir === "string" && useFastembedBackend ? this.configOverrides._ort_dylib_dir : null;
-    const ortLibraryPath = ortDir == null ? null : join(ortDir, process.platform === "win32" ? "onnxruntime.dll" : process.platform === "darwin" ? "libonnxruntime.dylib" : "libonnxruntime.so");
+    const ortLibraryPath = ortDir == null ? null : join2(ortDir, process.platform === "win32" ? "onnxruntime.dll" : process.platform === "darwin" ? "libonnxruntime.dylib" : "libonnxruntime.so");
     const envPath = process.platform === "win32" && ortDir ? `${ortDir};${process.env.PATH ?? ""}` : process.env.PATH;
     const env = {
       ...process.env,
@@ -12440,7 +12605,7 @@ class BinaryBridge {
     };
     this.logVia(`bridge.spawnProcess: useFastembedBackend=${useFastembedBackend}, ` + `parentORT=${process.env.ORT_DYLIB_PATH ?? "(unset)"}, ` + `ortLibraryPath=${ortLibraryPath ?? "(none)"}`);
     if (useFastembedBackend) {
-      env.FASTEMBED_CACHE_DIR = process.env.FASTEMBED_CACHE_DIR || (typeof this.configOverrides.storage_dir === "string" ? join(this.configOverrides.storage_dir, "semantic", "models") : join(homedir() || "", ".cache", "fastembed"));
+      env.FASTEMBED_CACHE_DIR = process.env.FASTEMBED_CACHE_DIR || (typeof this.configOverrides.storage_dir === "string" ? join2(this.configOverrides.storage_dir, "semantic", "models") : join2(homedir2() || "", ".cache", "fastembed"));
       if (process.env.ORT_DYLIB_PATH) {
         this.logVia(`ORT_DYLIB_PATH inherited from parent env: ${process.env.ORT_DYLIB_PATH}`);
       } else if (ortLibraryPath) {
@@ -12782,12 +12947,37 @@ function coerceStringArray(value) {
   }
   return [];
 }
+function coerceOptionalInt(v, paramName, min, max) {
+  if (v === undefined || v === null || v === "")
+    return;
+  if (typeof v === "number" && (!Number.isFinite(v) || v === 0 && min > 0))
+    return;
+  const n = typeof v === "string" ? Number(v) : v;
+  if (typeof n !== "number" || !Number.isInteger(n)) {
+    throw new Error(`${paramName} must be an integer between ${min} and ${max}`);
+  }
+  if (n < min || n > max) {
+    throw new Error(`${paramName} must be between ${min} and ${max}`);
+  }
+  return n;
+}
+function isEmptyParam(value) {
+  if (value === undefined || value === null)
+    return true;
+  if (typeof value === "string")
+    return value.length === 0;
+  if (Array.isArray(value))
+    return value.length === 0;
+  if (typeof value === "object")
+    return Object.keys(value).length === 0;
+  return false;
+}
 // ../aft-bridge/dist/downloader.js
 import { spawnSync } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
 import { chmodSync, closeSync, copyFileSync, createWriteStream, existsSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, statSync, unlinkSync, writeSync } from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import { join as join2 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+import { join as join3 } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 
@@ -12844,11 +13034,11 @@ function isExpectedCachedBinary(binaryPath, tag) {
 function getCacheDir() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join2(homedir2(), "AppData", "Local");
-    return join2(base2, "aft", "bin");
+    const base2 = localAppData || join3(homedir3(), "AppData", "Local");
+    return join3(base2, "aft", "bin");
   }
-  const base = process.env.XDG_CACHE_HOME || join2(homedir2(), ".cache");
-  return join2(base, "aft", "bin");
+  const base = process.env.XDG_CACHE_HOME || join3(homedir3(), ".cache");
+  return join3(base, "aft", "bin");
 }
 function getBinaryName() {
   return process.platform === "win32" ? "aft.exe" : "aft";
@@ -12856,7 +13046,7 @@ function getBinaryName() {
 function getCachedBinaryPath(version) {
   if (!version)
     return null;
-  const binaryPath = join2(getCacheDir(), version, getBinaryName());
+  const binaryPath = join3(getCacheDir(), version, getBinaryName());
   return existsSync(binaryPath) ? binaryPath : null;
 }
 async function downloadBinary(version) {
@@ -12873,16 +13063,16 @@ async function downloadBinary(version) {
     return null;
   }
   const tag = rawTag.startsWith("v") ? rawTag : `v${rawTag}`;
-  const versionedCacheDir = join2(getCacheDir(), tag);
+  const versionedCacheDir = join3(getCacheDir(), tag);
   const binaryName = getBinaryName();
-  const binaryPath = join2(versionedCacheDir, binaryName);
+  const binaryPath = join3(versionedCacheDir, binaryName);
   if (existsSync(binaryPath) && isExpectedCachedBinary(binaryPath, tag)) {
     return binaryPath;
   }
   const downloadUrl = `https://github.com/${REPO}/releases/download/${tag}/${assetName}`;
   const checksumUrl = `https://github.com/${REPO}/releases/download/${tag}/checksums.sha256`;
   log(`Downloading AFT binary (${tag}) for ${platformKey}...`);
-  const lockPath = join2(versionedCacheDir, ".download.lock");
+  const lockPath = join3(versionedCacheDir, ".download.lock");
   let releaseLock = null;
   let binaryController = null;
   let checksumController = null;
@@ -13034,7 +13224,7 @@ async function acquireDownloadLock(lockPath) {
       if (Date.now() - startedAt > DOWNLOAD_LOCK_TIMEOUT_MS) {
         throw new Error(`Timed out waiting for download lock: ${lockPath}`);
       }
-      await new Promise((resolve) => setTimeout(resolve, 100));
+      await new Promise((resolve2) => setTimeout(resolve2, 100));
     }
   }
 }
@@ -13127,18 +13317,18 @@ function stripJsoncSymbols(value) {
 // ../aft-bridge/dist/migration.js
 import { spawnSync as spawnSync2 } from "node:child_process";
 import { existsSync as existsSync4, mkdirSync as mkdirSync4 } from "node:fs";
-import { homedir as homedir4, tmpdir } from "node:os";
-import { dirname as dirname2, join as join5 } from "node:path";
+import { homedir as homedir5, tmpdir } from "node:os";
+import { dirname as dirname2, join as join6 } from "node:path";
 
 // ../aft-bridge/dist/paths.js
 import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync as renameSync2, writeFileSync } from "node:fs";
-import { dirname, join as join3 } from "node:path";
+import { dirname, join as join4 } from "node:path";
 function resolveHarnessStoragePath(storageRoot, harness, ...segments) {
-  return join3(storageRoot, harness, ...segments);
+  return join4(storageRoot, harness, ...segments);
 }
 function repairRootScopedStorageFile(storageRoot, harness, fileName) {
   const harnessPath = resolveHarnessStoragePath(storageRoot, harness, fileName);
-  const rootPath = join3(storageRoot, fileName);
+  const rootPath = join4(storageRoot, fileName);
   if (existsSync2(harnessPath) || !existsSync2(rootPath))
     return harnessPath;
   try {
@@ -13184,8 +13374,8 @@ function markAnnouncementSeen(storageRoot, harness, currentVersion) {
 import { execSync } from "node:child_process";
 import { chmodSync as chmodSync2, closeSync as closeSync2, copyFileSync as copyFileSync2, existsSync as existsSync3, mkdirSync as mkdirSync3, openSync as openSync2, readSync, renameSync as renameSync3, unlinkSync as unlinkSync2 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import { homedir as homedir3 } from "node:os";
-import { join as join4 } from "node:path";
+import { homedir as homedir4 } from "node:os";
+import { join as join5 } from "node:path";
 var ensureBinaryForResolver = ensureBinary;
 function copyToVersionedCache(npmBinaryPath, knownVersion) {
   try {
@@ -13194,9 +13384,9 @@ function copyToVersionedCache(npmBinaryPath, knownVersion) {
       return null;
     const tag = version.startsWith("v") ? version : `v${version}`;
     const cacheDir = getCacheDir();
-    const versionedDir = join4(cacheDir, tag);
+    const versionedDir = join5(cacheDir, tag);
     const ext = process.platform === "win32" ? ".exe" : "";
-    const cachedPath = join4(versionedDir, `aft${ext}`);
+    const cachedPath = join5(versionedDir, `aft${ext}`);
     if (existsSync3(cachedPath)) {
       const cachedVersion = readBinaryVersion(cachedPath);
       if (cachedVersion === version)
@@ -13226,18 +13416,18 @@ function normalizeBareVersion(version) {
   return version.startsWith("v") ? version.slice(1) : version;
 }
 function homeDirFromEnv(env) {
-  return (process.platform === "win32" ? env.USERPROFILE || env.HOME : env.HOME) || homedir3();
+  return (process.platform === "win32" ? env.USERPROFILE || env.HOME : env.HOME) || homedir4();
 }
 function cacheDirFromEnv(env) {
   if (process.platform === "win32") {
-    const base2 = env.LOCALAPPDATA || env.APPDATA || join4(homeDirFromEnv(env), "AppData", "Local");
-    return join4(base2, "aft", "bin");
+    const base2 = env.LOCALAPPDATA || env.APPDATA || join5(homeDirFromEnv(env), "AppData", "Local");
+    return join5(base2, "aft", "bin");
   }
-  const base = env.XDG_CACHE_HOME || join4(homeDirFromEnv(env), ".cache");
-  return join4(base, "aft", "bin");
+  const base = env.XDG_CACHE_HOME || join5(homeDirFromEnv(env), ".cache");
+  return join5(base, "aft", "bin");
 }
 function cachedBinaryPathFromEnv(version, env, ext) {
-  const binaryPath = join4(cacheDirFromEnv(env), version, `aft${ext}`);
+  const binaryPath = join5(cacheDirFromEnv(env), version, `aft${ext}`);
   return existsSync3(binaryPath) ? binaryPath : null;
 }
 function isExpectedCachedBinary2(binaryPath, expectedVersion) {
@@ -13356,7 +13546,7 @@ function findBinarySync(expectedVersion) {
         return usable;
     }
   } catch {}
-  const cargoPath = join4(homeDirFromEnv(env), ".cargo", "bin", `aft${ext}`);
+  const cargoPath = join5(homeDirFromEnv(env), ".cargo", "bin", `aft${ext}`);
   if (existsSync3(cargoPath)) {
     const usable = probeBinaryCandidate(cargoPath, "cargo", expectedVersion);
     if (usable)
@@ -13402,22 +13592,22 @@ function dataHome() {
   if (process.env.XDG_DATA_HOME)
     return process.env.XDG_DATA_HOME;
   if (process.platform === "win32") {
-    return process.env.LOCALAPPDATA || process.env.APPDATA || join5(homeDir(), "AppData", "Local");
+    return process.env.LOCALAPPDATA || process.env.APPDATA || join6(homeDir(), "AppData", "Local");
   }
-  return join5(homeDir(), ".local", "share");
+  return join6(homeDir(), ".local", "share");
 }
 function homeDir() {
   if (process.platform === "win32")
-    return process.env.USERPROFILE || process.env.HOME || homedir4();
-  return process.env.HOME || homedir4();
+    return process.env.USERPROFILE || process.env.HOME || homedir5();
+  return process.env.HOME || homedir5();
 }
 function resolveLegacyStorageRoot(harness) {
   if (harness === "pi")
-    return join5(homeDir(), ".pi", "agent", "aft");
-  return join5(dataHome(), "opencode", "storage", "plugin", "aft");
+    return join6(homeDir(), ".pi", "agent", "aft");
+  return join6(dataHome(), "opencode", "storage", "plugin", "aft");
 }
 function resolveCortexKitStorageRoot() {
-  return join5(dataHome(), "cortexkit", "aft");
+  return join6(dataHome(), "cortexkit", "aft");
 }
 function tail(value) {
   if (!value)
@@ -13431,12 +13621,12 @@ function spawnErrorLabel(error2) {
   return [code, error2.message].filter(Boolean).join(": ");
 }
 function migrationLogPath(newRoot, harness, logger) {
-  const desired = join5(newRoot, "logs", "migration", `${harness}-${Date.now()}.jsonl`);
+  const desired = join6(newRoot, "logs", "migration", `${harness}-${Date.now()}.jsonl`);
   try {
     mkdirSync4(dirname2(desired), { recursive: true });
     return desired;
   } catch (err) {
-    const fallback = join5(tmpdir(), `aft-migration-${harness}-${Date.now()}.jsonl`);
+    const fallback = join6(tmpdir(), `aft-migration-${harness}-${Date.now()}.jsonl`);
     logger?.warn?.(`Failed to create AFT migration log directory ${dirname2(desired)}: ${err instanceof Error ? err.message : String(err)}. ` + `Using fallback log path ${fallback}.`);
     return fallback;
   }
@@ -13499,13 +13689,13 @@ async function ensureStorageMigrated(opts) {
 }
 // ../aft-bridge/dist/npm-resolver.js
 import { readdirSync, statSync as statSync2 } from "node:fs";
-import { homedir as homedir5 } from "node:os";
-import { delimiter, dirname as dirname3, isAbsolute, join as join6 } from "node:path";
+import { homedir as homedir6 } from "node:os";
+import { delimiter, dirname as dirname3, isAbsolute as isAbsolute2, join as join7 } from "node:path";
 function defaultDeps() {
   return {
     platform: process.platform,
     env: process.env,
-    home: homedir5(),
+    home: homedir6(),
     execPath: process.execPath
   };
 }
@@ -13524,16 +13714,16 @@ function npmFromPath(deps) {
   const raw = deps.env.PATH ?? deps.env.Path ?? "";
   for (const entry of raw.split(delimiter)) {
     const dir = entry.trim().replace(/^"|"$/g, "");
-    if (!dir || !isAbsolute(dir))
+    if (!dir || !isAbsolute2(dir))
       continue;
-    if (isFile(join6(dir, name)))
+    if (isFile(join7(dir, name)))
       return dir;
   }
   return null;
 }
 function npmAdjacentToNode(deps) {
   const dir = dirname3(deps.execPath);
-  return isFile(join6(dir, npmBinaryName(deps.platform))) ? dir : null;
+  return isFile(join7(dir, npmBinaryName(deps.platform))) ? dir : null;
 }
 function highestVersionedNodeBin(installsDir, name) {
   let entries;
@@ -13542,8 +13732,8 @@ function highestVersionedNodeBin(installsDir, name) {
   } catch {
     return null;
   }
-  const candidates = entries.filter((v) => isFile(join6(installsDir, v, "bin", name))).sort((a, b) => compareVersionsDesc(a, b));
-  return candidates.length > 0 ? join6(installsDir, candidates[0], "bin") : null;
+  const candidates = entries.filter((v) => isFile(join7(installsDir, v, "bin", name))).sort((a, b) => compareVersionsDesc(a, b));
+  return candidates.length > 0 ? join7(installsDir, candidates[0], "bin") : null;
 }
 function compareVersionsDesc(a, b) {
   const pa = a.replace(/^v/, "").split(".").map((n) => Number.parseInt(n, 10));
@@ -13568,22 +13758,22 @@ function wellKnownNpmDirs(deps) {
     const programFiles = env.ProgramFiles || "C:\\Program Files";
     const appData = env.APPDATA;
     const localAppData = env.LOCALAPPDATA;
-    push(join6(programFiles, "nodejs"));
+    push(join7(programFiles, "nodejs"));
     if (appData)
-      push(join6(appData, "npm"));
+      push(join7(appData, "npm"));
     if (localAppData)
-      push(join6(localAppData, "Volta", "bin"));
+      push(join7(localAppData, "Volta", "bin"));
     if (env.NVM_SYMLINK)
       push(env.NVM_SYMLINK);
   } else {
     if (env.NVM_BIN)
       push(env.NVM_BIN);
-    push(highestVersionedNodeBin(join6(home, ".nvm", "versions", "node"), name));
-    push(highestVersionedNodeBin(join6(home, ".local", "share", "mise", "installs", "node"), name));
-    push(highestVersionedNodeBin(join6(home, ".asdf", "installs", "nodejs"), name));
-    push(join6(home, ".volta", "bin"));
-    push(join6(home, ".asdf", "shims"));
-    const systemDirs = deps.systemNpmDirs ?? (platform === "darwin" ? ["/opt/homebrew/bin", "/usr/local/bin"] : ["/usr/local/bin", "/usr/bin", join6(home, ".local", "bin")]);
+    push(highestVersionedNodeBin(join7(home, ".nvm", "versions", "node"), name));
+    push(highestVersionedNodeBin(join7(home, ".local", "share", "mise", "installs", "node"), name));
+    push(highestVersionedNodeBin(join7(home, ".asdf", "installs", "nodejs"), name));
+    push(join7(home, ".volta", "bin"));
+    push(join7(home, ".asdf", "shims"));
+    const systemDirs = deps.systemNpmDirs ?? (platform === "darwin" ? ["/opt/homebrew/bin", "/usr/local/bin"] : ["/usr/local/bin", "/usr/bin", join7(home, ".local", "bin")]);
     for (const dir of systemDirs)
       push(dir);
   }
@@ -13593,12 +13783,12 @@ function resolveNpm(deps = defaultDeps()) {
   const name = npmBinaryName(deps.platform);
   const onPath = npmFromPath(deps);
   if (onPath)
-    return { command: join6(onPath, name), binDir: onPath };
+    return { command: join7(onPath, name), binDir: onPath };
   const adjacent = npmAdjacentToNode(deps);
   if (adjacent)
-    return { command: join6(adjacent, name), binDir: adjacent };
+    return { command: join7(adjacent, name), binDir: adjacent };
   for (const dir of wellKnownNpmDirs(deps)) {
-    const candidate = join6(dir, name);
+    const candidate = join7(dir, name);
     if (isFile(candidate))
       return { command: candidate, binDir: dir };
   }
@@ -13615,7 +13805,7 @@ function npmSpawnEnv(resolved, baseEnv = process.env) {
 import { execFileSync } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
 import { chmodSync as chmodSync3, closeSync as closeSync3, copyFileSync as copyFileSync3, createWriteStream as createWriteStream2, existsSync as existsSync5, lstatSync, mkdirSync as mkdirSync5, openSync as openSync3, readdirSync as readdirSync2, readFileSync as readFileSync3, readlinkSync, realpathSync, rmSync as rmSync2, statSync as statSync3, symlinkSync, unlinkSync as unlinkSync3, writeFileSync as writeFileSync2 } from "node:fs";
-import { basename, dirname as dirname4, isAbsolute as isAbsolute2, join as join7, relative, resolve, win32 } from "node:path";
+import { basename, dirname as dirname4, isAbsolute as isAbsolute3, join as join8, relative as relative2, resolve as resolve2, win32 } from "node:path";
 import { Readable as Readable2 } from "node:stream";
 import { pipeline as pipeline2 } from "node:stream/promises";
 var ORT_VERSION = "1.24.4";
@@ -13678,10 +13868,10 @@ function getManualInstallHint() {
 }
 async function ensureOnnxRuntime(storageDir) {
   const info = getPlatformInfo();
-  const ortVersionDir = join7(storageDir, "onnxruntime", ORT_VERSION);
+  const ortVersionDir = join8(storageDir, "onnxruntime", ORT_VERSION);
   const libName = info?.libName ?? "libonnxruntime.dylib";
   const resolvedOrtDir = resolveCachedOnnxRuntimeDir(ortVersionDir, libName);
-  const libPath = join7(resolvedOrtDir, libName);
+  const libPath = join8(resolvedOrtDir, libName);
   if (existsSync5(libPath)) {
     const meta = readOnnxInstalledMeta(ortVersionDir);
     if (meta?.sha256) {
@@ -13711,9 +13901,9 @@ async function ensureOnnxRuntime(storageDir) {
     warn(`ONNX Runtime auto-download not available for ${process.platform}/${process.arch}. Install manually: ${getManualInstallHint()}`);
     return null;
   }
-  const onnxBaseDir = join7(storageDir, "onnxruntime");
+  const onnxBaseDir = join8(storageDir, "onnxruntime");
   mkdirSync5(onnxBaseDir, { recursive: true });
-  const lockPath = join7(onnxBaseDir, ONNX_LOCK_FILE);
+  const lockPath = join8(onnxBaseDir, ONNX_LOCK_FILE);
   cleanupAbandonedStagingDirs(onnxBaseDir);
   if (!acquireLock(lockPath)) {
     warn(`ONNX Runtime install already in progress in another process (lock: ${lockPath}). Skipping.`);
@@ -13732,7 +13922,7 @@ function cleanupAbandonedStagingDirs(onnxBaseDir) {
     for (const entry of entries) {
       if (!entry.startsWith(`${ORT_VERSION}.tmp.`))
         continue;
-      const stagingDir = join7(onnxBaseDir, entry);
+      const stagingDir = join8(onnxBaseDir, entry);
       const parts = entry.split(".");
       const pidStr = parts[parts.length - 2];
       const pid = pidStr ? Number.parseInt(pidStr, 10) : NaN;
@@ -13769,7 +13959,7 @@ function cleanupAbandonedStagingDirs(onnxBaseDir) {
 }
 function cleanupIncompleteTargetIfUnowned(ortDir) {
   try {
-    if (existsSync5(ortDir) && !existsSync5(join7(ortDir, ONNX_INSTALLED_META_FILE))) {
+    if (existsSync5(ortDir) && !existsSync5(join8(ortDir, ONNX_INSTALLED_META_FILE))) {
       log(`[onnx] removing half-populated install dir ${ortDir} (no meta file)`);
       rmSync2(ortDir, { recursive: true, force: true });
     }
@@ -13797,8 +13987,8 @@ function parseOnnxVersionFromDirectoryPath(value) {
   return null;
 }
 function isPathInsideRoot(root, candidate) {
-  const rel = relative(root, candidate);
-  return rel === "" || !rel.startsWith("../") && !rel.startsWith("..\\") && rel !== ".." && !isAbsolute2(rel) && !win32.isAbsolute(rel);
+  const rel = relative2(root, candidate);
+  return rel === "" || !rel.startsWith("../") && !rel.startsWith("..\\") && rel !== ".." && !isAbsolute3(rel) && !win32.isAbsolute(rel);
 }
 function detectOnnxVersion(libDir, libName) {
   try {
@@ -13813,7 +14003,7 @@ function detectOnnxVersion(libDir, libName) {
       if (version)
         return version;
     }
-    const base = join7(libDir, libName);
+    const base = join8(libDir, libName);
     if (existsSync5(base)) {
       try {
         const real = realpathSync(base);
@@ -13849,7 +14039,7 @@ function pathEntriesForPlatform() {
   return pathEnvValue().split(delimiter2).map((entry) => entry.trim().replace(/^"|"$/g, "")).filter((entry) => {
     if (!entry || entry === "." || entry.includes("\x00"))
       return false;
-    return isAbsolute2(entry) || win32.isAbsolute(entry);
+    return isAbsolute3(entry) || win32.isAbsolute(entry);
   });
 }
 function directoryContainsLibrary(dir, libName) {
@@ -13865,10 +14055,10 @@ function directoryContainsLibrary(dir, libName) {
   }
 }
 function resolveCachedOnnxRuntimeDir(ortVersionDir, libName) {
-  if (existsSync5(join7(ortVersionDir, libName)))
+  if (existsSync5(join8(ortVersionDir, libName)))
     return ortVersionDir;
-  const libSubdir = join7(ortVersionDir, "lib");
-  if (existsSync5(join7(libSubdir, libName)))
+  const libSubdir = join8(ortVersionDir, "lib");
+  if (existsSync5(join8(libSubdir, libName)))
     return libSubdir;
   return ortVersionDir;
 }
@@ -13883,12 +14073,12 @@ 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(join7(programFiles, "onnxruntime", "lib"), join7(programFiles, "Microsoft ONNX Runtime", "lib"), join7(programFiles, "Microsoft Machine Learning", "lib"), join7(programFilesX86, "onnxruntime", "lib"), ...(() => {
+    searchPaths.push(join8(programFiles, "onnxruntime", "lib"), join8(programFiles, "Microsoft ONNX Runtime", "lib"), join8(programFiles, "Microsoft Machine Learning", "lib"), join8(programFilesX86, "onnxruntime", "lib"), ...(() => {
       const nugetPaths = [];
       const userProfile = process.env.USERPROFILE ?? "";
       if (!userProfile)
         return nugetPaths;
-      const nugetPackageDir = join7(userProfile, ".nuget", "packages", "microsoft.ml.onnxruntime");
+      const nugetPackageDir = join8(userProfile, ".nuget", "packages", "microsoft.ml.onnxruntime");
       if (!existsSync5(nugetPackageDir))
         return nugetPaths;
       try {
@@ -13897,7 +14087,7 @@ function findSystemOnnxRuntime(libName) {
             continue;
           if (entry.name === "__globalPackagesFolder" || entry.name.startsWith("."))
             continue;
-          nugetPaths.push(join7(nugetPackageDir, entry.name, "runtimes", "win-x64", "native"), join7(nugetPackageDir, entry.name, "runtimes", "win-arm64", "native"));
+          nugetPaths.push(join8(nugetPackageDir, entry.name, "runtimes", "win-x64", "native"), join8(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)}`);
@@ -13909,7 +14099,7 @@ function findSystemOnnxRuntime(libName) {
   const normalizeCase = process.platform === "win32" || process.platform === "darwin";
   const seen = new Set;
   const uniquePaths = searchPaths.filter((p) => {
-    let key = resolve(p).replace(/[/\\]+$/, "");
+    let key = resolve2(p).replace(/[/\\]+$/, "");
     if (normalizeCase)
       key = key.toLowerCase();
     if (seen.has(key))
@@ -13919,7 +14109,7 @@ function findSystemOnnxRuntime(libName) {
   });
   const unknownVersionPaths = [];
   for (const dir of uniquePaths) {
-    const libPath = join7(dir, libName);
+    const libPath = join8(dir, libName);
     if (process.platform === "win32") {
       if (!directoryContainsLibrary(dir, libName))
         continue;
@@ -13985,19 +14175,19 @@ function validateExtractedTree(stagingRoot) {
   const walk = (dir) => {
     const entries = readdirSync2(dir);
     for (const entry of entries) {
-      const fullPath = join7(dir, entry);
+      const fullPath = join8(dir, entry);
       const lst = lstatSync(fullPath);
       if (lst.isSymbolicLink()) {
         const linkTarget = readlinkSync(fullPath);
-        const resolvedTarget = resolve(dirname4(fullPath), linkTarget);
-        const rel2 = relative(realRoot, resolvedTarget);
-        if (rel2.startsWith("..") || isAbsolute2(rel2) || win32.isAbsolute(rel2)) {
+        const resolvedTarget = resolve2(dirname4(fullPath), linkTarget);
+        const rel2 = relative2(realRoot, resolvedTarget);
+        if (rel2.startsWith("..") || isAbsolute3(rel2) || win32.isAbsolute(rel2)) {
           throw new Error(`extracted symlink ${fullPath} points outside staging root: ${linkTarget}`);
         }
         continue;
       }
-      const rel = relative(realRoot, fullPath);
-      if (rel.startsWith("..") || isAbsolute2(rel) || win32.isAbsolute(rel)) {
+      const rel = relative2(realRoot, fullPath);
+      if (rel.startsWith("..") || isAbsolute3(rel) || win32.isAbsolute(rel)) {
         throw new Error(`extracted entry ${fullPath} escapes staging root`);
       }
       if (lst.isDirectory()) {
@@ -14020,7 +14210,7 @@ async function downloadOnnxRuntime(info, targetDir) {
   const tmpDir = `${targetDir}.tmp.${process.pid}.${Date.now().toString(36)}`;
   try {
     mkdirSync5(tmpDir, { recursive: true });
-    const archivePath = join7(tmpDir, `onnxruntime.${info.archiveType}`);
+    const archivePath = join8(tmpDir, `onnxruntime.${info.archiveType}`);
     await downloadFileWithCap(url, archivePath);
     const archiveSha256 = sha256File(archivePath);
     log(`ONNX Runtime archive sha256=${archiveSha256}`);
@@ -14036,7 +14226,7 @@ async function downloadOnnxRuntime(info, targetDir) {
       unlinkSync3(archivePath);
     } catch {}
     validateExtractedTree(tmpDir);
-    const extractedDir = join7(tmpDir, info.assetName, "lib");
+    const extractedDir = join8(tmpDir, info.assetName, "lib");
     if (!existsSync5(extractedDir)) {
       throw new Error(`Expected directory not found: ${extractedDir}`);
     }
@@ -14045,7 +14235,7 @@ async function downloadOnnxRuntime(info, targetDir) {
     const realFiles = [];
     const symlinks = [];
     for (const libFile of libFiles) {
-      const src = join7(extractedDir, libFile);
+      const src = join8(extractedDir, libFile);
       try {
         const stat = lstatSync(src);
         log(`ORT extract: ${libFile} — isSymlink=${stat.isSymbolicLink()}, isFile=${stat.isFile()}, size=${stat.size}`);
@@ -14060,7 +14250,7 @@ async function downloadOnnxRuntime(info, targetDir) {
       }
     }
     copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks);
-    const libPath = join7(targetDir, info.libName);
+    const libPath = join8(targetDir, info.libName);
     let libHash = null;
     try {
       libHash = sha256File(libPath);
@@ -14085,8 +14275,8 @@ async function downloadOnnxRuntime(info, targetDir) {
 function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, copyFile = copyFileSync3) {
   const requiredLibs = new Set([info.libName]);
   for (const libFile of realFiles) {
-    const src = join7(extractedDir, libFile);
-    const dst = join7(targetDir, libFile);
+    const src = join8(extractedDir, libFile);
+    const dst = join8(targetDir, libFile);
     try {
       copyFile(src, dst);
       if (process.platform !== "win32") {
@@ -14102,12 +14292,12 @@ function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, c
   }
   const targetRoot = realpathSync(targetDir);
   for (const link of symlinks) {
-    const dst = join7(targetDir, link.name);
+    const dst = join8(targetDir, link.name);
     try {
       unlinkSync3(dst);
     } catch {}
-    const dstForContainment = join7(targetRoot, link.name);
-    const resolvedTarget = resolve(dirname4(dstForContainment), link.target);
+    const dstForContainment = join8(targetRoot, link.name);
+    const resolvedTarget = resolve2(dirname4(dstForContainment), link.target);
     if (!isPathInsideRoot(targetRoot, resolvedTarget)) {
       const message = `ONNX Runtime symlink ${link.name} points outside install dir: ${link.target}`;
       if (requiredLibs.has(link.name)) {
@@ -14127,7 +14317,7 @@ function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, c
       log(`ORT extract: failed to symlink optional ${link.name}: ${symlinkErr}`);
     }
   }
-  const requiredPath = join7(targetDir, info.libName);
+  const requiredPath = join8(targetDir, info.libName);
   if (!existsSync5(requiredPath)) {
     rmSync2(targetDir, { recursive: true, force: true });
     throw new Error(`Required ONNX Runtime library missing after install: ${requiredPath}`);
@@ -14154,17 +14344,17 @@ function writeOnnxInstalledMeta(installDir, version, sha256, archiveSha256) {
       ...sha256 ? { sha256 } : {},
       archiveSha256
     };
-    writeFileSync2(join7(installDir, ONNX_INSTALLED_META_FILE), JSON.stringify(meta), "utf8");
+    writeFileSync2(join8(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 = join7(installDir, ONNX_INSTALLED_META_FILE);
+  const path2 = join8(installDir, ONNX_INSTALLED_META_FILE);
   try {
-    if (!statSync3(path).isFile())
+    if (!statSync3(path2).isFile())
       return null;
-    const raw = readFileSync3(path, "utf8");
+    const raw = readFileSync3(path2, "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.version !== "string" || parsed.version.length === 0)
       return null;
@@ -14178,9 +14368,9 @@ function readOnnxInstalledMeta(installDir) {
     return null;
   }
 }
-function sha256File(path) {
+function sha256File(path2) {
   const hash = createHash2("sha256");
-  hash.update(readFileSync3(path));
+  hash.update(readFileSync3(path2));
   return hash.digest("hex");
 }
 function acquireLock(lockPath) {
@@ -14840,13 +15030,13 @@ function tokenizeStage(stage) {
 }
 // ../aft-bridge/dist/pool.js
 import { realpathSync as realpathSync2 } from "node:fs";
-import { homedir as homedir6 } from "node:os";
+import { homedir as homedir7 } from "node:os";
 var DEFAULT_IDLE_TIMEOUT_MS = 30 * 60 * 1000;
 var DEFAULT_MAX_POOL_SIZE = 8;
 var CLEANUP_INTERVAL_MS = 60 * 1000;
 function canonicalHomeDir() {
   try {
-    const home = homedir6();
+    const home = homedir7();
     if (!home)
       return null;
     try {
@@ -15038,6 +15228,91 @@ function normalizeKey(projectRoot) {
     return stripped;
   }
 }
+// ../aft-bridge/dist/tool-format.js
+function asPlainObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return;
+  return value;
+}
+function candidateLocation(candidate) {
+  const file = typeof candidate.file === "string" && candidate.file.length > 0 ? candidate.file : undefined;
+  if (!file)
+    return;
+  const line = typeof candidate.line === "number" && Number.isFinite(candidate.line) ? candidate.line : undefined;
+  return line === undefined ? file : `${file}:${line}`;
+}
+function stringifyData(data) {
+  if (data === undefined)
+    return;
+  try {
+    return JSON.stringify(data, null, 2);
+  } catch {
+    return String(data);
+  }
+}
+function formatBridgeErrorMessage(command, response, params = {}) {
+  const code = typeof response.code === "string" && response.code.length > 0 ? response.code : undefined;
+  const message = typeof response.message === "string" && response.message.length > 0 ? response.message : `${command} failed`;
+  const data = asPlainObject(response.data);
+  const rawCandidates = Array.isArray(response.candidates) ? response.candidates : Array.isArray(data?.candidates) ? data.candidates : undefined;
+  const rawSymbol = typeof response.symbol === "string" && response.symbol.length > 0 ? response.symbol : typeof data?.symbol === "string" && data.symbol.length > 0 ? data.symbol : undefined;
+  if (code === "ambiguous_target" || code === "target_symbol_not_in_file") {
+    const candidates = (rawCandidates ?? []).map(asPlainObject).filter((candidate) => candidate !== undefined).map(candidateLocation).filter((candidate) => candidate !== undefined);
+    if (candidates.length > 0) {
+      const symbol = typeof params.toSymbol === "string" && params.toSymbol.length > 0 ? params.toSymbol : rawSymbol;
+      const target = symbol ? `multiple symbols named "${symbol}"` : message.replace(/[.!?]+$/, "");
+      const action = code === "ambiguous_target" ? "Pass toFile to disambiguate" : "Try one of these files for toFile";
+      return `${command}: ${code} — ${target}. ${action}:
+${candidates.map((candidate) => `  - ${candidate}`).join(`
+`)}`;
+    }
+  }
+  if (!code)
+    return message;
+  const lines = [`${command}: ${code} — ${message}`];
+  const extras = collectStructuredExtras(response);
+  if (extras)
+    lines.push(`data: ${extras}`);
+  return lines.join(`
+`);
+}
+function collectStructuredExtras(response) {
+  const reserved = new Set([
+    "id",
+    "success",
+    "code",
+    "message",
+    "data",
+    "status_bar",
+    "bg_completions"
+  ]);
+  const extras = {};
+  for (const [key, value] of Object.entries(response)) {
+    if (reserved.has(key))
+      continue;
+    extras[key] = value;
+  }
+  if (Object.keys(extras).length === 0) {
+    return stringifyData(response.data);
+  }
+  if (response.data !== undefined)
+    extras.data = response.data;
+  return stringifyData(extras);
+}
+function formatReadFooter(agentSpecifiedRange, data, options) {
+  if (agentSpecifiedRange)
+    return "";
+  if (!data.truncated)
+    return "";
+  const startLine = data.start_line;
+  const endLine = data.end_line;
+  const totalLines = data.total_lines;
+  if (startLine === undefined || endLine === undefined || totalLines === undefined) {
+    return "";
+  }
+  return `
+(Showing lines ${startLine}-${endLine} of ${totalLines}. Use ${options.rangeHint} to read other sections.)`;
+}
 // ../aft-bridge/dist/zoom-format.js
 function formatZoomText(targetLabel, response) {
   const range = response.range;
@@ -15118,13 +15393,36 @@ function formatZoomMultiTargetResult(entries) {
 
 `) };
 }
+function isRustZoomBatchEnvelope(response) {
+  if (!Array.isArray(response.symbols) || response.symbols.length === 0) {
+    return false;
+  }
+  return response.symbols.every((entry) => {
+    if (!entry || typeof entry !== "object")
+      return false;
+    const row = entry;
+    return typeof row.name === "string" && row.response !== undefined && row.response !== null;
+  });
+}
+function unwrapRustZoomBatchEnvelope(response) {
+  if (!isRustZoomBatchEnvelope(response)) {
+    return null;
+  }
+  const names = [];
+  const responses = [];
+  for (const entry of response.symbols) {
+    names.push(entry.name);
+    responses.push(entry.response);
+  }
+  return { names, responses };
+}
 // src/logger.ts
 import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
+import * as os2 from "node:os";
+import * as path2 from "node:path";
 var TAG = "[aft-pi]";
 var isTestEnv = process.env.BUN_TEST === "1" || false;
-var logFile = path.join(os.tmpdir(), isTestEnv ? "aft-pi-test.log" : "aft-pi.log");
+var logFile = path2.join(os2.tmpdir(), isTestEnv ? "aft-pi-test.log" : "aft-pi.log");
 var useStderr = process.env.AFT_LOG_STDERR === "1";
 var buffer = [];
 var flushTimer = null;
@@ -15760,7 +16058,7 @@ import {
 // package.json
 var package_default = {
   name: "@cortexkit/aft-pi",
-  version: "0.38.0",
+  version: "0.39.1",
   type: "module",
   description: "Pi coding agent extension for Agent File Tools (AFT) — tree-sitter and LSP-powered code analysis",
   main: "dist/index.js",
@@ -15783,7 +16081,7 @@ var package_default = {
     "test:unit": "bun test src/__tests__ --path-ignore-patterns 'src/__tests__/e2e/**'"
   },
   dependencies: {
-    "@cortexkit/aft-bridge": "0.38.0",
+    "@cortexkit/aft-bridge": "0.39.1",
     "@xterm/headless": "^5.5.0",
     "comment-json": "^5.0.0",
     diff: "^8.0.4",
@@ -15791,12 +16089,12 @@ var package_default = {
     zod: "^4.1.8"
   },
   optionalDependencies: {
-    "@cortexkit/aft-darwin-arm64": "0.38.0",
-    "@cortexkit/aft-darwin-x64": "0.38.0",
-    "@cortexkit/aft-linux-arm64": "0.38.0",
-    "@cortexkit/aft-linux-x64": "0.38.0",
-    "@cortexkit/aft-win32-arm64": "0.38.0",
-    "@cortexkit/aft-win32-x64": "0.38.0"
+    "@cortexkit/aft-darwin-arm64": "0.39.1",
+    "@cortexkit/aft-darwin-x64": "0.39.1",
+    "@cortexkit/aft-linux-arm64": "0.39.1",
+    "@cortexkit/aft-linux-x64": "0.39.1",
+    "@cortexkit/aft-win32-arm64": "0.39.1",
+    "@cortexkit/aft-win32-x64": "0.39.1"
   },
   devDependencies: {
     "@earendil-works/pi-coding-agent": "*",
@@ -16029,101 +16327,6 @@ function formatStatusDialogMessage(status) {
 // src/tools/_shared.ts
 import { Type } from "typebox";
 var optionalInt = (_min, _max) => Type.Optional(Type.Any({ description: "(integer)" }));
-function coerceOptionalInt(v, paramName, min, max) {
-  if (v === undefined || v === null || v === "")
-    return;
-  if (typeof v === "number" && (!Number.isFinite(v) || v === 0 && min > 0))
-    return;
-  const n = typeof v === "string" ? Number(v) : v;
-  if (typeof n !== "number" || !Number.isInteger(n)) {
-    throw new Error(`${paramName} must be an integer between ${min} and ${max}`);
-  }
-  if (n < min || n > max) {
-    throw new Error(`${paramName} must be between ${min} and ${max}`);
-  }
-  return n;
-}
-function isEmptyParam(value) {
-  if (value === undefined || value === null)
-    return true;
-  if (typeof value === "string")
-    return value.length === 0;
-  if (Array.isArray(value))
-    return value.length === 0;
-  if (typeof value === "object")
-    return Object.keys(value).length === 0;
-  return false;
-}
-function asPlainObject(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    return;
-  return value;
-}
-function candidateLocation(candidate) {
-  const file = typeof candidate.file === "string" && candidate.file.length > 0 ? candidate.file : undefined;
-  if (!file)
-    return;
-  const line = typeof candidate.line === "number" && Number.isFinite(candidate.line) ? candidate.line : undefined;
-  return line === undefined ? file : `${file}:${line}`;
-}
-function stringifyData(data) {
-  if (data === undefined)
-    return;
-  try {
-    return JSON.stringify(data, null, 2);
-  } catch {
-    return String(data);
-  }
-}
-function formatBridgeErrorMessage(command, response, params = {}) {
-  const code = typeof response.code === "string" && response.code.length > 0 ? response.code : undefined;
-  const message = typeof response.message === "string" && response.message.length > 0 ? response.message : `${command} failed`;
-  const data = asPlainObject(response.data);
-  const rawCandidates = Array.isArray(response.candidates) ? response.candidates : Array.isArray(data?.candidates) ? data.candidates : undefined;
-  const rawSymbol = typeof response.symbol === "string" && response.symbol.length > 0 ? response.symbol : typeof data?.symbol === "string" && data.symbol.length > 0 ? data.symbol : undefined;
-  if (code === "ambiguous_target" || code === "target_symbol_not_in_file") {
-    const candidates = (rawCandidates ?? []).map(asPlainObject).filter((candidate) => candidate !== undefined).map(candidateLocation).filter((candidate) => candidate !== undefined);
-    if (candidates.length > 0) {
-      const symbol = typeof params.toSymbol === "string" && params.toSymbol.length > 0 ? params.toSymbol : rawSymbol;
-      const target = symbol ? `multiple symbols named "${symbol}"` : message.replace(/[.!?]+$/, "");
-      const action = code === "ambiguous_target" ? "Pass toFile to disambiguate" : "Try one of these files for toFile";
-      return `${command}: ${code} — ${target}. ${action}:
-${candidates.map((candidate) => `  - ${candidate}`).join(`
-`)}`;
-    }
-  }
-  if (!code)
-    return message;
-  const lines = [`${command}: ${code} — ${message}`];
-  const extras = collectStructuredExtras(response);
-  if (extras)
-    lines.push(`data: ${extras}`);
-  return lines.join(`
-`);
-}
-function collectStructuredExtras(response) {
-  const reserved = new Set([
-    "id",
-    "success",
-    "code",
-    "message",
-    "data",
-    "status_bar",
-    "bg_completions"
-  ]);
-  const extras = {};
-  for (const [key, value] of Object.entries(response)) {
-    if (reserved.has(key))
-      continue;
-    extras[key] = value;
-  }
-  if (Object.keys(extras).length === 0) {
-    return stringifyData(response.data);
-  }
-  if (response.data !== undefined)
-    extras.data = response.data;
-  return stringifyData(extras);
-}
 function bridgeFor(ctx, cwd) {
   return ctx.pool.getBridge(cwd);
 }
@@ -16466,8 +16669,8 @@ function registerStatusCommand(pi, ctx) {
 
 // src/config.ts
 import { existsSync as existsSync6, readFileSync as readFileSync4, renameSync as renameSync4, unlinkSync as unlinkSync4, writeFileSync as writeFileSync3 } from "node:fs";
-import { homedir as homedir7 } from "node:os";
-import { join as join9 } from "node:path";
+import { homedir as homedir8 } from "node:os";
+import { join as join10 } from "node:path";
 var import_comment_json = __toESM(require_src2(), 1);
 
 // ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/external.js
@@ -17235,10 +17438,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path2) {
-  if (!path2)
+function getElementAtPath(obj, path3) {
+  if (!path3)
     return obj;
-  return path2.reduce((acc, key) => acc?.[key], obj);
+  return path3.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -17619,11 +17822,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path2, issues) {
+function prefixIssues(path3, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path2);
+    iss.path.unshift(path3);
     return iss;
   });
 }
@@ -17806,7 +18009,7 @@ function formatError(error3, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error3, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error4, path2 = []) => {
+  const processError = (error4, path3 = []) => {
     var _a, _b;
     for (const issue2 of error4.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -17816,7 +18019,7 @@ function treeifyError(error3, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path2, ...issue2.path];
+        const fullpath = [...path3, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -17848,8 +18051,8 @@ function treeifyError(error3, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path2 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path2) {
+  const path3 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path3) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -29596,13 +29799,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path2 = ref.slice(1).split("/").filter(Boolean);
-  if (path2.length === 0) {
+  const path3 = ref.slice(1).split("/").filter(Boolean);
+  if (path3.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path2[0] === defsKey) {
-    const key = path2[1];
+  if (path3[0] === defsKey) {
+    const key = path3[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -30259,9 +30462,9 @@ function extractCommentsForPreservation(content) {
   }
   return comments;
 }
-function ensureRecordAtPath(root, path2) {
+function ensureRecordAtPath(root, path3) {
   let current = root;
-  for (const segment of path2) {
+  for (const segment of path3) {
     const existing = current[segment];
     if (!existing || typeof existing !== "object" || Array.isArray(existing)) {
       current[segment] = {};
@@ -30270,9 +30473,9 @@ function ensureRecordAtPath(root, path2) {
   }
   return current;
 }
-function hasPath(root, path2) {
+function hasPath(root, path3) {
   let current = root;
-  for (const segment of path2) {
+  for (const segment of path3) {
     if (!current || typeof current !== "object" || Array.isArray(current))
       return false;
     const record2 = current;
@@ -30282,9 +30485,9 @@ function hasPath(root, path2) {
   }
   return true;
 }
-function setPath(root, path2, value) {
-  const parent = ensureRecordAtPath(root, path2.slice(0, -1));
-  parent[path2[path2.length - 1]] = value;
+function setPath(root, path3, value) {
+  const parent = ensureRecordAtPath(root, path3.slice(0, -1));
+  parent[path3[path3.length - 1]] = value;
 }
 function migrateRawConfig(rawConfig, configPath, logger) {
   const oldKeys = [];
@@ -30601,15 +30804,15 @@ function mergeConfigs(base, override) {
   };
 }
 function getGlobalPiDir() {
-  return join9(homedir7(), ".pi", "agent");
+  return join10(homedir8(), ".pi", "agent");
 }
 function loadAftConfig(projectDirectory) {
-  const userBasePath = join9(getGlobalPiDir(), "aft");
+  const userBasePath = join10(getGlobalPiDir(), "aft");
   migrateAftConfigFile(`${userBasePath}.jsonc`);
   migrateAftConfigFile(`${userBasePath}.json`);
   const userDetected = detectConfigFile(userBasePath);
   const userConfigPath = userDetected.format !== "none" ? userDetected.path : `${userBasePath}.json`;
-  const projectBasePath = join9(projectDirectory, ".pi", "aft");
+  const projectBasePath = join10(projectDirectory, ".pi", "aft");
   migrateAftConfigFile(`${projectBasePath}.jsonc`);
   migrateAftConfigFile(`${projectBasePath}.json`);
   const projectDetected = detectConfigFile(projectBasePath);
@@ -30646,7 +30849,7 @@ import {
   statSync as statSync5,
   writeFileSync as writeFileSync5
 } from "node:fs";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 
 // src/lsp-cache.ts
 import {
@@ -30658,36 +30861,36 @@ import {
   unlinkSync as unlinkSync5,
   writeFileSync as writeFileSync4
 } from "node:fs";
-import { homedir as homedir8 } from "node:os";
-import { join as join10 } from "node:path";
+import { homedir as homedir9 } from "node:os";
+import { join as join11 } from "node:path";
 function aftCacheBase() {
   const override = process.env.AFT_CACHE_DIR;
   if (override && override.length > 0)
     return override;
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join10(homedir8(), "AppData", "Local");
-    return join10(base2, "aft");
+    const base2 = localAppData || join11(homedir9(), "AppData", "Local");
+    return join11(base2, "aft");
   }
-  const base = process.env.XDG_CACHE_HOME || join10(homedir8(), ".cache");
-  return join10(base, "aft");
+  const base = process.env.XDG_CACHE_HOME || join11(homedir9(), ".cache");
+  return join11(base, "aft");
 }
 function lspCacheRoot() {
-  return join10(aftCacheBase(), "lsp-packages");
+  return join11(aftCacheBase(), "lsp-packages");
 }
 function lspPackageDir(npmPackage) {
-  return join10(lspCacheRoot(), encodeURIComponent(npmPackage));
+  return join11(lspCacheRoot(), encodeURIComponent(npmPackage));
 }
 function lspBinaryPath(npmPackage, binary) {
-  return join10(lspPackageDir(npmPackage), "node_modules", ".bin", binary);
+  return join11(lspPackageDir(npmPackage), "node_modules", ".bin", binary);
 }
 function lspBinDir(npmPackage) {
-  return join10(lspPackageDir(npmPackage), "node_modules", ".bin");
+  return join11(lspPackageDir(npmPackage), "node_modules", ".bin");
 }
 function isInstalled(npmPackage, binary) {
   for (const candidate of lspBinaryCandidates(binary)) {
     try {
-      if (statSync4(join10(lspBinDir(npmPackage), candidate)).isFile())
+      if (statSync4(join11(lspBinDir(npmPackage), candidate)).isFile())
         return true;
     } catch {}
   }
@@ -30707,17 +30910,17 @@ function writeInstalledMetaIn(installDir, version2, sha256) {
       installedAt: new Date().toISOString(),
       ...sha256 ? { sha256 } : {}
     };
-    writeFileSync4(join10(installDir, INSTALLED_META_FILE), JSON.stringify(meta3), "utf8");
+    writeFileSync4(join11(installDir, INSTALLED_META_FILE), JSON.stringify(meta3), "utf8");
   } catch (err) {
     log2(`[lsp-cache] failed to write installed-meta in ${installDir}: ${err}`);
   }
 }
 function readInstalledMetaIn(installDir) {
-  const path2 = join10(installDir, INSTALLED_META_FILE);
+  const path3 = join11(installDir, INSTALLED_META_FILE);
   try {
-    if (!statSync4(path2).isFile())
+    if (!statSync4(path3).isFile())
       return null;
-    const raw = readFileSync5(path2, "utf8");
+    const raw = readFileSync5(path3, "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.version !== "string" || parsed.version.length === 0)
       return null;
@@ -30737,7 +30940,7 @@ function readInstalledMeta(packageKey) {
   return readInstalledMetaIn(lspPackageDir(packageKey));
 }
 function lockPath(npmPackage) {
-  return join10(lspPackageDir(npmPackage), ".aft-installing");
+  return join11(lspPackageDir(npmPackage), ".aft-installing");
 }
 var STALE_LOCK_MS2 = 30 * 60 * 1000;
 function acquireInstallLock(lockKey) {
@@ -30844,7 +31047,7 @@ async function withInstallLock(lockKey, task) {
 }
 var VERSION_CHECK_FILE = ".aft-version-check";
 function readVersionCheck(npmPackage) {
-  const file2 = join10(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
+  const file2 = join11(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
   try {
     const raw = readFileSync5(file2, "utf8");
     const parsed = JSON.parse(raw);
@@ -30861,7 +31064,7 @@ function readVersionCheck(npmPackage) {
 }
 function writeVersionCheck(npmPackage, latest) {
   mkdirSync6(lspPackageDir(npmPackage), { recursive: true });
-  const file2 = join10(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
+  const file2 = join11(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
   const record2 = {
     last_checked: new Date().toISOString(),
     latest_eligible: latest
@@ -31024,7 +31227,7 @@ var NPM_LSP_TABLE = [
 
 // src/lsp-project-relevance.ts
 import { existsSync as existsSync7, readdirSync as readdirSync3, readFileSync as readFileSync6 } from "node:fs";
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 var MAX_WALK_DIRS = 200;
 var MAX_WALK_DEPTH = 4;
 var NOISE_DIRS = new Set([
@@ -31041,7 +31244,7 @@ function hasRootMarker(projectRoot, rootMarkers) {
   if (!rootMarkers)
     return false;
   for (const marker of rootMarkers) {
-    if (existsSync7(join11(projectRoot, marker)))
+    if (existsSync7(join12(projectRoot, marker)))
       return true;
   }
   return false;
@@ -31065,7 +31268,7 @@ function hasPackageJsonDep(projectRoot, depNames) {
 }
 function readPackageJson(projectRoot) {
   try {
-    const raw = readFileSync6(join11(projectRoot, "package.json"), "utf8");
+    const raw = readFileSync6(join12(projectRoot, "package.json"), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null)
       return null;
@@ -31095,7 +31298,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: join11(current.dir, entry.name), depth: current.depth + 1 });
+          queue.push({ dir: join12(current.dir, entry.name), depth: current.depth + 1 });
         }
         continue;
       }
@@ -31222,7 +31425,7 @@ async function resolveTargetVersion(spec, config2, fetchImpl = fetch) {
 }
 function ensureInstallAnchor(cwd) {
   try {
-    const stub = join12(cwd, "package.json");
+    const stub = join13(cwd, "package.json");
     if (!existsSync8(stub)) {
       writeFileSync5(stub, `${JSON.stringify({ name: "aft-lsp-cache", version: "0.0.0", private: true })}
 `);
@@ -31232,18 +31435,18 @@ function ensureInstallAnchor(cwd) {
   }
 }
 function runInstall(spec, version2, cwd, signal) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     const target = `${spec.npm}@${version2}`;
     log2(`[lsp] installing ${target} to ${cwd}`);
     if (signal?.aborted) {
       warn2(`[lsp] install ${target} aborted before spawn`);
-      resolve2(false);
+      resolve3(false);
       return;
     }
     const npm = resolveNpm();
     if (!npm) {
       warn2(`[lsp] npm not found on PATH or known locations; cannot install ${target}`);
-      resolve2(false);
+      resolve3(false);
       return;
     }
     ensureInstallAnchor(cwd);
@@ -31266,7 +31469,7 @@ function runInstall(spec, version2, cwd, signal) {
         return;
       settled = true;
       cleanup();
-      resolve2(ok);
+      resolve3(ok);
     };
     const onAbort = () => {
       warn2(`[lsp] install ${target} aborted during shutdown`);
@@ -31367,7 +31570,7 @@ function cachedPackageDir(npmPackage) {
   return lspBinDir(npmPackage).replace(/[\\/]node_modules[\\/]\.bin[\\/]?$/, "");
 }
 function hashInstalledBinary(spec) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const candidates = process.platform === "win32" ? [
       lspBinaryPath(spec.npm, spec.binary),
       lspBinaryPath(spec.npm, `${spec.binary}.cmd`),
@@ -31391,7 +31594,7 @@ function hashInstalledBinary(spec) {
     const stream = createReadStream(pathToHash);
     stream.on("error", reject);
     stream.on("data", (chunk) => hash2.update(chunk));
-    stream.on("end", () => resolve2(hash2.digest("hex")));
+    stream.on("end", () => resolve3(hash2.digest("hex")));
   });
 }
 function installedBinaryPath(spec) {
@@ -31409,15 +31612,15 @@ function installedBinaryPath(spec) {
   }
   return null;
 }
-function sha256OfFileSync(path2) {
-  return createHash3("sha256").update(readFileSync7(path2)).digest("hex");
+function sha256OfFileSync(path3) {
+  return createHash3("sha256").update(readFileSync7(path3)).digest("hex");
 }
 function quarantineCachedNpmInstall(spec, reason) {
   const packageDir = lspPackageDir(spec.npm);
-  const dest = join12(packageDir, "..", ".quarantine", encodeURIComponent(spec.npm), `${Date.now()}`);
+  const dest = join13(packageDir, "..", ".quarantine", encodeURIComponent(spec.npm), `${Date.now()}`);
   warn2(`[lsp] tofu_mismatch ${spec.npm}: ${reason}; quarantining ${packageDir} -> ${dest}`);
   try {
-    mkdirSync7(join12(dest, ".."), { recursive: true });
+    mkdirSync7(join13(dest, ".."), { recursive: true });
     rmSync3(dest, { recursive: true, force: true });
     renameSync5(packageDir, dest);
   } catch (err) {
@@ -31512,7 +31715,7 @@ import {
   unlinkSync as unlinkSync6,
   writeFileSync as writeFileSync6
 } from "node:fs";
-import { dirname as dirname5, join as join13, relative as relative2, resolve as resolve2 } from "node:path";
+import { dirname as dirname5, join as join14, relative as relative3, resolve as resolve3 } from "node:path";
 import { Readable as Readable3 } from "node:stream";
 import { pipeline as pipeline3 } from "node:stream/promises";
 
@@ -31602,26 +31805,26 @@ function detectHostPlatform() {
 
 // src/lsp-github-install.ts
 function ghCacheRoot() {
-  return join13(aftCacheBase(), "lsp-binaries");
+  return join14(aftCacheBase(), "lsp-binaries");
 }
 function ghPackageDir(spec) {
-  return join13(ghCacheRoot(), spec.id);
+  return join14(ghCacheRoot(), spec.id);
 }
 function ghBinDir(spec) {
-  return join13(ghPackageDir(spec), "bin");
+  return join14(ghPackageDir(spec), "bin");
 }
 function ghExtractDir(spec) {
-  return join13(ghPackageDir(spec), "extracted");
+  return join14(ghPackageDir(spec), "extracted");
 }
 var INSTALLED_META_FILE2 = ".aft-installed";
 function ghBinaryPath(spec, platform) {
   const ext = platform === "win32" ? ".exe" : "";
-  return join13(ghBinDir(spec), `${spec.binary}${ext}`);
+  return join14(ghBinDir(spec), `${spec.binary}${ext}`);
 }
 function isGithubInstalled(spec, platform) {
   for (const candidate of ghBinaryCandidates(spec, platform)) {
     try {
-      if (statSync6(join13(ghBinDir(spec), candidate)).isFile())
+      if (statSync6(join14(ghBinDir(spec), candidate)).isFile())
         return true;
     } catch {}
   }
@@ -31634,10 +31837,10 @@ function ghBinaryCandidates(spec, platform) {
 }
 function readGithubInstalledMetaIn(installDir) {
   try {
-    const path2 = join13(installDir, INSTALLED_META_FILE2);
-    if (!statSync6(path2).isFile())
+    const path3 = join14(installDir, INSTALLED_META_FILE2);
+    if (!statSync6(path3).isFile())
       return null;
-    const parsed = JSON.parse(readFileSync8(path2, "utf8"));
+    const parsed = JSON.parse(readFileSync8(path3, "utf8"));
     if (typeof parsed.version !== "string" || parsed.version.length === 0)
       return null;
     return {
@@ -31661,24 +31864,24 @@ function writeGithubInstalledMetaIn(installDir, version2, binarySha256, archiveS
       binarySha256,
       ...archiveSha256 ? { archiveSha256 } : {}
     };
-    writeFileSync6(join13(installDir, INSTALLED_META_FILE2), JSON.stringify(meta3), "utf8");
+    writeFileSync6(join14(installDir, INSTALLED_META_FILE2), JSON.stringify(meta3), "utf8");
   } catch (err) {
     warn2(`[lsp] failed to write github installed metadata in ${installDir}: ${err}`);
   }
 }
 var MAX_DOWNLOAD_BYTES3 = 256 * 1024 * 1024;
 var MAX_EXTRACT_BYTES2 = 1024 * 1024 * 1024;
-function sha256OfFile(path2) {
-  return new Promise((resolve3, reject) => {
+function sha256OfFile(path3) {
+  return new Promise((resolve4, reject) => {
     const hash2 = createHash4("sha256");
-    const stream = createReadStream2(path2);
+    const stream = createReadStream2(path3);
     stream.on("error", reject);
     stream.on("data", (chunk) => hash2.update(chunk));
-    stream.on("end", () => resolve3(hash2.digest("hex")));
+    stream.on("end", () => resolve4(hash2.digest("hex")));
   });
 }
-function sha256OfFileSync2(path2) {
-  return createHash4("sha256").update(readFileSync8(path2)).digest("hex");
+function sha256OfFileSync2(path3) {
+  return createHash4("sha256").update(readFileSync8(path3)).digest("hex");
 }
 async function fetchReleaseByTag(githubRepo, tag, fetchImpl, signal) {
   const candidates = [];
@@ -31910,7 +32113,7 @@ function validateExtraction(stagingRoot) {
       throw new Error(`failed to read staging dir ${dir}: ${err}`);
     }
     for (const entry of entries) {
-      const full = join13(dir, entry);
+      const full = join14(dir, entry);
       let lst;
       try {
         lst = lstatSync2(full);
@@ -31922,7 +32125,7 @@ function validateExtraction(stagingRoot) {
         try {
           target = readlinkSync2(full);
         } catch {}
-        throw new Error(`archive contains symlink ${relative2(realStagingRoot, full)} → ${target}; rejecting (zip-slip defense)`);
+        throw new Error(`archive contains symlink ${relative3(realStagingRoot, full)} → ${target}; rejecting (zip-slip defense)`);
       }
       let realFull;
       try {
@@ -31930,8 +32133,8 @@ function validateExtraction(stagingRoot) {
       } catch (err) {
         throw new Error(`failed to realpath ${full}: ${err}`);
       }
-      const rel = relative2(realStagingRoot, realFull);
-      if (rel.startsWith("..") || resolve2(realStagingRoot, rel) !== realFull) {
+      const rel = relative3(realStagingRoot, realFull);
+      if (rel.startsWith("..") || resolve3(realStagingRoot, rel) !== realFull) {
         throw new Error(`archive entry escapes staging root: ${full} → ${realFull} (zip-slip defense)`);
       }
       if (lst.isDirectory()) {
@@ -31998,7 +32201,7 @@ function extractArchiveSafely(archivePath, destDir, archiveType) {
 }
 function quarantineCachedGithubInstall(spec, reason) {
   const packageDir = ghPackageDir(spec);
-  const dest = join13(ghCacheRoot(), ".quarantine", encodeURIComponent(spec.id), `${Date.now()}`);
+  const dest = join14(ghCacheRoot(), ".quarantine", encodeURIComponent(spec.id), `${Date.now()}`);
   warn2(`[lsp] tofu_mismatch ${spec.id}: ${reason}; quarantining ${packageDir} -> ${dest}`);
   try {
     mkdirSync8(dirname5(dest), { recursive: true });
@@ -32011,7 +32214,7 @@ function quarantineCachedGithubInstall(spec, reason) {
 function validateCachedGithubInstall(spec, platform) {
   const packageDir = ghPackageDir(spec);
   const meta3 = readGithubInstalledMetaIn(packageDir);
-  const binaryPath = ghBinaryCandidates(spec, platform).map((candidate) => join13(ghBinDir(spec), candidate)).find((candidate) => {
+  const binaryPath = ghBinaryCandidates(spec, platform).map((candidate) => join14(ghBinDir(spec), candidate)).find((candidate) => {
     try {
       return statSync6(candidate).isFile();
     } catch {
@@ -32089,7 +32292,7 @@ async function downloadAndInstall(spec, tag, assets, platform, arch, fetchImpl,
   }
   const pkgDir = ghPackageDir(spec);
   const extractDir = ghExtractDir(spec);
-  const archivePath = join13(pkgDir, expected.name);
+  const archivePath = join14(pkgDir, expected.name);
   log2(`[lsp] downloading ${spec.id} ${tag} → ${matchingAsset.url}`);
   try {
     await downloadFile(matchingAsset.url, archivePath, fetchImpl, matchingAsset.size, signal);
@@ -32129,7 +32332,7 @@ async function downloadAndInstall(spec, tag, assets, platform, arch, fetchImpl,
       unlinkSync6(archivePath);
     } catch {}
   }
-  const innerBinaryPath = join13(extractDir, spec.binaryPathInArchive(platform, arch, version2));
+  const innerBinaryPath = join14(extractDir, spec.binaryPathInArchive(platform, arch, version2));
   if (!existsSync9(innerBinaryPath)) {
     error2(`[lsp] ${spec.id}: extracted binary not found at ${innerBinaryPath}`);
     return null;
@@ -32527,7 +32730,7 @@ function renderScreen(state, rows = state.rows, cols = state.cols) {
 `);
 }
 function writeTerminal(terminal, data) {
-  return new Promise((resolve3) => terminal.write(data, resolve3));
+  return new Promise((resolve4) => terminal.write(data, resolve4));
 }
 
 // src/shutdown-hooks.ts
@@ -32584,8 +32787,8 @@ function installProcessHandlers() {
       }
       signalShutdownStarted = true;
       process.exitCode = SIGNAL_EXIT_CODES[sig];
-      const timeout = new Promise((resolve3) => {
-        setTimeout(resolve3, SIGNAL_CLEANUP_TIMEOUT_MS);
+      const timeout = new Promise((resolve4) => {
+        setTimeout(resolve4, SIGNAL_CLEANUP_TIMEOUT_MS);
       });
       Promise.race([runCleanups(sig), timeout]).finally(() => {
         process.exit(SIGNAL_EXIT_CODES[sig]);
@@ -32627,8 +32830,8 @@ import { Type as Type3 } from "typebox";
 
 // src/tools/hoisted.ts
 import { stat } from "node:fs/promises";
-import { homedir as homedir9 } from "node:os";
-import { isAbsolute as isAbsolute3, relative as relative3, resolve as resolve3, sep } from "node:path";
+import { homedir as homedir10 } from "node:os";
+import { isAbsolute as isAbsolute4, relative as relative4, resolve as resolve4, sep } from "node:path";
 import {
   renderDiff
 } from "@earendil-works/pi-coding-agent";
@@ -32742,18 +32945,18 @@ function diagnosticsOnEditDefault(ctx) {
   return ctx.config.lsp?.diagnostics_on_edit ?? false;
 }
 function containsPath(parent, child) {
-  const rel = relative3(parent, child);
-  return rel === "" || !rel.startsWith("..") && !isAbsolute3(rel);
+  const rel = relative4(parent, child);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute4(rel);
 }
-function expandTilde(path2) {
-  if (!path2 || !path2.startsWith("~"))
-    return path2;
-  if (path2 === "~")
-    return homedir9();
-  if (path2.startsWith(`~${sep}`) || path2.startsWith("~/")) {
-    return resolve3(homedir9(), path2.slice(2));
+function expandTilde2(path3) {
+  if (!path3 || !path3.startsWith("~"))
+    return path3;
+  if (path3 === "~")
+    return homedir10();
+  if (path3.startsWith(`~${sep}`) || path3.startsWith("~/")) {
+    return resolve4(homedir10(), path3.slice(2));
   }
-  return path2;
+  return path3;
 }
 function externalDirectoryPromptTimeoutMs() {
   const raw = process.env.AFT_PI_EXTERNAL_PROMPT_TIMEOUT_MS;
@@ -32765,8 +32968,8 @@ function externalDirectoryPromptTimeoutMs() {
 async function assertExternalDirectoryPermission(extCtx, target, action = "modify", options = {}) {
   if (!target)
     return;
-  const expanded = expandTilde(target);
-  const absoluteTarget = isAbsolute3(expanded) ? expanded : resolve3(extCtx.cwd, expanded);
+  const expanded = expandTilde2(target);
+  const absoluteTarget = isAbsolute4(expanded) ? expanded : resolve4(extCtx.cwd, expanded);
   if (containsPath(extCtx.cwd, absoluteTarget))
     return;
   if (options.restrictToProjectRoot === false)
@@ -32777,8 +32980,8 @@ async function assertExternalDirectoryPermission(extCtx, target, action = "modif
   }
   const timeoutMs = externalDirectoryPromptTimeoutMs();
   let timer;
-  const timeoutPromise = new Promise((resolve4) => {
-    timer = setTimeout(() => resolve4("timeout"), timeoutMs);
+  const timeoutPromise = new Promise((resolve5) => {
+    timer = setTimeout(() => resolve5("timeout"), timeoutMs);
   });
   try {
     const result = await Promise.race([
@@ -32842,8 +33045,12 @@ function registerHoistedTools(pi, ctx, surface) {
         const bridge = bridgeFor(ctx, extCtx.cwd);
         const offset = coerceOptionalInt(params.offset, "offset", 1, Number.MAX_SAFE_INTEGER);
         const limit = coerceOptionalInt(params.limit, "limit", 1, Number.MAX_SAFE_INTEGER);
+        const filePath = await resolvePathArg(extCtx.cwd, params.path);
+        await assertExternalDirectoryPermission(extCtx, filePath, "read", {
+          restrictToProjectRoot: surface.restrictToProjectRoot
+        });
         const req = {
-          file: await resolvePathArg(extCtx.cwd, params.path)
+          file: filePath
         };
         if (offset !== undefined) {
           req.start_line = offset;
@@ -32860,7 +33067,7 @@ function registerHoistedTools(pi, ctx, surface) {
         }
         let text = response.content ?? "";
         const agentSpecifiedRange = offset !== undefined || limit !== undefined;
-        const footer = formatReadFooter(agentSpecifiedRange, response);
+        const footer = formatReadFooter2(agentSpecifiedRange, response);
         if (footer)
           text += footer;
         return textResult(text);
@@ -33116,15 +33323,15 @@ ${summary}${suffix}`);
   container.addChild(new Text(renderDiff(diff), 1, 0));
   return container;
 }
-function shortenPath(path2) {
-  const home = homedir9();
-  if (path2.startsWith(home))
-    return `~${path2.slice(home.length)}`;
-  return path2;
+function shortenPath(path3) {
+  const home = homedir10();
+  if (path3.startsWith(home))
+    return `~${path3.slice(home.length)}`;
+  return path3;
 }
-async function resolvePathArg(cwd, path2) {
-  const expanded = expandTilde(path2);
-  const abs = isAbsolute3(expanded) ? expanded : resolve3(cwd, expanded);
+async function resolvePathArg(cwd, path3) {
+  const expanded = expandTilde2(path3);
+  const abs = isAbsolute4(expanded) ? expanded : resolve4(cwd, expanded);
   try {
     await stat(abs);
     return abs;
@@ -33162,23 +33369,12 @@ function splitIncludeGlobs(include) {
     out.push(tail2);
   return out;
 }
-function formatReadFooter(agentSpecifiedRange, data) {
-  if (agentSpecifiedRange)
-    return "";
-  if (!data.truncated)
-    return "";
-  const startLine = data.start_line;
-  const endLine = data.end_line;
-  const totalLines = data.total_lines;
-  if (startLine === undefined || endLine === undefined || totalLines === undefined) {
-    return "";
-  }
-  return `
-(Showing lines ${startLine}-${endLine} of ${totalLines}. Use offset/limit to read other sections.)`;
+function formatReadFooter2(agentSpecifiedRange, data) {
+  return formatReadFooter(agentSpecifiedRange, data, { rangeHint: "offset/limit" });
 }
 
 // src/tools/render-helpers.ts
-import { homedir as homedir10 } from "node:os";
+import { homedir as homedir11 } from "node:os";
 import { renderDiff as renderDiff2 } from "@earendil-works/pi-coding-agent";
 import { Container as Container2, Spacer as Spacer2, Text as Text2 } from "@earendil-works/pi-tui";
 function reuseText2(last) {
@@ -33187,11 +33383,11 @@ function reuseText2(last) {
 function reuseContainer2(last) {
   return last instanceof Container2 ? last : new Container2;
 }
-function shortenPath2(path2) {
-  const home = homedir10();
-  if (path2.startsWith(home))
-    return `~${path2.slice(home.length)}`;
-  return path2;
+function shortenPath2(path3) {
+  const home = homedir11();
+  if (path3.startsWith(home))
+    return `~${path3.slice(home.length)}`;
+  return path3;
 }
 function renderToolCall(toolName, summary, theme, context) {
   const text = reuseText2(context.lastComponent);
@@ -33199,10 +33395,10 @@ function renderToolCall(toolName, summary, theme, context) {
   text.setText(`${theme.fg("toolTitle", theme.bold(toolName))}${suffix}`);
   return text;
 }
-function accentPath(theme, path2) {
-  if (!path2)
+function accentPath(theme, path3) {
+  if (!path3)
     return theme.fg("toolOutput", "...");
-  return theme.fg("accent", shortenPath2(path2));
+  return theme.fg("accent", shortenPath2(path3));
 }
 function collectTextContent(result) {
   return result.content.filter((part) => part.type === "text").map((part) => part.text ?? "").join(`
@@ -33349,7 +33545,7 @@ function renderUnifiedDiff(unifiedDiff) {
 }
 
 // src/tools/ast.ts
-var AstLang = StringEnum(["typescript", "tsx", "javascript", "python", "rust", "go", "pascal"], {
+var AstLang = StringEnum(["typescript", "tsx", "javascript", "python", "rust", "go", "pascal", "r"], {
   description: "Target language"
 });
 var SearchParams = Type3.Object({
@@ -33390,17 +33586,17 @@ ${warningStrings.map((w) => `  ${w}`).join(`
 async function resolveAstPaths(extCtx, paths) {
   if (isEmptyParam(paths) || !Array.isArray(paths))
     return;
-  return Promise.all(paths.filter((path2) => typeof path2 === "string").map((path2) => resolvePathArg(extCtx.cwd, path2)));
+  return Promise.all(paths.filter((path3) => typeof path3 === "string").map((path3) => resolvePathArg(extCtx.cwd, path3)));
 }
 async function assertAstPathsPermission(extCtx, paths, action, restrictToProjectRoot) {
   if (paths === undefined || paths.length === 0)
     return;
   const checked = new Set;
-  for (const path2 of paths) {
-    if (checked.has(path2))
+  for (const path3 of paths) {
+    if (checked.has(path3))
       continue;
-    checked.add(path2);
-    await assertExternalDirectoryPermission(extCtx, path2, action, { restrictToProjectRoot });
+    checked.add(path3);
+    await assertExternalDirectoryPermission(extCtx, path3, action, { restrictToProjectRoot });
   }
 }
 function buildAstSearchSections(payload, theme) {
@@ -33583,6 +33779,7 @@ var FOREGROUND_POLL_INTERVAL_MS = 100;
 var BASH_WAIT_POLL_INTERVAL_MS = 100;
 var DEFAULT_BASH_STATUS_WAIT_TIMEOUT_MS = 30000;
 var MAX_BASH_STATUS_WAIT_TIMEOUT_MS = 300000;
+var REGEX_WAIT_SCAN_WINDOW_BYTES = 64 * 1024;
 function resolveForegroundWaitMs(configured) {
   const override = process.env.AFT_TEST_FOREGROUND_WAIT_MS;
   if (override !== undefined) {
@@ -33767,7 +33964,7 @@ DO NOT use bash for code search or code exploration. If you are about to run gre
             throw new Error(status.message ?? "bash_status failed");
           }
           if (isTerminalStatus(status.status)) {
-            return bashResult(appendPipeStripNote(withBashHints(formatForegroundResult(status), bridgeCommand, aftSearchRegistered), pipeStrip.note), {
+            return bashResult(appendPipeStripNote(withBashHints(formatForegroundResult(status), bridgeCommand, aftSearchRegistered, extCtx.cwd), pipeStrip.note), {
               exit_code: status.exit_code,
               duration_ms: status.duration_ms,
               truncated: status.output_truncated,
@@ -33794,7 +33991,7 @@ DO NOT use bash for code search or code exploration. If you are about to run gre
         task_id: taskId
       };
       const output = response.output ?? "";
-      return bashResult(appendPipeStripNote(withBashHints(output, bridgeCommand, aftSearchRegistered), pipeStrip.note), details);
+      return bashResult(appendPipeStripNote(withBashHints(output, bridgeCommand, aftSearchRegistered, extCtx.cwd), pipeStrip.note), details);
     },
     renderCall(args, theme, context) {
       return renderBashCall(args?.command, args?.description, theme, context);
@@ -33808,11 +34005,6 @@ DO NOT use bash for code search or code exploration. If you are about to run gre
   pi.registerTool(createBashWriteTool(ctx));
   pi.registerTool(createBashKillTool(ctx));
 }
-function appendPipeStripNote(output, note) {
-  return note ? `${output}
-
-${note}` : output;
-}
 function formatBackgroundLaunch(taskId, isPty) {
   if (isPty) {
     return `PTY task started: ${taskId}. Use bash_status({ task_id: "${taskId}", output_mode: "screen" }) to see the visible terminal, bash_write({ task_id: "${taskId}", input: ... }) to send keystrokes. A completion reminder fires automatically when the task exits.`;
@@ -33823,35 +34015,8 @@ function formatPromotionMessage(taskId, timeout, waitWindowMs) {
   const waited = timeout !== undefined ? Math.min(timeout, waitWindowMs) : waitWindowMs;
   return `Foreground bash didn't finish within ${formatSeconds(waited)} and was promoted to background: ${taskId}. A completion reminder will be delivered automatically; use bash_status({ task_id: "${taskId}" }) to inspect output or bash_kill({ task_id: "${taskId}" }) to terminate.`;
 }
-function formatSeconds(ms) {
-  return `${Number((ms / 1000).toFixed(1))}s`;
-}
-function withBashHints(output, command, aftSearchRegistered) {
-  return maybeAppendGrepSearchHint(maybeAppendConflictsHint(output), command, aftSearchRegistered);
-}
-function formatForegroundResult(data) {
-  const output = data.output_preview ?? "";
-  const outputPath = data.output_path;
-  const truncated = data.output_truncated === true;
-  const status = data.status;
-  const exit = data.exit_code;
-  let rendered = output;
-  if (truncated && outputPath) {
-    rendered += `
-[output truncated; full output at ${outputPath}]`;
-  }
-  if (status === "timed_out") {
-    rendered += `
-[command timed out]`;
-  }
-  if (typeof exit === "number" && exit !== 0) {
-    rendered += `
-[exit code: ${exit}]`;
-  }
-  return rendered;
-}
-function sleep(ms) {
-  return new Promise((resolve4) => setTimeout(resolve4, ms));
+function withBashHints(output, command, aftSearchRegistered, projectRoot) {
+  return maybeAppendGrepSearchHint(maybeAppendConflictsHint(output), command, aftSearchRegistered, projectRoot);
 }
 function createBashStatusTool(ctx) {
   return {
@@ -34018,6 +34183,9 @@ async function waitForBashStatus(ctx, bridge, extCtx, taskId, outputMode, waitFo
     keepBridgeOnTimeout: true,
     transportTimeoutMs: BASH_TRANSPORT_TIMEOUT_MS
   };
+  if (waitFor?.kind === "regex") {
+    await validateWaitRegex(bridge, extCtx, waitFor);
+  }
   const sessionId = resolveSessionId(extCtx);
   clearSyncWatchAbort(sessionId);
   if (waitForExit)
@@ -34034,7 +34202,12 @@ async function waitForBashStatus(ctx, bridge, extCtx, taskId, outputMode, waitFo
           if (scanText.length === 0)
             scanBaseOffset = scan.baseOffset;
           scanText += scan.text;
-          const match = findWaitMatch(scanText, waitFor);
+          if (waitFor.kind === "regex") {
+            const trimmed = trimWaitScanBuffer(scanText, scanBaseOffset, waitFor);
+            scanText = trimmed.text;
+            scanBaseOffset = trimmed.baseOffset;
+          }
+          const match = await findWaitMatch(bridge, extCtx, scanText, waitFor);
           if (match) {
             if (waitForExit && terminal) {
               sawTerminal = true;
@@ -34045,9 +34218,14 @@ async function waitForBashStatus(ctx, bridge, extCtx, taskId, outputMode, waitFo
               reason: "matched",
               elapsed_ms: Date.now() - startedAt,
               match: match.text,
-              match_offset: scanBaseOffset + Buffer.byteLength(scanText.slice(0, match.index), "utf8")
+              match_offset: scanBaseOffset + match.byteOffset
             });
           }
+          if (waitFor.kind === "substring") {
+            const trimmed = trimWaitScanBuffer(scanText, scanBaseOffset, waitFor);
+            scanText = trimmed.text;
+            scanBaseOffset = trimmed.baseOffset;
+          }
         }
       }
       if (terminal) {
@@ -34133,20 +34311,69 @@ function parseWaitPattern(value) {
   if (typeof value === "string")
     return { kind: "substring", value };
   if (isRegexWaitObject(value))
-    return { kind: "regex", value: new RegExp(value.regex), source: value.regex };
+    return { kind: "regex", source: value.regex };
   return;
 }
 function isRegexWaitObject(value) {
   return typeof value === "object" && value !== null && "regex" in value && typeof value.regex === "string";
 }
-function findWaitMatch(text, pattern) {
+async function validateWaitRegex(bridge, extCtx, pattern) {
+  await matchRegexWithBridge(bridge, extCtx, pattern.source, "");
+}
+async function findWaitMatch(bridge, extCtx, text, pattern) {
   if (pattern.kind === "substring") {
     const index = text.indexOf(pattern.value);
-    return index >= 0 ? { text: pattern.value, index } : undefined;
+    return index >= 0 ? { text: pattern.value, byteOffset: Buffer.byteLength(text.slice(0, index), "utf8") } : undefined;
+  }
+  return await matchRegexWithBridge(bridge, extCtx, pattern.source, text);
+}
+async function matchRegexWithBridge(bridge, extCtx, pattern, text) {
+  try {
+    const result = await callBashBridge(bridge, "bash_regex_match", { pattern, text }, extCtx);
+    if (result.matched !== true)
+      return;
+    return {
+      text: typeof result.match_text === "string" ? result.match_text : "",
+      byteOffset: coerceMatchOffset(result.match_offset)
+    };
+  } catch (err) {
+    if (err instanceof BridgeError && err.code === "invalid_regex") {
+      throw new Error(`invalid_request: invalid_regex: ${err.message}`);
+    }
+    throw err;
   }
-  pattern.value.lastIndex = 0;
-  const match = pattern.value.exec(text);
-  return match ? { text: match[0], index: match.index } : undefined;
+}
+function coerceMatchOffset(value) {
+  const offset = typeof value === "number" ? value : Number(value ?? 0);
+  return Number.isFinite(offset) && offset >= 0 ? offset : 0;
+}
+function trimWaitScanBuffer(text, baseOffset, pattern) {
+  const keepFrom = pattern.kind === "substring" ? substringKeepStart(text, pattern.value) : regexKeepStart(text, REGEX_WAIT_SCAN_WINDOW_BYTES);
+  if (keepFrom <= 0)
+    return { text, baseOffset };
+  return {
+    text: text.slice(keepFrom),
+    baseOffset: baseOffset + Buffer.byteLength(text.slice(0, keepFrom), "utf8")
+  };
+}
+function substringKeepStart(text, pattern) {
+  const keepChars = Math.max(0, pattern.length - 1);
+  return text.length > keepChars ? text.length - keepChars : 0;
+}
+function regexKeepStart(text, maxBytes) {
+  if (Buffer.byteLength(text, "utf8") <= maxBytes)
+    return 0;
+  let low = 0;
+  let high = text.length;
+  while (low < high) {
+    const mid = Math.floor((low + high) / 2);
+    if (Buffer.byteLength(text.slice(mid), "utf8") > maxBytes) {
+      low = mid + 1;
+    } else {
+      high = mid;
+    }
+  }
+  return low;
 }
 function withWaited(data, waited) {
   return { ...data, waited };
@@ -34222,9 +34449,6 @@ function ptyCacheKey(extCtx, taskId) {
 function watchPtyCacheKey(extCtx, taskId) {
   return `${ptyCacheKey(extCtx, taskId)}::watch`;
 }
-function isTerminalStatus(status) {
-  return status === "completed" || status === "failed" || status === "killed" || status === "timed_out";
-}
 function renderBashCall(command, description, theme, context) {
   const text = reuseText3(context.lastComponent);
   const display = description ?? (command ? shortenCommand(command) : "...");
@@ -34328,12 +34552,12 @@ function registerConflictsTool(pi, ctx) {
     async execute(_toolCallId, params, _signal, _onUpdate, extCtx) {
       const bridge = bridgeFor(ctx, extCtx.cwd);
       const reqParams = {};
-      const path2 = params?.path;
-      if (typeof path2 === "string" && path2.trim() !== "") {
-        await assertExternalDirectoryPermission(extCtx, path2, "inspect", {
+      const path3 = params?.path;
+      if (typeof path3 === "string" && path3.trim() !== "") {
+        await assertExternalDirectoryPermission(extCtx, path3, "inspect", {
           restrictToProjectRoot: ctx.config.restrict_to_project_root ?? false
         });
-        reqParams.path = await resolvePathArg(extCtx.cwd, path2);
+        reqParams.path = await resolvePathArg(extCtx.cwd, path3);
       }
       const response = await callBridge(bridge, "git_conflicts", reqParams, extCtx);
       return textResult(response.text ?? JSON.stringify(response, null, 2));
@@ -34732,8 +34956,8 @@ function tier2SummaryPart(summary, key, label) {
   return `${label} ${status ?? "unavailable"}`;
 }
 function shortDupOccurrence(entry) {
-  const [path2] = entry.split(":");
-  return path2?.split("/").pop() ?? entry;
+  const [path3] = entry.split(":");
+  return path3?.split("/").pop() ?? entry;
 }
 function tier2TopPreview(summary, theme) {
   const lines = [];
@@ -34942,9 +35166,9 @@ function depthWarning(response, theme, depthField = "depth_limited", truncatedFi
   const detail = truncated > 0 ? `, ${truncated} truncated` : "";
   return theme.fg("warning", `(depth limited${detail})`);
 }
-function renderTracePath(path2, index, lines) {
+function renderTracePath(path3, index, lines) {
   lines.push(`Path ${index + 1}`);
-  asRecords(path2.hops).forEach((hop, hopIndex) => {
+  asRecords(path3.hops).forEach((hop, hopIndex) => {
     const symbol2 = asString(hop.symbol) ?? "(unknown)";
     const file2 = shortenPath2(asString(hop.file) ?? "(unknown file)");
     const line = asNumber(hop.line);
@@ -34982,15 +35206,15 @@ function buildNavigateSections(args, payload, theme) {
     return sections2;
   }
   if (args.op === "trace_to_symbol") {
-    const path2 = asRecords(response.path);
+    const path3 = asRecords(response.path);
     const complete = asBoolean(response.complete);
     const reason = asString(response.reason);
-    if (path2.length === 0) {
+    if (path3.length === 0) {
       const prefix = complete === false ? theme.fg("warning", "No complete path") : theme.fg("muted", "No path");
       return [`${prefix}${reason ? ` (${reason})` : ""}`];
     }
-    const lines = [theme.fg("success", `${path2.length} hop${path2.length === 1 ? "" : "s"}`)];
-    path2.forEach((hop, index) => {
+    const lines = [theme.fg("success", `${path3.length} hop${path3.length === 1 ? "" : "s"}`)];
+    path3.forEach((hop, index) => {
       const symbol2 = asString(hop.symbol) ?? "(unknown)";
       const file2 = shortenPath2(asString(hop.file) ?? "(unknown file)");
       const line = asNumber(hop.line);
@@ -35006,9 +35230,9 @@ function buildNavigateSections(args, payload, theme) {
     ];
     if (paths.length === 0)
       sections2.push(theme.fg("muted", "No entry paths found."));
-    paths.forEach((path2, index) => {
+    paths.forEach((path3, index) => {
       const lines = [];
-      renderTracePath(path2, index, lines);
+      renderTracePath(path3, index, lines);
       sections2.push(lines.join(`
 `));
     });
@@ -35466,6 +35690,11 @@ Pass a single \`target\`:
           }));
           if (symbolsArray.length === 1) {
             const response2 = results[0] ?? { success: false, message: "missing zoom response" };
+            const rustBatch = unwrapRustZoomBatchEnvelope(response2);
+            if (rustBatch) {
+              const batch2 = formatZoomBatchResult(targetLabel, rustBatch.names, rustBatch.responses);
+              return textResult(batch2.text, batch2);
+            }
             if (response2.success === false) {
               throw new Error(response2.message || "zoom failed");
             }
@@ -35701,7 +35930,7 @@ function registerRefactorTool(pi, ctx) {
 import { StringEnum as StringEnum5 } from "@earendil-works/pi-ai";
 import { Type as Type12 } from "typebox";
 function responsePaths(response) {
-  return Array.isArray(response.paths) ? response.paths.filter((path2) => typeof path2 === "string" && path2.length > 0) : [];
+  return Array.isArray(response.paths) ? response.paths.filter((path3) => typeof path3 === "string" && path3.length > 0) : [];
 }
 var SafetyParams = Type12.Object({
   op: StringEnum5(["undo", "history", "checkpoint", "restore", "list"], {
@@ -36167,18 +36396,18 @@ function createVersionMismatchHandler(getPool, ensureCompatibleBinary = ensureBi
     const upgradePromise = (async () => {
       warn2(`WARNING: aft binary v${binaryVersion} is older than plugin v${minVersion}. ` + "Some features may not work. Attempting to download a compatible binary...");
       try {
-        const path2 = await ensureCompatibleBinary(`v${minVersion}`);
-        if (!path2) {
+        const path3 = await ensureCompatibleBinary(`v${minVersion}`);
+        if (!path3) {
           warn2(`Could not find or download v${minVersion}. Continuing with v${binaryVersion}.`);
           return null;
         }
         const pool = getPool();
         if (!pool) {
-          warn2(`Found/downloaded compatible binary at ${path2}, but bridge pool is not ready.`);
+          warn2(`Found/downloaded compatible binary at ${path3}, but bridge pool is not ready.`);
           return null;
         }
-        log2(`Found/downloaded compatible binary at ${path2}. Replacing running bridges...`);
-        const replaced = await pool.replaceBinary(path2);
+        log2(`Found/downloaded compatible binary at ${path3}. Replacing running bridges...`);
+        const replaced = await pool.replaceBinary(path3);
         log2("Binary replaced successfully. New bridges will use the updated binary.");
         return replaced;
       } catch (err) {
@@ -36200,12 +36429,11 @@ var PLUGIN_VERSION = (() => {
     return "0.0.0";
   }
 })();
-var ANNOUNCEMENT_VERSION = "0.38.0";
+var ANNOUNCEMENT_VERSION = "0.39.0";
 var ANNOUNCEMENT_FEATURES = [
-  "Code Health you can trust: dead code and unused exports are back in the status displays, rebuilt on a real TS/JS module-graph engine (oxc) — barrel re-exports, entry points, and dynamic imports resolve correctly now.",
-  "Tools stay responsive during builds: filesystem events are processed off the request thread, so a cargo/webpack compile no longer queues your tool calls behind an event flood.",
-  "Pascal support in outline, zoom, and the AST tools.",
-  "Transient environment errors (schema fetch timeouts) no longer count as code errors in the status bar."
+  "Accurate Rust dead code: constructors and associated functions reached through receiver-type inference are no longer mis-reported as dead.",
+  "Code Health scans reparse only the file you changed instead of the whole project on every edit — a single-file edit dropped from ~3s of scan work to ~130ms on this repo, byte-identical results.",
+  "R language support in outline, zoom, and the AST tools."
 ];
 var ANNOUNCEMENT_FOOTER = "Join us on Discord: https://discord.gg/DSa65w8wuf";
 var ALL_ONLY_TOOLS = new Set(["aft_callgraph", "aft_delete", "aft_move", "aft_refactor"]);
@@ -36504,7 +36732,7 @@ ${lines}
       if (onnxRuntimePromise) {
         await Promise.race([
           onnxRuntimePromise,
-          new Promise((resolve4) => setTimeout(() => resolve4(null), 60000))
+          new Promise((resolve5) => setTimeout(() => resolve5(null), 60000))
         ]);
       }
       const bridge = pool.getBridge(cwd);