agent-embassy 1.2.0 → 1.4.0

package/dist/src/gateway/providers.js

@@ -1,8 +1,7 @@
-import { createHash, randomBytes } from "node:crypto";
+import { createHash } from "node:crypto";
 import path from "node:path";
 import { BridgeError } from "../errors.js";
 import { CLAUDE_PEER_COMPATIBILITY, ClaudePeerAdapter, } from "./claude-peer.js";
-import { startClaudeCompatibilityScratch, } from "./claude-compatibility-scratch.js";
 import { certifiedCompatibilityVersions, compatibilityProbeNames, evaluateCompatibilityAttestation, sharesCompatibilityMajor, } from "./compatibility.js";
 import { CODEX_APP_SERVER_WRITABLE_VERSIONS, CodexAppServerConnector, CodexConnectorError, } from "./codex-app-server.js";
 import { LocalCodexTransportError } from "./codex-local-transport.js";
@@ -25,9 +24,6 @@ const DEFAULT_CODEX_RECOVERY_INITIAL_MS = 250;
 const DEFAULT_CODEX_RECOVERY_MAX_MS = 5_000;
 const MAX_CODEX_ENDPOINT_REFRESH_CANDIDATES = 3;
 const COMPATIBILITY_PROBE_THREAD_ID = "00000000-0000-7000-8000-000000000000";
