@cortexkit/aft 0.46.0 → 0.47.0

package/dist/index.js

@@ -1895,6 +1895,21 @@ function isEmptyParam(value) {
   return false;
 }
 
+// ../aft-bridge/dist/config-keys.js
+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;
+}
+var OPENCODE_ONLY_KEYS, PI_ONLY_KEYS;
+var init_config_keys = __esm(() => {
+  OPENCODE_ONLY_KEYS = ["hoist_builtin_tools", "auto_update"];
+  PI_ONLY_KEYS = [];
+});
+
 // ../aft-bridge/dist/config-tiers.js
 import { existsSync, readFileSync as readFileSync2 } from "node:fs";
 import { resolve as resolve2 } from "node:path";
@@ -2223,6 +2238,120 @@ var init_downloader = __esm(() => {
   DOWNLOAD_LOCK_STALE_MS = 10 * 60000;
 });
 
+// ../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";
+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;
+  }
+}
+var DEFAULT_LOG_BYTES, DEFAULT_LOG_GENERATIONS = 5;
+var init_durable_log = __esm(() => {
+  DEFAULT_LOG_BYTES = 20 * 1024 * 1024;
+});
+
 // ../aft-bridge/dist/edit-summary.js
 function formatEditSummary(data) {
   if (data.rolled_back === true) {
@@ -2308,27 +2437,27 @@ function stripJsoncSymbols(value) {
 
 // ../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 [
@@ -2337,10 +2466,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 {
@@ -2351,25 +2480,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;
@@ -2390,7 +2519,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;
@@ -2402,7 +2531,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 {}
 }
@@ -2412,8 +2541,8 @@ var init_paths = () => {};
 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 } 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";
 function copyToVersionedCache(npmBinaryPath, knownVersion) {
   try {
     const version = knownVersion ?? readBinaryVersion(npmBinaryPath);
@@ -2421,9 +2550,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)
@@ -2453,18 +2582,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) {
@@ -2583,7 +2712,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)
@@ -2631,28 +2760,28 @@ var init_resolver = __esm(() => {
 // ../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";
-function dataHome() {
+import { homedir as homedir8, tmpdir } from "node:os";
+import { basename, dirname as dirname3, join as join7, resolve as resolve4 } from "node:path";
+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 = "";
@@ -2781,8 +2910,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);
@@ -2803,8 +2932,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);
@@ -2927,7 +3056,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) => ({
@@ -2984,13 +3113,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;
   }
 }
@@ -3091,13 +3220,13 @@ var init_migration = __esm(() => {
 // ../aft-bridge/dist/npm-resolver.js
 import { execFileSync } from "node:child_process";
 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
   };
 }
@@ -3118,14 +3247,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;
@@ -3134,8 +3263,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));
@@ -3160,22 +3289,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);
   }
@@ -3185,12 +3314,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 };
   }
@@ -3226,7 +3355,7 @@ var init_npm_resolver = () => {};
 import { execFileSync as execFileSync2 } 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";
 function getPlatformInfo() {
@@ -3252,10 +3381,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) {
@@ -3285,9 +3414,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.`);
@@ -3306,7 +3435,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;
@@ -3343,7 +3472,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 });
     }
@@ -3388,7 +3517,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);
@@ -3427,6 +3556,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);
@@ -3440,10 +3580,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;
 }
@@ -3458,12 +3598,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 {
@@ -3472,7 +3612,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)}`);
@@ -3494,7 +3634,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;
@@ -3503,6 +3643,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;
     }
