@cortexkit/aft 0.49.4 → 0.50.1

package/dist/index.js

@@ -695,7 +695,7 @@ function coerceConfigureDroppedKeys(value) {
 function isBridgeTransportTimeout(err) {
   return err instanceof Error && err.code === "transport_timeout";
 }
-var DEFAULT_BRIDGE_TIMEOUT_MS = 30000, BRIDGE_HANG_TIMEOUT_THRESHOLD = 2, MAX_STDOUT_BUFFER, STDOUT_BUFFER_COMPACT_THRESHOLD, TERMINAL_BASH_STATUSES, binaryFingerprintReader, BENIGN_CPUINFO_PROC_CPUINFO_PARSE_FAILURE = "failed to parse processor information from /proc/cpuinfo", BridgeReplacedDuringVersionCheck, BridgeTransportTimeoutError, BinaryBridge;
+var DEFAULT_BRIDGE_TIMEOUT_MS = 30000, BRIDGE_HANG_TIMEOUT_THRESHOLD = 2, MAX_STDOUT_BUFFER, STDOUT_BUFFER_COMPACT_THRESHOLD, HASHLINE_REGISTRATION_LOG_INTERVAL_MS = 60000, HASHLINE_REGISTRATION_LOG_STATE_LIMIT = 256, TERMINAL_BASH_STATUSES, binaryFingerprintReader, BENIGN_CPUINFO_PROC_CPUINFO_PARSE_FAILURE = "failed to parse processor information from /proc/cpuinfo", BridgeReplacedDuringVersionCheck, BridgeTransportTimeoutError, BinaryBridge;
 var init_bridge = __esm(() => {
   init_active_logger();
   init_command_timeouts();
@@ -753,6 +753,9 @@ var init_bridge = __esm(() => {
     configured = false;
     _configurePromise = null;
     configOverrides;
+    editSlotSurvives;
+    editSlotSurvivesCaptured = false;
+    hashlineRegistrationLogState = new Map;
     minVersion;
     onVersionMismatch;
     onConfigureWarnings;
@@ -769,20 +772,33 @@ var init_bridge = __esm(() => {
     errorPrefix;
     logger;
     childEnv;
-    constructor(binaryPath, cwd, options, configOverrides) {
+    constructor(binaryPath, cwd, options, configOverrides, editSlotSurvives) {
       this.binaryPath = binaryPath;
       this.cwd = cwd;
       this.timeoutMs = options?.timeoutMs ?? DEFAULT_BRIDGE_TIMEOUT_MS;
       this.hangThreshold = options?.hangThreshold ?? BRIDGE_HANG_TIMEOUT_THRESHOLD;
       this.maxRestarts = options?.maxRestarts ?? 3;
-      this.configOverrides = configOverrides ?? {};
+      this.errorPrefix = options?.errorPrefix ?? "[aft-bridge]";
+      this.configOverrides = { ...configOverrides ?? {} };
+      const legacyEditSlotSurvives = this.configOverrides.edit_slot_survives;
+      delete this.configOverrides.edit_slot_survives;
+      if (legacyEditSlotSurvives !== undefined && typeof legacyEditSlotSurvives !== "boolean") {
+        throw new Error(`${this.errorPrefix} edit_slot_survives must be a boolean`);
+      }
+      if (editSlotSurvives !== undefined && legacyEditSlotSurvives !== undefined && editSlotSurvives !== legacyEditSlotSurvives) {
+        throw new Error(`${this.errorPrefix} conflicting edit_slot_survives construction values`);
+      }
+      const capturedEditSlotSurvives = editSlotSurvives ?? legacyEditSlotSurvives;
+      if (typeof capturedEditSlotSurvives === "boolean") {
+        this.editSlotSurvives = capturedEditSlotSurvives;
+        this.editSlotSurvivesCaptured = true;
+      }
       this.minVersion = options?.minVersion;
       this.onVersionMismatch = options?.onVersionMismatch;
       this.onConfigureWarnings = options?.onConfigureWarnings;
       this.onBashCompletion = options?.onBashCompletion;
       this.onBashLongRunning = options?.onBashLongRunning;
       this.onBashPatternMatch = options?.onBashPatternMatch;
-      this.errorPrefix = options?.errorPrefix ?? "[aft-bridge]";
       this.logger = options?.logger;
       this.childEnv = options?.childEnv;
     }
@@ -893,13 +909,54 @@ var init_bridge = __esm(() => {
     cacheStatusSnapshot(snapshot) {
       this.cachedStatus = snapshot;
     }
+    setEditSlotSurvives(value) {
+      if (this.editSlotSurvivesCaptured) {
+        throw new Error(`${this.errorPrefix} edit_slot_survives is write-once and was already captured`);
+      }
+      this.editSlotSurvives = value;
+      this.editSlotSurvivesCaptured = true;
+    }
+    logHashlineRegistrationCarrier(phase, sessionId, editSlotSurvives) {
+      const session = sessionId && sessionId.length > 0 ? sessionId : "__default__";
+      const key = `${phase}\x00${session}\x00${String(editSlotSurvives)}`;
+      const now = Date.now();
+      const state = this.hashlineRegistrationLogState.get(key);
+      if (state && now - state.lastEmittedAt < HASHLINE_REGISTRATION_LOG_INTERVAL_MS) {
+        state.suppressed += 1;
+        return;
+      }
+      const repeated = state && state.suppressed > 0 ? ` repeated=${state.suppressed + 1}` : "";
+      if (!state && this.hashlineRegistrationLogState.size >= HASHLINE_REGISTRATION_LOG_STATE_LIMIT) {
+        const oldest = this.hashlineRegistrationLogState.keys().next().value;
+        if (oldest !== undefined)
+          this.hashlineRegistrationLogState.delete(oldest);
+      }
+      this.hashlineRegistrationLogState.set(key, { lastEmittedAt: now, suppressed: 0 });
+      this.sessionLogVia(sessionId, `hashline registration carrier transport=ndjson phase=${phase} edit_slot_survives=${editSlotSurvives}${repeated}`);
+    }
     async send(command, params = {}, options) {
-      return this.sendWithVersionMismatchRetry(command, params, options, true);
+      let dispatchParams = params;
+      if (command === "configure") {
+        dispatchParams = { ...params };
+        delete dispatchParams.edit_slot_survives;
+        const editSlotSurvives = this.editSlotSurvives;
+        if (this.editSlotSurvivesCaptured && typeof editSlotSurvives === "boolean") {
+          dispatchParams.edit_slot_survives = editSlotSurvives;
+          const sessionId = typeof dispatchParams.session_id === "string" ? dispatchParams.session_id : undefined;
+          this.logHashlineRegistrationCarrier("configure", sessionId, editSlotSurvives);
+        }
+      }
+      return this.sendWithVersionMismatchRetry(command, dispatchParams, options, true);
     }
     async toolCall(sessionId, name, rawArgs = {}, options) {
       const params = { name, arguments: rawArgs };
       if (sessionId)
         params.session_id = sessionId;
+      const editSlotSurvives = this.editSlotSurvives;
+      if (this.editSlotSurvivesCaptured && typeof editSlotSurvives === "boolean") {
+        params.edit_slot_survives = editSlotSurvives;
+        this.logHashlineRegistrationCarrier("tool_call", sessionId, editSlotSurvives);
+      }
       const { preview, ...sendOptions } = options ?? {};
       if (preview === true)
         params.preview = true;
@@ -2019,7 +2076,8 @@ var init_platform = __esm(() => {
 // ../aft-bridge/dist/downloader.js
 import { spawnSync } from "node:child_process";
 import { createHash as createHash2, randomUUID } from "node:crypto";
-import { chmodSync, closeSync, copyFileSync, createWriteStream, existsSync as existsSync2, mkdirSync, openSync, readFileSync as readFileSync3, renameSync, rmSync, statSync as statSync2, unlinkSync, writeSync } from "node:fs";
+import { chmodSync, closeSync, copyFileSync, createWriteStream, existsSync as existsSync2, mkdirSync, openSync, readdirSync, readFileSync as readFileSync3, renameSync, rmSync, statSync as statSync2, unlinkSync, writeSync } from "node:fs";
+import { hostname } from "node:os";
 import { join as join4 } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
@@ -2090,11 +2148,37 @@ async function downloadBinary(version) {
   let binaryTimeout = null;
   let checksumTimeout = null;
   const tmpPath = `${binaryPath}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`;
+  const cleanUpPartialDownload = () => {
+    try {
+      if (existsSync2(tmpPath))
+        unlinkSync(tmpPath);
+    } catch {}
+  };
+  let interrupted = false;
+  const cleanUpInterruptedDownload = () => {
+    if (interrupted)
+      return;
+    interrupted = true;
+    binaryController?.abort();
+    checksumController?.abort();
+    cleanUpPartialDownload();
+    releaseLock?.();
+    releaseLock = null;
+  };
+  const handleSigint = () => {
+    cleanUpInterruptedDownload();
+    process.off("SIGINT", handleSigint);
+    process.kill(process.pid, "SIGINT");
+  };
+  const handleExit = () => cleanUpInterruptedDownload();
+  process.once("SIGINT", handleSigint);
+  process.once("exit", handleExit);
   try {
     if (!existsSync2(versionedCacheDir)) {
       mkdirSync(versionedCacheDir, { recursive: true });
     }
     releaseLock = await acquireDownloadLock(lockPath);
+    sweepStaleDownloadTemps(versionedCacheDir, binaryName);
     if (existsSync2(binaryPath) && isExpectedCachedBinary(binaryPath, tag)) {
       return binaryPath;
     }
@@ -2170,13 +2254,11 @@ async function downloadBinary(version) {
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     error(`Failed to download AFT binary: ${msg}`);
-    if (existsSync2(tmpPath)) {
-      try {
-        unlinkSync(tmpPath);
-      } catch {}
-    }
+    cleanUpPartialDownload();
     return null;
   } finally {
+    process.off("SIGINT", handleSigint);
+    process.off("exit", handleExit);
     if (binaryTimeout) {
       binaryController?.abort();
       clearTimeout(binaryTimeout);
@@ -2202,17 +2284,85 @@ async function ensureBinary(version) {
   log("No cached binary found, downloading latest...");
   return downloadBinary();
 }
-async function acquireDownloadLock(lockPath) {
+function createDownloadLockOwner() {
+  return JSON.stringify({
+    pid: process.pid,
+    hostname: hostname(),
+    createdAt: Date.now(),
+    token: randomUUID()
+  });
+}
+function parseDownloadLockOwner(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null) {
+      const { pid, hostname: ownerHostname } = parsed;
+      return {
+        pid: typeof pid === "number" && Number.isSafeInteger(pid) && pid > 0 ? pid : null,
+        hostname: typeof ownerHostname === "string" && ownerHostname ? ownerHostname : null
+      };
+    }
+  } catch {}
+  const legacyPid = Number(raw.split(":", 1)[0]);
+  return {
+    pid: Number.isSafeInteger(legacyPid) && legacyPid > 0 ? legacyPid : null,
+    hostname: null
+  };
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code !== "ESRCH";
+  }
+}
+function isReclaimableDownloadLock(owner, ageMs, staleMs) {
+  if (Math.abs(ageMs) > staleMs)
+    return true;
+  return (owner.hostname === null || owner.hostname === hostname()) && owner.pid !== null && !isProcessAlive(owner.pid);
+}
+function reclaimDownloadLock(lockPath, expectedOwner) {
+  try {
+    if (readFileSync3(lockPath, "utf-8") !== expectedOwner)
+      return false;
+    rmSync(lockPath, { force: true });
+    return true;
+  } catch (err) {
+    if (err.code === "ENOENT")
+      return true;
+    throw err;
+  }
+}
+function sweepStaleDownloadTemps(versionedCacheDir, binaryName) {
+  const tempPrefix = `${binaryName}.`;
+  try {
+    for (const entry of readdirSync(versionedCacheDir, { withFileTypes: true })) {
+      if (!entry.isFile() || !entry.name.startsWith(tempPrefix) || !entry.name.endsWith(".tmp")) {
+        continue;
+      }
+      const tempPath = join4(versionedCacheDir, entry.name);
+      const ageMs = Date.now() - statSync2(tempPath).mtimeMs;
+      if (Math.abs(ageMs) > DOWNLOAD_LOCK_STALE_MS)
+        unlinkSync(tempPath);
+    }
+  } catch {}
+}
+async function acquireDownloadLock(lockPath, timing = {}) {
+  const timeoutMs = timing.timeoutMs ?? DOWNLOAD_LOCK_TIMEOUT_MS;
+  const staleMs = timing.staleMs ?? DOWNLOAD_LOCK_STALE_MS;
+  const pollIntervalMs = timing.pollIntervalMs ?? 100;
   const startedAt = Date.now();
   while (true) {
     try {
-      const owner = `${process.pid}:${Date.now()}:${randomUUID()}`;
+      const owner = createDownloadLockOwner();
       const fd = openSync(lockPath, "wx");
-      writeSync(fd, owner);
+      try {
+        writeSync(fd, owner);
+      } finally {
+        closeSync(fd);
+      }
       return () => {
-        try {
-          closeSync(fd);
-        } catch {}
         try {
           if (readFileSync3(lockPath, "utf-8") === owner) {
             rmSync(lockPath, { force: true });
@@ -2223,19 +2373,24 @@ async function acquireDownloadLock(lockPath) {
       const code = err.code;
       if (code !== "EEXIST")
         throw err;
+      let existingOwner;
+      let ageMs;
       try {
-        const ageMs = Date.now() - statSync2(lockPath).mtimeMs;
-        if (ageMs > DOWNLOAD_LOCK_STALE_MS) {
-          rmSync(lockPath, { force: true });
+        existingOwner = readFileSync3(lockPath, "utf-8");
+        ageMs = Date.now() - statSync2(lockPath).mtimeMs;
+      } catch (readErr) {
+        if (readErr.code === "ENOENT")
+          continue;
+        throw readErr;
+      }
+      if (isReclaimableDownloadLock(parseDownloadLockOwner(existingOwner), ageMs, staleMs)) {
+        if (reclaimDownloadLock(lockPath, existingOwner))
           continue;
-        }
-      } catch {
-        continue;
       }
-      if (Date.now() - startedAt > DOWNLOAD_LOCK_TIMEOUT_MS) {
+      if (Date.now() - startedAt > timeoutMs) {
         throw new Error(`Timed out waiting for download lock: ${lockPath}`);
       }
-      await new Promise((resolve3) => setTimeout(resolve3, 100));
+      await new Promise((resolve3) => setTimeout(resolve3, pollIntervalMs));
     }
   }
 }
@@ -2270,7 +2425,7 @@ async function fetchLatestTag() {
     clearTimeout(timeout);
   }
 }
-var REPO = "cortexkit/aft", DOWNLOAD_TIMEOUT_MS = 300000, LATEST_TAG_TIMEOUT_MS = 30000, MAX_DOWNLOAD_BYTES, DOWNLOAD_LOCK_TIMEOUT_MS = 120000, DOWNLOAD_LOCK_STALE_MS;
+var REPO = "cortexkit/aft", DOWNLOAD_TIMEOUT_MS = 300000, LATEST_TAG_TIMEOUT_MS = 30000, MAX_DOWNLOAD_BYTES, DOWNLOAD_LOCK_STALE_MS, DOWNLOAD_LOCK_TIMEOUT_MS;
 var init_downloader = __esm(() => {
   init_active_logger();
   init_cache_paths();
@@ -2278,6 +2433,7 @@ var init_downloader = __esm(() => {
   init_cache_paths();
   MAX_DOWNLOAD_BYTES = 200 * 1024 * 1024;
   DOWNLOAD_LOCK_STALE_MS = 10 * 60000;
+  DOWNLOAD_LOCK_TIMEOUT_MS = DOWNLOAD_LOCK_STALE_MS + 30000;
 });
 
 // ../aft-bridge/dist/durable-log.js
@@ -5112,12 +5268,15 @@ class BgSubscription {
   canAttach;
   onRootAttachFailure;
   onDormant;
+  dispatchProbeIntervalMs;
   nudgeRef;
   isCurrent;
   stopped = false;
   current = null;
   loop;
-  constructor(identity, acquireClient, dropClient, consumerIdentity, onNudge, sleep2, canAttach, onRootAttachFailure, onDormant, nudgeRef, isCurrent = () => true) {
+  lifecycleLogState = new Map;
+  nudgeReceiptLogState = null;
+  constructor(identity, acquireClient, dropClient, consumerIdentity, onNudge, sleep2, canAttach, onRootAttachFailure, onDormant, dispatchProbeIntervalMs, nudgeRef, isCurrent = () => true) {
     this.identity = identity;
     this.acquireClient = acquireClient;
     this.dropClient = dropClient;
@@ -5127,6 +5286,7 @@ class BgSubscription {
     this.canAttach = canAttach;
     this.onRootAttachFailure = onRootAttachFailure;
     this.onDormant = onDormant;
+    this.dispatchProbeIntervalMs = dispatchProbeIntervalMs;
     this.nudgeRef = nudgeRef;
     this.isCurrent = isCurrent;
     this.loop = this.run();
@@ -5143,25 +5303,106 @@ class BgSubscription {
       return;
     });
   }
+  info(kind, message) {
+    const now = Date.now();
+    const state = this.lifecycleLogState.get(kind);
+    if (state && now - state.lastEmittedAt < BG_LIFECYCLE_LOG_INTERVAL_MS) {
+      state.suppressed += 1;
+      return;
+    }
+    const suppressed = state?.suppressed ?? 0;
+    this.lifecycleLogState.set(kind, { lastEmittedAt: now, suppressed: 0 });
+    const suffix = suppressed > 0 ? ` suppressed=${suppressed}` : "";
+    log(`subc bg_events: ${message}${suffix}`, { sessionId: this.identity.session });
+  }
+  routeId(route) {
+    return `${route.channel}@${route.epoch}`;
+  }
+  recordNudgeReceipt(routeId) {
+    const now = Date.now();
+    const state = this.nudgeReceiptLogState;
+    if (state && now - state.lastEmittedAt < BG_LIFECYCLE_LOG_INTERVAL_MS) {
+      state.count += 1;
+      return;
+    }
+    const count = (state?.count ?? 0) + 1;
+    this.nudgeReceiptLogState = { lastEmittedAt: now, count: 0 };
+    log(`subc bg_events: nudge received channel=${routeId} count=${count}`, {
+      sessionId: this.identity.session
+    });
+  }
+  errorText(error2) {
+    return error2 instanceof Error ? `${error2.name}: ${error2.message}` : String(error2);
+  }
+  startDispatchProbe(client, routeId) {
+    const initial = client.droppedIngressFrames;
+    if (typeof initial !== "number")
+      return () => {
+        return;
+      };
+    let previous = initial;
+    const timer = setInterval(() => {
+      const total = client.droppedIngressFrames;
+      if (typeof total !== "number" || total <= previous)
+        return;
+      const delta = total - previous;
+      previous = total;
+      this.info("dispatch-epoch-drop", `client ingress epoch drops scope=client observed_while_channel=${routeId} delta=${delta} total=${total}`);
+    }, this.dispatchProbeIntervalMs);
+    timer.unref?.();
+    return () => clearInterval(timer);
+  }
   async run() {
-    let attempt = 0;
+    let backoffAttempt = 0;
+    let reconnectAttempt = 0;
+    let reconnecting = false;
+    const beginReconnect = () => {
+      reconnecting = true;
+      reconnectAttempt = reconnectAttempt === 0 ? 1 : reconnectAttempt + 1;
+    };
+    const giveUp = (reason) => {
+      this.info("reconnect-gave-up", `reconnect gave-up attempt=${reconnectAttempt} reason=${reason}`);
+    };
     while (!this.stopped) {
-      if (!this.isCurrent())
+      if (!this.isCurrent()) {
+        if (reconnecting)
+          giveUp("stale-session");
         return;
+      }
       if (!this.canAttach()) {
+        if (reconnecting)
+          giveUp("root-dormant");
         this.onDormant();
         return;
       }
+      if (reconnecting) {
+        this.info("reconnect-attempt", `reconnect attempt=${reconnectAttempt}`);
+      }
       let client;
       try {
         client = await this.acquireClient();
-      } catch {
-        await this.backoff(attempt++);
+      } catch (err) {
+        if (!reconnecting)
+          beginReconnect();
+        this.info("reconnect-error", `reconnect error attempt=${reconnectAttempt} error=${this.errorText(err)}`);
+        await this.backoff(backoffAttempt++);
+        if (reconnecting)
+          reconnectAttempt += 1;
         continue;
       }
-      if (this.stopped || !this.isCurrent())
+      if (this.stopped) {
+        if (reconnecting)
+          giveUp("stopped");
         return;
+      }
+      if (!this.isCurrent()) {
+        if (reconnecting)
+          giveUp("stale-session");
+        return;
+      }
       if (!this.canAttach()) {
+        if (reconnecting)
+          giveUp("root-dormant");
         this.onDormant();
         return;
       }
@@ -5170,44 +5411,84 @@ class BgSubscription {
         route = await client.routeOpen({ kind: "tool_provider", module_id: AFT_MODULE_ID }, this.identity, { consumerIdentity: this.consumerIdentity });
       } catch (err) {
         if (this.isCurrent() && this.onRootAttachFailure(err)) {
+          if (reconnecting)
+            giveUp("root-dormant");
           this.onDormant();
           return;
         }
         if (isConsumerReconnectTransient(err))
           this.dropClient(client);
-        await this.backoff(attempt++);
+        if (!reconnecting)
+          beginReconnect();
+        this.info("reconnect-error", `reconnect error attempt=${reconnectAttempt} error=${this.errorText(err)}`);
+        await this.backoff(backoffAttempt++);
+        if (reconnecting)
+          reconnectAttempt += 1;
         continue;
       }
       if (this.stopped || !this.isCurrent()) {
         safeCloseRoute(client, route);
+        if (reconnecting)
+          giveUp(this.stopped ? "stopped" : "stale-session");
         return;
       }
       const subscribedAt = Date.now();
+      const routeId = this.routeId(route);
+      let stopDispatchProbe = () => {
+        return;
+      };
       try {
         const sub = client.subscribe(route, { op: "bg_events" }, () => {
-          if (!this.stopped && this.isCurrent())
-            this.onNudge();
+          if (this.stopped) {
+            this.info("nudge-drop-stopped", `nudge dropped cause=subscription-stopped channel=${routeId}`);
+            return;
+          }
+          this.recordNudgeReceipt(routeId);
+          if (!this.isCurrent()) {
+            this.info("nudge-stale-carrier", `nudge carried by stale subscription; checking current session channel=${routeId}`);
+          }
+          this.onNudge();
         });
         this.current = sub;
+        stopDispatchProbe = this.startDispatchProbe(client, routeId);
+        this.info("subscription-open", `subscription open channel=${routeId}`);
+        if (reconnecting) {
+          this.info("reconnect-success", `reconnect success attempt=${reconnectAttempt} channel=${routeId}`);
+          reconnecting = false;
+          reconnectAttempt = 0;
+        }
         if (this.stopped)
           sub.unsubscribe();
         if (!this.stopped && this.isCurrent())
           this.onNudge();
         await sub.closed;
-        return;
+        this.info("stream-end", `stream ended channel=${routeId}`);
+        if (this.stopped) {
+          giveUp("stopped");
+          return;
+        }
+        beginReconnect();
       } catch (err) {
-        if (this.stopped)
+        const routeId2 = this.routeId(route);
+        this.info("stream-error", `stream error channel=${routeId2} error=${this.errorText(err)}`);
+        if (this.stopped) {
+          giveUp("stopped");
           return;
+        }
         if (isConsumerReconnectTransient(err))
           this.dropClient(client);
         if (Date.now() - subscribedAt >= BG_STABLE_MS)
-          attempt = 0;
+          backoffAttempt = 0;
+        beginReconnect();
       } finally {
+        stopDispatchProbe();
         this.current = null;
         safeCloseRoute(client, route);
       }
-      await this.backoff(attempt++);
+      await this.backoff(backoffAttempt++);
     }
+    if (reconnecting)
+      giveUp("stopped");
   }
   async backoff(attempt) {
     const ms = Math.min(100 * 2 ** Math.min(attempt, 6), 2000);
@@ -5302,6 +5583,9 @@ class SubcTransport {
     this.assertCurrent();
     const { preview, timeoutMs, onProgress } = this.splitOptions(options);
     const body = { name, arguments: rawArgs };
+    const editSlotSurvives = this.pool.getEditSlotSurvives();
+    if (editSlotSurvives !== undefined)
+      body.edit_slot_survives = editSlotSurvives;
     if (preview === true)
       body.preview = true;
     const reply = await this.pool.routeRequest(this.identityFor(sessionId), body, timeoutMs, onProgress, this.generation);
@@ -5316,7 +5600,11 @@ class SubcTransport {
     }
     const { timeoutMs, onProgress } = this.splitOptions(options);
     const session = typeof params.session_id === "string" ? params.session_id : undefined;
-    const reply = await this.pool.routeRequest(this.identityFor(session), { name: command, arguments: params }, timeoutMs, onProgress, this.generation);
+    const body = { name: command, arguments: params };
+    const editSlotSurvives = this.pool.getEditSlotSurvives();
+    if (editSlotSurvives !== undefined)
+      body.edit_slot_survives = editSlotSurvives;
+    const reply = await this.pool.routeRequest(this.identityFor(session), body, timeoutMs, onProgress, this.generation);
     const response = reliftReply(reply);
     this.captureStatusBar(response);
     return response;
@@ -5340,6 +5628,7 @@ class SubcTransportPool {
   onBgEventsNudge;
   onBgEventsNudgeRef;
   bgBackoffSleep;
+  bgDispatchProbeIntervalMs;
   lifecycleDemandCheck;
   onLifecycleEvent;
   onBgNudgeRejected;
@@ -5355,8 +5644,11 @@ class SubcTransportPool {
   transportFailures = 0;
   transports = new Map;
   generationRejections = new Set;
+  nudgeDeliveryLogState = new Map;
   pendingRootCleanups = new Set;
   shuttingDown = false;
+  editSlotSurvives;
+  editSlotSurvivesCaptured = false;
   constructor(options) {
     this.connectionFile = options.connectionFile;
     this.harness = options.harness;
@@ -5366,6 +5658,7 @@ class SubcTransportPool {
     this.onBgEventsNudge = options.onBgEventsNudge;
     this.onBgEventsNudgeRef = options.onBgEventsNudgeRef;
     this.bgBackoffSleep = options.bgBackoffSleep ?? ((ms) => new Promise((resolve4) => setTimeout(resolve4, ms)));
+    this.bgDispatchProbeIntervalMs = options.bgDispatchProbeIntervalMs ?? BG_DISPATCH_PROBE_INTERVAL_MS;
     const lifecycle = options.lifecycle;
     const demandCheck = options.lifecycleDemandCheck ?? options.demandCheck ?? lifecycle?.demandCheck;
     this.lifecycleDemandCheck = demandCheck;
@@ -5682,6 +5975,35 @@ class SubcTransportPool {
   isCurrentSession(key, record) {
     return this.sessions.get(key) === record && !record.closed;
   }
+  currentSessionForNudge(identity) {
+    const current = this.sessions.get(identityKey(identity));
+    return current && !current.closed ? current : null;
+  }
+  nudgeRefFor(record) {
+    const poolId = this.currentPoolId();
+    const generation = record.generation;
+    if (poolId === undefined || generation === undefined)
+      return;
+    return {
+      canonicalRoot: record.canonicalRoot,
+      session: record.identity.session,
+      concretePoolId: poolId,
+      generation
+    };
+  }
+  logNudgeDelivery(kind, record, message) {
+    const key = `${kind}\x00${record.identityKey}`;
+    const now = Date.now();
+    const state = this.nudgeDeliveryLogState.get(key);
+    if (state && now - state.lastEmittedAt < BG_LIFECYCLE_LOG_INTERVAL_MS) {
+      state.suppressed += 1;
+      return;
+    }
+    const suppressed = state?.suppressed ?? 0;
+    this.nudgeDeliveryLogState.set(key, { lastEmittedAt: now, suppressed: 0 });
+    const suffix = suppressed > 0 ? ` suppressed=${suppressed}` : "";
+    log(`subc bg_events: ${message}${suffix}`, { sessionId: record.identity.session });
+  }
   removeIndexMembership(record) {
     const keys = this.rootIndex.get(record.canonicalRoot);
     if (!keys)
@@ -5935,20 +6257,32 @@ class SubcTransportPool {
       return;
     if (record.bgSub)
       return;
-    const poolId = this.currentPoolId();
-    const generation = record.generation;
-    const nudgeRef = poolId !== undefined && generation !== undefined ? {
-      canonicalRoot: record.canonicalRoot,
-      session: identity.session,
-      concretePoolId: poolId,
-      generation
-    } : undefined;
+    const nudgeRef = this.nudgeRefFor(record);
     const onNudge = () => {
-      if (!this.isCurrentSession(record.identityKey, record))
+      const currentRecord = this.currentSessionForNudge(identity);
+      if (!currentRecord) {
+        this.logNudgeDelivery("drop-no-current-session", record, `nudge dropped cause=no-current-session root=${record.canonicalRoot}`);
         return;
-      this.onBgEventsNudge?.(identity.project_root, identity.session);
-      if (nudgeRef)
-        this.onBgEventsNudgeRef?.(nudgeRef);
+      }
+      if (currentRecord !== record) {
+        this.logNudgeDelivery("forward-superseded-carrier", currentRecord, `nudge forwarding cause=superseded-carrying-record root=${currentRecord.canonicalRoot}`);
+      }
+      const currentRef = this.nudgeRefFor(currentRecord);
+      let delivered = false;
+      if (currentRef && this.onBgEventsNudgeRef) {
+        this.onBgEventsNudgeRef(currentRef);
+        delivered = true;
+      }
+      if (this.onBgEventsNudge) {
+        if (!currentRef && this.onBgEventsNudgeRef) {
+          this.logNudgeDelivery("fallback-missing-generation", currentRecord, `nudge dispatch fallback=root-session-handler cause=generation-provenance-unavailable root=${currentRecord.canonicalRoot}`);
+        }
+        this.onBgEventsNudge(currentRecord.identity.project_root, currentRecord.identity.session);
+        delivered = true;
+      }
+      if (delivered)
+        return;
+      this.logNudgeDelivery("drop-no-compatible-handler", currentRecord, `nudge dropped cause=generation-provenance-unavailable-and-root-session-handler-unwired root=${currentRecord.canonicalRoot}`);
     };
     let sub = null;
     const clearDormantSubscription = () => {
@@ -5960,7 +6294,7 @@ class SubcTransportPool {
         return false;
       this.markRootDormant(record.canonicalRoot, error2);
       return true;
-    }, clearDormantSubscription, nudgeRef, () => this.isCurrentSession(record.identityKey, record) && this.isCurrentLiveGeneration(record.canonicalRoot, record.generation));
+    }, clearDormantSubscription, this.bgDispatchProbeIntervalMs, nudgeRef, () => this.isCurrentSession(record.identityKey, record) && this.isCurrentLiveGeneration(record.canonicalRoot, record.generation));
     record.bgSub = sub;
     if (!this.rootCanAttach(record.canonicalRoot)) {
       record.bgSub = null;
@@ -6022,7 +6356,21 @@ class SubcTransportPool {
       return Promise.resolve();
     return registry.requestProjectRootClose(registration.concretePoolId, root, generation, cause);
   }
-  setConfigureOverride(_key, _value) {}
+  setConfigureOverride(key, value) {
+    if (key !== "edit_slot_survives")
+      return;
+    if (typeof value !== "boolean") {
+      throw new Error("edit_slot_survives must be set once to a boolean");
+    }
+    if (this.editSlotSurvivesCaptured) {
+      throw new Error("edit_slot_survives is write-once and was already captured");
+    }
+    this.editSlotSurvives = value;
+    this.editSlotSurvivesCaptured = true;
+  }
+  getEditSlotSurvives() {
+    return this.editSlotSurvives;
+  }
   async reconfigure(_projectRoot, _overrides) {}
   async replaceBinary(path2) {
     return path2;
@@ -6081,7 +6429,7 @@ function resolveBridgeForNudge(pool, ref) {
     currentConcretePoolId: candidate.getConcretePoolId?.()
   });
 }
-var AFT_MODULE_ID = "aft", MAX_CONSECUTIVE_TRANSPORT_FAILURES = 3, BG_STABLE_MS = 5000, DEFAULT_SESSION_ID = "__default__", LOCALLY_SATISFIED_COMMANDS, SubcRootReapedError, SubcRootGenerationExpiredError, SubcRootDemandRequiredError, RouteTornDownError;
+var AFT_MODULE_ID = "aft", MAX_CONSECUTIVE_TRANSPORT_FAILURES = 3, BG_STABLE_MS = 5000, BG_LIFECYCLE_LOG_INTERVAL_MS = 60000, BG_DISPATCH_PROBE_INTERVAL_MS = 60000, DEFAULT_SESSION_ID = "__default__", LOCALLY_SATISFIED_COMMANDS, SubcRootReapedError, SubcRootGenerationExpiredError, SubcRootDemandRequiredError, RouteTornDownError;
 var init_subc_transport = __esm(() => {
   init_dist();
   init_active_logger();
@@ -6141,20 +6489,34 @@ function toolErrorFromResponse(command, response) {
   const message = typeof response.message === "string" && response.message.length > 0 ? response.message : `${command} failed`;
   return new AftToolError(message, code, response);
 }
+function isRouteGoodbyeError(error2) {
+  if (!(error2 instanceof SubcError))
+    return false;
+  if (error2.code === undefined) {
+    return error2.message.includes("route closed by subc");
+  }
+  return error2.code === "route_closed" && error2.message.includes("route closed by subc");
+}
 function isTransportClassError(error2) {
   return isBridgeTransportTimeout(error2) || isConsumerReconnectTransient(error2) || error2 instanceof StaleRouteHandleError || error2 instanceof SubcRootGenerationExpiredError || error2 instanceof SubcRootReapedError;
 }
 function adaptToolError(command, error2) {
-  if (command !== "bash" || !isTransportClassError(error2))
-    return error2;
   if (!(error2 instanceof Error))
     return error2;
+  if (isRouteGoodbyeError(error2)) {
+    if (error2.message.includes(SUBC_MODULE_RESTART_DISPOSITION))
+      return error2;
+    error2.message = error2.message ? `${error2.message} ${SUBC_MODULE_RESTART_DISPOSITION}` : SUBC_MODULE_RESTART_DISPOSITION;
+    return error2;
+  }
+  if (command !== "bash" || !isTransportClassError(error2))
+    return error2;
   if (error2.message.includes(BASH_TRANSPORT_DISPOSITION))
     return error2;
   error2.message = error2.message ? `${error2.message} ${BASH_TRANSPORT_DISPOSITION}` : BASH_TRANSPORT_DISPOSITION;
   return error2;
 }
-var AftToolError, BASH_TRANSPORT_DISPOSITION = "The transport to the AFT daemon was interrupted; no background task was created for this command and no task ID exists. Re-run the command. Do not poll bash_status for it.";
+var AftToolError, BASH_TRANSPORT_DISPOSITION = "The transport to the AFT daemon was interrupted; no background task was created for this command and no task ID exists. Re-run the command. Do not poll bash_status for it.", SUBC_MODULE_RESTART_DISPOSITION = "The AFT daemon module restarted while this call was in flight, so its outcome is UNKNOWN: it may or may not have executed. Verify actual state before re-running, and never blind-retry a mutation.";
 var init_error_contract = __esm(() => {
   init_dist();
   init_bridge();
@@ -7028,7 +7390,7 @@ var init_migration = __esm(() => {
 
 // ../aft-bridge/dist/npm-resolver.js
 import { execFileSync } from "node:child_process";
-import { readdirSync, statSync as statSync5 } from "node:fs";
+import { readdirSync as readdirSync2, statSync as statSync5 } from "node:fs";
 import { homedir as homedir9 } from "node:os";
 import { delimiter, dirname as dirname4, isAbsolute as isAbsolute3, join as join9 } from "node:path";
 function defaultDeps() {
@@ -7068,7 +7430,7 @@ function npmAdjacentToNode(deps) {
 function highestVersionedNodeBin(installsDir, name) {
   let entries;
   try {
-    entries = readdirSync(installsDir);
+    entries = readdirSync2(installsDir);
   } catch {
     return null;
   }
@@ -7163,7 +7525,7 @@ var init_npm_resolver = () => {};
 // ../aft-bridge/dist/onnx-runtime.js
 import { execFileSync as execFileSync2 } from "node:child_process";
 import { createHash as createHash4 } from "node:crypto";
-import { chmodSync as chmodSync3, closeSync as closeSync4, copyFileSync as copyFileSync3, createWriteStream as createWriteStream2, existsSync as existsSync7, lstatSync, mkdirSync as mkdirSync5, openSync as openSync4, readdirSync as readdirSync2, readFileSync as readFileSync6, readlinkSync, realpathSync as realpathSync2, rmSync as rmSync3, statSync as statSync6, symlinkSync, unlinkSync as unlinkSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { chmodSync as chmodSync3, closeSync as closeSync4, copyFileSync as copyFileSync3, createWriteStream as createWriteStream2, existsSync as existsSync7, lstatSync, mkdirSync as mkdirSync5, openSync as openSync4, readdirSync as readdirSync3, readFileSync as readFileSync6, readlinkSync, realpathSync as realpathSync2, rmSync as rmSync3, statSync as statSync6, symlinkSync, unlinkSync as unlinkSync4, writeFileSync as writeFileSync3 } from "node:fs";
 import { basename as basename2, dirname as dirname5, isAbsolute as isAbsolute4, join as join10, relative as relative2, resolve as resolve6, win32 } from "node:path";
 import { Readable as Readable2 } from "node:stream";
 import { pipeline as pipeline2 } from "node:stream/promises";
@@ -7240,7 +7602,7 @@ async function ensureOnnxRuntime(storageDir) {
 }
 function cleanupAbandonedStagingDirs(onnxBaseDir) {
   try {
-    const entries = readdirSync2(onnxBaseDir);
+    const entries = readdirSync3(onnxBaseDir);
     for (const entry of entries) {
       if (!entry.startsWith(`${ORT_VERSION}.tmp.`))
         continue;
@@ -7251,7 +7613,7 @@ function cleanupAbandonedStagingDirs(onnxBaseDir) {
       let abandoned = false;
       if (Number.isFinite(pid) && pid > 0) {
         if (process.platform === "win32") {
-          const ownerAlive = isProcessAlive(pid);
+          const ownerAlive = isProcessAlive2(pid);
           if (!ownerAlive) {
             abandoned = true;
           } else {
@@ -7263,7 +7625,7 @@ function cleanupAbandonedStagingDirs(onnxBaseDir) {
             }
           }
         } else {
-          abandoned = !isProcessAlive(pid);
+          abandoned = !isProcessAlive2(pid);
         }
       } else {
         abandoned = true;
@@ -7315,7 +7677,7 @@ function isPathInsideRoot(root, candidate) {
 }
 function detectOnnxVersion(libDir, libName) {
   try {
-    const entries = readdirSync2(libDir);
+    const entries = readdirSync3(libDir);
     const barePrefix = libName.replace(/\.(so|dylib|dll)$/, "");
     const expectedPrefix = process.platform === "win32" ? barePrefix.toLowerCase() : barePrefix;
     for (const entry of entries) {
@@ -7378,7 +7740,7 @@ function isWindowsSystem32Directory(dir) {
 }
 function directoryContainsLibrary(dir, libName) {
   try {
-    const entries = readdirSync2(dir);
+    const entries = readdirSync3(dir);
     if (process.platform === "win32") {
       const expected = libName.toLowerCase();
       return entries.some((entry) => entry.toLowerCase() === expected);
@@ -7416,7 +7778,7 @@ function findSystemOnnxRuntime(libName) {
       if (!existsSync7(nugetPackageDir))
         return nugetPaths;
       try {
-        for (const entry of readdirSync2(nugetPackageDir, { withFileTypes: true })) {
+        for (const entry of readdirSync3(nugetPackageDir, { withFileTypes: true })) {
           if (!entry.isDirectory())
             continue;
           if (entry.name === "__globalPackagesFolder" || entry.name.startsWith("."))
@@ -7511,7 +7873,7 @@ function validateExtractedTree(stagingRoot) {
   const realRoot = realpathSync2(stagingRoot);
   let totalBytes = 0;
   const walk = (dir) => {
-    const entries = readdirSync2(dir);
+    const entries = readdirSync3(dir);
     for (const entry of entries) {
       const fullPath = join10(dir, entry);
       const lst = lstatSync(fullPath);
@@ -7569,7 +7931,7 @@ async function downloadOnnxRuntime(info, targetDir) {
       throw new Error(`Expected directory not found: ${extractedDir}`);
     }
     mkdirSync5(targetDir, { recursive: true });
-    const libFiles = readdirSync2(extractedDir).filter((f) => f.startsWith("libonnxruntime") || f.startsWith("onnxruntime"));
+    const libFiles = readdirSync3(extractedDir).filter((f) => f.startsWith("libonnxruntime") || f.startsWith("onnxruntime"));
     const realFiles = [];
     const symlinks = [];
     for (const libFile of libFiles) {
@@ -7747,7 +8109,7 @@ ${new Date().toISOString()}
   }
   const age = Date.now() - lockMtimeMs;
   const ageWithinFresh = Math.abs(age) < STALE_LOCK_MS;
-  const ownerAlive = owningPid !== null && isProcessAlive(owningPid);
+  const ownerAlive = owningPid !== null && isProcessAlive2(owningPid);
   if (ownerAlive && ageWithinFresh) {
     return false;
   }
@@ -7811,7 +8173,7 @@ function isWindowsProcessAlive(pid) {
     return false;
   }
 }
-function isProcessAlive(pid) {
+function isProcessAlive2(pid) {
   if (process.platform === "win32")
     return isWindowsProcessAlive(pid);
   try {
@@ -8223,6 +8585,19 @@ function parseEditArray(value) {
   }
   return value;
 }
+function stripLineRangeSentinels(item) {
+  const hasRangeField = ["startLine", "endLine", "content"].some((key) => hasOwn(item, key));
+  if (!hasRangeField)
+    return;
+  if (item.oldString === "")
+    delete item.oldString;
+  if (item.newString === "")
+    delete item.newString;
+  if (item.replaceAll === false)
+    delete item.replaceAll;
+  if (item.occurrence === 1)
+    delete item.occurrence;
+}
 function normalizeEditItem(value, index) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     throw new InvalidRequestError(`edit: edits[${index}] must be an object`);
@@ -8231,6 +8606,7 @@ function normalizeEditItem(value, index) {
   const item = copyOwnProperties(source);
   normalizeItemAlias(item, "oldString", "oldText");
   normalizeItemAlias(item, "newString", "newText");
+  stripLineRangeSentinels(item);
   const hasFindField = ["oldString", "newString", "replaceAll", "occurrence"].some((key) => hasOwn(item, key));
   const hasRangeField = ["startLine", "endLine", "content"].some((key) => hasOwn(item, key));
   if (hasFindField && hasRangeField) {
@@ -8404,6 +8780,8 @@ class BridgePool {
   idleTimeoutMs;
   bridgeOptions;
   configOverrides;
+  editSlotSurvives;
+  editSlotSurvivesCaptured = false;
   projectConfigLoader;
   logger;
   cleanupTimer = null;
@@ -8428,7 +8806,16 @@ class BridgePool {
       logger: options.logger,
       childEnv: options.childEnv
     };
-    this.configOverrides = configOverrides;
+    this.configOverrides = { ...configOverrides };
+    const initialEditSlotSurvives = this.configOverrides.edit_slot_survives;
+    delete this.configOverrides.edit_slot_survives;
+    if (initialEditSlotSurvives !== undefined) {
+      if (typeof initialEditSlotSurvives !== "boolean") {
+        throw new Error("edit_slot_survives must be a boolean");
+      }
+      this.editSlotSurvives = initialEditSlotSurvives;
+      this.editSlotSurvivesCaptured = true;
+    }
     this.startCleanupTimer();
   }
   getActiveBridgeForRoot(projectRoot) {
@@ -8467,7 +8854,8 @@ class BridgePool {
     }
     const projectOverrides = this.loadProjectOverrides(key);
     const mergedOverrides = { ...this.configOverrides, ...projectOverrides };
-    const bridge = new BinaryBridge(this.binaryPath, key, this.bridgeOptions, mergedOverrides);
+    delete mergedOverrides.edit_slot_survives;
+    const bridge = new BinaryBridge(this.binaryPath, key, this.bridgeOptions, mergedOverrides, this.editSlotSurvivesCaptured ? this.editSlotSurvives : undefined);
     this.bridges.set(key, { bridge, lastUsed: Date.now() });
     return bridge;
   }
@@ -8571,6 +8959,23 @@ class BridgePool {
       error(message, meta);
   }
   setConfigureOverride(key, value) {
+    if (key === "edit_slot_survives") {
+      if (typeof value !== "boolean") {
+        throw new Error("edit_slot_survives must be set once to a boolean");
+      }
+      if (this.editSlotSurvivesCaptured) {
+        throw new Error("edit_slot_survives is write-once and was already captured");
+      }
+      this.editSlotSurvives = value;
+      this.editSlotSurvivesCaptured = true;
+      for (const entry of this.bridges.values()) {
+        entry.bridge.setEditSlotSurvives(value);
+      }
+      for (const bridge of this.staleBridges) {
+        bridge.setEditSlotSurvives(value);
+      }
+      return;
+    }
     if (value === undefined) {
       delete this.configOverrides[key];
     } else {
@@ -8645,6 +9050,7 @@ class RevivableTransportPool {
   revival = null;
   transports = new Map;
   configureOverrides = new Map;
+  editSlotSurvivesCaptured = false;
   constructor(initialPool, createPool, onBinaryReplaced) {
     this.createPool = createPool;
     this.onBinaryReplaced = onBinaryReplaced;
@@ -8675,6 +9081,18 @@ class RevivableTransportPool {
     return this.getBridge(projectRoot).toolCall(runtime.sessionID, name, rawArgs, options);
   }
   setConfigureOverride(key, value) {
+    if (key === "edit_slot_survives") {
+      if (typeof value !== "boolean") {
+        throw new Error("edit_slot_survives must be set once to a boolean");
+      }
+      if (this.editSlotSurvivesCaptured) {
+        throw new Error("edit_slot_survives is write-once and was already captured");
+      }
+      this.activePool.setConfigureOverride(key, value);
+      this.editSlotSurvivesCaptured = true;
+      this.configureOverrides.set(key, value);
+      return;
+    }
     if (value === undefined)
       this.configureOverrides.delete(key);
     else
@@ -8682,14 +9100,20 @@ class RevivableTransportPool {
     this.activePool.setConfigureOverride(key, value);
   }
   async reconfigure(projectRoot, overrides) {
+    const pool = await this.ensureActivePool();
+    const runtimeOverrides = {};
     for (const [key, value] of Object.entries(overrides)) {
+      if (key === "edit_slot_survives") {
+        this.setConfigureOverride(key, value);
+        continue;
+      }
       if (value === undefined)
         this.configureOverrides.delete(key);
       else
         this.configureOverrides.set(key, value);
+      runtimeOverrides[key] = value;
     }
-    const pool = await this.ensureActivePool();
-    await pool.reconfigure(projectRoot, overrides);
+    await pool.reconfigure(projectRoot, runtimeOverrides);
   }
   async replaceBinary(path2) {
     const replaced = await this.activePool.replaceBinary(path2);
@@ -9453,7 +9877,7 @@ var init_binary_probe = __esm(async () => {
 });
 
 // src/lib/fs-util.ts
-import { existsSync as existsSync10, readdirSync as readdirSync3, statSync as statSync7 } from "node:fs";
+import { existsSync as existsSync10, readdirSync as readdirSync4, statSync as statSync7 } from "node:fs";
 import { join as join14 } from "node:path";
 function dirSize(path2) {
   if (!existsSync10(path2)) {
@@ -9467,7 +9891,7 @@ function dirSize(path2) {
     return 0;
   }
   let total = 0;
-  for (const entry of readdirSync3(path2)) {
+  for (const entry of readdirSync4(path2)) {
     total += dirSize(join14(path2, entry));
   }
   return total;
@@ -19894,7 +20318,7 @@ __export(exports_lsp, {
   printLspDoctorHelp: () => printLspDoctorHelp,
   findProjectRootForFile: () => findProjectRootForFile
 });
-import { existsSync as existsSync14, readdirSync as readdirSync4, statSync as statSync9 } from "node:fs";
+import { existsSync as existsSync14, readdirSync as readdirSync5, statSync as statSync9 } from "node:fs";
 import { createRequire as createRequire4 } from "node:module";
 import { dirname as dirname8, join as join17, resolve as resolve8 } from "node:path";
 function findProjectRootForFile(filePath, fallbackCwd = process.cwd()) {
@@ -20066,7 +20490,7 @@ function childDirs(path2) {
   if (!existsSync14(path2))
     return [];
   try {
-    return readdirSync4(path2).map((entry) => join17(path2, entry)).filter((entry) => {
+    return readdirSync5(path2).map((entry) => join17(path2, entry)).filter((entry) => {
       try {
         return statSync9(entry).isDirectory();
       } catch {
@@ -20397,7 +20821,7 @@ var init_doctor_filters = __esm(async () => {
 });
 
 // src/lib/binary-cache.ts
-import { existsSync as existsSync16, readdirSync as readdirSync5, statSync as statSync10 } from "node:fs";
+import { existsSync as existsSync16, readdirSync as readdirSync6, statSync as statSync10 } from "node:fs";
 import { join as join18 } from "node:path";
 function getBinaryCacheInfo(activeVersion) {
   const path2 = getAftBinaryCacheDir();
@@ -20409,7 +20833,7 @@ function getBinaryCacheInfo(activeVersion) {
       path: path2
     };
   }
-  const versions = readdirSync5(path2).filter((entry) => {
+  const versions = readdirSync6(path2).filter((entry) => {
     try {
       return statSync10(join18(path2, entry)).isDirectory();
     } catch {
@@ -20651,7 +21075,7 @@ var init_bridge_tool_failures = __esm(() => {
 });
 
 // src/lib/legacy-storage.ts
-import { existsSync as existsSync18, readdirSync as readdirSync6, statSync as statSync12 } from "node:fs";
+import { existsSync as existsSync18, readdirSync as readdirSync7, statSync as statSync12 } from "node:fs";
 import { join as join19 } from "node:path";
 function summarizeLegacyPartitionDuplication(storageRoot) {
   if (!existsSync18(storageRoot)) {
@@ -20749,7 +21173,7 @@ function looksLikePartitionKey(value) {
 }
 function safeReadDir(path2) {
   try {
-    return readdirSync6(path2).sort((left, right) => left.localeCompare(right));
+    return readdirSync7(path2).sort((left, right) => left.localeCompare(right));
   } catch {
     return [];
   }
@@ -20775,7 +21199,7 @@ var init_legacy_storage = __esm(() => {
 });
 
 // src/lib/lsp-cache.ts
-import { existsSync as existsSync19, readdirSync as readdirSync7, rmSync as rmSync5, statSync as statSync13 } from "node:fs";
+import { existsSync as existsSync19, readdirSync as readdirSync8, rmSync as rmSync5, statSync as statSync13 } from "node:fs";
 import { join as join20 } from "node:path";
 function inspectDir(path2) {
   if (!existsSync19(path2)) {
@@ -20785,7 +21209,7 @@ function inspectDir(path2) {
   let totalSize = 0;
   let names;
   try {
-    names = readdirSync7(path2);
+    names = readdirSync8(path2);
   } catch {
     return { entries: [], totalSize: 0 };
   }
@@ -20848,7 +21272,7 @@ var init_lsp_cache = __esm(() => {
 });
 
 // src/lib/onnx.ts
-import { existsSync as existsSync20, readdirSync as readdirSync8, readlinkSync as readlinkSync2, realpathSync as realpathSync4 } from "node:fs";
+import { existsSync as existsSync20, readdirSync as readdirSync9, readlinkSync as readlinkSync2, realpathSync as realpathSync4 } from "node:fs";
 import { basename as basename3, isAbsolute as isAbsolute6, join as join21, resolve as resolve10, win32 as win322 } from "node:path";
 function getOnnxLibraryName() {
   if (process.platform === "darwin")
@@ -20902,7 +21326,7 @@ function isWindowsSystem32Directory2(dir) {
 }
 function directoryContainsLibrary2(dir, libName) {
   try {
-    const entries = readdirSync8(dir);
+    const entries = readdirSync9(dir);
     if (process.platform === "win32") {
       const expected = libName.toLowerCase();
       return entries.some((entry) => entry.toLowerCase() === expected);
@@ -20950,7 +21374,7 @@ function findSystemOnnxRuntime2() {
       if (!existsSync20(nugetPackageDir))
         return nugetPaths;
       try {
-        for (const entry of readdirSync8(nugetPackageDir, { withFileTypes: true })) {
+        for (const entry of readdirSync9(nugetPackageDir, { withFileTypes: true })) {
           if (!entry.isDirectory())
             continue;
           if (entry.name === "__globalPackagesFolder" || entry.name.startsWith("."))
@@ -21017,7 +21441,7 @@ function detectOrtVersion(libDir) {
     return null;
   const libName = getOnnxLibraryName();
   try {
-    const entries = readdirSync8(libDir);
+    const entries = readdirSync9(libDir);
     const barePrefix = libName.replace(/\.(so|dylib|dll)$/, "");
     const expectedPrefix = process.platform === "win32" ? barePrefix.toLowerCase() : barePrefix;
     for (const entry of entries) {
@@ -21649,7 +22073,7 @@ var init_onnx_fix = __esm(() => {
 });
 
 // src/lib/sessions.ts
-import { existsSync as existsSync23, readdirSync as readdirSync9, readFileSync as readFileSync10, statSync as statSync15 } from "node:fs";
+import { existsSync as existsSync23, readdirSync as readdirSync10, readFileSync as readFileSync10, statSync as statSync15 } from "node:fs";
 import { createRequire as createRequire5 } from "node:module";
 import { homedir as homedir18 } from "node:os";
 import { basename as basename4, join as join23 } from "node:path";
@@ -21745,7 +22169,7 @@ function collectJsonlFiles(root) {
       continue;
     let entries;
     try {
-      entries = readdirSync9(dir, { withFileTypes: true });
+      entries = readdirSync10(dir, { withFileTypes: true });
     } catch {
       continue;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/aft",
-  "version": "0.49.4",
+  "version": "0.50.1",
   "type": "module",
   "description": "Unified CLI for Agent File Tools (AFT) — setup, doctor, and diagnostics across supported agent harnesses (OpenCode, Pi)",
   "license": "MIT",
@@ -24,7 +24,7 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.6.0",
-    "@cortexkit/aft-bridge": "0.49.4",
+    "@cortexkit/aft-bridge": "0.50.1",
     "comment-json": "^4.6.2"
   },
   "devDependencies": {