@cortexkit/aft-pi 0.26.0 → 0.26.1

package/dist/index.js

@@ -6889,7 +6889,7 @@ ${len.toString(16)}\r
 // ../../node_modules/.bun/undici@8.2.0/node_modules/undici/lib/dispatcher/client-h2.js
 var require_client_h2 = __commonJS((exports, module) => {
   var assert = __require("node:assert");
-  var { pipeline: pipeline2 } = __require("node:stream");
+  var { pipeline: pipeline3 } = __require("node:stream");
   var util = require_util();
   var {
     RequestContentLengthMismatchError,
@@ -7658,7 +7658,7 @@ var require_client_h2 = __commonJS((exports, module) => {
   }
   function writeStream(abort, socket, expectsPayload, h2stream, body, client, request, contentLength) {
     assert(contentLength !== 0 || client[kRunning] === 0, "stream body cannot be pipelined");
-    const pipe = pipeline2(body, h2stream, (err) => {
+    const pipe = pipeline3(body, h2stream, (err) => {
       if (err) {
         util.destroy(pipe, err);
         abort(err);
@@ -10422,7 +10422,7 @@ var require_h2c_client = __commonJS((exports, module) => {
 var require_readable = __commonJS((exports, module) => {
   var assert = __require("node:assert");
   var { addAbortListener } = __require("node:events");
-  var { Readable: Readable2 } = __require("node:stream");
+  var { Readable: Readable3 } = __require("node:stream");
   var { RequestAbortedError, NotSupportedError, InvalidArgumentError, AbortError } = require_errors();
   var util = require_util();
   var { ReadableStreamFrom } = require_util();
@@ -10436,7 +10436,7 @@ var require_readable = __commonJS((exports, module) => {
   var kBytesRead = Symbol("kBytesRead");
   var noop = () => {};
 
-  class BodyReadable extends Readable2 {
+  class BodyReadable extends Readable3 {
     constructor({
       resume,
       abort,
@@ -10723,7 +10723,7 @@ var require_readable = __commonJS((exports, module) => {
 var require_api_request = __commonJS((exports, module) => {
   var assert = __require("node:assert");
   var { AsyncResource } = __require("node:async_hooks");
-  var { Readable: Readable2 } = require_readable();
+  var { Readable: Readable3 } = require_readable();
   var { InvalidArgumentError, RequestAbortedError } = require_errors();
   var util = require_util();
   function noop() {}
@@ -10807,7 +10807,7 @@ var require_api_request = __commonJS((exports, module) => {
       const parsedHeaders = headers;
       const contentType = parsedHeaders?.["content-type"];
       const contentLength = parsedHeaders?.["content-length"];
-      const res = new Readable2({
+      const res = new Readable3({
         resume: () => controller.resume(),
         abort: (reason) => controller.abort(reason),
         contentType,
@@ -11137,7 +11137,7 @@ var require_api_stream = __commonJS((exports, module) => {
 // ../../node_modules/.bun/undici@8.2.0/node_modules/undici/lib/api/api-pipeline.js
 var require_api_pipeline = __commonJS((exports, module) => {
   var {
-    Readable: Readable2,
+    Readable: Readable3,
     Duplex,
     PassThrough
   } = __require("node:stream");
@@ -11153,7 +11153,7 @@ var require_api_pipeline = __commonJS((exports, module) => {
   function noop() {}
   var kResume = Symbol("resume");
 
-  class PipelineRequest extends Readable2 {
+  class PipelineRequest extends Readable3 {
     constructor() {
       super({ autoDestroy: true });
       this[kResume] = null;
@@ -11171,7 +11171,7 @@ var require_api_pipeline = __commonJS((exports, module) => {
     }
   }
 
-  class PipelineResponse extends Readable2 {
+  class PipelineResponse extends Readable3 {
     constructor(resume) {
       super({ autoDestroy: true });
       this[kResume] = resume;
@@ -11326,7 +11326,7 @@ var require_api_pipeline = __commonJS((exports, module) => {
       util.destroy(ret, err);
     }
   }
-  function pipeline2(opts, handler) {
+  function pipeline3(opts, handler) {
     try {
       const pipelineHandler = new PipelineHandler(opts, handler);
       this.dispatch({ ...opts, body: pipelineHandler.req }, pipelineHandler);
@@ -11335,7 +11335,7 @@ var require_api_pipeline = __commonJS((exports, module) => {
       return new PassThrough().destroy(err);
     }
   }
-  module.exports = pipeline2;
+  module.exports = pipeline3;
 });
 
 // ../../node_modules/.bun/undici@8.2.0/node_modules/undici/lib/api/api-upgrade.js
@@ -15358,7 +15358,7 @@ var require_cache_revalidation_handler = __commonJS((exports, module) => {
 // ../../node_modules/.bun/undici@8.2.0/node_modules/undici/lib/interceptor/cache.js
 var require_cache2 = __commonJS((exports, module) => {
   var assert = __require("node:assert");
-  var { Readable: Readable2 } = __require("node:stream");
+  var { Readable: Readable3 } = __require("node:stream");
   var util = require_util();
   var CacheHandler = require_cache_handler();
   var MemoryCacheStore = require_memory_cache_store();
@@ -15454,7 +15454,7 @@ var require_cache2 = __commonJS((exports, module) => {
     return dispatch(opts, new CacheHandler(globalOpts, cacheKey, handler));
   }
   function sendCachedValue(handler, opts, result, age, context, isStale2) {
-    const stream = util.isStream(result.body) ? result.body : Readable2.from(result.body ?? []);
+    const stream = util.isStream(result.body) ? result.body : Readable3.from(result.body ?? []);
     assert(!stream.destroyed, "stream should not be destroyed");
     assert(!stream.readableDidRead, "stream should not be readableDidRead");
     const controller = {
@@ -15668,7 +15668,7 @@ var require_cache2 = __commonJS((exports, module) => {
 // ../../node_modules/.bun/undici@8.2.0/node_modules/undici/lib/interceptor/decompress.js
 var require_decompress = __commonJS((exports, module) => {
   var { createInflate, createGunzip, createBrotliDecompress, createZstdDecompress } = __require("node:zlib");
-  var { pipeline: pipeline2 } = __require("node:stream");
+  var { pipeline: pipeline3 } = __require("node:stream");
   var DecoratorHandler = require_decorator_handler();
   var supportedEncodings = {
     gzip: createGunzip,
@@ -15743,7 +15743,7 @@ var require_decompress = __commonJS((exports, module) => {
     #setupMultipleDecompressors(controller) {
       const lastDecompressor = this.#decompressors[this.#decompressors.length - 1];
       this.#setupDecompressorEvents(lastDecompressor, controller);
-      pipeline2(this.#decompressors, (err) => {
+      pipeline3(this.#decompressors, (err) => {
         if (err) {
           super.onResponseError(controller, err);
           return;
@@ -18046,7 +18046,7 @@ var require_fetch = __commonJS((exports, module) => {
     subresourceSet
   } = require_constants3();
   var EE = __require("node:events");
-  var { Readable: Readable2, pipeline: pipeline2, finished, isErrored, isReadable } = __require("node:stream");
+  var { Readable: Readable3, pipeline: pipeline3, finished, isErrored, isReadable } = __require("node:stream");
   var { addAbortListener, bufferToLowerCasedHeaderName } = require_util();
   var { dataURLProcessor, serializeAMimeType, minimizeSupportedMimeType } = require_data_url();
   var { getGlobalDispatcher } = require_global2();
@@ -18937,7 +18937,7 @@ var require_fetch = __commonJS((exports, module) => {
             const headersList = new HeadersList;
             appendHeadersListFromResponseHeaders(headersList, headers, rawHeaders);
             const location = headersList.get("location", true);
-            this.body = new Readable2({ read: () => controller.resume() });
+            this.body = new Readable3({ read: () => controller.resume() });
             const willFollow = location && request.redirect === "follow" && redirectStatusSet.has(status);
             const decoders = [];
             if (request.method !== "HEAD" && request.method !== "CONNECT" && !nullBodyStatus.includes(status) && !willFollow) {
@@ -18981,7 +18981,7 @@ var require_fetch = __commonJS((exports, module) => {
               status,
               statusText,
               headersList,
-              body: decoders.length ? pipeline2(this.body, ...decoders, (err) => {
+              body: decoders.length ? pipeline3(this.body, ...decoders, (err) => {
                 if (err) {
                   this.onResponseError(controller, err);
                 }
@@ -22363,7 +22363,7 @@ ${value}`;
 
 // ../../node_modules/.bun/undici@8.2.0/node_modules/undici/lib/web/eventsource/eventsource.js
 var require_eventsource = __commonJS((exports, module) => {
-  var { pipeline: pipeline2 } = __require("node:stream");
+  var { pipeline: pipeline3 } = __require("node:stream");
   var { fetching } = require_fetch();
   var { makeRequest } = require_request2();
   var { webidl } = require_webidl();
@@ -22492,7 +22492,7 @@ var require_eventsource = __commonJS((exports, module) => {
             this.dispatchEvent(createFastMessageEvent(event.type, event.options));
           }
         });
-        pipeline2(response.body.stream, eventSourceStream, (error2) => {
+        pipeline3(response.body.stream, eventSourceStream, (error2) => {
           if (error2?.aborted === false) {
             this.close();
             this.dispatchEvent(new Event("error"));
@@ -30490,12 +30490,22 @@ function getActiveLogger() {
   return loggerGlobal()[ACTIVE_LOGGER_SYMBOL];
 }
 function getLogFilePath() {
-  return getActiveLogger()?.getLogFilePath?.();
+  try {
+    return getActiveLogger()?.getLogFilePath?.();
+  } catch (err) {
+    console.error(`[aft-bridge] ERROR: active logger getLogFilePath threw: ${err instanceof Error ? err.message : String(err)}`);
+    return;
+  }
 }
 function log(message, meta) {
   const active = getActiveLogger();
   if (active) {
-    active.log(message, meta);
+    try {
+      active.log(message, meta);
+    } catch (err) {
+      console.error(`[aft-bridge] ERROR: active logger log threw: ${err instanceof Error ? err.message : String(err)}`);
+      console.error(`[aft-bridge] ${message}`);
+    }
   } else {
     console.error(`[aft-bridge] ${message}`);
   }
@@ -30503,7 +30513,12 @@ function log(message, meta) {
 function warn(message, meta) {
   const active = getActiveLogger();
   if (active) {
-    active.warn(message, meta);
+    try {
+      active.warn(message, meta);
+    } catch (err) {
+      console.error(`[aft-bridge] ERROR: active logger warn threw: ${err instanceof Error ? err.message : String(err)}`);
+      console.error(`[aft-bridge] WARN: ${message}`);
+    }
   } else {
     console.error(`[aft-bridge] WARN: ${message}`);
   }
@@ -30511,20 +30526,16 @@ function warn(message, meta) {
 function error(message, meta) {
   const active = getActiveLogger();
   if (active) {
-    active.error(message, meta);
+    try {
+      active.error(message, meta);
+    } catch (err) {
+      console.error(`[aft-bridge] ERROR: active logger error threw: ${err instanceof Error ? err.message : String(err)}`);
+      console.error(`[aft-bridge] ERROR: ${message}`);
+    }
   } else {
     console.error(`[aft-bridge] ERROR: ${message}`);
   }
 }
-function sessionLog(sessionId, message) {
-  log(message, sessionId ? { sessionId } : undefined);
-}
-function sessionWarn(sessionId, message) {
-  warn(message, sessionId ? { sessionId } : undefined);
-}
-function sessionError(sessionId, message) {
-  error(message, sessionId ? { sessionId } : undefined);
-}
 // ../aft-bridge/dist/bridge.js
 import { spawn } from "node:child_process";
 import { homedir } from "node:os";
@@ -30619,6 +30630,7 @@ class BinaryBridge {
   pending = new Map;
   nextId = 1;
   stdoutBuffer = "";
+  stderrBuffer = "";
   stderrTail = [];
   _restartCount = 0;
   _shuttingDown = false;
@@ -30654,24 +30666,62 @@ class BinaryBridge {
   }
   logVia(message, meta) {
     const logger = this.logger ?? getActiveLogger();
-    if (logger)
-      logger.log(message, meta);
-    else
+    if (logger) {
+      try {
+        logger.log(message, meta);
+      } catch (err) {
+        console.error(`[aft-bridge] ERROR: logger log threw: ${err instanceof Error ? err.message : String(err)}`);
+        console.error(`[aft-bridge] ${message}`);
+      }
+    } else {
       log(message, meta);
+    }
   }
   warnVia(message, meta) {
     const logger = this.logger ?? getActiveLogger();
-    if (logger)
-      logger.warn(message, meta);
-    else
+    if (logger) {
+      try {
+        logger.warn(message, meta);
+      } catch (err) {
+        console.error(`[aft-bridge] ERROR: logger warn threw: ${err instanceof Error ? err.message : String(err)}`);
+        console.error(`[aft-bridge] WARN: ${message}`);
+      }
+    } else {
       warn(message, meta);
+    }
   }
   errorVia(message, meta) {
     const logger = this.logger ?? getActiveLogger();
-    if (logger)
-      logger.error(message, meta);
-    else
+    if (logger) {
+      try {
+        logger.error(message, meta);
+      } catch (err) {
+        console.error(`[aft-bridge] ERROR: logger error threw: ${err instanceof Error ? err.message : String(err)}`);
+        console.error(`[aft-bridge] ERROR: ${message}`);
+      }
+    } else {
       error(message, meta);
+    }
+  }
+  getLogFilePathVia() {
+    if (this.logger?.getLogFilePath) {
+      try {
+        return this.logger.getLogFilePath();
+      } catch (err) {
+        console.error(`[aft-bridge] ERROR: logger getLogFilePath threw: ${err instanceof Error ? err.message : String(err)}`);
+        return;
+      }
+    }
+    return getLogFilePath();
+  }
+  sessionLogVia(sessionId, message) {
+    this.logVia(message, sessionId ? { sessionId } : undefined);
+  }
+  sessionWarnVia(sessionId, message) {
+    this.warnVia(message, sessionId ? { sessionId } : undefined);
+  }
+  sessionErrorVia(sessionId, message) {
+    this.errorVia(message, sessionId ? { sessionId } : undefined);
   }
   get restartCount() {
     return this._restartCount;
@@ -30730,7 +30780,7 @@ class BinaryBridge {
                 await this.deliverConfigureWarnings(configResult, params, options);
                 await this.checkVersion();
                 if (!this.isAlive()) {
-                  throw new Error(`${this.errorPrefix} Bridge died during version check. Check logs: ${getLogFilePath()}`);
+                  throw new Error(`${this.errorPrefix} Bridge died during version check. Check logs: ${this.getLogFilePathVia()}`);
                 }
                 this.configured = true;
               } finally {
@@ -30766,9 +30816,9 @@ class BinaryBridge {
           const restartSuffix = keepBridgeOnTimeout ? "" : " — restarting bridge";
           const timeoutMsg = `Request "${command}" (id=${id}) timed out after ${effectiveTimeoutMs}ms${restartSuffix}`;
           if (requestSessionId) {
-            sessionWarn(requestSessionId, timeoutMsg);
+            this.sessionWarnVia(requestSessionId, timeoutMsg);
           } else {
-            warn(timeoutMsg);
+            this.warnVia(timeoutMsg);
           }
           reject(new Error(`${this.errorPrefix} Request "${command}" (id=${id}) timed out after ${effectiveTimeoutMs}ms`));
           if (!keepBridgeOnTimeout) {
@@ -30795,7 +30845,7 @@ class BinaryBridge {
       });
     } catch (err) {
       if (err instanceof BridgeReplacedDuringVersionCheck && canRetryAfterVersionSwap && command !== "configure" && command !== "version") {
-        log(`Retrying request "${command}" once after coordinated binary replacement: ${err.newBinaryPath}`);
+        this.logVia(`Retrying request "${command}" once after coordinated binary replacement: ${err.newBinaryPath}`);
         return this.sendWithVersionMismatchRetry(command, params, options, false);
       }
       throw err;
@@ -30815,7 +30865,7 @@ class BinaryBridge {
         warnings: configResult.warnings
       });
     } catch (err) {
-      warn(`configure warning delivery failed: ${err instanceof Error ? err.message : String(err)}`);
+      this.warnVia(`configure warning delivery failed: ${err instanceof Error ? err.message : String(err)}`);
     } finally {
       if (sessionId) {
         this.configureWarningClients.delete(sessionId);
@@ -30849,7 +30899,7 @@ class BinaryBridge {
     if (!snapshot || typeof snapshot !== "object" || Array.isArray(snapshot))
       return;
     this.cachedStatus = snapshot;
-    log("Received status_changed push frame; cached AFT status snapshot");
+    this.logVia("Received status_changed push frame; cached AFT status snapshot");
     for (const listener of this.statusListeners) {
       this.deliverStatusSnapshot(listener, this.cachedStatus);
     }
@@ -30858,7 +30908,7 @@ class BinaryBridge {
     try {
       listener(snapshot);
     } catch (err) {
-      warn(`status listener threw: ${err instanceof Error ? err.message : String(err)}`);
+      this.warnVia(`status listener threw: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
   async shutdown() {
@@ -30876,7 +30926,7 @@ class BinaryBridge {
         }, 5000);
         proc.once("exit", () => {
           clearTimeout(forceKillTimer);
-          log("Process exited during shutdown");
+          this.logVia("Process exited during shutdown");
           resolve();
         });
         proc.kill("SIGTERM");
@@ -30895,9 +30945,9 @@ class BinaryBridge {
       if (typeof binaryVersion !== "string") {
         throw new Error(`Binary did not report a version — likely too old (minVersion: ${this.minVersion})`);
       }
-      log(`Binary version: ${binaryVersion}`);
+      this.logVia(`Binary version: ${binaryVersion}`);
       if (compareSemver(binaryVersion, this.minVersion) < 0) {
-        warn(`Binary version ${binaryVersion} is older than required ${this.minVersion}`);
+        this.warnVia(`Binary version ${binaryVersion} is older than required ${this.minVersion}`);
         const replacementPath = await this.onVersionMismatch?.(binaryVersion, this.minVersion);
         if (replacementPath === undefined) {
           return;
@@ -30909,7 +30959,7 @@ class BinaryBridge {
         throw new BridgeReplacedDuringVersionCheck(replacementPath);
       }
     } catch (err) {
-      warn(`Version check failed: ${err.message}`);
+      this.warnVia(`Version check failed: ${err.message}`);
       throw err;
     }
   }
@@ -30929,7 +30979,7 @@ class BinaryBridge {
       }, 5000);
       proc.once("exit", () => {
         clearTimeout(forceKillTimer);
-        log("Process exited during coordinated binary replacement");
+        this.logVia("Process exited during coordinated binary replacement");
         resolve();
       });
       proc.kill("SIGTERM");
@@ -30942,9 +30992,9 @@ class BinaryBridge {
   }
   spawnProcess(triggeringSessionId) {
     if (triggeringSessionId) {
-      sessionLog(triggeringSessionId, `Spawning binary: ${this.binaryPath} (cwd: ${this.cwd})`);
+      this.sessionLogVia(triggeringSessionId, `Spawning binary: ${this.binaryPath} (cwd: ${this.cwd})`);
     } else {
-      log(`Spawning binary: ${this.binaryPath} (cwd: ${this.cwd})`);
+      this.logVia(`Spawning binary: ${this.binaryPath} (cwd: ${this.cwd})`);
     }
     const semantic = this.configOverrides.semantic;
     const semanticBackend = (() => {
@@ -30991,11 +31041,12 @@ class BinaryBridge {
       const remaining = stderrDecoder.end();
       if (remaining)
         this.onStderrData(remaining);
+      this.flushStderrBuffer();
     });
     child.on("error", (err) => {
       if (this.process !== currentChild)
         return;
-      error(`Process error: ${err.message}${this.formatStderrTail()}`);
+      this.errorVia(`Process error: ${err.message}${this.formatStderrTail()}`);
       this.handleCrash();
     });
     child.on("exit", (code, signal) => {
@@ -31003,7 +31054,7 @@ class BinaryBridge {
         return;
       if (this._shuttingDown)
         return;
-      log(`Process exited: code=${code}, signal=${signal}`);
+      this.logVia(`Process exited: code=${code}, signal=${signal}`);
       if (signal === "SIGTERM" || signal === "SIGKILL" || signal === "SIGHUP" || signal === "SIGINT") {
         this.process = null;
         this.configured = false;
@@ -31015,6 +31066,7 @@ class BinaryBridge {
     });
     this.process = child;
     this.stdoutBuffer = "";
+    this.stderrBuffer = "";
     this.stderrTail = [];
   }
   pushStderrLine(line) {
@@ -31024,16 +31076,28 @@ class BinaryBridge {
     }
   }
   onStderrData(data) {
-    const lines = data.trimEnd().split(`
-`);
-    for (const line of lines) {
+    this.stderrBuffer += data;
+    let newlineIdx;
+    while ((newlineIdx = this.stderrBuffer.indexOf(`
+`)) !== -1) {
+      const line = this.stderrBuffer.slice(0, newlineIdx).replace(/\r$/, "");
+      this.stderrBuffer = this.stderrBuffer.slice(newlineIdx + 1);
       if (!line)
         continue;
       const tagged = tagStderrLine(line);
-      log(tagged);
+      this.logVia(tagged);
       this.pushStderrLine(tagged);
     }
   }
+  flushStderrBuffer() {
+    const line = this.stderrBuffer.replace(/\r$/, "");
+    this.stderrBuffer = "";
+    if (!line)
+      return;
+    const tagged = tagStderrLine(line);
+    this.logVia(tagged);
+    this.pushStderrLine(tagged);
+  }
   formatStderrTail() {
     if (this.stderrTail.length === 0)
       return "";
@@ -31091,7 +31155,7 @@ class BinaryBridge {
         }
         if (response.type === "configure_warnings") {
           this.handleConfigureWarningsFrame(response).catch((err) => {
-            warn(`configure warning delivery failed: ${err instanceof Error ? err.message : String(err)}`);
+            this.warnVia(`configure warning delivery failed: ${err instanceof Error ? err.message : String(err)}`);
           });
           continue;
         }
@@ -31109,10 +31173,10 @@ class BinaryBridge {
           this.scheduleRestartCountReset();
           entry.resolve(response);
         } else if (typeof response.type === "string") {
-          log(`Ignoring unknown stdout push frame type: ${response.type}`);
+          this.logVia(`Ignoring unknown stdout push frame type: ${response.type}`);
         }
       } catch (_err) {
-        warn(`Failed to parse stdout line: ${line}`);
+        this.warnVia(`Failed to parse stdout line: ${line}`);
       }
     }
   }
@@ -31126,17 +31190,17 @@ class BinaryBridge {
     this.configured = false;
     const tail = this.formatStderrTail();
     this.stderrTail = [];
-    const killedMsg = tail ? `Bridge killed after timeout.${tail}` : `Bridge killed after timeout (see ${getLogFilePath()})`;
+    const killedMsg = tail ? `Bridge killed after timeout.${tail}` : `Bridge killed after timeout (see ${this.getLogFilePathVia()})`;
     if (tail) {
       if (triggeringSessionId) {
-        sessionError(triggeringSessionId, killedMsg);
+        this.sessionErrorVia(triggeringSessionId, killedMsg);
       } else {
-        error(killedMsg);
+        this.errorVia(killedMsg);
       }
     } else if (triggeringSessionId) {
-      sessionWarn(triggeringSessionId, killedMsg);
+      this.sessionWarnVia(triggeringSessionId, killedMsg);
     } else {
-      warn(killedMsg);
+      this.warnVia(killedMsg);
     }
   }
   handleCrash(cause) {
@@ -31149,25 +31213,25 @@ class BinaryBridge {
     this.configured = false;
     const tail = this.formatStderrTail();
     if (tail) {
-      error(`Binary crashed (restarts: ${this._restartCount})${cause ? `: ${cause.message}` : ""}.${tail}`);
+      this.errorVia(`Binary crashed (restarts: ${this._restartCount})${cause ? `: ${cause.message}` : ""}.${tail}`);
     }
-    this.rejectAllPending(new Error(`${this.errorPrefix} Binary crashed (restarts: ${this._restartCount})${cause ? `: ${cause.message}` : ""} (see ${getLogFilePath()})`));
+    this.rejectAllPending(new Error(`${this.errorPrefix} Binary crashed (restarts: ${this._restartCount})${cause ? `: ${cause.message}` : ""} (see ${this.getLogFilePathVia()})`));
     if (this._restartCount < this.maxRestarts) {
       const delay = 100 * 2 ** this._restartCount;
       this._restartCount++;
-      log(`Auto-restart #${this._restartCount} in ${delay}ms`);
+      this.logVia(`Auto-restart #${this._restartCount} in ${delay}ms`);
       setTimeout(() => {
         if (!this._shuttingDown && !this.isAlive()) {
           try {
             this.spawnProcess();
           } catch (err) {
-            error(`Failed to restart: ${err.message}`);
+            this.errorVia(`Failed to restart: ${err.message}`);
           }
         }
       }, delay);
       this.scheduleRestartCountReset();
     } else {
-      error(`Max restarts (${this.maxRestarts}) reached, giving up. Logs: ${getLogFilePath()}${tail}`);
+      this.errorVia(`Max restarts (${this.maxRestarts}) reached, giving up. Logs: ${this.getLogFilePathVia()}${tail}`);
       this.scheduleRestartCountReset();
     }
   }
@@ -31193,9 +31257,12 @@ class BinaryBridge {
   }
 }
 // ../aft-bridge/dist/downloader.js
-import { chmodSync, existsSync, mkdirSync, unlinkSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { chmodSync, closeSync, createWriteStream, existsSync, mkdirSync, openSync, renameSync, rmSync, statSync, unlinkSync } from "node:fs";
 import { homedir as homedir2 } from "node:os";
 import { join as join2 } from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
 
 // ../aft-bridge/dist/platform.js
 var PLATFORM_ARCH_MAP = {
@@ -31213,6 +31280,11 @@ var PLATFORM_ASSET_MAP = {
 
 // ../aft-bridge/dist/downloader.js
 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;
 function getCacheDir() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
@@ -31254,54 +31326,101 @@ async function downloadBinary(version) {
   const downloadUrl = `https://github.com/${REPO}/releases/download/${tag}/${assetName}`;
   const checksumUrl = `https://github.com/${REPO}/releases/download/${tag}/checksums.sha256`;
   log(`Downloading AFT binary (${tag}) for ${platformKey}...`);
+  const lockPath = join2(versionedCacheDir, ".download.lock");
+  let releaseLock = null;
+  let binaryController = null;
+  let checksumController = null;
+  let binaryTimeout = null;
+  let checksumTimeout = null;
+  const tmpPath = `${binaryPath}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`;
   try {
     if (!existsSync(versionedCacheDir)) {
       mkdirSync(versionedCacheDir, { recursive: true });
     }
+    releaseLock = await acquireDownloadLock(lockPath);
+    if (existsSync(binaryPath)) {
+      return binaryPath;
+    }
+    binaryController = new AbortController;
+    checksumController = new AbortController;
+    const activeBinaryController = binaryController;
+    const activeChecksumController = checksumController;
+    binaryTimeout = setTimeout(() => activeBinaryController.abort(), DOWNLOAD_TIMEOUT_MS);
+    checksumTimeout = setTimeout(() => activeChecksumController.abort(), DOWNLOAD_TIMEOUT_MS);
     const [binaryResponse, checksumResponse] = await Promise.all([
-      fetch(downloadUrl, { redirect: "follow" }),
-      fetch(checksumUrl, { redirect: "follow" })
+      fetch(downloadUrl, { redirect: "follow", signal: activeBinaryController.signal }),
+      fetch(checksumUrl, { redirect: "follow", signal: activeChecksumController.signal })
     ]);
     if (!binaryResponse.ok) {
       throw new Error(`HTTP ${binaryResponse.status}: ${binaryResponse.statusText} (${downloadUrl})`);
     }
-    const arrayBuffer = await binaryResponse.arrayBuffer();
+    if (!binaryResponse.body) {
+      throw new Error(`Download response for ${assetName} had no body`);
+    }
+    const advertised = Number.parseInt(binaryResponse.headers.get("content-length") ?? "", 10);
+    if (Number.isFinite(advertised) && advertised > MAX_DOWNLOAD_BYTES) {
+      throw new Error(`Content-Length ${advertised} exceeds max ${MAX_DOWNLOAD_BYTES}`);
+    }
     if (!checksumResponse.ok) {
       warn(`Checksum verification failed: no checksums.sha256 found for ${tag}. ` + "Binary download aborted for security reasons.");
       return null;
     }
     const checksumText = await checksumResponse.text();
+    clearTimeout(checksumTimeout);
+    checksumTimeout = null;
     const expectedHash = parseChecksumForAsset(checksumText, assetName);
     if (!expectedHash) {
       warn(`Checksum verification failed: checksums.sha256 found but no entry for ${assetName}. ` + "Binary download aborted for security reasons.");
       return null;
     }
-    const { createHash } = await import("node:crypto");
-    const actualHash = createHash("sha256").update(Buffer.from(arrayBuffer)).digest("hex");
+    const hash = createHash("sha256");
+    let bytesWritten = 0;
+    const guard = new TransformStream({
+      transform(chunk, controller) {
+        bytesWritten += chunk.byteLength;
+        if (bytesWritten > MAX_DOWNLOAD_BYTES) {
+          controller.error(new Error(`download exceeded ${MAX_DOWNLOAD_BYTES} bytes after streaming (server lied about size or sent unbounded body)`));
+          return;
+        }
+        hash.update(chunk);
+        controller.enqueue(chunk);
+      }
+    });
+    const guarded = binaryResponse.body.pipeThrough(guard);
+    const nodeStream = Readable.fromWeb(guarded);
+    await pipeline(nodeStream, createWriteStream(tmpPath), { signal: binaryController.signal });
+    clearTimeout(binaryTimeout);
+    binaryTimeout = null;
+    const actualHash = hash.digest("hex");
     if (actualHash !== expectedHash) {
-      throw new Error(`Checksum mismatch for ${assetName}: expected ${expectedHash}, got ${actualHash}. The binary may have been tampered with.`);
+      throw new Error(`Checksum mismatch for ${assetName}: expected ${expectedHash}, got ${actualHash}. ` + "The binary may have been tampered with.");
     }
     log(`Checksum verified (SHA-256: ${actualHash.slice(0, 16)}...)`);
-    const tmpPath = `${binaryPath}.tmp`;
-    const { writeFileSync } = await import("node:fs");
-    writeFileSync(tmpPath, Buffer.from(arrayBuffer));
     if (process.platform !== "win32") {
       chmodSync(tmpPath, 493);
     }
-    const { renameSync } = await import("node:fs");
     renameSync(tmpPath, binaryPath);
     log(`AFT binary ready at ${binaryPath}`);
     return binaryPath;
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     error(`Failed to download AFT binary: ${msg}`);
-    const tmpPath = `${binaryPath}.tmp`;
     if (existsSync(tmpPath)) {
       try {
         unlinkSync(tmpPath);
       } catch {}
     }
     return null;
+  } finally {
+    if (binaryTimeout) {
+      binaryController?.abort();
+      clearTimeout(binaryTimeout);
+    }
+    if (checksumTimeout) {
+      checksumController?.abort();
+      clearTimeout(checksumTimeout);
+    }
+    releaseLock?.();
   }
 }
 async function ensureBinary(version) {
@@ -31318,6 +31437,39 @@ async function ensureBinary(version) {
   log("No cached binary found, downloading latest...");
   return downloadBinary();
 }
+async function acquireDownloadLock(lockPath) {
+  const startedAt = Date.now();
+  while (true) {
+    try {
+      const fd = openSync(lockPath, "wx");
+      return () => {
+        try {
+          closeSync(fd);
+        } catch {}
+        try {
+          rmSync(lockPath, { force: true });
+        } catch {}
+      };
+    } catch (err) {
+      const code = err.code;
+      if (code !== "EEXIST")
+        throw err;
+      try {
+        const ageMs = Date.now() - statSync(lockPath).mtimeMs;
+        if (ageMs > DOWNLOAD_LOCK_STALE_MS) {
+          rmSync(lockPath, { force: true });
+          continue;
+        }
+      } catch {
+        continue;
+      }
+      if (Date.now() - startedAt > DOWNLOAD_LOCK_TIMEOUT_MS) {
+        throw new Error(`Timed out waiting for download lock: ${lockPath}`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+  }
+}
 function parseChecksumForAsset(checksumText, assetName) {
   for (const line of checksumText.split(`
 `)) {
@@ -31332,9 +31484,12 @@ function parseChecksumForAsset(checksumText, assetName) {
   return null;
 }
 async function fetchLatestTag() {
+  const controller = new AbortController;
+  const timeout = setTimeout(() => controller.abort(), LATEST_TAG_TIMEOUT_MS);
   try {
     const response = await fetch(`https://api.github.com/repos/${REPO}/releases/latest`, {
-      headers: { Accept: "application/vnd.github.v3+json" }
+      headers: { Accept: "application/vnd.github.v3+json" },
+      signal: controller.signal
     });
     if (!response.ok)
       return null;
@@ -31342,18 +31497,20 @@ async function fetchLatestTag() {
     return data.tag_name ?? null;
   } catch {
     return null;
+  } finally {
+    clearTimeout(timeout);
   }
 }
 // ../aft-bridge/dist/onnx-runtime.js
 import { execFileSync } from "node:child_process";
-import { createHash } from "node:crypto";
-import { chmodSync as chmodSync2, closeSync, copyFileSync, createWriteStream, existsSync as existsSync2, lstatSync, mkdirSync as mkdirSync2, openSync, readdirSync, readFileSync, readlinkSync, realpathSync, rmSync, statSync, symlinkSync, unlinkSync as unlinkSync2, writeFileSync } from "node:fs";
+import { createHash as createHash2 } from "node:crypto";
+import { chmodSync as chmodSync2, closeSync as closeSync2, copyFileSync, createWriteStream as createWriteStream2, existsSync as existsSync2, lstatSync, mkdirSync as mkdirSync2, openSync as openSync2, readdirSync, readFileSync, readlinkSync, realpathSync, rmSync as rmSync2, statSync as statSync2, symlinkSync, unlinkSync as unlinkSync2, writeFileSync } from "node:fs";
 import { dirname, join as join3, relative, resolve } from "node:path";
-import { Readable } from "node:stream";
-import { pipeline } from "node:stream/promises";
+import { Readable as Readable2 } from "node:stream";
+import { pipeline as pipeline2 } from "node:stream/promises";
 var ORT_VERSION = "1.24.4";
 var ORT_REPO = "microsoft/onnxruntime";
-var MAX_DOWNLOAD_BYTES = 256 * 1024 * 1024;
+var MAX_DOWNLOAD_BYTES2 = 256 * 1024 * 1024;
 var MAX_EXTRACT_BYTES = 1 * 1024 * 1024 * 1024;
 var ONNX_LOCK_FILE = ".aft-onnx-installing";
 var ONNX_INSTALLED_META_FILE = ".aft-onnx-installed";
@@ -31471,7 +31628,7 @@ function cleanupAbandonedStagingDirs(onnxBaseDir) {
       if (Number.isFinite(pid) && pid > 0) {
         if (process.platform === "win32") {
           try {
-            const ageMs = Date.now() - statSync(stagingDir).mtimeMs;
+            const ageMs = Date.now() - statSync2(stagingDir).mtimeMs;
             abandoned = ageMs > STALE_LOCK_MS;
           } catch {
             abandoned = true;
@@ -31485,7 +31642,7 @@ function cleanupAbandonedStagingDirs(onnxBaseDir) {
       if (abandoned) {
         log(`[onnx] removing abandoned staging dir ${stagingDir}`);
         try {
-          rmSync(stagingDir, { recursive: true, force: true });
+          rmSync2(stagingDir, { recursive: true, force: true });
         } catch (err) {
           warn(`[onnx] failed to remove ${stagingDir}: ${err}`);
         }
@@ -31497,7 +31654,7 @@ function cleanupIncompleteTargetIfUnowned(ortDir) {
   try {
     if (existsSync2(ortDir) && !existsSync2(join3(ortDir, ONNX_INSTALLED_META_FILE))) {
       log(`[onnx] removing half-populated install dir ${ortDir} (no meta file)`);
-      rmSync(ortDir, { recursive: true, force: true });
+      rmSync2(ortDir, { recursive: true, force: true });
     }
   } catch (err) {
     warn(`[onnx] failed to sweep ${ortDir}: ${err}`);
@@ -31577,24 +31734,24 @@ async function downloadFileWithCap(url, destPath) {
       throw new Error(`download failed (HTTP ${res.status})`);
     }
     const advertised = Number.parseInt(res.headers.get("content-length") ?? "", 10);
-    if (Number.isFinite(advertised) && advertised > MAX_DOWNLOAD_BYTES) {
-      throw new Error(`Content-Length ${advertised} exceeds max ${MAX_DOWNLOAD_BYTES}`);
+    if (Number.isFinite(advertised) && advertised > MAX_DOWNLOAD_BYTES2) {
+      throw new Error(`Content-Length ${advertised} exceeds max ${MAX_DOWNLOAD_BYTES2}`);
     }
     mkdirSync2(dirname(destPath), { recursive: true });
     let bytesWritten = 0;
     const guard = new TransformStream({
       transform(chunk, transformController) {
         bytesWritten += chunk.byteLength;
-        if (bytesWritten > MAX_DOWNLOAD_BYTES) {
-          transformController.error(new Error(`download exceeded ${MAX_DOWNLOAD_BYTES} bytes after streaming (server lied about size or sent unbounded body)`));
+        if (bytesWritten > MAX_DOWNLOAD_BYTES2) {
+          transformController.error(new Error(`download exceeded ${MAX_DOWNLOAD_BYTES2} bytes after streaming (server lied about size or sent unbounded body)`));
           return;
         }
         transformController.enqueue(chunk);
       }
     });
     const guarded = res.body.pipeThrough(guard);
-    const nodeStream = Readable.fromWeb(guarded);
-    await pipeline(nodeStream, createWriteStream(destPath), { signal: controller.signal });
+    const nodeStream = Readable2.fromWeb(guarded);
+    await pipeline2(nodeStream, createWriteStream2(destPath), { signal: controller.signal });
   } catch (err) {
     try {
       unlinkSync2(destPath);
@@ -31693,16 +31850,16 @@ async function downloadOnnxRuntime(info, targetDir) {
       warn(`Could not hash newly-installed ONNX library at ${libPath}: ${err}`);
     }
     writeOnnxInstalledMeta(targetDir, ORT_VERSION, libHash, archiveSha256);
-    rmSync(tmpDir, { recursive: true, force: true });
+    rmSync2(tmpDir, { recursive: true, force: true });
     log(`ONNX Runtime v${ORT_VERSION} installed to ${targetDir}`);
     return targetDir;
   } catch (err) {
     error(`Failed to download ONNX Runtime: ${err}`);
     try {
-      rmSync(tmpDir, { recursive: true, force: true });
+      rmSync2(tmpDir, { recursive: true, force: true });
     } catch {}
     try {
-      rmSync(targetDir, { recursive: true, force: true });
+      rmSync2(targetDir, { recursive: true, force: true });
     } catch {}
     return null;
   }
@@ -31719,7 +31876,7 @@ function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, c
       }
     } catch (copyErr) {
       if (requiredLibs.has(libFile)) {
-        rmSync(targetDir, { recursive: true, force: true });
+        rmSync2(targetDir, { recursive: true, force: true });
         throw copyErr;
       }
       log(`ORT extract: failed to copy optional ${libFile}: ${copyErr}`);
@@ -31734,7 +31891,7 @@ function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, c
       symlinkSync(link.target, dst);
     } catch (symlinkErr) {
       if (requiredLibs.has(link.name)) {
-        rmSync(targetDir, { recursive: true, force: true });
+        rmSync2(targetDir, { recursive: true, force: true });
         throw symlinkErr;
       }
       log(`ORT extract: failed to symlink optional ${link.name}: ${symlinkErr}`);
@@ -31742,7 +31899,7 @@ function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, c
   }
   const requiredPath = join3(targetDir, info.libName);
   if (!existsSync2(requiredPath)) {
-    rmSync(targetDir, { recursive: true, force: true });
+    rmSync2(targetDir, { recursive: true, force: true });
     throw new Error(`Required ONNX Runtime library missing after install: ${requiredPath}`);
   }
 }
@@ -31775,7 +31932,7 @@ function writeOnnxInstalledMeta(installDir, version, sha256, archiveSha256) {
 function readOnnxInstalledMeta(installDir) {
   const path = join3(installDir, ONNX_INSTALLED_META_FILE);
   try {
-    if (!statSync(path).isFile())
+    if (!statSync2(path).isFile())
       return null;
     const raw = readFileSync(path, "utf8");
     const parsed = JSON.parse(raw);
@@ -31792,20 +31949,20 @@ function readOnnxInstalledMeta(installDir) {
   }
 }
 function sha256File(path) {
-  const hash = createHash("sha256");
+  const hash = createHash2("sha256");
   hash.update(readFileSync(path));
   return hash.digest("hex");
 }
 function acquireLock(lockPath) {
   const tryClaim = () => {
     try {
-      const fd = openSync(lockPath, "wx");
+      const fd = openSync2(lockPath, "wx");
       try {
         writeFileSync(fd, `${process.pid}
 ${new Date().toISOString()}
 `);
       } finally {
-        closeSync(fd);
+        closeSync2(fd);
       }
       return true;
     } catch (err) {
@@ -31826,7 +31983,7 @@ ${new Date().toISOString()}
     const parsed = Number.parseInt(firstLine, 10);
     if (Number.isFinite(parsed) && parsed > 0)
       owningPid = parsed;
-    lockMtimeMs = statSync(lockPath).mtimeMs;
+    lockMtimeMs = statSync2(lockPath).mtimeMs;
   } catch {
     return tryClaim();
   }
@@ -31943,7 +32100,9 @@ class BridgePool {
       onVersionMismatch: options.onVersionMismatch,
       onConfigureWarnings: options.onConfigureWarnings,
       onBashCompletion: options.onBashCompletion,
-      onBashLongRunning: options.onBashLongRunning
+      onBashLongRunning: options.onBashLongRunning,
+      errorPrefix: options.errorPrefix,
+      logger: options.logger
     };
     this.configOverrides = configOverrides;
     if (Number.isFinite(this.idleTimeoutMs)) {
@@ -32015,24 +32174,32 @@ class BridgePool {
   }
   async replaceBinary(newPath) {
     this.binaryPath = newPath;
-    const shutdowns = Array.from(this.bridges.values()).map((entry) => entry.bridge.shutdown());
     this.bridges.clear();
-    await Promise.allSettled(shutdowns);
     this.log(`Binary path updated to ${newPath}. All bridges cleared — next calls will use the new binary.`);
     return newPath;
   }
   log(message, meta) {
     const logger = this.logger ?? getActiveLogger();
-    if (logger)
-      logger.log(message, meta);
-    else
+    if (logger) {
+      try {
+        logger.log(message, meta);
+      } catch (err) {
+        console.error(`[aft-bridge] ERROR: pool logger log threw: ${err instanceof Error ? err.message : String(err)}`);
+        console.error(`[aft-bridge] ${message}`);
+      }
+    } else
       log(message, meta);
   }
   error(message, meta) {
     const logger = this.logger ?? getActiveLogger();
-    if (logger)
-      logger.error(message, meta);
-    else
+    if (logger) {
+      try {
+        logger.error(message, meta);
+      } catch (err) {
+        console.error(`[aft-bridge] ERROR: pool logger error threw: ${err instanceof Error ? err.message : String(err)}`);
+        console.error(`[aft-bridge] ERROR: ${message}`);
+      }
+    } else
       error(message, meta);
   }
   setConfigureOverride(key, value) {
@@ -32059,7 +32226,7 @@ function normalizeKey(projectRoot) {
 }
 // ../aft-bridge/dist/resolver.js
 import { execSync, spawnSync } from "node:child_process";
-import { chmodSync as chmodSync3, copyFileSync as copyFileSync2, existsSync as existsSync3, mkdirSync as mkdirSync3, renameSync } from "node:fs";
+import { chmodSync as chmodSync3, copyFileSync as copyFileSync2, existsSync as existsSync3, mkdirSync as mkdirSync3, renameSync as renameSync2 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
 import { homedir as homedir4 } from "node:os";
 import { join as join4 } from "node:path";
@@ -32090,15 +32257,19 @@ function copyToVersionedCache(npmBinaryPath, knownVersion) {
     const versionedDir = join4(cacheDir, tag);
     const ext = process.platform === "win32" ? ".exe" : "";
     const cachedPath = join4(versionedDir, `aft${ext}`);
-    if (existsSync3(cachedPath))
-      return cachedPath;
+    if (existsSync3(cachedPath)) {
+      const cachedVersion = readBinaryVersion(cachedPath);
+      if (cachedVersion === version)
+        return cachedPath;
+      warn(`Cached binary at ${cachedPath} reports ${cachedVersion ?? "no version"}, expected ${version}; refreshing from npm package`);
+    }
     mkdirSync3(versionedDir, { recursive: true });
-    const tmpPath = `${cachedPath}.tmp`;
+    const tmpPath = `${cachedPath}.${process.pid}.${Date.now()}.tmp`;
     copyFileSync2(npmBinaryPath, tmpPath);
     if (process.platform !== "win32") {
       chmodSync3(tmpPath, 493);
     }
-    renameSync(tmpPath, cachedPath);
+    renameSync2(tmpPath, cachedPath);
     log(`Copied npm binary to versioned cache: ${cachedPath}`);
     return cachedPath;
   } catch (err) {
@@ -32106,6 +32277,17 @@ function copyToVersionedCache(npmBinaryPath, knownVersion) {
     return null;
   }
 }
+function normalizeBareVersion(version) {
+  return version.startsWith("v") ? version.slice(1) : version;
+}
+function isExpectedCachedBinary(binaryPath, expectedVersion) {
+  const expected = normalizeBareVersion(expectedVersion);
+  const actual = readBinaryVersion(binaryPath);
+  if (actual === expected)
+    return true;
+  warn(`Cached binary at ${binaryPath} reports ${actual ?? "no version"}, expected ${expected}; skipping cache candidate`);
+  return false;
+}
 function platformKey(platform = process.platform, arch = process.arch) {
   const archMap = PLATFORM_ARCH_MAP[platform];
   if (!archMap) {
@@ -32130,7 +32312,7 @@ function findBinarySync(expectedVersion) {
   if (pluginVersion) {
     const tag = pluginVersion.startsWith("v") ? pluginVersion : `v${pluginVersion}`;
     const versionCached = getCachedBinaryPath(tag);
-    if (versionCached)
+    if (versionCached && isExpectedCachedBinary(versionCached, pluginVersion))
       return versionCached;
   }
   try {
@@ -32140,10 +32322,12 @@ function findBinarySync(expectedVersion) {
     const resolved = req.resolve(packageBin);
     if (existsSync3(resolved)) {
       const npmVersion = readBinaryVersion(resolved);
-      if (pluginVersion && npmVersion && npmVersion !== pluginVersion) {
+      if (npmVersion === null) {
+        warn(`npm platform package binary at ${resolved} did not report a version; skipping (continuing to PATH lookup)`);
+      } else if (pluginVersion && npmVersion !== normalizeBareVersion(pluginVersion)) {
         warn(`npm platform package binary v${npmVersion} does not match plugin v${pluginVersion}; skipping (continuing to PATH lookup)`);
       } else {
-        const copied = copyToVersionedCache(resolved, npmVersion ?? undefined);
+        const copied = copyToVersionedCache(resolved, npmVersion);
         return copied ?? resolved;
       }
     }
@@ -32192,7 +32376,7 @@ async function findBinary(expectedVersion) {
 `));
 }
 // ../aft-bridge/dist/url-fetch.js
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import { lookup } from "node:dns/promises";
 import { existsSync as existsSync4, mkdirSync as mkdirSync4, readdirSync as readdirSync2, readFileSync as readFileSync2, unlinkSync as unlinkSync3, writeFileSync as writeFileSync2 } from "node:fs";
 import { isIP } from "node:net";
@@ -32349,7 +32533,7 @@ function cacheDir(storageDir) {
   return join5(storageDir, "url_cache");
 }
 function hashUrl(url) {
-  return createHash2("sha256").update(url).digest("hex").slice(0, 16);
+  return createHash3("sha256").update(url).digest("hex").slice(0, 16);
 }
 function metaPath(storageDir, hash) {
   return join5(cacheDir(storageDir), `${hash}.meta.json`);
@@ -32607,8 +32791,8 @@ async function fetchUrlToTempFile(url, storageDir, options = {}) {
   const contentFile = contentPath(storageDir, hash, extension);
   const tmpContent = `${contentFile}.tmp-${process.pid}`;
   writeFileSync2(tmpContent, body);
-  const { renameSync: renameSync2 } = await import("node:fs");
-  renameSync2(tmpContent, contentFile);
+  const { renameSync: renameSync3 } = await import("node:fs");
+  renameSync3(tmpContent, contentFile);
   const meta = {
     url,
     contentType,
@@ -32617,7 +32801,7 @@ async function fetchUrlToTempFile(url, storageDir, options = {}) {
   };
   const tmpMeta = `${metaFile}.tmp-${process.pid}`;
   writeFileSync2(tmpMeta, JSON.stringify(meta));
-  renameSync2(tmpMeta, metaFile);
+  renameSync3(tmpMeta, metaFile);
   log(`URL cached (${total} bytes): ${url}`);
   return contentFile;
 }
@@ -32735,31 +32919,31 @@ function warn2(message, data) {
 function error2(message, data) {
   write("ERROR", message, data);
 }
-function sessionLog2(sessionId, message, data) {
+function sessionLog(sessionId, message, data) {
   write("INFO", message, data, sessionId);
 }
-function sessionWarn2(sessionId, message, data) {
+function sessionWarn(sessionId, message, data) {
   write("WARN", message, data, sessionId);
 }
-function sessionError2(sessionId, message, data) {
+function sessionError(sessionId, message, data) {
   write("ERROR", message, data, sessionId);
 }
 var bridgeLogger = {
   log(message, meta) {
     if (meta?.sessionId)
-      sessionLog2(meta.sessionId, message);
+      sessionLog(meta.sessionId, message);
     else
       write("INFO", message);
   },
   warn(message, meta) {
     if (meta?.sessionId)
-      sessionWarn2(meta.sessionId, message);
+      sessionWarn(meta.sessionId, message);
     else
       write("WARN", message);
   },
   error(message, meta) {
     if (meta?.sessionId)
-      sessionError2(meta.sessionId, message);
+      sessionError(meta.sessionId, message);
     else
       write("ERROR", message);
   },
@@ -32771,6 +32955,7 @@ var sessionBgStates = new Map;
 var SESSION_BG_STATE_IDLE_TTL_MS = 60 * 60 * 1000;
 var DEBOUNCE_STEP_MS = 200;
 var DEBOUNCE_CAP_MS = 1000;
+var MAX_WAKE_SEND_ATTEMPTS = 5;
 var UNKNOWN_COMPLETION_TTL_MS = 5000;
 var UNKNOWN_COMPLETION_CAP = 32;
 var DEFAULT_SESSION_ID = "__default__";
@@ -32820,16 +33005,22 @@ async function handlePushedBgLongRunning(drainContext, reminder) {
 }
 async function appendToolResultBgCompletions(drainContext, content) {
   const state = stateFor(drainContext.sessionID);
+  if (state.outstandingTaskIds.size === 0 && state.pendingCompletions.length === 0 && state.pendingLongRunning.length === 0)
+    await drainCompletions(drainContext);
   if (state.outstandingTaskIds.size === 0 && state.pendingCompletions.length === 0 && state.pendingLongRunning.length === 0)
     return;
-  if (state.outstandingTaskIds.size > 0) {
+  if (state.outstandingTaskIds.size > 0 || !state.forcedDrainCompleted) {
     await drainCompletions(drainContext);
   }
   if (state.pendingCompletions.length === 0 && state.pendingLongRunning.length === 0)
     return;
+  const deliveredCompletions = [...state.pendingCompletions];
   const reminder = formatCombinedSystemReminder(state.pendingCompletions, state.pendingLongRunning);
   state.pendingCompletions = [];
   state.pendingLongRunning = [];
+  state.wakeRetryAttempts = 0;
+  state.wakeHardStopped = false;
+  await ackCompletions(drainContext, deliveredCompletions);
   if (state.debounceTimer) {
     clearTimeout(state.debounceTimer);
     state.debounceTimer = null;
@@ -32844,15 +33035,16 @@ async function handleTurnEndBgCompletions(drainContext) {
 }
 async function triggerWakeIfPending(drainContext, skipDrain) {
   const state = stateFor(drainContext.sessionID);
-  if (!skipDrain && state.outstandingTaskIds.size > 0) {
+  if (!skipDrain && (state.outstandingTaskIds.size > 0 || !state.forcedDrainCompleted)) {
     await drainCompletions(drainContext);
   }
   if (state.pendingCompletions.length === 0 && state.pendingLongRunning.length === 0)
     return;
-  scheduleWake(state, async (reminder) => {
+  scheduleWake(state, async (reminder, deliveredCompletions) => {
     drainContext.runtime.sendUserMessage(reminder, { deliverAs: "steer" });
-  }, (err) => {
-    sessionWarn2(drainContext.sessionID ?? "", `${LOG_PREFIX} wake send failed: ${err instanceof Error ? err.message : String(err)}`);
+    await ackCompletions(drainContext, deliveredCompletions);
+  }, (err, hardStopped) => {
+    sessionWarn(drainContext.sessionID ?? "", hardStopped ? `${LOG_PREFIX} wake send failed ${MAX_WAKE_SEND_ATTEMPTS} times; stopping retries: ${err instanceof Error ? err.message : String(err)}` : `${LOG_PREFIX} wake send failed: ${err instanceof Error ? err.message : String(err)}`);
   });
 }
 function formatSystemReminder(completions) {
@@ -32885,20 +33077,39 @@ function formatCombinedSystemReminder(completions, longRunning) {
 ${formatLongRunningReminder(longRunning)}`;
 }
 async function drainCompletions({ ctx, directory, sessionID }) {
+  const state = stateFor(sessionID);
   try {
     const bridge = ctx.pool.getActiveBridgeForRoot(directory) ?? ctx.pool.getBridge(directory);
     const params = sessionID ? { session_id: sessionID } : {};
     const response = await bridge.send("bash_drain_completions", params);
     if (response.success === false) {
-      sessionWarn2(sessionID ?? "", `${LOG_PREFIX} drain failed: ${String(response.message ?? "unknown error")}`);
+      sessionWarn(sessionID ?? "", `${LOG_PREFIX} drain failed: ${String(response.message ?? "unknown error")}`);
       return;
     }
-    ingestBgCompletions(sessionID, response.bg_completions);
+    state.forcedDrainCompleted = true;
+    ingestDrainedBgCompletions(sessionID, response.bg_completions);
   } catch (err) {
-    sessionWarn2(sessionID ?? "", `${LOG_PREFIX} drain failed: ${err instanceof Error ? err.message : String(err)}`);
+    sessionWarn(sessionID ?? "", `${LOG_PREFIX} drain failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+async function ackCompletions({ ctx, directory, sessionID }, completions) {
+  const taskIds = [...new Set(completions.map((completion) => completion.task_id))];
+  if (taskIds.length === 0)
+    return;
+  try {
+    const bridge = ctx.pool.getActiveBridgeForRoot(directory) ?? ctx.pool.getBridge(directory);
+    const params = sessionID ? { session_id: sessionID, task_ids: taskIds } : { task_ids: taskIds };
+    const response = await bridge.send("bash_ack_completions", params);
+    if (response.success === false) {
+      sessionWarn(sessionID ?? "", `${LOG_PREFIX} ack failed: ${String(response.message ?? "unknown error")}`);
+    }
+  } catch (err) {
+    sessionWarn(sessionID ?? "", `${LOG_PREFIX} ack failed: ${err instanceof Error ? err.message : String(err)}`);
   }
 }
 function scheduleWake(state, sendWake, onSendFailure) {
+  if (state.wakeHardStopped)
+    return;
   const now = Date.now();
   const pendingCount = state.pendingCompletions.length + state.pendingLongRunning.length;
   if (state.debounceTimer && pendingCount <= state.scheduledCompletionCount) {
@@ -32927,13 +33138,22 @@ function scheduleWake(state, sendWake, onSendFailure) {
     const reminder = formatCombinedSystemReminder(pending, pendingLongRunning);
     state.pendingCompletions = [];
     state.pendingLongRunning = [];
-    sendWake(reminder).then(() => {
+    sendWake(reminder, pending).then(() => {
       state.retryDelayMs = null;
+      state.wakeRetryAttempts = 0;
+      state.wakeHardStopped = false;
     }).catch((err) => {
       state.pendingCompletions = [...pending, ...state.pendingCompletions];
       state.pendingLongRunning = [...pendingLongRunning, ...state.pendingLongRunning];
+      state.wakeRetryAttempts += 1;
+      if (state.wakeRetryAttempts >= MAX_WAKE_SEND_ATTEMPTS) {
+        state.retryDelayMs = null;
+        state.wakeHardStopped = true;
+        onSendFailure(err, true);
+        return;
+      }
       state.retryDelayMs = Math.min((delay || DEBOUNCE_STEP_MS) * 2, DEBOUNCE_CAP_MS);
-      onSendFailure(err);
+      onSendFailure(err, false);
       scheduleWake(state, sendWake, onSendFailure);
     });
   }, delay);
@@ -32954,6 +33174,9 @@ function stateFor(sessionID) {
       scheduledFireAt: null,
       scheduledCompletionCount: 0,
       retryDelayMs: null,
+      wakeRetryAttempts: 0,
+      wakeHardStopped: false,
+      forcedDrainCompleted: false,
       unknownCompletions: [],
       lastSeenAt: now
     };
@@ -32963,6 +33186,22 @@ function stateFor(sessionID) {
   }
   return state;
 }
+function ingestDrainedBgCompletions(sessionID, completions) {
+  if (!Array.isArray(completions) || completions.length === 0)
+    return [];
+  const state = stateFor(sessionID);
+  const accepted = [];
+  for (const completion of completions) {
+    if (!isBgCompletion(completion))
+      continue;
+    state.outstandingTaskIds.delete(completion.task_id);
+    if (!state.pendingCompletions.some((pending) => pending.task_id === completion.task_id) && !accepted.some((pending) => pending.task_id === completion.task_id)) {
+      accepted.push(completion);
+    }
+  }
+  state.pendingCompletions.push(...accepted);
+  return accepted;
+}
 function cleanupIdleSessionStates(now = Date.now()) {
   const cutoff = now - SESSION_BG_STATE_IDLE_TTL_MS;
   for (const [sessionID, state] of sessionBgStates) {
@@ -33055,7 +33294,7 @@ import {
 // package.json
 var package_default = {
   name: "@cortexkit/aft-pi",
-  version: "0.26.0",
+  version: "0.26.1",
   type: "module",
   description: "Pi coding agent extension for Agent File Tools (AFT) — tree-sitter and LSP-powered code analysis",
   main: "dist/index.js",
@@ -33077,18 +33316,18 @@ var package_default = {
     prepublishOnly: "bun run build"
   },
   dependencies: {
-    "@cortexkit/aft-bridge": "0.26.0",
+    "@cortexkit/aft-bridge": "0.26.1",
     typebox: "^1.1.24",
     "comment-json": "^5.0.0",
     diff: "^8.0.4",
     zod: "^4.1.8"
   },
   optionalDependencies: {
-    "@cortexkit/aft-darwin-arm64": "0.26.0",
-    "@cortexkit/aft-darwin-x64": "0.26.0",
-    "@cortexkit/aft-linux-arm64": "0.26.0",
-    "@cortexkit/aft-linux-x64": "0.26.0",
-    "@cortexkit/aft-win32-x64": "0.26.0"
+    "@cortexkit/aft-darwin-arm64": "0.26.1",
+    "@cortexkit/aft-darwin-x64": "0.26.1",
+    "@cortexkit/aft-linux-arm64": "0.26.1",
+    "@cortexkit/aft-linux-x64": "0.26.1",
+    "@cortexkit/aft-win32-x64": "0.26.1"
   },
   devDependencies: {
     "@earendil-works/pi-coding-agent": "*",
@@ -33573,7 +33812,7 @@ function registerStatusCommand(pi, ctx) {
 
 // src/config.ts
 var import_comment_json = __toESM(require_src2(), 1);
-import { existsSync as existsSync5, readFileSync as readFileSync3, renameSync as renameSync2, unlinkSync as unlinkSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync5, readFileSync as readFileSync3, renameSync as renameSync3, unlinkSync as unlinkSync4, writeFileSync as writeFileSync3 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
 import { join as join7 } from "node:path";
 
@@ -47348,7 +47587,7 @@ function migrateAftConfigFile(configPath, logger = { log: log2, warn: warn2 }) {
 ${serialized}` : serialized;
     tmpPath = `${configPath}.tmp.${process.pid}`;
     writeFileSync3(tmpPath, nextContent, "utf-8");
-    renameSync2(tmpPath, configPath);
+    renameSync3(tmpPath, configPath);
     logger.log(`Migrated config at ${configPath}: removed ${oldKeys.join(", ")}`);
     return { migrated: true, oldKeys };
   } catch (err) {
@@ -47563,17 +47802,17 @@ function loadAftConfig(projectDirectory) {
 
 // src/lsp-auto-install.ts
 import { spawn as spawn2 } from "node:child_process";
-import { createHash as createHash3 } from "node:crypto";
-import { createReadStream, mkdirSync as mkdirSync6, readFileSync as readFileSync5, renameSync as renameSync3, rmSync as rmSync2, statSync as statSync3 } from "node:fs";
+import { createHash as createHash4 } from "node:crypto";
+import { createReadStream, mkdirSync as mkdirSync6, readFileSync as readFileSync5, renameSync as renameSync4, rmSync as rmSync3, statSync as statSync4 } from "node:fs";
 import { join as join10 } from "node:path";
 
 // src/lsp-cache.ts
 import {
-  closeSync as closeSync2,
+  closeSync as closeSync3,
   mkdirSync as mkdirSync5,
-  openSync as openSync2,
+  openSync as openSync3,
   readFileSync as readFileSync4,
-  statSync as statSync2,
+  statSync as statSync3,
   unlinkSync as unlinkSync5,
   writeFileSync as writeFileSync4
 } from "node:fs";
@@ -47606,7 +47845,7 @@ function lspBinDir(npmPackage) {
 function isInstalled(npmPackage, binary) {
   for (const candidate of lspBinaryCandidates(binary)) {
     try {
-      if (statSync2(join8(lspBinDir(npmPackage), candidate)).isFile())
+      if (statSync3(join8(lspBinDir(npmPackage), candidate)).isFile())
         return true;
     } catch {}
   }
@@ -47634,7 +47873,7 @@ function writeInstalledMetaIn(installDir, version2, sha256) {
 function readInstalledMetaIn(installDir) {
   const path2 = join8(installDir, INSTALLED_META_FILE);
   try {
-    if (!statSync2(path2).isFile())
+    if (!statSync3(path2).isFile())
       return null;
     const raw = readFileSync4(path2, "utf8");
     const parsed = JSON.parse(raw);
@@ -47664,13 +47903,13 @@ function acquireInstallLock(lockKey) {
   const lock = lockPath(lockKey);
   const tryClaim = () => {
     try {
-      const fd = openSync2(lock, "wx");
+      const fd = openSync3(lock, "wx");
       try {
         writeFileSync4(fd, `${process.pid}
 ${new Date().toISOString()}
 `);
       } finally {
-        closeSync2(fd);
+        closeSync3(fd);
       }
       return true;
     } catch (err) {
@@ -47691,7 +47930,7 @@ ${new Date().toISOString()}
     const parsed = Number.parseInt(firstLine, 10);
     if (Number.isFinite(parsed) && parsed > 0)
       owningPid = parsed;
-    lockMtimeMs = statSync2(lock).mtimeMs;
+    lockMtimeMs = statSync3(lock).mtimeMs;
   } catch {
     return tryClaim();
   }
@@ -48233,7 +48472,7 @@ function hashInstalledBinary(spec) {
     let pathToHash = null;
     for (const p of candidates) {
       try {
-        if (statSync3(p).isFile()) {
+        if (statSync4(p).isFile()) {
           pathToHash = p;
           break;
         }
@@ -48243,7 +48482,7 @@ function hashInstalledBinary(spec) {
       reject(new Error(`installed binary not found at any of: ${candidates.join(", ")}`));
       return;
     }
-    const hash2 = createHash3("sha256");
+    const hash2 = createHash4("sha256");
     const stream = createReadStream(pathToHash);
     stream.on("error", reject);
     stream.on("data", (chunk) => hash2.update(chunk));
@@ -48259,14 +48498,14 @@ function installedBinaryPath(spec) {
   ] : [lspBinaryPath(spec.npm, spec.binary)];
   for (const candidate of candidates) {
     try {
-      if (statSync3(candidate).isFile())
+      if (statSync4(candidate).isFile())
         return candidate;
     } catch {}
   }
   return null;
 }
 function sha256OfFileSync(path2) {
-  return createHash3("sha256").update(readFileSync5(path2)).digest("hex");
+  return createHash4("sha256").update(readFileSync5(path2)).digest("hex");
 }
 function quarantineCachedNpmInstall(spec, reason) {
   const packageDir = lspPackageDir(spec.npm);
@@ -48274,8 +48513,8 @@ function quarantineCachedNpmInstall(spec, reason) {
   warn2(`[lsp] tofu_mismatch ${spec.npm}: ${reason}; quarantining ${packageDir} -> ${dest}`);
   try {
     mkdirSync6(join10(dest, ".."), { recursive: true });
-    rmSync2(dest, { recursive: true, force: true });
-    renameSync3(packageDir, dest);
+    rmSync3(dest, { recursive: true, force: true });
+    renameSync4(packageDir, dest);
   } catch (err) {
     warn2(`[lsp] tofu_mismatch ${spec.npm}: failed to quarantine cache entry: ${err}`);
   }
@@ -48351,11 +48590,11 @@ function runAutoInstall(projectRoot, config2, fetchImpl2 = fetch) {
 
 // src/lsp-github-install.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { createHash as createHash4, randomBytes } from "node:crypto";
+import { createHash as createHash5, randomBytes } from "node:crypto";
 import {
   copyFileSync as copyFileSync3,
   createReadStream as createReadStream2,
-  createWriteStream as createWriteStream2,
+  createWriteStream as createWriteStream3,
   existsSync as existsSync7,
   lstatSync as lstatSync2,
   mkdirSync as mkdirSync7,
@@ -48363,14 +48602,15 @@ import {
   readFileSync as readFileSync6,
   readlinkSync as readlinkSync2,
   realpathSync as realpathSync3,
-  renameSync as renameSync4,
-  rmSync as rmSync3,
-  statSync as statSync4,
-  unlinkSync as unlinkSync6
+  renameSync as renameSync5,
+  rmSync as rmSync4,
+  statSync as statSync5,
+  unlinkSync as unlinkSync6,
+  writeFileSync as writeFileSync5
 } from "node:fs";
 import { dirname as dirname2, join as join11, relative as relative2, resolve as resolve2 } from "node:path";
-import { Readable as Readable2 } from "node:stream";
-import { pipeline as pipeline2 } from "node:stream/promises";
+import { Readable as Readable3 } from "node:stream";
+import { pipeline as pipeline3 } from "node:stream/promises";
 
 // src/lsp-github-table.ts
 function exe(platform, name) {
@@ -48469,6 +48709,7 @@ function ghBinDir(spec) {
 function ghExtractDir(spec) {
   return join11(ghPackageDir(spec), "extracted");
 }
+var INSTALLED_META_FILE2 = ".aft-installed";
 function ghBinaryPath(spec, platform) {
   const ext = platform === "win32" ? ".exe" : "";
   return join11(ghBinDir(spec), `${spec.binary}${ext}`);
@@ -48476,7 +48717,7 @@ function ghBinaryPath(spec, platform) {
 function isGithubInstalled(spec, platform) {
   for (const candidate of ghBinaryCandidates(spec, platform)) {
     try {
-      if (statSync4(join11(ghBinDir(spec), candidate)).isFile())
+      if (statSync5(join11(ghBinDir(spec), candidate)).isFile())
         return true;
     } catch {}
   }
@@ -48487,11 +48728,45 @@ function ghBinaryCandidates(spec, platform) {
     return [spec.binary];
   return [spec.binary, `${spec.binary}.cmd`, `${spec.binary}.exe`, `${spec.binary}.bat`];
 }
-var MAX_DOWNLOAD_BYTES2 = 256 * 1024 * 1024;
+function readGithubInstalledMetaIn(installDir) {
+  try {
+    const path2 = join11(installDir, INSTALLED_META_FILE2);
+    if (!statSync5(path2).isFile())
+      return null;
+    const parsed = JSON.parse(readFileSync6(path2, "utf8"));
+    if (typeof parsed.version !== "string" || parsed.version.length === 0)
+      return null;
+    return {
+      version: parsed.version,
+      installedAt: typeof parsed.installedAt === "string" ? parsed.installedAt : "",
+      ...typeof parsed.sha256 === "string" && parsed.sha256.length > 0 ? { sha256: parsed.sha256 } : {},
+      ...typeof parsed.binarySha256 === "string" && parsed.binarySha256.length > 0 ? { binarySha256: parsed.binarySha256 } : {},
+      ...typeof parsed.archiveSha256 === "string" && parsed.archiveSha256.length > 0 ? { archiveSha256: parsed.archiveSha256 } : {}
+    };
+  } catch {
+    return null;
+  }
+}
+function writeGithubInstalledMetaIn(installDir, version2, binarySha256, archiveSha256) {
+  try {
+    mkdirSync7(installDir, { recursive: true });
+    const meta3 = {
+      version: version2,
+      installedAt: new Date().toISOString(),
+      sha256: binarySha256,
+      binarySha256,
+      ...archiveSha256 ? { archiveSha256 } : {}
+    };
+    writeFileSync5(join11(installDir, INSTALLED_META_FILE2), JSON.stringify(meta3), "utf8");
+  } catch (err) {
+    warn2(`[lsp] failed to write github installed metadata in ${installDir}: ${err}`);
+  }
+}
+var MAX_DOWNLOAD_BYTES3 = 256 * 1024 * 1024;
 var MAX_EXTRACT_BYTES2 = 1024 * 1024 * 1024;
 function sha256OfFile(path2) {
   return new Promise((resolve3, reject) => {
-    const hash2 = createHash4("sha256");
+    const hash2 = createHash5("sha256");
     const stream = createReadStream2(path2);
     stream.on("error", reject);
     stream.on("data", (chunk) => hash2.update(chunk));
@@ -48499,7 +48774,7 @@ function sha256OfFile(path2) {
   });
 }
 function sha256OfFileSync2(path2) {
-  return createHash4("sha256").update(readFileSync6(path2)).digest("hex");
+  return createHash5("sha256").update(readFileSync6(path2)).digest("hex");
 }
 async function fetchReleaseByTag(githubRepo, tag, fetchImpl2, signal) {
   const candidates = [];
@@ -48662,8 +48937,8 @@ function assertAllowedDownloadUrl(rawUrl) {
   return parsed;
 }
 async function downloadFile(url2, destPath, fetchImpl2, assetSize, signal) {
-  if (assetSize !== undefined && assetSize > MAX_DOWNLOAD_BYTES2) {
-    throw new Error(`asset size ${assetSize} exceeds max ${MAX_DOWNLOAD_BYTES2} (set lsp.versions to pin a smaller release if this is wrong)`);
+  if (assetSize !== undefined && assetSize > MAX_DOWNLOAD_BYTES3) {
+    throw new Error(`asset size ${assetSize} exceeds max ${MAX_DOWNLOAD_BYTES3} (set lsp.versions to pin a smaller release if this is wrong)`);
   }
   const timeout = controlledTimeoutSignal(120000, signal);
   try {
@@ -48672,24 +48947,24 @@ async function downloadFile(url2, destPath, fetchImpl2, assetSize, signal) {
       throw new Error(`download failed (${res.status})`);
     }
     const advertised = Number.parseInt(res.headers.get("content-length") ?? "", 10);
-    if (Number.isFinite(advertised) && advertised > MAX_DOWNLOAD_BYTES2) {
-      throw new Error(`Content-Length ${advertised} exceeds max ${MAX_DOWNLOAD_BYTES2}`);
+    if (Number.isFinite(advertised) && advertised > MAX_DOWNLOAD_BYTES3) {
+      throw new Error(`Content-Length ${advertised} exceeds max ${MAX_DOWNLOAD_BYTES3}`);
     }
     mkdirSync7(dirname2(destPath), { recursive: true });
     let bytesWritten = 0;
     const guard = new TransformStream({
       transform(chunk, controller) {
         bytesWritten += chunk.byteLength;
-        if (bytesWritten > MAX_DOWNLOAD_BYTES2) {
-          controller.error(new Error(`download exceeded ${MAX_DOWNLOAD_BYTES2} bytes after streaming (server lied about size or sent unbounded body)`));
+        if (bytesWritten > MAX_DOWNLOAD_BYTES3) {
+          controller.error(new Error(`download exceeded ${MAX_DOWNLOAD_BYTES3} bytes after streaming (server lied about size or sent unbounded body)`));
           return;
         }
         controller.enqueue(chunk);
       }
     });
     const guarded = res.body.pipeThrough(guard);
-    const nodeStream = Readable2.fromWeb(guarded);
-    await pipeline2(nodeStream, createWriteStream2(destPath), { signal: timeout.signal });
+    const nodeStream = Readable3.fromWeb(guarded);
+    await pipeline3(nodeStream, createWriteStream3(destPath), { signal: timeout.signal });
   } catch (err) {
     try {
       unlinkSync6(destPath);
@@ -48769,7 +49044,7 @@ function validateExtraction(stagingRoot) {
   };
   walk(realStagingRoot);
 }
-function precheckArchiveSize(archivePath, archiveType) {
+function precheckArchiveContents(archivePath, archiveType) {
   let totalBytes = 0;
   if (archiveType === "zip") {
     const out = execFileSync2("unzip", ["-l", archivePath], { encoding: "utf8" });
@@ -48780,6 +49055,9 @@ function precheckArchiveSize(archivePath, archiveType) {
     const out = execFileSync2("tar", ["-tvf", archivePath], { encoding: "utf8" });
     for (const line of out.split(`
 `)) {
+      if (line.startsWith("h")) {
+        throw new Error(`archive contains hardlink entry: ${line.trim()}`);
+      }
       const parts = line.trim().split(/\s+/);
       if (parts.length >= 6) {
         const numeric = parts.map((part) => Number.parseInt(part, 10)).filter((value) => Number.isFinite(value) && value >= 0);
@@ -48796,20 +49074,20 @@ function extractArchiveSafely(archivePath, destDir, archiveType) {
   const suffix = randomBytes(8).toString("hex");
   const stagingDir = `${destDir}.staging-${suffix}`;
   try {
-    rmSync3(stagingDir, { recursive: true, force: true });
+    rmSync4(stagingDir, { recursive: true, force: true });
   } catch {}
   mkdirSync7(stagingDir, { recursive: true });
   try {
-    precheckArchiveSize(archivePath, archiveType);
+    precheckArchiveContents(archivePath, archiveType);
     runPlatformExtractor(archivePath, stagingDir, archiveType);
     validateExtraction(stagingDir);
     try {
-      rmSync3(destDir, { recursive: true, force: true });
+      rmSync4(destDir, { recursive: true, force: true });
     } catch {}
-    renameSync4(stagingDir, destDir);
+    renameSync5(stagingDir, destDir);
   } catch (err) {
     try {
-      rmSync3(stagingDir, { recursive: true, force: true });
+      rmSync4(stagingDir, { recursive: true, force: true });
     } catch {}
     throw err;
   }
@@ -48820,28 +49098,44 @@ function quarantineCachedGithubInstall(spec, reason) {
   warn2(`[lsp] tofu_mismatch ${spec.id}: ${reason}; quarantining ${packageDir} -> ${dest}`);
   try {
     mkdirSync7(dirname2(dest), { recursive: true });
-    rmSync3(dest, { recursive: true, force: true });
-    renameSync4(packageDir, dest);
+    rmSync4(dest, { recursive: true, force: true });
+    renameSync5(packageDir, dest);
   } catch (err) {
     warn2(`[lsp] tofu_mismatch ${spec.id}: failed to quarantine cache entry: ${err}`);
   }
 }
 function validateCachedGithubInstall(spec, platform) {
-  const meta3 = readInstalledMetaIn(ghPackageDir(spec));
+  const packageDir = ghPackageDir(spec);
+  const meta3 = readGithubInstalledMetaIn(packageDir);
   const binaryPath = ghBinaryCandidates(spec, platform).map((candidate) => join11(ghBinDir(spec), candidate)).find((candidate) => {
     try {
-      return statSync4(candidate).isFile();
+      return statSync5(candidate).isFile();
     } catch {
       return false;
     }
   });
-  if (!meta3?.sha256 || !meta3.version || !isSafeVersion(meta3.version) || !binaryPath) {
+  if (!meta3?.version || !isSafeVersion(meta3.version) || !binaryPath) {
     quarantineCachedGithubInstall(spec, "missing/unsafe metadata or binary");
     return false;
   }
   const currentHash = sha256OfFileSync2(binaryPath);
-  if (currentHash !== meta3.sha256) {
-    quarantineCachedGithubInstall(spec, `recorded ${meta3.sha256}, current ${currentHash}`);
+  const recordedBinaryHash = meta3.binarySha256 ?? meta3.sha256;
+  if (recordedBinaryHash && currentHash === recordedBinaryHash) {
+    if (meta3.sha256 !== currentHash || meta3.binarySha256 !== currentHash) {
+      writeGithubInstalledMetaIn(packageDir, meta3.version, currentHash, meta3.archiveSha256);
+    }
+    return true;
+  }
+  if (meta3.sha256 && !meta3.binarySha256 && !meta3.archiveSha256) {
+    writeGithubInstalledMetaIn(packageDir, meta3.version, currentHash, meta3.sha256);
+    return true;
+  }
+  if (!recordedBinaryHash) {
+    quarantineCachedGithubInstall(spec, "missing binary sha256 metadata");
+    return false;
+  }
+  if (currentHash !== recordedBinaryHash) {
+    quarantineCachedGithubInstall(spec, `recorded ${recordedBinaryHash}, current ${currentHash}`);
     return false;
   }
   return true;
@@ -48910,10 +49204,11 @@ async function downloadAndInstall(spec, tag, assets, platform, arch, fetchImpl2,
     return null;
   }
   log2(`[lsp] ${spec.id} ${tag} sha256=${archiveSha256}`);
-  const previousMeta = readInstalledMetaIn(ghPackageDir(spec));
-  if (previousMeta && previousMeta.version === tag && previousMeta.sha256) {
-    if (previousMeta.sha256 !== archiveSha256) {
-      error2(`[lsp] ${spec.id} ${tag}: TOFU sha256 mismatch — refusing install. ` + `Previously installed sha256=${previousMeta.sha256}, downloaded sha256=${archiveSha256}. ` + `This means the published release for tag ${tag} changed. Investigate before proceeding.`);
+  const previousMeta = readGithubInstalledMetaIn(ghPackageDir(spec));
+  const previousArchiveSha256 = previousMeta?.archiveSha256 ?? (previousMeta?.binarySha256 ? undefined : previousMeta?.sha256);
+  if (previousMeta && previousMeta.version === tag && previousArchiveSha256) {
+    if (previousArchiveSha256 !== archiveSha256) {
+      error2(`[lsp] ${spec.id} ${tag}: TOFU sha256 mismatch — refusing install. ` + `Previously installed archive sha256=${previousArchiveSha256}, downloaded sha256=${archiveSha256}. ` + `This means the published release for tag ${tag} changed. Investigate before proceeding.`);
       try {
         unlinkSync6(archivePath);
       } catch {}
@@ -48948,7 +49243,9 @@ async function downloadAndInstall(spec, tag, assets, platform, arch, fetchImpl2,
     return null;
   }
   log2(`[lsp] installed ${spec.id} ${tag} at ${targetBinary}`);
-  return archiveSha256;
+  const binarySha256 = await sha256OfFile(targetBinary);
+  log2(`[lsp] ${spec.id} ${tag} binary_sha256=${binarySha256}`);
+  return { archiveSha256, binarySha256 };
 }
 async function ensureGithubInstalled(spec, config2, fetchImpl2, platform, arch, signal) {
   const outcome = await withInstallLock(spec.githubRepo, async () => {
@@ -48974,14 +49271,14 @@ async function ensureGithubInstalled(spec, config2, fetchImpl2, platform, arch,
         log2(`[lsp] reinstalling ${spec.id}@${tag}: no installed-version metadata recorded`);
       }
     }
-    const archiveSha256 = await downloadAndInstall(spec, tag, assets, platform, arch, fetchImpl2, signal).catch((err) => {
+    const hashes = await downloadAndInstall(spec, tag, assets, platform, arch, fetchImpl2, signal).catch((err) => {
       error2(`[lsp] github install ${spec.id} crashed: ${err}`);
       return null;
     });
-    if (!archiveSha256) {
+    if (!hashes) {
       return { started: true, reason: "install failed (see plugin log)" };
     }
-    writeInstalledMetaIn(ghPackageDir(spec), tag, archiveSha256);
+    writeGithubInstalledMetaIn(ghPackageDir(spec), tag, hashes.binarySha256, hashes.archiveSha256);
     return { started: true };
   });
   if (outcome === null) {
@@ -49111,7 +49408,7 @@ function discoverRelevantGithubServers(projectRoot) {
 }
 
 // src/notifications.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync8, readFileSync as readFileSync7, renameSync as renameSync5, rmSync as rmSync4, writeFileSync as writeFileSync5 } from "node:fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync8, readFileSync as readFileSync7, renameSync as renameSync6, rmSync as rmSync5, writeFileSync as writeFileSync6 } from "node:fs";
 import { join as join12 } from "node:path";
 var WARNING_MARKER = "\uD83D\uDD27 AFT: ⚠️";
 var FEATURE_MARKER = "\uD83D\uDD27 AFT: ✨";
@@ -49124,7 +49421,7 @@ function sendIgnoredMessage(client, sessionId, text) {
     typedClient.ui.notify(text, "warning");
     return true;
   } catch (err) {
-    sessionLog2(sessionId, `[aft-pi] notification send failed: ${err instanceof Error ? err.message : String(err)}`);
+    sessionLog(sessionId, `[aft-pi] notification send failed: ${err instanceof Error ? err.message : String(err)}`);
     return false;
   }
 }
@@ -49152,9 +49449,9 @@ function writeWarnedTools(storageDir, warned) {
     mkdirSync8(storageDir, { recursive: true });
     const warnedToolsPath = join12(storageDir, WARNED_TOOLS_FILE);
     const tmpPath = join12(storageDir, `${WARNED_TOOLS_FILE}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`);
-    writeFileSync5(tmpPath, `${JSON.stringify(warned, null, 2)}
+    writeFileSync6(tmpPath, `${JSON.stringify(warned, null, 2)}
 `);
-    renameSync5(tmpPath, warnedToolsPath);
+    renameSync6(tmpPath, warnedToolsPath);
   } catch {}
 }
 async function withWarnedToolsLock(storageDir, fn) {
@@ -49166,7 +49463,7 @@ async function withWarnedToolsLock(storageDir, fn) {
       try {
         return await fn();
       } finally {
-        rmSync4(lockDir, { recursive: true, force: true });
+        rmSync5(lockDir, { recursive: true, force: true });
       }
     } catch (err) {
       const code = err.code;
@@ -49253,7 +49550,7 @@ function sendFeatureAnnouncement(version2, features, storageDir) {
 `));
   try {
     mkdirSync8(storageDir, { recursive: true });
-    writeFileSync5(versionFile, version2);
+    writeFileSync6(versionFile, version2);
   } catch {}
 }
 
@@ -51856,33 +52153,39 @@ ${hintsBlock}` };
 // src/index.ts
 setActiveLogger(bridgeLogger);
 function createVersionMismatchHandler(getPool, ensureCompatibleBinary = ensureBinary) {
-  let versionUpgradeAttempted = null;
+  const versionUpgradePromises = new Map;
   return async (binaryVersion, minVersion) => {
-    if (versionUpgradeAttempted === binaryVersion) {
-      log2(`Version ${binaryVersion} < ${minVersion} but upgrade already attempted — continuing`);
-      return null;
+    const existing = versionUpgradePromises.get(minVersion);
+    if (existing) {
+      log2(`Version ${binaryVersion} < ${minVersion}; awaiting in-flight compatible binary upgrade`);
+      return existing;
     }
-    versionUpgradeAttempted = binaryVersion;
-    warn2(`WARNING: aft binary v${binaryVersion} is older than plugin v${minVersion}. ` + "Some features may not work. Attempting to download a compatible binary...");
-    try {
-      const path2 = await ensureCompatibleBinary(`v${minVersion}`);
-      if (!path2) {
-        warn2(`Could not find or download v${minVersion}. Continuing with v${binaryVersion}.`);
-        return null;
-      }
-      const pool = getPool();
-      if (!pool) {
-        warn2(`Found/downloaded compatible binary at ${path2}, but bridge pool is not ready.`);
+    const upgradePromise = (async () => {
+      warn2(`WARNING: aft binary v${binaryVersion} is older than plugin v${minVersion}. ` + "Some features may not work. Attempting to download a compatible binary...");
+      try {
+        const path2 = await ensureCompatibleBinary(`v${minVersion}`);
+        if (!path2) {
+          warn2(`Could not find or download v${minVersion}. Continuing with v${binaryVersion}.`);
+          return null;
+        }
+        const pool = getPool();
+        if (!pool) {
+          warn2(`Found/downloaded compatible binary at ${path2}, but bridge pool is not ready.`);
+          return null;
+        }
+        log2(`Found/downloaded compatible binary at ${path2}. Replacing running bridges...`);
+        const replaced = await pool.replaceBinary(path2);
+        log2("Binary replaced successfully. New bridges will use the updated binary.");
+        return replaced;
+      } catch (err) {
+        error2(`Auto-download failed: ${err.message}. Install manually: cargo install agent-file-tools@${minVersion}`);
         return null;
+      } finally {
+        versionUpgradePromises.delete(minVersion);
       }
-      log2(`Found/downloaded compatible binary at ${path2}. Replacing running bridges...`);
-      const replaced = await pool.replaceBinary(path2);
-      log2("Binary replaced successfully. New bridges will use the updated binary.");
-      return replaced;
-    } catch (err) {
-      error2(`Auto-download failed: ${err.message}. Install manually: cargo install agent-file-tools@${minVersion}`);
-      return null;
-    }
+    })();
+    versionUpgradePromises.set(minVersion, upgradePromise);
+    return upgradePromise;
   };
 }
 var PLUGIN_VERSION = (() => {