@cortexkit/aft-pi 0.49.4 → 0.50.1

package/dist/index.js

@@ -8410,6 +8410,8 @@ var DEFAULT_BRIDGE_TIMEOUT_MS = 30000;
 var BRIDGE_HANG_TIMEOUT_THRESHOLD = 2;
 var MAX_STDOUT_BUFFER = 64 * 1024 * 1024;
 var STDOUT_BUFFER_COMPACT_THRESHOLD = 64 * 1024;
+var HASHLINE_REGISTRATION_LOG_INTERVAL_MS = 60000;
+var HASHLINE_REGISTRATION_LOG_STATE_LIMIT = 256;
 var TERMINAL_BASH_STATUSES = new Set([
   "completed",
   "failed",
@@ -8559,6 +8561,9 @@ class BinaryBridge {
   configured = false;
   _configurePromise = null;
   configOverrides;
+  editSlotSurvives;
+  editSlotSurvivesCaptured = false;
+  hashlineRegistrationLogState = new Map;
   minVersion;
   onVersionMismatch;
   onConfigureWarnings;
@@ -8575,20 +8580,33 @@ class BinaryBridge {
   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;
   }
@@ -8699,13 +8717,54 @@ class BinaryBridge {
   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;
@@ -9781,7 +9840,8 @@ function formatDroppedKeyWarnings(dropped) {
 // ../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";
@@ -9806,8 +9866,8 @@ var REPO = "cortexkit/aft";
 var DOWNLOAD_TIMEOUT_MS = 300000;
 var LATEST_TAG_TIMEOUT_MS = 30000;
 var MAX_DOWNLOAD_BYTES = 200 * 1024 * 1024;
-var DOWNLOAD_LOCK_TIMEOUT_MS = 120000;
 var DOWNLOAD_LOCK_STALE_MS = 10 * 60000;
+var DOWNLOAD_LOCK_TIMEOUT_MS = DOWNLOAD_LOCK_STALE_MS + 30000;
 function readBinaryVersion(binaryPath) {
   try {
     const result = spawnSync(binaryPath, ["--version"], {
@@ -9875,11 +9935,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;
     }
@@ -9955,13 +10041,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);
@@ -9987,17 +10071,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 });
@@ -10008,19 +10160,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));
     }
   }
 }
@@ -12873,6 +13030,8 @@ function normalizeWindowsRoot(p) {
 var AFT_MODULE_ID = "aft";
 var MAX_CONSECUTIVE_TRANSPORT_FAILURES = 3;
 var BG_STABLE_MS = 5000;
+var BG_LIFECYCLE_LOG_INTERVAL_MS = 60000;
+var BG_DISPATCH_PROBE_INTERVAL_MS = 60000;
 var DEFAULT_SESSION_ID = "__default__";
 var LOCALLY_SATISFIED_COMMANDS = new Set(["configure"]);
 
@@ -12935,12 +13094,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;
@@ -12950,6 +13112,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();
@@ -12966,25 +13129,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;
       }
