@cortexkit/aft-opencode 0.38.0 → 0.39.1

package/dist/index.js

@@ -7652,10 +7652,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)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two, gap)), 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)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two, gap)), gap) : EMPTY;
   var join_content = (inside, value, gap) => {
     const comment = process_comments(value, PREFIX_BEFORE, gap + indent, true);
-    return join9(comment, inside, gap);
+    return join10(comment, inside, gap);
   };
   var stringify_string = (holder, key, value) => {
     const raw = get_raw_string_literal(holder, key);
@@ -7677,13 +7677,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) => {
@@ -7704,13 +7704,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) {
@@ -11593,7 +11593,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.`;
@@ -11607,48 +11645,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";
@@ -11756,8 +11921,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
@@ -12135,7 +12300,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)
@@ -12170,7 +12335,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);
@@ -12268,15 +12433,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");
       });
@@ -12321,15 +12486,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");
     });
@@ -12356,7 +12521,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,
@@ -12364,7 +12529,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) {
@@ -12706,12 +12871,23 @@ function coerceStringArray(value) {
   }
   return [];
 }
+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";
 
@@ -12768,11 +12944,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";
@@ -12780,7 +12956,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) {
@@ -12797,16 +12973,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;
@@ -12958,7 +13134,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));
     }
   }
 }
@@ -13044,18 +13220,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 {
@@ -13101,8 +13277,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 {
@@ -13111,9 +13287,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)
@@ -13143,18 +13319,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) {
@@ -13273,7 +13449,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)
@@ -13319,22 +13495,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)
@@ -13348,12 +13524,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;
   }
@@ -13416,13 +13592,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
   };
 }
@@ -13441,16 +13617,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;
@@ -13459,8 +13635,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));
@@ -13485,22 +13661,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);
   }
@@ -13510,12 +13686,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 };
   }
@@ -13535,7 +13711,7 @@ function isNpmAvailable(deps = defaultDeps()) {
 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";
@@ -13601,10 +13777,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) {
@@ -13634,9 +13810,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.`);
@@ -13655,7 +13831,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;
@@ -13692,7 +13868,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 });
     }
@@ -13720,8 +13896,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 {
@@ -13736,7 +13912,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);
@@ -13772,7 +13948,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) {
@@ -13788,10 +13964,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;
 }
@@ -13806,12 +13982,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 {
@@ -13820,7 +13996,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)}`);
@@ -13832,7 +14008,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))
@@ -13842,7 +14018,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;
@@ -13908,19 +14084,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()) {
@@ -13943,7 +14119,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}`);
@@ -13959,7 +14135,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}`);
     }
@@ -13968,7 +14144,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}`);
@@ -13983,7 +14159,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);
@@ -14008,8 +14184,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") {
@@ -14025,12 +14201,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)) {
@@ -14050,7 +14226,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}`);
@@ -14077,17 +14253,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;
@@ -14101,9 +14277,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) {
@@ -14939,6 +15115,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;
@@ -15019,16 +15280,39 @@ 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/bg-notifications.ts
 import { createHash as createHash3, randomUUID as randomUUID2 } from "node:crypto";
 
 // 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-plugin]";
 var isTestEnv = process.env.BUN_TEST === "1" || false;
-var logFile = path.join(os.tmpdir(), isTestEnv ? "aft-plugin-test.log" : "aft-plugin.log");
+var logFile = path2.join(os2.tmpdir(), isTestEnv ? "aft-plugin-test.log" : "aft-plugin.log");
 var useStderr = process.env.AFT_LOG_STDERR === "1";
 var buffer = [];
 var flushTimer = null;
@@ -15972,8 +16256,8 @@ function formatDuration(completion) {
 
 // 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 homedir6 } from "node:os";
-import { join as join9 } from "node:path";
+import { homedir as homedir7 } 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
@@ -16741,10 +17025,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);
@@ -17125,11 +17409,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;
   });
 }
@@ -17312,7 +17596,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) {
@@ -17322,7 +17606,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;
@@ -17354,8 +17638,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")
@@ -29102,13 +29386,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}`);
     }
