@cortexkit/aft-bridge 0.61.0 → 0.62.0

package/dist/subc-transport.js

@@ -17,7 +17,7 @@
  * published plugin dist; it is never a published runtime dependency.
  */
 import { statSync } from "node:fs";
-import { AuthError, connectionFileExists, isConsumerReconnectTransient, routeCloseReason, SocketTimeoutError, StaleRouteHandleError, SubcCallError, SubcClient, SubcError, } from "@cortexkit/subc-client";
+import { AuthError, connectionFileExists, isConsumerReconnectTransient, routeCloseReason, SocketClosedError, SocketTimeoutError, StaleRouteHandleError, SubcCallError, SubcClient, SubcError, } from "@cortexkit/subc-client";
 import { log, warn } from "./active-logger.js";
 import { isTerminalStatus } from "./bash-format.js";
 import { isRouteOpenReloadWindowError, isRouteRequestReloadRefusal } from "./error-contract.js";
@@ -171,6 +171,81 @@ export function isSocketDeathError(error, depth = 0) {
     }
     return isConsumerReconnectTransient(error) || isSubcClientClosedError(error);
 }
+/** Typed system codes for a reset or broken connected socket. */
+const REQUEST_CONNECTION_LOSS_CODES = new Set(["ECONNABORTED", "ECONNRESET", "EPIPE"]);
+function hasRequestConnectionLossCode(error) {
+    if (typeof error !== "object" || error === null || !("code" in error))
+        return false;
+    return typeof error.code === "string" && REQUEST_CONNECTION_LOSS_CODES.has(error.code);
+}
+function hasRequestConnectionLossEvidence(error, depth = 0) {
+    if (error instanceof SocketClosedError)
+        return true;
+    if (error instanceof SubcError && error.closeReason === "connection_lost")
+        return true;
+    if (hasRequestConnectionLossCode(error))
+        return true;
+    if (!(error instanceof SubcCallError) ||
+        error.kind !== "outcome_unknown" ||
+        depth >= 4 ||
+        error.cause === undefined ||
+        error.cause === error) {
+        return false;
+    }
+    return hasRequestConnectionLossEvidence(error.cause, depth + 1);
+}
+/**
+ * A raw request first checks `closedErr`, then records itself pending and starts
+ * `writeBorrowed` in the same synchronous send(). A later read-loop failure goes
+ * through fail(), which rejects route-pending requests as SubcError with
+ * closeReason="connection_lost". That proves the request write was attempted,
+ * but the raw request API does not expose whether the socket queued those bytes;
+ * the outcome must therefore stay unknown, not be retried.
+ *
+ * The timer path is different: it rejects with code="request_deadline" while
+ * leaving the shared socket potentially live. Read/body timeouts reach fail() and
+ * get the connection-lost close reason; a direct SocketTimeoutError from writing
+ * can be before or after queueing. The socket's queued/not-queued write wrappers
+ * are stripped by the raw write helper, so neither a bare timeout nor a bare
+ * SocketClosedError alone identifies the write state. The latter remains
+ * supported for older clients that rejected pending calls with that class.
+ * Explicit kind="not_sent" is authoritative and always wins over these shapes.
+ */
+function connectionClosedAfterDispatch(error) {
+    if (error instanceof SubcCallError && error.kind === "not_sent")
+        return error;
+    if (typeof error === "object" && error !== null && "kind" in error && error.kind === "not_sent") {
+        return error;
+    }
+    if (!hasRequestConnectionLossEvidence(error))
+        return error;
+    if (error instanceof SubcCallError)
+        return error;
+    if (!(error instanceof Error))
+        return error;
+    return Object.assign(error, { kind: "outcome_unknown" });
+}
+/**
+ * Requests that subc-client's own deadline rejected after the request had been
+ * handed to `client.request`. Unlike the same `request_deadline` code on a
+ * route.open (which proves nothing was sent), the request may have reached AFT
+ * and started running, so its outcome is unknown. Kept outside the error
+ * object so the error's class, code, message and retry handling stay as
+ * subc-client made them.
+ */
+const dispatchedRequestDeadlines = new WeakSet();
+function noteDispatchedRequestDeadline(error) {
+    if (error instanceof SubcError && error.code === REQUEST_DEADLINE_CODE) {
+        dispatchedRequestDeadlines.add(error);
+    }
+}
+/**
+ * True for a request that ran out of subc-client's deadline after it was sent,
+ * so AFT may have started it (see `dispatchedRequestDeadlines`).
+ */
+export function isDispatchedRequestDeadlineError(error) {
+    return typeof error === "object" && error !== null && dispatchedRequestDeadlines.has(error);
+}
 /**
  * A call that never got an answer on a socket that may still be alive: the
  * client's own request deadline (raw `request`/`routeOpen` reject with code
@@ -967,7 +1042,29 @@ class SubcTransport {
         // dropping it here would cap long tool executions at the subc client's
         // default unary deadline while the command keeps running module-side.
         const timeoutMs = options.transportTimeoutMs ?? options.timeoutMs;
-        const onProgress = options.onProgress;
+        // subc-client delivers wire bodies; hosts use the same decoded callback
+        // shape as BinaryBridge, regardless of the route carrying the request.
+        const callback = options.onProgress;
+        const onProgress = callback
+            ? (body) => {
+                let frame;
+                try {
+                    frame = JSON.parse(new TextDecoder().decode(body));
+                }
+                catch {
+                    return;
+                }
+                if (typeof frame !== "object" || frame === null)
+                    return;
+                const progress = frame;
+                if (progress.type !== "progress" || typeof progress.chunk !== "string")
+                    return;
+                callback({
+                    kind: progress.kind === "stderr" ? "stderr" : "stdout",
+                    text: progress.chunk,
+                });
+            }
+            : undefined;
         return { preview, timeoutMs, onProgress, abortSignal: options.abortSignal };
     }
 }
@@ -984,7 +1081,7 @@ export class SubcTransportPool {
     hostScopes;
     /** Scope identity is host-session-wide, even when the session uses multiple project roots. */
     hostScopeCache = new Map();
