@cortexkit/aft 0.56.2 → 0.57.1

package/dist/index.js

@@ -2717,11 +2717,34 @@ var init_npm_resolver = __esm(() => {
   };
 });
 
-// ../aft-bridge/dist/onnx-runtime.js
+// ../aft-bridge/dist/tar-executable.js
 import { execFileSync } from "node:child_process";
+import { existsSync as existsSync4 } from "node:fs";
+import { join as join7 } from "node:path";
+function windowsTarExecutable(options = {}) {
+  const platform = options.platform ?? process.platform;
+  if (platform !== "win32")
+    return "tar";
+  const env = options.env ?? process.env;
+  const systemTar = join7(env.SystemRoot ?? "C:\\Windows", "System32", "tar.exe");
+  return (options.exists ?? existsSync4)(systemTar) ? systemTar : "tar";
+}
+function execTarExtractionSync(args, timeout) {
+  const executable = windowsTarExecutable();
+  try {
+    execFileSync(executable, args, { stdio: "pipe", timeout });
+  } catch (cause) {
+    const detail = cause instanceof Error ? cause.message : String(cause);
+    throw new Error(`tar extraction failed using ${executable}: ${detail}`, { cause });
+  }
+}
+var init_tar_executable = () => {};
+
+// ../aft-bridge/dist/onnx-runtime.js
+import { execFileSync as execFileSync2 } from "node:child_process";
 import { createHash as createHash3 } from "node:crypto";
