@cortexkit/aft-opencode 0.45.1 → 0.46.0

package/dist/index.js

@@ -11442,11 +11442,11 @@ class BridgePool {
 function normalizeKey(projectRoot) {
   return canonicalizeProjectRoot(projectRoot);
 }
-// ../../node_modules/.bun/@cortexkit+subc-client@0.3.0/node_modules/@cortexkit/subc-client/src/client.ts
+// ../../node_modules/.bun/@cortexkit+subc-client@0.3.4/node_modules/@cortexkit/subc-client/dist/client.js
 import { promises as fs2 } from "node:fs";
 import { debuglog } from "node:util";
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.3.0/node_modules/@cortexkit/subc-client/src/auth.ts
+// ../../node_modules/.bun/@cortexkit+subc-client@0.3.4/node_modules/@cortexkit/subc-client/dist/auth.js
 import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
 var NONCE_LEN = 32;
 var MAX_AUTH_MESSAGE_LEN = 4096;
@@ -11510,7 +11510,7 @@ async function authenticateClient(sock, conn, deadlineMs) {
   await writeMessage(sock, { client_auth: Array.from(clientAuth) }, deadlineMs);
 }
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.3.0/node_modules/@cortexkit/subc-client/src/connection-file.ts
+// ../../node_modules/.bun/@cortexkit+subc-client@0.3.4/node_modules/@cortexkit/subc-client/dist/connection-file.js
 import { promises as fs } from "node:fs";
 var SCHEMA_VERSION = 1;
 var MIN_KEY_LEN = 32;
@@ -11579,13 +11579,13 @@ async function readConnectionFile(path2) {
   return info;
 }
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.3.0/node_modules/@cortexkit/subc-client/src/envelope.ts
+// ../../node_modules/.bun/@cortexkit+subc-client@0.3.4/node_modules/@cortexkit/subc-client/dist/envelope.js
 var PROTOCOL_VERSION = 1;
 var HEADER_LEN = 17;
 var FROZEN_PREFIX_LEN = 5;
 var MAX_FRAME_BODY_LEN = 64 * 1024 * 1024;
 var FrameType;
-((FrameType2) => {
+(function(FrameType2) {
   FrameType2[FrameType2["Request"] = 0] = "Request";
   FrameType2[FrameType2["Response"] = 1] = "Response";
   FrameType2[FrameType2["Push"] = 2] = "Push";
@@ -11598,11 +11598,17 @@ var FrameType;
   FrameType2[FrameType2["Hello"] = 9] = "Hello";
   FrameType2[FrameType2["HelloAck"] = 10] = "HelloAck";
   FrameType2[FrameType2["Goodbye"] = 11] = "Goodbye";
-})(FrameType ||= {});
-var FRAME_TYPE_MAX = 11 /* Goodbye */;
+})(FrameType || (FrameType = {}));
+var FRAME_TYPE_MAX = FrameType.Goodbye;
 function isPureHeader(ty) {
-  return ty === 6 /* Cancel */ || ty === 7 /* Ping */ || ty === 8 /* Pong */ || ty === 11 /* Goodbye */;
-}
+  return ty === FrameType.Cancel || ty === FrameType.Ping || ty === FrameType.Pong || ty === FrameType.Goodbye;
+}
+var Priority;
+(function(Priority2) {
+  Priority2[Priority2["Passive"] = 0] = "Passive";
+  Priority2[Priority2["Interactive"] = 1] = "Interactive";
+  Priority2[Priority2["Background"] = 2] = "Background";
+})(Priority || (Priority = {}));
 var FLAG_BINARY = 1;
 var FLAG_PRIORITY_MASK = 6;
 var FLAG_PRIORITY_SHIFT = 1;
@@ -11686,7 +11692,7 @@ function encodeFrame(frame) {
   return out;
 }
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.3.0/node_modules/@cortexkit/subc-client/src/socket.ts
+// ../../node_modules/.bun/@cortexkit+subc-client@0.3.4/node_modules/@cortexkit/subc-client/dist/socket.js
 import net from "node:net";
 
 class SocketClosedError extends Error {
@@ -11878,14 +11884,14 @@ class SubcSocket {
   }
 }
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.3.0/node_modules/@cortexkit/subc-client/src/client.ts
+// ../../node_modules/.bun/@cortexkit+subc-client@0.3.4/node_modules/@cortexkit/subc-client/dist/client.js
 var debug = debuglog("subc-client");
 var DEFAULT_HANDSHAKE_TIMEOUT_MS = 1e4;
 var DEFAULT_REQUEST_TIMEOUT_MS = 30000;
 var TIMEOUT_ARBITRATION_GRACE_MS = 50;
 var REQUEST_DEADLINE_MARKER = "request_deadline";
 var DEADLINE_NO_DROP_CODE = "deadline_exceeded_no_drop_observed";
-var ROUTE_OPEN_RETRY_DEADLINE_MS = 1e4;
+var ROUTE_OPEN_RETRY_DEADLINE_MS = 30000;
 var BODY_READ_TIMEOUT_MS = 30000;
 var EMPTY_BODY = new Uint8Array(0);
 var DEFAULT_MANAGED_TARGET_KIND = "management_surface";
