@cortexkit/aft-pi 0.30.0 → 0.30.2

package/dist/index.js

@@ -12399,7 +12399,7 @@ var require_snapshot_utils = __commonJS((exports, module) => {
 // ../../node_modules/.bun/undici@7.25.0/node_modules/undici/lib/mock/snapshot-recorder.js
 var require_snapshot_recorder = __commonJS((exports, module) => {
   var { writeFile, readFile, mkdir } = __require("node:fs/promises");
-  var { dirname: dirname3, resolve: resolve2 } = __require("node:path");
+  var { dirname: dirname4, resolve: resolve2 } = __require("node:path");
   var { setTimeout: setTimeout2, clearTimeout: clearTimeout2 } = __require("node:timers");
   var { InvalidArgumentError, UndiciError } = require_errors();
   var { hashId, isUrlExcludedFactory, normalizeHeaders, createHeaderFilters } = require_snapshot_utils();
@@ -12594,7 +12594,7 @@ var require_snapshot_recorder = __commonJS((exports, module) => {
         throw new InvalidArgumentError("Snapshot path is required");
       }
       const resolvedPath = resolve2(path);
-      await mkdir(dirname3(resolvedPath), { recursive: true });
+      await mkdir(dirname4(resolvedPath), { recursive: true });
       const data = Array.from(this.#snapshots.entries()).map(([hash, snapshot]) => ({
         hash,
         snapshot
@@ -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.0",
+  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.0",
+    "@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.0",
-    "@cortexkit/aft-darwin-x64": "0.30.0",
-    "@cortexkit/aft-linux-arm64": "0.30.0",
-    "@cortexkit/aft-linux-x64": "0.30.0",
-    "@cortexkit/aft-win32-arm64": "0.30.0",
-    "@cortexkit/aft-win32-x64": "0.30.0"
+    "@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": "*",
@@ -37170,6 +37294,22 @@ function formatStatusDialogMessage(status) {
 }
 
 // src/tools/_shared.ts
+import { Type } from "typebox";
+var optionalInt = (_min, _max) => Type.Optional(Type.Any({ description: "(integer)" }));
+function coerceOptionalInt(v, paramName, min, max) {
+  if (v === undefined || v === null || v === "")
+    return;
+  if (typeof v === "number" && (v === 0 || !Number.isFinite(v)))
+    return;
+  const n = typeof v === "string" ? Number(v) : v;
+  if (typeof n !== "number" || !Number.isInteger(n)) {
+    throw new Error(`${paramName} must be an integer between ${min} and ${max}`);
+  }
+  if (n < min || n > max) {
+    throw new Error(`${paramName} must be between ${min} and ${max}`);
+  }
+  return n;
+}
 var LONG_RUNNING_COMMAND_TIMEOUT_MS = {
   callers: 60000,
   trace_to: 60000,
@@ -37252,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)
@@ -37483,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);
@@ -37505,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 = {};
@@ -51351,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: [] };
@@ -51374,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) {
@@ -51394,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`);
@@ -51575,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);
@@ -51610,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 {}
   }
@@ -51666,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;
@@ -51702,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 {
@@ -51732,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)
@@ -51770,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)
@@ -51809,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 {
@@ -51825,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
@@ -51988,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([
@@ -52006,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;
@@ -52030,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;
@@ -52060,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;
       }
@@ -52357,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}`);
   }
@@ -52413,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)
@@ -52442,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";
 
@@ -52550,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 {}
   }
@@ -52582,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 {
@@ -52601,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(),
@@ -52609,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}`);
   }
@@ -52626,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 = [];
@@ -52802,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) {
@@ -52858,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);
@@ -52923,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);
@@ -52936,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 });
@@ -52946,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}`);
   }
@@ -52959,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 {
@@ -53037,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);
@@ -53077,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") {
@@ -53162,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 {}
@@ -53192,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)
@@ -53260,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) {
@@ -53354,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;
     }
@@ -53372,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 {}
 }
