agent-embassy 1.6.1 → 1.7.1

package/dist/src/gateway/service.js

@@ -1,15 +1,14 @@
 import { createHash, randomBytes } from "node:crypto";
 import { BridgeError } from "../errors.js";
 import { KeyedMutex } from "../mutex.js";
-import { certifiedCompatibilityVersions, compatibilityCoversWrites, compatibilitySurfaceDefinitions, evaluateCompatibilityAttestation, isCompatibilityAttestation, } from "./compatibility.js";
-import { createGatewayConversationId, isGatewaySnapshot, startGatewayControlServer, } from "./control.js";
+import { createGatewayConversationId, isGatewaySnapshot, startGatewayControlServer, pairParamAliases, pairParamThreadAttestation, } from "./control.js";
 import { publishGatewayDashboard } from "./dashboard.js";
 import { createDeliveryMachine, isTerminalDeliveryMachine, projectDelivery, projectDeliveryWakeups, transitionDelivery, } from "./delivery-machine.js";
 import { createCodexRegistrationSuccession, transitionCodexRegistrationSuccession, } from "./codex-registration-succession.js";
 import { createCodexRegistrationGeneration, isCodexRegistrationGeneration, } from "./codex-registration-generation.js";
 import { PROGRESS_WATCH_DEFAULT_IDLE_MS } from "./progress-watch-machine.js";
 import { GatewayStore, } from "./store.js";
-import { GATEWAY_PUBLIC_SNAPSHOT_BYTE_BUDGET, gatewayPublicSnapshotLimits, arePublicAvailablePeerSnapshots, projectPublicCompatibilityCheck, projectGatewayPublicSnapshot, } from "./types.js";
+import { GATEWAY_PUBLIC_SNAPSHOT_BYTE_BUDGET, gatewayPublicSnapshotLimits, gatewayRegistrationIngressPrefixes, arePublicAvailablePeerSnapshots, directionId, parseDirection, projectGatewayPublicSnapshot, CONNECTOR_OBSERVATION_STALE_AFTER_MS, } from "./types.js";
 const PUBLIC_ALIAS = /^[a-z][a-z0-9_-]{0,31}@[a-z0-9](?:[a-z0-9.-]{0,61}[a-z0-9])?$/;
 const CLAUDE_SESSION_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 const SAFE_CODE = /^[A-Z][A-Z0-9_]{0,63}$/;
