@cortexkit/aft-pi 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
@@ -29886,10 +29886,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) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two)), 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) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two)), 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);
@@ -29911,13 +29911,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) => {
@@ -29938,13 +29938,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) {
@@ -34061,6 +34061,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) {
@@ -34071,12 +34076,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()}`);
                 }
@@ -34106,9 +34111,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";
@@ -34141,6 +34145,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}`);
@@ -34231,11 +34239,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`);
       }
@@ -34310,10 +34318,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, [], {
@@ -34559,8 +34571,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";
@@ -34588,6 +34601,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;
@@ -34623,7 +34664,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}`;
@@ -34641,7 +34682,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;
@@ -34730,7 +34771,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;
     }
@@ -34744,13 +34785,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) {
@@ -34813,34 +34858,35 @@ function compressionSavingsPercent(original, compressed) {
 }
 // ../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);
@@ -34848,22 +34894,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) {
@@ -34879,17 +34925,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)
@@ -34897,6 +34943,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) {
@@ -34922,7 +34983,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 {
@@ -34930,7 +34991,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)`);
@@ -34949,12 +35010,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) {
@@ -34995,9 +35062,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")
@@ -35006,11 +35073,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)
@@ -35024,26 +35091,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;
   }
@@ -35093,8 +35160,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";
@@ -35157,9 +35224,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 {
@@ -35188,9 +35255,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.`);
@@ -35209,7 +35276,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;
@@ -35241,7 +35308,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 });
     }
@@ -35251,6 +35318,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);
@@ -35258,23 +35333,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 {}
@@ -35299,7 +35374,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)) {
@@ -35326,7 +35401,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) {
@@ -35356,11 +35431,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}`);
@@ -35390,8 +35465,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}`);
@@ -35407,16 +35482,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}`);
@@ -35431,7 +35506,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);
@@ -35456,8 +35531,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") {
@@ -35472,7 +35547,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 {}
@@ -35486,8 +35561,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}`);
   }
@@ -35513,17 +35588,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;
@@ -35539,7 +35614,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) {
@@ -35567,7 +35642,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)
@@ -35593,7 +35668,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)
@@ -35661,6 +35736,7 @@ function isHomeDirectoryRoot(normalizedKey) {
 
 class BridgePool {
   bridges = new Map;
+  staleBridges = new Set;
   binaryPath;
   maxPoolSize;
   idleTimeoutMs;
@@ -35683,6 +35759,7 @@ class BridgePool {
       onConfigureWarnings: options.onConfigureWarnings,
       onBashCompletion: options.onBashCompletion,
       onBashLongRunning: options.onBashLongRunning,
+      onBashPatternMatch: options.onBashPatternMatch,
       errorPrefix: options.errorPrefix,
       logger: options.logger
     };
@@ -35734,6 +35811,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;
@@ -35757,14 +35840,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) {
@@ -35814,11 +35904,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";
@@ -35968,16 +36058,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));
@@ -36102,13 +36192,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;
@@ -36119,7 +36217,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) {
@@ -36160,6 +36258,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 = {}) {
@@ -36175,15 +36276,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;
       }
@@ -36249,19 +36350,20 @@ 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;
 }
@@ -36499,7 +36601,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);
   }
 }
@@ -36527,13 +36629,18 @@ 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);
     }
   }
   state.pendingCompletions = remaining;
 }
