@cortexkit/aft-opencode 0.30.0 → 0.30.2

package/dist/index.js

@@ -12399,7 +12399,7 @@ var require_snapshot_utils = __commonJS((exports, module) => {
 // ../../node_modules/.bun/undici@7.25.0/node_modules/undici/lib/mock/snapshot-recorder.js
 var require_snapshot_recorder = __commonJS((exports, module) => {
   var { writeFile, readFile, mkdir } = __require("node:fs/promises");
-  var { dirname: dirname3, resolve: resolve2 } = __require("node:path");
+  var { dirname: dirname4, resolve: resolve2 } = __require("node:path");
   var { setTimeout: setTimeout2, clearTimeout: clearTimeout2 } = __require("node:timers");
   var { InvalidArgumentError, UndiciError } = require_errors();
   var { hashId, isUrlExcludedFactory, normalizeHeaders, createHeaderFilters } = require_snapshot_utils();
@@ -12594,7 +12594,7 @@ var require_snapshot_recorder = __commonJS((exports, module) => {
         throw new InvalidArgumentError("Snapshot path is required");
       }
       const resolvedPath = resolve2(path);
-      await mkdir(dirname3(resolvedPath), { recursive: true });
+      await mkdir(dirname4(resolvedPath), { recursive: true });
       const data = Array.from(this.#snapshots.entries()).map(([hash, snapshot]) => ({
         hash,
         snapshot
@@ -29810,10 +29810,10 @@ var require_stringify = __commonJS((exports, module) => {
     replacer = null;
     indent = EMPTY;
   };
-  var join8 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(one, gap)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two, gap)), gap) : EMPTY;
+  var join9 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(one, gap)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two, gap)), gap) : EMPTY;
   var join_content = (inside, value, gap) => {
     const comment = process_comments(value, PREFIX_BEFORE, gap + indent, true);
-    return join8(comment, inside, gap);
+    return join9(comment, inside, gap);
   };
   var stringify_string = (holder, key, value) => {
     const raw = get_raw_string_literal(holder, key);
@@ -29835,13 +29835,13 @@ var require_stringify = __commonJS((exports, module) => {
       if (i !== 0) {
         inside += COMMA;
       }
-      const before = join8(after_comma, process_comments(value, BEFORE(i), deeper_gap), deeper_gap);
+      const before = join9(after_comma, process_comments(value, BEFORE(i), deeper_gap), deeper_gap);
       inside += before || LF + deeper_gap;
       inside += stringify(i, value, deeper_gap) || STR_NULL;
       inside += process_comments(value, AFTER_VALUE(i), deeper_gap);
       after_comma = process_comments(value, AFTER(i), deeper_gap);
     }
-    inside += join8(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join9(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
     return BRACKET_OPEN + join_content(inside, value, gap) + BRACKET_CLOSE;
   };
   var object_stringify = (value, gap) => {
@@ -29862,13 +29862,13 @@ var require_stringify = __commonJS((exports, module) => {
         inside += COMMA;
       }
       first = false;
-      const before = join8(after_comma, process_comments(value, BEFORE(key), deeper_gap), deeper_gap);
+      const before = join9(after_comma, process_comments(value, BEFORE(key), deeper_gap), deeper_gap);
       inside += before || LF + deeper_gap;
       inside += quote(key) + process_comments(value, AFTER_PROP(key), deeper_gap) + COLON + process_comments(value, AFTER_COLON(key), deeper_gap) + SPACE + sv + process_comments(value, AFTER_VALUE(key), deeper_gap);
       after_comma = process_comments(value, AFTER(key), deeper_gap);
     };
     keys.forEach(iteratee);
-    inside += join8(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join9(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
     return CURLY_BRACKET_OPEN + join_content(inside, value, gap) + CURLY_BRACKET_CLOSE;
   };
   function stringify(key, holder, gap) {
@@ -33691,9 +33691,9 @@ var require_xterm_headless = __commonJS((exports) => {
 });
 
 // src/index.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync13, readFileSync as readFileSync13, writeFileSync as writeFileSync12 } from "node:fs";
+import { existsSync as existsSync17, mkdirSync as mkdirSync14, readFileSync as readFileSync14, writeFileSync as writeFileSync12 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
-import { join as join23 } from "node:path";
+import { dirname as dirname14 } from "node:path";
 
 // ../aft-bridge/dist/active-logger.js
 var ACTIVE_LOGGER_SYMBOL = Symbol.for("aft-bridge-active-logger");
@@ -33982,6 +33982,11 @@ class BinaryBridge {
       if (requestSessionId && options?.configureWarningClient !== undefined) {
         this.configureWarningClients.set(requestSessionId, options.configureWarningClient);
       }
+      const effectiveTimeoutMs = options?.transportTimeoutMs ?? options?.timeoutMs ?? this.timeoutMs;
+      const implicitTransportOptions = {
+        ...options?.transportTimeoutMs !== undefined || options?.timeoutMs !== undefined ? { transportTimeoutMs: effectiveTimeoutMs } : {},
+        markConfiguredOnSuccess: false
+      };
       if (!this.configured) {
         if (command !== "configure" && command !== "version") {
           if (!this._configurePromise) {
@@ -33992,12 +33997,12 @@ class BinaryBridge {
                   project_root: this.cwd,
                   ...this.configOverrides,
                   ...sessionIdForConfigure ? { session_id: sessionIdForConfigure } : {}
-                });
+                }, implicitTransportOptions);
                 if (configResult.success === false) {
                   throw new Error(`${this.errorPrefix} Configure failed: ${configResult.message ?? "unknown error"}`);
                 }
                 await this.deliverConfigureWarnings(configResult, params, options);
-                await this.checkVersion();
+                await this.checkVersion(implicitTransportOptions);
                 if (!this.isAlive()) {
                   throw new Error(`${this.errorPrefix} Bridge died during version check. Check logs: ${this.getLogFilePathVia()}`);
                 }
@@ -34027,9 +34032,8 @@ class BinaryBridge {
       }
       const line = `${JSON.stringify(request)}
 `;
-      const effectiveTimeoutMs = options?.transportTimeoutMs ?? options?.timeoutMs ?? this.timeoutMs;
       const keepBridgeOnTimeout = options?.keepBridgeOnTimeout === true;
-      return new Promise((resolve, reject) => {
+      const response = await new Promise((resolve, reject) => {
         const timer = setTimeout(() => {
           this.pending.delete(id);
           const restartSuffix = keepBridgeOnTimeout ? "" : " — restarting bridge";
@@ -34062,6 +34066,10 @@ class BinaryBridge {
           }
         });
       });
+      if (command === "configure" && response.success === true && options?.markConfiguredOnSuccess !== false) {
+        this.configured = true;
+      }
+      return response;
     } catch (err) {
       if (err instanceof BridgeReplacedDuringVersionCheck && canRetryAfterVersionSwap && command !== "configure" && command !== "version") {
         this.logVia(`Retrying request "${command}" once after coordinated binary replacement: ${err.newBinaryPath}`);
@@ -34152,11 +34160,11 @@ class BinaryBridge {
       });
     }
   }
-  async checkVersion() {
+  async checkVersion(options) {
     if (!this.minVersion)
       return;
     try {
-      const resp = await this.send("version");
+      const resp = await this.send("version", {}, options);
       if (resp.success === false) {
         throw new Error(`Binary version check failed: ${String(resp.code ?? "unknown")} — likely too old`);
       }
@@ -34231,10 +34239,14 @@ class BinaryBridge {
       ...process.env,
       ...envPath ? { PATH: envPath } : {}
     };
+    this.logVia(`bridge.spawnProcess: useFastembedBackend=${useFastembedBackend}, ` + `parentORT=${process.env.ORT_DYLIB_PATH ?? "(unset)"}, ` + `ortLibraryPath=${ortLibraryPath ?? "(none)"}`);
     if (useFastembedBackend) {
       env.FASTEMBED_CACHE_DIR = process.env.FASTEMBED_CACHE_DIR || (typeof this.configOverrides.storage_dir === "string" ? join(this.configOverrides.storage_dir, "semantic", "models") : join(homedir() || "", ".cache", "fastembed"));
-      if (ortLibraryPath) {
+      if (process.env.ORT_DYLIB_PATH) {
+        this.logVia(`ORT_DYLIB_PATH inherited from parent env: ${process.env.ORT_DYLIB_PATH}`);
+      } else if (ortLibraryPath) {
         env.ORT_DYLIB_PATH = ortLibraryPath;
+        this.logVia(`ORT_DYLIB_PATH set from managed ONNX Runtime: ${ortLibraryPath}`);
       }
     }
     const child = spawn(this.binaryPath, [], {
@@ -34480,8 +34492,9 @@ class BinaryBridge {
   }
 }
 // ../aft-bridge/dist/downloader.js
-import { createHash } from "node:crypto";
-import { chmodSync, closeSync, createWriteStream, existsSync, mkdirSync, openSync, renameSync, rmSync, statSync, unlinkSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import { chmodSync, closeSync, createWriteStream, existsSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, statSync, unlinkSync, writeSync } from "node:fs";
 import { homedir as homedir2 } from "node:os";
 import { join as join2 } from "node:path";
 import { Readable } from "node:stream";
@@ -34509,6 +34522,34 @@ var LATEST_TAG_TIMEOUT_MS = 30000;
 var MAX_DOWNLOAD_BYTES = 200 * 1024 * 1024;
 var DOWNLOAD_LOCK_TIMEOUT_MS = 120000;
 var DOWNLOAD_LOCK_STALE_MS = 10 * 60000;
+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 expectedVersionFromTag(tag) {
+  return tag.startsWith("v") ? tag.slice(1) : tag;
+}
+function isExpectedCachedBinary(binaryPath, tag) {
+  const expected = expectedVersionFromTag(tag);
+  const actual = readBinaryVersion(binaryPath);
+  if (actual === expected)
+    return true;
+  warn(`Cached binary at ${binaryPath} reports ${actual ?? "no version"}, expected ${expected}; refreshing cache entry`);
+  return false;
+}
 function getCacheDir() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
@@ -34544,7 +34585,7 @@ async function downloadBinary(version) {
   const versionedCacheDir = join2(getCacheDir(), tag);
   const binaryName = getBinaryName();
   const binaryPath = join2(versionedCacheDir, binaryName);
-  if (existsSync(binaryPath)) {
+  if (existsSync(binaryPath) && isExpectedCachedBinary(binaryPath, tag)) {
     return binaryPath;
   }
   const downloadUrl = `https://github.com/${REPO}/releases/download/${tag}/${assetName}`;
@@ -34562,7 +34603,7 @@ async function downloadBinary(version) {
       mkdirSync(versionedCacheDir, { recursive: true });
     }
     releaseLock = await acquireDownloadLock(lockPath);
-    if (existsSync(binaryPath)) {
+    if (existsSync(binaryPath) && isExpectedCachedBinary(binaryPath, tag)) {
       return binaryPath;
     }
     binaryController = new AbortController;
@@ -34651,7 +34692,7 @@ async function ensureBinary(version) {
   if (version) {
     const tag = version.startsWith("v") ? version : `v${version}`;
     const versionCached = getCachedBinaryPath(tag);
-    if (versionCached) {
+    if (versionCached && isExpectedCachedBinary(versionCached, tag)) {
       log(`Found cached binary for ${tag}: ${versionCached}`);
       return versionCached;
     }
@@ -34665,13 +34706,17 @@ async function acquireDownloadLock(lockPath) {
   const startedAt = Date.now();
   while (true) {
     try {
+      const owner = `${process.pid}:${Date.now()}:${randomUUID()}`;
       const fd = openSync(lockPath, "wx");
+      writeSync(fd, owner);
       return () => {
         try {
           closeSync(fd);
         } catch {}
         try {
-          rmSync(lockPath, { force: true });
+          if (readFileSync(lockPath, "utf-8") === owner) {
+            rmSync(lockPath, { force: true });
+          }
         } catch {}
       };
     } catch (err) {
@@ -34727,34 +34772,35 @@ async function fetchLatestTag() {
 }
 // ../aft-bridge/dist/migration.js
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync3, mkdirSync as mkdirSync3 } from "node:fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync4 } from "node:fs";
 import { homedir as homedir4, tmpdir } from "node:os";
-import { dirname, join as join4 } from "node:path";
+import { dirname as dirname2, join as join5 } from "node:path";
+
+// ../aft-bridge/dist/paths.js
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, renameSync as renameSync2 } from "node:fs";
+import { dirname, join as join3 } from "node:path";
+function resolveHarnessStoragePath(storageRoot, harness, ...segments) {
+  return join3(storageRoot, harness, ...segments);
+}
+function repairRootScopedStorageFile(storageRoot, harness, fileName) {
+  const harnessPath = resolveHarnessStoragePath(storageRoot, harness, fileName);
+  const rootPath = join3(storageRoot, fileName);
+  if (existsSync2(harnessPath) || !existsSync2(rootPath))
+    return harnessPath;
+  try {
+    mkdirSync2(dirname(harnessPath), { recursive: true });
+    renameSync2(rootPath, harnessPath);
+  } catch {}
+  return harnessPath;
+}
 
 // ../aft-bridge/dist/resolver.js
-import { execSync, spawnSync } from "node:child_process";
-import { chmodSync as chmodSync2, copyFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2, renameSync as renameSync2 } from "node:fs";
+import { execSync } from "node:child_process";
+import { chmodSync as chmodSync2, copyFileSync, existsSync as existsSync3, mkdirSync as mkdirSync3, renameSync as renameSync3 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
 import { homedir as homedir3 } from "node:os";
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 var ensureBinaryForResolver = ensureBinary;
-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);
@@ -34762,22 +34808,22 @@ function copyToVersionedCache(npmBinaryPath, knownVersion) {
       return null;
     const tag = version.startsWith("v") ? version : `v${version}`;
     const cacheDir = getCacheDir();
-    const versionedDir = join3(cacheDir, tag);
+    const versionedDir = join4(cacheDir, tag);
     const ext = process.platform === "win32" ? ".exe" : "";
-    const cachedPath = join3(versionedDir, `aft${ext}`);
-    if (existsSync2(cachedPath)) {
+    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`);
     }
-    mkdirSync2(versionedDir, { recursive: true });
+    mkdirSync3(versionedDir, { recursive: true });
     const tmpPath = `${cachedPath}.${process.pid}.${Date.now()}.tmp`;
     copyFileSync(npmBinaryPath, tmpPath);
     if (process.platform !== "win32") {
       chmodSync2(tmpPath, 493);
     }
-    renameSync2(tmpPath, cachedPath);
+    renameSync3(tmpPath, cachedPath);
     log(`Copied npm binary to versioned cache: ${cachedPath}`);
     return cachedPath;
   } catch (err) {
@@ -34793,17 +34839,17 @@ function homeDirFromEnv(env) {
 }
 function cacheDirFromEnv(env) {
   if (process.platform === "win32") {
-    const base2 = env.LOCALAPPDATA || env.APPDATA || join3(homeDirFromEnv(env), "AppData", "Local");
-    return join3(base2, "aft", "bin");
+    const base2 = env.LOCALAPPDATA || env.APPDATA || join4(homeDirFromEnv(env), "AppData", "Local");
+    return join4(base2, "aft", "bin");
   }
-  const base = env.XDG_CACHE_HOME || join3(homeDirFromEnv(env), ".cache");
-  return join3(base, "aft", "bin");
+  const base = env.XDG_CACHE_HOME || join4(homeDirFromEnv(env), ".cache");
+  return join4(base, "aft", "bin");
 }
 function cachedBinaryPathFromEnv(version, env, ext) {
-  const binaryPath = join3(cacheDirFromEnv(env), version, `aft${ext}`);
-  return existsSync2(binaryPath) ? binaryPath : null;
+  const binaryPath = join4(cacheDirFromEnv(env), version, `aft${ext}`);
+  return existsSync3(binaryPath) ? binaryPath : null;
 }
-function isExpectedCachedBinary(binaryPath, expectedVersion) {
+function isExpectedCachedBinary2(binaryPath, expectedVersion) {
   const expected = normalizeBareVersion(expectedVersion);
   const actual = readBinaryVersion(binaryPath);
   if (actual === expected)
@@ -34811,6 +34857,21 @@ function isExpectedCachedBinary(binaryPath, expectedVersion) {
   warn(`Cached binary at ${binaryPath} reports ${actual ?? "no version"}, expected ${expected}; skipping cache candidate`);
   return false;
 }
+function probeBinaryCandidate(binaryPath, source, expectedVersion) {
+  const actual = readBinaryVersion(binaryPath);
+  if (actual === null) {
+    warn(`${source} binary at ${binaryPath} did not report a version; skipping`);
+    return null;
+  }
+  if (expectedVersion && actual !== normalizeBareVersion(expectedVersion)) {
+    warn(`${source} binary at ${binaryPath} reports ${actual}, expected ${normalizeBareVersion(expectedVersion)}; skipping`);
+    return null;
+  }
+  return binaryPath;
+}
+function parsePathLookupOutput(output) {
+  return output.split(/\r?\n/).map((candidate) => candidate.trim()).filter(Boolean);
+}
 function platformKey(platform = process.platform, arch = process.arch) {
   const archMap = PLATFORM_ARCH_MAP[platform];
   if (!archMap) {
@@ -34836,7 +34897,7 @@ function findBinarySync(expectedVersion) {
   if (pluginVersion) {
     const tag = pluginVersion.startsWith("v") ? pluginVersion : `v${pluginVersion}`;
     const versionCached = cachedBinaryPathFromEnv(tag, env, ext);
-    if (versionCached && isExpectedCachedBinary(versionCached, pluginVersion))
+    if (versionCached && isExpectedCachedBinary2(versionCached, pluginVersion))
       return versionCached;
   }
   try {
@@ -34844,7 +34905,7 @@ function findBinarySync(expectedVersion) {
     const packageBin = `@cortexkit/aft-${key}/bin/aft${ext}`;
     const req = createRequire2(import.meta.url);
     const resolved = req.resolve(packageBin);
-    if (existsSync2(resolved)) {
+    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)`);
@@ -34863,12 +34924,18 @@ function findBinarySync(expectedVersion) {
       env,
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
-    if (result)
-      return result;
+    for (const candidate of parsePathLookupOutput(result)) {
+      const usable = probeBinaryCandidate(candidate, "PATH", expectedVersion);
+      if (usable)
+        return usable;
+    }
   } catch {}
-  const cargoPath = join3(homeDirFromEnv(env), ".cargo", "bin", `aft${ext}`);
-  if (existsSync2(cargoPath))
-    return cargoPath;
+  const cargoPath = join4(homeDirFromEnv(env), ".cargo", "bin", `aft${ext}`);
+  if (existsSync3(cargoPath)) {
+    const usable = probeBinaryCandidate(cargoPath, "cargo", expectedVersion);
+    if (usable)
+      return usable;
+  }
   return null;
 }
 async function findBinary(expectedVersion) {
@@ -34909,9 +34976,9 @@ 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 process.env.LOCALAPPDATA || process.env.APPDATA || join5(homeDir(), "AppData", "Local");
   }
-  return join4(homeDir(), ".local", "share");
+  return join5(homeDir(), ".local", "share");
 }
 function homeDir() {
   if (process.platform === "win32")
@@ -34920,11 +34987,11 @@ function homeDir() {
 }
 function resolveLegacyStorageRoot(harness) {
   if (harness === "pi")
-    return join4(homeDir(), ".pi", "agent", "aft");
-  return join4(dataHome(), "opencode", "storage", "plugin", "aft");
+    return join5(homeDir(), ".pi", "agent", "aft");
+  return join5(dataHome(), "opencode", "storage", "plugin", "aft");
 }
 function resolveCortexKitStorageRoot() {
-  return join4(dataHome(), "cortexkit", "aft");
+  return join5(dataHome(), "cortexkit", "aft");
 }
 function tail(value) {
   if (!value)
@@ -34938,26 +35005,26 @@ function spawnErrorLabel(error2) {
   return [code, error2.message].filter(Boolean).join(": ");
 }
 function migrationLogPath(newRoot, harness, logger) {
-  const desired = join4(newRoot, "logs", "migration", `${harness}-${Date.now()}.jsonl`);
+  const desired = join5(newRoot, "logs", "migration", `${harness}-${Date.now()}.jsonl`);
   try {
-    mkdirSync3(dirname(desired), { recursive: true });
+    mkdirSync4(dirname2(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}.`);
+    const fallback = join5(tmpdir(), `aft-migration-${harness}-${Date.now()}.jsonl`);
+    logger?.warn?.(`Failed to create AFT migration log directory ${dirname2(desired)}: ${err instanceof Error ? err.message : String(err)}. ` + `Using fallback log path ${fallback}.`);
     return fallback;
   }
 }
 async function ensureStorageMigrated(opts) {
   const legacyRoot = resolveLegacyStorageRoot(opts.harness);
   const newRoot = resolveCortexKitStorageRoot();
-  const targetMarker = join4(newRoot, opts.harness, TARGET_MARKER);
+  const targetMarker = resolveHarnessStoragePath(newRoot, opts.harness, TARGET_MARKER);
   const info = opts.logger?.info ?? opts.logger?.log;
-  if (existsSync3(targetMarker)) {
+  if (existsSync4(targetMarker)) {
     info?.(`AFT storage already migrated for ${opts.harness}; using ${newRoot}`);
     return;
   }
-  if (!existsSync3(legacyRoot)) {
+  if (!existsSync4(legacyRoot)) {
     info?.(`AFT storage migration skipped for ${opts.harness}: no legacy data at ${legacyRoot}; ` + `using ${newRoot} for fresh install`);
     return;
   }
@@ -35007,8 +35074,8 @@ async function ensureStorageMigrated(opts) {
 // ../aft-bridge/dist/onnx-runtime.js
 import { execFileSync } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
-import { chmodSync as chmodSync3, closeSync as closeSync2, copyFileSync as 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 "node:fs";
-import { dirname as dirname2, join as join5, relative, resolve } from "node:path";
+import { chmodSync as chmodSync3, closeSync as closeSync2, copyFileSync as copyFileSync2, createWriteStream as createWriteStream2, existsSync as existsSync5, lstatSync, mkdirSync as mkdirSync5, openSync as openSync2, readdirSync, readFileSync as readFileSync2, readlinkSync, realpathSync, rmSync as rmSync2, statSync as statSync2, symlinkSync, unlinkSync as unlinkSync2, writeFileSync } from "node:fs";
+import { basename, dirname as dirname3, join as join6, relative, resolve } from "node:path";
 import { Readable as Readable2 } from "node:stream";
 import { pipeline as pipeline2 } from "node:stream/promises";
 var ORT_VERSION = "1.24.4";
@@ -35074,9 +35141,9 @@ function getManualInstallHint() {
 }
 async function ensureOnnxRuntime(storageDir) {
   const info = getPlatformInfo();
-  const ortDir = join5(storageDir, "onnxruntime", ORT_VERSION);
-  const libPath = join5(ortDir, info?.libName ?? "libonnxruntime.dylib");
-  if (existsSync4(libPath)) {
+  const ortDir = join6(storageDir, "onnxruntime", ORT_VERSION);
+  const libPath = join6(ortDir, info?.libName ?? "libonnxruntime.dylib");
+  if (existsSync5(libPath)) {
     const meta = readOnnxInstalledMeta(ortDir);
     if (meta?.sha256) {
       try {
@@ -35105,9 +35172,9 @@ async function ensureOnnxRuntime(storageDir) {
     warn(`ONNX Runtime auto-download not available for ${process.platform}/${process.arch}. Install manually: ${getManualInstallHint()}`);
     return null;
   }
-  const onnxBaseDir = join5(storageDir, "onnxruntime");
-  mkdirSync4(onnxBaseDir, { recursive: true });
-  const lockPath = join5(onnxBaseDir, ONNX_LOCK_FILE);
+  const onnxBaseDir = join6(storageDir, "onnxruntime");
+  mkdirSync5(onnxBaseDir, { recursive: true });
+  const lockPath = join6(onnxBaseDir, ONNX_LOCK_FILE);
   cleanupAbandonedStagingDirs(onnxBaseDir);
   if (!acquireLock(lockPath)) {
     warn(`ONNX Runtime install already in progress in another process (lock: ${lockPath}). Skipping.`);
@@ -35126,7 +35193,7 @@ function cleanupAbandonedStagingDirs(onnxBaseDir) {
     for (const entry of entries) {
       if (!entry.startsWith(`${ORT_VERSION}.tmp.`))
         continue;
-      const stagingDir = join5(onnxBaseDir, entry);
+      const stagingDir = join6(onnxBaseDir, entry);
       const parts = entry.split(".");
       const pidStr = parts[parts.length - 2];
       const pid = pidStr ? Number.parseInt(pidStr, 10) : NaN;
@@ -35158,7 +35225,7 @@ function cleanupAbandonedStagingDirs(onnxBaseDir) {
 }
 function cleanupIncompleteTargetIfUnowned(ortDir) {
   try {
-    if (existsSync4(ortDir) && !existsSync4(join5(ortDir, ONNX_INSTALLED_META_FILE))) {
+    if (existsSync5(ortDir) && !existsSync5(join6(ortDir, ONNX_INSTALLED_META_FILE))) {
       log(`[onnx] removing half-populated install dir ${ortDir} (no meta file)`);
       rmSync2(ortDir, { recursive: true, force: true });
     }
@@ -35168,6 +35235,14 @@ function cleanupIncompleteTargetIfUnowned(ortDir) {
 }
 var REQUIRED_ORT_MAJOR = 1;
 var REQUIRED_ORT_MIN_MINOR = 20;
+var INVALID_ORT_VERSION = "<invalid>";
+function parseOnnxVersionFromPath(value) {
+  const name = basename(value);
+  const semverish = name.match(/\.(\d+\.\d+\.\d+(?:[-+][A-Za-z0-9.-]+)?)(?:\.dylib)?$/);
+  if (semverish)
+    return semverish[1].split(/[-+]/, 1)[0];
+  return /\d+\.\d+\.\d+/.test(name) ? INVALID_ORT_VERSION : null;
+}
 function detectOnnxVersion(libDir, libName) {
   try {
     const entries = readdirSync(libDir);
@@ -35175,23 +35250,23 @@ function detectOnnxVersion(libDir, libName) {
     for (const entry of entries) {
       if (!entry.startsWith(barePrefix))
         continue;
-      const match = entry.match(/\.(\d+\.\d+\.\d+)(?:\.dylib)?$/);
-      if (match)
-        return match[1];
+      const version = parseOnnxVersionFromPath(entry);
+      if (version)
+        return version;
     }
-    const base = join5(libDir, libName);
-    if (existsSync4(base)) {
+    const base = join6(libDir, libName);
+    if (existsSync5(base)) {
       try {
         const real = realpathSync(base);
-        const m = real.match(/\.(\d+\.\d+\.\d+)(?:\.dylib)?$/);
-        if (m)
-          return m[1];
+        const version = parseOnnxVersionFromPath(real);
+        if (version)
+          return version;
       } catch {}
       try {
         const target = readlinkSync(base);
-        const m = target.match(/\.(\d+\.\d+\.\d+)(?:\.dylib)?$/);
-        if (m)
-          return m[1];
+        const version = parseOnnxVersionFromPath(target);
+        if (version)
+          return version;
       } catch {}
     }
   } catch {}
@@ -35216,7 +35291,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 (!existsSync4(join5(dir, libName)))
+    if (!existsSync5(join6(dir, libName)))
       continue;
     const version = detectOnnxVersion(dir, libName);
     if (version && !isOnnxVersionCompatible(version)) {
@@ -35243,7 +35318,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}`);
     }
-    mkdirSync4(dirname2(destPath), { recursive: true });
+    mkdirSync5(dirname3(destPath), { recursive: true });
     let bytesWritten = 0;
     const guard = new TransformStream({
       transform(chunk, transformController) {
@@ -35273,11 +35348,11 @@ function validateExtractedTree(stagingRoot) {
   const walk = (dir) => {
     const entries = readdirSync(dir);
     for (const entry of entries) {
-      const fullPath = join5(dir, entry);
+      const fullPath = join6(dir, entry);
       const lst = lstatSync(fullPath);
       if (lst.isSymbolicLink()) {
         const linkTarget = readlinkSync(fullPath);
-        const resolvedTarget = resolve(dirname2(fullPath), linkTarget);
+        const resolvedTarget = resolve(dirname3(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}`);
@@ -35307,8 +35382,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 {
-    mkdirSync4(tmpDir, { recursive: true });
-    const archivePath = join5(tmpDir, `onnxruntime.${info.archiveType}`);
+    mkdirSync5(tmpDir, { recursive: true });
+    const archivePath = join6(tmpDir, `onnxruntime.${info.archiveType}`);
     await downloadFileWithCap(url, archivePath);
     const archiveSha256 = sha256File(archivePath);
     log(`ONNX Runtime archive sha256=${archiveSha256}`);
@@ -35324,16 +35399,16 @@ async function downloadOnnxRuntime(info, targetDir) {
       unlinkSync2(archivePath);
     } catch {}
     validateExtractedTree(tmpDir);
-    const extractedDir = join5(tmpDir, info.assetName, "lib");
-    if (!existsSync4(extractedDir)) {
+    const extractedDir = join6(tmpDir, info.assetName, "lib");
+    if (!existsSync5(extractedDir)) {
       throw new Error(`Expected directory not found: ${extractedDir}`);
     }
-    mkdirSync4(targetDir, { recursive: true });
+    mkdirSync5(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 = join5(extractedDir, libFile);
+      const src = join6(extractedDir, libFile);
       try {
         const stat = lstatSync(src);
         log(`ORT extract: ${libFile} — isSymlink=${stat.isSymbolicLink()}, isFile=${stat.isFile()}, size=${stat.size}`);
@@ -35348,7 +35423,7 @@ async function downloadOnnxRuntime(info, targetDir) {
       }
     }
     copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks);
-    const libPath = join5(targetDir, info.libName);
+    const libPath = join6(targetDir, info.libName);
     let libHash = null;
     try {
       libHash = sha256File(libPath);
@@ -35373,8 +35448,8 @@ async function downloadOnnxRuntime(info, targetDir) {
 function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, copyFile = copyFileSync2) {
   const requiredLibs = new Set([info.libName]);
   for (const libFile of realFiles) {
-    const src = join5(extractedDir, libFile);
-    const dst = join5(targetDir, libFile);
+    const src = join6(extractedDir, libFile);
+    const dst = join6(targetDir, libFile);
     try {
       copyFile(src, dst);
       if (process.platform !== "win32") {
@@ -35389,7 +35464,7 @@ function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, c
     }
   }
   for (const link of symlinks) {
-    const dst = join5(targetDir, link.name);
+    const dst = join6(targetDir, link.name);
     try {
       unlinkSync2(dst);
     } catch {}
@@ -35403,8 +35478,8 @@ function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, c
       log(`ORT extract: failed to symlink optional ${link.name}: ${symlinkErr}`);
     }
   }
-  const requiredPath = join5(targetDir, info.libName);
-  if (!existsSync4(requiredPath)) {
+  const requiredPath = join6(targetDir, info.libName);
+  if (!existsSync5(requiredPath)) {
     rmSync2(targetDir, { recursive: true, force: true });
     throw new Error(`Required ONNX Runtime library missing after install: ${requiredPath}`);
   }
@@ -35430,17 +35505,17 @@ function writeOnnxInstalledMeta(installDir, version, sha256, archiveSha256) {
       ...sha256 ? { sha256 } : {},
       archiveSha256
     };
-    writeFileSync(join5(installDir, ONNX_INSTALLED_META_FILE), JSON.stringify(meta), "utf8");
+    writeFileSync(join6(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 = join5(installDir, ONNX_INSTALLED_META_FILE);
+  const path = join6(installDir, ONNX_INSTALLED_META_FILE);
   try {
     if (!statSync2(path).isFile())
       return null;
-    const raw = readFileSync(path, "utf8");
+    const raw = readFileSync2(path, "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.version !== "string" || parsed.version.length === 0)
       return null;
@@ -35456,7 +35531,7 @@ function readOnnxInstalledMeta(installDir) {
 }
 function sha256File(path) {
   const hash = createHash2("sha256");
-  hash.update(readFileSync(path));
+  hash.update(readFileSync2(path));
   return hash.digest("hex");
 }
 function acquireLock(lockPath) {
@@ -35484,7 +35559,7 @@ ${new Date().toISOString()}
   let owningPid = null;
   let lockMtimeMs = 0;
   try {
-    const raw = readFileSync(lockPath, "utf8");
+    const raw = readFileSync2(lockPath, "utf8");
     const firstLine = raw.split(/\r?\n/, 1)[0]?.trim() ?? "";
     const parsed = Number.parseInt(firstLine, 10);
     if (Number.isFinite(parsed) && parsed > 0)
@@ -35510,7 +35585,7 @@ function releaseLock(lockPath) {
   try {
     let owningPid = null;
     try {
-      const raw = readFileSync(lockPath, "utf8");
+      const raw = readFileSync2(lockPath, "utf8");
       const firstLine = raw.split(/\r?\n/, 1)[0]?.trim() ?? "";
       const parsed = Number.parseInt(firstLine, 10);
       if (Number.isFinite(parsed) && parsed > 0)
@@ -35556,6 +35631,7 @@ var DEFAULT_MAX_POOL_SIZE = 8;
 var CLEANUP_INTERVAL_MS = 60 * 1000;
 class BridgePool {
   bridges = new Map;
+  staleBridges = new Set;
   binaryPath;
   maxPoolSize;
   idleTimeoutMs;
@@ -35578,6 +35654,7 @@ class BridgePool {
       onConfigureWarnings: options.onConfigureWarnings,
       onBashCompletion: options.onBashCompletion,
       onBashLongRunning: options.onBashLongRunning,
+      onBashPatternMatch: options.onBashPatternMatch,
       errorPrefix: options.errorPrefix,
       logger: options.logger
     };
@@ -35629,6 +35706,12 @@ class BridgePool {
         this.bridges.delete(dir);
       }
     }
+    for (const bridge of this.staleBridges) {
+      if (bridge.hasPendingRequests())
+        continue;
+      bridge.shutdown().catch((err) => this.error("stale cleanup shutdown failed:", err));
+      this.staleBridges.delete(bridge);
+    }
   }
   evictLRU() {
     let oldestDir = null;
@@ -35652,14 +35735,21 @@ class BridgePool {
       clearInterval(this.cleanupTimer);
       this.cleanupTimer = null;
     }
-    const shutdowns = Array.from(this.bridges.values()).map((e) => e.bridge.shutdown());
+    const shutdowns = [
+      ...Array.from(this.bridges.values(), (e) => e.bridge.shutdown()),
+      ...Array.from(this.staleBridges.values(), (bridge) => bridge.shutdown())
+    ];
     this.bridges.clear();
+    this.staleBridges.clear();
     await Promise.allSettled(shutdowns);
   }
   async replaceBinary(newPath) {
     this.binaryPath = newPath;
+    for (const entry of this.bridges.values()) {
+      this.staleBridges.add(entry.bridge);
+    }
     this.bridges.clear();
-    this.log(`Binary path updated to ${newPath}. All bridges cleared — next calls will use the new binary.`);
+    this.log(`Binary path updated to ${newPath}. Active bridges marked stale — next calls will use the new binary.`);
     return newPath;
   }
   log(message, meta) {
@@ -35709,11 +35799,11 @@ function normalizeKey(projectRoot) {
   }
 }
 // ../aft-bridge/dist/url-fetch.js
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash3, randomBytes } from "node:crypto";
 import { lookup } from "node:dns/promises";
-import { existsSync as existsSync5, mkdirSync as mkdirSync5, readdirSync as readdirSync2, readFileSync as readFileSync2, unlinkSync as unlinkSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync6, readdirSync as readdirSync2, readFileSync as readFileSync3, unlinkSync as unlinkSync3, writeFileSync as writeFileSync2 } from "node:fs";
 import { isIP } from "node:net";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 
 // ../../node_modules/.bun/undici@7.25.0/node_modules/undici/index.js
 var __filename = "/home/runner/work/aft/aft/node_modules/.bun/undici@7.25.0/node_modules/undici/index.js";
@@ -35863,16 +35953,16 @@ var FETCH_TIMEOUT_MS = 30000;
 var BODY_CHUNK_TIMEOUT_MS = 15000;
 var MAX_REDIRECTS = 5;
 function cacheDir(storageDir) {
-  return join6(storageDir, "url_cache");
+  return join7(storageDir, "url_cache");
 }
 function hashUrl(url) {
   return createHash3("sha256").update(url).digest("hex").slice(0, 16);
 }
 function metaPath(storageDir, hash) {
-  return join6(cacheDir(storageDir), `${hash}.meta.json`);
+  return join7(cacheDir(storageDir), `${hash}.meta.json`);
 }
 function contentPath(storageDir, hash, extension) {
-  return join6(cacheDir(storageDir), `${hash}${extension}`);
+  return join7(cacheDir(storageDir), `${hash}${extension}`);
 }
 function _isPrivateIpv4(address) {
   const parts = address.split(".").map((part) => Number.parseInt(part, 10));
@@ -35997,13 +36087,21 @@ function resolveRedirectUrl(currentUrl, location) {
   }
   return new URL(location, currentUrl);
 }
+var isBunRuntime = typeof globalThis.Bun !== "undefined";
 async function fetchWithRedirects(startUrl, allowPrivate, deps = {}) {
   let currentUrl = startUrl;
-  const fetchImpl2 = deps.fetchImpl ?? $fetch;
+  const fetchImpl2 = deps.fetchImpl ?? (isBunRuntime ? globalThis.fetch : $fetch);
   const dnsLookup = deps.lookup ?? lookup;
   for (let redirectCount = 0;redirectCount <= MAX_REDIRECTS; redirectCount++) {
     const validatedIp = await assertPublicUrl(currentUrl, allowPrivate, dnsLookup);
-    const dispatcher = validatedIp ? (deps.dispatcherFactory ?? createPinnedDispatcher)(validatedIp) : undefined;
+    let dispatcher;
+    if (validatedIp) {
+      if (deps.dispatcherFactory) {
+        dispatcher = deps.dispatcherFactory(validatedIp);
+      } else if (!isBunRuntime) {
+        dispatcher = createPinnedDispatcher(validatedIp);
+      }
+    }
     const controller = new AbortController;
     const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
     let response;
@@ -36014,7 +36112,7 @@ async function fetchWithRedirects(startUrl, allowPrivate, deps = {}) {
         dispatcher,
         headers: {
           "user-agent": "aft-opencode-plugin",
-          accept: "application/vnd.github.raw, text/markdown, text/x-markdown, text/html;q=0.9, text/plain;q=0.5"
+          accept: "application/vnd.github.raw, text/markdown, text/x-markdown, text/html;q=0.9, application/json;q=0.8, text/plain;q=0.5"
         }
       });
     } catch (err) {
@@ -36055,6 +36153,9 @@ function resolveExtension(contentType) {
   if (lower === "text/plain") {
     return ".md";
   }
+  if (lower === "application/json" || lower === "application/ld+json" || lower.endsWith("+json")) {
+    return ".json";
+  }
   return null;
 }
 async function fetchUrlToTempFile(url, storageDir, options = {}) {
@@ -36070,15 +36171,15 @@ async function fetchUrlToTempFile(url, storageDir, options = {}) {
   const allowPrivate = options.allowPrivate === true;
   await assertPublicUrl(parsed, allowPrivate, options.lookup);
   const dir = cacheDir(storageDir);
-  mkdirSync5(dir, { recursive: true });
+  mkdirSync6(dir, { recursive: true });
   const hash = hashUrl(url);
   const metaFile = metaPath(storageDir, hash);
-  if (existsSync5(metaFile)) {
+  if (existsSync6(metaFile)) {
     try {
-      const meta2 = JSON.parse(readFileSync2(metaFile, "utf8"));
+      const meta2 = JSON.parse(readFileSync3(metaFile, "utf8"));
       const age = Date.now() - meta2.fetchedAt;
       const cached = contentPath(storageDir, hash, meta2.extension);
-      if (age < CACHE_TTL_MS && existsSync5(cached)) {
+      if (age < CACHE_TTL_MS && existsSync6(cached)) {
         log(`URL cache hit: ${url} (${Math.round(age / 1000)}s old)`);
         return cached;
       }
@@ -36144,39 +36245,40 @@ async function fetchUrlToTempFile(url, storageDir, options = {}) {
   }
   const body = Buffer.concat(chunks);
   const contentFile = contentPath(storageDir, hash, extension);
-  const tmpContent = `${contentFile}.tmp-${process.pid}`;
+  const nonce = randomBytes(8).toString("hex");
+  const tmpContent = `${contentFile}.tmp-${process.pid}-${nonce}`;
   writeFileSync2(tmpContent, body);
-  const { renameSync: renameSync3 } = await import("node:fs");
-  renameSync3(tmpContent, contentFile);
+  const { renameSync: renameSync4 } = await import("node:fs");
+  renameSync4(tmpContent, contentFile);
   const meta = {
     url,
     contentType,
     extension,
     fetchedAt: Date.now()
   };
-  const tmpMeta = `${metaFile}.tmp-${process.pid}`;
+  const tmpMeta = `${metaFile}.tmp-${process.pid}-${nonce}`;
   writeFileSync2(tmpMeta, JSON.stringify(meta));
-  renameSync3(tmpMeta, metaFile);
+  renameSync4(tmpMeta, metaFile);
   log(`URL cached (${total} bytes): ${url}`);
   return contentFile;
 }
 function cleanupUrlCache(storageDir) {
   const dir = cacheDir(storageDir);
-  if (!existsSync5(dir))
+  if (!existsSync6(dir))
     return;
   let removed = 0;
   try {
     for (const entry of readdirSync2(dir)) {
       if (!entry.endsWith(".meta.json"))
         continue;
-      const metaFile = join6(dir, entry);
+      const metaFile = join7(dir, entry);
       try {
-        const meta = JSON.parse(readFileSync2(metaFile, "utf8"));
+        const meta = JSON.parse(readFileSync3(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 (existsSync5(content))
+          if (existsSync6(content))
             unlinkSync3(content);
           unlinkSync3(metaFile);
           removed++;
@@ -36247,7 +36349,7 @@ function formatZoomText(targetLabel, response) {
 `);
 }
 // src/bg-notifications.ts
-import { createHash as createHash4, randomUUID } from "node:crypto";
+import { createHash as createHash4, randomUUID as randomUUID2 } from "node:crypto";
 
 // src/logger.ts
 import * as fs from "node:fs";
@@ -36346,11 +36448,6 @@ function extractMessages(response) {
     return response.data;
   return [];
 }
-function getRole(message) {
-  if (!isRecord(message) || !isRecord(message.info))
-    return;
-  return typeof message.info.role === "string" ? message.info.role : undefined;
-}
 function extractFromMessage(message) {
   if (!isRecord(message) || !isRecord(message.info))
     return null;
@@ -36401,16 +36498,6 @@ async function resolvePromptContext(client, sessionId) {
   if (messages.length === 0)
     return null;
   let result = {};
-  for (let i = messages.length - 1;i >= 0; i -= 1) {
-    if (getRole(messages[i]) !== "assistant")
-      continue;
-    const ctx = extractFromMessage(messages[i]);
-    if (!ctx)
-      continue;
-    result = mergeContexts(result, ctx);
-    if (isComplete(result))
-      return result;
-  }
   for (let i = messages.length - 1;i >= 0; i -= 1) {
     const ctx = extractFromMessage(messages[i]);
     if (!ctx)
@@ -36430,6 +36517,13 @@ var clientCache = new Map;
 function cacheKey(serverUrl, directory) {
   return `${serverUrl}|${directory}`;
 }
+function normalizeServerUrl(serverUrl) {
+  try {
+    return new URL(serverUrl).toString();
+  } catch {
+    return serverUrl;
+  }
+}
 function serverAuthHeaders() {
   const password = process.env.OPENCODE_SERVER_PASSWORD;
   if (!password)
@@ -36453,30 +36547,46 @@ function getLiveServerClient(serverUrl, directory) {
   clientCache.set(key, client);
   return client;
 }
+var liveServerWakeAvailableByServerUrl = new Map;
+var legacyLiveServerWakeAvailable = false;
 async function probeServerReachable(serverUrl, timeoutMs = 1500) {
   if (!serverUrl)
     return false;
+  const normalizedServerUrl = normalizeServerUrl(serverUrl);
   const controller = new AbortController;
   const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let reachable = false;
   try {
     const probeUrl = new URL("/session", serverUrl).toString();
     const res = await globalThis.fetch(probeUrl, {
       method: "GET",
+      headers: serverAuthHeaders(),
       signal: controller.signal
     });
-    return res.status >= 200 && res.status < 500;
+    reachable = res.ok || res.status === 401 || res.status === 403;
   } catch {
-    return false;
+    reachable = false;
   } finally {
     clearTimeout(timer);
+    liveServerWakeAvailableByServerUrl.set(normalizedServerUrl, reachable);
   }
+  return reachable;
 }
-var liveServerWakeAvailable = false;
-function setLiveServerWakeAvailable(available) {
-  liveServerWakeAvailable = available;
+function setLiveServerWakeAvailable(serverUrlOrAvailable, available) {
+  if (typeof serverUrlOrAvailable === "boolean") {
+    legacyLiveServerWakeAvailable = serverUrlOrAvailable;
+    return;
+  }
+  if (!serverUrlOrAvailable) {
+    legacyLiveServerWakeAvailable = available ?? false;
+    return;
+  }
+  liveServerWakeAvailableByServerUrl.set(normalizeServerUrl(serverUrlOrAvailable), available ?? false);
 }
-function useLiveServerWake() {
-  return liveServerWakeAvailable;
+function useLiveServerWake(serverUrl) {
+  if (!serverUrl)
+    return legacyLiveServerWakeAvailable;
+  return liveServerWakeAvailableByServerUrl.get(normalizeServerUrl(serverUrl)) ?? false;
 }
 
 // src/bg-notifications.ts
@@ -36571,7 +36681,7 @@ function markExplicitControl(sessionID, taskId, trackOutstanding = true) {
   if (idx >= 0) {
     const completion = state.pendingCompletions[idx];
     state.pendingCompletions.splice(idx, 1);
-    queuePendingPatternMatch(state, completionToExitPattern(completion));
+    queuePendingPatternMatch(state, completionToExitPattern(completion, true));
     state.wakeDeferredTaskIds.delete(taskId);
   }
 }
@@ -36599,7 +36709,7 @@ function routeExplicitControlCompletions(state) {
       state.outstandingTaskIds.delete(completion.task_id);
       state.explicitControlTasks.delete(completion.task_id);
       state.wakeDeferredTaskIds.delete(completion.task_id);
-      queuePendingPatternMatch(state, completionToExitPattern(completion));
+      queuePendingPatternMatch(state, completionToExitPattern(completion, true));
     } else {
       remaining.push(completion);
     }
@@ -36626,7 +36736,7 @@ function ingestBgCompletions(sessionID, completions) {
     if (state.explicitControlTasks.has(completion.task_id)) {
       state.outstandingTaskIds.delete(completion.task_id);
       state.explicitControlTasks.delete(completion.task_id);
-      queuePendingPatternMatch(state, completionToExitPattern(completion));
+      queuePendingPatternMatch(state, completionToExitPattern(completion, true));
       continue;
     }
     if (!state.outstandingTaskIds.has(completion.task_id)) {
@@ -36666,6 +36776,8 @@ async function appendInTurnBgCompletions(drainContext, output) {
   if (state.pendingCompletions.length === 0 && state.pendingLongRunning.length === 0 && state.pendingPatternMatches.length === 0)
     return;
   const deliveredCompletions = [...state.pendingCompletions];
+  const deliveredPatternMatches = [...state.pendingPatternMatches];
+  const completionAcks = completionAcksForDelivery(deliveredCompletions, deliveredPatternMatches);
   const reminder = formatCombinedSystemReminder(state.pendingCompletions, state.pendingLongRunning, state.pendingPatternMatches);
   output.output = appendReminder(output.output ?? "", reminder);
   sessionLog(drainContext.sessionID, `${LOG_PREFIX} in-turn append`, {
@@ -36683,7 +36795,7 @@ async function appendInTurnBgCompletions(drainContext, output) {
   state.pendingPatternMatches = [];
   state.wakeRetryAttempts = 0;
   state.wakeHardStopped = false;
-  await ackCompletions(drainContext, deliveredCompletions);
+  await ackCompletions(drainContext, completionAcks);
   if (state.debounceTimer) {
     clearTimeout(state.debounceTimer);
     state.debounceTimer = null;
@@ -36705,86 +36817,112 @@ async function triggerWakeIfPending(drainContext, skipDrain, includeDeferredComp
   if (!hasWakeEligiblePending(state, includeDeferredCompletions))
     return;
   scheduleWake(state, async (reminder, deliveredCompletions) => {
-    let client;
-    let clientPath;
-    if (useLiveServerWake() && drainContext.serverUrl) {
-      client = getLiveServerClient(drainContext.serverUrl, drainContext.directory);
-      clientPath = "live-server";
-    } else {
+    const taskIDs = deliveredCompletions.map((completion) => completion.task_id);
+    const getInProcessClient = () => {
       if (!drainContext.client) {
         sessionWarn(drainContext.sessionID, `${LOG_PREFIX} wake client unavailable`, {
           event: "bash_completion_wake_client_unavailable",
-          task_ids: deliveredCompletions.map((c) => c.task_id),
+          task_ids: taskIDs,
           directory: drainContext.directory,
           attempt: state.wakeRetryAttempts + 1
         });
         throw new Error("no wake transport available: live-server unreachable and input.client absent");
       }
-      client = drainContext.client;
-      clientPath = "in-process-fallback";
-    }
-    if (typeof client.session?.promptAsync !== "function") {
-      throw new Error(`wake client.session.promptAsync is unavailable (path=${clientPath})`);
-    }
-    const promptContext = await resolvePromptContext(client, drainContext.sessionID);
-    const body = {
-      noReply: false,
-      parts: [{ type: "text", text: reminder }]
+      return drainContext.client;
     };
-    if (promptContext?.agent)
-      body.agent = promptContext.agent;
-    if (promptContext?.model) {
-      body.model = {
-        providerID: promptContext.model.providerID,
-        modelID: promptContext.model.modelID
+    const sendPrompt = async (client, clientPath) => {
+      if (typeof client.session?.promptAsync !== "function") {
+        throw new Error(`wake client.session.promptAsync is unavailable (path=${clientPath})`);
+      }
+      const promptContext = await resolvePromptContext(client, drainContext.sessionID);
+      const body = {
+        noReply: false,
+        parts: [{ type: "text", text: reminder }]
       };
-    }
-    if (promptContext?.variant)
-      body.variant = promptContext.variant;
-    const deliveryID = `aftdel_${randomUUID()}`;
-    const taskIDs = deliveredCompletions.map((c) => c.task_id);
-    const wakeMeta = {
-      delivery_id: deliveryID,
-      attempt: state.wakeRetryAttempts + 1,
-      task_ids: taskIDs,
-      directory: drainContext.directory,
-      reminder_sha256: hashReminder(reminder),
-      reminder_chars: reminder.length,
-      wake_client_path: clientPath,
-      prompt_context: promptContext ? {
-        agent: promptContext.agent,
-        model: promptContext.model ? {
+      if (promptContext?.agent)
+        body.agent = promptContext.agent;
+      if (promptContext?.model) {
+        body.model = {
           providerID: promptContext.model.providerID,
           modelID: promptContext.model.modelID
-        } : null,
-        variant: promptContext.variant ?? null
-      } : null
-    };
-    sessionLog(drainContext.sessionID, `${LOG_PREFIX} wake promptAsync start`, {
-      event: "bash_completion_wake_prompt_async_start",
-      ...wakeMeta
-    });
-    try {
-      await client.session.promptAsync({
-        path: { id: drainContext.sessionID },
-        body
+        };
+      }
+      if (promptContext?.variant)
+        body.variant = promptContext.variant;
+      const deliveryID2 = `aftdel_${randomUUID2()}`;
+      const wakeMeta = {
+        delivery_id: deliveryID2,
+        attempt: state.wakeRetryAttempts + 1,
+        task_ids: taskIDs,
+        directory: drainContext.directory,
+        reminder_sha256: hashReminder(reminder),
+        reminder_chars: reminder.length,
+        wake_client_path: clientPath,
+        prompt_context: promptContext ? {
+          agent: promptContext.agent,
+          model: promptContext.model ? {
+            providerID: promptContext.model.providerID,
+            modelID: promptContext.model.modelID
+          } : null,
+          variant: promptContext.variant ?? null
+        } : null
+      };
+      sessionLog(drainContext.sessionID, `${LOG_PREFIX} wake promptAsync start`, {
+        event: "bash_completion_wake_prompt_async_start",
+        ...wakeMeta
       });
-    } catch (err) {
-      sessionWarn(drainContext.sessionID, `${LOG_PREFIX} wake promptAsync error`, {
-        event: "bash_completion_wake_prompt_async_error",
-        delivery_id: deliveryID,
+      try {
+        await client.session.promptAsync({
+          path: { id: drainContext.sessionID },
+          body
+        });
+      } catch (err) {
+        sessionWarn(drainContext.sessionID, `${LOG_PREFIX} wake promptAsync error`, {
+          event: "bash_completion_wake_prompt_async_error",
+          delivery_id: deliveryID2,
+          attempt: state.wakeRetryAttempts + 1,
+          task_ids: taskIDs,
+          wake_client_path: clientPath,
+          error: err instanceof Error ? err.message : String(err)
+        });
+        throw err;
+      }
+      sessionLog(drainContext.sessionID, `${LOG_PREFIX} wake promptAsync ok`, {
+        event: "bash_completion_wake_prompt_async_ok",
+        delivery_id: deliveryID2,
         attempt: state.wakeRetryAttempts + 1,
         task_ids: taskIDs,
-        error: err instanceof Error ? err.message : String(err)
+        wake_client_path: clientPath
       });
-      throw err;
+      return deliveryID2;
+    };
+    if (useLiveServerWake(drainContext.serverUrl) && drainContext.serverUrl) {
+      try {
+        const liveClient = getLiveServerClient(drainContext.serverUrl, drainContext.directory);
+        const deliveryID2 = await sendPrompt(liveClient, "live-server");
+        await ackCompletions(drainContext, deliveredCompletions, deliveryID2);
+        return;
+      } catch (err) {
+        setLiveServerWakeAvailable(drainContext.serverUrl, false);
+        sessionWarn(drainContext.sessionID, `${LOG_PREFIX} live-server wake failed; falling back`, {
+          event: "bash_completion_wake_live_server_fallback",
+          task_ids: taskIDs,
+          directory: drainContext.directory,
+          server_url: drainContext.serverUrl,
+          attempt: state.wakeRetryAttempts + 1,
+          error: err instanceof Error ? err.message : String(err)
+        });
+        const fallbackClient2 = getInProcessClient();
+        const deliveryID2 = await sendPrompt(fallbackClient2, "in-process-fallback");
+        state.retryDelayMs = null;
+        state.wakeRetryAttempts = 0;
+        state.wakeHardStopped = false;
+        await ackCompletions(drainContext, deliveredCompletions, deliveryID2);
+        return;
+      }
     }
-    sessionLog(drainContext.sessionID, `${LOG_PREFIX} wake promptAsync ok`, {
-      event: "bash_completion_wake_prompt_async_ok",
-      delivery_id: deliveryID,
-      attempt: state.wakeRetryAttempts + 1,
-      task_ids: taskIDs
-    });
+    const fallbackClient = getInProcessClient();
+    const deliveryID = await sendPrompt(fallbackClient, "in-process-fallback");
     await ackCompletions(drainContext, deliveredCompletions, deliveryID);
   }, (err, hardStopped) => {
     sessionWarn(drainContext.sessionID, hardStopped ? `${LOG_PREFIX} wake send failed ${MAX_WAKE_SEND_ATTEMPTS} times; stopping retries: ${err instanceof Error ? err.message : String(err)}` : `${LOG_PREFIX} wake send failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -36965,7 +37103,8 @@ function scheduleWake(state, sendWake, onSendFailure, sessionID, includeDeferred
       state.wakeDeferredTaskIds.delete(taskId);
     state.pendingLongRunning = [];
     state.pendingPatternMatches = [];
-    sendWake(reminder, pending).then(() => {
+    const completionAcks = completionAcksForDelivery(pending, pendingPatternMatches);
+    sendWake(reminder, completionAcks).then(() => {
       state.retryDelayMs = null;
       state.wakeRetryAttempts = 0;
       state.wakeHardStopped = false;
@@ -37030,7 +37169,7 @@ function ingestDrainedBgCompletions(sessionID, completions) {
     state.outstandingTaskIds.delete(completion.task_id);
     if (state.explicitControlTasks.has(completion.task_id)) {
       state.explicitControlTasks.delete(completion.task_id);
-      queuePendingPatternMatch(state, completionToExitPattern(completion));
+      queuePendingPatternMatch(state, completionToExitPattern(completion, true));
       continue;
     }
     if (state.consumedTaskIds.has(completion.task_id))
@@ -37066,10 +37205,10 @@ function bufferUnknownCompletion(state, completion) {
 function pruneUnknownCompletions(state, now) {
   state.unknownCompletions = state.unknownCompletions.filter((entry) => now - entry.receivedAt <= UNKNOWN_COMPLETION_TTL_MS);
 }
-function completionToExitPattern(completion) {
+function completionToExitPattern(completion, ackCompletionOnDelivery = false) {
   const status = formatStatus(completion);
   const preview = formatOutputPreview(completion).replace(/^ {4}/gm, "").slice(-300);
-  return {
+  const entry = {
     task_id: completion.task_id,
     session_id: "",
     watch_id: "exit",
@@ -37080,6 +37219,20 @@ ${preview}` : `task ${completion.task_id} exited (${status})`,
     once: true,
     reason: "task_exit"
   };
+  if (ackCompletionOnDelivery)
+    entry.ackCompletionOnDelivery = true;
+  return entry;
+}
+function completionAcksForDelivery(completions, patternMatches) {
+  const acks = [...completions];
+  const ackedTaskIds = new Set(acks.map((completion) => completion.task_id));
+  for (const match of patternMatches) {
+    if (!match.ackCompletionOnDelivery || ackedTaskIds.has(match.task_id))
+      continue;
+    acks.push({ task_id: match.task_id, status: "unknown", exit_code: null, command: "" });
+    ackedTaskIds.add(match.task_id);
+  }
+  return acks;
 }
 function isBgCompletion(value) {
   if (!value || typeof value !== "object" || Array.isArray(value))
@@ -37147,9 +37300,9 @@ function formatDuration(completion) {
 
 // src/config.ts
 var import_comment_json = __toESM(require_src2(), 1);
-import { existsSync as existsSync6, readFileSync as readFileSync3, renameSync as renameSync3, unlinkSync as unlinkSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync7, readFileSync as readFileSync4, renameSync as renameSync4, unlinkSync as unlinkSync4, writeFileSync as writeFileSync3 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 
 // ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/external.js
 var exports_external = {};
@@ -51032,13 +51185,13 @@ function migrateExperimentalBashBlock(rawConfig, configPath, logger) {
   return movedKeys;
 }
 function migrateAftConfigFile(configPath, logger = { log: log2, warn: warn2 }) {
-  if (!existsSync6(configPath)) {
+  if (!existsSync7(configPath)) {
     return { migrated: false, oldKeys: [] };
   }
   let tmpPath = null;
   let oldKeys = [];
   try {
-    const content = readFileSync3(configPath, "utf-8");
+    const content = readFileSync4(configPath, "utf-8");
     const rawConfig = import_comment_json.parse(content);
     if (!rawConfig || typeof rawConfig !== "object" || Array.isArray(rawConfig)) {
       return { migrated: false, oldKeys: [] };
@@ -51056,7 +51209,7 @@ function migrateAftConfigFile(configPath, logger = { log: log2, warn: warn2 }) {
 ${serialized}` : serialized;
     tmpPath = `${configPath}.tmp.${process.pid}`;
     writeFileSync3(tmpPath, nextContent, "utf-8");
-    renameSync3(tmpPath, configPath);
+    renameSync4(tmpPath, configPath);
     logger.log(`Migrated config at ${configPath}: removed ${oldKeys.join(", ")}`);
     return { migrated: true, oldKeys };
   } catch (err) {
@@ -51076,10 +51229,10 @@ ${serialized}` : serialized;
 function detectConfigFile(basePath) {
   const jsoncPath = `${basePath}.jsonc`;
   const jsonPath = `${basePath}.json`;
-  if (existsSync6(jsoncPath)) {
+  if (existsSync7(jsoncPath)) {
     return { format: "jsonc", path: jsoncPath };
   }
-  if (existsSync6(jsonPath)) {
+  if (existsSync7(jsonPath)) {
     return { format: "json", path: jsonPath };
   }
   return { format: "none", path: jsonPath };
@@ -51112,10 +51265,10 @@ function parseConfigPartially(rawConfig) {
 }
 function loadConfigFromPath(configPath) {
   try {
-    if (!existsSync6(configPath)) {
+    if (!existsSync7(configPath)) {
       return null;
     }
-    const content = readFileSync3(configPath, "utf-8");
+    const content = readFileSync4(configPath, "utf-8");
     const rawConfig = import_comment_json.parse(content);
     migrateRawConfig(rawConfig, configPath, { log: log2, warn: warn2 });
     const result = AftConfigSchema.safeParse(rawConfig);
@@ -51276,17 +51429,17 @@ function getOpenCodeConfigDir() {
   if (envDir) {
     return envDir;
   }
-  const xdgConfig = process.env.XDG_CONFIG_HOME || join8(homedir5(), ".config");
-  return join8(xdgConfig, "opencode");
+  const xdgConfig = process.env.XDG_CONFIG_HOME || join9(homedir5(), ".config");
+  return join9(xdgConfig, "opencode");
 }
 function loadAftConfig(projectDirectory) {
   const configDir = getOpenCodeConfigDir();
-  const userBasePath = join8(configDir, "aft");
+  const userBasePath = join9(configDir, "aft");
   migrateAftConfigFile(`${userBasePath}.jsonc`);
   migrateAftConfigFile(`${userBasePath}.json`);
   const userDetected = detectConfigFile(userBasePath);
   const userConfigPath = userDetected.format !== "none" ? userDetected.path : `${userBasePath}.json`;
-  const projectBasePath = join8(projectDirectory, ".opencode", "aft");
+  const projectBasePath = join9(projectDirectory, ".opencode", "aft");
   migrateAftConfigFile(`${projectBasePath}.jsonc`);
   migrateAftConfigFile(`${projectBasePath}.json`);
   const projectDetected = detectConfigFile(projectBasePath);
@@ -51311,44 +51464,53 @@ function loadAftConfig(projectDirectory) {
 }
 
 // src/hooks/auto-update-checker/index.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync6, renameSync as renameSync4, writeFileSync as writeFileSync6 } from "node:fs";
-import { dirname as dirname5, join as join12 } from "node:path";
+import {
+  closeSync as closeSync3,
+  existsSync as existsSync10,
+  mkdirSync as mkdirSync7,
+  openSync as openSync3,
+  readFileSync as readFileSync7,
+  renameSync as renameSync5,
+  rmSync as rmSync4,
+  writeFileSync as writeFileSync6
+} from "node:fs";
+import { dirname as dirname6 } from "node:path";
 
 // src/hooks/auto-update-checker/cache.ts
 var import_comment_json3 = __toESM(require_src2(), 1);
 import { spawn as spawn2 } from "node:child_process";
-import { cpSync, existsSync as existsSync8, mkdtempSync, readFileSync as readFileSync5, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "node:fs";
+import { cpSync, existsSync as existsSync9, mkdtempSync, readFileSync as readFileSync6, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
-import { basename, dirname as dirname4, join as join11 } from "node:path";
+import { basename as basename2, dirname as dirname5, join as join12 } from "node:path";
 
 // src/hooks/auto-update-checker/checker.ts
 var import_comment_json2 = __toESM(require_src2(), 1);
-import { existsSync as existsSync7, readFileSync as readFileSync4, statSync as statSync3, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync8, readFileSync as readFileSync5, statSync as statSync3, writeFileSync as writeFileSync4 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
-import { dirname as dirname3, isAbsolute, join as join10, resolve as resolve2 } from "node:path";
+import { dirname as dirname4, isAbsolute, join as join11, resolve as resolve2 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/hooks/auto-update-checker/constants.ts
 import { homedir as homedir6, platform } from "node:os";
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 var PACKAGE_NAME = "@cortexkit/aft-opencode";
 var NPM_REGISTRY_URL = "https://registry.npmjs.org";
 var NPM_FETCH_TIMEOUT = 1e4;
 function getOpenCodeCacheRoot() {
   if (platform() === "win32") {
-    return join9(process.env.LOCALAPPDATA ?? homedir6(), "opencode");
+    return join10(process.env.LOCALAPPDATA ?? homedir6(), "opencode");
   }
-  return join9(homedir6(), ".cache", "opencode");
+  return join10(homedir6(), ".cache", "opencode");
 }
 function getOpenCodeConfigRoot() {
   if (platform() === "win32") {
-    return join9(process.env.APPDATA ?? join9(homedir6(), "AppData", "Roaming"), "opencode");
+    return join10(process.env.APPDATA ?? join10(homedir6(), "AppData", "Roaming"), "opencode");
   }
-  return join9(process.env.XDG_CONFIG_HOME ?? join9(homedir6(), ".config"), "opencode");
+  return join10(process.env.XDG_CONFIG_HOME ?? join10(homedir6(), ".config"), "opencode");
 }
-var CACHE_DIR = join9(getOpenCodeCacheRoot(), "packages");
-var USER_OPENCODE_CONFIG = join9(getOpenCodeConfigRoot(), "opencode.json");
-var USER_OPENCODE_CONFIG_JSONC = join9(getOpenCodeConfigRoot(), "opencode.jsonc");
+var CACHE_DIR = join10(getOpenCodeCacheRoot(), "packages");
+var USER_OPENCODE_CONFIG = join10(getOpenCodeConfigRoot(), "opencode.json");
+var USER_OPENCODE_CONFIG_JSONC = join10(getOpenCodeConfigRoot(), "opencode.jsonc");
 
 // src/hooks/auto-update-checker/types.ts
 var NpmPackageEnvelopeSchema = exports_external.object({
@@ -51406,8 +51568,8 @@ function extractChannel(version2) {
 }
 function getConfigPaths(directory) {
   return [
-    join10(directory, ".opencode", "opencode.json"),
-    join10(directory, ".opencode", "opencode.jsonc"),
+    join11(directory, ".opencode", "opencode.json"),
+    join11(directory, ".opencode", "opencode.jsonc"),
     USER_OPENCODE_CONFIG,
     USER_OPENCODE_CONFIG_JSONC
   ];
@@ -51422,14 +51584,14 @@ function resolvePathPluginSpec(spec, configPath) {
   }
   if (isAbsolute(spec) || /^[A-Za-z]:[\\/]/.test(spec))
     return spec;
-  return resolve2(dirname3(configPath), spec);
+  return resolve2(dirname4(configPath), spec);
 }
 function getLocalDevPath(directory) {
   for (const configPath of getConfigPaths(directory)) {
     try {
-      if (!existsSync7(configPath))
+      if (!existsSync8(configPath))
         continue;
-      const rawConfig = parseJsonConfig(readFileSync4(configPath, "utf-8"));
+      const rawConfig = parseJsonConfig(readFileSync5(configPath, "utf-8"));
       const plugins = getPluginEntries(rawConfig);
       for (const entry of plugins) {
         if (entry === PACKAGE_NAME || entry.startsWith(`${PACKAGE_NAME}@`))
@@ -51439,7 +51601,7 @@ function getLocalDevPath(directory) {
           const pkgPath = findPackageJsonUp(localPath);
           if (!pkgPath)
             continue;
-          const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync4(pkgPath, "utf-8")));
+          const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync5(pkgPath, "utf-8")));
           if (pkg.success && pkg.data.name === PACKAGE_NAME)
             return localPath;
         }
@@ -51451,17 +51613,17 @@ function getLocalDevPath(directory) {
 function findPackageJsonUp(startPath) {
   try {
     const stat = statSync3(startPath);
-    let dir = stat.isDirectory() ? startPath : dirname3(startPath);
+    let dir = stat.isDirectory() ? startPath : dirname4(startPath);
     for (let i = 0;i < 10; i++) {
-      const pkgPath = join10(dir, "package.json");
-      if (existsSync7(pkgPath)) {
+      const pkgPath = join11(dir, "package.json");
+      if (existsSync8(pkgPath)) {
         try {
-          const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync4(pkgPath, "utf-8")));
+          const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync5(pkgPath, "utf-8")));
           if (pkg.success && pkg.data.name === PACKAGE_NAME)
             return pkgPath;
         } catch {}
       }
-      const parent = dirname3(dir);
+      const parent = dirname4(dir);
       if (parent === dir)
         break;
       dir = parent;
@@ -51477,7 +51639,7 @@ function getLocalDevVersion(directory) {
     const pkgPath = findPackageJsonUp(localPath);
     if (!pkgPath)
       return null;
-    const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync4(pkgPath, "utf-8")));
+    const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync5(pkgPath, "utf-8")));
     return pkg.success ? pkg.data.version ?? null : null;
   } catch {
     return null;
@@ -51485,7 +51647,7 @@ function getLocalDevVersion(directory) {
 }
 function getCurrentRuntimePackageJsonPath(currentModuleUrl = import.meta.url) {
   try {
-    return findPackageJsonUp(dirname3(fileURLToPath(currentModuleUrl)));
+    return findPackageJsonUp(dirname4(fileURLToPath(currentModuleUrl)));
   } catch (err) {
     warn2(`[auto-update-checker] Failed to resolve runtime package path: ${String(err)}`);
     return null;
@@ -51494,9 +51656,9 @@ function getCurrentRuntimePackageJsonPath(currentModuleUrl = import.meta.url) {
 function findPluginEntry(directory) {
   for (const configPath of getConfigPaths(directory)) {
     try {
-      if (!existsSync7(configPath))
+      if (!existsSync8(configPath))
         continue;
-      const rawConfig = parseJsonConfig(readFileSync4(configPath, "utf-8"));
+      const rawConfig = parseJsonConfig(readFileSync5(configPath, "utf-8"));
       const plugins = getPluginEntries(rawConfig);
       for (const entry of plugins) {
         if (entry === PACKAGE_NAME) {
@@ -51514,7 +51676,7 @@ function findPluginEntry(directory) {
 }
 var cachedPackageVersion = null;
 function getSpecCachePackageJsonPath(spec) {
-  return join10(CACHE_DIR, spec, "node_modules", PACKAGE_NAME, "package.json");
+  return join11(CACHE_DIR, spec, "node_modules", PACKAGE_NAME, "package.json");
 }
 function getCachedVersion(spec) {
   if (!spec && cachedPackageVersion)
@@ -51523,13 +51685,13 @@ function getCachedVersion(spec) {
     getCurrentRuntimePackageJsonPath(),
     spec ? getSpecCachePackageJsonPath(spec) : null,
     getSpecCachePackageJsonPath(`${PACKAGE_NAME}@latest`),
-    join10(homedir7(), ".cache", "opencode", "node_modules", PACKAGE_NAME, "package.json")
+    join11(homedir7(), ".cache", "opencode", "node_modules", PACKAGE_NAME, "package.json")
   ].filter(isString);
   for (const packageJsonPath of candidates) {
     try {
-      if (!existsSync7(packageJsonPath))
+      if (!existsSync8(packageJsonPath))
         continue;
-      const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync4(packageJsonPath, "utf-8")));
+      const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync5(packageJsonPath, "utf-8")));
       if (pkg.success && pkg.data.version) {
         if (!spec)
           cachedPackageVersion = pkg.data.version;
@@ -51571,17 +51733,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 = 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;
+  const packageDir = join12(installDir, "node_modules", packageName);
+  const lockfilePath = join12(installDir, "package-lock.json");
+  const tempDir = mkdtempSync(join12(tmpdir3(), "aft-auto-update-"));
+  const stagedPackageDir = existsSync9(packageDir) ? join12(tempDir, "package") : null;
   if (stagedPackageDir)
     cpSync(packageDir, stagedPackageDir, { recursive: true });
   return {
     packageJsonPath,
-    packageJson: existsSync8(packageJsonPath) ? readFileSync5(packageJsonPath, "utf-8") : null,
+    packageJson: existsSync9(packageJsonPath) ? readFileSync6(packageJsonPath, "utf-8") : null,
     lockfilePath,
-    lockfile: existsSync8(lockfilePath) ? readFileSync5(lockfilePath, "utf-8") : null,
+    lockfile: existsSync9(lockfilePath) ? readFileSync6(lockfilePath, "utf-8") : null,
     packageDir,
     stagedPackageDir,
     tempDir
@@ -51608,18 +51770,18 @@ function restoreAutoUpdateSnapshot(snapshot) {
 function stripPackageNameFromPath(pathValue, packageName) {
   let current = pathValue;
   for (const segment of [...packageName.split("/")].reverse()) {
-    if (basename(current) !== segment)
+    if (basename2(current) !== segment)
       return null;
-    current = dirname4(current);
+    current = dirname5(current);
   }
   return current;
 }
 function removeFromPackageLock(installDir, packageName) {
-  const lockPath = join11(installDir, "package-lock.json");
-  if (!existsSync8(lockPath))
+  const lockPath = join12(installDir, "package-lock.json");
+  if (!existsSync9(lockPath))
     return false;
   try {
-    const lock = import_comment_json3.parse(readFileSync5(lockPath, "utf-8"));
+    const lock = import_comment_json3.parse(readFileSync6(lockPath, "utf-8"));
     let modified = false;
     if (lock.packages) {
       const key = `node_modules/${packageName}`;
@@ -51642,10 +51804,10 @@ function removeFromPackageLock(installDir, packageName) {
   }
 }
 function ensureDependencyVersion(packageJsonPath, packageName, version2) {
-  if (!existsSync8(packageJsonPath))
+  if (!existsSync9(packageJsonPath))
     return false;
   try {
-    const raw = import_comment_json3.parse(readFileSync5(packageJsonPath, "utf-8"));
+    const raw = import_comment_json3.parse(readFileSync6(packageJsonPath, "utf-8"));
     const pkgJson = PackageJsonSchema.safeParse(raw);
     if (!pkgJson.success)
       return false;
@@ -51664,8 +51826,8 @@ function ensureDependencyVersion(packageJsonPath, packageName, version2) {
   }
 }
 function removeInstalledPackage(installDir, packageName) {
-  const packageDir = join11(installDir, "node_modules", packageName);
-  if (!existsSync8(packageDir))
+  const packageDir = join12(installDir, "node_modules", packageName);
+  if (!existsSync9(packageDir))
     return false;
   rmSync3(packageDir, { recursive: true, force: true });
   log2(`[auto-update-checker] Package removed: ${packageDir}`);
@@ -51673,19 +51835,19 @@ function removeInstalledPackage(installDir, packageName) {
 }
 function resolveInstallContext(runtimePackageJsonPath = getCurrentRuntimePackageJsonPath()) {
   if (runtimePackageJsonPath) {
-    const packageDir = dirname4(runtimePackageJsonPath);
+    const packageDir = dirname5(runtimePackageJsonPath);
     const nodeModulesDir = stripPackageNameFromPath(packageDir, PACKAGE_NAME);
-    if (nodeModulesDir && basename(nodeModulesDir) === "node_modules") {
-      const installDir = dirname4(nodeModulesDir);
-      const packageJsonPath = join11(installDir, "package.json");
-      if (existsSync8(packageJsonPath))
+    if (nodeModulesDir && basename2(nodeModulesDir) === "node_modules") {
+      const installDir = dirname5(nodeModulesDir);
+      const packageJsonPath = join12(installDir, "package.json");
+      if (existsSync9(packageJsonPath))
         return { installDir, packageJsonPath };
     }
     return null;
   }
-  const legacyPackageJsonPath = join11(dirname4(CACHE_DIR), "package.json");
-  if (existsSync8(legacyPackageJsonPath)) {
-    return { installDir: dirname4(CACHE_DIR), packageJsonPath: legacyPackageJsonPath };
+  const legacyPackageJsonPath = join12(dirname5(CACHE_DIR), "package.json");
+  if (existsSync9(legacyPackageJsonPath)) {
+    return { installDir: dirname5(CACHE_DIR), packageJsonPath: legacyPackageJsonPath };
   }
   return null;
 }
@@ -51714,15 +51876,25 @@ function preparePackageUpdate(version2, packageName = PACKAGE_NAME, runtimePacka
     return null;
   }
 }
+var STDERR_TAIL_BYTES = 16 * 1024;
 async function runNpmInstallSafe(installDir, options = {}) {
   let timeout = null;
+  let stderrTail = "";
   try {
     if (options.signal?.aborted)
-      return false;
-    const proc = spawn2("npm", ["install", "--no-audit", "--no-fund", "--no-progress"], {
+      return { ok: false, reason: "aborted" };
+    const npmBin = process.platform === "win32" ? "npm.cmd" : "npm";
+    const proc = spawn2(npmBin, ["install", "--no-audit", "--no-fund", "--no-progress", "--ignore-scripts"], {
       cwd: installDir,
-      stdio: "ignore"
+      stdio: ["ignore", "pipe", "pipe"]
     });
+    proc.stderr?.on("data", (chunk) => {
+      stderrTail += chunk.toString("utf8");
+      if (stderrTail.length > STDERR_TAIL_BYTES) {
+        stderrTail = stderrTail.slice(-STDERR_TAIL_BYTES);
+      }
+    });
+    proc.stdout?.on("data", () => {});
     const abortProcess = () => {
       try {
         proc.kill();
@@ -51730,8 +51902,8 @@ async function runNpmInstallSafe(installDir, options = {}) {
     };
     options.signal?.addEventListener("abort", abortProcess, { once: true });
     const exitPromise = new Promise((resolveExit) => {
-      proc.on("error", () => resolveExit(false));
-      proc.on("exit", (code) => resolveExit(code === 0));
+      proc.on("error", (err) => resolveExit({ ok: false, reason: `spawn error: ${String(err)}` }));
+      proc.on("exit", (code) => resolveExit(code === 0 ? { ok: true } : { ok: false, reason: `npm install exited with code ${code ?? "signal/unknown"}` }));
     });
     const timeoutPromise = new Promise((resolveTimeout) => {
       timeout = setTimeout(() => resolveTimeout("timeout"), options.timeoutMs ?? 60000);
@@ -51745,29 +51917,41 @@ async function runNpmInstallSafe(installDir, options = {}) {
         pendingSnapshots.delete(installDir);
         restoreAutoUpdateSnapshot(snapshot2);
       }
-      return false;
+      const reason = options.signal?.aborted ? "aborted" : "timeout";
+      warnNpmInstallFailure(reason, stderrTail);
+      return { ok: false, reason, stderrTail: stderrTail || undefined };
     }
     const snapshot = pendingSnapshots.get(installDir);
     pendingSnapshots.delete(installDir);
-    if (!result && snapshot) {
+    if (!result.ok && snapshot) {
       restoreAutoUpdateSnapshot(snapshot);
     } else if (snapshot) {
       rmSync3(snapshot.tempDir, { recursive: true, force: true });
     }
-    return result;
+    if (!result.ok) {
+      warnNpmInstallFailure(result.reason ?? "npm install failed", stderrTail);
+    }
+    return { ...result, stderrTail: stderrTail || undefined };
   } catch (err) {
     const snapshot = pendingSnapshots.get(installDir);
     if (snapshot) {
       pendingSnapshots.delete(installDir);
       restoreAutoUpdateSnapshot(snapshot);
     }
-    warn2(`[auto-update-checker] npm install error: ${String(err)}`);
-    return false;
+    const reason = `exception: ${String(err)}`;
+    warnNpmInstallFailure(reason, stderrTail);
+    return { ok: false, reason, stderrTail: stderrTail || undefined };
   } finally {
     if (timeout)
       clearTimeout(timeout);
   }
 }
+function warnNpmInstallFailure(reason, stderrTail) {
+  const tail2 = stderrTail ? `
+stderr tail:
+${stderrTail}` : "";
+  warn2(`[auto-update-checker] npm install failed (${reason})${tail2}`);
+}
 
 // src/hooks/auto-update-checker/index.ts
 var DEFAULT_CHECK_INTERVAL_MS = 60 * 60 * 1000;
@@ -51813,36 +51997,76 @@ function createAutoUpdateCheckerHook(ctx, options = {}) {
 async function maybeRunCheck(ctx, options) {
   if (options.signal.aborted)
     return;
-  if (!claimCheckSlot(options.storageDir, options.checkIntervalMs)) {
+  const checkSlot = claimCheckSlot(options.storageDir, options.checkIntervalMs);
+  if (!checkSlot) {
     log2("[auto-update-checker] Skipping check (another instance ran one recently)");
     return;
   }
-  await runStartupCheck(ctx, options);
+  try {
+    await runStartupCheck(ctx, options);
+  } finally {
+    checkSlot.release();
+  }
 }
 function claimCheckSlot(storageDir, intervalMs) {
   if (!storageDir)
-    return true;
+    return { release: () => {} };
+  const file2 = repairRootScopedStorageFile(storageDir, "opencode", TIMESTAMP_FILENAME);
   try {
-    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;
-        if (Number.isFinite(last) && Date.now() - last < intervalMs) {
-          return false;
-        }
-      } catch {}
+    if (hasRecentCheckTimestamp(file2, intervalMs))
+      return null;
+    mkdirSync7(dirname6(file2), { recursive: true });
+    const lockPath = `${file2}.lock`;
+    let lockFd;
+    try {
+      lockFd = openSync3(lockPath, "wx");
+      writeFileSync6(lockFd, JSON.stringify({ pid: process.pid, startedMs: Date.now() }));
+    } catch (err) {
+      if (err.code !== "EEXIST") {
+        warn2(`[auto-update-checker] Could not acquire update lock: ${String(err)}`);
+      }
+      return null;
+    }
+    const lock = {
+      release: () => {
+        try {
+          closeSync3(lockFd);
+        } catch {}
+        rmSync4(lockPath, { force: true });
+      }
+    };
+    try {
+      if (hasRecentCheckTimestamp(file2, intervalMs)) {
+        lock.release();
+        return null;
+      }
+      writeCheckTimestamp(file2);
+      return lock;
+    } catch (err) {
+      lock.release();
+      throw err;
     }
-    mkdirSync6(dirname5(file2), { recursive: true });
-    const tmp = `${file2}.tmp.${process.pid}`;
-    writeFileSync6(tmp, JSON.stringify({ lastCheckedMs: Date.now() }), "utf-8");
-    renameSync4(tmp, file2);
-    return true;
   } catch (err) {
     warn2(`[auto-update-checker] Could not coordinate via timestamp file: ${String(err)}`);
-    return true;
+    return null;
   }
 }
+function hasRecentCheckTimestamp(file2, intervalMs) {
+  if (!existsSync10(file2))
+    return false;
+  try {
+    const raw = JSON.parse(readFileSync7(file2, "utf-8"));
+    const last = typeof raw.lastCheckedMs === "number" ? raw.lastCheckedMs : 0;
+    return Number.isFinite(last) && Date.now() - last < intervalMs;
+  } catch {
+    return false;
+  }
+}
+function writeCheckTimestamp(file2) {
+  const tmp = `${file2}.tmp.${process.pid}`;
+  writeFileSync6(tmp, JSON.stringify({ lastCheckedMs: Date.now() }), "utf-8");
+  renameSync5(tmp, file2);
+}
 async function runStartupCheck(ctx, options) {
   if (options.signal.aborted)
     return;
@@ -51907,32 +52131,39 @@ async function runBackgroundUpdateCheck(ctx, options) {
     warn2("[auto-update-checker] Failed to prepare install root for auto-update");
     return;
   }
-  const installSuccess = await runNpmInstallSafe(installDir, { signal: options.signal });
-  if (installSuccess) {
+  const installResult = await runNpmInstallSafe(installDir, { signal: options.signal });
+  if (installResult.ok) {
     showToast(ctx, "AFT Updated!", `v${currentVersion} → v${latestVersion}
 Restart OpenCode to apply.`, "success", 8000);
     log2(`[auto-update-checker] Update installed: ${currentVersion} → ${latestVersion}`);
     return;
   }
   showToast(ctx, `AFT ${latestVersion}`, `v${latestVersion} available, but auto-update failed to install it. Check logs or retry manually.`, "error", 8000);
-  warn2("[auto-update-checker] npm install failed; update not installed");
+  const failureDetail = installResult.reason ? `: ${installResult.reason}` : "";
+  const stderrDetail = installResult.stderrTail ? `
+stderr tail:
+${installResult.stderrTail}` : "";
+  warn2(`[auto-update-checker] npm install failed; update not installed${failureDetail}${stderrDetail}`);
 }
 function showToast(ctx, title, message, variant = "info", duration3 = 3000) {
-  ctx.client.tui.showToast({ body: { title, message, variant, duration: duration3 } }).catch(() => {});
+  const tui = ctx.client.tui;
+  if (typeof tui?.showToast !== "function")
+    return;
+  tui.showToast({ body: { title, message, variant, duration: duration3 } }).catch(() => {});
 }
 
 // src/lsp-auto-install.ts
 import { spawn as spawn3 } from "node:child_process";
 import { createHash as createHash5 } from "node:crypto";
-import { createReadStream, mkdirSync as mkdirSync8, readFileSync as readFileSync9, renameSync as renameSync5, rmSync as rmSync4, statSync as statSync5 } from "node:fs";
+import { createReadStream, mkdirSync as mkdirSync9, readFileSync as readFileSync10, renameSync as renameSync6, rmSync as rmSync5, statSync as statSync5 } from "node:fs";
 import { join as join15 } from "node:path";
 
 // src/lsp-cache.ts
 import {
-  closeSync as closeSync3,
-  mkdirSync as mkdirSync7,
-  openSync as openSync3,
-  readFileSync as readFileSync7,
+  closeSync as closeSync4,
+  mkdirSync as mkdirSync8,
+  openSync as openSync4,
+  readFileSync as readFileSync8,
   statSync as statSync4,
   unlinkSync as unlinkSync5,
   writeFileSync as writeFileSync7
@@ -51980,7 +52211,7 @@ function lspBinaryCandidates(binary) {
 var INSTALLED_META_FILE = ".aft-installed";
 function writeInstalledMetaIn(installDir, version2, sha256) {
   try {
-    mkdirSync7(installDir, { recursive: true });
+    mkdirSync8(installDir, { recursive: true });
     const meta3 = {
       version: version2,
       installedAt: new Date().toISOString(),
@@ -51996,7 +52227,7 @@ function readInstalledMetaIn(installDir) {
   try {
     if (!statSync4(path2).isFile())
       return null;
-    const raw = readFileSync7(path2, "utf8");
+    const raw = readFileSync8(path2, "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.version !== "string" || parsed.version.length === 0)
       return null;
@@ -52020,17 +52251,17 @@ function lockPath(npmPackage) {
 }
 var STALE_LOCK_MS2 = 30 * 60 * 1000;
 function acquireInstallLock(lockKey) {
-  mkdirSync7(lspPackageDir(lockKey), { recursive: true });
+  mkdirSync8(lspPackageDir(lockKey), { recursive: true });
   const lock = lockPath(lockKey);
   const tryClaim = () => {
     try {
-      const fd = openSync3(lock, "wx");
+      const fd = openSync4(lock, "wx");
       try {
         writeFileSync7(fd, `${process.pid}
 ${new Date().toISOString()}
 `);
       } finally {
-        closeSync3(fd);
+        closeSync4(fd);
       }
       return true;
     } catch (err) {
@@ -52046,7 +52277,7 @@ ${new Date().toISOString()}
   let owningPid = null;
   let lockMtimeMs = 0;
   try {
-    const raw = readFileSync7(lock, "utf8");
+    const raw = readFileSync8(lock, "utf8");
     const firstLine = raw.split(/\r?\n/, 1)[0]?.trim() ?? "";
     const parsed = Number.parseInt(firstLine, 10);
     if (Number.isFinite(parsed) && parsed > 0)
@@ -52084,7 +52315,7 @@ function releaseInstallLock(lockKey) {
   try {
     let owningPid = null;
     try {
-      const raw = readFileSync7(lock, "utf8");
+      const raw = readFileSync8(lock, "utf8");
       const firstLine = raw.split(/\r?\n/, 1)[0]?.trim() ?? "";
       const parsed = Number.parseInt(firstLine, 10);
       if (Number.isFinite(parsed) && parsed > 0)
@@ -52125,7 +52356,7 @@ var VERSION_CHECK_FILE = ".aft-version-check";
 function readVersionCheck(npmPackage) {
   const file2 = join13(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
   try {
-    const raw = readFileSync7(file2, "utf8");
+    const raw = readFileSync8(file2, "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.last_checked === "string") {
       return {
@@ -52139,7 +52370,7 @@ function readVersionCheck(npmPackage) {
   }
 }
 function writeVersionCheck(npmPackage, latest) {
-  mkdirSync7(lspPackageDir(npmPackage), { recursive: true });
+  mkdirSync8(lspPackageDir(npmPackage), { recursive: true });
   const file2 = join13(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
   const record2 = {
     last_checked: new Date().toISOString(),
@@ -52302,7 +52533,7 @@ var NPM_LSP_TABLE = [
 ];
 
 // src/lsp-project-relevance.ts
-import { existsSync as existsSync10, readdirSync as readdirSync3, readFileSync as readFileSync8 } from "node:fs";
+import { existsSync as existsSync11, readdirSync as readdirSync3, readFileSync as readFileSync9 } from "node:fs";
 import { join as join14 } from "node:path";
 var MAX_WALK_DIRS = 200;
 var MAX_WALK_DEPTH = 4;
@@ -52320,7 +52551,7 @@ function hasRootMarker(projectRoot, rootMarkers) {
   if (!rootMarkers)
     return false;
   for (const marker of rootMarkers) {
-    if (existsSync10(join14(projectRoot, marker)))
+    if (existsSync11(join14(projectRoot, marker)))
       return true;
   }
   return false;
@@ -52344,7 +52575,7 @@ function hasPackageJsonDep(projectRoot, depNames) {
 }
 function readPackageJson(projectRoot) {
   try {
-    const raw = readFileSync8(join14(projectRoot, "package.json"), "utf8");
+    const raw = readFileSync9(join14(projectRoot, "package.json"), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null)
       return null;
@@ -52671,16 +52902,16 @@ function installedBinaryPath(spec) {
   return null;
 }
 function sha256OfFileSync(path2) {
-  return createHash5("sha256").update(readFileSync9(path2)).digest("hex");
+  return createHash5("sha256").update(readFileSync10(path2)).digest("hex");
 }
 function quarantineCachedNpmInstall(spec, reason) {
   const packageDir = lspPackageDir(spec.npm);
   const dest = join15(packageDir, "..", ".quarantine", encodeURIComponent(spec.npm), `${Date.now()}`);
   warn2(`[lsp] tofu_mismatch ${spec.npm}: ${reason}; quarantining ${packageDir} -> ${dest}`);
   try {
-    mkdirSync8(join15(dest, ".."), { recursive: true });
-    rmSync4(dest, { recursive: true, force: true });
-    renameSync5(packageDir, dest);
+    mkdirSync9(join15(dest, ".."), { recursive: true });
+    rmSync5(dest, { recursive: true, force: true });
+    renameSync6(packageDir, dest);
   } catch (err) {
     warn2(`[lsp] tofu_mismatch ${spec.npm}: failed to quarantine cache entry: ${err}`);
   }
@@ -52756,25 +52987,25 @@ function runAutoInstall(projectRoot, config2, fetchImpl2 = fetch) {
 
 // src/lsp-github-install.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { createHash as createHash6, randomBytes } from "node:crypto";
+import { createHash as createHash6, randomBytes as randomBytes2 } from "node:crypto";
 import {
   copyFileSync as copyFileSync3,
   createReadStream as createReadStream2,
   createWriteStream as createWriteStream3,
-  existsSync as existsSync11,
+  existsSync as existsSync12,
   lstatSync as lstatSync2,
-  mkdirSync as mkdirSync9,
+  mkdirSync as mkdirSync10,
   readdirSync as readdirSync4,
-  readFileSync as readFileSync10,
+  readFileSync as readFileSync11,
   readlinkSync as readlinkSync2,
   realpathSync as realpathSync3,
-  renameSync as renameSync6,
-  rmSync as rmSync5,
+  renameSync as renameSync7,
+  rmSync as rmSync6,
   statSync as statSync6,
   unlinkSync as unlinkSync6,
   writeFileSync as writeFileSync8
 } from "node:fs";
-import { dirname as dirname6, join as join16, relative as relative2, resolve as resolve3 } from "node:path";
+import { dirname as dirname7, join as join16, relative as relative2, resolve as resolve3 } from "node:path";
 import { Readable as Readable3 } from "node:stream";
 import { pipeline as pipeline3 } from "node:stream/promises";
 
@@ -52899,7 +53130,7 @@ function readGithubInstalledMetaIn(installDir) {
     const path2 = join16(installDir, INSTALLED_META_FILE2);
     if (!statSync6(path2).isFile())
       return null;
-    const parsed = JSON.parse(readFileSync10(path2, "utf8"));
+    const parsed = JSON.parse(readFileSync11(path2, "utf8"));
     if (typeof parsed.version !== "string" || parsed.version.length === 0)
       return null;
     return {
@@ -52915,7 +53146,7 @@ function readGithubInstalledMetaIn(installDir) {
 }
 function writeGithubInstalledMetaIn(installDir, version2, binarySha256, archiveSha256) {
   try {
-    mkdirSync9(installDir, { recursive: true });
+    mkdirSync10(installDir, { recursive: true });
     const meta3 = {
       version: version2,
       installedAt: new Date().toISOString(),
@@ -52940,7 +53171,7 @@ function sha256OfFile(path2) {
   });
 }
 function sha256OfFileSync2(path2) {
-  return createHash6("sha256").update(readFileSync10(path2)).digest("hex");
+  return createHash6("sha256").update(readFileSync11(path2)).digest("hex");
 }
 async function fetchReleaseByTag(githubRepo, tag, fetchImpl2, signal) {
   const candidates = [];
@@ -53116,7 +53347,7 @@ async function downloadFile(url2, destPath, fetchImpl2, assetSize, signal) {
     if (Number.isFinite(advertised) && advertised > MAX_DOWNLOAD_BYTES3) {
       throw new Error(`Content-Length ${advertised} exceeds max ${MAX_DOWNLOAD_BYTES3}`);
     }
-    mkdirSync9(dirname6(destPath), { recursive: true });
+    mkdirSync10(dirname7(destPath), { recursive: true });
     let bytesWritten = 0;
     const guard = new TransformStream({
       transform(chunk, controller) {
@@ -53237,23 +53468,23 @@ function precheckArchiveContents(archivePath, archiveType) {
   }
 }
 function extractArchiveSafely(archivePath, destDir, archiveType) {
-  const suffix = randomBytes(8).toString("hex");
+  const suffix = randomBytes2(8).toString("hex");
   const stagingDir = `${destDir}.staging-${suffix}`;
   try {
-    rmSync5(stagingDir, { recursive: true, force: true });
+    rmSync6(stagingDir, { recursive: true, force: true });
   } catch {}
-  mkdirSync9(stagingDir, { recursive: true });
+  mkdirSync10(stagingDir, { recursive: true });
   try {
     precheckArchiveContents(archivePath, archiveType);
     runPlatformExtractor(archivePath, stagingDir, archiveType);
     validateExtraction(stagingDir);
     try {
-      rmSync5(destDir, { recursive: true, force: true });
+      rmSync6(destDir, { recursive: true, force: true });
     } catch {}
-    renameSync6(stagingDir, destDir);
+    renameSync7(stagingDir, destDir);
   } catch (err) {
     try {
-      rmSync5(stagingDir, { recursive: true, force: true });
+      rmSync6(stagingDir, { recursive: true, force: true });
     } catch {}
     throw err;
   }
@@ -53263,9 +53494,9 @@ function quarantineCachedGithubInstall(spec, reason) {
   const dest = join16(ghCacheRoot(), ".quarantine", encodeURIComponent(spec.id), `${Date.now()}`);
   warn2(`[lsp] tofu_mismatch ${spec.id}: ${reason}; quarantining ${packageDir} -> ${dest}`);
   try {
-    mkdirSync9(dirname6(dest), { recursive: true });
-    rmSync5(dest, { recursive: true, force: true });
-    renameSync6(packageDir, dest);
+    mkdirSync10(dirname7(dest), { recursive: true });
+    rmSync6(dest, { recursive: true, force: true });
+    renameSync7(packageDir, dest);
   } catch (err) {
     warn2(`[lsp] tofu_mismatch ${spec.id}: failed to quarantine cache entry: ${err}`);
   }
@@ -53392,12 +53623,12 @@ async function downloadAndInstall(spec, tag, assets, platform2, arch, fetchImpl2
     } catch {}
   }
   const innerBinaryPath = join16(extractDir, spec.binaryPathInArchive(platform2, arch, version2));
-  if (!existsSync11(innerBinaryPath)) {
+  if (!existsSync12(innerBinaryPath)) {
     error2(`[lsp] ${spec.id}: extracted binary not found at ${innerBinaryPath}`);
     return null;
   }
   const targetBinary = ghBinaryPath(spec, platform2);
-  mkdirSync9(dirname6(targetBinary), { recursive: true });
+  mkdirSync10(dirname7(targetBinary), { recursive: true });
   try {
     copyFileSync3(innerBinaryPath, targetBinary);
     if (platform2 !== "win32") {
@@ -53476,7 +53707,7 @@ function runGithubAutoInstall(relevantServers, config2, fetchImpl2 = fetch) {
   if (!host) {
     for (const spec of GITHUB_LSP_TABLE) {
       try {
-        if (existsSync11(ghBinDir(spec))) {
+        if (existsSync12(ghBinDir(spec))) {
           cachedBinDirs.push(ghBinDir(spec));
         }
       } catch {}
@@ -53639,9 +53870,9 @@ function normalizeToolMap(tools) {
 }
 
 // src/notifications.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync10, readFileSync as readFileSync11, writeFileSync as writeFileSync9 } from "node:fs";
+import { existsSync as existsSync13, mkdirSync as mkdirSync11, readFileSync as readFileSync12, writeFileSync as writeFileSync9 } from "node:fs";
 import { homedir as homedir9, platform as platform2 } from "node:os";
-import { join as join17 } from "node:path";
+import { dirname as dirname8, join as join17 } from "node:path";
 function isTuiMode() {
   return process.env.OPENCODE_CLIENT === "cli";
 }
@@ -53676,13 +53907,13 @@ function getDesktopStatePath() {
   }
   return null;
 }
-function readDesktopState(directory) {
+function readDesktopState() {
   const statePath = getDesktopStatePath();
-  if (!statePath || !existsSync12(statePath)) {
-    return { sessionId: null, serverUrl: null };
+  if (!statePath || !existsSync13(statePath)) {
+    return { serverUrl: null };
   }
   try {
-    const raw = readFileSync11(statePath, "utf-8");
+    const raw = readFileSync12(statePath, "utf-8");
     const state = JSON.parse(raw);
     let serverUrl = null;
     const serverStr = state.server;
@@ -53694,19 +53925,43 @@ function readDesktopState(directory) {
         }
       } catch {}
     }
-    let sessionId = null;
-    const layoutPage = state["layout.page"];
-    if (typeof layoutPage === "string") {
-      const parsed = JSON.parse(layoutPage);
-      const lastProjectSession = parsed.lastProjectSession;
-      if (lastProjectSession) {
-        const entry = lastProjectSession[directory];
-        sessionId = entry?.id ?? null;
-      }
-    }
-    return { sessionId, serverUrl };
+    return { serverUrl };
   } catch {
-    return { sessionId: null, serverUrl: null };
+    return { serverUrl: null };
+  }
+}
+var MAX_PENDING_DESKTOP_NOTIFICATIONS = 20;
+var pendingDesktopNotifications = new Map;
+function getExplicitSessionId(opts) {
+  const sessionId = opts.sessionId?.trim();
+  return sessionId ? sessionId : null;
+}
+function enqueuePendingDesktopNotification(directory, notification) {
+  if (!directory)
+    return;
+  const pending = pendingDesktopNotifications.get(directory) ?? [];
+  if (pending.some((item) => item.key === notification.key))
+    return;
+  pending.push(notification);
+  if (pending.length > MAX_PENDING_DESKTOP_NOTIFICATIONS) {
+    pending.splice(0, pending.length - MAX_PENDING_DESKTOP_NOTIFICATIONS);
+  }
+  pendingDesktopNotifications.set(directory, pending);
+}
+async function flushPendingDesktopNotifications(opts, sessionId) {
+  const pending = pendingDesktopNotifications.get(opts.directory);
+  if (!pending?.length)
+    return;
+  pendingDesktopNotifications.delete(opts.directory);
+  for (const notification of pending) {
+    if (notification.shouldSkip?.())
+      continue;
+    const delivered = await sendIgnoredMessage(opts.client, sessionId, notification.text);
+    if (delivered) {
+      notification.onDelivered?.();
+    } else {
+      enqueuePendingDesktopNotification(opts.directory, notification);
+    }
   }
 }
 function getServerAuth() {
@@ -53771,52 +54026,72 @@ async function sendWarning(opts, message) {
   const toastSent = await showTuiToast(opts.client, "AFT Warning", message, "warning", 1e4);
   if (toastSent)
     return;
-  const { sessionId } = readDesktopState(opts.directory);
-  if (!sessionId)
-    return;
   const text = `${WARNING_MARKER} ${message}`;
+  const sessionId = getExplicitSessionId(opts);
+  if (!sessionId) {
+    enqueuePendingDesktopNotification(opts.directory, { key: `warning:${message}`, text });
+    return;
+  }
+  await flushPendingDesktopNotifications(opts, sessionId);
   sessionLog(sessionId, `[aft-plugin] sending warning to session ${sessionId}`);
   await sendIgnoredMessage(opts.client, sessionId, text);
 }
 async function sendFeatureAnnouncement(opts, version2, features, footer, storageDir) {
-  if (storageDir) {
-    const versionFile = join17(storageDir, "last_announced_version");
-    try {
-      if (existsSync12(versionFile)) {
-        const lastVersion = readFileSync11(versionFile, "utf-8").trim();
-        if (lastVersion === version2)
-          return;
-      }
-    } catch {}
-  }
+  if (hasAnnouncedVersion(storageDir, version2))
+    return;
   const hasFooter = typeof footer === "string" && footer.trim().length > 0;
   const featureText = hasFooter ? [features.map((f) => `• ${f}`).join(`
 `), "", footer].join(`
 `) : features.map((f) => `• ${f}`).join(`
 `);
   const toastSent = await showTuiToast(opts.client, `AFT v${version2}`, featureText, "info", 12000);
-  if (!toastSent) {
-    const { sessionId } = readDesktopState(opts.directory);
-    if (!sessionId)
-      return;
-    const sections = [
-      `${FEATURE_MARKER} v${version2}:`,
-      ...features.map((f) => `  • ${f}`)
-    ];
-    if (hasFooter)
-      sections.push("", footer);
-    const text = sections.join(`
+  if (toastSent) {
+    persistAnnouncedVersion(storageDir, version2);
+    return;
+  }
+  const sections = [`${FEATURE_MARKER} v${version2}:`, ...features.map((f) => `  • ${f}`)];
+  if (hasFooter)
+    sections.push("", footer);
+  const text = sections.join(`
 `);
-    sessionLog(sessionId, `[aft-plugin] sending feature announcement for v${version2}`);
-    await sendIgnoredMessage(opts.client, sessionId, text);
+  const pending = {
+    key: `feature:${version2}`,
+    text,
+    shouldSkip: () => hasAnnouncedVersion(storageDir, version2),
+    onDelivered: () => persistAnnouncedVersion(storageDir, version2)
+  };
+  const sessionId = getExplicitSessionId(opts);
+  if (!sessionId) {
+    enqueuePendingDesktopNotification(opts.directory, pending);
+    return;
   }
-  if (storageDir) {
-    try {
-      mkdirSync10(storageDir, { recursive: true });
-      writeFileSync9(join17(storageDir, "last_announced_version"), version2);
-    } catch {}
+  await flushPendingDesktopNotifications(opts, sessionId);
+  if (hasAnnouncedVersion(storageDir, version2))
+    return;
+  sessionLog(sessionId, `[aft-plugin] sending feature announcement for v${version2}`);
+  if (await sendIgnoredMessage(opts.client, sessionId, text)) {
+    persistAnnouncedVersion(storageDir, version2);
   }
 }
+function hasAnnouncedVersion(storageDir, version2) {
+  if (!storageDir)
+    return false;
+  const versionFile = repairRootScopedStorageFile(storageDir, "opencode", "last_announced_version");
+  try {
+    return existsSync13(versionFile) && readFileSync12(versionFile, "utf-8").trim() === version2;
+  } catch {
+    return false;
+  }
+}
+function persistAnnouncedVersion(storageDir, version2) {
+  if (!storageDir)
+    return;
+  try {
+    const versionFile = repairRootScopedStorageFile(storageDir, "opencode", "last_announced_version");
+    mkdirSync11(dirname8(versionFile), { recursive: true });
+    writeFileSync9(versionFile, version2);
+  } catch {}
+}
 async function readWarnedTools(bridge) {
   try {
     const resp = await bridge.send("db_get_state", { key: "warned_tools" });
@@ -53883,6 +54158,9 @@ function formatConfigureWarning(warning) {
 ${warning.hint}`;
 }
 async function deliverConfigureWarnings(opts, warnings) {
+  if (opts.projectRoot) {
+    await flushPendingDesktopNotifications({ client: opts.client, directory: opts.projectRoot }, opts.sessionId);
+  }
   if (warnings.length === 0)
     return;
   for (const warning of warnings) {
@@ -53898,10 +54176,10 @@ async function deliverConfigureWarnings(opts, warnings) {
 async function cleanupWarnings(opts) {
   if (isTuiMode())
     return;
-  const { sessionId, serverUrl: desktopServerUrl } = readDesktopState(opts.directory);
+  const sessionId = getExplicitSessionId(opts);
   if (!sessionId)
     return;
-  const effectiveServerUrl = opts.serverUrl || desktopServerUrl;
+  const effectiveServerUrl = opts.serverUrl || readDesktopState().serverUrl;
   if (!effectiveServerUrl)
     return;
   const messages = await getSessionMessages(opts.client, sessionId);
@@ -54035,10 +54313,10 @@ function writeTerminal(terminal, data) {
 }
 
 // src/shared/rpc-server.ts
-import { randomBytes as randomBytes2 } from "node:crypto";
-import { mkdirSync as mkdirSync11, renameSync as renameSync7, unlinkSync as unlinkSync7, writeFileSync as writeFileSync10 } from "node:fs";
+import { randomBytes as randomBytes3 } from "node:crypto";
+import { mkdirSync as mkdirSync12, renameSync as renameSync8, unlinkSync as unlinkSync7, writeFileSync as writeFileSync10 } from "node:fs";
 import { createServer } from "node:http";
-import { dirname as dirname7, join as join19 } from "node:path";
+import { dirname as dirname9, join as join19 } from "node:path";
 
 // src/shared/rpc-utils.ts
 import { createHash as createHash7 } from "node:crypto";
@@ -54063,7 +54341,7 @@ class AftRpcServer {
   instanceId;
   constructor(storageDir, directory) {
     this.portsDir = rpcPortFileDir(storageDir, directory);
-    this.instanceId = randomBytes2(8).toString("hex");
+    this.instanceId = randomBytes3(8).toString("hex");
     this.portFilePath = join19(this.portsDir, `${this.instanceId}.json`);
   }
   handle(method, handler) {
@@ -54083,17 +54361,17 @@ class AftRpcServer {
           return;
         }
         this.port = addr.port;
-        this.token = randomBytes2(32).toString("hex");
+        this.token = randomBytes3(32).toString("hex");
         this.server = server;
         try {
-          const dir = dirname7(this.portFilePath);
-          mkdirSync11(dir, { recursive: true, mode: 448 });
+          const dir = dirname9(this.portFilePath);
+          mkdirSync12(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
           });
-          renameSync7(tmpPath, this.portFilePath);
+          renameSync8(tmpPath, this.portFilePath);
           log2(`RPC server listening on 127.0.0.1:${this.port}`);
         } catch (err) {
           warn2(`Failed to write RPC port file: ${err}`);
@@ -54402,8 +54680,8 @@ function formatStatusMarkdown(status) {
 
 // src/shared/tui-config.ts
 var import_comment_json4 = __toESM(require_src2(), 1);
-import { existsSync as existsSync13, mkdirSync as mkdirSync12, readFileSync as readFileSync12, writeFileSync as writeFileSync11 } from "node:fs";
-import { dirname as dirname8, join as join21 } from "node:path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync13, readFileSync as readFileSync13, writeFileSync as writeFileSync11 } from "node:fs";
+import { dirname as dirname10, join as join21 } from "node:path";
 
 // src/shared/opencode-config-dir.ts
 import { homedir as homedir10 } from "node:os";
@@ -54439,9 +54717,9 @@ function resolveTuiConfigPath() {
   const configDir = getOpenCodeConfigPaths({ binary: "opencode" }).configDir;
   const jsoncPath = join21(configDir, "tui.jsonc");
   const jsonPath = join21(configDir, "tui.json");
-  if (existsSync13(jsoncPath))
+  if (existsSync14(jsoncPath))
     return jsoncPath;
-  if (existsSync13(jsonPath))
+  if (existsSync14(jsonPath))
     return jsonPath;
   return jsonPath;
 }
@@ -54449,8 +54727,8 @@ function ensureTuiPluginEntry() {
   try {
     const configPath = resolveTuiConfigPath();
     let config2 = {};
-    if (existsSync13(configPath)) {
-      config2 = import_comment_json4.parse(readFileSync12(configPath, "utf-8")) ?? {};
+    if (existsSync14(configPath)) {
+      config2 = import_comment_json4.parse(readFileSync13(configPath, "utf-8")) ?? {};
     }
     const plugins = Array.isArray(config2.plugin) ? config2.plugin.filter((value) => typeof value === "string") : [];
     if (plugins.some((plugin) => plugin === PLUGIN_NAME || plugin.startsWith(`${PLUGIN_NAME}@`) || plugin.includes("opencode-plugin") || plugin.includes("aft-opencode"))) {
@@ -54458,7 +54736,7 @@ function ensureTuiPluginEntry() {
     }
     plugins.push(PLUGIN_ENTRY);
     config2.plugin = plugins;
-    mkdirSync12(dirname8(configPath), { recursive: true });
+    mkdirSync13(dirname10(configPath), { recursive: true });
     writeFileSync11(configPath, `${import_comment_json4.stringify(config2, null, 2)}
 `);
     log2(`[aft-plugin] added TUI plugin entry to ${configPath}`);
@@ -54522,11 +54800,14 @@ function registerShutdownCleanup(fn) {
 }
 
 // src/tools/ast.ts
-import { tool as tool2 } from "@opencode-ai/plugin";
+import { tool as tool3 } from "@opencode-ai/plugin";
 
 // src/tools/_shared.ts
 import * as fs3 from "node:fs";
 import * as path2 from "node:path";
+import { tool as tool2 } from "@opencode-ai/plugin";
+var z2 = tool2.schema;
+var optionalInt = (min, max) => z2.number().int().min(min).max(max).optional();
 var LONG_RUNNING_COMMAND_TIMEOUT_MS = {
   callers: 60000,
   trace_to: 60000,
@@ -54739,7 +55020,7 @@ function permissionDeniedResponse(message) {
 }
 
 // src/tools/ast.ts
-var z2 = tool2.schema;
+var z3 = tool3.schema;
 function showOutputToUser(context, output) {
   const ctx = context;
   ctx.metadata?.({ metadata: { output } });
@@ -54772,11 +55053,11 @@ function astTools(ctx) {
 
 ` + "Returns: Text summary — 'Found N match(es) across M file(s)' followed by file:line blocks with matched text and captured meta-variables.",
     args: {
-      pattern: z2.string().describe("AST pattern with meta-variables ($VAR, $$$). Must be complete AST node."),
-      lang: z2.enum(SUPPORTED_LANGS).describe("Target language"),
-      paths: z2.array(z2.string()).optional().describe("Paths to search (default: ['.'])"),
-      globs: z2.array(z2.string()).optional().describe("Include/exclude globs (prefix ! to exclude)"),
-      contextLines: z2.number().optional().describe("Number of context lines to show around each match")
+      pattern: z3.string().describe("AST pattern with meta-variables ($VAR, $$$). Must be complete AST node."),
+      lang: z3.enum(SUPPORTED_LANGS).describe("Target language"),
+      paths: z3.array(z3.string()).optional().describe("Paths to search (default: ['.'])"),
+      globs: z3.array(z3.string()).optional().describe("Include/exclude globs (prefix ! to exclude)"),
+      contextLines: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("Number of context lines to show around each match")
     },
     execute: async (args, context) => {
       const externalDenied = await checkAstPathsPermission(context, args.paths);
@@ -54866,12 +55147,12 @@ ${hint}`;
 
 ` + "Returns: Text summary — 'Replaced N match(es) across M file(s)' (or '[DRY RUN] Would replace...') followed by per-file output. In dry-run mode, each file is shown with its unified diff so you can verify the rewrite before applying (e.g. catch literal $$$ from anonymous-variadic typos). Diff preview is capped at 8KB total; remaining files are summarized.",
     args: {
-      pattern: z2.string().describe("AST pattern with meta-variables ($VAR, $$$). Must be complete AST node."),
-      rewrite: z2.string().describe("Replacement pattern (can use $VAR from pattern)"),
-      lang: z2.enum(SUPPORTED_LANGS).describe("Target language"),
-      paths: z2.array(z2.string()).optional().describe("Paths to search (default: ['.'])"),
-      globs: z2.array(z2.string()).optional().describe("Include/exclude globs (prefix ! to exclude)"),
-      dryRun: z2.boolean().optional().describe("Preview changes without applying (default: false)")
+      pattern: z3.string().describe("AST pattern with meta-variables ($VAR, $$$). Must be complete AST node."),
+      rewrite: z3.string().describe("Replacement pattern (can use $VAR from pattern)"),
+      lang: z3.enum(SUPPORTED_LANGS).describe("Target language"),
+      paths: z3.array(z3.string()).optional().describe("Paths to search (default: ['.'])"),
+      globs: z3.array(z3.string()).optional().describe("Include/exclude globs (prefix ! to exclude)"),
+      dryRun: z3.boolean().optional().describe("Preview changes without applying (default: false)")
     },
     execute: async (args, context) => {
       const isDryRun = args.dryRun === true;
@@ -55036,7 +55317,7 @@ function conflictTools(ctx) {
 // src/tools/hoisted.ts
 import * as fs6 from "node:fs";
 import * as path4 from "node:path";
-import { tool as tool6 } from "@opencode-ai/plugin";
+import { tool as tool7 } from "@opencode-ai/plugin";
 
 // src/patch-parser.ts
 function stripHeredoc(input) {
@@ -55330,7 +55611,7 @@ ${chunk.old_lines.join(`
 }
 
 // src/tools/bash.ts
-import { tool as tool3 } from "@opencode-ai/plugin";
+import { tool as tool4 } from "@opencode-ai/plugin";
 
 // src/shared/subagent-detect.ts
 var CACHE_MAX_ENTRIES2 = 200;
@@ -55383,7 +55664,7 @@ function setCache2(sessionId, isSubagent) {
 }
 
 // src/tools/bash.ts
-var z3 = tool3.schema;
+var z4 = tool4.schema;
 var METADATA_PREVIEW_LIMIT = 30 * 1024;
 var FOREGROUND_WAIT_WINDOW_MS = 5000;
 var FOREGROUND_POLL_INTERVAL_MS = 100;
@@ -55416,15 +55697,15 @@ function createBashTool(ctx) {
   return {
     description: BASH_DESCRIPTION,
     args: {
-      command: z3.string().describe("Shell command to execute through AFT's unified bash schema. Supports normal shell syntax, pipes, redirection, and command rewriting to dedicated AFT tools when available."),
-      timeout: z3.number().int().positive().optional().describe("Hard kill cap in milliseconds (positive integer). When omitted, the task can run up to 30 minutes. Foreground bash returns inline if the command finishes within ~5s; otherwise it's automatically promoted to background and a completion reminder is delivered when the task actually finishes."),
-      workdir: z3.string().optional().describe("Working directory for command execution. Relative paths resolve through the bridge; defaults to the current tool context/project root when omitted."),
-      description: z3.string().optional().describe("Short 5-10 word human-readable summary shown in OpenCode UI metadata instead of raw shell syntax."),
-      background: z3.boolean().optional().describe("When true, spawn the command in the background and return a task_id for bash_status/bash_kill instead of waiting for completion. Defaults to false."),
-      compressed: z3.boolean().optional().describe("When true or omitted, return compressed output with noisy terminal control sequences reduced. Set to false for raw output."),
-      pty: z3.boolean().optional().describe('When true, spawn the command in a real PTY for interactive programs (python/node/bash REPLs, vim). Requires background: true and is unavailable in subagent sessions. Inspect with bash_status({ taskId, outputMode: "screen" }) and drive interactively with bash_write — its input accepts either a string OR an array like [ "iHello", { key: "esc" }, ":wq", { key: "enter" } ] for atomic text+key sequences.'),
-      ptyRows: z3.number().int().min(1).max(60).optional().describe("PTY terminal height in rows. Applies only when pty: true; defaults to 24. Minimum 1, maximum 60."),
-      ptyCols: z3.number().int().min(1).max(140).optional().describe("PTY terminal width in columns. Applies only when pty: true; defaults to 80. Minimum 1, maximum 140.")
+      command: z4.string().describe("Shell command to execute through AFT's unified bash schema. Supports normal shell syntax, pipes, redirection, and command rewriting to dedicated AFT tools when available."),
+      timeout: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("Hard kill cap in milliseconds (positive integer). When omitted, the task can run up to 30 minutes. Foreground bash returns inline if the command finishes within ~5s; otherwise it's automatically promoted to background and a completion reminder is delivered when the task actually finishes."),
+      workdir: z4.string().optional().describe("Working directory for command execution. Relative paths resolve through the bridge; defaults to the current tool context/project root when omitted."),
+      description: z4.string().optional().describe("Short 5-10 word human-readable summary shown in OpenCode UI metadata instead of raw shell syntax."),
+      background: z4.boolean().optional().describe("When true, spawn the command in the background and return a task_id for bash_status/bash_kill instead of waiting for completion. Defaults to false."),
+      compressed: z4.boolean().optional().describe("When true or omitted, return compressed output with noisy terminal control sequences reduced. Set to false for raw output."),
+      pty: z4.boolean().optional().describe('When true, spawn the command in a real PTY for interactive programs (python/node/bash REPLs, vim). Implies background: true automatically. Unavailable in subagent sessions. Inspect with bash_status({ taskId, outputMode: "screen" }) and drive interactively with bash_write — its input accepts either a string OR an array like [ "iHello", { key: "esc" }, ":wq", { key: "enter" } ] for atomic text+key sequences.'),
+      ptyRows: optionalInt(1, 60).describe("PTY terminal height in rows — ignored when pty is false. Defaults to 24 when pty: true. Minimum 1, maximum 60."),
+      ptyCols: optionalInt(1, 140).describe("PTY terminal width in columns — ignored when pty is false. Defaults to 80 when pty: true. Minimum 1, maximum 140.")
     },
     execute: async (args, context) => {
       const bashCfg = resolveBashConfig(ctx.config);
@@ -55434,14 +55715,8 @@ function createBashTool(ctx) {
       const command = args.command;
       const cwd = args.workdir ?? context.directory;
       const isSubagent = await resolveIsSubagent(ctx.client, context.sessionID, context.directory);
-      const requestedBackground = args.background === true;
       const requestedPty = args.pty === true;
-      if (!requestedPty && (args.ptyRows !== undefined || args.ptyCols !== undefined)) {
-        throw new Error("invalid_request: ptyRows/ptyCols require pty: true");
-      }
-      if (requestedPty && !requestedBackground) {
-        throw new Error("PTY mode requires background: true");
-      }
+      const requestedBackground = args.background === true || requestedPty;
       if (requestedPty && isSubagent) {
         throw new Error("PTY mode is not available in subagent sessions; subagents cannot drive interactive terminals.");
       }
@@ -55515,6 +55790,10 @@ function createBashTool(ctx) {
             return rendered2;
           }
           if (Date.now() - startedAt >= waitTimeoutMs) {
+            if (subagentForcedForeground) {
+              await sleep(FOREGROUND_POLL_INTERVAL_MS);
+              continue;
+            }
             const promoted = await callBridge(ctx, context, "bash_promote", { task_id: taskId });
             if (promoted.success === false) {
               throw new Error(promoted.message ?? "bash_promote failed");
@@ -55578,8 +55857,8 @@ function createBashStatusTool(ctx) {
   return {
     description: "Read-only snapshot of a background or PTY bash task's current state and output. Returns immediately. Use bash_watch to block on or register for pattern matches and exit events.",
     args: {
-      taskId: z3.string().describe("Background task ID returned by bash({ background: true }), e.g. bash-6b454047."),
-      outputMode: z3.enum(["screen", "raw", "both"]).optional().describe("PTY output rendering mode. Defaults to screen for PTY tasks and preserves existing behavior for piped tasks when omitted.")
+      taskId: z4.string().describe("Background task ID returned by bash({ background: true }), e.g. bash-6b454047."),
+      outputMode: z4.enum(["screen", "raw", "both"]).optional().describe("PTY output rendering mode. Defaults to screen for PTY tasks and preserves existing behavior for piped tasks when omitted.")
     },
     execute: async (args, context) => {
       const taskId = args.taskId;
@@ -55593,7 +55872,7 @@ function createBashKillTool(ctx) {
   return {
     description: "Terminate a running background bash task spawned with bash({ background: true }). Returns confirmation of kill or an error if the task already finished.",
     args: {
-      taskId: z3.string().describe("Background task ID returned by bash({ background: true }), e.g. bash-6b454047.")
+      taskId: z4.string().describe("Background task ID returned by bash({ background: true }), e.g. bash-6b454047.")
     },
     execute: async (args, context) => {
       const data = await callBridge(ctx, context, "bash_kill", {
@@ -55741,21 +56020,22 @@ function shortenCommand(command) {
 
 // src/tools/bash_watch.ts
 import * as fs5 from "node:fs/promises";
-import { tool as tool4 } from "@opencode-ai/plugin";
-var z4 = tool4.schema;
+import { tool as tool5 } from "@opencode-ai/plugin";
+var z5 = tool5.schema;
 var BASH_WAIT_POLL_INTERVAL_MS = 100;
 var DEFAULT_BASH_STATUS_WAIT_TIMEOUT_MS = 30000;
 var MAX_BASH_STATUS_WAIT_TIMEOUT_MS = 300000;
 var BASH_TRANSPORT_TIMEOUT_MS2 = 30000;
+var REGEX_WAIT_SCAN_WINDOW_BYTES = 64 * 1024;
 function createBashWatchTool(ctx) {
   return {
     description: "Block on a background bash task until a pattern matches, it exits, or timeout elapses; or register an async pattern notification with background:true.",
     args: {
-      taskId: z4.string().describe("Background task ID returned by bash({ background: true })."),
-      pattern: z4.union([z4.string(), z4.object({ regex: z4.string() })]).optional().describe("Substring or regex pattern. Optional in sync mode; required with background:true."),
-      background: z4.boolean().optional().describe("When true, register an async watch and return immediately. Defaults to false (sync wait)."),
-      timeoutMs: z4.number().int().positive().optional().describe("Sync-only timeout in milliseconds. Default 30000, max 300000."),
-      once: z4.boolean().optional().describe("Async-only. Defaults true; false keeps the watch sticky until task exit.")
+      taskId: z5.string().describe("Background task ID returned by bash({ background: true })."),
+      pattern: z5.union([z5.string(), z5.object({ regex: z5.string() })]).optional().describe("Substring or regex pattern. Optional in sync mode; required with background:true. Sync substring watches keep only the overlap tail needed for boundary matches; sync regex watches use a 64 KB rolling output window."),
+      background: z5.boolean().optional().describe("When true, register an async watch and return immediately. Defaults to false (sync wait)."),
+      timeoutMs: optionalInt(1, MAX_BASH_STATUS_WAIT_TIMEOUT_MS).describe("Sync-only timeout in milliseconds. Default 30000, max 300000."),
+      once: z5.boolean().optional().describe("Async-only. Defaults true; false keeps the watch sticky until task exit.")
     },
     execute: async (args, context) => {
       const taskId = args.taskId;
@@ -55844,7 +56124,7 @@ async function bashStatusSnapshot2(ctx, runtime, taskId, outputMode, options) {
 async function waitForBashStatus(ctx, runtime, taskId, outputMode, waitFor, effectiveWaitMs) {
   const startedAt = Date.now();
   const deadline = startedAt + effectiveWaitMs;
-  let spillCursor = 0;
+  let spillCursor = { output: 0, stderr: 0, combined: 0 };
   let scanText = "";
   let scanBaseOffset = 0;
   const bridgeOptions = {
@@ -55852,14 +56132,11 @@ async function waitForBashStatus(ctx, runtime, taskId, outputMode, waitFor, effe
     transportTimeoutMs: BASH_TRANSPORT_TIMEOUT_MS2
   };
   markTaskWaiting(runtime.sessionID, taskId);
+  let sawTerminal = false;
   try {
     while (true) {
       const data = await bashStatusSnapshot2(ctx, runtime, taskId, outputMode, bridgeOptions);
-      if (isTerminalStatus2(data.status)) {
-        consumeBgCompletion(runtime.sessionID, taskId);
-        await markBgCompletionDelivered({ ctx, directory: projectRootFor(runtime), sessionID: runtime.sessionID }, taskId);
-        return withWaited(data, { reason: "exited", elapsed_ms: Date.now() - startedAt });
-      }
+      const terminal = isTerminalStatus2(data.status);
       if (waitFor) {
         const scan = await readNewTaskOutput(runtime, taskId, data, spillCursor);
         if (scan) {
@@ -55869,7 +56146,11 @@ async function waitForBashStatus(ctx, runtime, taskId, outputMode, waitFor, effe
           scanText += scan.text;
           const match = findWaitMatch(scanText, waitFor);
           if (match) {
-            unmarkTaskWaiting(runtime.sessionID, taskId);
+            if (terminal) {
+              sawTerminal = true;
+              consumeBgCompletion(runtime.sessionID, taskId);
+              await markBgCompletionDelivered({ ctx, directory: projectRootFor(runtime), sessionID: runtime.sessionID }, taskId);
+            }
             return withWaited(data, {
               reason: "matched",
               elapsed_ms: Date.now() - startedAt,
@@ -55877,31 +56158,61 @@ async function waitForBashStatus(ctx, runtime, taskId, outputMode, waitFor, effe
               match_offset: scanBaseOffset + Buffer.byteLength(scanText.slice(0, match.index), "utf8")
             });
           }
+          const trimmed = trimWaitScanBuffer(scanText, scanBaseOffset, waitFor);
+          scanText = trimmed.text;
+          scanBaseOffset = trimmed.baseOffset;
         }
       }
+      if (terminal) {
+        sawTerminal = true;
+        consumeBgCompletion(runtime.sessionID, taskId);
+        await markBgCompletionDelivered({ ctx, directory: projectRootFor(runtime), sessionID: runtime.sessionID }, taskId);
+        return withWaited(data, { reason: "exited", elapsed_ms: Date.now() - startedAt });
+      }
       if (Date.now() >= deadline) {
-        unmarkTaskWaiting(runtime.sessionID, taskId);
         return withWaited(data, { reason: "timeout", elapsed_ms: Date.now() - startedAt });
       }
       await sleep2(Math.min(BASH_WAIT_POLL_INTERVAL_MS, Math.max(0, deadline - Date.now())));
     }
-  } catch (err) {
-    unmarkTaskWaiting(runtime.sessionID, taskId);
-    throw err;
+  } finally {
+    if (!sawTerminal)
+      unmarkTaskWaiting(runtime.sessionID, taskId);
+    await disposePtyTerminal(watchPtyCacheKey(runtime, taskId));
   }
 }
 async function readNewTaskOutput(runtime, taskId, data, cursor) {
   const outputPath = data.output_path;
-  if (!outputPath)
-    return;
   if (data.mode === "pty") {
-    const state = await getOrCreatePtyTerminal(ptyCacheKey2(runtime, taskId), outputPath);
+    if (!outputPath)
+      return;
+    const state = await getOrCreatePtyTerminal(watchPtyCacheKey(runtime, taskId), outputPath);
     const baseOffset = state.offset;
-    const bytes2 = await readPtyBytes(state);
-    return { text: bytes2.toString("utf8"), baseOffset, nextCursor: state.offset };
+    const bytes = await readPtyBytes(state);
+    if (bytes.length === 0)
+      return;
+    return {
+      text: bytes.toString("utf8"),
+      baseOffset,
+      nextCursor: { output: state.offset, stderr: 0, combined: state.offset }
+    };
   }
-  const bytes = await readFileBytesFrom(outputPath, cursor);
-  return { text: bytes.toString("utf8"), baseOffset: cursor, nextCursor: cursor + bytes.length };
+  const stderrPath = data.stderr_path;
+  if (!outputPath && !stderrPath)
+    return;
+  const stdoutBytes = outputPath ? await readFileBytesFrom(outputPath, cursor.output) : Buffer.alloc(0);
+  const stderrBytes = stderrPath ? await readFileBytesFrom(stderrPath, cursor.stderr) : Buffer.alloc(0);
+  const bytesRead = stdoutBytes.length + stderrBytes.length;
+  if (bytesRead === 0)
+    return;
+  return {
+    text: Buffer.concat([stdoutBytes, stderrBytes]).toString("utf8"),
+    baseOffset: cursor.combined,
+    nextCursor: {
+      output: cursor.output + stdoutBytes.length,
+      stderr: cursor.stderr + stderrBytes.length,
+      combined: cursor.combined + bytesRead
+    }
+  };
 }
 async function readFileBytesFrom(outputPath, cursor) {
   const handle = await fs5.open(outputPath, "r");
@@ -55942,6 +56253,34 @@ function findWaitMatch(text, pattern) {
   const match = pattern.value.exec(text);
   return match ? { text: match[0], index: match.index } : undefined;
 }
+function trimWaitScanBuffer(text, baseOffset, pattern) {
+  const keepFrom = pattern.kind === "substring" ? substringKeepStart(text, pattern.value) : regexKeepStart(text, REGEX_WAIT_SCAN_WINDOW_BYTES);
+  if (keepFrom <= 0)
+    return { text, baseOffset };
+  return {
+    text: text.slice(keepFrom),
+    baseOffset: baseOffset + Buffer.byteLength(text.slice(0, keepFrom), "utf8")
+  };
+}
+function substringKeepStart(text, pattern) {
+  const keepChars = Math.max(0, pattern.length - 1);
+  return text.length > keepChars ? text.length - keepChars : 0;
+}
+function regexKeepStart(text, maxBytes) {
+  if (Buffer.byteLength(text, "utf8") <= maxBytes)
+    return 0;
+  let low = 0;
+  let high = text.length;
+  while (low < high) {
+    const mid = Math.floor((low + high) / 2);
+    if (Buffer.byteLength(text.slice(mid), "utf8") > maxBytes) {
+      low = mid + 1;
+    } else {
+      high = mid;
+    }
+  }
+  return low;
+}
 function withWaited(data, waited) {
   return { ...data, waited };
 }
@@ -55951,24 +56290,27 @@ function isTerminalStatus2(status) {
 function ptyCacheKey2(runtime, taskId) {
   return `${projectRootFor(runtime)}::${runtime.sessionID ?? "__default__"}::${taskId}`;
 }
+function watchPtyCacheKey(runtime, taskId) {
+  return `${ptyCacheKey2(runtime, taskId)}::watch`;
+}
 function sleep2(ms) {
   return new Promise((resolve7) => setTimeout(resolve7, ms));
 }
 
 // src/tools/bash_write.ts
-import { tool as tool5 } from "@opencode-ai/plugin";
-var z5 = tool5.schema;
+import { tool as tool6 } from "@opencode-ai/plugin";
+var z6 = tool6.schema;
 function createBashWriteTool(ctx) {
   return {
     description: 'Write input bytes to a running PTY bash task. PTY-only; check bash_status reports mode: "pty" first. ' + 'Input is either a string (verbatim bytes) or an array mixing strings and { key: "esc" | "enter" | "up" | "ctrl-c" | ... } objects ' + 'for atomic text+key sequences such as [ "iHello", { key: "esc" }, ":wq", { key: "enter" } ]. ' + "Named keys cover enter/return/tab/space/backspace/esc/escape, arrows, home/end/page-up/page-down/delete/insert, f1..f12, and ctrl-a..ctrl-z. " + "Maximum 1 MiB per call (post-expansion).",
     args: {
-      taskId: z5.string().describe("Background PTY task ID returned by bash({ pty: true, background: true })."),
-      input: z5.union([
-        z5.string(),
-        z5.array(z5.union([
-          z5.string(),
-          z5.object({
-            key: z5.string().describe("Named control key, e.g. 'esc', 'enter', 'up', 'ctrl-c'. Case-insensitive.")
+      taskId: z6.string().describe("Background PTY task ID returned by bash({ pty: true, background: true })."),
+      input: z6.union([
+        z6.string(),
+        z6.array(z6.union([
+          z6.string(),
+          z6.object({
+            key: z6.string().describe("Named control key, e.g. 'esc', 'enter', 'up', 'ctrl-c'. Case-insensitive.")
           })
         ]))
       ]).describe("Either a string of verbatim bytes (e.g. 'print(1)\\n') OR an array mixing strings " + "and { key: '<name>' } objects for atomic text+key sequences. " + "Example: [ 'iHello', { key: 'esc' }, ':wq', { key: 'enter' } ].")
@@ -56195,7 +56537,7 @@ function inferBeforeStart(ops, from, beforeLen) {
   }
   return beforeLen;
 }
-var z6 = tool6.schema;
+var z7 = tool7.schema;
 var READ_DESCRIPTION = `Read file contents or list directory entries.
 
 Use either startLine/endLine OR offset/limit to read a section of a file.
@@ -56219,11 +56561,11 @@ function createReadTool(ctx) {
   return {
     description: READ_DESCRIPTION,
     args: {
-      filePath: z6.string().describe("Path to file or directory (absolute or relative to project root)"),
-      startLine: z6.number().optional().describe("1-based line to start reading from"),
-      endLine: z6.number().optional().describe("1-based line to stop reading at (inclusive)"),
-      limit: z6.number().optional().describe("Max lines to return (default: 2000)"),
-      offset: z6.number().optional().describe("1-based line number to start reading from (use with limit). Ignored if startLine is provided")
+      filePath: z7.string().describe("Path to file or directory (absolute or relative to project root)"),
+      startLine: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("1-based line to start reading from"),
+      endLine: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("1-based line to stop reading at (inclusive)"),
+      limit: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("Max lines to return (default: 2000)"),
+      offset: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("1-based line number to start reading from (use with limit). Ignored if startLine is provided")
     },
     execute: async (args, context) => {
       const file2 = args.filePath;
@@ -56355,8 +56697,8 @@ function createWriteTool(ctx, editToolName = "edit") {
   return {
     description: getWriteDescription(editToolName),
     args: {
-      filePath: z6.string().describe("Path to the file to write (absolute or relative to project root)"),
-      content: z6.string().describe("The full content to write to the file")
+      filePath: z7.string().describe("Path to the file to write (absolute or relative to project root)"),
+      content: z7.string().describe("The full content to write to the file")
     },
     execute: async (args, context) => {
       const file2 = args.filePath;
@@ -56501,16 +56843,16 @@ function createEditTool(ctx, writeToolName = "write") {
   return {
     description: getEditDescription(writeToolName),
     args: {
-      filePath: z6.string().optional().describe("Path to the file to edit (absolute or relative to project root). Required for all modes except 'operations' multi-file transactions"),
-      oldString: z6.string().optional().describe("Text to find (exact match, with fuzzy fallback)"),
-      newString: z6.string().optional().describe("Text to replace with (omit or set to empty string to delete the matched text)"),
-      replaceAll: z6.boolean().optional().describe("Replace all occurrences"),
-      occurrence: z6.number().optional().describe("0-indexed occurrence to replace when multiple matches exist"),
-      symbol: z6.string().optional().describe("Named symbol to replace (function, class, type)"),
-      content: z6.string().optional().describe("New content for symbol replace or file write"),
-      appendContent: z6.string().optional().describe("Text to append to the end of filePath; creates the file if needed"),
-      edits: z6.array(z6.record(z6.string(), z6.unknown())).optional().describe("Batch edits — array of { oldString: string, newString: string } or { startLine: number (1-based), endLine: number (1-based, inclusive), content: string }"),
-      operations: z6.array(z6.record(z6.string(), z6.unknown())).optional().describe("Transaction — array of { file: string, command: 'edit_match' | 'write', match?: string, replacement?: string, content?: string } for multi-file edits with rollback. Note: uses 'file'/'match'/'replacement' (not filePath/oldString/newString)")
+      filePath: z7.string().optional().describe("Path to the file to edit (absolute or relative to project root). Required for all modes except 'operations' multi-file transactions"),
+      oldString: z7.string().optional().describe("Text to find (exact match, with fuzzy fallback)"),
+      newString: z7.string().optional().describe("Text to replace with (omit or set to empty string to delete the matched text)"),
+      replaceAll: z7.boolean().optional().describe("Replace all occurrences"),
+      occurrence: optionalInt(0, Number.MAX_SAFE_INTEGER).describe("0-indexed occurrence to replace when multiple matches exist"),
+      symbol: z7.string().optional().describe("Named symbol to replace (function, class, type)"),
+      content: z7.string().optional().describe("New content for symbol replace or file write"),
+      appendContent: z7.string().optional().describe("Text to append to the end of filePath; creates the file if needed"),
+      edits: z7.array(z7.record(z7.string(), z7.unknown())).optional().describe("Batch edits — array of { oldString: string, newString: string } or { startLine: number (1-based), endLine: number (1-based, inclusive), content: string }"),
+      operations: z7.array(z7.record(z7.string(), z7.unknown())).optional().describe("Transaction — array of { file: string, command: 'edit_match' | 'write', match?: string, replacement?: string, content?: string } for multi-file edits with rollback. Note: uses 'file'/'match'/'replacement' (not filePath/oldString/newString)")
     },
     execute: async (args, context) => {
       const argsRecord = args;
@@ -56726,7 +57068,7 @@ function createApplyPatchTool(ctx) {
   return {
     description: APPLY_PATCH_DESCRIPTION,
     args: {
-      patchText: z6.string().describe("The full patch text including Begin/End markers")
+      patchText: z7.string().describe("The full patch text including Begin/End markers")
     },
     execute: async (args, context) => {
       const patchText = args.patchText;
@@ -57002,8 +57344,8 @@ function createDeleteTool(ctx) {
   return {
     description: DELETE_DESCRIPTION,
     args: {
-      files: z6.array(z6.string()).min(1).describe("Paths to delete (one or more). May include directories when recursive=true."),
-      recursive: z6.boolean().optional().describe("Required to delete a directory and its contents. Defaults to false; passing a directory without this returns an error.")
+      files: z7.array(z7.string()).min(1).describe("Paths to delete (one or more). May include directories when recursive=true."),
+      recursive: z7.boolean().optional().describe("Required to delete a directory and its contents. Defaults to false; passing a directory without this returns an error.")
     },
     execute: async (args, context) => {
       const inputs = args.files;
@@ -57056,8 +57398,8 @@ function createMoveTool(ctx) {
   return {
     description: MOVE_DESCRIPTION,
     args: {
-      filePath: z6.string().describe("Source file path to move"),
-      destination: z6.string().describe("Destination file path")
+      filePath: z7.string().describe("Source file path to move"),
+      destination: z7.string().describe("Destination file path")
     },
     execute: async (args, context) => {
       const filePath = path4.isAbsolute(args.filePath) ? args.filePath : path4.resolve(context.directory, args.filePath);
@@ -57167,8 +57509,8 @@ function aftPrefixedTools(ctx) {
 }
 
 // src/tools/imports.ts
-import { tool as tool7 } from "@opencode-ai/plugin";
-var z7 = tool7.schema;
+import { tool as tool8 } from "@opencode-ai/plugin";
+var z8 = tool8.schema;
 function importTools(ctx) {
   return {
     aft_import: {
@@ -57184,14 +57526,14 @@ function importTools(ctx) {
 ` + `- remove: { file, removed, module, name?, formatted, syntax_valid?, format_skipped_reason?, validation_errors?, validate_skipped_reason?, backup_id?, lsp_diagnostics? }
 ` + "- organize: { file, groups: [{ name, count }], removed_duplicates, formatted?, syntax_valid?, format_skipped_reason?, validation_errors?, validate_skipped_reason?, backup_id?, lsp_diagnostics? }",
       args: {
-        op: z7.enum(["add", "remove", "organize"]).describe("Import operation"),
-        filePath: z7.string().describe("Path to the file (absolute or relative to project root)"),
-        module: z7.string().optional().describe("Module path (required for add, remove — e.g. 'react', './utils', 'std::fmt')"),
-        names: z7.array(z7.string()).optional().describe("Named imports to add (e.g. ['useState', 'useEffect'])"),
-        defaultImport: z7.string().optional().describe("Default import name (e.g. 'React')"),
-        typeOnly: z7.boolean().optional().describe("Type-only import (TS only, default: false)"),
-        removeName: z7.string().optional().describe("Named import to remove for 'remove' op; omit to remove entire import"),
-        validate: z7.enum(["syntax", "full"]).optional().describe("Validation level: 'syntax' (default) or 'full'. Syntax = tree-sitter parse check only. Full = also runs LSP type-checking (slower, catches more errors)")
+        op: z8.enum(["add", "remove", "organize"]).describe("Import operation"),
+        filePath: z8.string().describe("Path to the file (absolute or relative to project root)"),
+        module: z8.string().optional().describe("Module path (required for add, remove — e.g. 'react', './utils', 'std::fmt')"),
+        names: z8.array(z8.string()).optional().describe("Named imports to add (e.g. ['useState', 'useEffect'])"),
+        defaultImport: z8.string().optional().describe("Default import name (e.g. 'React')"),
+        typeOnly: z8.boolean().optional().describe("Type-only import (TS only, default: false)"),
+        removeName: z8.string().optional().describe("Named import to remove for 'remove' op; omit to remove entire import"),
+        validate: z8.enum(["syntax", "full"]).optional().describe("Validation level: 'syntax' (default) or 'full'. Syntax = tree-sitter parse check only. Full = also runs LSP type-checking (slower, catches more errors)")
       },
       execute: async (args, context) => {
         const op = args.op;
@@ -57236,8 +57578,8 @@ function importTools(ctx) {
 }
 
 // src/tools/lsp.ts
-import { tool as tool8 } from "@opencode-ai/plugin";
-var z8 = tool8.schema;
+import { tool as tool9 } from "@opencode-ai/plugin";
+var z9 = tool9.schema;
 function lspTools(ctx) {
   const diagnosticsTool = {
     description: "On-demand LSP file/scope check. Spawns the relevant language server (if " + "registered for the file's extension), opens the document, prefers LSP 3.17 " + "pull diagnostics when supported, and falls back to push + waitMs otherwise. " + "NOT a project-wide type checker — for full coverage run `tsc --noEmit`, " + "`cargo check`, `pyright`, etc.\n" + `
@@ -57259,10 +57601,10 @@ function lspTools(ctx) {
 ` + "- `total: 0, complete: true, lsp_servers_used: [{status: 'pull_ok'}]` → file is genuinely clean.\n" + "- `total: 0, lsp_servers_used: []` → **nothing was checked** (no server registered for this extension). Tell the user, don't claim 'no errors'.\n" + "- `lsp_servers_used: [{status: 'binary_not_installed: <name>'}]` → server matched the extension but its binary isn't on PATH. Tell the user to install it.\n" + "- `lsp_servers_used: [{status: 'no_root_marker (...)'}]` → server is registered but couldn't find a workspace root marker walking up from this file. The user's project layout doesn't match what the server expects.\n" + "- `complete: false` (directory mode) → some files in the directory weren't checked; see `unchecked_files`.\n" + `
 ` + "**When this tool gives an unhelpful answer**, run `npx @cortexkit/aft doctor lsp <filePath>` from a terminal to get a full per-server breakdown (registered servers, binary resolution, root-marker resolution, spawn outcome).",
     args: {
-      filePath: z8.string().optional().describe("Path to a file to check. Mutually exclusive with 'directory'. Omit both to dump all cached diagnostics."),
-      directory: z8.string().optional().describe("Path to a directory. Returns cached diagnostics + workspace pull from active servers; lists files we have no info for in 'unchecked_files'. Capped at 200 walked files."),
-      severity: z8.enum(["error", "warning", "information", "hint", "all"]).optional().describe("Filter by severity (default: 'all')."),
-      waitMs: z8.number().optional().describe("Wait up to N ms (max 10000, default 0) for push diagnostics to arrive. Only matters for servers that don't support LSP 3.17 pull (bash-language-server, yaml-language-server). Use after an edit to let the server re-analyze.")
+      filePath: z9.string().optional().describe("Path to a file to check. Mutually exclusive with 'directory'. Omit both to dump all cached diagnostics."),
+      directory: z9.string().optional().describe("Path to a directory. Returns cached diagnostics + workspace pull from active servers; lists files we have no info for in 'unchecked_files'. Capped at 200 walked files."),
+      severity: z9.enum(["error", "warning", "information", "hint", "all"]).optional().describe("Filter by severity (default: 'all')."),
+      waitMs: optionalInt(1, 1e4).describe("Wait up to N ms (max 10000, default 0) for push diagnostics to arrive. Only matters for servers that don't support LSP 3.17 pull (bash-language-server, yaml-language-server). Use after an edit to let the server re-analyze.")
     },
     execute: async (args, context) => {
       const filePath = args.filePath || undefined;
@@ -57293,8 +57635,8 @@ function lspTools(ctx) {
 }
 
 // src/tools/navigation.ts
-import { tool as tool9 } from "@opencode-ai/plugin";
-var z9 = tool9.schema;
+import { tool as tool10 } from "@opencode-ai/plugin";
+var z10 = tool10.schema;
 function navigationTools(ctx) {
   return {
     aft_navigate: {
@@ -57311,11 +57653,11 @@ function navigationTools(ctx) {
 
 `,
       args: {
-        op: z9.enum(["call_tree", "callers", "trace_to", "impact", "trace_data"]).describe("Navigation operation"),
-        filePath: z9.string().describe("Path to the source file containing the symbol (absolute or relative to project root)"),
-        symbol: z9.string().describe("Name of the symbol to analyze"),
-        depth: z9.number().optional().describe("Max traversal depth (default: call_tree=5, callers=1, trace_to=10, impact=5, trace_data=5)"),
-        expression: z9.string().optional().describe("Expression to track through data flow (required for trace_data op)")
+        op: z10.enum(["call_tree", "callers", "trace_to", "impact", "trace_data"]).describe("Navigation operation"),
+        filePath: z10.string().describe("Path to the source file containing the symbol (absolute or relative to project root)"),
+        symbol: z10.string().describe("Name of the symbol to analyze"),
+        depth: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("Max traversal depth (default: call_tree=5, callers=1, trace_to=10, impact=5, trace_data=5)"),
+        expression: z10.string().optional().describe("Expression to track through data flow (required for trace_data op)")
       },
       execute: async (args, context) => {
         const params = {
@@ -57341,8 +57683,8 @@ function navigationTools(ctx) {
 
 // src/tools/reading.ts
 import { resolve as resolve8 } from "node:path";
-import { tool as tool10 } from "@opencode-ai/plugin";
-var z10 = tool10.schema;
+import { tool as tool11 } from "@opencode-ai/plugin";
+var z11 = tool11.schema;
 function readingTools(ctx) {
   return {
     aft_outline: {
@@ -57353,7 +57695,7 @@ function readingTools(ctx) {
 ` + `  • URL (http:// or https://) → fetch and outline a remote HTML/Markdown document
 ` + "  • array of paths → outline multiple files in one call",
       args: {
-        target: z10.union([z10.string(), z10.array(z10.string())]).describe("What to outline: a file path, directory path, URL, or array of file paths. The mode is auto-detected: URLs by `http://`/`https://` prefix, directories by stat, arrays as multi-file.")
+        target: z11.union([z11.string(), z11.array(z11.string())]).describe("What to outline: a file path, directory path, URL, or array of file paths. The mode is auto-detected: URLs by `http://`/`https://` prefix, directories by stat, arrays as multi-file.")
       },
       execute: async (args, context) => {
         const target = args.target;
@@ -57408,11 +57750,11 @@ function readingTools(ctx) {
 
 Provide exactly ONE of 'filePath' or 'url'. Pass either 'symbol' for a single lookup or 'symbols' for multiple in one call.`,
       args: {
-        filePath: z10.string().optional().describe("Path to file (absolute or relative to project root)"),
-        url: z10.string().optional().describe("HTTP/HTTPS URL of an HTML or Markdown document to fetch and zoom into"),
-        symbol: z10.string().optional().describe("Symbol name for code, or heading text for Markdown/HTML"),
-        symbols: z10.array(z10.string()).optional().describe("Array of symbol names or heading texts for a single batched call"),
-        contextLines: z10.number().optional().describe("Lines of context before/after the symbol (default: 3)")
+        filePath: z11.string().optional().describe("Path to file (absolute or relative to project root)"),
+        url: z11.string().optional().describe("HTTP/HTTPS URL of an HTML or Markdown document to fetch and zoom into"),
+        symbol: z11.string().optional().describe("Symbol name for code, or heading text for Markdown/HTML"),
+        symbols: z11.array(z11.string()).optional().describe("Array of symbol names or heading texts for a single batched call"),
+        contextLines: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("Lines of context before/after the symbol (default: 3)")
       },
       execute: async (args, context) => {
         const hasFilePath = typeof args.filePath === "string" && args.filePath.length > 0;
@@ -57494,7 +57836,7 @@ ${lines}`;
 }
 
 // src/tools/refactoring.ts
-import { tool as tool11 } from "@opencode-ai/plugin";
+import { tool as tool12 } from "@opencode-ai/plugin";
 
 // src/lsp.ts
 var LSP_SYMBOL_KIND_MAP = {
@@ -57553,7 +57895,7 @@ async function queryLspHints(client, symbolName, directory, sessionId) {
 }
 
 // src/tools/refactoring.ts
-var z11 = tool11.schema;
+var z12 = tool12.schema;
 function refactoringTools(ctx) {
   return {
     aft_refactor: {
@@ -57571,15 +57913,15 @@ function refactoringTools(ctx) {
 
 ` + "Returns: move { ok, files_modified, consumers_updated, checkpoint_name, results }. extract returns { file, name, parameters, return_type, syntax_valid, formatted, ... }. inline returns { file, symbol, call_context, substitutions, conflicts, syntax_valid, formatted, ... }.",
       args: {
-        op: z11.enum(["move", "extract", "inline"]).describe("Refactoring operation"),
-        filePath: z11.string().describe("Path to the source file (absolute or relative to project root)"),
-        symbol: z11.string().optional().describe("Symbol name — required for 'move' and 'inline' ops"),
-        destination: z11.string().optional().describe("Target file path — required for 'move' op"),
-        scope: z11.string().optional().describe("Disambiguation scope for 'move' op — when multiple top-level symbols share the same name, specify the containing scope to disambiguate (e.g. 'MyClass'). Does NOT enable access to nested symbols or class methods."),
-        name: z11.string().optional().describe("New function name — required for 'extract' op"),
-        startLine: z11.number().optional().describe("1-based start line — required for 'extract' op"),
-        endLine: z11.number().optional().describe("1-based end line (inclusive) — required for 'extract' op"),
-        callSiteLine: z11.number().optional().describe("1-based call site line — required for 'inline' op")
+        op: z12.enum(["move", "extract", "inline"]).describe("Refactoring operation"),
+        filePath: z12.string().describe("Path to the source file (absolute or relative to project root)"),
+        symbol: z12.string().optional().describe("Symbol name — required for 'move' and 'inline' ops"),
+        destination: z12.string().optional().describe("Target file path — required for 'move' op"),
+        scope: z12.string().optional().describe("Disambiguation scope for 'move' op — when multiple top-level symbols share the same name, specify the containing scope to disambiguate (e.g. 'MyClass'). Does NOT enable access to nested symbols or class methods."),
+        name: z12.string().optional().describe("New function name — required for 'extract' op"),
+        startLine: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("1-based start line — required for 'extract' op"),
+        endLine: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("1-based end line (inclusive) — required for 'extract' op"),
+        callSiteLine: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("1-based call site line — required for 'inline' op")
       },
       execute: async (args, context) => {
         const op = args.op;
@@ -57660,8 +58002,8 @@ function refactoringTools(ctx) {
 
 // src/tools/safety.ts
 import * as path5 from "node:path";
-import { tool as tool12 } from "@opencode-ai/plugin";
-var z12 = tool12.schema;
+import { tool as tool13 } from "@opencode-ai/plugin";
+var z13 = tool13.schema;
 function safetyTools(ctx) {
   return {
     aft_safety: {
@@ -57682,10 +58024,10 @@ function safetyTools(ctx) {
 
 ` + "Returns: undo { path, backup_id }. history { file, entries }. checkpoint { ok, name }. restore { ok, name }. list { checkpoints }.",
       args: {
-        op: z12.enum(["undo", "history", "checkpoint", "restore", "list"]).describe("Safety operation"),
-        filePath: z12.string().optional().describe("File path (required for history, optional for undo). Absolute or relative to project root"),
-        name: z12.string().optional().describe("Checkpoint name (required for checkpoint, restore)"),
-        files: z12.array(z12.string()).optional().describe("Specific files to include in checkpoint (optional, defaults to all tracked files)")
+        op: z13.enum(["undo", "history", "checkpoint", "restore", "list"]).describe("Safety operation"),
+        filePath: z13.string().optional().describe("File path (required for history, optional for undo). Absolute or relative to project root"),
+        name: z13.string().optional().describe("Checkpoint name (required for checkpoint, restore)"),
+        files: z13.array(z13.string()).optional().describe("Specific files to include in checkpoint (optional, defaults to all tracked files)")
       },
       execute: async (args, context) => {
         const op = args.op;
@@ -57793,6 +58135,39 @@ function normalizeGlob(pattern) {
   }
   return pattern;
 }
+function absoluteSearchPath(context, target) {
+  return path6.isAbsolute(target) ? target : path6.resolve(context.directory, target);
+}
+function searchPathExists(context, target) {
+  return fs7.existsSync(absoluteSearchPath(context, target));
+}
+function splitSearchPathArg(context, raw) {
+  if (searchPathExists(context, raw) || !/\s/.test(raw)) {
+    return [raw];
+  }
+  const fragments = raw.trim().split(/\s+/).filter(Boolean);
+  if (fragments.length < 2 || !fragments.every((fragment) => searchPathExists(context, fragment))) {
+    return [raw];
+  }
+  return fragments;
+}
+function searchPathKind(context, target, defaultKind) {
+  try {
+    const stat = fs7.lstatSync(absoluteSearchPath(context, target));
+    if (defaultKind === "file") {
+      return stat.isDirectory() ? "directory" : "file";
+    }
+    return stat.isFile() ? "file" : "directory";
+  } catch {
+    return defaultKind;
+  }
+}
+function searchPathTargets(context, raw, defaultKind) {
+  return splitSearchPathArg(context, raw).map((target) => ({
+    target,
+    kind: searchPathKind(context, target, defaultKind)
+  }));
+}
 function splitIncludeArg(raw) {
   const out = [];
   let depth = 0;
@@ -57842,17 +58217,13 @@ function searchTools(ctx) {
       if (grepDenied)
         return permissionDeniedResponse(grepDenied);
       if (pathArg) {
-        let kind = "file";
-        try {
-          const abs = path6.isAbsolute(pathArg) ? pathArg : path6.resolve(context.directory, pathArg);
-          if (fs7.lstatSync(abs).isDirectory())
-            kind = "directory";
-        } catch {}
-        const externalDenied = await assertExternalDirectoryPermission(context, pathArg, {
-          kind
-        });
-        if (externalDenied)
-          return permissionDeniedResponse(externalDenied);
+        for (const target of searchPathTargets(context, pathArg, "file")) {
+          const externalDenied = await assertExternalDirectoryPermission(context, target.target, {
+            kind: target.kind
+          });
+          if (externalDenied)
+            return permissionDeniedResponse(externalDenied);
+        }
       }
       const response = await callBridge(ctx, context, "grep", {
         pattern,
@@ -57884,23 +58255,22 @@ function searchTools(ctx) {
             globPath = globPattern.slice(0, lastSlash);
             globPattern = `**/${globPattern.slice(lastSlash + 1)}`;
           }
+        } else if (metaIdx === -1) {
+          globPath = path6.dirname(globPattern);
+          globPattern = path6.basename(globPattern);
         }
       }
       const globDenied = await askGlobPermission(context, globPattern, { path: globPath });
       if (globDenied)
         return permissionDeniedResponse(globDenied);
       if (globPath) {
-        let kind = "directory";
-        try {
-          const abs = path6.isAbsolute(globPath) ? globPath : path6.resolve(context.directory, globPath);
-          if (fs7.lstatSync(abs).isFile())
-            kind = "file";
-        } catch {}
-        const externalDenied = await assertExternalDirectoryPermission(context, globPath, {
-          kind
-        });
-        if (externalDenied)
-          return permissionDeniedResponse(externalDenied);
+        for (const target of searchPathTargets(context, globPath, "directory")) {
+          const externalDenied = await assertExternalDirectoryPermission(context, target.target, {
+            kind: target.kind
+          });
+          if (externalDenied)
+            return permissionDeniedResponse(externalDenied);
+        }
       }
       const response = await callBridge(ctx, context, "glob", {
         pattern: globPattern,
@@ -57927,6 +58297,8 @@ function searchTools(ctx) {
 }
 
 // src/tools/semantic.ts
+import { tool as tool14 } from "@opencode-ai/plugin";
+var z14 = tool14.schema;
 function arg2(schema) {
   return schema;
 }
@@ -57951,8 +58323,8 @@ function semanticTools(ctx) {
     ].join(`
 `),
     args: {
-      query: arg2(exports_external.string().describe("Concept or capability to find, phrased as a programmer would describe the code. Examples: 'fuzzy match with whitespace tolerance', 'undo backup before edit', 'retry failed network request'.")),
-      topK: arg2(exports_external.number().optional().describe("Number of results (default: 10, max: 100)"))
+      query: arg2(z14.string().describe("Concept or capability to find, phrased as a programmer would describe the code. Examples: 'fuzzy match with whitespace tolerance', 'undo backup before edit', 'retry failed network request'.")),
+      topK: arg2(optionalInt(1, 100).describe("Number of results (default: 10, max: 100)"))
     },
     execute: async (args, context) => {
       const response = await callBridge(ctx, context, "semantic_search", {
@@ -57977,8 +58349,8 @@ function semanticTools(ctx) {
 }
 
 // src/tools/structure.ts
-import { tool as tool13 } from "@opencode-ai/plugin";
-var z13 = tool13.schema;
+import { tool as tool15 } from "@opencode-ai/plugin";
+var z15 = tool15.schema;
 function structureTools(ctx) {
   return {
     aft_transform: {
@@ -58002,19 +58374,19 @@ function structureTools(ctx) {
 ` + `- add_decorator: { file, target, decorator, formatted, syntax_valid?, format_skipped_reason?, validation_errors?, validate_skipped_reason?, backup_id?, lsp_diagnostics? }
 ` + "- add_struct_tags: { file, target, field, tag_string, formatted, syntax_valid?, format_skipped_reason?, validation_errors?, validate_skipped_reason?, backup_id?, lsp_diagnostics? }",
       args: {
-        op: z13.enum(["add_member", "add_derive", "wrap_try_catch", "add_decorator", "add_struct_tags"]).describe("Transformation operation"),
-        filePath: z13.string().describe("Path to the source file (absolute or relative to project root)"),
-        container: z13.string().optional().describe("Container name for add_member — the class, struct, or impl block to insert into. Appears as 'scope' in the response."),
-        code: z13.string().optional().describe("Member code to insert (add_member)"),
-        position: z13.string().optional().describe("For add_member: 'first', 'last' (default), 'before:name', 'after:name'. For add_decorator: 'first' (default) or 'last' only."),
-        target: z13.string().optional().describe("Target symbol name (add_derive: struct/enum, wrap_try_catch: function, add_decorator: function/class, add_struct_tags: struct)"),
-        derives: z13.array(z13.string()).optional().describe("Derive macro names (add_derive — e.g. ['Clone', 'Debug'])"),
-        catchBody: z13.string().optional().describe("Catch block body (wrap_try_catch — default: 'throw error;')"),
-        decorator: z13.string().optional().describe("Decorator text without @ (add_decorator — e.g. 'staticmethod')"),
-        field: z13.string().optional().describe("Struct field name (add_struct_tags)"),
-        tag: z13.string().optional().describe("Tag key (add_struct_tags — e.g. 'json')"),
-        value: z13.string().optional().describe("Tag value (add_struct_tags — e.g. 'user_name,omitempty')"),
-        validate: z13.enum(["syntax", "full"]).optional().describe("Validation level: 'syntax' (default) or 'full'. Syntax = tree-sitter parse check only. Full = also runs LSP type-checking (slower, catches more errors)")
+        op: z15.enum(["add_member", "add_derive", "wrap_try_catch", "add_decorator", "add_struct_tags"]).describe("Transformation operation"),
+        filePath: z15.string().describe("Path to the source file (absolute or relative to project root)"),
+        container: z15.string().optional().describe("Container name for add_member — the class, struct, or impl block to insert into. Appears as 'scope' in the response."),
+        code: z15.string().optional().describe("Member code to insert (add_member)"),
+        position: z15.string().optional().describe("For add_member: 'first', 'last' (default), 'before:name', 'after:name'. For add_decorator: 'first' (default) or 'last' only."),
+        target: z15.string().optional().describe("Target symbol name (add_derive: struct/enum, wrap_try_catch: function, add_decorator: function/class, add_struct_tags: struct)"),
+        derives: z15.array(z15.string()).optional().describe("Derive macro names (add_derive — e.g. ['Clone', 'Debug'])"),
+        catchBody: z15.string().optional().describe("Catch block body (wrap_try_catch — default: 'throw error;')"),
+        decorator: z15.string().optional().describe("Decorator text without @ (add_decorator — e.g. 'staticmethod')"),
+        field: z15.string().optional().describe("Struct field name (add_struct_tags)"),
+        tag: z15.string().optional().describe("Tag key (add_struct_tags — e.g. 'json')"),
+        value: z15.string().optional().describe("Tag value (add_struct_tags — e.g. 'user_name,omitempty')"),
+        validate: z15.enum(["syntax", "full"]).optional().describe("Validation level: 'syntax' (default) or 'full'. Syntax = tree-sitter parse check only. Full = also runs LSP type-checking (slower, catches more errors)")
       },
       execute: async (args, context) => {
         const op = args.op;
@@ -58482,10 +58854,10 @@ ${lines}
       return { show: false };
     }
     if (storageDir) {
-      const versionFile = join23(storageDir, "last_announced_version");
       try {
-        if (existsSync15(versionFile)) {
-          const lastVersion = readFileSync13(versionFile, "utf-8").trim();
+        const versionFile = repairRootScopedStorageFile(storageDir, "opencode", "last_announced_version");
+        if (existsSync17(versionFile)) {
+          const lastVersion = readFileSync14(versionFile, "utf-8").trim();
           if (lastVersion === ANNOUNCEMENT_VERSION)
             return { show: false };
         }
@@ -58501,8 +58873,9 @@ ${lines}
   rpcServer.handle("mark-announced", async () => {
     if (storageDir && ANNOUNCEMENT_VERSION) {
       try {
-        mkdirSync13(storageDir, { recursive: true });
-        writeFileSync12(join23(storageDir, "last_announced_version"), ANNOUNCEMENT_VERSION);
+        const versionFile = repairRootScopedStorageFile(storageDir, "opencode", "last_announced_version");
+        mkdirSync14(dirname14(versionFile), { recursive: true });
+        writeFileSync12(versionFile, ANNOUNCEMENT_VERSION);
       } catch {}
     }
     return { success: true };