@@ -22,6 +21,8 @@ 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_DISCOVERY_REFRESH_MS = 30_000;
+const CODEX_DOCTOR_REFRESH_MS = 30_000;
 const BOOT_REACTIVATION_TRUST_FAILURE_CODES = new Set([
     "HOME_INVALID",
     "MANAGED_CODEX_INVALID",
@@ -77,39 +78,13 @@ function bindingKey(binding) {
     ].join("\0");
 }
 function endpointRefreshCallbackKey(event) {
-    const attestation = {
-        schemaVersion: event.attestation.schemaVersion,
-        surface: event.attestation.surface,
-        version: event.attestation.version,
-        tier: event.attestation.tier,
-        checkedAt: event.attestation.checkedAt,
-        probes: event.attestation.probes.map((probe) => ({
-            name: probe.name,
-            outcome: probe.outcome,
-            ...(probe.safeErrorCode === undefined
-                ? {}
-                : { safeErrorCode: probe.safeErrorCode }),
-        })),
-        ...(event.attestation.safeErrorCode === undefined
-            ? {}
-            : { safeErrorCode: event.attestation.safeErrorCode }),
-    };
-    return event.outcome === "compatible"
-        ? JSON.stringify({
-            outcome: event.outcome,
-            previous: event.previous,
-            current: event.current,
-            attestation,
-            routes: [...event.routes]
-                .map((route) => ({ ...route }))
-                .sort((left, right) => left.routeHandle.localeCompare(right.routeHandle)),
-        })
-        : JSON.stringify({
-            outcome: event.outcome,
-            previous: event.previous,
-            candidate: event.candidate,
-            attestation,
-        });
+    return JSON.stringify({
+        previous: event.previous,
+        current: event.current,
+        routes: [...event.routes]
+            .map((route) => ({ ...route }))
+            .sort((left, right) => left.routeHandle.localeCompare(right.routeHandle)),
+    });
 }
 function stableLease(provider, value) {
     return `lease_${createHash("sha256").update(provider).update("\0").update(value).digest("base64url")}`;
@@ -149,13 +124,12 @@ export class GatewayService {
     config;
     store;
     adapters;
-    compatibilityObservers;
-    compatibilitySurfaceDefinitions;
     publishDashboard;
     now;
     timers;
     nativePeerCwd;
     successionGeneration;
+    codexDoctor;
     mutex = new KeyedMutex();
     routeBindings = new Map();
     routeStates = new Map();
@@ -176,9 +150,6 @@ export class GatewayService {
     deliveryTokens = new Map();
     runtimeAlerts = [];
     activityEvents = [];
-    /** Startup probe failures that must preflight cross-provider mutations. */
-    incompatibleProviderSurfaces = new Map();
-    activeCodexIncompatibility;
     activitySequence = 0;
     detachedReceiptWrites = new Set();
     nativeIngressByConversation = new Map();
@@ -202,8 +173,6 @@ export class GatewayService {
     durablyAppliedEndpointRefreshes = new Map();
     /** Selector transitions staged until their exact registration owns a helper. */
     pendingSelectorEndpointActivations = new Map();
-    /** Last incompatible transition already projected per allowed Codex host. */
-    handledIncompatibleEndpointRefreshes = new Map();
     /** Process-local dedupe for automatic public activity rows across retries. */
     endpointRefreshActivityKeys = new Set();
     callbackWorker;
@@ -211,8 +180,17 @@ export class GatewayService {
     callbackCapacity;
     deliveryCallbackReserve;
     deliveryTokenCapacity;
+    providerDispatchInFlightMessageIds = new Set();
+    connectorFreshnessDeadlineAt = new Map();
     lifecycleTimer;
+    lifecyclePublishPending = false;
     nextDashboardRefreshAt;
+    nextClaudeDiscoveryAt;
+    claudeDiscoveryScheduled = false;
+    claudeDiscoveryInFlight;
+    codexDoctorTimer;
+    codexDoctorInFlight;
+    codexDoctorResult;
     nextProgressWatchAt;
     control;
     /** Coarse controller mutation revision exposed by `health`. */
@@ -247,9 +225,6 @@ export class GatewayService {
     constructor(options) {
         this.config = options.config;
         this.adapters = [...(options.adapters ?? [])];
-        this.compatibilityObservers = [...(options.compatibilityObservers ?? [])];
-        this.compatibilitySurfaceDefinitions =
-            options.compatibilitySurfaceDefinitions ?? compatibilitySurfaceDefinitions;
         this.publishDashboard = options.publishDashboard ?? publishGatewayDashboard;
         this.now = options.now ?? (() => new Date());
         this.store =
@@ -262,6 +237,7 @@ export class GatewayService {
         this.successionGeneration =
             options.successionGeneration ??
                 createCodexRegistrationGeneration;
+        this.codexDoctor = options.codexDoctor;
         this.callbackCapacity = Math.max(64, options.config.limits.maxRoutes +
             options.config.limits.maxInFlightMessages * 8);
         // A callback flood must never crowd out write evidence. One selected route
@@ -297,28 +273,50 @@ export class GatewayService {
                 }
                 seen.add(key);
             }
-            if (this.adapters.length > 0) {
-                await this.runAutomaticCompatibilityProbesLocked();
-                assertStartActive();
-            }
             for (const adapter of this.adapters) {
                 const observation = await adapter.initialize(this.callbacksFor(adapter));
                 assertStartActive();
+                this.captureRegistryObservation(adapter, adapter.latestRegistryObservation?.());
                 await this.store.observeConnector({
                     identity: adapter.identity,
                     health: observation.health,
-                    compatibility: observation.compatibility,
                     protocol: adapter.protocol,
                     protocolVersion: adapter.protocolVersion,
                     ...(observation.safeErrorCode === undefined
                         ? {}
                         : { safeErrorCode: safeCode(observation.safeErrorCode, "ADAPTER_DEGRADED") }),
                 });
+                this.recordConnectorFreshness(adapter.identity, observation.health);
+                if (observation.ownedRoute !== undefined) {
+                    const route = observation.ownedRoute;
+                    const prefix = gatewayRegistrationIngressPrefixes[adapter.identity.provider];
+                    if (prefix === undefined || !route.alias.startsWith(prefix) ||
+                        !route.alias.endsWith(`@${adapter.identity.hostId}`) ||
+                        !PUBLIC_ALIAS.test(route.alias) || !PRIVATE_HANDLE.test(route.routeHandle) ||
+                        route.state !== "idle") {
+                        throw new BridgeError("GATEWAY_OWNED_ROUTE_INVALID", "A config-declared provider route has invalid identity evidence.");
+                    }
+                    const binding = {
+                        ...adapter.identity,
+                        routeHandle: route.routeHandle,
+                        ownerLease: stableLease(adapter.identity.provider, `${adapter.identity.hostId}\0${route.alias}`),
+                    };
+                    await this.registerOrRebind(route.alias, binding, "endpoint_reobserved", route.state, binding.ownerLease, "explicit_opt_in");
+                    this.rememberBinding(route.alias, binding, route.state);
+                    bootReactivatedIdleAliases.push(route.alias);
+                }
                 assertStartActive();
             }
+            await this.refreshClaudeDiscovery({ incrementRevision: false }).catch(() => false);
+            await this.refreshCodexDoctor();
+            for (const [alias, binding] of this.routeBindings) {
+                if (binding.provider === "claude" &&
+                    this.routeStates.get(alias) === "idle") {
+                    bootReactivatedIdleAliases.push(alias);
+                }
+            }
             await this.recoverCodexSuccessionAfterRestartLocked();
-            bootReactivatedIdleAliases =
-                await this.reactivateRetainedCodexRoutesAfterRestartLocked();
+            bootReactivatedIdleAliases.push(...(await this.reactivateRetainedCodexRoutesAfterRestartLocked()));
             assertStartActive();
             const control = await startGatewayControlServer({
                 stateDir: this.store.rootDir,
@@ -337,8 +335,11 @@ export class GatewayService {
             this.control = control;
             this.running = true;
             this.nextDashboardRefreshAt = undefined;
+            this.nextClaudeDiscoveryAt =
+                this.now().getTime() + CLAUDE_DISCOVERY_REFRESH_MS;
             await this.refreshNextProgressWatchWakeLocked();
             this.scheduleLifecycleWakeLocked();
+            this.scheduleCodexDoctor();
             for (const alias of bootReactivatedIdleAliases) {
                 this.scheduleDispatch(alias);
             }
@@ -367,6 +368,12 @@ export class GatewayService {
         const control = this.control;
         this.control = undefined;
         let closeFailed = false;
+        if (this.codexDoctorTimer !== undefined) {
+            this.timers.clearTimeout(this.codexDoctorTimer);
+            this.codexDoctorTimer = undefined;
+        }
+        await this.codexDoctorInFlight?.catch(() => undefined);
+        await this.claudeDiscoveryInFlight?.catch(() => undefined);
         if (control !== undefined) {
             try {
                 await control.close();
@@ -383,6 +390,9 @@ export class GatewayService {
                     this.timers.clearTimeout(this.lifecycleTimer);
                     this.lifecycleTimer = undefined;
                 }
+                this.nextClaudeDiscoveryAt = undefined;
+                this.lifecyclePublishPending = false;
+                this.connectorFreshnessDeadlineAt.clear();
                 const quiesceResults = await Promise.allSettled(this.adapters.map(async (adapter) => await adapter.quiesceNativeInbound?.()));
                 if (quiesceResults.some((result) => result.status === "rejected")) {
                     closeFailed = true;
@@ -395,6 +405,13 @@ export class GatewayService {
                 for (const messageId of [...this.messageContexts.keys()]) {
                     if (retainedQueuedMessageIds.has(messageId))
                         continue;
+                    if (this.providerDispatchInFlightMessageIds.has(messageId)) {
+                        await this.advanceDeliveryLocked(messageId, {
+                            type: "dispatch_ambiguous",
+                            at: this.now().getTime(),
+                            safeErrorCode: "DISPATCH_OUTCOME_AMBIGUOUS",
+                        });
+                    }
                     const queued = await this.store.settleQueuedMessage({
                         messageId,
                         state: "cancelled",
@@ -452,6 +469,7 @@ export class GatewayService {
                 this.activeDispatchByTarget.clear();
                 this.scheduledDispatchTargets.clear();
                 this.dispatchRunnerTargets.clear();
+                this.providerDispatchInFlightMessageIds.clear();
                 for (const timer of this.heldRedispatchTimers.values()) {
                     this.timers.clearTimeout(timer);
                 }
@@ -460,7 +478,6 @@ export class GatewayService {
                 this.deliveryTrackers.clear();
                 this.deliveryTokens.clear();
                 this.runtimeAlerts.length = 0;
-                this.incompatibleProviderSurfaces.clear();
                 this.registryEvidenceByConnector.clear();
                 this.registryAdaptersWithParseableRecords.clear();
                 this.detachedReceiptWrites.clear();
@@ -476,7 +493,6 @@ export class GatewayService {
                 this.activatedEndpointRefreshes.clear();
                 this.durablyAppliedEndpointRefreshes.clear();
                 this.pendingSelectorEndpointActivations.clear();
-                this.handledIncompatibleEndpointRefreshes.clear();
                 this.endpointRefreshActivityKeys.clear();
                 this.codexOrphanCleanupPending.clear();
                 this.candidates.clear();
@@ -536,12 +552,12 @@ export class GatewayService {
             pair: async (params) => await this.exclusiveDecision(async () => this.pairRoutes(params), {
                 kind: "pairing",
                 action: "routes_paired",
-                aliases: [params.claudeAlias, params.codexAlias],
+                aliases: [...pairParamAliases(params)],
             }),
             unpair: async (params) => await this.exclusiveDecision(async () => this.unpairRoutes(params), {
                 kind: "pairing",
                 action: "routes_unpaired",
-                aliases: [params.claudeAlias, params.codexAlias],
+                aliases: [...pairParamAliases(params)],
             }),
             listSnapshot: async () => (await this.observeSnapshot()).snapshot,
             observeSnapshot: async () => await this.observeSnapshot(),
@@ -572,91 +588,6 @@ export class GatewayService {
     async snapshot() {
         return (await this.observeSnapshot()).snapshot;
     }
-    async runAutomaticCompatibilityProbesLocked() {
-        const entries = [
-            ...this.adapters.map((adapter) => {
-                if (adapter.compatibilitySurface === undefined ||
-                    adapter.runCompatibilityProbes === undefined) {
-                    throw new BridgeError("COMPAT_PROVIDER_UNAVAILABLE", "Every local provider must expose the bounded compatibility probe contract.");
-                }
-                return {
-                    observer: adapter,
-                    adapter,
-                };
-            }),
-            ...this.compatibilityObservers.map((observer) => ({ observer })),
-        ];
-        const observedEntries = entries.map((entry) => ({
-            ...entry,
-            observation: entry.observer.compatibilitySurface(),
-        }));
-        const bySurface = new Map(observedEntries.map((entry) => [entry.observation.surface, entry]));
-        if (bySurface.size !== entries.length) {
-            throw new BridgeError("COMPAT_PROVIDER_UNAVAILABLE", "Each compatibility observer must expose one distinct surface.");
-        }
-        const declared = new Set(this.compatibilitySurfaceDefinitions.map(({ surface }) => surface));
-        if ([...bySurface.keys()].some((surface) => !declared.has(surface))) {
-            throw new BridgeError("COMPAT_SURFACE_UNDECLARED", "Every compatibility observer must use a declared surface.");
-        }
-        const forbiddenCodexThreadIds = (await this.store.inspectPrivateCodexRoutes()).map((route) => route.binding.routeHandle);
-        const probeContext = {
-            stateRoot: this.store.rootDir,
-            forbiddenCodexThreadIds,
-        };
-        const attestations = [];
-        for (const definition of this.compatibilitySurfaceDefinitions) {
-            const { surface } = definition;
-            const entry = bySurface.get(surface);
-            if (entry === undefined) {
-                if (!definition.required)
-                    continue;
-                throw new BridgeError("COMPAT_PROVIDER_UNAVAILABLE", "A required compatibility surface is unavailable.");
-            }
-            const probes = entry.adapter === undefined
-                ? await entry.observer.runCompatibilityProbes()
-                : await entry.adapter.runCompatibilityProbes(probeContext);
-            let writeProbePassed = false;
-            if (entry.adapter !== undefined) {
-                const writeProbe = entry.adapter.latestWriteCompatibilityProbeObservation?.(entry.adapter.identity.endpointGeneration);
-                writeProbePassed = writeProbe?.outcome === "pass";
-                if (writeProbe?.outcome === "fail") {
-                    this.addRuntimeAlert(writeProbe.safeErrorCode, writeProbe.safeErrorCode === "CODEX_WRITE_PROBE_TOOL_ACTIVITY_OBSERVED" ||
-                        writeProbe.safeErrorCode === "CODEX_WRITE_PROBE_CLEANUP_UNCONFIRMED"
-                        ? "error"
-                        : "warning", { provider: "codex", host: entry.adapter.identity.hostId });
-                }
-                this.captureRegistryObservation(entry.adapter, entry.adapter.latestRegistryObservation?.());
-            }
-            const attestation = evaluateCompatibilityAttestation({
-                surface,
-                version: entry.observation.version,
-                checkedAt: this.now().toISOString(),
-                certifiedVersions: certifiedCompatibilityVersions[surface],
-                probes,
-            });
-            await this.store.recordCompatibilityAttestation(attestation);
-            entry.observer.acceptCompatibilityAttestation?.(attestation);
-            if (attestation.tier === "incompatible" && entry.adapter !== undefined) {
-                const code = attestation.safeErrorCode ?? "COMPATIBILITY_CHECK_FAILED";
-                this.incompatibleProviderSurfaces.set(this.providerSurfaceKey(entry.adapter.identity.provider, entry.adapter.identity.hostId), code);
-                if (surface === "codex") {
-                    this.activeCodexIncompatibility = structuredClone(attestation);
-                }
-            }
-            else if (surface === "codex" &&
-                attestation.tier === "schema_attested" &&
-                !(compatibilityCoversWrites(attestation) && writeProbePassed) &&
-                entry.adapter !== undefined) {
-                // A live but untested App Server schema is useful for observation only.
-                // Fence retained boot reactivation before it can trigger endpoint
-                // refresh churn; an explicit registration may still re-probe a later,
-                // certified generation through the provider's bounded refresh path.
-                this.incompatibleProviderSurfaces.set(this.providerSurfaceKey("codex", entry.adapter.identity.hostId), "CODEX_MONITOR_ONLY");
-            }
-            attestations.push(attestation);
-        }
-        return attestations;
-    }
     captureRegistryObservation(adapter, observation) {
         if (adapter.identity.provider !== "claude" ||
             observation === undefined ||
@@ -703,6 +634,14 @@ export class GatewayService {
             const registry = this.registryEvidenceByConnector.get(`${connector.provider}\0${connector.host}`);
             return {
                 ...connector,
+                ...(connector.provider === "codex" &&
+                    this.codexDoctorResult !== undefined
+                    ? {
+                        codexDoctor: {
+                            conditions: this.codexDoctorConditions(connector),
+                        },
+                    }
+                    : {}),
                 ...(connector.provider !== "claude" || registry === undefined
                     ? {}
                     : {
@@ -714,6 +653,70 @@ export class GatewayService {
             };
         });
     }
+    recordConnectorFreshness(identity, health) {
+        const key = `${identity.provider}\0${identity.hostId}`;
+        if (health === "healthy") {
+            this.connectorFreshnessDeadlineAt.set(key, this.now().getTime() + CONNECTOR_OBSERVATION_STALE_AFTER_MS + 1);
+        }
+        else {
+            this.connectorFreshnessDeadlineAt.delete(key);
+        }
+    }
+    codexDoctorConditions(connector) {
+        const attachment = this.codexDoctorResult?.conditions[0] ?? "unknown";
+        const stale = connector.observationAgeMs === undefined ||
+            connector.observationAgeMs > CONNECTOR_OBSERVATION_STALE_AFTER_MS;
+        if (attachment === "split_brain" || attachment === "orphaned") {
+            return stale ? [attachment, "observation_stale"] : [attachment];
+        }
+        if (stale)
+            return ["observation_stale", attachment];
+        return [attachment];
+    }
+    async refreshCodexDoctor() {
+        if (this.codexDoctor === undefined)
+            return false;
+        const next = await this.codexDoctor().catch(() => ({ conditions: ["unknown"] }));
+        const changed = JSON.stringify(next.conditions) !==
+            JSON.stringify(this.codexDoctorResult?.conditions);
+        this.codexDoctorResult = next;
+        return changed;
+    }
+    scheduleCodexDoctor() {
+        if (!this.running ||
+            this.closing ||
+            this.codexDoctor === undefined ||
+            this.codexDoctorTimer !== undefined ||
+            this.codexDoctorInFlight !== undefined) {
+            return;
+        }
+        const timer = this.timers.setTimeout(() => {
+            if (this.codexDoctorTimer !== timer)
+                return;
+            this.codexDoctorTimer = undefined;
+            const operation = this.refreshCodexDoctor()
+                .then(async (changed) => {
+                if (!changed || this.closing)
+                    return;
+                await this.mutex.run("service", async () => {
+                    this.revision += 1;
+                    await this.publish();
+                });
+            })
+                .catch(() => {
+                this.dashboardHealthy = false;
+            });
+            this.codexDoctorInFlight = operation;
+            void operation.finally(() => {
+                if (this.codexDoctorInFlight === operation) {
+                    this.codexDoctorInFlight = undefined;
+                }
+                this.scheduleCodexDoctor();
+            });
+        }, CODEX_DOCTOR_REFRESH_MS);
+        this.codexDoctorTimer = timer;
+        timer.unref?.();
+    }
     async observeSnapshot() {
         return await this.mutex.run("service", async () => {
             const changed = await this.processLifecycleLocked();
@@ -746,7 +749,11 @@ export class GatewayService {
     fingerprintSnapshot(snapshot) {
         // Closed snapshot validation bounds every array and field before this
         // serialization. Omitting generatedAt is the sole semantic exception.
-        const { generatedAt: _generatedAt, ...semanticSnapshot } = snapshot;
+        const { generatedAt: _generatedAt, connectors, ...snapshotWithoutGeneratedAt } = snapshot;
+        const semanticSnapshot = {
+            ...snapshotWithoutGeneratedAt,
+            connectors: connectors.map(({ observationAgeMs: _observationAgeMs, ...connector }) => connector),
+        };
         const encoded = JSON.stringify(semanticSnapshot);
         if (Buffer.byteLength(encoded, "utf8") >
             GATEWAY_PUBLIC_SNAPSHOT_BYTE_BUDGET) {
@@ -884,50 +891,30 @@ export class GatewayService {
                 });
             },
             onEndpointRefresh: (event) => {
+                if (!Array.isArray(event.routes))
+                    return;
+                const routeHandles = event.routes.map((route) => route.routeHandle);
                 if (!this.running ||
                     adapter.identity.provider !== "codex" ||
                     event.previous.provider !== "codex" ||
                     event.previous.hostId !== adapter.identity.hostId ||
-                    !isCompatibilityAttestation(event.attestation) ||
-                    event.attestation.surface !== "codex") {
-                    return;
-                }
-                if (event.outcome === "compatible") {
-                    const routeHandles = event.routes.map((route) => route.routeHandle);
-                    if (event.current.provider !== "codex" ||
-                        event.current.hostId !== event.previous.hostId ||
-                        event.current.endpointGeneration !==
-                            adapter.identity.endpointGeneration ||
-                        event.attestation.version !== adapter.protocolVersion ||
-                        event.attestation.tier === "incompatible" ||
-                        routeHandles.length > this.config.limits.maxRoutes ||
-                        new Set(routeHandles).size !== routeHandles.length ||
-                        routeHandles.some((routeHandle) => !PRIVATE_HANDLE.test(routeHandle))) {
-                        return;
-                    }
-                }
-                else if (event.candidate.provider !== "codex" ||
-                    event.candidate.hostId !== event.previous.hostId ||
-                    event.previous.endpointGeneration !==
+                    event.current.provider !== "codex" ||
+                    event.current.hostId !== event.previous.hostId ||
+                    event.current.endpointGeneration !==
                         adapter.identity.endpointGeneration ||
-                    event.attestation.tier !== "incompatible") {
+                    routeHandles.length > this.config.limits.maxRoutes ||
+                    new Set(routeHandles).size !== routeHandles.length ||
+                    routeHandles.some((routeHandle) => !PRIVATE_HANDLE.test(routeHandle))) {
                     return;
                 }
                 this.enqueueCallback({
                     type: "endpoint_refresh",
                     adapter,
-                    value: event.outcome === "compatible"
-                        ? {
-                            ...event,
-                            previous: { ...event.previous },
-                            current: { ...event.current },
-                            routes: event.routes.map((route) => ({ ...route })),
-                        }
-                        : {
-                            ...event,
-                            previous: { ...event.previous },
-                            candidate: { ...event.candidate },
-                        },
+                    value: {
+                        previous: { ...event.previous },
+                        current: { ...event.current },
+                        routes: event.routes.map((route) => ({ ...route })),
+                    },
                 });
             },
         };
@@ -1032,10 +1019,10 @@ export class GatewayService {
             this.endpointRefreshConflictPending);
     }
     enqueueCallbackWorkerOnly() {
-        if (this.callbackScheduled)
+        if (this.callbackScheduled || this.callbackWorker !== undefined)
             return;
         this.callbackScheduled = true;
-        setImmediate(() => {
+        queueMicrotask(() => {
             this.callbackScheduled = false;
             const worker = this.mutex.run("service", async () => {
                 await this.drainCallbackQueueLocked();
@@ -1074,7 +1061,7 @@ export class GatewayService {
                         await this.onDelivery(event.source, event.value, event.receivedAt);
                     }
                     else if (event.type === "route") {
-                        if (pendingRefresh?.outcome === "compatible" &&
+                        if (pendingRefresh !== undefined &&
                             event.source.provider === "codex" &&
                             event.source.hostId === pendingRefresh.current.hostId &&
                             event.source.endpointGeneration ===
@@ -1204,12 +1191,7 @@ export class GatewayService {
         await this.drainDetachedReceiptWritesLocked();
     }
     async failClosedEndpointRefreshConflict(boundary) {
-        const identities = [
-            boundary.value.previous,
-            ...(boundary.value.outcome === "compatible"
-                ? [boundary.value.current]
-                : []),
-        ];
+        const identities = [boundary.value.previous, boundary.value.current];
         for (const identity of identities) {
             const routes = (await this.store.inspectPrivateCodexRoutes()).filter((route) => route.binding.hostId === identity.hostId &&
                 route.binding.endpointGeneration === identity.endpointGeneration);
@@ -1311,23 +1293,6 @@ export class GatewayService {
             throw new BridgeError("PROVIDER_UNAVAILABLE", "The selected provider is unavailable.", true);
         return adapter;
     }
-    providerSurfaceKey(provider, host) {
-        return `${provider}@${host}`;
-    }
-    incompatibleProviderCode(provider, host) {
-        return this.incompatibleProviderSurfaces.get(this.providerSurfaceKey(provider, host));
-    }
-    /** Reject before either half of a cross-provider mutation can acquire state. */
-    assertCrossProviderMutationCompatible(host, options = { allowCodexRefresh: false }) {
-        const claudeCode = this.incompatibleProviderCode("claude", host);
-        if (claudeCode !== undefined) {
-            throw new BridgeError(claudeCode, "The Claude provider is observation-only until Embassy restarts with a compatible runtime.");
-        }
-        const codexCode = this.incompatibleProviderCode("codex", host);
-        if (codexCode !== undefined && !options.allowCodexRefresh) {
-            throw new BridgeError(codexCode, "The Codex provider is observation-only until a compatible endpoint is re-observed.");
-        }
-    }
     async assertClaudeWorkspaceDisjoint(adapter, routeHandle) {
         if (adapter.identity.provider !== "claude") {
             throw new BridgeError("CLAUDE_PROVIDER_MISMATCH", "The selected workspace guard does not belong to Claude.");
@@ -1385,7 +1350,6 @@ export class GatewayService {
         for (const route of retained) {
             if (!route.enabled ||
                 route.state !== "stale" ||
-                route.compatibility !== "expired" ||
                 this.pendingCodexSuccessionRecovery?.journal.new.alias === route.alias ||
                 this.codexSuccessionPoisoned.has(route.alias)) {
                 continue;
@@ -1398,13 +1362,6 @@ export class GatewayService {
                 this.addRuntimeAlert("CODEX_BOOT_REACTIVATION_SKIPPED", "warning", { provider: "codex", host: route.binding.hostId, alias: route.alias });
                 continue;
             }
-            if (this.incompatibleProviderCode("codex", route.binding.hostId) !==
-                undefined ||
-                this.incompatibleProviderCode("claude", route.binding.hostId) !==
-                    undefined) {
-                this.addRuntimeAlert("CODEX_BOOT_REACTIVATION_SKIPPED", "warning", { provider: "codex", host: route.binding.hostId, alias: route.alias });
-                continue;
-            }
             let routeSelected = false;
             let advertiseAttempted = false;
             let storeReactivated = false;
@@ -1442,19 +1399,20 @@ export class GatewayService {
                     storeReactivated =
                         afterStaging !== undefined &&
                             afterStaging.enabled &&
-                            afterStaging.compatibility === "compatible" &&
+                            afterStaging.state !== "stale" &&
                             bindingKey(afterStaging.binding) === bindingKey(binding);
                 }
                 advertiseAttempted = true;
-                const advertise = claudeAdapter.advertiseNativeCodexPeer;
+                const advertise = claudeAdapter.advertiseNativeSourcePeer;
                 if (advertise === undefined) {
                     throw new BridgeError("CODEX_BOOT_REACTIVATION_UNAVAILABLE", "The retained Codex task cannot rebuild its native advertisement.");
                 }
                 await advertise.call(claudeAdapter, {
                     alias: route.alias,
+                    sourceProvider: "codex",
                     cwd: this.nativePeerCwd,
                 });
-                await claudeAdapter.updateNativeCodexPeerStatus?.(route.alias, selected.state === "idle"
+                await claudeAdapter.updateNativeSourcePeerStatus?.(route.alias, selected.state === "idle"
                     ? "idle"
                     : selected.state === "awaiting_approval"
                         ? "waiting"
@@ -1498,7 +1456,7 @@ export class GatewayService {
                 let cleanupFailed = false;
                 if (advertiseAttempted) {
                     await claudeAdapter
-                        .unadvertiseNativeCodexPeer?.(route.alias)
+                        .unadvertiseNativeSourcePeer?.(route.alias)
                         .catch(() => {
                         cleanupFailed = true;
                     });
@@ -1630,7 +1588,7 @@ export class GatewayService {
             oldInspection.binding.ownerLease !==
                 stableLease("codex", `${lock.hostId}\0${lock.threadId}`) ||
             !oldInspection.enabled ||
-            oldInspection.compatibility !== "compatible") {
+            oldInspection.state === "stale") {
             throw new BridgeError("CODEX_SUCCESSION_OWNER_MISMATCH", "The active Codex registration is no longer exact and compatible.");
         }
         const claudeAdapter = this.adapter("claude", params.hostId);
@@ -1939,7 +1897,7 @@ export class GatewayService {
                 this.rememberBinding(effect.registration.alias, execution.newBinding, state);
                 this.codexRegistrationLocks.delete(this.successionOldRegistration(execution).alias);
                 this.codexRegistrationLocks.set(effect.registration.alias, Object.freeze({ ...effect.registration }));
-                await claudeAdapter.updateNativeCodexPeerStatus?.(effect.registration.alias, state === "idle"
+                await claudeAdapter.updateNativeSourcePeerStatus?.(effect.registration.alias, state === "idle"
                     ? "idle"
                     : state === "awaiting_approval"
                         ? "waiting"
@@ -2084,8 +2042,8 @@ export class GatewayService {
                     throw new BridgeError("CODEX_SUCCESSION_DRAIN_INCOMPLETE", "Interrupted generations cannot close before pending work and receipts are drained. Restart the gateway with embassy serve.");
                 }
                 const results = await Promise.allSettled([
-                    claudeAdapter.unadvertiseNativeCodexPeer?.(execution.oldRegistration.alias),
-                    claudeAdapter.unadvertiseNativeCodexPeer?.(execution.newRegistration.alias),
+                    claudeAdapter.unadvertiseNativeSourcePeer?.(execution.oldRegistration.alias),
+                    claudeAdapter.unadvertiseNativeSourcePeer?.(execution.newRegistration.alias),
                     codexAdapter.releaseRoute?.(execution.oldRegistration.threadId),
                     codexAdapter.releaseRoute?.(execution.newRegistration.threadId),
                 ]);
@@ -2310,9 +2268,6 @@ export class GatewayService {
         if (!params.alias.startsWith("codex-")) {
             throw new BridgeError("INVALID_CODEX_PEER_ALIAS", "A registered Codex alias must start with codex-.");
         }
-        this.assertCrossProviderMutationCompatible(params.hostId, {
-            allowCodexRefresh: params.succeedsAlias === undefined,
-        });
         if (this.codexSuccessionPoisoned.has(params.alias) ||
             this.codexOrphanCleanupPending.has(params.alias) ||
             (params.succeedsAlias !== undefined &&
@@ -2383,7 +2338,7 @@ export class GatewayService {
             const afterRefresh = await this.store.inspectPrivateRoute(params.alias);
             const alreadyInstalledExactly = afterRefresh !== undefined &&
                 afterRefresh.enabled &&
-                afterRefresh.compatibility === "compatible" &&
+                afterRefresh.state !== "stale" &&
                 bindingKey(afterRefresh.binding) === bindingKey(binding);
             if (!alreadyInstalledExactly || !deferredEndpointRefresh) {
                 await this.registerOrRebind(params.alias, binding, "endpoint_reobserved", registered.state);
@@ -2398,15 +2353,16 @@ export class GatewayService {
         try {
             this.rememberBinding(params.alias, binding, registered.state);
             const claudeAdapter = this.adapter("claude", params.hostId);
-            const advertise = claudeAdapter.advertiseNativeCodexPeer;
+            const advertise = claudeAdapter.advertiseNativeSourcePeer;
             if (advertise !== undefined) {
                 advertiseAttempted = true;
                 await advertise.call(claudeAdapter, {
                     alias: params.alias,
+                    sourceProvider: "codex",
                     cwd: this.nativePeerCwd,
                 });
             }
-            await claudeAdapter.updateNativeCodexPeerStatus?.(params.alias, registered.state === "idle"
+            await claudeAdapter.updateNativeSourcePeerStatus?.(params.alias, registered.state === "idle"
                 ? "idle"
                 : registered.state === "awaiting_approval"
                     ? "waiting"
@@ -2428,8 +2384,7 @@ export class GatewayService {
         }
         catch (error) {
             if (routeBeforeRegistration !== undefined) {
-                if (deferredEndpointRefresh &&
-                    registered.endpointRefresh?.outcome === "compatible") {
+                if (deferredEndpointRefresh && registered.endpointRefresh !== undefined) {
                     try {
                         await this.store.markConnectorOffline(registered.endpointRefresh.current, "CODEX_ENDPOINT_ACTIVATION_FAILED", [], { preserveQueued: true });
                         this.routeStates.set(params.alias, "stale");
@@ -2511,7 +2466,7 @@ export class GatewayService {
         });
         if (advertiseAttempted) {
             await this.adapter("claude", params.hostId)
-                .unadvertiseNativeCodexPeer?.(params.alias)
+                .unadvertiseNativeSourcePeer?.(params.alias)
                 .catch(() => {
                 cleanupFailed = true;
             });
@@ -2538,7 +2493,7 @@ export class GatewayService {
         }
         this.forgetBinding(params.alias);
         await this.adapter("claude", host)
-            .unadvertiseNativeCodexPeer?.(params.alias)
+            .unadvertiseNativeSourcePeer?.(params.alias)
             .catch(() => {
             this.dashboardHealthy = false;
         });
@@ -2709,7 +2664,7 @@ export class GatewayService {
             }
             await this.requireUnchangedStaleCodexOrphan(alias, binding);
             if (nativeGeneration !== undefined) {
-                const unadvertise = claudeAdapter.unadvertiseNativeCodexPeer;
+                const unadvertise = claudeAdapter.unadvertiseNativeSourcePeer;
                 if (unadvertise === undefined) {
                     throw new BridgeError("CODEX_ORPHAN_NATIVE_IDENTITY_UNPROVEN", "The native Codex listener cannot be removed exactly.");
                 }
@@ -2773,7 +2728,7 @@ export class GatewayService {
         return JSON.stringify({
             inboundMode: snapshot.inboundMode,
             health: snapshot.health,
-            connectors: snapshot.connectors.map(({ lastSeenAt: _lastSeenAt, ...connector }) => connector),
+            connectors: snapshot.connectors.map(({ lastSeenAt: _lastSeenAt, observationAgeMs: _observationAgeMs, ...connector }) => connector),
             availablePeers: snapshot.availablePeers.map(({ lastSeenAt: _lastSeenAt, ...peer }) => peer),
             routes: snapshot.routes.map(({ lastSeenAt: _lastSeenAt, ...route }) => route),
             messages: snapshot.messages,
@@ -2782,7 +2737,116 @@ export class GatewayService {
             truncation: snapshot.truncation,
         });
     }
-    async refreshClaudeDiscovery() {
+    schedulePeriodicClaudeDiscovery() {
+        if (this.closing ||
+            this.claudeDiscoveryScheduled ||
+            this.claudeDiscoveryInFlight !== undefined) {
+            return;
+        }
+        this.claudeDiscoveryScheduled = true;
+        queueMicrotask(() => {
+            this.claudeDiscoveryScheduled = false;
+            if (this.closing || !this.running)
+                return;
+            const operation = this.refreshClaudeDiscoveryPeriodically().catch(() => {
+                this.dashboardHealthy = false;
+            });
+            this.claudeDiscoveryInFlight = operation;
+            void operation.finally(() => {
+                if (this.claudeDiscoveryInFlight === operation) {
+                    this.claudeDiscoveryInFlight = undefined;
+                }
+            });
+        });
+    }
+    async refreshClaudeDiscoveryPeriodically() {
+        const observations = (await Promise.all(this.adapters
+            .filter((adapter) => adapter.identity.provider === "claude")
+            .map(async (adapter) => {
+            try {
+                const snapshot = await adapter.discoverClaudePeers?.();
+                return snapshot === undefined ? undefined : { adapter, snapshot };
+            }
+            catch {
+                return undefined;
+            }
+        }))).filter((item) => item !== undefined);
+        if (this.closing)
+            return;
+        const preparedRebinds = [];
+        const persisted = await this.store.inspectPrivateClaudeRoutes();
+        for (const route of persisted) {
+            if (!route.enabled || route.state !== "stale")
+                continue;
+            const observation = observations.find(({ adapter, snapshot }) => snapshot.complete &&
+                adapter.identity.hostId === route.binding.hostId);
+            if (observation === undefined)
+                continue;
+            const peers = observation.snapshot.peers.filter((peer) => peer.kind === "interactive" &&
+                PUBLIC_ALIAS.test(peer.alias) &&
+                peer.alias.endsWith(`@${observation.adapter.identity.hostId}`));
+            const candidates = peers.filter((peer) => peer.routeHandle === route.binding.routeHandle);
+            const peer = candidates[0];
+            if (candidates.length !== 1 ||
+                peer === undefined ||
+                peers.filter((item) => item.alias === peer.alias).length !== 1) {
+                continue;
+            }
+            const candidate = { ...peer, adapter: observation.adapter };
+            try {
+                this.validatePersistedClaudeCandidate(candidate, route);
+                await this.assertClaudeWorkspaceDisjoint(candidate.adapter, candidate.routeHandle);
+                const selected = await candidate.adapter.selectRoute({
+                    alias: candidate.alias,
+                    routeHandle: candidate.routeHandle,
+                });
+                if (selected.routeHandle !== candidate.routeHandle) {
+                    throw new BridgeError("ROUTE_MISMATCH", "The peer identity changed during selection.");
+                }
+                preparedRebinds.push({
+                    candidate,
+                    persisted: route,
+                    selectedState: selected.state,
+                });
+            }
+            catch {
+                await candidate.adapter.releaseRoute?.(candidate.routeHandle).catch(() => undefined);
+            }
+        }
+        const consumed = new Set();
+        try {
+            await this.mutex.run("service", async () => {
+                if (this.closing || !this.running)
+                    return;
+                const changed = await this.refreshClaudeDiscovery({
+                    incrementRevision: false,
+                    observations,
+                    preparedRebinds,
+                    consumedPreparedRebinds: consumed,
+                });
+                if (changed) {
+                    this.revision += 1;
+                    await this.publish();
+                }
+                this.scheduleLifecycleWakeLocked();
+            });
+        }
+        finally {
+            const releasable = await this.mutex.run("service", async () => preparedRebinds.filter((prepared) => {
+                if (consumed.has(prepared))
+                    return false;
+                const binding = {
+                    ...prepared.candidate.adapter.identity,
+                    routeHandle: prepared.candidate.routeHandle,
+                    ownerLease: stableLease("claude", prepared.candidate.routeHandle),
+                };
+                const alias = this.bindingAliases.get(bindingKey(binding));
+                return alias === undefined || this.routeStates.get(alias) === "stale";
+            }));
+            await Promise.allSettled(releasable.map(async (prepared) => await prepared.candidate.adapter.releaseRoute?.(prepared.candidate.routeHandle)));
+        }
+    }
+    async refreshClaudeDiscovery(options = {}) {
         const publicBefore = await this.discoveryPublicFingerprint();
         this.candidates.clear();
         const rowsByAlias = new Map();
@@ -2794,14 +2858,33 @@ export class GatewayService {
                 peers: [],
                 complete: false,
             };
+            let discoverySucceeded = false;
             try {
-                discovered = (await adapter.discoverClaudePeers?.()) ?? discovered;
+                const observed = options.observations?.find((item) => item.adapter === adapter);
+                if (observed !== undefined) {
+                    discovered = observed.snapshot;
+                    discoverySucceeded = true;
+                }
+                else if (options.observations === undefined &&
+                    adapter.discoverClaudePeers !== undefined) {
+                    discovered = await adapter.discoverClaudePeers();
+                    discoverySucceeded = true;
+                }
             }
             catch {
                 // Registry observation is dashboard evidence, not Claude mailbox
                 // authority. The provider still revalidates the exact target before
                 // any write.
             }
+            if (discoverySucceeded && discovered.complete) {
+                await this.store.observeConnector({
+                    identity: adapter.identity,
+                    health: "healthy",
+                    protocol: adapter.protocol,
+                    protocolVersion: adapter.protocolVersion,
+                });
+                this.recordConnectorFreshness(adapter.identity, "healthy");
+            }
             this.captureRegistryObservation(adapter, discovered.registry ?? adapter.latestRegistryObservation?.());
             const grouped = new Map();
             const byHandle = new Map();
@@ -2899,7 +2982,6 @@ export class GatewayService {
         for (const route of persisted) {
             if (!route.enabled ||
                 route.state !== "stale" ||
-                route.compatibility !== "expired" ||
                 !CLAUDE_SESSION_ID.test(route.binding.routeHandle) ||
                 route.binding.ownerLease !==
                     stableLease("claude", route.binding.routeHandle)) {
@@ -2913,7 +2995,21 @@ export class GatewayService {
             const candidate = matches[0];
             if (candidate === undefined)
                 continue;
-            await this.activatePersistedClaudeCandidate(candidate, route, "peer_identity_reobserved").catch(() => undefined);
+            const prepared = options.preparedRebinds?.find((item) => item.candidate.adapter === candidate.adapter &&
+                item.candidate.routeHandle === candidate.routeHandle &&
+                item.persisted.binding.ownerLease === route.binding.ownerLease);
+            const activated = prepared === undefined
+                ? options.observations === undefined &&
+                    await this.activatePersistedClaudeCandidate(candidate, route, "peer_identity_reobserved").then(() => true, () => false)
+                : await this.commitPreparedClaudeRebind(prepared, "peer_identity_reobserved").then(() => {
+                    options.consumedPreparedRebinds?.add(prepared);
+                    return true;
+                }, () => false);
+            if (activated &&
+                this.running &&
+                this.routeStates.get(candidate.alias) === "idle") {
+                this.scheduleDispatch(candidate.alias);
+            }
         }
         const rows = [];
         for (const [alias, row] of rowsByAlias) {
@@ -2923,8 +3019,7 @@ export class GatewayService {
                     alias,
                     provider: "claude",
                     host: row.adapter.identity.hostId,
-                    state: "incompatible",
-                    compatibility: "incompatible",
+                    state: "offline",
                     validated: false,
                     selected: false,
                     safeErrorCode: row.safeErrorCode,
@@ -2942,7 +3037,6 @@ export class GatewayService {
                 provider: "claude",
                 host: row.adapter.identity.hostId,
                 state: row.peer.state,
-                compatibility: row.peer.compatibility,
                 validated: true,
                 selected,
             });
@@ -2951,7 +3045,6 @@ export class GatewayService {
                 await this.store.observeRoute({
                     binding: selectedBinding,
                     state: row.peer.state,
-                    compatibility: "compatible",
                 });
             }
         }
@@ -2966,7 +3059,7 @@ export class GatewayService {
             const inspection = await this.store.inspectPrivateRoute(alias);
             if (inspection !== undefined &&
                 inspection.enabled &&
-                inspection.compatibility === "compatible") {
+                inspection.state !== "stale") {
                 await this.drainPreDeadlineDeliveryCallbacksLocked();
                 const inFlightSettlements = await this.planRouteInFlightSettlementsLocked(alias, {
                     unwrittenOutcome: "failed",
@@ -2986,7 +3079,7 @@ export class GatewayService {
         }
         this.availablePeers = rows.sort((left, right) => left.alias.localeCompare(right.alias));
         const changed = publicBefore !== (await this.discoveryPublicFingerprint());
-        if (changed)
+        if (changed && options.incrementRevision !== false)
             this.revision += 1;
         return changed;
     }
@@ -3040,17 +3133,7 @@ export class GatewayService {
         return this.candidates.get(selector);
     }
     async activatePersistedClaudeCandidate(candidate, persisted, reason) {
-        const expectedLease = stableLease("claude", candidate.routeHandle);
-        if (!persisted.enabled ||
-            persisted.state !== "stale" ||
-            persisted.compatibility !== "expired" ||
-            persisted.binding.provider !== "claude" ||
-            candidate.adapter.identity.provider !== "claude" ||
-            persisted.binding.hostId !== candidate.adapter.identity.hostId ||
-            persisted.binding.routeHandle !== candidate.routeHandle ||
-            persisted.binding.ownerLease !== expectedLease) {
-            throw new BridgeError("ROUTE_REBIND_IDENTITY_MISMATCH", "The persisted Claude selection does not match the exact live session identity.");
-        }
+        this.validatePersistedClaudeCandidate(candidate, persisted);
         await this.assertClaudeWorkspaceDisjoint(candidate.adapter, candidate.routeHandle);
         try {
             const selected = await candidate.adapter.selectRoute({
@@ -3060,23 +3143,7 @@ export class GatewayService {
             if (selected.routeHandle !== candidate.routeHandle) {
                 throw new BridgeError("ROUTE_MISMATCH", "The peer identity changed during selection.");
             }
-            const binding = {
-                ...candidate.adapter.identity,
-                routeHandle: candidate.routeHandle,
-                ownerLease: expectedLease,
-            };
-            await this.store.rebindStaleRoute({
-                alias: persisted.alias,
-                newAlias: candidate.alias,
-                currentOwnerLease: persisted.binding.ownerLease,
-                newBinding: binding,
-                reason,
-                state: selected.state,
-            });
-            if (persisted.alias !== candidate.alias) {
-                this.forgetBinding(persisted.alias);
-            }
-            this.rememberBinding(candidate.alias, binding, selected.state);
+            await this.commitPreparedClaudeRebind({ candidate, persisted, selectedState: selected.state }, reason);
         }
         catch (error) {
             await candidate.adapter.releaseRoute?.(candidate.routeHandle).catch(() => {
@@ -3085,6 +3152,44 @@ export class GatewayService {
             throw error;
         }
     }
+    validatePersistedClaudeCandidate(candidate, persisted) {
+        const expectedLease = stableLease("claude", candidate.routeHandle);
+        if (!persisted.enabled ||
+            persisted.state !== "stale" ||
+            persisted.binding.provider !== "claude" ||
+            candidate.adapter.identity.provider !== "claude" ||
+            persisted.binding.hostId !== candidate.adapter.identity.hostId ||
+            persisted.binding.routeHandle !== candidate.routeHandle ||
+            persisted.binding.ownerLease !== expectedLease) {
+            throw new BridgeError("ROUTE_REBIND_IDENTITY_MISMATCH", "The persisted Claude selection does not match the exact live session identity.");
+        }
+    }
+    async commitPreparedClaudeRebind(prepared, reason) {
+        const { candidate, selectedState } = prepared;
+        const persisted = (await this.store.inspectPrivateRoute(prepared.persisted.alias)) ??
+            (await this.store.inspectPrivateRoute(candidate.alias));
+        if (persisted === undefined) {
+            throw new BridgeError("ROUTE_REBIND_IDENTITY_MISMATCH", "The persisted Claude selection changed before re-observation committed.");
+        }
+        this.validatePersistedClaudeCandidate(candidate, persisted);
+        const binding = {
+            ...candidate.adapter.identity,
+            routeHandle: candidate.routeHandle,
+            ownerLease: stableLease("claude", candidate.routeHandle),
+        };
+        await this.store.rebindStaleRoute({
+            alias: persisted.alias,
+            newAlias: candidate.alias,
+            currentOwnerLease: persisted.binding.ownerLease,
+            newBinding: binding,
+            reason,
+            state: selectedState,
+        });
+        if (persisted.alias !== candidate.alias) {
+            this.forgetBinding(persisted.alias);
+        }
+        this.rememberBinding(candidate.alias, binding, selectedState);
+    }
     async selectClaudeCandidate(candidate, persisted) {
         if (persisted !== undefined) {
             await this.activatePersistedClaudeCandidate(candidate, persisted, "peer_explicitly_reselected");
@@ -3109,7 +3214,6 @@ export class GatewayService {
                 binding,
                 registrationMode: "selected_live_peer",
                 state: selected.state,
-                compatibility: "compatible",
             });
             this.rememberBinding(candidate.alias, binding, selected.state);
         }
@@ -3161,7 +3265,6 @@ export class GatewayService {
                     binding,
                     registrationMode: "selected_live_peer",
                     state: selectedState,
-                    compatibility: "compatible",
                 },
                 inFlightSettlements,
             });
@@ -3234,47 +3337,83 @@ export class GatewayService {
         }
         return candidate.alias;
     }
-    assertCodexPairCaller(params) {
-        const binding = this.routeBindings.get(params.codexAlias);
+    assertPairThreadAttestation(params) {
+        const attestation = pairParamThreadAttestation(params);
+        const legacyAlias = "codexAlias" in params ? params.codexAlias : undefined;
+        if (attestation === undefined && legacyAlias === undefined)
+            return;
+        const binding = this.routeBindings.get(attestation?.alias ?? legacyAlias);
         if (binding?.provider !== "codex" ||
-            (params.codexThreadId !== undefined &&
-                binding.routeHandle !== params.codexThreadId)) {
+            (attestation !== undefined && binding.routeHandle !== attestation.threadId)) {
             throw new BridgeError("CODEX_CALLER_MISMATCH", "The inherited Codex task does not own the requested pair endpoint.");
         }
     }
     async pairRoutes(params) {
-        this.assertCodexPairCaller(params);
-        await this.selectAndPairClaude(params.claudeAlias, params.codexAlias);
+        this.assertPairThreadAttestation(params);
+        if ("claudeAlias" in params) {
+            await this.selectAndPairClaude(params.claudeAlias, params.codexAlias);
+            return;
+        }
+        await this.assertLiveConsentEndpoints(params.aliases);
+        const added = await this.store.addConsentEdge({ aliases: params.aliases });
+        if (added.created)
+            await this.changed();
+        else
+            await this.publish();
     }
     async unpairRoutes(params) {
-        this.assertCodexPairCaller(params);
-        const selected = await this.selectedClaudeRoute(params.claudeAlias);
-        await this.unpairClaudeRoute(selected, params.codexAlias);
+        this.assertPairThreadAttestation(params);
+        const aliases = pairParamAliases(params);
+        if (!("claudeAlias" in params))
+            await this.assertLiveConsentEndpoints(aliases);
+        await this.removeConsentEdge(aliases);
+    }
+    async assertLiveConsentEndpoints(aliases) {
+        const routes = await Promise.all(aliases.map((alias) => this.store.inspectPrivateRoute(alias)));
+        if (routes[0] === undefined || routes[1] === undefined) {
+            throw new BridgeError("CONSENT_EDGE_ROUTE_NOT_FOUND", "Both consent endpoints must be registered.");
+        }
+        for (const route of routes) {
+            const live = this.routeBindings.get(route.alias);
+            if (!route.enabled ||
+                route.state === "stale" ||
+                live === undefined ||
+                bindingKey(live) !== bindingKey(route.binding) ||
+                this.adapter(route.binding.provider, route.binding.hostId).identity.endpointGeneration !==
+                    route.binding.endpointGeneration) {
+                throw new BridgeError("ROUTE_UNAVAILABLE", "Both consent endpoints must be exact positively observed live routes.");
+            }
+        }
+        if (routes[0].binding.provider === routes[1].binding.provider || routes[0].binding.hostId !== routes[1].binding.hostId) {
+            throw new BridgeError("INVALID_CONSENT_EDGE", "A consent edge must connect distinct providers on the same host.");
+        }
+        return routes;
     }
-    async unpairClaudeRoute(selected, codexAlias) {
+    async removeConsentEdge(aliases) {
         await this.drainPreDeadlineDeliveryCallbacksLocked();
-        const pair = {
-            claudeAlias: selected.alias,
-            codexAlias,
-        };
-        const inFlightSettlements = await this.planPairInFlightSettlementsLocked(pair, {
+        const routes = await Promise.all(aliases.map((alias) => this.store.inspectPrivateRoute(alias)));
+        const edge = { aliases };
+        const inFlightSettlements = await this.planConsentEdgeInFlightSettlementsLocked(edge, {
             unwrittenOutcome: "cancelled",
             safeErrorCode: "PAIR_REMOVED",
         });
-        const result = await this.store.unpairRoutes({
-            ...pair,
+        const result = await this.store.removeConsentEdge({
+            ...edge,
             inFlightSettlements,
         });
         for (const settlement of result.settlements) {
             await this.applyTerminalSettlementLocked(settlement);
         }
-        this.purgePairCapabilitiesLocked(pair);
-        if (result.claudeRouteUnreferenced) {
-            const settlements = await this.store.unregisterRoute(selected.alias, selected.binding.ownerLease);
+        this.purgeConsentEdgeCapabilitiesLocked(aliases);
+        for (const alias of result.unreferencedAliases) {
+            const selected = routes.find((route) => route?.alias === alias);
+            if (selected?.binding.provider !== "claude" || selected.registrationMode !== "selected_live_peer")
+                continue;
+            const settlements = await this.store.unregisterRoute(alias, selected.binding.ownerLease);
             for (const settlement of settlements) {
                 await this.applyTerminalSettlementLocked(settlement);
             }
-            this.forgetBinding(selected.alias);
+            this.forgetBinding(alias);
             await this.adapters
                 .find((adapter) => adapter.identity.provider === "claude" &&
                 adapter.identity.hostId === selected.binding.hostId)
@@ -3282,7 +3421,7 @@ export class GatewayService {
                 .catch(() => {
                 this.dashboardHealthy = false;
             });
-            this.availablePeers = this.availablePeers.map((peer) => peer.alias === selected.alias ? { ...peer, selected: false } : peer);
+            this.availablePeers = this.availablePeers.map((peer) => peer.alias === alias ? { ...peer, selected: false } : peer);
         }
         await this.changed();
     }
@@ -3291,17 +3430,6 @@ export class GatewayService {
     }
     async selectAndPairClaude(selector, codexAlias) {
         const codexBinding = this.routeBindings.get(codexAlias);
-        const retainedCodexRoute = codexBinding?.provider === "codex"
-            ? undefined
-            : await this.store.inspectPrivateRoute(codexAlias);
-        const codexHost = codexBinding?.provider === "codex"
-            ? codexBinding.hostId
-            : retainedCodexRoute?.binding.provider === "codex"
-                ? retainedCodexRoute.binding.hostId
-                : undefined;
-        if (codexHost !== undefined) {
-            this.assertCrossProviderMutationCompatible(codexHost);
-        }
         const codexAdapter = codexBinding?.provider === "codex"
             ? this.adapters.find((adapter) => adapter.identity.provider === "codex" &&
                 adapter.identity.hostId === codexBinding.hostId)
@@ -3341,10 +3469,7 @@ export class GatewayService {
         }
         let paired;
         try {
-            paired = await this.store.pairRoutes({
-                claudeAlias: candidate.alias,
-                codexAlias,
-            });
+            paired = await this.store.addConsentEdge({ aliases: [candidate.alias, codexAlias] });
         }
         catch (error) {
             if (!alreadyLive &&
@@ -3384,7 +3509,7 @@ export class GatewayService {
     async unselectClaude(params) {
         const codexAlias = await this.inferCodexAlias(params.codexThreadId);
         const selected = await this.selectedClaudeRoute(params.alias);
-        await this.unpairClaudeRoute(selected, codexAlias);
+        await this.removeConsentEdge([selected.alias, codexAlias]);
     }
     async selectedClaudeRoute(selector) {
         const persisted = await this.store.inspectPrivateClaudeRoutes();
@@ -3396,14 +3521,13 @@ export class GatewayService {
             throw new BridgeError("PEER_NOT_FOUND", "No selected Claude session matches that selector.");
         return selected;
     }
-    async registerOrRebind(alias, binding, reason, state, currentOwnerLease = binding.ownerLease) {
+    async registerOrRebind(alias, binding, reason, state, currentOwnerLease = binding.ownerLease, registrationMode = binding.provider === "codex" ? "explicit_opt_in" : "selected_live_peer") {
         try {
             await this.store.registerRoute({
                 alias,
                 binding,
-                registrationMode: binding.provider === "codex" ? "explicit_opt_in" : "selected_live_peer",
+                registrationMode,
                 state,
-                compatibility: "compatible",
             });
         }
         catch (error) {
@@ -3473,14 +3597,13 @@ export class GatewayService {
         await this.store.observeConnector({
             identity: adapter.identity,
             health: "healthy",
-            compatibility: "compatible",
             protocol: adapter.protocol,
             protocolVersion: adapter.protocolVersion,
         });
+        this.recordConnectorFreshness(adapter.identity, "healthy");
         await this.store.observeRoute({
             binding,
             state,
-            compatibility: "compatible",
         });
         return binding;
     }
@@ -3783,7 +3906,15 @@ export class GatewayService {
                     unwrittenOutcome: input.unwrittenOutcome,
                     safeErrorCode: input.safeErrorCode,
                 };
-            const transition = transitionDelivery(tracker.machine, event);
+            const stateAtTermination = tracker.pendingTerminalEvent === undefined &&
+                this.providerDispatchInFlightMessageIds.has(messageId)
+                ? transitionDelivery(tracker.machine, {
+                    type: "dispatch_ambiguous",
+                    at: observedAt,
+                    safeErrorCode: "DISPATCH_OUTCOME_AMBIGUOUS",
+                }).state
+                : tracker.machine;
+            const transition = transitionDelivery(stateAtTermination, event);
             const settlement = transition.effects.find((effect) => effect.type === "settle_delivery");
             if (settlement === undefined) {
                 throw new BridgeError("ROUTE_TERMINATION_STATE_MISMATCH", "An affected in-flight delivery could not produce an exact terminal route settlement.", true);
@@ -3796,8 +3927,8 @@ export class GatewayService {
             };
         });
     }
-    async planPairInFlightSettlementsLocked(pair, input) {
-        const affected = await this.store.inspectAffectedPairInFlightMessages(pair);
+    async planConsentEdgeInFlightSettlementsLocked(edge, input) {
+        const affected = await this.store.inspectAffectedConsentEdgeInFlightMessages(edge);
         const observedAt = this.now().getTime();
         return affected.map(({ messageId }) => {
             const tracker = this.deliveryTrackers.get(messageId);
@@ -3815,7 +3946,15 @@ export class GatewayService {
                     unwrittenOutcome: input.unwrittenOutcome,
                     safeErrorCode: input.safeErrorCode,
                 };
-            const transition = transitionDelivery(tracker.machine, event);
+            const stateAtTermination = tracker.pendingTerminalEvent === undefined &&
+                this.providerDispatchInFlightMessageIds.has(messageId)
+                ? transitionDelivery(tracker.machine, {
+                    type: "dispatch_ambiguous",
+                    at: observedAt,
+                    safeErrorCode: "DISPATCH_OUTCOME_AMBIGUOUS",
+                }).state
+                : tracker.machine;
+            const transition = transitionDelivery(stateAtTermination, event);
             const settlement = transition.effects.find((effect) => effect.type === "settle_delivery");
             if (settlement === undefined) {
                 throw new BridgeError("PAIR_TERMINATION_STATE_MISMATCH", "An affected in-flight delivery could not produce an exact terminal pair settlement.", true);
@@ -3828,9 +3967,8 @@ export class GatewayService {
             };
         });
     }
-    purgePairCapabilitiesLocked(pair) {
-        const matches = (sourceAlias, targetAlias) => (sourceAlias === pair.claudeAlias && targetAlias === pair.codexAlias) ||
-            (sourceAlias === pair.codexAlias && targetAlias === pair.claudeAlias);
+    purgeConsentEdgeCapabilitiesLocked(aliases) {
+        const matches = (sourceAlias, targetAlias) => aliases.includes(sourceAlias) && aliases.includes(targetAlias);
         const conversationIds = new Set();
         for (const [conversationId, conversation] of this.conversations) {
             if (conversation.pair !== true ||
@@ -4181,6 +4319,17 @@ export class GatewayService {
     async processLifecycleLocked() {
         const now = this.now().getTime();
         let changed = false;
+        if (this.nextClaudeDiscoveryAt !== undefined &&
+            this.nextClaudeDiscoveryAt <= now) {
+            this.nextClaudeDiscoveryAt = now + CLAUDE_DISCOVERY_REFRESH_MS;
+            this.schedulePeriodicClaudeDiscovery();
+        }
+        for (const [key, deadlineAt] of this.connectorFreshnessDeadlineAt) {
+            if (deadlineAt > now)
+                continue;
+            this.connectorFreshnessDeadlineAt.delete(key);
+            changed = true;
+        }
         if (await this.processProgressWatchesLocked(now))
             changed = true;
         await this.drainPreDeadlineDeliveryCallbacksLocked();
@@ -4318,6 +4467,14 @@ export class GatewayService {
         if (this.nextProgressWatchAt !== undefined) {
             consider(this.nextProgressWatchAt);
         }
+        if (this.nextClaudeDiscoveryAt !== undefined) {
+            consider(this.nextClaudeDiscoveryAt);
+        }
+        for (const deadlineAt of this.connectorFreshnessDeadlineAt.values()) {
+            consider(deadlineAt);
+        }
+        if (this.lifecyclePublishPending)
+            consider(now);
         if (hasNonterminal) {
             this.nextDashboardRefreshAt ??= now + DELIVERY_DASHBOARD_REFRESH_MS;
             consider(this.nextDashboardRefreshAt);
@@ -4333,10 +4490,21 @@ export class GatewayService {
             this.lifecycleTimer = undefined;
             void this.mutex
                 .run("service", async () => {
-                const changed = await this.processLifecycleLocked();
-                if (changed) {
-                    this.revision += 1;
-                    await this.publish();
+                try {
+                    const changed = await this.processLifecycleLocked();
+                    if (changed) {
+                        this.revision += 1;
+                        this.lifecyclePublishPending = true;
+                    }
+                    if (this.lifecyclePublishPending) {
+                        await this.publish();
+                        this.lifecyclePublishPending = false;
+                    }
+                    this.scheduleLifecycleWakeLocked();
+                }
+                catch {
+                    this.dashboardHealthy = false;
+                    this.scheduleLifecycleRetryLocked();
                 }
             })
                 .catch(() => {
@@ -4346,6 +4514,23 @@ export class GatewayService {
         this.lifecycleTimer = timer;
         timer.unref?.();
     }
+    scheduleLifecycleRetryLocked() {
+        if (!this.running || this.closing || this.lifecycleTimer !== undefined) {
+            return;
+        }
+        const timer = this.timers.setTimeout(() => {
+            if (this.lifecycleTimer !== timer)
+                return;
+            this.lifecycleTimer = undefined;
+            void this.mutex.run("service", async () => {
+                this.scheduleLifecycleWakeLocked();
+            }).catch(() => {
+                this.dashboardHealthy = false;
+            });
+        }, DELIVERY_SETTLEMENT_RETRY_MS);
+        this.lifecycleTimer = timer;
+        timer.unref?.();
+    }
     async deliveryStatus(token) {
         return await this.mutex.run("service", async () => {
             if (!DELIVERY_TOKEN.test(token))
@@ -4614,12 +4799,13 @@ 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) {
+    async enqueueObservedClaudeReplyAfterRouteTeardownLocked(conversation, sourceBinding, expectedTargetBinding, text) {
         const target = await this.store.resolveRoute(conversation.sourceAlias);
         if (sourceBinding.provider !== "claude" ||
-            target.provider !== "codex" ||
+            target.provider === "claude" ||
+            target.provider !== expectedTargetBinding.provider || target.ownerLease !== expectedTargetBinding.ownerLease ||
             sourceBinding.hostId !== target.hostId) {
-            throw new BridgeError("RECOVERED_REPLY_ROUTE_MISMATCH", "The retained provider reply no longer matches an exact same-host Codex target.");
+            throw new BridgeError("RECOVERED_REPLY_ROUTE_MISMATCH", "The retained provider reply no longer matches an exact same-host non-Claude target.");
         }
         const sequence = conversation.nextSequence;
         const enqueuedAt = this.now().getTime();
@@ -4650,6 +4836,7 @@ export class GatewayService {
             expectsReply: false,
             sequence,
             targetBindingKey: bindingKey(target),
+            sourceBinding: { ...sourceBinding },
             authorization: "selected_route",
             targetAlias: conversation.sourceAlias,
             deadlineAt,
@@ -4662,7 +4849,7 @@ export class GatewayService {
             deadlineAt,
         });
         await this.changed();
-        await this.setNativeCodexStatus(conversation.sourceAlias, "waiting");
+        await this.setNativeSourceStatus(conversation.sourceAlias, "waiting");
         this.scheduleDispatch(conversation.sourceAlias);
     }
     pruneTransient() {
@@ -4703,7 +4890,7 @@ export class GatewayService {
                 break;
         }
     }
-    async awaitDispatchWithNativeHeldLocked(tracker, operation) {
+    async awaitDispatchWithNativeHeld(messageId, operation) {
         const outcome = operation.then((value) => ({ kind: "result", value }), (error) => ({ kind: "error", error }));
         const unwrap = (settled) => {
             if (settled.kind === "error")
@@ -4711,7 +4898,7 @@ export class GatewayService {
             return settled.value;
         };
         while (true) {
-            const current = this.deliveryTrackers.get(tracker.messageId);
+            const current = this.deliveryTrackers.get(messageId);
             if (current === undefined ||
                 current.nativeReceipt === undefined ||
                 current.nativeHeldSent ||
@@ -4736,14 +4923,15 @@ export class GatewayService {
             }
             // A terminal callback may have arrived before the provider's dispatch
             // promise resolved. Let that exact evidence win before emitting held.
-            await this.drainDeliveryCallbacksForMessageLocked(tracker.messageId);
-            const afterCallbacks = this.deliveryTrackers.get(tracker.messageId);
-            if (afterCallbacks === undefined ||
-                isTerminalDeliveryMachine(afterCallbacks.machine) ||
-                this.now().getTime() >= afterCallbacks.deadlineAt) {
-                return unwrap(await outcome);
-            }
-            await this.publishNativeHeldLocked(afterCallbacks);
+            await this.mutex.run("service", async () => {
+                await this.drainDeliveryCallbacksForMessageLocked(messageId);
+                const afterCallbacks = this.deliveryTrackers.get(messageId);
+                if (afterCallbacks !== undefined &&
+                    !isTerminalDeliveryMachine(afterCallbacks.machine) &&
+                    this.now().getTime() < afterCallbacks.deadlineAt) {
+                    await this.publishNativeHeldLocked(afterCallbacks);
+                }
+            });
         }
     }
     restoreQueuedMessageContextLocked(item, binding, canonicalConversationId) {
@@ -4784,7 +4972,7 @@ export class GatewayService {
         });
         return context;
     }
-    async dispatchOne(targetAlias) {
+    async prepareDispatchLocked(targetAlias) {
         if (!this.running ||
             this.closing ||
             this.codexSuccessionDispatchFrozen.has(targetAlias) ||
@@ -4882,7 +5070,6 @@ export class GatewayService {
                 !dispatchable ||
                 inspection === undefined ||
                 !inspection.enabled ||
-                inspection.compatibility !== "compatible" ||
                 !storedDispatchable ||
                 bindingKey(inspection.binding) !== bindingKey(binding) ||
                 bindingKey(selectedBinding) !== bindingKey(binding)) {
@@ -4972,13 +5159,35 @@ export class GatewayService {
                     })).markerActive
                     : false;
         }
-        let result;
-        try {
-            result = await this.awaitDispatchWithNativeHeldLocked(tracker, this.adapter(binding.provider, binding.hostId).dispatch({
+        const sourceBinding = context.sourceBinding ??
+            (await this.store.inspectPrivateRoute(item.sourceAlias))?.binding;
+        const parsedDirection = parseDirection(item.direction);
+        if (sourceBinding === undefined ||
+            parsedDirection?.sourceProvider !== sourceBinding.provider ||
+            parsedDirection.targetProvider !== binding.provider ||
+            item.direction !== directionId(sourceBinding.provider, binding.provider)) {
+            await this.finishDelivery({
+                messageId: item.messageId,
+                state: "failed",
+                safeErrorCode: "MESSAGE_DIRECTION_BINDING_MISMATCH",
+            });
+            return;
+        }
+        context.sourceBinding ??= { ...sourceBinding };
+        this.scheduleLifecycleWakeLocked();
+        return {
+            targetAlias,
+            messageId: item.messageId,
+            body: item.body,
+            binding: { ...binding },
+            authorization: context.authorization,
+            steeringWhileBusy,
+            input: {
                 sourceAlias: item.sourceAlias,
+                sourceProvider: sourceBinding.provider,
                 targetAlias: item.targetAlias,
                 conversationId: context.conversationId,
-                binding,
+                binding: { ...binding },
                 authorization: context.authorization,
                 messageId: item.messageId,
                 text: item.body,
@@ -4988,21 +5197,43 @@ export class GatewayService {
                 ...(item.steer === true && item.queuedAhead !== undefined
                     ? { queuedAhead: item.queuedAhead }
                     : {}),
-                ...(progressWatchActive
-                    ? { progressWatchActive: true }
-                    : {}),
-            }));
+                ...(progressWatchActive ? { progressWatchActive: true } : {}),
+            },
+        };
+    }
+    async commitDispatchLocked(prepared, outcome) {
+        const { targetAlias, messageId, body, binding, authorization, steeringWhileBusy, } = prepared;
+        await this.drainDeliveryCallbacksForMessageLocked(messageId);
+        if (await this.processLifecycleLocked()) {
+            await this.changed();
         }
-        catch {
-            await this.drainDeliveryCallbacksForMessageLocked(item.messageId);
-            if (await this.processLifecycleLocked()) {
-                await this.changed();
-            }
-            if (!this.messageContexts.has(item.messageId)) {
-                this.scheduleDispatch(this.bindingAliases.get(bindingKey(binding)) ?? targetAlias);
-                return;
-            }
-            await this.advanceDeliveryLocked(item.messageId, {
+        const context = this.messageContexts.get(messageId);
+        const tracker = this.deliveryTrackers.get(messageId);
+        if (context === undefined || tracker === undefined) {
+            this.scheduleDispatch(this.bindingAliases.get(bindingKey(binding)) ?? targetAlias);
+            return;
+        }
+        const currentTargetAlias = this.bindingAliases.get(context.targetBindingKey) ??
+            this.bindingAliases.get(bindingKey(binding)) ??
+            targetAlias;
+        const currentSelectedBinding = authorization === "selected_route"
+            ? this.routeBindings.get(currentTargetAlias)
+            : undefined;
+        const currentSelectedRoute = authorization === "selected_route"
+            ? await this.store.inspectPrivateRoute(currentTargetAlias)
+            : undefined;
+        const authorityStillCurrent = !(context.authorization !== authorization ||
+            context.targetBindingKey !== bindingKey(binding) ||
+            (authorization === "selected_route" &&
+                (currentSelectedBinding === undefined ||
+                    bindingKey(currentSelectedBinding) !== bindingKey(binding) ||
+                    currentSelectedRoute === undefined ||
+                    !currentSelectedRoute.enabled ||
+                    currentSelectedRoute.state === "stale" ||
+                    bindingKey(currentSelectedRoute.binding) !== bindingKey(binding) ||
+                    this.routeStates.get(currentTargetAlias) === "stale")));
+        if (outcome.kind === "error") {
+            await this.advanceDeliveryLocked(messageId, {
                 type: "dispatch_ambiguous",
                 at: this.now().getTime(),
                 safeErrorCode: "DISPATCH_OUTCOME_AMBIGUOUS",
@@ -5011,16 +5242,8 @@ export class GatewayService {
             this.scheduleDispatch(this.bindingAliases.get(bindingKey(binding)) ?? targetAlias);
             return;
         }
-        await this.drainDeliveryCallbacksForMessageLocked(item.messageId);
-        if (await this.processLifecycleLocked()) {
-            await this.changed();
-        }
-        if (!this.messageContexts.has(item.messageId)) {
-            this.scheduleDispatch(this.bindingAliases.get(bindingKey(binding)) ?? targetAlias);
-            return;
-        }
+        const result = outcome.result;
         if (result.state === "deferred") {
-            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"
@@ -5032,14 +5255,14 @@ export class GatewayService {
             const retryAt = binding.provider === "claude"
                 ? Math.min(now + retryDelayMs, tracker.deadlineAt - 1)
                 : now + retryDelayMs;
-            await this.advanceDeliveryLocked(item.messageId, {
+            await this.advanceDeliveryLocked(messageId, {
                 type: "dispatch_clean_prewrite_failed",
                 at: now,
                 retryAt,
                 safeErrorCode: deferredSafeErrorCode,
             });
             tracker.deliverySafeErrorCode = deferredSafeErrorCode;
-            const postDeferred = this.deliveryTrackers.get(item.messageId)?.machine;
+            const postDeferred = this.deliveryTrackers.get(messageId)?.machine;
             if (postDeferred === undefined ||
                 isTerminalDeliveryMachine(postDeferred)) {
                 await this.changed();
@@ -5050,32 +5273,33 @@ export class GatewayService {
             // evidence. Only the reducer's explicit queued retry phase may return
             // the body to the store queue.
             if (postDeferred.phase !== "queued") {
-                await this.advanceDeliveryLocked(item.messageId, {
+                await this.advanceDeliveryLocked(messageId, {
                     type: "await_terminal",
                     at: this.now().getTime(),
                 });
                 await this.changed();
                 return;
             }
-            const requeued = await this.store.requeueInFlightMessage(item.messageId, item.body, deferredSafeErrorCode);
-            if (this.activeDispatchByTarget.get(currentTargetAlias) === item.messageId) {
+            const requeued = await this.store.requeueInFlightMessage(messageId, body, deferredSafeErrorCode);
+            if (this.activeDispatchByTarget.get(currentTargetAlias) === messageId) {
                 this.activeDispatchByTarget.delete(currentTargetAlias);
             }
             if (requeued.status === "requeued") {
-                if (context.authorization === "selected_route") {
+                if (context.authorization === "selected_route" &&
+                    authorityStillCurrent) {
                     if (binding.provider === "codex" && !steeringWhileBusy) {
                         this.routeStates.set(currentTargetAlias, "idle");
                         await this.store.observeRoute({
                             binding,
                             state: "idle",
-                            compatibility: "compatible",
                         });
                     }
                     else if (binding.provider === "codex") {
                         this.scheduleHeldRedispatch(currentTargetAlias);
                     }
-                    await this.setNativeCodexStatus(currentTargetAlias, "waiting");
+                    await this.setNativeSourceStatus(currentTargetAlias, "waiting");
                 }
+                await this.publishNativeHeldLocked(tracker);
             }
             else if (requeued.status === "settled") {
                 await this.applyTerminalSettlementLocked(requeued.settlement);
@@ -5083,20 +5307,30 @@ export class GatewayService {
             await this.changed();
             return;
         }
+        if (!authorityStillCurrent) {
+            await this.advanceDeliveryLocked(messageId, {
+                type: "dispatch_ambiguous",
+                at: this.now().getTime(),
+                safeErrorCode: "DISPATCH_OUTCOME_AMBIGUOUS",
+            });
+            await this.changed();
+            this.scheduleDispatch(currentTargetAlias);
+            return;
+        }
         if (result.state === "pending" || result.state === "accepted") {
             if (result.state === "accepted" &&
-                (await this.acceptProviderDeliveryLocked(item.messageId))) {
+                (await this.acceptProviderDeliveryLocked(messageId))) {
                 await this.changed();
             }
             else if (result.state === "pending") {
-                await this.advanceDeliveryLocked(item.messageId, {
+                await this.advanceDeliveryLocked(messageId, {
                     type: "await_terminal",
                     at: this.now().getTime(),
                 });
             }
         }
         else {
-            await this.finishDelivery({ messageId: item.messageId, state: result.state, ...(result.safeErrorCode === undefined ? {} : { safeErrorCode: result.safeErrorCode }), ...(result.replyText === undefined ? {} : { replyText: result.replyText }) });
+            await this.finishDelivery({ messageId, state: result.state, ...(result.safeErrorCode === undefined ? {} : { safeErrorCode: result.safeErrorCode }), ...(result.replyText === undefined ? {} : { replyText: result.replyText }) });
         }
         this.scheduleDispatch(this.bindingAliases.get(bindingKey(binding)) ?? targetAlias);
     }
@@ -5110,27 +5344,100 @@ export class GatewayService {
             return;
         this.scheduledDispatchTargets.add(targetAlias);
         setImmediate(() => {
-            this.mutex
-                .run("service", async () => {
+            void this.runDispatch(targetAlias).catch(() => {
+                this.dashboardHealthy = false;
+            });
+        });
+    }
+    async runDispatch(targetAlias) {
+        let runnerStarted = false;
+        let initialScheduleConsumed = false;
+        let preparedMessageId;
+        let commitCompleted = false;
+        try {
+            const prepared = await this.mutex.run("service", async () => {
                 this.scheduledDispatchTargets.delete(targetAlias);
+                initialScheduleConsumed = true;
                 if (this.closing ||
                     this.codexSuccessionDispatchFrozen.has(targetAlias) ||
                     this.codexSuccessionPoisoned.has(targetAlias)) {
                     return;
                 }
                 this.dispatchRunnerTargets.add(targetAlias);
-                try {
-                    await this.dispatchOne(targetAlias);
-                }
-                finally {
+                runnerStarted = true;
+                const candidate = await this.prepareDispatchLocked(targetAlias);
+                if (candidate === undefined) {
                     this.dispatchRunnerTargets.delete(targetAlias);
                     this.scheduleLifecycleWakeLocked();
+                    runnerStarted = false;
                 }
-            })
-                .catch(() => {
-                this.dashboardHealthy = false;
+                else {
+                    preparedMessageId = candidate.messageId;
+                    this.providerDispatchInFlightMessageIds.add(candidate.messageId);
+                }
+                return candidate;
             });
-        });
+            if (prepared === undefined)
+                return;
+            let outcome;
+            try {
+                const adapter = this.adapter(prepared.binding.provider, prepared.binding.hostId);
+                outcome = {
+                    kind: "result",
+                    result: await this.awaitDispatchWithNativeHeld(prepared.messageId, adapter.dispatch(prepared.input)),
+                };
+            }
+            catch {
+                outcome = { kind: "error" };
+            }
+            await this.mutex.run("service", async () => {
+                await this.commitDispatchLocked(prepared, outcome);
+                commitCompleted = true;
+                this.providerDispatchInFlightMessageIds.delete(prepared.messageId);
+                preparedMessageId = undefined;
+                this.dispatchRunnerTargets.delete(targetAlias);
+                runnerStarted = false;
+                this.scheduleLifecycleWakeLocked();
+            });
+        }
+        finally {
+            await this.mutex.run("service", async () => {
+                if (preparedMessageId !== undefined) {
+                    let releaseUncertaintyMarker = commitCompleted;
+                    if (!commitCompleted) {
+                        const tracker = this.deliveryTrackers.get(preparedMessageId);
+                        if (tracker !== undefined &&
+                            !isTerminalDeliveryMachine(tracker.machine)) {
+                            try {
+                                await this.advanceDeliveryLocked(preparedMessageId, {
+                                    type: "dispatch_ambiguous",
+                                    at: this.now().getTime(),
+                                    safeErrorCode: "DISPATCH_OUTCOME_AMBIGUOUS",
+                                });
+                                await this.changed();
+                                releaseUncertaintyMarker = true;
+                            }
+                            catch {
+                                this.dashboardHealthy = false;
+                            }
+                        }
+                        else {
+                            releaseUncertaintyMarker = true;
+                        }
+                    }
+                    if (releaseUncertaintyMarker) {
+                        this.providerDispatchInFlightMessageIds.delete(preparedMessageId);
+                    }
+                }
+                if (runnerStarted) {
+                    this.dispatchRunnerTargets.delete(targetAlias);
+                }
+                if (!initialScheduleConsumed) {
+                    this.scheduledDispatchTargets.delete(targetAlias);
+                }
+                this.scheduleLifecycleWakeLocked();
+            });
+        }
     }
     scheduleHeldRedispatch(targetAlias) {
         if (this.closing || this.heldRedispatchTimers.has(targetAlias))
@@ -5285,13 +5592,12 @@ export class GatewayService {
                         .then(() => true)
                         .catch(() => false);
                     const pairStillActive = conversation.pair !== true ||
-                        (await this.store.hasPair({
-                            claudeAlias: conversation.targetAlias,
-                            codexAlias: conversation.sourceAlias,
+                        (await this.store.hasConsentEdge({
+                            aliases: [conversation.targetAlias, conversation.sourceAlias],
                         }));
                     if ((!sourceStillRoutable || !pairStillActive) &&
-                        sourceBinding?.provider === "claude") {
-                        await this.enqueueObservedClaudeReplyAfterRouteTeardownLocked(conversation, sourceBinding, replyText);
+                        sourceBinding?.provider === "claude" && context.sourceBinding !== undefined) {
+                        await this.enqueueObservedClaudeReplyAfterRouteTeardownLocked(conversation, sourceBinding, context.sourceBinding, replyText);
                     }
                     else {
                         await this.enqueue(conversation.targetAlias, conversation.sourceAlias, replyText, false, {
@@ -5384,7 +5690,7 @@ export class GatewayService {
             };
             const collision = this.routeBindings.get(event.sourceAlias);
             if (target === undefined ||
-                target.provider !== "codex" ||
+                target.provider === "claude" ||
                 target.hostId !== event.endpoint.hostId ||
                 (collision !== undefined &&
                     bindingKey(collision) !== bindingKey(sourceBinding))) {
@@ -5426,6 +5732,7 @@ export class GatewayService {
                 expectsReply: !steer,
                 sequence: 0,
                 targetBindingKey: bindingKey(target),
+                sourceBinding: { ...sourceBinding },
                 authorization: "selected_route",
                 targetAlias: event.targetAlias,
                 deadlineAt,
@@ -5451,13 +5758,17 @@ export class GatewayService {
                 deadlineAt,
             });
             await this.changed();
-            await this.setNativeCodexStatus(event.targetAlias, "waiting");
-            // Native ingress gets one immediate dispatch opportunity. Only an
-            // actual queued/waiting result earns a `held` acknowledgement; an idle
-            // fast path can therefore settle with one terminal acknowledgement.
-            await this.dispatchOne(event.targetAlias);
+            await this.setNativeSourceStatus(event.targetAlias, "waiting");
+            // Provider I/O runs outside the service mutex. The lifecycle timer emits
+            // `held` only if this exact body remains nonterminal at its prompt
+            // boundary; a fast provider result therefore still produces one
+            // terminal acknowledgement and never freezes control-plane callbacks.
+            this.scheduleDispatch(event.targetAlias);
             const tracker = this.deliveryTrackers.get(queued.messageId);
-            if (tracker?.machine.phase === "queued") {
+            const routeState = this.routeStates.get(event.targetAlias);
+            if (tracker?.machine.phase === "queued" &&
+                routeState !== "idle" &&
+                (!steer || routeState !== "busy")) {
                 await this.publishNativeHeldLocked(tracker);
             }
         }
@@ -5521,7 +5832,7 @@ export class GatewayService {
             return activationDeferred;
         }
         finally {
-            if (!succeeded && event.outcome === "compatible") {
+            if (!succeeded) {
                 adapter.releaseEndpointRefreshSelectorClaim?.(event.current.endpointGeneration);
             }
             if (ownsActiveTransition &&
@@ -5540,56 +5851,29 @@ export class GatewayService {
         }
     }
     async applyCodexEndpointRefresh(adapter, event, transitionKey, options) {
+        const routeHandles = Array.isArray(event.routes)
+            ? event.routes.map((route) => route.routeHandle)
+            : [];
         if (this.closing ||
-            (event.outcome !== "compatible" && event.outcome !== "incompatible") ||
-            !isCompatibilityAttestation(event.attestation) ||
-            event.attestation.surface !== "codex" ||
             event.previous.provider !== "codex" ||
             !PRIVATE_HANDLE.test(event.previous.endpointGeneration) ||
             adapter.identity.provider !== "codex" ||
             adapter.identity.hostId !== event.previous.hostId ||
-            !this.config.allowedHosts.includes(event.previous.hostId)) {
+            !this.config.allowedHosts.includes(event.previous.hostId) ||
+            event.current.provider !== "codex" ||
+            event.current.hostId !== event.previous.hostId ||
+            !PRIVATE_HANDLE.test(event.current.endpointGeneration) ||
+            event.current.endpointGeneration === event.previous.endpointGeneration ||
+            adapter.identity.endpointGeneration !== event.current.endpointGeneration ||
+            !Array.isArray(event.routes) ||
+            event.routes.length > this.config.limits.maxRoutes ||
+            new Set(routeHandles).size !== routeHandles.length ||
+            event.routes.some((route) => !PRIVATE_HANDLE.test(route.routeHandle) ||
+                !["idle", "busy", "awaiting_approval"].includes(route.state))) {
             throw new BridgeError("CODEX_ENDPOINT_REFRESH_MISMATCH", "The Codex endpoint transition failed closed runtime validation.");
         }
-        if (event.outcome === "compatible") {
-            const routeHandles = Array.isArray(event.routes)
-                ? event.routes.map((route) => route.routeHandle)
-                : [];
-            if (event.current.provider !== "codex" ||
-                event.current.hostId !== event.previous.hostId ||
-                !PRIVATE_HANDLE.test(event.current.endpointGeneration) ||
-                event.current.endpointGeneration ===
-                    event.previous.endpointGeneration ||
-                adapter.identity.endpointGeneration !==
-                    event.current.endpointGeneration ||
-                event.attestation.version !== adapter.protocolVersion ||
-                event.attestation.tier === "incompatible" ||
-                !Array.isArray(event.routes) ||
-                event.routes.length > this.config.limits.maxRoutes ||
-                new Set(routeHandles).size !== routeHandles.length ||
-                event.routes.some((route) => !PRIVATE_HANDLE.test(route.routeHandle) ||
-                    !["idle", "busy", "awaiting_approval"].includes(route.state))) {
-                throw new BridgeError("CODEX_ENDPOINT_REFRESH_MISMATCH", "The refreshed Codex provider identity changed before activation.");
-            }
-            if (this.activatedEndpointRefreshes.get(event.current.hostId) ===
-                transitionKey) {
-                return false;
-            }
-        }
-        else {
-            if (event.candidate.provider !== "codex" ||
-                event.candidate.hostId !== event.previous.hostId ||
-                !PRIVATE_HANDLE.test(event.candidate.endpointGeneration) ||
-                event.candidate.endpointGeneration ===
-                    event.previous.endpointGeneration ||
-                adapter.identity.endpointGeneration !==
-                    event.previous.endpointGeneration ||
-                event.attestation.tier !== "incompatible") {
-                throw new BridgeError("CODEX_ENDPOINT_REFRESH_MISMATCH", "The incompatible Codex candidate no longer matches the active endpoint.");
-            }
-            if (this.handledIncompatibleEndpointRefreshes.get(event.previous.hostId) === transitionKey) {
-                return false;
-            }
+        if (this.activatedEndpointRefreshes.get(event.current.hostId) === transitionKey) {
+            return false;
         }
         let inventory = await this.store.inspectPrivateCodexRoutes();
         const previousRoutes = inventory.filter((route) => route.binding.hostId === event.previous.hostId &&
@@ -5607,11 +5891,10 @@ export class GatewayService {
             settlements = await this.store.markConnectorOffline(event.previous, "ENDPOINT_GENERATION_CHANGED", inFlightSettlements, { preserveQueued: true });
         }
         catch (error) {
-            const alreadyInvalidatedCompatibleTransition = event.outcome === "compatible" &&
-                error instanceof BridgeError &&
+            const alreadyInvalidatedTransition = error instanceof BridgeError &&
                 error.code === "CONNECTOR_NOT_FOUND" &&
-                previousRoutes.every((route) => route.state === "stale" && route.compatibility === "expired");
-            if (!alreadyInvalidatedCompatibleTransition)
+                previousRoutes.every((route) => route.state === "stale");
+            if (!alreadyInvalidatedTransition)
                 throw error;
         }
         for (const settlement of settlements) {
@@ -5620,50 +5903,13 @@ export class GatewayService {
         for (const route of previousRoutes) {
             this.routeStates.set(route.alias, "stale");
         }
-        await this.store.recordCompatibilityAttestation(event.attestation);
-        if (event.outcome === "incompatible") {
-            await this.requireEndpointRefreshUnconflicted();
-            this.activeCodexIncompatibility = structuredClone(event.attestation);
-            this.incompatibleProviderSurfaces.set(this.providerSurfaceKey("codex", event.previous.hostId), event.attestation.safeErrorCode ?? "CODEX_ENDPOINT_INCOMPATIBLE");
-            this.addRuntimeAlert(event.attestation.safeErrorCode ?? "CODEX_ENDPOINT_INCOMPATIBLE", "error", { provider: "codex", host: event.previous.hostId });
-            this.handledIncompatibleEndpointRefreshes.set(event.previous.hostId, transitionKey);
-            await this.changed();
-            return false;
-        }
-        if (event.attestation.tier === "schema_attested" &&
-            !(compatibilityCoversWrites(event.attestation) &&
-                adapter.latestWriteCompatibilityProbeObservation?.(event.current.endpointGeneration)?.outcome === "pass")) {
-            // A passing untested-version schema is useful observation, but it is not
-            // durable route or write authority. Settle the provider's pending probe
-            // so a later generation can be examined, while leaving every G1 route
-            // stale and refusing selector/registration activation.
-            await this.requireEndpointRefreshUnconflicted();
-            await this.store.observeConnector({
-                identity: event.current,
-                health: "degraded",
-                compatibility: "unknown",
-                protocol: adapter.protocol,
-                protocolVersion: adapter.protocolVersion,
-                safeErrorCode: "CODEX_MONITOR_ONLY",
-            });
-            adapter.acceptCompatibilityAttestation(event.attestation);
-            this.activeCodexIncompatibility = undefined;
-            this.incompatibleProviderSurfaces.set(this.providerSurfaceKey("codex", event.current.hostId), "CODEX_MONITOR_ONLY");
-            this.handledIncompatibleEndpointRefreshes.delete(event.current.hostId);
-            await this.changed();
-            if (options.deferActivation === true ||
-                options.requiredRoute !== undefined) {
-                throw new BridgeError("CODEX_MONITOR_ONLY", "This Codex App Server passed read-only schema probes but cannot authorize a task route or message write.");
-            }
-            return false;
-        }
         await this.store.observeConnector({
             identity: event.current,
             health: "healthy",
-            compatibility: "compatible",
             protocol: adapter.protocol,
             protocolVersion: adapter.protocolVersion,
         });
+        this.recordConnectorFreshness(event.current, "healthy");
         const refreshedByHandle = new Map(event.routes.map((route) => [route.routeHandle, route.state]));
         const pendingReanchors = previousRoutes.flatMap((route) => {
             const state = refreshedByHandle.get(route.binding.routeHandle);
@@ -5715,7 +5961,7 @@ export class GatewayService {
                         route.binding.routeHandle === expected.threadId &&
                         route.binding.ownerLease === expected.ownerLease &&
                         route.enabled &&
-                        route.compatibility === "compatible");
+                        route.state !== "stale");
                     return matches.length === 1;
                 });
                 if (committedExactly) {
@@ -5748,8 +5994,7 @@ export class GatewayService {
                     route.binding.hostId !== event.current.hostId ||
                     route.binding.endpointGeneration !==
                         event.current.endpointGeneration ||
-                    route.state !== "stale" ||
-                    route.compatibility !== "expired") {
+                    route.state !== "stale") {
                     continue;
                 }
                 await this.registerOrRebind(route.alias, route.binding, "endpoint_reobserved", state, route.binding.ownerLease);
@@ -5764,7 +6009,7 @@ export class GatewayService {
                     event.current.endpointGeneration &&
                 route.binding.routeHandle === observed.routeHandle &&
                 route.enabled &&
-                route.compatibility === "compatible");
+                route.state !== "stale");
             if (matches.length > 1) {
                 throw new BridgeError("CODEX_ENDPOINT_REFRESH_MISMATCH", "A refreshed Codex task has multiple durable owners.");
             }
@@ -5804,7 +6049,7 @@ export class GatewayService {
                     event.current.endpointGeneration &&
                 route.binding.routeHandle === requiredRoute.threadId &&
                 route.enabled &&
-                route.compatibility === "compatible");
+                route.state !== "stale");
             const match = matches[0];
             if (matches.length !== 1 || match === undefined) {
                 throw new BridgeError("CODEX_ENDPOINT_REFRESH_MISMATCH", "The registering Codex task was not durably installed exactly.");
@@ -5858,7 +6103,7 @@ export class GatewayService {
             }
             for (const route of activatedRoutes) {
                 requireNativeContinuity(route);
-                await this.setNativeCodexStatus(route.alias, route.state === "idle"
+                await this.setNativeSourceStatus(route.alias, route.state === "idle"
                     ? "idle"
                     : route.state === "awaiting_approval"
                         ? "waiting"
@@ -5898,10 +6143,7 @@ export class GatewayService {
             for (const route of activatedRoutes) {
                 requireNativeContinuity(route);
             }
-            // Provider writes remain closed until every durable and native transition
-            // above is complete. This acknowledgement is deliberately the final
-            // fallible activation step.
-            adapter.acceptCompatibilityAttestation(event.attestation);
+            adapter.activateEndpointGeneration(event.current.endpointGeneration);
         }
         catch (error) {
             try {
@@ -5921,9 +6163,6 @@ export class GatewayService {
             ?.transitionKey === transitionKey) {
             this.pendingSelectorEndpointActivations.delete(event.current.hostId);
         }
-        this.handledIncompatibleEndpointRefreshes.delete(event.current.hostId);
-        this.activeCodexIncompatibility = undefined;
-        this.incompatibleProviderSurfaces.delete(this.providerSurfaceKey("codex", event.current.hostId));
         return false;
     }
     async onRouteState(source, event) {
@@ -5945,7 +6184,6 @@ export class GatewayService {
         await this.store.observeConnector({
             identity: source,
             health: event.state === "stale" ? "degraded" : "healthy",
-            compatibility: event.state === "stale" ? "expired" : "compatible",
             protocol: adapter.protocol,
             protocolVersion: adapter.protocolVersion,
             ...(event.safeErrorCode === undefined
@@ -5954,6 +6192,7 @@ export class GatewayService {
                     safeErrorCode: safeCode(event.safeErrorCode, "CONNECTOR_DEGRADED"),
                 }),
         });
+        this.recordConnectorFreshness(source, event.state === "stale" ? "degraded" : "healthy");
         if (event.state === "stale") {
             if (previousState !== "stale") {
                 this.addRuntimeAlert(staleSafeCode, "error", { provider: binding.provider, host: binding.hostId, alias });
@@ -5961,7 +6200,6 @@ export class GatewayService {
             await this.store.observeRoute({
                 binding,
                 state: "stale",
-                compatibility: "expired",
                 safeErrorCode: staleSafeCode,
             });
         }
@@ -5969,7 +6207,6 @@ export class GatewayService {
             await this.store.observeRoute({
                 binding,
                 state: event.state,
-                compatibility: "compatible",
                 ...(event.safeErrorCode === undefined
                     ? {}
                     : {
@@ -5979,15 +6216,15 @@ export class GatewayService {
         }
         await this.store.touchProgressWatchesForAlias(alias);
         await this.changed();
-        if (binding.provider === "codex") {
-            await this.setNativeCodexStatus(alias, event.state === "idle"
+        if (binding.provider !== "claude") {
+            await this.setNativeSourceStatus(alias, event.state === "idle"
                 ? "idle"
                 : event.state === "awaiting_approval"
                     ? "waiting"
                     : "busy");
-            if (previousState === "stale" && event.state !== "stale") {
-                adapter.rearmEndpointRefreshActivation?.(binding.endpointGeneration);
-            }
+        }
+        if (binding.provider === "codex" && previousState === "stale" && event.state !== "stale") {
+            adapter.rearmEndpointRefreshActivation?.(binding.endpointGeneration);
         }
         if (event.state === "idle" || event.state === "stale") {
             const heldTimer = this.heldRedispatchTimers.get(alias);
@@ -5998,12 +6235,12 @@ export class GatewayService {
             this.scheduleDispatch(alias);
         }
     }
-    async setNativeCodexStatus(alias, status, requireSuccess = false) {
+    async setNativeSourceStatus(alias, status, requireSuccess = false) {
         const binding = this.routeBindings.get(alias);
-        if (binding?.provider !== "codex")
+        if (binding === undefined || binding.provider === "claude")
             return;
         const adapter = this.adapter("claude", binding.hostId);
-        const update = adapter.updateNativeCodexPeerStatus;
+        const update = adapter.updateNativeSourcePeerStatus;
         if (update === undefined) {
             if (requireSuccess) {
                 throw new BridgeError("CODEX_ENDPOINT_REFRESH_NATIVE_STATUS_FAILED", "The native listener does not support refreshed Codex status activation.", true);
@@ -6102,30 +6339,6 @@ export class GatewayService {
     }
     async publicSnapshotLocked() {
         const base = await this.store.publicSnapshot();
-        const compatibilityChecks = [];
-        for (const { surface } of this.compatibilitySurfaceDefinitions) {
-            if (surface === "codex" && this.activeCodexIncompatibility !== undefined) {
-                compatibilityChecks.push(structuredClone(this.activeCodexIncompatibility));
-                continue;
-            }
-            const currentVersions = [
-                ...new Set([...this.adapters, ...this.compatibilityObservers].flatMap((observer) => {
-                    const observation = observer.compatibilitySurface?.();
-                    return observation?.surface === surface ? [observation.version] : [];
-                })),
-            ].sort((left, right) => left.localeCompare(right));
-            const currentAttestations = (await Promise.all(currentVersions.map(async (version) => await this.store.inspectCompatibilityAttestation(surface, version))))
-                .filter((attestation) => attestation !== undefined)
-                .sort((left, right) => {
-                const checkedAt = right.checkedAt.localeCompare(left.checkedAt);
-                if (checkedAt !== 0)
-                    return checkedAt;
-                return left.version.localeCompare(right.version);
-            });
-            const selected = currentAttestations[0];
-            if (selected !== undefined)
-                compatibilityChecks.push(selected);
-        }
         const peers = this.availablePeers.map((peer) => ({ ...peer }));
         if (!arePublicAvailablePeerSnapshots(peers)) {
             throw new BridgeError("INVALID_TRANSIENT_INVENTORY", "The transient peer inventory is unsafe.");
@@ -6154,11 +6367,6 @@ export class GatewayService {
         return projectGatewayPublicSnapshot({
             ...base,
             connectors: this.connectorsWithRegistry(base.connectors),
-            ...(compatibilityChecks.length === 0
-                ? {}
-                : {
-                    compatibilityChecks: compatibilityChecks.map(projectPublicCompatibilityCheck),
-                }),
             availablePeers: peers,
             activityEvents: this.activityEvents.map((event) => ({
                 ...event,