+async function handlePushedPatternMatch(drainContext, frame) {
+  const state = stateFor(drainContext.sessionID);
+  queuePendingPatternMatch(state, frame);
+  await triggerWakeIfPending(drainContext, true);
+}
 function ingestBgCompletions(sessionID, completions) {
   if (!Array.isArray(completions) || completions.length === 0)
     return [];
@@ -36549,7 +36656,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)) {
@@ -36585,6 +36692,8 @@ async function appendToolResultBgCompletions(drainContext, content) {
   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);
   state.pendingCompletions = [];
   for (const completion of deliveredCompletions) {
@@ -36594,7 +36703,7 @@ async function appendToolResultBgCompletions(drainContext, content) {
   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;
@@ -36757,7 +36866,8 @@ function scheduleWake(state, sendWake, onSendFailure, includeDeferredCompletions
       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;
@@ -36822,7 +36932,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))
@@ -36858,10 +36968,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",
@@ -36872,6 +36982,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))
@@ -36941,7 +37065,7 @@ import {
 // package.json
 var package_default = {
   name: "@cortexkit/aft-pi",
-  version: "0.30.1",
+  version: "0.30.2",
   type: "module",
   description: "Pi coding agent extension for Agent File Tools (AFT) — tree-sitter and LSP-powered code analysis",
   main: "dist/index.js",
@@ -36963,7 +37087,7 @@ var package_default = {
     prepublishOnly: "bun run build"
   },
   dependencies: {
-    "@cortexkit/aft-bridge": "0.30.1",
+    "@cortexkit/aft-bridge": "0.30.2",
     "@xterm/headless": "^5.5.0",
     "comment-json": "^5.0.0",
     diff: "^8.0.4",
@@ -36971,12 +37095,12 @@ var package_default = {
     zod: "^4.1.8"
   },
   optionalDependencies: {
-    "@cortexkit/aft-darwin-arm64": "0.30.1",
-    "@cortexkit/aft-darwin-x64": "0.30.1",
-    "@cortexkit/aft-linux-arm64": "0.30.1",
-    "@cortexkit/aft-linux-x64": "0.30.1",
-    "@cortexkit/aft-win32-arm64": "0.30.1",
-    "@cortexkit/aft-win32-x64": "0.30.1"
+    "@cortexkit/aft-darwin-arm64": "0.30.2",
+    "@cortexkit/aft-darwin-x64": "0.30.2",
+    "@cortexkit/aft-linux-arm64": "0.30.2",
+    "@cortexkit/aft-linux-x64": "0.30.2",
+    "@cortexkit/aft-win32-arm64": "0.30.2",
+    "@cortexkit/aft-win32-x64": "0.30.2"
   },
   devDependencies: {
     "@earendil-works/pi-coding-agent": "*",
@@ -37268,9 +37392,13 @@ class AftStatusDialogComponent {
   async fetchOnce() {
     try {
       const bridge = bridgeFor(this.props.pluginCtx, this.props.extCtx.cwd);
+      const sessionId = resolveSessionId(this.props.extCtx);
       const cached = bridge.getCachedStatus();
-      const response = cached ? { success: true, ...cached } : await callBridge(bridge, "status", {}, this.props.extCtx);
-      if (!cached) {
+      const cachedSession = cached?.session;
+      const cachedSessionId = cachedSession?.id;
+      const cacheUsable = cached !== null && cachedSessionId !== undefined && cachedSessionId === sessionId;
+      const response = cacheUsable ? { success: true, ...cached } : await callBridge(bridge, "status", {}, this.props.extCtx);
+      if (!cacheUsable) {
         bridge.cacheStatusSnapshot(response);
       }
       if (this.closed)
@@ -37499,9 +37627,13 @@ function registerStatusCommand(pi, ctx) {
           return;
         }
         const bridge = bridgeFor(ctx, extCtx.cwd);
+        const sessionId = resolveSessionId(extCtx);
         const cached = bridge.getCachedStatus();
-        const response = cached ? { success: true, ...cached } : await callBridge(bridge, "status", {}, extCtx);
-        if (!cached) {
+        const cachedSession = cached?.session;
+        const cachedSessionId = cachedSession?.id;
+        const cacheUsable = cached !== null && cachedSessionId !== undefined && cachedSessionId === sessionId;
+        const response = cacheUsable ? { success: true, ...cached } : await callBridge(bridge, "status", {}, extCtx);
+        if (!cacheUsable) {
           bridge.cacheStatusSnapshot(response);
         }
         const snapshot = coerceAftStatus(response);
@@ -37521,9 +37653,9 @@ function registerStatusCommand(pi, ctx) {
 
 // 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 homedir6 } 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 = {};
@@ -51367,13 +51499,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: [] };
@@ -51390,7 +51522,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) {
@@ -51410,17 +51542,17 @@ ${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 };
 }
 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);
     if (!rawConfig || typeof rawConfig !== "object" || Array.isArray(rawConfig)) {
       warn2(`Config validation error in ${configPath}: root must be an object`);
@@ -51591,15 +51723,15 @@ function mergeConfigs(base, override) {
   };
 }
 function getGlobalPiDir() {
-  return join8(homedir6(), ".pi", "agent");
+  return join9(homedir6(), ".pi", "agent");
 }
 function loadAftConfig(projectDirectory) {
-  const userBasePath = join8(getGlobalPiDir(), "aft");
+  const userBasePath = join9(getGlobalPiDir(), "aft");
   migrateAftConfigFile(`${userBasePath}.jsonc`);
   migrateAftConfigFile(`${userBasePath}.json`);
   const userDetected = detectConfigFile(userBasePath);
   const userConfigPath = userDetected.format !== "none" ? userDetected.path : `${userBasePath}.json`;
-  const projectBasePath = join8(projectDirectory, ".pi", "aft");
+  const projectBasePath = join9(projectDirectory, ".pi", "aft");
   migrateAftConfigFile(`${projectBasePath}.jsonc`);
   migrateAftConfigFile(`${projectBasePath}.json`);
   const projectDetected = detectConfigFile(projectBasePath);
@@ -51626,49 +51758,49 @@ function loadAftConfig(projectDirectory) {
 // src/lsp-auto-install.ts
 import { spawn as spawn2 } from "node:child_process";
 import { createHash as createHash4 } from "node:crypto";
-import { createReadStream, mkdirSync as mkdirSync7, readFileSync as readFileSync6, renameSync as renameSync4, rmSync as rmSync3, statSync as statSync4 } from "node:fs";
-import { join as join11 } from "node:path";
+import { createReadStream, mkdirSync as mkdirSync8, readFileSync as readFileSync7, renameSync as renameSync5, rmSync as rmSync3, statSync as statSync4 } from "node:fs";
+import { join as join12 } from "node:path";
 
 // src/lsp-cache.ts
 import {
   closeSync as closeSync3,
-  mkdirSync as mkdirSync6,
+  mkdirSync as mkdirSync7,
   openSync as openSync3,
-  readFileSync as readFileSync4,
+  readFileSync as readFileSync5,
   statSync as statSync3,
   unlinkSync as unlinkSync5,
   writeFileSync as writeFileSync4
 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 function aftCacheBase() {
   const override = process.env.AFT_CACHE_DIR;
   if (override && override.length > 0)
     return override;
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join9(homedir7(), "AppData", "Local");
-    return join9(base2, "aft");
+    const base2 = localAppData || join10(homedir7(), "AppData", "Local");
+    return join10(base2, "aft");
   }
-  const base = process.env.XDG_CACHE_HOME || join9(homedir7(), ".cache");
-  return join9(base, "aft");
+  const base = process.env.XDG_CACHE_HOME || join10(homedir7(), ".cache");
+  return join10(base, "aft");
 }
 function lspCacheRoot() {
-  return join9(aftCacheBase(), "lsp-packages");
+  return join10(aftCacheBase(), "lsp-packages");
 }
 function lspPackageDir(npmPackage) {
-  return join9(lspCacheRoot(), encodeURIComponent(npmPackage));
+  return join10(lspCacheRoot(), encodeURIComponent(npmPackage));
 }
 function lspBinaryPath(npmPackage, binary) {
-  return join9(lspPackageDir(npmPackage), "node_modules", ".bin", binary);
+  return join10(lspPackageDir(npmPackage), "node_modules", ".bin", binary);
 }
 function lspBinDir(npmPackage) {
-  return join9(lspPackageDir(npmPackage), "node_modules", ".bin");
+  return join10(lspPackageDir(npmPackage), "node_modules", ".bin");
 }
 function isInstalled(npmPackage, binary) {
   for (const candidate of lspBinaryCandidates(binary)) {
     try {
-      if (statSync3(join9(lspBinDir(npmPackage), candidate)).isFile())
+      if (statSync3(join10(lspBinDir(npmPackage), candidate)).isFile())
         return true;
     } catch {}
   }
@@ -51682,23 +51814,23 @@ function lspBinaryCandidates(binary) {
 var INSTALLED_META_FILE = ".aft-installed";
 function writeInstalledMetaIn(installDir, version2, sha256) {
   try {
-    mkdirSync6(installDir, { recursive: true });
+    mkdirSync7(installDir, { recursive: true });
     const meta3 = {
       version: version2,
       installedAt: new Date().toISOString(),
       ...sha256 ? { sha256 } : {}
     };
-    writeFileSync4(join9(installDir, INSTALLED_META_FILE), JSON.stringify(meta3), "utf8");
+    writeFileSync4(join10(installDir, INSTALLED_META_FILE), JSON.stringify(meta3), "utf8");
   } catch (err) {
     log2(`[lsp-cache] failed to write installed-meta in ${installDir}: ${err}`);
   }
 }
 function readInstalledMetaIn(installDir) {
-  const path2 = join9(installDir, INSTALLED_META_FILE);
+  const path2 = join10(installDir, INSTALLED_META_FILE);
   try {
     if (!statSync3(path2).isFile())
       return null;
-    const raw = readFileSync4(path2, "utf8");
+    const raw = readFileSync5(path2, "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.version !== "string" || parsed.version.length === 0)
       return null;
@@ -51718,11 +51850,11 @@ function readInstalledMeta(packageKey) {
   return readInstalledMetaIn(lspPackageDir(packageKey));
 }
 function lockPath(npmPackage) {
-  return join9(lspPackageDir(npmPackage), ".aft-installing");
+  return join10(lspPackageDir(npmPackage), ".aft-installing");
 }
 var STALE_LOCK_MS2 = 30 * 60 * 1000;
 function acquireInstallLock(lockKey) {
-  mkdirSync6(lspPackageDir(lockKey), { recursive: true });
+  mkdirSync7(lspPackageDir(lockKey), { recursive: true });
   const lock = lockPath(lockKey);
   const tryClaim = () => {
     try {
@@ -51748,7 +51880,7 @@ ${new Date().toISOString()}
   let owningPid = null;
   let lockMtimeMs = 0;
   try {
-    const raw = readFileSync4(lock, "utf8");
+    const raw = readFileSync5(lock, "utf8");
     const firstLine = raw.split(/\r?\n/, 1)[0]?.trim() ?? "";
     const parsed = Number.parseInt(firstLine, 10);
     if (Number.isFinite(parsed) && parsed > 0)
@@ -51786,7 +51918,7 @@ function releaseInstallLock(lockKey) {
   try {
     let owningPid = null;
     try {
-      const raw = readFileSync4(lock, "utf8");
+      const raw = readFileSync5(lock, "utf8");
       const firstLine = raw.split(/\r?\n/, 1)[0]?.trim() ?? "";
       const parsed = Number.parseInt(firstLine, 10);
       if (Number.isFinite(parsed) && parsed > 0)
@@ -51825,9 +51957,9 @@ async function withInstallLock(lockKey, task) {
 }
 var VERSION_CHECK_FILE = ".aft-version-check";
 function readVersionCheck(npmPackage) {
-  const file2 = join9(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
+  const file2 = join10(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
   try {
-    const raw = readFileSync4(file2, "utf8");
+    const raw = readFileSync5(file2, "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.last_checked === "string") {
       return {
@@ -51841,8 +51973,8 @@ function readVersionCheck(npmPackage) {
   }
 }
 function writeVersionCheck(npmPackage, latest) {
-  mkdirSync6(lspPackageDir(npmPackage), { recursive: true });
-  const file2 = join9(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
+  mkdirSync7(lspPackageDir(npmPackage), { recursive: true });
+  const file2 = join10(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
   const record2 = {
     last_checked: new Date().toISOString(),
     latest_eligible: latest
@@ -52004,8 +52136,8 @@ var NPM_LSP_TABLE = [
 ];
 
 // src/lsp-project-relevance.ts
-import { existsSync as existsSync7, readdirSync as readdirSync3, readFileSync as readFileSync5 } from "node:fs";
-import { join as join10 } from "node:path";
+import { existsSync as existsSync8, readdirSync as readdirSync3, readFileSync as readFileSync6 } from "node:fs";
+import { join as join11 } from "node:path";
 var MAX_WALK_DIRS = 200;
 var MAX_WALK_DEPTH = 4;
 var NOISE_DIRS = new Set([
@@ -52022,7 +52154,7 @@ function hasRootMarker(projectRoot, rootMarkers) {
   if (!rootMarkers)
     return false;
   for (const marker of rootMarkers) {
-    if (existsSync7(join10(projectRoot, marker)))
+    if (existsSync8(join11(projectRoot, marker)))
       return true;
   }
   return false;
@@ -52046,7 +52178,7 @@ function hasPackageJsonDep(projectRoot, depNames) {
 }
 function readPackageJson(projectRoot) {
   try {
-    const raw = readFileSync5(join10(projectRoot, "package.json"), "utf8");
+    const raw = readFileSync6(join11(projectRoot, "package.json"), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null)
       return null;
@@ -52076,7 +52208,7 @@ function relevantExtensionsInProject(projectRoot, extToServer) {
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (current.depth < MAX_WALK_DEPTH && !NOISE_DIRS.has(entry.name.toLowerCase())) {
-          queue.push({ dir: join10(current.dir, entry.name), depth: current.depth + 1 });
+          queue.push({ dir: join11(current.dir, entry.name), depth: current.depth + 1 });
         }
         continue;
       }
@@ -52373,16 +52505,16 @@ function installedBinaryPath(spec) {
   return null;
 }
 function sha256OfFileSync(path2) {
-  return createHash4("sha256").update(readFileSync6(path2)).digest("hex");
+  return createHash4("sha256").update(readFileSync7(path2)).digest("hex");
 }
 function quarantineCachedNpmInstall(spec, reason) {
   const packageDir = lspPackageDir(spec.npm);
-  const dest = join11(packageDir, "..", ".quarantine", encodeURIComponent(spec.npm), `${Date.now()}`);
+  const dest = join12(packageDir, "..", ".quarantine", encodeURIComponent(spec.npm), `${Date.now()}`);
   warn2(`[lsp] tofu_mismatch ${spec.npm}: ${reason}; quarantining ${packageDir} -> ${dest}`);
   try {
-    mkdirSync7(join11(dest, ".."), { recursive: true });
+    mkdirSync8(join12(dest, ".."), { recursive: true });
     rmSync3(dest, { recursive: true, force: true });
-    renameSync4(packageDir, dest);
+    renameSync5(packageDir, dest);
   } catch (err) {
     warn2(`[lsp] tofu_mismatch ${spec.npm}: failed to quarantine cache entry: ${err}`);
   }
@@ -52429,7 +52561,6 @@ function runAutoInstall(projectRoot, config2, fetchImpl2 = fetch) {
       continue;
     }
     installsStarted += 1;
-    installingBinaries.push(spec.binary);
     const controller = new AbortController;
     const promise2 = ensureServerInstalled(spec, config2, fetchImpl2, controller.signal).then((outcome) => {
       if (!outcome.started)
@@ -52458,25 +52589,25 @@ function runAutoInstall(projectRoot, config2, fetchImpl2 = fetch) {
 
 // src/lsp-github-install.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { createHash as createHash5, randomBytes } from "node:crypto";
+import { createHash as createHash5, randomBytes as randomBytes2 } from "node:crypto";
 import {
   copyFileSync as copyFileSync3,
   createReadStream as createReadStream2,
   createWriteStream as createWriteStream3,
-  existsSync as existsSync8,
+  existsSync as existsSync9,
   lstatSync as lstatSync2,
-  mkdirSync as mkdirSync8,
+  mkdirSync as mkdirSync9,
   readdirSync as readdirSync4,
-  readFileSync as readFileSync7,
+  readFileSync as readFileSync8,
   readlinkSync as readlinkSync2,
   realpathSync as realpathSync3,
-  renameSync as renameSync5,
+  renameSync as renameSync6,
   rmSync as rmSync4,
   statSync as statSync5,
   unlinkSync as unlinkSync6,
   writeFileSync as writeFileSync5
 } from "node:fs";
-import { dirname as dirname3, join as join12, relative as relative2, resolve as resolve2 } from "node:path";
+import { dirname as dirname4, join as join13, relative as relative2, resolve as resolve2 } from "node:path";
 import { Readable as Readable3 } from "node:stream";
 import { pipeline as pipeline3 } from "node:stream/promises";
 
@@ -52566,26 +52697,26 @@ function detectHostPlatform() {
 
 // src/lsp-github-install.ts
 function ghCacheRoot() {
-  return join12(aftCacheBase(), "lsp-binaries");
+  return join13(aftCacheBase(), "lsp-binaries");
 }
 function ghPackageDir(spec) {
-  return join12(ghCacheRoot(), spec.id);
+  return join13(ghCacheRoot(), spec.id);
 }
 function ghBinDir(spec) {
-  return join12(ghPackageDir(spec), "bin");
+  return join13(ghPackageDir(spec), "bin");
 }
 function ghExtractDir(spec) {
-  return join12(ghPackageDir(spec), "extracted");
+  return join13(ghPackageDir(spec), "extracted");
 }
 var INSTALLED_META_FILE2 = ".aft-installed";
 function ghBinaryPath(spec, platform) {
   const ext = platform === "win32" ? ".exe" : "";
-  return join12(ghBinDir(spec), `${spec.binary}${ext}`);
+  return join13(ghBinDir(spec), `${spec.binary}${ext}`);
 }
 function isGithubInstalled(spec, platform) {
   for (const candidate of ghBinaryCandidates(spec, platform)) {
     try {
-      if (statSync5(join12(ghBinDir(spec), candidate)).isFile())
+      if (statSync5(join13(ghBinDir(spec), candidate)).isFile())
         return true;
     } catch {}
   }
@@ -52598,10 +52729,10 @@ function ghBinaryCandidates(spec, platform) {
 }
 function readGithubInstalledMetaIn(installDir) {
   try {
-    const path2 = join12(installDir, INSTALLED_META_FILE2);
+    const path2 = join13(installDir, INSTALLED_META_FILE2);
     if (!statSync5(path2).isFile())
       return null;
-    const parsed = JSON.parse(readFileSync7(path2, "utf8"));
+    const parsed = JSON.parse(readFileSync8(path2, "utf8"));
     if (typeof parsed.version !== "string" || parsed.version.length === 0)
       return null;
     return {
@@ -52617,7 +52748,7 @@ function readGithubInstalledMetaIn(installDir) {
 }
 function writeGithubInstalledMetaIn(installDir, version2, binarySha256, archiveSha256) {
   try {
-    mkdirSync8(installDir, { recursive: true });
+    mkdirSync9(installDir, { recursive: true });
     const meta3 = {
       version: version2,
       installedAt: new Date().toISOString(),
@@ -52625,7 +52756,7 @@ function writeGithubInstalledMetaIn(installDir, version2, binarySha256, archiveS
       binarySha256,
       ...archiveSha256 ? { archiveSha256 } : {}
     };
-    writeFileSync5(join12(installDir, INSTALLED_META_FILE2), JSON.stringify(meta3), "utf8");
+    writeFileSync5(join13(installDir, INSTALLED_META_FILE2), JSON.stringify(meta3), "utf8");
   } catch (err) {
     warn2(`[lsp] failed to write github installed metadata in ${installDir}: ${err}`);
   }
@@ -52642,7 +52773,7 @@ function sha256OfFile(path2) {
   });
 }
 function sha256OfFileSync2(path2) {
-  return createHash5("sha256").update(readFileSync7(path2)).digest("hex");
+  return createHash5("sha256").update(readFileSync8(path2)).digest("hex");
 }
 async function fetchReleaseByTag(githubRepo, tag, fetchImpl2, signal) {
   const candidates = [];
@@ -52818,7 +52949,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}`);
     }
-    mkdirSync8(dirname3(destPath), { recursive: true });
+    mkdirSync9(dirname4(destPath), { recursive: true });
     let bytesWritten = 0;
     const guard = new TransformStream({
       transform(chunk, controller) {
@@ -52874,7 +53005,7 @@ function validateExtraction(stagingRoot) {
       throw new Error(`failed to read staging dir ${dir}: ${err}`);
     }
     for (const entry of entries) {
-      const full = join12(dir, entry);
+      const full = join13(dir, entry);
       let lst;
       try {
         lst = lstatSync2(full);
@@ -52939,12 +53070,12 @@ 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 {
     rmSync4(stagingDir, { recursive: true, force: true });
   } catch {}
-  mkdirSync8(stagingDir, { recursive: true });
+  mkdirSync9(stagingDir, { recursive: true });
   try {
     precheckArchiveContents(archivePath, archiveType);
     runPlatformExtractor(archivePath, stagingDir, archiveType);
@@ -52952,7 +53083,7 @@ function extractArchiveSafely(archivePath, destDir, archiveType) {
     try {
       rmSync4(destDir, { recursive: true, force: true });
     } catch {}
-    renameSync5(stagingDir, destDir);
+    renameSync6(stagingDir, destDir);
   } catch (err) {
     try {
       rmSync4(stagingDir, { recursive: true, force: true });
@@ -52962,12 +53093,12 @@ function extractArchiveSafely(archivePath, destDir, archiveType) {
 }
 function quarantineCachedGithubInstall(spec, reason) {
   const packageDir = ghPackageDir(spec);
-  const dest = join12(ghCacheRoot(), ".quarantine", encodeURIComponent(spec.id), `${Date.now()}`);
+  const dest = join13(ghCacheRoot(), ".quarantine", encodeURIComponent(spec.id), `${Date.now()}`);
   warn2(`[lsp] tofu_mismatch ${spec.id}: ${reason}; quarantining ${packageDir} -> ${dest}`);
   try {
-    mkdirSync8(dirname3(dest), { recursive: true });
+    mkdirSync9(dirname4(dest), { recursive: true });
     rmSync4(dest, { recursive: true, force: true });
-    renameSync5(packageDir, dest);
+    renameSync6(packageDir, dest);
   } catch (err) {
     warn2(`[lsp] tofu_mismatch ${spec.id}: failed to quarantine cache entry: ${err}`);
   }
@@ -52975,7 +53106,7 @@ function quarantineCachedGithubInstall(spec, reason) {
 function validateCachedGithubInstall(spec, platform) {
   const packageDir = ghPackageDir(spec);
   const meta3 = readGithubInstalledMetaIn(packageDir);
-  const binaryPath = ghBinaryCandidates(spec, platform).map((candidate) => join12(ghBinDir(spec), candidate)).find((candidate) => {
+  const binaryPath = ghBinaryCandidates(spec, platform).map((candidate) => join13(ghBinDir(spec), candidate)).find((candidate) => {
     try {
       return statSync5(candidate).isFile();
     } catch {
@@ -53053,7 +53184,7 @@ async function downloadAndInstall(spec, tag, assets, platform, arch, fetchImpl2,
   }
   const pkgDir = ghPackageDir(spec);
   const extractDir = ghExtractDir(spec);
-  const archivePath = join12(pkgDir, expected.name);
+  const archivePath = join13(pkgDir, expected.name);
   log2(`[lsp] downloading ${spec.id} ${tag} → ${matchingAsset.url}`);
   try {
     await downloadFile(matchingAsset.url, archivePath, fetchImpl2, matchingAsset.size, signal);
@@ -53093,13 +53224,13 @@ async function downloadAndInstall(spec, tag, assets, platform, arch, fetchImpl2,
       unlinkSync6(archivePath);
     } catch {}
   }
-  const innerBinaryPath = join12(extractDir, spec.binaryPathInArchive(platform, arch, version2));
-  if (!existsSync8(innerBinaryPath)) {
+  const innerBinaryPath = join13(extractDir, spec.binaryPathInArchive(platform, arch, version2));
+  if (!existsSync9(innerBinaryPath)) {
     error2(`[lsp] ${spec.id}: extracted binary not found at ${innerBinaryPath}`);
     return null;
   }
   const targetBinary = ghBinaryPath(spec, platform);
-  mkdirSync8(dirname3(targetBinary), { recursive: true });
+  mkdirSync9(dirname4(targetBinary), { recursive: true });
   try {
     copyFileSync3(innerBinaryPath, targetBinary);
     if (platform !== "win32") {
@@ -53178,7 +53309,7 @@ function runGithubAutoInstall(relevantServers, config2, fetchImpl2 = fetch) {
   if (!host) {
     for (const spec of GITHUB_LSP_TABLE) {
       try {
-        if (existsSync8(ghBinDir(spec))) {
+        if (existsSync9(ghBinDir(spec))) {
           cachedBinDirs.push(ghBinDir(spec));
         }
       } catch {}
@@ -53208,7 +53339,6 @@ function runGithubAutoInstall(relevantServers, config2, fetchImpl2 = fetch) {
       continue;
     }
     installsStarted += 1;
-    installingBinaries.push(spec.binary);
     const controller = new AbortController;
     const promise2 = ensureGithubInstalled(spec, config2, fetchImpl2, host.platform, host.arch, controller.signal).then((outcome) => {
       if (!outcome.started)
@@ -53276,8 +53406,8 @@ function discoverRelevantGithubServers(projectRoot) {
 }
 
 // src/notifications.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync9, readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "node:fs";
-import { join as join13 } from "node:path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync10, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "node:fs";
+import { dirname as dirname5 } from "node:path";
 var WARNING_MARKER = "\uD83D\uDD27 AFT: ⚠️";
 var FEATURE_MARKER = "\uD83D\uDD27 AFT: ✨";
 function sendIgnoredMessage(client, sessionId, text) {
@@ -53370,10 +53500,10 @@ async function deliverConfigureWarnings(opts, warnings) {
   }
 }
 function sendFeatureAnnouncement(version2, features, footer, storageDir) {
-  const versionFile = join13(storageDir, "last_announced_version");
+  const versionFile = repairRootScopedStorageFile(storageDir, "pi", "last_announced_version");
   try {
-    if (existsSync9(versionFile)) {
-      const lastVersion = readFileSync8(versionFile, "utf-8").trim();
+    if (existsSync10(versionFile)) {
+      const lastVersion = readFileSync9(versionFile, "utf-8").trim();
       if (lastVersion === version2)
         return;
     }
@@ -53388,7 +53518,7 @@ function sendFeatureAnnouncement(version2, features, footer, storageDir) {
   log2(sections.join(`
 `));
   try {
-    mkdirSync9(storageDir, { recursive: true });
+    mkdirSync10(dirname5(versionFile), { recursive: true });
     writeFileSync6(versionFile, version2);
   } catch {}
 }
@@ -54304,7 +54434,7 @@ async function bashStatusSnapshot(bridge, extCtx, taskId, outputMode, options) {
 async function waitForBashStatus(ctx, bridge, extCtx, taskId, outputMode, waitFor, waitForExit, 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 = {
@@ -54318,12 +54448,7 @@ async function waitForBashStatus(ctx, bridge, extCtx, taskId, outputMode, waitFo
   try {
     while (true) {
       const data = await bashStatusSnapshot(bridge, extCtx, taskId, outputMode, bridgeOptions);
-      if (waitForExit && isTerminalStatus(data.status)) {
-        sawTerminal = true;
-        consumeBgCompletion(sessionId, taskId);
-        await markBgCompletionDelivered({ ctx, directory: extCtx.cwd, sessionID: sessionId }, taskId);
-        return withWaited(data, { reason: "exited", elapsed_ms: Date.now() - startedAt });
-      }
+      const terminal = isTerminalStatus(data.status);
       if (waitFor) {
         const scan = await readNewTaskOutput(extCtx, taskId, data, spillCursor);
         if (scan) {
@@ -54333,6 +54458,11 @@ async function waitForBashStatus(ctx, bridge, extCtx, taskId, outputMode, waitFo
           scanText += scan.text;
           const match = findWaitMatch(scanText, waitFor);
           if (match) {
+            if (waitForExit && terminal) {
+              sawTerminal = true;
+              consumeBgCompletion(sessionId, taskId);
+              await markBgCompletionDelivered({ ctx, directory: extCtx.cwd, sessionID: sessionId }, taskId);
+            }
             return withWaited(data, {
               reason: "matched",
               elapsed_ms: Date.now() - startedAt,
@@ -54341,9 +54471,14 @@ async function waitForBashStatus(ctx, bridge, extCtx, taskId, outputMode, waitFo
             });
           }
         }
-        if (isTerminalStatus(data.status)) {
-          return withWaited(data, { reason: "exited", elapsed_ms: Date.now() - startedAt });
+      }
+      if (terminal) {
+        if (waitForExit) {
+          sawTerminal = true;
+          consumeBgCompletion(sessionId, taskId);
+          await markBgCompletionDelivered({ ctx, directory: extCtx.cwd, sessionID: sessionId }, taskId);
         }
+        return withWaited(data, { reason: "exited", elapsed_ms: Date.now() - startedAt });
       }
       if (Date.now() >= deadline) {
         return withWaited(data, { reason: "timeout", elapsed_ms: Date.now() - startedAt });
@@ -54353,21 +54488,45 @@ async function waitForBashStatus(ctx, bridge, extCtx, taskId, outputMode, waitFo
   } finally {
     if (waitForExit && !sawTerminal)
       unmarkTaskWaiting(sessionId, taskId);
+    if (waitFor) {
+      await disposePtyTerminal(watchPtyCacheKey(extCtx, taskId));
+    }
   }
 }
 async function readNewTaskOutput(extCtx, taskId, data, cursor) {
   const outputPath = data.output_path;
-  if (!outputPath)
-    return;
   if (data.mode === "pty") {
+    if (!outputPath)
+      return;
     const { rows, cols } = ptyDimensions(data);
-    const state = await getOrCreatePtyTerminal(ptyCacheKey(extCtx, taskId), outputPath, rows, cols);
+    const state = await getOrCreatePtyTerminal(watchPtyCacheKey(extCtx, taskId), outputPath, rows, cols);
     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 fs3.open(outputPath, "r");
@@ -54479,6 +54638,9 @@ function ptyDimensions(data) {
 function ptyCacheKey(extCtx, taskId) {
   return `${extCtx.cwd}::${resolveSessionId(extCtx) ?? "__default__"}::${taskId}`;
 }
+function watchPtyCacheKey(extCtx, taskId) {
+  return `${ptyCacheKey(extCtx, taskId)}::watch`;
+}
 function isTerminalStatus(status) {
   return status === "completed" || status === "failed" || status === "killed" || status === "timed_out";
 }
@@ -55434,6 +55596,14 @@ function renderCallTreeNode(node, depth, lines) {
     renderCallTreeNode(child, depth + 1, lines);
   });
 }
+function depthWarning(response, theme, depthField = "depth_limited", truncatedField = "truncated") {
+  const limited = asBoolean(response[depthField]);
+  const truncated = asNumber(response[truncatedField]) ?? 0;
+  if (!limited && truncated === 0)
+    return "";
+  const detail = truncated > 0 ? `, ${truncated} truncated` : "";
+  return theme.fg("warning", `(depth limited${detail})`);
+}
 function renderTracePath(path2, index, lines) {
   lines.push(`Path ${index + 1}`);
   asRecords(path2.hops).forEach((hop, hopIndex) => {
@@ -55451,12 +55621,16 @@ function buildNavigateSections(args, payload, theme) {
   if (args.op === "call_tree") {
     const lines = [];
     renderCallTreeNode(response, 0, lines);
+    const warning = depthWarning(response, theme);
+    if (warning)
+      lines.push(warning);
     return lines.length > 0 ? lines : [theme.fg("muted", "No call tree available.")];
   }
   if (args.op === "callers") {
     const groups = asRecords(response.callers);
+    const warning = depthWarning(response, theme);
     const sections2 = [
-      `${theme.fg("success", `${asNumber(response.total_callers) ?? 0} caller${(asNumber(response.total_callers) ?? 0) === 1 ? "" : "s"}`)} ${theme.fg("muted", `${groups.length} file group${groups.length === 1 ? "" : "s"}`)}`
+      `${theme.fg("success", `${asNumber(response.total_callers) ?? 0} caller${(asNumber(response.total_callers) ?? 0) === 1 ? "" : "s"}`)} ${theme.fg("muted", `${groups.length} file group${groups.length === 1 ? "" : "s"}`)} ${warning}`.trim()
     ];
     groups.forEach((group) => {
       const file2 = shortenPath(asString(group.file) ?? "(unknown file)");
@@ -55471,8 +55645,9 @@ function buildNavigateSections(args, payload, theme) {
   }
   if (args.op === "trace_to") {
     const paths = asRecords(response.paths);
+    const warning = depthWarning(response, theme, "max_depth_reached", "truncated_paths");
     const sections2 = [
-      `${theme.fg("success", `${asNumber(response.total_paths) ?? paths.length} path${(asNumber(response.total_paths) ?? paths.length) === 1 ? "" : "s"}`)} ${theme.fg("muted", `${asNumber(response.entry_points_found) ?? 0} entry point${(asNumber(response.entry_points_found) ?? 0) === 1 ? "" : "s"}`)}`
+      `${theme.fg("success", `${asNumber(response.total_paths) ?? paths.length} path${(asNumber(response.total_paths) ?? paths.length) === 1 ? "" : "s"}`)} ${theme.fg("muted", `${asNumber(response.entry_points_found) ?? 0} entry point${(asNumber(response.entry_points_found) ?? 0) === 1 ? "" : "s"}`)} ${warning}`.trim()
     ];
     if (paths.length === 0)
       sections2.push(theme.fg("muted", "No entry paths found."));
@@ -55486,8 +55661,9 @@ function buildNavigateSections(args, payload, theme) {
   }
   if (args.op === "impact") {
     const callers = asRecords(response.callers);
+    const warning = depthWarning(response, theme);
     const sections2 = [
-      `${theme.fg("warning", `${asNumber(response.total_affected) ?? callers.length} affected call site${(asNumber(response.total_affected) ?? callers.length) === 1 ? "" : "s"}`)} ${theme.fg("muted", `${asNumber(response.affected_files) ?? 0} file${(asNumber(response.affected_files) ?? 0) === 1 ? "" : "s"}`)}`
+      `${theme.fg("warning", `${asNumber(response.total_affected) ?? callers.length} affected call site${(asNumber(response.total_affected) ?? callers.length) === 1 ? "" : "s"}`)} ${theme.fg("muted", `${asNumber(response.affected_files) ?? 0} file${(asNumber(response.affected_files) ?? 0) === 1 ? "" : "s"}`)} ${warning}`.trim()
     ];
     if (callers.length === 0)
       sections2.push(theme.fg("muted", "No impacted callers found."));
@@ -56459,6 +56635,10 @@ function shouldPrepareOnnxRuntime(config2) {
   const isFastembedSemanticBackend = (config2.semantic?.backend ?? "fastembed") === "fastembed";
   return config2.semantic_search === true && isFastembedSemanticBackend;
 }
+function bridgeDirectoryFromCallback(bridge, fallback) {
+  const cwd = bridge?.cwd;
+  return typeof cwd === "string" && cwd.length > 0 ? cwd : fallback;
+}
 async function handleConfigureWarningsForSession(context) {
   const validWarnings = coerceConfigureWarnings(context.warnings);
   if (!context.sessionId) {
@@ -56675,21 +56855,32 @@ ${lines}
         });
       }, 0);
     },
-    onBashCompletion: (completion) => {
+    onBashCompletion: (completion, bridge) => {
+      const directory = bridgeDirectoryFromCallback(bridge, process.cwd());
       handlePushedBgCompletion({
         ctx,
-        directory: process.cwd(),
+        directory,
         sessionID: completion.session_id,
         runtime: pi
       }, completion);
     },
-    onBashLongRunning: (reminder) => {
+    onBashLongRunning: (reminder, bridge) => {
+      const directory = bridgeDirectoryFromCallback(bridge, process.cwd());
       handlePushedBgLongRunning({
         ctx,
-        directory: process.cwd(),
+        directory,
         sessionID: reminder.session_id,
         runtime: pi
       }, reminder);
+    },
+    onBashPatternMatch: (frame, bridge) => {
+      const directory = bridgeDirectoryFromCallback(bridge, process.cwd());
+      handlePushedPatternMatch({
+        ctx,
+        directory,
+        sessionID: frame.session_id,
+        runtime: pi
+      }, frame);
     }
   };
   pool = new BridgePool(binaryPath, poolOptions, configOverrides);
@@ -56786,28 +56977,31 @@ ${lines}
       runtime: pi
     });
   });
-  pi.on("session_shutdown", async () => {
+  const unregisterShutdownCleanup = registerShutdownCleanup(async () => {
     try {
       await Promise.allSettled([abortInFlightAutoInstalls(), abortInFlightGithubInstalls()]);
       await disposeAllPtyTerminals();
       await pool.shutdown();
-      log2("Bridge pool shut down");
     } catch (err) {
-      warn2(`Error during bridge shutdown: ${err instanceof Error ? err.message : String(err)}`);
+      warn2(`Error during process shutdown: ${err instanceof Error ? err.message : String(err)}`);
     }
   });
-  registerShutdownCleanup(async () => {
+  pi.on("session_shutdown", async () => {
     try {
       await Promise.allSettled([abortInFlightAutoInstalls(), abortInFlightGithubInstalls()]);
       await disposeAllPtyTerminals();
       await pool.shutdown();
+      log2("Bridge pool shut down");
     } catch (err) {
-      warn2(`Error during process shutdown: ${err instanceof Error ? err.message : String(err)}`);
+      warn2(`Error during bridge shutdown: ${err instanceof Error ? err.message : String(err)}`);
+    } finally {
+      unregisterShutdownCleanup();
     }
   });
   log2(`AFT extension ready (surface=${config2.tool_surface ?? "recommended"})`);
 }
 var __test__2 = {
+  bridgeDirectoryFromCallback,
   resolveToolSurface,
   handleConfigureWarningsForSession,
   shouldPrepareOnnxRuntime,