@cortexkit/aft-opencode 0.57.1 → 0.57.2

package/dist/index.js

@@ -10270,17 +10270,17 @@ async function renameIfPresent(from, to) {
       throw error;
   }
 }
-// ../../node_modules/.bun/@cortexkit+subc-client@0.8.1/node_modules/@cortexkit/subc-client/dist/client.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.13.1/node_modules/@cortexkit/subc-client/dist/client.js
 import { promises as fs3 } from "node:fs";
 import { debuglog } from "node:util";
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.8.1/node_modules/@cortexkit/subc-client/dist/auth.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.13.1/node_modules/@cortexkit/subc-client/dist/auth.js
 import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.8.1/node_modules/@cortexkit/subc-client/dist/socket.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.13.1/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/envelope.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.13.1/node_modules/@cortexkit/subc-client/dist/envelope.js
 var PROTOCOL_VERSION = 2;
 var HEADER_LEN = 21;
 var FROZEN_PREFIX_LEN = 5;
@@ -10322,7 +10322,7 @@ var FLAG_PRIORITY_SHIFT = 1;
 var FLAG_LAST = 8;
 var FLAG_ADMISSION_MASK = 48;
 var FLAG_ADMISSION_SHIFT = 4;
-var FLAG_RESERVED_MASK = 192;
+var FLAG_RESERVED_MASK = 0;
 function buildFlags(binary, priority, last, admissionClass = AdmissionClass.Normal) {
   let flags = 0;
   if (binary)
@@ -10333,6 +10333,9 @@ function buildFlags(binary, priority, last, admissionClass = AdmissionClass.Norm
   flags |= admissionClass << FLAG_ADMISSION_SHIFT;
   return flags;
 }
+function hasBinary(flags) {
+  return (flags & FLAG_BINARY) !== 0;
+}
 function encodeHeader(header) {
   const buffer = new Uint8Array(HEADER_LEN);
   const view = new DataView(buffer.buffer);
@@ -10449,7 +10452,7 @@ function encodeFrame(frame) {
   return output;
 }
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.8.1/node_modules/@cortexkit/subc-client/dist/socket.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.13.1/node_modules/@cortexkit/subc-client/dist/socket.js
 class SocketClosedError extends Error {
 }
 
@@ -10682,7 +10685,7 @@ class SubcSocket {
   }
 }
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.8.1/node_modules/@cortexkit/subc-client/dist/auth.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.13.1/node_modules/@cortexkit/subc-client/dist/auth.js
 var NONCE_LEN = 32;
 var MAX_AUTH_MESSAGE_LEN = 4096;
 var SERVER_PROOF_DOMAIN = "subc-server-v1";
@@ -10756,7 +10759,7 @@ async function authenticateClient(sock, conn, deadlineMs) {
   await writeMessage(sock, { client_auth: Array.from(clientAuth) }, deadlineMs);
 }
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.8.1/node_modules/@cortexkit/subc-client/dist/connection-file.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.13.1/node_modules/@cortexkit/subc-client/dist/connection-file.js
 import { promises as fs2 } from "node:fs";
 var SCHEMA_VERSION = 1;
 var MIN_KEY_LEN = 32;
@@ -10834,13 +10837,49 @@ async function readConnectionFile(path) {
   return info;
 }
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.8.1/node_modules/@cortexkit/subc-client/dist/route-handle.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.13.1/node_modules/@cortexkit/subc-client/dist/route-handle.js
 var connectionToken = new WeakMap;
+var reverseRequests = new WeakMap;
+
+class ReverseRequestRegistrationError extends Error {
+  methodFamily;
+  code = "reverse_request_capability_not_declared";
+  constructor(methodFamily) {
+    super(`reverse-request capability ${JSON.stringify(methodFamily)} was not registered before route.open`);
+    this.methodFamily = methodFamily;
+    this.name = "ReverseRequestRegistrationError";
+  }
+}
+
+class ReverseRequestRegistry {
+  handlers = new Map;
+  declaredFamilies = null;
+  onRequest(methodFamily, handler) {
+    if (!isMethodFamily(methodFamily)) {
+      throw new TypeError(`reverse-request method family must be a capability identifier, got ${JSON.stringify(methodFamily)}`);
+    }
+    if (typeof handler !== "function")
+      throw new TypeError("reverse-request handler must be a function");
+    if (this.declaredFamilies && !this.declaredFamilies.has(methodFamily)) {
+      throw new ReverseRequestRegistrationError(methodFamily);
+    }
+    this.handlers.set(methodFamily, handler);
+  }
+  capabilities() {
+    return [...this.handlers.keys()].sort();
+  }
+  handler(methodFamily) {
+    return this.handlers.get(methodFamily);
+  }
+  seal() {
+    this.declaredFamilies ??= new Set(this.handlers.keys());
+  }
+}
 
 class RouteHandle {
   channel;
   epoch;
-  constructor(channel, epoch, token) {
+  constructor(channel, epoch, token, registry) {
     if (!Number.isInteger(channel) || channel <= 0 || channel > 65535) {
       throw new RangeError(`route channel must be an integer in 1..65535, got ${channel}`);
     }
@@ -10849,16 +10888,27 @@ class RouteHandle {
     }
     this.channel = channel;
     this.epoch = epoch;
+    registry.seal();
     connectionToken.set(this, token);
+    reverseRequests.set(this, registry);
     Object.freeze(this);
   }
-  static create(channel, epoch, token) {
-    return new RouteHandle(channel, epoch, token);
+  onRequest(methodFamily, handler) {
+    reverseRequests.get(this).onRequest(methodFamily, handler);
+  }
+  static create(channel, epoch, token, registry) {
+    return new RouteHandle(channel, epoch, token, registry);
   }
 }
-function createRouteHandle(channel, epoch, token) {
+function createRouteHandle(channel, epoch, token, registry = new ReverseRequestRegistry) {
   const factory = RouteHandle;
-  return factory.create(channel, epoch, token);
+  return factory.create(channel, epoch, token, registry);
+}
+function reverseRequestHandler(handle, methodFamily) {
+  return reverseRequests.get(handle)?.handler(methodFamily);
+}
+function isMethodFamily(value) {
+  return /^[a-z][a-z0-9]*(?:[._-][a-z0-9]+)*$/.test(value);
 }
 
 class StaleRouteHandleError extends Error {
@@ -10880,7 +10930,7 @@ function sameRouteHandle(left, right) {
   return left === right;
 }
 
-// ../../node_modules/.bun/@cortexkit+subc-client@0.8.1/node_modules/@cortexkit/subc-client/dist/client.js
+// ../../node_modules/.bun/@cortexkit+subc-client@0.13.1/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;
@@ -10911,16 +10961,26 @@ class SubcCallError extends Error {
     this.cause = cause;
     this.name = "SubcCallError";
   }
+  get detail() {
+    return this.cause instanceof SubcError ? this.cause.detail : undefined;
+  }
 }
 
 class SubcError extends Error {
   code;
-  constructor(message, code) {
+  detail;
+  constructor(message, code, detail) {
     super(message);
     this.code = code;
+    this.detail = detail;
   }
 }
-
+function requireBinaryBody(body) {
+  if (body instanceof Uint8Array)
+    return body;
+  const type = body === null ? "null" : Array.isArray(body) ? "array" : typeof body;
+  throw new SubcError(`binary request body must be a Uint8Array; got ${type}`, "binary_body_required");
+}
 class SubcClient {
   sock;
   currentConn;
@@ -10957,15 +11017,34 @@ class SubcClient {
     const parsed = this.parseJson(reply);
     return parsed.modules ?? [];
   }
+  async resolveProvider(capability) {
+    const claimants = await this.resolveProviders(capability);
+    if (claimants.length === 0) {
+      throw new SubcError(`no catalog claimant for capability ${capability}`, "capability_unprovided");
+    }
+    if (claimants.length > 1) {
+      throw new SubcError(`multiple catalog claimants for capability ${capability}: ${claimants.join(", ")}`, "capability_ambiguous");
+    }
+    return claimants[0];
+  }
+  async resolveProviders(capability) {
+    if (!isValidCapabilityIdentifier(capability)) {
+      throw new SubcError(`malformed capability identifier ${JSON.stringify(capability)}`, "invalid_capability_identifier");
+    }
+    const modules = await this.catalogList();
+    return modules.filter((module) => module.capabilities?.provides.includes(capability) ?? false).map((module) => module.module_id).sort();
+  }
   async routeOpen(target, identity, opts = {}) {
     const consumerIdentity = routeOpenConsumerIdentity(opts);
-    const consumerCapabilities = opts.consumerCapabilities;
+    const reverseRequests = opts.reverseRequests ?? new ReverseRequestRegistry;
+    reverseRequests.seal();
+    const consumerCapabilities = reverseRequests.capabilities();
     const body = this.encode({
       op: "route.open",
       target,
       identity,
       ...consumerIdentity ? { consumer_identity: consumerIdentity } : {},
-      ...consumerCapabilities !== undefined ? { consumer_capabilities: consumerCapabilities } : {}
+      ...consumerCapabilities.length > 0 ? { consumer_capabilities: consumerCapabilities } : {}
     });
     let installed = null;
     const install = (frame) => {
@@ -10975,7 +11054,7 @@ class SubcClient {
       if (typeof parsed.route_channel !== "number" || typeof parsed.route_epoch !== "number") {
         throw new SubcError(`route.open returned no route handle: ${JSON.stringify(parsed)}`);
       }
-      installed = this.installRoute(parsed.route_channel, parsed.route_epoch);
+      installed = this.installRoute(parsed.route_channel, parsed.route_epoch, reverseRequests);
       return true;
     };
     const closeLateRoute = (frame) => {
@@ -11000,14 +11079,25 @@ class SubcClient {
   }
   async request(handle, body, opts = {}) {
     this.assertLiveHandle(handle);
-    const bytes = body instanceof Uint8Array ? body : this.encode(body);
+    const binary = opts.binary ?? false;
+    const bytes = binary ? requireBinaryBody(body) : body instanceof Uint8Array ? body : this.encode(body);
     const priority = opts.priority ?? Priority.Interactive;
     const admission = opts.admissionClass ?? AdmissionClass.Normal;
-    const reply = await this.send(handle, bytes, priority, admission, opts.timeoutMs, opts.onProgress);
-    return this.parseJson(reply);
+    const reply = await this.send(handle, bytes, priority, admission, opts.timeoutMs, opts.onProgress, undefined, undefined, binary, opts.signal);
+    return this.decodeReply(reply);
   }
   async call(moduleId, method, params, opts = {}) {
+    if (opts.binary) {
+      throw new SubcError("call() builds a JSON body and cannot send a binary request; use callBinary(moduleId, body, opts) with a Uint8Array", "binary_call_requires_call_binary");
+    }
     const body = params === undefined ? { method } : { method, params };
+    return await this.managedCall(moduleId, body, opts);
+  }
+  async callBinary(moduleId, body, opts = {}) {
+    const bytes = requireBinaryBody(body);
+    return this.managedCall(moduleId, bytes, { ...opts, binary: true });
+  }
+  async managedCall(moduleId, body, opts) {
     let retriedUnknownChannel = false;
     for (;; ) {
       const routeHandle = await this.cachedRouteHandle(moduleId, opts);
@@ -11085,6 +11175,22 @@ class SubcClient {
     };
     return { unsubscribe, closed };
   }
+  attachCancelSignal(signal, key, handle, corr, priority) {
+    if (!handle)
+      return;
+    const emit = () => {
+      if (!this.pending.has(key))
+        return;
+      try {
+        this.cancel(handle, corr, priority);
+      } catch {}
+    };
+    if (signal.aborted) {
+      emit();
+      return;
+    }
+    signal.addEventListener("abort", emit, { once: true });
+  }
   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);
@@ -11125,7 +11231,7 @@ class SubcClient {
     this.sendRouteGoodbye(handle);
   }
   async closeManagedRoute(target, identity, opts = {}) {
-    const key = routeCacheKey(target, identity, routeOpenConsumerIdentity(opts));
+    const key = routeCacheKey(target, identity, routeOpenConsumerIdentity(opts), (opts.reverseRequests ?? new ReverseRequestRegistry).capabilities());
     const cached = this.routes.get(key);
     if (!cached)
       return;
@@ -11193,7 +11299,7 @@ class SubcClient {
   async controlRpc(body, acceptFrame, onLateResponse) {
     return this.send(null, body, Priority.Interactive, AdmissionClass.Normal, undefined, undefined, acceptFrame, onLateResponse);
   }
-  send(handle, body, priority, admission, timeoutMs, onProgress, acceptFrame, onLateResponse) {
+  send(handle, body, priority, admission, timeoutMs, onProgress, acceptFrame, onLateResponse, binary = false, signal) {
     if (handle)
       this.assertLiveHandle(handle);
     if (this.closedErr)
@@ -11207,7 +11313,7 @@ class SubcClient {
     const key = pendingKey(handle, corr);
     const channel = handle?.channel ?? 0;
     const epoch = handle?.epoch ?? 0;
-    const frame = buildFrame(FrameType.Request, buildFlags(false, priority, false, admission), channel, epoch, corr, body);
+    const frame = buildFrame(FrameType.Request, buildFlags(binary, priority, false, admission), channel, epoch, corr, body);
     return new Promise((resolve, reject) => {
       const ms = timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
       const pending = {
@@ -11221,6 +11327,8 @@ class SubcClient {
       };
       pending.timer = setTimeout(() => this.arbitrateTimeout(key, pending, channel, corr, ms), ms);
       this.pending.set(key, pending);
+      if (signal)
+        this.attachCancelSignal(signal, key, handle, corr, priority);
       writeBorrowed(this.sock, encodeFrame(frame), Date.now() + ms).catch((error) => {
         const current = this.pending.get(key);
         if (current)
@@ -11248,19 +11356,20 @@ class SubcClient {
     setImmediate(arbitrate);
   }
   async managedRequest(handle, body, opts) {
-    const bytes = body instanceof Uint8Array ? body : this.encode(body);
+    const binary = opts.binary ?? false;
+    const bytes = binary ? requireBinaryBody(body) : body instanceof Uint8Array ? body : this.encode(body);
     const priority = opts.priority ?? Priority.Interactive;
     const admission = opts.admissionClass ?? AdmissionClass.Normal;
     try {
-      const reply = await this.sendManaged(handle, bytes, priority, admission, opts.timeoutMs, opts.onProgress);
-      return this.parseJson(reply);
+      const reply = await this.sendManaged(handle, bytes, priority, admission, opts.timeoutMs, opts.onProgress, binary, opts.signal);
+      return this.decodeReply(reply);
     } catch (error) {
       if (error instanceof SubcCallError)
         throw error;
       throw this.terminalCallError("managed call failed", error);
     }
   }
-  sendManaged(handle, body, priority, admission, timeoutMs, onProgress) {
+  sendManaged(handle, body, priority, admission, timeoutMs, onProgress, binary = false, signal) {
     try {
       this.assertLiveHandle(handle);
     } catch (error) {
@@ -11276,7 +11385,7 @@ class SubcClient {
       return Promise.reject(this.notSentCallError("request correlation allocator was exhausted", error));
     }
     const key = pendingKey(handle, corr);
-    const frame = buildFrame(FrameType.Request, buildFlags(false, priority, false, admission), handle.channel, handle.epoch, corr, body);
+    const frame = buildFrame(FrameType.Request, buildFlags(binary, priority, false, admission), handle.channel, handle.epoch, corr, body);
     let handedToSocket = false;
     const classifyFailure = (error) => {
       if (!handedToSocket)
@@ -11298,6 +11407,8 @@ class SubcClient {
       };
       pending.timer = setTimeout(() => this.arbitrateTimeout(key, pending, handle.channel, corr, ms), ms);
       this.pending.set(key, pending);
+      if (signal)
+        this.attachCancelSignal(signal, key, handle, corr, priority);
       const write = writeTrackedBorrowed(this.sock, encodeFrame(frame), Date.now() + ms);
       handedToSocket = write.queued;
       write.completed.catch((error) => {
@@ -11314,7 +11425,9 @@ class SubcClient {
     }
     const target = { kind: opts.targetKind ?? this.opts.targetKind, module_id: moduleId };
     const consumerIdentity = routeOpenConsumerIdentity(opts);
-    const key = routeCacheKey(target, identity, consumerIdentity);
+    const reverseRequests = opts.reverseRequests ?? new ReverseRequestRegistry;
+    reverseRequests.seal();
+    const key = routeCacheKey(target, identity, consumerIdentity, reverseRequests.capabilities());
     let cached = this.routes.get(key);
     if (!cached) {
       cached = {
@@ -11323,6 +11436,7 @@ class SubcClient {
         target,
         identity,
         consumerIdentity,
+        reverseRequests,
         handle: null,
         opening: null
       };
@@ -11338,7 +11452,7 @@ class SubcClient {
     return cached.opening;
   }
   async openCachedRoute(cached) {
-    const routeRetryDeadline = Date.now() + ROUTE_OPEN_RETRY_DEADLINE_MS;
+    const routeRetryDeadline = Date.now() + this.opts.routeOpenRetryDeadlineMs;
     let routeRetryDelay = this.opts.reconnectBackoff.baseMs;
     let routeRetryAttempt = 0;
     for (;; ) {
@@ -11353,7 +11467,8 @@ class SubcClient {
         return cached.handle;
       try {
         const handle = await this.routeOpen(cached.target, cached.identity, {
-          consumerIdentity: cached.consumerIdentity ?? null
+          consumerIdentity: cached.consumerIdentity ?? null,
+          reverseRequests: cached.reverseRequests
         });
         if (cached.closed) {
           this.liveRoutes.delete(handle.channel);
@@ -11375,12 +11490,12 @@ class SubcClient {
         }
         if (!this.closeStarted && error instanceof SubcError && isRetryableRouteOpenCode(error.code)) {
           routeRetryAttempt += 1;
-          if (routeRetryAttempt < this.opts.reconnectBackoff.maxAttempts && Date.now() < routeRetryDeadline) {
+          if (Date.now() < routeRetryDeadline) {
             await this.opts.sleep(routeRetryDelay);
             routeRetryDelay = Math.min(routeRetryDelay * 2, this.opts.reconnectBackoff.capMs);
             continue;
           }
-          throw this.notSentCallError(`route.open failed for module ${cached.moduleId}: ${error.code} (retry budget exhausted)`, error);
+          throw this.notSentCallError(`route.open failed for module ${cached.moduleId}: ${error.code} (retry deadline exhausted after ${routeRetryAttempt} attempts)`, error);
         }
         throw this.terminalCallError(`route.open failed for module ${cached.moduleId}`, error);
       }
@@ -11492,20 +11607,34 @@ class SubcClient {
     this.readLoop(opened.sock, this.generation);
   }
   async reopenCachedRoutes() {
-    for (const cached of this.routes.values())
-      cached.handle = null;
-    for (const cached of this.routes.values()) {
-      if (cached.closed)
-        continue;
-      const handle = await this.routeOpen(cached.target, cached.identity, {
-        consumerIdentity: cached.consumerIdentity ?? null
-      });
-      if (cached.closed) {
-        this.liveRoutes.delete(handle.channel);
-        this.sendRouteGoodbye(handle);
+    const routeKeys = [...this.routes.keys()];
+    for (const key of routeKeys) {
+      const cached = this.routes.get(key);
+      if (cached)
+        cached.handle = null;
+    }
+    for (const key of routeKeys) {
+      const cached = this.routes.get(key);
+      if (!cached || cached.closed)
         continue;
+      try {
+        const handle = await this.routeOpen(cached.target, cached.identity, {
+          consumerIdentity: cached.consumerIdentity ?? null,
+          reverseRequests: cached.reverseRequests
+        });
+        if (cached.closed) {
+          this.liveRoutes.delete(handle.channel);
+          this.sendRouteGoodbye(handle);
+          continue;
+        }
+        cached.handle = handle;
+      } catch (error) {
+        if (isRouteOpenRefusal(error)) {
+          this.routes.delete(key);
+          continue;
+        }
+        throw error;
       }
-      cached.handle = handle;
     }
   }
   timeoutMessage(channel, corr, ms) {
@@ -11563,6 +11692,10 @@ class SubcClient {
         return;
       }
     }
+    if (frame.header.ty === FrameType.Request && handle) {
+      this.dispatchReverseRequest(frame, handle);
+      return;
+    }
     const key = pendingKey(handle, frame.header.corr);
     const pending = this.pending.get(key);
     if (pending) {
@@ -11616,10 +11749,49 @@ class SubcClient {
   rejectPending(key, pending, err) {
     this.settle(key, pending, () => pending.reject(pending.classifyFailure?.(err) ?? err));
   }
+  dispatchReverseRequest(frame, handle) {
+    const method = reverseRequestMethod(frame.body);
+    const methodFamily = method?.split("/", 1)[0];
+    const handler = methodFamily ? reverseRequestHandler(handle, methodFamily) : undefined;
+    const sock = this.sock;
+    const generation = this.generation;
+    const reply = async () => {
+      if (!handler || !method) {
+        await this.sendReverseError(frame, handle, "reverse_request_unhandled", methodFamily ? `no reverse-request handler is registered for ${methodFamily}` : "reverse request has no valid method", sock, generation);
+        return;
+      }
+      let body;
+      try {
+        body = await handler(frame.body, { corr: frame.header.corr, method });
+        if (!(body instanceof Uint8Array)) {
+          throw new TypeError("reverse-request handler must return a Uint8Array");
+        }
+      } catch (error) {
+        await this.sendReverseError(frame, handle, "reverse_request_unhandled", error instanceof Error ? error.message : String(error), sock, generation);
+        return;
+      }
+      await this.sendReverseReply(frame, handle, FrameType.Response, body, sock, generation);
+    };
+    reply().catch((error) => {
+      if (this.sock === sock && this.generation === generation && !this.closeStarted) {
+        debug("failed to answer reverse request: %s", causeMessage(error));
+      }
+    });
+  }
+  async sendReverseError(request, handle, code, message, sock, generation) {
+    await this.sendReverseReply(request, handle, FrameType.Error, this.encode({ code, message }), sock, generation);
+  }
+  async sendReverseReply(request, handle, type, body, sock, generation) {
+    if (this.sock !== sock || this.generation !== generation || !this.isLiveHandle(handle) || this.closeStarted || this.closedErr) {
+      return;
+    }
+    const frame = buildFrame(type, buildFlags(false, Priority.Interactive, false), handle.channel, handle.epoch, request.header.corr, body);
+    await writeBorrowed(sock, encodeFrame(frame), Date.now() + DEFAULT_REQUEST_TIMEOUT_MS);
+  }
   errorFromFrame(frame) {
     try {
       const parsed = JSON.parse(Buffer.from(frame.body).toString("utf8"));
-      return new SubcError(parsed.message ?? "subc error", parsed.code);
+      return new SubcError(parsed.message ?? "subc error", parsed.code, parsed.detail);
     } catch {
       return new SubcError(Buffer.from(frame.body).toString("utf8") || "subc error");
     }
@@ -11664,8 +11836,8 @@ class SubcClient {
   get droppedIngressFrames() {
     return this.ingressEpochDropCount;
   }
-  installRoute(channel, epoch) {
-    const handle = createRouteHandle(channel, epoch, this.connectionToken);
+  installRoute(channel, epoch, reverseRequests = new ReverseRequestRegistry) {
+    const handle = createRouteHandle(channel, epoch, this.connectionToken, reverseRequests);
     this.liveRoutes.set(channel, handle);
     return handle;
   }
@@ -11702,6 +11874,9 @@ class SubcClient {
   encode(value) {
     return Buffer.from(JSON.stringify(value), "utf8");
   }
+  decodeReply(frame) {
+    return hasBinary(frame.header.flags) ? frame.body : this.parseJson(frame);
+  }
   parseJson(frame) {
     const b = frame.body;
     return JSON.parse(Buffer.from(b.buffer, b.byteOffset, b.byteLength).toString("utf8"));
@@ -11721,7 +11896,12 @@ function isConsumerReconnectTransient(err) {
   const code = errorCode(err);
   return code === "ECONNREFUSED" || code === "ECONNRESET" || code === "EPIPE" || code === "ETIMEDOUT" || code === "ENOENT";
 }
+function isRouteOpenRefusal(err) {
+  return err instanceof SubcError && typeof err.code === "string";
+}
 function isRetryableRouteOpenCode(code) {
+  if (code === "capability_forbidden")
+    return false;
   return code === "unknown_module" || code === "module_reloading" || code === "module_warming" || code === "target_unavailable" || code === "module_timeout";
 }
 async function connectionFileExists(path) {
@@ -11740,14 +11920,35 @@ function normalizeConnectOptions(opts) {
     targetKind: opts.targetKind ?? DEFAULT_MANAGED_TARGET_KIND,
     reconnectBackoff: opts.reconnectBackoff ?? DEFAULT_RECONNECT_BACKOFF,
     sleep: opts.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms))),
+    routeOpenRetryDeadlineMs: opts.routeOpenRetryDeadlineMs ?? ROUTE_OPEN_RETRY_DEADLINE_MS,
     timeoutArbitrationGraceMs: opts.timeoutArbitrationGraceMs ?? TIMEOUT_ARBITRATION_GRACE_MS,
     livenessProbeWindowMs: opts.livenessProbeWindowMs ?? LIVENESS_PROBE_WINDOW_MS,
     onControlPush: opts.onControlPush
   };
 }
-function routeCacheKey(target, identity, consumerIdentity) {
+function isValidCapabilityIdentifier(identifier) {
+  if (/\s/u.test(identifier))
+    return false;
+  const separator = identifier.indexOf("/v");
+  if (separator <= 0 || identifier.indexOf("/v", separator + 1) !== -1)
+    return false;
+  const name = identifier.slice(0, separator);
+  const version = identifier.slice(separator + 2);
+  if (new TextEncoder().encode(name).byteLength > 64 || version.length === 0)
+    return false;
+  if (!/^[a-z][a-z0-9-]*[a-z0-9]$/u.test(name) && !/^[a-z]$/u.test(name))
+    return false;
+  if (name.includes("--"))
+    return false;
+  if (!/^\d+$/u.test(version) || version.length > 1 && version.startsWith("0"))
+    return false;
+  const numericVersion = Number(version);
+  return Number.isSafeInteger(numericVersion) && numericVersion >= 1 && numericVersion <= 4294967295;
+}
+function routeCacheKey(target, identity, consumerIdentity, consumerCapabilities) {
   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}`;
+  const capabilitiesPart = [...consumerCapabilities].sort().join("\x00");
+  return `${target.kind}\x00${target.module_id}\x00${identity.project_root}\x00${identity.harness}\x00${identity.session}\x00${consumerPart}\x00${capabilitiesPart}`;
 }
 function routeOpenConsumerIdentity(opts = {}) {
   if (opts.consumerIdentity !== undefined)
@@ -11774,6 +11975,14 @@ function causeMessage(cause) {
 function pendingKey(handle, corr) {
   return handle ? `${handle.channel}:${handle.epoch}:${corr}` : `0:0:${corr}`;
 }
+function reverseRequestMethod(body) {
+  try {
+    const parsed = JSON.parse(Buffer.from(body).toString("utf8"));
+    return typeof parsed.method === "string" && parsed.method.length > 0 ? parsed.method : undefined;
+  } catch {
+    return;
+  }
+}
 // ../aft-bridge/dist/subc-transport.js
 import { existsSync as existsSync4, statSync as statSync3 } from "node:fs";
 
@@ -12261,8 +12470,16 @@ var AFT_MODULE_ID = "aft";
 var MAX_CONSECUTIVE_TRANSPORT_FAILURES = 3;
 var RECONNECT_RETRY_FLOOR_MS = 100;
 var RECONNECT_RETRY_CAP_MS = 2000;
-var ROUTE_OPEN_RELOAD_WAIT_CAP_MS = 15000;
-var ROUTE_OPEN_RELOAD_WAIT_EXHAUSTED_SUFFIX = " The AFT daemon module did not return within the 15s reload window.";
+var SUBC_DEFAULT_REQUEST_TIMEOUT_MS = 30000;
+var ROUTE_OPEN_RELOAD_WAIT_CEILING_MS = 45000;
+function reloadWaitExhaustedSuffix(callDeadlineMs) {
+  if (callDeadlineMs > ROUTE_OPEN_RELOAD_WAIT_CEILING_MS) {
+    const ceilingSeconds = ROUTE_OPEN_RELOAD_WAIT_CEILING_MS / 1000;
+    return ` The AFT daemon module did not return within the ${ceilingSeconds}s reload-wait ceiling.`;
+  }
+  const seconds = Math.round(callDeadlineMs / 100) / 10;
+  return ` The AFT daemon module did not return within this call's ${seconds}s deadline.`;
+}
 var BG_STABLE_MS = 5000;
 function reconnectBackoffMs(attempt) {
   return Math.min(RECONNECT_RETRY_FLOOR_MS * 2 ** Math.min(attempt, 6), RECONNECT_RETRY_CAP_MS);
@@ -12571,14 +12788,15 @@ function isAbsentRootRouteError(err) {
 function absentRootError(root) {
   return new SubcError(`invalid route project root: project root does not exist: ${root}`, "config_divergence");
 }
-function reloadWindowExhaustedError(error) {
+function reloadWindowExhaustedError(error, callDeadlineMs) {
+  const suffix = reloadWaitExhaustedSuffix(callDeadlineMs);
   if (error instanceof Error) {
     try {
-      error.message += ROUTE_OPEN_RELOAD_WAIT_EXHAUSTED_SUFFIX;
+      error.message += suffix;
       return error;
     } catch {}
   }
-  return new Error(`${String(error)}${ROUTE_OPEN_RELOAD_WAIT_EXHAUSTED_SUFFIX}`);
+  return new Error(`${String(error)}${suffix}`);
 }
 function safeCloseRoute(client, route) {
   try {
@@ -13183,18 +13401,20 @@ class SubcTransportPool {
           throw error;
         }
       };
+      const callDeadlineMs = timeoutMs ?? SUBC_DEFAULT_REQUEST_TIMEOUT_MS;
+      const reloadWaitBudgetMs = Math.min(callDeadlineMs, ROUTE_OPEN_RELOAD_WAIT_CEILING_MS);
+      let reloadWaitedMs = 0;
       const openRouteAfterReloadWindow = async () => {
-        let reloadWaitedMs = 0;
         while (true) {
           try {
             return await openRoute();
           } catch (error) {
             if (!isRouteOpenReloadWindowError(error))
               throw error;
-            const { delayMs, wait } = this.waitForRouteReopenBackoff();
-            if (reloadWaitedMs + delayMs > ROUTE_OPEN_RELOAD_WAIT_CAP_MS) {
-              throw reloadWindowExhaustedError(error);
+            if (reloadWaitedMs + this.nextRouteReopenDelayMs() >= reloadWaitBudgetMs) {
+              throw reloadWindowExhaustedError(error, callDeadlineMs);
             }
+            const { delayMs, wait } = this.waitForRouteReopenBackoff();
             reloadWaitedMs += delayMs;
             await wait;
           }
@@ -13240,7 +13460,8 @@ class SubcTransportPool {
         };
         abortSignal?.addEventListener("abort", onAbort, { once: true });
         try {
-          const request = client.request(route, body, { timeoutMs, onProgress });
+          const requestTimeoutMs = reloadWaitedMs > 0 ? callDeadlineMs - reloadWaitedMs : timeoutMs;
+          const request = client.request(route, body, { timeoutMs: requestTimeoutMs, onProgress });
           const reply = abortSignal ? await Promise.race([request, aborted]) : await request;
           if (!this.isCurrentSession(key, record)) {
             if (this.isReapInduced(record))
@@ -13257,28 +13478,41 @@ class SubcTransportPool {
         }
       };
       let routeAndEntry = await openRouteAfterReloadWindow();
-      try {
-        return await requestOnRoute(routeAndEntry.route, routeAndEntry.entry);
-      } catch (error) {
-        if (this.isReapInduced(record))
-          throw this.annotateReapError(error, record);
-        if (isRouteProvenAbsentError(error) && this.isCurrentSession(key, record) && this.client === client) {
-          clearRouteEntry(routeAndEntry.entry);
-          await this.waitForRouteReopenBackoff().wait;
-          routeAndEntry = await openRouteAfterReloadWindow();
-          try {
-            const reply = await requestOnRoute(routeAndEntry.route, routeAndEntry.entry);
+      let reopened = false;
+      let retriedAbsentRoute = false;
+      while (true) {
+        try {
+          const reply = await requestOnRoute(routeAndEntry.route, routeAndEntry.entry);
+          if (reopened)
             this.resetRouteReopenBackoff();
-            return reply;
-          } catch (retryError) {
-            if (this.isReapInduced(record))
-              throw this.annotateReapError(retryError, record);
-            handleRequestFailure(retryError, routeAndEntry.entry);
-            throw retryError;
+          return reply;
+        } catch (error) {
+          if (this.isReapInduced(record))
+            throw this.annotateReapError(error, record);
+          const ownsRoute = this.isCurrentSession(key, record) && this.client === client;
+          if (ownsRoute && isRouteRequestReloadRefusal(error)) {
+            clearRouteEntry(routeAndEntry.entry);
+            if (reloadWaitedMs + this.nextRouteReopenDelayMs() >= reloadWaitBudgetMs) {
+              throw reloadWindowExhaustedError(error, callDeadlineMs);
+            }
+            const { delayMs, wait } = this.waitForRouteReopenBackoff();
+            reloadWaitedMs += delayMs;
+            await wait;
+            routeAndEntry = await openRouteAfterReloadWindow();
+            reopened = true;
+            continue;
+          }
+          if (ownsRoute && !retriedAbsentRoute && isRouteProvenAbsentError(error)) {
+            retriedAbsentRoute = true;
+            clearRouteEntry(routeAndEntry.entry);
+            await this.waitForRouteReopenBackoff().wait;
+            routeAndEntry = await openRouteAfterReloadWindow();
+            reopened = true;
+            continue;
           }
+          handleRequestFailure(error, routeAndEntry.entry);
+          throw error;
         }
-        handleRequestFailure(error, routeAndEntry.entry);
-        throw error;
       }
     } catch (error) {
       if (this.isReapInduced(record))
@@ -13307,6 +13541,11 @@ class SubcTransportPool {
     this.routeReopenRetryMs = delayMs;
     return { delayMs, wait: retry };
   }
+  nextRouteReopenDelayMs() {
+    if (this.routeReopenRetry && this.routeReopenRetryMs !== null)
+      return this.routeReopenRetryMs;
+    return this.routeReopenRetryDelayMs;
+  }
   resetRouteReopenBackoff() {
     this.routeReopenRetryDelayMs = RECONNECT_RETRY_FLOOR_MS;
   }
@@ -13598,6 +13837,12 @@ function isRouteOpenReloadWindowError(error) {
   const code = error.code;
   return code === "module_reloading" || code === "module_warming" || code === "target_unavailable";
 }
+function isRouteRequestReloadRefusal(error) {
+  if (error instanceof SubcCallError) {
+    return error.kind === "not_sent" && error.code === "module_reloading";
+  }
+  return error instanceof SubcError && error.code === "module_reloading";
+}
 function hasEngineResponse(error) {
   const response = error.response;
   if (response !== null && typeof response === "object")
@@ -21626,6 +21871,13 @@ function sessionWarn(sessionId, message, data) {
 function sessionError(sessionId, message, data) {
   write("ERROR", message, data, sessionId);
 }
+function flushLog() {
+  if (flushTimer) {
+    clearTimeout(flushTimer);
+    flushTimer = null;
+  }
+  flush();
+}
 var bridgeLogger = {
   log(message, meta) {
     sessionLog(meta?.sessionId, message);
@@ -40576,6 +40828,7 @@ function coerceAftStatus(response) {
     },
     compression: readCompression(response.compression),
     status_bar: readStatusBar(response.status_bar),
+    status_bar_values: readStatusBar(response.status_bar_values),
     message: readString(response.message, "")
   };
 }
@@ -40919,14 +41172,13 @@ function isSystemTempPath(target) {
   const normalizedTarget = normalizePath(target);
   return systemTempRoots().some((root) => containsPath(normalizePath(root), normalizedTarget));
 }
-function isBashTaskArtifactPath(target) {
-  const storageRoot = normalizePath(resolveAftStorageRoot());
-  const normalizedTarget = normalizePath(target);
-  if (!containsPath(storageRoot, normalizedTarget))
+async function isSessionOwnedBashArtifact(ctx, context, target) {
+  try {
+    const response = await callBridge(ctx, context, "bash_artifact_owned", { path: target });
+    return response.success !== false && response.owned === true;
+  } catch {
     return false;
-  const relative = normalizedTarget.slice(storageRoot.length).replace(/^[/\\]+/, "");
-  const segments = relative.split(/[/\\]+/);
-  return segments.length === 4 && segments[1] === "bash-tasks";
+  }
 }
 function windowsPath(p) {
   if (process.platform !== "win32")
@@ -40990,7 +41242,7 @@ async function assertExternalDirectoryPermission(ctx, context, target, options)
   }
   if (isSystemTempPath(absoluteTarget))
     return;
-  if (options?.serverValidatedRead === true && isBashTaskArtifactPath(absoluteTarget)) {
+  if (options?.serverValidatedRead === true && await isSessionOwnedBashArtifact(ctx, context, absoluteTarget)) {
     return;
   }
   if (typeof context.ask !== "function")
@@ -41565,6 +41817,9 @@ var z4 = tool.schema;
 var METADATA_PREVIEW_LIMIT = 30 * 1024;
 var DEFAULT_HARD_TIMEOUT_MS = 30 * 60 * 1000;
 var BASH_TRANSPORT_MARGIN_MS = 1e4;
+var ABORT_REGISTRATION_WAIT_MS = 5000;
+var ABORT_REGISTRATION_POLL_MS = 25;
+var ABORT_ATTEMPT_TIMEOUT_MS = 1000;
 function resolveForegroundWaitMs(configured) {
   const override = process.env.AFT_TEST_FOREGROUND_WAIT_MS;
   if (override !== undefined) {
@@ -41578,20 +41833,75 @@ function orchestratedTransportTimeoutMs(blockToCompletion, wait, effectiveTimeou
   const waitBudget = blockToCompletion || wait ? effectiveTimeout ?? DEFAULT_HARD_TIMEOUT_MS : foregroundWaitMs;
   return waitBudget + BASH_TRANSPORT_MARGIN_MS;
 }
+async function abortForegroundWhenRegistered(ctx, runtime, disposed) {
+  const startedAt = Date.now();
+  const deadline = startedAt + ABORT_REGISTRATION_WAIT_MS;
+  const results = [];
+  let attempts = 0;
+  let lastResponse;
+  let lastError;
+  let outcome = "timed_out";
+  while (Date.now() < deadline) {
+    if (disposed()) {
+      outcome = "call_settled";
+      break;
+    }
+    attempts += 1;
+    try {
+      lastResponse = await callBashBridge(ctx, runtime, "bash_abort_inflight", {}, {
+        transportTimeoutMs: Math.max(1, Math.min(ABORT_ATTEMPT_TIMEOUT_MS, deadline - Date.now()))
+      });
+      lastError = undefined;
+      recordAbortAttempt(results, `killed=${String(lastResponse.killed)}`);
+      if (typeof lastResponse.killed === "number" && lastResponse.killed > 0) {
+        outcome = "killed";
+        break;
+      }
+    } catch (error) {
+      lastError = error instanceof Error ? error.message : String(error);
+      recordAbortAttempt(results, `error=${lastError}`);
+    }
+    if (disposed()) {
+      outcome = "call_settled";
+      break;
+    }
+    if (Date.now() >= deadline)
+      break;
+    await sleep(Math.min(ABORT_REGISTRATION_POLL_MS, deadline - Date.now()));
+  }
+  sessionLog(runtime.sessionID, `[bash] foreground abort ${outcome}`, {
+    attempts,
+    elapsed_ms: Date.now() - startedAt,
+    results,
+    ...results.length < attempts ? { results_omitted: attempts - results.length } : {},
+    last_response: lastResponse,
+    last_error: lastError
+  });
+  flushLog();
+}
+var ABORT_ATTEMPT_RESULTS_KEPT = 20;
+function recordAbortAttempt(results, result) {
+  if (results.length < ABORT_ATTEMPT_RESULTS_KEPT)
+    results.push(result);
+}
 function listenForForegroundAbort(ctx, runtime, enabled) {
   if (!enabled)
     return () => {};
   let fired = false;
+  let disposed = false;
   const onAbort = () => {
     if (fired)
       return;
     fired = true;
-    callBashBridge(ctx, runtime, "bash_abort_inflight").catch(() => {});
+    abortForegroundWhenRegistered(ctx, runtime, () => disposed);
   };
   runtime.abort.addEventListener("abort", onAbort, { once: true });
   if (runtime.abort.aborted)
     onAbort();
-  return () => runtime.abort.removeEventListener("abort", onAbort);
+  return () => {
+    disposed = true;
+    runtime.abort.removeEventListener("abort", onAbort);
+  };
 }
 function userMessageDetachDescription(detachOnUserMessage) {
   return detachOnUserMessage ? "A new user message detaches this wait. Set `bash.detach_on_user_message: false` to keep it blocking; even then, a message containing the literal `&detach` forces detachment, and the token is stripped before delivery and the rest of the message is preserved; a token-only message becomes `(requested background detach)`." : "Because `bash.detach_on_user_message` is false, a new user message leaves this wait blocking; include the literal `&detach` anywhere to force detachment, and the token is stripped before delivery and the rest of the message is preserved; a token-only message becomes `(requested background detach)`.";