@@ -3530,7 +3674,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) {
@@ -3560,11 +3704,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}`);
@@ -3595,7 +3739,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}`);
@@ -3611,7 +3755,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}`);
     }
@@ -3620,11 +3764,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);
@@ -3635,7 +3779,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);
@@ -3660,8 +3804,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") {
@@ -3677,12 +3821,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)) {
@@ -3702,7 +3846,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}`);
@@ -3729,13 +3873,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;
@@ -3873,7 +4017,7 @@ function isProcessAlive(pid) {
 }
 function cleanupOnnxRuntime(storageDir) {
   try {
-    const ortBase = join8(storageDir, "onnxruntime");
+    const ortBase = join9(storageDir, "onnxruntime");
     if (existsSync6(ortBase)) {
       rmSync3(ortBase, { recursive: true, force: true });
     }
@@ -3975,10 +4119,10 @@ function projectRootKeyHash(dir) {
 var init_project_identity = () => {};
 
 // ../aft-bridge/dist/pool.js
-import { homedir as homedir9 } from "node:os";
+import { homedir as homedir10 } from "node:os";
 function canonicalHomeDir() {
   try {
-    const home = homedir9();
+    const home = homedir10();
     if (!home)
       return null;
     return canonicalizeProjectRoot(home);
@@ -4004,6 +4148,7 @@ class BridgePool {
   projectConfigLoader;
   logger;
   cleanupTimer = null;
+  shutdownCalled = false;
   constructor(binaryPath, options = {}, configOverrides = {}) {
     this.binaryPath = binaryPath;
     this.maxPoolSize = options.maxPoolSize ?? DEFAULT_MAX_POOL_SIZE;
@@ -4025,12 +4170,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())
@@ -4038,7 +4182,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) {
@@ -4048,15 +4206,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() });
@@ -4106,6 +4256,7 @@ class BridgePool {
   }
   async closeSession(_projectRoot, _session) {}
   async shutdown() {
+    this.shutdownCalled = true;
     if (this.cleanupTimer) {
       clearInterval(this.cleanupTimer);
       this.cleanupTimer = null;
@@ -4118,6 +4269,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()) {
@@ -4127,6 +4281,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) {
@@ -4158,6 +4318,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;
   }
@@ -4188,7 +4378,186 @@ var init_pool = __esm(() => {
   };
 });
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.3.4/node_modules/@cortexkit/subc-client/dist/auth.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?.();
+  }
+}
+var init_revivable_transport = __esm(() => {
+  init_active_logger();
+  init_project_identity();
+});
+
+// ../../node_modules/.bun/@cortexkit+subc-client@0.5.0/node_modules/@cortexkit/subc-client/dist/auth.js
 import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
 function computeProof(key, domain, clientNonce, serverNonce, daemonId) {
   const mac = createHmac("sha256", Buffer.from(key));
@@ -4249,7 +4618,132 @@ var init_auth = __esm(() => {
   };
 });
 
-// ../../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/envelope.js
+function isPureHeader(ty) {
+  return ty === FrameType.Cancel || ty === FrameType.Ping || ty === FrameType.Pong || ty === FrameType.Goodbye;
+}
+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;
+}
+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;
+}
+var PROTOCOL_VERSION = 2, HEADER_LEN = 21, FROZEN_PREFIX_LEN = 5, MAX_FRAME_BODY_LEN, FrameType, FRAME_TYPE_MAX, Priority, AdmissionClass, FLAG_BINARY = 1, FLAG_PRIORITY_MASK = 6, FLAG_PRIORITY_SHIFT = 1, FLAG_LAST = 8, FLAG_ADMISSION_MASK = 48, FLAG_ADMISSION_SHIFT = 4, FLAG_RESERVED_MASK = 192, DecodeError;
+var init_envelope = __esm(() => {
+  MAX_FRAME_BODY_LEN = 64 * 1024 * 1024;
+  (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 = {}));
+  FRAME_TYPE_MAX = FrameType.Goodbye;
+  (function(Priority2) {
+    Priority2[Priority2["Passive"] = 0] = "Passive";
+    Priority2[Priority2["Interactive"] = 1] = "Interactive";
+    Priority2[Priority2["Background"] = 2] = "Background";
+  })(Priority || (Priority = {}));
+  (function(AdmissionClass2) {
+    AdmissionClass2[AdmissionClass2["Normal"] = 0] = "Normal";
+    AdmissionClass2[AdmissionClass2["Expedite"] = 1] = "Expedite";
+    AdmissionClass2[AdmissionClass2["Sheddable"] = 2] = "Sheddable";
+  })(AdmissionClass || (AdmissionClass = {}));
+  DecodeError = class DecodeError extends Error {
+    code;
+    constructor(message, code) {
+      super(message);
+      this.code = code;
+      this.name = "DecodeError";
+    }
+  };
+});
+
+// ../../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";
 function toBytes(value, field) {
   if (!Array.isArray(value) || value.some((n) => typeof n !== "number")) {
@@ -4274,8 +4768,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`);
   }
@@ -4289,6 +4783,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");
@@ -4313,116 +4811,59 @@ async function readConnectionFile(path2) {
 }
 var SCHEMA_VERSION = 1, MIN_KEY_LEN = 32, DAEMON_ID_LEN = 16, ConnectionFileError;
 var init_connection_file = __esm(() => {
+  init_envelope();
   ConnectionFileError = class ConnectionFileError extends Error {
   };
 });
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.3.4/node_modules/@cortexkit/subc-client/dist/envelope.js
-function isPureHeader(ty) {
-  return ty === FrameType.Cancel || ty === FrameType.Ping || ty === FrameType.Pong || ty === FrameType.Goodbye;
-}
-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;
-}
-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)}`);
-  }
-  if (isPureHeader(ty) && len !== 0) {
-    throw new DecodeError(`pure-header frame ${FrameType[ty]} declared non-zero body length ${len}`);
-  }
-  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 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`);
-  }
-  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;
-}
-var PROTOCOL_VERSION = 1, HEADER_LEN = 17, FROZEN_PREFIX_LEN = 5, MAX_FRAME_BODY_LEN, FrameType, FRAME_TYPE_MAX, Priority, FLAG_BINARY = 1, FLAG_PRIORITY_MASK = 6, FLAG_PRIORITY_SHIFT = 1, FLAG_LAST = 8, FLAG_RESERVED_MASK = 240, DecodeError;
-var init_envelope = __esm(() => {
-  MAX_FRAME_BODY_LEN = 64 * 1024 * 1024;
-  (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 = {}));
-  FRAME_TYPE_MAX = FrameType.Goodbye;
-  (function(Priority2) {
-    Priority2[Priority2["Passive"] = 0] = "Passive";
-    Priority2[Priority2["Interactive"] = 1] = "Interactive";
-    Priority2[Priority2["Background"] = 2] = "Background";
-  })(Priority || (Priority = {}));
-  DecodeError = class DecodeError extends Error {
+// ../../node_modules/.bun/@cortexkit+subc-client@0.5.0/node_modules/@cortexkit/subc-client/dist/route-handle.js
+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);
+  }
+  static create(channel, epoch, token) {
+    return new RouteHandle(channel, epoch, token);
+  }
+}
+function createRouteHandle(channel, epoch, token) {
+  const factory = RouteHandle;
+  return factory.create(channel, epoch, token);
+}
+function newConnectionToken() {
+  return Object.freeze({});
+}
+function belongsToConnection(handle, token) {
+  return connectionToken.get(handle) === token;
+}
+function sameRouteHandle(left, right) {
+  return left === right;
+}
+var connectionToken, StaleRouteHandleError;
+var init_route_handle = __esm(() => {
+  connectionToken = new WeakMap;
+  StaleRouteHandleError = 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";
+    }
   };
 });
 
-// ../../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 SubcSocket {
@@ -4471,6 +4912,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"));
@@ -4593,6 +5052,7 @@ class SubcSocket {
 }
 var SocketClosedError, SocketTimeoutError, SocketWriteNotQueuedError, SocketWriteQueuedError;
 var init_socket = __esm(() => {
+  init_envelope();
   SocketClosedError = class SocketClosedError extends Error {
   };
   SocketTimeoutError = class SocketTimeoutError extends Error {
@@ -4613,7 +5073,7 @@ var init_socket = __esm(() => {
   };
 });
 
-// ../../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
 import { promises as fs2 } from "node:fs";
 import { debuglog } from "node:util";
 
@@ -4623,7 +5083,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;
@@ -4651,40 +5115,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);
@@ -4700,29 +5195,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;
@@ -4730,45 +5227,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();
           };
         }));
@@ -4778,11 +5307,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);
@@ -4797,37 +5336,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;
@@ -4843,59 +5393,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");
@@ -4911,15 +5469,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;
@@ -4936,44 +5492,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);
       }
     }
   }
@@ -5036,25 +5591,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) {
@@ -5068,28 +5625,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) {
+    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;
       }
     }
-  }
-  dispatch(frame) {
-    const key = `${frame.header.channel}:${frame.header.corr}`;
+    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:
@@ -5106,15 +5672,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)
@@ -5137,18 +5710,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) {
@@ -5176,6 +5747,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"));
   }
@@ -5245,11 +5854,15 @@ function causeMessage(cause) {
     return "";
   return `: ${cause instanceof Error ? cause.message : String(cause)}`;
 }
+function pendingKey(handle, corr) {
+  return handle ? `${handle.channel}:${handle.epoch}:${corr}` : `0:0:${corr}`;
+}
 var debug, DEFAULT_HANDSHAKE_TIMEOUT_MS = 1e4, DEFAULT_REQUEST_TIMEOUT_MS = 30000, TIMEOUT_ARBITRATION_GRACE_MS = 50, REQUEST_DEADLINE_MARKER = "request_deadline", DEADLINE_NO_DROP_CODE = "deadline_exceeded_no_drop_observed", ROUTE_OPEN_RETRY_DEADLINE_MS = 30000, BODY_READ_TIMEOUT_MS = 30000, EMPTY_BODY, DEFAULT_MANAGED_TARGET_KIND = "management_surface", SUBC_MODULE_ID_ENV = "SUBC_MODULE_ID", SUBC_LAUNCH_NONCE_ENV = "SUBC_LAUNCH_NONCE", DEFAULT_RECONNECT_BACKOFF, SubcCallError, SubcError;
 var init_client = __esm(() => {
   init_auth();
   init_connection_file();
   init_envelope();
+  init_route_handle();
   init_socket();
   debug = debuglog("subc-client");
   EMPTY_BODY = new Uint8Array(0);
@@ -5279,7 +5892,7 @@ var init_client = __esm(() => {
   };
 });
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.3.4/node_modules/@cortexkit/subc-client/dist/provider.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.5.0/node_modules/@cortexkit/subc-client/dist/provider.js
 import { Buffer as Buffer2 } from "node:buffer";
 
 class AsyncPermitPool {
@@ -5328,6 +5941,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;
@@ -5347,12 +5965,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");
@@ -5367,7 +6028,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();
@@ -5375,12 +6036,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);
@@ -5393,19 +6055,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 {
@@ -5417,28 +6077,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);
             }
           });
         }
@@ -5447,19 +6137,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())
@@ -5468,9 +6167,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;
@@ -5478,47 +6177,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)
@@ -5526,8 +6271,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();
@@ -5535,14 +6280,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)
@@ -5550,7 +6295,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)
@@ -5558,42 +6303,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))
@@ -5603,16 +6385,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)
@@ -5620,7 +6415,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) {
@@ -5631,10 +6426,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();
   }
@@ -5644,7 +6439,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();
@@ -5664,6 +6464,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;
@@ -5677,8 +6495,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];
@@ -5693,6 +6519,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))),
@@ -5710,7 +6537,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),
@@ -5749,14 +6576,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:
@@ -5903,6 +6733,7 @@ var init_provider = __esm(() => {
   init_client();
   init_connection_file();
   init_envelope();
+  init_route_handle();
   init_socket();
   SubcProviderError = class SubcProviderError extends Error {
     code;
@@ -5913,9 +6744,10 @@ var init_provider = __esm(() => {
   };
 });
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.3.4/node_modules/@cortexkit/subc-client/dist/index.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.5.0/node_modules/@cortexkit/subc-client/dist/index.js
 var init_dist = __esm(() => {
   init_client();
+  init_route_handle();
   init_connection_file();
   init_envelope();
   init_auth();
@@ -5932,15 +6764,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();
@@ -5969,9 +6803,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);
@@ -5979,12 +6813,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();
         });
@@ -6004,7 +6838,7 @@ class BgSubscription {
           attempt = 0;
       } finally {
         this.current = null;
-        safeCloseRoute(client, channel);
+        safeCloseRoute(client, route);
       }
       await this.backoff(attempt++);
     }
@@ -6017,12 +6851,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 {}
@@ -6106,6 +6940,7 @@ class SubcTransportPool {
   harness;
   connectionFile;
   handshakeTimeoutMs;
+  consumerIdentity;
   connectFn;
   onBgEventsNudge;
   bgBackoffSleep;
@@ -6119,6 +6954,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)));
@@ -6141,6 +6977,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);
   }
@@ -6171,7 +7012,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");
           }
@@ -6197,29 +7038,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;
@@ -6261,24 +7102,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) {
@@ -6292,7 +7135,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)
@@ -6303,7 +7146,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) {
@@ -6324,9 +7167,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 = [];
@@ -6350,10 +7197,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) {
@@ -6382,9 +7229,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 {}
     }
   }
@@ -6485,18 +7332,25 @@ function formatReadFooter(agentSpecifiedRange, data, options) {
 }
 
 // ../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);
@@ -6507,6 +7361,7 @@ async function createAftTransportPool(opts) {
     return new SubcTransportPool({
       connectionFile,
       harness: opts.harness,
+      consumerIdentity: opts.subcConsumerIdentity,
       onBgEventsNudge: opts.onBgEventsNudge
     });
   }
@@ -6514,6 +7369,7 @@ async function createAftTransportPool(opts) {
 }
 var init_transport_factory = __esm(() => {
   init_pool();
+  init_revivable_transport();
   init_subc_transport();
 });
 
@@ -6631,6 +7487,7 @@ __export(exports_dist, {
   timeoutForCommand: () => timeoutForCommand,
   tagStderrLine: () => tagStderrLine,
   stripJsoncSymbols: () => stripJsoncSymbols,
+  stripHarnessSpecificConfigKeys: () => stripHarnessSpecificConfigKeys,
   statusBarLine: () => statusBarLine,
   sleep: () => sleep,
   shouldShowAnnouncement: () => shouldShowAnnouncement,
@@ -6645,6 +7502,8 @@ __export(exports_dist, {
   resolveCortexKitProjectConfigPath: () => resolveCortexKitProjectConfigPath,
   resolveCortexKitConfigPaths: () => resolveCortexKitConfigPaths,
   resolveBashKillTimeout: () => resolveBashKillTimeout,
+  resolveAftStorageRoot: () => resolveAftStorageRoot,
+  resolveAftLogPath: () => resolveAftLogPath,
   repairRootScopedStorageFile: () => repairRootScopedStorageFile,
   readConfigTiers: () => readConfigTiers,
   projectRootKeyHash: () => projectRootKeyHash,
@@ -6702,11 +7561,17 @@ __export(exports_dist, {
   __onnxTest__: () => __test__,
   SubcTransportPool: () => SubcTransportPool,
   STATUS_BAR_HEARTBEAT_CALLS: () => STATUS_BAR_HEARTBEAT_CALLS,
+  RotatingLogSink: () => RotatingLogSink,
+  RevivableTransportPool: () => RevivableTransportPool,
   PLATFORM_ASSET_MAP: () => PLATFORM_ASSET_MAP,
   PLATFORM_ARCH_MAP: () => PLATFORM_ARCH_MAP,
   PLAIN_CALLGRAPH_THEME: () => PLAIN_CALLGRAPH_THEME,
+  PI_ONLY_KEYS: () => PI_ONLY_KEYS,
+  OPENCODE_ONLY_KEYS: () => OPENCODE_ONLY_KEYS,
   LONG_RUNNING_COMMAND_TIMEOUT_MS: () => LONG_RUNNING_COMMAND_TIMEOUT_MS,
   HomeProjectRootError: () => HomeProjectRootError,
+  DEFAULT_LOG_GENERATIONS: () => DEFAULT_LOG_GENERATIONS,
+  DEFAULT_LOG_BYTES: () => DEFAULT_LOG_BYTES,
   BridgeTransportTimeoutError: () => BridgeTransportTimeoutError,
   BridgePool: () => BridgePool,
   BinaryBridge: () => BinaryBridge
@@ -6717,8 +7582,10 @@ var init_dist2 = __esm(() => {
   init_bridge();
   init_callgraph_format();
   init_command_timeouts();
+  init_config_keys();
   init_config_tiers();
   init_downloader();
+  init_durable_log();
   init_migration();
   init_npm_resolver();
   init_onnx_runtime();
@@ -6727,70 +7594,70 @@ var init_dist2 = __esm(() => {
   init_pool();
   init_project_identity();
   init_resolver();
+  init_revivable_transport();
   init_subc_transport();
   init_transport_factory();
 });
 
 // src/lib/paths.ts
-import { homedir as homedir11, tmpdir as tmpdir2 } from "node:os";
-import { join as join10 } from "node:path";
+import { homedir as homedir12 } from "node:os";
+import { join as join11 } from "node:path";
 function getAftBinaryCacheDir() {
   if (process.env.AFT_CACHE_DIR) {
-    return join10(process.env.AFT_CACHE_DIR, "bin");
+    return join11(process.env.AFT_CACHE_DIR, "bin");
   }
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join10(homedir11(), "AppData", "Local");
-    return join10(base2, "aft", "bin");
+    const base2 = localAppData || join11(homedir12(), "AppData", "Local");
+    return join11(base2, "aft", "bin");
   }
-  const base = process.env.XDG_CACHE_HOME || join10(homedir11(), ".cache");
-  return join10(base, "aft", "bin");
+  const base = process.env.XDG_CACHE_HOME || join11(homedir12(), ".cache");
+  return join11(base, "aft", "bin");
 }
 function getAftBinaryName() {
   return process.platform === "win32" ? "aft.exe" : "aft";
 }
 function getAftLspPackagesDir() {
   if (process.env.AFT_CACHE_DIR) {
-    return join10(process.env.AFT_CACHE_DIR, "lsp-packages");
+    return join11(process.env.AFT_CACHE_DIR, "lsp-packages");
   }
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join10(homedir11(), "AppData", "Local");
-    return join10(base2, "aft", "lsp-packages");
+    const base2 = localAppData || join11(homedir12(), "AppData", "Local");
+    return join11(base2, "aft", "lsp-packages");
   }
-  const base = process.env.XDG_CACHE_HOME || join10(homedir11(), ".cache");
-  return join10(base, "aft", "lsp-packages");
+  const base = process.env.XDG_CACHE_HOME || join11(homedir12(), ".cache");
+  return join11(base, "aft", "lsp-packages");
 }
 function getAftLspBinariesDir() {
   if (process.env.AFT_CACHE_DIR) {
-    return join10(process.env.AFT_CACHE_DIR, "lsp-binaries");
+    return join11(process.env.AFT_CACHE_DIR, "lsp-binaries");
   }
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join10(homedir11(), "AppData", "Local");
-    return join10(base2, "aft", "lsp-binaries");
+    const base2 = localAppData || join11(homedir12(), "AppData", "Local");
+    return join11(base2, "aft", "lsp-binaries");
   }
-  const base = process.env.XDG_CACHE_HOME || join10(homedir11(), ".cache");
-  return join10(base, "aft", "lsp-binaries");
+  const base = process.env.XDG_CACHE_HOME || join11(homedir12(), ".cache");
+  return join11(base, "aft", "lsp-binaries");
 }
-function homeDir3() {
+function homeDir4() {
   if (process.platform === "win32")
-    return process.env.USERPROFILE || process.env.HOME || homedir11();
-  return process.env.HOME || homedir11();
+    return process.env.USERPROFILE || process.env.HOME || homedir12();
+  return process.env.HOME || homedir12();
 }
-function dataHome2() {
+function dataHome3() {
   if (process.env.XDG_DATA_HOME)
     return process.env.XDG_DATA_HOME;
   if (process.platform === "win32") {
-    return process.env.LOCALAPPDATA || process.env.APPDATA || join10(homeDir3(), "AppData", "Local");
+    return process.env.LOCALAPPDATA || process.env.APPDATA || join11(homeDir4(), "AppData", "Local");
   }
-  return join10(homeDir3(), ".local", "share");
+  return join11(homeDir4(), ".local", "share");
 }
 function getCortexKitStorageRoot() {
-  return join10(dataHome2(), "cortexkit", "aft");
-}
-function getTmpLogPath(filename) {
-  return join10(tmpdir2(), filename);
+  if (process.env.AFT_CACHE_DIR)
+    return join11(process.env.AFT_CACHE_DIR, "aft");
+  return join11(dataHome3(), "cortexkit", "aft");
 }
 var init_paths2 = () => {};
 
@@ -6798,8 +7665,8 @@ var init_paths2 = () => {};
 import { execSync as execSync2, spawnSync as spawnSync3 } from "node:child_process";
 import { existsSync as existsSync7 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import { homedir as homedir12 } from "node:os";
-import { join as join11 } from "node:path";
+import { homedir as homedir13 } from "node:os";
+import { join as join12 } from "node:path";
 async function loadPluginVersion() {
   try {
     const bridge = await Promise.resolve().then(() => (init_dist2(), exports_dist));
@@ -6921,7 +7788,7 @@ function aftBinaryCandidates(preferredVersion) {
   const candidates = [];
   if (preferredVersion) {
     const tag = preferredVersion.startsWith("v") ? preferredVersion : `v${preferredVersion}`;
-    pushCandidate(candidates, join11(getAftBinaryCacheDir(), tag, getAftBinaryName()));
+    pushCandidate(candidates, join12(getAftBinaryCacheDir(), tag, getAftBinaryName()));
   }
   const key = platformKey2();
   if (key) {
@@ -6944,7 +7811,7 @@ function aftBinaryCandidates(preferredVersion) {
       }
     }
   } catch {}
-  pushCandidate(candidates, join11(homedir12(), ".cargo", "bin", getAftBinaryName()));
+  pushCandidate(candidates, join12(homedir13(), ".cargo", "bin", getAftBinaryName()));
   return candidates;
 }
 function findAftBinary(preferredVersion) {
@@ -6960,21 +7827,21 @@ var init_binary_probe = __esm(async () => {
 
 // src/lib/fs-util.ts
 import { existsSync as existsSync8, readdirSync as readdirSync3, statSync as statSync5 } from "node:fs";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 function dirSize(path2) {
   if (!existsSync8(path2)) {
     return 0;
   }
-  const stat = statSync5(path2);
-  if (stat.isFile()) {
-    return stat.size;
+  const stat2 = statSync5(path2);
+  if (stat2.isFile()) {
+    return stat2.size;
   }
-  if (!stat.isDirectory()) {
+  if (!stat2.isDirectory()) {
     return 0;
   }
   let total = 0;
   for (const entry of readdirSync3(path2)) {
-    total += dirSize(join12(path2, entry));
+    total += dirSize(join13(path2, entry));
   }
   return total;
 }
@@ -14597,10 +15464,10 @@ var require_stringify = __commonJS((exports, module) => {
     replacer = null;
     indent = EMPTY;
   };
-  var join13 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(one, gap)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two, gap)), gap) : EMPTY;
+  var join14 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(one, gap)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two, gap)), gap) : EMPTY;
   var join_content = (inside, value, gap) => {
     const comment = process_comments(value, PREFIX_BEFORE, gap + indent, true);
-    return join13(comment, inside, gap);
+    return join14(comment, inside, gap);
   };
   var stringify_string = (holder, key, value) => {
     const raw = get_raw_string_literal(holder, key);
@@ -14622,13 +15489,13 @@ var require_stringify = __commonJS((exports, module) => {
       if (i !== 0) {
         inside += COMMA;
       }
-      const before = join13(after_comma, process_comments(value, BEFORE(i), deeper_gap), deeper_gap);
+      const before = join14(after_comma, process_comments(value, BEFORE(i), deeper_gap), deeper_gap);
       inside += before || LF + deeper_gap;
       inside += stringify(i, value, deeper_gap) || STR_NULL;
       inside += process_comments(value, AFTER_VALUE(i), deeper_gap);
       after_comma = process_comments(value, AFTER(i), deeper_gap);
     }
-    inside += join13(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join14(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
     return BRACKET_OPEN + join_content(inside, value, gap) + BRACKET_CLOSE;
   };
   var object_stringify = (value, gap) => {
@@ -14649,13 +15516,13 @@ var require_stringify = __commonJS((exports, module) => {
         inside += COMMA;
       }
       first = false;
-      const before = join13(after_comma, process_comments(value, BEFORE(key), deeper_gap), deeper_gap);
+      const before = join14(after_comma, process_comments(value, BEFORE(key), deeper_gap), deeper_gap);
       inside += before || LF + deeper_gap;
       inside += quote(key) + process_comments(value, AFTER_PROP(key), deeper_gap) + COLON + process_comments(value, AFTER_COLON(key), deeper_gap) + SPACE + sv + process_comments(value, AFTER_VALUE(key), deeper_gap);
       after_comma = process_comments(value, AFTER(key), deeper_gap);
     };
     keys.forEach(iteratee);
-    inside += join13(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join14(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
     return CURLY_BRACKET_OPEN + join_content(inside, value, gap) + CURLY_BRACKET_CLOSE;
   };
   function stringify(key, holder, gap) {
@@ -14749,7 +15616,7 @@ var require_src2 = __commonJS((exports, module) => {
 
 // src/lib/jsonc.ts
 import { existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname5 } from "node:path";
+import { dirname as dirname6 } from "node:path";
 function detectJsoncFile(configDir, baseName) {
   const jsoncPath = `${configDir}/${baseName}.jsonc`;
   const jsonPath = `${configDir}/${baseName}.json`;
@@ -14777,7 +15644,7 @@ function readJsoncFile(path2) {
   }
 }
 function writeJsoncFile(path2, value, format = "json") {
-  mkdirSync6(dirname5(path2), { recursive: true });
+  mkdirSync6(dirname6(path2), { recursive: true });
   const serialized = format === "jsonc" ? import_comment_json.stringify(value, null, 2) : JSON.stringify(value, null, 2);
   writeFileSync4(path2, `${serialized}
 `);
@@ -14837,25 +15704,25 @@ var init_self_version = () => {};
 // src/adapters/opencode.ts
 import { execSync as execSync3 } from "node:child_process";
 import { existsSync as existsSync10, readFileSync as readFileSync8, rmSync as rmSync4, statSync as statSync6 } from "node:fs";
-import { homedir as homedir13 } from "node:os";
-import { dirname as dirname6, join as join13, parse, resolve as resolve7 } from "node:path";
+import { homedir as homedir14 } from "node:os";
+import { dirname as dirname7, join as join14, parse, resolve as resolve7 } from "node:path";
 import { fileURLToPath } from "node:url";
 function getOpenCodeConfigDir() {
   const envDir = process.env.OPENCODE_CONFIG_DIR?.trim();
   if (envDir)
     return resolve7(envDir);
-  const xdg = process.env.XDG_CONFIG_HOME || join13(homedir13(), ".config");
-  return join13(xdg, "opencode");
+  const xdg = process.env.XDG_CONFIG_HOME || join14(homedir14(), ".config");
+  return join14(xdg, "opencode");
 }
 function getOpenCodeCacheDir() {
   const xdg = process.env.XDG_CACHE_HOME;
   if (xdg)
-    return join13(xdg, "opencode");
+    return join14(xdg, "opencode");
   if (process.platform === "win32") {
-    const localAppData = process.env.LOCALAPPDATA ?? join13(homedir13(), "AppData", "Local");
-    return join13(localAppData, "opencode");
+    const localAppData = process.env.LOCALAPPDATA ?? join14(homedir14(), "AppData", "Local");
+    return join14(localAppData, "opencode");
   }
-  return join13(homedir13(), ".cache", "opencode");
+  return join14(homedir14(), ".cache", "opencode");
 }
 function hasOpenCodeCli() {
   try {
@@ -14868,12 +15735,12 @@ function hasOpenCodeCli() {
 function openCodeDesktopAppExists() {
   const candidates = [];
   if (process.platform === "darwin") {
-    candidates.push("/Applications/OpenCode.app", "/Applications/OpenCode Beta.app", join13(homedir13(), "Applications", "OpenCode.app"), join13(homedir13(), "Applications", "OpenCode Beta.app"));
+    candidates.push("/Applications/OpenCode.app", "/Applications/OpenCode Beta.app", join14(homedir14(), "Applications", "OpenCode.app"), join14(homedir14(), "Applications", "OpenCode Beta.app"));
   } else if (process.platform === "win32") {
-    const localAppData = process.env.LOCALAPPDATA ?? join13(homedir13(), "AppData", "Local");
-    candidates.push(join13(localAppData, "Programs", "opencode"), join13(localAppData, "opencode"));
+    const localAppData = process.env.LOCALAPPDATA ?? join14(homedir14(), "AppData", "Local");
+    candidates.push(join14(localAppData, "Programs", "opencode"), join14(localAppData, "opencode"));
   } else {
-    candidates.push("/opt/OpenCode", "/usr/lib/opencode", join13(homedir13(), ".local", "share", "applications", "opencode.desktop"));
+    candidates.push("/opt/OpenCode", "/usr/lib/opencode", join14(homedir14(), ".local", "share", "applications", "opencode.desktop"));
   }
   return candidates.some((p) => {
     try {
@@ -14902,15 +15769,15 @@ function pathPointsToOurPlugin(entry) {
   try {
     if (!existsSync10(fsPath))
       return false;
-    let searchDir = statSync6(fsPath).isDirectory() ? fsPath : dirname6(fsPath);
+    let searchDir = statSync6(fsPath).isDirectory() ? fsPath : dirname7(fsPath);
     let pkgJsonPath = null;
     while (true) {
-      const candidate = join13(searchDir, "package.json");
+      const candidate = join14(searchDir, "package.json");
       if (existsSync10(candidate)) {
         pkgJsonPath = candidate;
         break;
       }
-      const parent = dirname6(searchDir);
+      const parent = dirname7(searchDir);
       if (parent === searchDir || searchDir === parse(searchDir).root)
         break;
       searchDir = parent;
@@ -15076,10 +15943,10 @@ class OpenCodeAdapter {
     };
   }
   getPluginCacheInfo() {
-    const path2 = join13(getOpenCodeCacheDir(), "packages", PLUGIN_ENTRY);
+    const path2 = join14(getOpenCodeCacheDir(), "packages", PLUGIN_ENTRY);
     let cached;
     try {
-      const installedPkgPath = join13(path2, "node_modules", "@cortexkit", "aft-opencode", "package.json");
+      const installedPkgPath = join14(path2, "node_modules", "@cortexkit", "aft-opencode", "package.json");
       if (existsSync10(installedPkgPath)) {
         const pkg = JSON.parse(readFileSync8(installedPkgPath, "utf-8"));
         cached = typeof pkg.version === "string" ? pkg.version : undefined;
@@ -15098,7 +15965,7 @@ class OpenCodeAdapter {
     return getCortexKitStorageRoot();
   }
   getLogFile() {
-    return getTmpLogPath("aft-plugin.log");
+    return resolveAftLogPath("aft-plugin.log");
   }
   getInstallHint() {
     return "Install OpenCode: https://opencode.ai/docs/install";
@@ -15140,11 +16007,11 @@ class OpenCodeAdapter {
   describeStorageSubtrees() {
     const storage = this.getStorageDir();
     return {
-      index: dirSize(join13(storage, "index")),
-      semantic: dirSize(join13(storage, "semantic")),
-      backups: dirSize(join13(storage, "backups")),
-      url_cache: dirSize(join13(storage, "url_cache")),
-      onnxruntime: dirSize(join13(storage, "onnxruntime"))
+      index: dirSize(join14(storage, "index")),
+      semantic: dirSize(join14(storage, "semantic")),
+      backups: dirSize(join14(storage, "backups")),
+      url_cache: dirSize(join14(storage, "url_cache")),
+      onnxruntime: dirSize(join14(storage, "onnxruntime"))
     };
   }
 }
@@ -15161,15 +16028,15 @@ var init_opencode = __esm(() => {
 // src/adapters/pi.ts
 import { execSync as execSync4, spawnSync as spawnSync4 } from "node:child_process";
 import { existsSync as existsSync11, readFileSync as readFileSync9 } from "node:fs";
-import { homedir as homedir14 } from "node:os";
-import { join as join14 } from "node:path";
+import { homedir as homedir15 } from "node:os";
+import { join as join15 } from "node:path";
 function getPiAgentDir() {
   const envHome = process.platform === "win32" ? process.env.USERPROFILE : process.env.HOME;
-  const home = envHome && envHome.length > 0 ? envHome : homedir14();
-  return join14(home, ".pi", "agent");
+  const home = envHome && envHome.length > 0 ? envHome : homedir15();
+  return join15(home, ".pi", "agent");
 }
 function readPiExtensionIndex() {
-  const settingsPath = join14(getPiAgentDir(), "settings.json");
+  const settingsPath = join15(getPiAgentDir(), "settings.json");
   if (existsSync11(settingsPath)) {
     try {
       const raw = readFileSync9(settingsPath, "utf-8");
@@ -15183,10 +16050,10 @@ function readPiExtensionIndex() {
     } catch {}
   }
   const candidates = [
-    join14(getPiAgentDir(), "extensions.json"),
-    join14(getPiAgentDir(), "extensions.jsonc"),
-    join14(getPiAgentDir(), "config.json"),
-    join14(getPiAgentDir(), "config.jsonc")
+    join15(getPiAgentDir(), "extensions.json"),
+    join15(getPiAgentDir(), "extensions.jsonc"),
+    join15(getPiAgentDir(), "config.json"),
+    join15(getPiAgentDir(), "config.jsonc")
   ];
   for (const path2 of candidates) {
     if (!existsSync11(path2))
@@ -15222,14 +16089,14 @@ function piEntryMatchesAft(entry) {
   } else if (entry.startsWith("/")) {
     resolved = entry;
   } else if (entry.length > 0) {
-    resolved = join14(getPiAgentDir(), entry);
+    resolved = join15(getPiAgentDir(), entry);
   }
   if (!resolved)
     return false;
   try {
     if (!existsSync11(resolved))
       return false;
-    const pkgPath = join14(resolved, "package.json");
+    const pkgPath = join15(resolved, "package.json");
     if (!existsSync11(pkgPath))
       return false;
     const pkg = JSON.parse(readFileSync9(pkgPath, "utf-8"));
@@ -15281,7 +16148,7 @@ class PiAdapter {
     const aftConfigExists = existsSync11(aftConfigPath);
     return {
       configDir,
-      harnessConfig: index.path ?? join14(configDir, "extensions.json"),
+      harnessConfig: index.path ?? join15(configDir, "extensions.json"),
       harnessConfigFormat: index.path ? "json" : "none",
       aftConfig: aftConfigPath,
       aftConfigFormat: aftConfigExists ? "jsonc" : "none"
@@ -15326,8 +16193,8 @@ class PiAdapter {
   }
   getPluginCacheInfo() {
     const candidates = [
-      join14(getPiAgentDir(), "node_modules", "@cortexkit", "aft-pi", "package.json"),
-      join14(getPiAgentDir(), "extensions", "node_modules", "@cortexkit", "aft-pi", "package.json")
+      join15(getPiAgentDir(), "node_modules", "@cortexkit", "aft-pi", "package.json"),
+      join15(getPiAgentDir(), "extensions", "node_modules", "@cortexkit", "aft-pi", "package.json")
     ];
     for (const candidate of candidates) {
       if (!existsSync11(candidate))
@@ -15344,7 +16211,7 @@ class PiAdapter {
       } catch {}
     }
     return {
-      path: join14(getPiAgentDir(), "extensions"),
+      path: join15(getPiAgentDir(), "extensions"),
       exists: false
     };
   }
@@ -15352,7 +16219,7 @@ class PiAdapter {
     return getCortexKitStorageRoot();
   }
   getLogFile() {
-    return getTmpLogPath("aft-pi.log");
+    return resolveAftLogPath("aft-plugin.log");
   }
   getInstallHint() {
     return "Install Pi: https://github.com/badlogic/pi-mono";
@@ -15366,11 +16233,11 @@ class PiAdapter {
   describeStorageSubtrees() {
     const storage = this.getStorageDir();
     return {
-      index: dirSize(join14(storage, "index")),
-      semantic: dirSize(join14(storage, "semantic")),
-      backups: dirSize(join14(storage, "backups")),
-      url_cache: dirSize(join14(storage, "url_cache")),
-      onnxruntime: dirSize(join14(storage, "onnxruntime"))
+      index: dirSize(join15(storage, "index")),
+      semantic: dirSize(join15(storage, "semantic")),
+      backups: dirSize(join15(storage, "backups")),
+      url_cache: dirSize(join15(storage, "url_cache")),
+      onnxruntime: dirSize(join15(storage, "onnxruntime"))
     };
   }
 }
@@ -17394,28 +18261,30 @@ var init_aft_bridge = () => {};
 // src/commands/lsp.ts
 var exports_lsp = {};
 __export(exports_lsp, {
+  typescriptPackageWarning: () => typescriptPackageWarning,
   runLspDoctor: () => runLspDoctor,
   renderLspInspection: () => renderLspInspection,
   printLspDoctorHelp: () => printLspDoctorHelp,
   findProjectRootForFile: () => findProjectRootForFile
 });
 import { existsSync as existsSync12, readdirSync as readdirSync4, statSync as statSync7 } from "node:fs";
-import { dirname as dirname7, join as join15, resolve as resolve8 } from "node:path";
+import { createRequire as createRequire4 } from "node:module";
+import { dirname as dirname8, join as join16, resolve as resolve8 } from "node:path";
 function findProjectRootForFile(filePath, fallbackCwd = process.cwd()) {
   const resolvedFile = resolve8(fallbackCwd, filePath);
-  let dir = dirname7(resolvedFile);
+  let dir = dirname8(resolvedFile);
   try {
     if (existsSync12(resolvedFile) && statSync7(resolvedFile).isDirectory()) {
       dir = resolvedFile;
     }
   } catch {
-    dir = dirname7(resolvedFile);
+    dir = dirname8(resolvedFile);
   }
   while (true) {
-    if (PROJECT_ROOT_MARKERS.some((marker) => existsSync12(join15(dir, marker)))) {
+    if (PROJECT_ROOT_MARKERS.some((marker) => existsSync12(join16(dir, marker)))) {
       return dir;
     }
-    const parent = dirname7(dir);
+    const parent = dirname8(dir);
     if (parent === dir)
       return resolve8(fallbackCwd);
     dir = parent;
@@ -17471,7 +18340,12 @@ async function runLspDoctor(options) {
     log2.error(inspect.message ?? inspect.code ?? "lsp_inspect failed");
     return 1;
   }
-  console.log(renderLspInspection(file, inspect));
+  const inspection = inspect;
+  const typescriptWarning = typescriptPackageWarning(inspection);
+  console.log(renderLspInspection(file, {
+    ...inspection,
+    ...typescriptWarning ? { typescript_package_warning: typescriptWarning } : {}
+  }));
   return 0;
 }
 function renderLspInspection(inputFile, response) {
@@ -17507,6 +18381,10 @@ function renderLspInspection(inputFile, response) {
       lines.push(`    Action: ${installHint(server.binary_name)}`);
     }
   }
+  if (response.typescript_package_warning) {
+    lines.push("");
+    lines.push(`Warning: ${response.typescript_package_warning}`);
+  }
   const diagnostics = response.diagnostics ?? [];
   lines.push("");
   lines.push(`Diagnostics (${response.diagnostics_count ?? diagnostics.length} found):`);
@@ -17535,8 +18413,8 @@ function parseFileArg(argv) {
 function buildConfigureParams(adapter, projectRoot) {
   const userConfigPath = adapter.detectConfigPaths().aftConfig;
   const dir = adapter.kind === "pi" ? ".pi" : ".opencode";
-  const projectJsonc = join15(projectRoot, dir, "aft.jsonc");
-  const projectJson = join15(projectRoot, dir, "aft.json");
+  const projectJsonc = join16(projectRoot, dir, "aft.jsonc");
+  const projectJson = join16(projectRoot, dir, "aft.json");
   const projectConfigPath = existsSync12(projectJsonc) ? projectJsonc : projectJson;
   return {
     id: "doctor-lsp-configure",
@@ -17550,10 +18428,10 @@ function buildConfigureParams(adapter, projectRoot) {
 function inferLspPathsExtra(_lsp) {
   const paths = new Set;
   for (const entry of childDirs(getAftLspPackagesDir())) {
-    paths.add(join15(entry, "node_modules", ".bin"));
+    paths.add(join16(entry, "node_modules", ".bin"));
   }
   for (const entry of childDirs(getAftLspBinariesDir())) {
-    paths.add(join15(entry, "bin"));
+    paths.add(join16(entry, "bin"));
   }
   return [...paths];
 }
@@ -17561,7 +18439,7 @@ function childDirs(path2) {
   if (!existsSync12(path2))
     return [];
   try {
-    return readdirSync4(path2).map((entry) => join15(path2, entry)).filter((entry) => {
+    return readdirSync4(path2).map((entry) => join16(path2, entry)).filter((entry) => {
       try {
         return statSync7(entry).isDirectory();
       } catch {
@@ -17596,6 +18474,18 @@ function formatSpawnStatus(server) {
 function formatList(values) {
   return values.length === 0 ? "(none)" : values.join(", ");
 }
+function typescriptPackageWarning(response) {
+  const typescriptServerSpawned = response.matching_servers?.some((server) => server.id === "typescript" && server.spawn_status === "ok");
+  const diagnosticsCount = response.diagnostics_count ?? response.diagnostics?.length ?? 0;
+  if (!typescriptServerSpawned || !response.project_root || diagnosticsCount > 0)
+    return null;
+  try {
+    createRequire4(join16(response.project_root, "package.json")).resolve("typescript");
+    return null;
+  } catch {
+    return "typescript package not resolvable from project — server will produce no diagnostics";
+  }
+}
 function installHint(binaryName) {
   if (binaryName === "ty")
     return "Install with `uv tool install ty` or `pip install ty`.";
@@ -17639,7 +18529,7 @@ __export(exports_doctor_filters, {
   printDoctorFiltersHelp: () => printDoctorFiltersHelp
 });
 import { existsSync as existsSync13 } from "node:fs";
-import { homedir as homedir15 } from "node:os";
+import { homedir as homedir16 } from "node:os";
 import { relative as relative3, resolve as resolve9 } from "node:path";
 function printDoctorFiltersHelp() {
   console.log("Usage: aft doctor filters [--show <name>] [trust|untrust]");
@@ -17857,7 +18747,7 @@ function truncate(value) {
   return value.length <= 80 ? value : `${value.slice(0, 77)}…`;
 }
 function formatHome(path2) {
-  const home = homedir15();
+  const home = homedir16();
   return path2.startsWith(home) ? `~${path2.slice(home.length)}` : path2;
 }
 function formatProjectPath(path2, projectRoot) {
@@ -17881,7 +18771,7 @@ var init_doctor_filters = __esm(async () => {
 
 // src/lib/binary-cache.ts
 import { existsSync as existsSync14, readdirSync as readdirSync5, statSync as statSync8 } from "node:fs";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 function getBinaryCacheInfo(activeVersion) {
   const path2 = getAftBinaryCacheDir();
   if (!existsSync14(path2)) {
@@ -17894,7 +18784,7 @@ function getBinaryCacheInfo(activeVersion) {
   }
   const versions = readdirSync5(path2).filter((entry) => {
     try {
-      return statSync8(join16(path2, entry)).isDirectory();
+      return statSync8(join17(path2, entry)).isDirectory();
     } catch {
       return false;
     }
@@ -17915,7 +18805,7 @@ var init_binary_cache = __esm(() => {
 
 // src/lib/sanitize.ts
 import { realpathSync as realpathSync3 } from "node:fs";
-import { homedir as homedir16, userInfo } from "node:os";
+import { homedir as homedir17, userInfo } from "node:os";
 function escapeRegex(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -17946,7 +18836,7 @@ function redactSecrets(content) {
 }
 function sanitizeContent(content) {
   const username = userInfo().username;
-  const home = homedir16();
+  const home = homedir17();
   let sanitized = redactSecrets(content);
   const cwd = process.cwd();
   for (const candidate of new Set([cwd, safeRealpath(cwd)])) {
@@ -17993,11 +18883,9 @@ var init_sanitize = __esm(() => {
 
 // src/lib/bridge-tool-failures.ts
 import { closeSync as closeSync5, existsSync as existsSync15, openSync as openSync5, readSync as readSync2, statSync as statSync9 } from "node:fs";
-import { tmpdir as tmpdir3 } from "node:os";
-import { join as join17 } from "node:path";
 function resolveBridgePluginLogPath() {
   const isTestEnv = process.env.BUN_TEST === "1" || false;
-  return join17(tmpdir3(), isTestEnv ? "aft-plugin-test.log" : "aft-plugin.log");
+  return resolveAftLogPath(isTestEnv ? "aft-plugin-test.log" : "aft-plugin.log");
 }
 function tailLogFileBytes(path2, maxBytes) {
   if (!existsSync15(path2) || maxBytes <= 0)
@@ -18128,31 +19016,156 @@ function buildRecentAftToolFailuresSectionFromLog(logPath = resolveBridgePluginL
 }
 var BRIDGE_LOG_TAIL_BYTES, MAX_TOOL_FAILURE_CLASSES = 30, SESSION_TAG_PATTERN, STRUCTURED_CODE_PATTERN;
 var init_bridge_tool_failures = __esm(() => {
+  init_dist2();
   init_sanitize();
   BRIDGE_LOG_TAIL_BYTES = 2 * 1024 * 1024;
   SESSION_TAG_PATTERN = /\[ses_[^\]\s]+\]|\[[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\]/g;
   STRUCTURED_CODE_PATTERN = /"code"\s*:\s*"([^"]+)"/;
 });
 
-// src/lib/lsp-cache.ts
-import { existsSync as existsSync16, readdirSync as readdirSync6, rmSync as rmSync5, statSync as statSync10 } from "node:fs";
+// src/lib/legacy-storage.ts
+import { existsSync as existsSync16, readdirSync as readdirSync6, statSync as statSync10 } from "node:fs";
 import { join as join18 } from "node:path";
+function summarizeLegacyPartitionDuplication(storageRoot) {
+  if (!existsSync16(storageRoot)) {
+    return { totalPartitions: 0, totalBytes: 0, byHarness: [] };
+  }
+  const byHarness = [];
+  for (const harness of safeReadDir(storageRoot)) {
+    const harnessPath = join18(storageRoot, harness);
+    if (!isDirectory(harnessPath))
+      continue;
+    const partitions = new Map;
+    collectCallgraphPartitions(join18(harnessPath, "callgraph"), partitions);
+    collectInspectPartitions(join18(harnessPath, "inspect"), partitions);
+    if (partitions.size === 0)
+      continue;
+    let bytes = 0;
+    for (const size of partitions.values())
+      bytes += size;
+    byHarness.push({ harness, partitions: partitions.size, bytes });
+  }
+  byHarness.sort((left, right) => left.harness.localeCompare(right.harness));
+  return {
+    totalPartitions: byHarness.reduce((sum, item) => sum + item.partitions, 0),
+    totalBytes: byHarness.reduce((sum, item) => sum + item.bytes, 0),
+    byHarness
+  };
+}
+function collectCallgraphPartitions(domainPath, partitions) {
+  if (!isDirectory(domainPath))
+    return;
+  for (const name of safeReadDir(domainPath)) {
+    const path2 = join18(domainPath, name);
+    if (isDirectory(path2)) {
+      if (!looksLikePartitionKey(name))
+        continue;
+      addPartitionBytes(partitions, `callgraph:${name}`, dirSize(path2));
+      continue;
+    }
+    const key = callgraphPartitionKeyFromName(name);
+    if (!key)
+      continue;
+    addPartitionBytes(partitions, `callgraph:${key}`, safeFileSize(path2));
+  }
+}
+function collectInspectPartitions(domainPath, partitions) {
+  if (!isDirectory(domainPath))
+    return;
+  for (const name of safeReadDir(domainPath)) {
+    const path2 = join18(domainPath, name);
+    if (isDirectory(path2)) {
+      if (!looksLikePartitionKey(name))
+        continue;
+      addPartitionBytes(partitions, `inspect:${name}`, dirSize(path2));
+      continue;
+    }
+    const key = inspectPartitionKeyFromName(name);
+    if (!key)
+      continue;
+    addPartitionBytes(partitions, `inspect:${key}`, safeFileSize(path2));
+  }
+}
+function addPartitionBytes(partitions, key, bytes) {
+  partitions.set(key, (partitions.get(key) ?? 0) + bytes);
+}
+function callgraphPartitionKeyFromName(name) {
+  if (name.includes(".tmp."))
+    return null;
+  if (name.endsWith(".current")) {
+    const key2 = name.slice(0, -".current".length);
+    return looksLikePartitionKey(key2) ? key2 : null;
+  }
+  const base = sqliteishBaseName(name);
+  if (!base)
+    return null;
+  const split = base.indexOf(".g");
+  const key = split === -1 ? base : base.slice(0, split);
+  return looksLikePartitionKey(key) ? key : null;
+}
+function inspectPartitionKeyFromName(name) {
+  if (name.includes(".tmp."))
+    return null;
+  const base = sqliteishBaseName(name);
+  return base && looksLikePartitionKey(base) ? base : null;
+}
+function sqliteishBaseName(name) {
+  for (const suffix of SQLITE_SUFFIXES) {
+    if (name.endsWith(suffix)) {
+      return name.slice(0, -suffix.length);
+    }
+  }
+  return null;
+}
+function looksLikePartitionKey(value) {
+  return /^[0-9a-fA-F]{16}$/.test(value);
+}
+function safeReadDir(path2) {
+  try {
+    return readdirSync6(path2).sort((left, right) => left.localeCompare(right));
+  } catch {
+    return [];
+  }
+}
+function isDirectory(path2) {
+  try {
+    return statSync10(path2).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function safeFileSize(path2) {
+  try {
+    return statSync10(path2).isFile() ? statSync10(path2).size : 0;
+  } catch {
+    return 0;
+  }
+}
+var SQLITE_SUFFIXES;
+var init_legacy_storage = __esm(() => {
+  init_fs_util();
+  SQLITE_SUFFIXES = [".sqlite-wal", ".sqlite-shm", ".sqlite-journal", ".sqlite"];
+});
+
+// src/lib/lsp-cache.ts
+import { existsSync as existsSync17, readdirSync as readdirSync7, rmSync as rmSync5, statSync as statSync11 } from "node:fs";
+import { join as join19 } from "node:path";
 function inspectDir(path2) {
-  if (!existsSync16(path2)) {
+  if (!existsSync17(path2)) {
     return { entries: [], totalSize: 0 };
   }
   const entries = [];
   let totalSize = 0;
   let names;
   try {
-    names = readdirSync6(path2);
+    names = readdirSync7(path2);
   } catch {
     return { entries: [], totalSize: 0 };
   }
   for (const name of names) {
-    const full = join18(path2, name);
+    const full = join19(path2, name);
     try {
-      if (!statSync10(full).isDirectory())
+      if (!statSync11(full).isDirectory())
         continue;
       const size = dirSize(full);
       entries.push({
@@ -18208,8 +19221,8 @@ var init_lsp_cache = __esm(() => {
 });
 
 // src/lib/onnx.ts
-import { existsSync as existsSync17, readdirSync as readdirSync7, readlinkSync as readlinkSync2, realpathSync as realpathSync4 } from "node:fs";
-import { basename as basename3, isAbsolute as isAbsolute6, join as join19, resolve as resolve10, win32 as win322 } from "node:path";
+import { existsSync as existsSync18, readdirSync as readdirSync8, readlinkSync as readlinkSync2, realpathSync as realpathSync4 } from "node:fs";
+import { basename as basename3, isAbsolute as isAbsolute6, join as join20, resolve as resolve10, win32 as win322 } from "node:path";
 function getOnnxLibraryName() {
   if (process.platform === "darwin")
     return "libonnxruntime.dylib";
@@ -18249,9 +19262,20 @@ function pathEntriesForPlatform2() {
     return isAbsolute6(entry) || win322.isAbsolute(entry);
   });
 }
+function isWindowsSystem32Directory2(dir) {
+  if (process.platform !== "win32")
+    return false;
+  const normalizedDir = win322.resolve(dir).replace(/[\\/]+$/, "").toLowerCase();
+  const windowsRoots = [process.env.SystemRoot, process.env.windir, "C:\\Windows"];
+  return windowsRoots.some((root) => {
+    if (!root)
+      return false;
+    return normalizedDir === win322.resolve(root, "System32").replace(/[\\/]+$/, "").toLowerCase();
+  });
+}
 function directoryContainsLibrary2(dir, libName) {
   try {
-    const entries = readdirSync7(dir);
+    const entries = readdirSync8(dir);
     if (process.platform === "win32") {
       const expected = libName.toLowerCase();
       return entries.some((entry) => entry.toLowerCase() === expected);
@@ -18261,6 +19285,24 @@ function directoryContainsLibrary2(dir, libName) {
     return false;
   }
 }
+function findIgnoredWindowsSystemOnnxRuntime() {
+  if (process.platform !== "win32")
+    return null;
+  const windowsRoots = [process.env.SystemRoot, process.env.windir, "C:\\Windows"];
+  const seen = new Set;
+  for (const root of windowsRoots) {
+    if (!root)
+      continue;
+    const systemDir = join20(root, "System32");
+    const key = win322.resolve(systemDir).toLowerCase();
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    if (directoryContainsLibrary2(systemDir, getOnnxLibraryName()))
+      return systemDir;
+  }
+  return null;
+}
 function findSystemOnnxRuntime2() {
   const libName = getOnnxLibraryName();
   const searchPaths = [];
@@ -18272,21 +19314,21 @@ function findSystemOnnxRuntime2() {
     searchPaths.push(...pathEntriesForPlatform2());
     const programFiles = process.env.ProgramFiles ?? "C:\\Program Files";
     const programFilesX86 = process.env["ProgramFiles(x86)"] ?? "C:\\Program Files (x86)";
-    searchPaths.push(join19(programFiles, "onnxruntime", "lib"), join19(programFiles, "Microsoft ONNX Runtime", "lib"), join19(programFiles, "Microsoft Machine Learning", "lib"), join19(programFilesX86, "onnxruntime", "lib"), ...(() => {
+    searchPaths.push(join20(programFiles, "onnxruntime", "lib"), join20(programFiles, "Microsoft ONNX Runtime", "lib"), join20(programFiles, "Microsoft Machine Learning", "lib"), join20(programFilesX86, "onnxruntime", "lib"), ...(() => {
       const nugetPaths = [];
       const userProfile = process.env.USERPROFILE ?? "";
       if (!userProfile)
         return nugetPaths;
-      const nugetPackageDir = join19(userProfile, ".nuget", "packages", "microsoft.ml.onnxruntime");
-      if (!existsSync17(nugetPackageDir))
+      const nugetPackageDir = join20(userProfile, ".nuget", "packages", "microsoft.ml.onnxruntime");
+      if (!existsSync18(nugetPackageDir))
         return nugetPaths;
       try {
-        for (const entry of readdirSync7(nugetPackageDir, { withFileTypes: true })) {
+        for (const entry of readdirSync8(nugetPackageDir, { withFileTypes: true })) {
           if (!entry.isDirectory())
             continue;
           if (entry.name === "__globalPackagesFolder" || entry.name.startsWith("."))
             continue;
-          nugetPaths.push(join19(nugetPackageDir, entry.name, "runtimes", "win-x64", "native"), join19(nugetPackageDir, entry.name, "runtimes", "win-arm64", "native"));
+          nugetPaths.push(join20(nugetPackageDir, entry.name, "runtimes", "win-x64", "native"), join20(nugetPackageDir, entry.name, "runtimes", "win-arm64", "native"));
         }
       } catch {}
       return nugetPaths;
@@ -18306,6 +19348,8 @@ function findSystemOnnxRuntime2() {
       continue;
     const version = detectOrtVersion(dir);
     if (!version) {
+      if (isWindowsSystem32Directory2(dir))
+        continue;
       unknownVersionPaths.push(dir);
       continue;
     }
@@ -18316,12 +19360,12 @@ function findSystemOnnxRuntime2() {
   return unknownVersionPaths[0] ?? null;
 }
 function findCachedOnnxRuntime(storageDir) {
-  const ortDir = join19(storageDir, "onnxruntime", ONNX_RUNTIME_VERSION);
+  const ortDir = join20(storageDir, "onnxruntime", ONNX_RUNTIME_VERSION);
   const libName = getOnnxLibraryName();
-  if (existsSync17(join19(ortDir, libName)))
+  if (existsSync18(join20(ortDir, libName)))
     return ortDir;
-  const libSubdir = join19(ortDir, "lib");
-  if (existsSync17(join19(libSubdir, libName)))
+  const libSubdir = join20(ortDir, "lib");
+  if (existsSync18(join20(libSubdir, libName)))
     return libSubdir;
   return null;
 }
@@ -18342,11 +19386,11 @@ function parseOrtVersionFromDirectoryPath(value) {
   return null;
 }
 function detectOrtVersion(libDir) {
-  if (!existsSync17(libDir))
+  if (!existsSync18(libDir))
     return null;
   const libName = getOnnxLibraryName();
   try {
-    const entries = readdirSync7(libDir);
+    const entries = readdirSync8(libDir);
     const barePrefix = libName.replace(/\.(so|dylib|dll)$/, "");
     const expectedPrefix = process.platform === "win32" ? barePrefix.toLowerCase() : barePrefix;
     for (const entry of entries) {
@@ -18357,8 +19401,8 @@ function detectOrtVersion(libDir) {
       if (version)
         return version;
     }
-    const base = join19(libDir, libName);
-    if (existsSync17(base)) {
+    const base = join20(libDir, libName);
+    if (existsSync18(base)) {
       try {
         const real = realpathSync4(base);
         const version = parseOrtVersionFromPath(real) ?? parseOrtVersionFromDirectoryPath(real);
@@ -18393,10 +19437,10 @@ import {
   accessSync,
   closeSync as closeSync6,
   constants,
-  existsSync as existsSync18,
+  existsSync as existsSync19,
   openSync as openSync6,
   readSync as readSync3,
-  statSync as statSync11
+  statSync as statSync12
 } from "node:fs";
 async function collectDiagnostics(adapters) {
   const cliVersion = getSelfVersion();
@@ -18431,7 +19475,7 @@ async function diagnoseHarness(adapter) {
   const logPath = adapter.getLogFile();
   const pluginCache = adapter.getPluginCacheInfo();
   const storageAccessible = (() => {
-    if (!existsSync18(storage))
+    if (!existsSync19(storage))
       return false;
     try {
       accessSync(storage, constants.R_OK | constants.W_OK);
@@ -18441,8 +19485,10 @@ async function diagnoseHarness(adapter) {
     }
   })();
   const describeStorage = "describeStorageSubtrees" in adapter && typeof adapter.describeStorageSubtrees === "function" ? adapter.describeStorageSubtrees() : {};
+  const legacyDuplication = summarizeLegacyPartitionDuplication(storage);
   const semanticEnabled = aftEnabled && (aftConfigRead.value?.semantic_search === true || aftConfigRead.value?.experimental_semantic_search === true);
   const systemOrtDir = findSystemOnnxRuntime2();
+  const ignoredSystemOrtDir = systemOrtDir ? null : findIgnoredWindowsSystemOnnxRuntime();
   const cachedOrtDir = findCachedOnnxRuntime(storage);
   const systemVersion = systemOrtDir ? detectOrtVersion(systemOrtDir) : null;
   const cachedVersion = cachedOrtDir ? detectOrtVersion(cachedOrtDir) : null;
@@ -18454,7 +19500,7 @@ async function diagnoseHarness(adapter) {
     pluginRegistered: adapter.hasPluginEntry(),
     configPaths,
     aftConfig: {
-      exists: existsSync18(configPaths.aftConfig),
+      exists: existsSync19(configPaths.aftConfig),
       ...aftConfigRead.error ? { parseError: aftConfigRead.error } : {},
       enabled: aftEnabled,
       ...aftEnabledSource ? { enabledSource: aftEnabledSource } : {},
@@ -18463,15 +19509,18 @@ async function diagnoseHarness(adapter) {
     pluginCache,
     storageDir: {
       path: storage,
-      exists: existsSync18(storage),
+      exists: existsSync19(storage),
       accessible: storageAccessible,
-      sizesByKey: describeStorage
+      sizesByKey: describeStorage,
+      ...legacyDuplication.totalPartitions > 0 ? { legacyDuplication } : {}
     },
     onnxRuntime: {
       required: semanticEnabled,
       systemPath: systemOrtDir,
       systemVersion,
       systemCompatible: systemVersion ? isOrtVersionCompatible(systemVersion) : null,
+      ignoredSystemPath: ignoredSystemOrtDir,
+      ignoredSystemReason: ignoredSystemOrtDir ? "version unreadable (Windows system copy) — ignored" : null,
       cachedPath: cachedOrtDir,
       cachedVersion,
       cachedCompatible: cachedVersion ? isOrtVersionCompatible(cachedVersion) : null,
@@ -18481,8 +19530,8 @@ async function diagnoseHarness(adapter) {
     },
     logFile: {
       path: logPath,
-      exists: existsSync18(logPath),
-      sizeKb: existsSync18(logPath) ? Math.round(statSync11(logPath).size / 1024) : 0
+      exists: existsSync19(logPath),
+      sizeKb: existsSync19(logPath) ? Math.round(statSync12(logPath).size / 1024) : 0
     }
   };
 }
@@ -18637,7 +19686,7 @@ function collectDiagnosticIssues(report) {
           code: "onnx_missing",
           severity: "medium",
           scope: h2.displayName,
-          message: "ONNX Runtime is required for semantic search but was not detected.",
+          message: h2.onnxRuntime.ignoredSystemPath ? `ONNX Runtime at ${h2.onnxRuntime.ignoredSystemPath} has a ${h2.onnxRuntime.ignoredSystemReason}; no compatible runtime was detected.` : "ONNX Runtime is required for semantic search but was not detected.",
           remediation: `Run \`aft doctor --fix\` or install ONNX Runtime manually (${h2.onnxRuntime.installHint}).`
         });
       }
