agent-embassy 3.0.0 → 3.1.0

package/dist/src/gateway/service.js

@@ -1,10 +1,10 @@
 import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
 import { BridgeError } from "../errors.js";
 import { createGatewayConversationId, startGatewayControlServer, GATEWAY_EPHEMERAL_PEER_TTL_DEFAULT_MS, } from "./control.js";
-import { PeerConnectionLostError, spawnPeerClient } from "./peer-client.js";
-import { peerRouteRef } from "./peer-protocol.js";
+import { PeerConnectionLostError, PeerRequestError, spawnPeerClient } from "./peer-client.js";
+import { isPeerHandoffRefusal, peerRouteRef } from "./peer-protocol.js";
 import { GatewayStore } from "./store.js";
-import { CONNECTOR_OBSERVATION_STALE_AFTER_MS, directionId, GATEWAY_PUBLIC_SNAPSHOT_BYTE_BUDGET, gatewayPublicSnapshotLimits, gatewayRegistrationIngressPrefixes, parseDirection, projectGatewayPublicSnapshot, } from "./types.js";
+import { CONNECTOR_OBSERVATION_STALE_AFTER_MS, gatewayHealthWord, directionId, GATEWAY_PUBLIC_SNAPSHOT_BYTE_BUDGET, gatewayPublicSnapshotLimits, parseDirection, projectGatewayPublicSnapshot, } from "./types.js";
 const SAFE_CODE = /^[A-Z][A-Z0-9_]{0,63}$/;
 const PRIVATE_HANDLE = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/;
 const PUBLIC_ALIAS = /^[a-z][a-z0-9_-]{0,31}@[a-z0-9](?:[a-z0-9.-]{0,61}[a-z0-9])?$/;
@@ -121,9 +121,6 @@ function conversationIdForSuffix(suffix) {
     const fresh = createGatewayConversationId();
     return suffix === undefined ? fresh : `${fresh.slice(0, -8)}${suffix}`;
 }