@@ -12993,44 +13237,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);
@@ -13128,6 +13412,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);
@@ -13142,7 +13429,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;
@@ -13166,6 +13457,7 @@ class SubcTransportPool {
   onBgEventsNudge;
   onBgEventsNudgeRef;
   bgBackoffSleep;
+  bgDispatchProbeIntervalMs;
   lifecycleDemandCheck;
   onLifecycleEvent;
   onBgNudgeRejected;
@@ -13181,8 +13473,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;
@@ -13192,6 +13487,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;
@@ -13508,6 +13804,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)
@@ -13761,20 +14086,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 = () => {
@@ -13786,7 +14123,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;
@@ -13848,7 +14185,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;
@@ -13926,14 +14277,29 @@ function toolErrorFromResponse(command, response) {
   return new AftToolError(message, code, response);
 }
 var 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 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.";
+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;
@@ -14740,7 +15106,7 @@ async function ensureStorageMigrated(opts) {
   throw new Error(`AFT storage migration failed (${detail}). ` + `Harness: ${opts.harness}. Legacy: ${legacyRoot}. Target: ${newRoot}. ` + `See log: ${logPath}. ` + `Plugin load aborted to prevent legacy/new state divergence.` + (stderrTail ? ` Stderr tail: ${stderrTail}` : "") + (stdoutTail ? ` Stdout tail: ${stdoutTail}` : ""));
 }
 // ../aft-bridge/dist/npm-resolver.js
-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() {
@@ -14780,7 +15146,7 @@ function npmAdjacentToNode(deps) {
 function highestVersionedNodeBin(installsDir, name) {
   let entries;
   try {
-    entries = readdirSync(installsDir);
+    entries = readdirSync2(installsDir);
   } catch {
     return null;
   }
@@ -14856,7 +15222,7 @@ function npmSpawnEnv(resolved, baseEnv = process.env) {
 // ../aft-bridge/dist/onnx-runtime.js
 import { execFileSync } from "node:child_process";
 import { createHash as createHash3 } from "node:crypto";
-import { chmodSync as chmodSync3, closeSync as closeSync4, copyFileSync as copyFileSync3, createWriteStream as createWriteStream2, existsSync as 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";
@@ -14970,7 +15336,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;
@@ -14981,7 +15347,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 {
@@ -14993,7 +15359,7 @@ function cleanupAbandonedStagingDirs(onnxBaseDir) {
             }
           }
         } else {
-          abandoned = !isProcessAlive(pid);
+          abandoned = !isProcessAlive2(pid);
         }
       } else {
         abandoned = true;
@@ -15044,7 +15410,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) {
@@ -15107,7 +15473,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);
@@ -15145,7 +15511,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("."))
@@ -15240,7 +15606,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);
@@ -15298,7 +15664,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) {
@@ -15476,7 +15842,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;
   }
@@ -15540,7 +15906,7 @@ function isWindowsProcessAlive(pid) {
     return false;
   }
 }