@@ -53515,7 +53661,7 @@ function registerShutdownCleanup(fn) {
 
 // src/tools/ast.ts
 import { StringEnum } from "@earendil-works/pi-ai";
-import { Type } from "typebox";
+import { Type as Type2 } from "typebox";
 
 // src/tools/render-helpers.ts
 import { homedir as homedir8 } from "node:os";
@@ -53710,22 +53856,22 @@ function renderUnifiedDiff(unifiedDiff) {
 var AstLang = StringEnum(["typescript", "tsx", "javascript", "python", "rust", "go"], {
   description: "Target language"
 });
-var SearchParams = Type.Object({
-  pattern: Type.String({
+var SearchParams = Type2.Object({
+  pattern: Type2.String({
     description: "AST pattern with meta-variables (`$VAR` matches one node, `$$$` matches many). Must be a complete AST node."
   }),
   lang: AstLang,
-  paths: Type.Optional(Type.Array(Type.String(), { description: "Paths to search (default: ['.'])" })),
-  globs: Type.Optional(Type.Array(Type.String(), { description: "Include/exclude globs (prefix `!` to exclude)" })),
-  contextLines: Type.Optional(Type.Number({ description: "Number of context lines around each match" }))
+  paths: Type2.Optional(Type2.Array(Type2.String(), { description: "Paths to search (default: ['.'])" })),
+  globs: Type2.Optional(Type2.Array(Type2.String(), { description: "Include/exclude globs (prefix `!` to exclude)" })),
+  contextLines: Type2.Optional(Type2.Number({ description: "Number of context lines around each match" }))
 });
-var ReplaceParams = Type.Object({
-  pattern: Type.String({ description: "AST pattern with meta-variables" }),
-  rewrite: Type.String({ description: "Replacement pattern, can reference $VAR from pattern" }),
+var ReplaceParams = Type2.Object({
+  pattern: Type2.String({ description: "AST pattern with meta-variables" }),
+  rewrite: Type2.String({ description: "Replacement pattern, can reference $VAR from pattern" }),
   lang: AstLang,
-  paths: Type.Optional(Type.Array(Type.String(), { description: "Paths (default: ['.'])" })),
-  globs: Type.Optional(Type.Array(Type.String(), { description: "Include/exclude globs" })),
-  dryRun: Type.Optional(Type.Boolean({ description: "Preview without applying (default: false)" }))
+  paths: Type2.Optional(Type2.Array(Type2.String(), { description: "Paths (default: ['.'])" })),
+  globs: Type2.Optional(Type2.Array(Type2.String(), { description: "Include/exclude globs" })),
+  dryRun: Type2.Optional(Type2.Boolean({ description: "Preview without applying (default: false)" }))
 });
 function appendHintSection(response, sections, theme) {
   const hint = asString(response.hint);
@@ -53916,79 +54062,68 @@ function registerAstTools(pi, ctx, surface) {
 // src/tools/bash.ts
 import * as fs3 from "node:fs/promises";
 import { Container as Container2, Spacer as Spacer2, Text as Text2 } from "@earendil-works/pi-tui";
-import { Type as Type2 } from "typebox";
+import { Type as Type3 } from "typebox";
 var FOREGROUND_WAIT_WINDOW_MS = 5000;
 var FOREGROUND_POLL_INTERVAL_MS = 100;
 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_MS = 30000;
-var BashParams = Type2.Object({
-  command: Type2.String({
+var BashParams = Type3.Object({
+  command: Type3.String({
     description: "Shell command to execute. Supports pipes, redirections, and shell syntax."
   }),
-  timeout: Type2.Optional(Type2.Integer({
-    minimum: 1,
-    description: "Hard kill cap in milliseconds (positive integer). When omitted, the task can run up to 30 minutes. Foreground bash returns inline if the command finishes within ~5s; otherwise it's automatically promoted to background and a completion reminder is delivered when the task actually finishes."
-  })),
-  workdir: Type2.Optional(Type2.String({
+  timeout: optionalInt(1, Number.MAX_SAFE_INTEGER),
+  workdir: Type3.Optional(Type3.String({
     description: "Working directory for command execution. Relative paths resolve against the project root. Defaults to the current session's working directory."
   })),
-  description: Type2.Optional(Type2.String({
+  description: Type3.Optional(Type3.String({
     description: "Human-readable description shown in UI logs. Helps users understand what the command does without reading shell syntax."
   })),
-  background: Type2.Optional(Type2.Boolean({
+  background: Type3.Optional(Type3.Boolean({
     description: "Spawn command in background and return immediately with a task_id. Use bash_status to poll completion and bash_kill to terminate. Ideal for long-running tasks like builds or dev servers."
   })),
-  compressed: Type2.Optional(Type2.Boolean({
+  compressed: Type3.Optional(Type3.Boolean({
     description: "Compress output by removing ANSI codes, carriage returns, and excessive blank lines. Default: true. Set to false for raw terminal output including color codes."
   })),
-  pty: Type2.Optional(Type2.Boolean({
-    description: 'Spawn the command in a real PTY for interactive programs. Requires background: true. Inspect with bash_status({ task_id, output_mode: "screen" }) and send input with bash_write.'
+  pty: Type3.Optional(Type3.Boolean({
+    description: 'Spawn the command in a real PTY for interactive programs. Implies background: true automatically. Inspect with bash_status({ task_id, output_mode: "screen" }) and send input with bash_write.'
   })),
-  ptyRows: Type2.Optional(Type2.Integer({
-    minimum: 1,
-    maximum: 60,
-    description: "PTY terminal height in rows. Applies only when pty: true; defaults to 24. Minimum 1, maximum 60."
-  })),
-  ptyCols: Type2.Optional(Type2.Integer({
-    minimum: 1,
-    maximum: 140,
-    description: "PTY terminal width in columns. Applies only when pty: true; defaults to 80. Minimum 1, maximum 140."
-  }))
+  ptyRows: optionalInt(1, 60),
+  ptyCols: optionalInt(1, 140)
 });
-var BashTaskParams = Type2.Object({
-  task_id: Type2.String({
+var BashTaskParams = Type3.Object({
+  task_id: Type3.String({
     description: "Background bash task id returned by bash({ background: true })."
   })
 });
-var BashStatusParams = Type2.Object({
-  task_id: Type2.String({
+var BashStatusParams = Type3.Object({
+  task_id: Type3.String({
     description: "Background bash task id returned by bash({ background: true })."
   }),
-  output_mode: Type2.Optional(Type2.Union([Type2.Literal("screen"), Type2.Literal("raw"), Type2.Literal("both")], {
+  output_mode: Type3.Optional(Type3.Union([Type3.Literal("screen"), Type3.Literal("raw"), Type3.Literal("both")], {
     description: "PTY output rendering mode. Defaults to screen for PTY tasks and preserves existing behavior for piped tasks when omitted."
   }))
 });
-var BashWatchParams = Type2.Object({
-  task_id: Type2.String({
+var BashWatchParams = Type3.Object({
+  task_id: Type3.String({
     description: "Background bash task id returned by bash({ background: true })."
   }),
-  pattern: Type2.Optional(Type2.Union([Type2.String(), Type2.Object({ regex: Type2.String() })])),
-  background: Type2.Optional(Type2.Boolean()),
-  timeout_ms: Type2.Optional(Type2.Integer({ minimum: 1 })),
-  once: Type2.Optional(Type2.Boolean())
+  pattern: Type3.Optional(Type3.Union([Type3.String(), Type3.Object({ regex: Type3.String() })])),
+  background: Type3.Optional(Type3.Boolean()),
+  timeout_ms: optionalInt(1, MAX_BASH_STATUS_WAIT_TIMEOUT_MS),
+  once: Type3.Optional(Type3.Boolean())
 });
-var BashWriteParams = Type2.Object({
-  task_id: Type2.String({
+var BashWriteParams = Type3.Object({
+  task_id: Type3.String({
     description: "Background PTY task id returned by bash({ pty: true, background: true })."
   }),
-  input: Type2.Union([
-    Type2.String(),
-    Type2.Array(Type2.Union([
-      Type2.String(),
-      Type2.Object({
-        key: Type2.String({
+  input: Type3.Union([
+    Type3.String(),
+    Type3.Array(Type3.Union([
+      Type3.String(),
+      Type3.Object({
+        key: Type3.String({
           description: "Named control key, e.g. 'esc', 'enter', 'up', 'ctrl-c'. Case-insensitive."
         })
       })
@@ -54032,12 +54167,10 @@ function registerBashTool(pi, ctx) {
     parameters: BashParams,
     async execute(_toolCallId, params, _signal, onUpdate, extCtx) {
       const bridge = bridgeFor(ctx, extCtx.cwd);
-      if (params.pty !== true && (params.ptyRows !== undefined || params.ptyCols !== undefined)) {
-        throw new Error("invalid_request: ptyRows/ptyCols require pty: true");
-      }
-      if (params.pty === true && params.background !== true) {
-        throw new Error("PTY mode requires background: true");
-      }
+      const timeout = coerceOptionalInt(params.timeout, "timeout", 1, Number.MAX_SAFE_INTEGER);
+      const ptyRows = coerceOptionalInt(params.ptyRows, "ptyRows", 1, 60);
+      const ptyCols = coerceOptionalInt(params.ptyCols, "ptyCols", 1, 140);
+      const effectiveBackground = params.background === true || params.pty === true;
       let spawnContext = {
         command: params.command,
         cwd: params.workdir
@@ -54052,16 +54185,16 @@ function registerBashTool(pi, ctx) {
       let streamed = "";
       const response = await callBridge(bridge, "bash", {
         command: spawnContext.command,
-        timeout: params.timeout,
+        timeout,
         workdir: spawnContext.cwd ?? params.workdir,
         env: spawnContext.env,
         description: params.description,
-        background: params.background,
-        notify_on_completion: params.background === true,
+        background: effectiveBackground,
+        notify_on_completion: effectiveBackground,
         compressed: params.compressed,
         pty: params.pty,
-        pty_rows: params.ptyRows,
-        pty_cols: params.ptyCols
+        pty_rows: ptyRows,
+        pty_cols: ptyCols
       }, extCtx, {
         transportTimeoutMs: BASH_TRANSPORT_TIMEOUT_MS,
         keepBridgeOnTimeout: true,
@@ -54081,13 +54214,13 @@ function registerBashTool(pi, ctx) {
       }
       const taskId = response.task_id;
       if (response.status === "running" && taskId) {
-        if (params.background === true) {
+        if (effectiveBackground) {
           trackBgTask(resolveSessionId(extCtx), taskId);
           return bashResult(formatBackgroundLaunch(taskId, params.pty === true), {
             task_id: taskId
           });
         }
-        const waitTimeoutMs = params.timeout !== undefined ? Math.min(params.timeout, FOREGROUND_WAIT_WINDOW_MS) : FOREGROUND_WAIT_WINDOW_MS;
+        const waitTimeoutMs = timeout !== undefined ? Math.min(timeout, FOREGROUND_WAIT_WINDOW_MS) : FOREGROUND_WAIT_WINDOW_MS;
         const startedAt = Date.now();
         while (true) {
           const status = await callBridge(bridge, "bash_status", { task_id: taskId }, extCtx);
@@ -54228,7 +54361,7 @@ function createBashWatchTool(ctx) {
         return textResult(`Watch registered: ${registered.watch_id} on task ${params.task_id}
 A notification will fire when the pattern matches or the task exits.`, watchDetails);
       }
-      const data = await waitForBashStatus(ctx, bridge, extCtx, params.task_id, undefined, waitFor, true, Math.min(params.timeout_ms ?? DEFAULT_BASH_STATUS_WAIT_TIMEOUT_MS, MAX_BASH_STATUS_WAIT_TIMEOUT_MS));
+      const data = await waitForBashStatus(ctx, bridge, extCtx, params.task_id, undefined, waitFor, true, Math.min(coerceOptionalInt(params.timeout_ms, "timeout_ms", 1, MAX_BASH_STATUS_WAIT_TIMEOUT_MS) ?? DEFAULT_BASH_STATUS_WAIT_TIMEOUT_MS, MAX_BASH_STATUS_WAIT_TIMEOUT_MS));
       const text = await formatBashStatus(extCtx, params.task_id, data, undefined);
       return textResult(text, data);
     }
@@ -54301,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 = {
@@ -54315,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) {
@@ -54330,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,
@@ -54338,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 });
@@ -54350,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");
@@ -54476,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";
 }
@@ -54546,8 +54711,8 @@ function shortenCommand(command) {
 }
 
 // src/tools/conflicts.ts
-import { Type as Type3 } from "typebox";
-var ConflictsParams = Type3.Object({});
+import { Type as Type4 } from "typebox";
+var ConflictsParams = Type4.Object({});
 function renderConflictCall(theme, context) {
   return renderToolCall("conflicts", undefined, theme, context);
 }
@@ -54595,19 +54760,19 @@ function registerConflictsTool(pi, ctx) {
 }
 
 // src/tools/fs.ts
-import { Type as Type4 } from "typebox";
-var DeleteParams = Type4.Object({
-  files: Type4.Array(Type4.String(), {
+import { Type as Type5 } from "typebox";
+var DeleteParams = Type5.Object({
+  files: Type5.Array(Type5.String(), {
     description: "Paths to delete (one or more). May include directories when recursive=true.",
     minItems: 1
   }),
-  recursive: Type4.Optional(Type4.Boolean({
+  recursive: Type5.Optional(Type5.Boolean({
     description: "Required to delete a directory and its contents. Defaults to false; passing a directory without this returns an error."
   }))
 });
-var MoveParams = Type4.Object({
-  filePath: Type4.String({ description: "Source file path to move" }),
-  destination: Type4.String({ description: "Destination file path" })
+var MoveParams = Type5.Object({
+  filePath: Type5.String({ description: "Source file path to move" }),
+  destination: Type5.String({ description: "Destination file path" })
 });
 function renderFsCall(toolName, args, theme, context) {
   if (toolName === "aft_delete") {
@@ -54715,7 +54880,7 @@ import {
   renderDiff as renderDiff2
 } from "@earendil-works/pi-coding-agent";
 import { Container as Container3, Spacer as Spacer3, Text as Text3 } from "@earendil-works/pi-tui";
-import { Type as Type5 } from "typebox";
+import { Type as Type6 } from "typebox";
 
 // src/tools/diff-format.ts
 import { diffLines } from "diff";
@@ -54835,33 +55000,33 @@ async function assertExternalDirectoryPermission(extCtx, target, action = "modif
     return;
   throw new Error("Permission denied: external directory access was cancelled.");
 }
-var ReadParams = Type5.Object({
-  path: Type5.String({ description: "Path to the file to read (relative or absolute)" }),
-  offset: Type5.Optional(Type5.Number({ description: "Line number to start reading from (1-indexed)" })),
-  limit: Type5.Optional(Type5.Number({ description: "Maximum number of lines to read" }))
+var ReadParams = Type6.Object({
+  path: Type6.String({ description: "Path to the file to read (relative or absolute)" }),
+  offset: optionalInt(1, Number.MAX_SAFE_INTEGER),
+  limit: optionalInt(1, Number.MAX_SAFE_INTEGER)
 });
-var WriteParams = Type5.Object({
-  filePath: Type5.String({
+var WriteParams = Type6.Object({
+  filePath: Type6.String({
     description: "Path to the file to write (absolute or project-relative)"
   }),
-  content: Type5.String({ description: "Full file contents to write" })
-});
-var EditParams = Type5.Object({
-  filePath: Type5.String({ description: "Path to the file to edit" }),
-  oldString: Type5.Optional(Type5.String({ description: "Text to find (exact match, fuzzy fallback)" })),
-  newString: Type5.Optional(Type5.String({ description: "Replacement text (omit to delete match)" })),
-  replaceAll: Type5.Optional(Type5.Boolean({ description: "Replace every occurrence" })),
-  occurrence: Type5.Optional(Type5.Number({ description: "0-indexed occurrence when multiple matches exist" })),
-  appendContent: Type5.Optional(Type5.String({
+  content: Type6.String({ description: "Full file contents to write" })
+});
+var EditParams = Type6.Object({
+  filePath: Type6.String({ description: "Path to the file to edit" }),
+  oldString: Type6.Optional(Type6.String({ description: "Text to find (exact match, fuzzy fallback)" })),
+  newString: Type6.Optional(Type6.String({ description: "Replacement text (omit to delete match)" })),
+  replaceAll: Type6.Optional(Type6.Boolean({ description: "Replace every occurrence" })),
+  occurrence: optionalInt(0, Number.MAX_SAFE_INTEGER),
+  appendContent: Type6.Optional(Type6.String({
     description: "Append text to the end of the file (creates the file if missing, parent dirs auto-created). When set, oldString/newString are ignored."
   }))
 });
-var GrepParams = Type5.Object({
-  pattern: Type5.String({ description: "Regex pattern to search for" }),
-  path: Type5.Optional(Type5.String({ description: "Path scope (file or directory)" })),
-  include: Type5.Optional(Type5.String({ description: "Glob filter for included files (e.g. '*.ts,*.tsx')" })),
-  caseSensitive: Type5.Optional(Type5.Boolean({ description: "Case-sensitive matching" })),
-  contextLines: Type5.Optional(Type5.Number({ description: "Lines of context before/after each match" }))
+var GrepParams = Type6.Object({
+  pattern: Type6.String({ description: "Regex pattern to search for" }),
+  path: Type6.Optional(Type6.String({ description: "Path scope (file or directory)" })),
+  include: Type6.Optional(Type6.String({ description: "Glob filter for included files (e.g. '*.ts,*.tsx')" })),
+  caseSensitive: Type6.Optional(Type6.Boolean({ description: "Case-sensitive matching" })),
+  contextLines: optionalInt(1, Number.MAX_SAFE_INTEGER)
 });
 function registerHoistedTools(pi, ctx, surface) {
   if (surface.hoistRead) {
@@ -54874,14 +55039,16 @@ function registerHoistedTools(pi, ctx, surface) {
       parameters: ReadParams,
       async execute(_toolCallId, params, _signal, _onUpdate, extCtx) {
         const bridge = bridgeFor(ctx, extCtx.cwd);
+        const offset = coerceOptionalInt(params.offset, "offset", 1, Number.MAX_SAFE_INTEGER);
+        const limit = coerceOptionalInt(params.limit, "limit", 1, Number.MAX_SAFE_INTEGER);
         const req = { file: params.path };
-        if (params.offset !== undefined) {
-          req.start_line = params.offset;
-          if (params.limit !== undefined) {
-            req.end_line = params.offset + params.limit - 1;
+        if (offset !== undefined) {
+          req.start_line = offset;
+          if (limit !== undefined) {
+            req.end_line = offset + limit - 1;
           }
-        } else if (params.limit !== undefined) {
-          req.end_line = params.limit;
+        } else if (limit !== undefined) {
+          req.end_line = limit;
         }
         const response = await callBridge(bridge, "read", req, extCtx);
         if (Array.isArray(response.entries)) {
@@ -54889,7 +55056,7 @@ function registerHoistedTools(pi, ctx, surface) {
 `));
         }
         let text = response.content ?? "";
-        const agentSpecifiedRange = params.offset !== undefined || params.limit !== undefined;
+        const agentSpecifiedRange = offset !== undefined || limit !== undefined;
         const footer = formatReadFooter(agentSpecifiedRange, response);
         if (footer)
           text += footer;
@@ -54959,8 +55126,9 @@ function registerHoistedTools(pi, ctx, surface) {
         };
         if (params.replaceAll === true)
           req.replace_all = true;
-        if (params.occurrence !== undefined)
-          req.occurrence = params.occurrence;
+        const occurrence = coerceOptionalInt(params.occurrence, "occurrence", 0, Number.MAX_SAFE_INTEGER);
+        if (occurrence !== undefined)
+          req.occurrence = occurrence;
         const response = await callBridge(bridge, "edit_match", req, extCtx);
         return buildMutationResult(params.filePath, response);
       },
@@ -54991,8 +55159,9 @@ function registerHoistedTools(pi, ctx, surface) {
           req.include = splitIncludeGlobs(params.include);
         if (params.caseSensitive !== undefined)
           req.case_sensitive = params.caseSensitive;
-        if (params.contextLines !== undefined)
-          req.context_lines = params.contextLines;
+        const contextLines = coerceOptionalInt(params.contextLines, "contextLines", 1, Number.MAX_SAFE_INTEGER);
+        if (contextLines !== undefined)
+          req.context_lines = contextLines;
         const response = await callBridge(bridge, "grep", req, extCtx);
         const text = response.text ?? "";
         return textResult(text);
@@ -55211,16 +55380,16 @@ function formatReadFooter(agentSpecifiedRange, data) {
 
 // src/tools/imports.ts
 import { StringEnum as StringEnum2 } from "@earendil-works/pi-ai";
-import { Type as Type6 } from "typebox";
-var ImportParams = Type6.Object({
+import { Type as Type7 } from "typebox";
+var ImportParams = Type7.Object({
   op: StringEnum2(["add", "remove", "organize"], { description: "Import operation" }),
-  filePath: Type6.String({ description: "Path to the file" }),
-  module: Type6.Optional(Type6.String({ description: "Module path (required for add/remove), e.g. 'react', './utils'" })),
-  names: Type6.Optional(Type6.Array(Type6.String(), { description: "Named imports to add, e.g. ['useState']" })),
-  defaultImport: Type6.Optional(Type6.String({ description: "Default import name (e.g. 'React')" })),
-  removeName: Type6.Optional(Type6.String({ description: "Named import to remove; omit to remove entire import" })),
-  typeOnly: Type6.Optional(Type6.Boolean({ description: "Type-only import (TS only)" })),
-  validate: Type6.Optional(StringEnum2(["syntax", "full"], {
+  filePath: Type7.String({ description: "Path to the file" }),
+  module: Type7.Optional(Type7.String({ description: "Module path (required for add/remove), e.g. 'react', './utils'" })),
+  names: Type7.Optional(Type7.Array(Type7.String(), { description: "Named imports to add, e.g. ['useState']" })),
+  defaultImport: Type7.Optional(Type7.String({ description: "Default import name (e.g. 'React')" })),
+  removeName: Type7.Optional(Type7.String({ description: "Named import to remove; omit to remove entire import" })),
+  typeOnly: Type7.Optional(Type7.Boolean({ description: "Type-only import (TS only)" })),
+  validate: Type7.Optional(StringEnum2(["syntax", "full"], {
     description: "Post-edit validation level (default: syntax)"
   }))
 });
@@ -55309,16 +55478,16 @@ function registerImportTools(pi, ctx) {
 
 // src/tools/lsp.ts
 import { StringEnum as StringEnum3 } from "@earendil-works/pi-ai";
-import { Type as Type7 } from "typebox";
-var LspDiagnosticsParams = Type7.Object({
-  filePath: Type7.Optional(Type7.String({ description: "File to get diagnostics for (mutually exclusive with directory)" })),
-  directory: Type7.Optional(Type7.String({
+import { Type as Type8 } from "typebox";
+var LspDiagnosticsParams = Type8.Object({
+  filePath: Type8.Optional(Type8.String({ description: "File to get diagnostics for (mutually exclusive with directory)" })),
+  directory: Type8.Optional(Type8.String({
     description: "Directory to get diagnostics for (mutually exclusive with filePath)"
   })),
-  severity: Type7.Optional(StringEnum3(["error", "warning", "information", "hint", "all"], {
+  severity: Type8.Optional(StringEnum3(["error", "warning", "information", "hint", "all"], {
     description: "Filter by severity (default: all)"
   })),
-  waitMs: Type7.Optional(Type7.Number({
+  waitMs: Type8.Optional(Type8.Number({
     description: "Wait N ms for fresh diagnostics (max 10000, default: 0)"
   }))
 });
@@ -55403,16 +55572,16 @@ function registerLspTools(pi, ctx) {
 
 // src/tools/navigate.ts
 import { StringEnum as StringEnum4 } from "@earendil-works/pi-ai";
-import { Type as Type8 } from "typebox";
+import { Type as Type9 } from "typebox";
 function navigateParamsSchema() {
-  return Type8.Object({
+  return Type9.Object({
     op: StringEnum4(["call_tree", "callers", "trace_to", "impact", "trace_data"], {
       description: "Navigation operation"
     }),
-    filePath: Type8.String({ description: "Source file containing the symbol" }),
-    symbol: Type8.String({ description: "Name of the symbol to analyze" }),
-    depth: Type8.Optional(Type8.Number({ description: "Max traversal depth" })),
-    expression: Type8.Optional(Type8.String({ description: "Expression to track (required for trace_data)" }))
+    filePath: Type9.String({ description: "Source file containing the symbol" }),
+    symbol: Type9.String({ description: "Name of the symbol to analyze" }),
+    depth: optionalInt(1, Number.MAX_SAFE_INTEGER),
+    expression: Type9.Optional(Type9.String({ description: "Expression to track (required for trace_data)" }))
   });
 }
 function treeLine(depth, text) {
@@ -55427,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) => {
@@ -55444,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)");
@@ -55464,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."));
@@ -55479,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."));
@@ -55546,8 +55729,9 @@ function registerNavigateTool(pi, ctx) {
         file: params.filePath,
         symbol: params.symbol
       };
-      if (params.depth !== undefined)
-        req.depth = params.depth;
+      const depth = coerceOptionalInt(params.depth, "depth", 1, Number.MAX_SAFE_INTEGER);
+      if (depth !== undefined)
+        req.depth = depth;
       if (params.expression !== undefined)
         req.expression = params.expression;
       const response = await callBridge(bridge, params.op, req, extCtx);
@@ -55565,20 +55749,20 @@ function registerNavigateTool(pi, ctx) {
 // src/tools/reading.ts
 import { stat as stat2 } from "node:fs/promises";
 import { resolve as resolve4 } from "node:path";
-import { Type as Type9 } from "typebox";
-var OutlineParams = Type9.Object({
-  target: Type9.Union([Type9.String(), Type9.Array(Type9.String())], {
+import { Type as Type10 } from "typebox";
+var OutlineParams = Type10.Object({
+  target: Type10.Union([Type10.String(), Type10.Array(Type10.String())], {
     description: "What to outline: a file path, directory path, URL (http:// or https://), or array of file paths. The mode is auto-detected: URLs by `http://`/`https://` prefix, directories by stat, arrays as multi-file. Directory walks cap at 200 files."
   })
 });
-var ZoomParams = Type9.Object({
-  filePath: Type9.Optional(Type9.String({ description: "Path to file (absolute or project-relative)" })),
-  url: Type9.Optional(Type9.String({
+var ZoomParams = Type10.Object({
+  filePath: Type10.Optional(Type10.String({ description: "Path to file (absolute or project-relative)" })),
+  url: Type10.Optional(Type10.String({
     description: "HTTP/HTTPS URL of an HTML or Markdown document to fetch and zoom into"
   })),
-  symbol: Type9.Optional(Type9.String({ description: "Symbol name (function/class/type) or Markdown heading" })),
-  symbols: Type9.Optional(Type9.Array(Type9.String(), { description: "Multiple symbols — returns array of matches" })),
-  contextLines: Type9.Optional(Type9.Number({ description: "Lines of context before/after (default: 3)" }))
+  symbol: Type10.Optional(Type10.String({ description: "Symbol name (function/class/type) or Markdown heading" })),
+  symbols: Type10.Optional(Type10.Array(Type10.String(), { description: "Multiple symbols — returns array of matches" })),
+  contextLines: Type10.Optional(Type10.Number({ description: "Lines of context before/after (default: 3)" }))
 });
 function isUrl(s) {
   return s.startsWith("http://") || s.startsWith("https://");
@@ -55826,17 +56010,17 @@ ${lines}`;
 
 // src/tools/refactor.ts
 import { StringEnum as StringEnum5 } from "@earendil-works/pi-ai";
-import { Type as Type10 } from "typebox";
-var RefactorParams = Type10.Object({
+import { Type as Type11 } from "typebox";
+var RefactorParams = Type11.Object({
   op: StringEnum5(["move", "extract", "inline"], { description: "Refactoring operation" }),
-  filePath: Type10.String({ description: "Source file" }),
-  symbol: Type10.Optional(Type10.String({ description: "Symbol name (for move, inline)" })),
-  destination: Type10.Optional(Type10.String({ description: "Target file (for move)" })),
-  scope: Type10.Optional(Type10.String({ description: "Disambiguation scope for move op" })),
-  name: Type10.Optional(Type10.String({ description: "New function name (for extract)" })),
-  startLine: Type10.Optional(Type10.Number({ description: "1-based start line (for extract)" })),
-  endLine: Type10.Optional(Type10.Number({ description: "1-based end line, inclusive (for extract)" })),
-  callSiteLine: Type10.Optional(Type10.Number({ description: "1-based call site line (for inline)" }))
+  filePath: Type11.String({ description: "Source file" }),
+  symbol: Type11.Optional(Type11.String({ description: "Symbol name (for move, inline)" })),
+  destination: Type11.Optional(Type11.String({ description: "Target file (for move)" })),
+  scope: Type11.Optional(Type11.String({ description: "Disambiguation scope for move op" })),
+  name: Type11.Optional(Type11.String({ description: "New function name (for extract)" })),
+  startLine: optionalInt(1, Number.MAX_SAFE_INTEGER),
+  endLine: optionalInt(1, Number.MAX_SAFE_INTEGER),
+  callSiteLine: optionalInt(1, Number.MAX_SAFE_INTEGER)
 });
 function buildRefactorSections(args, payload, theme) {
   const response = asRecord2(payload);
@@ -55902,13 +56086,16 @@ function registerRefactorTool(pi, ctx) {
         req.scope = params.scope;
       if (params.name !== undefined)
         req.name = params.name;
-      if (params.startLine !== undefined)
-        req.start_line = params.startLine;
-      if (params.endLine !== undefined) {
-        req.end_line = params.op === "extract" ? params.endLine + 1 : params.endLine;
-      }
-      if (params.callSiteLine !== undefined)
-        req.call_site_line = params.callSiteLine;
+      const startLine = coerceOptionalInt(params.startLine, "startLine", 1, Number.MAX_SAFE_INTEGER);
+      const endLine = coerceOptionalInt(params.endLine, "endLine", 1, Number.MAX_SAFE_INTEGER);
+      const callSiteLine = coerceOptionalInt(params.callSiteLine, "callSiteLine", 1, Number.MAX_SAFE_INTEGER);
+      if (startLine !== undefined)
+        req.start_line = startLine;
+      if (endLine !== undefined) {
+        req.end_line = params.op === "extract" ? endLine + 1 : endLine;
+      }
+      if (callSiteLine !== undefined)
+        req.call_site_line = callSiteLine;
       const response = await callBridge(bridge, commandMap[params.op], req, extCtx);
       return textResult(JSON.stringify(response, null, 2));
     },
@@ -55923,14 +56110,14 @@ function registerRefactorTool(pi, ctx) {
 
 // src/tools/safety.ts
 import { StringEnum as StringEnum6 } from "@earendil-works/pi-ai";
-import { Type as Type11 } from "typebox";
-var SafetyParams = Type11.Object({
+import { Type as Type12 } from "typebox";
+var SafetyParams = Type12.Object({
   op: StringEnum6(["undo", "history", "checkpoint", "restore", "list"], {
     description: "Safety operation"
   }),
-  filePath: Type11.Optional(Type11.String({ description: "File path (required for history, optional for undo)" })),
-  name: Type11.Optional(Type11.String({ description: "Checkpoint name (required for checkpoint, restore)" })),
-  files: Type11.Optional(Type11.Array(Type11.String(), {
+  filePath: Type12.Optional(Type12.String({ description: "File path (required for history, optional for undo)" })),
+  name: Type12.Optional(Type12.String({ description: "Checkpoint name (required for checkpoint, restore)" })),
+  files: Type12.Optional(Type12.Array(Type12.String(), {
     description: "Specific files for checkpoint (optional, defaults to all tracked)"
   }))
 });
@@ -56061,12 +56248,12 @@ function registerSafetyTool(pi, ctx) {
 }
 
 // src/tools/semantic.ts
-import { Type as Type12 } from "typebox";
-var SearchParams2 = Type12.Object({
-  query: Type12.String({
+import { Type as Type13 } from "typebox";
+var SearchParams2 = Type13.Object({
+  query: Type13.String({
     description: "Concept or capability to find, phrased as a programmer would describe the code. Examples: 'fuzzy match with whitespace tolerance', 'undo backup before edit', 'retry failed network request'."
   }),
-  topK: Type12.Optional(Type12.Number({ description: "Maximum number of results (default: 10, max: 100)" }))
+  topK: Type13.Optional(Type13.Number({ description: "Maximum number of results (default: 10, max: 100)" }))
 });
 function buildSemanticSections(args, payload, theme) {
   const response = asRecord2(payload);
@@ -56167,23 +56354,23 @@ function registerSemanticTool(pi, ctx) {
 
 // src/tools/structure.ts
 import { StringEnum as StringEnum7 } from "@earendil-works/pi-ai";
-import { Type as Type13 } from "typebox";
-var TransformParams = Type13.Object({
+import { Type as Type14 } from "typebox";
+var TransformParams = Type14.Object({
   op: StringEnum7(["add_member", "add_derive", "wrap_try_catch", "add_decorator", "add_struct_tags"], { description: "Transformation operation" }),
-  filePath: Type13.String({ description: "Path to the source file" }),
-  container: Type13.Optional(Type13.String({ description: "Class/struct/impl name for add_member" })),
-  code: Type13.Optional(Type13.String({ description: "Member code to insert (add_member)" })),
-  target: Type13.Optional(Type13.String({ description: "Target symbol name" })),
-  derives: Type13.Optional(Type13.Array(Type13.String(), { description: "Derive macro names (add_derive)" })),
-  catchBody: Type13.Optional(Type13.String({ description: "Catch block body (wrap_try_catch, default: 'throw error;')" })),
-  decorator: Type13.Optional(Type13.String({ description: "Decorator text without @ (add_decorator)" })),
-  field: Type13.Optional(Type13.String({ description: "Struct field name (add_struct_tags)" })),
-  tag: Type13.Optional(Type13.String({ description: "Tag key (add_struct_tags)" })),
-  value: Type13.Optional(Type13.String({ description: "Tag value (add_struct_tags)" })),
-  position: Type13.Optional(Type13.String({
+  filePath: Type14.String({ description: "Path to the source file" }),
+  container: Type14.Optional(Type14.String({ description: "Class/struct/impl name for add_member" })),
+  code: Type14.Optional(Type14.String({ description: "Member code to insert (add_member)" })),
+  target: Type14.Optional(Type14.String({ description: "Target symbol name" })),
+  derives: Type14.Optional(Type14.Array(Type14.String(), { description: "Derive macro names (add_derive)" })),
+  catchBody: Type14.Optional(Type14.String({ description: "Catch block body (wrap_try_catch, default: 'throw error;')" })),
+  decorator: Type14.Optional(Type14.String({ description: "Decorator text without @ (add_decorator)" })),
+  field: Type14.Optional(Type14.String({ description: "Struct field name (add_struct_tags)" })),
+  tag: Type14.Optional(Type14.String({ description: "Tag key (add_struct_tags)" })),
+  value: Type14.Optional(Type14.String({ description: "Tag value (add_struct_tags)" })),
+  position: Type14.Optional(Type14.String({
     description: "Position hint: 'first', 'last' (default), 'before:name', 'after:name' for add_member"
   })),
-  validate: Type13.Optional(StringEnum7(["syntax", "full"], {
+  validate: Type14.Optional(StringEnum7(["syntax", "full"], {
     description: "Validation level (default: syntax)"
   }))
 });
@@ -56448,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) {
@@ -56664,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);
@@ -56775,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,