@cortexkit/aft-opencode 0.49.4 → 0.50.1

package/dist/index.js

@@ -8334,6 +8334,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",
@@ -8483,6 +8485,9 @@ class BinaryBridge {
   configured = false;
   _configurePromise = null;
   configOverrides;
+  editSlotSurvives;
+  editSlotSurvivesCaptured = false;
+  hashlineRegistrationLogState = new Map;
   minVersion;
   onVersionMismatch;
   onConfigureWarnings;
@@ -8499,20 +8504,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;
   }
@@ -8623,13 +8641,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;
@@ -9433,7 +9492,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";
@@ -9458,8 +9518,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"], {
@@ -9527,11 +9587,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;
     }
@@ -9607,13 +9693,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);
@@ -9639,17 +9723,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 });
@@ -9660,19 +9812,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;
-        }
-      } catch {
-        continue;
+        throw readErr;
       }
-      if (Date.now() - startedAt > DOWNLOAD_LOCK_TIMEOUT_MS) {
+      if (isReclaimableDownloadLock(parseDownloadLockOwner(existingOwner), ageMs, staleMs)) {
+        if (reclaimDownloadLock(lockPath, existingOwner))
+          continue;
+      }
+      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));
     }
   }
 }
@@ -12483,6 +12640,8 @@ function projectRootKeyHash(dir) {
 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"]);
 
@@ -12545,12 +12704,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;
@@ -12560,6 +12722,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();
@@ -12576,25 +12739,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;
       }
@@ -12603,44 +12847,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);
@@ -12738,6 +13022,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);
@@ -12752,7 +13039,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;
@@ -12776,6 +13067,7 @@ class SubcTransportPool {
   onBgEventsNudge;
   onBgEventsNudgeRef;
   bgBackoffSleep;
+  bgDispatchProbeIntervalMs;
   lifecycleDemandCheck;
   onLifecycleEvent;
   onBgNudgeRejected;
@@ -12791,8 +13083,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;
@@ -12802,6 +13097,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;
@@ -13118,6 +13414,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)
@@ -13371,20 +13696,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 = () => {
@@ -13396,7 +13733,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;
@@ -13458,7 +13795,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;
@@ -13536,14 +13887,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;
@@ -14343,7 +14709,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 homedir8 } from "node:os";
 import { delimiter, dirname as dirname4, isAbsolute as isAbsolute3, join as join9 } from "node:path";
 function defaultDeps() {
@@ -14383,7 +14749,7 @@ function npmAdjacentToNode(deps) {
 function highestVersionedNodeBin(installsDir, name) {
   let entries;
   try {
-    entries = readdirSync(installsDir);
+    entries = readdirSync2(installsDir);
   } catch {
     return null;
   }
@@ -14462,7 +14828,7 @@ function isNpmAvailable(deps = defaultDeps()) {
 // ../aft-bridge/dist/onnx-runtime.js
 import { execFileSync } 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";
@@ -14579,7 +14945,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;
@@ -14590,7 +14956,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 {
@@ -14602,7 +14968,7 @@ function cleanupAbandonedStagingDirs(onnxBaseDir) {
             }
           }
         } else {
-          abandoned = !isProcessAlive(pid);
+          abandoned = !isProcessAlive2(pid);
         }
       } else {
         abandoned = true;
@@ -14653,7 +15019,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) {
@@ -14716,7 +15082,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);
@@ -14754,7 +15120,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("."))
@@ -14849,7 +15215,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);
@@ -14907,7 +15273,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) {
@@ -15085,7 +15451,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;
   }
@@ -15149,7 +15515,7 @@ function isWindowsProcessAlive(pid) {
     return false;
   }
 }
