@cortexkit/aft-opencode 0.26.4 → 0.27.0

package/dist/index.js

@@ -1607,10 +1607,10 @@ var require_esprima = __commonJS((exports, module) => {
         }();
         exports2.TaggedTemplateExpression = TaggedTemplateExpression;
         var TemplateElement = function() {
-          function TemplateElement2(value, tail) {
+          function TemplateElement2(value, tail2) {
             this.type = syntax_1.Syntax.TemplateElement;
             this.value = value;
-            this.tail = tail;
+            this.tail = tail2;
           }
           return TemplateElement2;
         }();
@@ -5450,14 +5450,14 @@ var require_esprima = __commonJS((exports, module) => {
             var terminated = false;
             var start = this.index;
             var head = this.source[start] === "`";
-            var tail = false;
+            var tail2 = false;
             var rawOffset = 2;
             ++this.index;
             while (!this.eof()) {
               var ch = this.source[this.index++];
               if (ch === "`") {
                 rawOffset = 1;
-                tail = true;
+                tail2 = true;
                 terminated = true;
                 break;
               } else if (ch === "$") {
@@ -5558,7 +5558,7 @@ var require_esprima = __commonJS((exports, module) => {
               value: this.source.slice(start + 1, this.index - rawOffset),
               cooked,
               head,
-              tail,
+              tail: tail2,
               lineNumber: this.lineNumber,
               lineStart: this.lineStart,
               start,
@@ -7652,10 +7652,10 @@ var require_stringify = __commonJS((exports, module) => {
     replacer = null;
     indent = EMPTY;
   };
-  var join7 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(one, gap)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two, gap)), gap) : EMPTY;
+  var join8 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(one, gap)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two, gap)), gap) : EMPTY;
   var join_content = (inside, value, gap) => {
     const comment = process_comments(value, PREFIX_BEFORE, gap + indent, true);
-    return join7(comment, inside, gap);
+    return join8(comment, inside, gap);
   };
   var stringify_string = (holder, key, value) => {
     const raw = get_raw_string_literal(holder, key);
@@ -7677,13 +7677,13 @@ var require_stringify = __commonJS((exports, module) => {
       if (i !== 0) {
         inside += COMMA;
       }
-      const before = join7(after_comma, process_comments(value, BEFORE(i), deeper_gap), deeper_gap);
+      const before = join8(after_comma, process_comments(value, BEFORE(i), deeper_gap), deeper_gap);
       inside += before || LF + deeper_gap;
       inside += stringify(i, value, deeper_gap) || STR_NULL;
       inside += process_comments(value, AFTER_VALUE(i), deeper_gap);
       after_comma = process_comments(value, AFTER(i), deeper_gap);
     }
-    inside += join7(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join8(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
     return BRACKET_OPEN + join_content(inside, value, gap) + BRACKET_CLOSE;
   };
   var object_stringify = (value, gap) => {
@@ -7704,13 +7704,13 @@ var require_stringify = __commonJS((exports, module) => {
         inside += COMMA;
       }
       first = false;
-      const before = join7(after_comma, process_comments(value, BEFORE(key), deeper_gap), deeper_gap);
+      const before = join8(after_comma, process_comments(value, BEFORE(key), deeper_gap), deeper_gap);
       inside += before || LF + deeper_gap;
       inside += quote(key) + process_comments(value, AFTER_PROP(key), deeper_gap) + COLON + process_comments(value, AFTER_COLON(key), deeper_gap) + SPACE + sv + process_comments(value, AFTER_VALUE(key), deeper_gap);
       after_comma = process_comments(value, AFTER(key), deeper_gap);
     };
     keys.forEach(iteratee);
-    inside += join7(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join8(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
     return CURLY_BRACKET_OPEN + join_content(inside, value, gap) + CURLY_BRACKET_CLOSE;
   };
   function stringify(key, holder, gap) {
@@ -7803,10 +7803,9 @@ var require_src2 = __commonJS((exports, module) => {
 });
 
 // src/index.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync12, readFileSync as readFileSync12, writeFileSync as writeFileSync12 } from "fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync13, readFileSync as readFileSync12, writeFileSync as writeFileSync12 } from "fs";
 import { createRequire as createRequire2 } from "module";
-import { homedir as homedir10 } from "os";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 
 // ../aft-bridge/dist/active-logger.js
 var ACTIVE_LOGGER_SYMBOL = Symbol.for("aft-bridge-active-logger");
@@ -8831,11 +8830,288 @@ async function fetchLatestTag() {
     clearTimeout(timeout);
   }
 }
+// ../aft-bridge/dist/migration.js
+import { spawnSync as spawnSync2 } from "child_process";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3 } from "fs";
+import { homedir as homedir4, tmpdir } from "os";
+import { dirname, join as join4 } from "path";
+
+// ../aft-bridge/dist/resolver.js
+import { execSync, spawnSync } from "child_process";
+import { chmodSync as chmodSync2, copyFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2, renameSync as renameSync2 } from "fs";
+import { createRequire } from "module";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
+function readBinaryVersion(binaryPath) {
+  try {
+    const result = spawnSync(binaryPath, ["--version"], {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 5000
+    });
+    const stdoutVersion = result.stdout?.trim();
+    const stderrVersion = result.stderr?.trim();
+    const rawVersion = stdoutVersion || stderrVersion;
+    if (!rawVersion)
+      return null;
+    return rawVersion.replace(/^aft\s+/, "");
+  } catch {
+    return null;
+  }
+}
+function copyToVersionedCache(npmBinaryPath, knownVersion) {
+  try {
+    const version = knownVersion ?? readBinaryVersion(npmBinaryPath);
+    if (!version)
+      return null;
+    const tag = version.startsWith("v") ? version : `v${version}`;
+    const cacheDir = getCacheDir();
+    const versionedDir = join3(cacheDir, tag);
+    const ext = process.platform === "win32" ? ".exe" : "";
+    const cachedPath = join3(versionedDir, `aft${ext}`);
+    if (existsSync2(cachedPath)) {
+      const cachedVersion = readBinaryVersion(cachedPath);
+      if (cachedVersion === version)
+        return cachedPath;
+      warn(`Cached binary at ${cachedPath} reports ${cachedVersion ?? "no version"}, expected ${version}; refreshing from npm package`);
+    }
+    mkdirSync2(versionedDir, { recursive: true });
+    const tmpPath = `${cachedPath}.${process.pid}.${Date.now()}.tmp`;
+    copyFileSync(npmBinaryPath, tmpPath);
+    if (process.platform !== "win32") {
+      chmodSync2(tmpPath, 493);
+    }
+    renameSync2(tmpPath, cachedPath);
+    log(`Copied npm binary to versioned cache: ${cachedPath}`);
+    return cachedPath;
+  } catch (err) {
+    warn(`Failed to copy binary to cache: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  }
+}
+function normalizeBareVersion(version) {
+  return version.startsWith("v") ? version.slice(1) : version;
+}
+function homeDirFromEnv(env) {
+  return (process.platform === "win32" ? env.USERPROFILE || env.HOME : env.HOME) || homedir3();
+}
+function cacheDirFromEnv(env) {
+  if (process.platform === "win32") {
+    const base2 = env.LOCALAPPDATA || env.APPDATA || join3(homeDirFromEnv(env), "AppData", "Local");
+    return join3(base2, "aft", "bin");
+  }
+  const base = env.XDG_CACHE_HOME || join3(homeDirFromEnv(env), ".cache");
+  return join3(base, "aft", "bin");
+}
+function cachedBinaryPathFromEnv(version, env, ext) {
+  const binaryPath = join3(cacheDirFromEnv(env), version, `aft${ext}`);
+  return existsSync2(binaryPath) ? binaryPath : null;
+}
+function isExpectedCachedBinary(binaryPath, expectedVersion) {
+  const expected = normalizeBareVersion(expectedVersion);
+  const actual = readBinaryVersion(binaryPath);
+  if (actual === expected)
+    return true;
+  warn(`Cached binary at ${binaryPath} reports ${actual ?? "no version"}, expected ${expected}; skipping cache candidate`);
+  return false;
+}
+function platformKey(platform = process.platform, arch = process.arch) {
+  const archMap = PLATFORM_ARCH_MAP[platform];
+  if (!archMap) {
+    throw new Error(`Unsupported platform: ${platform} (arch: ${arch}). ` + `Supported platforms: ${Object.keys(PLATFORM_ARCH_MAP).join(", ")}`);
+  }
+  const key = archMap[arch];
+  if (!key) {
+    throw new Error(`Unsupported architecture: ${arch} on platform ${platform}. ` + `Supported architectures for ${platform}: ${Object.keys(archMap).join(", ")}`);
+  }
+  return key;
+}
+function findBinarySync(expectedVersion) {
+  const ext = process.platform === "win32" ? ".exe" : "";
+  const env = { ...process.env };
+  const pluginVersion = expectedVersion ?? (() => {
+    try {
+      const req = createRequire(import.meta.url);
+      return req("../package.json").version;
+    } catch {
+      return null;
+    }
+  })();
+  if (pluginVersion) {
+    const tag = pluginVersion.startsWith("v") ? pluginVersion : `v${pluginVersion}`;
+    const versionCached = cachedBinaryPathFromEnv(tag, env, ext);
+    if (versionCached && isExpectedCachedBinary(versionCached, pluginVersion))
+      return versionCached;
+  }
+  try {
+    const key = platformKey();
+    const packageBin = `@cortexkit/aft-${key}/bin/aft${ext}`;
+    const req = createRequire(import.meta.url);
+    const resolved = req.resolve(packageBin);
+    if (existsSync2(resolved)) {
+      const npmVersion = readBinaryVersion(resolved);
+      if (npmVersion === null) {
+        warn(`npm platform package binary at ${resolved} did not report a version; skipping (continuing to PATH lookup)`);
+      } else if (pluginVersion && npmVersion !== normalizeBareVersion(pluginVersion)) {
+        warn(`npm platform package binary v${npmVersion} does not match plugin v${pluginVersion}; skipping (continuing to PATH lookup)`);
+      } else {
+        const copied = copyToVersionedCache(resolved, npmVersion);
+        return copied ?? resolved;
+      }
+    }
+  } catch {}
+  try {
+    const whichCmd = process.platform === "win32" ? "where aft" : "which aft";
+    const result = execSync(whichCmd, {
+      encoding: "utf-8",
+      env,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    if (result)
+      return result;
+  } catch {}
+  const cargoPath = join3(homeDirFromEnv(env), ".cargo", "bin", `aft${ext}`);
+  if (existsSync2(cargoPath))
+    return cargoPath;
+  return null;
+}
+async function findBinary(expectedVersion) {
+  const syncResult = findBinarySync(expectedVersion);
+  if (syncResult) {
+    log(`Resolved binary: ${syncResult}`);
+    return syncResult;
+  }
+  log("Binary not found locally, attempting auto-download...");
+  const downloaded = await ensureBinary(expectedVersion);
+  if (downloaded)
+    return downloaded;
+  throw new Error([
+    "Could not find the `aft` binary.",
+    "",
+    "Attempted sources:",
+    "  - Cache directory (~/.cache/aft/bin/)",
+    "  - npm platform package (@cortexkit/aft-<platform>)",
+    "  - PATH lookup (which aft)",
+    "  - ~/.cargo/bin/aft",
+    "  - Auto-download from GitHub releases (failed)",
+    "",
+    "Install it using one of these methods:",
+    "  npm install @cortexkit/aft-opencode        # installs platform-specific binary via npm",
+    "  cargo install agent-file-tools             # from crates.io",
+    "  cargo build --release         # from source (binary at target/release/aft)",
+    "",
+    "Or add the aft directory to your PATH."
+  ].join(`
+`));
+}
+
+// ../aft-bridge/dist/migration.js
+var TARGET_MARKER = ".migrated_from_legacy";
+var DEFAULT_TIMEOUT_MS = 30 * 60 * 1000;
+function dataHome() {
+  if (process.env.XDG_DATA_HOME)
+    return process.env.XDG_DATA_HOME;
+  if (process.platform === "win32") {
+    return process.env.LOCALAPPDATA || process.env.APPDATA || join4(homeDir(), "AppData", "Local");
+  }
+  return join4(homeDir(), ".local", "share");
+}
+function homeDir() {
+  if (process.platform === "win32")
+    return process.env.USERPROFILE || process.env.HOME || homedir4();
+  return process.env.HOME || homedir4();
+}
+function resolveLegacyStorageRoot(harness) {
+  if (harness === "pi")
+    return join4(homeDir(), ".pi", "agent", "aft");
+  return join4(dataHome(), "opencode", "storage", "plugin", "aft");
+}
+function resolveCortexKitStorageRoot() {
+  return join4(dataHome(), "cortexkit", "aft");
+}
+function tail(value) {
+  if (!value)
+    return "";
+  return value.split(`
+`).slice(-20).join(`
+`).trim();
+}
+function spawnErrorLabel(error2) {
+  const code = "code" in error2 ? String(error2.code ?? "") : "";
+  return [code, error2.message].filter(Boolean).join(": ");
+}
+function migrationLogPath(newRoot, harness, logger) {
+  const desired = join4(newRoot, "logs", "migration", `${harness}-${Date.now()}.jsonl`);
+  try {
+    mkdirSync3(dirname(desired), { recursive: true });
+    return desired;
+  } catch (err) {
+    const fallback = join4(tmpdir(), `aft-migration-${harness}-${Date.now()}.jsonl`);
+    logger?.warn?.(`Failed to create AFT migration log directory ${dirname(desired)}: ${err instanceof Error ? err.message : String(err)}. ` + `Using fallback log path ${fallback}.`);
+    return fallback;
+  }
+}
+async function ensureStorageMigrated(opts) {
+  const legacyRoot = resolveLegacyStorageRoot(opts.harness);
+  const newRoot = resolveCortexKitStorageRoot();
+  const targetMarker = join4(newRoot, opts.harness, TARGET_MARKER);
+  const info = opts.logger?.info ?? opts.logger?.log;
+  if (existsSync3(targetMarker)) {
+    info?.(`AFT storage already migrated for ${opts.harness}; using ${newRoot}`);
+    return;
+  }
+  if (!existsSync3(legacyRoot)) {
+    info?.(`AFT storage migration skipped for ${opts.harness}: no legacy data at ${legacyRoot}; ` + `using ${newRoot} for fresh install`);
+    return;
+  }
+  const logPath = migrationLogPath(newRoot, opts.harness, opts.logger);
+  const binaryPath = opts.binaryPath ?? await findBinary();
+  const startMs = Date.now();
+  info?.(`AFT storage migration starting for ${opts.harness}: ${legacyRoot} -> ${newRoot} ` + `(binary=${binaryPath}, log=${logPath})`);
+  try {
+    process.stderr.write(`
+[AFT] Migrating ${opts.harness} storage to ${newRoot}.
+` + `[AFT] This may take several minutes for large indexes \u2014 please do not close ${opts.harness === "pi" ? "Pi" : "OpenCode"}.
+` + `[AFT] Source: ${legacyRoot}
+` + `[AFT] Log:    ${logPath}
+
+`);
+  } catch {}
+  const result = spawnSync2(binaryPath, [
+    "migrate-storage",
+    "--from",
+    legacyRoot,
+    "--to",
+    newRoot,
+    "--harness",
+    opts.harness,
+    "--log",
+    logPath
+  ], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS
+  });
+  if (!result.error && result.status === 0) {
+    const elapsedMs = Date.now() - startMs;
+    info?.(`AFT storage migration completed for ${opts.harness} in ${elapsedMs}ms (log=${logPath})`);
+    try {
+      process.stderr.write(`[AFT] Migration complete (${(elapsedMs / 1000).toFixed(1)}s).
+
+`);
+    } catch {}
+    return;
+  }
+  const detail = result.error ? `spawn error ${spawnErrorLabel(result.error)}` : result.status === null ? `terminated by signal ${result.signal ?? "unknown"}` : `exit ${result.status}`;
+  const stderrTail = tail(result.stderr);
+  const stdoutTail = tail(result.stdout);
+  throw new Error(`AFT storage migration failed (${detail}). ` + `Harness: ${opts.harness}. Legacy: ${legacyRoot}. Target: ${newRoot}. ` + `See log: ${logPath}. ` + `Plugin load aborted to prevent legacy/new state divergence.` + (stderrTail ? ` Stderr tail: ${stderrTail}` : "") + (stdoutTail ? ` Stdout tail: ${stdoutTail}` : ""));
+}
 // ../aft-bridge/dist/onnx-runtime.js
 import { execFileSync } from "child_process";
 import { createHash as createHash2 } from "crypto";
-import { chmodSync as chmodSync2, closeSync as closeSync2, copyFileSync, createWriteStream as createWriteStream2, existsSync as existsSync2, lstatSync, mkdirSync as mkdirSync2, openSync as openSync2, readdirSync, readFileSync, readlinkSync, realpathSync, rmSync as rmSync2, statSync as statSync2, symlinkSync, unlinkSync as unlinkSync2, writeFileSync } from "fs";
-import { dirname, join as join3, relative, resolve } from "path";
+import { chmodSync as chmodSync3, closeSync as closeSync2, copyFileSync as copyFileSync2, createWriteStream as createWriteStream2, existsSync as existsSync4, lstatSync, mkdirSync as mkdirSync4, openSync as openSync2, readdirSync, readFileSync, readlinkSync, realpathSync, rmSync as rmSync2, statSync as statSync2, symlinkSync, unlinkSync as unlinkSync2, writeFileSync } from "fs";
+import { dirname as dirname2, join as join5, relative, resolve } from "path";
 import { Readable as Readable2 } from "stream";
 import { pipeline as pipeline2 } from "stream/promises";
 var ORT_VERSION = "1.24.4";
@@ -8883,8 +9159,8 @@ function getPlatformInfo() {
   if (!platformMap)
     return null;
   const archMap = PLATFORM_ARCH_MAP[process.platform] ?? {};
-  const platformKey = archMap[process.arch];
-  const ortArch = platformKey ? platformKey.split("-")[1] : process.arch;
+  const platformKey2 = archMap[process.arch];
+  const ortArch = platformKey2 ? platformKey2.split("-")[1] : process.arch;
   return platformMap[ortArch] || null;
 }
 function isOrtAutoDownloadSupported() {
@@ -8901,9 +9177,9 @@ function getManualInstallHint() {
 }
 async function ensureOnnxRuntime(storageDir) {
   const info = getPlatformInfo();
-  const ortDir = join3(storageDir, "onnxruntime", ORT_VERSION);
-  const libPath = join3(ortDir, info?.libName ?? "libonnxruntime.dylib");
-  if (existsSync2(libPath)) {
+  const ortDir = join5(storageDir, "onnxruntime", ORT_VERSION);
+  const libPath = join5(ortDir, info?.libName ?? "libonnxruntime.dylib");
+  if (existsSync4(libPath)) {
     const meta = readOnnxInstalledMeta(ortDir);
     if (meta?.sha256) {
       try {
@@ -8932,9 +9208,9 @@ async function ensureOnnxRuntime(storageDir) {
     warn(`ONNX Runtime auto-download not available for ${process.platform}/${process.arch}. Install manually: ${getManualInstallHint()}`);
     return null;
   }
-  const onnxBaseDir = join3(storageDir, "onnxruntime");
-  mkdirSync2(onnxBaseDir, { recursive: true });
-  const lockPath = join3(onnxBaseDir, ONNX_LOCK_FILE);
+  const onnxBaseDir = join5(storageDir, "onnxruntime");
+  mkdirSync4(onnxBaseDir, { recursive: true });
+  const lockPath = join5(onnxBaseDir, ONNX_LOCK_FILE);
   cleanupAbandonedStagingDirs(onnxBaseDir);
   if (!acquireLock(lockPath)) {
     warn(`ONNX Runtime install already in progress in another process (lock: ${lockPath}). Skipping.`);
@@ -8953,7 +9229,7 @@ function cleanupAbandonedStagingDirs(onnxBaseDir) {
     for (const entry of entries) {
       if (!entry.startsWith(`${ORT_VERSION}.tmp.`))
         continue;
-      const stagingDir = join3(onnxBaseDir, entry);
+      const stagingDir = join5(onnxBaseDir, entry);
       const parts = entry.split(".");
       const pidStr = parts[parts.length - 2];
       const pid = pidStr ? Number.parseInt(pidStr, 10) : NaN;
@@ -8985,7 +9261,7 @@ function cleanupAbandonedStagingDirs(onnxBaseDir) {
 }
 function cleanupIncompleteTargetIfUnowned(ortDir) {
   try {
-    if (existsSync2(ortDir) && !existsSync2(join3(ortDir, ONNX_INSTALLED_META_FILE))) {
+    if (existsSync4(ortDir) && !existsSync4(join5(ortDir, ONNX_INSTALLED_META_FILE))) {
       log(`[onnx] removing half-populated install dir ${ortDir} (no meta file)`);
       rmSync2(ortDir, { recursive: true, force: true });
     }
@@ -9006,8 +9282,8 @@ function detectOnnxVersion(libDir, libName) {
       if (match)
         return match[1];
     }
-    const base = join3(libDir, libName);
-    if (existsSync2(base)) {
+    const base = join5(libDir, libName);
+    if (existsSync4(base)) {
       try {
         const real = realpathSync(base);
         const m = real.match(/\.(\d+\.\d+\.\d+)(?:\.dylib)?$/);
@@ -9043,7 +9319,7 @@ function findSystemOnnxRuntime(libName) {
     searchPaths.push("/usr/lib", "/usr/lib/x86_64-linux-gnu", "/usr/lib/aarch64-linux-gnu", "/usr/local/lib");
   }
   for (const dir of searchPaths) {
-    if (!existsSync2(join3(dir, libName)))
+    if (!existsSync4(join5(dir, libName)))
       continue;
     const version = detectOnnxVersion(dir, libName);
     if (version && !isOnnxVersionCompatible(version)) {
@@ -9070,7 +9346,7 @@ async function downloadFileWithCap(url, destPath) {
     if (Number.isFinite(advertised) && advertised > MAX_DOWNLOAD_BYTES2) {
       throw new Error(`Content-Length ${advertised} exceeds max ${MAX_DOWNLOAD_BYTES2}`);
     }
-    mkdirSync2(dirname(destPath), { recursive: true });
+    mkdirSync4(dirname2(destPath), { recursive: true });
     let bytesWritten = 0;
     const guard = new TransformStream({
       transform(chunk, transformController) {
@@ -9100,11 +9376,11 @@ function validateExtractedTree(stagingRoot) {
   const walk = (dir) => {
     const entries = readdirSync(dir);
     for (const entry of entries) {
-      const fullPath = join3(dir, entry);
+      const fullPath = join5(dir, entry);
       const lst = lstatSync(fullPath);
       if (lst.isSymbolicLink()) {
         const linkTarget = readlinkSync(fullPath);
-        const resolvedTarget = resolve(dirname(fullPath), linkTarget);
+        const resolvedTarget = resolve(dirname2(fullPath), linkTarget);
         const rel2 = relative(realRoot, resolvedTarget);
         if (rel2.startsWith("..") || process.platform !== "win32" && rel2.startsWith("/")) {
           throw new Error(`extracted symlink ${fullPath} points outside staging root: ${linkTarget}`);
@@ -9134,8 +9410,8 @@ async function downloadOnnxRuntime(info, targetDir) {
   log(`Downloading ONNX Runtime v${ORT_VERSION} for ${process.platform}/${process.arch}...`);
   const tmpDir = `${targetDir}.tmp.${process.pid}.${Date.now().toString(36)}`;
   try {
-    mkdirSync2(tmpDir, { recursive: true });
-    const archivePath = join3(tmpDir, `onnxruntime.${info.archiveType}`);
+    mkdirSync4(tmpDir, { recursive: true });
+    const archivePath = join5(tmpDir, `onnxruntime.${info.archiveType}`);
     await downloadFileWithCap(url, archivePath);
     const archiveSha256 = sha256File(archivePath);
     log(`ONNX Runtime archive sha256=${archiveSha256}`);
@@ -9151,16 +9427,16 @@ async function downloadOnnxRuntime(info, targetDir) {
       unlinkSync2(archivePath);
     } catch {}
     validateExtractedTree(tmpDir);
-    const extractedDir = join3(tmpDir, info.assetName, "lib");
-    if (!existsSync2(extractedDir)) {
+    const extractedDir = join5(tmpDir, info.assetName, "lib");
+    if (!existsSync4(extractedDir)) {
       throw new Error(`Expected directory not found: ${extractedDir}`);
     }
-    mkdirSync2(targetDir, { recursive: true });
+    mkdirSync4(targetDir, { recursive: true });
     const libFiles = readdirSync(extractedDir).filter((f) => f.startsWith("libonnxruntime") || f.startsWith("onnxruntime"));
     const realFiles = [];
     const symlinks = [];
     for (const libFile of libFiles) {
-      const src = join3(extractedDir, libFile);
+      const src = join5(extractedDir, libFile);
       try {
         const stat = lstatSync(src);
         log(`ORT extract: ${libFile} \u2014 isSymlink=${stat.isSymbolicLink()}, isFile=${stat.isFile()}, size=${stat.size}`);
@@ -9175,7 +9451,7 @@ async function downloadOnnxRuntime(info, targetDir) {
       }
     }
     copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks);
-    const libPath = join3(targetDir, info.libName);
+    const libPath = join5(targetDir, info.libName);
     let libHash = null;
     try {
       libHash = sha256File(libPath);
@@ -9197,15 +9473,15 @@ async function downloadOnnxRuntime(info, targetDir) {
     return null;
   }
 }
-function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, copyFile = copyFileSync) {
+function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, copyFile = copyFileSync2) {
   const requiredLibs = new Set([info.libName]);
   for (const libFile of realFiles) {
-    const src = join3(extractedDir, libFile);
-    const dst = join3(targetDir, libFile);
+    const src = join5(extractedDir, libFile);
+    const dst = join5(targetDir, libFile);
     try {
       copyFile(src, dst);
       if (process.platform !== "win32") {
-        chmodSync2(dst, 493);
+        chmodSync3(dst, 493);
       }
     } catch (copyErr) {
       if (requiredLibs.has(libFile)) {
@@ -9216,7 +9492,7 @@ function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, c
     }
   }
   for (const link of symlinks) {
-    const dst = join3(targetDir, link.name);
+    const dst = join5(targetDir, link.name);
     try {
       unlinkSync2(dst);
     } catch {}
@@ -9230,8 +9506,8 @@ function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, c
       log(`ORT extract: failed to symlink optional ${link.name}: ${symlinkErr}`);
     }
   }
-  const requiredPath = join3(targetDir, info.libName);
-  if (!existsSync2(requiredPath)) {
+  const requiredPath = join5(targetDir, info.libName);
+  if (!existsSync4(requiredPath)) {
     rmSync2(targetDir, { recursive: true, force: true });
     throw new Error(`Required ONNX Runtime library missing after install: ${requiredPath}`);
   }
@@ -9257,13 +9533,13 @@ function writeOnnxInstalledMeta(installDir, version, sha256, archiveSha256) {
       ...sha256 ? { sha256 } : {},
       archiveSha256
     };
-    writeFileSync(join3(installDir, ONNX_INSTALLED_META_FILE), JSON.stringify(meta), "utf8");
+    writeFileSync(join5(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 = join3(installDir, ONNX_INSTALLED_META_FILE);
+  const path = join5(installDir, ONNX_INSTALLED_META_FILE);
   try {
     if (!statSync2(path).isFile())
       return null;
@@ -9523,196 +9799,28 @@ function normalizeKey(projectRoot) {
     return stripped;
   }
 }
-// ../aft-bridge/dist/resolver.js
-import { execSync, spawnSync } from "child_process";
-import { chmodSync as chmodSync3, copyFileSync as copyFileSync2, existsSync as existsSync3, mkdirSync as mkdirSync3, renameSync as renameSync2 } from "fs";
-import { createRequire } from "module";
-import { homedir as homedir3 } from "os";
-import { join as join4 } from "path";
-function readBinaryVersion(binaryPath) {
-  try {
-    const result = spawnSync(binaryPath, ["--version"], {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: 5000
-    });
-    const stdoutVersion = result.stdout?.trim();
-    const stderrVersion = result.stderr?.trim();
-    const rawVersion = stdoutVersion || stderrVersion;
-    if (!rawVersion)
-      return null;
-    return rawVersion.replace(/^aft\s+/, "");
-  } catch {
-    return null;
-  }
-}
-function copyToVersionedCache(npmBinaryPath, knownVersion) {
-  try {
-    const version = knownVersion ?? readBinaryVersion(npmBinaryPath);
-    if (!version)
-      return null;
-    const tag = version.startsWith("v") ? version : `v${version}`;
-    const cacheDir = getCacheDir();
-    const versionedDir = join4(cacheDir, tag);
-    const ext = process.platform === "win32" ? ".exe" : "";
-    const cachedPath = join4(versionedDir, `aft${ext}`);
-    if (existsSync3(cachedPath)) {
-      const cachedVersion = readBinaryVersion(cachedPath);
-      if (cachedVersion === version)
-        return cachedPath;
-      warn(`Cached binary at ${cachedPath} reports ${cachedVersion ?? "no version"}, expected ${version}; refreshing from npm package`);
-    }
-    mkdirSync3(versionedDir, { recursive: true });
-    const tmpPath = `${cachedPath}.${process.pid}.${Date.now()}.tmp`;
-    copyFileSync2(npmBinaryPath, tmpPath);
-    if (process.platform !== "win32") {
-      chmodSync3(tmpPath, 493);
-    }
-    renameSync2(tmpPath, cachedPath);
-    log(`Copied npm binary to versioned cache: ${cachedPath}`);
-    return cachedPath;
-  } catch (err) {
-    warn(`Failed to copy binary to cache: ${err instanceof Error ? err.message : String(err)}`);
-    return null;
-  }
-}
-function normalizeBareVersion(version) {
-  return version.startsWith("v") ? version.slice(1) : version;
-}
-function homeDirFromEnv(env) {
-  return (process.platform === "win32" ? env.USERPROFILE || env.HOME : env.HOME) || homedir3();
-}
-function cacheDirFromEnv(env) {
-  if (process.platform === "win32") {
-    const base2 = env.LOCALAPPDATA || env.APPDATA || join4(homeDirFromEnv(env), "AppData", "Local");
-    return join4(base2, "aft", "bin");
-  }
-  const base = env.XDG_CACHE_HOME || join4(homeDirFromEnv(env), ".cache");
-  return join4(base, "aft", "bin");
-}
-function cachedBinaryPathFromEnv(version, env, ext) {
-  const binaryPath = join4(cacheDirFromEnv(env), version, `aft${ext}`);
-  return existsSync3(binaryPath) ? binaryPath : null;
-}
-function isExpectedCachedBinary(binaryPath, expectedVersion) {
-  const expected = normalizeBareVersion(expectedVersion);
-  const actual = readBinaryVersion(binaryPath);
-  if (actual === expected)
-    return true;
-  warn(`Cached binary at ${binaryPath} reports ${actual ?? "no version"}, expected ${expected}; skipping cache candidate`);
-  return false;
-}
-function platformKey(platform = process.platform, arch = process.arch) {
-  const archMap = PLATFORM_ARCH_MAP[platform];
-  if (!archMap) {
-    throw new Error(`Unsupported platform: ${platform} (arch: ${arch}). ` + `Supported platforms: ${Object.keys(PLATFORM_ARCH_MAP).join(", ")}`);
-  }
-  const key = archMap[arch];
-  if (!key) {
-    throw new Error(`Unsupported architecture: ${arch} on platform ${platform}. ` + `Supported architectures for ${platform}: ${Object.keys(archMap).join(", ")}`);
-  }
-  return key;
-}
-function findBinarySync(expectedVersion) {
-  const ext = process.platform === "win32" ? ".exe" : "";
-  const env = { ...process.env };
-  const pluginVersion = expectedVersion ?? (() => {
-    try {
-      const req = createRequire(import.meta.url);
-      return req("../package.json").version;
-    } catch {
-      return null;
-    }
-  })();
-  if (pluginVersion) {
-    const tag = pluginVersion.startsWith("v") ? pluginVersion : `v${pluginVersion}`;
-    const versionCached = cachedBinaryPathFromEnv(tag, env, ext);
-    if (versionCached && isExpectedCachedBinary(versionCached, pluginVersion))
-      return versionCached;
-  }
-  try {
-    const key = platformKey();
-    const packageBin = `@cortexkit/aft-${key}/bin/aft${ext}`;
-    const req = createRequire(import.meta.url);
-    const resolved = req.resolve(packageBin);
-    if (existsSync3(resolved)) {
-      const npmVersion = readBinaryVersion(resolved);
-      if (npmVersion === null) {
-        warn(`npm platform package binary at ${resolved} did not report a version; skipping (continuing to PATH lookup)`);
-      } else if (pluginVersion && npmVersion !== normalizeBareVersion(pluginVersion)) {
-        warn(`npm platform package binary v${npmVersion} does not match plugin v${pluginVersion}; skipping (continuing to PATH lookup)`);
-      } else {
-        const copied = copyToVersionedCache(resolved, npmVersion);
-        return copied ?? resolved;
-      }
-    }
-  } catch {}
-  try {
-    const whichCmd = process.platform === "win32" ? "where aft" : "which aft";
-    const result = execSync(whichCmd, {
-      encoding: "utf-8",
-      env,
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    if (result)
-      return result;
-  } catch {}
-  const cargoPath = join4(homeDirFromEnv(env), ".cargo", "bin", `aft${ext}`);
-  if (existsSync3(cargoPath))
-    return cargoPath;
-  return null;
-}
-async function findBinary(expectedVersion) {
-  const syncResult = findBinarySync(expectedVersion);
-  if (syncResult) {
-    log(`Resolved binary: ${syncResult}`);
-    return syncResult;
-  }
-  log("Binary not found locally, attempting auto-download...");
-  const downloaded = await ensureBinary(expectedVersion);
-  if (downloaded)
-    return downloaded;
-  throw new Error([
-    "Could not find the `aft` binary.",
-    "",
-    "Attempted sources:",
-    "  - Cache directory (~/.cache/aft/bin/)",
-    "  - npm platform package (@cortexkit/aft-<platform>)",
-    "  - PATH lookup (which aft)",
-    "  - ~/.cargo/bin/aft",
-    "  - Auto-download from GitHub releases (failed)",
-    "",
-    "Install it using one of these methods:",
-    "  npm install @cortexkit/aft-opencode        # installs platform-specific binary via npm",
-    "  cargo install agent-file-tools             # from crates.io",
-    "  cargo build --release         # from source (binary at target/release/aft)",
-    "",
-    "Or add the aft directory to your PATH."
-  ].join(`
-`));
-}
 // ../aft-bridge/dist/url-fetch.js
 import { createHash as createHash3 } from "crypto";
 import { lookup } from "dns/promises";
-import { existsSync as existsSync4, mkdirSync as mkdirSync4, readdirSync as readdirSync2, readFileSync as readFileSync2, unlinkSync as unlinkSync3, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync5, readdirSync as readdirSync2, readFileSync as readFileSync2, unlinkSync as unlinkSync3, writeFileSync as writeFileSync2 } from "fs";
 import { isIP } from "net";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 import { Agent, fetch as undiciFetch } from "undici";
 var MAX_RESPONSE_BYTES = 10 * 1024 * 1024;
 var CACHE_TTL_MS = 24 * 60 * 60 * 1000;
 var FETCH_TIMEOUT_MS = 30000;
 var MAX_REDIRECTS = 5;
 function cacheDir(storageDir) {
-  return join5(storageDir, "url_cache");
+  return join6(storageDir, "url_cache");
 }
 function hashUrl(url) {
   return createHash3("sha256").update(url).digest("hex").slice(0, 16);
 }
 function metaPath(storageDir, hash) {
-  return join5(cacheDir(storageDir), `${hash}.meta.json`);
+  return join6(cacheDir(storageDir), `${hash}.meta.json`);
 }
 function contentPath(storageDir, hash, extension) {
-  return join5(cacheDir(storageDir), `${hash}${extension}`);
+  return join6(cacheDir(storageDir), `${hash}${extension}`);
 }
 function _isPrivateIpv4(address) {
   const parts = address.split(".").map((part) => Number.parseInt(part, 10));
@@ -9730,9 +9838,9 @@ function expandIpv6(addr) {
   let normalized = addr;
   const lastColon = normalized.lastIndexOf(":");
   if (lastColon !== -1) {
-    const tail = normalized.slice(lastColon + 1);
-    if (tail.includes(".")) {
-      const octets = tail.split(".").map((p) => Number.parseInt(p, 10));
+    const tail2 = normalized.slice(lastColon + 1);
+    if (tail2.includes(".")) {
+      const octets = tail2.split(".").map((p) => Number.parseInt(p, 10));
       if (octets.length !== 4 || octets.some((o) => Number.isNaN(o) || o < 0 || o > 255)) {
         return null;
       }
@@ -9910,15 +10018,15 @@ async function fetchUrlToTempFile(url, storageDir, options = {}) {
   const allowPrivate = options.allowPrivate === true;
   await assertPublicUrl(parsed, allowPrivate, options.lookup);
   const dir = cacheDir(storageDir);
-  mkdirSync4(dir, { recursive: true });
+  mkdirSync5(dir, { recursive: true });
   const hash = hashUrl(url);
   const metaFile = metaPath(storageDir, hash);
-  if (existsSync4(metaFile)) {
+  if (existsSync5(metaFile)) {
     try {
       const meta2 = JSON.parse(readFileSync2(metaFile, "utf8"));
       const age = Date.now() - meta2.fetchedAt;
       const cached = contentPath(storageDir, hash, meta2.extension);
-      if (age < CACHE_TTL_MS && existsSync4(cached)) {
+      if (age < CACHE_TTL_MS && existsSync5(cached)) {
         log(`URL cache hit: ${url} (${Math.round(age / 1000)}s old)`);
         return cached;
       }
@@ -9980,21 +10088,21 @@ async function fetchUrlToTempFile(url, storageDir, options = {}) {
 }
 function cleanupUrlCache(storageDir) {
   const dir = cacheDir(storageDir);
-  if (!existsSync4(dir))
+  if (!existsSync5(dir))
     return;
   let removed = 0;
   try {
     for (const entry of readdirSync2(dir)) {
       if (!entry.endsWith(".meta.json"))
         continue;
-      const metaFile = join5(dir, entry);
+      const metaFile = join6(dir, entry);
       try {
         const meta = JSON.parse(readFileSync2(metaFile, "utf8"));
         const age = Date.now() - meta.fetchedAt;
         if (age > CACHE_TTL_MS) {
           const hash = entry.slice(0, -".meta.json".length);
           const content = contentPath(storageDir, hash, meta.extension);
-          if (existsSync4(content))
+          if (existsSync5(content))
             unlinkSync3(content);
           unlinkSync3(metaFile);
           removed++;
@@ -10366,12 +10474,12 @@ function formatSystemReminder(completions) {
   const bullets = completions.map((completion) => formatCompletion(completion)).join(`
 `);
   const anyTruncated = completions.some((c) => c.output_truncated === true);
-  const tail = anyTruncated ? `
+  const tail2 = anyTruncated ? `
 
 For truncated tasks, use bash_status({ taskId: "..." }) to retrieve full output.` : "";
   return `<system-reminder>
 [BACKGROUND BASH COMPLETED]
-${bullets}${tail}
+${bullets}${tail2}
 </system-reminder>`;
 }
 function formatLongRunningReminder(reminders) {
@@ -10626,9 +10734,9 @@ function formatDuration(completion) {
 
 // src/config.ts
 var import_comment_json = __toESM(require_src2(), 1);
-import { existsSync as existsSync5, readFileSync as readFileSync3, renameSync as renameSync3, unlinkSync as unlinkSync4, writeFileSync as writeFileSync3 } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join7 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync3, renameSync as renameSync3, unlinkSync as unlinkSync4, writeFileSync as writeFileSync3 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join8 } from "path";
 
 // ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/external.js
 var exports_external = {};
@@ -24381,7 +24489,7 @@ function migrateRawConfig(rawConfig, configPath, logger) {
   return oldKeys;
 }
 function migrateAftConfigFile(configPath, logger = { log: log2, warn: warn2 }) {
-  if (!existsSync5(configPath)) {
+  if (!existsSync6(configPath)) {
     return { migrated: false, oldKeys: [] };
   }
   let tmpPath = null;
@@ -24425,10 +24533,10 @@ ${serialized}` : serialized;
 function detectConfigFile(basePath) {
   const jsoncPath = `${basePath}.jsonc`;
   const jsonPath = `${basePath}.json`;
-  if (existsSync5(jsoncPath)) {
+  if (existsSync6(jsoncPath)) {
     return { format: "jsonc", path: jsoncPath };
   }
-  if (existsSync5(jsonPath)) {
+  if (existsSync6(jsonPath)) {
     return { format: "json", path: jsonPath };
   }
   return { format: "none", path: jsonPath };
@@ -24461,7 +24569,7 @@ function parseConfigPartially(rawConfig) {
 }
 function loadConfigFromPath(configPath) {
   try {
-    if (!existsSync5(configPath)) {
+    if (!existsSync6(configPath)) {
       return null;
     }
     const content = readFileSync3(configPath, "utf-8");
@@ -24605,17 +24713,17 @@ function getOpenCodeConfigDir() {
   if (envDir) {
     return envDir;
   }
-  const xdgConfig = process.env.XDG_CONFIG_HOME || join7(homedir4(), ".config");
-  return join7(xdgConfig, "opencode");
+  const xdgConfig = process.env.XDG_CONFIG_HOME || join8(homedir5(), ".config");
+  return join8(xdgConfig, "opencode");
 }
 function loadAftConfig(projectDirectory) {
   const configDir = getOpenCodeConfigDir();
-  const userBasePath = join7(configDir, "aft");
+  const userBasePath = join8(configDir, "aft");
   migrateAftConfigFile(`${userBasePath}.jsonc`);
   migrateAftConfigFile(`${userBasePath}.json`);
   const userDetected = detectConfigFile(userBasePath);
   const userConfigPath = userDetected.format !== "none" ? userDetected.path : `${userBasePath}.json`;
-  const projectBasePath = join7(projectDirectory, ".opencode", "aft");
+  const projectBasePath = join8(projectDirectory, ".opencode", "aft");
   migrateAftConfigFile(`${projectBasePath}.jsonc`);
   migrateAftConfigFile(`${projectBasePath}.json`);
   const projectDetected = detectConfigFile(projectBasePath);
@@ -24640,44 +24748,44 @@ function loadAftConfig(projectDirectory) {
 }
 
 // src/hooks/auto-update-checker/index.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync6, renameSync as renameSync4, writeFileSync as writeFileSync6 } from "fs";
-import { dirname as dirname4, join as join11 } from "path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync6, renameSync as renameSync4, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname5, join as join12 } from "path";
 
 // src/hooks/auto-update-checker/cache.ts
 var import_comment_json3 = __toESM(require_src2(), 1);
 import { spawn as spawn2 } from "child_process";
-import { cpSync, existsSync as existsSync7, mkdtempSync, readFileSync as readFileSync5, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "fs";
-import { tmpdir as tmpdir2 } from "os";
-import { basename, dirname as dirname3, join as join10 } from "path";
+import { cpSync, existsSync as existsSync8, mkdtempSync, readFileSync as readFileSync5, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "fs";
+import { tmpdir as tmpdir3 } from "os";
+import { basename, dirname as dirname4, join as join11 } from "path";
 
 // src/hooks/auto-update-checker/checker.ts
 var import_comment_json2 = __toESM(require_src2(), 1);
-import { existsSync as existsSync6, readFileSync as readFileSync4, statSync as statSync3, writeFileSync as writeFileSync4 } from "fs";
-import { homedir as homedir6 } from "os";
-import { dirname as dirname2, isAbsolute, join as join9, resolve as resolve2 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync4, statSync as statSync3, writeFileSync as writeFileSync4 } from "fs";
+import { homedir as homedir7 } from "os";
+import { dirname as dirname3, isAbsolute, join as join10, resolve as resolve2 } from "path";
 import { fileURLToPath } from "url";
 
 // src/hooks/auto-update-checker/constants.ts
-import { homedir as homedir5, platform } from "os";
-import { join as join8 } from "path";
+import { homedir as homedir6, platform } from "os";
+import { join as join9 } from "path";
 var PACKAGE_NAME = "@cortexkit/aft-opencode";
 var NPM_REGISTRY_URL = "https://registry.npmjs.org";
 var NPM_FETCH_TIMEOUT = 1e4;
 function getOpenCodeCacheRoot() {
   if (platform() === "win32") {
-    return join8(process.env.LOCALAPPDATA ?? homedir5(), "opencode");
+    return join9(process.env.LOCALAPPDATA ?? homedir6(), "opencode");
   }
-  return join8(homedir5(), ".cache", "opencode");
+  return join9(homedir6(), ".cache", "opencode");
 }
 function getOpenCodeConfigRoot() {
   if (platform() === "win32") {
-    return join8(process.env.APPDATA ?? join8(homedir5(), "AppData", "Roaming"), "opencode");
+    return join9(process.env.APPDATA ?? join9(homedir6(), "AppData", "Roaming"), "opencode");
   }
-  return join8(process.env.XDG_CONFIG_HOME ?? join8(homedir5(), ".config"), "opencode");
+  return join9(process.env.XDG_CONFIG_HOME ?? join9(homedir6(), ".config"), "opencode");
 }
-var CACHE_DIR = join8(getOpenCodeCacheRoot(), "packages");
-var USER_OPENCODE_CONFIG = join8(getOpenCodeConfigRoot(), "opencode.json");
-var USER_OPENCODE_CONFIG_JSONC = join8(getOpenCodeConfigRoot(), "opencode.jsonc");
+var CACHE_DIR = join9(getOpenCodeCacheRoot(), "packages");
+var USER_OPENCODE_CONFIG = join9(getOpenCodeConfigRoot(), "opencode.json");
+var USER_OPENCODE_CONFIG_JSONC = join9(getOpenCodeConfigRoot(), "opencode.jsonc");
 
 // src/hooks/auto-update-checker/types.ts
 var NpmPackageEnvelopeSchema = exports_external.object({
@@ -24735,8 +24843,8 @@ function extractChannel(version2) {
 }
 function getConfigPaths(directory) {
   return [
-    join9(directory, ".opencode", "opencode.json"),
-    join9(directory, ".opencode", "opencode.jsonc"),
+    join10(directory, ".opencode", "opencode.json"),
+    join10(directory, ".opencode", "opencode.jsonc"),
     USER_OPENCODE_CONFIG,
     USER_OPENCODE_CONFIG_JSONC
   ];
@@ -24751,12 +24859,12 @@ function resolvePathPluginSpec(spec, configPath) {
   }
   if (isAbsolute(spec) || /^[A-Za-z]:[\\/]/.test(spec))
     return spec;
-  return resolve2(dirname2(configPath), spec);
+  return resolve2(dirname3(configPath), spec);
 }
 function getLocalDevPath(directory) {
   for (const configPath of getConfigPaths(directory)) {
     try {
-      if (!existsSync6(configPath))
+      if (!existsSync7(configPath))
         continue;
       const rawConfig = parseJsonConfig(readFileSync4(configPath, "utf-8"));
       const plugins = getPluginEntries(rawConfig);
@@ -24780,17 +24888,17 @@ function getLocalDevPath(directory) {
 function findPackageJsonUp(startPath) {
   try {
     const stat = statSync3(startPath);
-    let dir = stat.isDirectory() ? startPath : dirname2(startPath);
+    let dir = stat.isDirectory() ? startPath : dirname3(startPath);
     for (let i = 0;i < 10; i++) {
-      const pkgPath = join9(dir, "package.json");
-      if (existsSync6(pkgPath)) {
+      const pkgPath = join10(dir, "package.json");
+      if (existsSync7(pkgPath)) {
         try {
           const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync4(pkgPath, "utf-8")));
           if (pkg.success && pkg.data.name === PACKAGE_NAME)
             return pkgPath;
         } catch {}
       }
-      const parent = dirname2(dir);
+      const parent = dirname3(dir);
       if (parent === dir)
         break;
       dir = parent;
@@ -24814,7 +24922,7 @@ function getLocalDevVersion(directory) {
 }
 function getCurrentRuntimePackageJsonPath(currentModuleUrl = import.meta.url) {
   try {
-    return findPackageJsonUp(dirname2(fileURLToPath(currentModuleUrl)));
+    return findPackageJsonUp(dirname3(fileURLToPath(currentModuleUrl)));
   } catch (err) {
     warn2(`[auto-update-checker] Failed to resolve runtime package path: ${String(err)}`);
     return null;
@@ -24823,7 +24931,7 @@ function getCurrentRuntimePackageJsonPath(currentModuleUrl = import.meta.url) {
 function findPluginEntry(directory) {
   for (const configPath of getConfigPaths(directory)) {
     try {
-      if (!existsSync6(configPath))
+      if (!existsSync7(configPath))
         continue;
       const rawConfig = parseJsonConfig(readFileSync4(configPath, "utf-8"));
       const plugins = getPluginEntries(rawConfig);
@@ -24843,7 +24951,7 @@ function findPluginEntry(directory) {
 }
 var cachedPackageVersion = null;
 function getSpecCachePackageJsonPath(spec) {
-  return join9(CACHE_DIR, spec, "node_modules", PACKAGE_NAME, "package.json");
+  return join10(CACHE_DIR, spec, "node_modules", PACKAGE_NAME, "package.json");
 }
 function getCachedVersion(spec) {
   if (!spec && cachedPackageVersion)
@@ -24852,11 +24960,11 @@ function getCachedVersion(spec) {
     getCurrentRuntimePackageJsonPath(),
     spec ? getSpecCachePackageJsonPath(spec) : null,
     getSpecCachePackageJsonPath(`${PACKAGE_NAME}@latest`),
-    join9(homedir6(), ".cache", "opencode", "node_modules", PACKAGE_NAME, "package.json")
+    join10(homedir7(), ".cache", "opencode", "node_modules", PACKAGE_NAME, "package.json")
   ].filter(isString);
   for (const packageJsonPath of candidates) {
     try {
-      if (!existsSync6(packageJsonPath))
+      if (!existsSync7(packageJsonPath))
         continue;
       const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync4(packageJsonPath, "utf-8")));
       if (pkg.success && pkg.data.version) {
@@ -24900,17 +25008,17 @@ async function getLatestVersion(channel = "latest", options = {}) {
 // src/hooks/auto-update-checker/cache.ts
 var pendingSnapshots = new Map;
 function createAutoUpdateSnapshot(installDir, packageJsonPath, packageName) {
-  const packageDir = join10(installDir, "node_modules", packageName);
-  const lockfilePath = join10(installDir, "package-lock.json");
-  const tempDir = mkdtempSync(join10(tmpdir2(), "aft-auto-update-"));
-  const stagedPackageDir = existsSync7(packageDir) ? join10(tempDir, "package") : null;
+  const packageDir = join11(installDir, "node_modules", packageName);
+  const lockfilePath = join11(installDir, "package-lock.json");
+  const tempDir = mkdtempSync(join11(tmpdir3(), "aft-auto-update-"));
+  const stagedPackageDir = existsSync8(packageDir) ? join11(tempDir, "package") : null;
   if (stagedPackageDir)
     cpSync(packageDir, stagedPackageDir, { recursive: true });
   return {
     packageJsonPath,
-    packageJson: existsSync7(packageJsonPath) ? readFileSync5(packageJsonPath, "utf-8") : null,
+    packageJson: existsSync8(packageJsonPath) ? readFileSync5(packageJsonPath, "utf-8") : null,
     lockfilePath,
-    lockfile: existsSync7(lockfilePath) ? readFileSync5(lockfilePath, "utf-8") : null,
+    lockfile: existsSync8(lockfilePath) ? readFileSync5(lockfilePath, "utf-8") : null,
     packageDir,
     stagedPackageDir,
     tempDir
@@ -24939,13 +25047,13 @@ function stripPackageNameFromPath(pathValue, packageName) {
   for (const segment of [...packageName.split("/")].reverse()) {
     if (basename(current) !== segment)
       return null;
-    current = dirname3(current);
+    current = dirname4(current);
   }
   return current;
 }
 function removeFromPackageLock(installDir, packageName) {
-  const lockPath = join10(installDir, "package-lock.json");
-  if (!existsSync7(lockPath))
+  const lockPath = join11(installDir, "package-lock.json");
+  if (!existsSync8(lockPath))
     return false;
   try {
     const lock = import_comment_json3.parse(readFileSync5(lockPath, "utf-8"));
@@ -24971,7 +25079,7 @@ function removeFromPackageLock(installDir, packageName) {
   }
 }
 function ensureDependencyVersion(packageJsonPath, packageName, version2) {
-  if (!existsSync7(packageJsonPath))
+  if (!existsSync8(packageJsonPath))
     return false;
   try {
     const raw = import_comment_json3.parse(readFileSync5(packageJsonPath, "utf-8"));
@@ -24993,8 +25101,8 @@ function ensureDependencyVersion(packageJsonPath, packageName, version2) {
   }
 }
 function removeInstalledPackage(installDir, packageName) {
-  const packageDir = join10(installDir, "node_modules", packageName);
-  if (!existsSync7(packageDir))
+  const packageDir = join11(installDir, "node_modules", packageName);
+  if (!existsSync8(packageDir))
     return false;
   rmSync3(packageDir, { recursive: true, force: true });
   log2(`[auto-update-checker] Package removed: ${packageDir}`);
@@ -25002,19 +25110,19 @@ function removeInstalledPackage(installDir, packageName) {
 }
 function resolveInstallContext(runtimePackageJsonPath = getCurrentRuntimePackageJsonPath()) {
   if (runtimePackageJsonPath) {
-    const packageDir = dirname3(runtimePackageJsonPath);
+    const packageDir = dirname4(runtimePackageJsonPath);
     const nodeModulesDir = stripPackageNameFromPath(packageDir, PACKAGE_NAME);
     if (nodeModulesDir && basename(nodeModulesDir) === "node_modules") {
-      const installDir = dirname3(nodeModulesDir);
-      const packageJsonPath = join10(installDir, "package.json");
-      if (existsSync7(packageJsonPath))
+      const installDir = dirname4(nodeModulesDir);
+      const packageJsonPath = join11(installDir, "package.json");
+      if (existsSync8(packageJsonPath))
         return { installDir, packageJsonPath };
     }
     return null;
   }
-  const legacyPackageJsonPath = join10(dirname3(CACHE_DIR), "package.json");
-  if (existsSync7(legacyPackageJsonPath)) {
-    return { installDir: dirname3(CACHE_DIR), packageJsonPath: legacyPackageJsonPath };
+  const legacyPackageJsonPath = join11(dirname4(CACHE_DIR), "package.json");
+  if (existsSync8(legacyPackageJsonPath)) {
+    return { installDir: dirname4(CACHE_DIR), packageJsonPath: legacyPackageJsonPath };
   }
   return null;
 }
@@ -25152,8 +25260,8 @@ function claimCheckSlot(storageDir, intervalMs) {
   if (!storageDir)
     return true;
   try {
-    const file2 = join11(storageDir, TIMESTAMP_FILENAME);
-    if (existsSync8(file2)) {
+    const file2 = join12(storageDir, TIMESTAMP_FILENAME);
+    if (existsSync9(file2)) {
       try {
         const raw = JSON.parse(readFileSync6(file2, "utf-8"));
         const last = typeof raw.lastCheckedMs === "number" ? raw.lastCheckedMs : 0;
@@ -25162,7 +25270,7 @@ function claimCheckSlot(storageDir, intervalMs) {
         }
       } catch {}
     }
-    mkdirSync5(dirname4(file2), { recursive: true });
+    mkdirSync6(dirname5(file2), { recursive: true });
     const tmp = `${file2}.tmp.${process.pid}`;
     writeFileSync6(tmp, JSON.stringify({ lastCheckedMs: Date.now() }), "utf-8");
     renameSync4(tmp, file2);
@@ -25253,49 +25361,49 @@ function showToast(ctx, title, message, variant = "info", duration3 = 3000) {
 // src/lsp-auto-install.ts
 import { spawn as spawn3 } from "child_process";
 import { createHash as createHash4 } from "crypto";
-import { createReadStream, mkdirSync as mkdirSync7, readFileSync as readFileSync8, renameSync as renameSync5, rmSync as rmSync4, statSync as statSync5 } from "fs";
-import { join as join14 } from "path";
+import { createReadStream, mkdirSync as mkdirSync8, readFileSync as readFileSync8, renameSync as renameSync5, rmSync as rmSync4, statSync as statSync5 } from "fs";
+import { join as join15 } from "path";
 
 // src/lsp-cache.ts
 import {
   closeSync as closeSync3,
-  mkdirSync as mkdirSync6,
+  mkdirSync as mkdirSync7,
   openSync as openSync3,
   readFileSync as readFileSync7,
   statSync as statSync4,
   unlinkSync as unlinkSync5,
   writeFileSync as writeFileSync7
 } from "fs";
-import { homedir as homedir7 } from "os";
-import { join as join12 } from "path";
+import { homedir as homedir8 } from "os";
+import { join as join13 } from "path";
 function aftCacheBase() {
   const override = process.env.AFT_CACHE_DIR;
   if (override && override.length > 0)
     return override;
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join12(homedir7(), "AppData", "Local");
-    return join12(base2, "aft");
+    const base2 = localAppData || join13(homedir8(), "AppData", "Local");
+    return join13(base2, "aft");
   }
-  const base = process.env.XDG_CACHE_HOME || join12(homedir7(), ".cache");
-  return join12(base, "aft");
+  const base = process.env.XDG_CACHE_HOME || join13(homedir8(), ".cache");
+  return join13(base, "aft");
 }
 function lspCacheRoot() {
-  return join12(aftCacheBase(), "lsp-packages");
+  return join13(aftCacheBase(), "lsp-packages");
 }
 function lspPackageDir(npmPackage) {
-  return join12(lspCacheRoot(), encodeURIComponent(npmPackage));
+  return join13(lspCacheRoot(), encodeURIComponent(npmPackage));
 }
 function lspBinaryPath(npmPackage, binary) {
-  return join12(lspPackageDir(npmPackage), "node_modules", ".bin", binary);
+  return join13(lspPackageDir(npmPackage), "node_modules", ".bin", binary);
 }
 function lspBinDir(npmPackage) {
-  return join12(lspPackageDir(npmPackage), "node_modules", ".bin");
+  return join13(lspPackageDir(npmPackage), "node_modules", ".bin");
 }
 function isInstalled(npmPackage, binary) {
   for (const candidate of lspBinaryCandidates(binary)) {
     try {
-      if (statSync4(join12(lspBinDir(npmPackage), candidate)).isFile())
+      if (statSync4(join13(lspBinDir(npmPackage), candidate)).isFile())
         return true;
     } catch {}
   }
@@ -25309,19 +25417,19 @@ function lspBinaryCandidates(binary) {
 var INSTALLED_META_FILE = ".aft-installed";
 function writeInstalledMetaIn(installDir, version2, sha256) {
   try {
-    mkdirSync6(installDir, { recursive: true });
+    mkdirSync7(installDir, { recursive: true });
     const meta3 = {
       version: version2,
       installedAt: new Date().toISOString(),
       ...sha256 ? { sha256 } : {}
     };
-    writeFileSync7(join12(installDir, INSTALLED_META_FILE), JSON.stringify(meta3), "utf8");
+    writeFileSync7(join13(installDir, INSTALLED_META_FILE), JSON.stringify(meta3), "utf8");
   } catch (err) {
     log2(`[lsp-cache] failed to write installed-meta in ${installDir}: ${err}`);
   }
 }
 function readInstalledMetaIn(installDir) {
-  const path2 = join12(installDir, INSTALLED_META_FILE);
+  const path2 = join13(installDir, INSTALLED_META_FILE);
   try {
     if (!statSync4(path2).isFile())
       return null;
@@ -25345,11 +25453,11 @@ function readInstalledMeta(packageKey) {
   return readInstalledMetaIn(lspPackageDir(packageKey));
 }
 function lockPath(npmPackage) {
-  return join12(lspPackageDir(npmPackage), ".aft-installing");
+  return join13(lspPackageDir(npmPackage), ".aft-installing");
 }
 var STALE_LOCK_MS2 = 30 * 60 * 1000;
 function acquireInstallLock(lockKey) {
-  mkdirSync6(lspPackageDir(lockKey), { recursive: true });
+  mkdirSync7(lspPackageDir(lockKey), { recursive: true });
   const lock = lockPath(lockKey);
   const tryClaim = () => {
     try {
@@ -25452,7 +25560,7 @@ async function withInstallLock(lockKey, task) {
 }
 var VERSION_CHECK_FILE = ".aft-version-check";
 function readVersionCheck(npmPackage) {
-  const file2 = join12(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
+  const file2 = join13(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
   try {
     const raw = readFileSync7(file2, "utf8");
     const parsed = JSON.parse(raw);
@@ -25468,8 +25576,8 @@ function readVersionCheck(npmPackage) {
   }
 }
 function writeVersionCheck(npmPackage, latest) {
-  mkdirSync6(lspPackageDir(npmPackage), { recursive: true });
-  const file2 = join12(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
+  mkdirSync7(lspPackageDir(npmPackage), { recursive: true });
+  const file2 = join13(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
   const record2 = {
     last_checked: new Date().toISOString(),
     latest_eligible: latest
@@ -25617,8 +25725,8 @@ var NPM_LSP_TABLE = [
 ];
 
 // src/lsp-project-relevance.ts
-import { existsSync as existsSync9, readdirSync as readdirSync3 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync10, readdirSync as readdirSync3 } from "fs";
+import { join as join14 } from "path";
 var MAX_WALK_DIRS = 200;
 var MAX_WALK_DEPTH = 4;
 var NOISE_DIRS = new Set([
@@ -25635,7 +25743,7 @@ function hasRootMarker(projectRoot, rootMarkers) {
   if (!rootMarkers)
     return false;
   for (const marker of rootMarkers) {
-    if (existsSync9(join13(projectRoot, marker)))
+    if (existsSync10(join14(projectRoot, marker)))
       return true;
   }
   return false;
@@ -25661,7 +25769,7 @@ function relevantExtensionsInProject(projectRoot, extToServer) {
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (current.depth < MAX_WALK_DEPTH && !NOISE_DIRS.has(entry.name.toLowerCase())) {
-          queue.push({ dir: join13(current.dir, entry.name), depth: current.depth + 1 });
+          queue.push({ dir: join14(current.dir, entry.name), depth: current.depth + 1 });
         }
         continue;
       }
@@ -25958,10 +26066,10 @@ function sha256OfFileSync(path2) {
 }
 function quarantineCachedNpmInstall(spec, reason) {
   const packageDir = lspPackageDir(spec.npm);
-  const dest = join14(packageDir, "..", ".quarantine", encodeURIComponent(spec.npm), `${Date.now()}`);
+  const dest = join15(packageDir, "..", ".quarantine", encodeURIComponent(spec.npm), `${Date.now()}`);
   warn2(`[lsp] tofu_mismatch ${spec.npm}: ${reason}; quarantining ${packageDir} -> ${dest}`);
   try {
-    mkdirSync7(join14(dest, ".."), { recursive: true });
+    mkdirSync8(join15(dest, ".."), { recursive: true });
     rmSync4(dest, { recursive: true, force: true });
     renameSync5(packageDir, dest);
   } catch (err) {
@@ -26044,9 +26152,9 @@ import {
   copyFileSync as copyFileSync3,
   createReadStream as createReadStream2,
   createWriteStream as createWriteStream3,
-  existsSync as existsSync10,
+  existsSync as existsSync11,
   lstatSync as lstatSync2,
-  mkdirSync as mkdirSync8,
+  mkdirSync as mkdirSync9,
   readdirSync as readdirSync4,
   readFileSync as readFileSync9,
   readlinkSync as readlinkSync2,
@@ -26057,7 +26165,7 @@ import {
   unlinkSync as unlinkSync6,
   writeFileSync as writeFileSync8
 } from "fs";
-import { dirname as dirname5, join as join15, relative as relative2, resolve as resolve3 } from "path";
+import { dirname as dirname6, join as join16, relative as relative2, resolve as resolve3 } from "path";
 import { Readable as Readable3 } from "stream";
 import { pipeline as pipeline3 } from "stream/promises";
 
@@ -26147,26 +26255,26 @@ function detectHostPlatform() {
 
 // src/lsp-github-install.ts
 function ghCacheRoot() {
-  return join15(aftCacheBase(), "lsp-binaries");
+  return join16(aftCacheBase(), "lsp-binaries");
 }
 function ghPackageDir(spec) {
-  return join15(ghCacheRoot(), spec.id);
+  return join16(ghCacheRoot(), spec.id);
 }
 function ghBinDir(spec) {
-  return join15(ghPackageDir(spec), "bin");
+  return join16(ghPackageDir(spec), "bin");
 }
 function ghExtractDir(spec) {
-  return join15(ghPackageDir(spec), "extracted");
+  return join16(ghPackageDir(spec), "extracted");
 }
 var INSTALLED_META_FILE2 = ".aft-installed";
 function ghBinaryPath(spec, platform2) {
   const ext = platform2 === "win32" ? ".exe" : "";
-  return join15(ghBinDir(spec), `${spec.binary}${ext}`);
+  return join16(ghBinDir(spec), `${spec.binary}${ext}`);
 }
 function isGithubInstalled(spec, platform2) {
   for (const candidate of ghBinaryCandidates(spec, platform2)) {
     try {
-      if (statSync6(join15(ghBinDir(spec), candidate)).isFile())
+      if (statSync6(join16(ghBinDir(spec), candidate)).isFile())
         return true;
     } catch {}
   }
@@ -26179,7 +26287,7 @@ function ghBinaryCandidates(spec, platform2) {
 }
 function readGithubInstalledMetaIn(installDir) {
   try {
-    const path2 = join15(installDir, INSTALLED_META_FILE2);
+    const path2 = join16(installDir, INSTALLED_META_FILE2);
     if (!statSync6(path2).isFile())
       return null;
     const parsed = JSON.parse(readFileSync9(path2, "utf8"));
@@ -26198,7 +26306,7 @@ function readGithubInstalledMetaIn(installDir) {
 }
 function writeGithubInstalledMetaIn(installDir, version2, binarySha256, archiveSha256) {
   try {
-    mkdirSync8(installDir, { recursive: true });
+    mkdirSync9(installDir, { recursive: true });
     const meta3 = {
       version: version2,
       installedAt: new Date().toISOString(),
@@ -26206,7 +26314,7 @@ function writeGithubInstalledMetaIn(installDir, version2, binarySha256, archiveS
       binarySha256,
       ...archiveSha256 ? { archiveSha256 } : {}
     };
-    writeFileSync8(join15(installDir, INSTALLED_META_FILE2), JSON.stringify(meta3), "utf8");
+    writeFileSync8(join16(installDir, INSTALLED_META_FILE2), JSON.stringify(meta3), "utf8");
   } catch (err) {
     warn2(`[lsp] failed to write github installed metadata in ${installDir}: ${err}`);
   }
@@ -26399,7 +26507,7 @@ async function downloadFile(url2, destPath, fetchImpl, assetSize, signal) {
     if (Number.isFinite(advertised) && advertised > MAX_DOWNLOAD_BYTES3) {
       throw new Error(`Content-Length ${advertised} exceeds max ${MAX_DOWNLOAD_BYTES3}`);
     }
-    mkdirSync8(dirname5(destPath), { recursive: true });
+    mkdirSync9(dirname6(destPath), { recursive: true });
     let bytesWritten = 0;
     const guard = new TransformStream({
       transform(chunk, controller) {
@@ -26455,7 +26563,7 @@ function validateExtraction(stagingRoot) {
       throw new Error(`failed to read staging dir ${dir}: ${err}`);
     }
     for (const entry of entries) {
-      const full = join15(dir, entry);
+      const full = join16(dir, entry);
       let lst;
       try {
         lst = lstatSync2(full);
@@ -26525,7 +26633,7 @@ function extractArchiveSafely(archivePath, destDir, archiveType) {
   try {
     rmSync5(stagingDir, { recursive: true, force: true });
   } catch {}
-  mkdirSync8(stagingDir, { recursive: true });
+  mkdirSync9(stagingDir, { recursive: true });
   try {
     precheckArchiveContents(archivePath, archiveType);
     runPlatformExtractor(archivePath, stagingDir, archiveType);
@@ -26543,10 +26651,10 @@ function extractArchiveSafely(archivePath, destDir, archiveType) {
 }
 function quarantineCachedGithubInstall(spec, reason) {
   const packageDir = ghPackageDir(spec);
-  const dest = join15(ghCacheRoot(), ".quarantine", encodeURIComponent(spec.id), `${Date.now()}`);
+  const dest = join16(ghCacheRoot(), ".quarantine", encodeURIComponent(spec.id), `${Date.now()}`);
   warn2(`[lsp] tofu_mismatch ${spec.id}: ${reason}; quarantining ${packageDir} -> ${dest}`);
   try {
-    mkdirSync8(dirname5(dest), { recursive: true });
+    mkdirSync9(dirname6(dest), { recursive: true });
     rmSync5(dest, { recursive: true, force: true });
     renameSync6(packageDir, dest);
   } catch (err) {
@@ -26556,7 +26664,7 @@ function quarantineCachedGithubInstall(spec, reason) {
 function validateCachedGithubInstall(spec, platform2) {
   const packageDir = ghPackageDir(spec);
   const meta3 = readGithubInstalledMetaIn(packageDir);
-  const binaryPath = ghBinaryCandidates(spec, platform2).map((candidate) => join15(ghBinDir(spec), candidate)).find((candidate) => {
+  const binaryPath = ghBinaryCandidates(spec, platform2).map((candidate) => join16(ghBinDir(spec), candidate)).find((candidate) => {
     try {
       return statSync6(candidate).isFile();
     } catch {
@@ -26634,7 +26742,7 @@ async function downloadAndInstall(spec, tag, assets, platform2, arch, fetchImpl,
   }
   const pkgDir = ghPackageDir(spec);
   const extractDir = ghExtractDir(spec);
-  const archivePath = join15(pkgDir, expected.name);
+  const archivePath = join16(pkgDir, expected.name);
   log2(`[lsp] downloading ${spec.id} ${tag} \u2192 ${matchingAsset.url}`);
   try {
     await downloadFile(matchingAsset.url, archivePath, fetchImpl, matchingAsset.size, signal);
@@ -26674,13 +26782,13 @@ async function downloadAndInstall(spec, tag, assets, platform2, arch, fetchImpl,
       unlinkSync6(archivePath);
     } catch {}
   }
-  const innerBinaryPath = join15(extractDir, spec.binaryPathInArchive(platform2, arch, version2));
-  if (!existsSync10(innerBinaryPath)) {
+  const innerBinaryPath = join16(extractDir, spec.binaryPathInArchive(platform2, arch, version2));
+  if (!existsSync11(innerBinaryPath)) {
     error2(`[lsp] ${spec.id}: extracted binary not found at ${innerBinaryPath}`);
     return null;
   }
   const targetBinary = ghBinaryPath(spec, platform2);
-  mkdirSync8(dirname5(targetBinary), { recursive: true });
+  mkdirSync9(dirname6(targetBinary), { recursive: true });
   try {
     copyFileSync3(innerBinaryPath, targetBinary);
     if (platform2 !== "win32") {
@@ -26759,7 +26867,7 @@ function runGithubAutoInstall(relevantServers, config2, fetchImpl = fetch) {
   if (!host) {
     for (const spec of GITHUB_LSP_TABLE) {
       try {
-        if (existsSync10(ghBinDir(spec))) {
+        if (existsSync11(ghBinDir(spec))) {
           cachedBinDirs.push(ghBinDir(spec));
         }
       } catch {}
@@ -26922,9 +27030,9 @@ function normalizeToolMap(tools) {
 }
 
 // src/notifications.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync9, readFileSync as readFileSync10, renameSync as renameSync7, rmSync as rmSync6, writeFileSync as writeFileSync9 } from "fs";
-import { homedir as homedir8, platform as platform2 } from "os";
-import { join as join16 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync10, readFileSync as readFileSync10, writeFileSync as writeFileSync9 } from "fs";
+import { homedir as homedir9, platform as platform2 } from "os";
+import { join as join17 } from "path";
 function isTuiMode() {
   return process.env.OPENCODE_CLIENT === "cli";
 }
@@ -26943,26 +27051,25 @@ var AFT_MARKER = "\uD83D\uDD27 AFT:";
 var FEATURE_MARKER = `${AFT_MARKER} New in`;
 var WARNING_MARKER = `${AFT_MARKER} \u26A0\uFE0F`;
 var STATUS_MARKER = `${AFT_MARKER} \u2705`;
-var WARNED_TOOLS_FILE = "warned_tools.json";
 function getDesktopStatePath() {
   const os2 = platform2();
-  const home = homedir8();
+  const home = homedir9();
   if (os2 === "darwin") {
-    return join16(home, "Library", "Application Support", "ai.opencode.desktop", "opencode.global.dat");
+    return join17(home, "Library", "Application Support", "ai.opencode.desktop", "opencode.global.dat");
   }
   if (os2 === "linux") {
-    const xdgConfig = process.env.XDG_CONFIG_HOME || join16(home, ".config");
-    return join16(xdgConfig, "ai.opencode.desktop", "opencode.global.dat");
+    const xdgConfig = process.env.XDG_CONFIG_HOME || join17(home, ".config");
+    return join17(xdgConfig, "ai.opencode.desktop", "opencode.global.dat");
   }
   if (os2 === "win32") {
-    const appData = process.env.APPDATA || join16(home, "AppData", "Roaming");
-    return join16(appData, "ai.opencode.desktop", "opencode.global.dat");
+    const appData = process.env.APPDATA || join17(home, "AppData", "Roaming");
+    return join17(appData, "ai.opencode.desktop", "opencode.global.dat");
   }
   return null;
 }
 function readDesktopState(directory) {
   const statePath = getDesktopStatePath();
-  if (!statePath || !existsSync11(statePath)) {
+  if (!statePath || !existsSync12(statePath)) {
     return { sessionId: null, serverUrl: null };
   }
   try {
@@ -27064,9 +27171,9 @@ async function sendWarning(opts, message) {
 }
 async function sendFeatureAnnouncement(opts, version2, features, storageDir) {
   if (storageDir) {
-    const versionFile = join16(storageDir, "last_announced_version");
+    const versionFile = join17(storageDir, "last_announced_version");
     try {
-      if (existsSync11(versionFile)) {
+      if (existsSync12(versionFile)) {
         const lastVersion = readFileSync10(versionFile, "utf-8").trim();
         if (lastVersion === version2)
           return;
@@ -27087,60 +27194,41 @@ async function sendFeatureAnnouncement(opts, version2, features, storageDir) {
   }
   if (storageDir) {
     try {
-      mkdirSync9(storageDir, { recursive: true });
-      writeFileSync9(join16(storageDir, "last_announced_version"), version2);
+      mkdirSync10(storageDir, { recursive: true });
+      writeFileSync9(join17(storageDir, "last_announced_version"), version2);
     } catch {}
   }
 }
-function readWarnedTools(storageDir) {
+async function readWarnedTools(bridge) {
   try {
-    const warnedToolsPath = join16(storageDir, WARNED_TOOLS_FILE);
-    if (!existsSync11(warnedToolsPath))
+    const resp = await bridge.send("db_get_state", { key: "warned_tools" });
+    if (resp.success === false)
       return {};
-    const parsed = JSON.parse(readFileSync10(warnedToolsPath, "utf-8"));
+    const value = resp.data?.value;
+    if (typeof value !== "string")
+      return {};
+    const parsed = JSON.parse(value);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
       return {};
-    const warned = {};
-    for (const [key, version2] of Object.entries(parsed)) {
-      if (typeof version2 === "string") {
-        warned[key] = version2;
-      }
-    }
-    return warned;
+    return parsed;
   } catch {
     return {};
   }
 }
-function writeWarnedTools(storageDir, warned) {
+async function hasWarnedFor(bridge, key) {
+  const warned = await readWarnedTools(bridge);
+  return warned[key] === true || typeof warned[key] === "string";
+}
+async function recordWarning(bridge, key) {
+  const warned = await readWarnedTools(bridge);
+  warned[key] = true;
   try {
-    mkdirSync9(storageDir, { recursive: true });
-    const warnedToolsPath = join16(storageDir, WARNED_TOOLS_FILE);
-    const tmpPath = join16(storageDir, `${WARNED_TOOLS_FILE}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`);
-    writeFileSync9(tmpPath, `${JSON.stringify(warned, null, 2)}
-`);
-    renameSync7(tmpPath, warnedToolsPath);
+    await bridge.send("db_set_state", {
+      key: "warned_tools",
+      value: JSON.stringify(warned)
+    });
   } catch {}
 }
-async function withWarnedToolsLock(storageDir, fn) {
-  const lockDir = join16(storageDir, "warned_tools.lock");
-  for (let attempt = 0;attempt < 5; attempt++) {
-    try {
-      mkdirSync9(storageDir, { recursive: true });
-      mkdirSync9(lockDir, { mode: 448 });
-      try {
-        return await fn();
-      } finally {
-        rmSync6(lockDir, { recursive: true, force: true });
-      }
-    } catch (err) {
-      const code = err.code;
-      if (code !== "EEXIST")
-        return null;
-      await new Promise((resolve4) => setTimeout(resolve4, 10 * (attempt + 1)));
-    }
-  }
-  return null;
-}
 function warningKey(warning, projectRoot) {
   const scope = warning.kind === "lsp_binary_missing" ? "_" : projectRoot ?? "_";
   return [
@@ -27179,29 +27267,14 @@ ${warning.hint}`;
 async function deliverConfigureWarnings(opts, warnings) {
   if (warnings.length === 0)
     return;
-  const deliveredWithLock = await withWarnedToolsLock(opts.storageDir, async () => {
-    const warned = readWarnedTools(opts.storageDir);
-    let changed = false;
-    for (const warning of warnings) {
-      const key = warningKey(warning, opts.projectRoot);
-      if (Object.hasOwn(warned, key))
-        continue;
-      const delivered = await sendIgnoredMessage(opts.client, opts.sessionId, formatConfigureWarning(warning));
-      if (!delivered)
-        continue;
-      warned[key] = opts.pluginVersion;
-      changed = true;
-    }
-    if (changed) {
-      const merged = { ...readWarnedTools(opts.storageDir), ...warned };
-      writeWarnedTools(opts.storageDir, merged);
-    }
-    return true;
-  });
-  if (deliveredWithLock)
-    return;
   for (const warning of warnings) {
-    await sendIgnoredMessage(opts.client, opts.sessionId, formatConfigureWarning(warning));
+    const key = warningKey(warning, opts.projectRoot);
+    if (await hasWarnedFor(opts.bridge, key))
+      continue;
+    const delivered = await sendIgnoredMessage(opts.client, opts.sessionId, formatConfigureWarning(warning));
+    if (!delivered)
+      continue;
+    await recordWarning(opts.bridge, key);
   }
 }
 async function cleanupWarnings(opts) {
@@ -27239,20 +27312,20 @@ async function cleanupWarnings(opts) {
 
 // src/shared/rpc-server.ts
 import { randomBytes as randomBytes2 } from "crypto";
-import { mkdirSync as mkdirSync10, renameSync as renameSync8, unlinkSync as unlinkSync7, writeFileSync as writeFileSync10 } from "fs";
+import { mkdirSync as mkdirSync11, renameSync as renameSync7, unlinkSync as unlinkSync7, writeFileSync as writeFileSync10 } from "fs";
 import { createServer } from "http";
-import { dirname as dirname6 } from "path";
+import { dirname as dirname7 } from "path";
 
 // src/shared/rpc-utils.ts
 import { createHash as createHash6 } from "crypto";
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 function projectHash(directory) {
   const normalized = directory.replace(/\/+$/, "");
   return createHash6("sha256").update(normalized).digest("hex").slice(0, 16);
 }
 function rpcPortFilePath(storageDir, directory) {
   const hash2 = projectHash(directory);
-  return join17(storageDir, "rpc", hash2, "port");
+  return join18(storageDir, "rpc", hash2, "port");
 }
 
 // src/shared/rpc-server.ts
@@ -27285,14 +27358,14 @@ class AftRpcServer {
         this.token = randomBytes2(32).toString("hex");
         this.server = server;
         try {
-          const dir = dirname6(this.portFilePath);
-          mkdirSync10(dir, { recursive: true, mode: 448 });
+          const dir = dirname7(this.portFilePath);
+          mkdirSync11(dir, { recursive: true, mode: 448 });
           const tmpPath = `${this.portFilePath}.tmp`;
           writeFileSync10(tmpPath, JSON.stringify({ port: this.port, token: this.token }), {
             encoding: "utf-8",
             mode: 384
           });
-          renameSync8(tmpPath, this.portFilePath);
+          renameSync7(tmpPath, this.portFilePath);
           log2(`RPC server listening on 127.0.0.1:${this.port}`);
         } catch (err) {
           warn2(`Failed to write RPC port file: ${err}`);
@@ -27446,6 +27519,24 @@ function readNumber(value, fallback = 0) {
 function readOptionalNumber(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
+function readCompressionAggregate(value) {
+  const aggregate = asRecord(value);
+  return {
+    events: readNumber(aggregate.events),
+    original_tokens: readNumber(aggregate.original_tokens),
+    compressed_tokens: readNumber(aggregate.compressed_tokens),
+    savings_tokens: readNumber(aggregate.savings_tokens)
+  };
+}
+function readCompression(value) {
+  if (typeof value !== "object" || value === null)
+    return;
+  const compression = asRecord(value);
+  return {
+    project: readCompressionAggregate(compression.project),
+    session: readCompressionAggregate(compression.session)
+  };
+}
 function formatFlag(enabled) {
   return enabled ? "enabled" : "disabled";
 }
@@ -27524,6 +27615,7 @@ function coerceAftStatus(response) {
       tracked_files: readNumber(session.tracked_files),
       checkpoints: readNumber(session.checkpoints)
     },
+    compression: readCompression(response.compression),
     message: readString(response.message, "")
   };
 }
@@ -27582,21 +27674,21 @@ function formatStatusMarkdown(status) {
 
 // src/shared/tui-config.ts
 var import_comment_json4 = __toESM(require_src2(), 1);
-import { existsSync as existsSync12, mkdirSync as mkdirSync11, readFileSync as readFileSync11, writeFileSync as writeFileSync11 } from "fs";
-import { dirname as dirname7, join as join19 } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync12, readFileSync as readFileSync11, writeFileSync as writeFileSync11 } from "fs";
+import { dirname as dirname8, join as join20 } from "path";
 
 // src/shared/opencode-config-dir.ts
-import { homedir as homedir9 } from "os";
-import { join as join18, resolve as resolve4 } from "path";
+import { homedir as homedir10 } from "os";
+import { join as join19, resolve as resolve4 } from "path";
 function getCliConfigDir() {
   const envConfigDir = process.env.OPENCODE_CONFIG_DIR?.trim();
   if (envConfigDir) {
     return resolve4(envConfigDir);
   }
   if (process.platform === "win32") {
-    return join18(homedir9(), ".config", "opencode");
+    return join19(homedir10(), ".config", "opencode");
   }
-  return join18(process.env.XDG_CONFIG_HOME || join18(homedir9(), ".config"), "opencode");
+  return join19(process.env.XDG_CONFIG_HOME || join19(homedir10(), ".config"), "opencode");
 }
 function getOpenCodeConfigDir2(_options) {
   return getCliConfigDir();
@@ -27605,10 +27697,10 @@ function getOpenCodeConfigPaths(options) {
   const configDir = getOpenCodeConfigDir2(options);
   return {
     configDir,
-    configJson: join18(configDir, "opencode.json"),
-    configJsonc: join18(configDir, "opencode.jsonc"),
-    packageJson: join18(configDir, "package.json"),
-    omoConfig: join18(configDir, "magic-context.jsonc")
+    configJson: join19(configDir, "opencode.json"),
+    configJsonc: join19(configDir, "opencode.jsonc"),
+    packageJson: join19(configDir, "package.json"),
+    omoConfig: join19(configDir, "magic-context.jsonc")
   };
 }
 
@@ -27617,11 +27709,11 @@ var PLUGIN_NAME = "@cortexkit/aft-opencode";
 var PLUGIN_ENTRY = `${PLUGIN_NAME}@latest`;
 function resolveTuiConfigPath() {
   const configDir = getOpenCodeConfigPaths({ binary: "opencode" }).configDir;
-  const jsoncPath = join19(configDir, "tui.jsonc");
-  const jsonPath = join19(configDir, "tui.json");
-  if (existsSync12(jsoncPath))
+  const jsoncPath = join20(configDir, "tui.jsonc");
+  const jsonPath = join20(configDir, "tui.json");
+  if (existsSync13(jsoncPath))
     return jsoncPath;
-  if (existsSync12(jsonPath))
+  if (existsSync13(jsonPath))
     return jsonPath;
   return jsonPath;
 }
@@ -27629,7 +27721,7 @@ function ensureTuiPluginEntry() {
   try {
     const configPath = resolveTuiConfigPath();
     let config2 = {};
-    if (existsSync12(configPath)) {
+    if (existsSync13(configPath)) {
       config2 = import_comment_json4.parse(readFileSync11(configPath, "utf-8")) ?? {};
     }
     const plugins = Array.isArray(config2.plugin) ? config2.plugin.filter((value) => typeof value === "string") : [];
@@ -27638,7 +27730,7 @@ function ensureTuiPluginEntry() {
     }
     plugins.push(PLUGIN_ENTRY);
     config2.plugin = plugins;
-    mkdirSync11(dirname7(configPath), { recursive: true });
+    mkdirSync12(dirname8(configPath), { recursive: true });
     writeFileSync11(configPath, `${import_comment_json4.stringify(config2, null, 2)}
 `);
     log2(`[aft-plugin] added TUI plugin entry to ${configPath}`);
@@ -30662,9 +30754,9 @@ function splitIncludeArg(raw) {
     }
     buf += ch;
   }
-  const tail = buf.trim();
-  if (tail.length > 0)
-    out.push(tail);
+  const tail2 = buf.trim();
+  if (tail2.length > 0)
+    out.push(tail2);
   return out;
 }
 function searchTools(ctx) {
@@ -31024,6 +31116,7 @@ async function handleConfigureWarningsForSession(context) {
   await deliverConfigureWarnings({
     client: context.client ?? context.fallbackClient,
     sessionId: context.sessionId,
+    bridge: context.bridge,
     storageDir: context.storageDir,
     pluginVersion: context.pluginVersion,
     projectRoot: context.projectRoot
@@ -31078,6 +31171,7 @@ var ANNOUNCEMENT_FEATURES = [
 var plugin = async (input) => initializePluginForDirectory(input);
 async function initializePluginForDirectory(input) {
   const binaryPath = await findBinary(PLUGIN_VERSION);
+  await ensureStorageMigrated({ harness: "opencode", binaryPath, logger: bridgeLogger });
   const aftConfig = loadAftConfig(input.directory);
   const autoUpdateAbort = new AbortController;
   const configOverrides = {};
@@ -31104,8 +31198,7 @@ async function initializePluginForDirectory(input) {
   if (aftConfig.max_callgraph_files !== undefined)
     configOverrides.max_callgraph_files = aftConfig.max_callgraph_files;
   const isFastembedSemanticBackend = (aftConfig.semantic?.backend ?? "fastembed") === "fastembed";
-  const dataHome = process.env.XDG_DATA_HOME || join21(homedir10(), ".local", "share");
-  configOverrides.storage_dir = join21(dataHome, "opencode", "storage", "plugin", "aft");
+  configOverrides.storage_dir = resolveCortexKitStorageRoot();
   let onnxRuntimePromise = null;
   if (aftConfig.semantic_search && isFastembedSemanticBackend) {
     const storageDir2 = configOverrides.storage_dir;
@@ -31212,17 +31305,23 @@ ${lines}
       versionUpgradePromises.set(minVersion, upgradePromise);
       return upgradePromise;
     },
-    onConfigureWarnings: async ({ projectRoot, sessionId, client, warnings }) => {
+    onConfigureWarnings: ({ projectRoot, sessionId, client, warnings }) => {
+      const bridge = pool.getActiveBridgeForRoot(projectRoot);
+      if (!bridge)
+        return;
       const pendingWarnings = sessionId ? drainPendingEagerWarnings(projectRoot) : [];
-      await handleConfigureWarningsForSession({
-        projectRoot,
-        sessionId,
-        client,
-        warnings: [...pendingWarnings, ...warnings],
-        fallbackClient: input.client,
-        storageDir: configOverrides.storage_dir,
-        pluginVersion: PLUGIN_VERSION
-      });
+      setTimeout(() => {
+        handleConfigureWarningsForSession({
+          projectRoot,
+          sessionId,
+          client,
+          bridge,
+          warnings: [...pendingWarnings, ...warnings],
+          fallbackClient: input.client,
+          storageDir: configOverrides.storage_dir,
+          pluginVersion: PLUGIN_VERSION
+        });
+      }, 0);
     },
     onBashCompletion: (completion) => {
       const sessionDir = getSessionDirectoryCached(completion.session_id) ?? input.directory;
@@ -31244,6 +31343,7 @@ ${lines}
     }
   };
   const pool = new BridgePool(binaryPath, poolOptions, configOverrides);
+  pool.setConfigureOverride("harness", "opencode");
   const ctx = {
     pool,
     client: input.client,
@@ -31293,7 +31393,9 @@ ${lines}
       };
     }
     const cached2 = bridge.getCachedStatus();
-    if (cached2 !== null) {
+    const cachedSessionId = cached2?.session;
+    const cachedId = cachedSessionId?.id;
+    if (cached2 !== null && cachedId === sessionID) {
       return { success: true, ...cached2 };
     }
     const response = await bridge.send("status", { session_id: sessionID });
@@ -31308,9 +31410,9 @@ ${lines}
       return { show: false };
     }
     if (storageDir) {
-      const versionFile = join21(storageDir, "last_announced_version");
+      const versionFile = join22(storageDir, "last_announced_version");
       try {
-        if (existsSync14(versionFile)) {
+        if (existsSync15(versionFile)) {
           const lastVersion = readFileSync12(versionFile, "utf-8").trim();
           if (lastVersion === ANNOUNCEMENT_VERSION)
             return { show: false };
@@ -31322,8 +31424,8 @@ ${lines}
   rpcServer.handle("mark-announced", async () => {
     if (storageDir && ANNOUNCEMENT_VERSION) {
       try {
-        mkdirSync12(storageDir, { recursive: true });
-        writeFileSync12(join21(storageDir, "last_announced_version"), ANNOUNCEMENT_VERSION);
+        mkdirSync13(storageDir, { recursive: true });
+        writeFileSync12(join22(storageDir, "last_announced_version"), ANNOUNCEMENT_VERSION);
       } catch {}
     }
     return { success: true };
@@ -31464,8 +31566,11 @@ Install: ${getManualInstallHint()}`).catch(() => {});
       const sessionDir = await getSessionDirectory(input.client, commandInput.sessionID, input.directory) ?? input.directory;
       const bridge = ctx.pool.getActiveBridgeForRoot(sessionDir) ?? ctx.pool.getBridge(sessionDir);
       const cached2 = bridge.getCachedStatus();
-      const response = cached2 ? { success: true, ...cached2 } : await bridge.send("status", { session_id: commandInput.sessionID });
-      if (!cached2 && response.success !== false) {
+      const cachedSessionId = cached2?.session;
+      const cachedId = cachedSessionId?.id;
+      const cacheUsable = cached2 !== null && cachedId === commandInput.sessionID;
+      const response = cacheUsable ? { success: true, ...cached2 } : await bridge.send("status", { session_id: commandInput.sessionID });
+      if (!cacheUsable && response.success !== false) {
         bridge.cacheStatusSnapshot(response);
       }
       if (response.success === false) {