-function bodyHash(body) {
-    return createHash("sha256").update(body, "utf8").digest("hex");
-}
 function peerCatalogAuthorityChanged(prior, current) {
     const authority = (catalog) => JSON.stringify(catalog.routes.map(({ state: _state, queueDepth: _depth, lastSeenAt: _seen, safeErrorCode: _code, ...route }) => route).sort((a, b) => a.ref.localeCompare(b.ref)));
     return prior === undefined || authority(prior) !== authority(current);
@@ -151,7 +148,7 @@ export class GatewayService {
     spawnPeer;
     peerClients = new Map();
     peerCatalogs = new Map();
-    peerCleanupAliases = new Set();
+    routeCleanupAliases = new Set();
     /** View-only freshness; never consulted by routing or write authorization. */
     peerRouteViews = new Map();
     connectors = new Map();
@@ -237,9 +234,6 @@ export class GatewayService {
                 if (registry !== undefined)
                     runtime.registry = publicRegistry(registry, false);
                 this.connectors.set(key, runtime);
-                if (started.ownedRoute !== undefined) {
-                    await this.installOwnedRoute(adapter, started.ownedRoute);
-                }
             }
             await this.refreshClaudeDiscovery().catch(() => undefined);
             await this.refreshManagedCodexSocket().catch(() => undefined);
@@ -335,7 +329,9 @@ export class GatewayService {
         const decide = async (operation, peerPrincipal = false) => {
             try {
                 this.assertWritable();
-                await operation();
+                const decision = await operation();
+                if (decision !== undefined)
+                    return decision;
                 this.revision += 1;
                 return { accepted: true, code: "ok" };
             }
@@ -360,6 +356,14 @@ export class GatewayService {
             unregisterPeer: (params) => decide(async () => this.unregisterPeer(params), true),
             awaitPeer: (params) => this.awaitPeer(params),
             peerReceipt: (params) => decide(async () => this.peerReceipt(params), true),
+            retireRoute: async ({ alias }) => {
+                try {
+                    return await this.retireRoute(alias);
+                }
+                catch (error) {
+                    return sendRefusal(error);
+                }
+            },
             unregisterCodex: (params) => decide(async () => this.unregisterCodex(params)),
             listSnapshot: () => this.snapshot(),
             observeSnapshot: () => this.observeSnapshot(),
@@ -418,7 +422,17 @@ export class GatewayService {
     async receivePeerHandoff(peerHost, handoff) {
         if (!this.config.peerNodes.includes(peerHost))
             throw new BridgeError("PEER_NOT_CONFIGURED", "The sending peer host is not configured.");
-        const enqueued = await this.store.enqueuePeerHandoff(peerHost, handoff);
+        let enqueued;
+        try {
+            enqueued = await this.store.enqueuePeerHandoff(peerHost, handoff);
+        }
+        catch (error) {
+            const refusal = { accepted: false, reason: error instanceof BridgeError ? error.code : undefined };
+            if (isPeerHandoffRefusal(refusal))
+                return refusal;
+            throw error;
+        }
+        // Post-admission bookkeeping is deliberately outside the refusal catch.
         if (enqueued.messageId !== undefined) {
             const source = await this.store.inspectPrivateRoute(handoff.source.alias);
             const target = await this.store.inspectPrivateRoute(handoff.target.alias);
@@ -460,26 +474,8 @@ export class GatewayService {
                 ...(persisted.safeErrorCode === undefined ? {} : { safeErrorCode: persisted.safeErrorCode }),
             };
         });
-        const connectors = [...this.connectors.values()].map((runtime) => {
-            const observedAt = runtime.observedAt;
-            const age = observedAt === undefined ? undefined : Math.max(0, now.getTime() - Date.parse(observedAt));
-            const stale = runtime.health === "healthy" &&
-                (age === undefined || age > CONNECTOR_OBSERVATION_STALE_AFTER_MS);
-            const socketHeld = runtime.adapter.identity.provider === "codex" && this.managedCodexSocketHeldOutside;
-            const connectorCode = stale ? "CONNECTOR_OBSERVATION_STALE" : runtime.safeErrorCode ??
-                (socketHeld ? "MANAGED_CODEX_UNAVAILABLE" : undefined);
-            return {
-                provider: runtime.adapter.identity.provider,
-                host: runtime.adapter.identity.hostId,
-                health: stale || socketHeld ? "degraded" : runtime.health,
-                protocol: runtime.adapter.protocol,
-                protocolVersion: runtime.adapter.protocolVersion,
-                ...(observedAt === undefined ? {} : { lastSeenAt: observedAt }),
-                ...(age === undefined ? {} : { observationAgeMs: age }),
-                ...(runtime.registry === undefined ? {} : { registry: runtime.registry }),
-                ...(connectorCode === undefined ? {} : { safeErrorCode: connectorCode }),
-            };
-        });
+        const connectors = this.publicConnectors(now);
+        const word = gatewayHealthWord(connectors);
         const availablePeers = [...this.candidates.values()]
             .filter((candidate) => !this.collidingClaudeAliases.has(candidate.alias))
             .slice(0, gatewayPublicSnapshotLimits.availablePeers)
@@ -495,11 +491,7 @@ export class GatewayService {
         return projectGatewayPublicSnapshot({
             ...base,
             generatedAt: now.toISOString(),
-            health: connectors.some((connector) => connector.health === "degraded")
-                ? "degraded"
-                : connectors.length === 0
-                    ? "offline"
-                    : "healthy",
+            health: word === "ok" || word === "stale" ? "healthy" : word,
             connectors,
             availablePeers,
             routes,
@@ -517,30 +509,29 @@ export class GatewayService {
         return { snapshotRevision: this.snapshotRevision, snapshot };
     }
     health() {
-        return this.connectors.size > 0 &&
-            [...this.connectors.values()].every((runtime) => runtime.health === "healthy") ? "ok" : "degraded";
-    }
-    async installOwnedRoute(adapter, owned) {
-        const prefix = gatewayRegistrationIngressPrefixes[adapter.identity.provider];
-        if (!PUBLIC_ALIAS.test(owned.alias) ||
-            !owned.alias.endsWith(`@${adapter.identity.hostId}`) ||
-            (prefix !== undefined && !owned.alias.startsWith(prefix)) ||
-            !PRIVATE_HANDLE.test(owned.routeHandle)) {
-            throw new BridgeError("GATEWAY_OWNED_ROUTE_INVALID", "The configured route identity is invalid.");
-        }
-        const existing = await this.store.inspectPrivateRoute(owned.alias);
-        if (existing !== undefined) {
-            if (existing.binding.provider !== adapter.identity.provider ||
-                existing.binding.hostId !== adapter.identity.hostId ||
-                existing.binding.routeHandle !== owned.routeHandle) {
-                throw new BridgeError("ROUTE_ALIAS_ALREADY_REGISTERED", "The configured route conflicts with durable state.");
-            }
-            return;
-        }
-        await this.store.registerRoute({
-            alias: owned.alias,
-            binding: { ...adapter.identity, routeHandle: owned.routeHandle, registrationId: registrationId() },
-            registrationMode: "explicit_opt_in",
+        const word = gatewayHealthWord(this.publicConnectors(this.now()));
+        return word === "ok" || word === "stale" ? "ok" : "degraded";
+    }
+    publicConnectors(now) {
+        return [...this.connectors.values()].map((runtime) => {
+            const observedAt = runtime.observedAt;
+            const age = observedAt === undefined ? undefined : Math.max(0, now.getTime() - Date.parse(observedAt));
+            const stale = runtime.health === "healthy" &&
+                (age === undefined || age > CONNECTOR_OBSERVATION_STALE_AFTER_MS);
+            const socketHeld = runtime.adapter.identity.provider === "codex" && this.managedCodexSocketHeldOutside;
+            const connectorCode = runtime.safeErrorCode ??
+                (socketHeld ? "MANAGED_CODEX_UNAVAILABLE" : stale ? "CONNECTOR_OBSERVATION_STALE" : undefined);
+            return {
+                provider: runtime.adapter.identity.provider,
+                host: runtime.adapter.identity.hostId,
+                health: stale || socketHeld ? "degraded" : runtime.health,
+                protocol: runtime.adapter.protocol,
+                protocolVersion: runtime.adapter.protocolVersion,
+                ...(observedAt === undefined ? {} : { lastSeenAt: observedAt }),
+                ...(age === undefined ? {} : { observationAgeMs: age }),
+                ...(runtime.registry === undefined ? {} : { registry: runtime.registry }),
+                ...(connectorCode === undefined ? {} : { safeErrorCode: connectorCode }),
+            };
         });
     }
     async observeLoadedRoutes() {
@@ -584,18 +575,18 @@ export class GatewayService {
         return this.adapterFor({ provider: "claude", hostId });
     }
     async advertise(route) {
-        const hostId = route.registrationMode === "federated_peer"
-            ? this.config.hostId : route.binding.hostId;
-        await this.claudeAdapter(hostId)?.advertiseNativeSourcePeer?.({
+        if (route.registrationMode === "federated_peer")
+            return;
+        await this.claudeAdapter(route.binding.hostId)?.advertiseNativeSourcePeer?.({
             alias: route.alias,
             sourceProvider: route.binding.provider,
             cwd: this.nativePeerCwd,
         });
     }
     async unadvertise(route) {
-        const hostId = route.registrationMode === "federated_peer"
-            ? this.config.hostId : route.binding.hostId;
-        await this.claudeAdapter(hostId)?.unadvertiseNativeSourcePeer?.(route.alias);
+        if (route.registrationMode === "federated_peer")
+            return;
+        await this.claudeAdapter(route.binding.hostId)?.unadvertiseNativeSourcePeer?.(route.alias);
     }
     reconcileAdvertisement(route) {
         void this.advertise(route).catch((error) => this.alert("NATIVE_ADVERTISEMENT_FAILED", route, error));
@@ -603,6 +594,66 @@ export class GatewayService {
     async reconcileUnadvertisement(route) {
         await this.unadvertise(route).catch((error) => this.alert("NATIVE_UNADVERTISEMENT_FAILED", route, error));
     }
+    assertRouteNotCleaning(alias) {
+        if (this.routeCleanupAliases.has(alias))
+            throw new BridgeError("ROUTE_BUSY", "The route is still completing cleanup.", true);
+    }
+    async retireRoute(alias) {
+        this.assertWritable();
+        const route = await this.store.inspectPrivateRoute(alias);
+        if (!route)
+            return { accepted: false, code: "not_found" };
+        if (route.registrationMode === "federated_peer" || route.binding.hostId !== this.config.hostId) {
+            throw new BridgeError("FEDERATED_ROUTE_READ_ONLY", "A remote route is retired by its owner, not this broker.");
+        }
+        this.assertRouteNotCleaning(alias);
+        this.routeCleanupAliases.add(alias);
+        const expiry = this.ephemeralPeerExpiries.get(alias);
+        this.ephemeralPeerExpiries.delete(alias);
+        this.ephemeralExpiryFailures.delete(alias);
+        let removed = false;
+        try {
+            const result = await this.store.removeOwnedRouteAtomic({ alias, binding: route.binding,
+                activity: { operatorAction: true, action: "route_retired" } });
+            if (!result.removed)
+                return { accepted: false, code: "not_found" };
+            removed = true;
+            await this.finishSettlements(result.settlements);
+            const incident = (row) => row.sourceBinding?.registrationId === route.binding.registrationId || row.targetBinding?.registrationId === route.binding.registrationId;
+            for (const [id, conversation] of this.conversations)
+                if (incident(conversation))
+                    this.conversations.delete(id);
+            for (const [id, rows] of this.pendingClaudeReplies) {
+                const retained = rows.filter((row) => !incident(row));
+                if (retained.length)
+                    this.pendingClaudeReplies.set(id, retained);
+                else
+                    this.pendingClaudeReplies.delete(id);
+            }
+            this.forgetRoute(route);
+            if (route.binding.provider === "claude") {
+                try {
+                    await this.adapterFor(route.binding)?.releaseRoute?.(route.binding.routeHandle);
+                }
+                catch (error) {
+                    this.alert("ROUTE_RELEASE_FAILED", route, error);
+                }
+            }
+            else
+                await this.reconcileUnadvertisement(route);
+            this.revision += 1;
+            return { accepted: true, code: "ok", settlements: {
+                    cancelled: result.settlements.filter((row) => row.state === "cancelled").length,
+                    ambiguous: result.settlements.filter((row) => row.state === "ambiguous").length,
+                    unconfirmed: result.settlements.filter((row) => row.state === "unconfirmed").length,
+                } };
+        }
+        finally {
+            if (!removed && expiry !== undefined)
+                this.ephemeralPeerExpiries.set(alias, expiry);
+            this.routeCleanupAliases.delete(alias);
+        }
+    }
     async removeOwnedRoute(route) {
         this.assertWritable();
         const result = await this.store.removeOwnedRouteAtomic({
@@ -627,6 +678,7 @@ export class GatewayService {
     }
     async registerCodex(params) {
         const existing = await this.store.inspectPrivateRoute(params.alias);
+        this.assertRouteNotCleaning(params.alias);
         if (existing !== undefined && params.succeedsAlias === undefined) {
             if (existing.binding.provider !== "codex" || existing.binding.routeHandle !== params.threadId) {
                 throw new BridgeError("ROUTE_ALIAS_ALREADY_REGISTERED", "The alias belongs to another registration.");
@@ -647,6 +699,7 @@ export class GatewayService {
         };
         if (params.succeedsAlias === undefined) {
             this.assertWritable();
+            this.assertRouteNotCleaning(params.alias);
             await this.store.registerRoute(replacement);
             const installed = (await this.store.inspectPrivateRoute(params.alias));
             await this.recordActivity("registration", "codex_registered", [installed.alias], true);
@@ -668,6 +721,7 @@ export class GatewayService {
             throw new BridgeError("CODEX_SUCCESSION_OWNER_MISMATCH", "The succeeded registration is absent.");
         }
         this.assertWritable();
+        this.assertRouteNotCleaning(params.alias);
         const result = await this.store.replaceCodexRegistrationAtomic({
             oldAlias: params.succeedsAlias,
             expectedOldRegistrationId: previous.binding.registrationId,
@@ -685,7 +739,7 @@ export class GatewayService {
         this.kick(params.alias);
     }
     async registerPeer(params) {
-        if (this.peerCleanupAliases.has(params.alias)) {
+        if (this.routeCleanupAliases.has(params.alias)) {
             throw new BridgeError("ROUTE_BUSY", "The route is still completing cleanup.", true);
         }
         const existing = await this.store.inspectPrivateRoute(params.alias);
@@ -702,6 +756,7 @@ export class GatewayService {
             throw new BridgeError("ROUTE_UNREGISTERED", "The route binding does not match.");
         }
         const token = `peer_${randomBytes(24).toString("base64url")}`;
+        this.assertRouteNotCleaning(params.alias);
         await this.store.registerRoute({ alias: params.alias, binding: {
                 provider: "peer", hostId: this.config.hostId,
                 routeHandle: peerHandle(process.getuid(), params.alias, token), registrationId: registrationId(),
@@ -729,9 +784,9 @@ export class GatewayService {
     }
     async unregisterPeer(params) {
         const route = await this.assertPeer(params);
-        if (this.peerCleanupAliases.has(route.alias))
+        if (this.routeCleanupAliases.has(route.alias))
             throw new BridgeError("ROUTE_BUSY", "The route is still completing cleanup.", true);
-        this.peerCleanupAliases.add(route.alias);
+        this.routeCleanupAliases.add(route.alias);
         // The expiry leaves the map before the removal, under the same cleanup
         // guard, so a clock that fires mid-removal has nothing to act on; a
         // removal that does not happen puts it back, so a refused unregister
@@ -752,7 +807,7 @@ export class GatewayService {
         finally {
             if (!removed && expiry !== undefined)
                 this.ephemeralPeerExpiries.set(route.alias, expiry);
-            this.peerCleanupAliases.delete(route.alias);
+            this.routeCleanupAliases.delete(route.alias);
         }
     }
     /**
@@ -774,7 +829,7 @@ export class GatewayService {
             if (expiresAt > now)
                 continue;
             // Another owner is mid-removal; the entry is theirs to clear or restore.
-            if (this.peerCleanupAliases.has(alias))
+            if (this.routeCleanupAliases.has(alias))
                 continue;
             const route = await this.store.inspectPrivateRoute(alias);
             if (route === undefined || !this.store.isEphemeralRegistration(route.binding.registrationId)) {
@@ -782,7 +837,7 @@ export class GatewayService {
                 this.ephemeralExpiryFailures.delete(alias);
                 continue;
             }
-            this.peerCleanupAliases.add(alias);
+            this.routeCleanupAliases.add(alias);
             try {
                 const result = await this.store.removeOwnedRouteAtomic({ alias, binding: route.binding });
                 if (result.removed) {
@@ -808,7 +863,7 @@ export class GatewayService {
                 }
             }
             finally {
-                this.peerCleanupAliases.delete(alias);
+                this.routeCleanupAliases.delete(alias);
             }
         }
     }
@@ -826,7 +881,7 @@ export class GatewayService {
         const route = await this.assertPeer(params);
         const adapter = this.adapterFor(route.binding);
         if (adapter?.acknowledgeReceipt({ alias: route.alias, ...route.binding, receipt: params.receipt }) === "rejected") {
-            throw new BridgeError("ROUTE_UNREGISTERED", "The route binding does not match.");
+            return { accepted: false, code: "not_found" };
         }
     }
     async unregisterCodex(params) {
@@ -894,6 +949,7 @@ export class GatewayService {
             },
             registrationMode: "selected_live_peer",
         };
+        this.assertRouteNotCleaning(alias);
         const result = await this.installWithConcurrentFirstSend(input, adapter.identity.hostId, chosen.routeHandle);
         await this.finishSettlements(result.settlements);
         const after = (await this.store.listLogicalRoutes()).filter((route) => route.binding.provider === "claude");
@@ -1014,9 +1070,6 @@ export class GatewayService {
             return routed;
         return await this.installClaudeRoute(candidate);
     }
-    async resolveClaudeRoute(selector, hostId) {
-        return await this.materializeClaudeRoute(await this.lookUpClaudeRoute(selector, hostId));
-    }
     async assertThread(alias, threadId) {
         const route = await this.store.inspectPrivateRoute(alias);
         // No registration at all is its own condition — the state every Codex
@@ -1468,190 +1521,198 @@ export class GatewayService {
                 await this.resolvePrewrite(attempt.messageId, attempt.attemptId, "failed", "ROUTE_UNREGISTERED");
                 return false;
             }
-            if (target.registrationMode === "federated_peer") {
-                const peer = this.peerClients.get(target.binding.hostId);
-                if (peer === undefined || source.registrationMode === "federated_peer") {
-                    await this.resolvePrewrite(attempt.messageId, attempt.attemptId, "requeue", "PEER_TUNNEL_UNAVAILABLE");
-                    return false;
-                }
-                const sourceEndpoint = { alias: source.alias, provider: source.binding.provider,
-                    host: source.binding.hostId, routeRef: peerRouteRef(source.binding.hostId, source.binding.registrationId) };
-                const targetEndpoint = { alias: target.alias, provider: target.binding.provider,
-                    host: target.binding.hostId, routeRef: target.binding.routeHandle };
-                const params = {
-                    originAttemptId: attempt.attemptId, originMessageId: attempt.messageId,
-                    source: sourceEndpoint, target: targetEndpoint,
-                    deadlineAt: attempt.deadlineAt, expectsReply: conversation?.expectsReply ?? true,
-                    body: attempt.body,
-                    ...(attempt.steer === true ? { steer: true } : {}),
-                    ...(attempt.conversationIdSuffix === undefined ? {} : { conversationCorrelation: attempt.conversationIdSuffix }),
-                };
-                let armed = false, authorizationUncertain = false, acceptanceObserved = false, result;
-                try {
-                    const prepared = peer.prepareHandoff(params);
-                    let authorized;
+            return target.registrationMode === "federated_peer"
+                ? this.runPeerAttempt(attempt, source, target, conversation)
+                : this.runProviderAttempt(attempt, source, target, conversation, messageContext);
+        }
+        return false;
+    }
+    async runPeerAttempt(attempt, source, target, conversation) {
+        const peer = this.peerClients.get(target.binding.hostId);
+        if (peer === undefined || source.registrationMode === "federated_peer") {
+            await this.resolvePrewrite(attempt.messageId, attempt.attemptId, "requeue", "PEER_TUNNEL_UNAVAILABLE");
+            return false;
+        }
+        const sourceEndpoint = { alias: source.alias, provider: source.binding.provider,
+            host: source.binding.hostId, routeRef: peerRouteRef(source.binding.hostId, source.binding.registrationId) };
+        const targetEndpoint = { alias: target.alias, provider: target.binding.provider,
+            host: target.binding.hostId, routeRef: target.binding.routeHandle };
+        const params = {
+            originAttemptId: attempt.attemptId, originMessageId: attempt.messageId,
+            source: sourceEndpoint, target: targetEndpoint,
+            deadlineAt: attempt.deadlineAt, expectsReply: conversation?.expectsReply ?? true,
+            body: attempt.body,
+            ...(attempt.steer === true ? { steer: true } : {}),
+            ...(attempt.conversationIdSuffix === undefined ? {} : { conversationCorrelation: attempt.conversationIdSuffix }),
+        };
+        let armed = false, authorizationUncertain = false, acceptanceObserved = false, result;
+        try {
+            const prepared = peer.prepareHandoff(params);
+            let authorized;
+            try {
+                authorized = await this.store.authorizeMessage({ messageId: attempt.messageId,
+                    attemptId: attempt.attemptId, sourceRegistrationId: attempt.sourceRegistrationId,
+                    targetRegistrationId: attempt.targetRegistrationId,
+                    prepared: { kind: "peer_handoff", bodyBytes: prepared.bodyBytes,
+                        bodySha256: prepared.bodySha256, frameBytes: prepared.frameBytes, sha256: prepared.sha256 } });
+            }
+            catch (error) {
+                authorizationUncertain = true;
+                throw error;
+            }
+            if (authorized.status !== "authorized") {
+                prepared.cancel();
+                if (authorized.status === "terminal")
+                    await this.finishSettlement(authorized.settlement);
+                this.activeAttempts.delete(attempt.messageId);
+                return false;
+            }
+            armed = true;
+            await prepared.perform();
+            acceptanceObserved = true;
+            const accepted = await this.store.acceptMessage({ messageId: attempt.messageId,
+                attemptId: attempt.attemptId, lossOutcome: "unconfirmed" });
+            if (accepted.status !== "accepted")
+                throw new BridgeError("ACCEPTANCE_UNCONFIRMED", "The peer acceptance fence is stale.");
+            result = { state: "delivered", safeErrorCode: "PEER_HANDOFF_CONFIRMED" };
+        }
+        catch (error) {
+            if (!armed && !authorizationUncertain) {
+                peer.close();
+                this.peerClients.delete(target.binding.hostId);
+                await this.resolvePrewrite(attempt.messageId, attempt.attemptId, "requeue", "PEER_TUNNEL_UNAVAILABLE");
+                return false;
+            }
+            result = armed && !authorizationUncertain && !acceptanceObserved &&
+                error instanceof PeerRequestError && error.detail.code === -32000 && isPeerHandoffRefusal(error.detail.data)
+                ? { state: "failed", safeErrorCode: error.detail.data.reason }
+                : acceptanceObserved
+                    ? { state: "unconfirmed", safeErrorCode: "PEER_HANDOFF_ACCEPTANCE_UNCONFIRMED" }
+                    : { state: "ambiguous", safeErrorCode: authorizationUncertain ? "WRITE_AUTHORIZATION_UNCERTAIN" : "PEER_HANDOFF_OUTCOME_UNKNOWN" };
+        }
+        const requeued = await this.applyDispatchResult(attempt.messageId, attempt.attemptId, result, armed, conversation, source.alias, target.alias);
+        this.activeAttempts.delete(attempt.messageId);
+        return requeued;
+    }
+    async runProviderAttempt(attempt, source, target, conversation, messageContext) {
+        const adapter = this.adapterFor(target.binding);
+        if (adapter === undefined) {
+            await this.resolvePrewrite(attempt.messageId, attempt.attemptId, "failed", "PROVIDER_UNAVAILABLE");
+            return false;
+        }
+        const active = this.activeAttempts.get(attempt.messageId);
+        let authorizationUncertain = false;
+        let armed = false;
+        let accepted = false;
+        const conversationId = messageContext?.conversationId ??
+            conversationIdForSuffix(attempt.conversationIdSuffix);
+        const parsed = parseDirection(attempt.direction);
+        if (target.binding.provider === "claude" &&
+            messageContext?.expectsReply === true &&
+            ![...this.pendingClaudeReplies.values()].some((rows) => rows.some((row) => row.messageId === attempt.messageId)) &&
+            [...this.pendingClaudeReplies.values()].reduce((count, rows) => count + rows.length, 0) >= MAX_PENDING_CLAUDE_REPLIES) {
+            await this.resolvePrewrite(attempt.messageId, attempt.attemptId, "requeue", "ROUTE_BUSY");
+            return true;
+        }
+        let result;
+        try {
+            result = await adapter.dispatch({
+                attemptId: attempt.attemptId,
+                sourceAlias: source.alias,
+                sourceProvider: parsed.sourceProvider,
+                // The route's CURRENT alias, not the one captured at reserve. The
+                // provider adapters compare this against the alias they hold for the
+                // binding, so a session renamed between reserve and dispatch would
+                // otherwise fail its own delivery over a stale display name.
+                targetAlias: target.alias,
+                conversationId,
+                binding: target.binding,
+                authorization: "selected_route",
+                messageId: attempt.messageId,
+                text: attempt.body,
+                expectsReply: conversation?.expectsReply ?? true,
+                deadlineAt: attempt.deadlineAt,
+                ...(attempt.steer === true ? { steer: true, queuedAhead: 0 } : {}),
+                authorizeWrite: async (evidence) => {
+                    if (evidence.attemptId !== attempt.attemptId)
+                        return false;
                     try {
-                        authorized = await this.store.authorizeMessage({ messageId: attempt.messageId,
-                            attemptId: attempt.attemptId, sourceRegistrationId: attempt.sourceRegistrationId,
+                        const authorized = await this.store.authorizeMessage({
+                            messageId: attempt.messageId,
+                            attemptId: attempt.attemptId,
+                            sourceRegistrationId: attempt.sourceRegistrationId,
                             targetRegistrationId: attempt.targetRegistrationId,
-                            prepared: { kind: "peer_handoff", bodyBytes: prepared.bodyBytes,
-                                bodySha256: prepared.bodySha256, frameBytes: prepared.frameBytes, sha256: prepared.sha256 } });
+                            prepared: {
+                                kind: evidence.kind,
+                                bodyBytes: evidence.bodyBytes,
+                                bodySha256: evidence.bodySha256,
+                                frameBytes: evidence.frameBytes,
+                                sha256: evidence.sha256,
+                            },
+                        });
+                        if (authorized.status === "terminal") {
+                            await this.finishSettlement(authorized.settlement);
+                        }
+                        if (authorized.status === "authorized") {
+                            armed = true;
+                            if (target.binding.provider === "claude" &&
+                                messageContext?.expectsReply === true) {
+                                this.installPendingClaudeReply({
+                                    messageId: attempt.messageId,
+                                    conversationId,
+                                    sourceAlias: source.alias,
+                                    targetAlias: target.alias,
+                                    sourceBinding: source.binding,
+                                    targetBinding: target.binding,
+                                    deadlineAt: attempt.deadlineAt,
+                                    state: "armed",
+                                });
+                            }
+                        }
+                        return authorized.status === "authorized";
                     }
                     catch (error) {
                         authorizationUncertain = true;
                         throw error;
                     }
-                    if (authorized.status !== "authorized") {
-                        prepared.cancel();
-                        if (authorized.status === "terminal")
-                            await this.finishSettlement(authorized.settlement);
-                        this.activeAttempts.delete(attempt.messageId);
-                        return false;
+                },
+                onAccepted: async (evidence) => {
+                    if ((target.binding.provider !== "codex" && target.binding.provider !== "peer") ||
+                        evidence.attemptId !== attempt.attemptId) {
+                        throw new BridgeError("ACCEPTANCE_UNCONFIRMED", "The provider accepted another attempt.");
                     }
-                    armed = true;
-                    await prepared.perform();
-                    acceptanceObserved = true;
-                    const accepted = await this.store.acceptMessage({ messageId: attempt.messageId,
-                        attemptId: attempt.attemptId, lossOutcome: "unconfirmed" });
-                    if (accepted.status !== "accepted")
-                        throw new BridgeError("ACCEPTANCE_UNCONFIRMED", "The peer acceptance fence is stale.");
-                    result = { state: "delivered", safeErrorCode: "PEER_HANDOFF_CONFIRMED" };
-                }
-                catch {
-                    if (!armed && !authorizationUncertain) {
-                        peer.close();
-                        this.peerClients.delete(target.binding.hostId);
-                        await this.resolvePrewrite(attempt.messageId, attempt.attemptId, "requeue", "PEER_TUNNEL_UNAVAILABLE");
-                        return false;
+                    const result = await this.store.acceptMessage({
+                        messageId: attempt.messageId,
+                        attemptId: attempt.attemptId,
+                        lossOutcome: attempt.steer === true ? "ambiguous" : "unconfirmed",
+                    });
+                    if (result.status !== "accepted") {
+                        throw new BridgeError("ACCEPTANCE_UNCONFIRMED", "The durable acceptance fence is stale.");
                     }
-                    result = acceptanceObserved
-                        ? { state: "unconfirmed", safeErrorCode: "PEER_HANDOFF_ACCEPTANCE_UNCONFIRMED" }
-                        : { state: "ambiguous", safeErrorCode: authorizationUncertain ? "WRITE_AUTHORIZATION_UNCERTAIN" : "PEER_HANDOFF_OUTCOME_UNKNOWN" };
-                }
-                const requeued = await this.applyDispatchResult(attempt.messageId, attempt.attemptId, result, armed, conversation, attempt.sourceAlias, attempt.targetAlias);
-                this.activeAttempts.delete(attempt.messageId);
-                return requeued;
-            }
-            const adapter = this.adapterFor(target.binding);
-            if (adapter === undefined) {
-                await this.resolvePrewrite(attempt.messageId, attempt.attemptId, "failed", "PROVIDER_UNAVAILABLE");
-                return false;
-            }
-            const active = this.activeAttempts.get(attempt.messageId);
-            let authorizationUncertain = false;
-            let armed = false;
-            let accepted = false;
-            const conversationId = messageContext?.conversationId ??
-                conversationIdForSuffix(attempt.conversationIdSuffix);
-            const parsed = parseDirection(attempt.direction);
-            if (target.binding.provider === "claude" &&
-                messageContext?.expectsReply === true &&
-                ![...this.pendingClaudeReplies.values()].some((rows) => rows.some((row) => row.messageId === attempt.messageId)) &&
-                [...this.pendingClaudeReplies.values()].reduce((count, rows) => count + rows.length, 0) >= MAX_PENDING_CLAUDE_REPLIES) {
-                await this.resolvePrewrite(attempt.messageId, attempt.attemptId, "requeue", "ROUTE_BUSY");
-                return true;
-            }
-            let result;
-            try {
-                result = await adapter.dispatch({
-                    attemptId: attempt.attemptId,
-                    sourceAlias: attempt.sourceAlias,
-                    sourceProvider: parsed.sourceProvider,
-                    // The route's CURRENT alias, not the one captured at reserve. The
-                    // provider adapters compare this against the alias they hold for the
-                    // binding, so a session renamed between reserve and dispatch would
-                    // otherwise fail its own delivery over a stale display name.
-                    targetAlias: target.alias,
-                    conversationId,
-                    binding: target.binding,
-                    authorization: "selected_route",
-                    messageId: attempt.messageId,
-                    text: attempt.body,
-                    expectsReply: conversation?.expectsReply ?? true,
-                    deadlineAt: attempt.deadlineAt,
-                    ...(attempt.steer === true ? { steer: true, queuedAhead: 0 } : {}),
-                    authorizeWrite: async (evidence) => {
-                        if (evidence.attemptId !== attempt.attemptId)
-                            return false;
-                        try {
-                            const authorized = await this.store.authorizeMessage({
-                                messageId: attempt.messageId,
-                                attemptId: attempt.attemptId,
-                                sourceRegistrationId: attempt.sourceRegistrationId,
-                                targetRegistrationId: attempt.targetRegistrationId,
-                                prepared: {
-                                    kind: evidence.kind,
-                                    bodyBytes: evidence.bodyBytes,
-                                    bodySha256: evidence.bodySha256,
-                                    frameBytes: evidence.frameBytes,
-                                    sha256: evidence.sha256,
-                                },
-                            });
-                            if (authorized.status === "terminal") {
-                                await this.finishSettlement(authorized.settlement);
-                            }
-                            if (authorized.status === "authorized") {
-                                armed = true;
-                                if (target.binding.provider === "claude" &&
-                                    messageContext?.expectsReply === true) {
-                                    this.installPendingClaudeReply({
-                                        messageId: attempt.messageId,
-                                        conversationId,
-                                        sourceAlias: attempt.sourceAlias,
-                                        targetAlias: attempt.targetAlias,
-                                        sourceBinding: source.binding,
-                                        targetBinding: target.binding,
-                                        deadlineAt: attempt.deadlineAt,
-                                        state: "armed",
-                                    });
-                                }
-                            }
-                            return authorized.status === "authorized";
-                        }
-                        catch (error) {
-                            authorizationUncertain = true;
-                            throw error;
-                        }
-                    },
-                    onAccepted: async (evidence) => {
-                        if ((target.binding.provider !== "codex" && target.binding.provider !== "peer") ||
-                            evidence.attemptId !== attempt.attemptId) {
-                            throw new BridgeError("ACCEPTANCE_UNCONFIRMED", "The provider accepted another attempt.");
-                        }
-                        const result = await this.store.acceptMessage({
-                            messageId: attempt.messageId,
-                            attemptId: attempt.attemptId,
-                            lossOutcome: attempt.steer === true ? "ambiguous" : "unconfirmed",
-                        });
-                        if (result.status !== "accepted") {
-                            throw new BridgeError("ACCEPTANCE_UNCONFIRMED", "The durable acceptance fence is stale.");
-                        }
-                        accepted = true;
-                    },
-                });
-            }
-            catch {
-                result = {
-                    state: accepted
-                        ? attempt.steer === true
-                            ? "ambiguous"
-                            : "unconfirmed"
-                        : armed || authorizationUncertain
-                            ? "ambiguous"
-                            : "failed",
-                    safeErrorCode: accepted
-                        ? "DELIVERY_UNCONFIRMED"
-                        : authorizationUncertain || armed
-                            ? "WRITE_AUTHORIZATION_UNCERTAIN"
-                            : "PROVIDER_DISPATCH_FAILED",
-                };
-            }
-            const requeued = await this.applyDispatchResult(attempt.messageId, attempt.attemptId, result, armed, conversation, attempt.sourceAlias, attempt.targetAlias);
-            if (this.activeAttempts.get(attempt.messageId) === active)
-                this.activeAttempts.delete(attempt.messageId);
-            return requeued;
+                    accepted = true;
+                },
+            });
         }
-        return false;
+        catch {
+            result = {
+                state: accepted
+                    ? attempt.steer === true
+                        ? "ambiguous"
+                        : "unconfirmed"
+                    : armed || authorizationUncertain
+                        ? "ambiguous"
+                        : "failed",
+                safeErrorCode: accepted
+                    ? "DELIVERY_UNCONFIRMED"
+                    : authorizationUncertain || armed
+                        ? "WRITE_AUTHORIZATION_UNCERTAIN"
+                        : "PROVIDER_DISPATCH_FAILED",
+            };
+        }
+        const requeued = await this.applyDispatchResult(attempt.messageId, attempt.attemptId, result, armed, conversation, source.alias, target.alias);
+        if (this.activeAttempts.get(attempt.messageId) === active)
+            this.activeAttempts.delete(attempt.messageId);
+        return requeued;
     }
     async settleAttemptForShutdown(messageId, attemptId) {
         const result = await this.store.settleAttemptForShutdown({ messageId, attemptId });