-function isProcessAlive(pid) {
+function isProcessAlive2(pid) {
   if (process.platform === "win32")
     return isWindowsProcessAlive(pid);
   try {
@@ -15524,6 +15890,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`);
@@ -15532,6 +15911,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) {
@@ -15656,6 +16036,8 @@ class BridgePool {
   idleTimeoutMs;
   bridgeOptions;
   configOverrides;
+  editSlotSurvives;
+  editSlotSurvivesCaptured = false;
   projectConfigLoader;
   logger;
   cleanupTimer = null;
@@ -15680,7 +16062,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) {
@@ -15719,7 +16110,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;
   }
@@ -15823,6 +16215,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 {
@@ -15880,6 +16289,7 @@ class RevivableTransportPool {
   revival = null;
   transports = new Map;
   configureOverrides = new Map;
+  editSlotSurvivesCaptured = false;
   constructor(initialPool, createPool, onBinaryReplaced) {
     this.createPool = createPool;
     this.onBinaryReplaced = onBinaryReplaced;
@@ -15910,6 +16320,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
@@ -15917,14 +16339,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);
@@ -16336,6 +16764,9 @@ var UNKNOWN_COMPLETION_TTL_MS = 5000;
 var UNKNOWN_COMPLETION_CAP = 32;
 var DEFAULT_SESSION_ID2 = "__default__";
 var LOG_PREFIX = "[aft-plugin] bg-notifications:";
+var SUBC_NUDGE_LOG_INTERVAL_MS = 60000;
+var subcNudgesInFlight = new Map;
+var subcNudgeLogState = new Map;
 function consumeBgCompletion(sessionID, taskId) {
   const state = stateFor(sessionID);
   state.pendingCompletions = state.pendingCompletions.filter((c) => c.task_id !== taskId);
@@ -16542,11 +16973,45 @@ async function handleIdleBgCompletions(drainContext) {
   stateFor(drainContext.sessionID).wakeDeferredTaskIds.clear();
   await triggerWakeIfPending(drainContext, false, true);
 }
-async function handleSubcBgEventsNudge(drainContext) {
+function handleSubcBgEventsNudge(drainContext) {
+  const key = `${drainContext.directory}\x00${drainContext.sessionID}`;
+  const inFlight = subcNudgesInFlight.get(key);
+  if (inFlight) {
+    logSubcNudgeLifecycle(drainContext, "coalesced-in-flight", "nudge coalesced cause=handler-already-in-flight");
+    return inFlight;
+  }
+  logSubcNudgeLifecycle(drainContext, "handler-entry", "nudge handler entered");
+  const handling = handleSubcBgEventsNudgeOnce(drainContext);
+  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)) {
@@ -17412,6 +17877,7 @@ async function signalBashWaitDetachForProject(pool, projectRoot, sessionID) {
 
 // src/config.ts
 import { existsSync as existsSync10, readFileSync as readFileSync7, renameSync as renameSync5, unlinkSync as unlinkSync5, writeFileSync as writeFileSync4 } from "node:fs";
+import { parse as parsePath, resolve as resolvePath } from "node:path";
 var import_comment_json = __toESM(require_src2(), 1);
 
 // ../../node_modules/.bun/zod@4.4.3/node_modules/zod/v4/classic/external.js
@@ -17524,7 +17990,7 @@ __export(exports_external, {
   instanceof: () => _instanceof,
   includes: () => _includes,
   httpUrl: () => httpUrl,
-  hostname: () => hostname2,
+  hostname: () => hostname3,
   hex: () => hex2,
   hash: () => hash,
   guid: () => guid2,
@@ -18975,7 +19441,7 @@ __export(exports_regexes, {
   idnEmail: () => idnEmail,
   httpProtocol: () => httpProtocol,
   html5Email: () => html5Email,
-  hostname: () => hostname,
+  hostname: () => hostname2,
   hex: () => hex,
   guid: () => guid,
   extendedDuration: () => extendedDuration,
@@ -19033,7 +19499,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}$/;
@@ -29657,7 +30123,7 @@ __export(exports_schemas2, {
   int: () => int,
   instanceof: () => _instanceof,
   httpUrl: () => httpUrl,
-  hostname: () => hostname2,
+  hostname: () => hostname3,
   hex: () => hex2,
   hash: () => hash,
   guid: () => guid2,
@@ -30309,7 +30775,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) {
@@ -31798,6 +32264,7 @@ var BackupConfigSchema = exports_external.object({
 var AftConfigSchema = exports_external.preprocess((value) => stripHarnessSpecificConfigKeys(value, PI_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(),
@@ -32035,14 +32502,19 @@ ${serialized}` : serialized;
   }
 }
 function parseConfigPartially(rawConfig) {
-  const fullResult = AftConfigSchema.safeParse(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 fullResult = AftConfigSchema.safeParse(configForParsing);
   if (fullResult.success) {
     return fullResult.data;
   }
   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) {
@@ -32211,6 +32683,7 @@ function getProjectLspStrippedKeys(lsp) {
 }
 var PROJECT_SAFE_TOP_LEVEL_FIELDS = new Set([
   "enabled",
+  "edit_mode",
   "tool_surface",
   "hoist_builtin_tools",
   "format_on_edit",
@@ -32326,6 +32799,12 @@ function resolveAftConfigPaths(projectDirectory) {
   migrateAftConfigFile2(paths.projectConfigPath);
   return paths;
 }
+function resolveOpenCodeRegistrationRoot(directory, worktree) {
+  if (!worktree)
+    return directory;
+  const resolvedWorktree = resolvePath(worktree);
+  return parsePath(resolvedWorktree).root === resolvedWorktree ? directory : resolvedWorktree;
+}
 function buildConfigTierConfigureParams(projectDirectory, processState = {}) {
   const paths = resolveAftConfigPaths(projectDirectory);
   const initialPluginState = Object.keys(processState).length > 0;
@@ -33784,7 +34263,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;
   }
@@ -33794,7 +34273,7 @@ ${new Date().toISOString()}
   } catch {}
   return tryClaim();
 }
-function isProcessAlive2(pid) {
+function isProcessAlive3(pid) {
   try {
     process.kill(pid, 0);
     return true;
@@ -34028,7 +34507,7 @@ var NPM_LSP_TABLE = [
 ];
 
 // src/lsp-project-relevance.ts
-import { existsSync as existsSync15, readdirSync as readdirSync3, readFileSync as readFileSync13 } from "node:fs";
+import { existsSync as existsSync15, readdirSync as readdirSync4, readFileSync as readFileSync13 } from "node:fs";
 import { join as join17 } from "node:path";
 var MAX_WALK_DIRS = 200;
 var MAX_WALK_DEPTH = 4;
@@ -34093,7 +34572,7 @@ function relevantExtensionsInProject(projectRoot, extToServer) {
     visitedDirs += 1;
     let entries;
     try {
-      entries = readdirSync3(current.dir, { withFileTypes: true });
+      entries = readdirSync4(current.dir, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -34514,7 +34993,7 @@ import {
   existsSync as existsSync17,
   lstatSync as lstatSync2,
   mkdirSync as mkdirSync9,
-  readdirSync as readdirSync4,
+  readdirSync as readdirSync5,
   readFileSync as readFileSync15,
   readlinkSync as readlinkSync2,
   realpathSync as realpathSync3,
@@ -34917,7 +35396,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}`);
     }
@@ -35359,14 +35838,18 @@ function normalizeToolArgSchemas(toolDefinition) {
 function bareToolName2(toolName) {
   return toolName.startsWith("aft_") ? toolName.slice(4) : toolName;
 }
-function prepareOpenCodeArguments(toolName, rawArguments) {
+function prepareOpenCodeArguments(toolName, rawArguments, preparation = {}) {
   const bare = bareToolName2(toolName);
+  if (bare === "edit" && preparation.hashlineEffective === true) {
+    return rawArguments;
+  }
   if (bare === "edit") {
     return prepareCanonicalEditArguments(toolName, rawArguments);
   }
   return prepareCanonicalPathArguments(toolName, rawArguments);
 }
 var DISPLAY_FILE_PATH_TOOLS = new Set(["read", "write", "edit"]);
+var PREPARED_EXECUTORS = new WeakSet;
 function preserveDisplayFilePathAlias(toolName, rawArguments, prepared) {
   if (!DISPLAY_FILE_PATH_TOOLS.has(toolName))
     return;
@@ -35377,21 +35860,25 @@ function preserveDisplayFilePathAlias(toolName, rawArguments, prepared) {
     raw.filePath = prepared.path;
   }
 }
-function prepareToolMap(tools) {
+function prepareToolMap(tools, preparation = {}) {
   for (const [toolName, def] of Object.entries(tools)) {
+    if (PREPARED_EXECUTORS.has(def.execute))
+      continue;
     const execute = def.execute;
-    def.execute = async (args, context) => {
-      const prepared = prepareOpenCodeArguments(toolName, args);
+    const preparedExecute = async (args, context) => {
+      const prepared = prepareOpenCodeArguments(toolName, args, preparation);
       preserveDisplayFilePathAlias(toolName, args, prepared);
       return execute(prepared, context);
     };
+    PREPARED_EXECUTORS.add(preparedExecute);
+    def.execute = preparedExecute;
   }
   return tools;
 }
-function normalizeToolMap(tools) {
+function normalizeToolMap(tools, preparation = {}) {
   for (const def of Object.values(tools))
     normalizeToolArgSchemas(def);
-  return prepareToolMap(tools);
+  return prepareToolMap(tools, preparation);
 }
 // src/shared/ignored-message.ts
 async function sendIgnoredMessage2(client, sessionID, text) {
@@ -35522,7 +36009,7 @@ import { randomBytes as randomBytes3, timingSafeEqual as timingSafeEqual2 } from
 import {
   existsSync as existsSync18,
   mkdirSync as mkdirSync10,
-  readdirSync as readdirSync5,
+  readdirSync as readdirSync6,
   readFileSync as readFileSync16,
   renameSync as renameSync9,
   unlinkSync as unlinkSync8,
@@ -35692,7 +36179,7 @@ class AftRpcServer {
   sweepDeadPortFiles() {
     let entries;
     try {
-      entries = readdirSync5(this.portsDir);
+      entries = readdirSync6(this.portsDir);
     } catch {
       return;
     }
@@ -37901,7 +38388,56 @@ ${backupBehavior}
 - Symbol replace includes decorators, attributes, and doc comments in range
 - Response is a compact server-rendered summary; before/after diff details are attached as UI metadata when available.`;
 }
+function createHashlineEditTool(ctx) {
+  return {
+    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.",
+    args: {
+      patch: z8.string().min(1).describe("Hashline patch text with one or more [path#TAG] sections and PUT/CUT/REM/MV operations")
+    },
+    execute: async (args, context) => {
+      const patch = args.patch;
+      const projectRoot = await resolveProjectRoot(ctx, context);
+      const rawArgs = { patch };
+      const preflight = await callToolCall(ctx, context, "hashline_preflight", rawArgs);
+      if (preflight.success === false)
+        throw toolErrorFromResponse("edit", preflight);
+      const permissionPatterns = [
+        ...coerceStringArray(preflight.affected_paths),
+        ...coerceStringArray(preflight.affected_rel_paths),
+        ...coerceStringArray(preflight.mv_destinations)
+      ].filter((value, index, all) => all.indexOf(value) === index);
+      for (const target of [
+        ...coerceStringArray(preflight.affected_paths),
+        ...coerceStringArray(preflight.mv_destinations)
+      ]) {
+        const absolute = resolvePathFromProjectRoot(projectRoot, target);
+        const denial2 = await assertExternalDirectoryPermission(ctx, context, absolute);
+        if (denial2)
+          return permissionDeniedResponse(denial2);
+      }
+      const denial = await askEditPermission(context, permissionPatterns, {
+        surface: "hashline"
+      });
+      if (denial)
+        return permissionDeniedResponse(denial);
+      const preview2 = await callToolCall(ctx, context, "edit", rawArgs, { preview: true });
+      if (preview2.success === false)
+        throw toolErrorFromResponse("edit", preview2);
+      const data = await callToolCall(ctx, context, "edit", rawArgs);
+      if (data.success === false)
+        throw toolErrorFromResponse("edit", data);
+      const firstPath = typeof data.filePath === "string" ? resolvePathFromProjectRoot(projectRoot, data.filePath) : "";
+      return {
+        output: data.text,
+        title: firstPath ? relativeToWorktree(firstPath, projectRoot) : "edit",
+        metadata: data.metadata && typeof data.metadata === "object" ? data.metadata : {}
+      };
+    }
+  };
+}
 function createEditTool(ctx, writeToolName = "write") {
+  if (ctx.hashlineEffective === true)
+    return createHashlineEditTool(ctx);
   return {
     description: getEditDescription(ctx, writeToolName),
     args: {
@@ -38209,7 +38745,7 @@ function hoistedTools(ctx) {
       tools.bash_kill = createBashKillTool(ctx);
     }
   }
-  return prepareToolMap(tools);
+  return prepareToolMap(tools, { hashlineEffective: ctx.hashlineEffective });
 }
 function aftPrefixedTools(ctx) {
   const aftEditTool = createEditTool(ctx, "aft_write");
@@ -38231,7 +38767,7 @@ function aftPrefixedTools(ctx) {
       tools.bash_kill = createBashKillTool(ctx);
     }
   }
-  return prepareToolMap(tools);
+  return prepareToolMap(tools, { hashlineEffective: ctx.hashlineEffective });
 }
 
 // src/tools/imports.ts
@@ -39240,6 +39776,15 @@ function semanticTools(ctx) {
 
 // src/tool-registration.ts
 var ALL_ONLY_TOOLS = ["aft_callgraph", "aft_delete", "aft_move", "aft_refactor"];
+function openCodeEditSlotSurvives(config2) {
+  return (config2.tool_surface ?? "recommended") !== "minimal" && config2.hoist_builtin_tools !== false && !(config2.disabled_tools ?? []).includes("edit");
+}
+function openCodeHashlineEffective(config2) {
+  return config2.edit_mode === "hashline" && openCodeEditSlotSurvives(config2);
+}
+function openCodeHashlineEditRegistered(config2, registeredTools) {
+  return openCodeHashlineEffective(config2) && registeredTools.has("edit");
+}
 function buildOpenCodeToolMap(ctx, config2, onUnknownDisabled) {
   const surface = config2.tool_surface ?? "recommended";
   const allTools = normalizeToolMap({
@@ -39254,7 +39799,7 @@ function buildOpenCodeToolMap(ctx, config2, onUnknownDisabled) {
     ...surface !== "minimal" && config2.search_index === true && searchTools(ctx),
     ...refactoringTools(ctx),
     ...surface !== "minimal" && conflictTools(ctx)
-  });
+  }, { hashlineEffective: ctx.hashlineEffective });
   if (surface !== "all") {
     for (const name of ALL_ONLY_TOOLS)
       delete allTools[name];
@@ -39395,7 +39940,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).",
@@ -39411,22 +39956,23 @@ async function initializePluginForDirectory(input) {
       });
     }
   };
-  let aftConfig = loadAftConfig(input.directory);
+  const registrationRoot = resolveOpenCodeRegistrationRoot(input.directory, input.worktree);
+  let aftConfig = loadAftConfig(registrationRoot);
   if (aftConfig.enabled === false) {
-    log2(`AFT disabled by config for ${input.directory}`);
+    log2(`AFT disabled by config for ${registrationRoot}`);
     return { tool: {} };
   }
-  deliverConfigMigrationWarnings(input.directory, migrateAftConfigLocations(input.directory, bridgeLogger).flatMap((result) => result.warnings));
-  aftConfig = loadAftConfig(input.directory);
-  enqueueConfigParseWarnings(input.directory, getConfigLoadErrors());
+  deliverConfigMigrationWarnings(registrationRoot, migrateAftConfigLocations(registrationRoot, bridgeLogger).flatMap((result) => result.warnings));
+  aftConfig = loadAftConfig(registrationRoot);
+  enqueueConfigParseWarnings(registrationRoot, getConfigLoadErrors());
   if (aftConfig.enabled === false) {
-    log2(`AFT disabled by config for ${input.directory}`);
+    log2(`AFT disabled by config for ${registrationRoot}`);
     return { tool: {} };
   }
   const binaryPath = await findBinary(PLUGIN_VERSION);
   await ensureStorageMigrated({ harness: "opencode", binaryPath, logger: bridgeLogger });
   const autoUpdateAbort = new AbortController;
-  const projectEnabledCache = new Map([[input.directory, true]]);
+  const projectEnabledCache = new Map([[registrationRoot, true]]);
   const loggedDisabledProjects = new Set;
   const isProjectEnabled = (projectRoot) => {
     const cached2 = projectEnabledCache.get(projectRoot);
@@ -39442,10 +39988,11 @@ async function initializePluginForDirectory(input) {
     return enabled;
   };
   const storageDir = resolveCortexKitStorageRoot();
-  const configOverrides = buildConfigTierConfigureParams(input.directory, {
+  const configOverrides = buildConfigTierConfigureParams(registrationRoot, {
     bash_permissions: true,
     storage_dir: storageDir
   });
+  const hashlineEffective = openCodeHashlineEffective(aftConfig);
   let lspInstallCompletion = null;
   const isFastembedSemanticBackend = (aftConfig.semantic?.backend ?? "fastembed") === "fastembed";
   let onnxRuntimePromise = null;
@@ -39635,6 +40182,16 @@ ${lines}
     poolOptions,
     configOverrides,
     subcConnectionFile: aftConfig.subc?.connection_file,
+    onBgEventsNudge: (directory, sessionID) => {
+      handleSubcBgEventsNudge({
+        ctx,
+        directory,
+        sessionID,
+        client: input.client
+      }).catch((err) => {
+        warn2(`[aft-plugin] bg nudge rejected: ${err instanceof Error ? err.message : String(err)}`);
+      });
+    },
     onBgEventsNudgeRef: (ref) => {
       handleSubcBgEventsNudge({
         ctx,
@@ -39664,6 +40221,7 @@ ${lines}
     client: input.client,
     plugin: input.plugin,
     config: aftConfig,
+    hashlineEffective,
     storageDir: configOverrides.storage_dir,
     isProjectEnabled
   };
@@ -39865,6 +40423,10 @@ Install: ${getManualInstallHint()}`).catch(() => {});
     "bash_status"
   ];
   const registeredTools = new Set(Object.keys(allTools));
+  const hashlineEditRegistered = openCodeHashlineEditRegistered(aftConfig, registeredTools);
+  ctx.hashlineEffective = hashlineEditRegistered;
+  pool.setConfigureOverride("edit_slot_survives", hashlineEditRegistered);
+  log2(`hashline activation decision requested=${aftConfig.edit_mode === "hashline"} ` + `edit_slot_survives=${hashlineEditRegistered} effective=${ctx.hashlineEffective}`);
   const aftSearchRegistered = registeredTools.has("aft_search");
   pool.setConfigureOverride("aft_search_registered", aftSearchRegistered);
   ctx.aftSearchRegistered = aftSearchRegistered;
@@ -39959,7 +40521,9 @@ Install: ${getManualInstallHint()}`).catch(() => {});
       signalBashWaitDetachForProject(pool, sessionDir, sid);
     },
     "tool.execute.before": async (toolInput, output) => {
-      output.args = prepareOpenCodeArguments(toolInput.tool, output.args);
+      output.args = prepareOpenCodeArguments(toolInput.tool, output.args, {
+        hashlineEffective: ctx.hashlineEffective
+      });
       if (toolInput.sessionID)
         inspectTier2Idle.clear(toolInput.sessionID);
     },