-const COMPATIBILITY_TURN_TIMEOUT_MS = 60_000;
-const CLAUDE_CERTIFICATION_TIMEOUT_MS = 10_000;
-const CLAUDE_CERTIFICATION_DISCOVERY_POLL_MS = 100;
 const CLAUDE_CLEAN_PREWRITE_RETRY_CODES = new Set([
     "CLAUDE_PEER_TARGET_UNKNOWN",
     "CLAUDE_PEER_TARGET_STALE",
@@ -109,7 +105,8 @@ function invokeCallback(operation) {
     }
 }
 function validateAttestedClaudeRuntime(runtime) {
-    if (!sharesCompatibilityMajor(runtime.claudeCodeVersion, CLAUDE_PEER_COMPATIBILITY.claudeCodeVersion) ||
+    if (runtime.claudeCodeVersion !==
+        CLAUDE_PEER_COMPATIBILITY.claudeCodeVersion ||
         [
             runtime.claudeExecutable,
             runtime.sessionsDir,
@@ -146,7 +143,6 @@ export class LocalClaudeGatewayProvider {
     now;
     selectedStateRoots = new Map();
     nativeHelpers;
-    compatibilityScratchFactory;
     discovered = new Map();
     selected = new Map();
     /** Exact live same-UID sessions observed through native inbound frames. */
@@ -179,7 +175,6 @@ export class LocalClaudeGatewayProvider {
     retiredNativeCodexListener;
     /** Fences discovery callbacks and monitor restarts across listener rotation. */
     nativeCodexSuccessionFreeze;
-    compatibilityCertificationInFlight = false;
     initialized = false;
     closed = false;
     constructor(options) {
@@ -205,9 +200,6 @@ export class LocalClaudeGatewayProvider {
                 locale,
                 deliveryNotices,
             })))(options.runtime, options.locale ?? "en", options.deliveryNotices ?? "merged");
-        this.compatibilityScratchFactory =
-            options.compatibilityScratchFactory ??
-                (() => startClaudeCompatibilityScratch(options.runtime));
         this.nativeHelpers =
             options.nativeHelpers === undefined
                 ? undefined
@@ -258,90 +250,6 @@ export class LocalClaudeGatewayProvider {
             ];
         }
     }
-    async runCompatibilityCertification(input) {
-        void input.routeHandle;
-        void input.withTurn;
-        const depth = "wire";
-        let scratch;
-        let listener;
-        if (this.compatibilityCertificationInFlight) {
-            return {
-                depth,
-                outcome: "fail",
-                certifiedAt: new Date(this.now()).toISOString(),
-                safeErrorCode: "CLAUDE_CERTIFICATION_BUSY",
-            };
-        }
-        this.compatibilityCertificationInFlight = true;
-        try {
-            this.assertReady();
-            scratch = await this.compatibilityScratchFactory();
-            const deadlineAt = this.now() + CLAUDE_CERTIFICATION_TIMEOUT_MS;
-            let targetId;
-            while (this.now() < deadlineAt) {
-                scratch.assertRunning();
-                const discovery = await this.peer.discover();
-                if (discovery.truncated) {
-                    throw new BridgeError("CLAUDE_CERTIFICATION_DISCOVERY_INCOMPLETE", "The scratch session could not be proven from a complete registry scan.", true);
-                }
-                const matches = discovery.peers.filter((peer) => peer.alias === scratch?.name && peer.targetId === scratch?.sessionId);
-                if (matches.length > 1) {
-                    throw new BridgeError("CLAUDE_CERTIFICATION_TARGET_COLLISION", "The scratch session identity was not unique.");
-                }
-                if (matches.length === 1) {
-                    targetId = matches[0]?.targetId;
-                    break;
-                }
-                await new Promise((resolve) => {
-                    const timer = setTimeout(resolve, CLAUDE_CERTIFICATION_DISCOVERY_POLL_MS);
-                    timer.unref();
-                });
-            }
-            if (targetId === undefined) {
-                throw new BridgeError("CLAUDE_CERTIFICATION_TARGET_UNAVAILABLE", "The bounded scratch session did not publish a discoverable peer record.", true);
-            }
-            await this.peer.assertTargetWorkspaceDisjoint(targetId, input.controllerStateRoot);
-            listener = await this.peer.listen({
-                onMessage: () => undefined,
-                onReceipt: () => undefined,
-            });
-            const sent = await this.peer.send(targetId, "[embassy compat-certify] ignore", {
-                listener,
-                receiptDeadlineAt: deadlineAt,
-            });
-            if (sent.transportStatus !== "transport_written" ||
-                sent.receiptStatus !== "pending") {
-                throw new BridgeError("CLAUDE_CERTIFICATION_WRITE_UNCONFIRMED", "The scratch diagnostic frame was not accepted for receipt tracking.", true);
-            }
-            // A direct `crossSessionInbound: accept` write emits no native
-            // peer_message_status frame. That status family describes the optional
-            // approval lifecycle, not universal delivery acknowledgement. For this
-            // wire-depth certification, the strongest portable evidence is the
-            // confirmed write to the exact, uniquely discovered scratch session.
-            return {
-                depth,
-                outcome: "pass",
-                certifiedAt: new Date(this.now()).toISOString(),
-            };
-        }
-        catch (error) {
-            const observedCode = error instanceof BridgeError && /^[A-Z][A-Z0-9_]{0,63}$/.test(error.code)
-                ? error.code
-                : "CLAUDE_CERTIFICATION_FAILED";
-            return {
-                depth,
-                outcome: "fail",
-                certifiedAt: new Date(this.now()).toISOString(),
-                safeErrorCode: observedCode,
-            };
-        }
-        finally {
-            await listener?.close().catch(() => undefined);
-            await scratch?.close().catch(() => undefined);
-            await this.peer.discover().catch(() => undefined);
-            this.compatibilityCertificationInFlight = false;
-        }
-    }
     async initialize(callbacks) {
         if (this.closed) {
             throw new BridgeError("CLAUDE_PROVIDER_CLOSED", "The local Claude provider is closed.");
@@ -871,9 +779,7 @@ export class LocalClaudeGatewayProvider {
             const selectedAlias = this.selected.get(input.binding.routeHandle);
             const stateRoot = this.selectedStateRoots.get(input.binding.routeHandle);
             if (input.authorization === "selected_route" &&
-                (selectedAlias === undefined ||
-                    selectedAlias !== input.targetAlias ||
-                    stateRoot === undefined)) {
+                (selectedAlias === undefined || stateRoot === undefined)) {
                 return { state: "failed", safeErrorCode: "CLAUDE_ROUTE_UNAVAILABLE" };
             }
             if (input.authorization === "selected_route") {
@@ -919,29 +825,17 @@ export class LocalClaudeGatewayProvider {
             return { state: "failed", safeErrorCode: "CLAUDE_ROUTE_UNAVAILABLE" };
         }
         if (input.authorization === "native_reply") {
-            try {
-                await this.refreshClaudeDiscovery();
-            }
-            catch {
-                return { state: "failed", safeErrorCode: "CLAUDE_ROUTE_UNAVAILABLE" };
-            }
             const observedRoute = this.nativeInbound.get(input.binding.routeHandle);
-            const current = this.discovered.get(input.binding.routeHandle);
             if (observedRoute === undefined ||
-                observedRoute.listenerGeneration !== activeListener.generation ||
-                current?.alias !== observedRoute.alias) {
+                observedRoute.listenerGeneration !== activeListener.generation) {
                 this.nativeInbound.delete(input.binding.routeHandle);
                 return { state: "failed", safeErrorCode: "CLAUDE_NATIVE_REPLY_STALE" };
             }
-            if (observedRoute.alias !== input.targetAlias) {
-                return { state: "failed", safeErrorCode: "CLAUDE_ROUTE_UNAVAILABLE" };
-            }
         }
         else {
             const selectedAlias = this.selected.get(input.binding.routeHandle);
             const stateRoot = this.selectedStateRoots.get(input.binding.routeHandle);
             if (selectedAlias === undefined ||
-                selectedAlias !== input.targetAlias ||
                 stateRoot === undefined) {
                 return { state: "failed", safeErrorCode: "CLAUDE_ROUTE_UNAVAILABLE" };
             }
@@ -970,6 +864,9 @@ export class LocalClaudeGatewayProvider {
                 targetAlias: input.targetAlias,
                 conversationId: input.conversationId,
                 body: input.text,
+                ...(input.progressWatchActive === true
+                    ? { progressWatchActive: true }
+                    : {}),
             });
         }
         catch (error) {
@@ -987,8 +884,8 @@ export class LocalClaudeGatewayProvider {
             }
             this.selectedDispatchEpoch.set(input.binding.routeHandle, (this.selectedDispatchEpoch.get(input.binding.routeHandle) ?? 0) + 1);
             // The exact workspace attestation is refreshed before every send. A
-            // clean failure keeps the route busy until a later authoritative idle
-            // observation wakes the one bounded retry.
+            // clean prewrite failure remains retryable within the message deadline;
+            // retry timing does not depend on the model turn's observed state.
             this.selectedObservationDirty.add(input.binding.routeHandle);
             this.emitClaudeRouteObservation(input.binding.routeHandle, "busy");
             try {
@@ -1558,29 +1455,16 @@ export class LocalClaudeGatewayProvider {
             this.discovered.set(peer.targetId, row);
             rows.push(row);
         }
-        for (const [routeHandle, route] of this.nativeInbound) {
-            const current = this.discovered.get(routeHandle);
-            if (current !== undefined) {
-                // The stable session UUID owns native reply authority. A rename only
-                // updates its current public coordinate.
-                this.nativeInbound.set(routeHandle, {
-                    alias: current.alias,
-                    listenerGeneration: route.listenerGeneration,
-                });
-            }
-            else if (!discovery.truncated) {
-                this.nativeInbound.delete(routeHandle);
-            }
-        }
         for (const [routeHandle, selectedAlias] of this.selected) {
             const row = this.discovered.get(routeHandle);
             if (row === undefined) {
                 this.emitClaudeRouteObservation(routeHandle, "busy", "CLAUDE_PEER_NOT_OBSERVED", true);
             }
             else {
-                if (row.alias !== selectedAlias) {
+                if (!discovery.truncated && row.alias !== selectedAlias) {
                     // A Claude rename changes only the live name index. The native
-                    // session UUID remains the selected logical route.
+                    // session UUID remains the selected logical route. An incomplete
+                    // scan is display evidence only and cannot rename dispatch authority.
                     this.selected.set(routeHandle, row.alias);
                 }
                 if (row.state === "idle" &&
@@ -1665,7 +1549,8 @@ function validateCodexFactory(factory) {
     if (factory.hostId !== LOCAL_HOST ||
         factory.protocol !== "codex-app-server" ||
         factory.protocolVersion !== factory.appServerVersion ||
-        (!certified && !schemaCandidate) ||
+        (!certified &&
+            (!schemaCandidate || write !== null || factory.writableReady)) ||
         schema.appServerVersion !== factory.appServerVersion ||
         schema.endpointGeneration !== factory.endpointGeneration ||
         schema.protocol !== "app-server-v2-stable" ||
@@ -1714,7 +1599,6 @@ function codexRouteSafeCode(observation) {
 export class LocalCodexGatewayProvider {
     factory;
     refreshFactory;
-    compatibilityPolicy;
     maxCallbacks;
     maxRoutes;
     maxReplyBytes;
@@ -1735,8 +1619,6 @@ export class LocalCodexGatewayProvider {
     trackedRoutes = new Set();
     retiredEndpointGeneration;
     expectsReply = new Map();
-    compatibilityCertifyingRoutes = new Set();
-    compatibilityTurns = new Map();
     callbackQueue = [];
     callbackScheduled = false;
     callbacks;
@@ -1756,8 +1638,6 @@ export class LocalCodexGatewayProvider {
         validateCodexFactory(options.factory);
         this.factory = options.factory;
         this.refreshFactory = options.refreshFactory;
-        this.compatibilityPolicy =
-            options.compatibilityPolicy ?? options.factory.compatibilityPolicy;
         exactLocalHost(options.factory.hostId);
         this.compatibilityAttested = CODEX_APP_SERVER_WRITABLE_VERSIONS.includes(options.factory.appServerVersion);
         this.maxCallbacks = positiveBounded(options.maxCallbackEvents, MAX_CODEX_CALLBACKS, 4_096);
@@ -1795,7 +1675,8 @@ export class LocalCodexGatewayProvider {
         const pending = this.pendingEndpointAttestation;
         if (attestation.surface !== "codex" ||
             attestation.version !== this.factory.appServerVersion ||
-            attestation.tier === "incompatible" ||
+            attestation.tier !== "certified" ||
+            !CODEX_APP_SERVER_WRITABLE_VERSIONS.includes(attestation.version) ||
             (this.endpointUnavailable && pending === undefined) ||
             (pending !== undefined &&
                 (attestation.checkedAt !== pending.checkedAt ||
@@ -1885,107 +1766,6 @@ export class LocalCodexGatewayProvider {
             }
         }
     }
-    async runCompatibilityCertification(input) {
-        void input.controllerStateRoot;
-        const certifiedAt = this.now().toISOString();
-        const depth = input.withTurn ? "turn" : "thread_ops";
-        const routeHandle = input.routeHandle;
-        if (routeHandle === undefined || this.compatibilityCertifyingRoutes.has(routeHandle)) {
-            return {
-                depth,
-                outcome: "fail",
-                certifiedAt,
-                safeErrorCode: "CODEX_CERTIFICATION_ROUTE_REQUIRED",
-            };
-        }
-        this.assertReady();
-        const route = this.routes.get(routeHandle);
-        if (route === undefined || !this.observeRouteSuccessionBarrier(routeHandle).clean) {
-            return {
-                depth,
-                outcome: "fail",
-                certifiedAt,
-                safeErrorCode: "CODEX_CERTIFICATION_ROUTE_BUSY",
-            };
-        }
-        this.compatibilityCertifyingRoutes.add(routeHandle);
-        try {
-            const loaded = await route.connector.observeLoadedThread(route.connector.guard());
-            if (!loaded.selectedThreadLoaded) {
-                return {
-                    depth,
-                    outcome: "fail",
-                    certifiedAt: this.now().toISOString(),
-                    safeErrorCode: "CODEX_CERTIFICATION_THREAD_UNAVAILABLE",
-                };
-            }
-            await route.connector.certifyThreadOperations(route.connector.guard());
-            if (!input.withTurn) {
-                return {
-                    depth,
-                    outcome: "pass",
-                    certifiedAt: this.now().toISOString(),
-                };
-            }
-            const messageId = `compat_${randomBytes(12).toString("hex")}`;
-            const result = new Promise((resolve) => {
-                const timer = setTimeout(() => {
-                    this.compatibilityTurns.delete(messageId);
-                    resolve({
-                        messageId,
-                        outcome: "expired",
-                        replyCode: "REPLY_UNAVAILABLE",
-                        text: null,
-                    });
-                }, COMPATIBILITY_TURN_TIMEOUT_MS);
-                timer.unref();
-                this.compatibilityTurns.set(messageId, { resolve, timer });
-            });
-            try {
-                const disposition = await route.connector.submitMessage(route.connector.guard(), {
-                    deadlineAt: new Date(this.now().getTime() + COMPATIBILITY_TURN_TIMEOUT_MS).toISOString(),
-                    messageId,
-                    text: "reply OK",
-                });
-                if (disposition.disposition !== "started") {
-                    throw new BridgeError("CODEX_CERTIFICATION_TURN_NOT_STARTED", "The bounded certification turn did not start on the exact idle route.");
-                }
-                const settled = await result;
-                if (settled.outcome !== "completed" ||
-                    settled.text?.trim() !== "OK") {
-                    return {
-                        depth,
-                        outcome: "fail",
-                        certifiedAt: this.now().toISOString(),
-                        safeErrorCode: "CODEX_CERTIFICATION_TURN_FAILED",
-                    };
-                }
-                return {
-                    depth,
-                    outcome: "pass",
-                    certifiedAt: this.now().toISOString(),
-                };
-            }
-            finally {
-                const pending = this.compatibilityTurns.get(messageId);
-                if (pending !== undefined) {
-                    clearTimeout(pending.timer);
-                    this.compatibilityTurns.delete(messageId);
-                }
-            }
-        }
-        catch {
-            return {
-                depth,
-                outcome: "fail",
-                certifiedAt: this.now().toISOString(),
-                safeErrorCode: "CODEX_CERTIFICATION_FAILED",
-            };
-        }
-        finally {
-            this.compatibilityCertifyingRoutes.delete(routeHandle);
-        }
-    }
     async initialize(callbacks) {
         if (this.closed || this.initialized) {
             throw new BridgeError("CODEX_PROVIDER_INITIALIZATION_REJECTED", "The local Codex provider cannot be initialized in this state.");
@@ -2172,9 +1952,6 @@ export class LocalCodexGatewayProvider {
             route.endpointGeneration !== this.factory.endpointGeneration) {
             return { state: "failed", safeErrorCode: "CODEX_ROUTE_UNAVAILABLE" };
         }
-        if (this.compatibilityCertifyingRoutes.has(input.binding.routeHandle)) {
-            return { state: "deferred", safeErrorCode: "CODEX_ROUTE_HELD" };
-        }
         if (!this.factory.writableReady ||
             this.factory.writeCompatibility === null) {
             return { state: "failed", safeErrorCode: "CODEX_WRITES_DISABLED" };
@@ -2197,6 +1974,9 @@ export class LocalCodexGatewayProvider {
                 targetAlias: input.targetAlias,
                 conversationId: input.conversationId,
                 body: input.text,
+                ...(input.progressWatchActive === true
+                    ? { progressWatchActive: true }
+                    : {}),
             });
         }
         catch (error) {
@@ -2321,17 +2101,6 @@ export class LocalCodexGatewayProvider {
         this.closed = true;
         this.closing = false;
         this.callbackQueue.length = 0;
-        for (const [messageId, pending] of this.compatibilityTurns) {
-            clearTimeout(pending.timer);
-            pending.resolve({
-                messageId,
-                outcome: "abandoned",
-                replyCode: "REPLY_UNAVAILABLE",
-                text: null,
-            });
-        }
-        this.compatibilityTurns.clear();
-        this.compatibilityCertifyingRoutes.clear();
         this.pendingEndpointAttestation = undefined;
         this.pendingEndpointRefreshEvent = undefined;
         this.trackedRoutes.clear();
@@ -2723,8 +2492,7 @@ export class LocalCodexGatewayProvider {
                 candidate = await refreshFactory();
                 validateCodexFactory(candidate);
                 if (candidate.hostId !== previous.hostId ||
-                    candidate.protocol !== previousFactory.protocol ||
-                    candidate.compatibilityPolicy !== this.compatibilityPolicy) {
+                    candidate.protocol !== previousFactory.protocol) {
                     throw new BridgeError("CODEX_FACTORY_ATTESTATION_INVALID", "The replacement Codex factory moved outside its pinned boundary.");
                 }
                 if (candidate === previousFactory ||
@@ -2744,7 +2512,6 @@ export class LocalCodexGatewayProvider {
                     surface: "codex",
                     version: candidate.appServerVersion,
                     checkedAt: this.now().toISOString(),
-                    policy: this.compatibilityPolicy,
                     certifiedVersions: certifiedCompatibilityVersions.codex,
                     probes,
                 });
@@ -2881,13 +2648,6 @@ export class LocalCodexGatewayProvider {
         invokeCallback(() => callbacks.onEndpointRefresh?.(event));
     }
     onTurnResult(endpointGeneration, result) {
-        const certification = this.compatibilityTurns.get(result.messageId);
-        if (certification !== undefined) {
-            clearTimeout(certification.timer);
-            this.compatibilityTurns.delete(result.messageId);
-            certification.resolve(result);
-            return;
-        }
         const wantsReply = this.expectsReply.get(result.messageId) === true;
         this.expectsReply.delete(result.messageId);
         let replyText;