agent-embassy 1.2.0 → 1.4.0

package/dist/src/gateway/service.js

@@ -1,7 +1,7 @@
 import { createHash, randomBytes } from "node:crypto";
 import { BridgeError } from "../errors.js";
 import { KeyedMutex } from "../mutex.js";
-import { certifiedCompatibilityVersions, compatibilitySurfaces, attachCompatibilityCertification, evaluateCompatibilityAttestation, isCompatibilityAttestation, isCompatibilityCertification, isCompatibilityCertificationReport, isCompatibilityCheckReport, } from "./compatibility.js";
+import { certifiedCompatibilityVersions, compatibilitySurfaces, evaluateCompatibilityAttestation, isCompatibilityAttestation, } from "./compatibility.js";
 import { createGatewayConversationId, isGatewaySnapshot, startGatewayControlServer, } from "./control.js";
 import { publishGatewayDashboard } from "./dashboard.js";
 import { createDeliveryMachine, isTerminalDeliveryMachine, projectDelivery, projectDeliveryWakeups, transitionDelivery, } from "./delivery-machine.js";
@@ -22,12 +22,6 @@ const NATIVE_HELD_THRESHOLD_MS = 1_000;
 const RUNTIME_ACTIVITY_CAPACITY = 256;
 const DELIVERY_SETTLEMENT_RETRY_MS = 250;
 const DELIVERY_DASHBOARD_REFRESH_MS = 15_000;
-const CLAUDE_CLEAN_PREWRITE_ROUTE_CODES = new Set([
-    "CLAUDE_PEER_TARGET_UNKNOWN",
-    "CLAUDE_PEER_TARGET_STALE",
-    "CLAUDE_PEER_TARGET_CHANGED",
-    "CLAUDE_PEER_WORKSPACE_UNATTESTED",
-]);
 function progressWatchActivity(text, conversationId, actorAlias, explicitIdleMinutes) {
     const prefixedOpen = text.startsWith("TRACK:");
     const completionSignal = text.startsWith("DONE:");
@@ -69,9 +63,6 @@ function endpointRefreshCallbackKey(event) {
                 ? {}
                 : { safeErrorCode: probe.safeErrorCode }),
         })),
-        ...(event.attestation.certification === undefined
-            ? {}
-            : { certification: { ...event.attestation.certification } }),
         ...(event.attestation.safeErrorCode === undefined
             ? {}
             : { safeErrorCode: event.attestation.safeErrorCode }),