-function isProcessAlive(pid) {
+function isProcessAlive2(pid) {
   if (process.platform === "win32")
     return isWindowsProcessAlive(pid);
   try {
@@ -15915,6 +16281,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`);
@@ -15923,6 +16302,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) {
@@ -16065,6 +16445,8 @@ class BridgePool {
   idleTimeoutMs;
   bridgeOptions;
   configOverrides;
+  editSlotSurvives;
+  editSlotSurvivesCaptured = false;
   projectConfigLoader;
   logger;
   cleanupTimer = null;
@@ -16089,7 +16471,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) {
@@ -16128,7 +16519,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;
   }
@@ -16232,6 +16624,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 {
@@ -16289,6 +16698,7 @@ class RevivableTransportPool {
   revival = null;
   transports = new Map;
   configureOverrides = new Map;
+  editSlotSurvivesCaptured = false;
   constructor(initialPool, createPool, onBinaryReplaced) {
     this.createPool = createPool;
     this.onBinaryReplaced = onBinaryReplaced;
@@ -16319,6 +16729,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
@@ -16326,14 +16748,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);
@@ -16739,6 +17167,12 @@ var UNKNOWN_COMPLETION_TTL_MS = 5000;
 var UNKNOWN_COMPLETION_CAP = 32;
 var DEFAULT_SESSION_ID2 = "__default__";
 var LOG_PREFIX = "[aft-pi] bg-notifications:";
+var SUBC_NUDGE_LOG_INTERVAL_MS = 60000;
+var subcNudgesInFlight = new Map;
+var subcNudgeLogState = new Map;
+function normalizeSessionID(sessionID) {
+  return sessionID && sessionID.length > 0 ? sessionID : DEFAULT_SESSION_ID2;
+}
 function consumeBgCompletion(sessionID, taskId) {
   const state = stateFor(sessionID);
   state.pendingCompletions = state.pendingCompletions.filter((c) => c.task_id !== taskId);
@@ -16934,11 +17368,49 @@ async function handleTurnEndBgCompletions(drainContext) {
   stateFor(drainContext.sessionID).wakeDeferredTaskIds.clear();
   await triggerWakeIfPending(drainContext, false, true);
 }
-async function handleSubcBgEventsNudge(drainContext) {
+function handleSubcBgEventsNudge(drainContext) {
+  const resolvedDrainContext = {
+    ...drainContext,
+    sessionID: normalizeSessionID(drainContext.sessionID)
+  };
+  const key = `${resolvedDrainContext.directory}\x00${resolvedDrainContext.sessionID}`;
+  const inFlight = subcNudgesInFlight.get(key);
+  if (inFlight) {
+    logSubcNudgeLifecycle(resolvedDrainContext, "coalesced-in-flight", "nudge coalesced cause=handler-already-in-flight");
+    return inFlight;
+  }
+  logSubcNudgeLifecycle(resolvedDrainContext, "handler-entry", "nudge handler entered");
+  const handling = handleSubcBgEventsNudgeOnce(resolvedDrainContext);
+  subcNudgesInFlight.set(key, handling);
+  const clear = () => {
+    if (subcNudgesInFlight.get(key) === handling)
+      subcNudgesInFlight.delete(key);
+  };
+  handling.then(clear, clear);
+  return handling;
+}
+async function handleSubcBgEventsNudgeOnce(drainContext) {
   bridgeForDrain(drainContext);
   stateFor(drainContext.sessionID).wakeDeferredTaskIds.clear();
   await triggerWakeIfPending(drainContext, false, true, true);
 }
+function logSubcNudgeLifecycle(drainContext, kind, message) {
+  const key = `${kind}\x00${drainContext.directory}\x00${drainContext.sessionID}`;
+  const now = Date.now();
+  const state = subcNudgeLogState.get(key);
+  if (state && now - state.lastEmittedAt < SUBC_NUDGE_LOG_INTERVAL_MS) {
+    state.suppressed += 1;
+    return;
+  }
+  const suppressed = state?.suppressed ?? 0;
+  subcNudgeLogState.set(key, { lastEmittedAt: now, suppressed: 0 });
+  sessionLog(drainContext.sessionID, `${LOG_PREFIX} ${message}`, {
+    event: "subc_bg_nudge_delivery",
+    cause: kind,
+    canonical_root: drainContext.directory,
+    suppressed
+  });
+}
 async function triggerWakeIfPending(drainContext, skipDrain, includeDeferredCompletions = true, forceDrain = false) {
   const state = stateFor(drainContext.sessionID);
   if (!skipDrain && (forceDrain || state.outstandingTaskIds.size > 0 || !state.forcedDrainCompleted)) {
@@ -17406,7 +17878,7 @@ import {
 // package.json
 var package_default = {
   name: "@cortexkit/aft-pi",
-  version: "0.49.4",
+  version: "0.50.1",
   type: "module",
   description: "Pi coding agent extension for Agent File Tools (AFT) — tree-sitter and LSP-powered code analysis",
   main: "dist/index.js",
@@ -17429,19 +17901,19 @@ var package_default = {
     "test:unit": "bun test src/__tests__ --path-ignore-patterns 'src/__tests__/e2e/**'"
   },
   dependencies: {
-    "@cortexkit/aft-bridge": "0.49.4",
+    "@cortexkit/aft-bridge": "0.50.1",
     "comment-json": "^5.0.0",
     diff: "^8.0.4",
     typebox: "1.1.38",
     zod: "^4.4.3"
   },
   optionalDependencies: {
-    "@cortexkit/aft-darwin-arm64": "0.49.4",
-    "@cortexkit/aft-darwin-x64": "0.49.4",
-    "@cortexkit/aft-linux-arm64": "0.49.4",
-    "@cortexkit/aft-linux-x64": "0.49.4",
-    "@cortexkit/aft-win32-arm64": "0.49.4",
-    "@cortexkit/aft-win32-x64": "0.49.4"
+    "@cortexkit/aft-darwin-arm64": "0.50.1",
+    "@cortexkit/aft-darwin-x64": "0.50.1",
+    "@cortexkit/aft-linux-arm64": "0.50.1",
+    "@cortexkit/aft-linux-x64": "0.50.1",
+    "@cortexkit/aft-win32-arm64": "0.50.1",
+    "@cortexkit/aft-win32-x64": "0.50.1"
   },
   devDependencies: {
     "@earendil-works/pi-coding-agent": "^0.80.2",
@@ -18181,7 +18653,7 @@ __export(exports_external, {
   instanceof: () => _instanceof,
   includes: () => _includes,
   httpUrl: () => httpUrl,
-  hostname: () => hostname2,
+  hostname: () => hostname3,
   hex: () => hex2,
   hash: () => hash,
   guid: () => guid2,
@@ -19632,7 +20104,7 @@ __export(exports_regexes, {
   idnEmail: () => idnEmail,
   httpProtocol: () => httpProtocol,
   html5Email: () => html5Email,
-  hostname: () => hostname,
+  hostname: () => hostname2,
   hex: () => hex,
   guid: () => guid,
   extendedDuration: () => extendedDuration,
@@ -19690,7 +20162,7 @@ var cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]
 var cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
 var base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
 var base64url = /^[A-Za-z0-9_-]*$/;
-var hostname = /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/;
+var hostname2 = /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/;
 var domain = /^([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
 var httpProtocol = /^https?$/;
 var e164 = /^\+[1-9]\d{6,14}$/;
@@ -30314,7 +30786,7 @@ __export(exports_schemas2, {
   int: () => int,
   instanceof: () => _instanceof,
   httpUrl: () => httpUrl,
-  hostname: () => hostname2,
+  hostname: () => hostname3,
   hex: () => hex2,
   hash: () => hash,
   guid: () => guid2,
@@ -30966,7 +31438,7 @@ var ZodCustomStringFormat = /* @__PURE__ */ $constructor("ZodCustomStringFormat"
 function stringFormat(format, fnOrRegex, _params = {}) {
   return _stringFormat(ZodCustomStringFormat, format, fnOrRegex, _params);
 }
-function hostname2(_params) {
+function hostname3(_params) {
   return _stringFormat(ZodCustomStringFormat, "hostname", exports_regexes.hostname, _params);
 }
 function hex2(_params) {
@@ -32502,6 +32974,7 @@ var BackupConfigSchema = exports_external.object({
 var AftConfigSchema = exports_external.preprocess((value) => stripHarnessSpecificConfigKeys(value, OPENCODE_ONLY_KEYS), exports_external.object({
   $schema: exports_external.string().optional(),
   enabled: exports_external.boolean().optional(),
+  edit_mode: exports_external.enum(["default", "hashline"]).optional(),
   format_on_edit: exports_external.boolean().optional(),
   formatter_timeout_secs: exports_external.number().int().min(1).max(600).optional(),
   validate_on_edit: exports_external.enum(["syntax", "full"]).optional(),
@@ -32715,10 +33188,15 @@ function loadConfigFromPath(configPath) {
   }
 }
 function parseConfigPartially(rawConfig) {
+  let configForParsing = rawConfig;
+  if (Object.hasOwn(rawConfig, "edit_mode") && rawConfig.edit_mode !== "default" && rawConfig.edit_mode !== "hashline") {
+    warn2(`Unknown edit_mode value ${JSON.stringify(rawConfig.edit_mode)}; falling back to "default"`);
+    configForParsing = { ...rawConfig, edit_mode: "default" };
+  }
   const partialConfig = {};
   const invalidSections = [];
-  for (const key of Object.keys(rawConfig)) {
-    const sectionResult = AftConfigSchema.safeParse({ [key]: rawConfig[key] });
+  for (const key of Object.keys(configForParsing)) {
+    const sectionResult = AftConfigSchema.safeParse({ [key]: configForParsing[key] });
     if (sectionResult.success) {
       const parsed = sectionResult.data;
       if (parsed[key] !== undefined) {
@@ -32843,6 +33321,7 @@ function getProjectLspStrippedKeys(lsp) {
 }
 var PROJECT_SAFE_TOP_LEVEL_FIELDS = new Set([
   "enabled",
+  "edit_mode",
   "tool_surface",
   "format_on_edit",
   "validate_on_edit",
@@ -33122,7 +33601,7 @@ ${new Date().toISOString()}
   const age = Date.now() - lockMtimeMs;
   const ageWithinFresh = Math.abs(age) < STALE_LOCK_MS2;
   const skipLiveness = process.platform === "win32";
-  const ownerAlive = !skipLiveness && owningPid !== null && isProcessAlive2(owningPid);
+  const ownerAlive = !skipLiveness && owningPid !== null && isProcessAlive3(owningPid);
   if (skipLiveness ? ageWithinFresh : ownerAlive && ageWithinFresh) {
     return false;
   }
@@ -33132,7 +33611,7 @@ ${new Date().toISOString()}
   } catch {}
   return tryClaim();
 }
-function isProcessAlive2(pid) {
+function isProcessAlive3(pid) {
   try {
     process.kill(pid, 0);
     return true;
@@ -33366,7 +33845,7 @@ var NPM_LSP_TABLE = [
 ];
 
 // src/lsp-project-relevance.ts
-import { existsSync as existsSync11, readdirSync as readdirSync3, readFileSync as readFileSync9 } from "node:fs";
+import { existsSync as existsSync11, readdirSync as readdirSync4, readFileSync as readFileSync9 } from "node:fs";
 import { join as join13 } from "node:path";
 var MAX_WALK_DIRS = 200;
 var MAX_WALK_DEPTH = 4;
@@ -33431,7 +33910,7 @@ function relevantExtensionsInProject(projectRoot, extToServer) {
     visitedDirs += 1;
     let entries;
     try {
-      entries = readdirSync3(current.dir, { withFileTypes: true });
+      entries = readdirSync4(current.dir, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -33851,7 +34330,7 @@ import {
   existsSync as existsSync13,
   lstatSync as lstatSync2,
   mkdirSync as mkdirSync8,
-  readdirSync as readdirSync4,
+  readdirSync as readdirSync5,
   readFileSync as readFileSync11,
   readlinkSync as readlinkSync2,
   realpathSync as realpathSync3,
@@ -34254,7 +34733,7 @@ function validateExtraction(stagingRoot) {
   const walk = (dir) => {
     let entries;
     try {
-      entries = readdirSync4(dir);
+      entries = readdirSync5(dir);
     } catch (err) {
       throw new Error(`failed to read staging dir ${dir}: ${err}`);
     }
@@ -35190,6 +35669,15 @@ var EditParams = Type2.Object({
     description: "Batch edits — non-empty array of { oldString, newString }, { oldString, newString, replaceAll: true }, or { startLine, endLine, content } objects applied atomically."
   }))
 });
+var HashlineEditParams = Type2.Object({
+  patch: Type2.String({
+    minLength: 1,
+    description: "Hashline patch text with one or more [path#TAG] sections and PUT/CUT/REM/MV operations"
+  })
+}, { additionalProperties: false });
+function stringList(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
 var GrepParams = Type2.Object({
   pattern: Type2.String({ description: "Regex pattern to search for" }),
   path: Type2.Optional(Type2.String({
@@ -35354,7 +35842,42 @@ PDFs aren't supported on the Pi harness yet.`, response);
       }
     }));
   }
