@cortexkit/aft-opencode 0.35.0 → 0.35.2

package/dist/index.js

@@ -7637,9 +7637,9 @@ var require_stringify = __commonJS((exports, module) => {
       if (line_breaks_before === null) {
         line_breaks_before = inline ? 0 : 1;
       }
-      const delimiter = line_breaks_before > 0 ? repeat_line_breaks(line_breaks_before, deeper_gap) : inline ? SPACE : i === 0 ? EMPTY : LF + deeper_gap;
+      const delimiter2 = line_breaks_before > 0 ? repeat_line_breaks(line_breaks_before, deeper_gap) : inline ? SPACE : i === 0 ? EMPTY : LF + deeper_gap;
       const is_line_comment = type === "LineComment";
-      str += delimiter + comment_stringify(value, is_line_comment);
+      str += delimiter2 + comment_stringify(value, is_line_comment);
       last_comment = comment;
     });
     const default_line_breaks_after = display_block || last_comment.type === "LineComment" ? 1 : 0;
@@ -7652,10 +7652,10 @@ var require_stringify = __commonJS((exports, module) => {
     replacer = null;
     indent = EMPTY;
   };
-  var join8 = (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 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 join_content = (inside, value, gap) => {
     const comment = process_comments(value, PREFIX_BEFORE, gap + indent, true);
-    return join8(comment, inside, gap);
+    return join9(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 = join8(after_comma, process_comments(value, BEFORE(i), deeper_gap), deeper_gap);
+      const before = join9(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 += join8(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join9(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 = join8(after_comma, process_comments(value, BEFORE(key), deeper_gap), deeper_gap);
+      const before = join9(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 += join8(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join9(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) {
@@ -12740,6 +12740,49 @@ async function fetchLatestTag() {
     clearTimeout(timeout);
   }
 }
+// ../aft-bridge/dist/edit-summary.js
+function formatEditSummary(data) {
+  if (data.rolled_back === true) {
+    return "Edit rolled back: the change produced invalid syntax, so the file was left unchanged.";
+  }
+  if (typeof data.files_modified === "number") {
+    const n = data.files_modified;
+    return `Applied edits to ${n} file${n === 1 ? "" : "s"}.`;
+  }
+  const additions = data.diff?.additions ?? 0;
+  const deletions = data.diff?.deletions ?? 0;
+  const counts = `+${additions}/-${deletions}`;
+  if (data.created === true) {
+    let s2 = `Created file (${counts}).`;
+    if (data.formatted)
+      s2 += " Auto-formatted.";
+    return s2;
+  }
+  let detail = counts;
+  if (typeof data.edits_applied === "number" && data.edits_applied > 1) {
+    detail = `${counts}, ${data.edits_applied} edits`;
+  } else if (typeof data.replacements === "number" && data.replacements > 1) {
+    detail = `${counts}, ${data.replacements} replacements`;
+  }
+  let s = `Edited (${detail}).`;
+  if (data.formatted)
+    s += " Auto-formatted.";
+  return s;
+}
+// ../aft-bridge/dist/jsonc.js
+function stripJsoncSymbols(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => stripJsoncSymbols(item));
+  }
+  if (value !== null && typeof value === "object") {
+    const out = {};
+    for (const [key, val] of Object.entries(value)) {
+      out[key] = stripJsoncSymbols(val);
+    }
+    return out;
+  }
+  return value;
+}
 // ../aft-bridge/dist/migration.js
 import { spawnSync as spawnSync2 } from "node:child_process";
 import { existsSync as existsSync4, mkdirSync as mkdirSync4 } from "node:fs";
@@ -12798,7 +12841,7 @@ function markAnnouncementSeen(storageRoot, harness, currentVersion) {
 
 // ../aft-bridge/dist/resolver.js
 import { execSync } from "node:child_process";
-import { chmodSync as chmodSync2, copyFileSync as copyFileSync2, existsSync as existsSync3, mkdirSync as mkdirSync3, renameSync as renameSync3, unlinkSync as unlinkSync2 } from "node:fs";
+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";
@@ -12879,6 +12922,37 @@ function probeBinaryCandidate(binaryPath, source, expectedVersion) {
 function parsePathLookupOutput(output) {
   return output.split(/\r?\n/).map((candidate) => candidate.trim()).filter(Boolean);
 }
+function isNativeExecutable(binaryPath) {
+  let fd = null;
+  try {
+    fd = openSync2(binaryPath, "r");
+    const buf = Buffer.alloc(4);
+    const read = readSync(fd, buf, 0, 4, 0);
+    if (read < 2)
+      return false;
+    const b0 = buf[0];
+    const b1 = buf[1];
+    if (b0 === 35 && b1 === 33)
+      return false;
+    const m32 = buf.readUInt32BE(0);
+    const machO = new Set([4277009102, 4277009103, 3472551422, 3489328638, 3405691582]);
+    if (read >= 4 && machO.has(m32))
+      return true;
+    if (read >= 4 && m32 === 2135247942)
+      return true;
+    if (b0 === 77 && b1 === 90)
+      return true;
+    return false;
+  } catch {
+    return false;
+  } finally {
+    if (fd !== null) {
+      try {
+        closeSync2(fd);
+      } catch {}
+    }
+  }
+}
 function platformKey(platform = process.platform, arch = process.arch) {
   const archMap = PLATFORM_ARCH_MAP[platform];
   if (!archMap) {
@@ -12932,6 +13006,10 @@ function findBinarySync(expectedVersion) {
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
     for (const candidate of parsePathLookupOutput(result)) {
+      if (!isNativeExecutable(candidate)) {
+        warn(`PATH binary at ${candidate} is not a native executable (script shim?); skipping`);
+        continue;
+      }
       const usable = probeBinaryCandidate(candidate, "PATH", expectedVersion);
       if (usable)
         return usable;
@@ -13078,11 +13156,128 @@ async function ensureStorageMigrated(opts) {
   const stdoutTail = tail(result.stdout);
   throw new Error(`AFT storage migration failed (${detail}). ` + `Harness: ${opts.harness}. Legacy: ${legacyRoot}. Target: ${newRoot}. ` + `See log: ${logPath}. ` + `Plugin load aborted to prevent legacy/new state divergence.` + (stderrTail ? ` Stderr tail: ${stderrTail}` : "") + (stdoutTail ? ` Stdout tail: ${stdoutTail}` : ""));
 }
+// ../aft-bridge/dist/npm-resolver.js
+import { 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";
+function defaultDeps() {
+  return {
+    platform: process.platform,
+    env: process.env,
+    home: homedir5(),
+    execPath: process.execPath
+  };
+}
+function npmBinaryName(platform) {
+  return platform === "win32" ? "npm.cmd" : "npm";
+}
+function isFile(p) {
+  try {
+    return statSync2(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function npmFromPath(deps) {
+  const name = npmBinaryName(deps.platform);
+  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))
+      continue;
+    if (isFile(join6(dir, name)))
+      return dir;
+  }
+  return null;
+}
+function npmAdjacentToNode(deps) {
+  const dir = dirname3(deps.execPath);
+  return isFile(join6(dir, npmBinaryName(deps.platform))) ? dir : null;
+}
+function highestVersionedNodeBin(installsDir, name) {
+  let entries;
+  try {
+    entries = readdirSync(installsDir);
+  } 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;
+}
+function compareVersionsDesc(a, b) {
+  const pa = a.replace(/^v/, "").split(".").map((n) => Number.parseInt(n, 10));
+  const pb = b.replace(/^v/, "").split(".").map((n) => Number.parseInt(n, 10));
+  for (let i = 0;i < Math.max(pa.length, pb.length); i++) {
+    const na = Number.isFinite(pa[i]) ? pa[i] : -1;
+    const nb = Number.isFinite(pb[i]) ? pb[i] : -1;
+    if (na !== nb)
+      return nb - na;
+  }
+  return b.localeCompare(a);
+}
+function wellKnownNpmDirs(deps) {
+  const { platform, env, home } = deps;
+  const name = npmBinaryName(platform);
+  const dirs = [];
+  const push = (dir) => {
+    if (dir && !dirs.includes(dir))
+      dirs.push(dir);
+  };
+  if (platform === "win32") {
+    const programFiles = env.ProgramFiles || "C:\\Program Files";
+    const appData = env.APPDATA;
+    const localAppData = env.LOCALAPPDATA;
+    push(join6(programFiles, "nodejs"));
+    if (appData)
+      push(join6(appData, "npm"));
+    if (localAppData)
+      push(join6(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")]);
+    for (const dir of systemDirs)
+      push(dir);
+  }
+  return dirs;
+}
+function resolveNpm(deps = defaultDeps()) {
+  const name = npmBinaryName(deps.platform);
+  const onPath = npmFromPath(deps);
+  if (onPath)
+    return { command: join6(onPath, name), binDir: onPath };
+  const adjacent = npmAdjacentToNode(deps);
+  if (adjacent)
+    return { command: join6(adjacent, name), binDir: adjacent };
+  for (const dir of wellKnownNpmDirs(deps)) {
+    const candidate = join6(dir, name);
+    if (isFile(candidate))
+      return { command: candidate, binDir: dir };
+  }
+  return null;
+}
+function npmSpawnEnv(resolved, baseEnv = process.env) {
+  if (!resolved.binDir)
+    return { ...baseEnv };
+  const existing = baseEnv.PATH ?? baseEnv.Path ?? "";
+  const next = existing ? `${resolved.binDir}${delimiter}${existing}` : resolved.binDir;
+  return { ...baseEnv, PATH: next };
+}
+function isNpmAvailable(deps = defaultDeps()) {
+  return resolveNpm(deps) !== null;
+}
 // ../aft-bridge/dist/onnx-runtime.js
 import { execFileSync } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
-import { chmodSync as chmodSync3, closeSync as closeSync2, copyFileSync as copyFileSync3, createWriteStream as createWriteStream2, existsSync as existsSync5, lstatSync, mkdirSync as mkdirSync5, openSync as openSync2, readdirSync, readFileSync as readFileSync3, readlinkSync, realpathSync, rmSync as rmSync2, statSync as statSync2, symlinkSync, unlinkSync as unlinkSync3, writeFileSync as writeFileSync2 } from "node:fs";
-import { basename, dirname as dirname3, isAbsolute, join as join6, relative, resolve, win32 } from "node:path";
+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 { Readable as Readable2 } from "node:stream";
 import { pipeline as pipeline2 } from "node:stream/promises";
 var ORT_VERSION = "1.24.4";
@@ -13148,10 +13343,10 @@ function getManualInstallHint() {
 }
 async function ensureOnnxRuntime(storageDir) {
   const info = getPlatformInfo();
-  const ortVersionDir = join6(storageDir, "onnxruntime", ORT_VERSION);
+  const ortVersionDir = join7(storageDir, "onnxruntime", ORT_VERSION);
   const libName = info?.libName ?? "libonnxruntime.dylib";
   const resolvedOrtDir = resolveCachedOnnxRuntimeDir(ortVersionDir, libName);
-  const libPath = join6(resolvedOrtDir, libName);
+  const libPath = join7(resolvedOrtDir, libName);
   if (existsSync5(libPath)) {
     const meta = readOnnxInstalledMeta(ortVersionDir);
     if (meta?.sha256) {
@@ -13181,9 +13376,9 @@ async function ensureOnnxRuntime(storageDir) {
     warn(`ONNX Runtime auto-download not available for ${process.platform}/${process.arch}. Install manually: ${getManualInstallHint()}`);
     return null;
   }
-  const onnxBaseDir = join6(storageDir, "onnxruntime");
+  const onnxBaseDir = join7(storageDir, "onnxruntime");
   mkdirSync5(onnxBaseDir, { recursive: true });
-  const lockPath = join6(onnxBaseDir, ONNX_LOCK_FILE);
+  const lockPath = join7(onnxBaseDir, ONNX_LOCK_FILE);
   cleanupAbandonedStagingDirs(onnxBaseDir);
   if (!acquireLock(lockPath)) {
     warn(`ONNX Runtime install already in progress in another process (lock: ${lockPath}). Skipping.`);
@@ -13198,11 +13393,11 @@ async function ensureOnnxRuntime(storageDir) {
 }
 function cleanupAbandonedStagingDirs(onnxBaseDir) {
   try {
-    const entries = readdirSync(onnxBaseDir);
+    const entries = readdirSync2(onnxBaseDir);
     for (const entry of entries) {
       if (!entry.startsWith(`${ORT_VERSION}.tmp.`))
         continue;
-      const stagingDir = join6(onnxBaseDir, entry);
+      const stagingDir = join7(onnxBaseDir, entry);
       const parts = entry.split(".");
       const pidStr = parts[parts.length - 2];
       const pid = pidStr ? Number.parseInt(pidStr, 10) : NaN;
@@ -13214,7 +13409,7 @@ function cleanupAbandonedStagingDirs(onnxBaseDir) {
             abandoned = true;
           } else {
             try {
-              const ageMs = Date.now() - statSync2(stagingDir).mtimeMs;
+              const ageMs = Date.now() - statSync3(stagingDir).mtimeMs;
               abandoned = ageMs > STALE_LOCK_MS;
             } catch {
               abandoned = true;
@@ -13239,7 +13434,7 @@ function cleanupAbandonedStagingDirs(onnxBaseDir) {
 }
 function cleanupIncompleteTargetIfUnowned(ortDir) {
   try {
-    if (existsSync5(ortDir) && !existsSync5(join6(ortDir, ONNX_INSTALLED_META_FILE))) {
+    if (existsSync5(ortDir) && !existsSync5(join7(ortDir, ONNX_INSTALLED_META_FILE))) {
       log(`[onnx] removing half-populated install dir ${ortDir} (no meta file)`);
       rmSync2(ortDir, { recursive: true, force: true });
     }
@@ -13268,11 +13463,11 @@ function parseOnnxVersionFromDirectoryPath(value) {
 }
 function isPathInsideRoot(root, candidate) {
   const rel = relative(root, candidate);
-  return rel === "" || !rel.startsWith("../") && !rel.startsWith("..\\") && rel !== ".." && !isAbsolute(rel) && !win32.isAbsolute(rel);
+  return rel === "" || !rel.startsWith("../") && !rel.startsWith("..\\") && rel !== ".." && !isAbsolute2(rel) && !win32.isAbsolute(rel);
 }
 function detectOnnxVersion(libDir, libName) {
   try {
-    const entries = readdirSync(libDir);
+    const entries = readdirSync2(libDir);
     const barePrefix = libName.replace(/\.(so|dylib|dll)$/, "");
     const expectedPrefix = process.platform === "win32" ? barePrefix.toLowerCase() : barePrefix;
     for (const entry of entries) {
@@ -13283,7 +13478,7 @@ function detectOnnxVersion(libDir, libName) {
       if (version)
         return version;
     }
-    const base = join6(libDir, libName);
+    const base = join7(libDir, libName);
     if (existsSync5(base)) {
       try {
         const real = realpathSync(base);
@@ -13315,16 +13510,16 @@ function pathEnvValue() {
   return process.env.PATH ?? process.env.Path ?? process.env.path ?? "";
 }
 function pathEntriesForPlatform() {
-  const delimiter = process.platform === "win32" ? ";" : ":";
-  return pathEnvValue().split(delimiter).map((entry) => entry.trim().replace(/^"|"$/g, "")).filter((entry) => {
+  const delimiter2 = process.platform === "win32" ? ";" : ":";
+  return pathEnvValue().split(delimiter2).map((entry) => entry.trim().replace(/^"|"$/g, "")).filter((entry) => {
     if (!entry || entry === "." || entry.includes("\x00"))
       return false;
-    return isAbsolute(entry) || win32.isAbsolute(entry);
+    return isAbsolute2(entry) || win32.isAbsolute(entry);
   });
 }
 function directoryContainsLibrary(dir, libName) {
   try {
-    const entries = readdirSync(dir);
+    const entries = readdirSync2(dir);
     if (process.platform === "win32") {
       const expected = libName.toLowerCase();
       return entries.some((entry) => entry.toLowerCase() === expected);
@@ -13335,10 +13530,10 @@ function directoryContainsLibrary(dir, libName) {
   }
 }
 function resolveCachedOnnxRuntimeDir(ortVersionDir, libName) {
-  if (existsSync5(join6(ortVersionDir, libName)))
+  if (existsSync5(join7(ortVersionDir, libName)))
     return ortVersionDir;
-  const libSubdir = join6(ortVersionDir, "lib");
-  if (existsSync5(join6(libSubdir, libName)))
+  const libSubdir = join7(ortVersionDir, "lib");
+  if (existsSync5(join7(libSubdir, libName)))
     return libSubdir;
   return ortVersionDir;
 }
@@ -13353,21 +13548,21 @@ 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(join6(programFiles, "onnxruntime", "lib"), join6(programFiles, "Microsoft ONNX Runtime", "lib"), join6(programFiles, "Microsoft Machine Learning", "lib"), join6(programFilesX86, "onnxruntime", "lib"), ...(() => {
+    searchPaths.push(join7(programFiles, "onnxruntime", "lib"), join7(programFiles, "Microsoft ONNX Runtime", "lib"), join7(programFiles, "Microsoft Machine Learning", "lib"), join7(programFilesX86, "onnxruntime", "lib"), ...(() => {
       const nugetPaths = [];
       const userProfile = process.env.USERPROFILE ?? "";
       if (!userProfile)
         return nugetPaths;
-      const nugetPackageDir = join6(userProfile, ".nuget", "packages", "microsoft.ml.onnxruntime");
+      const nugetPackageDir = join7(userProfile, ".nuget", "packages", "microsoft.ml.onnxruntime");
       if (!existsSync5(nugetPackageDir))
         return nugetPaths;
       try {
-        for (const entry of readdirSync(nugetPackageDir, { withFileTypes: true })) {
+        for (const entry of readdirSync2(nugetPackageDir, { withFileTypes: true })) {
           if (!entry.isDirectory())
             continue;
           if (entry.name === "__globalPackagesFolder" || entry.name.startsWith("."))
             continue;
-          nugetPaths.push(join6(nugetPackageDir, entry.name, "runtimes", "win-x64", "native"), join6(nugetPackageDir, entry.name, "runtimes", "win-arm64", "native"));
+          nugetPaths.push(join7(nugetPackageDir, entry.name, "runtimes", "win-x64", "native"), join7(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)}`);
@@ -13389,7 +13584,7 @@ function findSystemOnnxRuntime(libName) {
   });
   const unknownVersionPaths = [];
   for (const dir of uniquePaths) {
-    const libPath = join6(dir, libName);
+    const libPath = join7(dir, libName);
     if (process.platform === "win32") {
       if (!directoryContainsLibrary(dir, libName))
         continue;
@@ -13425,7 +13620,7 @@ async function downloadFileWithCap(url, destPath) {
     if (Number.isFinite(advertised) && advertised > MAX_DOWNLOAD_BYTES2) {
       throw new Error(`Content-Length ${advertised} exceeds max ${MAX_DOWNLOAD_BYTES2}`);
     }
-    mkdirSync5(dirname3(destPath), { recursive: true });
+    mkdirSync5(dirname4(destPath), { recursive: true });
     let bytesWritten = 0;
     const guard = new TransformStream({
       transform(chunk, transformController) {
@@ -13453,21 +13648,21 @@ function validateExtractedTree(stagingRoot) {
   const realRoot = realpathSync(stagingRoot);
   let totalBytes = 0;
   const walk = (dir) => {
-    const entries = readdirSync(dir);
+    const entries = readdirSync2(dir);
     for (const entry of entries) {
-      const fullPath = join6(dir, entry);
+      const fullPath = join7(dir, entry);
       const lst = lstatSync(fullPath);
       if (lst.isSymbolicLink()) {
         const linkTarget = readlinkSync(fullPath);
-        const resolvedTarget = resolve(dirname3(fullPath), linkTarget);
+        const resolvedTarget = resolve(dirname4(fullPath), linkTarget);
         const rel2 = relative(realRoot, resolvedTarget);
-        if (rel2.startsWith("..") || isAbsolute(rel2) || win32.isAbsolute(rel2)) {
+        if (rel2.startsWith("..") || isAbsolute2(rel2) || win32.isAbsolute(rel2)) {
           throw new Error(`extracted symlink ${fullPath} points outside staging root: ${linkTarget}`);
         }
         continue;
       }
       const rel = relative(realRoot, fullPath);
-      if (rel.startsWith("..") || isAbsolute(rel) || win32.isAbsolute(rel)) {
+      if (rel.startsWith("..") || isAbsolute2(rel) || win32.isAbsolute(rel)) {
         throw new Error(`extracted entry ${fullPath} escapes staging root`);
       }
       if (lst.isDirectory()) {
@@ -13490,7 +13685,7 @@ async function downloadOnnxRuntime(info, targetDir) {
   const tmpDir = `${targetDir}.tmp.${process.pid}.${Date.now().toString(36)}`;
   try {
     mkdirSync5(tmpDir, { recursive: true });
-    const archivePath = join6(tmpDir, `onnxruntime.${info.archiveType}`);
+    const archivePath = join7(tmpDir, `onnxruntime.${info.archiveType}`);
     await downloadFileWithCap(url, archivePath);
     const archiveSha256 = sha256File(archivePath);
     log(`ONNX Runtime archive sha256=${archiveSha256}`);
@@ -13506,16 +13701,16 @@ async function downloadOnnxRuntime(info, targetDir) {
       unlinkSync3(archivePath);
     } catch {}
     validateExtractedTree(tmpDir);
-    const extractedDir = join6(tmpDir, info.assetName, "lib");
+    const extractedDir = join7(tmpDir, info.assetName, "lib");
     if (!existsSync5(extractedDir)) {
       throw new Error(`Expected directory not found: ${extractedDir}`);
     }
     mkdirSync5(targetDir, { recursive: true });
-    const libFiles = readdirSync(extractedDir).filter((f) => f.startsWith("libonnxruntime") || f.startsWith("onnxruntime"));
+    const libFiles = readdirSync2(extractedDir).filter((f) => f.startsWith("libonnxruntime") || f.startsWith("onnxruntime"));
     const realFiles = [];
     const symlinks = [];
     for (const libFile of libFiles) {
-      const src = join6(extractedDir, libFile);
+      const src = join7(extractedDir, libFile);
       try {
         const stat = lstatSync(src);
         log(`ORT extract: ${libFile} — isSymlink=${stat.isSymbolicLink()}, isFile=${stat.isFile()}, size=${stat.size}`);
@@ -13530,7 +13725,7 @@ async function downloadOnnxRuntime(info, targetDir) {
       }
     }
     copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks);
-    const libPath = join6(targetDir, info.libName);
+    const libPath = join7(targetDir, info.libName);
     let libHash = null;
     try {
       libHash = sha256File(libPath);
@@ -13555,8 +13750,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 = join6(extractedDir, libFile);
-    const dst = join6(targetDir, libFile);
+    const src = join7(extractedDir, libFile);
+    const dst = join7(targetDir, libFile);
     try {
       copyFile(src, dst);
       if (process.platform !== "win32") {
@@ -13572,12 +13767,12 @@ function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, c
   }
   const targetRoot = realpathSync(targetDir);
   for (const link of symlinks) {
-    const dst = join6(targetDir, link.name);
+    const dst = join7(targetDir, link.name);
     try {
       unlinkSync3(dst);
     } catch {}
-    const dstForContainment = join6(targetRoot, link.name);
-    const resolvedTarget = resolve(dirname3(dstForContainment), link.target);
+    const dstForContainment = join7(targetRoot, link.name);
+    const resolvedTarget = resolve(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)) {
@@ -13597,7 +13792,7 @@ function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, c
       log(`ORT extract: failed to symlink optional ${link.name}: ${symlinkErr}`);
     }
   }
-  const requiredPath = join6(targetDir, info.libName);
+  const requiredPath = join7(targetDir, info.libName);
   if (!existsSync5(requiredPath)) {
     rmSync2(targetDir, { recursive: true, force: true });
     throw new Error(`Required ONNX Runtime library missing after install: ${requiredPath}`);
@@ -13624,15 +13819,15 @@ function writeOnnxInstalledMeta(installDir, version, sha256, archiveSha256) {
       ...sha256 ? { sha256 } : {},
       archiveSha256
     };
-    writeFileSync2(join6(installDir, ONNX_INSTALLED_META_FILE), JSON.stringify(meta), "utf8");
+    writeFileSync2(join7(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 = join6(installDir, ONNX_INSTALLED_META_FILE);
+  const path = join7(installDir, ONNX_INSTALLED_META_FILE);
   try {
-    if (!statSync2(path).isFile())
+    if (!statSync3(path).isFile())
       return null;
     const raw = readFileSync3(path, "utf8");
     const parsed = JSON.parse(raw);
@@ -13656,13 +13851,13 @@ function sha256File(path) {
 function acquireLock(lockPath) {
   const tryClaim = () => {
     try {
-      const fd = openSync2(lockPath, "wx");
+      const fd = openSync3(lockPath, "wx");
       try {
         writeFileSync2(fd, `${process.pid}
 ${new Date().toISOString()}
 `);
       } finally {
-        closeSync2(fd);
+        closeSync3(fd);
       }
       return true;
     } catch (err) {
@@ -13683,7 +13878,7 @@ ${new Date().toISOString()}
     const parsed = Number.parseInt(firstLine, 10);
     if (Number.isFinite(parsed) && parsed > 0)
       owningPid = parsed;
-    lockMtimeMs = statSync2(lockPath).mtimeMs;
+    lockMtimeMs = statSync3(lockPath).mtimeMs;
   } catch {
     return tryClaim();
   }
@@ -14982,10 +15177,10 @@ function formatDuration(completion) {
 }
 
 // src/config.ts
-var import_comment_json = __toESM(require_src2(), 1);
 import { existsSync as existsSync6, readFileSync as readFileSync4, renameSync as renameSync4, unlinkSync as unlinkSync4, writeFileSync as writeFileSync3 } from "node:fs";
-import { homedir as homedir5 } from "node:os";
-import { join as join8 } from "node:path";
+import { homedir as homedir6 } from "node:os";
+import { join as join9 } 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
 var exports_external = {};
@@ -16571,8 +16766,8 @@ function emoji() {
 }
 var ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
 var ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;
-var mac = (delimiter) => {
-  const escapedDelim = escapeRegex(delimiter ?? ":");
+var mac = (delimiter2) => {
+  const escapedDelim = escapeRegex(delimiter2 ?? ":");
   return new RegExp(`^(?:[0-9A-F]{2}${escapedDelim}){5}[0-9A-F]{2}$|^(?:[0-9a-f]{2}${escapedDelim}){5}[0-9a-f]{2}$`);
 };
 var cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
@@ -28989,14 +29184,15 @@ function loadConfigFromPath(configPath) {
     const content = readFileSync4(configPath, "utf-8");
     const rawConfig = import_comment_json.parse(content);
     migrateRawConfig(rawConfig, configPath, { log: log2, warn: warn2 });
-    const result = AftConfigSchema.safeParse(rawConfig);
+    const cleanConfig = stripJsoncSymbols(rawConfig);
+    const result = AftConfigSchema.safeParse(cleanConfig);
     if (result.success) {
       log2(`Config loaded from ${configPath}`);
       return result.data;
     }
     const errorMsg = result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", ");
     warn2(`Config validation error in ${configPath}: ${errorMsg}`);
-    return parseConfigPartially(rawConfig);
+    return parseConfigPartially(cleanConfig);
   } catch (err) {
     const errorMsg = err instanceof Error ? err.message : String(err);
     error2(`Error loading config from ${configPath}: ${errorMsg}`);
@@ -29178,17 +29374,17 @@ function getOpenCodeConfigDir() {
   if (envDir) {
     return envDir;
   }
-  const xdgConfig = process.env.XDG_CONFIG_HOME || join8(homedir5(), ".config");
-  return join8(xdgConfig, "opencode");
+  const xdgConfig = process.env.XDG_CONFIG_HOME || join9(homedir6(), ".config");
+  return join9(xdgConfig, "opencode");
 }
 function loadAftConfig(projectDirectory) {
   const configDir = getOpenCodeConfigDir();
-  const userBasePath = join8(configDir, "aft");
+  const userBasePath = join9(configDir, "aft");
   migrateAftConfigFile(`${userBasePath}.jsonc`);
   migrateAftConfigFile(`${userBasePath}.json`);
   const userDetected = detectConfigFile(userBasePath);
   const userConfigPath = userDetected.format !== "none" ? userDetected.path : `${userBasePath}.json`;
-  const projectBasePath = join8(projectDirectory, ".opencode", "aft");
+  const projectBasePath = join9(projectDirectory, ".opencode", "aft");
   migrateAftConfigFile(`${projectBasePath}.jsonc`);
   migrateAftConfigFile(`${projectBasePath}.json`);
   const projectDetected = detectConfigFile(projectBasePath);
@@ -29214,8 +29410,8 @@ function loadAftConfig(projectDirectory) {
 
 // src/notifications.ts
 import { existsSync as existsSync7, readFileSync as readFileSync5 } from "node:fs";
-import { homedir as homedir6, platform } from "node:os";
-import { join as join9 } from "node:path";
+import { homedir as homedir7, platform } from "node:os";
+import { join as join10 } from "node:path";
 function isTuiMode() {
   return process.env.OPENCODE_CLIENT === "cli";
 }
@@ -29236,17 +29432,17 @@ var WARNING_MARKER = `${AFT_MARKER} ⚠️`;
 var STATUS_MARKER = `${AFT_MARKER} ✅`;
 function getDesktopStatePath() {
   const os2 = platform();
-  const home = homedir6();
+  const home = homedir7();
   if (os2 === "darwin") {
-    return join9(home, "Library", "Application Support", "ai.opencode.desktop", "opencode.global.dat");
+    return join10(home, "Library", "Application Support", "ai.opencode.desktop", "opencode.global.dat");
   }
   if (os2 === "linux") {
-    const xdgConfig = process.env.XDG_CONFIG_HOME || join9(home, ".config");
-    return join9(xdgConfig, "ai.opencode.desktop", "opencode.global.dat");
+    const xdgConfig = process.env.XDG_CONFIG_HOME || join10(home, ".config");
+    return join10(xdgConfig, "ai.opencode.desktop", "opencode.global.dat");
   }
   if (os2 === "win32") {
-    const appData = process.env.APPDATA || join9(home, "AppData", "Roaming");
-    return join9(appData, "ai.opencode.desktop", "opencode.global.dat");
+    const appData = process.env.APPDATA || join10(home, "AppData", "Roaming");
+    return join10(appData, "ai.opencode.desktop", "opencode.global.dat");
   }
   return null;
 }
@@ -29701,52 +29897,52 @@ async function flushConfigureWarningsOnIdle(sessionId) {
 
 // src/hooks/auto-update-checker/index.ts
 import {
-  closeSync as closeSync3,
+  closeSync as closeSync4,
   existsSync as existsSync10,
   mkdirSync as mkdirSync6,
-  openSync as openSync3,
+  openSync as openSync4,
   readFileSync as readFileSync8,
   renameSync as renameSync5,
   rmSync as rmSync4,
   writeFileSync as writeFileSync6
 } from "node:fs";
-import { dirname as dirname6 } from "node:path";
+import { dirname as dirname7 } from "node:path";
 
 // src/hooks/auto-update-checker/cache.ts
-var import_comment_json3 = __toESM(require_src2(), 1);
 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 dirname5, join as join12 } from "node:path";
+import { basename as basename2, dirname as dirname6, join as join13 } 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 statSync3, writeFileSync as writeFileSync4 } from "node:fs";
-import { homedir as homedir8 } from "node:os";
-import { dirname as dirname4, isAbsolute as isAbsolute2, join as join11, resolve as resolve2 } from "node:path";
+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 { fileURLToPath } from "node:url";
 
 // src/hooks/auto-update-checker/constants.ts
-import { homedir as homedir7, platform as platform2 } from "node:os";
-import { join as join10 } from "node:path";
+import { homedir as homedir8, platform as platform2 } from "node:os";
+import { join as join11 } 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 join10(process.env.LOCALAPPDATA ?? homedir7(), "opencode");
+    return join11(process.env.LOCALAPPDATA ?? homedir8(), "opencode");
   }
-  return join10(homedir7(), ".cache", "opencode");
+  return join11(homedir8(), ".cache", "opencode");
 }
 function getOpenCodeConfigRoot() {
   if (platform2() === "win32") {
-    return join10(process.env.APPDATA ?? join10(homedir7(), "AppData", "Roaming"), "opencode");
+    return join11(process.env.APPDATA ?? join11(homedir8(), "AppData", "Roaming"), "opencode");
   }
-  return join10(process.env.XDG_CONFIG_HOME ?? join10(homedir7(), ".config"), "opencode");
+  return join11(process.env.XDG_CONFIG_HOME ?? join11(homedir8(), ".config"), "opencode");
 }
-var CACHE_DIR = join10(getOpenCodeCacheRoot(), "packages");
-var USER_OPENCODE_CONFIG = join10(getOpenCodeConfigRoot(), "opencode.json");
-var USER_OPENCODE_CONFIG_JSONC = join10(getOpenCodeConfigRoot(), "opencode.jsonc");
+var CACHE_DIR = join11(getOpenCodeCacheRoot(), "packages");
+var USER_OPENCODE_CONFIG = join11(getOpenCodeConfigRoot(), "opencode.json");
+var USER_OPENCODE_CONFIG_JSONC = join11(getOpenCodeConfigRoot(), "opencode.jsonc");
 
 // src/hooks/auto-update-checker/types.ts
 var NpmPackageEnvelopeSchema = exports_external.object({
@@ -29804,8 +30000,8 @@ function extractChannel(version2) {
 }
 function getConfigPaths(directory) {
   return [
-    join11(directory, ".opencode", "opencode.json"),
-    join11(directory, ".opencode", "opencode.jsonc"),
+    join12(directory, ".opencode", "opencode.json"),
+    join12(directory, ".opencode", "opencode.jsonc"),
     USER_OPENCODE_CONFIG,
     USER_OPENCODE_CONFIG_JSONC
   ];
@@ -29818,9 +30014,9 @@ function resolvePathPluginSpec(spec, configPath) {
       return spec.replace(/^file:\/\//, "");
     }
   }
-  if (isAbsolute2(spec) || /^[A-Za-z]:[\\/]/.test(spec))
+  if (isAbsolute3(spec) || /^[A-Za-z]:[\\/]/.test(spec))
     return spec;
-  return resolve2(dirname4(configPath), spec);
+  return resolve2(dirname5(configPath), spec);
 }
 function getLocalDevPath(directory) {
   for (const configPath of getConfigPaths(directory)) {
@@ -29832,7 +30028,7 @@ function getLocalDevPath(directory) {
       for (const entry of plugins) {
         if (entry === PACKAGE_NAME || entry.startsWith(`${PACKAGE_NAME}@`))
           continue;
-        if (entry.startsWith("file://") || entry.startsWith(".") || isAbsolute2(entry)) {
+        if (entry.startsWith("file://") || entry.startsWith(".") || isAbsolute3(entry)) {
           const localPath = resolvePathPluginSpec(entry, configPath);
           const pkgPath = findPackageJsonUp(localPath);
           if (!pkgPath)
@@ -29848,10 +30044,10 @@ function getLocalDevPath(directory) {
 }
 function findPackageJsonUp(startPath) {
   try {
-    const stat = statSync3(startPath);
-    let dir = stat.isDirectory() ? startPath : dirname4(startPath);
+    const stat = statSync4(startPath);
+    let dir = stat.isDirectory() ? startPath : dirname5(startPath);
     for (let i = 0;i < 10; i++) {
-      const pkgPath = join11(dir, "package.json");
+      const pkgPath = join12(dir, "package.json");
       if (existsSync8(pkgPath)) {
         try {
           const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync6(pkgPath, "utf-8")));
@@ -29859,7 +30055,7 @@ function findPackageJsonUp(startPath) {
             return pkgPath;
         } catch {}
       }
-      const parent = dirname4(dir);
+      const parent = dirname5(dir);
       if (parent === dir)
         break;
       dir = parent;
@@ -29883,7 +30079,7 @@ function getLocalDevVersion(directory) {
 }
 function getCurrentRuntimePackageJsonPath(currentModuleUrl = import.meta.url) {
   try {
-    return findPackageJsonUp(dirname4(fileURLToPath(currentModuleUrl)));
+    return findPackageJsonUp(dirname5(fileURLToPath(currentModuleUrl)));
   } catch (err) {
     warn2(`[auto-update-checker] Failed to resolve runtime package path: ${String(err)}`);
     return null;
@@ -29912,7 +30108,7 @@ function findPluginEntry(directory) {
 }
 var cachedPackageVersion = null;
 function getSpecCachePackageJsonPath(spec) {
-  return join11(CACHE_DIR, spec, "node_modules", PACKAGE_NAME, "package.json");
+  return join12(CACHE_DIR, spec, "node_modules", PACKAGE_NAME, "package.json");
 }
 function getCachedVersion(spec) {
   if (!spec && cachedPackageVersion)
@@ -29921,7 +30117,7 @@ function getCachedVersion(spec) {
     getCurrentRuntimePackageJsonPath(),
     spec ? getSpecCachePackageJsonPath(spec) : null,
     getSpecCachePackageJsonPath(`${PACKAGE_NAME}@latest`),
-    join11(homedir8(), ".cache", "opencode", "node_modules", PACKAGE_NAME, "package.json")
+    join12(homedir9(), ".cache", "opencode", "node_modules", PACKAGE_NAME, "package.json")
   ].filter(isString);
   for (const packageJsonPath of candidates) {
     try {
@@ -29969,10 +30165,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 = join12(installDir, "node_modules", packageName);
-  const lockfilePath = join12(installDir, "package-lock.json");
-  const tempDir = mkdtempSync(join12(tmpdir3(), "aft-auto-update-"));
-  const stagedPackageDir = existsSync9(packageDir) ? join12(tempDir, "package") : null;
+  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;
   if (stagedPackageDir)
     cpSync(packageDir, stagedPackageDir, { recursive: true });
   return {
@@ -30008,12 +30204,12 @@ function stripPackageNameFromPath(pathValue, packageName) {
   for (const segment of [...packageName.split("/")].reverse()) {
     if (basename2(current) !== segment)
       return null;
-    current = dirname5(current);
+    current = dirname6(current);
   }
   return current;
 }
 function removeFromPackageLock(installDir, packageName) {
-  const lockPath = join12(installDir, "package-lock.json");
+  const lockPath = join13(installDir, "package-lock.json");
   if (!existsSync9(lockPath))
     return false;
   try {
@@ -30062,7 +30258,7 @@ function ensureDependencyVersion(packageJsonPath, packageName, version2) {
   }
 }
 function removeInstalledPackage(installDir, packageName) {
-  const packageDir = join12(installDir, "node_modules", packageName);
+  const packageDir = join13(installDir, "node_modules", packageName);
   if (!existsSync9(packageDir))
     return false;
   rmSync3(packageDir, { recursive: true, force: true });
@@ -30071,19 +30267,19 @@ function removeInstalledPackage(installDir, packageName) {
 }
 function resolveInstallContext(runtimePackageJsonPath = getCurrentRuntimePackageJsonPath()) {
   if (runtimePackageJsonPath) {
-    const packageDir = dirname5(runtimePackageJsonPath);
+    const packageDir = dirname6(runtimePackageJsonPath);
     const nodeModulesDir = stripPackageNameFromPath(packageDir, PACKAGE_NAME);
     if (nodeModulesDir && basename2(nodeModulesDir) === "node_modules") {
-      const installDir = dirname5(nodeModulesDir);
-      const packageJsonPath = join12(installDir, "package.json");
+      const installDir = dirname6(nodeModulesDir);
+      const packageJsonPath = join13(installDir, "package.json");
       if (existsSync9(packageJsonPath))
         return { installDir, packageJsonPath };
     }
     return null;
   }
-  const legacyPackageJsonPath = join12(dirname5(CACHE_DIR), "package.json");
+  const legacyPackageJsonPath = join13(dirname6(CACHE_DIR), "package.json");
   if (existsSync9(legacyPackageJsonPath)) {
-    return { installDir: dirname5(CACHE_DIR), packageJsonPath: legacyPackageJsonPath };
+    return { installDir: dirname6(CACHE_DIR), packageJsonPath: legacyPackageJsonPath };
   }
   return null;
 }
@@ -30119,10 +30315,16 @@ async function runNpmInstallSafe(installDir, options = {}) {
   try {
     if (options.signal?.aborted)
       return { ok: false, reason: "aborted" };
-    const npmBin = process.platform === "win32" ? "npm.cmd" : "npm";
-    const proc = spawn2(npmBin, ["install", "--no-audit", "--no-fund", "--no-progress", "--ignore-scripts"], {
+    const npm = resolveNpm();
+    if (!npm) {
+      const reason = "npm not found on PATH or in known version-manager locations";
+      warnNpmInstallFailure(reason, stderrTail);
+      return { ok: false, reason };
+    }
+    const proc = spawn2(npm.command, ["install", "--no-audit", "--no-fund", "--no-progress", "--ignore-scripts"], {
       cwd: installDir,
-      stdio: ["ignore", "pipe", "pipe"]
+      stdio: ["ignore", "pipe", "pipe"],
+      env: npmSpawnEnv(npm)
     });
     proc.stderr?.on("data", (chunk) => {
       stderrTail += chunk.toString("utf8");
@@ -30251,11 +30453,11 @@ function claimCheckSlot(storageDir, intervalMs) {
   try {
     if (hasRecentCheckTimestamp(file2, intervalMs))
       return null;
-    mkdirSync6(dirname6(file2), { recursive: true });
+    mkdirSync6(dirname7(file2), { recursive: true });
     const lockPath = `${file2}.lock`;
     let lockFd;
     try {
-      lockFd = openSync3(lockPath, "wx");
+      lockFd = openSync4(lockPath, "wx");
       writeFileSync6(lockFd, JSON.stringify({ pid: process.pid, startedMs: Date.now() }));
     } catch (err) {
       if (err.code !== "EEXIST") {
@@ -30266,7 +30468,7 @@ function claimCheckSlot(storageDir, intervalMs) {
     const lock = {
       release: () => {
         try {
-          closeSync3(lockFd);
+          closeSync4(lockFd);
         } catch {}
         rmSync4(lockPath, { force: true });
       }
@@ -30361,6 +30563,11 @@ async function runBackgroundUpdateCheck(ctx, options) {
     log2("[auto-update-checker] Auto-update disabled, notification only");
     return;
   }
+  if (!isNpmAvailable()) {
+    showToast(ctx, `AFT ${latestVersion} available`, `v${latestVersion} is ready, but npm was not found so it can't auto-install. Run \`npx @cortexkit/aft doctor --fix\` from a terminal, or launch OpenCode from a shell where npm is on PATH.`, "warning", 1e4);
+    warn2("[auto-update-checker] npm not found on PATH or known version-manager locations; skipping destructive auto-update steps");
+    return;
+  }
   const installDir = preparePackageUpdate(latestVersion, PACKAGE_NAME);
   if (!installDir) {
     showToast(ctx, `AFT ${latestVersion}`, `v${latestVersion} available. Auto-update could not prepare the active install.`, "warning", 8000);
@@ -30391,49 +30598,49 @@ function showToast(ctx, title, message, variant = "info", duration3 = 3000) {
 // src/lsp-auto-install.ts
 import { spawn as spawn3 } from "node:child_process";
 import { createHash as createHash4 } from "node:crypto";
-import { createReadStream, mkdirSync as mkdirSync8, readFileSync as readFileSync11, renameSync as renameSync6, rmSync as rmSync5, statSync as statSync5 } from "node:fs";
-import { join as join15 } from "node:path";
+import { createReadStream, mkdirSync as mkdirSync8, readFileSync as readFileSync11, renameSync as renameSync6, rmSync as rmSync5, statSync as statSync6 } from "node:fs";
+import { join as join16 } from "node:path";
 
 // src/lsp-cache.ts
 import {
-  closeSync as closeSync4,
+  closeSync as closeSync5,
   mkdirSync as mkdirSync7,
-  openSync as openSync4,
+  openSync as openSync5,
   readFileSync as readFileSync9,
-  statSync as statSync4,
+  statSync as statSync5,
   unlinkSync as unlinkSync5,
   writeFileSync as writeFileSync7
 } from "node:fs";
-import { homedir as homedir9 } from "node:os";
-import { join as join13 } from "node:path";
+import { homedir as homedir10 } from "node:os";
+import { join as join14 } 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 || join13(homedir9(), "AppData", "Local");
-    return join13(base2, "aft");
+    const base2 = localAppData || join14(homedir10(), "AppData", "Local");
+    return join14(base2, "aft");
   }
-  const base = process.env.XDG_CACHE_HOME || join13(homedir9(), ".cache");
-  return join13(base, "aft");
+  const base = process.env.XDG_CACHE_HOME || join14(homedir10(), ".cache");
+  return join14(base, "aft");
 }
 function lspCacheRoot() {
-  return join13(aftCacheBase(), "lsp-packages");
+  return join14(aftCacheBase(), "lsp-packages");
 }
 function lspPackageDir(npmPackage) {
-  return join13(lspCacheRoot(), encodeURIComponent(npmPackage));
+  return join14(lspCacheRoot(), encodeURIComponent(npmPackage));
 }
 function lspBinaryPath(npmPackage, binary) {
-  return join13(lspPackageDir(npmPackage), "node_modules", ".bin", binary);
+  return join14(lspPackageDir(npmPackage), "node_modules", ".bin", binary);
 }
 function lspBinDir(npmPackage) {
-  return join13(lspPackageDir(npmPackage), "node_modules", ".bin");
+  return join14(lspPackageDir(npmPackage), "node_modules", ".bin");
 }
 function isInstalled(npmPackage, binary) {
   for (const candidate of lspBinaryCandidates(binary)) {
     try {
-      if (statSync4(join13(lspBinDir(npmPackage), candidate)).isFile())
+      if (statSync5(join14(lspBinDir(npmPackage), candidate)).isFile())
         return true;
     } catch {}
   }
@@ -30453,15 +30660,15 @@ function writeInstalledMetaIn(installDir, version2, sha256) {
       installedAt: new Date().toISOString(),
       ...sha256 ? { sha256 } : {}
     };
-    writeFileSync7(join13(installDir, INSTALLED_META_FILE), JSON.stringify(meta3), "utf8");
+    writeFileSync7(join14(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 = join13(installDir, INSTALLED_META_FILE);
+  const path2 = join14(installDir, INSTALLED_META_FILE);
   try {
-    if (!statSync4(path2).isFile())
+    if (!statSync5(path2).isFile())
       return null;
     const raw = readFileSync9(path2, "utf8");
     const parsed = JSON.parse(raw);
@@ -30483,7 +30690,7 @@ function readInstalledMeta(packageKey) {
   return readInstalledMetaIn(lspPackageDir(packageKey));
 }
 function lockPath(npmPackage) {
-  return join13(lspPackageDir(npmPackage), ".aft-installing");
+  return join14(lspPackageDir(npmPackage), ".aft-installing");
 }
 var STALE_LOCK_MS2 = 30 * 60 * 1000;
 function acquireInstallLock(lockKey) {
@@ -30491,13 +30698,13 @@ function acquireInstallLock(lockKey) {
   const lock = lockPath(lockKey);
   const tryClaim = () => {
     try {
-      const fd = openSync4(lock, "wx");
+      const fd = openSync5(lock, "wx");
       try {
         writeFileSync7(fd, `${process.pid}
 ${new Date().toISOString()}
 `);
       } finally {
-        closeSync4(fd);
+        closeSync5(fd);
       }
       return true;
     } catch (err) {
@@ -30518,7 +30725,7 @@ ${new Date().toISOString()}
     const parsed = Number.parseInt(firstLine, 10);
     if (Number.isFinite(parsed) && parsed > 0)
       owningPid = parsed;
-    lockMtimeMs = statSync4(lock).mtimeMs;
+    lockMtimeMs = statSync5(lock).mtimeMs;
   } catch {
     return tryClaim();
   }
@@ -30590,7 +30797,7 @@ async function withInstallLock(lockKey, task) {
 }
 var VERSION_CHECK_FILE = ".aft-version-check";
 function readVersionCheck(npmPackage) {
-  const file2 = join13(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
+  const file2 = join14(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
   try {
     const raw = readFileSync9(file2, "utf8");
     const parsed = JSON.parse(raw);
@@ -30607,7 +30814,7 @@ function readVersionCheck(npmPackage) {
 }
 function writeVersionCheck(npmPackage, latest) {
   mkdirSync7(lspPackageDir(npmPackage), { recursive: true });
-  const file2 = join13(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
+  const file2 = join14(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
   const record2 = {
     last_checked: new Date().toISOString(),
     latest_eligible: latest
@@ -30769,8 +30976,8 @@ var NPM_LSP_TABLE = [
 ];
 
 // src/lsp-project-relevance.ts
-import { existsSync as existsSync11, readdirSync as readdirSync2, readFileSync as readFileSync10 } from "node:fs";
-import { join as join14 } from "node:path";
+import { existsSync as existsSync11, readdirSync as readdirSync3, readFileSync as readFileSync10 } from "node:fs";
+import { join as join15 } from "node:path";
 var MAX_WALK_DIRS = 200;
 var MAX_WALK_DEPTH = 4;
 var NOISE_DIRS = new Set([
@@ -30787,7 +30994,7 @@ function hasRootMarker(projectRoot, rootMarkers) {
   if (!rootMarkers)
     return false;
   for (const marker of rootMarkers) {
-    if (existsSync11(join14(projectRoot, marker)))
+    if (existsSync11(join15(projectRoot, marker)))
       return true;
   }
   return false;
@@ -30811,7 +31018,7 @@ function hasPackageJsonDep(projectRoot, depNames) {
 }
 function readPackageJson(projectRoot) {
   try {
-    const raw = readFileSync10(join14(projectRoot, "package.json"), "utf8");
+    const raw = readFileSync10(join15(projectRoot, "package.json"), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null)
       return null;
@@ -30834,14 +31041,14 @@ function relevantExtensionsInProject(projectRoot, extToServer) {
     visitedDirs += 1;
     let entries;
     try {
-      entries = readdirSync2(current.dir, { withFileTypes: true });
+      entries = readdirSync3(current.dir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (current.depth < MAX_WALK_DEPTH && !NOISE_DIRS.has(entry.name.toLowerCase())) {
-          queue.push({ dir: join14(current.dir, entry.name), depth: current.depth + 1 });
+          queue.push({ dir: join15(current.dir, entry.name), depth: current.depth + 1 });
         }
         continue;
       }
@@ -30975,10 +31182,16 @@ function runInstall(spec, version2, cwd, signal) {
       resolve3(false);
       return;
     }
-    const npmBin = process.platform === "win32" ? "npm.cmd" : "npm";
-    const child = spawn3(npmBin, ["install", "--no-save", "--ignore-scripts", "--silent", target], {
+    const npm = resolveNpm();
+    if (!npm) {
+      warn2(`[lsp] npm not found on PATH or known locations; cannot install ${target}`);
+      resolve3(false);
+      return;
+    }
+    const child = spawn3(npm.command, ["install", "--no-save", "--ignore-scripts", "--silent", target], {
       stdio: ["ignore", "pipe", "pipe"],
-      cwd
+      cwd,
+      env: npmSpawnEnv(npm)
     });
     child.unref();
     let stderrBuf = "";
@@ -31105,7 +31318,7 @@ function hashInstalledBinary(spec) {
     let pathToHash = null;
     for (const p of candidates) {
       try {
-        if (statSync5(p).isFile()) {
+        if (statSync6(p).isFile()) {
           pathToHash = p;
           break;
         }
@@ -31131,7 +31344,7 @@ function installedBinaryPath(spec) {
   ] : [lspBinaryPath(spec.npm, spec.binary)];
   for (const candidate of candidates) {
     try {
-      if (statSync5(candidate).isFile())
+      if (statSync6(candidate).isFile())
         return candidate;
     } catch {}
   }
@@ -31142,10 +31355,10 @@ function sha256OfFileSync(path2) {
 }
 function quarantineCachedNpmInstall(spec, reason) {
   const packageDir = lspPackageDir(spec.npm);
-  const dest = join15(packageDir, "..", ".quarantine", encodeURIComponent(spec.npm), `${Date.now()}`);
+  const dest = join16(packageDir, "..", ".quarantine", encodeURIComponent(spec.npm), `${Date.now()}`);
   warn2(`[lsp] tofu_mismatch ${spec.npm}: ${reason}; quarantining ${packageDir} -> ${dest}`);
   try {
-    mkdirSync8(join15(dest, ".."), { recursive: true });
+    mkdirSync8(join16(dest, ".."), { recursive: true });
     rmSync5(dest, { recursive: true, force: true });
     renameSync6(packageDir, dest);
   } catch (err) {
@@ -31231,17 +31444,17 @@ import {
   existsSync as existsSync12,
   lstatSync as lstatSync2,
   mkdirSync as mkdirSync9,
-  readdirSync as readdirSync3,
+  readdirSync as readdirSync4,
   readFileSync as readFileSync12,
   readlinkSync as readlinkSync2,
   realpathSync as realpathSync3,
   renameSync as renameSync7,
   rmSync as rmSync6,
-  statSync as statSync6,
+  statSync as statSync7,
   unlinkSync as unlinkSync6,
   writeFileSync as writeFileSync8
 } from "node:fs";
-import { dirname as dirname7, join as join16, relative as relative2, resolve as resolve3 } from "node:path";
+import { dirname as dirname8, join as join17, relative as relative2, resolve as resolve3 } from "node:path";
 import { Readable as Readable3 } from "node:stream";
 import { pipeline as pipeline3 } from "node:stream/promises";
 
@@ -31331,26 +31544,26 @@ function detectHostPlatform() {
 
 // src/lsp-github-install.ts
 function ghCacheRoot() {
-  return join16(aftCacheBase(), "lsp-binaries");
+  return join17(aftCacheBase(), "lsp-binaries");
 }
 function ghPackageDir(spec) {
-  return join16(ghCacheRoot(), spec.id);
+  return join17(ghCacheRoot(), spec.id);
 }
 function ghBinDir(spec) {
-  return join16(ghPackageDir(spec), "bin");
+  return join17(ghPackageDir(spec), "bin");
 }
 function ghExtractDir(spec) {
-  return join16(ghPackageDir(spec), "extracted");
+  return join17(ghPackageDir(spec), "extracted");
 }
 var INSTALLED_META_FILE2 = ".aft-installed";
 function ghBinaryPath(spec, platform3) {
   const ext = platform3 === "win32" ? ".exe" : "";
-  return join16(ghBinDir(spec), `${spec.binary}${ext}`);
+  return join17(ghBinDir(spec), `${spec.binary}${ext}`);
 }
 function isGithubInstalled(spec, platform3) {
   for (const candidate of ghBinaryCandidates(spec, platform3)) {
     try {
-      if (statSync6(join16(ghBinDir(spec), candidate)).isFile())
+      if (statSync7(join17(ghBinDir(spec), candidate)).isFile())
         return true;
     } catch {}
   }
@@ -31363,8 +31576,8 @@ function ghBinaryCandidates(spec, platform3) {
 }
 function readGithubInstalledMetaIn(installDir) {
   try {
-    const path2 = join16(installDir, INSTALLED_META_FILE2);
-    if (!statSync6(path2).isFile())
+    const path2 = join17(installDir, INSTALLED_META_FILE2);
+    if (!statSync7(path2).isFile())
       return null;
     const parsed = JSON.parse(readFileSync12(path2, "utf8"));
     if (typeof parsed.version !== "string" || parsed.version.length === 0)
@@ -31390,7 +31603,7 @@ function writeGithubInstalledMetaIn(installDir, version2, binarySha256, archiveS
       binarySha256,
       ...archiveSha256 ? { archiveSha256 } : {}
     };
-    writeFileSync8(join16(installDir, INSTALLED_META_FILE2), JSON.stringify(meta3), "utf8");
+    writeFileSync8(join17(installDir, INSTALLED_META_FILE2), JSON.stringify(meta3), "utf8");
   } catch (err) {
     warn2(`[lsp] failed to write github installed metadata in ${installDir}: ${err}`);
   }
@@ -31583,7 +31796,7 @@ async function downloadFile(url2, destPath, fetchImpl, assetSize, signal) {
     if (Number.isFinite(advertised) && advertised > MAX_DOWNLOAD_BYTES3) {
       throw new Error(`Content-Length ${advertised} exceeds max ${MAX_DOWNLOAD_BYTES3}`);
     }
-    mkdirSync9(dirname7(destPath), { recursive: true });
+    mkdirSync9(dirname8(destPath), { recursive: true });
     let bytesWritten = 0;
     const guard = new TransformStream({
       transform(chunk, controller) {
@@ -31634,12 +31847,12 @@ function validateExtraction(stagingRoot) {
   const walk = (dir) => {
     let entries;
     try {
-      entries = readdirSync3(dir);
+      entries = readdirSync4(dir);
     } catch (err) {
       throw new Error(`failed to read staging dir ${dir}: ${err}`);
     }
     for (const entry of entries) {
-      const full = join16(dir, entry);
+      const full = join17(dir, entry);
       let lst;
       try {
         lst = lstatSync2(full);
@@ -31727,10 +31940,10 @@ function extractArchiveSafely(archivePath, destDir, archiveType) {
 }
 function quarantineCachedGithubInstall(spec, reason) {
   const packageDir = ghPackageDir(spec);
-  const dest = join16(ghCacheRoot(), ".quarantine", encodeURIComponent(spec.id), `${Date.now()}`);
+  const dest = join17(ghCacheRoot(), ".quarantine", encodeURIComponent(spec.id), `${Date.now()}`);
   warn2(`[lsp] tofu_mismatch ${spec.id}: ${reason}; quarantining ${packageDir} -> ${dest}`);
   try {
-    mkdirSync9(dirname7(dest), { recursive: true });
+    mkdirSync9(dirname8(dest), { recursive: true });
     rmSync6(dest, { recursive: true, force: true });
     renameSync7(packageDir, dest);
   } catch (err) {
@@ -31740,9 +31953,9 @@ function quarantineCachedGithubInstall(spec, reason) {
 function validateCachedGithubInstall(spec, platform3) {
   const packageDir = ghPackageDir(spec);
   const meta3 = readGithubInstalledMetaIn(packageDir);
-  const binaryPath = ghBinaryCandidates(spec, platform3).map((candidate) => join16(ghBinDir(spec), candidate)).find((candidate) => {
+  const binaryPath = ghBinaryCandidates(spec, platform3).map((candidate) => join17(ghBinDir(spec), candidate)).find((candidate) => {
     try {
-      return statSync6(candidate).isFile();
+      return statSync7(candidate).isFile();
     } catch {
       return false;
     }
@@ -31818,7 +32031,7 @@ async function downloadAndInstall(spec, tag, assets, platform3, arch, fetchImpl,
   }
   const pkgDir = ghPackageDir(spec);
   const extractDir = ghExtractDir(spec);
-  const archivePath = join16(pkgDir, expected.name);
+  const archivePath = join17(pkgDir, expected.name);
   log2(`[lsp] downloading ${spec.id} ${tag} → ${matchingAsset.url}`);
   try {
     await downloadFile(matchingAsset.url, archivePath, fetchImpl, matchingAsset.size, signal);
@@ -31858,13 +32071,13 @@ async function downloadAndInstall(spec, tag, assets, platform3, arch, fetchImpl,
       unlinkSync6(archivePath);
     } catch {}
   }
-  const innerBinaryPath = join16(extractDir, spec.binaryPathInArchive(platform3, arch, version2));
+  const innerBinaryPath = join17(extractDir, spec.binaryPathInArchive(platform3, arch, version2));
   if (!existsSync12(innerBinaryPath)) {
     error2(`[lsp] ${spec.id}: extracted binary not found at ${innerBinaryPath}`);
     return null;
   }
   const targetBinary = ghBinaryPath(spec, platform3);
-  mkdirSync9(dirname7(targetBinary), { recursive: true });
+  mkdirSync9(dirname8(targetBinary), { recursive: true });
   try {
     copyFileSync4(innerBinaryPath, targetBinary);
     if (platform3 !== "win32") {
@@ -32192,18 +32405,18 @@ function writeTerminal(terminal, data) {
 import { randomBytes as randomBytes2 } from "node:crypto";
 import { mkdirSync as mkdirSync10, renameSync as renameSync8, unlinkSync as unlinkSync7, writeFileSync as writeFileSync9 } from "node:fs";
 import { createServer } from "node:http";
-import { dirname as dirname8, join as join18 } from "node:path";
+import { dirname as dirname9, join as join19 } from "node:path";
 
 // src/shared/rpc-utils.ts
 import { createHash as createHash6 } from "node:crypto";
-import { join as join17 } from "node:path";
+import { join as join18 } 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 join17(storageDir, "rpc", hash2, "ports");
+  return join18(storageDir, "rpc", hash2, "ports");
 }
 
 // src/shared/rpc-server.ts
@@ -32218,7 +32431,7 @@ class AftRpcServer {
   constructor(storageDir, directory) {
     this.portsDir = rpcPortFileDir(storageDir, directory);
     this.instanceId = randomBytes2(8).toString("hex");
-    this.portFilePath = join18(this.portsDir, `${this.instanceId}.json`);
+    this.portFilePath = join19(this.portsDir, `${this.instanceId}.json`);
   }
   handle(method, handler) {
     this.handlers.set(method, handler);
@@ -32240,7 +32453,7 @@ class AftRpcServer {
         this.token = randomBytes2(32).toString("hex");
         this.server = server;
         try {
-          const dir = dirname8(this.portFilePath);
+          const dir = dirname9(this.portFilePath);
           mkdirSync10(dir, { recursive: true, mode: 448 });
           const tmpPath = `${this.portFilePath}.tmp`;
           writeFileSync9(tmpPath, JSON.stringify({ port: this.port, token: this.token }), {
@@ -32575,20 +32788,20 @@ function formatStatusMarkdown(status) {
 // src/shared/tui-config.ts
 var import_comment_json4 = __toESM(require_src2(), 1);
 import { existsSync as existsSync13, mkdirSync as mkdirSync11, readFileSync as readFileSync13, writeFileSync as writeFileSync10 } from "node:fs";
-import { dirname as dirname9, join as join20 } from "node:path";
+import { dirname as dirname10, join as join21 } from "node:path";
 
 // src/shared/opencode-config-dir.ts
-import { homedir as homedir10 } from "node:os";
-import { join as join19, resolve as resolve4 } from "node:path";
+import { homedir as homedir11 } from "node:os";
+import { join as join20, resolve as resolve4 } from "node:path";
 function getCliConfigDir() {
   const envConfigDir = process.env.OPENCODE_CONFIG_DIR?.trim();
   if (envConfigDir) {
     return resolve4(envConfigDir);
   }
   if (process.platform === "win32") {
-    return join19(homedir10(), ".config", "opencode");
+    return join20(homedir11(), ".config", "opencode");
   }
-  return join19(process.env.XDG_CONFIG_HOME || join19(homedir10(), ".config"), "opencode");
+  return join20(process.env.XDG_CONFIG_HOME || join20(homedir11(), ".config"), "opencode");
 }
 function getOpenCodeConfigDir2(_options) {
   return getCliConfigDir();
@@ -32597,10 +32810,10 @@ function getOpenCodeConfigPaths(options) {
   const configDir = getOpenCodeConfigDir2(options);
   return {
     configDir,
-    configJson: join19(configDir, "opencode.json"),
-    configJsonc: join19(configDir, "opencode.jsonc"),
-    packageJson: join19(configDir, "package.json"),
-    omoConfig: join19(configDir, "magic-context.jsonc")
+    configJson: join20(configDir, "opencode.json"),
+    configJsonc: join20(configDir, "opencode.jsonc"),
+    packageJson: join20(configDir, "package.json"),
+    omoConfig: join20(configDir, "magic-context.jsonc")
   };
 }
 
@@ -32609,8 +32822,8 @@ var PLUGIN_NAME = "@cortexkit/aft-opencode";
 var PLUGIN_ENTRY = `${PLUGIN_NAME}@latest`;
 function resolveTuiConfigPath() {
   const configDir = getOpenCodeConfigPaths({ binary: "opencode" }).configDir;
-  const jsoncPath = join20(configDir, "tui.jsonc");
-  const jsonPath = join20(configDir, "tui.json");
+  const jsoncPath = join21(configDir, "tui.jsonc");
+  const jsonPath = join21(configDir, "tui.json");
   if (existsSync13(jsoncPath))
     return jsoncPath;
   if (existsSync13(jsonPath))
@@ -32630,7 +32843,7 @@ function ensureTuiPluginEntry() {
     }
     plugins.push(PLUGIN_ENTRY);
     config2.plugin = plugins;
-    mkdirSync11(dirname9(configPath), { recursive: true });
+    mkdirSync11(dirname10(configPath), { recursive: true });
     writeFileSync10(configPath, `${import_comment_json4.stringify(config2, null, 2)}
 `);
     log2(`[aft-plugin] added TUI plugin entry to ${configPath}`);
@@ -32718,6 +32931,7 @@ 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 { tool as tool2 } from "@opencode-ai/plugin";
 var z2 = tool2.schema;
@@ -32830,8 +33044,19 @@ async function resolveProjectRoot(ctx, runtime) {
   }
   return projectRootFor(runtime);
 }
+function expandTilde(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 input;
+}
 function resolvePathFromProjectRoot(projectRoot, target) {
-  return path2.isAbsolute(target) ? target : path2.resolve(projectRoot, target);
+  const expanded = expandTilde(target);
+  return path2.isAbsolute(expanded) ? expanded : path2.resolve(projectRoot, expanded);
 }
 async function resolvePathArg(ctx, runtime, target) {
   return resolvePathFromProjectRoot(await resolveProjectRoot(ctx, runtime), target);
@@ -34912,7 +35137,7 @@ function createEditTool(ctx, writeToolName = "write") {
         if (response.success === false) {
           throw new Error(response.message ?? "transaction failed");
         }
-        return JSON.stringify(response);
+        return formatEditSummary(response);
       }
       const file2 = args.filePath;
       if (!file2)
@@ -34999,12 +35224,7 @@ function createEditTool(ctx, writeToolName = "write") {
           });
         }
       }
-      const agentData = { ...data };
-      if (agentData.diff && typeof agentData.diff === "object") {
-        const d = agentData.diff;
-        agentData.diff = { additions: d.additions ?? 0, deletions: d.deletions ?? 0 };
-      }
-      let result = JSON.stringify(agentData);
+      let result = formatEditSummary(data);
       const globSkipNote = formatGlobSkipReasonsNote(data.format_skip_reasons);
       if (globSkipNote)
         result += `
@@ -36547,18 +36767,7 @@ function safetyTools(ctx) {
 
 // src/tools/search.ts
 import * as fs7 from "node:fs";
-import * as os2 from "node:os";
 import * as path6 from "node:path";
-function expandTilde(input) {
-  if (!input || !input.startsWith("~"))
-    return input;
-  if (input === "~")
-    return os2.homedir();
-  if (input.startsWith("~/") || input.startsWith(`~${path6.sep}`)) {
-    return path6.resolve(os2.homedir(), input.slice(2));
-  }
-  return input;
-}
 function arg2(schema) {
   return schema;
 }
@@ -36772,6 +36981,14 @@ function semanticHonestyNote(response) {
     notes.push("partial/incomplete");
   return notes.length > 0 ? `Search status: ${notes.join("; ")}.` : undefined;
 }
+function extraHonestyNote(response) {
+  const notes = [];
+  if (response.fully_degraded === true)
+    notes.push("fully degraded");
+  if (response.complete === false)
+    notes.push("partial/incomplete");
+  return notes.length > 0 ? `Search status: ${notes.join("; ")}.` : undefined;
+}
 function arg3(schema) {
   return schema;
 }
@@ -36823,24 +37040,12 @@ function semanticTools(ctx) {
         const code = typeof response.code === "string" && response.code.length > 0 ? response.code : undefined;
         throw new Error(code ? `semantic_search: ${code} — ${message}` : message);
       }
-      const honestyNote = semanticHonestyNote(response);
-      if (typeof response.text === "string" && response.status === "disabled" && Array.isArray(response.results) && response.results.length === 0) {
-        return honestyNote ? `${response.text}
-${honestyNote}` : response.text;
-      }
-      const structured = JSON.stringify(response, null, 2);
       if (typeof response.text === "string" && response.text.length > 0) {
-        const display = honestyNote ? `${response.text}
-${honestyNote}` : response.text;
-        return `${display}
-
-Structured response:
-${structured}`;
+        const note = extraHonestyNote(response);
+        return note ? `${response.text}
+${note}` : response.text;
       }
-      return honestyNote ? `${honestyNote}
-
-Structured response:
-${structured}` : structured;
+      return semanticHonestyNote(response) ?? "No results.";
     }
   };
   return {