-    hostScopeRefusals = new Set();
+    hostScopeRefusals = new Map();
     hostScopeOutcomes = new Map();
     connectFn;
     onBgEventsNudge;
@@ -2038,7 +2135,7 @@ export class SubcTransportPool {
                     return reply;
                 }
                 catch (requestError) {
-                    const error = frameReadTimeoutError(routeClosedMidCallError(requestError, routeAndEntry.entry, record));
+                    const error = frameReadTimeoutError(routeClosedMidCallError(connectionClosedAfterDispatch(requestError), routeAndEntry.entry, record));
                     if (this.isReapInduced(record))
                         throw this.annotateReapError(error, record);
                     const ownsRoute = this.isCurrentSession(key, record) && this.client === client;
@@ -2085,6 +2182,7 @@ export class SubcTransportPool {
                         continue;
                     }
                     handleRequestFailure(error, routeAndEntry.entry);
+                    noteDispatchedRequestDeadline(error);
                     throw error;
                 }
             }
@@ -2247,21 +2345,45 @@ export class SubcTransportPool {
         return { route: await opening, entry };
     }
     hostScope(client, identity) {
-        if (this.hostScopeRefusals.has(identity.session))
-            return Promise.resolve(undefined);
+        let lookupReason = "cache_miss";
+        const refused = this.hostScopeRefusals.get(identity.session);
+        if (refused) {
+            // A refusal applies to one route-binding attempt, not to the session's future scope.
+            // Look up the host scope again on the next bind instead of leaving later routes unscoped.
+            const previous = this.hostScopeCache.get(identity.session);
+            if (previous)
+                this.cancelHostScopeRetry(previous);
+            this.hostScopeCache.delete(identity.session);
+            this.hostScopeRefusals.delete(identity.session);
+            lookupReason = `previous_bind_refusal code=${refused}`;
+        }
         let state = this.hostScopeCache.get(identity.session);
         if (!state) {
             state = { retryAt: 0, retryMs: HOST_SCOPE_RETRY_FLOOR_MS };
             this.hostScopeCache.set(identity.session, state);
         }
         if (state.answer) {
-            return Promise.resolve(state.answer.result === "scope" && !state.scopeBindPending ? state.answer.scope : undefined);
+            const reason = state.scopeBindPending
+                ? "scope_sync_pending"
+                : `cached_${state.answer.result}`;
+            log(`subc head scope: session=${identity.session} lookup=skipped reason=${reason}`);
+            return Promise.resolve({
+                scope: state.answer.result === "scope" && !state.scopeBindPending
+                    ? state.answer.scope
+                    : undefined,
+                reason,
+            });
         }
-        if (state.pending)
+        if (state.pending) {
+            log(`subc head scope: session=${identity.session} lookup=skipped reason=inflight_lookup`);
             return state.pending;
+        }
         // Backoff skips the lookup, not the bind, so an unavailable core cannot delay every root.
-        if (Date.now() < state.retryAt)
-            return Promise.resolve(undefined);
+        if (Date.now() < state.retryAt) {
+            log(`subc head scope: session=${identity.session} lookup=skipped reason=backoff retry_in=${state.retryAt - Date.now()}ms`);
+            return Promise.resolve({ reason: state.unscopedReason ?? "lookup_backoff" });
+        }
+        log(`subc head scope: session=${identity.session} lookup=started reason=${lookupReason}`);
         const current = state;
         clearTimeout(current.retryTimer);
         current.retryTimer = undefined;
@@ -2270,25 +2392,36 @@ export class SubcTransportPool {
         const lookup = this.readHostScope(client, identity, abort.signal).then((outcome) => {
             // A scope-close push may invalidate the session while the management request is in flight.
             if (this.hostScopeCache.get(identity.session) !== current)
-                return undefined;
+                return { reason: "lookup_invalidated" };
             current.pending = undefined;
             current.lookupAbort = undefined;
             if (abort.signal.aborted)
-                return undefined;
+                return { reason: "lookup_cancelled" };
             this.logHostScopeOutcome(identity.session, outcome);
+            const reason = outcome.result === "error"
+                ? `lookup_error code=${outcome.code}`
+                : `lookup_${outcome.result}`;
             if (outcome.result === "scope" || outcome.result === "no_scope") {
                 current.answer = outcome;
                 current.retryAt = 0;
                 current.retryMs = HOST_SCOPE_RETRY_FLOOR_MS;
-                if (outcome.result === "scope")
-                    this.promoteHostScope(identity.session);
+                if (outcome.result === "scope") {
+                    // After a refusal, confirm daemon acceptance before replacing working fallback routes.
+                    current.promoteAfterBind = Boolean(refused);
+                    if (!current.promoteAfterBind)
+                        this.promoteHostScope(identity.session);
+                }
             }
             else {
+                current.unscopedReason = reason;
                 current.retryAt = Date.now() + current.retryMs;
                 current.retryMs = Math.min(current.retryMs * 2, HOST_SCOPE_RETRY_CAP_MS);
                 this.scheduleHostScopeRetry(identity.session, current);
             }
-            return outcome.result === "scope" ? outcome.scope : undefined;
+            return {
+                scope: outcome.result === "scope" ? outcome.scope : undefined,
+                reason,
+            };
         });
         current.pending = lookup;
         return lookup;
@@ -2351,7 +2484,7 @@ export class SubcTransportPool {
                 retry = this.hostScope(client, record.identity);
             }
             void retry.catch((error) => {
-                warn(`subc head scope: background retry failed code=${error instanceof Error ? error.name : "Error"}`);
+                warn(`subc head scope: session=${session} background retry failed code=${error instanceof Error ? error.name : "Error"}`);
             });
         }, Math.max(0, state.retryAt - Date.now()));
         state.retryTimer.unref();
