@cortexkit/aft 0.51.3 → 0.52.1

package/dist/index.js

@@ -19,12 +19,14 @@ var __toESM = (mod, isNodeMode, target) => {
   }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: __accessProp.bind(mod, key),
-        enumerable: true
-      });
+  if (mod && typeof mod === "object" || typeof mod === "function") {
+    for (let key of __getOwnPropNames(mod))
+      if (!__hasOwnProp.call(to, key))
+        __defProp(to, key, {
+          get: __accessProp.bind(mod, key),
+          enumerable: true
+        });
+  }
   if (canCache)
     cache.set(mod, to);
   return to;
@@ -2389,19 +2391,37 @@ async function downloadBinary(version) {
     releaseLock?.();
   }
 }
+function ensureBinaryKey(version) {
+  if (!version)
+    return "latest";
+  return version.startsWith("v") ? version : `v${version}`;
+}
 async function ensureBinary(version) {
-  if (version) {
-    const tag = version.startsWith("v") ? version : `v${version}`;
-    const versionCached = getCachedBinaryPath(tag);
-    if (versionCached && isExpectedCachedBinary(versionCached, tag)) {
-      log(`Found cached binary for ${tag}: ${versionCached}`);
-      return versionCached;
-    }
-    log(`No cached binary for ${tag}, downloading...`);
-    return downloadBinary(tag);
+  const key = ensureBinaryKey(version);
+  const existing = ensureBinaryInFlight.get(key);
+  if (existing)
+    return existing;
+  const task = (async () => {
+    if (version) {
+      const tag = ensureBinaryKey(version);
+      const versionCached = getCachedBinaryPath(tag);
+      if (versionCached && isExpectedCachedBinary(versionCached, tag)) {
+        log(`Found cached binary for ${tag}: ${versionCached}`);
+        return versionCached;
+      }
+      log(`No cached binary for ${tag}, downloading...`);
+      return downloadBinary(tag);
+    }
+    log("No cached binary found, downloading latest...");
+    return downloadBinary();
+  })();
+  ensureBinaryInFlight.set(key, task);
+  try {
+    return await task;
+  } finally {
+    if (ensureBinaryInFlight.get(key) === task)
+      ensureBinaryInFlight.delete(key);
   }
-  log("No cached binary found, downloading latest...");
-  return downloadBinary();
 }
 function createDownloadLockOwner() {
   return JSON.stringify({
@@ -2544,7 +2564,7 @@ async function fetchLatestTag() {
     clearTimeout(timeout);
   }
 }
-var REPO = "cortexkit/aft", DOWNLOAD_TIMEOUT_MS = 300000, LATEST_TAG_TIMEOUT_MS = 30000, MAX_DOWNLOAD_BYTES, DOWNLOAD_LOCK_STALE_MS, DOWNLOAD_LOCK_TIMEOUT_MS;
+var REPO = "cortexkit/aft", DOWNLOAD_TIMEOUT_MS = 300000, LATEST_TAG_TIMEOUT_MS = 30000, MAX_DOWNLOAD_BYTES, DOWNLOAD_LOCK_STALE_MS, DOWNLOAD_LOCK_TIMEOUT_MS, ensureBinaryInFlight;
 var init_downloader = __esm(() => {
   init_active_logger();
   init_cache_paths();
@@ -2553,6 +2573,7 @@ var init_downloader = __esm(() => {
   MAX_DOWNLOAD_BYTES = 200 * 1024 * 1024;
   DOWNLOAD_LOCK_STALE_MS = 10 * 60000;
   DOWNLOAD_LOCK_TIMEOUT_MS = DOWNLOAD_LOCK_STALE_MS + 30000;
+  ensureBinaryInFlight = new Map;
 });
 
 // ../aft-bridge/dist/durable-log.js
@@ -2716,68 +2737,7 @@ ${reflowText}`;
   return " Auto-formatted.";
 }
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.5.0/node_modules/@cortexkit/subc-client/dist/auth.js
-import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
-function computeProof(key, domain, clientNonce, serverNonce, daemonId) {
-  const mac = createHmac("sha256", Buffer.from(key));
-  mac.update(Buffer.from(domain, "utf8"));
-  mac.update(Buffer.from(clientNonce));
-  mac.update(Buffer.from(serverNonce));
-  mac.update(Buffer.from(daemonId));
-  return new Uint8Array(mac.digest());
-}
-function constantTimeEq(a, b) {
-  if (a.length !== b.length)
-    return false;
-  return timingSafeEqual(Buffer.from(a), Buffer.from(b));
-}
-async function writeMessage(sock, value, deadlineMs) {
-  const json = Buffer.from(JSON.stringify(value), "utf8");
-  if (json.length > MAX_AUTH_MESSAGE_LEN) {
-    throw new AuthError(`auth message too large: ${json.length} > ${MAX_AUTH_MESSAGE_LEN}`);
-  }
-  const lenPrefix = new Uint8Array(4);
-  new DataView(lenPrefix.buffer).setUint32(0, json.length, true);
-  await sock.write(lenPrefix, deadlineMs);
-  await sock.write(json, deadlineMs);
-}
-async function readMessage(sock, deadlineMs) {
-  const lenBytes = await sock.readExact(4, deadlineMs);
-  const len = new DataView(lenBytes.buffer, lenBytes.byteOffset, 4).getUint32(0, true);
-  if (len > MAX_AUTH_MESSAGE_LEN) {
-    throw new AuthError(`auth message too large: ${len} > ${MAX_AUTH_MESSAGE_LEN}`);
-  }
-  const body = len === 0 ? new Uint8Array(0) : await sock.readExact(len, deadlineMs);
-  try {
-    return JSON.parse(Buffer.from(body).toString("utf8"));
-  } catch (err) {
-    throw new AuthError(`auth message JSON decode failed: ${String(err)}`);
-  }
-}
-async function authenticateClient(sock, conn, deadlineMs) {
-  const clientNonce = new Uint8Array(randomBytes(NONCE_LEN));
-  await writeMessage(sock, { client_nonce: Array.from(clientNonce), role: DEFAULT_CLIENT_ROLE }, deadlineMs);
-  const proof = await readMessage(sock, deadlineMs);
-  const serverNonce = Uint8Array.from(proof.server_nonce);
-  const daemonId = Uint8Array.from(proof.daemon_id);
-  const serverProof = Uint8Array.from(proof.server_proof);
-  const expected = computeProof(conn.key, SERVER_PROOF_DOMAIN, clientNonce, serverNonce, daemonId);
-  if (!constantTimeEq(expected, serverProof)) {
-    throw new AuthError("server proof mismatch — wrong key or impostor daemon");
-  }
-  if (!constantTimeEq(daemonId, conn.daemonId)) {
-    throw new AuthError("daemon id mismatch — connection file points at a different daemon");
-  }
-  const clientAuth = computeProof(conn.key, CLIENT_AUTH_DOMAIN, clientNonce, serverNonce, daemonId);
-  await writeMessage(sock, { client_auth: Array.from(clientAuth) }, deadlineMs);
-}
-var NONCE_LEN = 32, MAX_AUTH_MESSAGE_LEN = 4096, SERVER_PROOF_DOMAIN = "subc-server-v1", CLIENT_AUTH_DOMAIN = "subc-client-v1", DEFAULT_CLIENT_ROLE = "client", AuthError;
-var init_auth = __esm(() => {
-  AuthError = class AuthError extends Error {
-  };
-});
-
-// ../../node_modules/.bun/@cortexkit+subc-client@0.5.0/node_modules/@cortexkit/subc-client/dist/envelope.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.8.1/node_modules/@cortexkit/subc-client/dist/envelope.js
 function isPureHeader(ty) {
   return ty === FrameType.Cancel || ty === FrameType.Ping || ty === FrameType.Pong || ty === FrameType.Goodbye;
 }
@@ -2803,6 +2763,39 @@ function encodeHeader(header) {
   view.setBigUint64(13, header.corr, true);
   return buffer;
 }
+function validateHeaderFields(header) {
+  const len = header.len >>> 0;
+  const ver = header.ver >>> 0 & 255;
+  const typeByte = header.ty >>> 0 & 255;
+  const flags = header.flags >>> 0 & 255;
+  const channel = header.channel >>> 0 & 65535;
+  const epoch = header.epoch >>> 0;
+  BigInt.asUintN(64, header.corr);
+  if (ver !== PROTOCOL_VERSION)
+    throw new DecodeError(`unsupported envelope version ${ver}`, "unsupported_version");
+  if (typeByte > FRAME_TYPE_MAX)
+    throw new DecodeError(`unknown frame type byte ${typeByte}`, "unknown_frame_type");
+  const ty = typeByte;
+  if ((flags & FLAG_RESERVED_MASK) !== 0) {
+    throw new DecodeError(`reserved flag bits set in flags 0b${flags.toString(2).padStart(8, "0")}`, "reserved_flag_bits");
+  }
+  if ((flags & FLAG_PRIORITY_MASK) >> FLAG_PRIORITY_SHIFT === 3) {
+    throw new DecodeError(`reserved priority bits set in flags 0b${flags.toString(2).padStart(8, "0")}`, "reserved_priority_bits");
+  }
+  const admission = (flags & FLAG_ADMISSION_MASK) >> FLAG_ADMISSION_SHIFT;
+  if (admission === 3) {
+    throw new DecodeError(`reserved admission class set in flags 0b${flags.toString(2).padStart(8, "0")}`, "reserved_admission_class");
+  }
+  if (admission === AdmissionClass.Sheddable && ty !== FrameType.Push && ty !== FrameType.StreamData) {
+    throw new DecodeError(`SHEDDABLE admission class is illegal on ${FrameType[ty]} in flags 0b${flags.toString(2).padStart(8, "0")}`, "sheddable_illegal_frame_type");
+  }
+  if (channel === 0 && epoch !== 0) {
+    throw new DecodeError(`control channel carried nonzero epoch ${epoch}`, "nonzero_epoch_on_control_channel");
+  }
+  if (isPureHeader(ty) && len !== 0) {
+    throw new DecodeError(`pure-header frame ${FrameType[ty]} declared non-zero body length ${len}`, "pure_header_frame_with_body");
+  }
+}
 function decodeHeader(bytes) {
   if (bytes.length < FROZEN_PREFIX_LEN) {
     throw new DecodeError(`header shorter than frozen prefix: have ${bytes.length} bytes`, "too_short_for_prefix");
@@ -2851,7 +2844,7 @@ function buildFrameWithVersion(ver, ty, flags, channel, epoch, corr, body) {
     throw new DecodeError(`frame body ${body.length} exceeds max ${MAX_FRAME_BODY_LEN}`, "frame_body_too_large");
   }
   const header = { len: body.length, ver, ty, flags, channel, epoch, corr };
-  decodeHeader(encodeHeader(header));
+  validateHeaderFields(header);
   return { header, body };
 }
 function encodeFrame(frame) {
@@ -2902,12 +2895,324 @@ var init_envelope = __esm(() => {
   };
 });
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.5.0/node_modules/@cortexkit/subc-client/dist/connection-file.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.8.1/node_modules/@cortexkit/subc-client/dist/socket.js
+import net from "node:net";
+function toWriteBuffer(bytes) {
+  return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
+function writeBorrowed(socket, bytes, deadlineMs) {
+  const borrowed = socket[WRITE_BORROWED];
+  return borrowed ? borrowed.call(socket, bytes, deadlineMs) : socket.write(bytes, deadlineMs);
+}
+function writeTrackedBorrowed(socket, bytes, deadlineMs) {
+  const borrowed = socket[WRITE_TRACKED_BORROWED];
+  return borrowed ? borrowed.call(socket, bytes, deadlineMs) : socket.writeTracked(bytes, deadlineMs);
+}
+var SocketClosedError, SocketTimeoutError, SocketWriteNotQueuedError, SocketWriteQueuedError, WRITE_BORROWED, WRITE_TRACKED_BORROWED, SubcSocket;
+var init_socket = __esm(() => {
+  init_envelope();
+  SocketClosedError = class SocketClosedError extends Error {
+  };
+  SocketTimeoutError = class SocketTimeoutError extends Error {
+  };
+  SocketWriteNotQueuedError = class SocketWriteNotQueuedError extends Error {
+    cause;
+    constructor(message, cause) {
+      super(message);
+      this.cause = cause;
+    }
+  };
+  SocketWriteQueuedError = class SocketWriteQueuedError extends Error {
+    cause;
+    constructor(message, cause) {
+      super(message);
+      this.cause = cause;
+    }
+  };
+  WRITE_BORROWED = Symbol("subc.socket.writeBorrowed");
+  WRITE_TRACKED_BORROWED = Symbol("subc.socket.writeTrackedBorrowed");
+  SubcSocket = class SubcSocket {
+    sock;
+    chunks = [];
+    buffered = 0;
+    waiter = null;
+    closedErr = null;
+    bufferedBytes() {
+      return this.buffered;
+    }
+    constructor(sock) {
+      this.sock = sock;
+      sock.on("data", (chunk) => {
+        this.chunks.push(chunk);
+        this.buffered += chunk.length;
+        this.tryServe();
+      });
+      const fail = (err) => {
+        if (!this.closedErr)
+          this.closedErr = err;
+        this.tryServe();
+      };
+      sock.on("error", (err) => fail(err instanceof Error ? err : new Error(String(err))));
+      sock.on("end", () => fail(new SocketClosedError("subc closed the connection")));
+      sock.on("close", () => fail(new SocketClosedError("subc connection closed")));
+    }
+    localPort() {
+      return this.sock.localPort ?? null;
+    }
+    static connect(host, port, deadlineMs) {
+      return new Promise((resolve3, reject) => {
+        const sock = net.connect({ host, port });
+        sock.setNoDelay(true);
+        const timer = setTimeout(() => {
+          sock.destroy();
+          reject(new SocketTimeoutError(`timed out connecting to ${host}:${port}`));
+        }, Math.max(0, deadlineMs - Date.now()));
+        sock.once("connect", () => {
+          clearTimeout(timer);
+          resolve3(new SubcSocket(sock));
+        });
+        sock.once("error", (err) => {
+          clearTimeout(timer);
+          reject(err);
+        });
+      });
+    }
+    async readFrame(headerDeadlineMs, bodyDeadline, onHeader) {
+      const prefix = await this.readExact(FROZEN_PREFIX_LEN, headerDeadlineMs);
+      const version = prefix[4];
+      if (version !== PROTOCOL_VERSION)
+        throw new DecodeError(`unsupported envelope version ${version}`, "unsupported_version");
+      const remainder = await this.readExact(HEADER_LEN - FROZEN_PREFIX_LEN, headerDeadlineMs);
+      const headerBytes = new Uint8Array(HEADER_LEN);
+      headerBytes.set(prefix);
+      headerBytes.set(remainder, FROZEN_PREFIX_LEN);
+      const header = decodeHeader(headerBytes);
+      if (header.len > MAX_FRAME_BODY_LEN) {
+        throw new DecodeError(`frame body ${header.len} exceeds max ${MAX_FRAME_BODY_LEN}`, "frame_body_too_large");
+      }
+      onHeader?.();
+      const bodyDeadlineMs = typeof bodyDeadline === "number" ? bodyDeadline : Date.now() + bodyDeadline.afterHeaderMs;
+      const body = header.len === 0 ? new Uint8Array(0) : await this.readExact(header.len, bodyDeadlineMs);
+      return { header, body };
+    }
+    readExact(n, deadlineMs) {
+      if (this.waiter) {
+        return Promise.reject(new Error("concurrent readExact is not supported"));
+      }
+      if (n === 0)
+        return Promise.resolve(new Uint8Array(0));
+      return new Promise((resolve3, reject) => {
+        let timer = null;
+        if (Number.isFinite(deadlineMs)) {
+          const remaining = deadlineMs - Date.now();
+          if (remaining <= 0) {
+            reject(new SocketTimeoutError(`timed out waiting for ${n} bytes`));
+            return;
+          }
+          timer = setTimeout(() => {
+            this.waiter = null;
+            reject(new SocketTimeoutError(`timed out waiting for ${n} bytes`));
+          }, remaining);
+        }
+        this.waiter = { need: n, resolve: resolve3, reject, timer };
+        this.tryServe();
+      });
+    }
+    async write(bytes, deadlineMs) {
+      await this.writeBuffer(Buffer.from(bytes), deadlineMs);
+    }
+    writeTracked(bytes, deadlineMs) {
+      return this.writeTrackedBuffer(Buffer.from(bytes), deadlineMs);
+    }
+    async[WRITE_BORROWED](bytes, deadlineMs) {
+      await this.writeBuffer(toWriteBuffer(bytes), deadlineMs);
+    }
+    [WRITE_TRACKED_BORROWED](bytes, deadlineMs) {
+      return this.writeTrackedBuffer(toWriteBuffer(bytes), deadlineMs);
+    }
+    async writeBuffer(buffer, deadlineMs) {
+      try {
+        await this.writeTrackedBuffer(buffer, deadlineMs).completed;
+      } catch (err) {
+        if (err instanceof SocketWriteNotQueuedError || err instanceof SocketWriteQueuedError) {
+          throw err.cause ?? err;
+        }
+        throw err;
+      }
+    }
+    writeTrackedBuffer(buffer, deadlineMs) {
+      if (this.closedErr) {
+        return {
+          queued: false,
+          completed: Promise.reject(new SocketWriteNotQueuedError("subc socket was closed before bytes could be queued", this.closedErr))
+        };
+      }
+      let queued = false;
+      let settled = false;
+      let timer = null;
+      const completed = new Promise((resolve3, reject) => {
+        const settle = (run) => {
+          if (settled)
+            return;
+          settled = true;
+          if (timer)
+            clearTimeout(timer);
+          run();
+        };
+        const remaining = deadlineMs - Date.now();
+        if (remaining <= 0) {
+          settle(() => reject(new SocketWriteNotQueuedError("timed out before bytes could be queued to subc", new SocketTimeoutError("timed out writing to subc"))));
+          return;
+        }
+        timer = setTimeout(() => {
+          const timeout = new SocketTimeoutError("timed out writing to subc");
+          settle(() => reject(queued ? new SocketWriteQueuedError("timed out after bytes were handed to the subc socket", timeout) : new SocketWriteNotQueuedError("timed out before bytes could be queued to subc", timeout)));
+        }, remaining);
+        try {
+          this.sock.write(buffer, (err) => {
+            settle(() => {
+              if (err) {
+                reject(new SocketWriteQueuedError("subc socket reported a write error after bytes were handed to the socket", err instanceof Error ? err : new Error(String(err))));
+              } else {
+                resolve3();
+              }
+            });
+          });
+          queued = true;
+        } catch (err) {
+          settle(() => reject(new SocketWriteNotQueuedError("subc socket write threw before bytes could be queued", err instanceof Error ? err : new Error(String(err)))));
+        }
+      });
+      return { queued, completed };
+    }
+    close() {
+      this.sock.destroy();
+    }
+    tryServe() {
+      const w = this.waiter;
+      if (!w)
+        return;
+      if (this.buffered >= w.need) {
+        const out = this.take(w.need);
+        this.waiter = null;
+        if (w.timer)
+          clearTimeout(w.timer);
+        w.resolve(out);
+        return;
+      }
+      if (this.closedErr) {
+        this.waiter = null;
+        if (w.timer)
+          clearTimeout(w.timer);
+        w.reject(this.closedErr);
+      }
+    }
+    take(n) {
+      const out = Buffer.allocUnsafe(n);
+      let off = 0;
+      while (off < n) {
+        const head = this.chunks[0];
+        const want = n - off;
+        if (head.length <= want) {
+          head.copy(out, off);
+          off += head.length;
+          this.chunks.shift();
+        } else {
+          head.copy(out, off, 0, want);
+          this.chunks[0] = head.subarray(want);
+          off += want;
+        }
+      }
+      this.buffered -= n;
+      return out;
+    }
+  };
+});
+
+// ../../node_modules/.bun/@cortexkit+subc-client@0.8.1/node_modules/@cortexkit/subc-client/dist/auth.js
+import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
+function computeProof(key, domain, clientNonce, serverNonce, daemonId) {
+  const mac = createHmac("sha256", Buffer.from(key));
+  mac.update(Buffer.from(domain, "utf8"));
+  mac.update(Buffer.from(clientNonce));
+  mac.update(Buffer.from(serverNonce));
+  mac.update(Buffer.from(daemonId));
+  return new Uint8Array(mac.digest());
+}
+function constantTimeEq(a, b) {
+  if (a.length !== b.length)
+    return false;
+  return timingSafeEqual(Buffer.from(a), Buffer.from(b));
+}
+async function writeMessage(sock, value, deadlineMs) {
+  const json = Buffer.from(JSON.stringify(value), "utf8");
+  if (json.length > MAX_AUTH_MESSAGE_LEN) {
+    throw new AuthError(`auth message too large: ${json.length} > ${MAX_AUTH_MESSAGE_LEN}`);
+  }
+  const lenPrefix = new Uint8Array(4);
+  new DataView(lenPrefix.buffer).setUint32(0, json.length, true);
+  await writeBorrowed(sock, lenPrefix, deadlineMs);
+  await writeBorrowed(sock, json, deadlineMs);
+}
+async function readMessage(sock, deadlineMs) {
+  const lenBytes = await sock.readExact(4, deadlineMs);
+  const len = new DataView(lenBytes.buffer, lenBytes.byteOffset, 4).getUint32(0, true);
+  if (len > MAX_AUTH_MESSAGE_LEN) {
+    throw new AuthError(`auth message too large: ${len} > ${MAX_AUTH_MESSAGE_LEN}`);
+  }
+  const body = len === 0 ? new Uint8Array(0) : await sock.readExact(len, deadlineMs);
+  try {
+    return JSON.parse(Buffer.from(body).toString("utf8"));
+  } catch (err) {
+    throw new AuthError(`auth message JSON decode failed: ${String(err)}`);
+  }
+}
+function authBytes(value, field) {
+  if (!Array.isArray(value)) {
+    throw new AuthError(`auth field '${field}' must be a byte array`);
+  }
+  for (const byte of value) {
+    if (typeof byte !== "number" || !Number.isInteger(byte) || byte < 0 || byte > 255) {
+      throw new AuthError(`auth field '${field}' has invalid byte ${String(byte)}`);
+    }
+  }
+  return Uint8Array.from(value);
+}
+async function authenticateClient(sock, conn, deadlineMs) {
+  const clientNonce = new Uint8Array(randomBytes(NONCE_LEN));
+  await writeMessage(sock, { client_nonce: Array.from(clientNonce), role: DEFAULT_CLIENT_ROLE }, deadlineMs);
+  const proof = await readMessage(sock, deadlineMs);
+  const serverNonce = authBytes(proof.server_nonce, "server_nonce");
+  const daemonId = authBytes(proof.daemon_id, "daemon_id");
+  const serverProof = authBytes(proof.server_proof, "server_proof");
+  const expected = computeProof(conn.key, SERVER_PROOF_DOMAIN, clientNonce, serverNonce, daemonId);
+  if (!constantTimeEq(expected, serverProof)) {
+    throw new AuthError("server proof mismatch — wrong key or impostor daemon");
+  }
+  if (!constantTimeEq(daemonId, conn.daemonId)) {
+    throw new AuthError("daemon id mismatch — connection file points at a different daemon");
+  }
+  const clientAuth = computeProof(conn.key, CLIENT_AUTH_DOMAIN, clientNonce, serverNonce, daemonId);
+  await writeMessage(sock, { client_auth: Array.from(clientAuth) }, deadlineMs);
+}
+var NONCE_LEN = 32, MAX_AUTH_MESSAGE_LEN = 4096, SERVER_PROOF_DOMAIN = "subc-server-v1", CLIENT_AUTH_DOMAIN = "subc-client-v1", DEFAULT_CLIENT_ROLE = "client", AuthError;
+var init_auth = __esm(() => {
+  init_socket();
+  AuthError = class AuthError extends Error {
+  };
+});
+
+// ../../node_modules/.bun/@cortexkit+subc-client@0.8.1/node_modules/@cortexkit/subc-client/dist/connection-file.js
 import { promises as fs2 } from "node:fs";
 function toBytes(value, field) {
-  if (!Array.isArray(value) || value.some((n) => typeof n !== "number")) {
+  if (!Array.isArray(value)) {
     throw new ConnectionFileError(`connection file field '${field}' must be a JSON array of bytes`);
   }
+  for (const byte of value) {
+    if (typeof byte !== "number" || !Number.isInteger(byte) || byte < 0 || byte > 255) {
+      throw new ConnectionFileError(`connection file field '${field}' has invalid byte ${String(byte)}`);
+    }
+  }
   return Uint8Array.from(value);
 }
 function validate(info) {
@@ -2975,7 +3280,7 @@ var init_connection_file = __esm(() => {
   };
 });
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.5.0/node_modules/@cortexkit/subc-client/dist/route-handle.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.8.1/node_modules/@cortexkit/subc-client/dist/route-handle.js
 class RouteHandle {
   channel;
   epoch;
@@ -3022,237 +3327,27 @@ var init_route_handle = __esm(() => {
   };
 });
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.5.0/node_modules/@cortexkit/subc-client/dist/socket.js
-import net from "node:net";
+// ../../node_modules/.bun/@cortexkit+subc-client@0.8.1/node_modules/@cortexkit/subc-client/dist/client.js
+import { promises as fs3 } from "node:fs";
+import { debuglog } from "node:util";
 
-class SubcSocket {
+class SubcClient {
   sock;
-  chunks = [];
-  buffered = 0;
-  waiter = null;
+  currentConn;
+  opts;
+  nextCorr = 1n;
+  pending = new Map;
+  lateResponses = new Map;
+  routes = new Map;
+  liveRoutes = new Map;
+  connectionToken = newConnectionToken();
+  ingressEpochDropCount = 0;
   closedErr = null;
-  bufferedBytes() {
-    return this.buffered;
-  }
-  constructor(sock) {
-    this.sock = sock;
-    sock.on("data", (chunk) => {
-      this.chunks.push(chunk);
-      this.buffered += chunk.length;
-      this.tryServe();
-    });
-    const fail = (err) => {
-      if (!this.closedErr)
-        this.closedErr = err;
-      this.tryServe();
-    };
-    sock.on("error", (err) => fail(err instanceof Error ? err : new Error(String(err))));
-    sock.on("end", () => fail(new SocketClosedError("subc closed the connection")));
-    sock.on("close", () => fail(new SocketClosedError("subc connection closed")));
-  }
-  localPort() {
-    return this.sock.localPort ?? null;
-  }
-  static connect(host, port, deadlineMs) {
-    return new Promise((resolve3, reject) => {
-      const sock = net.connect({ host, port });
-      sock.setNoDelay(true);
-      const timer = setTimeout(() => {
-        sock.destroy();
-        reject(new SocketTimeoutError(`timed out connecting to ${host}:${port}`));
-      }, Math.max(0, deadlineMs - Date.now()));
-      sock.once("connect", () => {
-        clearTimeout(timer);
-        resolve3(new SubcSocket(sock));
-      });
-      sock.once("error", (err) => {
-        clearTimeout(timer);
-        reject(err);
-      });
-    });
-  }
-  async readFrame(headerDeadlineMs, bodyDeadline, onHeader) {
-    const prefix = await this.readExact(FROZEN_PREFIX_LEN, headerDeadlineMs);
-    const version = prefix[4];
-    if (version !== PROTOCOL_VERSION)
-      throw new DecodeError(`unsupported envelope version ${version}`, "unsupported_version");
-    const remainder = await this.readExact(HEADER_LEN - FROZEN_PREFIX_LEN, headerDeadlineMs);
-    const headerBytes = new Uint8Array(HEADER_LEN);
-    headerBytes.set(prefix);
-    headerBytes.set(remainder, FROZEN_PREFIX_LEN);
-    const header = decodeHeader(headerBytes);
-    if (header.len > MAX_FRAME_BODY_LEN) {
-      throw new DecodeError(`frame body ${header.len} exceeds max ${MAX_FRAME_BODY_LEN}`, "frame_body_too_large");
-    }
-    onHeader?.();
-    const bodyDeadlineMs = typeof bodyDeadline === "number" ? bodyDeadline : Date.now() + bodyDeadline.afterHeaderMs;
-    const body = header.len === 0 ? new Uint8Array(0) : await this.readExact(header.len, bodyDeadlineMs);
-    return { header, body };
-  }
-  readExact(n, deadlineMs) {
-    if (this.waiter) {
-      return Promise.reject(new Error("concurrent readExact is not supported"));
-    }
-    if (n === 0)
-      return Promise.resolve(new Uint8Array(0));
-    return new Promise((resolve3, reject) => {
-      let timer = null;
-      if (Number.isFinite(deadlineMs)) {
-        const remaining = deadlineMs - Date.now();
-        if (remaining <= 0) {
-          reject(new SocketTimeoutError(`timed out waiting for ${n} bytes`));
-          return;
-        }
-        timer = setTimeout(() => {
-          this.waiter = null;
-          reject(new SocketTimeoutError(`timed out waiting for ${n} bytes`));
-        }, remaining);
-      }
-      this.waiter = { need: n, resolve: resolve3, reject, timer };
-      this.tryServe();
-    });
-  }
-  async write(bytes, deadlineMs) {
-    try {
-      await this.writeTracked(bytes, deadlineMs).completed;
-    } catch (err) {
-      if (err instanceof SocketWriteNotQueuedError || err instanceof SocketWriteQueuedError) {
-        throw err.cause ?? err;
-      }
-      throw err;
-    }
-  }
-  writeTracked(bytes, deadlineMs) {
-    if (this.closedErr) {
-      return {
-        queued: false,
-        completed: Promise.reject(new SocketWriteNotQueuedError("subc socket was closed before bytes could be queued", this.closedErr))
-      };
-    }
-    let queued = false;
-    let settled = false;
-    let timer = null;
-    const completed = new Promise((resolve3, reject) => {
-      const settle = (run) => {
-        if (settled)
-          return;
-        settled = true;
-        if (timer)
-          clearTimeout(timer);
-        run();
-      };
-      const remaining = deadlineMs - Date.now();
-      if (remaining <= 0) {
-        settle(() => reject(new SocketWriteNotQueuedError("timed out before bytes could be queued to subc", new SocketTimeoutError("timed out writing to subc"))));
-        return;
-      }
-      timer = setTimeout(() => {
-        const timeout = new SocketTimeoutError("timed out writing to subc");
-        settle(() => reject(queued ? new SocketWriteQueuedError("timed out after bytes were handed to the subc socket", timeout) : new SocketWriteNotQueuedError("timed out before bytes could be queued to subc", timeout)));
-      }, remaining);
-      try {
-        this.sock.write(Buffer.from(bytes), (err) => {
-          settle(() => {
-            if (err) {
-              reject(new SocketWriteQueuedError("subc socket reported a write error after bytes were handed to the socket", err instanceof Error ? err : new Error(String(err))));
-            } else {
-              resolve3();
-            }
-          });
-        });
-        queued = true;
-      } catch (err) {
-        settle(() => reject(new SocketWriteNotQueuedError("subc socket write threw before bytes could be queued", err instanceof Error ? err : new Error(String(err)))));
-      }
-    });
-    return { queued, completed };
-  }
-  close() {
-    this.sock.destroy();
-  }
-  tryServe() {
-    const w = this.waiter;
-    if (!w)
-      return;
-    if (this.buffered >= w.need) {
-      const out = this.take(w.need);
-      this.waiter = null;
-      if (w.timer)
-        clearTimeout(w.timer);
-      w.resolve(out);
-      return;
-    }
-    if (this.closedErr) {
-      this.waiter = null;
-      if (w.timer)
-        clearTimeout(w.timer);
-      w.reject(this.closedErr);
-    }
-  }
-  take(n) {
-    const out = Buffer.allocUnsafe(n);
-    let off = 0;
-    while (off < n) {
-      const head = this.chunks[0];
-      const want = n - off;
-      if (head.length <= want) {
-        head.copy(out, off);
-        off += head.length;
-        this.chunks.shift();
-      } else {
-        head.copy(out, off, 0, want);
-        this.chunks[0] = head.subarray(want);
-        off += want;
-      }
-    }
-    this.buffered -= n;
-    return out;
-  }
-}
-var SocketClosedError, SocketTimeoutError, SocketWriteNotQueuedError, SocketWriteQueuedError;
-var init_socket = __esm(() => {
-  init_envelope();
-  SocketClosedError = class SocketClosedError extends Error {
-  };
-  SocketTimeoutError = class SocketTimeoutError extends Error {
-  };
-  SocketWriteNotQueuedError = class SocketWriteNotQueuedError extends Error {
-    cause;
-    constructor(message, cause) {
-      super(message);
-      this.cause = cause;
-    }
-  };
-  SocketWriteQueuedError = class SocketWriteQueuedError extends Error {
-    cause;
-    constructor(message, cause) {
-      super(message);
-      this.cause = cause;
-    }
-  };
-});
-
-// ../../node_modules/.bun/@cortexkit+subc-client@0.5.0/node_modules/@cortexkit/subc-client/dist/client.js
-import { promises as fs3 } from "node:fs";
-import { debuglog } from "node:util";
-
-class SubcClient {
-  sock;
-  currentConn;
-  opts;
-  nextCorr = 1n;
-  pending = new Map;
-  lateResponses = new Map;
-  routes = new Map;
-  liveRoutes = new Map;
-  connectionToken = newConnectionToken();
-  ingressEpochDropCount = 0;
-  closedErr = null;
-  closeStarted = false;
-  reconnecting = null;
-  generation = 1;
-  readerActive = false;
-  constructor(sock, currentConn, opts) {
+  closeStarted = false;
+  reconnecting = null;
+  generation = 1;
+  readerActive = false;
+  constructor(sock, currentConn, opts) {
     this.sock = sock;
     this.currentConn = currentConn;
     this.opts = opts;
@@ -3331,12 +3426,13 @@ class SubcClient {
       } catch (err) {
         if (!(err instanceof SubcCallError))
           throw this.terminalCallError("managed call failed", err);
-        if (err.code === "unknown_channel" && !retriedUnknownChannel && !this.closeStarted) {
+        const deadBindCode = err.code === "unknown_channel" || err.code === "stale_route_epoch";
+        if (deadBindCode && !retriedUnknownChannel && !this.closeStarted) {
           retriedUnknownChannel = true;
           this.evictRouteHandle(routeHandle);
           continue;
         }
-        if (err.code === "unknown_channel" && retriedUnknownChannel) {
+        if (deadBindCode && retriedUnknownChannel) {
           this.evictRouteHandle(routeHandle);
         }
         if (err.kind === "not_sent") {
@@ -3349,6 +3445,8 @@ class SubcClient {
         }
         if (err.kind === "outcome_unknown" && err.code !== DEADLINE_NO_DROP_CODE) {
           this.scheduleReconnectAfterDrop(err);
+        } else if (err.kind === "outcome_unknown" && err.code === DEADLINE_NO_DROP_CODE) {
+          this.probeLivenessAfterDeadline();
         }
         throw err;
       }
@@ -3361,21 +3459,25 @@ class SubcClient {
     const admission = opts.admissionClass ?? AdmissionClass.Normal;
     const corr = this.allocateCorr();
     const key = pendingKey(handle, corr);
+    let subscriptionPending = null;
+    let resolveClosed = null;
     const closed = new Promise((resolve3, reject) => {
       if (this.closedErr) {
         reject(this.closedErr);
         return;
       }
-      this.pending.set(key, {
+      resolveClosed = resolve3;
+      subscriptionPending = {
         handle,
         resolve: () => resolve3(),
         reject,
         onProgress: onEvent,
         timer: null,
         subscription: true
-      });
+      };
+      this.pending.set(key, subscriptionPending);
       const frame = buildFrame(FrameType.Request, buildFlags(false, priority, false, admission), handle.channel, handle.epoch, corr, bytes);
-      this.sock.write(encodeFrame(frame), Date.now() + DEFAULT_REQUEST_TIMEOUT_MS).catch((err) => {
+      writeBorrowed(this.sock, encodeFrame(frame), Date.now() + DEFAULT_REQUEST_TIMEOUT_MS).catch((err) => {
         const pending = this.pending.get(key);
         if (pending)
           this.rejectPending(key, pending, err instanceof Error ? err : new SubcError(String(err)));
@@ -3386,14 +3488,17 @@ class SubcClient {
       if (cancelled)
         return;
       cancelled = true;
-      this.cancel(handle, corr, priority);
+      if (subscriptionPending && resolveClosed)
+        this.settle(key, subscriptionPending, resolveClosed);
+      if (this.isLiveHandle(handle))
+        this.cancel(handle, corr, priority);
     };
     return { unsubscribe, closed };
   }
   cancel(handle, corr, priority = Priority.Interactive) {
     this.assertLiveHandle(handle);
     const cancel = buildFrame(FrameType.Cancel, buildFlags(false, priority, false), handle.channel, handle.epoch, corr, EMPTY_BODY);
-    this.sock.write(encodeFrame(cancel), Date.now() + DEFAULT_REQUEST_TIMEOUT_MS).catch(() => {
+    writeBorrowed(this.sock, encodeFrame(cancel), Date.now() + DEFAULT_REQUEST_TIMEOUT_MS).catch(() => {
       return;
     });
   }
@@ -3474,7 +3579,7 @@ class SubcClient {
       return;
     }
     const goodbye = buildFrame(FrameType.Goodbye, buildFlags(false, Priority.Interactive, false), handle.channel, handle.epoch, 0n, EMPTY_BODY);
-    const write = this.sock.writeTracked(encodeFrame(goodbye), Date.now() + DEFAULT_REQUEST_TIMEOUT_MS);
+    const write = writeTrackedBorrowed(this.sock, encodeFrame(goodbye), Date.now() + DEFAULT_REQUEST_TIMEOUT_MS);
     if (!write.queued && closeOnQueueFailure)
       this.closeConnectionAfterCleanupFailure();
     write.completed.catch(() => {
@@ -3526,7 +3631,7 @@ class SubcClient {
       };
       pending.timer = setTimeout(() => this.arbitrateTimeout(key, pending, channel, corr, ms), ms);
       this.pending.set(key, pending);
-      this.sock.write(encodeFrame(frame), Date.now() + ms).catch((error2) => {
+      writeBorrowed(this.sock, encodeFrame(frame), Date.now() + ms).catch((error2) => {
         const current = this.pending.get(key);
         if (current)
           this.rejectPending(key, current, error2 instanceof Error ? error2 : new SubcError(String(error2)));
@@ -3603,7 +3708,7 @@ class SubcClient {
       };
       pending.timer = setTimeout(() => this.arbitrateTimeout(key, pending, handle.channel, corr, ms), ms);
       this.pending.set(key, pending);
-      const write = this.sock.writeTracked(encodeFrame(frame), Date.now() + ms);
+      const write = writeTrackedBorrowed(this.sock, encodeFrame(frame), Date.now() + ms);
       handedToSocket = write.queued;
       write.completed.catch((error2) => {
         const current = this.pending.get(key);
@@ -3691,6 +3796,46 @@ class SubcClient {
       }
     }
   }
+  lastInboundAtMs = 0;
+  livenessProbe = null;
+  hasControlPending() {
+    for (const pending of this.pending.values()) {
+      if (pending.handle === null)
+        return true;
+    }
+    return false;
+  }
+  probeLivenessAfterDeadline() {
+    if (this.livenessProbe || this.closeStarted || this.closedErr)
+      return;
+    if (this.hasControlPending())
+      return;
+    const sock = this.sock;
+    const generation = this.generation;
+    let corr;
+    try {
+      corr = this.allocateCorr();
+    } catch {
+      return;
+    }
+    const t0 = Date.now();
+    const ping = buildFrame(FrameType.Ping, buildFlags(false, Priority.Interactive, false, AdmissionClass.Normal), 0, 0, corr, new Uint8Array);
+    const probe = (async () => {
+      await writeBorrowed(sock, encodeFrame(ping), t0 + this.opts.livenessProbeWindowMs).catch(() => {});
+      await this.opts.sleep(this.opts.livenessProbeWindowMs);
+      if (this.sock !== sock || this.generation !== generation || this.closeStarted)
+        return;
+      if (this.lastInboundAtMs >= t0)
+        return;
+      if (this.hasControlPending())
+        return;
+      this.fail(new SocketClosedError(`liveness probe convicted a half-open socket: no inbound frame for ${this.opts.livenessProbeWindowMs}ms after a channel-0 Ping (deadline-no-drop settles preceded this); closing so the next call reconnects`));
+      sock.close();
+    })().finally(() => {
+      this.livenessProbe = null;
+    });
+    this.livenessProbe = probe;
+  }
   async ensureConnectedForManaged() {
     if (this.closeStarted)
       throw new SubcError("client closed");
@@ -3802,6 +3947,24 @@ class SubcClient {
     }
   }
   dispatch(frame) {
+    this.lastInboundAtMs = Date.now();
+    if (frame.header.channel === 0 && frame.header.ty === FrameType.Push) {
+      const observer = this.opts.onControlPush;
+      if (observer) {
+        let parsed = null;
+        try {
+          const body = this.parseJson(frame);
+          if (body && typeof body.op === "string")
+            parsed = { op: body.op, body };
+        } catch {}
+        if (parsed) {
+          try {
+            observer(parsed);
+          } catch {}
+        }
+      }
+      return;
+    }
     let handle = null;
     if (frame.header.channel !== 0) {
       handle = this.liveRoutes.get(frame.header.channel) ?? null;
@@ -3818,7 +3981,9 @@ class SubcClient {
       switch (frame.header.ty) {
         case FrameType.Push:
         case FrameType.StreamData:
-          pending.onProgress?.(frame.body);
+          try {
+            pending.onProgress?.(frame.body);
+          } catch {}
           return;
         case FrameType.Response:
         case FrameType.StreamEnd:
@@ -3838,7 +4003,7 @@ class SubcClient {
       return;
     }
     if (frame.header.ty === FrameType.Goodbye && handle) {
-      this.failHandle(handle, new SubcError("route closed by subc (GOODBYE)"));
+      this.failHandle(handle, new SubcError("route closed by subc (GOODBYE)", "route_closed"));
       if (this.liveRoutes.get(handle.channel) === handle)
         this.liveRoutes.delete(handle.channel);
       this.evictRouteHandle(handle);
@@ -3945,10 +4110,11 @@ class SubcClient {
     this.scheduleReconnectAfterDrop(error2);
   }
   encode(value) {
-    return new Uint8Array(Buffer.from(JSON.stringify(value), "utf8"));
+    return Buffer.from(JSON.stringify(value), "utf8");
   }
   parseJson(frame) {
-    return JSON.parse(Buffer.from(frame.body).toString("utf8"));
+    const b = frame.body;
+    return JSON.parse(Buffer.from(b.buffer, b.byteOffset, b.byteLength).toString("utf8"));
   }
 }
 function isConsumerReconnectTransient(err) {
@@ -3966,7 +4132,7 @@ function isConsumerReconnectTransient(err) {
   return code === "ECONNREFUSED" || code === "ECONNRESET" || code === "EPIPE" || code === "ETIMEDOUT" || code === "ENOENT";
 }
 function isRetryableRouteOpenCode(code) {
-  return code === "unknown_module" || code === "module_reloading" || code === "target_unavailable" || code === "module_timeout";
+  return code === "unknown_module" || code === "module_reloading" || code === "module_warming" || code === "target_unavailable" || code === "module_timeout";
 }
 async function connectionFileExists(path2) {
   try {
@@ -3984,917 +4150,67 @@ function normalizeConnectOptions(opts) {
     targetKind: opts.targetKind ?? DEFAULT_MANAGED_TARGET_KIND,
     reconnectBackoff: opts.reconnectBackoff ?? DEFAULT_RECONNECT_BACKOFF,
     sleep: opts.sleep ?? ((ms) => new Promise((resolve3) => setTimeout(resolve3, ms))),
-    timeoutArbitrationGraceMs: opts.timeoutArbitrationGraceMs ?? TIMEOUT_ARBITRATION_GRACE_MS
-  };
-}
-function routeCacheKey(target, identity, consumerIdentity) {
-  const consumerPart = consumerIdentity ? `${consumerIdentity.module_id}\x00${consumerIdentity.launch_nonce}` : "";
-  return `${target.kind}\x00${target.module_id}\x00${identity.project_root}\x00${identity.harness}\x00${identity.session}\x00${consumerPart}`;
-}
-function routeOpenConsumerIdentity(opts = {}) {
-  if (opts.consumerIdentity !== undefined)
-    return opts.consumerIdentity ?? undefined;
-  const moduleId = process.env[SUBC_MODULE_ID_ENV];
-  const launchNonce = process.env[SUBC_LAUNCH_NONCE_ENV];
-  if (!moduleId || !launchNonce)
-    return;
-  return { module_id: moduleId, launch_nonce: launchNonce };
-}
-function errorCode(err) {
-  if (typeof err === "object" && err !== null && "code" in err) {
-    const code = err.code;
-    if (typeof code === "string")
-      return code;
-  }
-  return;
-}
-function causeMessage(cause) {
-  if (cause === undefined)
-    return "";
-  return `: ${cause instanceof Error ? cause.message : String(cause)}`;
-}
-function pendingKey(handle, corr) {
-  return handle ? `${handle.channel}:${handle.epoch}:${corr}` : `0:0:${corr}`;
-}
-var debug, DEFAULT_HANDSHAKE_TIMEOUT_MS = 1e4, DEFAULT_REQUEST_TIMEOUT_MS = 30000, TIMEOUT_ARBITRATION_GRACE_MS = 50, REQUEST_DEADLINE_MARKER = "request_deadline", DEADLINE_NO_DROP_CODE = "deadline_exceeded_no_drop_observed", ROUTE_OPEN_RETRY_DEADLINE_MS = 30000, BODY_READ_TIMEOUT_MS = 30000, EMPTY_BODY, DEFAULT_MANAGED_TARGET_KIND = "management_surface", SUBC_MODULE_ID_ENV = "SUBC_MODULE_ID", SUBC_LAUNCH_NONCE_ENV = "SUBC_LAUNCH_NONCE", DEFAULT_RECONNECT_BACKOFF, SubcCallError, SubcError;
-var init_client = __esm(() => {
-  init_auth();
-  init_connection_file();
-  init_envelope();
-  init_route_handle();
-  init_socket();
-  debug = debuglog("subc-client");
-  EMPTY_BODY = new Uint8Array(0);
-  DEFAULT_RECONNECT_BACKOFF = {
-    baseMs: 100,
-    capMs: 2000,
-    maxAttempts: 6
-  };
-  SubcCallError = class SubcCallError extends Error {
-    kind;
-    code;
-    cause;
-    constructor(kind, message, code, cause) {
-      super(message);
-      this.kind = kind;
-      this.code = code;
-      this.cause = cause;
-      this.name = "SubcCallError";
-    }
-  };
-  SubcError = class SubcError extends Error {
-    code;
-    constructor(message, code) {
-      super(message);
-      this.code = code;
-    }
-  };
-});
-
-// ../../node_modules/.bun/@cortexkit+subc-client@0.5.0/node_modules/@cortexkit/subc-client/dist/provider.js
-import { Buffer as Buffer2 } from "node:buffer";
-
-class AsyncPermitPool {
-  available;
-  waiters = [];
-  constructor(capacity) {
-    if (!Number.isInteger(capacity) || capacity <= 0) {
-      throw new SubcProviderError("provider handler capacity must be a positive integer", "invalid_handler_capacity");
-    }
-    this.available = capacity;
-  }
-  async acquire() {
-    if (this.available > 0) {
-      this.available -= 1;
-      return this.releaseOnce();
-    }
-    await new Promise((resolve3) => {
-      this.waiters.push(resolve3);
-    });
-    return this.releaseOnce();
-  }
-  releaseOnce() {
-    let released = false;
-    return () => {
-      if (released)
-        return;
-      released = true;
-      const next = this.waiters.shift();
-      if (next) {
-        next();
-      } else {
-        this.available += 1;
-      }
-    };
-  }
-}
-
-class SubcProvider {
-  sock;
-  currentConn;
-  opts;
-  closed;
-  resolveClosed = () => {
-    return;
-  };
-  closeStarted = false;
-  closedErr = null;
-  inflight = new Map;
-  pending = new Map;
-  liveRoutes = new Map;
-  connectionToken = newConnectionToken();
-  nextCorr = 1n;
-  ingressEpochDropCount = 0;
-  requestGate = new AsyncPermitPool(DEFAULT_PROVIDER_HANDLER_CAPACITY);
-  reconnecting = null;
-  generation = 1;
-  connectionEpoch = 1;
-  stateQueue = [];
-  drainingStateQueue = false;
-  restoredDebounceToken = 0;
-  storage;
-  constructor(sock, currentConn, opts, storage) {
-    this.sock = sock;
-    this.currentConn = currentConn;
-    this.opts = opts;
-    this.storage = storage;
-    this.closed = new Promise((resolve3) => {
-      this.resolveClosed = resolve3;
-    });
-    this.readLoop(sock, this.generation);
-    this.enqueueConnectionState({ state: "connected", epoch: this.connectionEpoch });
-  }
-  get droppedIngressFrames() {
-    return this.ingressEpochDropCount;
-  }
-  get conn() {
-    return this.currentConn;
-  }
-  currentEpoch() {
-    return this.connectionEpoch;
-  }
-  async request(handle, body, opts = {}) {
-    this.assertLiveHandle(handle);
-    const corr = this.allocateCorr();
-    const key = routeKey(handle, corr);
-    const timeoutMs = opts.timeoutMs ?? WRITE_TIMEOUT_MS;
-    const frame = buildFrame(FrameType.Request, buildFlags(false, opts.priority ?? Priority.Interactive, false, opts.admissionClass ?? AdmissionClass.Normal), handle.channel, handle.epoch, corr, body);
-    return await new Promise((resolve3, reject) => {
-      const timer = setTimeout(() => {
-        if (this.pending.delete(key))
-          reject(new SubcProviderError("reverse request timed out", "request_timeout"));
-      }, timeoutMs);
-      this.pending.set(key, {
-        resolve: (response) => resolve3(response.body),
-        reject,
-        timer
-      });
-      this.sendOn(this.sock, this.generation, frame).catch((error2) => {
-        const pending = this.pending.get(key);
-        if (!pending)
-          return;
-        this.pending.delete(key);
-        clearTimeout(pending.timer);
-        reject(error2 instanceof Error ? error2 : new SubcProviderError(String(error2)));
-      });
-    });
-  }
-  async push(handle, body, opts = {}) {
-    this.assertLiveHandle(handle);
-    await this.sendOn(this.sock, this.generation, buildFrame(FrameType.Push, buildFlags(false, opts.priority ?? Priority.Interactive, false, opts.admissionClass ?? AdmissionClass.Normal), handle.channel, handle.epoch, 0n, body));
-  }
-  cancel(handle, corr) {
-    this.assertLiveHandle(handle);
-    this.sendOn(this.sock, this.generation, buildFrame(FrameType.Cancel, controlFlags(), handle.channel, handle.epoch, corr, new Uint8Array(0)));
-  }
-  closeRoute(handle) {
-    this.assertLiveHandle(handle);
-    this.liveRoutes.delete(handle.channel);
-    this.abortHandle(handle);
-    this.sendOn(this.sock, this.generation, buildFrame(FrameType.Goodbye, controlFlags(), handle.channel, handle.epoch, 0n, new Uint8Array(0)));
-  }
-  static async connect(opts) {
-    if (opts.manifest.protocol_ver !== PROTOCOL_VERSION) {
-      throw new SubcProviderError(`manifest protocol_ver ${opts.manifest.protocol_ver} does not match client protocol ${PROTOCOL_VERSION}`, "invalid_manifest");
-    }
-    const normalized = normalizeProviderConnectOptions(opts);
-    const opened = await SubcProvider.openConnection(normalized);
-    return new SubcProvider(opened.sock, opened.conn, normalized, opened.ack.storage);
-  }
-  async close() {
-    if (!this.closeStarted) {
-      this.closeStarted = true;
-      this.cancelRestoredDebounce();
-      const sock = this.sock;
-      try {
-        await sendFrame(sock, buildFrame(FrameType.Goodbye, controlFlags(), 0, 0, 0n, new Uint8Array(0)));
-      } catch {} finally {
-        sock.close();
-        this.finishClosed();
-      }
-    }
-    await this.closed;
-  }
-  static async openConnection(opts, onSocket) {
-    const conn = await readConnectionFile(opts.connectionFile);
-    const deadline = Date.now() + (opts.handshakeTimeoutMs ?? DEFAULT_HANDSHAKE_TIMEOUT_MS2);
-    const endpoint = conn.endpoints[0];
-    const sock = await SubcSocket.connect(endpoint.host, endpoint.port, deadline);
-    try {
-      onSocket?.(sock);
-      await authenticateClient(sock, conn, deadline);
-      await sendFrame(sock, buildHelloFrame(opts));
-      const ack = await expectHelloAck(sock, deadline);
-      return { sock, conn, ack };
-    } catch (err) {
-      sock.close();
-      throw err;
-    }
-  }
-  async readLoop(sock, generation) {
-    try {
-      for (;; ) {
-        const frame = await sock.readFrame(Number.POSITIVE_INFINITY, { afterHeaderMs: BODY_READ_TIMEOUT_MS2 });
-        const keepGoing = await this.dispatch(frame, sock, generation);
-        if (!keepGoing) {
-          if (this.sock === sock && this.generation === generation)
-            this.closeStarted = true;
-          break;
-        }
-      }
-    } catch (error2) {
-      if (this.sock === sock && this.generation === generation && !this.closeStarted) {
-        this.handleUnexpectedDrop(sock, generation, error2 instanceof Error ? error2 : new SubcProviderError(String(error2)));
-        return;
-      }
-    } finally {
-      if (this.sock === sock && this.generation === generation) {
-        sock.close();
-        if (this.closeStarted)
-          this.finishClosed();
-      }
-    }
-  }
-  async dispatch(frame, sock, generation) {
-    let handle = null;
-    if (frame.header.channel !== 0) {
-      handle = this.liveRoutes.get(frame.header.channel) ?? null;
-      if (!handle || handle.epoch !== frame.header.epoch) {
-        this.ingressEpochDropCount += 1;
-        return true;
-      }
-    }
-    if (handle) {
-      const pendingKey2 = routeKey(handle, frame.header.corr);
-      const pending = this.pending.get(pendingKey2);
-      if (pending) {
-        if (frame.header.ty === FrameType.Push || frame.header.ty === FrameType.StreamData)
-          return true;
-        if (frame.header.ty === FrameType.Response || frame.header.ty === FrameType.StreamEnd) {
-          this.pending.delete(pendingKey2);
-          clearTimeout(pending.timer);
-          pending.resolve(frame);
-          return true;
-        }
-        if (frame.header.ty === FrameType.Error) {
-          this.pending.delete(pendingKey2);
-          clearTimeout(pending.timer);
-          pending.reject(providerErrorFromFrame(frame));
-          return true;
-        }
-      }
-    }
-    switch (frame.header.ty) {
-      case FrameType.Ping:
-        if (frame.header.channel === 0) {
-          await this.sendOn(sock, generation, buildFrameWithVersion(frame.header.ver, FrameType.Pong, frame.header.flags, 0, 0, frame.header.corr, new Uint8Array(0)));
-        }
-        return true;
-      case FrameType.Goodbye:
-        if (!handle)
-          return false;
-        this.liveRoutes.delete(handle.channel);
-        this.abortHandle(handle);
-        await this.opts.onRouteGone?.(handle);
-        return true;
-      case FrameType.Cancel:
-        if (handle)
-          this.inflight.get(routeKey(handle, frame.header.corr))?.abort();
-        return true;
-      case FrameType.Request:
-        if (frame.header.channel === 0) {
-          await this.handleControlRequest(frame, sock, generation);
-        } else if (handle) {
-          this.handleDataRequest(frame, handle, sock, generation).catch((error2) => {
-            if (!this.closeStarted && this.sock === sock && this.generation === generation) {
-              console.warn("SubcProvider handler failed after its request was dispatched", error2);
-            }
-          });
-        }
-        return true;
-      default:
-        return true;
-    }
-  }
-  abortHandle(handle) {
-    const prefix = `${handle.channel}:${handle.epoch}:`;
-    for (const [key, controller] of this.inflight) {
-      if (key.startsWith(prefix))
-        controller.abort();
-    }
-    for (const [key, pending] of this.pending) {
-      if (!key.startsWith(prefix))
-        continue;
-      this.pending.delete(key);
-      clearTimeout(pending.timer);
-      pending.reject(new StaleRouteHandleError(handle));
-    }
-  }
-  abortGeneration(_generation) {
-    this.abortAllInflight();
-    for (const [key, pending] of this.pending) {
-      this.pending.delete(key);
-      clearTimeout(pending.timer);
-      pending.reject(new SubcProviderError("provider connection dropped", "connection_dropped"));
-    }
-    this.liveRoutes.clear();
-  }
-  abortAllInflight() {
-    for (const controller of this.inflight.values())
-      controller.abort();
-  }
-  async handleControlRequest(frame, sock, generation) {
-    const request = parseJson(frame.body);
-    if (request.op === HEALTH_CHECK_OP) {
-      this.handleHealthRequest(frame, sock, generation).catch((error2) => {
-        if (!this.closeStarted && this.sock === sock && this.generation === generation) {
-          console.warn("SubcProvider health handler failed after its request was dispatched", error2);
-        }
-      });
-      return;
-    }
-    if (request.op !== "route.bind") {
-      throw new SubcProviderError(`unsupported module control request ${request.op ?? "<missing op>"}`);
-    }
-    const boundChannel = numberField(request.route_channel, "route_channel");
-    const boundEpoch = numberField(request.epoch, "epoch");
-    const stale = this.liveRoutes.get(boundChannel);
-    if (stale) {
-      if (boundEpoch <= stale.epoch) {
-        await this.sendError(frame, "route_rejected", `route.bind epoch ${boundEpoch} does not supersede installed epoch ${stale.epoch} on channel ${boundChannel}`, controlFlags(), sock, generation);
-        return;
-      }
-      this.liveRoutes.delete(stale.channel);
-      this.abortHandle(stale);
-      await this.opts.onRouteGone?.(stale);
-    }
-    const tentative = createRouteHandle(boundChannel, boundEpoch, this.connectionToken);
-    const bindRequest = {
-      handle: tentative,
-      target: request.target,
-      identity: request.identity,
-      principal: request.principal,
-      consumer_capabilities: request.consumer_capabilities
-    };
-    let decision;
-    try {
-      decision = await this.opts.onBind?.(bindRequest);
-    } catch (error2) {
-      try {
-        await this.sendError(frame, "route_rejected", error2 instanceof Error ? error2.message : String(error2), controlFlags(), sock, generation);
-      } finally {
-        await this.opts.onRouteGone?.(tentative);
-      }
-      return;
-    }
-    const rejection = bindRejection(decision);
-    if (rejection) {
-      try {
-        await this.sendError(frame, rejection.code, rejection.message, controlFlags(), sock, generation);
-      } finally {
-        await this.opts.onRouteGone?.(tentative);
-      }
-      return;
-    }
-    try {
-      await this.sendOn(sock, generation, buildFrameWithVersion(frame.header.ver, FrameType.Response, controlFlags(), 0, 0, frame.header.corr, encodeJson({ op: "route.bind" })));
-    } catch (error2) {
-      await this.opts.onRouteGone?.(tentative);
-      throw error2;
-    }
-    if (this.sock !== sock || this.generation !== generation || this.closeStarted || this.closedErr) {
-      await this.opts.onRouteGone?.(tentative);
-      return;
-    }
-    this.liveRoutes.set(tentative.channel, tentative);
-    await this.opts.onBound?.(tentative);
-  }
-  async handleDataRequest(frame, handle, sock, generation) {
-    const { corr, ver } = frame.header;
-    const key = routeKey(handle, corr);
-    const controller = new AbortController;
-    this.inflight.set(key, controller);
-    const context = {
-      handle,
-      signal: controller.signal,
-      currentEpoch: () => this.connectionEpoch,
-      emit: async (eventBody, options = {}) => {
-        this.assertLiveHandle(handle);
-        if (controller.signal.aborted)
-          return;
-        await this.sendOn(sock, generation, buildFrameWithVersion(ver, FrameType.StreamData, buildFlags(false, options.priority ?? Priority.Interactive, false, options.admissionClass ?? AdmissionClass.Normal), handle.channel, handle.epoch, corr, eventBody));
-      }
-    };
-    const releasePermit = await (this.requestGate ?? new AsyncPermitPool(DEFAULT_PROVIDER_HANDLER_CAPACITY)).acquire();
-    const dataFlags = buildFlags(false, Priority.Interactive, false);
-    try {
-      const body = await this.opts.handler(handle, frame.body, context);
-      if (controller.signal.aborted)
-        return;
-      this.assertLiveHandle(handle);
-      if (body === undefined) {
-        await this.sendOn(sock, generation, buildFrameWithVersion(ver, FrameType.StreamEnd, dataFlags, handle.channel, handle.epoch, corr, new Uint8Array(0)));
-      } else if (body instanceof Uint8Array) {
-        await this.sendOn(sock, generation, buildFrameWithVersion(ver, FrameType.Response, dataFlags, handle.channel, handle.epoch, corr, body));
-      } else {
-        throw new SubcProviderError("provider handler must return a Uint8Array or void", "invalid_handler_response");
-      }
-    } catch (error2) {
-      if (error2 instanceof StaleRouteHandleError || controller.signal.aborted)
-        return;
-      await this.sendError(frame, error2 instanceof SubcProviderError && error2.code ? error2.code : "handler_error", error2 instanceof Error ? error2.message : String(error2), dataFlags, sock, generation);
-    } finally {
-      releasePermit();
-      if (this.inflight.get(key) === controller)
-        this.inflight.delete(key);
-    }
-  }
-  async handleHealthRequest(frame, sock, generation) {
-    const { corr, ver } = frame.header;
-    const key = `control:${generation}:${corr}`;
-    const controller = new AbortController;
-    this.inflight.set(key, controller);
-    const releasePermit = await (this.requestGate ?? new AsyncPermitPool(DEFAULT_PROVIDER_HANDLER_CAPACITY)).acquire();
-    try {
-      if (controller.signal.aborted)
-        return;
-      const report = await this.opts.health();
-      await this.sendOn(sock, generation, buildFrameWithVersion(ver, FrameType.Response, controlFlags(), 0, 0, corr, encodeJson({
-        op: HEALTH_CHECK_OP,
-        status: report.status,
-        ...report.detail === undefined ? {} : { detail: report.detail },
-        ...report.metrics === undefined ? {} : { metrics: report.metrics }
-      })));
-    } catch (error2) {
-      await this.sendError(frame, error2 instanceof SubcProviderError && error2.code ? error2.code : "health_error", error2 instanceof Error ? error2.message : String(error2), controlFlags(), sock, generation);
-    } finally {
-      releasePermit();
-      if (this.inflight.get(key) === controller)
-        this.inflight.delete(key);
-    }
-  }
-  async sendError(frame, code, message, flags, sock, generation) {
-    await this.sendOn(sock, generation, buildFrameWithVersion(frame.header.ver, FrameType.Error, flags, frame.header.channel, frame.header.epoch, frame.header.corr, encodeJson({ code, message })));
-  }
-  async sendOn(sock, generation, frame) {
-    if (this.sock !== sock || this.generation !== generation || this.closeStarted || this.closedErr)
-      return;
-    await sendFrame(sock, frame);
-  }
-  handleUnexpectedDrop(sock, generation, cause) {
-    if (this.closeStarted || this.sock !== sock || this.generation !== generation)
-      return;
-    this.cancelRestoredDebounce();
-    this.abortGeneration(generation);
-    this.generation += 1;
-    sock.close();
-    this.scheduleReconnectAfterDrop(cause, this.generation, sock);
-  }
-  scheduleReconnectAfterDrop(cause, generation, droppedSocket) {
-    if (this.closeStarted)
-      return;
-    const previous = this.reconnecting;
-    if (previous) {
-      if (!this.shouldSupersedeReconnect(previous, generation, droppedSocket))
-        return;
-      previous.superseded = true;
-      previous.socket?.close();
-    }
-    const cycle = {
-      generation,
-      socket: null,
-      socketDied: false,
-      superseded: false
-    };
-    this.reconnecting = cycle;
-    this.enqueueConnectionState({ state: "down", cause });
-    this.reconnectWithRetry(cycle).catch((err) => {
-      if (this.isCurrentReconnect(cycle) && !this.closeStarted) {
-        this.failFatal(err instanceof Error ? err : new SubcProviderError(String(err)));
-      }
-    }).finally(() => {
-      if (this.isCurrentReconnect(cycle))
-        this.reconnecting = null;
-    });
-  }
-  async reconnectWithRetry(cycle) {
-    let attempt = 0;
-    let delay = this.opts.reconnectBackoff.baseMs;
-    for (;; ) {
-      if (!this.isCurrentReconnect(cycle))
-        return;
-      if (this.closeStarted)
-        throw new SubcProviderError("provider closed");
-      cycle.socket = null;
-      cycle.socketDied = false;
-      attempt += 1;
-      this.enqueueReconnectState(cycle, attempt);
-      try {
-        const opened = await SubcProvider.openConnection(this.opts, (sock) => {
-          if (!this.isCurrentReconnect(cycle)) {
-            sock.close();
-            return;
-          }
-          cycle.socket = sock;
-        });
-        if (!this.isCurrentReconnect(cycle) || this.closeStarted) {
-          opened.sock.close();
-          if (this.closeStarted)
-            throw new SubcProviderError("provider closed");
-          return;
-        }
-        const epoch = this.replaceConnection(opened, cycle.generation);
-        this.reconnecting = null;
-        if (this.reconnecting !== null) {
-          throw new SubcProviderError("reconnect state must clear before restored", "reconnect_state");
-        }
-        this.scheduleRestored(cycle.generation, epoch);
-        return;
-      } catch (err) {
-        if (!this.isCurrentReconnect(cycle))
-          return;
-        if (cycle.socket)
-          cycle.socketDied = true;
-        if (this.closeStarted)
-          throw err;
-        if (!isProviderReconnectTransient(err))
-          throw err;
-        await this.opts.sleep(delay);
-        delay = Math.min(delay * 2, this.opts.reconnectBackoff.capMs);
-      }
-    }
-  }
-  isCurrentReconnect(cycle) {
-    return !cycle.superseded && this.reconnecting === cycle && this.generation === cycle.generation;
-  }
-  shouldSupersedeReconnect(cycle, generation, droppedSocket) {
-    return cycle.generation < generation || cycle.socketDied || cycle.socket === droppedSocket;
-  }
-  enqueueReconnectState(cycle, attempt) {
-    if (!this.isCurrentReconnect(cycle))
-      return;
-    this.enqueueConnectionState({ state: "reconnecting", attempt }, cycle.generation, cycle);
-  }
-  replaceConnection(opened, generation) {
-    this.sock.close();
-    this.sock = opened.sock;
-    this.currentConn = opened.conn;
-    this.storage = opened.ack.storage;
-    this.closedErr = null;
-    this.connectionEpoch += 1;
-    this.connectionToken = newConnectionToken();
-    this.liveRoutes.clear();
-    this.nextCorr = 1n;
-    this.readLoop(opened.sock, generation);
-    return this.connectionEpoch;
-  }
-  scheduleRestored(generation, epoch) {
-    if (!this.opts.onConnectionState)
-      return;
-    const token = ++this.restoredDebounceToken;
-    this.opts.sleep(this.opts.restoredDebounceMs).then(() => {
-      if (token === this.restoredDebounceToken && !this.closeStarted && this.sock && this.generation === generation && this.connectionEpoch === epoch) {
-        this.enqueueConnectionState({ state: "restored", epoch }, generation);
-      }
-    }).catch((err) => {
-      if (token === this.restoredDebounceToken && !this.closeStarted) {
-        console.warn("SubcProvider restored debounce timer failed", err);
-      }
-    });
-  }
-  cancelRestoredDebounce() {
-    this.restoredDebounceToken += 1;
-  }
-  enqueueConnectionState(event, generation, reconnect) {
-    if (!this.opts.onConnectionState)
-      return;
-    this.stateQueue.push({ event, generation, reconnect });
-    if (!this.drainingStateQueue)
-      this.drainConnectionStateQueue();
-  }
-  async drainConnectionStateQueue() {
-    if (this.drainingStateQueue)
-      return;
-    this.drainingStateQueue = true;
-    try {
-      while (this.stateQueue.length > 0) {
-        const queued = this.stateQueue[0];
-        if (this.closeStarted || queued.generation !== undefined && queued.generation !== this.generation || queued.reconnect?.superseded) {
-          this.stateQueue.shift();
-          continue;
-        }
-        const { event } = queued;
-        try {
-          await this.opts.onConnectionState?.(event);
-          this.stateQueue.shift();
-        } catch (err) {
-          if (event.state === "restored") {
-            console.warn("SubcProvider restored callback failed; retrying delivery", err);
-            await pauseBeforeStateRetry();
-            continue;
-          }
-          console.warn("SubcProvider connection-state callback failed", err);
-          this.stateQueue.shift();
-        }
-      }
-    } finally {
-      this.drainingStateQueue = false;
-      if (this.stateQueue.length > 0)
-        this.drainConnectionStateQueue();
-    }
-  }
-  isLiveHandle(handle) {
-    return belongsToConnection(handle, this.connectionToken) && this.liveRoutes.get(handle.channel) === handle;
-  }
-  assertLiveHandle(handle) {
-    if (!this.isLiveHandle(handle))
-      throw new StaleRouteHandleError(handle);
-  }
-  allocateCorr() {
-    const maximum = 0xffffffffffffffffn;
-    if (this.nextCorr > maximum) {
-      const error2 = new SubcProviderError("channel-0 correlation id allocator exhausted", "corr_exhausted");
-      this.handleUnexpectedDrop(this.sock, this.generation, error2);
-      throw error2;
-    }
-    const corr = this.nextCorr;
-    this.nextCorr += 1n;
-    return corr;
-  }
-  failFatal(err) {
-    if (!this.closedErr)
-      this.closedErr = err;
-    this.closeStarted = true;
-    this.cancelRestoredDebounce();
-    this.abortAllInflight();
-    this.sock.close();
-    this.finishClosed();
-  }
-  finishClosed() {
-    this.resolveClosed();
-  }
-}
-function routeKey(handle, corr) {
-  return `${handle.channel}:${handle.epoch}:${corr}`;
-}
-function providerErrorFromFrame(frame) {
-  try {
-    const body = parseJson(frame.body);
-    return new SubcProviderError(body.message ?? "subc error", body.code);
-  } catch {
-    return new SubcProviderError(Buffer2.from(frame.body).toString("utf8") || "subc error");
-  }
-}
-function launchNonce(opts) {
-  const nonce = opts.launchNonce ?? process.env[SUBC_LAUNCH_NONCE_ENV2];
-  return nonce && nonce.length > 0 ? nonce : undefined;
-}
-function normalizeProviderConnectOptions(opts) {
-  return {
-    connectionFile: opts.connectionFile,
-    manifest: opts.manifest,
-    handler: opts.handler,
-    health: opts.health ?? (() => ({ status: "ok" })),
-    handshakeTimeoutMs: opts.handshakeTimeoutMs,
-    controlOps: opts.controlOps,
-    onBind: opts.onBind,
-    onBound: opts.onBound,
-    onRouteGone: opts.onRouteGone,
-    reconnectBackoff: opts.reconnectBackoff ?? DEFAULT_RECONNECT_BACKOFF,
-    sleep: opts.sleep ?? ((ms) => new Promise((resolve3) => setTimeout(resolve3, ms))),
-    restoredDebounceMs: opts.restoredDebounceMs ?? DEFAULT_RESTORED_DEBOUNCE_MS,
-    onConnectionState: opts.onConnectionState,
-    launchNonce: opts.launchNonce
-  };
-}
-function normalizedControlOps(controlOps) {
-  if (controlOps === null)
-    return null;
-  const merged = new Set(controlOps ?? []);
-  merged.add(HEALTH_CHECK_OP);
-  return [...merged];
-}
-function buildHelloFrame(opts) {
-  const nonce = launchNonce(opts);
-  return buildFrame(FrameType.Hello, controlFlags(), 0, 0, HELLO_CORR, encodeJson({
-    manifest: normalizeManifest(opts.manifest),
-    protocol_ver: PROTOCOL_VERSION,
-    control_ops: normalizedControlOps(opts.controlOps),
-    ...nonce ? { launch_nonce: nonce } : {}
-  }));
-}
-function isProviderReconnectTransient(err) {
-  if (err instanceof SubcProviderError)
-    return err.code === "duplicate_module_id";
-  if (err instanceof SocketClosedError || err instanceof SocketTimeoutError)
-    return true;
-  if (err instanceof SocketWriteNotQueuedError || err instanceof SocketWriteQueuedError)
-    return true;
-  if (err instanceof AuthError)
-    return true;
-  if (err instanceof ConnectionFileError)
-    return false;
-  const code = errorCode2(err);
-  return code === "ECONNREFUSED" || code === "ECONNRESET" || code === "EPIPE" || code === "ETIMEDOUT" || code === "ENOENT";
-}
-function errorCode2(err) {
-  if (typeof err === "object" && err !== null && "code" in err) {
-    const code = err.code;
-    if (typeof code === "string")
-      return code;
-  }
-  return;
-}
-async function pauseBeforeStateRetry() {
-  await new Promise((resolve3) => setTimeout(resolve3, 0));
-}
-function controlFlags() {
-  return buildFlags(false, Priority.Passive, false);
-}
-async function sendFrame(sock, frame) {
-  await sock.write(encodeFrame(frame), Date.now() + WRITE_TIMEOUT_MS);
-}
-async function expectHelloAck(sock, deadline) {
-  const frame = await sock.readFrame(deadline, deadline);
-  switch (frame.header.ty) {
-    case FrameType.HelloAck: {
-      const ack = parseJson(frame.body);
-      if (ack.negotiated_ver !== PROTOCOL_VERSION) {
-        throw new SubcProviderError(`subc negotiated protocol ${ack.negotiated_ver}; expected exactly ${PROTOCOL_VERSION}`, "unsupported_version");
-      }
-      return ack;
-    }
-    case FrameType.Error: {
-      const error2 = parseJson(frame.body);
-      throw new SubcProviderError(`subc rejected HELLO: ${error2.code ?? "unknown"} — ${error2.message ?? "subc error"}`, error2.code);
-    }
-    default:
-      throw new SubcProviderError(`unexpected frame ${FrameType[frame.header.ty]} awaiting HELLO_ACK`);
-  }
-}
-function encodeJson(value) {
-  return new Uint8Array(Buffer2.from(JSON.stringify(value), "utf8"));
-}
-function parseJson(bytes) {
-  return JSON.parse(Buffer2.from(bytes).toString("utf8"));
-}
-function numberField(value, field) {
-  if (typeof value !== "number" || !Number.isInteger(value)) {
-    throw new SubcProviderError(`route.bind ${field} must be an integer`);
-  }
-  return value;
-}
-function bindRejection(decision) {
-  if (decision === undefined || decision === true)
-    return null;
-  if (decision === false) {
-    return { code: "route_rejected", message: "route.bind rejected by provider" };
-  }
-  if (decision.accept)
-    return null;
-  return {
-    code: decision.code ?? "route_rejected",
-    message: decision.message ?? "route.bind rejected by provider"
-  };
-}
-function normalizeManifest(manifest) {
-  return {
-    module_id: manifest.module_id,
-    module_version: manifest.module_version,
-    protocol_ver: manifest.protocol_ver,
-    trust_tier: manifest.trust_tier,
-    provides: manifest.provides.map(normalizeProviderRole),
-    consumes: manifest.consumes.map(normalizeConsumerRole),
-    scheduled_tasks: manifest.scheduled_tasks.map(normalizeScheduledTask),
-    bindings: {
-      storage: {
-        kind: manifest.bindings.storage.kind,
-        scope: manifest.bindings.storage.scope,
-        owns_schema: manifest.bindings.storage.owns_schema
-      },
-      vault_grants: manifest.bindings.vault_grants.map((grant) => ({
-        secret: grant.secret,
-        reason: grant.reason
-      })),
-      identity: {
-        requires: [...manifest.bindings.identity.requires],
-        optional: [...manifest.bindings.identity.optional]
-      }
-    }
+    timeoutArbitrationGraceMs: opts.timeoutArbitrationGraceMs ?? TIMEOUT_ARBITRATION_GRACE_MS,
+    livenessProbeWindowMs: opts.livenessProbeWindowMs ?? LIVENESS_PROBE_WINDOW_MS,
+    onControlPush: opts.onControlPush
   };
 }
-function normalizeProviderRole(role) {
-  switch (role.role) {
-    case "tool_provider":
-      return {
-        role: "tool_provider",
-        tools: role.tools.map((tool) => ({
-          name: tool.name,
-          ...tool.description === undefined ? {} : { description: tool.description },
-          execution_mode: tool.execution_mode,
-          schema: tool.schema
-        })),
-        identity_scope: [...role.identity_scope],
-        concurrency: role.concurrency,
-        emits_push: role.emits_push,
-        sub_supervises: role.sub_supervises
-      };
-    case "pipeline_stage":
-      return {
-        role: "pipeline_stage",
-        stage: role.stage,
-        applies_to: {
-          provider: role.applies_to.provider,
-          model: role.applies_to.model
-        },
-        interface: role.interface,
-        declares_frozen_floor: role.declares_frozen_floor,
-        needs_signals: [...role.needs_signals],
-        conformance_class: role.conformance_class
-      };
-    case "management_surface":
-      return {
-        role: "management_surface",
-        operations: role.operations.map((operation) => ({
-          name: operation.name,
-          kind: operation.kind
-        })),
-        config_schema: role.config_schema,
-        observability: role.observability.map((surface) => ({
-          name: surface.name,
-          kind: surface.kind
-        })),
-        identity_scope: [...role.identity_scope]
-      };
-    case "internal_service":
-      return {
-        role: "internal_service",
-        service_id: role.service_id,
-        transport: role.transport,
-        agent_facing: role.agent_facing,
-        operations: [...role.operations]
-      };
-  }
+function routeCacheKey(target, identity, consumerIdentity) {
+  const consumerPart = consumerIdentity ? `${consumerIdentity.module_id}\x00${consumerIdentity.launch_nonce}` : "";
+  return `${target.kind}\x00${target.module_id}\x00${identity.project_root}\x00${identity.harness}\x00${identity.session}\x00${consumerPart}`;
+}
+function routeOpenConsumerIdentity(opts = {}) {
+  if (opts.consumerIdentity !== undefined)
+    return opts.consumerIdentity ?? undefined;
+  const moduleId = process.env[SUBC_MODULE_ID_ENV];
+  const launchNonce = process.env[SUBC_LAUNCH_NONCE_ENV];
+  if (!moduleId || !launchNonce)
+    return;
+  return { module_id: moduleId, launch_nonce: launchNonce };
 }
-function normalizeConsumerRole(role) {
-  switch (role.role) {
-    case "tool_client":
-      return { role: "tool_client", of: [...role.of] };
-    case "llm_client":
-      return { role: "llm_client", via: role.via, auth: role.auth };
-    case "service_client":
-      return { role: "service_client", of: [...role.of] };
+function errorCode(err) {
+  if (typeof err === "object" && err !== null && "code" in err) {
+    const code = err.code;
+    if (typeof code === "string")
+      return code;
   }
+  return;
 }
-function normalizeScheduledTask(task) {
-  return {
-    task_id: task.task_id,
-    eligibility: {
-      cooldown: task.eligibility.cooldown,
-      window: task.eligibility.window
-    },
-    lease_scope: task.lease_scope,
-    renews_during_calls: task.renews_during_calls,
-    toolset: [...task.toolset],
-    model_policy: {
-      tier: task.model_policy.tier,
-      fallback_chain: [...task.model_policy.fallback_chain]
-    },
-    step_cap: task.step_cap,
-    circuit_breaker: {
-      identical_failures: task.circuit_breaker.identical_failures
-    }
-  };
+function causeMessage(cause) {
+  if (cause === undefined)
+    return "";
+  return `: ${cause instanceof Error ? cause.message : String(cause)}`;
 }
-var DEFAULT_HANDSHAKE_TIMEOUT_MS2 = 1e4, BODY_READ_TIMEOUT_MS2 = 30000, WRITE_TIMEOUT_MS = 30000, DEFAULT_RESTORED_DEBOUNCE_MS = 250, DEFAULT_PROVIDER_HANDLER_CAPACITY = 64, HEALTH_CHECK_OP = "health.check", HELLO_CORR = 1n, SubcProviderError, SUBC_LAUNCH_NONCE_ENV2 = "SUBC_LAUNCH_NONCE";
-var init_provider = __esm(() => {
+function pendingKey(handle, corr) {
+  return handle ? `${handle.channel}:${handle.epoch}:${corr}` : `0:0:${corr}`;
+}
+var debug, DEFAULT_HANDSHAKE_TIMEOUT_MS = 1e4, DEFAULT_REQUEST_TIMEOUT_MS = 30000, TIMEOUT_ARBITRATION_GRACE_MS = 50, LIVENESS_PROBE_WINDOW_MS = 2000, REQUEST_DEADLINE_MARKER = "request_deadline", DEADLINE_NO_DROP_CODE = "deadline_exceeded_no_drop_observed", ROUTE_OPEN_RETRY_DEADLINE_MS = 30000, BODY_READ_TIMEOUT_MS = 30000, EMPTY_BODY, DEFAULT_MANAGED_TARGET_KIND = "management_surface", SUBC_MODULE_ID_ENV = "SUBC_MODULE_ID", SUBC_LAUNCH_NONCE_ENV = "SUBC_LAUNCH_NONCE", DEFAULT_RECONNECT_BACKOFF, SubcCallError, SubcError;
+var init_client = __esm(() => {
   init_auth();
-  init_client();
   init_connection_file();
   init_envelope();
   init_route_handle();
   init_socket();
-  SubcProviderError = class SubcProviderError extends Error {
+  debug = debuglog("subc-client");
+  EMPTY_BODY = new Uint8Array(0);
+  DEFAULT_RECONNECT_BACKOFF = {
+    baseMs: 100,
+    capMs: 2000,
+    maxAttempts: 6
+  };
+  SubcCallError = class SubcCallError extends Error {
+    kind;
+    code;
+    cause;
+    constructor(kind, message, code, cause) {
+      super(message);
+      this.kind = kind;
+      this.code = code;
+      this.cause = cause;
+      this.name = "SubcCallError";
+    }
+  };
+  SubcError = class SubcError extends Error {
     code;
     constructor(message, code) {
       super(message);
@@ -4903,7 +4219,17 @@ var init_provider = __esm(() => {
   };
 });
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.5.0/node_modules/@cortexkit/subc-client/dist/index.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.8.1/node_modules/@cortexkit/subc-client/dist/provider.js
+var init_provider = __esm(() => {
+  init_auth();
+  init_client();
+  init_connection_file();
+  init_envelope();
+  init_route_handle();
+  init_socket();
+});
+
+// ../../node_modules/.bun/@cortexkit+subc-client@0.8.1/node_modules/@cortexkit/subc-client/dist/index.js
 var init_dist = __esm(() => {
   init_client();
   init_route_handle();
@@ -5373,6 +4699,9 @@ var init_project_identity = () => {};
 
 // ../aft-bridge/dist/subc-transport.js
 import { existsSync as existsSync3, statSync as statSync3 } from "node:fs";
+function reconnectBackoffMs(attempt) {
+  return Math.min(RECONNECT_RETRY_FLOOR_MS * 2 ** Math.min(attempt, 6), RECONNECT_RETRY_CAP_MS);
+}
 function identityKey(identity) {
   return `${identity.project_root}\x00${identity.harness}\x00${identity.session}`;
 }
@@ -5586,6 +4915,8 @@ class BgSubscription {
           giveUp("stopped");
           return;
         }
+        if (Date.now() - subscribedAt >= BG_STABLE_MS)
+          backoffAttempt = 0;
         beginReconnect();
       } catch (err) {
         const routeId2 = this.routeId(route);
@@ -5610,8 +4941,7 @@ class BgSubscription {
       giveUp("stopped");
   }
   async backoff(attempt) {
-    const ms = Math.min(100 * 2 ** Math.min(attempt, 6), 2000);
-    await this.sleep(ms);
+    await this.sleep(reconnectBackoffMs(attempt));
   }
 }
 function isRecord(value) {
@@ -5626,6 +4956,15 @@ function isAbsentRootRouteError(err) {
 function absentRootError(root) {
   return new SubcError(`invalid route project root: project root does not exist: ${root}`, "config_divergence");
 }
+function reloadWindowExhaustedError(error2) {
+  if (error2 instanceof Error) {
+    try {
+      error2.message += ROUTE_OPEN_RELOAD_WAIT_EXHAUSTED_SUFFIX;
+      return error2;
+    } catch {}
+  }
+  return new Error(`${String(error2)}${ROUTE_OPEN_RELOAD_WAIT_EXHAUSTED_SUFFIX}`);
+}
 function safeCloseRoute(client, route) {
   try {
     client.closeRouteChannel(route).catch(() => {
@@ -5734,6 +5073,7 @@ class SubcTransportPool {
   onBgEventsNudge;
   onBgEventsNudgeRef;
   bgBackoffSleep;
+  routeRetrySleep;
   bgDispatchProbeIntervalMs;
   lifecycleDemandCheck;
   onLifecycleEvent;
@@ -5744,6 +5084,9 @@ class SubcTransportPool {
   outerFacadeEvictor;
   client = null;
   connecting = null;
+  routeReopenRetryDelayMs = RECONNECT_RETRY_FLOOR_MS;
+  routeReopenRetry = null;
+  routeReopenRetryMs = null;
   sessions = new Map;
   rootIndex = new Map;
   dormantRoots = new Map;
@@ -5764,6 +5107,7 @@ class SubcTransportPool {
     this.onBgEventsNudge = options.onBgEventsNudge;
     this.onBgEventsNudgeRef = options.onBgEventsNudgeRef;
     this.bgBackoffSleep = options.bgBackoffSleep ?? ((ms) => new Promise((resolve4) => setTimeout(resolve4, ms)));
+    this.routeRetrySleep = options.routeRetrySleep ?? ((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;
@@ -6216,6 +5560,23 @@ class SubcTransportPool {
           throw error2;
         }
       };
+      const openRouteAfterReloadWindow = async () => {
+        let reloadWaitedMs = 0;
+        while (true) {
+          try {
+            return await openRoute();
+          } catch (error2) {
+            if (!isRouteOpenReloadWindowError(error2))
+              throw error2;
+            const { delayMs, wait } = this.waitForRouteReopenBackoff();
+            if (reloadWaitedMs + delayMs > ROUTE_OPEN_RELOAD_WAIT_CAP_MS) {
+              throw reloadWindowExhaustedError(error2);
+            }
+            reloadWaitedMs += delayMs;
+            await wait;
+          }
+        }
+      };
       const clearRouteEntry = (entry) => {
         if (record.routeEntry !== entry)
           return;
@@ -6252,7 +5613,7 @@ class SubcTransportPool {
         this.ensureBgSubscription(identity, record);
         return reply;
       };
-      let routeAndEntry = await openRoute();
+      let routeAndEntry = await openRouteAfterReloadWindow();
       try {
         return await requestOnRoute(routeAndEntry.route);
       } catch (error2) {
@@ -6260,9 +5621,12 @@ class SubcTransportPool {
           throw this.annotateReapError(error2, record);
         if (isRouteProvenAbsentError(error2) && this.isCurrentSession(key, record) && this.client === client) {
           clearRouteEntry(routeAndEntry.entry);
-          routeAndEntry = await openRoute();
+          await this.waitForRouteReopenBackoff().wait;
+          routeAndEntry = await openRouteAfterReloadWindow();
           try {
-            return await requestOnRoute(routeAndEntry.route);
+            const reply = await requestOnRoute(routeAndEntry.route);
+            this.resetRouteReopenBackoff();
+            return reply;
           } catch (retryError) {
             if (this.isReapInduced(record))
               throw this.annotateReapError(retryError, record);
@@ -6282,6 +5646,27 @@ class SubcTransportPool {
       this.deleteSessionIfEmpty(key, record);
     }
   }
+  waitForRouteReopenBackoff() {
+    const pending = this.routeReopenRetry;
+    const pendingDelay = this.routeReopenRetryMs;
+    if (pending && pendingDelay !== null)
+      return { delayMs: pendingDelay, wait: pending };
+    const delayMs = this.routeReopenRetryDelayMs;
+    this.routeReopenRetryDelayMs = Math.min(delayMs * 2, RECONNECT_RETRY_CAP_MS);
+    let retry;
+    retry = Promise.resolve().then(() => this.routeRetrySleep(delayMs)).finally(() => {
+      if (this.routeReopenRetry === retry) {
+        this.routeReopenRetry = null;
+        this.routeReopenRetryMs = null;
+      }
+    });
+    this.routeReopenRetry = retry;
+    this.routeReopenRetryMs = delayMs;
+    return { delayMs, wait: retry };
+  }
+  resetRouteReopenBackoff() {
+    this.routeReopenRetryDelayMs = RECONNECT_RETRY_FLOOR_MS;
+  }
   async ensureClient() {
     if (this.shuttingDown)
       throw new SubcTransportShuttingDownError;
@@ -6535,10 +5920,11 @@ function resolveBridgeForNudge(pool, ref) {
     currentConcretePoolId: candidate.getConcretePoolId?.()
   });
 }
-var SubcTransportShuttingDownError, AFT_MODULE_ID = "aft", MAX_CONSECUTIVE_TRANSPORT_FAILURES = 3, BG_STABLE_MS = 5000, BG_LIFECYCLE_LOG_INTERVAL_MS = 60000, BG_DISPATCH_PROBE_INTERVAL_MS = 60000, DEFAULT_SESSION_ID = "__default__", LOCALLY_SATISFIED_COMMANDS, SubcRootReapedError, SubcRootGenerationExpiredError, SubcRootDemandRequiredError, RouteTornDownError;
+var SubcTransportShuttingDownError, AFT_MODULE_ID = "aft", MAX_CONSECUTIVE_TRANSPORT_FAILURES = 3, RECONNECT_RETRY_FLOOR_MS = 100, RECONNECT_RETRY_CAP_MS = 2000, ROUTE_OPEN_RELOAD_WAIT_CAP_MS = 15000, ROUTE_OPEN_RELOAD_WAIT_EXHAUSTED_SUFFIX = " The AFT daemon module did not return within the 15s reload window.", BG_STABLE_MS = 5000, BG_LIFECYCLE_LOG_INTERVAL_MS = 60000, BG_DISPATCH_PROBE_INTERVAL_MS = 60000, DEFAULT_SESSION_ID = "__default__", LOCALLY_SATISFIED_COMMANDS, SubcRootReapedError, SubcRootGenerationExpiredError, SubcRootDemandRequiredError, RouteTornDownError;
 var init_subc_transport = __esm(() => {
   init_dist();
   init_active_logger();
+  init_error_contract();
   init_lifecycle_registry();
   init_project_identity();
   SubcTransportShuttingDownError = class SubcTransportShuttingDownError extends SubcCallError {
@@ -6609,6 +5995,12 @@ function isRouteGoodbyeError(error2) {
   }
   return error2.code === "route_closed" && error2.message.includes("route closed by subc");
 }
+function isRouteOpenReloadWindowError(error2) {
+  if (error2 === null || typeof error2 !== "object")
+    return false;
+  const code = error2.code;
+  return code === "module_reloading" || code === "module_warming" || code === "target_unavailable";
+}
 function hasEngineResponse(error2) {
   const response = error2.response;
   if (response !== null && typeof response === "object")
@@ -6967,7 +6359,16 @@ function platformKey(platform = process.platform, arch = process.arch) {
   }
   return key;
 }
+function logBinaryResolution(resolution) {
+  log(`Resolved binary from ${resolution.source}: ${resolution.path}`);
+}
 function findBinarySync(expectedVersion) {
+  const resolution = findBinarySyncInner(expectedVersion);
+  if (resolution)
+    logBinaryResolution(resolution);
+  return resolution?.path ?? null;
+}
+function findBinarySyncInner(expectedVersion) {
   const ext = process.platform === "win32" ? ".exe" : "";
   const env = { ...process.env };
   const pluginVersion = expectedVersion ?? (() => {
@@ -6981,8 +6382,9 @@ function findBinarySync(expectedVersion) {
   if (pluginVersion) {
     const tag = pluginVersion.startsWith("v") ? pluginVersion : `v${pluginVersion}`;
     const versionCached = cachedBinaryPathFromEnv(tag, env, ext);
-    if (versionCached && isExpectedCachedBinary2(versionCached, pluginVersion))
-      return versionCached;
+    if (versionCached && isExpectedCachedBinary2(versionCached, pluginVersion)) {
+      return { path: versionCached, source: "versioned cache" };
+    }
   }
   try {
     const key = platformKey();
@@ -6997,7 +6399,7 @@ function findBinarySync(expectedVersion) {
         warn(`npm platform package binary v${npmVersion} does not match plugin v${pluginVersion}; skipping (continuing to PATH lookup)`);
       } else {
         const copied = copyToVersionedCache(resolved, npmVersion);
-        return copied ?? resolved;
+        return { path: copied ?? resolved, source: "npm platform package" };
       }
     }
   } catch {}
@@ -7015,27 +6417,28 @@ function findBinarySync(expectedVersion) {
       }
       const usable = probeBinaryCandidate(candidate, "PATH", expectedVersion);
       if (usable)
-        return usable;
+        return { path: usable, source: "PATH" };
     }
   } catch {}
   const cargoPath = join7(homeDirFromEnv(env), ".cargo", "bin", `aft${ext}`);
   if (existsSync5(cargoPath)) {
     const usable = probeBinaryCandidate(cargoPath, "cargo", expectedVersion);
     if (usable)
-      return usable;
+      return { path: usable, source: "cargo" };
   }
   return null;
 }
 async function findBinary(expectedVersion) {
   const syncResult = findBinarySync(expectedVersion);
   if (syncResult) {
-    log(`Resolved binary: ${syncResult}`);
     return syncResult;
   }
   log("Binary not found locally, attempting auto-download...");
   const downloaded = await ensureBinaryForResolver(expectedVersion);
-  if (downloaded)
+  if (downloaded) {
+    logBinaryResolution({ path: downloaded, source: "auto-download" });
     return downloaded;
+  }
   throw new Error([
     "Could not find the `aft` binary.",
     "",
@@ -9184,6 +8587,8 @@ class RevivableTransportPool {
   onBinaryReplaced;
   activePool;
   revival = null;
+  revivalRetryDelayMs = REVIVAL_RETRY_FLOOR_MS;
+  revivalRetryNotBefore = 0;
   transports = new Map;
   configureOverrides = new Map;
   editSlotSurvivesCaptured = false;
@@ -9277,12 +8682,30 @@ class RevivableTransportPool {
       return this.activePool;
     if (this.revival)
       return this.revival;
+    const delay = Math.max(0, this.revivalRetryNotBefore - Date.now());
+    if (delay > 0) {
+      let scheduled;
+      scheduled = new Promise((resolve7) => setTimeout(resolve7, delay)).then(() => {
+        if (this.revival === scheduled)
+          this.revival = null;
+        return this.ensureActivePool();
+      });
+      this.revival = scheduled;
+      scheduled.then(() => {
+        return;
+      }, () => {
+        return;
+      });
+      return scheduled;
+    }
     warn("transport was shut down but new demand arrived — reviving (host quit hook fired without process exit?)");
-    const revival = this.createPool().then((pool) => {
+    const revival = Promise.resolve().then(() => this.createPool()).then((pool) => {
       for (const [key, value] of this.configureOverrides) {
         pool.setConfigureOverride(key, value);
       }
       this.activePool = pool;
+      this.revivalRetryDelayMs = REVIVAL_RETRY_FLOOR_MS;
+      this.revivalRetryNotBefore = 0;
       for (const [root, transport] of this.transports) {
         transport.refreshStatusSubscription(pool.getActiveBridgeForRoot(root));
       }
@@ -9293,6 +8716,8 @@ class RevivableTransportPool {
       if (this.revival === revival)
         this.revival = null;
     }, () => {
+      this.revivalRetryNotBefore = Date.now() + this.revivalRetryDelayMs;
+      this.revivalRetryDelayMs = Math.min(this.revivalRetryDelayMs * 2, REVIVAL_RETRY_CAP_MS);
       if (this.revival === revival)
         this.revival = null;
     });
@@ -9386,6 +8811,7 @@ class RevivableProjectTransport {
     unsubscribe?.();
   }
 }
+var REVIVAL_RETRY_FLOOR_MS = 100, REVIVAL_RETRY_CAP_MS = 2000;
 var init_revivable_transport = __esm(() => {
   init_active_logger();
   init_project_identity();
@@ -9684,117 +9110,117 @@ function unwrapRustZoomBatchEnvelope(response) {
 // ../aft-bridge/dist/index.js
 var exports_dist = {};
 __export(exports_dist, {
-  unwrapRustZoomBatchEnvelope: () => unwrapRustZoomBatchEnvelope,
-  toolErrorFromResponse: () => toolErrorFromResponse,
-  timeoutForCommand: () => timeoutForCommand,
-  tagStderrLine: () => tagStderrLine,
-  stripJsoncSymbols: () => stripJsoncSymbols,
-  stripHarnessSpecificConfigKeys: () => stripHarnessSpecificConfigKeys,
-  sleep: () => sleep,
-  shouldShowAnnouncement: () => shouldShowAnnouncement,
-  setActiveLogger: () => setActiveLogger,
-  runBashHostFallback: () => runBashHostFallback,
-  resolveNpm: () => resolveNpm,
-  resolveLegacyStorageRoot: () => resolveLegacyStorageRoot,
-  resolveLegacyAftConfigSources: () => resolveLegacyAftConfigSources,
-  resolveHarnessStoragePath: () => resolveHarnessStoragePath,
-  resolveCortexKitUserConfigPath: () => resolveCortexKitUserConfigPath,
-  resolveCortexKitStorageRoot: () => resolveCortexKitStorageRoot,
-  resolveCortexKitProjectConfigPath: () => resolveCortexKitProjectConfigPath,
-  resolveCortexKitConfigPaths: () => resolveCortexKitConfigPaths,
-  resolveBridgeForNudge: () => resolveBridgeForNudge,
-  resolveBashKillTimeout: () => resolveBashKillTimeout,
-  resolveAftStorageRoot: () => resolveAftStorageRoot,
-  resolveAftLogPath: () => resolveAftLogPath,
-  repairRootScopedStorageFile: () => repairRootScopedStorageFile,
-  readConfigTiers: () => readConfigTiers,
-  projectRootKeyHash: () => projectRootKeyHash,
-  probeNpmVersion: () => probeNpmVersion,
-  prepareCanonicalPathArguments: () => prepareCanonicalPathArguments,
-  prepareCanonicalEditArguments: () => prepareCanonicalEditArguments,
-  platformKey: () => platformKey,
-  npmSpawnEnv: () => npmSpawnEnv,
-  migrateAftConfigFile: () => migrateAftConfigFile,
-  maybeAppendGrepSearchHint: () => maybeAppendGrepSearchHint,
-  maybeAppendConflictsHint: () => maybeAppendConflictsHint,
-  markAnnouncementSeen: () => markAnnouncementSeen,
-  isWellFormedUnicodeString: () => isWellFormedUnicodeString,
-  isTerminalStatus: () => isTerminalStatus,
-  isRustZoomBatchEnvelope: () => isRustZoomBatchEnvelope,
-  isOrtAutoDownloadSupported: () => isOrtAutoDownloadSupported,
-  isNpmAvailable: () => isNpmAvailable,
-  isNativeExecutable: () => isNativeExecutable,
-  isHomeDirectoryRoot: () => isHomeDirectoryRoot,
-  isEmptyParam: () => isEmptyParam,
-  isBridgeTransportTimeout: () => isBridgeTransportTimeout,
-  isBashTransportDeadError: () => isBashTransportDeadError,
-  inlineUserConfigTier: () => inlineUserConfigTier,
-  getMigrationStatus: () => getMigrationStatus,
-  getManualInstallHint: () => getManualInstallHint,
-  getCachedBinaryPath: () => getCachedBinaryPath,
-  getCacheDir: () => getAftBinaryCacheDir,
-  getBinaryName: () => getBinaryName,
-  getAftLspPackagesDir: () => getAftLspPackagesDir,
-  getAftLspBinariesDir: () => getAftLspBinariesDir,
-  getAftCacheRoot: () => getAftCacheRoot,
-  getAftBinaryCacheDir: () => getAftBinaryCacheDir,
-  formatZoomText: () => formatZoomText,
-  formatZoomMultiTargetResult: () => formatZoomMultiTargetResult,
-  formatTokenCount: () => formatTokenCount,
-  formatSeconds: () => formatSeconds,
-  formatReadFooter: () => formatReadFooter,
-  formatForegroundResult: () => formatForegroundResult,
-  formatEditSummary: () => formatEditSummary,
-  formatDroppedKeyWarnings: () => formatDroppedKeyWarnings,
-  formatCallgraphSections: () => formatCallgraphSections,
-  formatBridgeErrorMessage: () => formatBridgeErrorMessage,
-  findBinarySync: () => findBinarySync,
-  findBinary: () => findBinary,
-  ensureStorageMigrated: () => ensureStorageMigrated,
-  ensureOnnxRuntime: () => ensureOnnxRuntime,
-  ensureBinary: () => ensureBinary,
-  downloadBinary: () => downloadBinary,
-  decodeFileUrl: () => decodeFileUrl,
-  createAftTransportPool: () => createAftTransportPool,
-  compressionSavingsPercent: () => compressionSavingsPercent,
-  compareSemver: () => compareSemver,
-  commandInvokesCodeSearch: () => commandInvokesCodeSearch,
-  coerceTargetParam: () => coerceTargetParam,
-  coerceStringArray: () => coerceStringArray,
-  coerceOptionalInt: () => coerceOptionalInt,
-  coerceBoolean: () => coerceBoolean,
-  coerceAliasedStringParam: () => coerceAliasedStringParam,
-  cleanupOnnxRuntime: () => cleanupOnnxRuntime,
-  canonicalizeProjectRoot: () => canonicalizeProjectRoot,
-  bashHostFallbackAskPattern: () => bashHostFallbackAskPattern,
-  adaptToolError: () => adaptToolError,
-  __onnxTest__: () => __test__,
-  SubcTransportShuttingDownError: () => SubcTransportShuttingDownError,
-  SubcTransportPool: () => SubcTransportPool,
-  RotatingLogSink: () => RotatingLogSink,
-  RevivableTransportPool: () => RevivableTransportPool,
-  PLATFORM_ASSET_MAP: () => PLATFORM_ASSET_MAP,
-  PLATFORM_ARCH_MAP: () => PLATFORM_ARCH_MAP,
-  PLAIN_CALLGRAPH_THEME: () => PLAIN_CALLGRAPH_THEME,
-  PI_ONLY_KEYS: () => PI_ONLY_KEYS,
-  OPENCODE_ONLY_KEYS: () => OPENCODE_ONLY_KEYS,
-  LONG_RUNNING_COMMAND_TIMEOUT_MS: () => LONG_RUNNING_COMMAND_TIMEOUT_MS,
-  InvalidRequestError: () => InvalidRequestError,
-  HomeProjectRootError: () => HomeProjectRootError,
-  DEFAULT_LOG_GENERATIONS: () => DEFAULT_LOG_GENERATIONS,
-  DEFAULT_LOG_BYTES: () => DEFAULT_LOG_BYTES,
-  BridgeTransportUnknownOutcomeError: () => BridgeTransportUnknownOutcomeError,
-  BridgeTransportUnavailableError: () => BridgeTransportUnavailableError,
-  BridgeTransportTimeoutError: () => BridgeTransportTimeoutError,
-  BridgePool: () => BridgePool,
-  BinaryBridge: () => BinaryBridge,
-  BRIDGE_TRANSPORT_UNKNOWN_OUTCOME_DISPOSITION: () => BRIDGE_TRANSPORT_UNKNOWN_OUTCOME_DISPOSITION,
-  BASH_TRANSPORT_DISPOSITION: () => BASH_TRANSPORT_DISPOSITION,
-  BASH_HOST_FALLBACK_REFUSAL: () => BASH_HOST_FALLBACK_REFUSAL,
-  BASH_HOST_FALLBACK_MAX_TIMEOUT_MS: () => BASH_HOST_FALLBACK_MAX_TIMEOUT_MS,
-  BASH_HOST_FALLBACK_MAX_OUTPUT_BYTES: () => BASH_HOST_FALLBACK_MAX_OUTPUT_BYTES,
+  AftToolError: () => AftToolError,
   BASH_HOST_FALLBACK_BANNER: () => BASH_HOST_FALLBACK_BANNER,
-  AftToolError: () => AftToolError
+  BASH_HOST_FALLBACK_MAX_OUTPUT_BYTES: () => BASH_HOST_FALLBACK_MAX_OUTPUT_BYTES,
+  BASH_HOST_FALLBACK_MAX_TIMEOUT_MS: () => BASH_HOST_FALLBACK_MAX_TIMEOUT_MS,
+  BASH_HOST_FALLBACK_REFUSAL: () => BASH_HOST_FALLBACK_REFUSAL,
+  BASH_TRANSPORT_DISPOSITION: () => BASH_TRANSPORT_DISPOSITION,
+  BRIDGE_TRANSPORT_UNKNOWN_OUTCOME_DISPOSITION: () => BRIDGE_TRANSPORT_UNKNOWN_OUTCOME_DISPOSITION,
+  BinaryBridge: () => BinaryBridge,
+  BridgePool: () => BridgePool,
+  BridgeTransportTimeoutError: () => BridgeTransportTimeoutError,
+  BridgeTransportUnavailableError: () => BridgeTransportUnavailableError,
+  BridgeTransportUnknownOutcomeError: () => BridgeTransportUnknownOutcomeError,
+  DEFAULT_LOG_BYTES: () => DEFAULT_LOG_BYTES,
+  DEFAULT_LOG_GENERATIONS: () => DEFAULT_LOG_GENERATIONS,
+  HomeProjectRootError: () => HomeProjectRootError,
+  InvalidRequestError: () => InvalidRequestError,
+  LONG_RUNNING_COMMAND_TIMEOUT_MS: () => LONG_RUNNING_COMMAND_TIMEOUT_MS,
+  OPENCODE_ONLY_KEYS: () => OPENCODE_ONLY_KEYS,
+  PI_ONLY_KEYS: () => PI_ONLY_KEYS,
+  PLAIN_CALLGRAPH_THEME: () => PLAIN_CALLGRAPH_THEME,
+  PLATFORM_ARCH_MAP: () => PLATFORM_ARCH_MAP,
+  PLATFORM_ASSET_MAP: () => PLATFORM_ASSET_MAP,
+  RevivableTransportPool: () => RevivableTransportPool,
+  RotatingLogSink: () => RotatingLogSink,
+  SubcTransportPool: () => SubcTransportPool,
+  SubcTransportShuttingDownError: () => SubcTransportShuttingDownError,
+  __onnxTest__: () => __test__,
+  adaptToolError: () => adaptToolError,
+  bashHostFallbackAskPattern: () => bashHostFallbackAskPattern,
+  canonicalizeProjectRoot: () => canonicalizeProjectRoot,
+  cleanupOnnxRuntime: () => cleanupOnnxRuntime,
+  coerceAliasedStringParam: () => coerceAliasedStringParam,
+  coerceBoolean: () => coerceBoolean,
+  coerceOptionalInt: () => coerceOptionalInt,
+  coerceStringArray: () => coerceStringArray,
+  coerceTargetParam: () => coerceTargetParam,
+  commandInvokesCodeSearch: () => commandInvokesCodeSearch,
+  compareSemver: () => compareSemver,
+  compressionSavingsPercent: () => compressionSavingsPercent,
+  createAftTransportPool: () => createAftTransportPool,
+  decodeFileUrl: () => decodeFileUrl,
+  downloadBinary: () => downloadBinary,
+  ensureBinary: () => ensureBinary,
+  ensureOnnxRuntime: () => ensureOnnxRuntime,
+  ensureStorageMigrated: () => ensureStorageMigrated,
+  findBinary: () => findBinary,
+  findBinarySync: () => findBinarySync,
+  formatBridgeErrorMessage: () => formatBridgeErrorMessage,
+  formatCallgraphSections: () => formatCallgraphSections,
+  formatDroppedKeyWarnings: () => formatDroppedKeyWarnings,
+  formatEditSummary: () => formatEditSummary,
+  formatForegroundResult: () => formatForegroundResult,
+  formatReadFooter: () => formatReadFooter,
+  formatSeconds: () => formatSeconds,
+  formatTokenCount: () => formatTokenCount,
+  formatZoomMultiTargetResult: () => formatZoomMultiTargetResult,
+  formatZoomText: () => formatZoomText,
+  getAftBinaryCacheDir: () => getAftBinaryCacheDir,
+  getAftCacheRoot: () => getAftCacheRoot,
+  getAftLspBinariesDir: () => getAftLspBinariesDir,
+  getAftLspPackagesDir: () => getAftLspPackagesDir,
+  getBinaryName: () => getBinaryName,
+  getCacheDir: () => getAftBinaryCacheDir,
+  getCachedBinaryPath: () => getCachedBinaryPath,
+  getManualInstallHint: () => getManualInstallHint,
+  getMigrationStatus: () => getMigrationStatus,
+  inlineUserConfigTier: () => inlineUserConfigTier,
+  isBashTransportDeadError: () => isBashTransportDeadError,
+  isBridgeTransportTimeout: () => isBridgeTransportTimeout,
+  isEmptyParam: () => isEmptyParam,
+  isHomeDirectoryRoot: () => isHomeDirectoryRoot,
+  isNativeExecutable: () => isNativeExecutable,
+  isNpmAvailable: () => isNpmAvailable,
+  isOrtAutoDownloadSupported: () => isOrtAutoDownloadSupported,
+  isRustZoomBatchEnvelope: () => isRustZoomBatchEnvelope,
+  isTerminalStatus: () => isTerminalStatus,
+  isWellFormedUnicodeString: () => isWellFormedUnicodeString,
+  markAnnouncementSeen: () => markAnnouncementSeen,
+  maybeAppendConflictsHint: () => maybeAppendConflictsHint,
+  maybeAppendGrepSearchHint: () => maybeAppendGrepSearchHint,
+  migrateAftConfigFile: () => migrateAftConfigFile,
+  npmSpawnEnv: () => npmSpawnEnv,
+  platformKey: () => platformKey,
+  prepareCanonicalEditArguments: () => prepareCanonicalEditArguments,
+  prepareCanonicalPathArguments: () => prepareCanonicalPathArguments,
+  probeNpmVersion: () => probeNpmVersion,
+  projectRootKeyHash: () => projectRootKeyHash,
+  readConfigTiers: () => readConfigTiers,
+  repairRootScopedStorageFile: () => repairRootScopedStorageFile,
+  resolveAftLogPath: () => resolveAftLogPath,
+  resolveAftStorageRoot: () => resolveAftStorageRoot,
+  resolveBashKillTimeout: () => resolveBashKillTimeout,
+  resolveBridgeForNudge: () => resolveBridgeForNudge,
+  resolveCortexKitConfigPaths: () => resolveCortexKitConfigPaths,
+  resolveCortexKitProjectConfigPath: () => resolveCortexKitProjectConfigPath,
+  resolveCortexKitStorageRoot: () => resolveCortexKitStorageRoot,
+  resolveCortexKitUserConfigPath: () => resolveCortexKitUserConfigPath,
+  resolveHarnessStoragePath: () => resolveHarnessStoragePath,
+  resolveLegacyAftConfigSources: () => resolveLegacyAftConfigSources,
+  resolveLegacyStorageRoot: () => resolveLegacyStorageRoot,
+  resolveNpm: () => resolveNpm,
+  runBashHostFallback: () => runBashHostFallback,
+  setActiveLogger: () => setActiveLogger,
+  shouldShowAnnouncement: () => shouldShowAnnouncement,
+  sleep: () => sleep,
+  stripHarnessSpecificConfigKeys: () => stripHarnessSpecificConfigKeys,
+  stripJsoncSymbols: () => stripJsoncSymbols,
+  tagStderrLine: () => tagStderrLine,
+  timeoutForCommand: () => timeoutForCommand,
+  toolErrorFromResponse: () => toolErrorFromResponse,
+  unwrapRustZoomBatchEnvelope: () => unwrapRustZoomBatchEnvelope
 });
 var init_dist2 = __esm(() => {
   init_active_logger();
@@ -10048,7 +9474,7 @@ function compareVersionLabels(a, b) {
 var init_fs_util = () => {};
 
 // ../../node_modules/.bun/esprima@4.0.1/node_modules/esprima/dist/esprima.js
-var require_esprima = __commonJS((exports, module) => {
+var require_esprima = __commonJS(function(exports, module) {
   (function webpackUniversalModuleDefinition(root, factory) {
     if (typeof exports === "object" && typeof module === "object")
       module.exports = factory();
@@ -16188,7 +15614,7 @@ var require_esprima = __commonJS((exports, module) => {
 });
 
 // ../../node_modules/.bun/array-timsort@1.0.3/node_modules/array-timsort/src/index.js
-var require_src = __commonJS((exports, module) => {
+var require_src = __commonJS(function(exports, module) {
   var DEFAULT_MIN_MERGE = 32;
   var DEFAULT_MIN_GALLOPING = 7;
   var DEFAULT_TMP_STORAGE_LENGTH = 256;
@@ -16831,7 +16257,7 @@ var require_src = __commonJS((exports, module) => {
 });
 
 // ../../node_modules/.bun/comment-json@4.6.2/node_modules/comment-json/src/common.js
-var require_common = __commonJS((exports, module) => {
+var require_common = __commonJS(function(exports, module) {
   var PREFIX_BEFORE = "before";
   var PREFIX_AFTER_PROP = "after-prop";
   var PREFIX_AFTER_COLON = "after-colon";
@@ -17075,7 +16501,7 @@ var require_common = __commonJS((exports, module) => {
 });
 
 // ../../node_modules/.bun/comment-json@4.6.2/node_modules/comment-json/src/array.js
-var require_array = __commonJS((exports, module) => {
+var require_array = __commonJS(function(exports, module) {
   var { sort } = require_src();
   var {
     PROP_SYMBOL_PREFIXES,
@@ -17233,7 +16659,7 @@ var require_array = __commonJS((exports, module) => {
 });
 
 // ../../node_modules/.bun/comment-json@4.6.2/node_modules/comment-json/src/parse.js
-var require_parse = __commonJS((exports, module) => {
+var require_parse = __commonJS(function(exports, module) {
   var esprima = require_esprima();
   var {
     CommentArray
@@ -17558,7 +16984,7 @@ var require_parse = __commonJS((exports, module) => {
 });
 
 // ../../node_modules/.bun/comment-json@4.6.2/node_modules/comment-json/src/stringify.js
-var require_stringify = __commonJS((exports, module) => {
+var require_stringify = __commonJS(function(exports, module) {
   var {
     PREFIX_BEFORE_ALL,
     PREFIX_BEFORE,
@@ -17770,7 +17196,7 @@ var require_stringify = __commonJS((exports, module) => {
 });
 
 // ../../node_modules/.bun/comment-json@4.6.2/node_modules/comment-json/src/index.js
-var require_src2 = __commonJS((exports, module) => {
+var require_src2 = __commonJS(function(exports, module) {
   var { parse, tokenize } = require_parse();
   var stringify = require_stringify();
   var { CommentArray } = require_array();
@@ -18201,7 +17627,8 @@ class OpenCodeAdapter {
       semantic: dirSize(join15(storage, "semantic")),
       backups: dirSize(join15(storage, "backups")),
       url_cache: dirSize(join15(storage, "url_cache")),
-      onnxruntime: dirSize(join15(storage, "onnxruntime"))
+      onnxruntime: dirSize(join15(storage, "onnxruntime")),
+      logs: dirSize(join15(storage, "logs"))
     };
   }
 }
@@ -18219,8 +17646,11 @@ var init_opencode = __esm(() => {
 import { execSync as execSync4, spawnSync as spawnSync4 } from "node:child_process";
 import { existsSync as existsSync13, readFileSync as readFileSync9 } from "node:fs";
 import { homedir as homedir15 } from "node:os";
-import { join as join16 } from "node:path";
+import { join as join16, resolve as resolve8 } from "node:path";
 function getPiAgentDir() {
+  const configuredDir = process.env.PI_CODING_AGENT_DIR?.trim();
+  if (configuredDir)
+    return resolve8(configuredDir);
   const envHome = process.platform === "win32" ? process.env.USERPROFILE : process.env.HOME;
   const home = envHome && envHome.length > 0 ? envHome : homedir15();
   return join16(home, ".pi", "agent");
@@ -18234,7 +17664,14 @@ function readPiExtensionIndex() {
       const value = JSON.parse(trimmed);
       const packages = value.packages;
       if (Array.isArray(packages)) {
-        const installed = packages.filter((p) => typeof p === "string");
+        const installed = packages.flatMap((p) => {
+          if (typeof p === "string")
+            return [p];
+          if (typeof p === "object" && p !== null && typeof p.source === "string") {
+            return [p.source];
+          }
+          return [];
+        });
         return { installed, path: settingsPath };
       }
     } catch {}
@@ -18383,6 +17820,7 @@ class PiAdapter {
   }
   getPluginCacheInfo() {
     const candidates = [
+      join16(getPiAgentDir(), "npm", "node_modules", "@cortexkit", "aft-pi", "package.json"),
       join16(getPiAgentDir(), "node_modules", "@cortexkit", "aft-pi", "package.json"),
       join16(getPiAgentDir(), "extensions", "node_modules", "@cortexkit", "aft-pi", "package.json")
     ];
@@ -18401,7 +17839,7 @@ class PiAdapter {
       } catch {}
     }
     return {
-      path: join16(getPiAgentDir(), "extensions"),
+      path: join16(getPiAgentDir(), "npm", "node_modules", "@cortexkit", "aft-pi", "package.json"),
       exists: false
     };
   }
@@ -18427,7 +17865,8 @@ class PiAdapter {
       semantic: dirSize(join16(storage, "semantic")),
       backups: dirSize(join16(storage, "backups")),
       url_cache: dirSize(join16(storage, "url_cache")),
-      onnxruntime: dirSize(join16(storage, "onnxruntime"))
+      onnxruntime: dirSize(join16(storage, "onnxruntime")),
+      logs: dirSize(join16(storage, "logs"))
     };
   }
 }
@@ -18800,7 +18239,7 @@ var init_main = __esm(() => {
 });
 
 // ../../node_modules/.bun/sisteransi@1.0.5/node_modules/sisteransi/src/index.js
-var require_src3 = __commonJS((exports, module) => {
+var require_src3 = __commonJS(function(exports, module) {
   var ESC2 = "\x1B";
   var CSI2 = `${ESC2}[`;
   var beep = "\x07";
@@ -18867,25 +18306,6 @@ function findCursor(s, o, l) {
   const t = s + o, n = Math.max(l.length - 1, 0), e = t < 0 ? n : t > n ? 0 : t;
   return l[e].disabled ? findCursor(e, o < 0 ? -1 : 1, l) : e;
 }
-function findTextCursor(s, o, l, i) {
-  const t = i.split(`
-`);
-  let n = 0, e = s;
-  for (const r of t) {
-    if (e <= r.length)
-      break;
-    e -= r.length + 1, n++;
-  }
-  for (n = Math.max(0, Math.min(t.length - 1, n + l)), e = Math.min(e, t[n].length) + o;e < 0 && n > 0; )
-    n--, e += t[n].length + 1;
-  for (;e > t[n].length && n < t.length - 1; )
-    e -= t[n].length + 1, n++;
-  e = Math.max(0, Math.min(t[n].length, e));
-  let h = 0;
-  for (let r = 0;r < n; r++)
-    h += t[r].length + 1;
-  return h + e;
-}
 function isActionKey(n, e) {
   if (typeof n == "string")
     return settings.aliases.get(n) === e;
@@ -19077,77 +18497,7 @@ class V {
     }
   }
 }
-function p$1(l, e) {
-  if (l === undefined || e.length === 0)
-    return 0;
-  const i = e.findIndex((s) => s.value === l);
-  return i !== -1 ? i : 0;
-}
-function g(l, e) {
-  return (e.label ?? String(e.value)).toLowerCase().includes(l.toLowerCase());
-}
-function m(l, e) {
-  if (e)
-    return l ? e : e[0];
-}
-function M(r2) {
-  return [...r2].map((t2) => _[t2]);
-}
-function P(r2) {
-  const i = new Intl.DateTimeFormat(r2, {
-    year: "numeric",
-    month: "2-digit",
-    day: "2-digit"
-  }).formatToParts(new Date(2000, 0, 15)), s = [];
-  let n = "/";
-  for (const e of i)
-    e.type === "literal" ? n = e.value.trim() || e.value : (e.type === "year" || e.type === "month" || e.type === "day") && s.push({ type: e.type, len: e.type === "year" ? 4 : 2 });
-  return { segments: s, separator: n };
-}
-function p(r2) {
-  return Number.parseInt((r2 || "0").replace(/_/g, "0"), 10) || 0;
-}
-function f(r2) {
-  return {
-    year: p(r2.year),
-    month: p(r2.month),
-    day: p(r2.day)
-  };
-}
-function c(r2, t2) {
-  return new Date(r2 || 2001, t2 || 1, 0).getDate();
-}
-function b(r2) {
-  const { year: t2, month: i, day: s } = f(r2);
-  if (!t2 || t2 < 0 || t2 > 9999 || !i || i < 1 || i > 12 || !s || s < 1)
-    return;
-  const n = new Date(Date.UTC(t2, i - 1, s));
-  if (!(n.getUTCFullYear() !== t2 || n.getUTCMonth() !== i - 1 || n.getUTCDate() !== s))
-    return { year: t2, month: i, day: s };
-}
-function C(r2) {
-  const t2 = b(r2);
-  return t2 ? new Date(Date.UTC(t2.year, t2.month - 1, t2.day)) : undefined;
-}
-function T2(r2, t2, i, s) {
-  const n = i ? {
-    year: i.getUTCFullYear(),
-    month: i.getUTCMonth() + 1,
-    day: i.getUTCDate()
-  } : null, e = s ? {
-    year: s.getUTCFullYear(),
-    month: s.getUTCMonth() + 1,
-    day: s.getUTCDate()
-  } : null;
-  return r2 === "year" ? { min: n?.year ?? 1, max: e?.year ?? 9999 } : r2 === "month" ? {
-    min: n && t2.year === n.year ? n.month : 1,
-    max: e && t2.year === e.year ? e.month : 12
-  } : {
-    min: n && t2.year === n.year && t2.month === n.month ? n.day : 1,
-    max: e && t2.year === e.year && t2.month === e.month ? e.day : c(t2.year, t2.month)
-  };
-}
-var import_sisteransi, a$2, t, settings, R, CANCEL_SYMBOL, getColumns = (e) => ("columns" in e) && typeof e.columns == "number" ? e.columns : 80, getRows = (e) => ("rows" in e) && typeof e.rows == "number" ? e.rows : 20, T$1, r, _, U, u$1, o$1, h, a$1, a2, n;
+var import_sisteransi, a$2, t, settings, R, CANCEL_SYMBOL, getColumns = (e) => ("columns" in e) && typeof e.columns == "number" ? e.columns : 80, getRows = (e) => ("rows" in e) && typeof e.rows == "number" ? e.rows : 20, r, a$1, a2, n;
 var init_dist5 = __esm(() => {
   init_main();
   import_sisteransi = __toESM(require_src3(), 1);
@@ -19194,72 +18544,6 @@ var init_dist5 = __esm(() => {
   };
   R = globalThis.process.platform.startsWith("win");
   CANCEL_SYMBOL = Symbol("clack:cancel");
-  T$1 = class T extends V {
-    filteredOptions;
-    multiple;
-    isNavigating = false;
-    selectedValues = [];
-    focusedValue;
-    #e = 0;
-    #s = "";
-    #t;
-    #i;
-    #n;
-    get cursor() {
-      return this.#e;
-    }
-    get userInputWithCursor() {
-      if (!this.userInput)
-        return styleText(["inverse", "hidden"], "_");
-      if (this._cursor >= this.userInput.length)
-        return `${this.userInput}█`;
-      const e = this.userInput.slice(0, this._cursor), [t2, ...i] = this.userInput.slice(this._cursor);
-      return `${e}${styleText("inverse", t2)}${i.join("")}`;
-    }
-    get options() {
-      return typeof this.#i == "function" ? this.#i() : this.#i;
-    }
-    constructor(e) {
-      super(e), this.#i = e.options, this.#n = e.placeholder;
-      const t2 = this.options;
-      this.filteredOptions = [...t2], this.multiple = e.multiple === true, this.#t = typeof e.options == "function" ? e.filter : e.filter ?? g;
-      let i;
-      if (e.initialValue && Array.isArray(e.initialValue) ? this.multiple ? i = e.initialValue : i = e.initialValue.slice(0, 1) : !this.multiple && this.options.length > 0 && (i = [this.options[0].value]), i)
-        for (const s of i) {
-          const n = t2.findIndex((o) => o.value === s);
-          n !== -1 && (this.toggleSelected(s), this.#e = n);
-        }
-      this.focusedValue = this.options[this.#e]?.value, this.on("key", (s, n) => this.#l(s, n)), this.on("userInput", (s) => this.#u(s));
-    }
-    _isActionKey(e, t2) {
-      return e === "\t" || this.multiple && this.isNavigating && t2.name === "space" && e !== undefined && e !== "";
-    }
-    #l(e, t2) {
-      const i = t2.name === "up", s = t2.name === "down", n = t2.name === "return", o = this.userInput === "" || this.userInput === "\t", u = this.#n, h = this.options, f = u !== undefined && u !== "" && h.some((r) => !r.disabled && (this.#t ? this.#t(u, r) : true));
-      if (t2.name === "tab" && o && f) {
-        this.userInput === "\t" && this._clearUserInput(), this._setUserInput(u, true), this.isNavigating = false;
-        return;
-      }
-      i || s ? (this.#e = findCursor(this.#e, i ? -1 : 1, this.filteredOptions), this.focusedValue = this.filteredOptions[this.#e]?.value, this.multiple || (this.selectedValues = [this.focusedValue]), this.isNavigating = true) : n ? this.value = m(this.multiple, this.selectedValues) : this.multiple ? this.focusedValue !== undefined && (t2.name === "tab" || this.isNavigating && t2.name === "space") ? this.toggleSelected(this.focusedValue) : this.isNavigating = false : (this.focusedValue && (this.selectedValues = [this.focusedValue]), this.isNavigating = false);
-    }
-    deselectAll() {
-      this.selectedValues = [];
-    }
-    toggleSelected(e) {
-      this.filteredOptions.length !== 0 && (this.multiple ? this.selectedValues.includes(e) ? this.selectedValues = this.selectedValues.filter((t2) => t2 !== e) : this.selectedValues = [...this.selectedValues, e] : this.selectedValues = [e]);
-    }
-    #u(e) {
-      if (e !== this.#s) {
-        this.#s = e;
-        const t2 = this.options;
-        e && this.#t ? this.filteredOptions = t2.filter((n) => this.#t?.(e, n)) : this.filteredOptions = [...t2];
-        const i = p$1(this.focusedValue, this.filteredOptions);
-        this.#e = findCursor(i, 0, this.filteredOptions);
-        const s = this.filteredOptions[this.#e];
-        s && !s.disabled ? this.focusedValue = s.value : this.focusedValue = undefined, this.multiple || (this.focusedValue !== undefined ? this.toggleSelected(this.focusedValue) : this.deselectAll());
-      }
-    }
-  };
   r = class r extends V {
     get cursor() {
       return this.value ? 0 : 1;
@@ -19277,304 +18561,6 @@ var init_dist5 = __esm(() => {
       });
     }
   };
-  _ = {
-    Y: { type: "year", len: 4 },
-    M: { type: "month", len: 2 },
-    D: { type: "day", len: 2 }
-  };
-  U = class U extends V {
-    #i;
-    #o;
-    #t;
-    #h;
-    #u;
-    #e = { segmentIndex: 0, positionInSegment: 0 };
-    #n = true;
-    #s = null;
-    inlineError = "";
-    get segmentCursor() {
-      return { ...this.#e };
-    }
-    get segmentValues() {
-      return { ...this.#t };
-    }
-    get segments() {
-      return this.#i;
-    }
-    get separator() {
-      return this.#o;
-    }
-    get formattedValue() {
-      return this.#l(this.#t);
-    }
-    #l(t2) {
-      return this.#i.map((i) => t2[i.type]).join(this.#o);
-    }
-    #r() {
-      this._setUserInput(this.#l(this.#t)), this._setValue(C(this.#t) ?? undefined);
-    }
-    constructor(t2) {
-      const i = t2.format ? { segments: M(t2.format), separator: t2.separator ?? "/" } : P(t2.locale), s = t2.separator ?? i.separator, n = t2.format ? M(t2.format) : i.segments, e = t2.initialValue ?? t2.defaultValue, m2 = e ? {
-        year: String(e.getUTCFullYear()).padStart(4, "0"),
-        month: String(e.getUTCMonth() + 1).padStart(2, "0"),
-        day: String(e.getUTCDate()).padStart(2, "0")
-      } : { year: "____", month: "__", day: "__" }, o = n.map((a) => m2[a.type]).join(s);
-      super({ ...t2, initialUserInput: o }, false), this.#i = n, this.#o = s, this.#t = m2, this.#h = t2.minDate, this.#u = t2.maxDate, this.#r(), this.on("cursor", (a) => this.#f(a)), this.on("key", (a, u) => this.#y(a, u)), this.on("finalize", () => this.#p(t2));
-    }
-    #a() {
-      const t2 = Math.max(0, Math.min(this.#e.segmentIndex, this.#i.length - 1)), i = this.#i[t2];
-      if (i)
-        return this.#e.positionInSegment = Math.max(0, Math.min(this.#e.positionInSegment, i.len - 1)), { segment: i, index: t2 };
-    }
-    #m(t2) {
-      this.inlineError = "", this.#s = null;
-      const i = this.#a();
-      i && (this.#e.segmentIndex = Math.max(0, Math.min(this.#i.length - 1, i.index + t2)), this.#e.positionInSegment = 0, this.#n = true);
-    }
-    #d(t2) {
-      const i = this.#a();
-      if (!i)
-        return;
-      const { segment: s } = i, n = this.#t[s.type], e = !n || n.replace(/_/g, "") === "", m2 = Number.parseInt((n || "0").replace(/_/g, "0"), 10) || 0, o = T2(s.type, f(this.#t), this.#h, this.#u);
-      let a;
-      e ? a = t2 === 1 ? o.min : o.max : a = Math.max(Math.min(o.max, m2 + t2), o.min), this.#t = {
-        ...this.#t,
-        [s.type]: a.toString().padStart(s.len, "0")
-      }, this.#n = true, this.#s = null, this.#r();
-    }
-    #f(t2) {
-      if (t2)
-        switch (t2) {
-          case "right":
-            return this.#m(1);
-          case "left":
-            return this.#m(-1);
-          case "up":
-            return this.#d(1);
-          case "down":
-            return this.#d(-1);
-        }
-    }
-    #y(t2, i) {
-      if (i?.name === "backspace" || i?.sequence === "" || i?.sequence === "\b" || t2 === "" || t2 === "\b") {
-        this.inlineError = "";
-        const n = this.#a();
-        if (!n)
-          return;
-        if (!this.#t[n.segment.type].replace(/_/g, "")) {
-          this.#m(-1);
-          return;
-        }
-        this.#t[n.segment.type] = "_".repeat(n.segment.len), this.#n = true, this.#e.positionInSegment = 0, this.#r();
-        return;
-      }
-      if (i?.name === "tab") {
-        this.inlineError = "";
-        const n = this.#a();
-        if (!n)
-          return;
-        const e = i.shift ? -1 : 1, m2 = n.index + e;
-        m2 >= 0 && m2 < this.#i.length && (this.#e.segmentIndex = m2, this.#e.positionInSegment = 0, this.#n = true);
-        return;
-      }
-      if (t2 && /^[0-9]$/.test(t2)) {
-        const n = this.#a();
-        if (!n)
-          return;
-        const { segment: e } = n, m2 = !this.#t[e.type].replace(/_/g, "");
-        if (this.#n && this.#s !== null && !m2) {
-          const h = this.#s + t2, d = { ...this.#t, [e.type]: h }, g2 = this.#g(d, e);
-          if (g2) {
-            this.inlineError = g2, this.#s = null, this.#n = false;
-            return;
-          }
-          this.inlineError = "", this.#t[e.type] = h, this.#s = null, this.#n = false, this.#r(), n.index < this.#i.length - 1 && (this.#e.segmentIndex = n.index + 1, this.#e.positionInSegment = 0, this.#n = true);
-          return;
-        }
-        this.#n && !m2 && (this.#t[e.type] = "_".repeat(e.len), this.#e.positionInSegment = 0), this.#n = false, this.#s = null;
-        const o = this.#t[e.type], a = o.indexOf("_"), u = a >= 0 ? a : Math.min(this.#e.positionInSegment, e.len - 1);
-        if (u < 0 || u >= e.len)
-          return;
-        let l = o.slice(0, u) + t2 + o.slice(u + 1), D = false;
-        if (u === 0 && o === "__" && (e.type === "month" || e.type === "day")) {
-          const h = Number.parseInt(t2, 10);
-          l = `0${t2}`, D = h <= (e.type === "month" ? 1 : 2);
-        }
-        if (e.type === "year" && (l = (o.replace(/_/g, "") + t2).padStart(e.len, "_")), !l.includes("_")) {
-          const h = { ...this.#t, [e.type]: l }, d = this.#g(h, e);
-          if (d) {
-            this.inlineError = d;
-            return;
-          }
-        }
-        this.inlineError = "", this.#t[e.type] = l;
-        const y = l.includes("_") ? undefined : b(this.#t);
-        if (y) {
-          const { year: h, month: d } = y, g2 = c(h, d);
-          this.#t = {
-            year: String(Math.max(0, Math.min(9999, h))).padStart(4, "0"),
-            month: String(Math.max(1, Math.min(12, d))).padStart(2, "0"),
-            day: String(Math.max(1, Math.min(g2, y.day))).padStart(2, "0")
-          };
-        }
-        this.#r();
-        const S = l.indexOf("_");
-        D ? (this.#n = true, this.#s = t2) : S >= 0 ? this.#e.positionInSegment = S : a >= 0 && n.index < this.#i.length - 1 ? (this.#e.segmentIndex = n.index + 1, this.#e.positionInSegment = 0, this.#n = true) : this.#e.positionInSegment = Math.min(u + 1, e.len - 1);
-      }
-    }
-    #g(t2, i) {
-      const { month: s, day: n } = f(t2);
-      if (i.type === "month" && (s < 0 || s > 12))
-        return settings.date.messages.invalidMonth;
-      if (i.type === "day" && (n < 0 || n > 31))
-        return settings.date.messages.invalidDay(31, "any month");
-    }
-    #p(t2) {
-      const { year: i, month: s, day: n } = f(this.#t);
-      if (i && s && n) {
-        const e = c(i, s);
-        this.#t = {
-          ...this.#t,
-          day: String(Math.min(n, e)).padStart(2, "0")
-        };
-      }
-      this.value = C(this.#t) ?? t2.defaultValue ?? undefined;
-    }
-  };
-  u$1 = class u extends V {
-    options;
-    cursor = 0;
-    #t;
-    getGroupItems(t2) {
-      return this.options.filter((r2) => r2.group === t2);
-    }
-    isGroupSelected(t2) {
-      const r2 = this.getGroupItems(t2), e = this.value;
-      return e === undefined ? false : r2.every((s) => e.includes(s.value));
-    }
-    toggleValue() {
-      const t2 = this.options[this.cursor];
-      if (this.value === undefined && (this.value = []), t2.group === true) {
-        const r2 = t2.value, e = this.getGroupItems(r2);
-        this.isGroupSelected(r2) ? this.value = this.value.filter((s) => e.findIndex((i) => i.value === s) === -1) : this.value = [...this.value, ...e.map((s) => s.value)], this.value = Array.from(new Set(this.value));
-      } else {
-        const r2 = this.value.includes(t2.value);
-        this.value = r2 ? this.value.filter((e) => e !== t2.value) : [...this.value, t2.value];
-      }
-    }
-    constructor(t2) {
-      super(t2, false);
-      const { options: r2 } = t2;
-      this.#t = t2.selectableGroups !== false, this.options = Object.entries(r2).flatMap(([e, s]) => [
-        { value: e, group: true, label: e },
-        ...s.map((i) => ({ ...i, group: e }))
-      ]), this.value = [...t2.initialValues ?? []], this.cursor = Math.max(this.options.findIndex(({ value: e }) => e === t2.cursorAt), this.#t ? 0 : 1), this.on("cursor", (e) => {
-        switch (e) {
-          case "left":
-          case "up": {
-            this.cursor = this.cursor === 0 ? this.options.length - 1 : this.cursor - 1;
-            const s = this.options[this.cursor]?.group === true;
-            !this.#t && s && (this.cursor = this.cursor === 0 ? this.options.length - 1 : this.cursor - 1);
-            break;
-          }
-          case "down":
-          case "right": {
-            this.cursor = this.cursor === this.options.length - 1 ? 0 : this.cursor + 1;
-            const s = this.options[this.cursor]?.group === true;
-            !this.#t && s && (this.cursor = this.cursor === this.options.length - 1 ? 0 : this.cursor + 1);
-            break;
-          }
-          case "space":
-            this.toggleValue();
-            break;
-        }
-      });
-    }
-  };
-  o$1 = /* @__PURE__ */ new Set(["up", "down", "left", "right"]);
-  h = class h extends V {
-    #t = false;
-    #s;
-    focused = "editor";
-    get userInputWithCursor() {
-      if (this.state === "submit")
-        return this.userInput;
-      const t2 = this.userInput;
-      if (this.cursor >= t2.length)
-        return `${t2}█`;
-      const s = t2.slice(0, this.cursor), r2 = t2[this.cursor], i = t2.slice(this.cursor + 1);
-      return r2 === `
-` ? `${s}█
-${i}` : `${s}${styleText("inverse", r2)}${i}`;
-    }
-    get cursor() {
-      return this._cursor;
-    }
-    #r(t2) {
-      if (this.userInput.length === 0) {
-        this._setUserInput(t2);
-        return;
-      }
-      this._setUserInput(this.userInput.slice(0, this.cursor) + t2 + this.userInput.slice(this.cursor));
-    }
-    #i(t2) {
-      const s = this.value ?? "";
-      switch (t2) {
-        case "up":
-          this._cursor = findTextCursor(this._cursor, 0, -1, s);
-          return;
-        case "down":
-          this._cursor = findTextCursor(this._cursor, 0, 1, s);
-          return;
-        case "left":
-          this._cursor = findTextCursor(this._cursor, -1, 0, s);
-          return;
-        case "right":
-          this._cursor = findTextCursor(this._cursor, 1, 0, s);
-          return;
-      }
-    }
-    _shouldSubmit(t2, s) {
-      if (this.#s)
-        return this.focused === "submit" ? true : (this.#r(`
-`), this._cursor++, false);
-      const r2 = this.#t;
-      return this.#t = true, r2 && this.cursor === this.userInput.length ? (this.userInput[this.cursor - 1] === `
-` && (this._setUserInput(this.userInput.slice(0, this.cursor - 1) + this.userInput.slice(this.cursor)), this._cursor--), true) : (this.#r(`
-`), this._cursor++, false);
-    }
-    constructor(t2) {
-      const s = t2.initialUserInput ?? t2.initialValue;
-      super({
-        ...t2,
-        initialUserInput: s
-      }, false), s !== undefined && (this._cursor = s.length), this.#s = t2.showSubmit ?? false, this.on("key", (r2, i) => {
-        if (i?.name && o$1.has(i.name)) {
-          this.#t = false, this.#i(i.name);
-          return;
-        }
-        if (r2 === "\t" && this.#s) {
-          this.focused = this.focused === "editor" ? "submit" : "editor";
-          return;
-        }
-        if (i?.name !== "return") {
-          if (this.#t = false, i?.name === "backspace" && this.cursor > 0) {
-            this._setUserInput(this.userInput.slice(0, this.cursor - 1) + this.userInput.slice(this.cursor)), this._cursor--;
-            return;
-          }
-          if (i?.name === "delete" && this.cursor < this.userInput.length) {
-            this._setUserInput(this.userInput.slice(0, this.cursor) + this.userInput.slice(this.cursor + 1));
-            return;
-          }
-          r2 && (this.#s && this.focused === "submit" && (this.focused = "editor"), this.#r(r2 ?? ""), this._cursor++);
-        }
-      }), this.on("userInput", (r2) => {
-        this._setValue(r2);
-      }), this.on("finalize", () => {
-        this.value || (this.value = t2.defaultValue), this.value === undefined && (this.value = "");
-      });
-    }
-  };
   a$1 = class a extends V {
     options;
     cursor = 0;
@@ -19712,34 +18698,34 @@ var import_sisteransi2, unicode, unicodeOr = (o2, e) => unicode ? o2 : e, S_STEP
     case "submit":
       return styleText2("green", S_BAR);
   }
-}, E$1 = (l, o2, g2, c2, h2, O = false) => {
+}, E$1 = (l, o2, g, c, h2, O = false) => {
   let r2 = o2, w = 0;
   if (O)
-    for (let i = c2 - 1;i >= g2 && (r2 -= l[i].length, w++, !(r2 <= h2)); i--)
+    for (let i = c - 1;i >= g && (r2 -= l[i].length, w++, !(r2 <= h2)); i--)
       ;
   else
-    for (let i = g2;i < c2 && (r2 -= l[i].length, w++, !(r2 <= h2)); i++)
+    for (let i = g;i < c && (r2 -= l[i].length, w++, !(r2 <= h2)); i++)
       ;
   return { lineCount: r2, removals: w };
 }, limitOptions = ({
   cursor: l,
   options: o2,
-  style: g2,
-  output: c2 = process.stdout,
+  style: g,
+  output: c = process.stdout,
   maxItems: h2 = Number.POSITIVE_INFINITY,
   columnPadding: O = 0,
   rowPadding: r2 = 4
 }) => {
-  const i = getColumns(c2) - O, I = getRows(c2), C2 = styleText2("dim", "..."), x = Math.max(I - r2, 0), m2 = Math.max(Math.min(h2, x), 5);
-  let p2 = 0;
-  l >= m2 - 3 && (p2 = Math.max(Math.min(l - m2 + 3, o2.length - m2), 0));
-  let f2 = m2 < o2.length && p2 > 0, u3 = m2 < o2.length && p2 + m2 < o2.length;
-  const W = Math.min(p2 + m2, o2.length), e = [];
+  const i = getColumns(c) - O, I = getRows(c), C = styleText2("dim", "..."), x = Math.max(I - r2, 0), m = Math.max(Math.min(h2, x), 5);
+  let p = 0;
+  l >= m - 3 && (p = Math.max(Math.min(l - m + 3, o2.length - m), 0));
+  let f = m < o2.length && p > 0, u2 = m < o2.length && p + m < o2.length;
+  const W = Math.min(p + m, o2.length), e = [];
   let d = 0;
-  f2 && d++, u3 && d++;
-  const v = p2 + (f2 ? 1 : 0), P2 = W - (u3 ? 1 : 0);
-  for (let t2 = v;t2 < P2; t2++) {
-    const n2 = wrapAnsi(g2(o2[t2], t2 === l), i, {
+  f && d++, u2 && d++;
+  const v = p + (f ? 1 : 0), P = W - (u2 ? 1 : 0);
+  for (let t2 = v;t2 < P; t2++) {
+    const n2 = wrapAnsi(g(o2[t2], t2 === l), i, {
       hard: true,
       trim: false
     }).split(`
@@ -19748,17 +18734,17 @@ var import_sisteransi2, unicode, unicodeOr = (o2, e) => unicode ? o2 : e, S_STEP
   }
   if (d > x) {
     let t2 = 0, n2 = 0, s = d;
-    const M2 = l - v;
+    const M = l - v;
     let a3 = x;
-    const T3 = () => E$1(e, s, 0, M2, a3), L = () => E$1(e, s, M2 + 1, e.length, a3, true);
-    f2 ? ({ lineCount: s, removals: t2 } = T3(), s > a3 && (u3 || (a3 -= 1), { lineCount: s, removals: n2 } = L())) : (u3 || (a3 -= 1), { lineCount: s, removals: n2 } = L(), s > a3 && (a3 -= 1, { lineCount: s, removals: t2 } = T3())), t2 > 0 && (f2 = true, e.splice(0, t2)), n2 > 0 && (u3 = true, e.splice(e.length - n2, n2));
+    const T = () => E$1(e, s, 0, M, a3), L = () => E$1(e, s, M + 1, e.length, a3, true);
+    f ? ({ lineCount: s, removals: t2 } = T(), s > a3 && (u2 || (a3 -= 1), { lineCount: s, removals: n2 } = L())) : (u2 || (a3 -= 1), { lineCount: s, removals: n2 } = L(), s > a3 && (a3 -= 1, { lineCount: s, removals: t2 } = T())), t2 > 0 && (f = true, e.splice(0, t2)), n2 > 0 && (u2 = true, e.splice(e.length - n2, n2));
   }
-  const b2 = [];
-  f2 && b2.push(C2);
+  const b = [];
+  f && b.push(C);
   for (const t2 of e)
     for (const n2 of t2)
-      b2.push(n2);
-  return u3 && b2.push(C2), b2;
+      b.push(n2);
+  return u2 && b.push(C), b;
 }, confirm = (i) => {
   const a3 = i.active ?? "Yes", s = i.inactive ?? "No";
   return new r({
@@ -19769,36 +18755,36 @@ var import_sisteransi2, unicode, unicodeOr = (o2, e) => unicode ? o2 : e, S_STEP
     output: i.output,
     initialValue: i.initialValue ?? true,
     render() {
-      const e = i.withGuide ?? settings.withGuide, u3 = `${symbol(this.state)}  `, l = e ? `${styleText2("gray", S_BAR)}  ` : "", f2 = wrapTextWithPrefix(i.output, i.message, l, u3), o2 = `${e ? `${styleText2("gray", S_BAR)}
-` : ""}${f2}
-`, c2 = this.value ? a3 : s;
+      const e = i.withGuide ?? settings.withGuide, u2 = `${symbol(this.state)}  `, l = e ? `${styleText2("gray", S_BAR)}  ` : "", f = wrapTextWithPrefix(i.output, i.message, l, u2), o2 = `${e ? `${styleText2("gray", S_BAR)}
+` : ""}${f}
+`, c = this.value ? a3 : s;
       switch (this.state) {
         case "submit": {
           const r2 = e ? `${styleText2("gray", S_BAR)}  ` : "";
-          return `${o2}${r2}${styleText2("dim", c2)}`;
+          return `${o2}${r2}${styleText2("dim", c)}`;
         }
         case "cancel": {
           const r2 = e ? `${styleText2("gray", S_BAR)}  ` : "";
-          return `${o2}${r2}${styleText2(["strikethrough", "dim"], c2)}${e ? `
+          return `${o2}${r2}${styleText2(["strikethrough", "dim"], c)}${e ? `
 ${styleText2("gray", S_BAR)}` : ""}`;
         }
         default: {
-          const r2 = e ? `${styleText2("cyan", S_BAR)}  ` : "", g2 = e ? styleText2("cyan", S_BAR_END) : "";
+          const r2 = e ? `${styleText2("cyan", S_BAR)}  ` : "", g = e ? styleText2("cyan", S_BAR_END) : "";
           return `${o2}${r2}${this.value ? `${styleText2("green", S_RADIO_ACTIVE)} ${a3}` : `${styleText2("dim", S_RADIO_INACTIVE)} ${styleText2("dim", a3)}`}${i.vertical ? e ? `
 ${styleText2("cyan", S_BAR)}  ` : `
 ` : ` ${styleText2("dim", "/")} `}${this.value ? `${styleText2("dim", S_RADIO_INACTIVE)} ${styleText2("dim", s)}` : `${styleText2("green", S_RADIO_ACTIVE)} ${s}`}
-${g2}
+${g}
 `;
         }
       }
     }
   }).prompt();
-}, MULTISELECT_INSTRUCTIONS, m2 = (n2, o2) => n2.split(`
+}, MULTISELECT_INSTRUCTIONS, m = (n2, o2) => n2.split(`
 `).map((d) => o2(d)).join(`
 `), multiselect = (n2) => {
   const o2 = (t2, a3) => {
     const r2 = t2.label ?? String(t2.value);
-    return a3 === "disabled" ? `${styleText2("gray", S_CHECKBOX_INACTIVE)} ${m2(r2, (l) => styleText2(["strikethrough", "gray"], l))}${t2.hint ? ` ${styleText2("dim", `(${t2.hint ?? "disabled"})`)}` : ""}` : a3 === "active" ? `${styleText2("cyan", S_CHECKBOX_ACTIVE)} ${r2}${t2.hint ? ` ${styleText2("dim", `(${t2.hint})`)}` : ""}` : a3 === "selected" ? `${styleText2("green", S_CHECKBOX_SELECTED)} ${m2(r2, (l) => styleText2("dim", l))}${t2.hint ? ` ${styleText2("dim", `(${t2.hint})`)}` : ""}` : a3 === "cancelled" ? `${m2(r2, (l) => styleText2(["strikethrough", "dim"], l))}` : a3 === "active-selected" ? `${styleText2("green", S_CHECKBOX_SELECTED)} ${r2}${t2.hint ? ` ${styleText2("dim", `(${t2.hint})`)}` : ""}` : a3 === "submitted" ? `${m2(r2, (l) => styleText2("dim", l))}` : `${styleText2("dim", S_CHECKBOX_INACTIVE)} ${m2(r2, (l) => styleText2("dim", l))}`;
+    return a3 === "disabled" ? `${styleText2("gray", S_CHECKBOX_INACTIVE)} ${m(r2, (l) => styleText2(["strikethrough", "gray"], l))}${t2.hint ? ` ${styleText2("dim", `(${t2.hint ?? "disabled"})`)}` : ""}` : a3 === "active" ? `${styleText2("cyan", S_CHECKBOX_ACTIVE)} ${r2}${t2.hint ? ` ${styleText2("dim", `(${t2.hint})`)}` : ""}` : a3 === "selected" ? `${styleText2("green", S_CHECKBOX_SELECTED)} ${m(r2, (l) => styleText2("dim", l))}${t2.hint ? ` ${styleText2("dim", `(${t2.hint})`)}` : ""}` : a3 === "cancelled" ? `${m(r2, (l) => styleText2(["strikethrough", "dim"], l))}` : a3 === "active-selected" ? `${styleText2("green", S_CHECKBOX_SELECTED)} ${r2}${t2.hint ? ` ${styleText2("dim", `(${t2.hint})`)}` : ""}` : a3 === "submitted" ? `${m(r2, (l) => styleText2("dim", l))}` : `${styleText2("dim", S_CHECKBOX_INACTIVE)} ${m(r2, (l) => styleText2("dim", l))}`;
   }, d = n2.required ?? true;
   return new a$1({
     options: n2.options,
@@ -19816,30 +18802,30 @@ ${styleText2("reset", styleText2("dim", `Press ${styleText2(["gray", "bgWhite",
     render() {
       const t2 = n2.withGuide ?? settings.withGuide, a3 = wrapTextWithPrefix(n2.output, n2.message, t2 ? `${symbolBar(this.state)}  ` : "", `${symbol(this.state)}  `), r2 = `${t2 ? `${styleText2("gray", S_BAR)}
 ` : ""}${a3}
-`, l = this.value ?? [], p2 = (i, u3) => {
+`, l = this.value ?? [], p = (i, u2) => {
         if (i.disabled)
           return o2(i, "disabled");
         const s = l.includes(i.value);
-        return u3 && s ? o2(i, "active-selected") : s ? o2(i, "selected") : o2(i, u3 ? "active" : "inactive");
+        return u2 && s ? o2(i, "active-selected") : s ? o2(i, "selected") : o2(i, u2 ? "active" : "inactive");
       };
       switch (this.state) {
         case "submit": {
-          const i = this.options.filter(({ value: s }) => l.includes(s)).map((s) => o2(s, "submitted")).join(styleText2("dim", ", ")) || styleText2("dim", "none"), u3 = wrapTextWithPrefix(n2.output, i, t2 ? `${styleText2("gray", S_BAR)}  ` : "");
-          return `${r2}${u3}`;
+          const i = this.options.filter(({ value: s }) => l.includes(s)).map((s) => o2(s, "submitted")).join(styleText2("dim", ", ")) || styleText2("dim", "none"), u2 = wrapTextWithPrefix(n2.output, i, t2 ? `${styleText2("gray", S_BAR)}  ` : "");
+          return `${r2}${u2}`;
         }
         case "cancel": {
           const i = this.options.filter(({ value: s }) => l.includes(s)).map((s) => o2(s, "cancelled")).join(styleText2("dim", ", "));
           if (i.trim() === "")
             return `${r2}${styleText2("gray", S_BAR)}`;
-          const u3 = wrapTextWithPrefix(n2.output, i, t2 ? `${styleText2("gray", S_BAR)}  ` : "");
-          return `${r2}${u3}${t2 ? `
+          const u2 = wrapTextWithPrefix(n2.output, i, t2 ? `${styleText2("gray", S_BAR)}  ` : "");
+          return `${r2}${u2}${t2 ? `
 ${styleText2("gray", S_BAR)}` : ""}`;
         }
         case "error": {
-          const i = t2 ? `${styleText2("yellow", S_BAR)}  ` : "", u3 = this.error.split(`
+          const i = t2 ? `${styleText2("yellow", S_BAR)}  ` : "", u2 = this.error.split(`
 `).map(($, x) => x === 0 ? `${t2 ? `${styleText2("yellow", S_BAR_END)}  ` : ""}${styleText2("yellow", $)}` : `   ${$}`).join(`
 `), s = r2.split(`
-`).length, g2 = u3.split(`
+`).length, g = u2.split(`
 `).length + 1;
           return `${r2}${i}${limitOptions({
             output: n2.output,
@@ -19847,16 +18833,16 @@ ${styleText2("gray", S_BAR)}` : ""}`;
             cursor: this.cursor,
             maxItems: n2.maxItems,
             columnPadding: i.length,
-            rowPadding: s + g2,
-            style: p2
+            rowPadding: s + g,
+            style: p
           }).join(`
 ${i}`)}
-${u3}
+${u2}
 `;
         }
         default: {
-          const i = t2 ? `${styleText2("cyan", S_BAR)}  ` : "", u3 = r2.split(`
-`).length, s = formatInstructionFooter(MULTISELECT_INSTRUCTIONS, t2), g2 = s.join(`
+          const i = t2 ? `${styleText2("cyan", S_BAR)}  ` : "", u2 = r2.split(`
+`).length, s = formatInstructionFooter(MULTISELECT_INSTRUCTIONS, t2), g = s.join(`
 `), $ = s.length + 1;
           return `${r2}${i}${limitOptions({
             output: n2.output,
@@ -19864,11 +18850,11 @@ ${u3}
             cursor: this.cursor,
             maxItems: n2.maxItems,
             columnPadding: i.length,
-            rowPadding: u3 + $,
-            style: p2
+            rowPadding: u2 + $,
+            style: p
           }).join(`
 ${i}`)}
-${g2}
+${g}
 `;
         }
       }
@@ -19884,42 +18870,42 @@ ${styleText2("gray", S_BAR_END)}  ` : "";
   i.write(`${e}${o2}
 
 `);
-}, W$1 = (o2) => o2, C2 = (o2, e, s) => {
+}, W$1 = (o2) => o2, C = (o2, e, s) => {
   const a3 = {
     hard: true,
     trim: false
   }, i = wrapAnsi(o2, e, a3).split(`
-`), c2 = i.reduce((n2, t2) => Math.max(dist_default2(t2), n2), 0), u3 = i.map(s).reduce((n2, t2) => Math.max(dist_default2(t2), n2), 0), g2 = e - (u3 - c2);
-  return wrapAnsi(o2, g2, a3);
+`), c = i.reduce((n2, t2) => Math.max(dist_default2(t2), n2), 0), u2 = i.map(s).reduce((n2, t2) => Math.max(dist_default2(t2), n2), 0), g = e - (u2 - c);
+  return wrapAnsi(o2, g, a3);
 }, note = (o2 = "", e = "", s) => {
-  const a3 = s?.output ?? process$1.stdout, i = s?.withGuide ?? settings.withGuide, c2 = s?.format ?? W$1, g2 = ["", ...C2(o2, getColumns(a3) - 6, c2).split(`
-`).map(c2), ""], n2 = dist_default2(e), t2 = Math.max(g2.reduce((m3, F) => {
+  const a3 = s?.output ?? process$1.stdout, i = s?.withGuide ?? settings.withGuide, c = s?.format ?? W$1, g = ["", ...C(o2, getColumns(a3) - 6, c).split(`
+`).map(c), ""], n2 = dist_default2(e), t2 = Math.max(g.reduce((m2, F) => {
     const O = dist_default2(F);
-    return O > m3 ? O : m3;
-  }, 0), n2) + 2, h2 = g2.map((m3) => `${styleText2("gray", S_BAR)}  ${m3}${" ".repeat(t2 - dist_default2(m3))}${styleText2("gray", S_BAR)}`).join(`
-`), T3 = i ? `${styleText2("gray", S_BAR)}
+    return O > m2 ? O : m2;
+  }, 0), n2) + 2, h2 = g.map((m2) => `${styleText2("gray", S_BAR)}  ${m2}${" ".repeat(t2 - dist_default2(m2))}${styleText2("gray", S_BAR)}`).join(`
+`), T = i ? `${styleText2("gray", S_BAR)}
 ` : "", l$1 = i ? S_CONNECT_LEFT : S_CORNER_BOTTOM_LEFT;
-  a3.write(`${T3}${styleText2("green", S_STEP_SUBMIT)}  ${styleText2("reset", e)} ${styleText2("gray", S_BAR_H.repeat(Math.max(t2 - n2 - 1, 1)) + S_CORNER_TOP_RIGHT)}
+  a3.write(`${T}${styleText2("green", S_STEP_SUBMIT)}  ${styleText2("reset", e)} ${styleText2("gray", S_BAR_H.repeat(Math.max(t2 - n2 - 1, 1)) + S_CORNER_TOP_RIGHT)}
 ${h2}
 ${styleText2("gray", l$1 + S_BAR_H.repeat(t2 + 2) + S_CORNER_BOTTOM_RIGHT)}
 `);
-}, u3, SELECT_INSTRUCTIONS, c2 = (t2, a3) => t2.includes(`
+}, u2, SELECT_INSTRUCTIONS, c = (t2, a3) => t2.includes(`
 `) ? t2.split(`
 `).map((i) => a3(i)).join(`
 `) : a3(t2), select = (t2) => {
-  const a3 = (i, m3) => {
+  const a3 = (i, m2) => {
     const s = i.label ?? String(i.value);
-    switch (m3) {
+    switch (m2) {
       case "disabled":
-        return `${styleText2("gray", S_RADIO_INACTIVE)} ${c2(s, (n2) => styleText2("gray", n2))}${i.hint ? ` ${styleText2("dim", `(${i.hint ?? "disabled"})`)}` : ""}`;
+        return `${styleText2("gray", S_RADIO_INACTIVE)} ${c(s, (n2) => styleText2("gray", n2))}${i.hint ? ` ${styleText2("dim", `(${i.hint ?? "disabled"})`)}` : ""}`;
       case "selected":
-        return `${c2(s, (n2) => styleText2("dim", n2))}`;
+        return `${c(s, (n2) => styleText2("dim", n2))}`;
       case "active":
         return `${styleText2("green", S_RADIO_ACTIVE)} ${s}${i.hint ? ` ${styleText2("dim", `(${i.hint})`)}` : ""}`;
       case "cancelled":
-        return `${c2(s, (n2) => styleText2(["strikethrough", "dim"], n2))}`;
+        return `${c(s, (n2) => styleText2(["strikethrough", "dim"], n2))}`;
       default:
-        return `${styleText2("dim", S_RADIO_INACTIVE)} ${c2(s, (n2) => styleText2("dim", n2))}`;
+        return `${styleText2("dim", S_RADIO_INACTIVE)} ${c(s, (n2) => styleText2("dim", n2))}`;
     }
   };
   return new a2({
@@ -19929,31 +18915,31 @@ ${styleText2("gray", l$1 + S_BAR_H.repeat(t2 + 2) + S_CORNER_BOTTOM_RIGHT)}
     output: t2.output,
     initialValue: t2.initialValue,
     render() {
-      const i = t2.withGuide ?? settings.withGuide, m3 = `${symbol(this.state)}  `, s = `${symbolBar(this.state)}  `, n2 = wrapTextWithPrefix(t2.output, t2.message, s, m3), u4 = `${i ? `${styleText2("gray", S_BAR)}
+      const i = t2.withGuide ?? settings.withGuide, m2 = `${symbol(this.state)}  `, s = `${symbolBar(this.state)}  `, n2 = wrapTextWithPrefix(t2.output, t2.message, s, m2), u3 = `${i ? `${styleText2("gray", S_BAR)}
 ` : ""}${n2}
 `;
       switch (this.state) {
         case "submit": {
           const r2 = i ? `${styleText2("gray", S_BAR)}  ` : "", o2 = wrapTextWithPrefix(t2.output, a3(this.options[this.cursor], "selected"), r2);
-          return `${u4}${o2}`;
+          return `${u3}${o2}`;
         }
         case "cancel": {
           const r2 = i ? `${styleText2("gray", S_BAR)}  ` : "", o2 = wrapTextWithPrefix(t2.output, a3(this.options[this.cursor], "cancelled"), r2);
-          return `${u4}${o2}${i ? `
+          return `${u3}${o2}${i ? `
 ${styleText2("gray", S_BAR)}` : ""}`;
         }
         default: {
-          const r2 = i ? `${styleText2("cyan", S_BAR)}  ` : "", o2 = u4.split(`
+          const r2 = i ? `${styleText2("cyan", S_BAR)}  ` : "", o2 = u3.split(`
 `).length, $ = formatInstructionFooter(SELECT_INSTRUCTIONS, i), h2 = $.join(`
-`), b2 = $.length + 1;
-          return `${u4}${r2}${limitOptions({
+`), b = $.length + 1;
+          return `${u3}${r2}${limitOptions({
             output: t2.output,
             cursor: this.cursor,
             options: this.options,
             maxItems: t2.maxItems,
             columnPadding: r2.length,
-            rowPadding: o2 + b2,
-            style: (p2, x) => a3(p2, p2.disabled ? "disabled" : x ? "active" : "inactive")
+            rowPadding: o2 + b,
+            style: (p, x) => a3(p, p.disabled ? "disabled" : x ? "active" : "inactive")
           }).join(`
 ${r2}`)}
 ${h2}
@@ -19973,7 +18959,7 @@ ${h2}
   render() {
     const i2 = t2?.withGuide ?? settings.withGuide, s = `${`${i2 ? `${styleText2("gray", S_BAR)}
 ` : ""}${symbol(this.state)}  `}${t2.message}
-`, c3 = t2.placeholder ? styleText2("inverse", t2.placeholder[0]) + styleText2("dim", t2.placeholder.slice(1)) : styleText2(["inverse", "hidden"], "_"), o2 = this.userInput ? this.userInputWithCursor : c3, a3 = this.value ?? "";
+`, c2 = t2.placeholder ? styleText2("inverse", t2.placeholder[0]) + styleText2("dim", t2.placeholder.slice(1)) : styleText2(["inverse", "hidden"], "_"), o2 = this.userInput ? this.userInputWithCursor : c2, a3 = this.value ?? "";
     switch (this.state) {
       case "error": {
         const n2 = this.error ? `  ${styleText2("yellow", this.error)}` : "", r2 = i2 ? `${styleText2("yellow", S_BAR)}  ` : "", d = i2 ? styleText2("yellow", S_BAR_END) : "";
@@ -20041,22 +19027,22 @@ var init_dist6 = __esm(() => {
     message: (s = [], {
       symbol: e = styleText2("gray", S_BAR),
       secondarySymbol: r2 = styleText2("gray", S_BAR),
-      output: m3 = process.stdout,
+      output: m2 = process.stdout,
       spacing: l = 1,
-      withGuide: c2
+      withGuide: c
     } = {}) => {
-      const t2 = [], o2 = c2 ?? settings.withGuide, f2 = o2 ? r2 : "", O = o2 ? `${e}  ` : "", u3 = o2 ? `${r2}  ` : "";
+      const t2 = [], o2 = c ?? settings.withGuide, f = o2 ? r2 : "", O = o2 ? `${e}  ` : "", u2 = o2 ? `${r2}  ` : "";
       for (let i = 0;i < l; i++)
-        t2.push(f2);
-      const g2 = Array.isArray(s) ? s : s.split(`
+        t2.push(f);
+      const g = Array.isArray(s) ? s : s.split(`
 `);
-      if (g2.length > 0) {
-        const [i, ...y] = g2;
+      if (g.length > 0) {
+        const [i, ...y] = g;
         i.length > 0 ? t2.push(`${O}${i}`) : t2.push(o2 ? e : "");
-        for (const p2 of y)
-          p2.length > 0 ? t2.push(`${u3}${p2}`) : t2.push(o2 ? r2 : "");
+        for (const p of y)
+          p.length > 0 ? t2.push(`${u2}${p}`) : t2.push(o2 ? r2 : "");
       }
-      m3.write(`${t2.join(`
+      m2.write(`${t2.join(`
 `)}
 `);
     },
@@ -20079,7 +19065,7 @@ var init_dist6 = __esm(() => {
       log2.message(s, { ...e, symbol: styleText2("red", S_ERROR) });
     }
   };
-  u3 = {
+  u2 = {
     light: unicodeOr("─", "-"),
     heavy: unicodeOr("━", "="),
     block: unicodeOr("█", "#")
@@ -20344,7 +19330,7 @@ function isResponseForRequest(parsed, expectedIds) {
   return expectedIds.has(id);
 }
 async function sendAftRequests(binaryPath, requests) {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const child = spawn3(binaryPath, [], {
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -20381,7 +19367,7 @@ async function sendAftRequests(binaryPath, requests) {
       const response = parsed;
       responses.push(response);
       if (responses.length === requests.length) {
-        finish(() => resolve8(responses));
+        finish(() => resolve9(responses));
       }
     };
     child.stdout.setEncoding("utf-8");
@@ -20411,11 +19397,14 @@ async function sendAftRequests(binaryPath, requests) {
         return;
       finish(() => reject(buildBridgeError({ binaryPath, code, stderr, noiseLines, responses })));
     });
-    for (const request of requests) {
-      child.stdin.write(`${JSON.stringify(request)}
+    child.stdin.on("error", () => {});
+    try {
+      for (const request of requests) {
+        child.stdin.write(`${JSON.stringify(request)}
 `);
-    }
-    child.stdin.end();
+      }
+      child.stdin.end();
+    } catch {}
   });
 }
 function buildBridgeError(ctx) {
@@ -20451,17 +19440,17 @@ var init_aft_bridge = () => {};
 // src/commands/lsp.ts
 var exports_lsp = {};
 __export(exports_lsp, {
-  typescriptPackageWarning: () => typescriptPackageWarning,
-  runLspDoctor: () => runLspDoctor,
-  renderLspInspection: () => renderLspInspection,
+  findProjectRootForFile: () => findProjectRootForFile,
   printLspDoctorHelp: () => printLspDoctorHelp,
-  findProjectRootForFile: () => findProjectRootForFile
+  renderLspInspection: () => renderLspInspection,
+  runLspDoctor: () => runLspDoctor,
+  typescriptPackageWarning: () => typescriptPackageWarning
 });
 import { existsSync as existsSync14, readdirSync as readdirSync5, statSync as statSync9 } from "node:fs";
 import { createRequire as createRequire4 } from "node:module";
-import { dirname as dirname8, join as join17, resolve as resolve8 } from "node:path";
+import { dirname as dirname8, join as join17, resolve as resolve9 } from "node:path";
 function findProjectRootForFile(filePath, fallbackCwd = process.cwd()) {
-  const resolvedFile = resolve8(fallbackCwd, filePath);
+  const resolvedFile = resolve9(fallbackCwd, filePath);
   let dir = dirname8(resolvedFile);
   try {
     if (existsSync14(resolvedFile) && statSync9(resolvedFile).isDirectory()) {
@@ -20476,7 +19465,7 @@ function findProjectRootForFile(filePath, fallbackCwd = process.cwd()) {
     }
     const parent = dirname8(dir);
     if (parent === dir)
-      return resolve8(fallbackCwd);
+      return resolve9(fallbackCwd);
     dir = parent;
   }
 }
@@ -20507,7 +19496,7 @@ async function runLspDoctor(options) {
     log2.error("Could not find the aft binary in the cache, platform package, PATH, or ~/.cargo/bin.");
     return 1;
   }
-  const resolvedFile = resolve8(file);
+  const resolvedFile = resolve9(file);
   const projectRoot = findProjectRootForFile(resolvedFile);
   const config = buildConfigureParams(adapter, projectRoot);
   const inspectRequest = {
@@ -20712,15 +19701,15 @@ var init_lsp = __esm(async () => {
 // src/commands/doctor-filters.ts
 var exports_doctor_filters = {};
 __export(exports_doctor_filters, {
-  runDoctorFilters: () => runDoctorFilters,
-  renderTrustedProjects: () => renderTrustedProjects,
-  renderFilterShow: () => renderFilterShow,
+  printDoctorFiltersHelp: () => printDoctorFiltersHelp,
   renderFilterList: () => renderFilterList,
-  printDoctorFiltersHelp: () => printDoctorFiltersHelp
+  renderFilterShow: () => renderFilterShow,
+  renderTrustedProjects: () => renderTrustedProjects,
+  runDoctorFilters: () => runDoctorFilters
 });
 import { existsSync as existsSync15 } from "node:fs";
 import { homedir as homedir16 } from "node:os";
-import { relative as relative3, resolve as resolve9 } from "node:path";
+import { relative as relative3, resolve as resolve10 } from "node:path";
 function printDoctorFiltersHelp() {
   console.log(`Usage: ${CLI} doctor filters [--show <name>] [trust|untrust]`);
   console.log("");
@@ -20755,7 +19744,7 @@ async function runDoctorFilters(options) {
     log2.error("Could not find the aft binary in the cache, platform package, PATH, or ~/.cargo/bin.");
     return 1;
   }
-  const projectRoot = resolve9(process.cwd());
+  const projectRoot = resolve10(process.cwd());
   const list = await listFilters(binary, adapter, projectRoot, options.sendRequests ?? sendAftRequests);
   if (!list.success) {
     log2.error(list.message ?? list.code ?? "list_filters failed");
@@ -20999,9 +19988,9 @@ import { homedir as homedir17, userInfo } from "node:os";
 function escapeRegex(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function safeRealpath(p2) {
+function safeRealpath(p) {
   try {
-    return realpathSync3(p2);
+    return realpathSync3(p);
   } catch {
     return null;
   }
@@ -21172,11 +20161,11 @@ function aggregateBridgeToolFailures(logText) {
   }
   return counts;
 }
-function sortFailureKeys(a3, b2, counts) {
-  const countDiff = (counts.get(b2) ?? 0) - (counts.get(a3) ?? 0);
+function sortFailureKeys(a3, b, counts) {
+  const countDiff = (counts.get(b) ?? 0) - (counts.get(a3) ?? 0);
   if (countDiff !== 0)
     return countDiff;
-  return a3.localeCompare(b2);
+  return a3.localeCompare(b);
 }
 function formatRecentAftToolFailuresSection(counts, options) {
   const maxClasses = options?.maxClasses ?? MAX_TOOL_FAILURE_CLASSES;
@@ -21185,7 +20174,7 @@ function formatRecentAftToolFailuresSection(counts, options) {
     return `${heading}
 No recent AFT tool failures recorded.`;
   }
-  const sorted = [...counts.keys()].sort((a3, b2) => sortFailureKeys(a3, b2, counts));
+  const sorted = [...counts.keys()].sort((a3, b) => sortFailureKeys(a3, b, counts));
   const shown = sorted.slice(0, maxClasses);
   const hidden = sorted.length - shown.length;
   const bullets = shown.map((key) => {
@@ -21213,21 +20202,105 @@ var init_bridge_tool_failures = __esm(() => {
   STRUCTURED_CODE_PATTERN = /"code"\s*:\s*"([^"]+)"/;
 });
 
-// src/lib/legacy-storage.ts
-import { existsSync as existsSync18, readdirSync as readdirSync7, statSync as statSync12 } from "node:fs";
+// src/lib/build-breaker.ts
+import { existsSync as existsSync18, readdirSync as readdirSync7 } from "node:fs";
 import { join as join19 } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+function buildBreakerDatabases(storageRoot) {
+  const callgraphRoot = join19(storageRoot, "callgraph");
+  if (!existsSync18(callgraphRoot))
+    return [];
+  try {
+    return readdirSync7(callgraphRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join19(callgraphRoot, entry.name, "build-breaker.sqlite")).filter((path2) => existsSync18(path2));
+  } catch {
+    return [];
+  }
+}
+function readBuildBreakerSuspensions(storageRoot, nowMs = Date.now()) {
+  const suspensions = [];
+  for (const databasePath of buildBreakerDatabases(storageRoot)) {
+    let database;
+    try {
+      database = new DatabaseSync(databasePath, { readOnly: true });
+      const rows = database.prepare(`SELECT root_id, domain, corpus_fingerprint, zero_credit_deaths, credited_deaths,
+                  suspended_reason, suspended_since_ms
+             FROM breaker_records
+            WHERE configuration_version = 'v1'
+              AND suspended_reason IS NOT NULL
+              AND suspended_since_ms IS NOT NULL
+              AND suspended_until_ms > ?
+            ORDER BY root_id, domain`).all(nowMs);
+      for (const row of rows) {
+        const deathCount = Number(row.zero_credit_deaths) + Number(row.credited_deaths);
+        const ageS = Math.floor(Math.max(0, nowMs - Number(row.suspended_since_ms)) / 1000);
+        suspensions.push({
+          root: row.root_id,
+          domain: row.domain,
+          reason: row.suspended_reason,
+          deathCount,
+          ageS,
+          fingerprint: row.corpus_fingerprint
+        });
+      }
+    } catch {} finally {
+      database?.close();
+    }
+  }
+  return suspensions;
+}
+function formatBuildBreakerSuspension(suspension) {
+  return [
+    `  build suspended: root=${suspension.root}`,
+    `domain=${suspension.domain}`,
+    `deaths=${suspension.deathCount}`,
+    `age_s=${suspension.ageS}`,
+    `reason=${suspension.reason};`,
+    `reset with \`${DOCTOR_BUILD_BREAKER_RESET_COMMAND} --root ${suspension.root} --domain ${suspension.domain} --fingerprint ${suspension.fingerprint}\``
+  ].join(" ");
+}
+function resetBuildBreakerSuspension(storageRoot, target) {
+  let reset = 0;
+  for (const databasePath of buildBreakerDatabases(storageRoot)) {
+    let database;
+    try {
+      database = new DatabaseSync(databasePath);
+      const result = database.prepare(`UPDATE breaker_records
+              SET zero_credit_deaths = 0,
+                  credited_deaths = 0,
+                  in_build_burn_ms = 0,
+                  suspended_reason = NULL,
+                  suspended_since_ms = NULL,
+                  suspended_until_ms = NULL
+            WHERE root_id = ?
+              AND domain = ?
+              AND corpus_fingerprint = ?`).run(target.root, target.domain, target.fingerprint);
+      reset += Number(result.changes ?? 0);
+    } catch {} finally {
+      database?.close();
+    }
+  }
+  return reset;
+}
+var DOCTOR_BUILD_BREAKER_RESET_COMMAND;
+var init_build_breaker = __esm(() => {
+  DOCTOR_BUILD_BREAKER_RESET_COMMAND = `${CLI} doctor reset-build-breaker`;
+});
+
+// src/lib/legacy-storage.ts
+import { existsSync as existsSync19, readdirSync as readdirSync8, statSync as statSync12 } from "node:fs";
+import { join as join20 } from "node:path";
 function summarizeLegacyPartitionDuplication(storageRoot) {
-  if (!existsSync18(storageRoot)) {
+  if (!existsSync19(storageRoot)) {
     return { totalPartitions: 0, totalBytes: 0, byHarness: [] };
   }
   const byHarness = [];
   for (const harness of safeReadDir(storageRoot)) {
-    const harnessPath = join19(storageRoot, harness);
+    const harnessPath = join20(storageRoot, harness);
     if (!isDirectory(harnessPath))
       continue;
     const partitions = new Map;
-    collectCallgraphPartitions(join19(harnessPath, "callgraph"), partitions);
-    collectInspectPartitions(join19(harnessPath, "inspect"), partitions);
+    collectCallgraphPartitions(join20(harnessPath, "callgraph"), partitions);
+    collectInspectPartitions(join20(harnessPath, "inspect"), partitions);
     if (partitions.size === 0)
       continue;
     let bytes = 0;
@@ -21246,7 +20319,7 @@ function collectCallgraphPartitions(domainPath, partitions) {
   if (!isDirectory(domainPath))
     return;
   for (const name of safeReadDir(domainPath)) {
-    const path2 = join19(domainPath, name);
+    const path2 = join20(domainPath, name);
     if (isDirectory(path2)) {
       if (!looksLikePartitionKey(name))
         continue;
@@ -21263,7 +20336,7 @@ function collectInspectPartitions(domainPath, partitions) {
   if (!isDirectory(domainPath))
     return;
   for (const name of safeReadDir(domainPath)) {
-    const path2 = join19(domainPath, name);
+    const path2 = join20(domainPath, name);
     if (isDirectory(path2)) {
       if (!looksLikePartitionKey(name))
         continue;
@@ -21312,7 +20385,7 @@ function looksLikePartitionKey(value) {
 }
 function safeReadDir(path2) {
   try {
-    return readdirSync7(path2).sort((left, right) => left.localeCompare(right));
+    return readdirSync8(path2).sort((left, right) => left.localeCompare(right));
   } catch {
     return [];
   }
@@ -21338,22 +20411,22 @@ var init_legacy_storage = __esm(() => {
 });
 
 // src/lib/lsp-cache.ts
-import { existsSync as existsSync19, readdirSync as readdirSync8, rmSync as rmSync5, statSync as statSync13 } from "node:fs";
-import { join as join20 } from "node:path";
+import { existsSync as existsSync20, readdirSync as readdirSync9, rmSync as rmSync5, statSync as statSync13 } from "node:fs";
+import { join as join21 } from "node:path";
 function inspectDir(path2) {
-  if (!existsSync19(path2)) {
+  if (!existsSync20(path2)) {
     return { entries: [], totalSize: 0 };
   }
   const entries = [];
   let totalSize = 0;
   let names;
   try {
-    names = readdirSync8(path2);
+    names = readdirSync9(path2);
   } catch {
     return { entries: [], totalSize: 0 };
   }
   for (const name of names) {
-    const full = join20(path2, name);
+    const full = join21(path2, name);
     try {
       if (!statSync13(full).isDirectory())
         continue;
@@ -21366,7 +20439,7 @@ function inspectDir(path2) {
       totalSize += size;
     } catch {}
   }
-  entries.sort((a3, b2) => b2.size - a3.size);
+  entries.sort((a3, b) => b.size - a3.size);
   return { entries, totalSize };
 }
 function getLspCacheReport() {
@@ -21411,8 +20484,8 @@ var init_lsp_cache = __esm(() => {
 });
 
 // src/lib/onnx.ts
-import { existsSync as existsSync20, readdirSync as readdirSync9, readlinkSync as readlinkSync2, realpathSync as realpathSync4 } from "node:fs";
-import { basename as basename3, isAbsolute as isAbsolute6, join as join21, resolve as resolve10, win32 as win322 } from "node:path";
+import { existsSync as existsSync21, readdirSync as readdirSync10, readlinkSync as readlinkSync2, realpathSync as realpathSync4 } from "node:fs";
+import { basename as basename3, isAbsolute as isAbsolute6, join as join22, resolve as resolve11, win32 as win322 } from "node:path";
 function getOnnxLibraryName() {
   if (process.platform === "darwin")
     return "libonnxruntime.dylib";
@@ -21421,20 +20494,20 @@ function getOnnxLibraryName() {
   return "libonnxruntime.so";
 }
 function getManualInstallHint2() {
-  const p2 = process.platform;
+  const p = process.platform;
   const a3 = process.arch;
-  if (p2 === "darwin") {
+  if (p === "darwin") {
     if (a3 === "arm64")
       return "brew install onnxruntime (Apple Silicon)";
     return "Intel Mac requires manual install — see docs";
   }
-  if (p2 === "linux") {
+  if (p === "linux") {
     if (a3 === "x64" || a3 === "arm64") {
       return "AFT auto-downloads ONNX Runtime on supported Linux (glibc)";
     }
     return "manual install required for this Linux arch";
   }
-  if (p2 === "win32") {
+  if (p === "win32") {
     if (a3 === "x64" || a3 === "arm64")
       return "AFT auto-downloads ONNX Runtime on Windows";
     return "manual install required for this Windows arch";
@@ -21465,7 +20538,7 @@ function isWindowsSystem32Directory2(dir) {
 }
 function directoryContainsLibrary2(dir, libName) {
   try {
-    const entries = readdirSync9(dir);
+    const entries = readdirSync10(dir);
     if (process.platform === "win32") {
       const expected = libName.toLowerCase();
       return entries.some((entry) => entry.toLowerCase() === expected);
@@ -21483,7 +20556,7 @@ function findIgnoredWindowsSystemOnnxRuntime() {
   for (const root of windowsRoots) {
     if (!root)
       continue;
-    const systemDir = join21(root, "System32");
+    const systemDir = join22(root, "System32");
     const key = win322.resolve(systemDir).toLowerCase();
     if (seen.has(key))
       continue;
@@ -21504,21 +20577,21 @@ function findSystemOnnxRuntime2() {
     searchPaths.push(...pathEntriesForPlatform2());
     const programFiles = process.env.ProgramFiles ?? "C:\\Program Files";
     const programFilesX86 = process.env["ProgramFiles(x86)"] ?? "C:\\Program Files (x86)";
-    searchPaths.push(join21(programFiles, "onnxruntime", "lib"), join21(programFiles, "Microsoft ONNX Runtime", "lib"), join21(programFiles, "Microsoft Machine Learning", "lib"), join21(programFilesX86, "onnxruntime", "lib"), ...(() => {
+    searchPaths.push(join22(programFiles, "onnxruntime", "lib"), join22(programFiles, "Microsoft ONNX Runtime", "lib"), join22(programFiles, "Microsoft Machine Learning", "lib"), join22(programFilesX86, "onnxruntime", "lib"), ...(() => {
       const nugetPaths = [];
       const userProfile = process.env.USERPROFILE ?? "";
       if (!userProfile)
         return nugetPaths;
-      const nugetPackageDir = join21(userProfile, ".nuget", "packages", "microsoft.ml.onnxruntime");
-      if (!existsSync20(nugetPackageDir))
+      const nugetPackageDir = join22(userProfile, ".nuget", "packages", "microsoft.ml.onnxruntime");
+      if (!existsSync21(nugetPackageDir))
         return nugetPaths;
       try {
-        for (const entry of readdirSync9(nugetPackageDir, { withFileTypes: true })) {
+        for (const entry of readdirSync10(nugetPackageDir, { withFileTypes: true })) {
           if (!entry.isDirectory())
             continue;
           if (entry.name === "__globalPackagesFolder" || entry.name.startsWith("."))
             continue;
-          nugetPaths.push(join21(nugetPackageDir, entry.name, "runtimes", "win-x64", "native"), join21(nugetPackageDir, entry.name, "runtimes", "win-arm64", "native"));
+          nugetPaths.push(join22(nugetPackageDir, entry.name, "runtimes", "win-x64", "native"), join22(nugetPackageDir, entry.name, "runtimes", "win-arm64", "native"));
         }
       } catch {}
       return nugetPaths;
@@ -21528,7 +20601,7 @@ function findSystemOnnxRuntime2() {
   const seen = new Set;
   const unknownVersionPaths = [];
   for (const dir of searchPaths) {
-    let key = resolve10(dir).replace(/[/\\]+$/, "");
+    let key = resolve11(dir).replace(/[/\\]+$/, "");
     if (normalizeCase)
       key = key.toLowerCase();
     if (seen.has(key))
@@ -21550,12 +20623,12 @@ function findSystemOnnxRuntime2() {
   return unknownVersionPaths[0] ?? null;
 }
 function findCachedOnnxRuntime(storageDir) {
-  const ortDir = join21(storageDir, "onnxruntime", ONNX_RUNTIME_VERSION);
+  const ortDir = join22(storageDir, "onnxruntime", ONNX_RUNTIME_VERSION);
   const libName = getOnnxLibraryName();
-  if (existsSync20(join21(ortDir, libName)))
+  if (existsSync21(join22(ortDir, libName)))
     return ortDir;
-  const libSubdir = join21(ortDir, "lib");
-  if (existsSync20(join21(libSubdir, libName)))
+  const libSubdir = join22(ortDir, "lib");
+  if (existsSync21(join22(libSubdir, libName)))
     return libSubdir;
   return null;
 }
@@ -21576,11 +20649,11 @@ function parseOrtVersionFromDirectoryPath(value) {
   return null;
 }
 function detectOrtVersion(libDir) {
-  if (!existsSync20(libDir))
+  if (!existsSync21(libDir))
     return null;
   const libName = getOnnxLibraryName();
   try {
-    const entries = readdirSync9(libDir);
+    const entries = readdirSync10(libDir);
     const barePrefix = libName.replace(/\.(so|dylib|dll)$/, "");
     const expectedPrefix = process.platform === "win32" ? barePrefix.toLowerCase() : barePrefix;
     for (const entry of entries) {
@@ -21591,8 +20664,8 @@ function detectOrtVersion(libDir) {
       if (version)
         return version;
     }
-    const base = join21(libDir, libName);
-    if (existsSync20(base)) {
+    const base = join22(libDir, libName);
+    if (existsSync21(base)) {
       try {
         const real = realpathSync4(base);
         const version = parseOrtVersionFromPath(real) ?? parseOrtVersionFromDirectoryPath(real);
@@ -21611,7 +20684,7 @@ function detectOrtVersion(libDir) {
   return null;
 }
 function isOrtVersionCompatible(version) {
-  const parts = version.split(".").map((p2) => parseInt(p2, 10));
+  const parts = version.split(".").map((p) => parseInt(p, 10));
   const [major, minor] = parts;
   if (!Number.isFinite(major) || !Number.isFinite(minor))
     return false;
@@ -21627,7 +20700,7 @@ import {
   accessSync,
   closeSync as closeSync6,
   constants,
-  existsSync as existsSync21,
+  existsSync as existsSync22,
   openSync as openSync6,
   readSync as readSync3,
   statSync as statSync14
@@ -21648,7 +20721,8 @@ async function collectDiagnostics(adapters) {
     binaryVersion,
     harnesses,
     binaryCache: getBinaryCacheInfo(cliVersion),
-    lspCache: getLspCacheReport()
+    lspCache: getLspCacheReport(),
+    buildBreakerSuspensions: harnesses[0] ? readBuildBreakerSuspensions(harnesses[0].storageDir.path) : []
   };
 }
 async function diagnoseHarness(adapter) {
@@ -21665,7 +20739,7 @@ async function diagnoseHarness(adapter) {
   const logPath = adapter.getLogFile();
   const pluginCache = adapter.getPluginCacheInfo();
   const storageAccessible = (() => {
-    if (!existsSync21(storage))
+    if (!existsSync22(storage))
       return false;
     try {
       accessSync(storage, constants.R_OK | constants.W_OK);
@@ -21690,7 +20764,7 @@ async function diagnoseHarness(adapter) {
     pluginRegistered: adapter.hasPluginEntry(),
     configPaths,
     aftConfig: {
-      exists: existsSync21(configPaths.aftConfig),
+      exists: existsSync22(configPaths.aftConfig),
       ...aftConfigRead.error ? { parseError: aftConfigRead.error } : {},
       enabled: aftEnabled,
       ...aftEnabledSource ? { enabledSource: aftEnabledSource } : {},
@@ -21699,7 +20773,7 @@ async function diagnoseHarness(adapter) {
     pluginCache,
     storageDir: {
       path: storage,
-      exists: existsSync21(storage),
+      exists: existsSync22(storage),
       accessible: storageAccessible,
       sizesByKey: describeStorage,
       ...legacyDuplication.totalPartitions > 0 ? { legacyDuplication } : {}
@@ -21720,8 +20794,8 @@ async function diagnoseHarness(adapter) {
     },
     logFile: {
       path: logPath,
-      exists: existsSync21(logPath),
-      sizeKb: existsSync21(logPath) ? Math.round(statSync14(logPath).size / 1024) : 0
+      exists: existsSync22(logPath),
+      sizeKb: existsSync22(logPath) ? Math.round(statSync14(logPath).size / 1024) : 0
     }
   };
 }
@@ -21794,9 +20868,9 @@ function renderDiagnosticsMarkdown(report) {
 function normalizeVersion(version) {
   return version.trim().replace(/^v/, "");
 }
-function compareLooseSemver(a3, b2) {
+function compareLooseSemver(a3, b) {
   const aParts = normalizeVersion(a3).split(/[.-]/).slice(0, 3).map((part) => Number.parseInt(part, 10));
-  const bParts = normalizeVersion(b2).split(/[.-]/).slice(0, 3).map((part) => Number.parseInt(part, 10));
+  const bParts = normalizeVersion(b).split(/[.-]/).slice(0, 3).map((part) => Number.parseInt(part, 10));
   for (let i2 = 0;i2 < 3; i2 += 1) {
     const av = Number.isFinite(aParts[i2]) ? aParts[i2] : 0;
     const bv = Number.isFinite(bParts[i2]) ? bParts[i2] : 0;
@@ -21828,14 +20902,15 @@ function pluginVersionSkewIssue(harness, cliVersion) {
 }
 function collectDiagnosticIssues(report) {
   const issues = [];
-  const hasEnabledRegisteredHarness = report.harnesses.some((h2) => h2.pluginRegistered && h2.aftConfig.enabled);
-  if (!report.binaryVersion && hasEnabledRegisteredHarness) {
+  const hasEnabledHarness = report.harnesses.some((h2) => h2.hostInstalled && h2.aftConfig.enabled);
+  const hasMatchingEnabledPlugin = report.harnesses.some((h2) => h2.pluginRegistered && h2.aftConfig.enabled && h2.pluginCache.cached && normalizeVersion(h2.pluginCache.cached) === normalizeVersion(report.cliVersion));
+  if (!report.binaryVersion && hasEnabledHarness) {
     issues.push({
       code: "binary_missing",
-      severity: "high",
+      severity: hasMatchingEnabledPlugin ? "info" : "high",
       scope: "AFT binary",
-      message: `No aft binary matching CLI ${report.cliVersion} was detected.`,
-      remediation: `Run \`${CLI} doctor --fix\` to download the matching binary, or start an AFT-enabled session to trigger plugin-side install.`
+      message: hasMatchingEnabledPlugin ? `No aft binary matching CLI ${report.cliVersion} was detected; it will self-install when the next AFT-enabled session starts.` : `No aft binary matching CLI ${report.cliVersion} was detected.`,
+      remediation: hasMatchingEnabledPlugin ? `Start an AFT-enabled session to install the matching binary automatically, or run \`${CLI} doctor --fix\`.` : `Run \`${CLI} doctor --fix\` to download the matching binary, or start an AFT-enabled session to trigger plugin-side install.`
     });
   }
   for (const h2 of report.harnesses) {
@@ -21917,7 +20992,7 @@ function formatDiagnosticIssuesSection(report) {
   return lines;
 }
 function tailLogFile(path2, lines) {
-  if (!existsSync21(path2))
+  if (!existsSync22(path2))
     return "";
   if (lines <= 0)
     return "";
@@ -21956,6 +21031,7 @@ function tailLogFile(path2, lines) {
 var init_diagnostics = __esm(async () => {
   init_dist2();
   init_binary_cache();
+  init_build_breaker();
   init_jsonc();
   init_legacy_storage();
   init_lsp_cache();
@@ -22105,14 +21181,14 @@ var init_issue_body = __esm(() => {
 });
 
 // src/lib/onnx-fix.ts
-import { existsSync as existsSync22, rmSync as rmSync6 } from "node:fs";
-import { join as join22 } from "node:path";
+import { existsSync as existsSync23, rmSync as rmSync6 } from "node:fs";
+import { join as join23 } from "node:path";
 function findOnnxFixCandidates(report) {
   const candidates = [];
   for (const harness of report.harnesses) {
     if (!harness.onnxRuntime.required)
       continue;
-    const storageOnnxDir = join22(harness.storageDir.path, "onnxruntime");
+    const storageOnnxDir = join23(harness.storageDir.path, "onnxruntime");
     const systemTooOld = harness.onnxRuntime.systemPath !== null && harness.onnxRuntime.systemCompatible === false;
     const cachedTooOld = harness.onnxRuntime.cachedPath !== null && harness.onnxRuntime.cachedCompatible === false;
     const hasCompatibleCached = harness.onnxRuntime.cachedCompatible === true;
@@ -22121,7 +21197,7 @@ function findOnnxFixCandidates(report) {
         harness,
         reason: `cached ONNX Runtime at ${harness.onnxRuntime.cachedPath} is v${harness.onnxRuntime.cachedVersion}, but AFT requires ${harness.onnxRuntime.requirement}. Clearing it allows an immediate managed download.`,
         storageOnnxDir,
-        storageOnnxBytes: existsSync22(storageOnnxDir) ? dirSize(storageOnnxDir) : 0
+        storageOnnxBytes: existsSync23(storageOnnxDir) ? dirSize(storageOnnxDir) : 0
       });
       continue;
     }
@@ -22130,7 +21206,7 @@ function findOnnxFixCandidates(report) {
         harness,
         reason: `system ONNX Runtime at ${harness.onnxRuntime.systemPath} is v${harness.onnxRuntime.systemVersion}, but AFT requires ${harness.onnxRuntime.requirement}, and no AFT-managed install is present. AFT will leave the system copy untouched and download v1.24 into managed storage.`,
         storageOnnxDir,
-        storageOnnxBytes: existsSync22(storageOnnxDir) ? dirSize(storageOnnxDir) : 0
+        storageOnnxBytes: existsSync23(storageOnnxDir) ? dirSize(storageOnnxDir) : 0
       });
       continue;
     }
@@ -22140,7 +21216,7 @@ function findOnnxFixCandidates(report) {
         harness,
         reason: `no compatible ONNX Runtime is installed.${ignoredCopy} AFT will download v1.24 into managed storage.`,
         storageOnnxDir,
-        storageOnnxBytes: existsSync22(storageOnnxDir) ? dirSize(storageOnnxDir) : 0
+        storageOnnxBytes: existsSync23(storageOnnxDir) ? dirSize(storageOnnxDir) : 0
       });
     }
   }
@@ -22170,7 +21246,7 @@ async function runOnnxFix(adapters, report, options = {}) {
   const rmFn = options.rmFn ?? rmSync6;
   const ensureFn = options.ensureFn ?? ensureOnnxRuntime;
   for (const candidate of candidates) {
-    if (existsSync22(candidate.storageOnnxDir)) {
+    if (existsSync23(candidate.storageOnnxDir)) {
       try {
         rmFn(candidate.storageOnnxDir, { recursive: true, force: true });
         result.cleared += 1;
@@ -22212,10 +21288,10 @@ var init_onnx_fix = __esm(() => {
 });
 
 // src/lib/sessions.ts
-import { existsSync as existsSync23, readdirSync as readdirSync10, readFileSync as readFileSync10, statSync as statSync15 } from "node:fs";
+import { existsSync as existsSync24, readdirSync as readdirSync11, readFileSync as readFileSync10, statSync as statSync15 } from "node:fs";
 import { createRequire as createRequire5 } from "node:module";
 import { homedir as homedir18 } from "node:os";
-import { basename as basename4, join as join23 } from "node:path";
+import { basename as basename4, join as join24 } from "node:path";
 function listRecentSessions(adapter) {
   try {
     if (adapter.kind === "opencode")
@@ -22241,11 +21317,11 @@ function mapOpenCodeSessionRows(rows) {
       title: row.title,
       lastActivity
     };
-  }).filter((session) => session !== null).sort((a3, b2) => b2.lastActivity - a3.lastActivity).slice(0, MAX_RECENT_SESSIONS);
+  }).filter((session) => session !== null).sort((a3, b) => b.lastActivity - a3.lastActivity).slice(0, MAX_RECENT_SESSIONS);
 }
 function listRecentOpenCodeSessions() {
-  const dbPath = join23(getXdgDataHome(), "opencode", "opencode.db");
-  if (!existsSync23(dbPath))
+  const dbPath = join24(getXdgDataHome(), "opencode", "opencode.db");
+  if (!existsSync24(dbPath))
     return [];
   let db = null;
   try {
@@ -22264,10 +21340,10 @@ function listRecentOpenCodeSessions() {
 }
 function getXdgDataHome() {
   const xdgDataHome = process.env.XDG_DATA_HOME;
-  return xdgDataHome && xdgDataHome.length > 0 ? xdgDataHome : join23(homedir18(), ".local", "share");
+  return xdgDataHome && xdgDataHome.length > 0 ? xdgDataHome : join24(homedir18(), ".local", "share");
 }
 function listRecentPiSessions() {
-  return listPiSessionsFromDir(join23(getHomeDir(), ".pi", "agent", "sessions"));
+  return listPiSessionsFromDir(join24(getHomeDir(), ".pi", "agent", "sessions"));
 }
 function getHomeDir() {
   const envHome = process.platform === "win32" ? process.env.USERPROFILE : process.env.HOME;
@@ -22275,7 +21351,7 @@ function getHomeDir() {
 }
 function listPiSessionsFromDir(sessionsDir) {
   try {
-    if (!existsSync23(sessionsDir))
+    if (!existsSync24(sessionsDir))
       return [];
     const files = collectJsonlFiles(sessionsDir).map((filePath) => {
       try {
@@ -22284,7 +21360,7 @@ function listPiSessionsFromDir(sessionsDir) {
       } catch {
         return null;
       }
-    }).filter((entry) => entry !== null).sort((a3, b2) => b2.mtimeMs - a3.mtimeMs).slice(0, MAX_RECENT_SESSIONS * 4);
+    }).filter((entry) => entry !== null).sort((a3, b) => b.mtimeMs - a3.mtimeMs).slice(0, MAX_RECENT_SESSIONS * 4);
     const sessions = [];
     for (const file of files) {
       const parsed = parsePiSessionJsonl(readFileSync10(file.filePath, "utf8"), basename4(file.filePath));
@@ -22308,12 +21384,12 @@ function collectJsonlFiles(root) {
       continue;
     let entries;
     try {
-      entries = readdirSync10(dir, { withFileTypes: true });
+      entries = readdirSync11(dir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
-      const path2 = join23(dir, entry.name);
+      const path2 = join24(dir, entry.name);
       if (entry.isDirectory()) {
         stack.push(path2);
       } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
@@ -22397,23 +21473,25 @@ var init_sessions = () => {};
 // src/commands/doctor.ts
 var exports_doctor = {};
 __export(exports_doctor, {
-  shouldSkipDoctorFixConfirmation: () => shouldSkipDoctorFixConfirmation,
-  runDoctor: () => runDoctor,
-  hasDoctorProblems: () => hasDoctorProblems,
-  formatDoctorStorageStatus: () => formatDoctorStorageStatus,
-  fixPluginEntries: () => fixPluginEntries,
-  doctorSkewBinaryDownloadDecision: () => doctorSkewBinaryDownloadDecision,
-  deriveIssueTitleFromBody: () => deriveIssueTitleFromBody,
-  clearOldBinaries: () => clearOldBinaries,
-  clearDoctorCaches: () => clearDoctorCaches,
-  buildDoctorFixPlan: () => buildDoctorFixPlan,
+  DOCTOR_CLEAR_TARGET_OPTIONS: () => DOCTOR_CLEAR_TARGET_OPTIONS,
   DOCTOR_FORCE_CLEAR_TARGETS: () => DOCTOR_FORCE_CLEAR_TARGETS,
-  DOCTOR_CLEAR_TARGET_OPTIONS: () => DOCTOR_CLEAR_TARGET_OPTIONS
+  buildDoctorFixPlan: () => buildDoctorFixPlan,
+  clearDoctorCaches: () => clearDoctorCaches,
+  clearOldBinaries: () => clearOldBinaries,
+  deriveIssueTitleFromBody: () => deriveIssueTitleFromBody,
+  doctorSkewBinaryDownloadDecision: () => doctorSkewBinaryDownloadDecision,
+  fixPluginEntries: () => fixPluginEntries,
+  formatDoctorStorageStatus: () => formatDoctorStorageStatus,
+  hasDoctorProblems: () => hasDoctorProblems,
+  logBuildBreakerSuspensions: () => logBuildBreakerSuspensions,
+  runDoctor: () => runDoctor,
+  runDoctorBuildBreakerReset: () => runDoctorBuildBreakerReset,
+  shouldSkipDoctorFixConfirmation: () => shouldSkipDoctorFixConfirmation
 });
 import { execFileSync as execFileSync3 } from "node:child_process";
 import {
   chmodSync as chmodSync4,
-  existsSync as existsSync24,
+  existsSync as existsSync25,
   mkdirSync as mkdirSync7,
   mkdtempSync,
   readFileSync as readFileSync11,
@@ -22423,7 +21501,7 @@ import {
   writeFileSync as writeFileSync5
 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join24 } from "node:path";
+import { join as join25 } from "node:path";
 async function runDoctor(options) {
   if (options.issue) {
     return runIssueFlow(options.argv);
@@ -22444,8 +21522,11 @@ async function runDoctor(options) {
   if (!report.binaryVersion) {
     const hasEnabledRegisteredHarness = report.harnesses.some((h2) => h2.pluginRegistered && h2.aftConfig.enabled);
     const hasRegisteredHarness = report.harnesses.some((h2) => h2.pluginRegistered);
-    if (hasEnabledRegisteredHarness) {
-      log2.warn(`  no matching aft binary detected — run \`${CLI} doctor --fix\` to download, or it will install automatically when an AFT-enabled session makes its first tool call`);
+    const binaryIssue = collectDiagnosticIssues(report).find((issue) => issue.code === "binary_missing");
+    if (hasEnabledRegisteredHarness && binaryIssue?.severity === "info") {
+      log2.info(`  no matching aft binary detected — it will self-install when the next AFT-enabled session starts (or run \`${CLI} doctor --fix\`)`);
+    } else if (hasEnabledRegisteredHarness) {
+      log2.warn(`  no matching aft binary detected — run \`${CLI} doctor --fix\` to download, or start an AFT-enabled session to trigger plugin-side install`);
     } else if (hasRegisteredHarness) {
       log2.info("  no matching aft binary detected; all registered AFT harnesses are disabled by config");
     } else {
@@ -22454,6 +21535,7 @@ async function runDoctor(options) {
     logUnmatchedBinaryCandidates(report.cliVersion);
   }
   log2.info(`Binary cache: ${report.binaryCache.versions.length} version(s), ${formatBytes(report.binaryCache.totalSize)} at ${report.binaryCache.path}`);
+  logBuildBreakerSuspensions(report);
   const npmCount = report.lspCache.npm.entries.length;
   const ghCount = report.lspCache.github.entries.length;
   if (npmCount + ghCount > 0) {
@@ -22520,7 +21602,41 @@ async function runDoctor(options) {
   return 0;
 }
 function hasDoctorProblems(report) {
-  return formatDiagnosticIssuesSection(report).length > 0;
+  return collectDiagnosticIssues(report).some((issue) => issue.severity !== "info") || (report.buildBreakerSuspensions?.length ?? 0) > 0;
+}
+function logBuildBreakerSuspensions(report) {
+  for (const suspension of report.buildBreakerSuspensions ?? []) {
+    log2.warn(formatBuildBreakerSuspension(suspension));
+  }
+}
+async function runDoctorBuildBreakerReset(argv) {
+  const optionValue = (name) => {
+    const index = argv.indexOf(name);
+    return index >= 0 ? argv[index + 1] : undefined;
+  };
+  const root = optionValue("--root");
+  const domain = optionValue("--domain");
+  const fingerprint = optionValue("--fingerprint");
+  if (!root || !domain || !fingerprint) {
+    log2.error(`Usage: ${DOCTOR_BUILD_BREAKER_RESET_COMMAND} --root <root> --domain <domain> --fingerprint <fingerprint>`);
+    return 2;
+  }
+  const adapters = await resolveAdaptersForCommand(argv, {
+    allowMulti: false,
+    verb: "reset the build breaker for"
+  });
+  const storageRoot = adapters[0]?.getStorageDir();
+  if (!storageRoot) {
+    log2.error("No AFT storage root was found for the selected harness.");
+    return 1;
+  }
+  const reset = resetBuildBreakerSuspension(storageRoot, { root, domain, fingerprint });
+  if (reset === 0) {
+    log2.warn("No matching build-breaker suspension was found; no records were changed.");
+    return 1;
+  }
+  log2.success(`Reset build breaker for root=${root} domain=${domain}.`);
+  return 0;
 }
 async function runClearFlow(argv) {
   const targets = await selectMany("What do you want to clear?", DOCTOR_CLEAR_TARGET_OPTIONS, undefined, false);
@@ -22590,7 +21706,7 @@ function clearOldBinaries() {
     errors: [],
     keptVersion: keepTag
   };
-  if (!existsSync24(info.path)) {
+  if (!existsSync25(info.path)) {
     log2.info(`Binary cache: nothing to clear at ${info.path}`);
     return result;
   }
@@ -22600,7 +21716,7 @@ function clearOldBinaries() {
     return result;
   }
   for (const version of stale) {
-    const dir = join24(info.path, version);
+    const dir = join25(info.path, version);
     let bytes = 0;
     try {
       bytes = statSync16(dir).isDirectory() ? dirSize(dir) : 0;
@@ -22905,6 +22021,8 @@ function logDoctorIssues(report) {
     const remediation = lines[i2 + 1];
     if (issue.startsWith("[HIGH]")) {
       log2.error(issue);
+    } else if (issue.startsWith("[INFO]")) {
+      log2.info(issue);
     } else {
       log2.warn(issue);
     }
@@ -22945,7 +22063,7 @@ function ensureStorageDirsForRegisteredPlugins(adapters) {
       if (!adapter.isInstalled() || !adapter.hasPluginEntry())
         continue;
       const storageDir = adapter.getStorageDir();
-      if (existsSync24(storageDir))
+      if (existsSync25(storageDir))
         continue;
       mkdirSync7(storageDir, { recursive: true });
       summary.created += 1;
@@ -23024,8 +22142,14 @@ function describeAdapterInstallHint(kind) {
   return "(unknown harness)";
 }
 function formatStorageSizes(sizes) {
-  const parts = Object.entries(sizes).filter(([, size]) => size > 0).map(([key, size]) => `${key}: ${formatBytes(size)}`);
-  return parts.length > 0 ? parts.join(", ") : "empty";
+  const projectParts = Object.entries(sizes).filter(([key, size]) => key !== "logs" && size > 0).map(([key, size]) => `${key}: ${formatBytes(size)}`);
+  const logsSize = sizes.logs ?? 0;
+  const parts = [...projectParts];
+  if (logsSize > 0)
+    parts.push(`logs: ${formatBytes(logsSize)}`);
+  if (projectParts.length > 0)
+    return parts.join(", ");
+  return logsSize > 0 ? `${parts[0]}; no project data yet` : "empty";
 }
 function formatLegacyDuplication(summary) {
   if (!summary || summary.totalPartitions === 0)
@@ -23064,11 +22188,11 @@ function deriveIssueTitleFromBody(body) {
 function writeIssueReviewFile(body) {
   let reviewDir = null;
   try {
-    reviewDir = mkdtempSync(join24(tmpdir2(), "aft-issue-"));
+    reviewDir = mkdtempSync(join25(tmpdir2(), "aft-issue-"));
     if (process.platform !== "win32") {
       chmodSync4(reviewDir, 448);
     }
-    const outPath = join24(reviewDir, "issue.md");
+    const outPath = join25(reviewDir, "issue.md");
     writeFileSync5(outPath, `${body}
 `, { encoding: "utf8", mode: 384, flag: "wx" });
     return { path: outPath, realPath: realpathSync5(outPath) };
@@ -23232,6 +22356,7 @@ var init_doctor = __esm(async () => {
   init_dist2();
   init_binary_cache();
   init_bridge_tool_failures();
+  init_build_breaker();
   init_fs_util();
   init_github();
   init_harness_select();
@@ -23280,6 +22405,7 @@ function printHelp() {
   console.log("    doctor --fix     Auto-fix common issues (e.g. ONNX Runtime mismatch)");
   console.log("    doctor --clear   Select caches to clear with an interactive prompt");
   console.log("    doctor --issue   Collect diagnostics and open a GitHub issue");
+  console.log("    doctor reset-build-breaker --root <root> --domain <domain> --fingerprint <fingerprint>");
   console.log("");
   console.log("  Harness selection:");
   console.log("    --harness opencode    Target OpenCode only");
@@ -23292,6 +22418,7 @@ function printHelp() {
   console.log(`    ${CLI} doctor lsp ./src/main.py`);
   console.log(`    ${CLI} doctor --clear`);
   console.log(`    ${CLI} doctor --issue`);
+  console.log(`    ${CLI} doctor reset-build-breaker --root <root> --domain <domain> --fingerprint <fingerprint>`);
   console.log("");
 }
 async function main() {
@@ -23312,6 +22439,10 @@ async function main() {
       const { runDoctorFilters: runDoctorFilters2 } = await init_doctor_filters().then(() => exports_doctor_filters);
       return runDoctorFilters2({ argv: args.slice(1) });
     }
+    if (args[0] === "reset-build-breaker") {
+      const { runDoctorBuildBreakerReset: runDoctorBuildBreakerReset2 } = await init_doctor().then(() => exports_doctor);
+      return runDoctorBuildBreakerReset2(args.slice(1));
+    }
     const { runDoctor: runDoctor2 } = await init_doctor().then(() => exports_doctor);
     const force = args.includes("--force");
     const clear = args.includes("--clear");