@@ -29806,9 +30090,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] = {};
@@ -29817,9 +30101,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;
@@ -29829,9 +30113,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 = [];
@@ -30168,17 +30452,17 @@ function getOpenCodeConfigDir() {
   if (envDir) {
     return envDir;
   }
-  const xdgConfig = process.env.XDG_CONFIG_HOME || join9(homedir6(), ".config");
-  return join9(xdgConfig, "opencode");
+  const xdgConfig = process.env.XDG_CONFIG_HOME || join10(homedir7(), ".config");
+  return join10(xdgConfig, "opencode");
 }
 function loadAftConfig(projectDirectory) {
   const configDir = getOpenCodeConfigDir();
-  const userBasePath = join9(configDir, "aft");
+  const userBasePath = join10(configDir, "aft");
   migrateAftConfigFile(`${userBasePath}.jsonc`);
   migrateAftConfigFile(`${userBasePath}.json`);
   const userDetected = detectConfigFile(userBasePath);
   const userConfigPath = userDetected.format !== "none" ? userDetected.path : `${userBasePath}.json`;
-  const projectBasePath = join9(projectDirectory, ".opencode", "aft");
+  const projectBasePath = join10(projectDirectory, ".opencode", "aft");
   migrateAftConfigFile(`${projectBasePath}.jsonc`);
   migrateAftConfigFile(`${projectBasePath}.json`);
   const projectDetected = detectConfigFile(projectBasePath);
@@ -30204,8 +30488,8 @@ function loadAftConfig(projectDirectory) {
 
 // src/notifications.ts
 import { existsSync as existsSync7, readFileSync as readFileSync5 } from "node:fs";
-import { homedir as homedir7, platform } from "node:os";
-import { join as join10 } from "node:path";
+import { homedir as homedir8, platform } from "node:os";
+import { join as join11 } from "node:path";
 function isTuiMode() {
   return process.env.OPENCODE_CLIENT === "cli";
 }
@@ -30225,18 +30509,18 @@ var FEATURE_MARKER = `${AFT_MARKER} New in`;
 var WARNING_MARKER = `${AFT_MARKER} ⚠️`;
 var STATUS_MARKER = `${AFT_MARKER} ✅`;
 function getDesktopStatePath() {
-  const os2 = platform();
-  const home = homedir7();
-  if (os2 === "darwin") {
-    return join10(home, "Library", "Application Support", "ai.opencode.desktop", "opencode.global.dat");
+  const os3 = platform();
+  const home = homedir8();
+  if (os3 === "darwin") {
+    return join11(home, "Library", "Application Support", "ai.opencode.desktop", "opencode.global.dat");
   }
-  if (os2 === "linux") {
-    const xdgConfig = process.env.XDG_CONFIG_HOME || join10(home, ".config");
-    return join10(xdgConfig, "ai.opencode.desktop", "opencode.global.dat");
+  if (os3 === "linux") {
+    const xdgConfig = process.env.XDG_CONFIG_HOME || join11(home, ".config");
+    return join11(xdgConfig, "ai.opencode.desktop", "opencode.global.dat");
   }
-  if (os2 === "win32") {
-    const appData = process.env.APPDATA || join10(home, "AppData", "Roaming");
-    return join10(appData, "ai.opencode.desktop", "opencode.global.dat");
+  if (os3 === "win32") {
+    const appData = process.env.APPDATA || join11(home, "AppData", "Roaming");
+    return join11(appData, "ai.opencode.desktop", "opencode.global.dat");
   }
   return null;
 }
@@ -30706,37 +30990,37 @@ import { dirname as dirname7 } from "node:path";
 import { spawn as spawn2 } from "node:child_process";
 import { cpSync, existsSync as existsSync9, mkdtempSync, readFileSync as readFileSync7, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
-import { basename as basename2, dirname as dirname6, join as join13 } from "node:path";
+import { basename as basename2, dirname as dirname6, join as join14 } from "node:path";
 var import_comment_json3 = __toESM(require_src2(), 1);
 
 // src/hooks/auto-update-checker/checker.ts
 var import_comment_json2 = __toESM(require_src2(), 1);
 import { existsSync as existsSync8, readFileSync as readFileSync6, statSync as statSync4, writeFileSync as writeFileSync4 } from "node:fs";
-import { homedir as homedir9 } from "node:os";
-import { dirname as dirname5, isAbsolute as isAbsolute3, join as join12, resolve as resolve2 } from "node:path";
+import { homedir as homedir10 } from "node:os";
+import { dirname as dirname5, isAbsolute as isAbsolute4, join as join13, resolve as resolve3 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/hooks/auto-update-checker/constants.ts
-import { homedir as homedir8, platform as platform2 } from "node:os";
-import { join as join11 } from "node:path";
+import { homedir as homedir9, platform as platform2 } from "node:os";
+import { join as join12 } from "node:path";
 var PACKAGE_NAME = "@cortexkit/aft-opencode";
 var NPM_REGISTRY_URL = "https://registry.npmjs.org";
 var NPM_FETCH_TIMEOUT = 1e4;
 function getOpenCodeCacheRoot() {
   if (platform2() === "win32") {
-    return join11(process.env.LOCALAPPDATA ?? homedir8(), "opencode");
+    return join12(process.env.LOCALAPPDATA ?? homedir9(), "opencode");
   }
-  return join11(homedir8(), ".cache", "opencode");
+  return join12(homedir9(), ".cache", "opencode");
 }
 function getOpenCodeConfigRoot() {
   if (platform2() === "win32") {
-    return join11(process.env.APPDATA ?? join11(homedir8(), "AppData", "Roaming"), "opencode");
+    return join12(process.env.APPDATA ?? join12(homedir9(), "AppData", "Roaming"), "opencode");
   }
-  return join11(process.env.XDG_CONFIG_HOME ?? join11(homedir8(), ".config"), "opencode");
+  return join12(process.env.XDG_CONFIG_HOME ?? join12(homedir9(), ".config"), "opencode");
 }
-var CACHE_DIR = join11(getOpenCodeCacheRoot(), "packages");
-var USER_OPENCODE_CONFIG = join11(getOpenCodeConfigRoot(), "opencode.json");
-var USER_OPENCODE_CONFIG_JSONC = join11(getOpenCodeConfigRoot(), "opencode.jsonc");
+var CACHE_DIR = join12(getOpenCodeCacheRoot(), "packages");
+var USER_OPENCODE_CONFIG = join12(getOpenCodeConfigRoot(), "opencode.json");
+var USER_OPENCODE_CONFIG_JSONC = join12(getOpenCodeConfigRoot(), "opencode.jsonc");
 
 // src/hooks/auto-update-checker/types.ts
 var NpmPackageEnvelopeSchema = exports_external.object({
@@ -30794,8 +31078,8 @@ function extractChannel(version2) {
 }
 function getConfigPaths(directory) {
   return [
-    join12(directory, ".opencode", "opencode.json"),
-    join12(directory, ".opencode", "opencode.jsonc"),
+    join13(directory, ".opencode", "opencode.json"),
+    join13(directory, ".opencode", "opencode.jsonc"),
     USER_OPENCODE_CONFIG,
     USER_OPENCODE_CONFIG_JSONC
   ];
@@ -30808,9 +31092,9 @@ function resolvePathPluginSpec(spec, configPath) {
       return spec.replace(/^file:\/\//, "");
     }
   }
-  if (isAbsolute3(spec) || /^[A-Za-z]:[\\/]/.test(spec))
+  if (isAbsolute4(spec) || /^[A-Za-z]:[\\/]/.test(spec))
     return spec;
-  return resolve2(dirname5(configPath), spec);
+  return resolve3(dirname5(configPath), spec);
 }
 function getLocalDevPath(directory) {
   for (const configPath of getConfigPaths(directory)) {
@@ -30822,7 +31106,7 @@ function getLocalDevPath(directory) {
       for (const entry of plugins) {
         if (entry === PACKAGE_NAME || entry.startsWith(`${PACKAGE_NAME}@`))
           continue;
-        if (entry.startsWith("file://") || entry.startsWith(".") || isAbsolute3(entry)) {
+        if (entry.startsWith("file://") || entry.startsWith(".") || isAbsolute4(entry)) {
           const localPath = resolvePathPluginSpec(entry, configPath);
           const pkgPath = findPackageJsonUp(localPath);
           if (!pkgPath)
@@ -30841,7 +31125,7 @@ function findPackageJsonUp(startPath) {
     const stat = statSync4(startPath);
     let dir = stat.isDirectory() ? startPath : dirname5(startPath);
     for (let i = 0;i < 10; i++) {
-      const pkgPath = join12(dir, "package.json");
+      const pkgPath = join13(dir, "package.json");
       if (existsSync8(pkgPath)) {
         try {
           const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync6(pkgPath, "utf-8")));
@@ -30902,7 +31186,7 @@ function findPluginEntry(directory) {
 }
 var cachedPackageVersion = null;
 function getSpecCachePackageJsonPath(spec) {
-  return join12(CACHE_DIR, spec, "node_modules", PACKAGE_NAME, "package.json");
+  return join13(CACHE_DIR, spec, "node_modules", PACKAGE_NAME, "package.json");
 }
 function getCachedVersion(spec) {
   if (!spec && cachedPackageVersion)
@@ -30911,7 +31195,7 @@ function getCachedVersion(spec) {
     getCurrentRuntimePackageJsonPath(),
     spec ? getSpecCachePackageJsonPath(spec) : null,
     getSpecCachePackageJsonPath(`${PACKAGE_NAME}@latest`),
-    join12(homedir9(), ".cache", "opencode", "node_modules", PACKAGE_NAME, "package.json")
+    join13(homedir10(), ".cache", "opencode", "node_modules", PACKAGE_NAME, "package.json")
   ].filter(isString);
   for (const packageJsonPath of candidates) {
     try {
@@ -30959,10 +31243,10 @@ async function getLatestVersion(channel = "latest", options = {}) {
 // src/hooks/auto-update-checker/cache.ts
 var pendingSnapshots = new Map;
 function createAutoUpdateSnapshot(installDir, packageJsonPath, packageName) {
-  const packageDir = join13(installDir, "node_modules", packageName);
-  const lockfilePath = join13(installDir, "package-lock.json");
-  const tempDir = mkdtempSync(join13(tmpdir3(), "aft-auto-update-"));
-  const stagedPackageDir = existsSync9(packageDir) ? join13(tempDir, "package") : null;
+  const packageDir = join14(installDir, "node_modules", packageName);
+  const lockfilePath = join14(installDir, "package-lock.json");
+  const tempDir = mkdtempSync(join14(tmpdir3(), "aft-auto-update-"));
+  const stagedPackageDir = existsSync9(packageDir) ? join14(tempDir, "package") : null;
   if (stagedPackageDir)
     cpSync(packageDir, stagedPackageDir, { recursive: true });
   return {
@@ -31003,7 +31287,7 @@ function stripPackageNameFromPath(pathValue, packageName) {
   return current;
 }
 function removeFromPackageLock(installDir, packageName) {
-  const lockPath = join13(installDir, "package-lock.json");
+  const lockPath = join14(installDir, "package-lock.json");
   if (!existsSync9(lockPath))
     return false;
   try {
@@ -31052,7 +31336,7 @@ function ensureDependencyVersion(packageJsonPath, packageName, version2) {
   }
 }
 function removeInstalledPackage(installDir, packageName) {
-  const packageDir = join13(installDir, "node_modules", packageName);
+  const packageDir = join14(installDir, "node_modules", packageName);
   if (!existsSync9(packageDir))
     return false;
   rmSync3(packageDir, { recursive: true, force: true });
@@ -31065,13 +31349,13 @@ function resolveInstallContext(runtimePackageJsonPath = getCurrentRuntimePackage
     const nodeModulesDir = stripPackageNameFromPath(packageDir, PACKAGE_NAME);
     if (nodeModulesDir && basename2(nodeModulesDir) === "node_modules") {
       const installDir = dirname6(nodeModulesDir);
-      const packageJsonPath = join13(installDir, "package.json");
+      const packageJsonPath = join14(installDir, "package.json");
       if (existsSync9(packageJsonPath))
         return { installDir, packageJsonPath };
     }
     return null;
   }
-  const legacyPackageJsonPath = join13(dirname6(CACHE_DIR), "package.json");
+  const legacyPackageJsonPath = join14(dirname6(CACHE_DIR), "package.json");
   if (existsSync9(legacyPackageJsonPath)) {
     return { installDir: dirname6(CACHE_DIR), packageJsonPath: legacyPackageJsonPath };
   }
@@ -31402,7 +31686,7 @@ import {
   statSync as statSync6,
   writeFileSync as writeFileSync8
 } from "node:fs";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 
 // src/lsp-cache.ts
 import {
@@ -31414,36 +31698,36 @@ import {
   unlinkSync as unlinkSync5,
   writeFileSync as writeFileSync7
 } from "node:fs";
-import { homedir as homedir10 } from "node:os";
-import { join as join14 } from "node:path";
+import { homedir as homedir11 } from "node:os";
+import { join as join15 } 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 || join14(homedir10(), "AppData", "Local");
-    return join14(base2, "aft");
+    const base2 = localAppData || join15(homedir11(), "AppData", "Local");
+    return join15(base2, "aft");
   }
-  const base = process.env.XDG_CACHE_HOME || join14(homedir10(), ".cache");
-  return join14(base, "aft");
+  const base = process.env.XDG_CACHE_HOME || join15(homedir11(), ".cache");
+  return join15(base, "aft");
 }
 function lspCacheRoot() {
-  return join14(aftCacheBase(), "lsp-packages");
+  return join15(aftCacheBase(), "lsp-packages");
 }
 function lspPackageDir(npmPackage) {
-  return join14(lspCacheRoot(), encodeURIComponent(npmPackage));
+  return join15(lspCacheRoot(), encodeURIComponent(npmPackage));
 }
 function lspBinaryPath(npmPackage, binary) {
-  return join14(lspPackageDir(npmPackage), "node_modules", ".bin", binary);
+  return join15(lspPackageDir(npmPackage), "node_modules", ".bin", binary);
 }
 function lspBinDir(npmPackage) {
-  return join14(lspPackageDir(npmPackage), "node_modules", ".bin");
+  return join15(lspPackageDir(npmPackage), "node_modules", ".bin");
 }
 function isInstalled(npmPackage, binary) {
   for (const candidate of lspBinaryCandidates(binary)) {
     try {
-      if (statSync5(join14(lspBinDir(npmPackage), candidate)).isFile())
+      if (statSync5(join15(lspBinDir(npmPackage), candidate)).isFile())
         return true;
     } catch {}
   }
@@ -31463,17 +31747,17 @@ function writeInstalledMetaIn(installDir, version2, sha256) {
       installedAt: new Date().toISOString(),
       ...sha256 ? { sha256 } : {}
     };
-    writeFileSync7(join14(installDir, INSTALLED_META_FILE), JSON.stringify(meta3), "utf8");
+    writeFileSync7(join15(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 = join14(installDir, INSTALLED_META_FILE);
+  const path3 = join15(installDir, INSTALLED_META_FILE);
   try {
-    if (!statSync5(path2).isFile())
+    if (!statSync5(path3).isFile())
       return null;
-    const raw = readFileSync9(path2, "utf8");
+    const raw = readFileSync9(path3, "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.version !== "string" || parsed.version.length === 0)
       return null;
@@ -31493,7 +31777,7 @@ function readInstalledMeta(packageKey) {
   return readInstalledMetaIn(lspPackageDir(packageKey));
 }
 function lockPath(npmPackage) {
-  return join14(lspPackageDir(npmPackage), ".aft-installing");
+  return join15(lspPackageDir(npmPackage), ".aft-installing");
 }
 var STALE_LOCK_MS2 = 30 * 60 * 1000;
 function acquireInstallLock(lockKey) {
@@ -31600,7 +31884,7 @@ async function withInstallLock(lockKey, task) {
 }
 var VERSION_CHECK_FILE = ".aft-version-check";
 function readVersionCheck(npmPackage) {
-  const file2 = join14(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
+  const file2 = join15(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
   try {
     const raw = readFileSync9(file2, "utf8");
     const parsed = JSON.parse(raw);
@@ -31617,7 +31901,7 @@ function readVersionCheck(npmPackage) {
 }
 function writeVersionCheck(npmPackage, latest) {
   mkdirSync7(lspPackageDir(npmPackage), { recursive: true });
-  const file2 = join14(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
+  const file2 = join15(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
   const record2 = {
     last_checked: new Date().toISOString(),
     latest_eligible: latest
@@ -31780,7 +32064,7 @@ var NPM_LSP_TABLE = [
 
 // src/lsp-project-relevance.ts
 import { existsSync as existsSync11, readdirSync as readdirSync3, readFileSync as readFileSync10 } from "node:fs";
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 var MAX_WALK_DIRS = 200;
 var MAX_WALK_DEPTH = 4;
 var NOISE_DIRS = new Set([
@@ -31797,7 +32081,7 @@ function hasRootMarker(projectRoot, rootMarkers) {
   if (!rootMarkers)
     return false;
   for (const marker of rootMarkers) {
-    if (existsSync11(join15(projectRoot, marker)))
+    if (existsSync11(join16(projectRoot, marker)))
       return true;
   }
   return false;
@@ -31821,7 +32105,7 @@ function hasPackageJsonDep(projectRoot, depNames) {
 }
 function readPackageJson(projectRoot) {
   try {
-    const raw = readFileSync10(join15(projectRoot, "package.json"), "utf8");
+    const raw = readFileSync10(join16(projectRoot, "package.json"), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null)
       return null;
@@ -31851,7 +32135,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: join15(current.dir, entry.name), depth: current.depth + 1 });
+          queue.push({ dir: join16(current.dir, entry.name), depth: current.depth + 1 });
         }
         continue;
       }
@@ -31978,7 +32262,7 @@ async function resolveTargetVersion(spec, config2, fetchImpl = fetch) {
 }
 function ensureInstallAnchor(cwd) {
   try {
-    const stub = join16(cwd, "package.json");
+    const stub = join17(cwd, "package.json");
     if (!existsSync12(stub)) {
       writeFileSync8(stub, `${JSON.stringify({ name: "aft-lsp-cache", version: "0.0.0", private: true })}
 `);
@@ -31988,18 +32272,18 @@ function ensureInstallAnchor(cwd) {
   }
 }
 function runInstall(spec, version2, cwd, signal) {
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     const target = `${spec.npm}@${version2}`;
     log2(`[lsp] installing ${target} to ${cwd}`);
     if (signal?.aborted) {
       warn2(`[lsp] install ${target} aborted before spawn`);
-      resolve3(false);
+      resolve4(false);
       return;
     }
     const npm = resolveNpm();
     if (!npm) {
       warn2(`[lsp] npm not found on PATH or known locations; cannot install ${target}`);
-      resolve3(false);
+      resolve4(false);
       return;
     }
     ensureInstallAnchor(cwd);
@@ -32022,7 +32306,7 @@ function runInstall(spec, version2, cwd, signal) {
         return;
       settled = true;
       cleanup();
-      resolve3(ok);
+      resolve4(ok);
     };
     const onAbort = () => {
       warn2(`[lsp] install ${target} aborted during shutdown`);
@@ -32123,7 +32407,7 @@ function cachedPackageDir(npmPackage) {
   return lspBinDir(npmPackage).replace(/[\\/]node_modules[\\/]\.bin[\\/]?$/, "");
 }
 function hashInstalledBinary(spec) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const candidates = process.platform === "win32" ? [
       lspBinaryPath(spec.npm, spec.binary),
       lspBinaryPath(spec.npm, `${spec.binary}.cmd`),
@@ -32147,7 +32431,7 @@ function hashInstalledBinary(spec) {
     const stream = createReadStream(pathToHash);
     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 installedBinaryPath(spec) {
@@ -32165,15 +32449,15 @@ function installedBinaryPath(spec) {
   }
   return null;
 }
-function sha256OfFileSync(path2) {
-  return createHash4("sha256").update(readFileSync11(path2)).digest("hex");
+function sha256OfFileSync(path3) {
+  return createHash4("sha256").update(readFileSync11(path3)).digest("hex");
 }
 function quarantineCachedNpmInstall(spec, reason) {
   const packageDir = lspPackageDir(spec.npm);
-  const dest = join16(packageDir, "..", ".quarantine", encodeURIComponent(spec.npm), `${Date.now()}`);
+  const dest = join17(packageDir, "..", ".quarantine", encodeURIComponent(spec.npm), `${Date.now()}`);
   warn2(`[lsp] tofu_mismatch ${spec.npm}: ${reason}; quarantining ${packageDir} -> ${dest}`);
   try {
-    mkdirSync8(join16(dest, ".."), { recursive: true });
+    mkdirSync8(join17(dest, ".."), { recursive: true });
     rmSync5(dest, { recursive: true, force: true });
     renameSync6(packageDir, dest);
   } catch (err) {
@@ -32269,7 +32553,7 @@ import {
   unlinkSync as unlinkSync6,
   writeFileSync as writeFileSync9
 } from "node:fs";
-import { dirname as dirname8, join as join17, relative as relative2, resolve as resolve3 } from "node:path";
+import { dirname as dirname8, join as join18, relative as relative3, resolve as resolve4 } from "node:path";
 import { Readable as Readable3 } from "node:stream";
 import { pipeline as pipeline3 } from "node:stream/promises";
 
@@ -32359,26 +32643,26 @@ function detectHostPlatform() {
 
 // src/lsp-github-install.ts
 function ghCacheRoot() {
-  return join17(aftCacheBase(), "lsp-binaries");
+  return join18(aftCacheBase(), "lsp-binaries");
 }
 function ghPackageDir(spec) {
-  return join17(ghCacheRoot(), spec.id);
+  return join18(ghCacheRoot(), spec.id);
 }
 function ghBinDir(spec) {
-  return join17(ghPackageDir(spec), "bin");
+  return join18(ghPackageDir(spec), "bin");
 }
 function ghExtractDir(spec) {
-  return join17(ghPackageDir(spec), "extracted");
+  return join18(ghPackageDir(spec), "extracted");
 }
 var INSTALLED_META_FILE2 = ".aft-installed";
 function ghBinaryPath(spec, platform3) {
   const ext = platform3 === "win32" ? ".exe" : "";
-  return join17(ghBinDir(spec), `${spec.binary}${ext}`);
+  return join18(ghBinDir(spec), `${spec.binary}${ext}`);
 }
 function isGithubInstalled(spec, platform3) {
   for (const candidate of ghBinaryCandidates(spec, platform3)) {
     try {
-      if (statSync7(join17(ghBinDir(spec), candidate)).isFile())
+      if (statSync7(join18(ghBinDir(spec), candidate)).isFile())
         return true;
     } catch {}
   }
@@ -32391,10 +32675,10 @@ function ghBinaryCandidates(spec, platform3) {
 }
 function readGithubInstalledMetaIn(installDir) {
   try {
-    const path2 = join17(installDir, INSTALLED_META_FILE2);
-    if (!statSync7(path2).isFile())
+    const path3 = join18(installDir, INSTALLED_META_FILE2);
+    if (!statSync7(path3).isFile())
       return null;
-    const parsed = JSON.parse(readFileSync12(path2, "utf8"));
+    const parsed = JSON.parse(readFileSync12(path3, "utf8"));
     if (typeof parsed.version !== "string" || parsed.version.length === 0)
       return null;
     return {
@@ -32418,24 +32702,24 @@ function writeGithubInstalledMetaIn(installDir, version2, binarySha256, archiveS
       binarySha256,
       ...archiveSha256 ? { archiveSha256 } : {}
     };
-    writeFileSync9(join17(installDir, INSTALLED_META_FILE2), JSON.stringify(meta3), "utf8");
+    writeFileSync9(join18(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((resolve4, reject) => {
+function sha256OfFile(path3) {
+  return new Promise((resolve5, reject) => {
     const hash2 = createHash5("sha256");
-    const stream = createReadStream2(path2);
+    const stream = createReadStream2(path3);
     stream.on("error", reject);
     stream.on("data", (chunk) => hash2.update(chunk));
-    stream.on("end", () => resolve4(hash2.digest("hex")));
+    stream.on("end", () => resolve5(hash2.digest("hex")));
   });
 }
-function sha256OfFileSync2(path2) {
-  return createHash5("sha256").update(readFileSync12(path2)).digest("hex");
+function sha256OfFileSync2(path3) {
+  return createHash5("sha256").update(readFileSync12(path3)).digest("hex");
 }
 async function fetchReleaseByTag(githubRepo, tag, fetchImpl, signal) {
   const candidates = [];
@@ -32667,7 +32951,7 @@ function validateExtraction(stagingRoot) {
       throw new Error(`failed to read staging dir ${dir}: ${err}`);
     }
     for (const entry of entries) {
-      const full = join17(dir, entry);
+      const full = join18(dir, entry);
       let lst;
       try {
         lst = lstatSync2(full);
@@ -32679,7 +32963,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 {
@@ -32687,8 +32971,8 @@ function validateExtraction(stagingRoot) {
       } catch (err) {
         throw new Error(`failed to realpath ${full}: ${err}`);
       }
-      const rel = relative2(realStagingRoot, realFull);
-      if (rel.startsWith("..") || resolve3(realStagingRoot, rel) !== realFull) {
+      const rel = relative3(realStagingRoot, realFull);
+      if (rel.startsWith("..") || resolve4(realStagingRoot, rel) !== realFull) {
         throw new Error(`archive entry escapes staging root: ${full} → ${realFull} (zip-slip defense)`);
       }
       if (lst.isDirectory()) {
@@ -32755,7 +33039,7 @@ function extractArchiveSafely(archivePath, destDir, archiveType) {
 }
 function quarantineCachedGithubInstall(spec, reason) {
   const packageDir = ghPackageDir(spec);
-  const dest = join17(ghCacheRoot(), ".quarantine", encodeURIComponent(spec.id), `${Date.now()}`);
+  const dest = join18(ghCacheRoot(), ".quarantine", encodeURIComponent(spec.id), `${Date.now()}`);
   warn2(`[lsp] tofu_mismatch ${spec.id}: ${reason}; quarantining ${packageDir} -> ${dest}`);
   try {
     mkdirSync9(dirname8(dest), { recursive: true });
@@ -32768,7 +33052,7 @@ function quarantineCachedGithubInstall(spec, reason) {
 function validateCachedGithubInstall(spec, platform3) {
   const packageDir = ghPackageDir(spec);
   const meta3 = readGithubInstalledMetaIn(packageDir);
-  const binaryPath = ghBinaryCandidates(spec, platform3).map((candidate) => join17(ghBinDir(spec), candidate)).find((candidate) => {
+  const binaryPath = ghBinaryCandidates(spec, platform3).map((candidate) => join18(ghBinDir(spec), candidate)).find((candidate) => {
     try {
       return statSync7(candidate).isFile();
     } catch {
@@ -32846,7 +33130,7 @@ async function downloadAndInstall(spec, tag, assets, platform3, arch, fetchImpl,
   }
   const pkgDir = ghPackageDir(spec);
   const extractDir = ghExtractDir(spec);
-  const archivePath = join17(pkgDir, expected.name);
+  const archivePath = join18(pkgDir, expected.name);
   log2(`[lsp] downloading ${spec.id} ${tag} → ${matchingAsset.url}`);
   try {
     await downloadFile(matchingAsset.url, archivePath, fetchImpl, matchingAsset.size, signal);
@@ -32886,7 +33170,7 @@ async function downloadAndInstall(spec, tag, assets, platform3, arch, fetchImpl,
       unlinkSync6(archivePath);
     } catch {}
   }
-  const innerBinaryPath = join17(extractDir, spec.binaryPathInArchive(platform3, arch, version2));
+  const innerBinaryPath = join18(extractDir, spec.binaryPathInArchive(platform3, arch, version2));
   if (!existsSync13(innerBinaryPath)) {
     error2(`[lsp] ${spec.id}: extracted binary not found at ${innerBinaryPath}`);
     return null;
@@ -33181,7 +33465,7 @@ function renderScreen(state, rows = state.rows, cols = state.cols) {
 `);
 }
 function writeTerminal(terminal, data) {
-  return new Promise((resolve4) => terminal.write(data, resolve4));
+  return new Promise((resolve5) => terminal.write(data, resolve5));
 }
 
 // src/shared/rpc-server.ts
@@ -33196,18 +33480,18 @@ import {
   writeFileSync as writeFileSync10
 } from "node:fs";
 import { createServer } from "node:http";
-import { dirname as dirname9, join as join19 } from "node:path";
+import { dirname as dirname9, join as join20 } from "node:path";
 
 // src/shared/rpc-utils.ts
 import { createHash as createHash6 } from "node:crypto";
-import { join as join18 } from "node:path";
+import { join as join19 } from "node:path";
 function projectHash(directory) {
   const normalized = directory.replace(/\/+$/, "");
   return createHash6("sha256").update(normalized).digest("hex").slice(0, 16);
 }
 function rpcPortFileDir(storageDir, directory) {
   const hash2 = projectHash(directory);
-  return join18(storageDir, "rpc", hash2, "ports");
+  return join19(storageDir, "rpc", hash2, "ports");
 }
 function isPidAlive(pid) {
   if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0)
@@ -33260,13 +33544,13 @@ class AftRpcServer {
   constructor(storageDir, directory) {
     this.portsDir = rpcPortFileDir(storageDir, directory);
     this.instanceId = randomBytes2(8).toString("hex");
-    this.portFilePath = join19(this.portsDir, `${this.instanceId}.json`);
+    this.portFilePath = join20(this.portsDir, `${this.instanceId}.json`);
   }
   handle(method, handler) {
     this.handlers.set(method, handler);
   }
   async start() {
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       const server = createServer((req, res) => this.dispatch(req, res));
       server.on("error", (err) => {
         warn2(`RPC server error: ${err.message}`);
@@ -33299,7 +33583,7 @@ class AftRpcServer {
         } catch (err) {
           warn2(`Failed to write RPC port file: ${err}`);
         }
-        resolve4(this.port);
+        resolve5(this.port);
       });
       server.unref();
     });
@@ -33314,7 +33598,7 @@ class AftRpcServer {
     for (const entry of entries) {
       if (!entry.endsWith(".json"))
         continue;
-      const filePath = join19(this.portsDir, entry);
+      const filePath = join20(this.portsDir, entry);
       if (filePath === this.portFilePath)
         continue;
       try {
@@ -33719,20 +34003,20 @@ function formatStatusMarkdown(status) {
 // src/shared/tui-config.ts
 var import_comment_json4 = __toESM(require_src2(), 1);
 import { existsSync as existsSync15, mkdirSync as mkdirSync11, readFileSync as readFileSync14, writeFileSync as writeFileSync11 } from "node:fs";
-import { dirname as dirname10, join as join21 } from "node:path";
+import { dirname as dirname10, join as join22 } from "node:path";
 
 // src/shared/opencode-config-dir.ts
-import { homedir as homedir11 } from "node:os";
-import { join as join20, resolve as resolve4 } from "node:path";
+import { homedir as homedir12 } from "node:os";
+import { join as join21, resolve as resolve5 } from "node:path";
 function getCliConfigDir() {
   const envConfigDir = process.env.OPENCODE_CONFIG_DIR?.trim();
   if (envConfigDir) {
-    return resolve4(envConfigDir);
+    return resolve5(envConfigDir);
   }
   if (process.platform === "win32") {
-    return join20(homedir11(), ".config", "opencode");
+    return join21(homedir12(), ".config", "opencode");
   }
-  return join20(process.env.XDG_CONFIG_HOME || join20(homedir11(), ".config"), "opencode");
+  return join21(process.env.XDG_CONFIG_HOME || join21(homedir12(), ".config"), "opencode");
 }
 function getOpenCodeConfigDir2(_options) {
   return getCliConfigDir();
@@ -33741,10 +34025,10 @@ function getOpenCodeConfigPaths(options) {
   const configDir = getOpenCodeConfigDir2(options);
   return {
     configDir,
-    configJson: join20(configDir, "opencode.json"),
-    configJsonc: join20(configDir, "opencode.jsonc"),
-    packageJson: join20(configDir, "package.json"),
-    omoConfig: join20(configDir, "magic-context.jsonc")
+    configJson: join21(configDir, "opencode.json"),
+    configJsonc: join21(configDir, "opencode.jsonc"),
+    packageJson: join21(configDir, "package.json"),
+    omoConfig: join21(configDir, "magic-context.jsonc")
   };
 }
 
@@ -33753,8 +34037,8 @@ var PLUGIN_NAME = "@cortexkit/aft-opencode";
 var PLUGIN_ENTRY = `${PLUGIN_NAME}@latest`;
 function resolveTuiConfigPath() {
   const configDir = getOpenCodeConfigPaths({ binary: "opencode" }).configDir;
-  const jsoncPath = join21(configDir, "tui.jsonc");
-  const jsonPath = join21(configDir, "tui.json");
+  const jsoncPath = join22(configDir, "tui.jsonc");
+  const jsonPath = join22(configDir, "tui.json");
   if (existsSync15(jsoncPath))
     return jsoncPath;
   if (existsSync15(jsonPath))
@@ -33843,8 +34127,8 @@ function installProcessHandlers() {
       }
       signalShutdownStarted = true;
       process.exitCode = SIGNAL_EXIT_CODES[sig];
-      const timeout = new Promise((resolve5) => {
-        setTimeout(resolve5, SIGNAL_CLEANUP_TIMEOUT_MS);
+      const timeout = new Promise((resolve6) => {
+        setTimeout(resolve6, SIGNAL_CLEANUP_TIMEOUT_MS);
       });
       Promise.race([runCleanups(sig), timeout]).finally(() => {
         process.exit(SIGNAL_EXIT_CODES[sig]);
@@ -33956,99 +34240,18 @@ import { tool as tool3 } from "@opencode-ai/plugin";
 
 // src/tools/_shared.ts
 import * as fs3 from "node:fs";
-import * as os2 from "node:os";
-import * as path2 from "node:path";
+import * as os3 from "node:os";
+import * as path3 from "node:path";
 import { tool as tool2 } from "@opencode-ai/plugin";
 var z2 = tool2.schema;
 var optionalInt = (min, max) => z2.number().int().min(min).max(max).optional();
-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;
-}
 var BASH_TRANSPORT_TIMEOUT_MS = 30000;
-function asPlainObject(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    return;
-  return value;
-}
-function candidateLocation(candidate) {
-  const file2 = typeof candidate.file === "string" && candidate.file.length > 0 ? candidate.file : undefined;
-  if (!file2)
-    return;
-  const line = typeof candidate.line === "number" && Number.isFinite(candidate.line) ? candidate.line : undefined;
-  return line === undefined ? file2 : `${file2}:${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 symbol2 = typeof params.toSymbol === "string" && params.toSymbol.length > 0 ? params.toSymbol : rawSymbol;
-      const target = symbol2 ? `multiple symbols named "${symbol2}"` : 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 canonicalizeDirectory(dir) {
   const trimmed = dir.replace(/[/\\]+$/, "");
   try {
     return fs3.realpathSync(trimmed);
   } catch {
-    return path2.resolve(trimmed);
+    return path3.resolve(trimmed);
   }
 }
 function projectRootFor(runtime) {
@@ -34065,19 +34268,19 @@ async function resolveProjectRoot(ctx, runtime) {
   }
   return projectRootFor(runtime);
 }
-function expandTilde(input) {
+function expandTilde2(input) {
   if (!input || !input.startsWith("~"))
     return input;
   if (input === "~")
-    return os2.homedir();
-  if (input.startsWith("~/") || input.startsWith(`~${path2.sep}`)) {
-    return path2.resolve(os2.homedir(), input.slice(2));
+    return os3.homedir();
+  if (input.startsWith("~/") || input.startsWith(`~${path3.sep}`)) {
+    return path3.resolve(os3.homedir(), input.slice(2));
   }
   return input;
 }
 function resolvePathFromProjectRoot(projectRoot, target) {
-  const expanded = expandTilde(target);
-  return path2.isAbsolute(expanded) ? expanded : path2.resolve(projectRoot, expanded);
+  const expanded = expandTilde2(target);
+  return path3.isAbsolute(expanded) ? expanded : path3.resolve(projectRoot, expanded);
 }
 async function resolvePathArg(ctx, runtime, target) {
   return resolvePathFromProjectRoot(await resolveProjectRoot(ctx, runtime), target);
@@ -34119,19 +34322,19 @@ async function callBashBridge(ctx, runtime, command, params = {}, options) {
 
 // src/tools/permissions.ts
 import * as fs4 from "node:fs";
-import * as path3 from "node:path";
+import * as path4 from "node:path";
 var UNSUPPORTED_ASK_HOST = "AFT requires OpenCode 1.15.5 or newer for permission asks; please upgrade OpenCode";
 async function runAsk(maybe) {
   await maybe;
 }
 function resolveAbsolutePath(context, target) {
-  return path3.isAbsolute(target) ? target : path3.resolve(projectRootFor(context), target);
+  return path4.isAbsolute(target) ? target : path4.resolve(projectRootFor(context), target);
 }
 function resolveRelativePattern(context, target) {
-  return path3.relative(projectRootFor(context), resolveAbsolutePath(context, target)) || ".";
+  return path4.relative(projectRootFor(context), resolveAbsolutePath(context, target)) || ".";
 }
 function resolveRelativePatternFromAbsolute(context, absolutePath) {
-  return path3.relative(projectRootFor(context), absolutePath) || ".";
+  return path4.relative(projectRootFor(context), absolutePath) || ".";
 }
 function resolveRelativePatterns(context, targets) {
   const seen = new Set;
@@ -34171,8 +34374,8 @@ async function askEditPermission(context, patterns, metadata = {}) {
 function containsPath(parent, child) {
   if (!parent)
     return false;
-  const rel = path3.relative(parent, child);
-  return rel === "" || !rel.startsWith("..") && !path3.isAbsolute(rel);
+  const rel = path4.relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !path4.isAbsolute(rel);
 }
 function windowsPath(p) {
   if (process.platform !== "win32")
@@ -34182,7 +34385,7 @@ function windowsPath(p) {
 function normalizePath(p) {
   if (process.platform !== "win32")
     return p;
-  const resolved = path3.resolve(windowsPath(p));
+  const resolved = path4.resolve(windowsPath(p));
   try {
     return fs4.realpathSync.native(resolved);
   } catch {
@@ -34198,7 +34401,7 @@ function normalizePathPattern(p) {
   if (!match)
     return normalizePath(p);
   const dir = /^[A-Za-z]:$/.test(match[1]) ? `${match[1]}\\` : match[1];
-  return path3.join(normalizePath(dir), match[2]);
+  return path4.join(normalizePath(dir), match[2]);
 }
 async function assertExternalDirectoryPermission(context, target, options) {
   if (!target)
@@ -34217,8 +34420,8 @@ async function assertExternalDirectoryPermission(context, target, options) {
     return;
   }
   const kind = options?.kind ?? "file";
-  const parentDir = kind === "directory" ? absoluteTarget : path3.dirname(absoluteTarget);
-  const rawGlob = process.platform === "win32" ? normalizePathPattern(path3.join(parentDir, "*")) : path3.join(parentDir, "*").replaceAll("\\", "/");
+  const parentDir = kind === "directory" ? absoluteTarget : path4.dirname(absoluteTarget);
+  const rawGlob = process.platform === "win32" ? normalizePathPattern(path4.join(parentDir, "*")) : path4.join(parentDir, "*").replaceAll("\\", "/");
   try {
     await runAsk(context.ask({
       permission: "external_directory",
@@ -34292,6 +34495,20 @@ function extractHint(response) {
   const hint = response.hint;
   return typeof hint === "string" && hint.length > 0 ? hint : null;
 }
+function appendSkippedFiles(output, skippedFiles) {
+  if (!skippedFiles || skippedFiles.length === 0)
+    return output;
+  const lines = skippedFiles.map((skipped) => {
+    const file2 = skipped.file ?? "unknown";
+    const reason = skipped.reason ?? "unknown reason";
+    return `  ${file2}: ${reason}`;
+  });
+  return `${output}
+
+Incomplete: skipped ${skippedFiles.length} file(s)
+${lines.join(`
+`)}`;
+}
 async function resolveAstPaths(ctx, context, paths) {
   if (isEmptyParam(paths) || !Array.isArray(paths))
     return;
@@ -34316,17 +34533,18 @@ var SUPPORTED_LANGS = [
   "python",
   "rust",
   "go",
-  "pascal"
+  "pascal",
+  "r"
 ];
 function astTools(ctx) {
   const searchTool = {
-    description: `Search code patterns across filesystem using AST-aware matching. Supports 7 languages.
+    description: `Search code patterns across filesystem using AST-aware matching. Supports 8 languages.
 
 ` + `Use meta-variables: $VAR matches a single AST node, $$$ matches multiple nodes (variadic).
 ` + `IMPORTANT: Patterns must be complete AST nodes (valid code fragments).
 ` + `For functions, include params and body: 'export async function $NAME($$$) { $$$ }' not just 'export async function $NAME'.
 
-` + "Examples: pattern='console.log($MSG)' lang='typescript', pattern='async function $NAME($$$) { $$$ }' lang='javascript', pattern='def $FUNC($$$): $$$' lang='python', pattern='Writeln($MSG);' lang='pascal'",
+` + "Examples: pattern='console.log($MSG)' lang='typescript', pattern='async function $NAME($$$) { $$$ }' lang='javascript', pattern='def $FUNC($$$): $$$' lang='python', pattern='Writeln($MSG);' lang='pascal', pattern='$X <- $Y' lang='r'",
     args: {
       pattern: z3.string().describe("AST pattern with meta-variables ($VAR, $$$). Must be complete AST node."),
       lang: z3.enum(SUPPORTED_LANGS).describe("Target language"),
@@ -34407,6 +34625,9 @@ ${hint}`;
           }
         }
       }
+      if (data.complete === false || (data.skipped_files?.length ?? 0) > 0) {
+        output = appendSkippedFiles(output, data.skipped_files);
+      }
       showOutputToUser(context, output);
       return output;
     }
@@ -34750,7 +34971,7 @@ function createBashTool(ctx, aftSearchRegisteredOverride) {
             throw new Error(status.message ?? "bash_status failed");
           }
           if (isTerminalStatus(status.status)) {
-            const rendered2 = maybeAppendGrepSearchHint(appendPipeStripNote(formatForegroundResult(status), pipeStrip.note), command, aftSearchRegistered);
+            const rendered2 = maybeAppendGrepSearchHint(appendPipeStripNote(formatForegroundResult(status), pipeStrip.note), command, aftSearchRegistered, projectRootFor(context));
             const metadataPayload2 = foregroundMetadata(description, status, rendered2);
             metadata?.(metadataPayload2);
             return { output: rendered2, title: uiTitle, metadata: metadataPayload2 };
@@ -34814,11 +35035,6 @@ function createBashTool(ctx, aftSearchRegisteredOverride) {
     }
   };
 }
-function appendPipeStripNote(output, note) {
-  return note ? `${output}
-
-${note}` : output;
-}
 function createBashStatusTool(ctx) {
   return {
     description: "Read-only snapshot of a background or PTY bash task's current state and output. Returns immediately. Never waits. Use bash_watch to block on or register for pattern matches and exit events.",
@@ -34923,9 +35139,6 @@ function ptyCacheKey(runtime, taskId) {
 function preview(output) {
   return output.length <= METADATA_PREVIEW_LIMIT ? output : output.slice(-METADATA_PREVIEW_LIMIT);
 }
-function isTerminalStatus(status) {
-  return status === "completed" || status === "failed" || status === "killed" || status === "timed_out";
-}
 function subagentGuidance(taskId) {
   return `
 
@@ -34941,30 +35154,6 @@ 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({ taskId: "${taskId}" }) to inspect output or bash_kill({ taskId: "${taskId}" }) to terminate.`;
 }
-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 foregroundMetadata(description, data, rendered) {
   const outputPath = data.output_path;
   return {
@@ -34975,9 +35164,6 @@ function foregroundMetadata(description, data, rendered) {
     ...outputPath ? { outputPath } : {}
   };
 }
-function sleep(ms) {
-  return new Promise((resolve7) => setTimeout(resolve7, ms));
-}
 function getCallID(ctx) {
   const c = ctx;
   return c.callID ?? c.callId ?? c.call_id;
@@ -35000,7 +35186,7 @@ function conflictTools(ctx) {
       execute: async (args, context) => {
         const params = {};
         if (!isEmptyParam(args?.path)) {
-          const expanded = expandTilde(String(args.path));
+          const expanded = expandTilde2(String(args.path));
           const projectRoot = await resolveProjectRoot(ctx, context);
           const resolved = resolvePathFromProjectRoot(projectRoot, expanded);
           const denied = await assertExternalDirectoryPermission(context, resolved, {
@@ -35022,7 +35208,7 @@ function conflictTools(ctx) {
 
 // src/tools/hoisted.ts
 import * as fs6 from "node:fs";
-import * as path4 from "node:path";
+import * as path5 from "node:path";
 import { tool as tool8 } from "@opencode-ai/plugin";
 
 // src/patch-parser.ts
@@ -35462,13 +35648,16 @@ async function waitForBashStatus(ctx, runtime, taskId, outputMode, waitFor, effe
   let scanText = "";
   let scanBaseOffset = 0;
   const bridgeOptions = {};
+  if (waitFor?.kind === "regex") {
+    await validateWaitRegex(ctx, runtime, waitFor);
+  }
   clearSyncWatchAbort(runtime.sessionID);
   markTaskWaiting(runtime.sessionID, taskId);
   let sawTerminal = false;
   try {
     while (true) {
       const data = await bashStatusSnapshot2(ctx, runtime, taskId, outputMode, bridgeOptions);
-      const terminal = isTerminalStatus2(data.status);
+      const terminal = isTerminalStatus(data.status);
       if (waitFor) {
         const scan = await readNewTaskOutput(runtime, taskId, data, spillCursor);
         if (scan) {
@@ -35476,7 +35665,12 @@ async function waitForBashStatus(ctx, runtime, taskId, outputMode, waitFor, effe
           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(ctx, runtime, scanText, waitFor);
           if (match) {
             if (terminal) {
               sawTerminal = true;
@@ -35487,12 +35681,14 @@ async function waitForBashStatus(ctx, runtime, taskId, outputMode, waitFor, effe
               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
             });
           }
-          const trimmed = trimWaitScanBuffer(scanText, scanBaseOffset, waitFor);
-          scanText = trimmed.text;
-          scanBaseOffset = trimmed.baseOffset;
+          if (waitFor.kind === "substring") {
+            const trimmed = trimWaitScanBuffer(scanText, scanBaseOffset, waitFor);
+            scanText = trimmed.text;
+            scanBaseOffset = trimmed.baseOffset;
+          }
         }
       }
       if (terminal) {
@@ -35507,7 +35703,7 @@ async function waitForBashStatus(ctx, runtime, taskId, outputMode, waitFor, effe
       if (Date.now() >= deadline) {
         return withWaited(data, { reason: "timeout", elapsed_ms: Date.now() - startedAt });
       }
-      await sleep2(Math.min(BASH_WAIT_POLL_INTERVAL_MS, Math.max(0, deadline - Date.now())));
+      await sleep(Math.min(BASH_WAIT_POLL_INTERVAL_MS, Math.max(0, deadline - Date.now())));
     }
   } finally {
     if (!sawTerminal)
@@ -35573,20 +35769,41 @@ 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(ctx, runtime, pattern) {
+  await matchRegexWithBridge(ctx, runtime, pattern.source, "");
+}
+async function findWaitMatch(ctx, runtime, 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;
   }
-  pattern.value.lastIndex = 0;
-  const match = pattern.value.exec(text);
-  return match ? { text: match[0], index: match.index } : undefined;
+  return await matchRegexWithBridge(ctx, runtime, pattern.source, text);
+}
+async function matchRegexWithBridge(ctx, runtime, pattern, text) {
+  const result = await callBashBridge(ctx, runtime, "bash_regex_match", { pattern, text });
+  if (result.success === false) {
+    const code = String(result.code ?? "invalid_request");
+    const message = String(result.message ?? "bash_regex_match failed");
+    if (code === "invalid_regex")
+      throw new Error(`invalid_request: invalid_regex: ${message}`);
+    throw new Error(`${code}: ${message}`);
+  }
+  if (result.matched !== true)
+    return;
+  return {
+    text: typeof result.match_text === "string" ? result.match_text : "",
+    byteOffset: coerceMatchOffset(result.match_offset)
+  };
+}
+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);
@@ -35619,18 +35836,12 @@ function regexKeepStart(text, maxBytes) {
 function withWaited(data, waited) {
   return { ...data, waited };
 }
-function isTerminalStatus2(status) {
-  return status === "completed" || status === "failed" || status === "killed" || status === "timed_out";
-}
 function ptyCacheKey2(runtime, taskId) {
   return `${projectRootFor(runtime)}::${runtime.sessionID ?? "__default__"}::${taskId}`;
 }
 function watchPtyCacheKey(runtime, taskId) {
   return `${ptyCacheKey2(runtime, taskId)}::watch`;
 }
-function sleep2(ms) {
-  return new Promise((resolve7) => setTimeout(resolve7, ms));
-}
 
 // src/tools/bash_write.ts
 import { tool as tool7 } from "@opencode-ai/plugin";
@@ -35665,21 +35876,10 @@ function createBashWriteTool(ctx) {
 
 // src/tools/hoisted.ts
 function relativeToWorktree(fp, worktree) {
-  return path4.relative(worktree, fp);
+  return path5.relative(worktree, fp);
 }
-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 startLine/endLine to read other sections.)`;
+function formatReadFooter2(agentSpecifiedRange, data) {
+  return formatReadFooter(agentSpecifiedRange, data, { rangeHint: "startLine/endLine" });
 }
 function buildUnifiedDiff(fp, before, after) {
   const beforeLines = before.split(`
@@ -35872,6 +36072,91 @@ var z8 = tool8.schema;
 function diagnosticsOnEditDefault(ctx) {
   return ctx.config.lsp?.diagnostics_on_edit ?? false;
 }
+async function readCurrentFileForPreview(filePath) {
+  try {
+    return await fs6.promises.readFile(filePath, "utf-8");
+  } catch (error50) {
+    if (error50 && typeof error50 === "object" && "code" in error50 && error50.code === "ENOENT") {
+      return "";
+    }
+    throw error50;
+  }
+}
+function previewDiffFromResponse(data, filePath) {
+  const previewDiff = data.preview_diff;
+  if (typeof previewDiff === "string")
+    return previewDiff;
+  const diff = data.diff;
+  if (typeof diff?.before === "string" && typeof diff.after === "string") {
+    return buildUnifiedDiff(filePath, diff.before, diff.after);
+  }
+  return "";
+}
+function virtualPatchContent(virtualFiles, filePath) {
+  return virtualFiles.has(filePath) ? virtualFiles.get(filePath) ?? null : undefined;
+}
+async function readPatchPreviewContent(virtualFiles, filePath, action, patchPath) {
+  const virtualContent = virtualPatchContent(virtualFiles, filePath);
+  if (virtualContent !== undefined) {
+    if (virtualContent === null) {
+      throw new Error(`Failed to ${action} ${patchPath}: file not found: ${filePath}`);
+    }
+    return virtualContent;
+  }
+  try {
+    return await fs6.promises.readFile(filePath, "utf-8");
+  } catch (error50) {
+    throw new Error(`Failed to ${action} ${patchPath}: ${formatError2(error50)}`);
+  }
+}
+async function buildApplyPatchPreview(hunks, projectRoot) {
+  const virtualFiles = new Map;
+  const patches = [];
+  let firstFilePath = "";
+  for (const hunk of hunks) {
+    const filePath = resolvePathFromProjectRoot(projectRoot, hunk.path);
+    if (!firstFilePath)
+      firstFilePath = filePath;
+    switch (hunk.type) {
+      case "add": {
+        const virtualContent = virtualPatchContent(virtualFiles, filePath);
+        const exists = virtualContent !== undefined ? virtualContent !== null : fs6.existsSync(filePath);
+        if (exists) {
+          throw new Error(`Failed to create ${hunk.path}: file already exists. Use *** Update File: to modify, or *** Delete File: first if you want to replace it entirely.`);
+        }
+        const after = hunk.contents.endsWith(`
+`) ? hunk.contents : `${hunk.contents}
+`;
+        patches.push(buildUnifiedDiff(filePath, "", after));
+        virtualFiles.set(filePath, after);
+        break;
+      }
+      case "delete": {
+        const before = await readPatchPreviewContent(virtualFiles, filePath, "delete", hunk.path);
+        patches.push(buildUnifiedDiff(filePath, before, ""));
+        virtualFiles.set(filePath, null);
+        break;
+      }
+      case "update": {
+        const before = await readPatchPreviewContent(virtualFiles, filePath, "update", hunk.path);
+        let after;
+        try {
+          after = applyUpdateChunks(before, filePath, hunk.chunks);
+        } catch (error50) {
+          throw new Error(`Failed to update ${hunk.path}: ${formatError2(error50)}`);
+        }
+        const targetPath = hunk.move_path ? resolvePathFromProjectRoot(projectRoot, hunk.move_path) : filePath;
+        patches.push(buildUnifiedDiff(targetPath, before, after));
+        if (hunk.move_path)
+          virtualFiles.set(filePath, null);
+        virtualFiles.set(targetPath, after);
+        break;
+      }
+    }
+  }
+  return { filepath: firstFilePath || projectRoot, diff: patches.join(`
+`) };
+}
 var READ_DESCRIPTION = `Read file contents or list directory entries.
 
 Use either startLine/endLine OR offset/limit to read a section of a file.
@@ -35921,7 +36206,7 @@ function createReadTool(ctx) {
           return permissionDeniedResponse(error50.message);
         return permissionDeniedResponse("Permission denied.");
       }
-      const ext = path4.extname(filePath).toLowerCase();
+      const ext = path5.extname(filePath).toLowerCase();
       const mimeMap = {
         ".png": "image/png",
         ".jpg": "image/jpeg",
@@ -35950,7 +36235,7 @@ function createReadTool(ctx) {
         const msg = `${label} read successfully`;
         return {
           output: `${msg} (${ext.slice(1).toUpperCase()}, ${sizeStr}). File: ${filePath}`,
-          title: path4.relative(projectRoot, filePath),
+          title: path5.relative(projectRoot, filePath),
           metadata: {
             preview: msg,
             filepath: filePath,
@@ -35992,7 +36277,7 @@ function createReadTool(ctx) {
       }
       let output = data.content;
       const agentSpecifiedRange = args.startLine !== undefined || args.endLine !== undefined || args.offset !== undefined || args.limit !== undefined;
-      const footer = formatReadFooter(agentSpecifiedRange, data);
+      const footer = formatReadFooter2(agentSpecifiedRange, data);
       if (footer)
         output += footer;
       return { output, title: dp, metadata: { title: dp } };
@@ -36014,18 +36299,20 @@ function createWriteTool(ctx, editToolName = "edit") {
       const content = args.content;
       const projectRoot = await resolveProjectRoot(ctx, context);
       const filePath = resolvePathFromProjectRoot(projectRoot, file2);
-      const relPath = path4.relative(projectRoot, filePath);
+      const relPath = path5.relative(projectRoot, filePath);
       {
-        const denial = await assertExternalDirectoryPermission(context, filePath);
-        if (denial)
-          return permissionDeniedResponse(denial);
-      }
-      await runAsk(context.ask({
-        permission: "edit",
-        patterns: [relPath],
-        always: ["*"],
-        metadata: { filepath: filePath }
-      }));
+        const denial2 = await assertExternalDirectoryPermission(context, filePath);
+        if (denial2)
+          return permissionDeniedResponse(denial2);
+      }
+      const currentContent = await readCurrentFileForPreview(filePath);
+      const previewDiff = buildUnifiedDiff(filePath, currentContent, content);
+      const denial = await askEditPermission(context, [relPath], {
+        filepath: filePath,
+        diff: previewDiff
+      });
+      if (denial)
+        return permissionDeniedResponse(denial);
       const data = await callBridge(ctx, context, "write", {
         file: filePath,
         content,
@@ -36163,18 +36450,12 @@ function createEditTool(ctx, writeToolName = "write") {
         throw new Error("'filePath' parameter is required");
       const projectRoot = await resolveProjectRoot(ctx, context);
       const filePath = resolvePathFromProjectRoot(projectRoot, file2);
-      const relPath = path4.relative(projectRoot, filePath);
+      const relPath = path5.relative(projectRoot, filePath);
       {
-        const denial = await assertExternalDirectoryPermission(context, filePath);
-        if (denial)
-          return permissionDeniedResponse(denial);
+        const denial2 = await assertExternalDirectoryPermission(context, filePath);
+        if (denial2)
+          return permissionDeniedResponse(denial2);
       }
-      await runAsk(context.ask({
-        permission: "edit",
-        patterns: [relPath],
-        always: ["*"],
-        metadata: { filepath: filePath }
-      }));
       const params = { file: filePath };
       let command;
       if (typeof args.appendContent === "string") {
@@ -36217,6 +36498,21 @@ function createEditTool(ctx, writeToolName = "write") {
         const hint = typeof args.content === "string" ? ` To write the whole file, use the '${writeToolName}' tool. To edit existing content, provide 'oldString' (and optionally 'newString'), 'symbol' + 'content', or an 'edits' array.` : " Provide 'oldString' (+ optional 'newString'), 'symbol' + 'content', or an 'edits' array.";
         throw new Error(`edit: no edit mode resolved from arguments.${hint}`);
       }
+      const previewData = await callBridge(ctx, context, command, {
+        ...params,
+        preview: true,
+        include_diff_content: true
+      });
+      if (previewData.success === false) {
+        throw new Error(previewData.message || "edit preview failed");
+      }
+      const previewDiff = previewDiffFromResponse(previewData, filePath);
+      const denial = await askEditPermission(context, [relPath], {
+        filepath: filePath,
+        diff: previewDiff
+      });
+      if (denial)
+        return permissionDeniedResponse(denial);
       params.diagnostics = diagnosticsOnEditDefault(ctx);
       params.include_diff_content = true;
       const data = await callBridge(ctx, context, command, params);
@@ -36357,22 +36653,34 @@ function createApplyPatchTool(ctx) {
       }
       const projectRoot = await resolveProjectRoot(ctx, context);
       const affectedAbs = new Set;
+      const initiallyExistsAbs = new Map;
+      const rememberAffectedPath = (abs) => {
+        affectedAbs.add(abs);
+        if (!initiallyExistsAbs.has(abs)) {
+          initiallyExistsAbs.set(abs, fs6.existsSync(abs));
+        }
+      };
+      for (const h of hunks) {
+        const srcAbs = resolvePathFromProjectRoot(projectRoot, h.path);
+        rememberAffectedPath(srcAbs);
+        if (h.type === "update" && h.move_path) {
+          rememberAffectedPath(resolvePathFromProjectRoot(projectRoot, h.move_path));
+        }
+      }
       const newlyCreatedAbs = new Set;
       for (const h of hunks) {
         const srcAbs = resolvePathFromProjectRoot(projectRoot, h.path);
-        affectedAbs.add(srcAbs);
-        if (h.type === "add") {
+        if (h.type === "add" && initiallyExistsAbs.get(srcAbs) === false) {
           newlyCreatedAbs.add(srcAbs);
         }
         if (h.type === "update" && h.move_path) {
           const dstAbs = resolvePathFromProjectRoot(projectRoot, h.move_path);
-          affectedAbs.add(dstAbs);
-          if (!fs6.existsSync(dstAbs)) {
+          if (initiallyExistsAbs.get(dstAbs) === false) {
             newlyCreatedAbs.add(dstAbs);
           }
         }
       }
-      const relPaths = Array.from(affectedAbs).map((abs) => path4.relative(projectRoot, abs));
+      const relPaths = Array.from(affectedAbs).map((abs) => path5.relative(projectRoot, abs));
       const multiFileWritePaths = Array.from(affectedAbs);
       {
         const asked = new Set;
@@ -36380,17 +36688,18 @@ function createApplyPatchTool(ctx) {
           if (asked.has(filePath))
             continue;
           asked.add(filePath);
-          const denial = await assertExternalDirectoryPermission(context, filePath);
-          if (denial)
-            return permissionDeniedResponse(denial);
+          const denial2 = await assertExternalDirectoryPermission(context, filePath);
+          if (denial2)
+            return permissionDeniedResponse(denial2);
         }
       }
-      await runAsk(context.ask({
-        permission: "edit",
-        patterns: relPaths,
-        always: ["*"],
-        metadata: {}
-      }));
+      const preview2 = await buildApplyPatchPreview(hunks, projectRoot);
+      const denial = await askEditPermission(context, relPaths, {
+        filepath: preview2.filepath,
+        diff: preview2.diff
+      });
+      if (denial)
+        return permissionDeniedResponse(denial);
       const checkpointPaths = Array.from(affectedAbs).filter((abs) => !newlyCreatedAbs.has(abs));
       const checkpointName = `apply_patch_${Date.now()}`;
       let checkpointCreated = false;
@@ -36405,15 +36714,15 @@ function createApplyPatchTool(ctx) {
       }
       const results = [];
       const failures = [];
-      const perFileDiffs = [];
-      for (const hunk of hunks) {
+      const appliedHunkResults = [];
+      for (const [hunkIndex, hunk] of hunks.entries()) {
         const filePath = resolvePathFromProjectRoot(projectRoot, hunk.path);
         switch (hunk.type) {
           case "add": {
             if (fs6.existsSync(filePath)) {
               const msg = `Failed to create ${hunk.path}: file already exists. Use *** Update File: to modify, or *** Delete File: first if you want to replace it entirely.`;
               results.push(msg);
-              failures.push(hunk.path);
+              failures.push({ index: hunkIndex, path: hunk.path });
               break;
             }
             try {
@@ -36435,10 +36744,13 @@ function createApplyPatchTool(ctx) {
                 throw new Error("produced invalid syntax (rolled back)");
               }
               const wrDiff = writeResult.diff;
-              perFileDiffs.push({
+              appliedHunkResults.push({
+                index: hunkIndex,
+                hunk,
                 filePath,
+                displayPath: filePath,
                 before: "",
-                after: hunk.contents,
+                after: content,
                 additions: wrDiff?.additions ?? lineCount(content),
                 deletions: wrDiff?.deletions ?? 0
               });
@@ -36446,7 +36758,7 @@ function createApplyPatchTool(ctx) {
             } catch (e) {
               const msg = `Failed to create ${hunk.path}: ${e instanceof Error ? e.message : e}`;
               results.push(msg);
-              failures.push(hunk.path);
+              failures.push({ index: hunkIndex, path: hunk.path });
               const filePath2 = resolvePathFromProjectRoot(projectRoot, hunk.path);
               if (fs6.existsSync(filePath2)) {
                 try {
@@ -36465,8 +36777,11 @@ function createApplyPatchTool(ctx) {
               if (deleteResult.success === false) {
                 throw new Error(deleteResult.message ?? "delete failed");
               }
-              perFileDiffs.push({
+              appliedHunkResults.push({
+                index: hunkIndex,
+                hunk,
                 filePath,
+                displayPath: filePath,
                 before,
                 after: "",
                 additions: 0,
@@ -36475,7 +36790,7 @@ function createApplyPatchTool(ctx) {
               results.push(`Deleted ${hunk.path}`);
             } catch (e) {
               results.push(`Failed to delete ${hunk.path}: ${e instanceof Error ? e.message : e}`);
-              failures.push(hunk.path);
+              failures.push({ index: hunkIndex, path: hunk.path });
             }
             break;
           }
@@ -36502,7 +36817,7 @@ function createApplyPatchTool(ctx) {
               if (diags && diags.length > 0) {
                 const errors3 = diags.filter((d) => d.severity === "error");
                 if (errors3.length > 0) {
-                  const relPath = path4.relative(projectRoot, targetPath);
+                  const relPath = path5.relative(projectRoot, targetPath);
                   const diagLines = errors3.map((d) => `  Line ${d.line}: ${d.message}`).join(`
 `);
                   results.push(`
@@ -36516,13 +36831,17 @@ ${diagLines}`);
                 additions: wrDiff.additions,
                 deletions: wrDiff.deletions
               };
-              perFileDiffs.push({
+              const appliedHunkResult = {
+                index: hunkIndex,
+                hunk,
                 filePath,
+                displayPath: targetPath,
+                ...hunk.move_path ? { movePath: targetPath } : {},
                 before: original,
                 after: newContent,
                 additions,
                 deletions
-              });
+              };
               if (hunk.move_path) {
                 try {
                   const deleteResult = await callBridge(ctx, context, "delete_file", {
@@ -36555,13 +36874,15 @@ ${diagLines}`);
                   }
                   throw new Error(`source delete failed after writing move destination; restored pre-patch checkpoint ${checkpointName}: ${formatError2(deleteError)}`);
                 }
+                appliedHunkResults.push(appliedHunkResult);
                 results.push(`Updated and moved ${hunk.path} → ${hunk.move_path}`);
               } else {
+                appliedHunkResults.push(appliedHunkResult);
                 results.push(`Updated ${hunk.path}`);
               }
             } catch (e) {
               results.push(`Failed to update ${hunk.path}: ${e instanceof Error ? e.message : e}`);
-              failures.push(hunk.path);
+              failures.push({ index: hunkIndex, path: hunk.path });
               break;
             }
             break;
@@ -36570,7 +36891,8 @@ ${diagLines}`);
       }
       if (failures.length > 0) {
         const partial2 = failures.length < hunks.length;
-        const summary = partial2 ? `Patch partially applied — ${hunks.length - failures.length} of ${hunks.length} hunk(s) succeeded. Failed: ${failures.join(", ")}. Successful changes are kept; use \`aft_safety\` to revert if you want to abort.` : `Patch failed — none of the ${hunks.length} hunk(s) applied: ${failures.join(", ")}.`;
+        const failedList = failures.map((failure) => failure.path).join(", ");
+        const summary = partial2 ? `Patch partially applied — ${hunks.length - failures.length} of ${hunks.length} hunk(s) succeeded. Failed: ${failedList}. Successful changes are kept; use \`aft_safety\` to revert if you want to abort.` : `Patch failed — none of the ${hunks.length} hunk(s) applied: ${failedList}.`;
         results.push(summary);
         if (!partial2) {
           throw new Error(results.join(`
@@ -36578,28 +36900,56 @@ ${diagLines}`);
         }
       }
       {
-        const diffByPath = new Map(perFileDiffs.map((d) => [d.filePath, d]));
-        const failedPaths = new Set(failures);
-        const appliedHunks = hunks.filter((h) => !failedPaths.has(h.path));
-        const files = appliedHunks.map((h) => {
-          const filePath = resolvePathFromProjectRoot(projectRoot, h.path);
-          const rawMovePath = h.type === "update" ? h.move_path : undefined;
-          const movePath = rawMovePath ? resolvePathFromProjectRoot(projectRoot, rawMovePath) : undefined;
-          const displayPath = movePath ?? filePath;
-          const relPath = path4.relative(projectRoot, displayPath);
-          const diffEntry = diffByPath.get(filePath);
-          const patch = diffEntry ? buildUnifiedDiff(displayPath, diffEntry.before, diffEntry.after) : "";
-          const additions = diffEntry?.additions ?? 0;
-          const deletions = diffEntry?.deletions ?? 0;
-          const uiType = h.type === "update" && rawMovePath ? "move" : h.type;
+        const diffByReportKey = new Map;
+        for (const applied of appliedHunkResults) {
+          const reportKey = applied.movePath ? `${applied.filePath}\x00${applied.displayPath}` : applied.filePath;
+          const existing = diffByReportKey.get(reportKey);
+          if (!existing) {
+            diffByReportKey.set(reportKey, {
+              filePath: applied.filePath,
+              displayPath: applied.displayPath,
+              ...applied.movePath ? { movePath: applied.movePath } : {},
+              lastHunk: applied.hunk,
+              before: applied.before,
+              after: applied.after,
+              additions: applied.additions,
+              deletions: applied.deletions,
+              hunkCount: 1
+            });
+            continue;
+          }
+          existing.displayPath = applied.displayPath;
+          existing.movePath = applied.movePath ?? existing.movePath;
+          existing.lastHunk = applied.hunk;
+          existing.after = applied.after;
+          existing.hunkCount += 1;
+          const netCounts = countDiffLines(existing.before, existing.after);
+          existing.additions = netCounts.additions;
+          existing.deletions = netCounts.deletions;
+        }
+        const files = Array.from(diffByReportKey.values()).map((entry) => {
+          const relPath = path5.relative(projectRoot, entry.displayPath);
+          const patch = buildUnifiedDiff(entry.displayPath, entry.before, entry.after);
+          let uiType;
+          if (entry.movePath) {
+            uiType = "move";
+          } else if (entry.hunkCount === 1) {
+            uiType = entry.lastHunk.type;
+          } else if (entry.before.length === 0 && entry.after.length > 0) {
+            uiType = "add";
+          } else if (entry.before.length > 0 && entry.after.length === 0) {
+            uiType = "delete";
+          } else {
+            uiType = "update";
+          }
           return {
-            filePath,
+            filePath: entry.filePath,
             relativePath: relPath,
             type: uiType,
             patch,
-            additions,
-            deletions,
-            ...movePath ? { movePath } : {}
+            additions: entry.additions,
+            deletions: entry.deletions,
+            ...entry.movePath ? { movePath: entry.movePath } : {}
           };
         });
         const fileList = files.map((f) => {
@@ -36607,7 +36957,7 @@ ${diagLines}`);
           return `${prefix} ${f.relativePath}`;
         }).join(`
 `);
-        const title = failures.length > 0 ? `Partially applied (${files.length} of ${hunks.length}). Updated:
+        const title = failures.length > 0 ? `Partially applied (${hunks.length - failures.length} of ${hunks.length}). Updated:
 ${fileList}` : `Success. Updated the following files:
 ${fileList}`;
         const diffText = files.map((f) => f.patch).filter(Boolean).join(`
@@ -36760,18 +37110,20 @@ function aftPrefixedTools(ctx) {
           const file2 = normalizedArgs.filePath;
           const projectRoot = await resolveProjectRoot(ctx, context);
           const filePath = resolvePathFromProjectRoot(projectRoot, file2);
-          const relPath = path4.relative(projectRoot, filePath);
+          const relPath = path5.relative(projectRoot, filePath);
           {
-            const denial = await assertExternalDirectoryPermission(context, filePath);
-            if (denial)
-              return permissionDeniedResponse(denial);
+            const denial2 = await assertExternalDirectoryPermission(context, filePath);
+            if (denial2)
+              return permissionDeniedResponse(denial2);
           }
-          await runAsk(context.ask({
-            permission: "edit",
-            patterns: [relPath],
-            always: ["*"],
-            metadata: { filepath: filePath }
-          }));
+          const currentContent = await readCurrentFileForPreview(filePath);
+          const previewDiff = buildUnifiedDiff(filePath, currentContent, normalizedArgs.content);
+          const denial = await askEditPermission(context, [relPath], {
+            filepath: filePath,
+            diff: previewDiff
+          });
+          if (denial)
+            return permissionDeniedResponse(denial);
           const writeParams = {
             file: filePath,
             content: normalizedArgs.content,
@@ -37155,15 +37507,15 @@ function buildZoomTitle(args) {
     }
     return `${args.targets.filePath}#${args.targets.symbol}`;
   }
-  const path5 = args.filePath ?? args.url ?? "";
+  const path6 = args.filePath ?? args.url ?? "";
   if (typeof args.symbols === "string")
-    return path5 ? `${path5}#${args.symbols}` : args.symbols;
+    return path6 ? `${path6}#${args.symbols}` : args.symbols;
   if (Array.isArray(args.symbols) && args.symbols.length > 0) {
     if (args.symbols.length === 1)
-      return path5 ? `${path5}#${args.symbols[0]}` : args.symbols[0];
-    return path5 ? `${path5} (${args.symbols.length} symbols)` : `${args.symbols.length} symbols`;
+      return path6 ? `${path6}#${args.symbols[0]}` : args.symbols[0];
+    return path6 ? `${path6} (${args.symbols.length} symbols)` : `${args.symbols.length} symbols`;
   }
-  return path5 || "(no target)";
+  return path6 || "(no target)";
 }
 function readingTools(ctx) {
   return {
@@ -37396,6 +37748,11 @@ function readingTools(ctx) {
           }));
           if (symbolsArray.length === 1) {
             const response = results[0] ?? { success: false, message: "missing zoom response" };
+            const rustBatch = unwrapRustZoomBatchEnvelope(response);
+            if (rustBatch) {
+              const batch = formatZoomBatchResult(targetLabel, rustBatch.names, rustBatch.responses);
+              return withMeta(batch.text);
+            }
             if (response.success === false) {
               throw new Error(response.message || "zoom failed");
             }
@@ -37664,11 +38021,11 @@ function refactoringTools(ctx) {
 }
 
 // src/tools/safety.ts
-import * as path5 from "node:path";
+import * as path6 from "node:path";
 import { tool as tool14 } from "@opencode-ai/plugin";
 var z14 = tool14.schema;
 function responsePaths(response) {
-  return Array.isArray(response.paths) ? response.paths.filter((path6) => typeof path6 === "string" && path6.length > 0) : [];
+  return Array.isArray(response.paths) ? response.paths.filter((path7) => typeof path7 === "string" && path7.length > 0) : [];
 }
 function bridgeErrorMessage(response, fallback) {
   return typeof response.message === "string" && response.message.length > 0 ? response.message : fallback;
@@ -37745,9 +38102,9 @@ function safetyTools(ctx) {
             for (const rawFile of checkpointFiles) {
               if (typeof rawFile !== "string")
                 continue;
-              const file2 = expandTilde(rawFile);
-              const abs = path5.isAbsolute(file2) ? file2 : path5.resolve(projectRoot, file2);
-              const parent = path5.dirname(abs);
+              const file2 = expandTilde2(rawFile);
+              const abs = path6.isAbsolute(file2) ? file2 : path6.resolve(projectRoot, file2);
+              const parent = path6.dirname(abs);
               if (uniqueParents.has(parent))
                 continue;
               uniqueParents.add(parent);
@@ -37785,8 +38142,8 @@ function safetyTools(ctx) {
         const params = {};
         if (args.name !== undefined)
           params.name = args.name;
-        const payloadFiles = coerceStringArray(args.files).map(expandTilde);
-        const filePathArg = typeof args.filePath === "string" ? expandTilde(args.filePath) : undefined;
+        const payloadFiles = coerceStringArray(args.files).map(expandTilde2);
+        const filePathArg = typeof args.filePath === "string" ? expandTilde2(args.filePath) : undefined;
         if (op === "checkpoint") {
           if (payloadFiles.length > 0) {
             params.files = payloadFiles;
@@ -37811,7 +38168,7 @@ function safetyTools(ctx) {
 
 // src/tools/search.ts
 import * as fs7 from "node:fs";
-import * as path6 from "node:path";
+import * as path7 from "node:path";
 function arg2(schema) {
   return schema;
 }
@@ -37843,7 +38200,7 @@ function normalizeGlob(pattern) {
   return pattern;
 }
 function absoluteSearchPath(projectRoot, target) {
-  return resolvePathFromProjectRoot(projectRoot, expandTilde(target));
+  return resolvePathFromProjectRoot(projectRoot, expandTilde2(target));
 }
 function searchPathExists(projectRoot, target) {
   return fs7.existsSync(absoluteSearchPath(projectRoot, target));
@@ -37920,7 +38277,7 @@ function searchTools(ctx) {
       const projectRoot = await resolveProjectRoot(ctx, context);
       const pattern = String(args.pattern);
       const includeArg = args.include ? String(args.include) : undefined;
-      const pathArg = args.path ? expandTilde(String(args.path)) : undefined;
+      const pathArg = args.path ? expandTilde2(String(args.path)) : undefined;
       const bridgePath = pathArg ? absoluteSearchPath(projectRoot, pathArg) : undefined;
       const grepDenied = await askGrepPermission(context, pattern, {
         path: bridgePath,
@@ -37958,8 +38315,8 @@ function searchTools(ctx) {
     },
     execute: async (args, context) => {
       const projectRoot = await resolveProjectRoot(ctx, context);
-      let globPattern = expandTilde(String(args.pattern));
-      let globPath = args.path ? expandTilde(String(args.path)) : undefined;
+      let globPattern = expandTilde2(String(args.pattern));
+      let globPath = args.path ? expandTilde2(String(args.path)) : undefined;
       if (!globPath && globPattern.startsWith("/")) {
         const metaIdx = globPattern.search(/[*?{}[\]]/);
         if (metaIdx > 0) {
@@ -37969,8 +38326,8 @@ function searchTools(ctx) {
             globPattern = `**/${globPattern.slice(lastSlash + 1)}`;
           }
         } else if (metaIdx === -1) {
-          globPath = path6.dirname(globPattern);
-          globPattern = path6.basename(globPattern);
+          globPath = path7.dirname(globPattern);
+          globPattern = path7.basename(globPattern);
         }
       }
       const globDenied = await askGlobPermission(context, globPattern, { path: globPath });
@@ -38218,12 +38575,12 @@ 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 sidebar and 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.",
-  "Sidebar reliability: the status panel reconnects after heavy host load instead of going dark, and transient environment errors (schema fetch timeouts) no longer count as code errors."
+  "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.",
+  "Edit approval prompts now show the pending diff instead of 'No diff provided', so you can review a change before approving it."
 ];
 var ANNOUNCEMENT_FOOTER = "Join us on Discord: https://discord.gg/DSa65w8wuf";
 var plugin = async (input) => initializePluginForDirectory(input);
@@ -38335,13 +38692,13 @@ ${lines}
       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 path7 = await ensureBinary(`v${minVersion}`);
-          if (!path7) {
+          const path8 = await ensureBinary(`v${minVersion}`);
+          if (!path8) {
             warn2(`Could not find or download v${minVersion}. Continuing with v${binaryVersion}.`);
             return null;
           }
-          log2(`Found/downloaded compatible binary at ${path7}. Replacing running bridges...`);
-          const replaced = await pool.replaceBinary(path7);
+          log2(`Found/downloaded compatible binary at ${path8}. Replacing running bridges...`);
+          const replaced = await pool.replaceBinary(path8);
           log2("Binary replaced successfully. New bridges will use the updated binary.");
           return replaced;
         } catch (err) {