-  if (surface.hoistEdit) {
+  if (surface.hoistEdit && ctx.hashlineEffective === true) {
+    pi.registerTool({
+      name: "edit",
+      label: "edit",
+      description: "Apply a hashline patch. Arguments are exactly `{patch}` where `patch` is a non-empty string of one or more `[path#TAG]` sections with PUT/CUT/REM/MV operations. Paths and tags come from section headers; obtain tags from tagged reads. Server-owned preview control is outside this schema.",
+      promptSnippet: "Apply a tagged hashline patch through the edit tool",
+      promptGuidelines: [
+        "Read a file to obtain its current hashline tag before editing it.",
+        "Pass exactly one patch string; paths and tags belong in patch section headers."
+      ],
+      parameters: HashlineEditParams,
+      async execute(_toolCallId, params, _signal, _onUpdate, extCtx) {
+        const bridge = bridgeFor(ctx, extCtx.cwd);
+        const rawArgs = { patch: params.patch };
+        const preflight = await callToolCall(bridge, "hashline_preflight", rawArgs, extCtx);
+        if (preflight.success === false)
+          throw toolErrorFromResponse("edit", preflight);
+        for (const target of [
+          ...stringList(preflight.affected_paths),
+          ...stringList(preflight.mv_destinations)
+        ]) {
+          await assertExternalDirectoryPermission(extCtx, await resolvePathArg(extCtx.cwd, target), {
+            restrictToProjectRoot: surface.restrictToProjectRoot
+          });
+        }
+        const preview = await callToolCall(bridge, "edit", rawArgs, extCtx, { preview: true });
+        if (preview.success === false)
+          throw toolErrorFromResponse("edit", preview);
+        const response = await callToolCall(bridge, "edit", rawArgs, extCtx);
+        if (response.success === false)
+          throw toolErrorFromResponse("edit", response);
+        return buildMutationResult(response);
+      }
+    });
+  }
+  if (surface.hoistEdit && ctx.hashlineEffective !== true) {
     pi.registerTool(withPathAliasPreparation({
       name: "edit",
       label: "edit",
@@ -38574,7 +39097,7 @@ var PLUGIN_VERSION = (() => {
     return "0.0.0";
   }
 })();
-var ANNOUNCEMENT_VERSION = "0.49.4";
+var ANNOUNCEMENT_VERSION = "0.50.1";
 var ANNOUNCEMENT_FEATURES = [
   "Callgraph stays consistent under load: edits arriving mid-rebuild can no longer be silently lost from navigation results.",
   "aft_zoom handles real-world .jsonc: files with comment banners above the opening brace now resolve, and not-found errors point at the segment that actually failed (thanks @iceteaSA).",
@@ -38850,6 +39373,16 @@ ${lines}
     poolOptions,
     configOverrides,
     subcConnectionFile: config2.subc?.connection_file,
+    onBgEventsNudge: (directory, sessionID) => {
+      handleSubcBgEventsNudge({
+        ctx,
+        directory,
+        sessionID,
+        runtime: pi
+      }).catch((err) => {
+        warn2(`[aft-pi] bg nudge rejected: ${err instanceof Error ? err.message : String(err)}`);
+      });
+    },
     onBgEventsNudgeRef: (ref) => {
       handleSubcBgEventsNudge({
         ctx,
@@ -38874,8 +39407,16 @@ ${lines}
     });
   }
   pool.setConfigureOverride("harness", "pi");
-  pool.setConfigureOverride("aft_search_registered", resolvePiToolSurface(config2).semantic);
-  const ctx = { pool, config: config2, storageDir };
+  const surface = resolvePiToolSurface(config2);
+  const hashlineEditRegistered = config2.edit_mode === "hashline" && surface.hoistEdit;
+  pool.setConfigureOverride("edit_slot_survives", hashlineEditRegistered);
+  pool.setConfigureOverride("aft_search_registered", surface.semantic);
+  const ctx = {
+    pool,
+    config: config2,
+    hashlineEffective: hashlineEditRegistered,
+    storageDir
+  };
   if (onnxRuntimePromise) {
     onnxRuntimePromise.then((ortDylibDir) => {
       if (ortDylibDir) {
@@ -38913,7 +39454,6 @@ ${lines}
   if (ANNOUNCEMENT_VERSION && ANNOUNCEMENT_FEATURES.length > 0) {
     sendFeatureAnnouncement(ANNOUNCEMENT_VERSION, ANNOUNCEMENT_FEATURES, ANNOUNCEMENT_FOOTER, storageDir);
   }
-  const surface = resolvePiToolSurface(config2);
   registerPiToolSurface(pi, ctx, surface);
   registerWorkflowHints(pi, config2, surface);
   registerStatusCommand(pi, ctx);