@@ -103,6 +94,9 @@ function decisionFor(error) {
     if (!(error instanceof BridgeError)) {
         return { accepted: false, code: "rejected" };
     }
+    if (error.code === "PROGRESS_WATCH_REPLACEMENT_OWNER_REQUIRED") {
+        return { accepted: false, code: "watch_owner_conflict" };
+    }
     if (error.code.includes("NOT_FOUND") || error.code === "ROUTE_UNAVAILABLE") {
         return { accepted: false, code: "not_found" };
     }
@@ -145,8 +139,6 @@ export class GatewayService {
     activeDispatchByTarget = new Map();
     scheduledDispatchTargets = new Set();
     dispatchRunnerTargets = new Set();
-    /** Claude sends that proved no write wait for exact provider-idle evidence. */
-    claudePrewriteIdleWaitTargets = new Set();
     heldRedispatchTimers = new Map();
     pendingClaudeReplies = new Map();
     deliveryTrackers = new Map();
@@ -285,8 +277,8 @@ export class GatewayService {
             if (this.adapters.length > 0 &&
                 this.adapters.every((adapter) => adapter.compatibilitySurface !== undefined &&
                     adapter.runCompatibilityProbes !== undefined)) {
-                const report = await this.compatibilityCheckLocked();
-                const incompatible = report.surfaces.find((surface) => surface.tier === "incompatible");
+                const attestations = await this.runAutomaticCompatibilityProbesLocked();
+                const incompatible = attestations.find((surface) => surface.tier === "incompatible");
                 if (incompatible !== undefined) {
                     throw new BridgeError(incompatible.safeErrorCode ?? "COMPATIBILITY_CHECK_FAILED", "A local provider failed bounded compatibility attestation.");
                 }
@@ -427,7 +419,6 @@ export class GatewayService {
                 this.activeDispatchByTarget.clear();
                 this.scheduledDispatchTargets.clear();
                 this.dispatchRunnerTargets.clear();
-                this.claudePrewriteIdleWaitTargets.clear();
                 for (const timer of this.heldRedispatchTimers.values()) {
                     this.timers.clearTimeout(timer);
                 }
@@ -518,8 +509,6 @@ export class GatewayService {
             }),
             listSnapshot: async () => (await this.observeSnapshot()).snapshot,
             observeSnapshot: async () => await this.observeSnapshot(),
-            compatibilityCheck: async () => await this.compatibilityCheck(),
-            compatibilityCertify: async (params) => await this.compatibilityCertify(params),
             deliveryStatus: async (params) => await this.deliveryStatus(params.token),
             untrack: async (params) => await this.exclusiveDecision(async () => {
                 const settled = await this.store.settleProgressWatch({
@@ -550,133 +539,7 @@ export class GatewayService {
     async snapshot() {
         return (await this.observeSnapshot()).snapshot;
     }
-    async compatibilityCheck() {
-        return await this.mutex.run("service", async () => await this.compatibilityCheckLocked());
-    }
-    async compatibilityCertify(params) {
-        const plan = await this.mutex.run("service", async () => {
-            if (!this.running || this.closing) {
-                throw new BridgeError("COMPAT_PROVIDER_UNAVAILABLE", "Compatibility certification requires one running broker.");
-            }
-            const report = await this.compatibilityCheckLocked();
-            const codexRoutes = (await this.store.inspectPrivateCodexRoutes()).filter((route) => route.enabled);
-            const codexRoute = params.codexAlias === undefined
-                ? codexRoutes.length === 1
-                    ? codexRoutes[0]
-                    : undefined
-                : codexRoutes.find((route) => route.alias === params.codexAlias);
-            if (codexRoute === undefined) {
-                throw new BridgeError("COMPAT_CERTIFY_CODEX_ROUTE_REQUIRED", "Choose one exact registered Codex route for live certification.");
-            }
-            const adapters = new Map(this.adapters.map((adapter) => [adapter.identity.provider, adapter]));
-            return { adapters, codexRoute, report };
-        });
-        const certifiedAt = this.now().toISOString();
-        const updated = [];
-        for (const attestation of plan.report.surfaces) {
-            const adapter = plan.adapters.get(attestation.surface);
-            let certification;
-            if (attestation.tier === "incompatible" ||
-                adapter?.runCompatibilityCertification === undefined) {
-                certification = {
-                    depth: attestation.surface === "claude"
-                        ? "wire"
-                        : params.withTurn
-                            ? "turn"
-                            : "thread_ops",
-                    outcome: "fail",
-                    certifiedAt,
-                    safeErrorCode: attestation.safeErrorCode ??
-                        `${attestation.surface.toUpperCase()}_CERTIFICATION_UNAVAILABLE`,
-                };
-            }
-            else {
-                try {
-                    certification = await adapter.runCompatibilityCertification({
-                        controllerStateRoot: this.store.rootDir,
-                        withTurn: params.withTurn,
-                        ...(attestation.surface === "codex"
-                            ? { routeHandle: plan.codexRoute.binding.routeHandle }
-                            : {}),
-                    });
-                }
-                catch {
-                    certification = {
-                        depth: attestation.surface === "claude"
-                            ? "wire"
-                            : params.withTurn
-                                ? "turn"
-                                : "thread_ops",
-                        outcome: "fail",
-                        certifiedAt: this.now().toISOString(),
-                        safeErrorCode: `${attestation.surface.toUpperCase()}_CERTIFICATION_FAILED`,
-                    };
-                }
-            }
-            const expectedDepth = attestation.surface === "claude"
-                ? "wire"
-                : params.withTurn
-                    ? "turn"
-                    : "thread_ops";
-            if (!isCompatibilityCertification(certification) ||
-                certification.depth !== expectedDepth) {
-                certification = {
-                    depth: expectedDepth,
-                    outcome: "fail",
-                    certifiedAt: this.now().toISOString(),
-                    safeErrorCode: `${attestation.surface.toUpperCase()}_CERTIFICATION_EVIDENCE_INVALID`,
-                };
-            }
-            updated.push(attachCompatibilityCertification(attestation, certification));
-        }
-        return await this.mutex.run("service", async () => {
-            const currentCodexRoute = (await this.store.inspectPrivateCodexRoutes()).find((route) => route.enabled &&
-                route.alias === plan.codexRoute.alias &&
-                bindingKey(route.binding) === bindingKey(plan.codexRoute.binding));
-            const reconciled = updated.map((attestation) => {
-                if (attestation.surface === "codex" && currentCodexRoute === undefined) {
-                    return attachCompatibilityCertification(attestation, {
-                        depth: params.withTurn ? "turn" : "thread_ops",
-                        outcome: "fail",
-                        certifiedAt: this.now().toISOString(),
-                        safeErrorCode: "CODEX_CERTIFICATION_ROUTE_CHANGED",
-                    });
-                }
-                const observation = plan.adapters
-                    .get(attestation.surface)
-                    ?.compatibilitySurface?.();
-                if (observation?.surface === attestation.surface &&
-                    observation.version === attestation.version) {
-                    return attestation;
-                }
-                return attachCompatibilityCertification(attestation, {
-                    depth: attestation.surface === "claude"
-                        ? "wire"
-                        : params.withTurn
-                            ? "turn"
-                            : "thread_ops",
-                    outcome: "fail",
-                    certifiedAt: this.now().toISOString(),
-                    safeErrorCode: `${attestation.surface.toUpperCase()}_CERTIFICATION_VERSION_CHANGED`,
-                });
-            });
-            const result = {
-                policy: plan.report.policy,
-                certified: reconciled.every((attestation) => attestation.certification?.outcome === "pass"),
-                withTurn: params.withTurn,
-                surfaces: reconciled,
-            };
-            if (!isCompatibilityCertificationReport(result)) {
-                throw new BridgeError("COMPAT_CERTIFICATION_REPORT_INVALID", "Compatibility certification evidence failed its closed report schema.");
-            }
-            for (const attestation of reconciled) {
-                await this.store.recordCompatibilityAttestation(attestation);
-            }
-            await this.changed();
-            return result;
-        });
-    }
-    async compatibilityCheckLocked() {
+    async runAutomaticCompatibilityProbesLocked() {
         const bySurface = new Map(this.adapters.map((adapter) => {
             if (adapter.compatibilitySurface === undefined ||
                 adapter.runCompatibilityProbes === undefined) {
@@ -695,39 +558,21 @@ export class GatewayService {
             if (entry === undefined) {
                 throw new BridgeError("COMPAT_PROVIDER_UNAVAILABLE", "A required compatibility surface is unavailable.");
             }
-            const cached = await this.store.inspectCompatibilityAttestation(surface, entry.observation.version);
-            const probes = cached?.probes ?? (await entry.adapter.runCompatibilityProbes());
-            const checkedAt = cached?.checkedAt ?? this.now().toISOString();
-            let attestation = evaluateCompatibilityAttestation({
+            const probes = await entry.adapter.runCompatibilityProbes();
+            const attestation = evaluateCompatibilityAttestation({
                 surface,
                 version: entry.observation.version,
-                checkedAt,
-                policy: this.config.compatibilityPolicy ?? "observed",
+                checkedAt: this.now().toISOString(),
                 certifiedVersions: certifiedCompatibilityVersions[surface],
                 probes,
             });
-            if (cached?.certification !== undefined &&
-                attestation.tier !== "incompatible") {
-                attestation = attachCompatibilityCertification(attestation, cached.certification);
-            }
-            if (cached === undefined ||
-                JSON.stringify(cached) !== JSON.stringify(attestation)) {
-                await this.store.recordCompatibilityAttestation(attestation);
-            }
+            await this.store.recordCompatibilityAttestation(attestation);
             if (attestation.tier !== "incompatible") {
                 entry.adapter.acceptCompatibilityAttestation?.(attestation);
             }
             attestations.push(attestation);
         }
-        const report = {
-            policy: this.config.compatibilityPolicy ?? "observed",
-            compatible: attestations.every((attestation) => attestation.tier !== "incompatible"),
-            surfaces: attestations,
-        };
-        if (!isCompatibilityCheckReport(report)) {
-            throw new BridgeError("COMPAT_REPORT_INVALID", "Compatibility evidence failed its closed report schema.");
-        }
-        return report;
+        return attestations;
     }
     async observeSnapshot() {
         return await this.mutex.run("service", async () => {
@@ -2746,13 +2591,22 @@ export class GatewayService {
         const publicBefore = await this.discoveryPublicFingerprint();
         this.candidates.clear();
         const rowsByAlias = new Map();
+        const collisionByRouteHandle = new Map();
         const discoveredCandidates = [];
         const observedSelected = new Set();
         for (const adapter of this.adapters.filter((item) => item.identity.provider === "claude")) {
-            const discovered = (await adapter.discoverClaudePeers?.()) ?? {
+            let discovered = {
                 peers: [],
                 complete: false,
             };
+            try {
+                discovered = (await adapter.discoverClaudePeers?.()) ?? discovered;
+            }
+            catch {
+                // Registry observation is dashboard evidence, not Claude mailbox
+                // authority. The provider still revalidates the exact target before
+                // any write.
+            }
             const grouped = new Map();
             const byHandle = new Map();
             for (const peer of discovered.peers) {
@@ -2772,6 +2626,8 @@ export class GatewayService {
                 if (peer === undefined)
                     continue;
                 if (matches.length !== 1) {
+                    for (const match of matches)
+                        collisionByRouteHandle.set(match.routeHandle, "PEER_ALIAS_COLLISION");
                     rowsByAlias.set(alias, {
                         peer,
                         adapter,
@@ -2788,6 +2644,7 @@ export class GatewayService {
                     continue;
                 }
                 if ((byHandle.get(peer.routeHandle)?.length ?? 0) !== 1) {
+                    collisionByRouteHandle.set(peer.routeHandle, "PEER_SESSION_COLLISION");
                     rowsByAlias.set(alias, {
                         peer,
                         adapter,
@@ -2813,6 +2670,8 @@ export class GatewayService {
                     const collision = this.routeBindings.get(alias);
                     if (collision !== undefined &&
                         bindingKey(collision) !== bindingKey(existing[1])) {
+                        collisionByRouteHandle.set(routeHandle, "PEER_ALIAS_COLLISION");
+                        collisionByRouteHandle.set(collision.routeHandle, "PEER_ALIAS_COLLISION");
                         rowsByAlias.set(alias, {
                             peer: candidate,
                             adapter,
@@ -2827,10 +2686,16 @@ export class GatewayService {
             catch (error) {
                 if (!(error instanceof BridgeError))
                     throw error;
+                // Only a real alias collision may wear that receipt; every other
+                // rename failure is an unobserved peer, not a name conflict.
+                const safeErrorCode = error.code === "ROUTE_ALIAS_COLLISION"
+                    ? "PEER_ALIAS_COLLISION"
+                    : "PEER_NOT_OBSERVED";
+                collisionByRouteHandle.set(routeHandle, safeErrorCode);
                 rowsByAlias.set(alias, {
                     peer: candidate,
                     adapter,
-                    safeErrorCode: "PEER_ALIAS_COLLISION",
+                    safeErrorCode,
                 });
             }
         }
@@ -2899,6 +2764,9 @@ export class GatewayService {
                 observedSelected.has(bindingKey(binding))) {
                 continue;
             }
+            const discoveryError = collisionByRouteHandle.get(binding.routeHandle);
+            if (discoveryError === undefined)
+                continue;
             const inspection = await this.store.inspectPrivateRoute(alias);
             if (inspection !== undefined &&
                 inspection.enabled &&
@@ -2906,9 +2774,9 @@ export class GatewayService {
                 await this.drainPreDeadlineDeliveryCallbacksLocked();
                 const inFlightSettlements = await this.planRouteInFlightSettlementsLocked(alias, {
                     unwrittenOutcome: "failed",
-                    safeErrorCode: "PEER_NOT_OBSERVED",
+                    safeErrorCode: discoveryError,
                 });
-                const settlements = await this.store.invalidateRoute(binding, "PEER_NOT_OBSERVED", inFlightSettlements);
+                const settlements = await this.store.invalidateRoute(binding, discoveryError, inFlightSettlements);
                 for (const settlement of settlements) {
                     await this.applyTerminalSettlementLocked(settlement);
                 }
@@ -3135,6 +3003,11 @@ export class GatewayService {
     async resolveSelectedClaudeDestination(selector) {
         const discoveryChanged = await this.refreshClaudeDiscovery();
         try {
+            const selected = [...this.routeBindings.entries()].find(([alias, binding]) => binding.provider === "claude" &&
+                (alias === selector ||
+                    binding.routeHandle.toLowerCase() === selector.toLowerCase()));
+            if (selected !== undefined)
+                return { alias: selected[0], discoveryChanged };
             const candidate = this.claudeCandidate(selector);
             if (candidate === undefined) {
                 throw new BridgeError("PEER_NOT_FOUND", "No unique compatible interactive peer matches that current name or session UUID.");
@@ -3327,9 +3200,6 @@ export class GatewayService {
         this.routeBindings.set(alias, binding);
         this.routeStates.set(alias, state);
         this.bindingAliases.set(bindingKey(binding), alias);
-        if (binding.provider === "claude" && state === "idle") {
-            this.claudePrewriteIdleWaitTargets.delete(alias);
-        }
     }
     forgetBinding(alias) {
         const heldTimer = this.heldRedispatchTimers.get(alias);
@@ -3344,7 +3214,6 @@ export class GatewayService {
         }
         this.routeBindings.delete(alias);
         this.routeStates.delete(alias);
-        this.claudePrewriteIdleWaitTargets.delete(alias);
         for (const [messageId, continuation] of this.providerTurnContinuations) {
             if (continuation.targetAlias !== alias)
                 continue;
@@ -3453,8 +3322,10 @@ export class GatewayService {
                 enqueuedAt: input.enqueuedAt,
                 stallAt,
                 deadlineAt,
-                // Deferred means the provider proved no write. Permit one bounded
-                // attempt per 500 ms slice until this message's immutable deadline.
+                // Deferred means the provider proved no write. This budgets one
+                // attempt per 500 ms slice of this message's immutable deadline; a
+                // Codex-bound retry spends one slice each, while a Claude-bound retry
+                // backs off exponentially and spends far fewer of them.
                 maxCleanPrewriteRetries: Math.max(0, Math.ceil((deadlineAt - input.enqueuedAt) / 500)),
                 nativeReceipt: input.nativeReceipt !== undefined,
                 maxNativeReceiptCleanPrewriteRetries: DELIVERY_ACK_RETRY_DELAYS_MS.length,
@@ -4061,22 +3932,14 @@ export class GatewayService {
                     : "PROGRESS_WATCH_ENDPOINT_RETIRED", action.outcome === "unresponsive" ? "error" : "warning", { alias: action.ownerAlias });
                 continue;
             }
-            if (action.type === "notify_capability_degraded") {
-                this.addRuntimeAlert("PROGRESS_WATCH_CAPABILITY_DEGRADED", "warning", {
-                    alias: action.ownerAlias,
-                });
-                continue;
-            }
             const text = `[Embassy automated liveness check — ${action.conversationId} / ` +
                 `Embassy 自动活跃检查 — ${action.conversationId}]\n` +
                 "Reply with the result or a status. / 请回复结果或状态。";
             try {
-                await this.enqueue(action.ownerAlias, action.workerAlias, text, false, false, {
+                await this.enqueue(action.ownerAlias, action.workerAlias, text, false, {
                     existingConversationId: action.conversationId,
-                    requestedHopCount: 0,
                     exposeDeliveryToken: false,
                     skipProgressWatchActivity: true,
-                    preserveConversationHop: true,
                     progressWatchNudge: {
                         conversationId: action.conversationId,
                         nudgeNumber: action.nudgeNumber,
@@ -4123,8 +3986,7 @@ export class GatewayService {
                 }
                 if (!isTerminalDeliveryMachine(tracker.machine) &&
                     tracker.machine.dispatchRetryAt !== null &&
-                    tracker.machine.dispatchRetryAt <= now &&
-                    !this.claudePrewriteIdleWaitTargets.has(tracker.targetAlias)) {
+                    tracker.machine.dispatchRetryAt <= now) {
                     if (!this.dispatchRunnerTargets.has(tracker.targetAlias)) {
                         this.scheduleDispatch(tracker.targetAlias);
                     }
@@ -4213,7 +4075,6 @@ export class GatewayService {
                 if (wakeups.deadlineAt !== undefined)
                     consider(wakeups.deadlineAt);
                 if (wakeups.dispatchRetryAt !== undefined &&
-                    !this.claudePrewriteIdleWaitTargets.has(tracker.targetAlias) &&
                     !this.scheduledDispatchTargets.has(tracker.targetAlias) &&
                     !this.dispatchRunnerTargets.has(tracker.targetAlias)) {
                     consider(wakeups.dispatchRetryAt);
@@ -4311,7 +4172,7 @@ export class GatewayService {
                 await this.verifyCodex(params.fromAlias, params.threadId);
                 const resolved = await this.resolveSelectedClaudeDestination(params.toAlias);
                 discoveryChanged = resolved.discoveryChanged;
-                return this.acceptedControlResult(await this.enqueue(params.fromAlias, resolved.alias, params.text, params.expectsReply, false, params.trackIdleMinutes === undefined
+                return this.acceptedControlResult(await this.enqueue(params.fromAlias, resolved.alias, params.text, params.expectsReply, params.trackIdleMinutes === undefined
                     ? {}
                     : { trackIdleMinutes: params.trackIdleMinutes }));
             }
@@ -4330,7 +4191,7 @@ export class GatewayService {
             try {
                 await this.verifyClaude(params.fromAlias, params.replyAddress);
                 const steer = this.config.steeringEnabled && params.text.startsWith("STEER:");
-                return this.acceptedControlResult(await this.enqueue(params.fromAlias, params.toAlias, params.text, steer ? false : params.expectsReply, false, {
+                return this.acceptedControlResult(await this.enqueue(params.fromAlias, params.toAlias, params.text, steer ? false : params.expectsReply, {
                     ...(steer ? { steer: true } : {}),
                     ...(params.trackIdleMinutes === undefined
                         ? {}
@@ -4359,10 +4220,9 @@ export class GatewayService {
                     throw new BridgeError("ROUTE_MISMATCH", "The caller is not a conversation participant.");
                 const result = caller.kind === "codex" &&
                     this.nativeIngressByConversation.has(conversation.id)
-                    ? await this.enqueueNativeReply(conversation, from, params.text, conversation.lastHopCount + 1, true, params.trackIdleMinutes)
-                    : await this.enqueue(from, to, params.text, false, true, {
+                    ? await this.enqueueNativeReply(conversation, from, params.text, true, params.trackIdleMinutes)
+                    : await this.enqueue(from, to, params.text, false, {
                         existingConversationId: conversation.id,
-                        requestedHopCount: conversation.lastHopCount + 1,
                         ...(params.trackIdleMinutes === undefined
                             ? {}
                             : { trackIdleMinutes: params.trackIdleMinutes }),
@@ -4374,7 +4234,7 @@ export class GatewayService {
             }
         });
     }
-    async enqueue(sourceAlias, targetAlias, text, expectsReply, isReply, options = {}) {
+    async enqueue(sourceAlias, targetAlias, text, expectsReply, options = {}) {
         if (this.codexSuccessionPoisoned.has(sourceAlias) ||
             this.codexSuccessionPoisoned.has(targetAlias)) {
             throw new BridgeError("CODEX_SUCCESSION_RECOVERY_REQUIRED", "No message can be accepted while Codex succession requires manual recovery.");
@@ -4397,11 +4257,8 @@ export class GatewayService {
             targetAlias,
             expectsReply,
             nextSequence: 0,
-            lastHopCount: 0,
             lastActivityAt: this.now().toISOString(),
         };
-        const hopCount = options.requestedHopCount ??
-            (isReply ? conversation.lastHopCount + 1 : 0);
         const sequence = conversation.nextSequence;
         const enqueuedAt = this.now().getTime();
         const deliveryToken = (options.exposeDeliveryToken ?? true)
@@ -4414,7 +4271,6 @@ export class GatewayService {
             body: text,
             dedupeKey: `${conversationId}:${sequence}`,
             conversationIdSuffix: conversationId.slice(-8),
-            hopCount,
             deadlineAt,
             ...(options.steer === true ? { steer: true } : {}),
             ...(options.skipProgressWatchActivity === true
@@ -4435,15 +4291,10 @@ export class GatewayService {
         if (queued.pair === true)
             conversation.pair = true;
         conversation.nextSequence += 1;
-        if (options.preserveConversationHop !== true) {
-            conversation.lastHopCount = hopCount;
-        }
         conversation.lastActivityAt = this.now().toISOString();
         this.messageContexts.set(queued.messageId, {
             conversationId,
-            isReply,
             expectsReply,
-            hopCount,
             sequence,
             targetBindingKey: bindingKey(target),
             authorization: "selected_route",
@@ -4462,7 +4313,6 @@ export class GatewayService {
             this.pendingClaudeReplies.set(bindingKey(target), {
                 conversationId,
                 bindingKey: bindingKey(target),
-                hopCount,
                 deadlineAt,
                 tainted: false,
             });
@@ -4476,7 +4326,7 @@ export class GatewayService {
             ...(deliveryToken === undefined ? {} : { deliveryToken }),
         };
     }
-    async enqueueNativeReply(conversation, sourceAlias, text, requestedHopCount, exposeDeliveryToken = true, trackIdleMinutes) {
+    async enqueueNativeReply(conversation, sourceAlias, text, exposeDeliveryToken = true, trackIdleMinutes) {
         this.pruneTransient();
         const capability = this.nativeIngressByConversation.get(conversation.id);
         if (capability === undefined ||
@@ -4500,7 +4350,6 @@ export class GatewayService {
             body: text,
             dedupeKey: `${conversation.id}:${sequence}`,
             conversationIdSuffix: conversation.id.slice(-8),
-            hopCount: requestedHopCount,
             deadlineAt,
             ...(conversation.pair === true ? { pair: true } : {}),
             progressWatch: progressWatchActivity(text, conversation.id, sourceAlias, trackIdleMinutes),
@@ -4509,13 +4358,10 @@ export class GatewayService {
             throw new BridgeError("MESSAGE_REJECTED", "The native reply was not accepted.");
         }
         conversation.nextSequence += 1;
-        conversation.lastHopCount = requestedHopCount;
         conversation.lastActivityAt = this.now().toISOString();
         this.messageContexts.set(queued.messageId, {
             conversationId: conversation.id,
-            isReply: true,
             expectsReply: false,
-            hopCount: requestedHopCount,
             sequence,
             targetBindingKey: bindingKey(capability.binding),
             nativeReplyBinding: { ...capability.binding },
@@ -4547,7 +4393,7 @@ export class GatewayService {
      * native-ingress boundary; this preserves the exact connector generation
      * without recreating route authority or accepting a new unsolicited send.
      */
-    async enqueueObservedClaudeReplyAfterRouteTeardownLocked(conversation, sourceBinding, text, requestedHopCount) {
+    async enqueueObservedClaudeReplyAfterRouteTeardownLocked(conversation, sourceBinding, text) {
         const target = await this.store.resolveRoute(conversation.sourceAlias);
         if (sourceBinding.provider !== "claude" ||
             target.provider !== "codex" ||
@@ -4566,7 +4412,6 @@ export class GatewayService {
             body: text,
             dedupeKey: `${conversation.id}:${sequence}`,
             conversationIdSuffix: conversation.id.slice(-8),
-            hopCount: requestedHopCount,
             deadlineAt,
             authorizedPairTeardownReply: true,
             progressWatch: progressWatchActivity(text, conversation.id, conversation.targetAlias),
@@ -4575,16 +4420,13 @@ export class GatewayService {
             throw new BridgeError("MESSAGE_REJECTED", "The retained provider reply was not accepted.");
         }
         conversation.nextSequence += 1;
-        conversation.lastHopCount = requestedHopCount;
         conversation.lastActivityAt = this.now().toISOString();
         // The old edge has already been removed. Retain only this already-observed
         // reply attempt; the conversation no longer grants pair reply authority.
         delete conversation.pair;
         this.messageContexts.set(queued.messageId, {
             conversationId: conversation.id,
-            isReply: true,
             expectsReply: false,
-            hopCount: requestedHopCount,
             sequence,
             targetBindingKey: bindingKey(target),
             authorization: "selected_route",
@@ -4695,15 +4537,12 @@ export class GatewayService {
             targetAlias: item.targetAlias,
             expectsReply: false,
             nextSequence: 1,
-            lastHopCount: item.hopCount,
             lastActivityAt: this.now().toISOString(),
             ...(item.pair === true ? { pair: true } : {}),
         };
         const context = {
             conversationId,
-            isReply: false,
             expectsReply: false,
-            hopCount: item.hopCount,
             sequence: 0,
             targetBindingKey: bindingKey(binding),
             authorization: "selected_route",
@@ -4726,8 +4565,7 @@ export class GatewayService {
         if (!this.running ||
             this.closing ||
             this.codexSuccessionDispatchFrozen.has(targetAlias) ||
-            this.codexSuccessionPoisoned.has(targetAlias) ||
-            this.claudePrewriteIdleWaitTargets.has(targetAlias)) {
+            this.codexSuccessionPoisoned.has(targetAlias)) {
             return;
         }
         if (await this.processLifecycleLocked()) {
@@ -4762,7 +4600,6 @@ export class GatewayService {
         if (context === undefined && selectedBinding !== undefined) {
             context = this.restoreQueuedMessageContextLocked(item, selectedBinding);
         }
-        const binding = context?.nativeReplyBinding ?? selectedBinding;
         if (context === undefined) {
             const result = await this.store.settleMessage({
                 messageId: item.messageId,
@@ -4775,6 +4612,7 @@ export class GatewayService {
             }
             return;
         }
+        const binding = context.nativeReplyBinding ?? selectedBinding;
         if (binding === undefined) {
             const result = await this.store.requeueInFlightMessage(item.messageId, item.body);
             if (result.status === "settled") {
@@ -4785,8 +4623,8 @@ export class GatewayService {
         }
         if (context.authorization === "selected_route") {
             const routeState = this.routeStates.get(targetAlias);
-            const dispatchable = routeState === "idle" ||
-                (binding.provider === "claude" && routeState === "busy") ||
+            const dispatchable = binding.provider === "claude" ||
+                routeState === "idle" ||
                 (binding.provider === "codex" &&
                     item.steer === true &&
                     routeState === "busy");
@@ -4814,8 +4652,8 @@ export class GatewayService {
                 this.scheduleDispatch(targetAlias);
                 return;
             }
-            const storedDispatchable = inspection?.state === "idle" ||
-                (binding.provider === "claude" && inspection?.state === "busy") ||
+            const storedDispatchable = binding.provider === "claude" ||
+                inspection?.state === "idle" ||
                 (binding.provider === "codex" &&
                     item.steer === true &&
                     inspection?.state === "busy");
@@ -4903,6 +4741,23 @@ export class GatewayService {
             this.scheduleLifecycleWakeLocked();
             return;
         }
+        let progressWatches = await this.store.inspectProgressWatches();
+        if (context.recovered === true &&
+            item.pair === true &&
+            !item.body.startsWith("DONE:") &&
+            progressWatches.some((watch) => watch.capability === "route" &&
+                watch.ownerAlias === item.sourceAlias &&
+                watch.workerAlias === item.targetAlias)) {
+            await this.store.bindProgressWatchConversation({
+                conversationId: context.conversationId,
+                ownerAlias: item.sourceAlias,
+                workerAlias: item.targetAlias,
+            });
+            progressWatches = await this.store.inspectProgressWatches();
+        }
+        const progressWatchActive = progressWatches.some((watch) => watch.capability === "conversation" &&
+            watch.workerAlias === item.targetAlias &&
+            watch.conversationId === context.conversationId);
         let result;
         try {
             result = await this.awaitDispatchWithNativeHeldLocked(tracker, this.adapter(binding.provider, binding.hostId).dispatch({
@@ -4913,9 +4768,12 @@ export class GatewayService {
                 authorization: context.authorization,
                 messageId: item.messageId,
                 text: item.body,
-                expectsReply: context?.expectsReply ?? false,
+                expectsReply: context.expectsReply,
                 deadlineAt: item.deadlineAt,
                 ...(item.steer === true ? { steer: true } : {}),
+                ...(progressWatchActive
+                    ? { progressWatchActive: true }
+                    : {}),
             }));
         }
         catch {
@@ -4948,10 +4806,19 @@ export class GatewayService {
             const currentTargetAlias = this.bindingAliases.get(bindingKey(binding)) ?? targetAlias;
             const now = this.now().getTime();
             const deferredSafeErrorCode = safeCode(result.safeErrorCode, "PROVIDER_DISPATCH_DEFERRED");
+            const retryDelayMs = binding.provider === "claude"
+                ? Math.min(500 * 2 ** (tracker.machine.dispatchAttempt - 1), 300_000)
+                : 500;
+            // Only Claude's backoff is clamped inside the deadline, so a long delay
+            // still buys one last attempt. A Codex-bound retry keeps its exact
+            // unclamped slice: a slice past the deadline must settle now, not wait.
+            const retryAt = binding.provider === "claude"
+                ? Math.min(now + retryDelayMs, tracker.deadlineAt - 1)
+                : now + retryDelayMs;
             await this.advanceDeliveryLocked(item.messageId, {
                 type: "dispatch_clean_prewrite_failed",
                 at: now,
-                retryAt: now + 500,
+                retryAt,
                 safeErrorCode: deferredSafeErrorCode,
             });
             tracker.deliverySafeErrorCode = deferredSafeErrorCode;
@@ -4979,12 +4846,7 @@ export class GatewayService {
             }
             if (requeued.status === "requeued") {
                 if (context.authorization === "selected_route") {
-                    const waitForClaudeIdle = binding.provider === "claude" &&
-                        CLAUDE_CLEAN_PREWRITE_ROUTE_CODES.has(deferredSafeErrorCode);
-                    if (waitForClaudeIdle) {
-                        this.claudePrewriteIdleWaitTargets.add(currentTargetAlias);
-                    }
-                    else if (!steeringWhileBusy) {
+                    if (binding.provider === "codex" && !steeringWhileBusy) {
                         this.routeStates.set(currentTargetAlias, "idle");
                         await this.store.observeRoute({
                             binding,
@@ -4992,7 +4854,7 @@ export class GatewayService {
                             compatibility: "compatible",
                         });
                     }
-                    else {
+                    else if (binding.provider === "codex") {
                         this.scheduleHeldRedispatch(currentTargetAlias);
                     }
                     await this.setNativeCodexStatus(currentTargetAlias, "waiting");
@@ -5024,8 +4886,7 @@ export class GatewayService {
     scheduleDispatch(targetAlias) {
         if (this.closing ||
             this.codexSuccessionDispatchFrozen.has(targetAlias) ||
-            this.codexSuccessionPoisoned.has(targetAlias) ||
-            this.claudePrewriteIdleWaitTargets.has(targetAlias)) {
+            this.codexSuccessionPoisoned.has(targetAlias)) {
             return;
         }
         if (this.scheduledDispatchTargets.has(targetAlias))
@@ -5198,7 +5059,7 @@ export class GatewayService {
             conversation !== undefined) {
             try {
                 if (this.nativeIngressByConversation.has(conversation.id)) {
-                    await this.enqueueNativeReply(conversation, conversation.targetAlias, replyText, context.hopCount + 1, false);
+                    await this.enqueueNativeReply(conversation, conversation.targetAlias, replyText, false);
                 }
                 else {
                     const sourceBinding = this.routeBindings.get(conversation.targetAlias);
@@ -5213,12 +5074,11 @@ export class GatewayService {
                         }));
                     if ((!sourceStillRoutable || !pairStillActive) &&
                         sourceBinding?.provider === "claude") {
-                        await this.enqueueObservedClaudeReplyAfterRouteTeardownLocked(conversation, sourceBinding, replyText, context.hopCount + 1);
+                        await this.enqueueObservedClaudeReplyAfterRouteTeardownLocked(conversation, sourceBinding, replyText);
                     }
                     else {
-                        await this.enqueue(conversation.targetAlias, conversation.sourceAlias, replyText, false, true, {
+                        await this.enqueue(conversation.targetAlias, conversation.sourceAlias, replyText, false, {
                             existingConversationId: conversation.id,
-                            requestedHopCount: context.hopCount + 1,
                             exposeDeliveryToken: false,
                         });
                     }
@@ -5279,9 +5139,8 @@ export class GatewayService {
         if (conversation === undefined)
             return;
         this.pendingClaudeReplies.delete(key);
-        await this.enqueue(conversation.targetAlias, conversation.sourceAlias, event.text, false, true, {
+        await this.enqueue(conversation.targetAlias, conversation.sourceAlias, event.text, false, {
             existingConversationId: conversation.id,
-            requestedHopCount: pending.hopCount + 1,
             exposeDeliveryToken: false,
         });
     }
@@ -5324,7 +5183,6 @@ export class GatewayService {
                 body: event.text,
                 dedupeKey: `${conversationId}:0`,
                 conversationIdSuffix: conversationId.slice(-8),
-                hopCount: 0,
                 deadlineAt,
                 ...(steer ? { steer: true } : {}),
                 progressWatch: progressWatchActivity(event.text, conversationId, event.sourceAlias),
@@ -5342,16 +5200,13 @@ export class GatewayService {
                 targetAlias: event.targetAlias,
                 expectsReply: !steer,
                 nextSequence: 1,
-                lastHopCount: 0,
                 lastActivityAt: this.now().toISOString(),
                 ...(queued.pair === true ? { pair: true } : {}),
             };
             this.conversations.set(conversationId, conversation);
             this.messageContexts.set(queued.messageId, {
                 conversationId,
-                isReply: false,
                 expectsReply: !steer,
-                hopCount: 0,
                 sequence: 0,
                 targetBindingKey: bindingKey(target),
                 authorization: "selected_route",
@@ -5824,9 +5679,6 @@ export class GatewayService {
         const [alias, binding] = entry;
         const previousState = this.routeStates.get(alias);
         this.routeStates.set(alias, event.state);
-        if (binding.provider === "claude" && event.state === "idle") {
-            this.claudePrewriteIdleWaitTargets.delete(alias);
-        }
         const staleSafeCode = binding.provider === "codex"
             ? "CODEX_ROUTE_STALE"
             : safeCode(event.safeErrorCode, "ROUTE_STALE");
@@ -6037,21 +5889,6 @@ export class GatewayService {
                 },
             ];
         });
-        const certificationAlerts = compatibilityChecks.flatMap((attestation) => {
-            const certification = attestation.certification;
-            if (certification?.outcome !== "fail")
-                return [];
-            const adapter = this.adapters.find((candidate) => candidate.identity.provider === attestation.surface);
-            return [
-                {
-                    code: "COMPATIBILITY_CERTIFICATION_FAILED",
-                    severity: "error",
-                    timestamp: certification.certifiedAt,
-                    provider: attestation.surface,
-                    host: adapter?.identity.hostId ?? "this-mac",
-                },
-            ];
-        });
         return projectGatewayPublicSnapshot({
             ...base,
             ...(compatibilityChecks.length === 0 ? {} : { compatibilityChecks }),
@@ -6067,7 +5904,6 @@ export class GatewayService {
             alerts: [
                 ...base.alerts,
                 ...this.runtimeAlerts.map((alert) => ({ ...alert })),
-                ...certificationAlerts,
                 ...stalledAlerts,
             ],
         });