@@ -18678,14 +19727,14 @@ function formatDiagnosticIssuesSection(report) {
   return lines;
 }
 function tailLogFile(path2, lines) {
-  if (!existsSync18(path2))
+  if (!existsSync19(path2))
     return "";
   if (lines <= 0)
     return "";
   const chunkSize = 64 * 1024;
   let fd = null;
   try {
-    const size = statSync11(path2).size;
+    const size = statSync12(path2).size;
     fd = openSync6(path2, "r");
     const chunks = [];
     let position = size;
@@ -18718,6 +19767,7 @@ var init_diagnostics = __esm(async () => {
   init_dist2();
   init_binary_cache();
   init_jsonc();
+  init_legacy_storage();
   init_lsp_cache();
   init_onnx();
   init_sanitize();
@@ -18865,34 +19915,42 @@ var init_issue_body = __esm(() => {
 });
 
 // src/lib/onnx-fix.ts
-import { existsSync as existsSync19, rmSync as rmSync6 } from "node:fs";
-import { join as join20 } from "node:path";
+import { existsSync as existsSync20, rmSync as rmSync6 } from "node:fs";
+import { join as join21 } from "node:path";
 function findOnnxFixCandidates(report) {
   const candidates = [];
   for (const harness of report.harnesses) {
     if (!harness.onnxRuntime.required)
       continue;
-    if (!harness.storageDir.exists)
-      continue;
-    const storageOnnxDir = join20(harness.storageDir.path, "onnxruntime");
+    const storageOnnxDir = join21(harness.storageDir.path, "onnxruntime");
     const systemTooOld = harness.onnxRuntime.systemPath !== null && harness.onnxRuntime.systemCompatible === false;
     const cachedTooOld = harness.onnxRuntime.cachedPath !== null && harness.onnxRuntime.cachedCompatible === false;
     const hasCompatibleCached = harness.onnxRuntime.cachedCompatible === true;
     if (cachedTooOld) {
       candidates.push({
         harness,
-        reason: `cached ONNX Runtime at ${harness.onnxRuntime.cachedPath} is v${harness.onnxRuntime.cachedVersion}, but AFT requires ${harness.onnxRuntime.requirement}. Clearing forces a fresh download on next start.`,
+        reason: `cached ONNX Runtime at ${harness.onnxRuntime.cachedPath} is v${harness.onnxRuntime.cachedVersion}, but AFT requires ${harness.onnxRuntime.requirement}. Clearing it allows an immediate managed download.`,
         storageOnnxDir,
-        storageOnnxBytes: existsSync19(storageOnnxDir) ? dirSize(storageOnnxDir) : 0
+        storageOnnxBytes: existsSync20(storageOnnxDir) ? dirSize(storageOnnxDir) : 0
       });
       continue;
     }
     if (systemTooOld && !hasCompatibleCached) {
       candidates.push({
         harness,
-        reason: `system ONNX Runtime at ${harness.onnxRuntime.systemPath} is v${harness.onnxRuntime.systemVersion}, but AFT requires ${harness.onnxRuntime.requirement}, and no AFT-managed install is present. AFT v0.19.5+ skips incompatible system installs and auto-downloads v1.24 on next start; clearing any stale state here ensures a clean slate.`,
+        reason: `system ONNX Runtime at ${harness.onnxRuntime.systemPath} is v${harness.onnxRuntime.systemVersion}, but AFT requires ${harness.onnxRuntime.requirement}, and no AFT-managed install is present. AFT will leave the system copy untouched and download v1.24 into managed storage.`,
+        storageOnnxDir,
+        storageOnnxBytes: existsSync20(storageOnnxDir) ? dirSize(storageOnnxDir) : 0
+      });
+      continue;
+    }
+    if (!harness.onnxRuntime.systemPath && !harness.onnxRuntime.cachedPath) {
+      const ignoredCopy = harness.onnxRuntime.ignoredSystemPath ? ` The Windows system copy at ${harness.onnxRuntime.ignoredSystemPath} was ignored because its version is unreadable.` : "";
+      candidates.push({
+        harness,
+        reason: `no compatible ONNX Runtime is installed.${ignoredCopy} AFT will download v1.24 into managed storage.`,
         storageOnnxDir,
-        storageOnnxBytes: existsSync19(storageOnnxDir) ? dirSize(storageOnnxDir) : 0
+        storageOnnxBytes: existsSync20(storageOnnxDir) ? dirSize(storageOnnxDir) : 0
       });
     }
   }
@@ -18900,58 +19958,74 @@ function findOnnxFixCandidates(report) {
 }
 async function runOnnxFix(adapters, report, options = {}) {
   const candidates = findOnnxFixCandidates(report);
-  if (candidates.length === 0) {
+  if (candidates.length === 0)
     return null;
-  }
-  log2.warn(`Found ${candidates.length} ONNX Runtime issue(s) that --fix can address by clearing AFT-managed cache:`);
-  for (const c3 of candidates) {
-    log2.info(`  • ${c3.harness.displayName}: ${c3.reason}`);
-    if (c3.storageOnnxBytes > 0) {
-      log2.info(`    will delete: ${c3.storageOnnxDir} (${formatBytes(c3.storageOnnxBytes)})`);
+  log2.warn(`Found ${candidates.length} ONNX Runtime issue(s) that --fix can repair with an AFT-managed runtime:`);
+  for (const candidate of candidates) {
+    log2.info(`  • ${candidate.harness.displayName}: ${candidate.reason}`);
+    if (candidate.storageOnnxBytes > 0) {
+      log2.info(`    will delete: ${candidate.storageOnnxDir} (${formatBytes(candidate.storageOnnxBytes)})`);
     } else {
-      log2.info(`    no AFT-managed ONNX cache to delete; nothing to reclaim`);
+      log2.info("    no AFT-managed ONNX cache to delete");
     }
   }
-  note("This NEVER touches system paths like /usr/lib. It only deletes AFT's own ONNX download cache. " + "On next bridge start, AFT will re-download ONNX Runtime v1.24 and use that instead of the " + "incompatible system library.", "Safe operation");
+  note("This NEVER touches system paths like /usr/lib or C:\\Windows\\System32. It only replaces AFT's own ONNX cache, then downloads the compatible managed runtime.", "Safe operation");
   const confirmFn = options.confirmFn ?? confirm2;
   const proceed = options.yes ? true : await confirmFn("Proceed with the fixes above?", true);
   if (!proceed) {
     log2.info("Skipped — no changes made.");
     return null;
   }
-  const result = { cleared: 0, bytesReclaimed: 0, errors: [] };
+  const result = { cleared: 0, installed: 0, bytesReclaimed: 0, errors: [] };
   const rmFn = options.rmFn ?? rmSync6;
-  for (const c3 of candidates) {
-    if (!existsSync19(c3.storageOnnxDir)) {
-      log2.success(`${c3.harness.displayName}: no cached state to clear; restart your harness to trigger a fresh ONNX download`);
-      continue;
+  const ensureFn = options.ensureFn ?? ensureOnnxRuntime;
+  for (const candidate of candidates) {
+    if (existsSync20(candidate.storageOnnxDir)) {
+      try {
+        rmFn(candidate.storageOnnxDir, { recursive: true, force: true });
+        result.cleared += 1;
+        result.bytesReclaimed += candidate.storageOnnxBytes;
+        log2.success(`${candidate.harness.displayName}: cleared ${candidate.storageOnnxDir} (reclaimed ${formatBytes(candidate.storageOnnxBytes)})`);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        log2.error(`${candidate.harness.displayName}: failed to clear ${candidate.storageOnnxDir}: ${message}`);
+        result.errors.push({ path: candidate.storageOnnxDir, error: message });
+        continue;
+      }
     }
     try {
-      rmFn(c3.storageOnnxDir, { recursive: true, force: true });
-      result.cleared += 1;
-      result.bytesReclaimed += c3.storageOnnxBytes;
-      log2.success(`${c3.harness.displayName}: cleared ${c3.storageOnnxDir} (reclaimed ${formatBytes(c3.storageOnnxBytes)})`);
+      log2.info(`${candidate.harness.displayName}: downloading managed ONNX Runtime…`);
+      const installedPath = await ensureFn(candidate.harness.storageDir.path);
+      if (!installedPath) {
+        const message = "managed ONNX Runtime download was unavailable";
+        log2.error(`${candidate.harness.displayName}: ${message}`);
+        result.errors.push({ path: candidate.storageOnnxDir, error: message });
+        continue;
+      }
+      result.installed += 1;
+      log2.success(`${candidate.harness.displayName}: ONNX Runtime installed at ${installedPath}`);
     } catch (err) {
-      const message = err.message ?? "unknown error";
-      log2.error(`${c3.harness.displayName}: failed to clear ${c3.storageOnnxDir}: ${message}`);
-      result.errors.push({ path: c3.storageOnnxDir, error: message });
+      const message = err instanceof Error ? err.message : String(err);
+      log2.error(`${candidate.harness.displayName}: ONNX Runtime download failed: ${message}`);
+      result.errors.push({ path: candidate.storageOnnxDir, error: message });
     }
   }
-  if (result.cleared > 0 || candidates.some((c3) => c3.storageOnnxBytes === 0)) {
-    note("Restart your AFT-using harness (OpenCode / Pi) to trigger a fresh ONNX Runtime download. " + "Watch the TUI sidebar — the Semantic Index status should move from 'failed' → 'building' → 'ready'.", "Next step");
+  if (result.installed > 0) {
+    note("Restart your AFT-using harness (OpenCode / Pi) so semantic indexing uses the newly installed managed runtime.", "Next step");
   }
   return result;
 }
 var init_onnx_fix = __esm(() => {
+  init_dist2();
   init_fs_util();
   init_prompts();
 });
 
 // src/lib/sessions.ts
-import { existsSync as existsSync20, readdirSync as readdirSync8, readFileSync as readFileSync10, statSync as statSync12 } from "node:fs";
-import { createRequire as createRequire4 } from "node:module";
-import { homedir as homedir17 } from "node:os";
-import { basename as basename4, join as join21 } from "node:path";
+import { existsSync as existsSync21, readdirSync as readdirSync9, readFileSync as readFileSync10, statSync as statSync13 } from "node:fs";
+import { createRequire as createRequire5 } from "node:module";
+import { homedir as homedir18 } from "node:os";
+import { basename as basename4, join as join22 } from "node:path";
 function listRecentSessions(adapter) {
   try {
     if (adapter.kind === "opencode")
@@ -18980,12 +20054,12 @@ function mapOpenCodeSessionRows(rows) {
   }).filter((session) => session !== null).sort((a3, b2) => b2.lastActivity - a3.lastActivity).slice(0, MAX_RECENT_SESSIONS);
 }
 function listRecentOpenCodeSessions() {
-  const dbPath = join21(getXdgDataHome(), "opencode", "opencode.db");
-  if (!existsSync20(dbPath))
+  const dbPath = join22(getXdgDataHome(), "opencode", "opencode.db");
+  if (!existsSync21(dbPath))
     return [];
   let db = null;
   try {
-    const require2 = createRequire4(import.meta.url);
+    const require2 = createRequire5(import.meta.url);
     const sqlite = require2("node:sqlite");
     db = new sqlite.DatabaseSync(dbPath, { readOnly: true });
     const rows = db.prepare("SELECT id, title, time_updated FROM session ORDER BY time_updated DESC LIMIT 5").all();
@@ -19000,22 +20074,22 @@ function listRecentOpenCodeSessions() {
 }
 function getXdgDataHome() {
   const xdgDataHome = process.env.XDG_DATA_HOME;
-  return xdgDataHome && xdgDataHome.length > 0 ? xdgDataHome : join21(homedir17(), ".local", "share");
+  return xdgDataHome && xdgDataHome.length > 0 ? xdgDataHome : join22(homedir18(), ".local", "share");
 }
 function listRecentPiSessions() {
-  return listPiSessionsFromDir(join21(getHomeDir(), ".pi", "agent", "sessions"));
+  return listPiSessionsFromDir(join22(getHomeDir(), ".pi", "agent", "sessions"));
 }
 function getHomeDir() {
   const envHome = process.platform === "win32" ? process.env.USERPROFILE : process.env.HOME;
-  return envHome && envHome.length > 0 ? envHome : homedir17();
+  return envHome && envHome.length > 0 ? envHome : homedir18();
 }
 function listPiSessionsFromDir(sessionsDir) {
   try {
-    if (!existsSync20(sessionsDir))
+    if (!existsSync21(sessionsDir))
       return [];
     const files = collectJsonlFiles(sessionsDir).map((filePath) => {
       try {
-        const stats = statSync12(filePath);
+        const stats = statSync13(filePath);
         return { filePath, mtimeMs: stats.mtimeMs };
       } catch {
         return null;
@@ -19044,12 +20118,12 @@ function collectJsonlFiles(root) {
       continue;
     let entries;
     try {
-      entries = readdirSync8(dir, { withFileTypes: true });
+      entries = readdirSync9(dir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
-      const path2 = join21(dir, entry.name);
+      const path2 = join22(dir, entry.name);
       if (entry.isDirectory()) {
         stack.push(path2);
       } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
@@ -19149,17 +20223,17 @@ __export(exports_doctor, {
 import { execFileSync as execFileSync3 } from "node:child_process";
 import {
   chmodSync as chmodSync4,
-  existsSync as existsSync21,
+  existsSync as existsSync22,
   mkdirSync as mkdirSync7,
   mkdtempSync,
   readFileSync as readFileSync11,
   realpathSync as realpathSync5,
   rmSync as rmSync7,
-  statSync as statSync13,
+  statSync as statSync14,
   writeFileSync as writeFileSync5
 } from "node:fs";
-import { tmpdir as tmpdir4 } from "node:os";
-import { join as join22 } from "node:path";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join23 } from "node:path";
 async function runDoctor(options) {
   if (options.issue) {
     return runIssueFlow(options.argv);
@@ -19228,6 +20302,8 @@ async function runDoctor(options) {
       }
       if (h2.onnxRuntime.systemPath) {
         parts.push(`system: ${h2.onnxRuntime.systemVersion ?? "unknown"}${h2.onnxRuntime.systemCompatible === false ? " (incompatible)" : ""}`);
+      } else if (h2.onnxRuntime.ignoredSystemPath) {
+        parts.push(`system: ${h2.onnxRuntime.ignoredSystemReason} at ${h2.onnxRuntime.ignoredSystemPath}`);
       }
       if (!h2.onnxRuntime.cachedPath && !h2.onnxRuntime.systemPath) {
         parts.push(`not installed — ${h2.onnxRuntime.installHint}`);
@@ -19324,7 +20400,7 @@ function clearOldBinaries() {
     errors: [],
     keptVersion: keepTag
   };
-  if (!existsSync21(info.path)) {
+  if (!existsSync22(info.path)) {
     log2.info(`Binary cache: nothing to clear at ${info.path}`);
     return result;
   }
@@ -19334,10 +20410,10 @@ function clearOldBinaries() {
     return result;
   }
   for (const version of stale) {
-    const dir = join22(info.path, version);
+    const dir = join23(info.path, version);
     let bytes = 0;
     try {
-      bytes = statSync13(dir).isDirectory() ? dirSize(dir) : 0;
+      bytes = statSync14(dir).isDirectory() ? dirSize(dir) : 0;
     } catch {
       bytes = 0;
     }
@@ -19511,12 +20587,12 @@ function buildDoctorFixPlan(adapters, report) {
     if (candidate.storageOnnxBytes > 0) {
       items.push({
         kind: "onnx",
-        message: `Will delete AFT-managed ONNX cache at ${candidate.storageOnnxDir} (${formatBytes(candidate.storageOnnxBytes)})`
+        message: `Will replace AFT-managed ONNX cache at ${candidate.storageOnnxDir} (${formatBytes(candidate.storageOnnxBytes)}) and download a compatible runtime`
       });
     } else {
       items.push({
         kind: "onnx",
-        message: `Will leave system ONNX untouched and refresh AFT-managed ONNX state for ${candidate.harness.displayName} on next start`
+        message: `Will leave system ONNX untouched and download a compatible AFT-managed runtime for ${candidate.harness.displayName}`
       });
     }
   }
@@ -19648,7 +20724,8 @@ function logDoctorIssues(report) {
 }
 function formatDoctorStorageStatus(h2) {
   const state = h2.storageDir.exists ? h2.storageDir.path : `${h2.storageDir.path} (${h2.pluginRegistered ? "not yet created (lazy — created on first tool call)" : "not created"})`;
-  return `${state} (${formatStorageSizes(h2.storageDir.sizesByKey)})`;
+  const legacyDuplication = formatLegacyDuplication(h2.storageDir.legacyDuplication);
+  return `${state} (${[formatStorageSizes(h2.storageDir.sizesByKey), legacyDuplication].filter((part) => Boolean(part)).join("; ")})`;
 }
 async function confirmBinaryDownloadDespitePluginSkew(report, argv) {
   const skews = findPluginCliVersionSkews(report);
@@ -19678,7 +20755,7 @@ function ensureStorageDirsForRegisteredPlugins(adapters) {
       if (!adapter.isInstalled() || !adapter.hasPluginEntry())
         continue;
       const storageDir = adapter.getStorageDir();
-      if (existsSync21(storageDir))
+      if (existsSync22(storageDir))
         continue;
       mkdirSync7(storageDir, { recursive: true });
       summary.created += 1;
@@ -19760,6 +20837,12 @@ function formatStorageSizes(sizes) {
   const parts = Object.entries(sizes).filter(([, size]) => size > 0).map(([key, size]) => `${key}: ${formatBytes(size)}`);
   return parts.length > 0 ? parts.join(", ") : "empty";
 }
+function formatLegacyDuplication(summary) {
+  if (!summary || summary.totalPartitions === 0)
+    return null;
+  const byHarness = summary.byHarness.map((entry) => `${entry.harness}: ${entry.partitions} partition(s) / ${formatBytes(entry.bytes)}`).join("; ");
+  return `legacy duplication: ${summary.totalPartitions} partition(s), ${formatBytes(summary.totalBytes)} total [${byHarness}]`;
+}
 function isInteractiveTerminal() {
   return process.stdin.isTTY === true && process.stdout.isTTY === true;
 }
@@ -19791,11 +20874,11 @@ function deriveIssueTitleFromBody(body) {
 function writeIssueReviewFile(body) {
   let reviewDir = null;
   try {
-    reviewDir = mkdtempSync(join22(tmpdir4(), "aft-issue-"));
+    reviewDir = mkdtempSync(join23(tmpdir2(), "aft-issue-"));
     if (process.platform !== "win32") {
       chmodSync4(reviewDir, 448);
     }
-    const outPath = join22(reviewDir, "issue.md");
+    const outPath = join23(reviewDir, "issue.md");
     writeFileSync5(outPath, `${body}
 `, { encoding: "utf8", mode: 384, flag: "wx" });
     return { path: outPath, realPath: realpathSync5(outPath) };