@cortexkit/aft-pi 0.46.0 → 0.47.0

package/dist/index.js

@@ -9697,6 +9697,16 @@ function isEmptyParam(value) {
     return Object.keys(value).length === 0;
   return false;
 }
+// ../aft-bridge/dist/config-keys.js
+var OPENCODE_ONLY_KEYS = ["hoist_builtin_tools", "auto_update"];
+function stripHarnessSpecificConfigKeys(value, keys) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return value;
+  const stripped = { ...value };
+  for (const key of keys)
+    delete stripped[key];
+  return stripped;
+}
 // ../aft-bridge/dist/config-tiers.js
 import { existsSync, readFileSync as readFileSync2 } from "node:fs";
 import { resolve as resolve2 } from "node:path";
@@ -10017,6 +10027,117 @@ async function fetchLatestTag() {
     clearTimeout(timeout);
   }
 }
+// ../aft-bridge/dist/durable-log.js
+import { appendFile, mkdir, rename, rm, stat } from "node:fs/promises";
+import { homedir as homedir5 } from "node:os";
+import { dirname, join as join4 } from "node:path";
+var DEFAULT_LOG_BYTES = 20 * 1024 * 1024;
+var DEFAULT_LOG_GENERATIONS = 5;
+function homeDir() {
+  if (process.platform === "win32")
+    return process.env.USERPROFILE || process.env.HOME || homedir5();
+  return process.env.HOME || homedir5();
+}
+function dataHome() {
+  if (process.env.XDG_DATA_HOME)
+    return process.env.XDG_DATA_HOME;
+  if (process.platform === "win32") {
+    return process.env.LOCALAPPDATA || process.env.APPDATA || join4(homeDir(), "AppData", "Local");
+  }
+  return join4(homeDir(), ".local", "share");
+}
+function resolveAftStorageRoot(configuredRoot) {
+  if (configuredRoot)
+    return configuredRoot;
+  if (process.env.AFT_CACHE_DIR)
+    return join4(process.env.AFT_CACHE_DIR, "aft");
+  return join4(dataHome(), "cortexkit", "aft");
+}
+function resolveAftLogPath(filename, configuredRoot) {
+  return join4(resolveAftStorageRoot(configuredRoot), "logs", filename);
+}
+
+class RotatingLogSink {
+  path;
+  maxBytes;
+  generations;
+  estimatedBytes = null;
+  queue = Promise.resolve();
+  disabled = false;
+  failureReported = false;
+  constructor(path2, options = {}) {
+    this.path = path2;
+    this.maxBytes = options.maxBytes ?? DEFAULT_LOG_BYTES;
+    this.generations = options.generations ?? DEFAULT_LOG_GENERATIONS;
+  }
+  append(data) {
+    if (this.disabled || data.length === 0)
+      return;
+    this.queue = this.queue.then(() => this.write(data)).catch((error2) => {
+      this.disabled = true;
+      if (!this.failureReported) {
+        this.failureReported = true;
+        try {
+          process.stderr.write(`[aft-plugin] durable log disabled for ${this.path}: ${error2 instanceof Error ? error2.message : String(error2)}
+`);
+        } catch {}
+      }
+    });
+  }
+  async drain() {
+    await this.queue;
+  }
+  async write(data) {
+    await mkdir(dirname(this.path), { recursive: true });
+    if (this.estimatedBytes === null) {
+      try {
+        this.estimatedBytes = (await stat(this.path)).size;
+      } catch (error2) {
+        if (!isMissing(error2))
+          throw error2;
+        this.estimatedBytes = 0;
+      }
+    }
+    const bytes = Buffer.byteLength(data);
+    if (this.estimatedBytes > 0 && this.estimatedBytes + bytes > this.maxBytes) {
+      await this.rotate();
+    }
+    await appendFile(this.path, data, "utf8");
+    this.estimatedBytes = (this.estimatedBytes ?? 0) + bytes;
+  }
+  async rotate() {
+    if (this.generations <= 0) {
+      await removeIfPresent(this.path);
+      this.estimatedBytes = 0;
+      return;
+    }
+    await removeIfPresent(`${this.path}.${this.generations}`);
+    for (let generation = this.generations - 1;generation >= 1; generation -= 1) {
+      await renameIfPresent(`${this.path}.${generation}`, `${this.path}.${generation + 1}`);
+    }
+    await renameIfPresent(this.path, `${this.path}.1`);
+    this.estimatedBytes = 0;
+  }
+}
+function isMissing(error2) {
+  return typeof error2 === "object" && error2 !== null && "code" in error2 && error2.code === "ENOENT";
+}
+async function removeIfPresent(path2) {
+  try {
+    await rm(path2, { force: true });
+  } catch (error2) {
+    if (!isMissing(error2))
+      throw error2;
+  }
+}
+async function renameIfPresent(from, to) {
+  try {
+    await rename(from, to);
+  } catch (error2) {
+    if (!isMissing(error2))
+      throw error2;
+  }
+}
 // ../aft-bridge/dist/edit-summary.js
 function formatEditSummary(data) {
   if (data.rolled_back === true) {
@@ -10087,32 +10208,32 @@ function stripJsoncSymbols(value) {
 // ../aft-bridge/dist/migration.js
 import { spawnSync as spawnSync2 } from "node:child_process";
 import { closeSync as closeSync3, existsSync as existsSync5, mkdirSync as mkdirSync4, openSync as openSync3, readFileSync as readFileSync5, renameSync as renameSync4, rmSync as rmSync2, statSync as statSync2, unlinkSync as unlinkSync3, writeFileSync as writeFileSync2 } from "node:fs";
-import { homedir as homedir7, tmpdir } from "node:os";
-import { basename, dirname as dirname2, join as join6, resolve as resolve4 } from "node:path";
+import { homedir as homedir8, tmpdir } from "node:os";
+import { basename, dirname as dirname3, join as join7, resolve as resolve4 } from "node:path";
 
 // ../aft-bridge/dist/paths.js
 import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync4, renameSync as renameSync2, writeFileSync } from "node:fs";
-import { homedir as homedir5 } from "node:os";
-import { dirname, isAbsolute as isAbsolute2, join as join4, resolve as resolve3 } from "node:path";
-function homeDir() {
+import { homedir as homedir6 } from "node:os";
+import { dirname as dirname2, isAbsolute as isAbsolute2, join as join5, resolve as resolve3 } from "node:path";
+function homeDir2() {
   if (process.platform === "win32")
-    return process.env.USERPROFILE || process.env.HOME || homedir5();
-  return process.env.HOME || homedir5();
+    return process.env.USERPROFILE || process.env.HOME || homedir6();
+  return process.env.HOME || homedir6();
 }
 function configHome() {
   const xdg = process.env.XDG_CONFIG_HOME;
   if (xdg && isAbsolute2(xdg))
     return xdg;
-  return join4(homeDir(), ".config");
+  return join5(homeDir2(), ".config");
 }
 function legacyOpenCodeConfigDir() {
   const envDir = process.env.OPENCODE_CONFIG_DIR?.trim();
   if (envDir)
     return resolve3(envDir);
-  return join4(configHome(), "opencode");
+  return join5(configHome(), "opencode");
 }
 function legacyPiAgentDir() {
-  return join4(homeDir(), ".pi", "agent");
+  return join5(homeDir2(), ".pi", "agent");
 }
 function legacySources(basePath, label, harness) {
   return [
@@ -10121,10 +10242,10 @@ function legacySources(basePath, label, harness) {
   ];
 }
 function resolveCortexKitUserConfigPath() {
-  return join4(configHome(), "cortexkit", "aft.jsonc");
+  return join5(configHome(), "cortexkit", "aft.jsonc");
 }
 function resolveCortexKitProjectConfigPath(projectDirectory) {
-  return join4(projectDirectory, ".cortexkit", "aft.jsonc");
+  return join5(projectDirectory, ".cortexkit", "aft.jsonc");
 }
 function resolveCortexKitConfigPaths(projectDirectory) {
   return {
@@ -10135,25 +10256,25 @@ function resolveCortexKitConfigPaths(projectDirectory) {
 function resolveLegacyAftConfigSources(projectDirectory) {
   return {
     user: [
-      ...legacySources(join4(legacyOpenCodeConfigDir(), "aft"), "OpenCode user", "opencode"),
-      ...legacySources(join4(legacyPiAgentDir(), "aft"), "Pi user", "pi")
+      ...legacySources(join5(legacyOpenCodeConfigDir(), "aft"), "OpenCode user", "opencode"),
+      ...legacySources(join5(legacyPiAgentDir(), "aft"), "Pi user", "pi")
     ],
     project: [
-      ...legacySources(join4(projectDirectory, ".opencode", "aft"), "OpenCode project", "opencode"),
-      ...legacySources(join4(projectDirectory, ".pi", "aft"), "Pi project", "pi")
+      ...legacySources(join5(projectDirectory, ".opencode", "aft"), "OpenCode project", "opencode"),
+      ...legacySources(join5(projectDirectory, ".pi", "aft"), "Pi project", "pi")
     ]
   };
 }
 function resolveHarnessStoragePath(storageRoot, harness, ...segments) {
-  return join4(storageRoot, harness, ...segments);
+  return join5(storageRoot, harness, ...segments);
 }
 function repairRootScopedStorageFile(storageRoot, harness, fileName) {
   const harnessPath = resolveHarnessStoragePath(storageRoot, harness, fileName);
-  const rootPath = join4(storageRoot, fileName);
+  const rootPath = join5(storageRoot, fileName);
   if (existsSync3(harnessPath) || !existsSync3(rootPath))
     return harnessPath;
   try {
-    mkdirSync2(dirname(harnessPath), { recursive: true });
+    mkdirSync2(dirname2(harnessPath), { recursive: true });
     renameSync2(rootPath, harnessPath);
   } catch {}
   return harnessPath;
@@ -10174,7 +10295,7 @@ function shouldShowAnnouncement(storageRoot, harness, currentVersion) {
     return false;
   if (!lastVersion) {
     try {
-      mkdirSync2(dirname(versionFile), { recursive: true });
+      mkdirSync2(dirname2(versionFile), { recursive: true });
       writeFileSync(versionFile, currentVersion);
     } catch {}
     return false;
@@ -10186,7 +10307,7 @@ function markAnnouncementSeen(storageRoot, harness, currentVersion) {
     return;
   const versionFile = repairRootScopedStorageFile(storageRoot, harness, "last_announced_version");
   try {
-    mkdirSync2(dirname(versionFile), { recursive: true });
+    mkdirSync2(dirname2(versionFile), { recursive: true });
     writeFileSync(versionFile, currentVersion);
   } catch {}
 }
@@ -10195,8 +10316,8 @@ function markAnnouncementSeen(storageRoot, harness, currentVersion) {
 import { execSync } from "node:child_process";
 import { chmodSync as chmodSync2, closeSync as closeSync2, copyFileSync as copyFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync3, openSync as openSync2, readSync, renameSync as renameSync3, unlinkSync as unlinkSync2 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import { homedir as homedir6 } from "node:os";
-import { join as join5 } from "node:path";
+import { homedir as homedir7 } from "node:os";
+import { join as join6 } from "node:path";
 var ensureBinaryForResolver = ensureBinary;
 function copyToVersionedCache(npmBinaryPath, knownVersion) {
   try {
@@ -10205,9 +10326,9 @@ function copyToVersionedCache(npmBinaryPath, knownVersion) {
       return null;
     const tag = version.startsWith("v") ? version : `v${version}`;
     const cacheDir = getCacheDir();
-    const versionedDir = join5(cacheDir, tag);
+    const versionedDir = join6(cacheDir, tag);
     const ext = process.platform === "win32" ? ".exe" : "";
-    const cachedPath = join5(versionedDir, `aft${ext}`);
+    const cachedPath = join6(versionedDir, `aft${ext}`);
     if (existsSync4(cachedPath)) {
       const cachedVersion = readBinaryVersion(cachedPath);
       if (cachedVersion === version)
@@ -10237,18 +10358,18 @@ function normalizeBareVersion(version) {
   return version.startsWith("v") ? version.slice(1) : version;
 }
 function homeDirFromEnv(env) {
-  return (process.platform === "win32" ? env.USERPROFILE || env.HOME : env.HOME) || homedir6();
+  return (process.platform === "win32" ? env.USERPROFILE || env.HOME : env.HOME) || homedir7();
 }
 function cacheDirFromEnv(env) {
   if (process.platform === "win32") {
-    const base2 = env.LOCALAPPDATA || env.APPDATA || join5(homeDirFromEnv(env), "AppData", "Local");
-    return join5(base2, "aft", "bin");
+    const base2 = env.LOCALAPPDATA || env.APPDATA || join6(homeDirFromEnv(env), "AppData", "Local");
+    return join6(base2, "aft", "bin");
   }
-  const base = env.XDG_CACHE_HOME || join5(homeDirFromEnv(env), ".cache");
-  return join5(base, "aft", "bin");
+  const base = env.XDG_CACHE_HOME || join6(homeDirFromEnv(env), ".cache");
+  return join6(base, "aft", "bin");
 }
 function cachedBinaryPathFromEnv(version, env, ext) {
-  const binaryPath = join5(cacheDirFromEnv(env), version, `aft${ext}`);
+  const binaryPath = join6(cacheDirFromEnv(env), version, `aft${ext}`);
   return existsSync4(binaryPath) ? binaryPath : null;
 }
 function isExpectedCachedBinary2(binaryPath, expectedVersion) {
@@ -10367,7 +10488,7 @@ function findBinarySync(expectedVersion) {
         return usable;
     }
   } catch {}
-  const cargoPath = join5(homeDirFromEnv(env), ".cargo", "bin", `aft${ext}`);
+  const cargoPath = join6(homeDirFromEnv(env), ".cargo", "bin", `aft${ext}`);
   if (existsSync4(cargoPath)) {
     const usable = probeBinaryCandidate(cargoPath, "cargo", expectedVersion);
     if (usable)
@@ -10409,26 +10530,26 @@ async function findBinary(expectedVersion) {
 var spawnSyncForMigration = spawnSync2;
 var TARGET_MARKER = ".migrated_from_legacy";
 var DEFAULT_TIMEOUT_MS = 30 * 60 * 1000;
-function dataHome() {
+function dataHome2() {
   if (process.env.XDG_DATA_HOME)
     return process.env.XDG_DATA_HOME;
   if (process.platform === "win32") {
-    return process.env.LOCALAPPDATA || process.env.APPDATA || join6(homeDir2(), "AppData", "Local");
+    return process.env.LOCALAPPDATA || process.env.APPDATA || join7(homeDir3(), "AppData", "Local");
   }
-  return join6(homeDir2(), ".local", "share");
+  return join7(homeDir3(), ".local", "share");
 }
-function homeDir2() {
+function homeDir3() {
   if (process.platform === "win32")
-    return process.env.USERPROFILE || process.env.HOME || homedir7();
-  return process.env.HOME || homedir7();
+    return process.env.USERPROFILE || process.env.HOME || homedir8();
+  return process.env.HOME || homedir8();
 }
 function resolveLegacyStorageRoot(harness) {
   if (harness === "pi")
-    return join6(homeDir2(), ".pi", "agent", "aft");
-  return join6(dataHome(), "opencode", "storage", "plugin", "aft");
+    return join7(homeDir3(), ".pi", "agent", "aft");
+  return join7(dataHome2(), "opencode", "storage", "plugin", "aft");
 }
 function resolveCortexKitStorageRoot() {
-  return join6(dataHome(), "cortexkit", "aft");
+  return join7(dataHome2(), "cortexkit", "aft");
 }
 function stripJsoncForParse(input) {
   let out = "";
@@ -10557,8 +10678,8 @@ function acquireConfigMigrationLock(lockDir) {
   }
 }
 function atomicCopyConfigFile(sourcePath, targetPath) {
-  mkdirSync4(dirname2(targetPath), { recursive: true });
-  const tmpPath = join6(dirname2(targetPath), `.${basename(targetPath)}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`);
+  mkdirSync4(dirname3(targetPath), { recursive: true });
+  const tmpPath = join7(dirname3(targetPath), `.${basename(targetPath)}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`);
   let fd = null;
   try {
     fd = openSync3(tmpPath, "wx", 384);
@@ -10579,8 +10700,8 @@ function atomicCopyConfigFile(sourcePath, targetPath) {
   }
 }
 function atomicWriteConfigFile(targetPath, content) {
-  mkdirSync4(dirname2(targetPath), { recursive: true });
-  const tmpPath = join6(dirname2(targetPath), `.${basename(targetPath)}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`);
+  mkdirSync4(dirname3(targetPath), { recursive: true });
+  const tmpPath = join7(dirname3(targetPath), `.${basename(targetPath)}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`);
   let fd = null;
   try {
     fd = openSync3(tmpPath, "wx", 384);
@@ -10705,7 +10826,7 @@ function migrateAftConfigFile(opts) {
   if (existingSources.length === 0) {
     return { migrated: false, conflict: false, targetPath: opts.targetPath, warnings };
   }
-  mkdirSync4(dirname2(opts.targetPath), { recursive: true });
+  mkdirSync4(dirname3(opts.targetPath), { recursive: true });
   const release = acquireConfigMigrationLock(`${opts.targetPath}.lock`);
   try {
     const sources = existingSources.map((source) => ({
@@ -10762,13 +10883,13 @@ function spawnErrorLabel(error2) {
   return [code, error2.message].filter(Boolean).join(": ");
 }
 function migrationLogPath(newRoot, harness, logger) {
-  const desired = join6(newRoot, "logs", "migration", `${harness}-${Date.now()}.jsonl`);
+  const desired = join7(newRoot, "logs", "migration", `${harness}-${Date.now()}.jsonl`);
   try {
-    mkdirSync4(dirname2(desired), { recursive: true });
+    mkdirSync4(dirname3(desired), { recursive: true });
     return desired;
   } catch (err) {
-    const fallback = join6(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}.`);
+    const fallback = join7(tmpdir(), `aft-migration-${harness}-${Date.now()}.jsonl`);
+    logger?.warn?.(`Failed to create AFT migration log directory ${dirname3(desired)}: ${err instanceof Error ? err.message : String(err)}. ` + `Using fallback log path ${fallback}.`);
     return fallback;
   }
 }
@@ -10830,13 +10951,13 @@ async function ensureStorageMigrated(opts) {
 }
 // ../aft-bridge/dist/npm-resolver.js
 import { readdirSync, statSync as statSync3 } from "node:fs";
-import { homedir as homedir8 } from "node:os";
-import { delimiter, dirname as dirname3, isAbsolute as isAbsolute3, join as join7 } from "node:path";
+import { homedir as homedir9 } from "node:os";
+import { delimiter, dirname as dirname4, isAbsolute as isAbsolute3, join as join8 } from "node:path";
 function defaultDeps() {
   return {
     platform: process.platform,
     env: process.env,
-    home: homedir8(),
+    home: homedir9(),
     execPath: process.execPath
   };
 }
@@ -10857,14 +10978,14 @@ function npmFromPath(deps) {
     const dir = entry.trim().replace(/^"|"$/g, "");
     if (!dir || !isAbsolute3(dir))
       continue;
-    if (isFile(join7(dir, name)))
+    if (isFile(join8(dir, name)))
       return dir;
   }
   return null;
 }
 function npmAdjacentToNode(deps) {
-  const dir = dirname3(deps.execPath);
-  return isFile(join7(dir, npmBinaryName(deps.platform))) ? dir : null;
+  const dir = dirname4(deps.execPath);
+  return isFile(join8(dir, npmBinaryName(deps.platform))) ? dir : null;
 }
 function highestVersionedNodeBin(installsDir, name) {
   let entries;
@@ -10873,8 +10994,8 @@ function highestVersionedNodeBin(installsDir, name) {
   } catch {
     return null;
   }
-  const candidates = entries.filter((v) => isFile(join7(installsDir, v, "bin", name))).sort((a, b) => compareVersionsDesc(a, b));
-  return candidates.length > 0 ? join7(installsDir, candidates[0], "bin") : null;
+  const candidates = entries.filter((v) => isFile(join8(installsDir, v, "bin", name))).sort((a, b) => compareVersionsDesc(a, b));
+  return candidates.length > 0 ? join8(installsDir, candidates[0], "bin") : null;
 }
 function compareVersionsDesc(a, b) {
   const pa = a.replace(/^v/, "").split(".").map((n) => Number.parseInt(n, 10));
@@ -10899,22 +11020,22 @@ function wellKnownNpmDirs(deps) {
     const programFiles = env.ProgramFiles || "C:\\Program Files";
     const appData = env.APPDATA;
     const localAppData = env.LOCALAPPDATA;
-    push(join7(programFiles, "nodejs"));
+    push(join8(programFiles, "nodejs"));
     if (appData)
-      push(join7(appData, "npm"));
+      push(join8(appData, "npm"));
     if (localAppData)
-      push(join7(localAppData, "Volta", "bin"));
+      push(join8(localAppData, "Volta", "bin"));
     if (env.NVM_SYMLINK)
       push(env.NVM_SYMLINK);
   } else {
     if (env.NVM_BIN)
       push(env.NVM_BIN);
-    push(highestVersionedNodeBin(join7(home, ".nvm", "versions", "node"), name));
-    push(highestVersionedNodeBin(join7(home, ".local", "share", "mise", "installs", "node"), name));
-    push(highestVersionedNodeBin(join7(home, ".asdf", "installs", "nodejs"), name));
-    push(join7(home, ".volta", "bin"));
-    push(join7(home, ".asdf", "shims"));
-    const systemDirs = deps.systemNpmDirs ?? (platform === "darwin" ? ["/opt/homebrew/bin", "/usr/local/bin"] : ["/usr/local/bin", "/usr/bin", join7(home, ".local", "bin")]);
+    push(highestVersionedNodeBin(join8(home, ".nvm", "versions", "node"), name));
+    push(highestVersionedNodeBin(join8(home, ".local", "share", "mise", "installs", "node"), name));
+    push(highestVersionedNodeBin(join8(home, ".asdf", "installs", "nodejs"), name));
+    push(join8(home, ".volta", "bin"));
+    push(join8(home, ".asdf", "shims"));
+    const systemDirs = deps.systemNpmDirs ?? (platform === "darwin" ? ["/opt/homebrew/bin", "/usr/local/bin"] : ["/usr/local/bin", "/usr/bin", join8(home, ".local", "bin")]);
     for (const dir of systemDirs)
       push(dir);
   }
@@ -10924,12 +11045,12 @@ function resolveNpm(deps = defaultDeps()) {
   const name = npmBinaryName(deps.platform);
   const onPath = npmFromPath(deps);
   if (onPath)
-    return { command: join7(onPath, name), binDir: onPath };
+    return { command: join8(onPath, name), binDir: onPath };
   const adjacent = npmAdjacentToNode(deps);
   if (adjacent)
-    return { command: join7(adjacent, name), binDir: adjacent };
+    return { command: join8(adjacent, name), binDir: adjacent };
   for (const dir of wellKnownNpmDirs(deps)) {
-    const candidate = join7(dir, name);
+    const candidate = join8(dir, name);
     if (isFile(candidate))
       return { command: candidate, binDir: dir };
   }
@@ -10946,7 +11067,7 @@ function npmSpawnEnv(resolved, baseEnv = process.env) {
 import { execFileSync } from "node:child_process";
 import { createHash as createHash3 } from "node:crypto";
 import { chmodSync as chmodSync3, closeSync as closeSync4, copyFileSync as copyFileSync3, createWriteStream as createWriteStream2, existsSync as existsSync6, lstatSync, mkdirSync as mkdirSync5, openSync as openSync4, readdirSync as readdirSync2, readFileSync as readFileSync6, readlinkSync, realpathSync, rmSync as rmSync3, statSync as statSync4, symlinkSync, unlinkSync as unlinkSync4, writeFileSync as writeFileSync3 } from "node:fs";
-import { basename as basename2, dirname as dirname4, isAbsolute as isAbsolute4, join as join8, relative as relative2, resolve as resolve5, win32 } from "node:path";
+import { basename as basename2, dirname as dirname5, isAbsolute as isAbsolute4, join as join9, relative as relative2, resolve as resolve5, win32 } from "node:path";
 import { Readable as Readable2 } from "node:stream";
 import { pipeline as pipeline2 } from "node:stream/promises";
 var ORT_VERSION = "1.24.4";
@@ -11009,10 +11130,10 @@ function getManualInstallHint() {
 }
 async function ensureOnnxRuntime(storageDir) {
   const info = getPlatformInfo();
-  const ortVersionDir = join8(storageDir, "onnxruntime", ORT_VERSION);
+  const ortVersionDir = join9(storageDir, "onnxruntime", ORT_VERSION);
   const libName = info?.libName ?? "libonnxruntime.dylib";
   const resolvedOrtDir = resolveCachedOnnxRuntimeDir(ortVersionDir, libName);
-  const libPath = join8(resolvedOrtDir, libName);
+  const libPath = join9(resolvedOrtDir, libName);
   if (existsSync6(libPath)) {
     const meta = readOnnxInstalledMeta(ortVersionDir);
     if (meta?.sha256) {
@@ -11042,9 +11163,9 @@ async function ensureOnnxRuntime(storageDir) {
     warn(`ONNX Runtime auto-download not available for ${process.platform}/${process.arch}. Install manually: ${getManualInstallHint()}`);
     return null;
   }
-  const onnxBaseDir = join8(storageDir, "onnxruntime");
+  const onnxBaseDir = join9(storageDir, "onnxruntime");
   mkdirSync5(onnxBaseDir, { recursive: true });
-  const lockPath = join8(onnxBaseDir, ONNX_LOCK_FILE);
+  const lockPath = join9(onnxBaseDir, ONNX_LOCK_FILE);
   cleanupAbandonedStagingDirs(onnxBaseDir);
   if (!acquireLock(lockPath)) {
     warn(`ONNX Runtime install already in progress in another process (lock: ${lockPath}). Skipping.`);
@@ -11063,7 +11184,7 @@ function cleanupAbandonedStagingDirs(onnxBaseDir) {
     for (const entry of entries) {
       if (!entry.startsWith(`${ORT_VERSION}.tmp.`))
         continue;
-      const stagingDir = join8(onnxBaseDir, entry);
+      const stagingDir = join9(onnxBaseDir, entry);
       const parts = entry.split(".");
       const pidStr = parts[parts.length - 2];
       const pid = pidStr ? Number.parseInt(pidStr, 10) : NaN;
@@ -11100,7 +11221,7 @@ function cleanupAbandonedStagingDirs(onnxBaseDir) {
 }
 function cleanupIncompleteTargetIfUnowned(ortDir) {
   try {
-    if (existsSync6(ortDir) && !existsSync6(join8(ortDir, ONNX_INSTALLED_META_FILE))) {
+    if (existsSync6(ortDir) && !existsSync6(join9(ortDir, ONNX_INSTALLED_META_FILE))) {
       log(`[onnx] removing half-populated install dir ${ortDir} (no meta file)`);
       rmSync3(ortDir, { recursive: true, force: true });
     }
@@ -11144,7 +11265,7 @@ function detectOnnxVersion(libDir, libName) {
       if (version)
         return version;
     }
-    const base = join8(libDir, libName);
+    const base = join9(libDir, libName);
     if (existsSync6(base)) {
       try {
         const real = realpathSync(base);
@@ -11183,6 +11304,17 @@ function pathEntriesForPlatform() {
     return isAbsolute4(entry) || win32.isAbsolute(entry);
   });
 }
+function isWindowsSystem32Directory(dir) {
+  if (process.platform !== "win32")
+    return false;
+  const normalizedDir = win32.resolve(dir).replace(/[\\/]+$/, "").toLowerCase();
+  const windowsRoots = [process.env.SystemRoot, process.env.windir, "C:\\Windows"];
+  return windowsRoots.some((root) => {
+    if (!root)
+      return false;
+    return normalizedDir === win32.resolve(root, "System32").replace(/[\\/]+$/, "").toLowerCase();
+  });
+}
 function directoryContainsLibrary(dir, libName) {
   try {
     const entries = readdirSync2(dir);
@@ -11196,10 +11328,10 @@ function directoryContainsLibrary(dir, libName) {
   }
 }
 function resolveCachedOnnxRuntimeDir(ortVersionDir, libName) {
-  if (existsSync6(join8(ortVersionDir, libName)))
+  if (existsSync6(join9(ortVersionDir, libName)))
     return ortVersionDir;
-  const libSubdir = join8(ortVersionDir, "lib");
-  if (existsSync6(join8(libSubdir, libName)))
+  const libSubdir = join9(ortVersionDir, "lib");
+  if (existsSync6(join9(libSubdir, libName)))
     return libSubdir;
   return ortVersionDir;
 }
@@ -11214,12 +11346,12 @@ function findSystemOnnxRuntime(libName) {
   } else if (process.platform === "win32") {
     const programFiles = process.env.ProgramFiles ?? "C:\\Program Files";
     const programFilesX86 = process.env["ProgramFiles(x86)"] ?? "C:\\Program Files (x86)";
-    searchPaths.push(join8(programFiles, "onnxruntime", "lib"), join8(programFiles, "Microsoft ONNX Runtime", "lib"), join8(programFiles, "Microsoft Machine Learning", "lib"), join8(programFilesX86, "onnxruntime", "lib"), ...(() => {
+    searchPaths.push(join9(programFiles, "onnxruntime", "lib"), join9(programFiles, "Microsoft ONNX Runtime", "lib"), join9(programFiles, "Microsoft Machine Learning", "lib"), join9(programFilesX86, "onnxruntime", "lib"), ...(() => {
       const nugetPaths = [];
       const userProfile = process.env.USERPROFILE ?? "";
       if (!userProfile)
         return nugetPaths;
-      const nugetPackageDir = join8(userProfile, ".nuget", "packages", "microsoft.ml.onnxruntime");
+      const nugetPackageDir = join9(userProfile, ".nuget", "packages", "microsoft.ml.onnxruntime");
       if (!existsSync6(nugetPackageDir))
         return nugetPaths;
       try {
@@ -11228,7 +11360,7 @@ function findSystemOnnxRuntime(libName) {
             continue;
           if (entry.name === "__globalPackagesFolder" || entry.name.startsWith("."))
             continue;
-          nugetPaths.push(join8(nugetPackageDir, entry.name, "runtimes", "win-x64", "native"), join8(nugetPackageDir, entry.name, "runtimes", "win-arm64", "native"));
+          nugetPaths.push(join9(nugetPackageDir, entry.name, "runtimes", "win-x64", "native"), join9(nugetPackageDir, entry.name, "runtimes", "win-arm64", "native"));
         }
       } catch (err) {
         warn(`Failed to scan NuGet ONNX Runtime cache ${nugetPackageDir}: ${err instanceof Error ? err.message : String(err)}`);
@@ -11250,7 +11382,7 @@ function findSystemOnnxRuntime(libName) {
   });
   const unknownVersionPaths = [];
   for (const dir of uniquePaths) {
-    const libPath = join8(dir, libName);
+    const libPath = join9(dir, libName);
     if (process.platform === "win32") {
       if (!directoryContainsLibrary(dir, libName))
         continue;
@@ -11259,6 +11391,10 @@ function findSystemOnnxRuntime(libName) {
     }
     const version = detectOnnxVersion(dir, libName);
     if (!version) {
+      if (isWindowsSystem32Directory(dir)) {
+        warn(`Skipping unversioned Windows system ONNX Runtime at ${dir}; falling through to AFT-managed download.`);
+        continue;
+      }
       unknownVersionPaths.push(dir);
       continue;
     }
@@ -11286,7 +11422,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}`);
     }
-    mkdirSync5(dirname4(destPath), { recursive: true });
+    mkdirSync5(dirname5(destPath), { recursive: true });
     let bytesWritten = 0;
     const guard = new TransformStream({
       transform(chunk, transformController) {
@@ -11316,11 +11452,11 @@ function validateExtractedTree(stagingRoot) {
   const walk = (dir) => {
     const entries = readdirSync2(dir);
     for (const entry of entries) {
-      const fullPath = join8(dir, entry);
+      const fullPath = join9(dir, entry);
       const lst = lstatSync(fullPath);
       if (lst.isSymbolicLink()) {
         const linkTarget = readlinkSync(fullPath);
-        const resolvedTarget = resolve5(dirname4(fullPath), linkTarget);
+        const resolvedTarget = resolve5(dirname5(fullPath), linkTarget);
         const rel2 = relative2(realRoot, resolvedTarget);
         if (rel2.startsWith("..") || isAbsolute4(rel2) || win32.isAbsolute(rel2)) {
           throw new Error(`extracted symlink ${fullPath} points outside staging root: ${linkTarget}`);
@@ -11351,7 +11487,7 @@ async function downloadOnnxRuntime(info, targetDir) {
   const tmpDir = `${targetDir}.tmp.${process.pid}.${Date.now().toString(36)}`;
   try {
     mkdirSync5(tmpDir, { recursive: true });
-    const archivePath = join8(tmpDir, `onnxruntime.${info.archiveType}`);
+    const archivePath = join9(tmpDir, `onnxruntime.${info.archiveType}`);
     await downloadFileWithCap(url, archivePath);
     const archiveSha256 = sha256File(archivePath);
     log(`ONNX Runtime archive sha256=${archiveSha256}`);
@@ -11367,7 +11503,7 @@ async function downloadOnnxRuntime(info, targetDir) {
       unlinkSync4(archivePath);
     } catch {}
     validateExtractedTree(tmpDir);
-    const extractedDir = join8(tmpDir, info.assetName, "lib");
+    const extractedDir = join9(tmpDir, info.assetName, "lib");
     if (!existsSync6(extractedDir)) {
       throw new Error(`Expected directory not found: ${extractedDir}`);
     }
@@ -11376,11 +11512,11 @@ async function downloadOnnxRuntime(info, targetDir) {
     const realFiles = [];
     const symlinks = [];
     for (const libFile of libFiles) {
-      const src = join8(extractedDir, libFile);
+      const src = join9(extractedDir, libFile);
       try {
-        const stat = lstatSync(src);
-        log(`ORT extract: ${libFile} — isSymlink=${stat.isSymbolicLink()}, isFile=${stat.isFile()}, size=${stat.size}`);
-        if (stat.isSymbolicLink()) {
+        const stat2 = lstatSync(src);
+        log(`ORT extract: ${libFile} — isSymlink=${stat2.isSymbolicLink()}, isFile=${stat2.isFile()}, size=${stat2.size}`);
+        if (stat2.isSymbolicLink()) {
           symlinks.push({ name: libFile, target: readlinkSync(src) });
         } else {
           realFiles.push(libFile);
@@ -11391,7 +11527,7 @@ async function downloadOnnxRuntime(info, targetDir) {
       }
     }
     copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks);
-    const libPath = join8(targetDir, info.libName);
+    const libPath = join9(targetDir, info.libName);
     let libHash = null;
     try {
       libHash = sha256File(libPath);
@@ -11416,8 +11552,8 @@ async function downloadOnnxRuntime(info, targetDir) {
 function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, copyFile = copyFileSync3) {
   const requiredLibs = new Set([info.libName]);
   for (const libFile of realFiles) {
-    const src = join8(extractedDir, libFile);
-    const dst = join8(targetDir, libFile);
+    const src = join9(extractedDir, libFile);
+    const dst = join9(targetDir, libFile);
     try {
       copyFile(src, dst);
       if (process.platform !== "win32") {
@@ -11433,12 +11569,12 @@ function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, c
   }
   const targetRoot = realpathSync(targetDir);
   for (const link of symlinks) {
-    const dst = join8(targetDir, link.name);
+    const dst = join9(targetDir, link.name);
     try {
       unlinkSync4(dst);
     } catch {}
-    const dstForContainment = join8(targetRoot, link.name);
-    const resolvedTarget = resolve5(dirname4(dstForContainment), link.target);
+    const dstForContainment = join9(targetRoot, link.name);
+    const resolvedTarget = resolve5(dirname5(dstForContainment), link.target);
     if (!isPathInsideRoot(targetRoot, resolvedTarget)) {
       const message = `ONNX Runtime symlink ${link.name} points outside install dir: ${link.target}`;
       if (requiredLibs.has(link.name)) {
@@ -11458,7 +11594,7 @@ function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, c
       log(`ORT extract: failed to symlink optional ${link.name}: ${symlinkErr}`);
     }
   }
-  const requiredPath = join8(targetDir, info.libName);
+  const requiredPath = join9(targetDir, info.libName);
   if (!existsSync6(requiredPath)) {
     rmSync3(targetDir, { recursive: true, force: true });
     throw new Error(`Required ONNX Runtime library missing after install: ${requiredPath}`);
@@ -11485,13 +11621,13 @@ function writeOnnxInstalledMeta(installDir, version, sha256, archiveSha256) {
       ...sha256 ? { sha256 } : {},
       archiveSha256
     };
-    writeFileSync3(join8(installDir, ONNX_INSTALLED_META_FILE), JSON.stringify(meta), "utf8");
+    writeFileSync3(join9(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 path2 = join8(installDir, ONNX_INSTALLED_META_FILE);
+  const path2 = join9(installDir, ONNX_INSTALLED_META_FILE);
   try {
     if (!statSync4(path2).isFile())
       return null;
@@ -11628,7 +11764,7 @@ function isProcessAlive(pid) {
   }
 }
 // ../aft-bridge/dist/pool.js
-import { homedir as homedir9 } from "node:os";
+import { homedir as homedir10 } from "node:os";
 
 // ../aft-bridge/dist/project-identity.js
 import { realpathSync as realpathSync2 } from "node:fs";
@@ -11667,7 +11803,7 @@ var DEFAULT_MAX_POOL_SIZE = 8;
 var CLEANUP_INTERVAL_MS = 60 * 1000;
 function canonicalHomeDir() {
   try {
-    const home = homedir9();
+    const home = homedir10();
     if (!home)
       return null;
     return canonicalizeProjectRoot(home);
@@ -11693,6 +11829,7 @@ class BridgePool {
   projectConfigLoader;
   logger;
   cleanupTimer = null;
+  shutdownCalled = false;
   constructor(binaryPath, options = {}, configOverrides = {}) {
     this.binaryPath = binaryPath;
     this.maxPoolSize = options.maxPoolSize ?? DEFAULT_MAX_POOL_SIZE;
@@ -11714,12 +11851,11 @@ class BridgePool {
       childEnv: options.childEnv
     };
     this.configOverrides = configOverrides;
-    if (Number.isFinite(this.idleTimeoutMs)) {
-      this.cleanupTimer = setInterval(() => this.cleanup(), CLEANUP_INTERVAL_MS);
-      this.cleanupTimer.unref();
-    }
+    this.startCleanupTimer();
   }
   getActiveBridgeForRoot(projectRoot) {
+    if (this.shutdownCalled)
+      return null;
     const key = normalizeKey(projectRoot);
     const entry = this.bridges.get(key);
     if (!entry?.bridge.isAlive())
@@ -11727,7 +11863,21 @@ class BridgePool {
     entry.lastUsed = Date.now();
     return entry.bridge;
   }
+  activeBridges() {
+    if (this.shutdownCalled)
+      return [];
+    const alive = [];
+    for (const entry of this.bridges.values()) {
+      if (entry.bridge.isAlive())
+        alive.push(entry.bridge);
+    }
+    return alive;
+  }
   getBridge(projectRoot) {
+    if (this.shutdownCalled) {
+      this.shutdownCalled = false;
+      this.startCleanupTimer();
+    }
     const key = normalizeKey(projectRoot);
     const existing = this.bridges.get(key);
     if (existing) {
@@ -11737,15 +11887,7 @@ class BridgePool {
     if (this.bridges.size >= this.maxPoolSize) {
       this.evictLRU();
     }
-    let projectOverrides = {};
-    if (this.projectConfigLoader) {
-      try {
-        projectOverrides = this.projectConfigLoader(key) ?? {};
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        this.error(`projectConfigLoader failed; using global overrides only: ${message}`);
-      }
-    }
+    const projectOverrides = this.loadProjectOverrides(key);
     const mergedOverrides = { ...this.configOverrides, ...projectOverrides };
     const bridge = new BinaryBridge(this.binaryPath, key, this.bridgeOptions, mergedOverrides);
     this.bridges.set(key, { bridge, lastUsed: Date.now() });
@@ -11795,6 +11937,7 @@ class BridgePool {
   }
   async closeSession(_projectRoot, _session) {}
   async shutdown() {
+    this.shutdownCalled = true;
     if (this.cleanupTimer) {
       clearInterval(this.cleanupTimer);
       this.cleanupTimer = null;
@@ -11807,6 +11950,9 @@ class BridgePool {
     this.staleBridges.clear();
     await Promise.allSettled(shutdowns);
   }
+  isShutdown() {
+    return this.shutdownCalled;
+  }
   async replaceBinary(newPath) {
     this.binaryPath = newPath;
     for (const entry of this.bridges.values()) {
@@ -11816,6 +11962,12 @@ class BridgePool {
     this.log(`Binary path updated to ${newPath}. Active bridges marked stale — next calls will use the new binary.`);
     return newPath;
   }
+  startCleanupTimer() {
+    if (!Number.isFinite(this.idleTimeoutMs) || this.cleanupTimer)
+      return;
+    this.cleanupTimer = setInterval(() => this.cleanup(), CLEANUP_INTERVAL_MS);
+    this.cleanupTimer.unref();
+  }
   log(message, meta) {
     const logger = this.logger ?? getActiveLogger();
     if (logger) {
@@ -11847,6 +11999,36 @@ class BridgePool {
       this.configOverrides[key] = value;
     }
   }
+  async reconfigure(projectRoot, overrides) {
+    const key = normalizeKey(projectRoot);
+    for (const [name, value] of Object.entries(overrides)) {
+      this.setConfigureOverride(name, value);
+    }
+    const bridge = this.getActiveBridgeForRoot(key);
+    if (!bridge)
+      return;
+    const projectOverrides = this.loadProjectOverrides(key);
+    const response = await bridge.send("configure", {
+      project_root: key,
+      ...this.configOverrides,
+      ...projectOverrides,
+      ...overrides
+    });
+    if (response.success === false) {
+      throw new Error(`configure refresh failed for ${key}: ${String(response.message ?? "unknown error")}`);
+    }
+  }
+  loadProjectOverrides(key) {
+    if (!this.projectConfigLoader)
+      return {};
+    try {
+      return this.projectConfigLoader(key) ?? {};
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.error(`projectConfigLoader failed; using global overrides only: ${message}`);
+      return {};
+    }
+  }
   get size() {
     return this.bridges.size;
   }
@@ -11860,11 +12042,185 @@ class BridgePool {
 function normalizeKey(projectRoot) {
   return canonicalizeProjectRoot(projectRoot);
 }
-// ../../node_modules/.bun/@cortexkit+subc-client@0.3.4/node_modules/@cortexkit/subc-client/dist/client.js
+// ../aft-bridge/dist/revivable-transport.js
+class RevivableTransportPool {
+  createPool;
+  onBinaryReplaced;
+  activePool;
+  revival = null;
+  transports = new Map;
+  configureOverrides = new Map;
+  constructor(initialPool, createPool, onBinaryReplaced) {
+    this.createPool = createPool;
+    this.onBinaryReplaced = onBinaryReplaced;
+    this.activePool = initialPool;
+  }
+  getBridge(projectRoot) {
+    const key = canonicalizeProjectRoot(projectRoot);
+    let transport = this.transports.get(key);
+    if (!transport) {
+      transport = new RevivableProjectTransport(this, key);
+      this.transports.set(key, transport);
+    }
+    return transport;
+  }
+  activeBridges() {
+    return this.activePool.activeBridges();
+  }
+  getActiveBridgeForRoot(projectRoot) {
+    const key = canonicalizeProjectRoot(projectRoot);
+    const bridge = this.currentBridge(key);
+    if (!bridge)
+      return null;
+    const transport = this.getBridge(key);
+    transport.refreshStatusSubscription(bridge);
+    return transport;
+  }
+  async toolCall(projectRoot, runtime, name, rawArgs = {}, options) {
+    return this.getBridge(projectRoot).toolCall(runtime.sessionID, name, rawArgs, options);
+  }
+  setConfigureOverride(key, value) {
+    if (value === undefined)
+      this.configureOverrides.delete(key);
+    else
+      this.configureOverrides.set(key, value);
+    this.activePool.setConfigureOverride(key, value);
+  }
+  async reconfigure(projectRoot, overrides) {
+    for (const [key, value] of Object.entries(overrides)) {
+      if (value === undefined)
+        this.configureOverrides.delete(key);
+      else
+        this.configureOverrides.set(key, value);
+    }
+    const pool = await this.ensureActivePool();
+    await pool.reconfigure(projectRoot, overrides);
+  }
+  async replaceBinary(path2) {
+    const replaced = await this.activePool.replaceBinary(path2);
+    this.onBinaryReplaced?.(replaced);
+    return replaced;
+  }
+  closeSession(projectRoot, session) {
+    return this.activePool.closeSession(projectRoot, session);
+  }
+  async shutdown() {
+    const revival = this.revival;
+    if (revival) {
+      await Promise.allSettled([revival]);
+    }
+    await this.activePool.shutdown();
+    for (const transport of this.transports.values()) {
+      transport.refreshStatusSubscription(null);
+    }
+  }
+  isShutdown() {
+    return this.activePool.isShutdown();
+  }
+  async ensureActivePool() {
+    if (!this.activePool.isShutdown())
+      return this.activePool;
+    if (this.revival)
+      return this.revival;
+    warn("transport was shut down but new demand arrived — reviving (host quit hook fired without process exit?)");
+    const revival = this.createPool().then((pool) => {
+      for (const [key, value] of this.configureOverrides) {
+        pool.setConfigureOverride(key, value);
+      }
+      this.activePool = pool;
+      for (const [root, transport] of this.transports) {
+        transport.refreshStatusSubscription(pool.getActiveBridgeForRoot(root));
+      }
+      return pool;
+    });
+    this.revival = revival;
+    revival.then(() => {
+      if (this.revival === revival)
+        this.revival = null;
+    }, () => {
+      if (this.revival === revival)
+        this.revival = null;
+    });
+    return revival;
+  }
+  currentBridge(projectRoot) {
+    return this.activePool.getActiveBridgeForRoot(projectRoot);
+  }
+  async send(projectRoot, command, params, options) {
+    const pool = await this.ensureActivePool();
+    const bridge = pool.getBridge(projectRoot);
+    this.getBridge(projectRoot).refreshStatusSubscription(bridge);
+    return bridge.send(command, params, options);
+  }
+  async toolCallOnProject(projectRoot, sessionId, name, rawArgs, options) {
+    const pool = await this.ensureActivePool();
+    const bridge = pool.getBridge(projectRoot);
+    this.getBridge(projectRoot).refreshStatusSubscription(bridge);
+    return bridge.toolCall(sessionId, name, rawArgs, options);
+  }
+}
+
+class RevivableProjectTransport {
+  owner;
+  projectRoot;
+  statusListeners = new Map;
+  statusBridges = new Map;
+  constructor(owner, projectRoot) {
+    this.owner = owner;
+    this.projectRoot = projectRoot;
+  }
+  getCwd() {
+    return this.projectRoot;
+  }
+  getStatusBar() {
+    return this.owner.currentBridge(this.projectRoot)?.getStatusBar();
+  }
+  getCachedStatus() {
+    return this.owner.currentBridge(this.projectRoot)?.getCachedStatus() ?? null;
+  }
+  cacheStatusSnapshot(snapshot) {
+    this.owner.currentBridge(this.projectRoot)?.cacheStatusSnapshot(snapshot);
+  }
+  send(command, params, options) {
+    return this.owner.send(this.projectRoot, command, params, options);
+  }
+  toolCall(sessionId, name, rawArgs, options) {
+    return this.owner.toolCallOnProject(this.projectRoot, sessionId, name, rawArgs, options);
+  }
+  subscribeStatus(listener) {
+    if (this.statusListeners.has(listener))
+      return () => this.removeStatusListener(listener);
+    this.statusListeners.set(listener, () => {});
+    this.bindStatusListener(listener, this.owner.currentBridge(this.projectRoot));
+    return () => this.removeStatusListener(listener);
+  }
+  refreshStatusSubscription(bridge) {
+    for (const listener of this.statusListeners.keys()) {
+      this.bindStatusListener(listener, bridge);
+    }
+  }
+  bindStatusListener(listener, bridge) {
+    if (this.statusBridges.get(listener) === bridge)
+      return;
+    const previousUnsubscribe = this.statusListeners.get(listener);
+    previousUnsubscribe?.();
+    const maybe = bridge;
+    const unsubscribe = maybe && typeof maybe.subscribeStatus === "function" ? maybe.subscribeStatus(listener) : () => {};
+    this.statusListeners.set(listener, unsubscribe);
+    this.statusBridges.set(listener, bridge);
+  }
+  removeStatusListener(listener) {
+    const unsubscribe = this.statusListeners.get(listener);
+    this.statusListeners.delete(listener);
+    this.statusBridges.delete(listener);
+    unsubscribe?.();
+  }
+}
+// ../../node_modules/.bun/@cortexkit+subc-client@0.5.0/node_modules/@cortexkit/subc-client/dist/client.js
 import { promises as fs2 } from "node:fs";
 import { debuglog } from "node:util";
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.3.4/node_modules/@cortexkit/subc-client/dist/auth.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.5.0/node_modules/@cortexkit/subc-client/dist/auth.js
 import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
 var NONCE_LEN = 32;
 var MAX_AUTH_MESSAGE_LEN = 4096;
@@ -11928,8 +12284,146 @@ async function authenticateClient(sock, conn, deadlineMs) {
   await writeMessage(sock, { client_auth: Array.from(clientAuth) }, deadlineMs);
 }
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.3.4/node_modules/@cortexkit/subc-client/dist/connection-file.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.5.0/node_modules/@cortexkit/subc-client/dist/connection-file.js
 import { promises as fs } from "node:fs";
+
+// ../../node_modules/.bun/@cortexkit+subc-client@0.5.0/node_modules/@cortexkit/subc-client/dist/envelope.js
+var PROTOCOL_VERSION = 2;
+var HEADER_LEN = 21;
+var FROZEN_PREFIX_LEN = 5;
+var MAX_FRAME_BODY_LEN = 64 * 1024 * 1024;
+var FrameType;
+(function(FrameType2) {
+  FrameType2[FrameType2["Request"] = 0] = "Request";
+  FrameType2[FrameType2["Response"] = 1] = "Response";
+  FrameType2[FrameType2["Push"] = 2] = "Push";
+  FrameType2[FrameType2["StreamData"] = 3] = "StreamData";
+  FrameType2[FrameType2["StreamEnd"] = 4] = "StreamEnd";
+  FrameType2[FrameType2["Error"] = 5] = "Error";
+  FrameType2[FrameType2["Cancel"] = 6] = "Cancel";
+  FrameType2[FrameType2["Ping"] = 7] = "Ping";
+  FrameType2[FrameType2["Pong"] = 8] = "Pong";
+  FrameType2[FrameType2["Hello"] = 9] = "Hello";
+  FrameType2[FrameType2["HelloAck"] = 10] = "HelloAck";
+  FrameType2[FrameType2["Goodbye"] = 11] = "Goodbye";
+})(FrameType || (FrameType = {}));
+var FRAME_TYPE_MAX = FrameType.Goodbye;
+function isPureHeader(ty) {
+  return ty === FrameType.Cancel || ty === FrameType.Ping || ty === FrameType.Pong || ty === FrameType.Goodbye;
+}
+var Priority;
+(function(Priority2) {
+  Priority2[Priority2["Passive"] = 0] = "Passive";
+  Priority2[Priority2["Interactive"] = 1] = "Interactive";
+  Priority2[Priority2["Background"] = 2] = "Background";
+})(Priority || (Priority = {}));
+var AdmissionClass;
+(function(AdmissionClass2) {
+  AdmissionClass2[AdmissionClass2["Normal"] = 0] = "Normal";
+  AdmissionClass2[AdmissionClass2["Expedite"] = 1] = "Expedite";
+  AdmissionClass2[AdmissionClass2["Sheddable"] = 2] = "Sheddable";
+})(AdmissionClass || (AdmissionClass = {}));
+var FLAG_BINARY = 1;
+var FLAG_PRIORITY_MASK = 6;
+var FLAG_PRIORITY_SHIFT = 1;
+var FLAG_LAST = 8;
+var FLAG_ADMISSION_MASK = 48;
+var FLAG_ADMISSION_SHIFT = 4;
+var FLAG_RESERVED_MASK = 192;
+function buildFlags(binary, priority, last, admissionClass = AdmissionClass.Normal) {
+  let flags = 0;
+  if (binary)
+    flags |= FLAG_BINARY;
+  flags |= priority << FLAG_PRIORITY_SHIFT;
+  if (last)
+    flags |= FLAG_LAST;
+  flags |= admissionClass << FLAG_ADMISSION_SHIFT;
+  return flags;
+}
+function encodeHeader(header) {
+  const buffer = new Uint8Array(HEADER_LEN);
+  const view = new DataView(buffer.buffer);
+  view.setUint32(0, header.len, true);
+  buffer[4] = header.ver;
+  buffer[5] = header.ty;
+  buffer[6] = header.flags;
+  view.setUint16(7, header.channel, true);
+  view.setUint32(9, header.epoch, true);
+  view.setBigUint64(13, header.corr, true);
+  return buffer;
+}
+
+class DecodeError extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "DecodeError";
+  }
+}
+function decodeHeader(bytes) {
+  if (bytes.length < FROZEN_PREFIX_LEN) {
+    throw new DecodeError(`header shorter than frozen prefix: have ${bytes.length} bytes`, "too_short_for_prefix");
+  }
+  const ver = bytes[4];
+  if (ver !== PROTOCOL_VERSION)
+    throw new DecodeError(`unsupported envelope version ${ver}`, "unsupported_version");
+  if (bytes.length < HEADER_LEN) {
+    throw new DecodeError(`header too short for version: have ${bytes.length} bytes, need ${HEADER_LEN}`, "too_short_for_header");
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const len = view.getUint32(0, true);
+  const typeByte = bytes[5];
+  if (typeByte > FRAME_TYPE_MAX)
+    throw new DecodeError(`unknown frame type byte ${typeByte}`, "unknown_frame_type");
+  const ty = typeByte;
+  const flags = bytes[6];
+  if ((flags & FLAG_RESERVED_MASK) !== 0) {
+    throw new DecodeError(`reserved flag bits set in flags 0b${flags.toString(2).padStart(8, "0")}`, "reserved_flag_bits");
+  }
+  if ((flags & FLAG_PRIORITY_MASK) >> FLAG_PRIORITY_SHIFT === 3) {
+    throw new DecodeError(`reserved priority bits set in flags 0b${flags.toString(2).padStart(8, "0")}`, "reserved_priority_bits");
+  }
+  const admission = (flags & FLAG_ADMISSION_MASK) >> FLAG_ADMISSION_SHIFT;
+  if (admission === 3) {
+    throw new DecodeError(`reserved admission class set in flags 0b${flags.toString(2).padStart(8, "0")}`, "reserved_admission_class");
+  }
+  if (admission === AdmissionClass.Sheddable && ty !== FrameType.Push && ty !== FrameType.StreamData) {
+    throw new DecodeError(`SHEDDABLE admission class is illegal on ${FrameType[ty]} in flags 0b${flags.toString(2).padStart(8, "0")}`, "sheddable_illegal_frame_type");
+  }
+  const channel = view.getUint16(7, true);
+  const epoch = view.getUint32(9, true);
+  if (channel === 0 && epoch !== 0) {
+    throw new DecodeError(`control channel carried nonzero epoch ${epoch}`, "nonzero_epoch_on_control_channel");
+  }
+  if (isPureHeader(ty) && len !== 0) {
+    throw new DecodeError(`pure-header frame ${FrameType[ty]} declared non-zero body length ${len}`, "pure_header_frame_with_body");
+  }
+  return { len, ver, ty, flags, channel, epoch, corr: view.getBigUint64(13, true) };
+}
+function buildFrame(ty, flags, channel, epoch, corr, body) {
+  return buildFrameWithVersion(PROTOCOL_VERSION, ty, flags, channel, epoch, corr, body);
+}
+function buildFrameWithVersion(ver, ty, flags, channel, epoch, corr, body) {
+  if (body.length > MAX_FRAME_BODY_LEN) {
+    throw new DecodeError(`frame body ${body.length} exceeds max ${MAX_FRAME_BODY_LEN}`, "frame_body_too_large");
+  }
+  const header = { len: body.length, ver, ty, flags, channel, epoch, corr };
+  decodeHeader(encodeHeader(header));
+  return { header, body };
+}
+function encodeFrame(frame) {
+  if (frame.header.len !== frame.body.length) {
+    throw new DecodeError(`frame header length ${frame.header.len} does not match body length ${frame.body.length}`, "frame_length_mismatch");
+  }
+  const header = encodeHeader(frame.header);
+  const output = new Uint8Array(header.length + frame.body.length);
+  output.set(header, 0);
+  output.set(frame.body, header.length);
+  return output;
+}
+
+// ../../node_modules/.bun/@cortexkit+subc-client@0.5.0/node_modules/@cortexkit/subc-client/dist/connection-file.js
 var SCHEMA_VERSION = 1;
 var MIN_KEY_LEN = 32;
 var DAEMON_ID_LEN = 16;
@@ -11959,8 +12453,8 @@ function validate(info) {
 async function verifyOwnerOnly(path2) {
   if (process.platform === "win32")
     return;
-  const stat = await fs.stat(path2);
-  const mode = stat.mode & 511;
+  const stat2 = await fs.stat(path2);
+  const mode = stat2.mode & 511;
   if ((mode & 63) !== 0) {
     throw new ConnectionFileError(`connection file ${path2} has insecure permissions 0o${mode.toString(8)}; expected owner-only 0600`);
   }
@@ -11974,6 +12468,10 @@ async function readConnectionFile(path2) {
   } catch (err) {
     throw new ConnectionFileError(`connection file JSON read failed for ${path2}: ${String(err)}`);
   }
+  const wireVersion = parsed.wire_version;
+  if (wireVersion !== undefined && wireVersion !== PROTOCOL_VERSION) {
+    throw new ConnectionFileError(`connection file wire_version ${String(wireVersion)} but this client speaks ${PROTOCOL_VERSION}; the client library must be upgraded`);
+  }
   const endpointsRaw = parsed.endpoints;
   if (!Array.isArray(endpointsRaw)) {
     throw new ConnectionFileError("connection file 'endpoints' must be an array");
@@ -11991,128 +12489,60 @@ async function readConnectionFile(path2) {
     key: toBytes(parsed.key, "key"),
     daemonId: toBytes(parsed.daemon_id, "daemon_id"),
     pid: parsed.pid,
-    daemonVer: parsed.daemon_ver ?? ""
-  };
-  validate(info);
-  return info;
-}
-
-// ../../node_modules/.bun/@cortexkit+subc-client@0.3.4/node_modules/@cortexkit/subc-client/dist/envelope.js
-var PROTOCOL_VERSION = 1;
-var HEADER_LEN = 17;
-var FROZEN_PREFIX_LEN = 5;
-var MAX_FRAME_BODY_LEN = 64 * 1024 * 1024;
-var FrameType;
-(function(FrameType2) {
-  FrameType2[FrameType2["Request"] = 0] = "Request";
-  FrameType2[FrameType2["Response"] = 1] = "Response";
-  FrameType2[FrameType2["Push"] = 2] = "Push";
-  FrameType2[FrameType2["StreamData"] = 3] = "StreamData";
-  FrameType2[FrameType2["StreamEnd"] = 4] = "StreamEnd";
-  FrameType2[FrameType2["Error"] = 5] = "Error";
-  FrameType2[FrameType2["Cancel"] = 6] = "Cancel";
-  FrameType2[FrameType2["Ping"] = 7] = "Ping";
-  FrameType2[FrameType2["Pong"] = 8] = "Pong";
-  FrameType2[FrameType2["Hello"] = 9] = "Hello";
-  FrameType2[FrameType2["HelloAck"] = 10] = "HelloAck";
-  FrameType2[FrameType2["Goodbye"] = 11] = "Goodbye";
-})(FrameType || (FrameType = {}));
-var FRAME_TYPE_MAX = FrameType.Goodbye;
-function isPureHeader(ty) {
-  return ty === FrameType.Cancel || ty === FrameType.Ping || ty === FrameType.Pong || ty === FrameType.Goodbye;
-}
-var Priority;
-(function(Priority2) {
-  Priority2[Priority2["Passive"] = 0] = "Passive";
-  Priority2[Priority2["Interactive"] = 1] = "Interactive";
-  Priority2[Priority2["Background"] = 2] = "Background";
-})(Priority || (Priority = {}));
-var FLAG_BINARY = 1;
-var FLAG_PRIORITY_MASK = 6;
-var FLAG_PRIORITY_SHIFT = 1;
-var FLAG_LAST = 8;
-var FLAG_RESERVED_MASK = 240;
-function buildFlags(binary, priority, last) {
-  let b = 0;
-  if (binary)
-    b |= FLAG_BINARY;
-  b |= priority << FLAG_PRIORITY_SHIFT;
-  if (last)
-    b |= FLAG_LAST;
-  return b;
-}
-function encodeHeader(h) {
-  const buf = new Uint8Array(HEADER_LEN);
-  const view = new DataView(buf.buffer);
-  view.setUint32(0, h.len, true);
-  buf[4] = h.ver;
-  buf[5] = h.ty;
-  buf[6] = h.flags;
-  view.setUint16(7, h.channel, true);
-  view.setBigUint64(9, h.corr, true);
-  return buf;
+    daemonVer: parsed.daemon_ver ?? ""
+  };
+  validate(info);
+  return info;
 }
 
-class DecodeError extends Error {
-}
-function decodeHeader(bytes) {
-  if (bytes.length < FROZEN_PREFIX_LEN) {
-    throw new DecodeError(`header shorter than frozen prefix: have ${bytes.length} bytes`);
-  }
-  const ver = bytes[4];
-  if (ver !== PROTOCOL_VERSION) {
-    throw new DecodeError(`unsupported envelope version ${ver}`);
-  }
-  if (bytes.length < HEADER_LEN) {
-    throw new DecodeError(`header too short for version: have ${bytes.length} bytes, need ${HEADER_LEN}`);
-  }
-  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-  const len = view.getUint32(0, true);
-  const tyByte = bytes[5];
-  if (tyByte > FRAME_TYPE_MAX) {
-    throw new DecodeError(`unknown frame type byte ${tyByte}`);
-  }
-  const ty = tyByte;
-  const flags = bytes[6];
-  if ((flags & FLAG_RESERVED_MASK) !== 0) {
-    throw new DecodeError(`reserved flag bits set in flags 0b${flags.toString(2)}`);
-  }
-  if ((flags & FLAG_PRIORITY_MASK) >> FLAG_PRIORITY_SHIFT === 3) {
-    throw new DecodeError(`reserved priority bits set in flags 0b${flags.toString(2)}`);
+// ../../node_modules/.bun/@cortexkit+subc-client@0.5.0/node_modules/@cortexkit/subc-client/dist/route-handle.js
+var connectionToken = new WeakMap;
+
+class RouteHandle {
+  channel;
+  epoch;
+  constructor(channel, epoch, token) {
+    if (!Number.isInteger(channel) || channel <= 0 || channel > 65535) {
+      throw new RangeError(`route channel must be an integer in 1..65535, got ${channel}`);
+    }
+    if (!Number.isInteger(epoch) || epoch <= 0 || epoch > 4294967295) {
+      throw new RangeError(`route epoch must be an integer in 1..4294967295, got ${epoch}`);
+    }
+    this.channel = channel;
+    this.epoch = epoch;
+    connectionToken.set(this, token);
+    Object.freeze(this);
   }
-  if (isPureHeader(ty) && len !== 0) {
-    throw new DecodeError(`pure-header frame ${FrameType[ty]} declared non-zero body length ${len}`);
+  static create(channel, epoch, token) {
+    return new RouteHandle(channel, epoch, token);
   }
-  const channel = view.getUint16(7, true);
-  const corr = view.getBigUint64(9, true);
-  return { len, ver, ty, flags, channel, corr };
 }
-function buildFrame(ty, flags, channel, corr, body) {
-  return buildFrameWithVersion(PROTOCOL_VERSION, ty, flags, channel, corr, body);
+function createRouteHandle(channel, epoch, token) {
+  const factory = RouteHandle;
+  return factory.create(channel, epoch, token);
 }
-function buildFrameWithVersion(ver, ty, flags, channel, corr, body) {
-  if (body.length > MAX_FRAME_BODY_LEN) {
-    throw new DecodeError(`frame body ${body.length} exceeds max ${MAX_FRAME_BODY_LEN}`);
-  }
-  if (isPureHeader(ty) && body.length !== 0) {
-    throw new DecodeError(`pure-header frame ${FrameType[ty]} cannot carry a body`);
+
+class StaleRouteHandleError extends Error {
+  handle;
+  code = "stale_route_handle";
+  constructor(handle) {
+    super(`route handle (${handle.channel}, ${handle.epoch}) is not live on the current connection`);
+    this.handle = handle;
+    this.name = "StaleRouteHandleError";
   }
-  return {
-    header: { len: body.length, ver, ty, flags, channel, corr },
-    body
-  };
 }
-function encodeFrame(frame) {
-  const header = encodeHeader(frame.header);
-  const out = new Uint8Array(header.length + frame.body.length);
-  out.set(header, 0);
-  out.set(frame.body, header.length);
-  return out;
+function newConnectionToken() {
+  return Object.freeze({});
+}
+function belongsToConnection(handle, token) {
+  return connectionToken.get(handle) === token;
+}
+function sameRouteHandle(left, right) {
+  return left === right;
 }
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.3.4/node_modules/@cortexkit/subc-client/dist/socket.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.5.0/node_modules/@cortexkit/subc-client/dist/socket.js
 import net from "node:net";
-
 class SocketClosedError extends Error {
 }
 
@@ -12181,6 +12611,24 @@ class SubcSocket {
       });
     });
   }
+  async readFrame(headerDeadlineMs, bodyDeadline, onHeader) {
+    const prefix = await this.readExact(FROZEN_PREFIX_LEN, headerDeadlineMs);
+    const version = prefix[4];
+    if (version !== PROTOCOL_VERSION)
+      throw new DecodeError(`unsupported envelope version ${version}`, "unsupported_version");
+    const remainder = await this.readExact(HEADER_LEN - FROZEN_PREFIX_LEN, headerDeadlineMs);
+    const headerBytes = new Uint8Array(HEADER_LEN);
+    headerBytes.set(prefix);
+    headerBytes.set(remainder, FROZEN_PREFIX_LEN);
+    const header = decodeHeader(headerBytes);
+    if (header.len > MAX_FRAME_BODY_LEN) {
+      throw new DecodeError(`frame body ${header.len} exceeds max ${MAX_FRAME_BODY_LEN}`, "frame_body_too_large");
+    }
+    onHeader?.();
+    const bodyDeadlineMs = typeof bodyDeadline === "number" ? bodyDeadline : Date.now() + bodyDeadline.afterHeaderMs;
+    const body = header.len === 0 ? new Uint8Array(0) : await this.readExact(header.len, bodyDeadlineMs);
+    return { header, body };
+  }
   readExact(n, deadlineMs) {
     if (this.waiter) {
       return Promise.reject(new Error("concurrent readExact is not supported"));
@@ -12302,7 +12750,7 @@ class SubcSocket {
   }
 }
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.3.4/node_modules/@cortexkit/subc-client/dist/client.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.5.0/node_modules/@cortexkit/subc-client/dist/client.js
 var debug = debuglog("subc-client");
 var DEFAULT_HANDSHAKE_TIMEOUT_MS = 1e4;
 var DEFAULT_REQUEST_TIMEOUT_MS = 30000;
@@ -12348,7 +12796,11 @@ class SubcClient {
   opts;
   nextCorr = 1n;
   pending = new Map;
+  lateResponses = new Map;
   routes = new Map;
+  liveRoutes = new Map;
+  connectionToken = newConnectionToken();
+  ingressEpochDropCount = 0;
   closedErr = null;
   closeStarted = false;
   reconnecting = null;
@@ -12376,40 +12828,71 @@ class SubcClient {
   }
   async routeOpen(target, identity, opts = {}) {
     const consumerIdentity = routeOpenConsumerIdentity(opts);
+    const consumerCapabilities = opts.consumerCapabilities;
     const body = this.encode({
       op: "route.open",
       target,
       identity,
-      ...consumerIdentity ? { consumer_identity: consumerIdentity } : {}
+      ...consumerIdentity ? { consumer_identity: consumerIdentity } : {},
+      ...consumerCapabilities !== undefined ? { consumer_capabilities: consumerCapabilities } : {}
     });
-    const reply = await this.controlRpc(body);
-    const parsed = this.parseJson(reply);
-    if (typeof parsed.route_channel !== "number") {
-      throw new SubcError(`route.open returned no route_channel: ${JSON.stringify(parsed)}`);
-    }
-    return parsed.route_channel;
+    let installed = null;
+    const install = (frame) => {
+      if (frame.header.ty !== FrameType.Response)
+        return true;
+      const parsed = this.parseJson(frame);
+      if (typeof parsed.route_channel !== "number" || typeof parsed.route_epoch !== "number") {
+        throw new SubcError(`route.open returned no route handle: ${JSON.stringify(parsed)}`);
+      }
+      installed = this.installRoute(parsed.route_channel, parsed.route_epoch);
+      return true;
+    };
+    const closeLateRoute = (frame) => {
+      if (frame.header.ty !== FrameType.Response)
+        return;
+      try {
+        const parsed = this.parseJson(frame);
+        if (typeof parsed.route_channel !== "number" || typeof parsed.route_epoch !== "number")
+          return;
+        const lateHandle = this.installRoute(parsed.route_channel, parsed.route_epoch);
+        this.failHandle(lateHandle, new SubcError("late route.open was closed", "route_closed"));
+        this.liveRoutes.delete(lateHandle.channel);
+        this.sendRouteGoodbye(lateHandle, true);
+      } catch {
+        this.closeConnectionAfterCleanupFailure();
+      }
+    };
+    await this.controlRpc(body, install, closeLateRoute);
+    if (!installed)
+      throw new SubcError("route.open response was not installed");
+    return installed;
   }
-  async request(routeChannel, body, opts = {}) {
+  async request(handle, body, opts = {}) {
+    this.assertLiveHandle(handle);
     const bytes = body instanceof Uint8Array ? body : this.encode(body);
     const priority = opts.priority ?? Priority.Interactive;
-    const reply = await this.send(routeChannel, bytes, priority, opts.timeoutMs, opts.onProgress);
+    const admission = opts.admissionClass ?? AdmissionClass.Normal;
+    const reply = await this.send(handle, bytes, priority, admission, opts.timeoutMs, opts.onProgress);
     return this.parseJson(reply);
   }
   async call(moduleId, method, params, opts = {}) {
     const body = params === undefined ? { method } : { method, params };
     let retriedUnknownChannel = false;
     for (;; ) {
-      const routeChannel = await this.cachedRouteChannel(moduleId, opts);
+      const routeHandle = await this.cachedRouteHandle(moduleId, opts);
       try {
-        return await this.managedRequest(routeChannel, body, opts);
+        return await this.managedRequest(routeHandle, body, opts);
       } catch (err) {
         if (!(err instanceof SubcCallError))
           throw this.terminalCallError("managed call failed", err);
         if (err.code === "unknown_channel" && !retriedUnknownChannel && !this.closeStarted) {
           retriedUnknownChannel = true;
-          this.evictRouteChannel(routeChannel);
+          this.evictRouteHandle(routeHandle);
           continue;
         }
+        if (err.code === "unknown_channel" && retriedUnknownChannel) {
+          this.evictRouteHandle(routeHandle);
+        }
         if (err.kind === "not_sent") {
           try {
             await this.reconnectAfterDrop(err);
@@ -12425,29 +12908,31 @@ class SubcClient {
       }
     }
   }
-  subscribe(routeChannel, body, onEvent, opts = {}) {
+  subscribe(handle, body, onEvent, opts = {}) {
+    this.assertLiveHandle(handle);
     const bytes = body instanceof Uint8Array ? body : this.encode(body);
     const priority = opts.priority ?? Priority.Interactive;
-    const corr = this.nextCorr++;
-    const key = `${routeChannel}:${corr}`;
+    const admission = opts.admissionClass ?? AdmissionClass.Normal;
+    const corr = this.allocateCorr();
+    const key = pendingKey(handle, corr);
     const closed = new Promise((resolve7, reject) => {
       if (this.closedErr) {
         reject(this.closedErr);
         return;
       }
       this.pending.set(key, {
-        channel: routeChannel,
+        handle,
         resolve: () => resolve7(),
         reject,
         onProgress: onEvent,
         timer: null,
         subscription: true
       });
-      const frame = buildFrame(FrameType.Request, buildFlags(false, priority, false), routeChannel, corr, bytes);
+      const frame = buildFrame(FrameType.Request, buildFlags(false, priority, false, admission), handle.channel, handle.epoch, corr, bytes);
       this.sock.write(encodeFrame(frame), Date.now() + DEFAULT_REQUEST_TIMEOUT_MS).catch((err) => {
-        const p = this.pending.get(key);
-        if (p)
-          this.rejectPending(key, p, err instanceof Error ? err : new SubcError(String(err)));
+        const pending = this.pending.get(key);
+        if (pending)
+          this.rejectPending(key, pending, err instanceof Error ? err : new SubcError(String(err)));
       });
     });
     let cancelled = false;
@@ -12455,45 +12940,77 @@ class SubcClient {
       if (cancelled)
         return;
       cancelled = true;
-      const cancel = buildFrame(FrameType.Cancel, buildFlags(false, priority, false), routeChannel, corr, EMPTY_BODY);
-      this.sock.write(encodeFrame(cancel), Date.now() + DEFAULT_REQUEST_TIMEOUT_MS).catch(() => {});
+      this.cancel(handle, corr, priority);
     };
     return { unsubscribe, closed };
   }
-  async closeRoute(target, identity, opts = {}) {
+  cancel(handle, corr, priority = Priority.Interactive) {
+    this.assertLiveHandle(handle);
+    const cancel = buildFrame(FrameType.Cancel, buildFlags(false, priority, false), handle.channel, handle.epoch, corr, EMPTY_BODY);
+    this.sock.write(encodeFrame(cancel), Date.now() + DEFAULT_REQUEST_TIMEOUT_MS).catch(() => {
+      return;
+    });
+  }
+  async routePoll(handle, kind) {
+    this.assertLiveHandle(handle);
+    const body = this.encode({
+      op: "route.poll",
+      route_channel: handle.channel,
+      route_epoch: handle.epoch,
+      kind
+    });
+    const reply = await this.controlRpc(body, (frame) => {
+      if (frame.header.ty !== FrameType.Response)
+        return true;
+      const parsed = this.parseJson(frame);
+      return parsed.route_channel === handle.channel && parsed.route_epoch === handle.epoch;
+    });
+    return this.parseJson(reply);
+  }
+  async closeRoute(handle, opts = {}) {
+    this.assertLiveHandle(handle);
+    for (const [key, cached] of this.routes) {
+      if (cached.handle && sameRouteHandle(cached.handle, handle)) {
+        cached.closed = true;
+        cached.handle = null;
+        this.routes.delete(key);
+      }
+    }
+    if (opts.drain)
+      await this.drainUnaryOnHandle(handle);
+    this.failHandle(handle, new SubcError("route closed by closeRoute", "route_closed"));
+    if (this.liveRoutes.get(handle.channel) === handle)
+      this.liveRoutes.delete(handle.channel);
+    this.sendRouteGoodbye(handle);
+  }
+  async closeManagedRoute(target, identity, opts = {}) {
     const key = routeCacheKey(target, identity, routeOpenConsumerIdentity(opts));
     const cached = this.routes.get(key);
     if (!cached)
       return;
     cached.closed = true;
     this.routes.delete(key);
-    const channel = cached.channel;
-    cached.channel = null;
-    if (channel !== null)
-      await this.closeRouteChannel(channel, opts);
+    const handle = cached.handle;
+    cached.handle = null;
+    if (handle)
+      await this.closeRoute(handle, opts);
   }
-  async closeRouteChannel(channel, opts = {}) {
-    if (channel === 0)
-      return;
-    if (opts.drain) {
-      await this.drainUnaryOnChannel(channel);
-    }
-    this.failChannel(channel, new SubcError("route closed by closeRoute", "route_closed"));
-    this.sendRouteGoodbye(channel);
+  async closeRouteChannel(handle, opts = {}) {
+    await this.closeRoute(handle, opts);
   }
   close() {
     this.closeStarted = true;
     this.fail(new SubcError("client closed"));
     this.sock.close();
   }
-  drainUnaryOnChannel(channel) {
+  drainUnaryOnHandle(handle) {
     const waiters = [];
     for (const pending of this.pending.values()) {
-      if (pending.channel === channel && !pending.subscription) {
+      if (pending.handle === handle && !pending.subscription) {
         waiters.push(new Promise((resolve7) => {
-          const prev = pending.onSettle;
+          const previous = pending.onSettle;
           pending.onSettle = () => {
-            prev?.();
+            previous?.();
             resolve7();
           };
         }));
@@ -12503,11 +13020,21 @@ class SubcClient {
       return;
     });
   }
-  sendRouteGoodbye(channel) {
-    if (this.closedErr)
+  sendRouteGoodbye(handle, closeOnQueueFailure = false) {
+    this.assertLiveConnection(handle);
+    if (this.closedErr) {
+      if (closeOnQueueFailure)
+        this.closeConnectionAfterCleanupFailure();
       return;
-    const goodbye = buildFrame(FrameType.Goodbye, buildFlags(false, Priority.Interactive, false), channel, 0n, EMPTY_BODY);
-    this.sock.write(encodeFrame(goodbye), Date.now() + DEFAULT_REQUEST_TIMEOUT_MS).catch(() => {});
+    }
+    const goodbye = buildFrame(FrameType.Goodbye, buildFlags(false, Priority.Interactive, false), handle.channel, handle.epoch, 0n, EMPTY_BODY);
+    const write = this.sock.writeTracked(encodeFrame(goodbye), Date.now() + DEFAULT_REQUEST_TIMEOUT_MS);
+    if (!write.queued && closeOnQueueFailure)
+      this.closeConnectionAfterCleanupFailure();
+    write.completed.catch(() => {
+      if (closeOnQueueFailure && !write.queued)
+        this.closeConnectionAfterCleanupFailure();
+    });
   }
   static async openConnection(opts) {
     const conn = await readConnectionFile(opts.connectionFile);
@@ -12522,37 +13049,48 @@ class SubcClient {
     }
     return { sock, conn };
   }
-  async controlRpc(body) {
-    return this.send(0, body, Priority.Interactive, undefined, undefined);
+  async controlRpc(body, acceptFrame, onLateResponse) {
+    return this.send(null, body, Priority.Interactive, AdmissionClass.Normal, undefined, undefined, acceptFrame, onLateResponse);
   }
-  send(channel, body, priority, timeoutMs, onProgress) {
+  send(handle, body, priority, admission, timeoutMs, onProgress, acceptFrame, onLateResponse) {
+    if (handle)
+      this.assertLiveHandle(handle);
     if (this.closedErr)
       return Promise.reject(this.closedErr);
-    const corr = this.nextCorr++;
-    const key = `${channel}:${corr}`;
-    const frame = buildFrame(FrameType.Request, buildFlags(false, priority, false), channel, corr, body);
+    let corr;
+    try {
+      corr = this.allocateCorr();
+    } catch (error2) {
+      return Promise.reject(error2);
+    }
+    const key = pendingKey(handle, corr);
+    const channel = handle?.channel ?? 0;
+    const epoch = handle?.epoch ?? 0;
+    const frame = buildFrame(FrameType.Request, buildFlags(false, priority, false, admission), channel, epoch, corr, body);
     return new Promise((resolve7, reject) => {
       const ms = timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
       const pending = {
-        channel,
+        handle,
         resolve: resolve7,
         reject,
         onProgress,
-        timer: null
+        timer: null,
+        acceptFrame,
+        onLateResponse
       };
-      pending.timer = setTimeout(() => {
-        this.arbitrateTimeout(key, pending, channel, corr, ms);
-      }, ms);
+      pending.timer = setTimeout(() => this.arbitrateTimeout(key, pending, channel, corr, ms), ms);
       this.pending.set(key, pending);
-      this.sock.write(encodeFrame(frame), Date.now() + ms).catch((err) => {
-        const p = this.pending.get(key);
-        if (p)
-          this.rejectPending(key, p, err instanceof Error ? err : new SubcError(String(err)));
+      this.sock.write(encodeFrame(frame), Date.now() + ms).catch((error2) => {
+        const current = this.pending.get(key);
+        if (current)
+          this.rejectPending(key, current, error2 instanceof Error ? error2 : new SubcError(String(error2)));
       });
     });
   }
   arbitrateTimeout(key, pending, channel, corr, ms) {
     const settleAsTimeout = () => {
+      if (pending.onLateResponse)
+        this.lateResponses.set(key, pending.onLateResponse);
       this.rejectPending(key, pending, new SubcError(this.timeoutMessage(channel, corr, ms), REQUEST_DEADLINE_MARKER));
     };
     const graceDeadline = Date.now() + this.opts.timeoutArbitrationGraceMs;
@@ -12568,59 +13106,67 @@ class SubcClient {
     };
     setImmediate(arbitrate);
   }
-  async managedRequest(routeChannel, body, opts) {
+  async managedRequest(handle, body, opts) {
     const bytes = body instanceof Uint8Array ? body : this.encode(body);
     const priority = opts.priority ?? Priority.Interactive;
+    const admission = opts.admissionClass ?? AdmissionClass.Normal;
     try {
-      const reply = await this.sendManaged(routeChannel, bytes, priority, opts.timeoutMs, opts.onProgress);
+      const reply = await this.sendManaged(handle, bytes, priority, admission, opts.timeoutMs, opts.onProgress);
       return this.parseJson(reply);
-    } catch (err) {
-      if (err instanceof SubcCallError)
-        throw err;
-      throw this.terminalCallError("managed call failed", err);
+    } catch (error2) {
+      if (error2 instanceof SubcCallError)
+        throw error2;
+      throw this.terminalCallError("managed call failed", error2);
     }
   }
-  sendManaged(channel, body, priority, timeoutMs, onProgress) {
+  sendManaged(handle, body, priority, admission, timeoutMs, onProgress) {
+    try {
+      this.assertLiveHandle(handle);
+    } catch (error2) {
+      return Promise.reject(this.notSentCallError("request used a stale route handle", error2));
+    }
     if (this.closedErr) {
       return Promise.reject(this.notSentCallError("request was not sent because the subc connection was already closed", this.closedErr));
     }
-    const corr = this.nextCorr++;
-    const key = `${channel}:${corr}`;
-    const frame = buildFrame(FrameType.Request, buildFlags(false, priority, false), channel, corr, body);
+    let corr;
+    try {
+      corr = this.allocateCorr();
+    } catch (error2) {
+      return Promise.reject(this.notSentCallError("request correlation allocator was exhausted", error2));
+    }
+    const key = pendingKey(handle, corr);
+    const frame = buildFrame(FrameType.Request, buildFlags(false, priority, false, admission), handle.channel, handle.epoch, corr, body);
     let handedToSocket = false;
-    const classifyFailure = (err) => {
-      if (!handedToSocket) {
-        return this.notSentCallError("request bytes were not queued to the subc socket", err);
-      }
-      if (err instanceof SubcError && err.code === REQUEST_DEADLINE_MARKER) {
-        return new SubcCallError("outcome_unknown", `managed call deadline exceeded after request bytes were queued to the local socket; no terminal response was observed; outcome unknown${causeMessage(err)}`, DEADLINE_NO_DROP_CODE, err);
+    const classifyFailure = (error2) => {
+      if (!handedToSocket)
+        return this.notSentCallError("request bytes were not queued to the subc socket", error2);
+      if (error2 instanceof SubcError && error2.code === REQUEST_DEADLINE_MARKER) {
+        return new SubcCallError("outcome_unknown", `managed call deadline exceeded after request bytes were queued to the local socket; no terminal response was observed; outcome unknown${causeMessage(error2)}`, DEADLINE_NO_DROP_CODE, error2);
       }
-      return this.outcomeUnknownCallError("connection dropped before the managed call returned a response", err);
+      return this.outcomeUnknownCallError("connection dropped before the managed call returned a response", error2);
     };
     return new Promise((resolve7, reject) => {
       const ms = timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
       const pending = {
-        channel,
+        handle,
         resolve: resolve7,
         reject,
         onProgress,
         timer: null,
         classifyFailure
       };
-      pending.timer = setTimeout(() => {
-        this.arbitrateTimeout(key, pending, channel, corr, ms);
-      }, ms);
+      pending.timer = setTimeout(() => this.arbitrateTimeout(key, pending, handle.channel, corr, ms), ms);
       this.pending.set(key, pending);
       const write = this.sock.writeTracked(encodeFrame(frame), Date.now() + ms);
       handedToSocket = write.queued;
-      write.completed.catch((err) => {
-        const p = this.pending.get(key);
-        if (p)
-          this.rejectPending(key, p, err instanceof Error ? err : new SubcError(String(err)));
+      write.completed.catch((error2) => {
+        const current = this.pending.get(key);
+        if (current)
+          this.rejectPending(key, current, error2 instanceof Error ? error2 : new SubcError(String(error2)));
       });
     });
   }
-  async cachedRouteChannel(moduleId, opts) {
+  async cachedRouteHandle(moduleId, opts) {
     const identity = opts.identity ?? this.opts.identity;
     if (!identity) {
       throw new SubcCallError("terminal", "managed call requires a BindIdentity in SubcClient.connect({ identity }) or call(..., { identity })", "missing_identity");
@@ -12636,15 +13182,13 @@ class SubcClient {
         target,
         identity,
         consumerIdentity,
-        channel: null,
-        generation: 0,
+        handle: null,
         opening: null
       };
       this.routes.set(key, cached);
     }
-    if (cached.channel !== null && cached.generation === this.generation && !this.closedErr) {
-      return cached.channel;
-    }
+    if (cached.handle && this.isLiveHandle(cached.handle))
+      return cached.handle;
     if (!cached.opening) {
       cached.opening = this.openCachedRoute(cached).finally(() => {
         cached.opening = null;
@@ -12661,44 +13205,43 @@ class SubcClient {
         throw this.routeClosedDuringOpen();
       try {
         await this.ensureConnectedForManaged();
-      } catch (err) {
-        throw this.notSentRecoveryError("route.open could not run because reconnect failed", err);
-      }
-      if (cached.channel !== null && cached.generation === this.generation && !this.closedErr) {
-        return cached.channel;
+      } catch (error2) {
+        throw this.notSentRecoveryError("route.open could not run because reconnect failed", error2);
       }
+      if (cached.handle && this.isLiveHandle(cached.handle))
+        return cached.handle;
       try {
-        const channel = await this.routeOpen(cached.target, cached.identity, {
+        const handle = await this.routeOpen(cached.target, cached.identity, {
           consumerIdentity: cached.consumerIdentity ?? null
         });
         if (cached.closed) {
-          this.sendRouteGoodbye(channel);
+          this.liveRoutes.delete(handle.channel);
+          this.sendRouteGoodbye(handle);
           throw this.routeClosedDuringOpen();
         }
-        cached.channel = channel;
-        cached.generation = this.generation;
-        return channel;
-      } catch (err) {
-        if (err instanceof SubcCallError && err.code === "route_closed")
-          throw err;
-        if (!this.closeStarted && isConsumerReconnectTransient(err)) {
+        cached.handle = handle;
+        return handle;
+      } catch (error2) {
+        if (error2 instanceof SubcCallError && error2.code === "route_closed")
+          throw error2;
+        if (!this.closeStarted && isConsumerReconnectTransient(error2)) {
           try {
-            await this.reconnectAfterDrop(err);
-          } catch (reconnectErr) {
-            throw this.notSentRecoveryError("route.open was not sent and reconnect failed", reconnectErr);
+            await this.reconnectAfterDrop(error2);
+          } catch (reconnectError) {
+            throw this.notSentRecoveryError("route.open was not sent and reconnect failed", reconnectError);
           }
           continue;
         }
-        if (!this.closeStarted && err instanceof SubcError && isRetryableRouteOpenCode(err.code)) {
+        if (!this.closeStarted && error2 instanceof SubcError && isRetryableRouteOpenCode(error2.code)) {
           routeRetryAttempt += 1;
           if (routeRetryAttempt < this.opts.reconnectBackoff.maxAttempts && Date.now() < routeRetryDeadline) {
             await this.opts.sleep(routeRetryDelay);
             routeRetryDelay = Math.min(routeRetryDelay * 2, this.opts.reconnectBackoff.capMs);
             continue;
           }
-          throw this.notSentCallError(`route.open failed for module ${cached.moduleId}: ${err.code} (retry budget exhausted)`, err);
+          throw this.notSentCallError(`route.open failed for module ${cached.moduleId}: ${error2.code} (retry budget exhausted)`, error2);
         }
-        throw this.terminalCallError(`route.open failed for module ${cached.moduleId}`, err);
+        throw this.terminalCallError(`route.open failed for module ${cached.moduleId}`, error2);
       }
     }
   }
@@ -12761,25 +13304,27 @@ class SubcClient {
     this.currentConn = opened.conn;
     this.closedErr = null;
     this.generation += 1;
+    this.connectionToken = newConnectionToken();
+    this.liveRoutes.clear();
+    this.lateResponses.clear();
+    this.nextCorr = 1n;
     this.readLoop(opened.sock, this.generation);
   }
   async reopenCachedRoutes() {
-    for (const cached of this.routes.values()) {
-      cached.channel = null;
-      cached.generation = 0;
-    }
+    for (const cached of this.routes.values())
+      cached.handle = null;
     for (const cached of this.routes.values()) {
       if (cached.closed)
         continue;
-      const channel = await this.routeOpen(cached.target, cached.identity, {
+      const handle = await this.routeOpen(cached.target, cached.identity, {
         consumerIdentity: cached.consumerIdentity ?? null
       });
       if (cached.closed) {
-        this.sendRouteGoodbye(channel);
+        this.liveRoutes.delete(handle.channel);
+        this.sendRouteGoodbye(handle);
         continue;
       }
-      cached.channel = channel;
-      cached.generation = this.generation;
+      cached.handle = handle;
     }
   }
   timeoutMessage(channel, corr, ms) {
@@ -12793,28 +13338,37 @@ class SubcClient {
   async readLoop(sock, generation) {
     try {
       for (;; ) {
-        const headerBytes = await sock.readExact(HEADER_LEN, Number.POSITIVE_INFINITY);
-        this.readerActive = true;
+        this.readerActive = false;
+        const frame = await sock.readFrame(Number.POSITIVE_INFINITY, { afterHeaderMs: BODY_READ_TIMEOUT_MS }, () => {
+          this.readerActive = true;
+        });
         try {
-          const header = decodeHeader(headerBytes);
-          const body = header.len === 0 ? new Uint8Array(0) : await sock.readExact(header.len, Date.now() + BODY_READ_TIMEOUT_MS);
-          if (this.sock === sock && this.generation === generation) {
-            this.dispatch({ header, body });
-          }
+          if (this.sock === sock && this.generation === generation)
+            this.dispatch(frame);
         } finally {
           this.readerActive = false;
         }
       }
-    } catch (err) {
+    } catch (error2) {
       if (this.sock === sock && this.generation === generation) {
-        this.fail(err instanceof Error ? err : new SubcError(String(err)));
+        this.fail(error2 instanceof Error ? error2 : new SubcError(String(error2)));
       }
     }
   }
   dispatch(frame) {
-    const key = `${frame.header.channel}:${frame.header.corr}`;
+    let handle = null;
+    if (frame.header.channel !== 0) {
+      handle = this.liveRoutes.get(frame.header.channel) ?? null;
+      if (!handle || handle.epoch !== frame.header.epoch) {
+        this.ingressEpochDropCount += 1;
+        return;
+      }
+    }
+    const key = pendingKey(handle, frame.header.corr);
     const pending = this.pending.get(key);
     if (pending) {
+      if (pending.acceptFrame && !pending.acceptFrame(frame))
+        return;
       switch (frame.header.ty) {
         case FrameType.Push:
         case FrameType.StreamData:
@@ -12831,15 +13385,22 @@ class SubcClient {
           return;
       }
     }
-    if (frame.header.ty === FrameType.Goodbye) {
-      this.failChannel(frame.header.channel, new SubcError("route closed by subc (GOODBYE)"));
-      this.evictRouteChannel(frame.header.channel);
+    const late = this.lateResponses.get(key);
+    if (late && (frame.header.ty === FrameType.Response || frame.header.ty === FrameType.Error)) {
+      this.lateResponses.delete(key);
+      late(frame);
       return;
     }
-    if (frame.header.ty === FrameType.Response || frame.header.ty === FrameType.Error || frame.header.ty === FrameType.StreamEnd) {
-      debug("dropped terminal frame with no waiter: type=%d channel=%d corr=%s port=%s", frame.header.ty, frame.header.channel, frame.header.corr, this.sock.localPort() ?? "?");
+    if (frame.header.ty === FrameType.Goodbye && handle) {
+      this.failHandle(handle, new SubcError("route closed by subc (GOODBYE)"));
+      if (this.liveRoutes.get(handle.channel) === handle)
+        this.liveRoutes.delete(handle.channel);
+      this.evictRouteHandle(handle);
       return;
     }
+    if (frame.header.ty === FrameType.Response || frame.header.ty === FrameType.Error || frame.header.ty === FrameType.StreamEnd) {
+      debug("dropped terminal frame with no waiter: type=%d channel=%d epoch=%d corr=%s port=%s", frame.header.ty, frame.header.channel, frame.header.epoch, frame.header.corr, this.sock.localPort() ?? "?");
+    }
   }
   settle(key, pending, run) {
     if (this.pending.get(key) !== pending)
@@ -12862,18 +13423,16 @@ class SubcClient {
       return new SubcError(Buffer.from(frame.body).toString("utf8") || "subc error");
     }
   }
-  evictRouteChannel(channel) {
+  evictRouteHandle(handle) {
     for (const cached of this.routes.values()) {
-      if (cached.channel === channel && cached.generation === this.generation) {
-        cached.channel = null;
-      }
+      if (cached.handle && sameRouteHandle(cached.handle, handle))
+        cached.handle = null;
     }
   }
-  failChannel(channel, err) {
+  failHandle(handle, error2) {
     for (const [key, pending] of this.pending) {
-      if (pending.channel === channel) {
-        this.rejectPending(key, pending, err);
-      }
+      if (pending.handle && sameRouteHandle(pending.handle, handle))
+        this.rejectPending(key, pending, error2);
     }
   }
   fail(err) {
@@ -12901,6 +13460,44 @@ class SubcClient {
       return this.notSentCallError(message, cause);
     return this.terminalCallError(message, cause);
   }
+  get droppedIngressFrames() {
+    return this.ingressEpochDropCount;
+  }
+  installRoute(channel, epoch) {
+    const handle = createRouteHandle(channel, epoch, this.connectionToken);
+    this.liveRoutes.set(channel, handle);
+    return handle;
+  }
+  isLiveHandle(handle) {
+    return belongsToConnection(handle, this.connectionToken) && this.liveRoutes.get(handle.channel) === handle;
+  }
+  assertLiveConnection(handle) {
+    if (!belongsToConnection(handle, this.connectionToken))
+      throw new StaleRouteHandleError(handle);
+  }
+  assertLiveHandle(handle) {
+    if (!this.isLiveHandle(handle))
+      throw new StaleRouteHandleError(handle);
+  }
+  allocateCorr() {
+    const maximum = 0xffffffffffffffffn;
+    if (this.nextCorr > maximum) {
+      const error2 = new SubcError("channel-0 correlation id allocator exhausted", "corr_exhausted");
+      this.fail(error2);
+      this.sock.close();
+      this.scheduleReconnectAfterDrop(error2);
+      throw error2;
+    }
+    const corr = this.nextCorr;
+    this.nextCorr += 1n;
+    return corr;
+  }
+  closeConnectionAfterCleanupFailure() {
+    const error2 = new SubcError("late route cleanup could not be queued", "late_route_cleanup_failed");
+    this.fail(error2);
+    this.sock.close();
+    this.scheduleReconnectAfterDrop(error2);
+  }
   encode(value) {
     return new Uint8Array(Buffer.from(JSON.stringify(value), "utf8"));
   }
@@ -12970,7 +13567,10 @@ function causeMessage(cause) {
     return "";
   return `: ${cause instanceof Error ? cause.message : String(cause)}`;
 }
-// ../../node_modules/.bun/@cortexkit+subc-client@0.3.4/node_modules/@cortexkit/subc-client/dist/provider.js
+function pendingKey(handle, corr) {
+  return handle ? `${handle.channel}:${handle.epoch}:${corr}` : `0:0:${corr}`;
+}
+// ../../node_modules/.bun/@cortexkit+subc-client@0.5.0/node_modules/@cortexkit/subc-client/dist/provider.js
 import { Buffer as Buffer2 } from "node:buffer";
 var DEFAULT_HANDSHAKE_TIMEOUT_MS2 = 1e4;
 var BODY_READ_TIMEOUT_MS2 = 30000;
@@ -13033,6 +13633,11 @@ class SubcProvider {
   closeStarted = false;
   closedErr = null;
   inflight = new Map;
+  pending = new Map;
+  liveRoutes = new Map;
+  connectionToken = newConnectionToken();
+  nextCorr = 1n;
+  ingressEpochDropCount = 0;
   requestGate = new AsyncPermitPool(DEFAULT_PROVIDER_HANDLER_CAPACITY);
   reconnecting = null;
   generation = 1;
@@ -13052,12 +13657,55 @@ class SubcProvider {
     this.readLoop(sock, this.generation);
     this.enqueueConnectionState({ state: "connected", epoch: this.connectionEpoch });
   }
+  get droppedIngressFrames() {
+    return this.ingressEpochDropCount;
+  }
   get conn() {
     return this.currentConn;
   }
   currentEpoch() {
     return this.connectionEpoch;
   }
+  async request(handle, body, opts = {}) {
+    this.assertLiveHandle(handle);
+    const corr = this.allocateCorr();
+    const key = routeKey(handle, corr);
+    const timeoutMs = opts.timeoutMs ?? WRITE_TIMEOUT_MS;
+    const frame = buildFrame(FrameType.Request, buildFlags(false, opts.priority ?? Priority.Interactive, false, opts.admissionClass ?? AdmissionClass.Normal), handle.channel, handle.epoch, corr, body);
+    return await new Promise((resolve7, reject) => {
+      const timer = setTimeout(() => {
+        if (this.pending.delete(key))
+          reject(new SubcProviderError("reverse request timed out", "request_timeout"));
+      }, timeoutMs);
+      this.pending.set(key, {
+        resolve: (response) => resolve7(response.body),
+        reject,
+        timer
+      });
+      this.sendOn(this.sock, this.generation, frame).catch((error2) => {
+        const pending = this.pending.get(key);
+        if (!pending)
+          return;
+        this.pending.delete(key);
+        clearTimeout(pending.timer);
+        reject(error2 instanceof Error ? error2 : new SubcProviderError(String(error2)));
+      });
+    });
+  }
+  async push(handle, body, opts = {}) {
+    this.assertLiveHandle(handle);
+    await this.sendOn(this.sock, this.generation, buildFrame(FrameType.Push, buildFlags(false, opts.priority ?? Priority.Interactive, false, opts.admissionClass ?? AdmissionClass.Normal), handle.channel, handle.epoch, 0n, body));
+  }
+  cancel(handle, corr) {
+    this.assertLiveHandle(handle);
+    this.sendOn(this.sock, this.generation, buildFrame(FrameType.Cancel, controlFlags(), handle.channel, handle.epoch, corr, new Uint8Array(0)));
+  }
+  closeRoute(handle) {
+    this.assertLiveHandle(handle);
+    this.liveRoutes.delete(handle.channel);
+    this.abortHandle(handle);
+    this.sendOn(this.sock, this.generation, buildFrame(FrameType.Goodbye, controlFlags(), handle.channel, handle.epoch, 0n, new Uint8Array(0)));
+  }
   static async connect(opts) {
     if (opts.manifest.protocol_ver !== PROTOCOL_VERSION) {
       throw new SubcProviderError(`manifest protocol_ver ${opts.manifest.protocol_ver} does not match client protocol ${PROTOCOL_VERSION}`, "invalid_manifest");
@@ -13072,7 +13720,7 @@ class SubcProvider {
       this.cancelRestoredDebounce();
       const sock = this.sock;
       try {
-        await sendFrame(sock, buildFrame(FrameType.Goodbye, controlFlags(), 0, 0n, new Uint8Array(0)));
+        await sendFrame(sock, buildFrame(FrameType.Goodbye, controlFlags(), 0, 0, 0n, new Uint8Array(0)));
       } catch {} finally {
         sock.close();
         this.finishClosed();
@@ -13080,12 +13728,13 @@ class SubcProvider {
     }
     await this.closed;
   }
-  static async openConnection(opts) {
+  static async openConnection(opts, onSocket) {
     const conn = await readConnectionFile(opts.connectionFile);
     const deadline = Date.now() + (opts.handshakeTimeoutMs ?? DEFAULT_HANDSHAKE_TIMEOUT_MS2);
     const endpoint = conn.endpoints[0];
     const sock = await SubcSocket.connect(endpoint.host, endpoint.port, deadline);
     try {
+      onSocket?.(sock);
       await authenticateClient(sock, conn, deadline);
       await sendFrame(sock, buildHelloFrame(opts));
       const ack = await expectHelloAck(sock, deadline);
@@ -13098,19 +13747,17 @@ class SubcProvider {
   async readLoop(sock, generation) {
     try {
       for (;; ) {
-        const headerBytes = await sock.readExact(HEADER_LEN, Number.POSITIVE_INFINITY);
-        const header = decodeHeader(headerBytes);
-        const body = header.len === 0 ? new Uint8Array(0) : await sock.readExact(header.len, Date.now() + BODY_READ_TIMEOUT_MS2);
-        const keepGoing = await this.dispatch({ header, body }, sock, generation);
+        const frame = await sock.readFrame(Number.POSITIVE_INFINITY, { afterHeaderMs: BODY_READ_TIMEOUT_MS2 });
+        const keepGoing = await this.dispatch(frame, sock, generation);
         if (!keepGoing) {
           if (this.sock === sock && this.generation === generation)
             this.closeStarted = true;
           break;
         }
       }
-    } catch (err) {
+    } catch (error2) {
       if (this.sock === sock && this.generation === generation && !this.closeStarted) {
-        this.handleUnexpectedDrop(sock, generation, err instanceof Error ? err : new SubcProviderError(String(err)));
+        this.handleUnexpectedDrop(sock, generation, error2 instanceof Error ? error2 : new SubcProviderError(String(error2)));
         return;
       }
     } finally {
@@ -13122,28 +13769,58 @@ class SubcProvider {
     }
   }
   async dispatch(frame, sock, generation) {
+    let handle = null;
+    if (frame.header.channel !== 0) {
+      handle = this.liveRoutes.get(frame.header.channel) ?? null;
+      if (!handle || handle.epoch !== frame.header.epoch) {
+        this.ingressEpochDropCount += 1;
+        return true;
+      }
+    }
+    if (handle) {
+      const pendingKey2 = routeKey(handle, frame.header.corr);
+      const pending = this.pending.get(pendingKey2);
+      if (pending) {
+        if (frame.header.ty === FrameType.Push || frame.header.ty === FrameType.StreamData)
+          return true;
+        if (frame.header.ty === FrameType.Response || frame.header.ty === FrameType.StreamEnd) {
+          this.pending.delete(pendingKey2);
+          clearTimeout(pending.timer);
+          pending.resolve(frame);
+          return true;
+        }
+        if (frame.header.ty === FrameType.Error) {
+          this.pending.delete(pendingKey2);
+          clearTimeout(pending.timer);
+          pending.reject(providerErrorFromFrame(frame));
+          return true;
+        }
+      }
+    }
     switch (frame.header.ty) {
       case FrameType.Ping:
         if (frame.header.channel === 0) {
-          await this.sendOn(sock, generation, buildFrameWithVersion(frame.header.ver, FrameType.Pong, frame.header.flags, 0, frame.header.corr, new Uint8Array(0)));
+          await this.sendOn(sock, generation, buildFrameWithVersion(frame.header.ver, FrameType.Pong, frame.header.flags, 0, 0, frame.header.corr, new Uint8Array(0)));
         }
         return true;
       case FrameType.Goodbye:
-        if (frame.header.channel === 0)
+        if (!handle)
           return false;
-        this.abortChannel(generation, frame.header.channel);
-        await this.opts.onRouteGone?.(frame.header.channel);
+        this.liveRoutes.delete(handle.channel);
+        this.abortHandle(handle);
+        await this.opts.onRouteGone?.(handle);
         return true;
       case FrameType.Cancel:
-        this.inflight.get(routeKey(generation, frame.header.channel, frame.header.corr))?.abort();
+        if (handle)
+          this.inflight.get(routeKey(handle, frame.header.corr))?.abort();
         return true;
       case FrameType.Request:
         if (frame.header.channel === 0) {
           await this.handleControlRequest(frame, sock, generation);
-        } else {
-          this.handleDataRequest(frame, sock, generation).catch((err) => {
+        } else if (handle) {
+          this.handleDataRequest(frame, handle, sock, generation).catch((error2) => {
             if (!this.closeStarted && this.sock === sock && this.generation === generation) {
-              console.warn("SubcProvider handler failed after its request was dispatched", err);
+              console.warn("SubcProvider handler failed after its request was dispatched", error2);
             }
           });
         }
@@ -13152,19 +13829,28 @@ class SubcProvider {
         return true;
     }
   }
-  abortChannel(generation, channel) {
-    const prefix = `${generation}:${channel}:`;
+  abortHandle(handle) {
+    const prefix = `${handle.channel}:${handle.epoch}:`;
     for (const [key, controller] of this.inflight) {
       if (key.startsWith(prefix))
         controller.abort();
     }
+    for (const [key, pending] of this.pending) {
+      if (!key.startsWith(prefix))
+        continue;
+      this.pending.delete(key);
+      clearTimeout(pending.timer);
+      pending.reject(new StaleRouteHandleError(handle));
+    }
   }
-  abortGeneration(generation) {
-    const prefix = `${generation}:`;
-    for (const [key, controller] of this.inflight) {
-      if (key.startsWith(prefix))
-        controller.abort();
+  abortGeneration(_generation) {
+    this.abortAllInflight();
+    for (const [key, pending] of this.pending) {
+      this.pending.delete(key);
+      clearTimeout(pending.timer);
+      pending.reject(new SubcProviderError("provider connection dropped", "connection_dropped"));
     }
+    this.liveRoutes.clear();
   }
   abortAllInflight() {
     for (const controller of this.inflight.values())
@@ -13173,9 +13859,9 @@ class SubcProvider {
   async handleControlRequest(frame, sock, generation) {
     const request = parseJson(frame.body);
     if (request.op === HEALTH_CHECK_OP) {
-      this.handleHealthRequest(frame, sock, generation).catch((err) => {
+      this.handleHealthRequest(frame, sock, generation).catch((error2) => {
         if (!this.closeStarted && this.sock === sock && this.generation === generation) {
-          console.warn("SubcProvider health handler failed after its request was dispatched", err);
+          console.warn("SubcProvider health handler failed after its request was dispatched", error2);
         }
       });
       return;
@@ -13183,47 +13869,93 @@ class SubcProvider {
     if (request.op !== "route.bind") {
       throw new SubcProviderError(`unsupported module control request ${request.op ?? "<missing op>"}`);
     }
+    const boundChannel = numberField(request.route_channel, "route_channel");
+    const boundEpoch = numberField(request.epoch, "epoch");
+    const stale = this.liveRoutes.get(boundChannel);
+    if (stale) {
+      if (boundEpoch <= stale.epoch) {
+        await this.sendError(frame, "route_rejected", `route.bind epoch ${boundEpoch} does not supersede installed epoch ${stale.epoch} on channel ${boundChannel}`, controlFlags(), sock, generation);
+        return;
+      }
+      this.liveRoutes.delete(stale.channel);
+      this.abortHandle(stale);
+      await this.opts.onRouteGone?.(stale);
+    }
+    const tentative = createRouteHandle(boundChannel, boundEpoch, this.connectionToken);
     const bindRequest = {
-      route_channel: numberField(request.route_channel, "route_channel"),
+      handle: tentative,
       target: request.target,
       identity: request.identity,
-      principal: request.principal
+      principal: request.principal,
+      consumer_capabilities: request.consumer_capabilities
     };
-    const decision = await this.opts.onBind?.(bindRequest);
+    let decision;
+    try {
+      decision = await this.opts.onBind?.(bindRequest);
+    } catch (error2) {
+      try {
+        await this.sendError(frame, "route_rejected", error2 instanceof Error ? error2.message : String(error2), controlFlags(), sock, generation);
+      } finally {
+        await this.opts.onRouteGone?.(tentative);
+      }
+      return;
+    }
     const rejection = bindRejection(decision);
     if (rejection) {
-      await this.sendError(frame, rejection.code, rejection.message, controlFlags(), sock, generation);
+      try {
+        await this.sendError(frame, rejection.code, rejection.message, controlFlags(), sock, generation);
+      } finally {
+        await this.opts.onRouteGone?.(tentative);
+      }
+      return;
+    }
+    try {
+      await this.sendOn(sock, generation, buildFrameWithVersion(frame.header.ver, FrameType.Response, controlFlags(), 0, 0, frame.header.corr, encodeJson({ op: "route.bind" })));
+    } catch (error2) {
+      await this.opts.onRouteGone?.(tentative);
+      throw error2;
+    }
+    if (this.sock !== sock || this.generation !== generation || this.closeStarted || this.closedErr) {
+      await this.opts.onRouteGone?.(tentative);
       return;
     }
-    await this.sendOn(sock, generation, buildFrameWithVersion(frame.header.ver, FrameType.Response, controlFlags(), 0, frame.header.corr, encodeJson({ op: "route.bind" })));
+    this.liveRoutes.set(tentative.channel, tentative);
+    await this.opts.onBound?.(tentative);
   }
-  async handleDataRequest(frame, sock, generation) {
-    const { channel, corr, ver } = frame.header;
-    const key = routeKey(generation, channel, corr);
+  async handleDataRequest(frame, handle, sock, generation) {
+    const { corr, ver } = frame.header;
+    const key = routeKey(handle, corr);
     const controller = new AbortController;
     this.inflight.set(key, controller);
-    const dataFlags = buildFlags(false, Priority.Interactive, false);
-    const ctx = {
+    const context = {
+      handle,
       signal: controller.signal,
       currentEpoch: () => this.connectionEpoch,
-      emit: async (eventBody) => {
+      emit: async (eventBody, options = {}) => {
+        this.assertLiveHandle(handle);
         if (controller.signal.aborted)
           return;
-        await this.sendOn(sock, generation, buildFrameWithVersion(ver, FrameType.StreamData, dataFlags, channel, corr, eventBody));
+        await this.sendOn(sock, generation, buildFrameWithVersion(ver, FrameType.StreamData, buildFlags(false, options.priority ?? Priority.Interactive, false, options.admissionClass ?? AdmissionClass.Normal), handle.channel, handle.epoch, corr, eventBody));
       }
     };
     const releasePermit = await (this.requestGate ?? new AsyncPermitPool(DEFAULT_PROVIDER_HANDLER_CAPACITY)).acquire();
+    const dataFlags = buildFlags(false, Priority.Interactive, false);
     try {
-      const body = await this.opts.handler(channel, frame.body, ctx);
+      const body = await this.opts.handler(handle, frame.body, context);
+      if (controller.signal.aborted)
+        return;
+      this.assertLiveHandle(handle);
       if (body === undefined) {
-        await this.sendOn(sock, generation, buildFrameWithVersion(ver, FrameType.StreamEnd, dataFlags, channel, corr, new Uint8Array(0)));
+        await this.sendOn(sock, generation, buildFrameWithVersion(ver, FrameType.StreamEnd, dataFlags, handle.channel, handle.epoch, corr, new Uint8Array(0)));
       } else if (body instanceof Uint8Array) {
-        await this.sendOn(sock, generation, buildFrameWithVersion(ver, FrameType.Response, dataFlags, channel, corr, body));
+        await this.sendOn(sock, generation, buildFrameWithVersion(ver, FrameType.Response, dataFlags, handle.channel, handle.epoch, corr, body));
       } else {
         throw new SubcProviderError("provider handler must return a Uint8Array or void", "invalid_handler_response");
       }
-    } catch (err) {
-      await this.sendError(frame, err instanceof SubcProviderError && err.code ? err.code : "handler_error", err instanceof Error ? err.message : String(err), dataFlags, sock, generation);
+    } catch (error2) {
+      if (error2 instanceof StaleRouteHandleError || controller.signal.aborted)
+        return;
+      await this.sendError(frame, error2 instanceof SubcProviderError && error2.code ? error2.code : "handler_error", error2 instanceof Error ? error2.message : String(error2), dataFlags, sock, generation);
     } finally {
       releasePermit();
       if (this.inflight.get(key) === controller)
@@ -13231,8 +13963,8 @@ class SubcProvider {
     }
   }
   async handleHealthRequest(frame, sock, generation) {
-    const { channel, corr, ver } = frame.header;
-    const key = routeKey(generation, channel, corr);
+    const { corr, ver } = frame.header;
+    const key = `control:${generation}:${corr}`;
     const controller = new AbortController;
     this.inflight.set(key, controller);
     const releasePermit = await (this.requestGate ?? new AsyncPermitPool(DEFAULT_PROVIDER_HANDLER_CAPACITY)).acquire();
@@ -13240,14 +13972,14 @@ class SubcProvider {
       if (controller.signal.aborted)
         return;
       const report = await this.opts.health();
-      await this.sendOn(sock, generation, buildFrameWithVersion(ver, FrameType.Response, controlFlags(), channel, corr, encodeJson({
+      await this.sendOn(sock, generation, buildFrameWithVersion(ver, FrameType.Response, controlFlags(), 0, 0, corr, encodeJson({
         op: HEALTH_CHECK_OP,
         status: report.status,
         ...report.detail === undefined ? {} : { detail: report.detail },
         ...report.metrics === undefined ? {} : { metrics: report.metrics }
       })));
-    } catch (err) {
-      await this.sendError(frame, err instanceof SubcProviderError && err.code ? err.code : "health_error", err instanceof Error ? err.message : String(err), controlFlags(), sock, generation);
+    } catch (error2) {
+      await this.sendError(frame, error2 instanceof SubcProviderError && error2.code ? error2.code : "health_error", error2 instanceof Error ? error2.message : String(error2), controlFlags(), sock, generation);
     } finally {
       releasePermit();
       if (this.inflight.get(key) === controller)
@@ -13255,7 +13987,7 @@ class SubcProvider {
     }
   }
   async sendError(frame, code, message, flags, sock, generation) {
-    await this.sendOn(sock, generation, buildFrameWithVersion(frame.header.ver, FrameType.Error, flags, frame.header.channel, frame.header.corr, encodeJson({ code, message })));
+    await this.sendOn(sock, generation, buildFrameWithVersion(frame.header.ver, FrameType.Error, flags, frame.header.channel, frame.header.epoch, frame.header.corr, encodeJson({ code, message })));
   }
   async sendOn(sock, generation, frame) {
     if (this.sock !== sock || this.generation !== generation || this.closeStarted || this.closedErr)
@@ -13263,42 +13995,79 @@ class SubcProvider {
     await sendFrame(sock, frame);
   }
   handleUnexpectedDrop(sock, generation, cause) {
+    if (this.closeStarted || this.sock !== sock || this.generation !== generation)
+      return;
     this.cancelRestoredDebounce();
     this.abortGeneration(generation);
     this.generation += 1;
     sock.close();
-    this.enqueueConnectionState({ state: "down", cause });
-    this.scheduleReconnectAfterDrop(cause);
+    this.scheduleReconnectAfterDrop(cause, this.generation, sock);
   }
-  scheduleReconnectAfterDrop(trigger) {
-    if (this.closeStarted || this.reconnecting)
+  scheduleReconnectAfterDrop(cause, generation, droppedSocket) {
+    if (this.closeStarted)
       return;
-    const promise = this.reconnectWithRetry(trigger).catch((err) => {
-      if (!this.closeStarted)
+    const previous = this.reconnecting;
+    if (previous) {
+      if (!this.shouldSupersedeReconnect(previous, generation, droppedSocket))
+        return;
+      previous.superseded = true;
+      previous.socket?.close();
+    }
+    const cycle = {
+      generation,
+      socket: null,
+      socketDied: false,
+      superseded: false
+    };
+    this.reconnecting = cycle;
+    this.enqueueConnectionState({ state: "down", cause });
+    this.reconnectWithRetry(cycle).catch((err) => {
+      if (this.isCurrentReconnect(cycle) && !this.closeStarted) {
         this.failFatal(err instanceof Error ? err : new SubcProviderError(String(err)));
+      }
     }).finally(() => {
-      if (this.reconnecting === promise)
+      if (this.isCurrentReconnect(cycle))
         this.reconnecting = null;
     });
-    this.reconnecting = promise;
   }
-  async reconnectWithRetry(_trigger) {
+  async reconnectWithRetry(cycle) {
     let attempt = 0;
     let delay = this.opts.reconnectBackoff.baseMs;
     for (;; ) {
+      if (!this.isCurrentReconnect(cycle))
+        return;
       if (this.closeStarted)
         throw new SubcProviderError("provider closed");
+      cycle.socket = null;
+      cycle.socketDied = false;
       attempt += 1;
-      this.enqueueConnectionState({ state: "reconnecting", attempt });
+      this.enqueueReconnectState(cycle, attempt);
       try {
-        const opened = await SubcProvider.openConnection(this.opts);
-        if (this.closeStarted) {
+        const opened = await SubcProvider.openConnection(this.opts, (sock) => {
+          if (!this.isCurrentReconnect(cycle)) {
+            sock.close();
+            return;
+          }
+          cycle.socket = sock;
+        });
+        if (!this.isCurrentReconnect(cycle) || this.closeStarted) {
           opened.sock.close();
-          throw new SubcProviderError("provider closed");
+          if (this.closeStarted)
+            throw new SubcProviderError("provider closed");
+          return;
         }
-        this.replaceConnection(opened);
+        const epoch = this.replaceConnection(opened, cycle.generation);
+        this.reconnecting = null;
+        if (this.reconnecting !== null) {
+          throw new SubcProviderError("reconnect state must clear before restored", "reconnect_state");
+        }
+        this.scheduleRestored(cycle.generation, epoch);
         return;
       } catch (err) {
+        if (!this.isCurrentReconnect(cycle))
+          return;
+        if (cycle.socket)
+          cycle.socketDied = true;
         if (this.closeStarted)
           throw err;
         if (!isProviderReconnectTransient(err))
@@ -13308,16 +14077,29 @@ class SubcProvider {
       }
     }
   }
-  replaceConnection(opened) {
+  isCurrentReconnect(cycle) {
+    return !cycle.superseded && this.reconnecting === cycle && this.generation === cycle.generation;
+  }
+  shouldSupersedeReconnect(cycle, generation, droppedSocket) {
+    return cycle.generation < generation || cycle.socketDied || cycle.socket === droppedSocket;
+  }
+  enqueueReconnectState(cycle, attempt) {
+    if (!this.isCurrentReconnect(cycle))
+      return;
+    this.enqueueConnectionState({ state: "reconnecting", attempt }, cycle.generation, cycle);
+  }
+  replaceConnection(opened, generation) {
     this.sock.close();
     this.sock = opened.sock;
     this.currentConn = opened.conn;
     this.storage = opened.ack.storage;
     this.closedErr = null;
     this.connectionEpoch += 1;
-    const generation = this.generation;
+    this.connectionToken = newConnectionToken();
+    this.liveRoutes.clear();
+    this.nextCorr = 1n;
     this.readLoop(opened.sock, generation);
-    this.scheduleRestored(generation, this.connectionEpoch);
+    return this.connectionEpoch;
   }
   scheduleRestored(generation, epoch) {
     if (!this.opts.onConnectionState)
@@ -13325,7 +14107,7 @@ class SubcProvider {
     const token = ++this.restoredDebounceToken;
     this.opts.sleep(this.opts.restoredDebounceMs).then(() => {
       if (token === this.restoredDebounceToken && !this.closeStarted && this.sock && this.generation === generation && this.connectionEpoch === epoch) {
-        this.enqueueConnectionState({ state: "restored", epoch });
+        this.enqueueConnectionState({ state: "restored", epoch }, generation);
       }
     }).catch((err) => {
       if (token === this.restoredDebounceToken && !this.closeStarted) {
@@ -13336,10 +14118,10 @@ class SubcProvider {
   cancelRestoredDebounce() {
     this.restoredDebounceToken += 1;
   }
-  enqueueConnectionState(event) {
+  enqueueConnectionState(event, generation, reconnect) {
     if (!this.opts.onConnectionState)
       return;
-    this.stateQueue.push(event);
+    this.stateQueue.push({ event, generation, reconnect });
     if (!this.drainingStateQueue)
       this.drainConnectionStateQueue();
   }
@@ -13349,7 +14131,12 @@ class SubcProvider {
     this.drainingStateQueue = true;
     try {
       while (this.stateQueue.length > 0) {
-        const event = this.stateQueue[0];
+        const queued = this.stateQueue[0];
+        if (this.closeStarted || queued.generation !== undefined && queued.generation !== this.generation || queued.reconnect?.superseded) {
+          this.stateQueue.shift();
+          continue;
+        }
+        const { event } = queued;
         try {
           await this.opts.onConnectionState?.(event);
           this.stateQueue.shift();
@@ -13369,6 +14156,24 @@ class SubcProvider {
         this.drainConnectionStateQueue();
     }
   }
+  isLiveHandle(handle) {
+    return belongsToConnection(handle, this.connectionToken) && this.liveRoutes.get(handle.channel) === handle;
+  }
+  assertLiveHandle(handle) {
+    if (!this.isLiveHandle(handle))
+      throw new StaleRouteHandleError(handle);
+  }
+  allocateCorr() {
+    const maximum = 0xffffffffffffffffn;
+    if (this.nextCorr > maximum) {
+      const error2 = new SubcProviderError("channel-0 correlation id allocator exhausted", "corr_exhausted");
+      this.handleUnexpectedDrop(this.sock, this.generation, error2);
+      throw error2;
+    }
+    const corr = this.nextCorr;
+    this.nextCorr += 1n;
+    return corr;
+  }
   failFatal(err) {
     if (!this.closedErr)
       this.closedErr = err;
@@ -13382,8 +14187,16 @@ class SubcProvider {
     this.resolveClosed();
   }
 }
-function routeKey(generation, channel, corr) {
-  return `${generation}:${channel}:${corr}`;
+function routeKey(handle, corr) {
+  return `${handle.channel}:${handle.epoch}:${corr}`;
+}
+function providerErrorFromFrame(frame) {
+  try {
+    const body = parseJson(frame.body);
+    return new SubcProviderError(body.message ?? "subc error", body.code);
+  } catch {
+    return new SubcProviderError(Buffer2.from(frame.body).toString("utf8") || "subc error");
+  }
 }
 function launchNonce(opts) {
   const nonce = opts.launchNonce ?? process.env[SUBC_LAUNCH_NONCE_ENV2];
@@ -13399,6 +14212,7 @@ function normalizeProviderConnectOptions(opts) {
     handshakeTimeoutMs: opts.handshakeTimeoutMs,
     controlOps: opts.controlOps,
     onBind: opts.onBind,
+    onBound: opts.onBound,
     onRouteGone: opts.onRouteGone,
     reconnectBackoff: opts.reconnectBackoff ?? DEFAULT_RECONNECT_BACKOFF,
     sleep: opts.sleep ?? ((ms) => new Promise((resolve7) => setTimeout(resolve7, ms))),
@@ -13416,7 +14230,7 @@ function normalizedControlOps(controlOps) {
 }
 function buildHelloFrame(opts) {
   const nonce = launchNonce(opts);
-  return buildFrame(FrameType.Hello, controlFlags(), 0, HELLO_CORR, encodeJson({
+  return buildFrame(FrameType.Hello, controlFlags(), 0, 0, HELLO_CORR, encodeJson({
     manifest: normalizeManifest(opts.manifest),
     protocol_ver: PROTOCOL_VERSION,
     control_ops: normalizedControlOps(opts.controlOps),
@@ -13455,14 +14269,17 @@ async function sendFrame(sock, frame) {
   await sock.write(encodeFrame(frame), Date.now() + WRITE_TIMEOUT_MS);
 }
 async function expectHelloAck(sock, deadline) {
-  const header = decodeHeader(await sock.readExact(HEADER_LEN, deadline));
-  const body = header.len === 0 ? new Uint8Array(0) : await sock.readExact(header.len, deadline);
-  const frame = { header, body };
-  switch (header.ty) {
-    case FrameType.HelloAck:
-      return parseJson(body);
+  const frame = await sock.readFrame(deadline, deadline);
+  switch (frame.header.ty) {
+    case FrameType.HelloAck: {
+      const ack = parseJson(frame.body);
+      if (ack.negotiated_ver !== PROTOCOL_VERSION) {
+        throw new SubcProviderError(`subc negotiated protocol ${ack.negotiated_ver}; expected exactly ${PROTOCOL_VERSION}`, "unsupported_version");
+      }
+      return ack;
+    }
     case FrameType.Error: {
-      const error2 = parseJson(body);
+      const error2 = parseJson(frame.body);
       throw new SubcProviderError(`subc rejected HELLO: ${error2.code ?? "unknown"} — ${error2.message ?? "subc error"}`, error2.code);
     }
     default:
@@ -13617,15 +14434,17 @@ class BgSubscription {
   identity;
   acquireClient;
   dropClient;
+  consumerIdentity;
   onNudge;
   sleep;
   stopped = false;
   current = null;
   loop;
-  constructor(identity, acquireClient, dropClient, onNudge, sleep2) {
+  constructor(identity, acquireClient, dropClient, consumerIdentity, onNudge, sleep2) {
     this.identity = identity;
     this.acquireClient = acquireClient;
     this.dropClient = dropClient;
+    this.consumerIdentity = consumerIdentity;
     this.onNudge = onNudge;
     this.sleep = sleep2;
     this.loop = this.run();
@@ -13654,9 +14473,9 @@ class BgSubscription {
       }
       if (this.stopped)
         return;
-      let channel;
+      let route;
       try {
-        channel = await client.routeOpen({ kind: "tool_provider", module_id: AFT_MODULE_ID }, this.identity);
+        route = await client.routeOpen({ kind: "tool_provider", module_id: AFT_MODULE_ID }, this.identity, { consumerIdentity: this.consumerIdentity });
       } catch (err) {
         if (isConsumerReconnectTransient(err))
           this.dropClient(client);
@@ -13664,12 +14483,12 @@ class BgSubscription {
         continue;
       }
       if (this.stopped) {
-        safeCloseRoute(client, channel);
+        safeCloseRoute(client, route);
         return;
       }
       const subscribedAt = Date.now();
       try {
-        const sub = client.subscribe(channel, { op: "bg_events" }, () => {
+        const sub = client.subscribe(route, { op: "bg_events" }, () => {
           if (!this.stopped)
             this.onNudge();
         });
@@ -13689,7 +14508,7 @@ class BgSubscription {
           attempt = 0;
       } finally {
         this.current = null;
-        safeCloseRoute(client, channel);
+        safeCloseRoute(client, route);
       }
       await this.backoff(attempt++);
     }
@@ -13702,12 +14521,12 @@ class BgSubscription {
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function isUnknownChannelError(err) {
-  return err instanceof SubcError && err.code === "unknown_channel";
+function isRouteProvenAbsentError(err) {
+  return err instanceof SubcError && err.code === "unknown_channel" || err instanceof StaleRouteHandleError;
 }
-function safeCloseRoute(client, channel) {
+function safeCloseRoute(client, route) {
   try {
-    client.closeRouteChannel(channel).catch(() => {
+    client.closeRouteChannel(route).catch(() => {
       return;
     });
   } catch {}
@@ -13794,6 +14613,7 @@ class SubcTransportPool {
   harness;
   connectionFile;
   handshakeTimeoutMs;
+  consumerIdentity;
   connectFn;
   onBgEventsNudge;
   bgBackoffSleep;
@@ -13807,6 +14627,7 @@ class SubcTransportPool {
     this.connectionFile = options.connectionFile;
     this.harness = options.harness;
     this.handshakeTimeoutMs = options.handshakeTimeoutMs;
+    this.consumerIdentity = options.consumerIdentity;
     this.connectFn = options.connect ?? ((opts) => SubcClient.connect(opts));
     this.onBgEventsNudge = options.onBgEventsNudge;
     this.bgBackoffSleep = options.bgBackoffSleep ?? ((ms) => new Promise((resolve7) => setTimeout(resolve7, ms)));
@@ -13829,6 +14650,11 @@ class SubcTransportPool {
       return null;
     return this.transports.get(key) ?? null;
   }
+  activeBridges() {
+    if (!this.client || this.shuttingDown)
+      return [];
+    return [...this.transports.values()];
+  }
   async toolCall(projectRoot, runtime, name, rawArgs = {}, options) {
     return this.getBridge(projectRoot).toolCall(runtime.sessionID, name, rawArgs, options);
   }
@@ -13859,7 +14685,7 @@ class SubcTransportPool {
           throw new RouteTornDownError("subc session closed");
         }
         try {
-          const opened = await this.routeChannel(client, identity, record);
+          const opened = await this.routeHandle(client, identity, record);
           if (!this.isCurrentSession(key, record)) {
             throw new RouteTornDownError("subc session closed");
           }
@@ -13885,29 +14711,29 @@ class SubcTransportPool {
           if (isConsumerReconnectTransient(err)) {
             this.transportFailures = 0;
             this.dropClient(client);
-          } else if (!isUnknownChannelError(err) && ++this.transportFailures >= MAX_CONSECUTIVE_TRANSPORT_FAILURES) {
+          } else if (!isRouteProvenAbsentError(err) && ++this.transportFailures >= MAX_CONSECUTIVE_TRANSPORT_FAILURES) {
             this.transportFailures = 0;
             this.dropClient(client);
           }
         }
       };
-      const requestOnRoute = async (channel2) => {
-        const reply = await client.request(channel2, body, { timeoutMs, onProgress });
+      const requestOnRoute = async (route2) => {
+        const reply = await client.request(route2, body, { timeoutMs, onProgress });
         if (this.isCurrentSession(key, record) && this.client === client) {
           this.transportFailures = 0;
         }
         this.ensureBgSubscription(identity, record);
         return reply;
       };
-      let { channel, entry } = await openRoute();
+      let { route, entry } = await openRoute();
       try {
-        return await requestOnRoute(channel);
+        return await requestOnRoute(route);
       } catch (err) {
-        if (isUnknownChannelError(err) && this.isCurrentSession(key, record) && this.client === client) {
+        if (isRouteProvenAbsentError(err) && this.isCurrentSession(key, record) && this.client === client) {
           clearRouteEntry(entry);
-          ({ channel, entry } = await openRoute());
+          ({ route, entry } = await openRoute());
           try {
-            return await requestOnRoute(channel);
+            return await requestOnRoute(route);
           } catch (retryErr) {
             handleRequestFailure(retryErr, entry);
             throw retryErr;
@@ -13949,24 +14775,26 @@ class SubcTransportPool {
     });
     return this.connecting;
   }
-  async routeChannel(client, identity, record) {
+  async routeHandle(client, identity, record) {
     const key = identityKey(identity);
     const existing = record.routeEntry;
-    if (existing?.channel != null)
-      return { channel: existing.channel, entry: existing };
+    if (existing?.handle != null)
+      return { route: existing.handle, entry: existing };
     if (existing?.opening)
-      return { channel: await existing.opening, entry: existing };
-    const entry = { client, opening: null, channel: null, closed: false };
-    const opening = client.routeOpen({ kind: "tool_provider", module_id: AFT_MODULE_ID }, identity).then((channel) => {
+      return { route: await existing.opening, entry: existing };
+    const entry = { client, opening: null, handle: null, closed: false };
+    const opening = client.routeOpen({ kind: "tool_provider", module_id: AFT_MODULE_ID }, identity, {
+      consumerIdentity: this.consumerIdentity
+    }).then((route) => {
       if (!this.isCurrentSession(key, record) || record.routeEntry !== entry || entry.closed || this.client !== client) {
-        safeCloseRoute(client, channel);
+        safeCloseRoute(client, route);
         if (record.routeEntry === entry)
           record.routeEntry = null;
         throw new RouteTornDownError("subc route opened after teardown");
       }
-      entry.channel = channel;
+      entry.handle = route;
       entry.opening = null;
-      return channel;
+      return route;
     }).catch((err) => {
       const current = this.isCurrentSession(key, record);
       if (record.routeEntry === entry) {
@@ -13980,7 +14808,7 @@ class SubcTransportPool {
     });
     entry.opening = opening;
     record.routeEntry = entry;
-    return { channel: await opening, entry };
+    return { route: await opening, entry };
   }
   ensureBgSubscription(identity, record) {
     if (this.shuttingDown || !this.onBgEventsNudge)
@@ -13991,7 +14819,7 @@ class SubcTransportPool {
     if (record.bgSub)
       return;
     const onNudge = () => this.onBgEventsNudge?.(identity.project_root, identity.session);
-    const sub = new BgSubscription(identity, () => this.ensureClient(), (client) => this.dropClient(client), onNudge, this.bgBackoffSleep);
+    const sub = new BgSubscription(identity, () => this.ensureClient(), (client) => this.dropClient(client), this.consumerIdentity, onNudge, this.bgBackoffSleep);
     record.bgSub = sub;
   }
   dropClient(client) {
@@ -14012,9 +14840,13 @@ class SubcTransportPool {
     }
   }
   setConfigureOverride(_key, _value) {}
+  async reconfigure(_projectRoot, _overrides) {}
   async replaceBinary(path2) {
     return path2;
   }
+  isShutdown() {
+    return this.shuttingDown;
+  }
   async shutdown() {
     this.shuttingDown = true;
     const subs = [];
@@ -14038,10 +14870,10 @@ class SubcTransportPool {
     this.transports.clear();
     await Promise.allSettled(subs.map((sub) => sub.stop()));
     await Promise.allSettled(entries.map(async (entry) => {
-      if (entry.channel == null)
+      if (entry.handle == null)
         return;
       try {
-        await entry.client.closeRouteChannel(entry.channel);
+        await entry.client.closeRouteChannel(entry.handle);
       } catch {}
     }));
     if (client) {
@@ -14070,9 +14902,9 @@ class SubcTransportPool {
       entry.closed = true;
     if (sub)
       await sub.stop();
-    if (entry?.channel != null) {
+    if (entry?.handle != null) {
       try {
-        await entry.client.closeRouteChannel(entry.channel);
+        await entry.client.closeRouteChannel(entry.handle);
       } catch {}
     }
   }
@@ -14149,18 +14981,25 @@ function collectStructuredExtras(response) {
   return stringifyData(extras);
 }
 // ../aft-bridge/dist/transport-factory.js
-import { homedir as homedir10 } from "node:os";
-import { isAbsolute as isAbsolute5, join as join9 } from "node:path";
+import { homedir as homedir11 } from "node:os";
+import { isAbsolute as isAbsolute5, join as join10 } from "node:path";
 function resolveConnectionFilePath(raw) {
   const trimmed = raw.trim();
   if (trimmed.startsWith("~")) {
-    return join9(homedir10(), trimmed.slice(1).replace(/^[/\\]/, ""));
+    return join10(homedir11(), trimmed.slice(1).replace(/^[/\\]/, ""));
   }
   if (isAbsolute5(trimmed))
     return trimmed;
-  return join9(homedir10(), trimmed);
+  return join10(homedir11(), trimmed);
 }
 async function createAftTransportPool(opts) {
+  let binaryPath = opts.binaryPath;
+  const createPool = () => createConcreteAftTransportPool({ ...opts, binaryPath });
+  return new RevivableTransportPool(await createPool(), createPool, (path2) => {
+    binaryPath = path2;
+  });
+}
+async function createConcreteAftTransportPool(opts) {
   const raw = opts.subcConnectionFile?.trim();
   if (raw && raw.length > 0) {
     const connectionFile = resolveConnectionFilePath(raw);
@@ -14171,18 +15010,17 @@ async function createAftTransportPool(opts) {
     return new SubcTransportPool({
       connectionFile,
       harness: opts.harness,
+      consumerIdentity: opts.subcConsumerIdentity,
       onBgEventsNudge: opts.onBgEventsNudge
     });
   }
   return new BridgePool(opts.binaryPath, opts.poolOptions, opts.configOverrides);
 }
 // src/logger.ts
-import * as fs3 from "node:fs";
-import * as os2 from "node:os";
-import * as path2 from "node:path";
 var TAG = "[aft-pi]";
 var isTestEnv = process.env.BUN_TEST === "1" || false;
-var logFile = path2.join(os2.tmpdir(), isTestEnv ? "aft-pi-test.log" : "aft-pi.log");
+var logFile = resolveAftLogPath(isTestEnv ? "aft-plugin-test.log" : "aft-plugin.log");
+var fileSink = new RotatingLogSink(logFile);
 var useStderr = process.env.AFT_LOG_STDERR === "1";
 var buffer = [];
 var flushTimer = null;
@@ -14197,7 +15035,7 @@ function flush() {
     if (useStderr) {
       process.stderr.write(data);
     } else {
-      fs3.appendFileSync(logFile, data);
+      fileSink.append(data);
     }
   } catch {}
 }
@@ -14910,7 +15748,7 @@ import {
 // package.json
 var package_default = {
   name: "@cortexkit/aft-pi",
-  version: "0.46.0",
+  version: "0.47.0",
   type: "module",
   description: "Pi coding agent extension for Agent File Tools (AFT) — tree-sitter and LSP-powered code analysis",
   main: "dist/index.js",
@@ -14933,19 +15771,19 @@ var package_default = {
     "test:unit": "bun test src/__tests__ --path-ignore-patterns 'src/__tests__/e2e/**'"
   },
   dependencies: {
-    "@cortexkit/aft-bridge": "0.46.0",
+    "@cortexkit/aft-bridge": "0.47.0",
     "comment-json": "^5.0.0",
     diff: "^8.0.4",
     typebox: "1.1.38",
     zod: "^4.4.3"
   },
   optionalDependencies: {
-    "@cortexkit/aft-darwin-arm64": "0.46.0",
-    "@cortexkit/aft-darwin-x64": "0.46.0",
-    "@cortexkit/aft-linux-arm64": "0.46.0",
-    "@cortexkit/aft-linux-x64": "0.46.0",
-    "@cortexkit/aft-win32-arm64": "0.46.0",
-    "@cortexkit/aft-win32-x64": "0.46.0"
+    "@cortexkit/aft-darwin-arm64": "0.47.0",
+    "@cortexkit/aft-darwin-x64": "0.47.0",
+    "@cortexkit/aft-linux-arm64": "0.47.0",
+    "@cortexkit/aft-linux-x64": "0.47.0",
+    "@cortexkit/aft-win32-arm64": "0.47.0",
+    "@cortexkit/aft-win32-x64": "0.47.0"
   },
   devDependencies: {
     "@earendil-works/pi-coding-agent": "^0.80.2",
@@ -15176,9 +16014,15 @@ function formatStatusDialogMessage(status) {
 }
 
 // src/tools/_shared.ts
+import { existsSync as existsSync7 } from "node:fs";
 import { Type } from "typebox";
-var optionalInt = (_min, _max) => Type.Optional(Type.Any({ description: "(integer)" }));
+var optionalInt = (min, max, description = "(integer)") => Type.Optional(Type.Union([Type.Integer({ minimum: min, maximum: max }), Type.String()], {
+  description
+}));
 function bridgeFor(ctx, cwd) {
+  if (!existsSync7(cwd)) {
+    throw new Error(`project directory no longer exists: ${cwd} (stale restored session?)`);
+  }
   return ctx.pool.getBridge(cwd);
 }
 function resolveSessionId(extCtx) {
@@ -15534,7 +16378,7 @@ function registerStatusCommand(pi, ctx) {
 }
 
 // src/config.ts
-import { existsSync as existsSync7, readFileSync as readFileSync7, renameSync as renameSync5, unlinkSync as unlinkSync5, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync8, readFileSync as readFileSync7, renameSync as renameSync5, unlinkSync as unlinkSync5, writeFileSync as writeFileSync4 } from "node:fs";
 var import_comment_json = __toESM(require_src2(), 1);
 
 // ../../node_modules/.bun/zod@4.4.3/node_modules/zod/v4/classic/external.js
@@ -16301,10 +17145,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path3) {
-  if (!path3)
+function getElementAtPath(obj, path2) {
+  if (!path2)
     return obj;
-  return path3.reduce((acc, key) => acc?.[key], obj);
+  return path2.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -16712,11 +17556,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path3, issues) {
+function prefixIssues(path2, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path3);
+    iss.path.unshift(path2);
     return iss;
   });
 }
@@ -16863,16 +17707,16 @@ function flattenError(error3, mapper = (issue2) => issue2.message) {
 }
 function formatError(error3, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error4, path3 = []) => {
+  const processError = (error4, path2 = []) => {
     for (const issue2 of error4.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path3, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path2, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path2, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path2, ...issue2.path]);
       } else {
-        const fullpath = [...path3, ...issue2.path];
+        const fullpath = [...path2, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -16899,17 +17743,17 @@ function formatError(error3, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error3, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error4, path3 = []) => {
+  const processError = (error4, path2 = []) => {
     var _a2, _b;
     for (const issue2 of error4.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path3, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path2, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path2, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path2, ...issue2.path]);
       } else {
-        const fullpath = [...path3, ...issue2.path];
+        const fullpath = [...path2, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -16941,8 +17785,8 @@ function treeifyError(error3, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path3 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path3) {
+  const path2 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path2) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -29401,13 +30245,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path3 = ref.slice(1).split("/").filter(Boolean);
-  if (path3.length === 0) {
+  const path2 = ref.slice(1).split("/").filter(Boolean);
+  if (path2.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path3[0] === defsKey) {
-    const key = path3[1];
+  if (path2[0] === defsKey) {
+    const key = path2[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -29893,6 +30737,7 @@ var SemanticConfigSchema = exports_external.object({
   base_url: exports_external.string().trim().min(1).optional(),
   api_key_env: exports_external.string().trim().min(1).optional(),
   timeout_ms: exports_external.number().int().positive().optional(),
+  query_timeout_ms: exports_external.number().int().positive().optional(),
   max_batch_size: exports_external.number().int().positive().optional(),
   max_files: exports_external.number().int().positive().optional()
 });
@@ -29958,7 +30803,7 @@ var BackupConfigSchema = exports_external.object({
   max_depth: exports_external.number().int().positive().optional(),
   max_file_size: exports_external.number().int().positive().optional()
 });
-var AftConfigSchema = exports_external.object({
+var AftConfigSchema = exports_external.preprocess((value) => stripHarnessSpecificConfigKeys(value, OPENCODE_ONLY_KEYS), exports_external.object({
   $schema: exports_external.string().optional(),
   enabled: exports_external.boolean().optional(),
   format_on_edit: exports_external.boolean().optional(),
@@ -29983,7 +30828,7 @@ var AftConfigSchema = exports_external.object({
   semantic: SemanticConfigSchema.optional(),
   bridge: BridgeConfigSchema.optional(),
   subc: SubcConfigSchema.optional()
-}).strict();
+}).strict());
 var CONFIG_MIGRATIONS = [
   { oldKey: "experimental_search_index", newPath: ["search_index"] },
   { oldKey: "experimental_semantic_search", newPath: ["semantic_search"] },
@@ -30008,9 +30853,9 @@ function extractCommentsForPreservation(content) {
   }
   return comments;
 }
-function ensureRecordAtPath(root, path3) {
+function ensureRecordAtPath(root, path2) {
   let current = root;
-  for (const segment of path3) {
+  for (const segment of path2) {
     const existing = current[segment];
     if (!existing || typeof existing !== "object" || Array.isArray(existing)) {
       current[segment] = {};
@@ -30019,9 +30864,9 @@ function ensureRecordAtPath(root, path3) {
   }
   return current;
 }
-function hasPath(root, path3) {
+function hasPath(root, path2) {
   let current = root;
-  for (const segment of path3) {
+  for (const segment of path2) {
     if (!current || typeof current !== "object" || Array.isArray(current))
       return false;
     const record2 = current;
@@ -30031,9 +30876,9 @@ function hasPath(root, path3) {
   }
   return true;
 }
-function setPath(root, path3, value) {
-  const parent = ensureRecordAtPath(root, path3.slice(0, -1));
-  parent[path3[path3.length - 1]] = value;
+function setPath(root, path2, value) {
+  const parent = ensureRecordAtPath(root, path2.slice(0, -1));
+  parent[path2[path2.length - 1]] = value;
 }
 function migrateRawConfig(rawConfig, configPath, logger) {
   const oldKeys = [];
@@ -30094,7 +30939,7 @@ function migrateExperimentalBashBlock(rawConfig, configPath, logger) {
   return movedKeys;
 }
 function migrateAftConfigFile2(configPath, logger = { log: log2, warn: warn2 }) {
-  if (!existsSync7(configPath)) {
+  if (!existsSync8(configPath)) {
     return { migrated: false, oldKeys: [] };
   }
   let tmpPath = null;
@@ -30147,7 +30992,7 @@ function recordConfigParseFailure(configPath, errorMessage) {
 }
 function loadConfigFromPath(configPath) {
   try {
-    if (!existsSync7(configPath))
+    if (!existsSync8(configPath))
       return null;
     const content = readFileSync7(configPath, "utf-8");
     const rawConfig = import_comment_json.parse(content);
@@ -30428,7 +31273,7 @@ import { spawn as spawn2 } from "node:child_process";
 import { createHash as createHash4 } from "node:crypto";
 import {
   createReadStream,
-  existsSync as existsSync9,
+  existsSync as existsSync10,
   mkdirSync as mkdirSync7,
   readFileSync as readFileSync10,
   renameSync as renameSync6,
@@ -30448,7 +31293,7 @@ import {
   unlinkSync as unlinkSync6,
   writeFileSync as writeFileSync5
 } from "node:fs";
-import { homedir as homedir11 } from "node:os";
+import { homedir as homedir12 } from "node:os";
 import { join as join11 } from "node:path";
 function aftCacheBase() {
   const override = process.env.AFT_CACHE_DIR;
@@ -30456,10 +31301,10 @@ function aftCacheBase() {
     return override;
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join11(homedir11(), "AppData", "Local");
+    const base2 = localAppData || join11(homedir12(), "AppData", "Local");
     return join11(base2, "aft");
   }
-  const base = process.env.XDG_CACHE_HOME || join11(homedir11(), ".cache");
+  const base = process.env.XDG_CACHE_HOME || join11(homedir12(), ".cache");
   return join11(base, "aft");
 }
 function lspCacheRoot() {
@@ -30503,11 +31348,11 @@ function writeInstalledMetaIn(installDir, version2, sha256) {
   }
 }
 function readInstalledMetaIn(installDir) {
-  const path3 = join11(installDir, INSTALLED_META_FILE);
+  const path2 = join11(installDir, INSTALLED_META_FILE);
   try {
-    if (!statSync5(path3).isFile())
+    if (!statSync5(path2).isFile())
       return null;
-    const raw = readFileSync8(path3, "utf8");
+    const raw = readFileSync8(path2, "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.version !== "string" || parsed.version.length === 0)
       return null;
@@ -30813,7 +31658,7 @@ var NPM_LSP_TABLE = [
 ];
 
 // src/lsp-project-relevance.ts
-import { existsSync as existsSync8, readdirSync as readdirSync3, readFileSync as readFileSync9 } from "node:fs";
+import { existsSync as existsSync9, readdirSync as readdirSync3, readFileSync as readFileSync9 } from "node:fs";
 import { join as join12 } from "node:path";
 var MAX_WALK_DIRS = 200;
 var MAX_WALK_DEPTH = 4;
@@ -30831,7 +31676,7 @@ function hasRootMarker(projectRoot, rootMarkers) {
   if (!rootMarkers)
     return false;
   for (const marker of rootMarkers) {
-    if (existsSync8(join12(projectRoot, marker)))
+    if (existsSync9(join12(projectRoot, marker)))
       return true;
   }
   return false;
@@ -31013,7 +31858,7 @@ async function resolveTargetVersion(spec, config2, fetchImpl = fetch) {
 function ensureInstallAnchor(cwd) {
   try {
     const stub = join13(cwd, "package.json");
-    if (!existsSync9(stub)) {
+    if (!existsSync10(stub)) {
       writeFileSync6(stub, `${JSON.stringify({ name: "aft-lsp-cache", version: "0.0.0", private: true })}
 `);
     }
@@ -31199,8 +32044,8 @@ function installedBinaryPath(spec) {
   }
   return null;
 }
-function sha256OfFileSync(path3) {
-  return createHash4("sha256").update(readFileSync10(path3)).digest("hex");
+function sha256OfFileSync(path2) {
+  return createHash4("sha256").update(readFileSync10(path2)).digest("hex");
 }
 function quarantineCachedNpmInstall(spec, reason) {
   const packageDir = lspPackageDir(spec.npm);
@@ -31278,9 +32123,15 @@ function runAutoInstall(projectRoot, config2, fetchImpl = fetch) {
       return installsStarted;
     },
     skipped,
-    installsComplete: Promise.all(installPromises).then(() => {})
+    installsComplete: Promise.all(installPromises).then(() => {}),
+    getCachedBinDirs: () => NPM_LSP_TABLE.filter((spec) => isInstalled(spec.npm, spec.binary) && validateCachedNpmInstall(spec)).map((spec) => lspBinDir(spec.npm))
   };
 }
+async function pushLspPathsAfterAutoInstall(pool, projectRoot, cachedBinDirs) {
+  const paths = [...new Set(cachedBinDirs)];
+  pool.setConfigureOverride("lsp_paths_extra", paths);
+  await pool.reconfigure(projectRoot, { lsp_paths_extra: paths });
+}
 
 // src/lsp-github-install.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
@@ -31289,7 +32140,7 @@ import {
   copyFileSync as copyFileSync4,
   createReadStream as createReadStream2,
   createWriteStream as createWriteStream3,
-  existsSync as existsSync10,
+  existsSync as existsSync11,
   lstatSync as lstatSync2,
   mkdirSync as mkdirSync8,
   readdirSync as readdirSync4,
@@ -31302,7 +32153,7 @@ import {
   unlinkSync as unlinkSync7,
   writeFileSync as writeFileSync7
 } from "node:fs";
-import { dirname as dirname5, join as join14, relative as relative3, resolve as resolve7 } from "node:path";
+import { dirname as dirname6, join as join14, relative as relative3, resolve as resolve7 } from "node:path";
 import { Readable as Readable3 } from "node:stream";
 import { pipeline as pipeline3 } from "node:stream/promises";
 
@@ -31424,10 +32275,10 @@ function ghBinaryCandidates(spec, platform) {
 }
 function readGithubInstalledMetaIn(installDir) {
   try {
-    const path3 = join14(installDir, INSTALLED_META_FILE2);
-    if (!statSync7(path3).isFile())
+    const path2 = join14(installDir, INSTALLED_META_FILE2);
+    if (!statSync7(path2).isFile())
       return null;
-    const parsed = JSON.parse(readFileSync11(path3, "utf8"));
+    const parsed = JSON.parse(readFileSync11(path2, "utf8"));
     if (typeof parsed.version !== "string" || parsed.version.length === 0)
       return null;
     return {
@@ -31458,17 +32309,17 @@ function writeGithubInstalledMetaIn(installDir, version2, binarySha256, archiveS
 }
 var MAX_DOWNLOAD_BYTES3 = 256 * 1024 * 1024;
 var MAX_EXTRACT_BYTES2 = 1024 * 1024 * 1024;
-function sha256OfFile(path3) {
+function sha256OfFile(path2) {
   return new Promise((resolve8, reject) => {
     const hash2 = createHash5("sha256");
-    const stream = createReadStream2(path3);
+    const stream = createReadStream2(path2);
     stream.on("error", reject);
     stream.on("data", (chunk) => hash2.update(chunk));
     stream.on("end", () => resolve8(hash2.digest("hex")));
   });
 }
-function sha256OfFileSync2(path3) {
-  return createHash5("sha256").update(readFileSync11(path3)).digest("hex");
+function sha256OfFileSync2(path2) {
+  return createHash5("sha256").update(readFileSync11(path2)).digest("hex");
 }
 async function fetchReleaseByTag(githubRepo, tag, fetchImpl, signal) {
   const candidates = [];
@@ -31644,7 +32495,7 @@ async function downloadFile(url2, destPath, fetchImpl, assetSize, signal) {
     if (Number.isFinite(advertised) && advertised > MAX_DOWNLOAD_BYTES3) {
       throw new Error(`Content-Length ${advertised} exceeds max ${MAX_DOWNLOAD_BYTES3}`);
     }
-    mkdirSync8(dirname5(destPath), { recursive: true });
+    mkdirSync8(dirname6(destPath), { recursive: true });
     let bytesWritten = 0;
     const guard = new TransformStream({
       transform(chunk, controller) {
@@ -31791,7 +32642,7 @@ function quarantineCachedGithubInstall(spec, reason) {
   const dest = join14(ghCacheRoot(), ".quarantine", encodeURIComponent(spec.id), `${Date.now()}`);
   warn2(`[lsp] tofu_mismatch ${spec.id}: ${reason}; quarantining ${packageDir} -> ${dest}`);
   try {
-    mkdirSync8(dirname5(dest), { recursive: true });
+    mkdirSync8(dirname6(dest), { recursive: true });
     rmSync5(dest, { recursive: true, force: true });
     renameSync7(packageDir, dest);
   } catch (err) {
@@ -31920,12 +32771,12 @@ async function downloadAndInstall(spec, tag, assets, platform, arch, fetchImpl,
     } catch {}
   }
   const innerBinaryPath = join14(extractDir, spec.binaryPathInArchive(platform, arch, version2));
-  if (!existsSync10(innerBinaryPath)) {
+  if (!existsSync11(innerBinaryPath)) {
     error2(`[lsp] ${spec.id}: extracted binary not found at ${innerBinaryPath}`);
     return null;
   }
   const targetBinary = ghBinaryPath(spec, platform);
-  mkdirSync8(dirname5(targetBinary), { recursive: true });
+  mkdirSync8(dirname6(targetBinary), { recursive: true });
   try {
     copyFileSync4(innerBinaryPath, targetBinary);
     if (platform !== "win32") {
@@ -32004,7 +32855,7 @@ function runGithubAutoInstall(relevantServers, config2, fetchImpl = fetch) {
   if (!host) {
     for (const spec of GITHUB_LSP_TABLE) {
       try {
-        if (existsSync10(ghBinDir(spec))) {
+        if (existsSync11(ghBinDir(spec))) {
           cachedBinDirs.push(ghBinDir(spec));
         }
       } catch {}
@@ -32014,7 +32865,8 @@ function runGithubAutoInstall(relevantServers, config2, fetchImpl = fetch) {
       installsStarted: 0,
       installingBinaries: [],
       skipped,
-      installsComplete: Promise.resolve()
+      installsComplete: Promise.resolve(),
+      getCachedBinDirs: () => [...cachedBinDirs]
     };
   }
   for (const spec of GITHUB_LSP_TABLE) {
@@ -32056,7 +32908,13 @@ function runGithubAutoInstall(relevantServers, config2, fetchImpl = fetch) {
       return installsStarted;
     },
     skipped,
-    installsComplete: Promise.all(installPromises).then(() => {})
+    installsComplete: Promise.all(installPromises).then(() => {}),
+    getCachedBinDirs: () => {
+      const currentHost = detectHostPlatform();
+      if (!currentHost)
+        return [];
+      return GITHUB_LSP_TABLE.filter((spec) => isGithubInstalled(spec, currentHost.platform) && validateCachedGithubInstall(spec, currentHost.platform)).map((spec) => ghBinDir(spec));
+    }
   };
 }
 function discoverRelevantGithubServers(projectRoot) {
@@ -32242,6 +33100,27 @@ function statusBarBlockForSession(sessionID, counts, force = false) {
   return shouldEmitStatusBar(state, counts) ? formatStatusBar(counts) : undefined;
 }
 
+// src/bash-wait-detach.ts
+var BASH_TRANSPORT_TIMEOUT_MS = 30000;
+async function sendBashWaitDetach(bridge, sessionID) {
+  const response = await bridge.send("bash_wait_detach", { session_id: sessionID }, { keepBridgeOnTimeout: true, transportTimeoutMs: BASH_TRANSPORT_TIMEOUT_MS });
+  if (response.success === false) {
+    throw new Error(String(response.message ?? "bash_wait_detach failed"));
+  }
+}
+async function signalBashWaitDetachForProject(pool, projectRoot, sessionID) {
+  if (!sessionID)
+    return;
+  const bridge = pool.getActiveBridgeForRoot(projectRoot);
+  if (!bridge)
+    return;
+  try {
+    await sendBashWaitDetach(bridge, sessionID);
+  } catch (err) {
+    warn2(`[bash_wait_detach] failed for session ${sessionID}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+
 // src/shutdown-hooks.ts
 var GLOBAL_KEY = "__aftPiShutdownHooks__";
 function getState() {
@@ -32338,8 +33217,8 @@ import { StringEnum } from "@earendil-works/pi-ai";
 import { Type as Type3 } from "typebox";
 
 // src/tools/hoisted.ts
-import { stat } from "node:fs/promises";
-import { homedir as homedir12 } from "node:os";
+import { stat as stat2 } from "node:fs/promises";
+import { homedir as homedir13 } from "node:os";
 import { isAbsolute as isAbsolute6, relative as relative4, resolve as resolve8, sep } from "node:path";
 import {
   renderDiff
@@ -32483,15 +33362,15 @@ function containsPath(parent, child) {
   const rel = relative4(parent, child);
   return rel === "" || !rel.startsWith("..") && !isAbsolute6(rel);
 }
-function expandTilde2(path3) {
-  if (!path3 || !path3.startsWith("~"))
-    return path3;
-  if (path3 === "~")
-    return homedir12();
-  if (path3.startsWith(`~${sep}`) || path3.startsWith("~/")) {
-    return resolve8(homedir12(), path3.slice(2));
+function expandTilde2(path2) {
+  if (!path2 || !path2.startsWith("~"))
+    return path2;
+  if (path2 === "~")
+    return homedir13();
+  if (path2.startsWith(`~${sep}`) || path2.startsWith("~/")) {
+    return resolve8(homedir13(), path2.slice(2));
   }
-  return path3;
+  return path2;
 }
 function absoluteSearchPath(cwd, target) {
   const expanded = expandTilde2(target);
@@ -32499,7 +33378,7 @@ function absoluteSearchPath(cwd, target) {
 }
 async function searchPathExists(cwd, target) {
   try {
-    await stat(absoluteSearchPath(cwd, target));
+    await stat2(absoluteSearchPath(cwd, target));
     return true;
   } catch {
     return false;
@@ -32556,6 +33435,8 @@ async function assertExternalDirectoryPermission(extCtx, target, options = {}) {
     return;
   if (options.restrictToProjectRoot === false)
     return;
+  if (options.serverValidatedRead === true)
+    return;
   throw new Error(`Blocked: '${absoluteTarget}' is outside the project root and restrict_to_project_root is ` + "enabled (AFT full isolation). Not overridable per-call; set restrict_to_project_root: false " + "in aft.jsonc to allow external paths.");
 }
 var ReadParams = Type2.Object({
@@ -32565,8 +33446,8 @@ var ReadParams = Type2.Object({
   filePath: Type2.Optional(Type2.String({
     description: "Alias for `path` — provide one of the two."
   })),
-  offset: optionalInt(1, Number.MAX_SAFE_INTEGER),
-  limit: optionalInt(1, Number.MAX_SAFE_INTEGER)
+  offset: optionalInt(1, Number.MAX_SAFE_INTEGER, "1-based line number to start reading from (use with limit)"),
+  limit: optionalInt(1, Number.MAX_SAFE_INTEGER, "Maximum number of lines to return")
 });
 var WriteParams = Type2.Object({
   filePath: Type2.Optional(Type2.String({
@@ -32580,8 +33461,10 @@ var WriteParams = Type2.Object({
 var BatchEditParams = Type2.Object({
   oldString: Type2.Optional(Type2.String({ description: "Text to find for a batch find/replace edit" })),
   newString: Type2.Optional(Type2.String({ description: "Replacement text for a batch find/replace edit" })),
-  startLine: Type2.Optional(Type2.Any({ description: "1-based start line for a batch line-range edit" })),
-  endLine: Type2.Optional(Type2.Any({ description: "1-based end line for a batch line-range edit" })),
+  replaceAll: Type2.Optional(Type2.Boolean({ description: "Replace every occurrence for this batch item" })),
+  occurrence: optionalInt(0, Number.MAX_SAFE_INTEGER, "0-based occurrence for this batch item"),
+  startLine: optionalInt(1, Number.MAX_SAFE_INTEGER, "1-based start line for a batch line-range edit"),
+  endLine: optionalInt(1, Number.MAX_SAFE_INTEGER, "1-based end line for a batch line-range edit"),
   content: Type2.Optional(Type2.String({
     description: "Replacement text for a batch line-range edit (empty string deletes the lines)"
   }))
@@ -32596,12 +33479,12 @@ var EditParams = Type2.Object({
   oldString: Type2.Optional(Type2.String({ description: "Text to find (exact match, fuzzy fallback)" })),
   newString: Type2.Optional(Type2.String({ description: "Replacement text (omit to delete match)" })),
   replaceAll: Type2.Optional(Type2.Boolean({ description: "Replace every occurrence" })),
-  occurrence: optionalInt(0, Number.MAX_SAFE_INTEGER),
+  occurrence: optionalInt(0, Number.MAX_SAFE_INTEGER, "0-based occurrence to replace when multiple matches exist"),
   appendContent: Type2.Optional(Type2.String({
     description: "Append text to the end of the file (creates the file if missing, parent dirs auto-created). When set, edits/oldString/newString are ignored."
   })),
   edits: Type2.Optional(Type2.Array(BatchEditParams, {
-    description: "Batch edits — array of { oldString, newString } or { startLine, endLine, content } objects applied atomically to one file."
+    description: "Batch edits — array of { oldString, newString }, { oldString, newString, replaceAll: true }, or { startLine, endLine, content } objects applied atomically."
   }))
 });
 var GrepParams = Type2.Object({
@@ -32685,7 +33568,8 @@ function registerHoistedTools(pi, ctx, surface) {
         const limit = coerceOptionalInt(params.limit, "limit", 1, Number.MAX_SAFE_INTEGER);
         const filePath = await resolvePathArg(extCtx.cwd, pathArg);
         await assertExternalDirectoryPermission(extCtx, filePath, {
-          restrictToProjectRoot: surface.restrictToProjectRoot
+          restrictToProjectRoot: surface.restrictToProjectRoot,
+          serverValidatedRead: true
         });
         const rawArgs = { filePath: pathArg };
         if (offset !== undefined)
@@ -32766,7 +33650,7 @@ PDFs aren't supported on the Pi harness yet.`, response);
     pi.registerTool({
       name: "edit",
       label: "edit",
-      description: "Edit part of a file via `appendContent`, batch `edits[]`, or `oldString`/`newString` find-and-replace. Mode priority: appendContent > edits > oldString. Find/replace errors on multiple matches — use `occurrence` or `replaceAll: true`.",
+      description: "Edit part of a file via `appendContent`, batch `edits[]`, or `oldString`/`newString` find-and-replace. Batch `{ oldString, newString, replaceAll: true }` replaces every match. Mode priority: appendContent > edits > oldString.",
       promptSnippet: "Partial file edits via appendContent, edits[], or oldString/newString (mode priority: appendContent > edits > oldString).",
       promptGuidelines: [
         "Prefer edit over write when changing part of an existing file.",
@@ -32792,10 +33676,20 @@ PDFs aren't supported on the Pi harness yet.`, response);
         });
         const bridge = bridgeFor(ctx, extCtx.cwd);
         const rawArgs = { filePath: filePathArg };
-        for (const key of ["appendContent", "edits", "oldString", "newString"]) {
+        for (const key of ["appendContent", "oldString", "newString"]) {
           if (argsRecord[key] !== undefined)
             rawArgs[key] = argsRecord[key];
         }
+        if (Array.isArray(argsRecord.edits)) {
+          rawArgs.edits = argsRecord.edits.map((item) => {
+            if (!item || typeof item !== "object" || Array.isArray(item))
+              return item;
+            const batchItem = item;
+            return batchItem.replaceAll === undefined ? batchItem : { ...batchItem, replaceAll: coerceBoolean(batchItem.replaceAll) };
+          });
+        } else if (argsRecord.edits !== undefined) {
+          rawArgs.edits = argsRecord.edits;
+        }
         if (params.replaceAll !== undefined)
           rawArgs.replaceAll = coerceBoolean(params.replaceAll);
         const occurrence = coerceOptionalInt(params.occurrence, "occurrence", 0, Number.MAX_SAFE_INTEGER);
@@ -32998,17 +33892,17 @@ ${summary}${suffix}`);
   container.addChild(new Text(renderDiff(diff), 1, 0));
   return container;
 }
-function shortenPath2(path3) {
-  const home = homedir12();
-  if (path3.startsWith(home))
-    return `~${path3.slice(home.length)}`;
-  return path3;
+function shortenPath2(path2) {
+  const home = homedir13();
+  if (path2.startsWith(home))
+    return `~${path2.slice(home.length)}`;
+  return path2;
 }
-async function resolvePathArg(cwd, path3) {
-  const expanded = expandTilde2(path3);
-  const abs = absoluteSearchPath(cwd, path3);
+async function resolvePathArg(cwd, path2) {
+  const expanded = expandTilde2(path2);
+  const abs = absoluteSearchPath(cwd, path2);
   try {
-    await stat(abs);
+    await stat2(abs);
     return abs;
   } catch {
     return expanded;
@@ -33016,7 +33910,7 @@ async function resolvePathArg(cwd, path3) {
 }
 
 // src/tools/render-helpers.ts
-import { homedir as homedir13 } from "node:os";
+import { homedir as homedir14 } from "node:os";
 import { renderDiff as renderDiff2 } from "@earendil-works/pi-coding-agent";
 import { Container as Container2, Spacer as Spacer2, Text as Text2 } from "@earendil-works/pi-tui";
 function reuseText2(last) {
@@ -33025,11 +33919,11 @@ function reuseText2(last) {
 function reuseContainer2(last) {
   return last instanceof Container2 ? last : new Container2;
 }
-function shortenPath3(path3) {
-  const home = homedir13();
-  if (path3.startsWith(home))
-    return `~${path3.slice(home.length)}`;
-  return path3;
+function shortenPath3(path2) {
+  const home = homedir14();
+  if (path2.startsWith(home))
+    return `~${path2.slice(home.length)}`;
+  return path2;
 }
 function renderToolCall(toolName, summary, theme, context) {
   const text = reuseText2(context.lastComponent);
@@ -33037,10 +33931,10 @@ function renderToolCall(toolName, summary, theme, context) {
   text.setText(`${theme.fg("toolTitle", theme.bold(toolName))}${suffix}`);
   return text;
 }
-function accentPath(theme, path3) {
-  if (!path3)
+function accentPath(theme, path2) {
+  if (!path2)
     return theme.fg("toolOutput", "...");
-  return theme.fg("accent", shortenPath3(path3));
+  return theme.fg("accent", shortenPath3(path2));
 }
 function collectTextContent(result) {
   return result.content.filter((part) => part.type === "text").map((part) => part.text ?? "").join(`
@@ -33225,17 +34119,17 @@ ${warningStrings.map((w) => `  ${w}`).join(`
 async function resolveAstPaths(extCtx, paths) {
   if (isEmptyParam(paths) || !Array.isArray(paths))
     return;
-  return Promise.all(paths.filter((path3) => typeof path3 === "string").map((path3) => resolvePathArg(extCtx.cwd, path3)));
+  return Promise.all(paths.filter((path2) => typeof path2 === "string").map((path2) => resolvePathArg(extCtx.cwd, path2)));
 }
 async function assertAstPathsPermission(extCtx, paths, restrictToProjectRoot) {
   if (paths === undefined || paths.length === 0)
     return;
   const checked = new Set;
-  for (const path3 of paths) {
-    if (checked.has(path3))
+  for (const path2 of paths) {
+    if (checked.has(path2))
       continue;
-    checked.add(path3);
-    await assertExternalDirectoryPermission(extCtx, path3, { restrictToProjectRoot });
+    checked.add(path2);
+    await assertExternalDirectoryPermission(extCtx, path2, { restrictToProjectRoot });
   }
 }
 function buildAstSearchSections(payload, theme) {
@@ -33417,7 +34311,7 @@ function registerAstTools(pi, ctx, surface) {
 }
 
 // src/tools/bash.ts
-import * as fs4 from "node:fs/promises";
+import * as fs3 from "node:fs/promises";
 import { Container as Container3, Spacer as Spacer3, Text as Text3 } from "@earendil-works/pi-tui";
 import { Type as Type4 } from "typebox";
 var BASH_WAIT_POLL_INTERVAL_MS = 100;
@@ -33433,7 +34327,7 @@ function resolveForegroundWaitMs(configured) {
   }
   return configured;
 }
-var BASH_TRANSPORT_TIMEOUT_MS = 30000;
+var BASH_TRANSPORT_TIMEOUT_MS2 = 30000;
 var DEFAULT_HARD_TIMEOUT_MS = 30 * 60 * 1000;
 var BASH_TRANSPORT_MARGIN_MS = 1e4;
 function orchestratedTransportTimeoutMs(blockToCompletion, wait, effectiveTimeout, foregroundWaitMs) {
@@ -33444,7 +34338,7 @@ var BashBaseParams = {
   command: Type4.String({
     description: "Shell command to execute. Supports pipes, redirections, and shell syntax."
   }),
-  timeout: optionalInt(1, Number.MAX_SAFE_INTEGER),
+  timeout: optionalInt(1, Number.MAX_SAFE_INTEGER, "Hard kill timeout in milliseconds"),
   workdir: Type4.Optional(Type4.String({
     description: "Working directory for command execution. Relative paths resolve against the project root. Defaults to the current session's working directory."
   })),
@@ -33452,7 +34346,7 @@ var BashBaseParams = {
     description: "Human-readable description shown in UI logs. Helps users understand what the command does without reading shell syntax."
   })),
   wait: Type4.Optional(Type4.Boolean({
-    description: "When true, run in the foreground without auto-promoting and wait until the command finishes or reaches its timeout. Use only when you know the result is required before doing anything else."
+    description: "When true, run in the foreground without auto-promoting and wait until the command finishes or reaches its timeout; if you send a new message, the wait detaches to background. Use only when you know the result is required before doing anything else."
   }))
 };
 var BashBackgroundFlagParam = {
@@ -33469,8 +34363,8 @@ var BashPtyParams = {
   pty: Type4.Optional(Type4.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: optionalInt(1, 60),
-  ptyCols: optionalInt(1, 140)
+  ptyRows: optionalInt(1, 60, "PTY terminal height in rows (minimum 1, maximum 60)"),
+  ptyCols: optionalInt(1, 140, "PTY terminal width in columns (minimum 1, maximum 140)")
 };
 var BashParams = Type4.Object({
   ...BashBaseParams,
@@ -33504,7 +34398,7 @@ var BashWatchParams = Type4.Object({
   }),
   pattern: Type4.Optional(Type4.Union([Type4.String(), Type4.Object({ regex: Type4.String() })])),
   background: Type4.Optional(Type4.Boolean()),
-  timeout_ms: optionalInt(1, MAX_BASH_STATUS_WAIT_TIMEOUT_MS),
+  timeout_ms: optionalInt(1, MAX_BASH_STATUS_WAIT_TIMEOUT_MS, "Maximum time to wait in milliseconds"),
   once: Type4.Optional(Type4.Boolean())
 });
 var BashWriteParams = Type4.Object({
@@ -33530,7 +34424,7 @@ function unavailableSnapshot() {
 }
 async function callBashBridge(bridge, command, params = {}, extCtx, options) {
   return await callBridge(bridge, command, params, extCtx, {
-    transportTimeoutMs: BASH_TRANSPORT_TIMEOUT_MS,
+    transportTimeoutMs: BASH_TRANSPORT_TIMEOUT_MS2,
     ...options,
     keepBridgeOnTimeout: true
   });
@@ -33561,7 +34455,7 @@ function registerBashTool(pi, ctx, aftSearchRegistered = false) {
   const searchSteer = aftSearchRegistered ? "use `aft_search` (concepts, identifiers, regex, literals), `read`, `aft_outline`, or `aft_zoom` instead" : "use the `grep` tool, `read`, `aft_outline`, or `aft_zoom` instead";
   const bashCfg = resolveBashConfig(ctx.config);
   const compressionSentence = bashCfg.compress ? " Output is compressed by default; pass `compressed: false` for raw output. Piped commands run verbatim and show the pipeline's output; for AFT's test/build summary, run the runner without `| head`, `| tail`, or `| grep`." : "";
-  const tasksSentence = bashCfg.background ? ' Commands run in the foreground and return inline; `wait: true` blocks until a long command finishes instead of auto-promoting — use it when you need the result before doing anything else; keep it off otherwise so auto-promote can remind you while you work. Use `background: true` yourself ONLY when you have other useful work to do while it runs; then `bash_watch` waits on the task (sync blocks until exit/pattern, async notifies) and `bash_status` peeks at it — never background a command and immediately `bash_watch` it (that wastes a turn for what foreground returns in one), and never loop `bash_status` to wait. `pty: true` runs interactive programs (REPLs, TUIs), implies background, and is driven with `bash_status({ output_mode: "screen" })` plus `bash_write`.' : " Commands run in the foreground to completion; `timeout` is the hard kill cap (default 30 minutes).";
+  const tasksSentence = bashCfg.background ? ' Commands run in the foreground and return inline; `wait: true` blocks until a long command finishes instead of auto-promoting, but detaches to background if you send a new message — use it when you need the result before doing anything else; keep it off otherwise so auto-promote can remind you while you work. Use `background: true` yourself ONLY when you have other useful work to do while it runs; then `bash_watch` waits on the task (sync blocks until exit/pattern, async notifies) and `bash_status` peeks at it — never background a command and immediately `bash_watch` it (that wastes a turn for what foreground returns in one), and never loop `bash_status` to wait. `pty: true` runs interactive programs (REPLs, TUIs), implies background, and is driven with `bash_status({ output_mode: "screen" })` plus `bash_write`.' : " Commands run in the foreground to completion; `timeout` is the hard kill cap (default 30 minutes).";
   pi.registerTool({
     name: "bash",
     label: "bash",
@@ -33835,7 +34729,7 @@ async function waitForBashStatus(ctx, bridge, extCtx, taskId, outputMode, waitFo
   let scanBaseOffset = 0;
   const bridgeOptions = {
     keepBridgeOnTimeout: true,
-    transportTimeoutMs: BASH_TRANSPORT_TIMEOUT_MS
+    transportTimeoutMs: BASH_TRANSPORT_TIMEOUT_MS2
   };
   if (waitFor?.kind === "regex") {
     await validateWaitRegex(bridge, extCtx, waitFor);
@@ -33946,7 +34840,7 @@ async function readNewTaskOutput(data, cursor) {
   };
 }
 async function readFileBytesFrom(outputPath, cursor) {
-  const handle = await fs4.open(outputPath, "r");
+  const handle = await fs3.open(outputPath, "r");
   try {
     const chunks = [];
     let offset = cursor;
@@ -34075,7 +34969,7 @@ async function formatPtyStatus(_extCtx, taskId, details, requestedOutputMode) {
     return `
 [PTY output path unavailable]`;
   const outputMode = requestedOutputMode ?? "screen";
-  const raw = outputMode === "raw" || outputMode === "both" ? await fs4.readFile(details.output_path) : undefined;
+  const raw = outputMode === "raw" || outputMode === "both" ? await fs3.readFile(details.output_path) : undefined;
   let suffix = "";
   if (outputMode === "raw") {
     suffix = raw && raw.length > 0 ? `
@@ -34196,12 +35090,12 @@ function registerConflictsTool(pi, ctx) {
     async execute(_toolCallId, params, _signal, _onUpdate, extCtx) {
       const bridge = bridgeFor(ctx, extCtx.cwd);
       const reqParams = {};
-      const path3 = params?.path;
-      if (typeof path3 === "string" && path3.trim() !== "") {
-        await assertExternalDirectoryPermission(extCtx, path3, {
+      const path2 = params?.path;
+      if (typeof path2 === "string" && path2.trim() !== "") {
+        await assertExternalDirectoryPermission(extCtx, path2, {
           restrictToProjectRoot: ctx.config.restrict_to_project_root ?? false
         });
-        reqParams.path = await resolvePathArg(extCtx.cwd, path3);
+        reqParams.path = await resolvePathArg(extCtx.cwd, path2);
       }
       const response = await callToolCall(bridge, "conflicts", reqParams, extCtx);
       if (response.success === false) {
@@ -34613,8 +35507,8 @@ function tier2SummaryPart(summary, key, label) {
   return `${label} ${status ?? "unavailable"}`;
 }
 function shortDupOccurrence(entry) {
-  const [path3] = entry.split(":");
-  return path3?.split("/").pop() ?? entry;
+  const [path2] = entry.split(":");
+  return path2?.split("/").pop() ?? entry;
 }
 function tier2TopPreview(summary, theme) {
   const lines = [];
@@ -34798,7 +35692,7 @@ function navigateParamsSchema() {
       description: "Source file containing the symbol (absolute or relative to project root)"
     }),
     symbol: Type9.String({ description: "Name of the symbol to analyze" }),
-    depth: optionalInt(1, Number.MAX_SAFE_INTEGER),
+    depth: optionalInt(1, Number.MAX_SAFE_INTEGER, "Maximum call-graph depth to traverse"),
     expression: Type9.Optional(Type9.String({ description: "Expression to track (required for trace_data)" })),
     toSymbol: Type9.Optional(Type9.String({
       description: "Target symbol for trace_to_symbol; the returned path ends here"
@@ -35235,9 +36129,9 @@ var RefactorParams = Type11.Object({
   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)
+  startLine: optionalInt(1, Number.MAX_SAFE_INTEGER, "1-based start line for extract"),
+  endLine: optionalInt(1, Number.MAX_SAFE_INTEGER, "1-based end line (inclusive) for extract"),
+  callSiteLine: optionalInt(1, Number.MAX_SAFE_INTEGER, "1-based call site line for inline")
 });
 function buildRefactorSections(args, payload, theme) {
   const response = asRecord3(payload);
@@ -35356,7 +36250,7 @@ function registerRefactorTool(pi, ctx) {
 import { StringEnum as StringEnum5 } from "@earendil-works/pi-ai";
 import { Type as Type12 } from "typebox";
 function responsePaths(response) {
-  return Array.isArray(response.paths) ? response.paths.filter((path3) => typeof path3 === "string" && path3.length > 0) : [];
+  return Array.isArray(response.paths) ? response.paths.filter((path2) => typeof path2 === "string" && path2.length > 0) : [];
 }
 var SafetyParams = Type12.Object({
   op: StringEnum5(["undo", "history", "checkpoint", "restore", "list"], {
@@ -35738,7 +36632,7 @@ function buildWorkflowHints(opts) {
   }
   if (hasBgBash) {
     sections.push([
-      `**Long-running commands** (builds, installs, full test suites): run them in the FOREGROUND — use \`${bashName}({ command, wait: true })\` when you know it is long and need the result before anything else; otherwise omit \`wait\` so auto-promote can hand you a reminder while you work.`,
+      `**Long-running commands** (builds, installs, full test suites): run them in the FOREGROUND — use \`${bashName}({ command, wait: true })\` when you know it is long and need the result before anything else; if you send a new message, the wait detaches to background; otherwise omit \`wait\` so auto-promote can hand you a reminder while you work.`,
       "- `background: true` is ONLY for when you have OTHER useful work to do while it runs: start it, do the other work, and the completion reminder delivers the result (or spawn a subagent for the side work). Do NOT background a command and then immediately `bash_watch` it — that spends a whole extra turn waiting for something foreground returns in one.",
       "- `bash_watch` is for blocking on an ALREADY-backgrounded task once you've run out of parallel work (sync — the user can interrupt), or reacting to a specific early output line (async: background:true + pattern). Never loop `bash_status` to wait — it's a one-shot inspector."
     ].join(`
@@ -35809,18 +36703,18 @@ function createVersionMismatchHandler(getPool, ensureCompatibleBinary = ensureBi
     const upgradePromise = (async () => {
       warn2(`WARNING: aft binary v${binaryVersion} is older than plugin v${minVersion}. ` + "Some features may not work. Attempting to download a compatible binary...");
       try {
-        const path3 = await ensureCompatibleBinary(`v${minVersion}`);
-        if (!path3) {
+        const path2 = await ensureCompatibleBinary(`v${minVersion}`);
+        if (!path2) {
           warn2(`Could not find or download v${minVersion}. Continuing with v${binaryVersion}.`);
           return null;
         }
         const pool = getPool();
         if (!pool) {
-          warn2(`Found/downloaded compatible binary at ${path3}, but bridge pool is not ready.`);
+          warn2(`Found/downloaded compatible binary at ${path2}, but bridge pool is not ready.`);
           return null;
         }
-        log2(`Found/downloaded compatible binary at ${path3}. Replacing running bridges...`);
-        const replaced = await pool.replaceBinary(path3);
+        log2(`Found/downloaded compatible binary at ${path2}. Replacing running bridges...`);
+        const replaced = await pool.replaceBinary(path2);
         log2("Binary replaced successfully. New bridges will use the updated binary.");
         return replaced;
       } catch (err) {
@@ -35842,12 +36736,14 @@ var PLUGIN_VERSION = (() => {
     return "0.0.0";
   }
 })();
-var ANNOUNCEMENT_VERSION = "0.46.0";
+var ANNOUNCEMENT_VERSION = "0.47.0";
 var ANNOUNCEMENT_FEATURES = [
-  "Search index changes persist on clean shutdown, so restarts and cross-worktree searches see current results.",
-  "Cross-project search: sessions can search sibling checkouts read-only, serving borrowed indexes with drift warnings instead of failing.",
-  "Duplicate detection requires a 10-line minimum span, ending flags on 3-4 line idiomatic blocks.",
-  "Pi edit tool supports batch edits[] arrays, matching OpenCode."
+  "Big background CPU cuts: semantic re-embeds coalesce behind a 15s quiet window instead of firing per edit, file-change processing is sliced and budgeted, and a callgraph resolver bug that could pin a core at 100% on cyclic barrel re-exports is fixed.",
+  "Faster search: indexed grep and glob skip a per-query filesystem walk (2-4x faster), and cross-project search reuses cached artifacts (~40x faster).",
+  "bash with wait:true now detaches to the background the moment you send a new message instead of blocking the conversation.",
+  "apply_patch failures show the nearest-miss file lines so a failed patch is fixable in one shot; batch edits support replaceAll per item.",
+  "Groovy, Gradle, and Jenkinsfile support in outline, zoom, search, and AST tools.",
+  "Fixed: LSP memory growth during repeated scoped diagnostics (#160), fresh LSP auto-installs picked up without restart (#153), and truthful delete results for symlinked directories and failed batches."
 ];
 var ANNOUNCEMENT_FOOTER = "Join us on Discord: https://discord.gg/DSa65w8wuf";
 var ALL_ONLY_TOOLS = new Set(["aft_callgraph", "aft_delete", "aft_move", "aft_refactor"]);
@@ -36044,6 +36940,7 @@ async function src_default(pi) {
   const configOverrides = buildConfigTierConfigureParams(projectRoot, {
     storage_dir: storageDir
   });
+  let lspInstallCompletion = null;
   try {
     const lspAutoInstall = config2.lsp?.auto_install ?? true;
     const lspGraceDays = config2.lsp?.grace_days ?? 7;
@@ -36073,10 +36970,24 @@ async function src_default(pi) {
     if (lspInflightInstalls.length > 0) {
       configOverrides.lsp_inflight_installs = lspInflightInstalls;
     }
-    if (npmResult.installsStarted > 0 || ghResult.installsStarted > 0) {
+    const installsWereStarted = npmResult.installsStarted > 0 || ghResult.installsStarted > 0;
+    if (installsWereStarted) {
       log2(`[lsp] auto-install: ${npmResult.installsStarted} npm + ${ghResult.installsStarted} github install(s) running in background`);
     }
-    Promise.all([npmResult.installsComplete, ghResult.installsComplete]).then(() => {
+    const installCompletion = Promise.all([npmResult.installsComplete, ghResult.installsComplete]).then(() => {
+      if (installsWereStarted) {
+        const updatedPaths = [
+          ...new Set([...npmResult.getCachedBinDirs(), ...ghResult.getCachedBinDirs()])
+        ];
+        if (updatedPaths.length > 0) {
+          configOverrides.lsp_paths_extra = updatedPaths;
+        } else {
+          delete configOverrides.lsp_paths_extra;
+        }
+        return updatedPaths;
+      }
+      return null;
+    }).then((updatedPaths) => {
       const actionable = [...npmResult.skipped, ...ghResult.skipped].filter((s) => {
         const r = s.reason.toLowerCase();
         if (r === "auto_install: false")
@@ -36091,16 +37002,20 @@ async function src_default(pi) {
           return false;
         return true;
       });
-      if (actionable.length === 0)
-        return;
-      const lines = actionable.map((s) => `  • ${s.id}: ${s.reason}`).join(`
+      if (actionable.length > 0) {
+        const lines = actionable.map((s) => `  • ${s.id}: ${s.reason}`).join(`
 `);
-      warn2(`[lsp] skipped or failed to install ${actionable.length} server(s):
+        warn2(`[lsp] skipped or failed to install ${actionable.length} server(s):
 ${lines}
 ` + 'Pin a working version with `lsp.versions: { "<package>": "<version>" }` if grace is blocking, ' + "or set `lsp.auto_install: false` to suppress.");
+      }
+      return updatedPaths;
     }).catch((err) => {
       warn2(`[lsp] install-summary aggregation failed: ${err}`);
+      return null;
     });
+    if (installsWereStarted)
+      lspInstallCompletion = installCompletion;
   } catch (err) {
     warn2(`[lsp] auto-install setup failed: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -36171,6 +37086,17 @@ ${lines}
       });
     }
   });
+  if (lspInstallCompletion) {
+    lspInstallCompletion.then((updatedPaths) => {
+      if (!updatedPaths)
+        return;
+      pushLspPathsAfterAutoInstall(pool, projectRoot, updatedPaths).then(() => {
+        log2(`[lsp] lsp_paths_extra updated after auto-install: ${updatedPaths.length} dirs pushed to live bridges`);
+      }).catch((err) => {
+        warn2(`[lsp] live bridge lsp_paths_extra update failed: ${err}`);
+      });
+    });
+  }
   pool.setConfigureOverride("harness", "pi");
   pool.setConfigureOverride("aft_search_registered", resolveToolSurface(config2).semantic);
   const ctx = { pool, config: config2, storageDir };
@@ -36283,7 +37209,9 @@ ${lines}
     }
   });
   pi.on("input", (_event, extCtx) => {
-    signalSyncWatchAbort(resolveSessionId(extCtx));
+    const sessionId = resolveSessionId(extCtx);
+    signalSyncWatchAbort(sessionId);
+    signalBashWaitDetachForProject(pool, extCtx.cwd, sessionId);
   });
   const unregisterShutdownCleanup = registerShutdownCleanup(async () => {
     try {