@@ -2367,8 +2500,8 @@ export class SubcTransportPool {
     }
     refuseHostScopeBind(session, state, code) {
         if (!this.hostScopeRefusals.has(session)) {
-            this.hostScopeRefusals.add(session);
-            warn(`subc head scope: session=${session} scoped bind refused code=${code}; binding unscoped; retry stopped`);
+            this.hostScopeRefusals.set(session, code);
+            warn(`subc head scope: session=${session} scoped bind refused code=${code}; retry stopped until next bind lookup`);
         }
         if (state) {
             state.scopeBindPending = false;
@@ -2379,7 +2512,7 @@ export class SubcTransportPool {
     async retryHostScopeBind(client, identity, state, scope) {
         try {
             // Validate daemon acceptance before retiring a working fallback route or its held requests.
-            const route = await client.routeOpen({ kind: "tool_provider", module_id: AFT_MODULE_ID }, identity, { consumerIdentity: this.consumerIdentity, scope });
+            const route = await this.bindHostToolRoute(client, identity, "scope_probe", "scope_sync_retry", scope);
             safeCloseRoute(client, route);
             if (this.hostScopeCache.get(identity.session) !== state ||
                 !state.scopeBindPending ||
@@ -2388,6 +2521,7 @@ export class SubcTransportPool {
                 !this.unscopedHostRecord(identity.session))
                 return;
             state.scopeBindPending = false;
+            state.promoteAfterBind = false;
             state.retryAt = 0;
             state.retryMs = HOST_SCOPE_RETRY_FLOOR_MS;
             log(`subc head scope: session=${identity.session} scoped bind recovered ref=${scope.ref.slice(0, 8)} epoch=${scope.scopeEpoch}`);
@@ -2543,27 +2677,49 @@ export class SubcTransportPool {
             signal.removeEventListener("abort", cancel);
         }
     }
-    openHostToolRoute(client, identity, record, entry) {
+    openHostToolRoute(client, identity, record, entry, channel = "tool") {
         if (!this.hostScopes ||
             !["opencode", "pi"].includes(identity.harness) ||
             identity.session === DEFAULT_SESSION_ID) {
-            return client.routeOpen({ kind: "tool_provider", module_id: AFT_MODULE_ID }, identity, {
-                consumerIdentity: this.consumerIdentity,
-            });
-        }
-        return this.openScopedHostToolRoute(client, identity, record, entry);
+            const reason = !this.hostScopes
+                ? "host_scopes_disabled"
+                : identity.session === DEFAULT_SESSION_ID
+                    ? "default_session"
+                    : "unsupported_harness";
+            log(`subc head scope: session=${identity.session} lookup=skipped reason=${reason}`);
+            return this.bindHostToolRoute(client, identity, channel, reason);
+        }
+        return this.openScopedHostToolRoute(client, identity, record, entry, channel);
+    }
+    bindHostToolRoute(client, identity, channel, reason, scope) {
+        log(`subc head scope: session=${identity.session} bind=${scope ? "scoped" : "unscoped"} channel=${channel} root=${identity.project_root} reason=${reason}` +
+            (scope ? ` ref=${scope.ref.slice(0, 8)} epoch=${scope.scopeEpoch}` : ""));
+        return client.routeOpen({ kind: "tool_provider", module_id: AFT_MODULE_ID }, identity, {
+            consumerIdentity: this.consumerIdentity,
+            ...(scope ? { scope } : {}),
+        });
     }
-    async openScopedHostToolRoute(client, identity, record, entry) {
-        const scope = await this.hostScope(client, identity);
+    async openScopedHostToolRoute(client, identity, record, entry, channel = "tool") {
+        const decision = await this.hostScope(client, identity);
+        const scope = decision.scope;
+        let reason = decision.reason;
         this.assertRecordLive(record);
         if (scope) {
             try {
-                const route = await client.routeOpen({ kind: "tool_provider", module_id: AFT_MODULE_ID }, identity, { consumerIdentity: this.consumerIdentity, scope });
+                const route = await this.bindHostToolRoute(client, identity, channel, reason, scope);
                 if (entry)
                     entry.hostScope = scope;
+                const state = this.hostScopeCache.get(identity.session);
+                if (state?.promoteAfterBind &&
+                    state.answer?.result === "scope" &&
+                    state.answer.scope === scope) {
+                    state.promoteAfterBind = false;
+                    this.promoteHostScope(identity.session);
+                }
                 return route;
             }
             catch (error) {
+                log(`subc head scope: session=${identity.session} bind=failed channel=${channel} reason=scoped_open_error code=${error instanceof SubcError ? (error.code ?? error.name) : "Error"}`);
                 if (!(error instanceof SubcError) || !error.code || isSocketDeathError(error))
                     throw error;
                 // A restarting provider has not rejected the scope. Keep it for the normal reopen retry.
@@ -2573,22 +2729,27 @@ export class SubcTransportPool {
                 const state = this.hostScopeCache.get(identity.session);
                 if (state && isHostScopeSyncRefusal(error.code)) {
                     this.deferHostScopeBind(identity.session, state, error.code);
+                    reason = `scope_sync_pending code=${error.code}`;
                 }
                 else {
                     this.refuseHostScopeBind(identity.session, state, error.code);
+                    // Look up the host scope again after a cached scoped route is refused,
+                    // before opening an unscoped route.
+                    if (decision.reason === "cached_scope") {
+                        return this.openScopedHostToolRoute(client, identity, record, entry, channel);
+                    }
+                    reason = `scoped_bind_refused code=${error.code}`;
                 }
             }
         }
         this.assertRecordLive(record);
-        const route = await client.routeOpen({ kind: "tool_provider", module_id: AFT_MODULE_ID }, identity, {
-            consumerIdentity: this.consumerIdentity,
-        });
+        const route = await this.bindHostToolRoute(client, identity, channel, reason);
         // Scope recovery can finish while a fallback bind waits for the provider, including bg_events.
         if (this.hostScopeCache.get(identity.session)?.answer?.result === "scope" &&
             !this.hostScopeCache.get(identity.session)?.scopeBindPending &&
             !this.hostScopeRefusals.has(identity.session)) {
             safeCloseRoute(client, route);
-            return this.openScopedHostToolRoute(client, identity, record, entry);
+            return this.openScopedHostToolRoute(client, identity, record, entry, channel);
         }
         return route;
     }
@@ -2689,7 +2850,7 @@ export class SubcTransportPool {
         };
         sub = new BgSubscription(identity, () => this.ensureClient(), (client, cause) => this.dropClient(client, cause), (client) => {
             binding.hostScope = undefined;
-            return this.openHostToolRoute(client, identity, record, binding);
+            return this.openHostToolRoute(client, identity, record, binding, "bg_events");
         }, onNudge, this.bgBackoffSleep, () => this.rootCanAttach(record.canonicalRoot), (error) => {
             if (!isAbsentRootRouteError(error))
                 return false;