@@ -11967,12 +11973,13 @@ class SubcClient {
   }
   async request(routeChannel, body, opts = {}) {
     const bytes = body instanceof Uint8Array ? body : this.encode(body);
-    const priority = opts.priority ?? 1 /* Interactive */;
+    const priority = opts.priority ?? Priority.Interactive;
     const reply = await this.send(routeChannel, bytes, priority, opts.timeoutMs, opts.onProgress);
     return this.parseJson(reply);
   }
   async call(moduleId, method, params, opts = {}) {
     const body = params === undefined ? { method } : { method, params };
+    let retriedUnknownChannel = false;
     for (;; ) {
       const routeChannel = await this.cachedRouteChannel(moduleId, opts);
       try {
@@ -11980,6 +11987,11 @@ class SubcClient {
       } catch (err) {
         if (!(err instanceof SubcCallError))
           throw this.terminalCallError("managed call failed", err);
+        if (err.code === "unknown_channel" && !retriedUnknownChannel && !this.closeStarted) {
+          retriedUnknownChannel = true;
+          this.evictRouteChannel(routeChannel);
+          continue;
+        }
         if (err.kind === "not_sent") {
           try {
             await this.reconnectAfterDrop(err);
@@ -11997,7 +12009,7 @@ class SubcClient {
   }
   subscribe(routeChannel, body, onEvent, opts = {}) {
     const bytes = body instanceof Uint8Array ? body : this.encode(body);
-    const priority = opts.priority ?? 1 /* Interactive */;
+    const priority = opts.priority ?? Priority.Interactive;
     const corr = this.nextCorr++;
     const key = `${routeChannel}:${corr}`;
     const closed = new Promise((resolve7, reject) => {
@@ -12013,7 +12025,7 @@ class SubcClient {
         timer: null,
         subscription: true
       });
-      const frame = buildFrame(0 /* Request */, buildFlags(false, priority, false), routeChannel, corr, bytes);
+      const frame = buildFrame(FrameType.Request, buildFlags(false, priority, false), routeChannel, corr, bytes);
       this.sock.write(encodeFrame(frame), Date.now() + DEFAULT_REQUEST_TIMEOUT_MS).catch((err) => {
         const p = this.pending.get(key);
         if (p)
@@ -12025,7 +12037,7 @@ class SubcClient {
       if (cancelled)
         return;
       cancelled = true;
-      const cancel = buildFrame(6 /* Cancel */, buildFlags(false, priority, false), routeChannel, corr, EMPTY_BODY);
+      const cancel = buildFrame(FrameType.Cancel, buildFlags(false, priority, false), routeChannel, corr, EMPTY_BODY);
       this.sock.write(encodeFrame(cancel), Date.now() + DEFAULT_REQUEST_TIMEOUT_MS).catch(() => {});
     };
     return { unsubscribe, closed };
@@ -12076,7 +12088,7 @@ class SubcClient {
   sendRouteGoodbye(channel) {
     if (this.closedErr)
       return;
-    const goodbye = buildFrame(11 /* Goodbye */, buildFlags(false, 1 /* Interactive */, false), channel, 0n, EMPTY_BODY);
+    const goodbye = buildFrame(FrameType.Goodbye, buildFlags(false, Priority.Interactive, false), channel, 0n, EMPTY_BODY);
     this.sock.write(encodeFrame(goodbye), Date.now() + DEFAULT_REQUEST_TIMEOUT_MS).catch(() => {});
   }
   static async openConnection(opts) {
@@ -12093,14 +12105,14 @@ class SubcClient {
     return { sock, conn };
   }
   async controlRpc(body) {
-    return this.send(0, body, 1 /* Interactive */, undefined, undefined);
+    return this.send(0, body, Priority.Interactive, undefined, undefined);
   }
   send(channel, body, priority, timeoutMs, onProgress) {
     if (this.closedErr)
       return Promise.reject(this.closedErr);
     const corr = this.nextCorr++;
     const key = `${channel}:${corr}`;
-    const frame = buildFrame(0 /* Request */, buildFlags(false, priority, false), channel, corr, body);
+    const frame = buildFrame(FrameType.Request, buildFlags(false, priority, false), channel, corr, body);
     return new Promise((resolve7, reject) => {
       const ms = timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
       const pending = {
@@ -12140,7 +12152,7 @@ class SubcClient {
   }
   async managedRequest(routeChannel, body, opts) {
     const bytes = body instanceof Uint8Array ? body : this.encode(body);
-    const priority = opts.priority ?? 1 /* Interactive */;
+    const priority = opts.priority ?? Priority.Interactive;
     try {
       const reply = await this.sendManaged(routeChannel, bytes, priority, opts.timeoutMs, opts.onProgress);
       return this.parseJson(reply);
@@ -12156,7 +12168,7 @@ class SubcClient {
     }
     const corr = this.nextCorr++;
     const key = `${channel}:${corr}`;
-    const frame = buildFrame(0 /* Request */, buildFlags(false, priority, false), channel, corr, body);
+    const frame = buildFrame(FrameType.Request, buildFlags(false, priority, false), channel, corr, body);
     let handedToSocket = false;
     const classifyFailure = (err) => {
       if (!handedToSocket) {
@@ -12315,6 +12327,9 @@ class SubcClient {
         return;
       } catch (err) {
         if (!isConsumerReconnectTransient(err) || attempt >= this.opts.reconnectBackoff.maxAttempts) {
+          if (err instanceof AuthError && attempt > 1) {
+            throw new AuthError(`reconnect gave up after ${attempt} attempts: ${err.message} — the connection file and the daemon's key disagree persistently ` + `(daemon restarting in a loop, split connection-file paths, or a genuinely foreign daemon on this port); ` + `check the daemon, then restart this host app`);
+          }
           throw err;
         }
         await this.opts.sleep(delay);
@@ -12383,26 +12398,27 @@ class SubcClient {
     const pending = this.pending.get(key);
     if (pending) {
       switch (frame.header.ty) {
-        case 2 /* Push */:
-        case 3 /* StreamData */:
+        case FrameType.Push:
+        case FrameType.StreamData:
           pending.onProgress?.(frame.body);
           return;
-        case 1 /* Response */:
-        case 4 /* StreamEnd */:
+        case FrameType.Response:
+        case FrameType.StreamEnd:
           this.settle(key, pending, () => pending.resolve(frame));
           return;
-        case 5 /* Error */:
+        case FrameType.Error:
           this.settle(key, pending, () => pending.reject(this.errorFromFrame(frame)));
           return;
         default:
           return;
       }
     }
-    if (frame.header.ty === 11 /* Goodbye */) {
+    if (frame.header.ty === FrameType.Goodbye) {
       this.failChannel(frame.header.channel, new SubcError("route closed by subc (GOODBYE)"));
+      this.evictRouteChannel(frame.header.channel);
       return;
     }
-    if (frame.header.ty === 1 /* Response */ || frame.header.ty === 5 /* Error */ || frame.header.ty === 4 /* StreamEnd */) {
+    if (frame.header.ty === FrameType.Response || frame.header.ty === FrameType.Error || frame.header.ty === FrameType.StreamEnd) {
       debug("dropped terminal frame with no waiter: type=%d channel=%d corr=%s port=%s", frame.header.ty, frame.header.channel, frame.header.corr, this.sock.localPort() ?? "?");
       return;
     }
@@ -12428,6 +12444,13 @@ class SubcClient {
       return new SubcError(Buffer.from(frame.body).toString("utf8") || "subc error");
     }
   }
+  evictRouteChannel(channel) {
+    for (const cached of this.routes.values()) {
+      if (cached.channel === channel && cached.generation === this.generation) {
+        cached.channel = null;
+      }
+    }
+  }
   failChannel(channel, err) {
     for (const [key, pending] of this.pending) {
       if (pending.channel === channel) {
@@ -12474,7 +12497,9 @@ function isConsumerReconnectTransient(err) {
     return true;
   if (err instanceof SubcCallError)
     return err.kind === "not_sent" || err.kind === "outcome_unknown";
-  if (err instanceof SubcError || err instanceof ConnectionFileError || err instanceof AuthError)
+  if (err instanceof AuthError)
+    return true;
+  if (err instanceof SubcError || err instanceof ConnectionFileError)
     return false;
   const code = errorCode(err);
   return code === "ECONNREFUSED" || code === "ECONNRESET" || code === "EPIPE" || code === "ETIMEDOUT" || code === "ENOENT";
@@ -12527,14 +12552,51 @@ function causeMessage(cause) {
     return "";
   return `: ${cause instanceof Error ? cause.message : String(cause)}`;
 }
-// ../../node_modules/.bun/@cortexkit+subc-client@0.3.0/node_modules/@cortexkit/subc-client/src/provider.ts
+// ../../node_modules/.bun/@cortexkit+subc-client@0.3.4/node_modules/@cortexkit/subc-client/dist/provider.js
 import { Buffer as Buffer2 } from "node:buffer";
 var DEFAULT_HANDSHAKE_TIMEOUT_MS2 = 1e4;
 var BODY_READ_TIMEOUT_MS2 = 30000;
 var WRITE_TIMEOUT_MS = 30000;
 var DEFAULT_RESTORED_DEBOUNCE_MS = 250;
+var DEFAULT_PROVIDER_HANDLER_CAPACITY = 64;
+var HEALTH_CHECK_OP = "health.check";
 var HELLO_CORR = 1n;
 
+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((resolve7) => {
+      this.waiters.push(resolve7);
+    });
+    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 SubcProviderError extends Error {
   code;
   constructor(message, code) {
@@ -12553,6 +12615,7 @@ class SubcProvider {
   closeStarted = false;
   closedErr = null;
   inflight = new Map;
+  requestGate = new AsyncPermitPool(DEFAULT_PROVIDER_HANDLER_CAPACITY);
   reconnecting = null;
   generation = 1;
   connectionEpoch = 1;
@@ -12591,7 +12654,7 @@ class SubcProvider {
       this.cancelRestoredDebounce();
       const sock = this.sock;
       try {
-        await sendFrame(sock, buildFrame(11 /* Goodbye */, controlFlags(), 0, 0n, new Uint8Array(0)));
+        await sendFrame(sock, buildFrame(FrameType.Goodbye, controlFlags(), 0, 0n, new Uint8Array(0)));
       } catch {} finally {
         sock.close();
         this.finishClosed();
@@ -12642,21 +12705,21 @@ class SubcProvider {
   }
   async dispatch(frame, sock, generation) {
     switch (frame.header.ty) {
-      case 7 /* Ping */:
+      case FrameType.Ping:
         if (frame.header.channel === 0) {
-          await this.sendOn(sock, generation, buildFrameWithVersion(frame.header.ver, 8 /* Pong */, frame.header.flags, 0, frame.header.corr, new Uint8Array(0)));
+          await this.sendOn(sock, generation, buildFrameWithVersion(frame.header.ver, FrameType.Pong, frame.header.flags, 0, frame.header.corr, new Uint8Array(0)));
         }
         return true;
-      case 11 /* Goodbye */:
+      case FrameType.Goodbye:
         if (frame.header.channel === 0)
           return false;
         this.abortChannel(generation, frame.header.channel);
         await this.opts.onRouteGone?.(frame.header.channel);
         return true;
-      case 6 /* Cancel */:
+      case FrameType.Cancel:
         this.inflight.get(routeKey(generation, frame.header.channel, frame.header.corr))?.abort();
         return true;
-      case 0 /* Request */:
+      case FrameType.Request:
         if (frame.header.channel === 0) {
           await this.handleControlRequest(frame, sock, generation);
         } else {
@@ -12691,6 +12754,14 @@ class SubcProvider {
   }
   async handleControlRequest(frame, sock, generation) {
     const request = parseJson(frame.body);
+    if (request.op === HEALTH_CHECK_OP) {
+      this.handleHealthRequest(frame, sock, generation).catch((err) => {
+        if (!this.closeStarted && this.sock === sock && this.generation === generation) {
+          console.warn("SubcProvider health handler failed after its request was dispatched", err);
+        }
+      });
+      return;
+    }
     if (request.op !== "route.bind") {
       throw new SubcProviderError(`unsupported module control request ${request.op ?? "<missing op>"}`);
     }
@@ -12706,41 +12777,67 @@ class SubcProvider {
       await this.sendError(frame, rejection.code, rejection.message, controlFlags(), sock, generation);
       return;
     }
-    await this.sendOn(sock, generation, buildFrameWithVersion(frame.header.ver, 1 /* Response */, controlFlags(), 0, frame.header.corr, encodeJson({ op: "route.bind" })));
+    await this.sendOn(sock, generation, buildFrameWithVersion(frame.header.ver, FrameType.Response, controlFlags(), 0, frame.header.corr, encodeJson({ op: "route.bind" })));
   }
   async handleDataRequest(frame, sock, generation) {
     const { channel, corr, ver } = frame.header;
     const key = routeKey(generation, channel, corr);
     const controller = new AbortController;
     this.inflight.set(key, controller);
-    const dataFlags = buildFlags(false, 1 /* Interactive */, false);
+    const dataFlags = buildFlags(false, Priority.Interactive, false);
     const ctx = {
       signal: controller.signal,
       currentEpoch: () => this.connectionEpoch,
       emit: async (eventBody) => {
         if (controller.signal.aborted)
           return;
-        await this.sendOn(sock, generation, buildFrameWithVersion(ver, 3 /* StreamData */, dataFlags, channel, corr, eventBody));
+        await this.sendOn(sock, generation, buildFrameWithVersion(ver, FrameType.StreamData, dataFlags, channel, corr, eventBody));
       }
     };
+    const releasePermit = await (this.requestGate ?? new AsyncPermitPool(DEFAULT_PROVIDER_HANDLER_CAPACITY)).acquire();
     try {
       const body = await this.opts.handler(channel, frame.body, ctx);
       if (body === undefined) {
-        await this.sendOn(sock, generation, buildFrameWithVersion(ver, 4 /* StreamEnd */, dataFlags, channel, corr, new Uint8Array(0)));
+        await this.sendOn(sock, generation, buildFrameWithVersion(ver, FrameType.StreamEnd, dataFlags, channel, corr, new Uint8Array(0)));
       } else if (body instanceof Uint8Array) {
-        await this.sendOn(sock, generation, buildFrameWithVersion(ver, 1 /* Response */, dataFlags, channel, corr, body));
+        await this.sendOn(sock, generation, buildFrameWithVersion(ver, FrameType.Response, dataFlags, channel, corr, body));
       } else {
         throw new SubcProviderError("provider handler must return a Uint8Array or void", "invalid_handler_response");
       }
     } catch (err) {
       await this.sendError(frame, err instanceof SubcProviderError && err.code ? err.code : "handler_error", err instanceof Error ? err.message : String(err), dataFlags, sock, generation);
     } finally {
+      releasePermit();
+      if (this.inflight.get(key) === controller)
+        this.inflight.delete(key);
+    }
+  }
+  async handleHealthRequest(frame, sock, generation) {
+    const { channel, corr, ver } = frame.header;
+    const key = routeKey(generation, channel, 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(), channel, corr, encodeJson({
+        op: HEALTH_CHECK_OP,
+        status: report.status,
+        ...report.detail === undefined ? {} : { detail: report.detail },
+        ...report.metrics === undefined ? {} : { metrics: report.metrics }
+      })));
+    } catch (err) {
+      await this.sendError(frame, err instanceof SubcProviderError && err.code ? err.code : "health_error", err instanceof Error ? err.message : String(err), 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, 5 /* Error */, flags, frame.header.channel, frame.header.corr, encodeJson({ code, message })));
+    await this.sendOn(sock, generation, buildFrameWithVersion(frame.header.ver, FrameType.Error, flags, frame.header.channel, frame.header.corr, encodeJson({ code, message })));
   }
   async sendOn(sock, generation, frame) {
     if (this.sock !== sock || this.generation !== generation || this.closeStarted || this.closedErr)
@@ -12880,6 +12977,7 @@ function normalizeProviderConnectOptions(opts) {
     connectionFile: opts.connectionFile,
     manifest: opts.manifest,
     handler: opts.handler,
+    health: opts.health ?? (() => ({ status: "ok" })),
     handshakeTimeoutMs: opts.handshakeTimeoutMs,
     controlOps: opts.controlOps,
     onBind: opts.onBind,
@@ -12891,12 +12989,19 @@ function normalizeProviderConnectOptions(opts) {
     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(9 /* Hello */, controlFlags(), 0, HELLO_CORR, encodeJson({
+  return buildFrame(FrameType.Hello, controlFlags(), 0, HELLO_CORR, encodeJson({
     manifest: normalizeManifest(opts.manifest),
     protocol_ver: PROTOCOL_VERSION,
-    control_ops: opts.controlOps === undefined ? null : opts.controlOps,
+    control_ops: normalizedControlOps(opts.controlOps),
     ...nonce ? { launch_nonce: nonce } : {}
   }));
 }
@@ -12907,7 +13012,9 @@ function isProviderReconnectTransient(err) {
     return true;
   if (err instanceof SocketWriteNotQueuedError || err instanceof SocketWriteQueuedError)
     return true;
-  if (err instanceof ConnectionFileError || err instanceof AuthError)
+  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";
@@ -12924,7 +13031,7 @@ async function pauseBeforeStateRetry() {
   await new Promise((resolve7) => setTimeout(resolve7, 0));
 }
 function controlFlags() {
-  return buildFlags(false, 0 /* Passive */, false);
+  return buildFlags(false, Priority.Passive, false);
 }
 async function sendFrame(sock, frame) {
   await sock.write(encodeFrame(frame), Date.now() + WRITE_TIMEOUT_MS);
@@ -12934,9 +13041,9 @@ async function expectHelloAck(sock, deadline) {
   const body = header.len === 0 ? new Uint8Array(0) : await sock.readExact(header.len, deadline);
   const frame = { header, body };
   switch (header.ty) {
-    case 10 /* HelloAck */:
+    case FrameType.HelloAck:
       return parseJson(body);
-    case 5 /* Error */: {
+    case FrameType.Error: {
       const error2 = parseJson(body);
       throw new SubcProviderError(`subc rejected HELLO: ${error2.code ?? "unknown"} — ${error2.message ?? "subc error"}`, error2.code);
     }
@@ -13002,6 +13109,7 @@ function normalizeProviderRole(role) {
         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
         })),
@@ -13176,6 +13284,9 @@ class BgSubscription {
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function isUnknownChannelError(err) {
+  return err instanceof SubcError && err.code === "unknown_channel";
+}
 function safeCloseRoute(client, channel) {
   try {
     client.closeRouteChannel(channel).catch(() => {
@@ -13255,7 +13366,7 @@ class SubcTransport {
     if (!options)
       return {};
     const preview = options.preview;
-    const timeoutMs = options.timeoutMs;
+    const timeoutMs = options.transportTimeoutMs ?? options.timeoutMs;
     const onProgress = options.onProgress;
     return { preview, timeoutMs, onProgress };
   }
@@ -13325,45 +13436,66 @@ class SubcTransportPool {
     record.inflight += 1;
     try {
       const client = await this.ensureClient();
-      if (!this.isCurrentSession(key, record)) {
-        throw new RouteTornDownError("subc session closed");
-      }
-      let channel;
-      let entry;
-      try {
-        ({ channel, entry } = await this.routeChannel(client, identity, record));
+      const openRoute = async () => {
         if (!this.isCurrentSession(key, record)) {
           throw new RouteTornDownError("subc session closed");
         }
-      } catch (err) {
-        if (err instanceof RouteTornDownError)
+        try {
+          const opened = await this.routeChannel(client, identity, record);
+          if (!this.isCurrentSession(key, record)) {
+            throw new RouteTornDownError("subc session closed");
+          }
+          return opened;
+        } catch (err) {
+          if (err instanceof RouteTornDownError)
+            throw err;
+          if (isConsumerReconnectTransient(err) && this.isCurrentSession(key, record) && this.client === client) {
+            this.dropClient(client);
+          }
           throw err;
-        if (isConsumerReconnectTransient(err) && this.isCurrentSession(key, record) && this.client === client) {
-          this.dropClient(client);
         }
-        throw err;
-      }
-      try {
-        const reply = await client.request(channel, body, { timeoutMs, onProgress });
-        if (this.isCurrentSession(key, record) && this.client === client) {
-          this.transportFailures = 0;
-        }
-        this.ensureBgSubscription(identity, record);
-        return reply;
-      } catch (err) {
-        if (record.routeEntry === entry) {
-          entry.closed = true;
+      };
+      const clearRouteEntry = (entry2) => {
+        if (record.routeEntry === entry2) {
+          entry2.closed = true;
           record.routeEntry = null;
         }
+      };
+      const handleRequestFailure = (err, entry2) => {
+        clearRouteEntry(entry2);
         if (this.isCurrentSession(key, record) && this.client === client) {
           if (isConsumerReconnectTransient(err)) {
             this.transportFailures = 0;
             this.dropClient(client);
-          } else if (++this.transportFailures >= MAX_CONSECUTIVE_TRANSPORT_FAILURES) {
+          } else if (!isUnknownChannelError(err) && ++this.transportFailures >= MAX_CONSECUTIVE_TRANSPORT_FAILURES) {
             this.transportFailures = 0;
             this.dropClient(client);
           }
         }
+      };
+      const requestOnRoute = async (channel2) => {
+        const reply = await client.request(channel2, body, { timeoutMs, onProgress });
+        if (this.isCurrentSession(key, record) && this.client === client) {
+          this.transportFailures = 0;
+        }
+        this.ensureBgSubscription(identity, record);
+        return reply;
+      };
+      let { channel, entry } = await openRoute();
+      try {
+        return await requestOnRoute(channel);
+      } catch (err) {
+        if (isUnknownChannelError(err) && this.isCurrentSession(key, record) && this.client === client) {
+          clearRouteEntry(entry);
+          ({ channel, entry } = await openRoute());
+          try {
+            return await requestOnRoute(channel);
+          } catch (retryErr) {
+            handleRequestFailure(retryErr, entry);
+            throw retryErr;
+          }
+        }
+        handleRequestFailure(err, entry);
         throw err;
       }
     } finally {
@@ -28853,16 +28985,7 @@ var InspectConfigSchema = exports_external.object({
   tier2_soft_deadline_ms: exports_external.number().int().positive().optional(),
   max_drill_down_items: exports_external.number().int().positive().max(100).optional(),
   duplicates: exports_external.object({
-    lower_bound: exports_external.number().int().positive().optional(),
-    discard_cost: exports_external.number().int().min(0).optional(),
-    expected_mirrors: exports_external.array(exports_external.tuple([exports_external.string().trim().min(1), exports_external.string().trim().min(1)])).optional(),
-    anonymize: exports_external.object({
-      variables: exports_external.boolean().optional(),
-      fields: exports_external.boolean().optional(),
-      methods: exports_external.boolean().optional(),
-      types: exports_external.boolean().optional(),
-      literals: exports_external.boolean().optional()
-    }).optional()
+    expected_mirrors: exports_external.array(exports_external.tuple([exports_external.string().trim().min(1), exports_external.string().trim().min(1)])).optional()
   }).optional()
 });
 var BackupConfigSchema = exports_external.object({
@@ -29214,16 +29337,9 @@ function mergeInspectConfig(baseInspect, overrideInspect) {
     ...overrideInspect,
     duplicates: baseInspect?.duplicates || overrideInspect?.duplicates ? {
       ...baseInspect?.duplicates,
-      ...overrideInspect?.duplicates,
-      anonymize: baseInspect?.duplicates?.anonymize || overrideInspect?.duplicates?.anonymize ? {
-        ...baseInspect?.duplicates?.anonymize,
-        ...overrideInspect?.duplicates?.anonymize
-      } : undefined
+      ...overrideInspect?.duplicates
     } : undefined
   };
-  if (inspect.duplicates && inspect.duplicates.anonymize === undefined) {
-    delete inspect.duplicates.anonymize;
-  }
   if (Object.values(inspect).every((value) => value === undefined)) {
     return;
   }
@@ -32368,28 +32484,44 @@ function normalizeToolMap(tools) {
 async function sendIgnoredMessage2(client, sessionID, text) {
   const typedClient = client;
   let agent;
+  let model;
+  let variant;
   try {
     const ctx = await resolvePromptContext(client, sessionID);
     agent = ctx?.agent;
+    model = ctx?.model;
+    variant = ctx?.variant;
   } catch {
     agent = undefined;
   }
-  const body = {
+  const send = async (body) => {
+    const promptInput = { path: { id: sessionID }, body };
+    if (typeof typedClient.session?.prompt === "function") {
+      await Promise.resolve(typedClient.session.prompt(promptInput));
+      return;
+    }
+    if (typeof typedClient.session?.promptAsync === "function") {
+      await typedClient.session.promptAsync(promptInput);
+      return;
+    }
+    throw new Error("[aft-plugin] client.session.prompt is unavailable");
+  };
+  const base = {
     noReply: true,
     parts: [{ type: "text", text, ignored: true }]
   };
   if (agent)
-    body.agent = agent;
-  const promptInput = { path: { id: sessionID }, body };
-  if (typeof typedClient.session?.prompt === "function") {
-    await Promise.resolve(typedClient.session.prompt(promptInput));
-    return;
-  }
-  if (typeof typedClient.session?.promptAsync === "function") {
-    await typedClient.session.promptAsync(promptInput);
-    return;
+    base.agent = agent;
+  if (model) {
+    const withModel = { ...base, model };
+    if (variant)
+      withModel.variant = variant;
+    try {
+      await send(withModel);
+      return;
+    } catch {}
   }
-  throw new Error("[aft-plugin] client.session.prompt is unavailable");
+  await send(base);
 }
 
 // src/shared/rpc-notifications.ts
@@ -33434,12 +33566,15 @@ async function callBashBridge(ctx, runtime, command, params = {}, options) {
 }
 
 // src/tools/permissions.ts
+import { execFileSync as execFileSync3 } from "node:child_process";
 import * as fs4 from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
 import * as path4 from "node:path";
 var UNSUPPORTED_ASK_HOST = "AFT requires OpenCode 1.15.5 or newer for permission asks; please upgrade OpenCode";
 var RESTRICT_NOTICE_THROTTLE_MS = 5 * 60 * 1000;
 var restrictNoticeLastSentAt = new Map;
+var aftSearchExternalDecisionCache = new Map;
+var aftSearchExternalPendingAsks = new Map;
 var POSIX_SYSTEM_TEMP_ROOTS = ["/tmp", "/var/tmp", "/private/tmp", "/private/var/tmp"];
 var MACOS_SYSTEM_TEMP_ROOTS = ["/var/folders", "/private/var/folders"];
 function restrictNoticeWording(target) {
@@ -33610,6 +33745,78 @@ async function assertExternalDirectoryPermission(ctx, context, target, options)
     return "Permission denied (external directory).";
   }
 }
+function gitRootForNearestExistingParent(resolved) {
+  const nearest = normalizeNearestExistingParent(resolved);
+  let cwd = nearest;
+  try {
+    if (fs4.statSync(nearest).isFile())
+      cwd = path4.dirname(nearest);
+  } catch {}
+  try {
+    const out = execFileSync3("git", ["rev-parse", "--show-toplevel"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return out ? normalizePath(out) : undefined;
+  } catch {
+    return;
+  }
+}
+async function assertAftSearchExternalPermission(ctx, context, target) {
+  if (!target)
+    return;
+  const resolved = resolveAbsolutePath(context, target);
+  const absoluteTarget = normalizePath(resolved);
+  const externalRoot = gitRootForNearestExistingParent(resolved) ?? normalizeNearestExistingParent(resolved);
+  const root = projectRootFor(context);
+  const directory = root ? normalizePath(root) : root;
+  const rawWorktree = context.worktree;
+  const worktree = rawWorktree && rawWorktree !== "/" ? normalizePath(rawWorktree) : rawWorktree;
+  if (directory && containsPath(directory, externalRoot))
+    return;
+  if (worktree && worktree !== "/" && worktree !== directory && containsPath(worktree, externalRoot)) {
+    return;
+  }
+  if (ctx.config.restrict_to_project_root === true) {
+    notifyRestrictBlocked(ctx, context, externalRoot);
+    return restrictDenialMessage(externalRoot);
+  }
+  if (typeof context.ask !== "function")
+    return UNSUPPORTED_ASK_HOST;
+  const sessionKey = context.sessionID ?? "unknown-session";
+  const cacheKey = `${sessionKey}\x00${externalRoot}`;
+  if (aftSearchExternalDecisionCache.has(cacheKey)) {
+    return aftSearchExternalDecisionCache.get(cacheKey);
+  }
+  const pending = aftSearchExternalPendingAsks.get(cacheKey);
+  if (pending)
+    return pending;
+  const rawGlob = process.platform === "win32" ? normalizePathPattern(path4.join(externalRoot, "*")) : path4.join(externalRoot, "*").replaceAll("\\", "/");
+  const askPromise = (async () => {
+    try {
+      await runAsk(context.ask({
+        permission: "aft_search_external",
+        patterns: [rawGlob],
+        always: [rawGlob],
+        metadata: {
+          filepath: absoluteTarget,
+          root: externalRoot
+        }
+      }));
+      aftSearchExternalDecisionCache.set(cacheKey, undefined);
+      return;
+    } catch (error53) {
+      const message = error53 instanceof Error && error53.message ? error53.message : "Permission denied (aft_search_external).";
+      aftSearchExternalDecisionCache.set(cacheKey, message);
+      return message;
+    } finally {
+      aftSearchExternalPendingAsks.delete(cacheKey);
+    }
+  })();
+  aftSearchExternalPendingAsks.set(cacheKey, askPromise);
+  return askPromise;
+}
 async function askSearchPatternPermission(context, permission, pattern, metadata = {}) {
   if (typeof context.ask !== "function")
     return UNSUPPORTED_ASK_HOST;
@@ -34882,6 +35089,7 @@ function createWriteTool(ctx, editToolName = "edit") {
       const diff = data.diff;
       if (!diff)
         return output;
+      const truncated = diff.truncated === true;
       const dp = relativeToWorktree(filePath, projectRoot);
       const beforeContent = diff.before ?? "";
       const afterContent = diff.after ?? content;
@@ -34889,13 +35097,15 @@ function createWriteTool(ctx, editToolName = "edit") {
         output,
         title: dp,
         metadata: {
-          diff: buildUnifiedDiff(filePath, beforeContent, afterContent),
-          filediff: {
-            file: filePath,
-            before: beforeContent,
-            after: afterContent,
-            additions: diff?.additions ?? 0,
-            deletions: diff?.deletions ?? 0
+          diff: truncated ? typeof preview2.preview_diff === "string" ? preview2.preview_diff : "" : buildUnifiedDiff(filePath, beforeContent, afterContent),
+          ...truncated ? {} : {
+            filediff: {
+              file: filePath,
+              before: beforeContent,
+              after: afterContent,
+              additions: diff?.additions ?? 0,
+              deletions: diff?.deletions ?? 0
+            }
           },
           diagnostics: {}
         }
@@ -35016,16 +35226,19 @@ function createEditTool(ctx, writeToolName = "write") {
       const diff = data.diff;
       if (!diff)
         return output;
+      const truncated = diff.truncated === true;
       const beforeContent = diff.before ?? "";
       const afterContent = diff.after ?? "";
       const uiMeta = {
-        diff: buildUnifiedDiff(filePath, beforeContent, afterContent),
-        filediff: {
-          file: filePath,
-          before: beforeContent,
-          after: afterContent,
-          additions: diff.additions ?? 0,
-          deletions: diff.deletions ?? 0
+        diff: truncated ? typeof preview2.preview_diff === "string" ? preview2.preview_diff : "" : buildUnifiedDiff(filePath, beforeContent, afterContent),
+        ...truncated ? {} : {
+          filediff: {
+            file: filePath,
+            before: beforeContent,
+            after: afterContent,
+            additions: diff.additions ?? 0,
+            deletions: diff.deletions ?? 0
+          }
         },
         diagnostics: {}
       };
@@ -36283,7 +36496,8 @@ function semanticTools(ctx) {
       query: arg3(z15.string().describe("Concept, regex, literal text, filename, or capability to find. Examples: 'fuzzy match with whitespace tolerance', '^export', 'Cargo.lock'.")),
       topK: arg3(optionalInt(1, 100).describe("Number of results (default: 10, max: 100)")),
       hint: arg3(z15.enum(["regex", "literal", "semantic", "auto"]).optional().describe("Optional routing hint. Defaults to 'auto'.")),
-      includeTests: arg3(z15.boolean().optional().describe("Include test files (*.test.*, *_test.rs, __tests__/, …) plus test-support, fixture, mock, snapshot, and corpus files. Defaults to false."))
+      includeTests: arg3(z15.boolean().optional().describe("Include test files (*.test.*, *_test.rs, __tests__/, …) plus test-support, fixture, mock, snapshot, and corpus files. Defaults to false.")),
+      path: arg3(z15.string().optional().describe("Search a different project root (absolute or ~ path). Requires that project to have been indexed by AFT."))
     },
     execute: async (args, context) => {
       if (isEmptyParam(args.query) || typeof args.query !== "string" || args.query.trim().length === 0) {
@@ -36291,11 +36505,17 @@ function semanticTools(ctx) {
       }
       const query = args.query;
       const hint = typeof args.hint === "string" ? args.hint : undefined;
+      const pathArg = typeof args.path === "string" && args.path.trim() ? args.path.trim() : undefined;
       if (hint !== "semantic") {
         const denied = await askSearchPermission(context, query);
         if (denied)
           return permissionDeniedResponse(denied);
       }
+      if (pathArg) {
+        const denied = await assertAftSearchExternalPermission(ctx, context, pathArg);
+        if (denied)
+          return permissionDeniedResponse(denied);
+      }
       const rawArgs = { query };
       const topK = coerceOptionalInt(args.topK, "topK", 1, 100);
       if (topK !== undefined)
@@ -36304,6 +36524,8 @@ function semanticTools(ctx) {
         rawArgs.hint = hint;
       if (typeof args.includeTests === "boolean")
         rawArgs.includeTests = args.includeTests;
+      if (pathArg)
+        rawArgs.path = pathArg;
       const response = await callToolCall(ctx, context, "search", rawArgs);
       if (response.success === false) {
         const message = typeof response.text === "string" && response.text.length > 0 ? response.text : typeof response.message === "string" && response.message.length > 0 ? response.message : "semantic_search failed";
@@ -36431,13 +36653,13 @@ var PLUGIN_VERSION = (() => {
     return "0.0.0";
   }
 })();
-var ANNOUNCEMENT_VERSION = "0.45.0";
+var ANNOUNCEMENT_VERSION = "0.46.0";
 var ANNOUNCEMENT_FEATURES = [
-  "Code Health verified against 12 real repositories: dead code is only reported for languages we can actually analyze (Java/Kotlin now say 'not analyzed' instead of guessing), and generated code (gen/ trees, *_pb.ts, DO NOT EDIT banners) moves out of the headline counts into its own bucket.",
-  "Config files (playwright/eslint/tsup/vitest *.config.ts), Storybook stories, Mocha hooks, and SvelteKit hooks/$lib imports are no longer flagged as dead code.",
-  "Rust module aliases, inline-module calls, and cross-crate pub use re-exports now resolve; Go interface methods (sort.Interface, Bubble Tea) are no longer flagged dead.",
-  "Fixed npx @cortexkit/aft doctor --fix and setup failing to download the binary on fresh installs.",
-  "Bridges now detect an updated aft binary on disk and respawn onto it automatically."
+  "TUI sidebar fixed on OpenCode 1.17.x: the panel is precompiled against the host runtime (no more import failures or frozen values), and it now works when the TUI is attached to a serve/Desktop host from another directory.",
+  "Search index changes persist on clean shutdown, so restarts and cross-worktree searches see current results.",
+  "Cross-project search: sessions can search sibling checkouts read-only, serving borrowed indexes with drift warnings instead of failing.",
+  "Duplicate detection requires a 10-line minimum span, ending flags on 3-4 line idiomatic blocks.",
+  "Pi edit tool supports batch edits[] arrays, matching OpenCode."
 ];
 var ANNOUNCEMENT_FOOTER = "Join us on Discord: https://discord.gg/DSa65w8wuf";
 var plugin = async (input) => initializePluginForDirectory(input);
@@ -36755,6 +36977,7 @@ ${lines}
         return {
           success: true,
           status: "not_initialized",
+          verified_directory: verifiedDir,
           message: "AFT bridge is now spawned lazily, information here will be populated after first tool call."
         };
       }
@@ -36767,6 +36990,7 @@ ${lines}
       return {
         success: true,
         status: "not_initialized",
+        ...verifiedDir ? { verified_directory: verifiedDir } : {},
         message: "AFT bridge is now spawned lazily, information here will be populated after first tool call."
       };
     }