@cortexkit/aft 0.49.4 → 0.50.0

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;
@@ -5112,12 +5169,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 +5187,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 +5204,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 +5312,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 +5484,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 +5501,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 +5529,7 @@ class SubcTransportPool {
   onBgEventsNudge;
   onBgEventsNudgeRef;
   bgBackoffSleep;
+  bgDispatchProbeIntervalMs;
   lifecycleDemandCheck;
   onLifecycleEvent;
   onBgNudgeRejected;
@@ -5355,8 +5545,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 +5559,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 +5876,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 +6158,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;
+      }
+      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.onBgEventsNudge?.(identity.project_root, identity.session);
-      if (nudgeRef)
-        this.onBgEventsNudgeRef?.(nudgeRef);
+      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 +6195,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 +6257,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 +6330,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 +6390,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();
@@ -8404,6 +8667,8 @@ class BridgePool {
   idleTimeoutMs;
   bridgeOptions;
   configOverrides;
+  editSlotSurvives;
+  editSlotSurvivesCaptured = false;
   projectConfigLoader;
   logger;
   cleanupTimer = null;
@@ -8428,7 +8693,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 +8741,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 +8846,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 +8937,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 +8968,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 +8987,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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/aft",
-  "version": "0.49.4",
+  "version": "0.50.0",
   "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.0",
     "comment-json": "^4.6.2"
   },
   "devDependencies": {