-import { chmodSync as chmodSync3, closeSync as closeSync3, copyFileSync as copyFileSync3, createWriteStream as createWriteStream2, existsSync as existsSync4, lstatSync, mkdirSync as mkdirSync3, openSync as openSync3, readdirSync as readdirSync3, readFileSync as readFileSync4, readlinkSync, realpathSync, rmSync as rmSync2, statSync as statSync3, symlinkSync, unlinkSync as unlinkSync3, writeFileSync } from "node:fs";
-import { basename, dirname as dirname3, isAbsolute as isAbsolute3, join as join7, relative, resolve as resolve4, win32 } from "node:path";
+import { chmodSync as chmodSync3, closeSync as closeSync3, copyFileSync as copyFileSync3, createWriteStream as createWriteStream2, existsSync as existsSync5, lstatSync, mkdirSync as mkdirSync3, openSync as openSync3, readdirSync as readdirSync3, readFileSync as readFileSync4, readlinkSync, realpathSync, renameSync as renameSync3, rmSync as rmSync2, statSync as statSync3, symlinkSync, unlinkSync as unlinkSync3, writeFileSync } from "node:fs";
+import { basename, dirname as dirname3, isAbsolute as isAbsolute3, join as join8, relative, resolve as resolve4, win32 } from "node:path";
 import { Readable as Readable2 } from "node:stream";
 import { pipeline as pipeline2 } from "node:stream/promises";
 function getPlatformInfo() {
@@ -2733,6 +2756,9 @@ function getPlatformInfo() {
   const ortArch = platformKey ? platformKey.split("-")[1] : process.arch;
   return platformMap[ortArch] || null;
 }
+function isOrtAutoDownloadSupported() {
+  return getPlatformInfo() !== null;
+}
 function getManualInstallHint() {
   if (process.platform === "darwin" && process.arch === "x64") {
     return "brew install onnxruntime";
@@ -2744,11 +2770,11 @@ 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);
-  if (existsSync4(libPath)) {
+  const libPath = join8(resolvedOrtDir, libName);
+  if (existsSync5(libPath)) {
     const meta = readOnnxInstalledMeta(ortVersionDir);
     if (meta?.sha256) {
       try {
@@ -2777,9 +2803,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");
   mkdirSync3(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.`);
@@ -2798,7 +2824,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;
@@ -2835,7 +2861,7 @@ function cleanupAbandonedStagingDirs(onnxBaseDir) {
 }
 function cleanupIncompleteTargetIfUnowned(ortDir) {
   try {
-    if (existsSync4(ortDir) && !existsSync4(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 });
     }
@@ -2876,8 +2902,8 @@ function detectOnnxVersion(libDir, libName) {
       if (version)
         return version;
     }
-    const base = join7(libDir, libName);
-    if (existsSync4(base)) {
+    const base = join8(libDir, libName);
+    if (existsSync5(base)) {
       try {
         const real = realpathSync(base);
         const version = parseOnnxVersionFromPath(real) ?? parseOnnxVersionFromDirectoryPath(real);
@@ -2943,10 +2969,10 @@ function directoryContainsLibrary(dir, libName) {
   }
 }
 function resolveCachedOnnxRuntimeDir(ortVersionDir, libName) {
-  if (existsSync4(join7(ortVersionDir, libName)))
+  if (existsSync5(join8(ortVersionDir, libName)))
     return ortVersionDir;
-  const libSubdir = join7(ortVersionDir, "lib");
-  if (existsSync4(join7(libSubdir, libName)))
+  const libSubdir = join8(ortVersionDir, "lib");
+  if (existsSync5(join8(libSubdir, libName)))
     return libSubdir;
   return ortVersionDir;
 }
@@ -2961,13 +2987,13 @@ function findSystemOnnxRuntime(libName) {
   } else if (process.platform === "win32") {
     const programFiles = process.env.ProgramFiles ?? "C:\\Program Files";
     const programFilesX86 = process.env["ProgramFiles(x86)"] ?? "C:\\Program Files (x86)";
-    searchPaths.push(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");
-      if (!existsSync4(nugetPackageDir))
+      const nugetPackageDir = join8(userProfile, ".nuget", "packages", "microsoft.ml.onnxruntime");
+      if (!existsSync5(nugetPackageDir))
         return nugetPaths;
       try {
         for (const entry of readdirSync3(nugetPackageDir, { withFileTypes: true })) {
@@ -2975,7 +3001,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)}`);
@@ -2997,11 +3023,11 @@ 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;
-    } else if (!existsSync4(libPath)) {
+    } else if (!existsSync5(libPath)) {
       continue;
     }
     const version = detectOnnxVersion(dir, libName);
@@ -3067,7 +3093,7 @@ function validateExtractedTree(stagingRoot) {
   const walk = (dir) => {
     const entries = readdirSync3(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);
@@ -3100,34 +3126,32 @@ async function downloadOnnxRuntime(info, targetDir) {
   const url = `https://github.com/${ORT_REPO}/releases/download/v${ORT_VERSION}/${info.assetName}.${info.archiveType === "tgz" ? "tgz" : "zip"}`;
   log(`Downloading ONNX Runtime v${ORT_VERSION} for ${process.platform}/${process.arch}...`);
   const tmpDir = `${targetDir}.tmp.${process.pid}.${Date.now().toString(36)}`;
+  const extractionRoot = join8(tmpDir, "extract");
+  const stagedInstallDir = join8(tmpDir, "install");
   try {
-    mkdirSync3(tmpDir, { recursive: true });
-    const archivePath = join7(tmpDir, `onnxruntime.${info.archiveType}`);
+    mkdirSync3(extractionRoot, { recursive: true });
+    const archivePath = join8(tmpDir, `onnxruntime.${info.archiveType}`);
     await downloadFileWithCap(url, archivePath);
     const archiveSha256 = sha256File(archivePath);
     log(`ONNX Runtime archive sha256=${archiveSha256}`);
     if (info.archiveType === "tgz") {
-      execFileSync("tar", ["xzf", archivePath, "-C", tmpDir], {
-        stdio: "pipe",
-        timeout: 120000
-      });
+      execTarExtractionSync(["xzf", archivePath, "-C", extractionRoot], 120000);
     } else {
-      await extractZipArchive(archivePath, tmpDir);
+      await extractZipArchive(archivePath, extractionRoot);
     }
     try {
       unlinkSync3(archivePath);
     } catch {}
-    validateExtractedTree(tmpDir);
-    const extractedDir = join7(tmpDir, info.assetName, "lib");
-    if (!existsSync4(extractedDir)) {
+    validateExtractedTree(extractionRoot);
+    const extractedDir = join8(extractionRoot, info.assetName, "lib");
+    if (!existsSync5(extractedDir)) {
       throw new Error(`Expected directory not found: ${extractedDir}`);
     }
-    mkdirSync3(targetDir, { recursive: true });
     const libFiles = readdirSync3(extractedDir).filter((f) => f.startsWith("libonnxruntime") || f.startsWith("onnxruntime"));
     const realFiles = [];
     const symlinks = [];
     for (const libFile of libFiles) {
-      const src = 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}`);
@@ -3141,15 +3165,11 @@ async function downloadOnnxRuntime(info, targetDir) {
         realFiles.push(libFile);
       }
     }
-    copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks);
-    const libPath = join7(targetDir, info.libName);
-    let libHash = null;
-    try {
-      libHash = sha256File(libPath);
-    } catch (err) {
-      warn(`Could not hash newly-installed ONNX library at ${libPath}: ${err}`);
-    }
-    writeOnnxInstalledMeta(targetDir, ORT_VERSION, libHash, archiveSha256);
+    copyOnnxLibraries(info, extractedDir, stagedInstallDir, realFiles, symlinks);
+    const libPath = join8(stagedInstallDir, info.libName);
+    const libHash = sha256File(libPath);
+    writeOnnxInstalledMeta(stagedInstallDir, ORT_VERSION, libHash, archiveSha256);
+    publishOnnxRuntime(stagedInstallDir, targetDir);
     rmSync2(tmpDir, { recursive: true, force: true });
     log(`ONNX Runtime v${ORT_VERSION} installed to ${targetDir}`);
     return targetDir;
@@ -3158,17 +3178,39 @@ async function downloadOnnxRuntime(info, targetDir) {
     try {
       rmSync2(tmpDir, { recursive: true, force: true });
     } catch {}
-    try {
-      rmSync2(targetDir, { recursive: true, force: true });
-    } catch {}
     return null;
   }
 }
+function publishOnnxRuntime(stagedInstallDir, targetDir) {
+  const backupDir = `${targetDir}.backup.${process.pid}.${Date.now().toString(36)}`;
+  const hadTarget = existsSync5(targetDir);
+  if (hadTarget)
+    renameSync3(targetDir, backupDir);
+  try {
+    renameSync3(stagedInstallDir, targetDir);
+  } catch (installError) {
+    if (hadTarget) {
+      try {
+        renameSync3(backupDir, targetDir);
+      } catch (restoreError) {
+        throw new Error(`ONNX Runtime replacement failed and the previous runtime could not be restored from ${backupDir}: ${restoreError}`, { cause: installError });
+      }
+    }
+    throw installError;
+  }
+  if (hadTarget) {
+    try {
+      rmSync2(backupDir, { recursive: true, force: true });
+    } catch (err) {
+      warn(`Could not remove replaced ONNX Runtime backup at ${backupDir}: ${err}`);
+    }
+  }
+}
 function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, copyFile = copyFileSync3) {
   const requiredLibs = new Set([info.libName]);
   for (const libFile of realFiles) {
-    const src = 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") {
@@ -3184,11 +3226,11 @@ 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 dstForContainment = join8(targetRoot, link.name);
     const resolvedTarget = resolve4(dirname3(dstForContainment), link.target);
     if (!isPathInsideRoot(targetRoot, resolvedTarget)) {
       const message = `ONNX Runtime symlink ${link.name} points outside install dir: ${link.target}`;
@@ -3209,21 +3251,18 @@ function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, c
       log(`ORT extract: failed to symlink optional ${link.name}: ${symlinkErr}`);
     }
   }
-  const requiredPath = join7(targetDir, info.libName);
-  if (!existsSync4(requiredPath)) {
+  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}`);
   }
 }
 async function extractZipArchive(archivePath, destinationDir) {
   if (process.platform === "win32") {
-    execFileSync("tar.exe", ["-xf", archivePath, "-C", destinationDir], {
-      stdio: "pipe",
-      timeout: 120000
-    });
+    execTarExtractionSync(["-xf", archivePath, "-C", destinationDir], 120000);
     return;
   }
-  execFileSync("unzip", ["-q", archivePath, "-d", destinationDir], {
+  execFileSync2("unzip", ["-q", archivePath, "-d", destinationDir], {
     stdio: "pipe",
     timeout: 120000
   });
@@ -3236,13 +3275,13 @@ function writeOnnxInstalledMeta(installDir, version, sha256, archiveSha256) {
       ...sha256 ? { sha256 } : {},
       archiveSha256
     };
-    writeFileSync(join7(installDir, ONNX_INSTALLED_META_FILE), JSON.stringify(meta), "utf8");
+    writeFileSync(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 path = join8(installDir, ONNX_INSTALLED_META_FILE);
   try {
     if (!statSync3(path).isFile())
       return null;
@@ -3354,7 +3393,7 @@ function isWindowsProcessAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0)
     return false;
   try {
-    const output = execFileSync("tasklist.exe", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], {
+    const output = execFileSync2("tasklist.exe", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], {
       encoding: "utf8",
       timeout: 2000,
       windowsHide: true
@@ -3382,6 +3421,7 @@ var ORT_VERSION = "1.24.4", ORT_REPO = "microsoft/onnxruntime", MAX_DOWNLOAD_BYT
 var init_onnx_runtime = __esm(() => {
   init_active_logger();
   init_platform();
+  init_tar_executable();
   MAX_DOWNLOAD_BYTES2 = 256 * 1024 * 1024;
   MAX_EXTRACT_BYTES = 1 * 1024 * 1024 * 1024;
   STALE_LOCK_MS = 5 * 60 * 1000;
@@ -3442,6 +3482,14 @@ var init_path_aliases = __esm(() => {
   ]);
   MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
 });
+
+// ../aft-bridge/dist/semantic-status.js
+var SEMANTIC_PROGRESS_STATUSES, SEMANTIC_READY_STATUSES, SEMANTIC_INACTIVE_STATUSES;
+var init_semantic_status = __esm(() => {
+  SEMANTIC_PROGRESS_STATUSES = new Set(["building", "loading"]);
+  SEMANTIC_READY_STATUSES = new Set(["ready", "empty"]);
+  SEMANTIC_INACTIVE_STATUSES = new Set(["disabled", "busy"]);
+});
 // ../aft-bridge/dist/index.js
 var init_dist2 = __esm(() => {
   init_active_logger();
@@ -3467,8 +3515,10 @@ var init_dist2 = __esm(() => {
   init_project_identity();
   init_resolver();
   init_revivable_transport();
+  init_semantic_status();
   init_storage_paths();
   init_subc_transport();
+  init_tar_executable();
   init_transport_factory();
 });
 
@@ -3485,10 +3535,10 @@ var init_paths2 = __esm(() => {
 
 // src/lib/binary-probe.ts
 import { execSync, spawnSync as spawnSync3 } from "node:child_process";
-import { existsSync as existsSync5 } from "node:fs";
+import { existsSync as existsSync6, readdirSync as readdirSync4 } from "node:fs";
 import { createRequire } from "node:module";
 import { homedir as homedir6 } from "node:os";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 async function loadPluginVersion() {
   try {
     const bridge = await Promise.resolve().then(() => (init_dist2(), {}));
@@ -3540,7 +3590,7 @@ function probeAftBinary(preferredVersion) {
   const candidates = [];
   for (const candidate of aftBinaryCandidates(preferredVersion)) {
     try {
-      if (!existsSync5(candidate))
+      if (!existsSync6(candidate))
         continue;
       const result = spawnSync3(candidate, ["--version"], {
         stdio: ["ignore", "pipe", "pipe"],
@@ -3591,7 +3641,7 @@ function pushCandidate(candidates, candidate) {
 function firstExisting(candidates) {
   for (const candidate of candidates) {
     try {
-      if (!existsSync5(candidate))
+      if (!existsSync6(candidate))
         continue;
       return candidate;
     } catch {}
@@ -3606,52 +3656,148 @@ function platformKey2(platform = process.platform, arch = process.arch) {
   };
   return table[platform]?.[arch] ?? null;
 }
-function aftBinaryCandidates(preferredVersion) {
-  const candidates = [];
+function newestCachedBinary(cacheDir, binaryName) {
+  let entries;
+  try {
+    entries = readdirSync4(cacheDir);
+  } catch {
+    return null;
+  }
+  let best = null;
+  for (const entry of entries) {
+    const version = entry.match(CACHE_VERSION_DIR)?.[1];
+    if (!version)
+      continue;
+    const path = join9(cacheDir, entry, binaryName);
+    try {
+      if (!existsSync6(path))
+        continue;
+    } catch {
+      continue;
+    }
+    if (!best || compareSemver(version, best.version) > 0)
+      best = { version, path };
+  }
+  return best?.path ?? null;
+}
+function cacheLocation(preferredVersion) {
+  const cacheDir = getAftBinaryCacheDir();
+  const binaryName = getAftBinaryName();
+  const label = "binary cache";
+  const installedHere = "`aft doctor --fix` installs here";
   if (preferredVersion) {
     const tag = preferredVersion.startsWith("v") ? preferredVersion : `v${preferredVersion}`;
-    pushCandidate(candidates, join8(getAftBinaryCacheDir(), tag, getAftBinaryName()));
+    return {
+      label,
+      paths: [join9(cacheDir, tag, binaryName)],
+      emptyReason: `no ${tag}/${binaryName} under ${cacheDir} (${installedHere})`
+    };
   }
+  const newest = newestCachedBinary(cacheDir, binaryName);
+  return {
+    label,
+    paths: newest ? [newest] : [],
+    emptyReason: `no v<version>/${binaryName} under ${cacheDir} (${installedHere})`
+  };
+}
+function platformPackageLocation() {
+  const label = "npm platform package";
   const key = platformKey2();
-  if (key) {
-    try {
-      const require2 = createRequire(import.meta.url);
-      pushCandidate(candidates, require2.resolve(`@cortexkit/aft-${key}/bin/${getAftBinaryName()}`));
-    } catch {}
+  if (!key) {
+    return {
+      label,
+      paths: [],
+      emptyReason: `no package published for ${process.platform}-${process.arch}`
+    };
   }
+  const packageName = `@cortexkit/aft-${key}`;
+  try {
+    const require2 = createRequire(import.meta.url);
+    return {
+      label,
+      paths: [require2.resolve(`${packageName}/bin/${getAftBinaryName()}`)],
+      emptyReason: `${packageName} not installed`
+    };
+  } catch {
+    return { label, paths: [], emptyReason: `${packageName} not installed` };
+  }
+}
+function pathLocation() {
+  const lookup = process.platform === "win32" ? "where aft" : "which aft";
+  const label = "PATH";
+  let hits = [];
   try {
-    const lookup = process.platform === "win32" ? "where aft" : "which aft";
     const resolved = execSync(lookup, {
       stdio: "pipe",
       encoding: "utf-8",
       env: process.env
     }).trim();
-    for (const line of resolved.split(/\r?\n/)) {
-      const candidate = line.trim();
-      if (candidate && isNativeExecutable(candidate)) {
-        pushCandidate(candidates, candidate);
-      }
-    }
+    hits = resolved.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
   } catch {}
-  pushCandidate(candidates, join8(homedir6(), ".cargo", "bin", getAftBinaryName()));
+  const native = hits.filter((candidate) => isNativeExecutable(candidate));
+  return {
+    label,
+    paths: native,
+    emptyReason: hits.length > 0 ? `only non-native \`aft\` entries on PATH (${hits.join(", ")}), skipped because running them would re-enter this CLI` : `no \`aft\` on PATH (\`${lookup}\` found nothing)`
+  };
+}
+function cargoLocation() {
+  const path = join9(homedir6(), ".cargo", "bin", getAftBinaryName());
+  return { label: "cargo install", paths: [path], emptyReason: `no ${path}` };
+}
+function aftBinarySearchLocations(preferredVersion) {
+  return [
+    cacheLocation(preferredVersion),
+    platformPackageLocation(),
+    pathLocation(),
+    cargoLocation()
+  ];
+}
+function aftBinaryCandidates(preferredVersion) {
+  const candidates = [];
+  for (const location of aftBinarySearchLocations(preferredVersion)) {
+    for (const path of location.paths)
+      pushCandidate(candidates, path);
+  }
   return candidates;
 }
+function describeAftBinarySearch(preferredVersion) {
+  return aftBinarySearchLocations(preferredVersion).map((location) => {
+    const found = location.paths.filter((path) => {
+      try {
+        return existsSync6(path);
+      } catch {
+        return false;
+      }
+    });
+    return `${location.label}: ${found.length > 0 ? found.join(", ") : location.emptyReason}`;
+  });
+}
+function missingAftBinaryMessage(command, preferredVersion) {
+  return [
+    `${command} requires a native AFT binary and none was found. Searched:`,
+    ...describeAftBinarySearch(preferredVersion).map((line) => `  - ${line}`),
+    "`aft doctor --fix` installs into the binary cache directory named above; if it already reported success, that line is the directory this command searched — AFT_CACHE_DIR and XDG_CACHE_HOME change it."
+  ].join(`
+`);
+}
 function findAftBinary(preferredVersion) {
   return firstExisting(aftBinaryCandidates(preferredVersion));
 }
-var PLUGIN_VERSION, VERSION_LINE;
+var PLUGIN_VERSION, VERSION_LINE, CACHE_VERSION_DIR;
 var init_binary_probe = __esm(async () => {
   init_dist2();
   init_paths2();
   PLUGIN_VERSION = await loadPluginVersion();
   VERSION_LINE = /^(?:aft\s+)?v?(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)$/i;
+  CACHE_VERSION_DIR = /^v(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)$/;
 });
 
 // src/lib/fs-util.ts
-import { existsSync as existsSync6, readdirSync as readdirSync4, statSync as statSync4 } from "node:fs";
-import { join as join9 } from "node:path";
+import { existsSync as existsSync7, readdirSync as readdirSync5, statSync as statSync4 } from "node:fs";
+import { join as join10 } from "node:path";
 function dirSize(path) {
-  if (!existsSync6(path)) {
+  if (!existsSync7(path)) {
     return 0;
   }
   const stat = statSync4(path);
@@ -3662,8 +3808,8 @@ function dirSize(path) {
     return 0;
   }
   let total = 0;
-  for (const entry of readdirSync4(path)) {
-    total += dirSize(join9(path, entry));
+  for (const entry of readdirSync5(path)) {
+    total += dirSize(join10(path, entry));
   }
   return total;
 }
@@ -3680,9 +3826,9 @@ function compareVersionLabels(a, b) {
 var init_fs_util = () => {};
 
 // src/lib/omp-paths.ts
-import { existsSync as existsSync7 } from "node:fs";
+import { existsSync as existsSync8 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
-import { join as join10, resolve as resolve5 } from "node:path";
+import { join as join11, resolve as resolve5 } from "node:path";
 function envFirstHomeDir() {
   return process.env.HOME?.trim() || homedir7();
 }
@@ -3690,9 +3836,9 @@ function resolveOmpPaths() {
   const normalizedProfile = (process.env.OMP_PROFILE ?? process.env.PI_PROFILE)?.trim();
   const profile = normalizedProfile && normalizedProfile !== "default" && /^[a-z0-9][a-z0-9._-]{0,63}$/.test(normalizedProfile) ? normalizedProfile : undefined;
   const configDirName = process.env.PI_CONFIG_DIR?.trim() || ".omp";
-  const baseConfigRoot = join10(envFirstHomeDir(), configDirName);
-  const configRoot = profile ? join10(baseConfigRoot, "profiles", profile) : baseConfigRoot;
-  const defaultAgentDir = join10(configRoot, "agent");
+  const baseConfigRoot = join11(envFirstHomeDir(), configDirName);
+  const configRoot = profile ? join11(baseConfigRoot, "profiles", profile) : baseConfigRoot;
+  const defaultAgentDir = join11(configRoot, "agent");
   const configuredAgentDir = profile ? undefined : process.env.PI_CODING_AGENT_DIR?.trim();
   const agentDir = configuredAgentDir ? resolve5(configuredAgentDir) : defaultAgentDir;
   const canUseXdg = (process.platform === "linux" || process.platform === "darwin") && agentDir === defaultAgentDir;
@@ -3700,9 +3846,9 @@ function resolveOmpPaths() {
   if (canUseXdg) {
     const xdgDataHome = process.env.XDG_DATA_HOME?.trim();
     if (xdgDataHome) {
-      const appRoot = join10(xdgDataHome, "omp");
-      const candidate = profile ? join10(appRoot, "profiles", profile) : appRoot;
-      if (existsSync7(candidate))
+      const appRoot = join11(xdgDataHome, "omp");
+      const candidate = profile ? join11(appRoot, "profiles", profile) : appRoot;
+      if (existsSync8(candidate))
         dataRoot = candidate;
     }
   }
@@ -3712,8 +3858,8 @@ function resolveOmpPaths() {
     agentDir,
     dataRoot,
     dataAgentRoot,
-    pluginsDir: join10(dataRoot, "plugins"),
-    sessionsRoot: join10(dataAgentRoot, "sessions")
+    pluginsDir: join11(dataRoot, "plugins"),
+    sessionsRoot: join11(dataAgentRoot, "sessions")
   };
 }
 function getOmpAgentDir() {
@@ -3723,7 +3869,7 @@ function getOmpPluginsDir() {
   return resolveOmpPaths().pluginsDir;
 }
 function getOmpPluginsLockPath() {
-  return join10(getOmpPluginsDir(), "omp-plugins.lock.json");
+  return join11(getOmpPluginsDir(), "omp-plugins.lock.json");
 }
 function getOmpSessionsRoot() {
   return resolveOmpPaths().sessionsRoot;
@@ -3743,12 +3889,12 @@ var init_omp_paths = () => {};
 
 // src/lib/omp-helpers.ts
 import { spawnSync as spawnSync4 } from "node:child_process";
-import { accessSync, constants, existsSync as existsSync8, readFileSync as readFileSync5, statSync as statSync5 } from "node:fs";
+import { accessSync, constants, existsSync as existsSync9, readFileSync as readFileSync5, statSync as statSync5 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
-import { delimiter, extname, join as join11, resolve as resolve6 } from "node:path";
+import { delimiter, extname, join as join12, resolve as resolve6 } from "node:path";
 function isExecutableFile(path, platform = process.platform) {
   try {
-    if (!existsSync8(path) || !statSync5(path).isFile())
+    if (!existsSync9(path) || !statSync5(path).isFile())
       return false;
     accessSync(path, platform === "win32" ? constants.F_OK : constants.X_OK);
     return true;
@@ -3777,11 +3923,11 @@ function detectOmpPackageCli() {
   if (!packageDir || !findOnPath("bun"))
     return null;
   try {
-    const manifest = JSON.parse(readFileSync5(join11(packageDir, "package.json"), "utf8"));
+    const manifest = JSON.parse(readFileSync5(join12(packageDir, "package.json"), "utf8"));
     if (manifest.name !== OMP_HOST_PACKAGE)
       return null;
-    const cli = join11(packageDir, "dist", "cli.js");
-    return existsSync8(cli) ? cli : null;
+    const cli = join12(packageDir, "dist", "cli.js");
+    return existsSync9(cli) ? cli : null;
   } catch {
     return null;
   }
@@ -3801,13 +3947,13 @@ function getOmpCommandInvocation(ompPath, args) {
 }
 function getOmpFallbackCandidates(platform, home, appData) {
   if (platform !== "win32") {
-    return [join11(home, ".bun", "bin", "omp"), join11(home, ".local", "bin", "omp")];
+    return [join12(home, ".bun", "bin", "omp"), join12(home, ".local", "bin", "omp")];
   }
   const npmRoot = appData?.trim();
   return [
-    ...npmRoot ? [join11(npmRoot, "npm", "omp.cmd"), join11(npmRoot, "npm", "omp.exe")] : [],
-    join11(home, ".bun", "bin", "omp.exe"),
-    join11(home, ".bun", "bin", "omp.cmd")
+    ...npmRoot ? [join12(npmRoot, "npm", "omp.cmd"), join12(npmRoot, "npm", "omp.exe")] : [],
+    join12(home, ".bun", "bin", "omp.exe"),
+    join12(home, ".bun", "bin", "omp.cmd")
   ];
 }
 function detectOmpBinary() {
@@ -3888,8 +4034,8 @@ var init_omp_helpers = __esm(() => {
 });
 
 // src/adapters/omp.ts
-import { existsSync as existsSync9, readFileSync as readFileSync6 } from "node:fs";
-import { join as join12 } from "node:path";
+import { existsSync as existsSync10, readFileSync as readFileSync6 } from "node:fs";
+import { join as join13 } from "node:path";
 
 class OmpAdapter {
   kind = "omp";
@@ -3914,9 +4060,9 @@ class OmpAdapter {
     return {
       configDir,
       harnessConfig,
-      harnessConfigFormat: existsSync9(harnessConfig) ? "json" : "none",
+      harnessConfigFormat: existsSync10(harnessConfig) ? "json" : "none",
       aftConfig,
-      aftConfigFormat: existsSync9(aftConfig) ? "jsonc" : "none"
+      aftConfigFormat: existsSync10(aftConfig) ? "jsonc" : "none"
     };
   }
   hasPluginEntry() {
@@ -4007,7 +4153,7 @@ class OmpAdapter {
       path,
       cached: plugin?.version,
       latest: undefined,
-      exists: Boolean(plugin) || existsSync9(path)
+      exists: Boolean(plugin) || existsSync10(path)
     };
   }
   getStorageDir() {
@@ -4031,12 +4177,12 @@ class OmpAdapter {
   describeStorageSubtrees() {
     const storage = this.getStorageDir();
     return {
-      index: dirSize(join12(storage, "index")),
-      semantic: dirSize(join12(storage, "semantic")),
-      backups: dirSize(join12(storage, "backups")),
-      url_cache: dirSize(join12(storage, "url_cache")),
-      onnxruntime: dirSize(join12(storage, "onnxruntime")),
-      logs: dirSize(join12(storage, "logs"))
+      index: dirSize(join13(storage, "index")),
+      semantic: dirSize(join13(storage, "semantic")),
+      backups: dirSize(join13(storage, "backups")),
+      url_cache: dirSize(join13(storage, "url_cache")),
+      onnxruntime: dirSize(join13(storage, "onnxruntime")),
+      logs: dirSize(join13(storage, "logs"))
     };
   }
   readRuntimeEnabled(configPath) {
@@ -11830,21 +11976,21 @@ var require_src2 = __commonJS(function(exports, module) {
 });
 
 // src/lib/jsonc.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync2 } from "node:fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync2 } from "node:fs";
 import { dirname as dirname4 } from "node:path";
 function detectJsoncFile(configDir, baseName) {
   const jsoncPath = `${configDir}/${baseName}.jsonc`;
   const jsonPath = `${configDir}/${baseName}.json`;
-  if (existsSync10(jsoncPath)) {
+  if (existsSync11(jsoncPath)) {
     return { path: jsoncPath, format: "jsonc" };
   }
-  if (existsSync10(jsonPath)) {
+  if (existsSync11(jsonPath)) {
     return { path: jsonPath, format: "json" };
   }
   return { path: jsonPath, format: "none" };
 }
 function readJsoncFile(path) {
-  if (!existsSync10(path)) {
+  if (!existsSync11(path)) {
     return { value: null };
   }
   try {
@@ -11865,7 +12011,7 @@ function writeJsoncFile(path, value, format = "json") {
 `);
 }
 function ensureAftSchemaUrl(path, format) {
-  const existed = existsSync10(path);
+  const existed = existsSync11(path);
   if (!existed) {
     const writeFormat = format === "jsonc" ? "jsonc" : "json";
     writeJsoncFile(path, { $schema: AFT_SCHEMA_URL }, writeFormat);
@@ -11922,62 +12068,130 @@ var opencode_version_default = `1.18.30
 var init_opencode_version = () => {};
 
 // src/setup/opencode-config.ts
+function openCodePluginKey(generation) {
+  return generation === "v2" ? "plugins" : "plugin";
+}
+function otherOpenCodePluginKey(key) {
+  return key === "plugins" ? "plugin" : "plugins";
+}
+function openCodePluginReadKeys(generation) {
+  if (generation === "v1")
+    return ["plugin"];
+  if (generation === "v2")
+    return ["plugins"];
+  return ["plugin", "plugins"];
+}
 function pinnedPluginEntry(version) {
   return `${AFT_OPENCODE_PACKAGE}@${version}`;
 }
 function isAftNpmEntry(entry) {
   return typeof entry === "string" && (entry === AFT_OPENCODE_PACKAGE || entry.startsWith(`${AFT_OPENCODE_PACKAGE}@`));
 }
-function ensurePinnedPluginConfig(value, version, hasLocalAftEntry = () => false) {
+function isPackageObjectEntry(entry) {
+  return typeof entry === "object" && entry !== null && !Array.isArray(entry) && typeof entry.package === "string";
+}
+function isPackageTupleEntry(entry) {
+  return Array.isArray(entry) && typeof entry[0] === "string";
+}
+function pluginEntryPackage(entry) {
+  if (typeof entry === "string")
+    return entry;
+  if (isPackageTupleEntry(entry))
+    return entry[0];
+  if (isPackageObjectEntry(entry))
+    return entry.package;
+  return null;
+}
+function pluginEntryOptions(entry) {
+  if (isPackageTupleEntry(entry))
+    return entry.length > 1 ? entry[1] : undefined;
+  if (isPackageObjectEntry(entry))
+    return entry.options;
+  return;
+}
+function pluginEntryFitsKey(entry, key) {
+  if (typeof entry === "string")
+    return true;
+  if (isPackageTupleEntry(entry))
+    return key === "plugin";
+  if (isPackageObjectEntry(entry))
+    return key === "plugins";
+  return false;
+}
+function shapePluginEntry(key, packageSpec, options) {
+  if (options === undefined)
+    return packageSpec;
+  return key === "plugins" ? { package: packageSpec, options } : [packageSpec, options];
+}
+function sameEntry(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+function findLocalAftEntry(list, hasLocalAftEntry) {
+  for (let index = 0;index < list.length; index += 1) {
+    const packageSpec = pluginEntryPackage(list[index]);
+    if (packageSpec === null || isAftNpmEntry(packageSpec))
+      continue;
+    if (hasLocalAftEntry(packageSpec)) {
+      return { index, packageSpec, options: pluginEntryOptions(list[index]) };
+    }
+  }
+  return null;
+}
+function ensurePinnedPluginConfig(value, version, hasLocalAftEntry = () => false, generation = "unknown") {
   const entry = pinnedPluginEntry(version);
-  const singular = Array.isArray(value.plugin) ? value.plugin : [];
-  const plural = Array.isArray(value.plugins) ? value.plugins : [];
-  const hadPluralKey = Object.hasOwn(value, "plugins");
-  if (!Array.isArray(value.plugin))
-    value.plugin = singular;
-  if (plural !== singular)
-    singular.push(...plural);
-  if (hadPluralKey)
-    delete value.plugins;
+  const key = openCodePluginKey(generation);
+  const hadKey = Array.isArray(value[key]);
+  const list = hadKey ? value[key] : [];
+  if (!hadKey)
+    value[key] = list;
   const npmIndexes = [];
-  let hasLocalEntry = false;
-  for (let index = 0;index < singular.length; index += 1) {
-    const candidate = singular[index];
-    if (isAftNpmEntry(candidate))
+  for (let index = 0;index < list.length; index += 1) {
+    const packageSpec = pluginEntryPackage(list[index]);
+    if (packageSpec !== null && isAftNpmEntry(packageSpec))
       npmIndexes.push(index);
-    else if (typeof candidate === "string" && hasLocalAftEntry(candidate))
-      hasLocalEntry = true;
   }
   if (npmIndexes.length > 0) {
     const firstIndex = npmIndexes[0];
-    const wasExact = singular[firstIndex] === entry;
-    singular[firstIndex] = entry;
+    const shaped = shapePluginEntry(key, entry, pluginEntryOptions(list[firstIndex]));
+    const wasExact = sameEntry(list[firstIndex], shaped);
+    list[firstIndex] = shaped;
     for (let index = npmIndexes.length - 1;index >= 1; index -= 1) {
-      singular.splice(npmIndexes[index], 1);
-    }
-    const changed = hadPluralKey || !wasExact || npmIndexes.length > 1;
-    return { action: changed ? "updated" : "already_present", changed, entry };
-  }
-  if (hasLocalEntry) {
-    return {
-      action: hadPluralKey ? "updated" : "already_present",
-      changed: hadPluralKey,
-      entry
-    };
-  }
-  singular.push(entry);
-  return { action: "added", changed: true, entry };
-}
-function pluginConfigNeedsUpdate(value, version, hasLocalAftEntry = () => false) {
-  if (Object.hasOwn(value, "plugins"))
-    return true;
-  if (!Array.isArray(value.plugin))
+      list.splice(npmIndexes[index], 1);
+    }
+    const changed = !wasExact || npmIndexes.length > 1;
+    return { action: changed ? "updated" : "already_present", changed, entry, key };
+  }
+  const local = findLocalAftEntry(list, hasLocalAftEntry);
+  if (local) {
+    const shaped = shapePluginEntry(key, local.packageSpec, local.options);
+    const changed = !sameEntry(list[local.index], shaped);
+    list[local.index] = shaped;
+    return { action: changed ? "updated" : "already_present", changed, entry, key };
+  }
+  const sibling = value[otherOpenCodePluginKey(key)];
+  const siblingList = Array.isArray(sibling) ? sibling : null;
+  const carried = siblingList ? findLocalAftEntry(siblingList, hasLocalAftEntry) : null;
+  list.push(carried ? shapePluginEntry(key, carried.packageSpec, carried.options) : entry);
+  if (carried && siblingList)
+    siblingList.splice(carried.index, 1);
+  return { action: "added", changed: true, entry, key };
+}
+function pluginConfigNeedsUpdate(value, version, hasLocalAftEntry = () => false, generation = "unknown") {
+  const key = openCodePluginKey(generation);
+  const list = value[key];
+  if (!Array.isArray(list))
     return true;
-  const npmEntries = value.plugin.filter(isAftNpmEntry);
+  const npmEntries = list.filter((candidate) => {
+    const packageSpec = pluginEntryPackage(candidate);
+    return packageSpec !== null && isAftNpmEntry(packageSpec);
+  });
   if (npmEntries.length > 0) {
-    return npmEntries.length !== 1 || npmEntries[0] !== pinnedPluginEntry(version);
+    return npmEntries.length !== 1 || pluginEntryPackage(npmEntries[0]) !== pinnedPluginEntry(version) || !pluginEntryFitsKey(npmEntries[0], key);
   }
-  return !value.plugin.some((entry) => typeof entry === "string" && hasLocalAftEntry(entry));
+  const local = findLocalAftEntry(list, hasLocalAftEntry);
+  if (local)
+    return !pluginEntryFitsKey(list[local.index], key);
+  return true;
 }
 var AFT_OPENCODE_PACKAGE = "@cortexkit/aft-opencode", MODERN_V1_VERSION;
 var init_opencode_config = __esm(() => {
@@ -11992,11 +12206,11 @@ import {
   accessSync as accessSync2,
   closeSync as closeSync4,
   constants as constants2,
-  existsSync as existsSync11,
+  existsSync as existsSync12,
   mkdirSync as mkdirSync5,
   mkdtempSync,
   openSync as openSync4,
-  readdirSync as readdirSync5,
+  readdirSync as readdirSync6,
   readFileSync as readFileSync8,
   readSync as readSync2,
   realpathSync as realpathSync2,
@@ -12004,7 +12218,7 @@ import {
   statSync as statSync6
 } from "node:fs";
 import { homedir as homedir9, tmpdir } from "node:os";
-import { delimiter as delimiter2, dirname as dirname5, join as join13, parse, resolve as resolve7 } from "node:path";
+import { delimiter as delimiter2, dirname as dirname5, join as join14, parse, resolve as resolve7 } from "node:path";
 function executableNames2(name, platform) {
   if (platform !== "win32")
     return [name];
@@ -12042,7 +12256,7 @@ function packageMetadataNearExecutable(executable, expectedName) {
     current = dirname5(executable);
   }
   while (true) {
-    const direct = packageMetadataAt(join13(current, "package.json"), expectedName);
+    const direct = packageMetadataAt(join14(current, "package.json"), expectedName);
     if (direct)
       return direct;
     const parent = dirname5(current);
@@ -12080,7 +12294,7 @@ function hashFileBytes(hash, path, size) {
   }
 }
 function snapshotTree(path) {
-  if (!existsSync11(path))
+  if (!existsSync12(path))
     return "missing";
   const hash = createHash4("sha256");
   const visit = (current, relativePath) => {
@@ -12093,8 +12307,8 @@ function snapshotTree(path) {
     }
     hash.update(`${relativePath}\x00${info.mode}\x00${info.size}\x00${info.mtimeMs}\x00`);
     if (info.isDirectory()) {
-      for (const entry of readdirSync5(current).sort()) {
-        visit(join13(current, entry), join13(relativePath, entry));
+      for (const entry of readdirSync6(current).sort()) {
+        visit(join14(current, entry), join14(relativePath, entry));
       }
       return;
     }
@@ -12110,31 +12324,31 @@ function snapshotTree(path) {
   return hash.digest("hex");
 }
 function snapshotOperatorState(operatorHome) {
-  const database = join13(operatorHome, ".local", "share", "opencode", "opencode.db");
+  const database = join14(operatorHome, ".local", "share", "opencode", "opencode.db");
   return JSON.stringify({
     database: snapshotTree(database),
     databaseWal: snapshotTree(`${database}-wal`),
     databaseShm: snapshotTree(`${database}-shm`),
-    logs: snapshotTree(join13(operatorHome, ".local", "share", "opencode", "log"))
+    logs: snapshotTree(join14(operatorHome, ".local", "share", "opencode", "log"))
   });
 }
 function probeCreatedIsolatedState(dataRoot, stateRoot) {
   return [dataRoot, stateRoot].some((root) => {
-    const opencodeRoot = join13(root, "opencode");
-    const database = join13(opencodeRoot, "opencode.db");
-    return [database, `${database}-wal`, `${database}-shm`, join13(opencodeRoot, "log")].some(existsSync11);
+    const opencodeRoot = join14(root, "opencode");
+    const database = join14(opencodeRoot, "opencode.db");
+    return [database, `${database}-wal`, `${database}-shm`, join14(opencodeRoot, "log")].some(existsSync12);
   });
 }
 function probeOpenCodeV1Version(executable, options = {}) {
   const operatorHome = options.operatorHome ?? homedir9();
   const before = snapshotOperatorState(operatorHome);
-  const root = mkdtempSync(join13(options.tempParent ?? tmpdir(), "aft-opencode-probe-"));
-  const home = join13(root, "home");
-  const config = join13(root, "config");
-  const data = join13(root, "data");
-  const state = join13(root, "state");
-  const cache = join13(root, "cache");
-  const project = join13(root, "project");
+  const root = mkdtempSync(join14(options.tempParent ?? tmpdir(), "aft-opencode-probe-"));
+  const home = join14(root, "home");
+  const config = join14(root, "config");
+  const data = join14(root, "data");
+  const state = join14(root, "state");
+  const cache = join14(root, "cache");
+  const project = join14(root, "project");
   for (const directory of [home, config, data, state, cache, project]) {
     mkdirSync5(directory, { recursive: true });
   }
@@ -12145,7 +12359,7 @@ function probeOpenCodeV1Version(executable, options = {}) {
     XDG_DATA_HOME: data,
     XDG_STATE_HOME: state,
     XDG_CACHE_HOME: cache,
-    TMPDIR: join13(root, "tmp")
+    TMPDIR: join14(root, "tmp")
   };
   mkdirSync5(env.TMPDIR, { recursive: true });
   delete env.OPENCODE_CONFIG;
@@ -12178,33 +12392,63 @@ function probeOpenCodeV1Version(executable, options = {}) {
     throw probeError;
   if (!result || result.error || result.status !== 0)
     return null;
-  const output = String(result.stdout ?? "").trim();
-  return output.length > 0 ? output : null;
+  return parseHostVersion(String(result.stdout ?? ""));
+}
+function parseHostVersion(output) {
+  if (!output)
+    return null;
+  const match = output.match(/(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z][0-9A-Za-z.-]*)?)/);
+  return match ? match[1] : null;
+}
+function v2MetadataNearExecutable(executable) {
+  for (const name of V2_PACKAGE_NAMES) {
+    const metadata = packageMetadataNearExecutable(executable, name);
+    if (metadata)
+      return metadata;
+  }
+  return null;
+}
+function isV2Version(version) {
+  const parsed = parseHostVersion(version);
+  if (!parsed)
+    return false;
+  if (/^0\.0\.0-(?:beta|dev)-/.test(parsed))
+    return true;
+  const major = Number.parseInt(parsed, 10);
+  return Number.isFinite(major) && major >= 2;
+}
+function resolvedPath(executable) {
+  try {
+    return realpathSync2(executable);
+  } catch {
+    return executable;
+  }
 }
 function detectOpenCodeHostGeneration(dependencies = {}) {
   const findExecutable = dependencies.findExecutable ?? ((name) => findExecutableOnPath(name, dependencies.path, dependencies.platform));
-  const v1Executable = findExecutable("opencode");
-  const v2Executable = findExecutable("opencode2");
+  const openCodeExecutable = findExecutable("opencode");
+  const openCode2Executable = findExecutable("opencode2");
   const evidence = [];
-  if (v1Executable) {
-    const v1Metadata = packageMetadataNearExecutable(v1Executable, "opencode-ai");
-    const v2Metadata = packageMetadataNearExecutable(v1Executable, "@opencode-ai/cli");
+  const sharedExecutable = openCodeExecutable !== null && openCode2Executable !== null && resolvedPath(openCodeExecutable) === resolvedPath(openCode2Executable);
+  if (openCodeExecutable) {
+    const v1Metadata = packageMetadataNearExecutable(openCodeExecutable, "opencode-ai");
+    const v2Metadata = v2MetadataNearExecutable(openCodeExecutable);
     const metadataVersion = packageVersion(v2Metadata) ?? packageVersion(v1Metadata);
-    const version = metadataVersion ?? (dependencies.probeV1Version ?? probeOpenCodeV1Version)(v1Executable);
-    const isV2 = Boolean(v2Metadata) || /^0\.0\.0-(?:beta|dev)-/.test(version ?? "");
+    const version = metadataVersion ?? (dependencies.probeV1Version ?? probeOpenCodeV1Version)(openCodeExecutable);
+    const isV2 = Boolean(v2Metadata) || sharedExecutable || isV2Version(version);
     evidence.push({
       generation: isV2 ? "v2" : "v1",
-      executable: v1Executable,
+      executable: openCodeExecutable,
       version,
       runtime: "bun",
       modernV1: !isV2 && version === MODERN_V1_VERSION
     });
   }
-  if (v2Executable) {
-    const version = packageVersion(packageMetadataNearExecutable(v2Executable, "@opencode-ai/cli"));
+  if (openCode2Executable && !sharedExecutable) {
+    const version = packageVersion(v2MetadataNearExecutable(openCode2Executable));
     evidence.push({
       generation: "v2",
-      executable: v2Executable,
+      executable: openCode2Executable,
       version,
       runtime: "bun",
       modernV1: false
@@ -12228,17 +12472,18 @@ function formatHostGenerations(detection) {
     return "V2";
   return "unknown";
 }
-var FULL_CONTENT_HASH_MAX_BYTES, PARTIAL_CONTENT_WINDOW_BYTES;
+var FULL_CONTENT_HASH_MAX_BYTES, PARTIAL_CONTENT_WINDOW_BYTES, V2_PACKAGE_NAMES;
 var init_host_generation = __esm(() => {
   init_opencode_config();
   FULL_CONTENT_HASH_MAX_BYTES = 64 * 1024 * 1024;
   PARTIAL_CONTENT_WINDOW_BYTES = 1024 * 1024;
+  V2_PACKAGE_NAMES = ["@opencode/cli", "@opencode-ai/cli"];
 });
 
 // src/adapters/opencode.ts
-import { existsSync as existsSync12, readFileSync as readFileSync9, rmSync as rmSync4, statSync as statSync7 } from "node:fs";
+import { existsSync as existsSync13, readFileSync as readFileSync9, rmSync as rmSync4, statSync as statSync7 } from "node:fs";
 import { homedir as homedir10 } from "node:os";
-import { dirname as dirname6, join as join14, parse as parse2, resolve as resolve8 } from "node:path";
+import { dirname as dirname6, join as join15, parse as parse2, resolve as resolve8 } from "node:path";
 import { fileURLToPath } from "node:url";
 function getOpenCodeConfigDir() {
   const envDir = process.env.OPENCODE_CONFIG_DIR?.trim();
@@ -12249,13 +12494,13 @@ function getOpenCodeConfigDir() {
 function getLegacyOpenCodePluginCachePath(primaryPath) {
   if (process.platform !== "win32")
     return null;
-  const localAppData = process.env.LOCALAPPDATA ?? join14(homedir10(), "AppData", "Local");
-  const legacyPath = join14(localAppData, "opencode", "packages", LEGACY_PLUGIN_ENTRY);
+  const localAppData = process.env.LOCALAPPDATA ?? join15(homedir10(), "AppData", "Local");
+  const legacyPath = join15(localAppData, "opencode", "packages", LEGACY_PLUGIN_ENTRY);
   return resolve8(legacyPath) === resolve8(primaryPath) ? null : legacyPath;
 }
 function clearLegacyOpenCodePluginCache(primaryPath) {
   const legacyPath = getLegacyOpenCodePluginCachePath(primaryPath);
-  if (!legacyPath || !existsSync12(legacyPath))
+  if (!legacyPath || !existsSync13(legacyPath))
     return { clearedPath: null };
   try {
     rmSync4(legacyPath, { recursive: true, force: true });
@@ -12273,16 +12518,16 @@ function hasOpenCodeCli() {
 function openCodeDesktopAppExists() {
   const candidates = [];
   if (process.platform === "darwin") {
-    candidates.push("/Applications/OpenCode.app", "/Applications/OpenCode Beta.app", join14(homedir10(), "Applications", "OpenCode.app"), join14(homedir10(), "Applications", "OpenCode Beta.app"));
+    candidates.push("/Applications/OpenCode.app", "/Applications/OpenCode Beta.app", join15(homedir10(), "Applications", "OpenCode.app"), join15(homedir10(), "Applications", "OpenCode Beta.app"));
   } else if (process.platform === "win32") {
-    const localAppData = process.env.LOCALAPPDATA ?? join14(homedir10(), "AppData", "Local");
-    candidates.push(join14(localAppData, "Programs", "opencode"), join14(localAppData, "opencode"));
+    const localAppData = process.env.LOCALAPPDATA ?? join15(homedir10(), "AppData", "Local");
+    candidates.push(join15(localAppData, "Programs", "opencode"), join15(localAppData, "opencode"));
   } else {
-    candidates.push("/opt/OpenCode", "/usr/lib/opencode", join14(homedir10(), ".local", "share", "applications", "opencode.desktop"));
+    candidates.push("/opt/OpenCode", "/usr/lib/opencode", join15(homedir10(), ".local", "share", "applications", "opencode.desktop"));
   }
   return candidates.some((p) => {
     try {
-      return existsSync12(p);
+      return existsSync13(p);
     } catch {
       return false;
     }
@@ -12305,13 +12550,13 @@ function pathPointsToOurPlugin(entry) {
   if (!fsPath)
     return false;
   try {
-    if (!existsSync12(fsPath))
+    if (!existsSync13(fsPath))
       return false;
     let searchDir = statSync7(fsPath).isDirectory() ? fsPath : dirname6(fsPath);
     let pkgJsonPath = null;
     while (true) {
-      const candidate = join14(searchDir, "package.json");
-      if (existsSync12(candidate)) {
+      const candidate = join15(searchDir, "package.json");
+      if (existsSync13(candidate)) {
         pkgJsonPath = candidate;
         break;
       }
@@ -12335,6 +12580,19 @@ function matchesPluginEntry(entry) {
     return true;
   return pathPointsToOurPlugin(entry);
 }
+function configRegistersAft(value, generation) {
+  if (!value)
+    return false;
+  return openCodePluginReadKeys(generation).some((key) => {
+    const list = value[key];
+    if (!Array.isArray(list))
+      return false;
+    return list.some((entry) => {
+      const packageSpec = pluginEntryPackage(entry);
+      return packageSpec !== null && matchesPluginEntry(packageSpec);
+    });
+  });
+}
 
 class OpenCodeAdapter {
   kind = "opencode";
@@ -12343,7 +12601,7 @@ class OpenCodeAdapter {
   pluginEntryWithVersion = PLUGIN_ENTRY;
   hostDetection;
   isInstalled() {
-    if (existsSync12(getOpenCodeConfigDir()))
+    if (existsSync13(getOpenCodeConfigDir()))
       return true;
     if (openCodeDesktopAppExists())
       return true;
@@ -12353,6 +12611,12 @@ class OpenCodeAdapter {
     this.hostDetection ??= detectOpenCodeHostGeneration();
     return this.hostDetection;
   }
+  useHostDetection(detection) {
+    this.hostDetection = detection;
+  }
+  configGeneration() {
+    return this.hostDetection?.status ?? "unknown";
+  }
   getHostVersion() {
     const versions = this.detectHostGeneration().evidence.map((item) => item.version).filter((version) => Boolean(version));
     return versions.length > 0 ? versions.join(" + ") : null;
@@ -12361,7 +12625,7 @@ class OpenCodeAdapter {
     const configDir = getOpenCodeConfigDir();
     const harness = detectJsoncFile(configDir, "opencode");
     const aftConfigPath = resolveCortexKitUserConfigPath();
-    const aftConfigExists = existsSync12(aftConfigPath);
+    const aftConfigExists = existsSync13(aftConfigPath);
     const tui = detectJsoncFile(configDir, "tui");
     return {
       configDir,
@@ -12376,8 +12640,7 @@ class OpenCodeAdapter {
   hasPluginEntry() {
     const paths = this.detectConfigPaths();
     const { value } = readJsoncFile(paths.harnessConfig);
-    const plugins = Array.isArray(value?.plugin) ? value.plugin : [];
-    return plugins.some((entry) => typeof entry === "string" && matchesPluginEntry(entry));
+    return configRegistersAft(value, this.configGeneration());
   }
   async ensurePluginEntry() {
     const paths = this.detectConfigPaths();
@@ -12392,8 +12655,7 @@ class OpenCodeAdapter {
     if (!paths.tuiConfig)
       return false;
     const { value } = readJsoncFile(paths.tuiConfig);
-    const plugins = Array.isArray(value?.plugin) ? value.plugin : [];
-    return plugins.some((entry) => typeof entry === "string" && matchesPluginEntry(entry));
+    return configRegistersAft(value, this.configGeneration());
   }
   async ensureTuiPluginEntry() {
     const paths = this.detectConfigPaths();
@@ -12412,12 +12674,14 @@ class OpenCodeAdapter {
     return paths.tuiConfig ? this.configEntryNeedsUpdate(paths.tuiConfig, paths.tuiConfigFormat ?? "none") : true;
   }
   ensureConfigEntry(configPath, format, label) {
+    const generation = this.configGeneration();
+    const key = openCodePluginKey(generation);
     if (format === "none") {
-      writeJsoncFile(configPath, { plugin: [PLUGIN_ENTRY] }, "json");
+      writeJsoncFile(configPath, { [key]: [PLUGIN_ENTRY] }, "json");
       return {
         ok: true,
         action: "added",
-        message: `Created ${configPath} and added ${PLUGIN_ENTRY} (${label})`,
+        message: `Created ${configPath} and added ${PLUGIN_ENTRY} under \`${key}\` (${label})`,
         configPath
       };
     }
@@ -12430,12 +12694,12 @@ class OpenCodeAdapter {
         configPath
       };
     }
-    const update = ensurePinnedPluginConfig(value, getSelfVersion(), pathPointsToOurPlugin);
+    const update = ensurePinnedPluginConfig(value, getSelfVersion(), pathPointsToOurPlugin, generation);
     if (!update.changed) {
       return {
         ok: true,
         action: "already_present",
-        message: `${PLUGIN_ENTRY} is already registered in ${configPath}`,
+        message: `${PLUGIN_ENTRY} is already registered under \`${update.key}\` in ${configPath}`,
         configPath
       };
     }
@@ -12443,7 +12707,7 @@ class OpenCodeAdapter {
     return {
       ok: true,
       action: update.action,
-      message: `${update.action === "added" ? "Added" : "Updated"} ${PLUGIN_ENTRY} in ${configPath} (${label})`,
+      message: `${update.action === "added" ? "Added" : "Updated"} ${PLUGIN_ENTRY} under \`${update.key}\` in ${configPath} (${label})`,
       configPath
     };
   }
@@ -12453,17 +12717,17 @@ class OpenCodeAdapter {
     const { value, error } = readJsoncFile(configPath);
     if (error || !value)
       return false;
-    return pluginConfigNeedsUpdate(value, getSelfVersion(), pathPointsToOurPlugin);
+    return pluginConfigNeedsUpdate(value, getSelfVersion(), pathPointsToOurPlugin, this.configGeneration());
   }
   getPluginCacheInfo() {
     const configPath = this.detectConfigPaths().harnessConfig;
     const { value } = readJsoncFile(configPath);
-    const configuredEntry = Array.isArray(value?.plugin) ? value.plugin.find(isAftNpmEntry) : undefined;
-    const path = join14(getOpenCodeCacheDir(), "packages", configuredEntry ?? PLUGIN_ENTRY);
+    const configuredEntry = openCodePluginReadKeys(this.configGeneration()).flatMap((key) => Array.isArray(value?.[key]) ? value[key] : []).map(pluginEntryPackage).find(isAftNpmEntry);
+    const path = join15(getOpenCodeCacheDir(), "packages", configuredEntry ?? PLUGIN_ENTRY);
     let cached;
     try {
-      const installedPkgPath = join14(path, "node_modules", "@cortexkit", "aft-opencode", "package.json");
-      if (existsSync12(installedPkgPath)) {
+      const installedPkgPath = join15(path, "node_modules", "@cortexkit", "aft-opencode", "package.json");
+      if (existsSync13(installedPkgPath)) {
         const pkg = JSON.parse(readFileSync9(installedPkgPath, "utf-8"));
         cached = typeof pkg.version === "string" ? pkg.version : undefined;
       }
@@ -12474,7 +12738,7 @@ class OpenCodeAdapter {
       path,
       cached,
       latest: getSelfVersion(),
-      exists: existsSync12(path)
+      exists: existsSync13(path)
     };
   }
   getStorageDir() {
@@ -12537,12 +12801,12 @@ class OpenCodeAdapter {
   describeStorageSubtrees() {
     const storage = this.getStorageDir();
     return {
-      index: dirSize(join14(storage, "index")),
-      semantic: dirSize(join14(storage, "semantic")),
-      backups: dirSize(join14(storage, "backups")),
-      url_cache: dirSize(join14(storage, "url_cache")),
-      onnxruntime: dirSize(join14(storage, "onnxruntime")),
-      logs: dirSize(join14(storage, "logs"))
+      index: dirSize(join15(storage, "index")),
+      semantic: dirSize(join15(storage, "semantic")),
+      backups: dirSize(join15(storage, "backups")),
+      url_cache: dirSize(join15(storage, "url_cache")),
+      onnxruntime: dirSize(join15(storage, "onnxruntime")),
+      logs: dirSize(join15(storage, "logs"))
     };
   }
 }
@@ -12562,20 +12826,20 @@ var init_opencode = __esm(() => {
 
 // src/adapters/pi.ts
 import { execSync as execSync2, spawnSync as spawnSync6 } from "node:child_process";
-import { existsSync as existsSync13, readFileSync as readFileSync10 } from "node:fs";
+import { existsSync as existsSync14, readFileSync as readFileSync10 } from "node:fs";
 import { homedir as homedir11 } from "node:os";
-import { join as join15, resolve as resolve9 } from "node:path";
+import { join as join16, resolve as resolve9 } from "node:path";
 function getPiAgentDir() {
   const configuredDir = process.env.PI_CODING_AGENT_DIR?.trim();
   if (configuredDir)
     return resolve9(configuredDir);
   const envHome = process.platform === "win32" ? process.env.USERPROFILE : process.env.HOME;
   const home = envHome && envHome.length > 0 ? envHome : homedir11();
-  return join15(home, ".pi", "agent");
+  return join16(home, ".pi", "agent");
 }
 function readPiExtensionIndex() {
-  const settingsPath = join15(getPiAgentDir(), "settings.json");
-  if (existsSync13(settingsPath)) {
+  const settingsPath = join16(getPiAgentDir(), "settings.json");
+  if (existsSync14(settingsPath)) {
     try {
       const raw = readFileSync10(settingsPath, "utf-8");
       const trimmed = raw.replace(/^\uFEFF/, "");
@@ -12595,13 +12859,13 @@ function readPiExtensionIndex() {
     } catch {}
   }
   const candidates = [
-    join15(getPiAgentDir(), "extensions.json"),
-    join15(getPiAgentDir(), "extensions.jsonc"),
-    join15(getPiAgentDir(), "config.json"),
-    join15(getPiAgentDir(), "config.jsonc")
+    join16(getPiAgentDir(), "extensions.json"),
+    join16(getPiAgentDir(), "extensions.jsonc"),
+    join16(getPiAgentDir(), "config.json"),
+    join16(getPiAgentDir(), "config.jsonc")
   ];
   for (const path of candidates) {
-    if (!existsSync13(path))
+    if (!existsSync14(path))
       continue;
     try {
       const { value } = readJsoncFile(path);
@@ -12634,15 +12898,15 @@ function piEntryMatchesAft(entry) {
   } else if (entry.startsWith("/")) {
     resolved = entry;
   } else if (entry.length > 0) {
-    resolved = join15(getPiAgentDir(), entry);
+    resolved = join16(getPiAgentDir(), entry);
   }
   if (!resolved)
     return false;
   try {
-    if (!existsSync13(resolved))
+    if (!existsSync14(resolved))
       return false;
-    const pkgPath = join15(resolved, "package.json");
-    if (!existsSync13(pkgPath))
+    const pkgPath = join16(resolved, "package.json");
+    if (!existsSync14(pkgPath))
       return false;
     const pkg = JSON.parse(readFileSync10(pkgPath, "utf-8"));
     return pkg.name === PLUGIN_NAME2;
@@ -12690,10 +12954,10 @@ class PiAdapter {
     const configDir = getPiAgentDir();
     const index = readPiExtensionIndex();
     const aftConfigPath = resolveCortexKitUserConfigPath();
-    const aftConfigExists = existsSync13(aftConfigPath);
+    const aftConfigExists = existsSync14(aftConfigPath);
     return {
       configDir,
-      harnessConfig: index.path ?? join15(configDir, "extensions.json"),
+      harnessConfig: index.path ?? join16(configDir, "extensions.json"),
       harnessConfigFormat: index.path ? "json" : "none",
       aftConfig: aftConfigPath,
       aftConfigFormat: aftConfigExists ? "jsonc" : "none"
@@ -12738,12 +13002,12 @@ class PiAdapter {
   }
   getPluginCacheInfo() {
     const candidates = [
-      join15(getPiAgentDir(), "npm", "node_modules", "@cortexkit", "aft-pi", "package.json"),
-      join15(getPiAgentDir(), "node_modules", "@cortexkit", "aft-pi", "package.json"),
-      join15(getPiAgentDir(), "extensions", "node_modules", "@cortexkit", "aft-pi", "package.json")
+      join16(getPiAgentDir(), "npm", "node_modules", "@cortexkit", "aft-pi", "package.json"),
+      join16(getPiAgentDir(), "node_modules", "@cortexkit", "aft-pi", "package.json"),
+      join16(getPiAgentDir(), "extensions", "node_modules", "@cortexkit", "aft-pi", "package.json")
     ];
     for (const candidate of candidates) {
-      if (!existsSync13(candidate))
+      if (!existsSync14(candidate))
         continue;
       try {
         const pkg = JSON.parse(readFileSync10(candidate, "utf-8"));
@@ -12757,7 +13021,7 @@ class PiAdapter {
       } catch {}
     }
     return {
-      path: join15(getPiAgentDir(), "npm", "node_modules", "@cortexkit", "aft-pi", "package.json"),
+      path: join16(getPiAgentDir(), "npm", "node_modules", "@cortexkit", "aft-pi", "package.json"),
       exists: false
     };
   }
@@ -12779,12 +13043,12 @@ class PiAdapter {
   describeStorageSubtrees() {
     const storage = this.getStorageDir();
     return {
-      index: dirSize(join15(storage, "index")),
-      semantic: dirSize(join15(storage, "semantic")),
-      backups: dirSize(join15(storage, "backups")),
-      url_cache: dirSize(join15(storage, "url_cache")),
-      onnxruntime: dirSize(join15(storage, "onnxruntime")),
-      logs: dirSize(join15(storage, "logs"))
+      index: dirSize(join16(storage, "index")),
+      semantic: dirSize(join16(storage, "semantic")),
+      backups: dirSize(join16(storage, "backups")),
+      url_cache: dirSize(join16(storage, "url_cache")),
+      onnxruntime: dirSize(join16(storage, "onnxruntime")),
+      logs: dirSize(join16(storage, "logs"))
     };
   }
 }
@@ -14170,6 +14434,7 @@ async function runSetup(argv, options = {}) {
     }
     if (adapter instanceof OpenCodeAdapter) {
       const detection = options.detectOpenCodeHost ? options.detectOpenCodeHost() : adapter.detectHostGeneration();
+      adapter.useHostDetection(detection);
       log2.info(`${adapter.displayName}: host generation ${formatHostGenerations(detection)}`);
       if (detection.status === "ambiguous") {
         log2.error(`${adapter.displayName}: both V1 and V2 hosts are installed; refusing to change either config until only one generation is selected on PATH.`);
@@ -14254,7 +14519,7 @@ import { spawnSync as spawnSync7 } from "node:child_process";
 function runIndex(argv) {
   const binary = findAftBinary();
   if (!binary) {
-    console.error("aft index requires a native AFT binary; run `aft doctor` to install or repair it.");
+    console.error(missingAftBinaryMessage("aft index"));
     return 1;
   }
   const result = spawnSync7(binary, ["index", ...argv], {
@@ -14272,24 +14537,50 @@ var init_commands = __esm(async () => {
 });
 
 // src/doctor/opencode.ts
-import { existsSync as existsSync14, readFileSync as readFileSync11 } from "node:fs";
-import { dirname as dirname7, join as join16 } from "node:path";
+import { existsSync as existsSync15, readFileSync as readFileSync11 } from "node:fs";
+import { dirname as dirname7, join as join17 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function isLoadPath(value) {
   return OPENCODE_LOAD_PATHS.includes(value);
 }
-function configuredAftEntry(value) {
-  if (!Array.isArray(value?.plugin))
+function aftEntryUnderKey(value, key) {
+  const list = value?.[key];
+  if (!Array.isArray(list))
     return null;
-  for (const entry of value.plugin) {
-    if (isAftNpmEntry(entry))
-      return entry;
-    const root = localPluginRoot(entry);
+  for (const entry of list) {
+    const packageSpec = pluginEntryPackage(entry);
+    if (packageSpec === null)
+      continue;
+    if (isAftNpmEntry(packageSpec))
+      return packageSpec;
+    const root = localPluginRoot(packageSpec);
     if (root && manifestFromLocalPath(root))
+      return packageSpec;
+  }
+  return null;
+}
+function configuredAftEntry(value, generation) {
+  for (const key of openCodePluginReadKeys(generation)) {
+    const entry = aftEntryUnderKey(value, key);
+    if (entry)
       return entry;
   }
   return null;
 }
+function misshapenEntries(value, key) {
+  const list = value?.[key];
+  if (!Array.isArray(list))
+    return [];
+  const packages = [];
+  for (const entry of list) {
+    if (pluginEntryFitsKey(entry, key))
+      continue;
+    const packageSpec = pluginEntryPackage(entry);
+    if (packageSpec !== null)
+      packages.push(packageSpec);
+  }
+  return packages;
+}
 function localPluginRoot(entry) {
   if (typeof entry !== "string")
     return null;
@@ -14318,10 +14609,10 @@ function readManifest(path) {
 }
 function manifestFromLocalPath(path) {
   let current = path;
-  if (!existsSync14(join16(current, "package.json")))
+  if (!existsSync15(join17(current, "package.json")))
     current = dirname7(current);
   while (true) {
-    const manifest = readManifest(join16(current, "package.json"));
+    const manifest = readManifest(join17(current, "package.json"));
     if (manifest)
       return manifest;
     const parent = dirname7(current);
@@ -14334,14 +14625,14 @@ function pluginManifest(entry, cachePath) {
   const localRoot = localPluginRoot(entry);
   if (localRoot)
     return manifestFromLocalPath(localRoot);
-  return readManifest(join16(cachePath, "node_modules", "@cortexkit", "aft-opencode", "package.json"));
+  return readManifest(join17(cachePath, "node_modules", "@cortexkit", "aft-opencode", "package.json"));
 }
 function hasExplicitSemver(entry) {
   const version = configuredVersion(entry);
   return Boolean(version && /^\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/.test(version));
 }
 function latestLoggedLoadPath(logPath) {
-  if (!existsSync14(logPath))
+  if (!existsSync15(logPath))
     return null;
   try {
     const text = readFileSync11(logPath, "utf8");
@@ -14370,27 +14661,25 @@ function expectedOpenCodeLoadPath(detection) {
 }
 function diagnoseOpenCodeLoad(input) {
   const expectedLoadPath = expectedOpenCodeLoadPath(input.detection);
+  const generation = input.detection.status;
   const config = readJsoncFile(input.configPath).value;
-  const entry = configuredAftEntry(config);
+  const entry = configuredAftEntry(config, generation);
   const manifest = pluginManifest(entry, input.pluginCachePath);
   const logged = latestLoggedLoadPath(input.logPath);
   let takenLoadPath = logged;
-  if (!takenLoadPath && input.detection.status === "v1") {
+  if (!takenLoadPath && generation === "v1") {
     takenLoadPath = "root-default";
-  } else if (!takenLoadPath && input.detection.status === "v2") {
+  } else if (!takenLoadPath && generation === "v2") {
     takenLoadPath = expectedLoadPath;
   }
   const pluginVersion = (typeof manifest?.version === "string" ? manifest.version : null) ?? input.cachedPluginVersion ?? configuredVersion(entry) ?? null;
-  const problems = [];
-  if (config && Object.hasOwn(config, "plugins")) {
-    problems.push("config uses unsupported `plugins`; run doctor --fix to migrate it to `plugin`");
-  }
+  const problems = [...describePluginKeyProblems(config, generation)];
   if (entry && isAftNpmEntry(entry) && input.expectedPluginEntry && entry !== input.expectedPluginEntry && !(input.acceptExplicitPluginVersion && hasExplicitSemver(entry))) {
     problems.push(`plugin entry ${entry} is not the required exact pin ${input.expectedPluginEntry}`);
   }
-  if (input.detection.status === "ambiguous") {
-    problems.push("both OpenCode V1 and V2 hosts were detected; refusing configuration writes");
-  } else if (input.detection.status === "unknown") {
+  if (generation === "ambiguous") {
+    problems.push("both OpenCode V1 and V2 hosts were detected; refusing configuration writes (a V1 host reads `plugin`, a V2 host reads `plugins`)");
+  } else if (generation === "unknown") {
     problems.push("OpenCode host generation could not be detected");
   }
   if (expectedLoadPath && takenLoadPath && expectedLoadPath !== takenLoadPath) {
@@ -14398,6 +14687,22 @@ function diagnoseOpenCodeLoad(input) {
   }
   return { expectedLoadPath, takenLoadPath, pluginVersion, problems };
 }
+function describePluginKeyProblems(config, generation) {
+  if (!config || generation === "ambiguous" || generation === "unknown")
+    return [];
+  const hostKey = openCodePluginKey(generation);
+  const otherKey = otherOpenCodePluginKey(hostKey);
+  const host = generation.toUpperCase();
+  const problems = [];
+  if (!aftEntryUnderKey(config, hostKey) && aftEntryUnderKey(config, otherKey)) {
+    problems.push(`AFT is registered under \`${otherKey}\`, which a ${host} host does not read; run doctor --fix to register it under \`${hostKey}\``);
+  }
+  const aftEntry = aftEntryUnderKey(config, hostKey);
+  for (const packageSpec of misshapenEntries(config, hostKey)) {
+    problems.push(packageSpec === aftEntry ? `plugin entry ${packageSpec} under \`${hostKey}\` uses the ${host === "V1" ? "V2" : "V1"} entry shape; run doctor --fix to rewrite it` : `plugin entry ${packageSpec} under \`${hostKey}\` uses the ${host === "V1" ? "V2" : "V1"} entry shape, which a ${host} host cannot load; left unchanged because AFT did not register it`);
+  }
+  return problems;
+}
 var OPENCODE_LOAD_PATHS;
 var init_opencode2 = __esm(() => {
   init_jsonc();
@@ -14536,11 +14841,11 @@ var MAX_NOISE_LINES_IN_ERROR = 5;
 var init_aft_bridge = () => {};
 
 // src/lib/binary-cache.ts
-import { existsSync as existsSync15, readdirSync as readdirSync6, statSync as statSync8 } from "node:fs";
-import { join as join17 } from "node:path";
+import { existsSync as existsSync16, readdirSync as readdirSync7, statSync as statSync8 } from "node:fs";
+import { join as join18 } from "node:path";
 function getBinaryCacheInfo(activeVersion) {
   const path = getAftBinaryCacheDir();
-  if (!existsSync15(path)) {
+  if (!existsSync16(path)) {
     return {
       versions: [],
       activeVersion: null,
@@ -14548,9 +14853,9 @@ function getBinaryCacheInfo(activeVersion) {
       path
     };
   }
-  const versions = readdirSync6(path).filter((entry) => {
+  const versions = readdirSync7(path).filter((entry) => {
     try {
-      return statSync8(join17(path, entry)).isDirectory();
+      return statSync8(join18(path, entry)).isDirectory();
     } catch {
       return false;
     }
@@ -14648,13 +14953,13 @@ var init_sanitize = __esm(() => {
 });
 
 // src/lib/bridge-tool-failures.ts
-import { closeSync as closeSync5, existsSync as existsSync16, openSync as openSync5, readSync as readSync3, statSync as statSync9 } from "node:fs";
+import { closeSync as closeSync5, existsSync as existsSync17, openSync as openSync5, readSync as readSync3, statSync as statSync9 } from "node:fs";
 function resolveBridgePluginLogPath() {
   const isTestEnv = process.env.BUN_TEST === "1" || false;
   return resolveAftLogPath(isTestEnv ? "aft-plugin-test.log" : "aft-plugin.log");
 }
 function tailLogFileBytes(path, maxBytes) {
-  if (!existsSync16(path) || maxBytes <= 0)
+  if (!existsSync17(path) || maxBytes <= 0)
     return "";
   let fd = null;
   try {
@@ -14790,9 +15095,9 @@ var init_bridge_tool_failures = __esm(() => {
 });
 
 // src/lib/build-breaker.ts
-import { existsSync as existsSync17, readdirSync as readdirSync7 } from "node:fs";
+import { existsSync as existsSync18, readdirSync as readdirSync8 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
-import { join as join18 } from "node:path";
+import { join as join19 } from "node:path";
 function loadDatabaseSync() {
   const require2 = createRequire3(import.meta.url);
   try {
@@ -14806,11 +15111,11 @@ function loadDatabaseSync() {
   }
 }
 function buildBreakerDatabases(storageRoot) {
-  const callgraphRoot = join18(storageRoot, "callgraph");
-  if (!existsSync17(callgraphRoot))
+  const callgraphRoot = join19(storageRoot, "callgraph");
+  if (!existsSync18(callgraphRoot))
     return [];
   try {
-    return readdirSync7(callgraphRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join18(callgraphRoot, entry.name, "build-breaker.sqlite")).filter((path) => existsSync17(path));
+    return readdirSync8(callgraphRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join19(callgraphRoot, entry.name, "build-breaker.sqlite")).filter((path) => existsSync18(path));
   } catch {
     return [];
   }
@@ -14886,20 +15191,20 @@ var init_build_breaker = __esm(() => {
 });
 
 // src/lib/legacy-storage.ts
-import { existsSync as existsSync18, readdirSync as readdirSync8, statSync as statSync10 } from "node:fs";
-import { join as join19 } from "node:path";
+import { existsSync as existsSync19, readdirSync as readdirSync9, statSync as statSync10 } from "node:fs";
+import { join as join20 } from "node:path";
 function summarizeLegacyPartitionDuplication(storageRoot) {
-  if (!existsSync18(storageRoot)) {
+  if (!existsSync19(storageRoot)) {
     return { totalPartitions: 0, totalBytes: 0, byHarness: [] };
   }
   const byHarness = [];
   for (const harness of safeReadDir(storageRoot)) {
-    const harnessPath = join19(storageRoot, harness);
+    const harnessPath = join20(storageRoot, harness);
     if (!isDirectory(harnessPath))
       continue;
     const partitions = new Map;
-    collectCallgraphPartitions(join19(harnessPath, "callgraph"), partitions);
-    collectInspectPartitions(join19(harnessPath, "inspect"), partitions);
+    collectCallgraphPartitions(join20(harnessPath, "callgraph"), partitions);
+    collectInspectPartitions(join20(harnessPath, "inspect"), partitions);
     if (partitions.size === 0)
       continue;
     let bytes = 0;
@@ -14918,7 +15223,7 @@ function collectCallgraphPartitions(domainPath, partitions) {
   if (!isDirectory(domainPath))
     return;
   for (const name of safeReadDir(domainPath)) {
-    const path = join19(domainPath, name);
+    const path = join20(domainPath, name);
     if (isDirectory(path)) {
       if (!looksLikePartitionKey(name))
         continue;
@@ -14935,7 +15240,7 @@ function collectInspectPartitions(domainPath, partitions) {
   if (!isDirectory(domainPath))
     return;
   for (const name of safeReadDir(domainPath)) {
-    const path = join19(domainPath, name);
+    const path = join20(domainPath, name);
     if (isDirectory(path)) {
       if (!looksLikePartitionKey(name))
         continue;
@@ -14984,7 +15289,7 @@ function looksLikePartitionKey(value) {
 }
 function safeReadDir(path) {
   try {
-    return readdirSync8(path).sort((left, right) => left.localeCompare(right));
+    return readdirSync9(path).sort((left, right) => left.localeCompare(right));
   } catch {
     return [];
   }
@@ -15010,22 +15315,22 @@ var init_legacy_storage = __esm(() => {
 });
 
 // src/lib/lsp-cache.ts
-import { existsSync as existsSync19, readdirSync as readdirSync9, rmSync as rmSync5, statSync as statSync11 } from "node:fs";
-import { join as join20 } from "node:path";
+import { existsSync as existsSync20, readdirSync as readdirSync10, rmSync as rmSync5, statSync as statSync11 } from "node:fs";
+import { join as join21 } from "node:path";
 function inspectDir(path) {
-  if (!existsSync19(path)) {
+  if (!existsSync20(path)) {
     return { entries: [], totalSize: 0 };
   }
   const entries = [];
   let totalSize = 0;
   let names;
   try {
-    names = readdirSync9(path);
+    names = readdirSync10(path);
   } catch {
     return { entries: [], totalSize: 0 };
   }
   for (const name of names) {
-    const full = join20(path, name);
+    const full = join21(path, name);
     try {
       if (!statSync11(full).isDirectory())
         continue;
@@ -15083,8 +15388,8 @@ var init_lsp_cache = __esm(() => {
 });
 
 // src/lib/onnx.ts
-import { existsSync as existsSync20, readdirSync as readdirSync10, readlinkSync as readlinkSync2, realpathSync as realpathSync4 } from "node:fs";
-import { basename as basename2, isAbsolute as isAbsolute4, join as join21, resolve as resolve10, win32 as win322 } from "node:path";
+import { existsSync as existsSync21, readdirSync as readdirSync11, readlinkSync as readlinkSync2, realpathSync as realpathSync4 } from "node:fs";
+import { basename as basename2, isAbsolute as isAbsolute4, join as join22, resolve as resolve10, win32 as win322 } from "node:path";
 function getOnnxLibraryName() {
   if (process.platform === "darwin")
     return "libonnxruntime.dylib";
@@ -15095,22 +15400,21 @@ function getOnnxLibraryName() {
 function getManualInstallHint2() {
   const p = process.platform;
   const a = process.arch;
-  if (p === "darwin") {
-    if (a === "arm64")
-      return "brew install onnxruntime (Apple Silicon)";
-    return "Intel Mac requires manual install — see docs";
-  }
-  if (p === "linux") {
-    if (a === "x64" || a === "arm64") {
+  if (isOrtAutoDownloadSupported()) {
+    if (p === "darwin")
+      return "AFT auto-downloads ONNX Runtime on Apple Silicon";
+    if (p === "linux")
       return "AFT auto-downloads ONNX Runtime on supported Linux (glibc)";
-    }
-    return "manual install required for this Linux arch";
-  }
-  if (p === "win32") {
-    if (a === "x64" || a === "arm64")
+    if (p === "win32")
       return "AFT auto-downloads ONNX Runtime on Windows";
-    return "manual install required for this Windows arch";
-  }
+    return `AFT auto-downloads ONNX Runtime on ${p}/${a}`;
+  }
+  if (p === "darwin")
+    return "brew install onnxruntime (Intel Mac — no published build)";
+  if (p === "linux")
+    return `manual install required for this Linux arch (${a})`;
+  if (p === "win32")
+    return `manual install required for this Windows arch (${a})`;
   return "ONNX Runtime must be installed manually for this platform";
 }
 function pathEnvValue2() {
@@ -15137,7 +15441,7 @@ function isWindowsSystem32Directory2(dir) {
 }
 function directoryContainsLibrary2(dir, libName) {
   try {
-    const entries = readdirSync10(dir);
+    const entries = readdirSync11(dir);
     if (process.platform === "win32") {
       const expected = libName.toLowerCase();
       return entries.some((entry) => entry.toLowerCase() === expected);
@@ -15155,7 +15459,7 @@ function findIgnoredWindowsSystemOnnxRuntime() {
   for (const root of windowsRoots) {
     if (!root)
       continue;
-    const systemDir = join21(root, "System32");
+    const systemDir = join22(root, "System32");
     const key = win322.resolve(systemDir).toLowerCase();
     if (seen.has(key))
       continue;
@@ -15176,21 +15480,21 @@ function findSystemOnnxRuntime2() {
     searchPaths.push(...pathEntriesForPlatform2());
     const programFiles = process.env.ProgramFiles ?? "C:\\Program Files";
     const programFilesX86 = process.env["ProgramFiles(x86)"] ?? "C:\\Program Files (x86)";
-    searchPaths.push(join21(programFiles, "onnxruntime", "lib"), join21(programFiles, "Microsoft ONNX Runtime", "lib"), join21(programFiles, "Microsoft Machine Learning", "lib"), join21(programFilesX86, "onnxruntime", "lib"), ...(() => {
+    searchPaths.push(join22(programFiles, "onnxruntime", "lib"), join22(programFiles, "Microsoft ONNX Runtime", "lib"), join22(programFiles, "Microsoft Machine Learning", "lib"), join22(programFilesX86, "onnxruntime", "lib"), ...(() => {
       const nugetPaths = [];
       const userProfile = process.env.USERPROFILE ?? "";
       if (!userProfile)
         return nugetPaths;
-      const nugetPackageDir = join21(userProfile, ".nuget", "packages", "microsoft.ml.onnxruntime");
-      if (!existsSync20(nugetPackageDir))
+      const nugetPackageDir = join22(userProfile, ".nuget", "packages", "microsoft.ml.onnxruntime");
+      if (!existsSync21(nugetPackageDir))
         return nugetPaths;
       try {
-        for (const entry of readdirSync10(nugetPackageDir, { withFileTypes: true })) {
+        for (const entry of readdirSync11(nugetPackageDir, { withFileTypes: true })) {
           if (!entry.isDirectory())
             continue;
           if (entry.name === "__globalPackagesFolder" || entry.name.startsWith("."))
             continue;
-          nugetPaths.push(join21(nugetPackageDir, entry.name, "runtimes", "win-x64", "native"), join21(nugetPackageDir, entry.name, "runtimes", "win-arm64", "native"));
+          nugetPaths.push(join22(nugetPackageDir, entry.name, "runtimes", "win-x64", "native"), join22(nugetPackageDir, entry.name, "runtimes", "win-arm64", "native"));
         }
       } catch {}
       return nugetPaths;
@@ -15222,12 +15526,12 @@ function findSystemOnnxRuntime2() {
   return unknownVersionPaths[0] ?? null;
 }
 function findCachedOnnxRuntime(storageDir) {
-  const ortDir = join21(storageDir, "onnxruntime", ONNX_RUNTIME_VERSION);
+  const ortDir = join22(storageDir, "onnxruntime", ONNX_RUNTIME_VERSION);
   const libName = getOnnxLibraryName();
-  if (existsSync20(join21(ortDir, libName)))
+  if (existsSync21(join22(ortDir, libName)))
     return ortDir;
-  const libSubdir = join21(ortDir, "lib");
-  if (existsSync20(join21(libSubdir, libName)))
+  const libSubdir = join22(ortDir, "lib");
+  if (existsSync21(join22(libSubdir, libName)))
     return libSubdir;
   return null;
 }
@@ -15248,11 +15552,11 @@ function parseOrtVersionFromDirectoryPath(value) {
   return null;
 }
 function detectOrtVersion(libDir) {
-  if (!existsSync20(libDir))
+  if (!existsSync21(libDir))
     return null;
   const libName = getOnnxLibraryName();
   try {
-    const entries = readdirSync10(libDir);
+    const entries = readdirSync11(libDir);
     const barePrefix = libName.replace(/\.(so|dylib|dll)$/, "");
     const expectedPrefix = process.platform === "win32" ? barePrefix.toLowerCase() : barePrefix;
     for (const entry of entries) {
@@ -15263,8 +15567,8 @@ function detectOrtVersion(libDir) {
       if (version)
         return version;
     }
-    const base = join21(libDir, libName);
-    if (existsSync20(base)) {
+    const base = join22(libDir, libName);
+    if (existsSync21(base)) {
       try {
         const real = realpathSync4(base);
         const version = parseOrtVersionFromPath(real) ?? parseOrtVersionFromDirectoryPath(real);
@@ -15292,14 +15596,16 @@ function isOrtVersionCompatible(version) {
   return minor >= REQUIRED_ORT_MIN_MINOR2;
 }
 var ONNX_RUNTIME_VERSION = "1.24.4", INVALID_ORT_VERSION2 = "<invalid>", REQUIRED_ORT_MAJOR2 = 1, REQUIRED_ORT_MIN_MINOR2 = 20;
-var init_onnx = () => {};
+var init_onnx = __esm(() => {
+  init_dist2();
+});
 
 // src/lib/diagnostics.ts
 import {
   accessSync as accessSync3,
   closeSync as closeSync6,
   constants as constants3,
-  existsSync as existsSync21,
+  existsSync as existsSync22,
   openSync as openSync6,
   readSync as readSync4,
   statSync as statSync12
@@ -15338,7 +15644,7 @@ async function diagnoseHarness(adapter) {
   const logPath = adapter.getLogFile();
   const pluginCache = adapter.getPluginCacheInfo();
   const storageAccessible = (() => {
-    if (!existsSync21(storage))
+    if (!existsSync22(storage))
       return false;
     try {
       accessSync3(storage, constants3.R_OK | constants3.W_OK);
@@ -15363,7 +15669,7 @@ async function diagnoseHarness(adapter) {
     pluginRegistered: adapter.hasPluginEntry(),
     configPaths,
     aftConfig: {
-      exists: existsSync21(configPaths.aftConfig),
+      exists: existsSync22(configPaths.aftConfig),
       ...aftConfigRead.error ? { parseError: aftConfigRead.error } : {},
       enabled: aftEnabled,
       ...aftEnabledSource ? { enabledSource: aftEnabledSource } : {},
@@ -15372,7 +15678,7 @@ async function diagnoseHarness(adapter) {
     pluginCache,
     storageDir: {
       path: storage,
-      exists: existsSync21(storage),
+      exists: existsSync22(storage),
       accessible: storageAccessible,
       sizesByKey: describeStorage,
       ...legacyDuplication.totalPartitions > 0 ? { legacyDuplication } : {}
@@ -15389,12 +15695,13 @@ async function diagnoseHarness(adapter) {
       cachedCompatible: cachedVersion ? isOrtVersionCompatible(cachedVersion) : null,
       platform: `${process.platform}-${process.arch}`,
       installHint: getManualInstallHint2(),
+      autoDownloadable: isOrtAutoDownloadSupported(),
       requirement: `>=${REQUIRED_ORT_MAJOR2}.${REQUIRED_ORT_MIN_MINOR2}`
     },
     logFile: {
       path: logPath,
-      exists: existsSync21(logPath),
-      sizeKb: existsSync21(logPath) ? Math.round(statSync12(logPath).size / 1024) : 0
+      exists: existsSync22(logPath),
+      sizeKb: existsSync22(logPath) ? Math.round(statSync12(logPath).size / 1024) : 0
     }
   };
 }
@@ -15551,7 +15858,7 @@ function collectDiagnosticIssues(report) {
           severity: "medium",
           scope: h.displayName,
           message: h.onnxRuntime.ignoredSystemPath ? `ONNX Runtime at ${h.onnxRuntime.ignoredSystemPath} has a ${h.onnxRuntime.ignoredSystemReason}; no compatible runtime was detected.` : "ONNX Runtime is required for semantic search but was not detected.",
-          remediation: `Run \`${CLI} doctor --fix\` or install ONNX Runtime manually (${h.onnxRuntime.installHint}).`
+          remediation: h.onnxRuntime.autoDownloadable ? `Run \`${CLI} doctor --fix\` to download the AFT-managed ONNX Runtime.` : `Install ONNX Runtime manually (${h.onnxRuntime.installHint}); AFT has no ONNX Runtime download for ${h.onnxRuntime.platform}.`
         });
       }
       if (h.onnxRuntime.cachedCompatible === false) {
@@ -15591,7 +15898,7 @@ function formatDiagnosticIssuesSection(report) {
   return lines;
 }
 function tailLogFile(path, lines) {
-  if (!existsSync21(path))
+  if (!existsSync22(path))
     return "";
   if (lines <= 0)
     return "";
@@ -15780,23 +16087,24 @@ var init_issue_body = __esm(() => {
 });
 
 // src/lib/onnx-fix.ts
-import { existsSync as existsSync22, rmSync as rmSync6 } from "node:fs";
-import { join as join22 } from "node:path";
+import { randomBytes } from "node:crypto";
+import { existsSync as existsSync23, mkdirSync as mkdirSync6, renameSync as renameSync4, rmSync as rmSync6 } from "node:fs";
+import { isAbsolute as isAbsolute5, join as join23, relative as relative2 } from "node:path";
 function findOnnxFixCandidates(report) {
   const candidates = [];
   for (const harness of report.harnesses) {
     if (!harness.onnxRuntime.required)
       continue;
-    const storageOnnxDir = join22(harness.storageDir.path, "onnxruntime");
+    const storageOnnxDir = join23(harness.storageDir.path, "onnxruntime");
     const systemTooOld = harness.onnxRuntime.systemPath !== null && harness.onnxRuntime.systemCompatible === false;
     const cachedTooOld = harness.onnxRuntime.cachedPath !== null && harness.onnxRuntime.cachedCompatible === false;
     const hasCompatibleCached = harness.onnxRuntime.cachedCompatible === true;
     if (cachedTooOld) {
       candidates.push({
         harness,
-        reason: `cached ONNX Runtime at ${harness.onnxRuntime.cachedPath} is v${harness.onnxRuntime.cachedVersion}, but AFT requires ${harness.onnxRuntime.requirement}. Clearing it allows an immediate managed download.`,
+        reason: `cached ONNX Runtime at ${harness.onnxRuntime.cachedPath} is v${harness.onnxRuntime.cachedVersion}, but AFT requires ${harness.onnxRuntime.requirement}. AFT will stage and verify a managed replacement before removing it.`,
         storageOnnxDir,
-        storageOnnxBytes: existsSync22(storageOnnxDir) ? dirSize(storageOnnxDir) : 0
+        storageOnnxBytes: existsSync23(storageOnnxDir) ? dirSize(storageOnnxDir) : 0
       });
       continue;
     }
@@ -15805,7 +16113,7 @@ function findOnnxFixCandidates(report) {
         harness,
         reason: `system ONNX Runtime at ${harness.onnxRuntime.systemPath} is v${harness.onnxRuntime.systemVersion}, but AFT requires ${harness.onnxRuntime.requirement}, and no AFT-managed install is present. AFT will leave the system copy untouched and download v1.24 into managed storage.`,
         storageOnnxDir,
-        storageOnnxBytes: existsSync22(storageOnnxDir) ? dirSize(storageOnnxDir) : 0
+        storageOnnxBytes: existsSync23(storageOnnxDir) ? dirSize(storageOnnxDir) : 0
       });
       continue;
     }
@@ -15815,12 +16123,61 @@ function findOnnxFixCandidates(report) {
         harness,
         reason: `no compatible ONNX Runtime is installed.${ignoredCopy} AFT will download v1.24 into managed storage.`,
         storageOnnxDir,
-        storageOnnxBytes: existsSync22(storageOnnxDir) ? dirSize(storageOnnxDir) : 0
+        storageOnnxBytes: existsSync23(storageOnnxDir) ? dirSize(storageOnnxDir) : 0
       });
     }
   }
   return candidates;
 }
+async function installManagedReplacement(candidate, ensureFn, rmFn) {
+  const suffix = `${process.pid}.${Date.now().toString(36)}.${randomBytes(6).toString("hex")}`;
+  const stagingStorageDir = `${candidate.harness.storageDir.path}.onnx-fix.tmp.${suffix}`;
+  const stagedOnnxDir = join23(stagingStorageDir, "onnxruntime");
+  const backupDir = `${candidate.storageOnnxDir}.backup.${suffix}`;
+  try {
+    const stagedInstalledPath = await ensureFn(stagingStorageDir);
+    if (!stagedInstalledPath || !existsSync23(stagedInstalledPath)) {
+      throw new Error("managed ONNX Runtime download was unavailable");
+    }
+    const installedRelativePath = relative2(stagedOnnxDir, stagedInstalledPath);
+    if (isAbsolute5(installedRelativePath) || installedRelativePath === ".." || installedRelativePath.startsWith("../") || installedRelativePath.startsWith("..\\")) {
+      throw new Error(`managed ONNX Runtime was installed outside staging: ${stagedInstalledPath}`);
+    }
+    mkdirSync6(candidate.harness.storageDir.path, { recursive: true });
+    const hadPrevious = existsSync23(candidate.storageOnnxDir);
+    if (hadPrevious)
+      renameSync4(candidate.storageOnnxDir, backupDir);
+    try {
+      renameSync4(stagedOnnxDir, candidate.storageOnnxDir);
+    } catch (installError) {
+      if (hadPrevious) {
+        try {
+          renameSync4(backupDir, candidate.storageOnnxDir);
+        } catch (restoreError) {
+          throw new Error(`managed ONNX Runtime replacement failed and the previous runtime could not be restored from ${backupDir}: ${restoreError}`, { cause: installError });
+        }
+      }
+      throw installError;
+    }
+    let cleanupError;
+    if (hadPrevious) {
+      try {
+        rmFn(backupDir, { recursive: true, force: true });
+      } catch (err) {
+        cleanupError = err instanceof Error ? err.message : String(err);
+      }
+    }
+    return {
+      installedPath: join23(candidate.storageOnnxDir, installedRelativePath),
+      clearedPrevious: hadPrevious && cleanupError === undefined,
+      cleanupError
+    };
+  } finally {
+    try {
+      rmSync6(stagingStorageDir, { recursive: true, force: true });
+    } catch {}
+  }
+}
 async function runOnnxFix(adapters, report, options = {}) {
   const candidates = findOnnxFixCandidates(report);
   if (candidates.length === 0)
@@ -15829,12 +16186,12 @@ async function runOnnxFix(adapters, report, options = {}) {
   for (const candidate of candidates) {
     log2.info(`  • ${candidate.harness.displayName}: ${candidate.reason}`);
     if (candidate.storageOnnxBytes > 0) {
-      log2.info(`    will delete: ${candidate.storageOnnxDir} (${formatBytes(candidate.storageOnnxBytes)})`);
+      log2.info(`    will replace after a verified download: ${candidate.storageOnnxDir} (${formatBytes(candidate.storageOnnxBytes)})`);
     } else {
       log2.info("    no AFT-managed ONNX cache to delete");
     }
   }
-  note("This NEVER touches system paths like /usr/lib or C:\\Windows\\System32. It only replaces AFT's own ONNX cache, then downloads the compatible managed runtime.", "Safe operation");
+  note("This NEVER touches system paths like /usr/lib or C:\\Windows\\System32. It downloads and verifies a replacement before swapping AFT's own ONNX cache.", "Safe operation");
   const confirmFn = options.confirmFn ?? confirm2;
   const proceed = options.yes ? true : await confirmFn("Proceed with the fixes above?", true);
   if (!proceed) {
@@ -15845,30 +16202,20 @@ async function runOnnxFix(adapters, report, options = {}) {
   const rmFn = options.rmFn ?? rmSync6;
   const ensureFn = options.ensureFn ?? ensureOnnxRuntime;
   for (const candidate of candidates) {
-    if (existsSync22(candidate.storageOnnxDir)) {
-      try {
-        rmFn(candidate.storageOnnxDir, { recursive: true, force: true });
+    try {
+      log2.info(`${candidate.harness.displayName}: downloading managed ONNX Runtime…`);
+      const replacement = await installManagedReplacement(candidate, ensureFn, rmFn);
+      if (replacement.clearedPrevious) {
         result.cleared += 1;
         result.bytesReclaimed += candidate.storageOnnxBytes;
-        log2.success(`${candidate.harness.displayName}: cleared ${candidate.storageOnnxDir} (reclaimed ${formatBytes(candidate.storageOnnxBytes)})`);
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        log2.error(`${candidate.harness.displayName}: failed to clear ${candidate.storageOnnxDir}: ${message}`);
-        result.errors.push({ path: candidate.storageOnnxDir, error: message });
-        continue;
+        log2.success(`${candidate.harness.displayName}: replaced ${candidate.storageOnnxDir} (reclaimed ${formatBytes(candidate.storageOnnxBytes)})`);
       }
-    }
-    try {
-      log2.info(`${candidate.harness.displayName}: downloading managed ONNX Runtime…`);
-      const installedPath = await ensureFn(candidate.harness.storageDir.path);
-      if (!installedPath) {
-        const message = "managed ONNX Runtime download was unavailable";
-        log2.error(`${candidate.harness.displayName}: ${message}`);
-        result.errors.push({ path: candidate.storageOnnxDir, error: message });
-        continue;
+      if (replacement.cleanupError) {
+        log2.warn(`${candidate.harness.displayName}: installed the replacement but could not remove the previous runtime backup: ${replacement.cleanupError}`);
+        result.errors.push({ path: candidate.storageOnnxDir, error: replacement.cleanupError });
       }
       result.installed += 1;
-      log2.success(`${candidate.harness.displayName}: ONNX Runtime installed at ${installedPath}`);
+      log2.success(`${candidate.harness.displayName}: ONNX Runtime installed at ${replacement.installedPath}`);
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       log2.error(`${candidate.harness.displayName}: ONNX Runtime download failed: ${message}`);
@@ -15887,10 +16234,10 @@ var init_onnx_fix = __esm(() => {
 });
 
 // src/lib/sessions.ts
-import { existsSync as existsSync23, readdirSync as readdirSync11, readFileSync as readFileSync12, statSync as statSync13 } from "node:fs";
+import { existsSync as existsSync24, readdirSync as readdirSync12, readFileSync as readFileSync12, statSync as statSync13 } from "node:fs";
 import { createRequire as createRequire4 } from "node:module";
 import { homedir as homedir13 } from "node:os";
-import { basename as basename3, join as join23 } from "node:path";
+import { basename as basename3, join as join24 } from "node:path";
 function listRecentSessions(adapter) {
   try {
     if (adapter.kind === "opencode")
@@ -15921,8 +16268,8 @@ function mapOpenCodeSessionRows(rows) {
   }).filter((session) => session !== null).sort((a, b) => b.lastActivity - a.lastActivity).slice(0, MAX_RECENT_SESSIONS);
 }
 function listRecentOpenCodeSessions() {
-  const dbPath = join23(getXdgDataHome(), "opencode", "opencode.db");
-  if (!existsSync23(dbPath))
+  const dbPath = join24(getXdgDataHome(), "opencode", "opencode.db");
+  if (!existsSync24(dbPath))
     return [];
   let db = null;
   try {
@@ -15941,10 +16288,10 @@ function listRecentOpenCodeSessions() {
 }
 function getXdgDataHome() {
   const xdgDataHome = process.env.XDG_DATA_HOME;
-  return xdgDataHome && xdgDataHome.length > 0 ? xdgDataHome : join23(homedir13(), ".local", "share");
+  return xdgDataHome && xdgDataHome.length > 0 ? xdgDataHome : join24(homedir13(), ".local", "share");
 }
 function listRecentPiSessions() {
-  return listPiSessionsFromDir(join23(getHomeDir(), ".pi", "agent", "sessions"));
+  return listPiSessionsFromDir(join24(getHomeDir(), ".pi", "agent", "sessions"));
 }
 function getHomeDir() {
   const envHome = process.platform === "win32" ? process.env.USERPROFILE : process.env.HOME;
@@ -15952,7 +16299,7 @@ function getHomeDir() {
 }
 function listPiSessionsFromDir(sessionsDir) {
   try {
-    if (!existsSync23(sessionsDir))
+    if (!existsSync24(sessionsDir))
       return [];
     const files = collectJsonlFiles(sessionsDir).map((filePath) => {
       try {
@@ -15985,12 +16332,12 @@ function collectJsonlFiles(root) {
       continue;
     let entries;
     try {
-      entries = readdirSync11(dir, { withFileTypes: true });
+      entries = readdirSync12(dir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
-      const path = join23(dir, entry.name);
+      const path = join24(dir, entry.name);
       if (entry.isDirectory()) {
         stack.push(path);
       } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
@@ -16077,8 +16424,8 @@ var init_sessions = __esm(() => {
 import { spawn as spawn4, spawnSync as spawnSync9 } from "node:child_process";
 import {
   chmodSync as chmodSync4,
-  existsSync as existsSync24,
-  mkdirSync as mkdirSync6,
+  existsSync as existsSync25,
+  mkdirSync as mkdirSync7,
   mkdtempSync as mkdtempSync2,
   readFileSync as readFileSync13,
   realpathSync as realpathSync5,
@@ -16087,7 +16434,7 @@ import {
   writeFileSync as writeFileSync3
 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join24 } from "node:path";
+import { join as join25 } from "node:path";
 function openCodeAdapter(adapters) {
   return adapters.find((adapter) => adapter.kind === "opencode");
 }
@@ -16095,9 +16442,11 @@ function detectOpenCodeForCommand(adapters, override) {
   const adapter = openCodeAdapter(adapters);
   if (!adapter)
     return null;
-  if (override)
-    return override();
-  return adapter instanceof OpenCodeAdapter ? adapter.detectHostGeneration() : null;
+  if (!(adapter instanceof OpenCodeAdapter))
+    return override ? override() : null;
+  const detection = override ? override() : adapter.detectHostGeneration();
+  adapter.useHostDetection(detection);
+  return detection;
 }
 function refuseAmbiguousOpenCodeWrites(detection) {
   if (detection?.status !== "ambiguous")
@@ -16122,7 +16471,7 @@ function buildDoctorProfileArgs(argv) {
 function runDoctorProfile(argv) {
   const binary = findAftBinary();
   if (!binary) {
-    console.error("aft doctor --profile requires a native AFT binary; run `aft doctor --fix` first.");
+    console.error(missingAftBinaryMessage("aft doctor --profile"));
     return 1;
   }
   const result = spawnSync9(binary, buildDoctorProfileArgs(argv), {
@@ -16141,7 +16490,7 @@ async function runDoctor(options) {
   }
   intro(`${CLI} doctor`);
   if (options.fix) {
-    return runFixFlow(options.argv, options.detectOpenCodeHost, options.resolveAdapters, options.collectDiagnostics);
+    return runFixFlow(options.argv, options.detectOpenCodeHost, options.resolveAdapters, options.collectDiagnostics, options.applyOnnxFix);
   }
   if (options.clear) {
     return runClearFlow(options.argv);
@@ -16448,7 +16797,7 @@ function clearOldBinaries() {
     errors: [],
     keptVersion: keepTag
   };
-  if (!existsSync24(info.path)) {
+  if (!existsSync25(info.path)) {
     log2.info(`Binary cache: nothing to clear at ${info.path}`);
     return result;
   }
@@ -16458,7 +16807,7 @@ function clearOldBinaries() {
     return result;
   }
   for (const version of stale) {
-    const dir = join24(info.path, version);
+    const dir = join25(info.path, version);
     let bytes = 0;
     try {
       bytes = statSync14(dir).isDirectory() ? dirSize(dir) : 0;
@@ -16748,15 +17097,16 @@ function logUnmatchedBinaryCandidates(expectedVersion) {
     log2.warn(`  unmatched: ${candidate.path} reported v${candidate.version ?? "unknown"}`);
   }
 }
-async function runFixFlow(argv, detectOpenCodeHost, resolveAdapters = resolveAdaptersForCommand, collect = collectDiagnostics) {
+async function runFixFlow(argv, detectOpenCodeHost, resolveAdapters = resolveAdaptersForCommand, collect = collectDiagnostics, applyOnnxFix = runOnnxFix) {
   const adapters = await resolveAdapters(argv, {
     allowMulti: false,
     verb: "auto-fix issues for"
   });
   const hostDetection = detectOpenCodeForCommand(adapters, detectOpenCodeHost);
-  if (refuseAmbiguousOpenCodeWrites(hostDetection)) {
-    outro("Done — no changes made.");
-    return 1;
+  const configWritesRefused = refuseAmbiguousOpenCodeWrites(hostDetection);
+  const skipped = [];
+  if (configWritesRefused) {
+    skipped.push("plugin registration in the OpenCode config (leave one OpenCode generation on PATH and re-run)");
   }
   if (hostDetection?.status === "unknown") {
     log2.warn("OpenCode: host generation is unavailable; applying only generation-independent exact-pin config fixes.");
@@ -16768,7 +17118,7 @@ async function runFixFlow(argv, detectOpenCodeHost, resolveAdapters = resolveAda
   if (!report.binaryVersion) {
     logUnmatchedBinaryCandidates(report.cliVersion);
   }
-  const plan = buildDoctorFixPlan(adapters, report);
+  const plan = buildDoctorFixPlan(adapters, report).filter((item) => !(configWritesRefused && item.kind === "plugin"));
   if (plan.length > 0) {
     log2.warn("Planned changes:");
     for (const item of plan) {
@@ -16780,7 +17130,7 @@ async function runFixFlow(argv, detectOpenCodeHost, resolveAdapters = resolveAda
       return 0;
     }
   }
-  await fixPluginEntries(adapters);
+  const pluginEntrySummary = configWritesRefused ? { changed: 0, errors: 0 } : await fixPluginEntries(adapters);
   const pluginUpdateSummary = await applyPluginUpdates(findPluginUpdateTargets(adapters, report));
   const storageSummary = ensureStorageDirsForRegisteredPlugins(adapters);
   const schemaSummary = applySchemaFixes(findSchemaFixTargets(adapters));
@@ -16791,6 +17141,7 @@ async function runFixFlow(argv, detectOpenCodeHost, resolveAdapters = resolveAda
     const shouldDownload = await confirmBinaryDownloadDespitePluginSkew(report, argv);
     if (!shouldDownload) {
       binaryDownloadSkipped = true;
+      skipped.push("aft binary download (declined because the installed plugin would not use it)");
     } else {
       log2.info("AFT binary not found. Downloading…");
       try {
@@ -16810,20 +17161,37 @@ async function runFixFlow(argv, detectOpenCodeHost, resolveAdapters = resolveAda
       }
     }
   }
-  const onnxResult = await runOnnxFix(adapters, report, { yes: true });
-  if (onnxResult === null && !binaryDownloaded && !binaryDownloadSkipped && !binaryDownloadError && storageSummary.created === 0 && storageSummary.errors === 0 && schemaSummary.changed === 0 && schemaSummary.errors === 0 && pluginUpdateSummary.updated === 0 && pluginUpdateSummary.errors === 0) {
+  const onnxResult = await applyOnnxFix(adapters, report, { yes: true });
+  const applied = [];
+  if (pluginEntrySummary.changed > 0)
+    applied.push("plugin registration");
+  if (pluginUpdateSummary.updated > 0)
+    applied.push("plugin package update");
+  if (storageSummary.created > 0)
+    applied.push("AFT storage directory");
+  if (schemaSummary.changed > 0)
+    applied.push("AFT config $schema");
+  if (binaryDownloaded)
+    applied.push("aft binary download");
+  if ((onnxResult?.installed ?? 0) > 0)
+    applied.push("ONNX Runtime install");
+  const nothingAttempted = onnxResult === null && !binaryDownloaded && !binaryDownloadSkipped && !binaryDownloadError && storageSummary.created === 0 && storageSummary.errors === 0 && schemaSummary.changed === 0 && schemaSummary.errors === 0 && pluginEntrySummary.changed === 0 && pluginEntrySummary.errors === 0 && pluginUpdateSummary.updated === 0 && pluginUpdateSummary.errors === 0;
+  if (nothingAttempted && skipped.length === 0) {
     log2.info("No auto-fixable issues detected.");
     note(`If you're still seeing 'Semantic Index: failed' in the TUI sidebar, run \`${CLI} doctor\` (without --fix) for a full diagnostic dump.`, "Tip");
-    const afterReport = await collect(adapters);
-    const stillHasProblems = hasDoctorProblems(afterReport);
-    outro(stillHasProblems ? "Done — some issues remain." : "Done.");
-    return stillHasProblems ? 1 : 0;
+  } else {
+    logDoctorFixSummary(applied, skipped);
   }
-  const hadErrors = (onnxResult?.errors.length ?? 0) > 0 || binaryDownloadError !== null || storageSummary.errors > 0 || schemaSummary.errors > 0 || pluginUpdateSummary.errors > 0;
-  const afterReport = await collectDiagnostics(adapters);
+  const hadErrors = (onnxResult?.errors.length ?? 0) > 0 || binaryDownloadError !== null || storageSummary.errors > 0 || schemaSummary.errors > 0 || pluginEntrySummary.errors > 0 || pluginUpdateSummary.errors > 0;
+  const afterReport = await collect(adapters);
   const stillHasProblems = hasDoctorProblems(afterReport);
-  outro(hadErrors ? "Done — some fixes failed." : stillHasProblems ? "Done — some issues remain." : "Done.");
-  return hadErrors || stillHasProblems ? 1 : 0;
+  outro(hadErrors ? "Done — some fixes failed." : skipped.length > 0 ? "Done — some fixes were skipped." : stillHasProblems ? "Done — some issues remain." : "Done.");
+  return hadErrors || stillHasProblems || configWritesRefused ? 1 : 0;
+}
+function logDoctorFixSummary(applied, skipped) {
+  log2.info(applied.length > 0 ? `Applied: ${applied.join(", ")}.` : "Applied: no changes.");
+  if (skipped.length > 0)
+    log2.warn(`Skipped: ${skipped.join("; ")}.`);
 }
 function logDoctorIssues(report) {
   const lines = formatDiagnosticIssuesSection(report);
@@ -16877,9 +17245,9 @@ function ensureStorageDirsForRegisteredPlugins(adapters) {
       if (!adapter.isInstalled() || !adapter.hasPluginEntry())
         continue;
       const storageDir = adapter.getStorageDir();
-      if (existsSync24(storageDir))
+      if (existsSync25(storageDir))
         continue;
-      mkdirSync6(storageDir, { recursive: true });
+      mkdirSync7(storageDir, { recursive: true });
       summary.created += 1;
       log2.success(`${adapter.displayName}: created AFT storage directory at ${storageDir}`);
     } catch (err) {
@@ -16926,19 +17294,27 @@ function reportLspCacheClear(cleanup) {
   }
 }
 async function fixPluginEntries(adapters) {
+  const summary = { changed: 0, errors: 0 };
   for (const adapter of adapters) {
-    await maybeFixPlugin(adapter);
+    const result = await maybeFixPlugin(adapter);
+    summary.changed += result.changed;
+    summary.errors += result.errors;
   }
+  return summary;
 }
 async function maybeFixPlugin(adapter) {
+  const summary = { changed: 0, errors: 0 };
   if (!adapter.isInstalled())
-    return;
+    return summary;
   if (!adapter.hasPluginEntry() || adapterConfigNeedsUpdate(adapter)) {
     log2.info(`${adapter.displayName}: attempting to register or update plugin config…`);
     const result = await adapter.ensurePluginEntry();
     if (result.ok) {
+      if (result.action === "added" || result.action === "updated")
+        summary.changed += 1;
       log2.success(`${adapter.displayName}: ${result.message}`);
     } else {
+      summary.errors += 1;
       log2.error(`${adapter.displayName}: ${result.message}`);
     }
   }
@@ -16947,12 +17323,15 @@ async function maybeFixPlugin(adapter) {
     if (!hasTuiEntry || adapterConfigNeedsUpdate(adapter, true)) {
       const result = await adapter.ensureTuiPluginEntry();
       if (result.ok && (result.action === "added" || result.action === "updated")) {
+        summary.changed += 1;
         log2.success(`${adapter.displayName}: ${result.message}`);
       } else if (!result.ok) {
+        summary.errors += 1;
         log2.error(`${adapter.displayName}: ${result.message}`);
       }
     }
   }
+  return summary;
 }
 function describeAdapterInstallHint(kind) {
   if (kind === "opencode")
@@ -17027,11 +17406,11 @@ function deriveIssueTitleFromBody(body) {
 function writeIssueReviewFile(body) {
   let reviewDir = null;
   try {
-    reviewDir = mkdtempSync2(join24(tmpdir2(), "aft-issue-"));
+    reviewDir = mkdtempSync2(join25(tmpdir2(), "aft-issue-"));
     if (process.platform !== "win32") {
       chmodSync4(reviewDir, 448);
     }
-    const outPath = join24(reviewDir, "issue.md");
+    const outPath = join25(reviewDir, "issue.md");
     writeFileSync3(outPath, `${body}
 `, { encoding: "utf8", mode: 384, flag: "wx" });
     return { path: outPath, realPath: realpathSync5(outPath) };
@@ -17233,21 +17612,21 @@ var init_doctor = __esm(async () => {
 });
 
 // src/commands/lsp.ts
-import { existsSync as existsSync25, readdirSync as readdirSync12, statSync as statSync15 } from "node:fs";
+import { existsSync as existsSync26, readdirSync as readdirSync13, statSync as statSync15 } from "node:fs";
 import { createRequire as createRequire5 } from "node:module";
-import { dirname as dirname8, join as join25, resolve as resolve11 } from "node:path";
+import { dirname as dirname8, join as join26, resolve as resolve11 } from "node:path";
 function findProjectRootForFile(filePath, fallbackCwd = process.cwd()) {
   const resolvedFile = resolve11(fallbackCwd, filePath);
   let dir = dirname8(resolvedFile);
   try {
-    if (existsSync25(resolvedFile) && statSync15(resolvedFile).isDirectory()) {
+    if (existsSync26(resolvedFile) && statSync15(resolvedFile).isDirectory()) {
       dir = resolvedFile;
     }
   } catch {
     dir = dirname8(resolvedFile);
   }
   while (true) {
-    if (PROJECT_ROOT_MARKERS.some((marker) => existsSync25(join25(dir, marker)))) {
+    if (PROJECT_ROOT_MARKERS.some((marker) => existsSync26(join26(dir, marker)))) {
       return dir;
     }
     const parent = dirname8(dir);
@@ -17396,18 +17775,18 @@ function buildConfigureParams(adapter, projectRoot) {
 function inferLspPathsExtra(_lsp) {
   const paths = new Set;
   for (const entry of childDirs(getAftLspPackagesDir())) {
-    paths.add(join25(entry, "node_modules", ".bin"));
+    paths.add(join26(entry, "node_modules", ".bin"));
   }
   for (const entry of childDirs(getAftLspBinariesDir())) {
-    paths.add(join25(entry, "bin"));
+    paths.add(join26(entry, "bin"));
   }
   return [...paths];
 }
 function childDirs(path) {
-  if (!existsSync25(path))
+  if (!existsSync26(path))
     return [];
   try {
-    return readdirSync12(path).map((entry) => join25(path, entry)).filter((entry) => {
+    return readdirSync13(path).map((entry) => join26(path, entry)).filter((entry) => {
       try {
         return statSync15(entry).isDirectory();
       } catch {
@@ -17449,7 +17828,7 @@ function typescriptPackageWarning(response) {
   if (!typescriptServerSpawned || !response.project_root || diagnosticsCount > 0)
     return null;
   try {
-    createRequire5(join25(response.project_root, "package.json")).resolve("typescript");
+    createRequire5(join26(response.project_root, "package.json")).resolve("typescript");
     return null;
   } catch {
     return "typescript package not resolvable from project — server will produce no diagnostics";
@@ -17489,9 +17868,9 @@ var init_lsp = __esm(async () => {
 });
 
 // src/commands/doctor-filters.ts
-import { existsSync as existsSync26 } from "node:fs";
+import { existsSync as existsSync27 } from "node:fs";
 import { homedir as homedir14 } from "node:os";
-import { relative as relative2, resolve as resolve12 } from "node:path";
+import { relative as relative3, resolve as resolve12 } from "node:path";
 function printDoctorFiltersHelp() {
   console.log(`Usage: ${CLI} doctor filters [--show <name>] [trust|untrust]`);
   console.log("");
@@ -17532,7 +17911,7 @@ async function runDoctorFilters(options) {
     log2.error(list.message ?? list.code ?? "list_filters failed");
     return 1;
   }
-  list.project_dir_exists = list.project_dir ? existsSync26(list.project_dir) : false;
+  list.project_dir_exists = list.project_dir ? existsSync27(list.project_dir) : false;
   if (mode.kind === "list") {
     console.log(renderFilterList(list, projectRoot));
     return 0;
@@ -17714,7 +18093,7 @@ function formatHome(path) {
 function formatProjectPath(path, projectRoot) {
   if (!path)
     return "";
-  const rel = relative2(projectRoot, path);
+  const rel = relative3(projectRoot, path);
   return rel.startsWith("..") || rel === "" ? path : `./${rel}`;
 }
 function formatSourcePath(path, projectRoot) {