@cortexkit/aft-opencode 0.30.1 → 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;
 }
@@ -51835,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;
@@ -51944,21 +52146,24 @@ ${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
@@ -52006,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(),
@@ -52022,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;
@@ -52046,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) {
@@ -52072,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)
@@ -52110,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)
@@ -52151,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 {
@@ -52165,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(),
@@ -52328,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;
@@ -52346,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;
@@ -52370,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;
@@ -52697,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}`);
   }
@@ -52782,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";
 
@@ -52925,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 {
@@ -52941,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(),
@@ -52966,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 = [];
@@ -53142,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) {
@@ -53263,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;
   }
@@ -53289,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}`);
   }
@@ -53418,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") {
@@ -53502,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 {}
@@ -53665,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";
 }
@@ -53702,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;
@@ -53720,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() {
@@ -53797,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" });
@@ -53909,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) {
@@ -53924,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);
@@ -54061,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";
@@ -54089,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) {
@@ -54109,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}`);
@@ -54428,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";
@@ -54465,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;
 }
@@ -54475,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"))) {
@@ -54484,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}`);
@@ -55538,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");
@@ -55770,12 +56026,13 @@ 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: 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."),
+      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.")
@@ -55867,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 = {
@@ -55875,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) {
@@ -55892,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,
@@ -55900,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");
@@ -55965,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 };
 }
@@ -55974,6 +56290,9 @@ 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));
 }
@@ -57816,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;
@@ -57865,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,
@@ -57907,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,
@@ -58507,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 };
         }
@@ -58526,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 };