agent-embassy 1.6.0 → 1.7.0

package/dist/src/gateway/dashboard-model.js

@@ -1,10 +1,9 @@
-import { arePublicAvailablePeerSnapshots, isPublicCompatibilityCheckSnapshot, isPublicRegistryObservationSnapshot, } from "./types.js";
-import { compatibilitySurfaceDefinitions, } from "./compatibility.js";
+import { arePublicAvailablePeerSnapshots, gatewayProviders, isPublicRegistryObservationSnapshot, parseDirection, } from "./types.js";
 export const DASHBOARD_MODEL_LIMITS = Object.freeze({
     connectors: 16,
     availablePeers: 64,
     routes: 128,
-    pairs: 64,
+    consentEdges: 64,
     messages: 50,
     messageEvents: 60,
     progressWatches: 64,
@@ -35,7 +34,6 @@ const statePresentation = {
         busy: { tone: "info", chip: "active" },
         awaiting_approval: { tone: "warning", chip: "warning" },
         offline: { tone: "danger", chip: "failure" },
-        incompatible: { tone: "danger", chip: "failure" },
         disabled: { tone: "quiet", chip: "inert" },
     }),
     peer: presentation({
@@ -43,20 +41,12 @@ const statePresentation = {
         busy: { tone: "info", chip: "active" },
         awaiting_approval: { tone: "warning", chip: "warning" },
         offline: { tone: "danger", chip: "inert" },
-        incompatible: { tone: "danger", chip: "failure" },
     }),
     health: presentation({
         healthy: { tone: "good", chip: "positive" },
         connecting: { tone: "info", chip: "progress" },
         degraded: { tone: "warning", chip: "warning" },
         offline: { tone: "danger", chip: "failure" },
-        incompatible: { tone: "danger", chip: "failure" },
-    }),
-    compatibility: presentation({
-        compatible: { tone: "good", chip: "positive" },
-        unknown: { tone: "quiet", chip: "inert" },
-        expired: { tone: "warning", chip: "warning" },
-        incompatible: { tone: "danger", chip: "failure" },
     }),
     overall: presentation({
         ready: { tone: "good", chip: "positive" },
@@ -104,7 +94,6 @@ const guidanceCopyKeys = {
     progress_watch: "progressWatch",
     registry_empty: "registryEmpty",
     registry_rejected: "registryRejected",
-    provider_incompatible: "providerIncompatible",
     generic: "generic",
 };
 const nextActionCopyKeys = {
@@ -115,7 +104,6 @@ const nextActionCopyKeys = {
     repair_claude_inventory: "next.repairClaude",
     register_codex: "next.registerCodex",
     restore_codex: "next.restoreCodex",
-    review_compatibility: "next.reviewCompatibility",
     none: "next.none",
 };
 const attentionCommands = {
@@ -137,7 +125,6 @@ const attentionCommands = {
     progress_watch: "embassy status",
     registry_empty: "embassy refresh-dashboard",
     registry_rejected: "embassy status",
-    provider_incompatible: "embassy refresh-dashboard",
     generic: "embassy status",
 };
 const deliveryMeaningKeys = {
@@ -158,8 +145,8 @@ const deliveryMeaningKeys = {
 /** JSON-safe semantics embedded once in the live dashboard boot payload. */
 export const DASHBOARD_SEMANTICS = Object.freeze({
     statePresentation,
-    deliveryChipByDirection: {
-        delivered: { codex_to_claude: "qualified" },
+    deliveryChipByTargetProvider: {
+        delivered: { claude: "qualified" },
     },
     deliveryChipBySafeErrorCode: {
         rejected: { SENDER_NOT_PAIRED: "inert" },
@@ -175,9 +162,11 @@ export const DASHBOARD_SEMANTICS = Object.freeze({
         codex_succession_recovery: "<old>",
     },
     deliveryMeaningKeys,
-    deliveryMeaningByDirection: {
-        codex_to_claude: "activity.meaning.delivered.codexToClaude",
-        claude_to_codex: "activity.meaning.delivered.claudeToCodex",
+    deliveryMeaningByTargetProvider: {
+        claude: "activity.meaning.delivered.toClaude",
+        codex: "activity.meaning.delivered.toCodex",
+        deepseek: "activity.meaning.delivered.toDeepSeek",
+        grok: "activity.meaning.delivered.toGrok",
     },
     deliveryMeaningBySafeErrorCode: {
         SENDER_NOT_PAIRED: "activity.meaning.senderNotPaired",
@@ -196,14 +185,15 @@ function semanticPresentation(domain, state) {
 export function dashboardChipKind(domain, state, direction, safeErrorCode) {
     if (domain === "delivery") {
         const byCode = DASHBOARD_SEMANTICS.deliveryChipBySafeErrorCode;
-        const byDirection = DASHBOARD_SEMANTICS.deliveryChipByDirection;
+        const byTarget = DASHBOARD_SEMANTICS.deliveryChipByTargetProvider;
         if (safeErrorCode !== undefined) {
             const override = byCode[state]?.[safeErrorCode];
             if (override !== undefined)
                 return override;
         }
         if (direction !== undefined) {
-            const override = byDirection[state]?.[direction];
+            const target = parseDirection(direction)?.targetProvider;
+            const override = target === undefined ? undefined : byTarget[state]?.[target];
             if (override !== undefined)
                 return override;
         }
@@ -224,7 +214,10 @@ export function deliveryMeaningKey(state, direction, safeErrorCode) {
         return DASHBOARD_SEMANTICS.deliveryMeaningBySafeErrorCode.SENDER_NOT_PAIRED;
     }
     if (state === "delivered" && direction !== undefined) {
-        return DASHBOARD_SEMANTICS.deliveryMeaningByDirection[direction];
+        const target = parseDirection(direction)?.targetProvider;
+        if (target !== undefined) {
+            return DASHBOARD_SEMANTICS.deliveryMeaningByTargetProvider[target];
+        }
     }
     if (state === "abandoned" && safeErrorCode !== undefined) {
         const byCode = DASHBOARD_SEMANTICS.deliveryMeaningBySafeErrorCode;
@@ -300,16 +293,14 @@ function normalizedCounters(counters) {
         bytesAccepted: normalizedInteger(counters?.bytesAccepted) ?? 0,
     };
 }
-export function buildDashboardViewModel(snapshot, options = {}) {
-    return buildProjectedDashboardViewModel(snapshot, false, options);
+export function buildDashboardViewModel(snapshot) {
+    return buildProjectedDashboardViewModel(snapshot, false);
 }
-export function buildLiveDashboardViewModel(snapshot, options = {}) {
-    return buildProjectedDashboardViewModel(snapshot, true, options);
+export function buildLiveDashboardViewModel(snapshot) {
+    return buildProjectedDashboardViewModel(snapshot, true);
 }
 function routeIsReady(route) {
     return (route.enabled &&
-        route.safeErrorCode !== "CODEX_WRITES_DISABLED" &&
-        route.compatibility === "compatible" &&
         (route.state === "idle" || route.state === "busy"));
 }
 function peerSelectionGuidance(peer) {
@@ -322,11 +313,6 @@ function peerSelectionGuidance(peer) {
     }
     if (peer.state === "offline")
         return "offline";
-    if (peer.state === "incompatible" ||
-        peer.compatibility !== "compatible" ||
-        peer.safeErrorCode !== undefined) {
-        return "incompatible";
-    }
     return undefined;
 }
 function peerIsSelectable(peer) {
@@ -343,10 +329,10 @@ function partyStatus(routes, ready) {
     return routes.some((route) => route.state === "busy") ? "busy" : "ready";
 }
 function routePriority(route) {
-    if (!route.enabled || route.state === "offline" || route.state === "incompatible") {
+    if (!route.enabled || route.state === "offline") {
         return 0;
     }
-    if (route.state === "stale" || route.compatibility !== "compatible")
+    if (route.state === "stale")
         return 1;
     if (route.state === "awaiting_approval")
         return 2;
@@ -367,8 +353,7 @@ function needsCodexAppReconnect(route, connectors, generatedAt) {
     }
     return connectors.some((connector) => connector.provider === "codex" &&
         connector.host === route.host &&
-        connector.health === "healthy" &&
-        connector.compatibility === "compatible");
+        connector.health === "healthy");
 }
 function alertPriority(severity) {
     return severity === "error" ? 0 : severity === "warning" ? 1 : 2;
@@ -405,14 +390,6 @@ function guidanceFor(code, provider) {
         case "ADAPTER_DEGRADED":
         case "ROUTE_DEGRADED":
             return "degraded";
-        case "CLAUDE_PEER_VERSION_UNSUPPORTED":
-        case "CLAUDE_VERSION_UNPARSEABLE":
-        case "CLAUDE_VERSION_CHECK_FAILED":
-        case "CLAUDE_VERSION_EVIDENCE_CONFLICT":
-        case "CLAUDE_VERSION_EVIDENCE_TOO_LARGE":
-        case "CODEX_APP_SERVER_VERSION_UNSUPPORTED":
-        case "CODEX_APP_SERVER_VERSION_UNPARSEABLE":
-            return "provider_incompatible";
         default:
             return "generic";
     }
@@ -574,35 +551,17 @@ function buildMessageGroups(messages, includeBodies) {
         activeGroups: all.filter((message) => ["queued", "dispatching", "transport_written", "held"].includes(message.state)).length,
     };
 }
-function buildProjectedDashboardViewModel(snapshot, includeBodies, options) {
-    const surfaceDefinitions = options.compatibilitySurfaceDefinitions ?? compatibilitySurfaceDefinitions;
+function buildProjectedDashboardViewModel(snapshot, includeBodies) {
     const generatedAt = normalizedTimestamp(snapshot.generatedAt);
     const inboundMode = snapshot.inboundMode === "open" ? "open" : "paired";
     const validPeers = arePublicAvailablePeerSnapshots(snapshot.availablePeers)
         ? snapshot.availablePeers
         : [];
-    const writesCoveredProviders = new Set((Array.isArray(snapshot.compatibilityChecks)
-        ? snapshot.compatibilityChecks.filter(isPublicCompatibilityCheckSnapshot)
-        : []).filter((check) => check.writesCovered).map((check) => check.surface));
-    const quarantinedProviders = new Set([
-        ...snapshot.connectors
-            .filter((connector) => connector.compatibility === "incompatible")
-            .map((connector) => connector.provider),
-        ...(Array.isArray(snapshot.compatibilityChecks)
-            ? snapshot.compatibilityChecks
-                .filter(isPublicCompatibilityCheckSnapshot)
-                .filter((check) => check.tier === "incompatible")
-                .flatMap((check) => check.surface === "claude" || check.surface === "codex"
-                ? [check.surface]
-                : [])
-            : []),
-    ]);
     const peers = validPeers
         .map((peer) => ({
         alias: boundedText(peer.alias),
         host: boundedText(peer.host),
         state: peer.state,
-        compatibility: peer.compatibility,
         validated: peer.validated,
         selected: peer.selected,
         selectable: peerIsSelectable(peer),
@@ -654,7 +613,6 @@ function buildProjectedDashboardViewModel(snapshot, includeBodies, options) {
             host: boundedText(route.host),
             enabled: Boolean(route.enabled),
             state: route.state,
-            compatibility: route.compatibility,
             queueDepth: depth,
             ...(oldestQueuedAt === undefined ? {} : { oldestQueuedAt }),
             ...(age === undefined ? {} : { queueAgeMs: age }),
@@ -671,33 +629,32 @@ function buildProjectedDashboardViewModel(snapshot, includeBodies, options) {
         .sort((left, right) => routePriority(left) - routePriority(right) ||
         compareText(left.alias, right.alias))
         .slice(0, DASHBOARD_MODEL_LIMITS.routes);
-    const routeByAlias = new Map(allRoutes.map((route) => [route.alias, route]));
-    const allPairs = snapshot.pairs
-        .map((pair) => {
-        const claudeAlias = boundedText(pair.claudeAlias);
-        const codexAlias = boundedText(pair.codexAlias);
-        const claudeRoute = routeByAlias.get(claudeAlias);
-        const codexRoute = routeByAlias.get(codexAlias);
-        const bothPresent = claudeRoute !== undefined && codexRoute !== undefined;
+    const routeByEndpoint = new Map(allRoutes.map((route) => [`${route.provider}\0${route.alias}`, route]));
+    const allConsentEdges = snapshot.consentEdges
+        .map((edge) => {
+        const endpoints = edge.endpoints.map((endpoint) => ({
+            alias: boundedText(endpoint.alias),
+            provider: endpoint.provider,
+        }));
+        const routes = endpoints.map((endpoint) => routeByEndpoint.get(`${endpoint.provider}\0${endpoint.alias}`));
+        const bothPresent = routes.every((route) => route !== undefined);
         return {
-            claudeAlias,
-            codexAlias,
-            host: boundedText(pair.host),
+            endpoints,
+            host: boundedText(edge.host),
             state: bothPresent &&
-                !quarantinedProviders.has("claude") &&
-                !quarantinedProviders.has("codex") &&
-                routeIsReady(claudeRoute) &&
-                routeIsReady(codexRoute)
+                routes.every((route) => route !== undefined && routeIsReady(route))
                 ? "ready"
                 : bothPresent
                     ? "degraded"
                     : "unavailable",
-            counters: normalizedCounters(pair.counters),
+            counters: normalizedCounters(edge.counters),
         };
     })
-        .sort((left, right) => compareText(left.claudeAlias, right.claudeAlias) ||
-        compareText(left.codexAlias, right.codexAlias));
-    const pairs = allPairs.slice(0, DASHBOARD_MODEL_LIMITS.pairs);
+        .sort((left, right) => compareText(left.endpoints[0].provider, right.endpoints[0].provider) ||
+        compareText(left.endpoints[0].alias, right.endpoints[0].alias) ||
+        compareText(left.endpoints[1].provider, right.endpoints[1].provider) ||
+        compareText(left.endpoints[1].alias, right.endpoints[1].alias));
+    const consentEdges = allConsentEdges.slice(0, DASHBOARD_MODEL_LIMITS.consentEdges);
     const allWatches = (snapshot.progressWatches ?? [])
         .flatMap((watch) => {
         const lastActivityAt = normalizedTimestamp(watch.lastActivityAt);
@@ -763,7 +720,6 @@ function buildProjectedDashboardViewModel(snapshot, includeBodies, options) {
             provider: connector.provider,
             host: boundedText(connector.host),
             health: connector.health,
-            compatibility: connector.compatibility,
             ...(safeProtocol(connector.protocol) === undefined
                 ? {}
                 : { protocol: safeProtocol(connector.protocol) }),
@@ -791,38 +747,6 @@ function buildProjectedDashboardViewModel(snapshot, includeBodies, options) {
     })
         .sort((left, right) => compareText(`${left.provider}\0${left.host}`, `${right.provider}\0${right.host}`))
         .slice(0, DASHBOARD_MODEL_LIMITS.connectors);
-    const detectedCompatibilityChecks = (Array.isArray(snapshot.compatibilityChecks)
-        ? snapshot.compatibilityChecks.filter(isPublicCompatibilityCheckSnapshot)
-        : [])
-        .map((attestation) => {
-        const failed = attestation.probes.find((probe) => probe.outcome === "fail");
-        const issue = safeCode(attestation.safeErrorCode);
-        return {
-            surface: attestation.surface,
-            version: boundedText(attestation.version),
-            ...(attestation.testedVersion === undefined
-                ? {}
-                : { testedVersion: boundedText(attestation.testedVersion) }),
-            ...(attestation.supportedMajor === undefined
-                ? {}
-                : { supportedMajor: boundedText(attestation.supportedMajor) }),
-            tier: attestation.tier,
-            writesCovered: attestation.writesCovered,
-            checkedAt: attestation.checkedAt,
-            ...(failed === undefined ? {} : { failure: failed.name }),
-            ...(issue === undefined ? {} : { safeErrorCode: issue }),
-        };
-    })
-        .sort((left, right) => compareText(left.surface, right.surface));
-    const detectedSurfaces = new Set(detectedCompatibilityChecks.map(({ surface }) => surface));
-    const compatibilityChecks = [
-        ...detectedCompatibilityChecks,
-        ...surfaceDefinitions
-            .filter(({ required, surface }) => !required && !detectedSurfaces.has(surface))
-            .map(({ surface }) => ({ surface, notDetected: true })),
-    ]
-        .sort((left, right) => compareText(left.surface, right.surface))
-        .slice(0, surfaceDefinitions.length);
     const messages = buildMessageGroups(snapshot.messages, includeBodies);
     const queuedMessages = allRoutes.reduce((total, route) => boundedAdd(total, route.queueDepth), 0);
     const queuedWithAge = allRoutes
@@ -830,69 +754,109 @@ function buildProjectedDashboardViewModel(snapshot, includeBodies, options) {
         .sort((left, right) => right.queueAgeMs - left.queueAgeMs);
     const oldest = queuedWithAge[0];
     const activeDeliveries = messages.activeGroups;
-    const claudeRoutes = allRoutes.filter((route) => route.provider === "claude");
-    const codexRoutes = allRoutes.filter((route) => route.provider === "codex");
-    const monitorOnlyCodexRoutes = codexRoutes.filter((route) => route.safeErrorCode === "CODEX_WRITES_DISABLED");
-    const routeIsExchangeReady = (route) => !quarantinedProviders.has(route.provider) && routeIsReady(route);
-    const readyClaude = claudeRoutes.filter(routeIsExchangeReady).length;
-    const readyCodex = codexRoutes.filter(routeIsExchangeReady).length;
-    const readyPairs = allPairs.filter((pair) => pair.state === "ready");
-    const pairedClaude = new Set(allPairs.map((pair) => pair.claudeAlias));
-    const pairedCodex = new Set(allPairs.map((pair) => pair.codexAlias));
-    const readyPairedClaude = claudeRoutes.some((route) => routeIsExchangeReady(route) && pairedClaude.has(route.alias));
-    const readyPairedCodex = codexRoutes.some((route) => routeIsExchangeReady(route) && pairedCodex.has(route.alias));
-    const pairCountIsLowerBound = (normalizedInteger(snapshot.truncation.pairs) ?? 0) > 0;
-    const hasPairEvidence = allPairs.length > 0 || pairCountIsLowerBound;
+    const routesByProvider = Object.fromEntries(gatewayProviders.map((provider) => [
+        provider,
+        allRoutes.filter((route) => route.provider === provider),
+    ]));
+    const readyByProvider = Object.fromEntries(gatewayProviders.map((provider) => [
+        provider,
+        routesByProvider[provider].filter(routeIsReady).length,
+    ]));
+    const pairedAliasesByProvider = Object.fromEntries(gatewayProviders.map((provider) => [provider, new Set()]));
+    for (const edge of allConsentEdges) {
+        for (const endpoint of edge.endpoints) {
+            pairedAliasesByProvider[endpoint.provider].add(endpoint.alias);
+        }
+    }
+    const readyConsentEdges = allConsentEdges.filter((edge) => edge.state === "ready");
+    const consentEdgeCountIsLowerBound = (normalizedInteger(snapshot.truncation.consentEdges) ?? 0) > 0;
+    const hasConsentEvidence = allConsentEdges.length > 0 || consentEdgeCountIsLowerBound;
     const graph = {
-        pairCount: allPairs.length,
-        readyPairCount: readyPairs.length,
-        pairCountIsLowerBound,
-        unpairedReadyClaude: claudeRoutes.filter((route) => routeIsExchangeReady(route) && !pairedClaude.has(route.alias)).length,
-        unpairedReadyCodex: codexRoutes.filter((route) => routeIsExchangeReady(route) && !pairedCodex.has(route.alias)).length,
+        consentEdgeCount: allConsentEdges.length,
+        readyConsentEdgeCount: readyConsentEdges.length,
+        consentEdgeCountIsLowerBound,
+        unpairedReadyByProvider: Object.fromEntries(gatewayProviders.map((provider) => [
+            provider,
+            routesByProvider[provider].filter((route) => routeIsReady(route) &&
+                !pairedAliasesByProvider[provider].has(route.alias)).length,
+        ])),
     };
     const selectedPeers = validPeers.filter((peer) => peer.selected && peerIsSelectable(peer));
     const selectablePeers = validPeers.filter(peerIsSelectable);
-    const selectedClaudeCount = quarantinedProviders.has("claude")
-        ? 0
-        : Math.max(selectedPeers.length, readyClaude);
-    const claudeStatus = partyStatus(claudeRoutes, readyClaude);
-    const codexStatus = partyStatus(codexRoutes, readyCodex);
-    const claudeNextAction = quarantinedProviders.has("claude")
-        ? "review_compatibility"
-        : selectedClaudeCount > 0 &&
-            (readyPairedClaude || (pairCountIsLowerBound && readyClaude > 0))
-            ? "none"
-            : readyClaude > 0
-                ? "pair_routes"
-                : validPeers.length === 0
-                    ? "discover_claude"
-                    : selectablePeers.length > 0
-                        ? !hasPairEvidence
-                            ? "pair_routes"
-                            : "restore_claude"
-                        : selectedPeers.length > 0
-                            ? "restore_claude"
-                            : "repair_claude_inventory";
-    const codexNextAction = quarantinedProviders.has("codex") || monitorOnlyCodexRoutes.length > 0
-        ? "review_compatibility"
-        : readyPairedCodex || (pairCountIsLowerBound && readyCodex > 0)
-            ? "none"
-            : readyCodex > 0
-                ? "pair_routes"
-                : codexRoutes.length === 0
-                    ? "register_codex"
-                    : "restore_codex";
+    const selectedClaudeCount = Math.max(selectedPeers.filter((peer) => peer.provider === "claude").length, readyByProvider.claude);
+    const readyPairedByProvider = Object.fromEntries(gatewayProviders.map((provider) => [
+        provider,
+        routesByProvider[provider].some((route) => routeIsReady(route) &&
+            pairedAliasesByProvider[provider].has(route.alias)),
+    ]));
+    const claudeNextAction = selectedClaudeCount > 0 &&
+        (readyPairedByProvider.claude ||
+            (consentEdgeCountIsLowerBound && readyByProvider.claude > 0))
+        ? "none"
+        : readyByProvider.claude > 0
+            ? "pair_routes"
+            : validPeers.length === 0
+                ? "discover_claude"
+                : selectablePeers.length > 0
+                    ? !hasConsentEvidence
+                        ? "pair_routes"
+                        : "restore_claude"
+                    : selectedPeers.length > 0
+                        ? "restore_claude"
+                        : "repair_claude_inventory";
+    const codexNextAction = readyPairedByProvider.codex ||
+        (consentEdgeCountIsLowerBound && readyByProvider.codex > 0)
+        ? "none"
+        : readyByProvider.codex > 0
+            ? "pair_routes"
+            : routesByProvider.codex.length === 0
+                ? "register_codex"
+                : "restore_codex";
+    const parties = gatewayProviders.map((provider) => {
+        const providerPeers = validPeers.filter((peer) => peer.provider === provider);
+        const providerRoutes = routesByProvider[provider];
+        const ready = provider === "claude"
+            ? selectedClaudeCount
+            : readyByProvider[provider];
+        const nextAction = provider === "claude"
+            ? claudeNextAction
+            : provider === "codex"
+                ? codexNextAction
+                : readyPairedByProvider[provider]
+                    ? "none"
+                    : ready > 0
+                        ? "pair_routes"
+                        : "none";
+        return {
+            kind: provider,
+            status: provider === "claude" && ready > 0 && partyStatus(providerRoutes, ready) === "missing"
+                ? "attention"
+                : partyStatus(providerRoutes, ready),
+            total: provider === "claude" ? providerPeers.length : providerRoutes.length,
+            ready,
+            ...(provider === "claude"
+                ? { selectable: selectablePeers.filter((peer) => peer.provider === provider).length }
+                : {}),
+            countIsLowerBound: (normalizedInteger(snapshot.truncation.routes) ?? 0) > 0 ||
+                (provider === "claude" &&
+                    (normalizedInteger(snapshot.truncation.availablePeers) ?? 0) > 0),
+            ...(providerPeers.find((peer) => peer.selected)?.alias === undefined
+                ? providerRoutes[0]?.alias === undefined
+                    ? {}
+                    : { primaryAlias: boundedText(providerRoutes[0].alias) }
+                : { primaryAlias: boundedText(providerPeers.find((peer) => peer.selected).alias) }),
+            nextAction,
+        };
+    });
     const explicitAlerts = coalesceCodexReactivationAlerts(snapshot.alerts
-        .filter((alert) => alert.code !== "COMPATIBILITY_CERTIFICATION_FAILED")
         .map((alert) => {
         const code = safeCode(alert.code);
-        const providerWritesCovered = (alert.provider === "claude" || alert.provider === "codex") &&
-            writesCoveredProviders.has(alert.provider);
-        const route = code === "QUEUE_STALLED" && typeof alert.alias === "string"
-            ? routeByAlias.get(alert.alias)
+        const route = code === "QUEUE_STALLED" && typeof alert.alias === "string" &&
+            alert.provider !== undefined
+            ? routeByEndpoint.get(`${alert.provider}\0${alert.alias}`)
             : undefined;
-        const alertRoute = typeof alert.alias === "string"
-            ? routeByAlias.get(alert.alias)
+        const alertRoute = typeof alert.alias === "string" && alert.provider !== undefined
+            ? routeByEndpoint.get(`${alert.provider}\0${alert.alias}`)
             : undefined;
         return {
             kind: "alert",
@@ -905,9 +869,7 @@ function buildProjectedDashboardViewModel(snapshot, includeBodies, options) {
             ...(normalizedTimestamp(alert.timestamp) === undefined
                 ? {}
                 : { timestamp: normalizedTimestamp(alert.timestamp) }),
-            ...(alert.provider === "claude" || alert.provider === "codex"
-                ? { provider: alert.provider }
-                : {}),
+            ...(alert.provider === undefined ? {} : { provider: alert.provider }),
             ...(typeof alert.alias === "string"
                 ? { alias: boundedText(alert.alias) }
                 : {}),
@@ -926,29 +888,19 @@ function buildProjectedDashboardViewModel(snapshot, includeBodies, options) {
             guidance: alertRoute !== undefined &&
                 needsCodexAppReconnect(alertRoute, connectors, generatedAt)
                 ? "codex_app_reconnect_required"
-                : !providerWritesCovered &&
-                    alert.provider !== undefined &&
-                    quarantinedProviders.has(alert.provider)
-                    ? "provider_incompatible"
-                    : providerWritesCovered &&
-                        guidanceFor(code, alert.provider) === "provider_incompatible"
-                        ? "degraded"
-                        : guidanceFor(code, alert.provider),
+                : guidanceFor(code, alert.provider),
         };
     }), allRoutes).sort((left, right) => alertPriority(left.severity) - alertPriority(right.severity) ||
         compareText(right.timestamp ?? "", left.timestamp ?? ""));
     const attentionCandidates = [...explicitAlerts];
     const unavailableConsentEdgeScopes = new Set();
-    for (const pair of allPairs) {
-        if (pair.state !== "unavailable")
+    for (const edge of allConsentEdges) {
+        if (edge.state !== "unavailable")
             continue;
-        for (const endpoint of [
-            { provider: "claude", alias: pair.claudeAlias },
-            { provider: "codex", alias: pair.codexAlias },
-        ]) {
-            if (routeByAlias.has(endpoint.alias))
+        for (const endpoint of edge.endpoints) {
+            if (routeByEndpoint.has(`${endpoint.provider}\0${endpoint.alias}`))
                 continue;
-            const scope = `${endpoint.provider}\0${endpoint.alias}\0${pair.host}`;
+            const scope = `${endpoint.provider}\0${endpoint.alias}\0${edge.host}`;
             if (unavailableConsentEdgeScopes.has(scope))
                 continue;
             unavailableConsentEdgeScopes.add(scope);
@@ -957,13 +909,13 @@ function buildProjectedDashboardViewModel(snapshot, includeBodies, options) {
                 severity: "warning",
                 provider: endpoint.provider,
                 alias: endpoint.alias,
-                host: pair.host,
+                host: edge.host,
                 guidance: "consent_edge_unavailable",
             });
         }
     }
     for (const route of allRoutes) {
-        const writes = messages.groups.filter(({ direction, targetAlias, state, timestamp }) => direction === "codex_to_claude" &&
+        const writes = messages.groups.filter(({ direction, targetAlias, state, timestamp }) => parseDirection(direction)?.targetProvider === "claude" &&
             targetAlias === route.alias && state === "delivered" &&
             timestamp !== undefined);
         // Groups arrive newest-first. The oldest unconsumed write owns the notice:
@@ -1008,9 +960,7 @@ function buildProjectedDashboardViewModel(snapshot, includeBodies, options) {
     }
     const representedScopes = new Set(attentionCandidates.map((item) => `${item.provider ?? ""}\0${item.alias ?? ""}\0${item.host ?? ""}`));
     for (const route of allRoutes) {
-        if (routeIsReady(route) ||
-            quarantinedProviders.has(route.provider) ||
-            route.safeErrorCode === "CODEX_WRITES_DISABLED") {
+        if (routeIsReady(route)) {
             continue;
         }
         const scope = `${route.provider}\0${route.alias}\0${route.host}`;
@@ -1019,9 +969,7 @@ function buildProjectedDashboardViewModel(snapshot, includeBodies, options) {
         attentionCandidates.push({
             kind: "route",
             ...(route.safeErrorCode === undefined ? {} : { code: route.safeErrorCode }),
-            severity: route.state === "offline" || route.state === "incompatible"
-                ? "error"
-                : "warning",
+            severity: route.state === "offline" ? "error" : "warning",
             ...(route.lastSeenAt === undefined ? {} : { timestamp: route.lastSeenAt }),
             provider: route.provider,
             alias: route.alias,
@@ -1039,10 +987,8 @@ function buildProjectedDashboardViewModel(snapshot, includeBodies, options) {
         representedScopes.add(scope);
     }
     for (const connector of connectors) {
-        if ((connector.health === "healthy" &&
-            connector.compatibility === "compatible")) {
+        if (connector.health === "healthy")
             continue;
-        }
         const scope = `${connector.provider}\0\0${connector.host}`;
         if (representedScopes.has(scope))
             continue;
@@ -1059,17 +1005,7 @@ function buildProjectedDashboardViewModel(snapshot, includeBodies, options) {
             host: connector.host,
             guidance: connector.health === "offline"
                 ? "connector_offline"
-                : !writesCoveredProviders.has(connector.provider) &&
-                    (quarantinedProviders.has(connector.provider) ||
-                        connector.safeErrorCode === "CLAUDE_PEER_VERSION_UNSUPPORTED" ||
-                        connector.safeErrorCode === "CLAUDE_VERSION_UNPARSEABLE" ||
-                        connector.safeErrorCode === "CLAUDE_VERSION_CHECK_FAILED" ||
-                        connector.safeErrorCode === "CLAUDE_VERSION_EVIDENCE_CONFLICT" ||
-                        connector.safeErrorCode === "CLAUDE_VERSION_EVIDENCE_TOO_LARGE" ||
-                        connector.safeErrorCode === "CODEX_APP_SERVER_VERSION_UNSUPPORTED" ||
-                        connector.safeErrorCode === "CODEX_APP_SERVER_VERSION_UNPARSEABLE")
-                    ? "provider_incompatible"
-                    : "degraded",
+                : "degraded",
         });
         representedScopes.add(scope);
     }
@@ -1112,10 +1048,7 @@ function buildProjectedDashboardViewModel(snapshot, includeBodies, options) {
             guidance: "registry_empty",
         });
     }
-    if ((snapshot.health === "degraded" ||
-        snapshot.health === "offline" ||
-        snapshot.health === "incompatible") &&
-        !(snapshot.health === "degraded" && quarantinedProviders.size > 0) &&
+    if ((snapshot.health === "degraded" || snapshot.health === "offline") &&
         !attentionCandidates.some((item) => item.kind === "broker")) {
         attentionCandidates.push({
             kind: "broker",
@@ -1124,11 +1057,11 @@ function buildProjectedDashboardViewModel(snapshot, includeBodies, options) {
         });
     }
     const attention = attentionCandidates.slice(0, DASHBOARD_MODEL_LIMITS.alerts);
-    const setupComplete = hasPairEvidence;
-    const hasDegradedPair = allPairs.some((pair) => pair.state !== "ready");
+    const setupComplete = hasConsentEvidence;
+    const hasDegradedConsentEdge = allConsentEdges.some((edge) => edge.state !== "ready");
     const overall = attentionCandidates.length > 0 ||
         (normalizedInteger(snapshot.truncation.alerts) ?? 0) > 0 ||
-        hasDegradedPair
+        hasDegradedConsentEdge
         ? "attention"
         : setupComplete
             ? "ready"
@@ -1137,7 +1070,7 @@ function buildProjectedDashboardViewModel(snapshot, includeBodies, options) {
         connectors: boundedAdd(normalizedInteger(snapshot.truncation.connectors) ?? 0, Math.max(0, snapshot.connectors.length - DASHBOARD_MODEL_LIMITS.connectors)),
         availablePeers: boundedAdd(normalizedInteger(snapshot.truncation.availablePeers) ?? 0, Math.max(0, validPeers.length - DASHBOARD_MODEL_LIMITS.availablePeers)),
         routes: boundedAdd(normalizedInteger(snapshot.truncation.routes) ?? 0, Math.max(0, allRoutes.length - DASHBOARD_MODEL_LIMITS.routes)),
-        pairs: boundedAdd(normalizedInteger(snapshot.truncation.pairs) ?? 0, Math.max(0, allPairs.length - DASHBOARD_MODEL_LIMITS.pairs)),
+        consentEdges: boundedAdd(normalizedInteger(snapshot.truncation.consentEdges) ?? 0, Math.max(0, allConsentEdges.length - DASHBOARD_MODEL_LIMITS.consentEdges)),
         progressWatches: boundedAdd(normalizedInteger(snapshot.truncation.progressWatches) ?? 0, Math.max(0, allWatches.length - DASHBOARD_MODEL_LIMITS.progressWatches)),
         upstreamProgressWatchEvents: normalizedInteger(snapshot.truncation.progressWatchEvents) ?? 0,
         progressWatchEvents: Math.max(0, allWatchEvents.length - DASHBOARD_MODEL_LIMITS.progressWatchEvents),
@@ -1150,43 +1083,13 @@ function buildProjectedDashboardViewModel(snapshot, includeBodies, options) {
         activityEvents: Math.max(0, allBrokerActivity.length - DASHBOARD_MODEL_LIMITS.activityEvents),
     };
     return {
-        schemaVersion: 1,
+        schemaVersion: 2,
         ...(generatedAt === undefined ? {} : { generatedAt }),
         inboundMode,
         health: snapshot.health,
         overall,
         exchange: {
-            claude: {
-                kind: "claude",
-                status: selectedClaudeCount > 0 && claudeStatus === "missing"
-                    ? "attention"
-                    : claudeStatus,
-                total: validPeers.length,
-                ready: selectedClaudeCount,
-                selectable: selectablePeers.length,
-                countIsLowerBound: (normalizedInteger(snapshot.truncation.availablePeers) ?? 0) > 0 ||
-                    (normalizedInteger(snapshot.truncation.routes) ?? 0) > 0,
-                ...(selectedPeers[0]?.alias === undefined
-                    ? claudeRoutes[0]?.alias === undefined
-                        ? {}
-                        : { primaryAlias: boundedText(claudeRoutes[0].alias) }
-                    : { primaryAlias: boundedText(selectedPeers[0].alias) }),
-                nextAction: claudeNextAction,
-            },
-            codex: {
-                kind: "codex",
-                status: codexStatus,
-                total: codexRoutes.length,
-                ready: readyCodex,
-                ...(monitorOnlyCodexRoutes.length === 0
-                    ? {}
-                    : { monitorOnly: monitorOnlyCodexRoutes.length }),
-                countIsLowerBound: (normalizedInteger(snapshot.truncation.routes) ?? 0) > 0,
-                ...(codexRoutes[0]?.alias === undefined
-                    ? {}
-                    : { primaryAlias: codexRoutes[0].alias }),
-                nextAction: codexNextAction,
-            },
+            parties,
             queuedMessages,
             queueCountIsLowerBound: (normalizedInteger(snapshot.truncation.routes) ?? 0) > 0,
             ...(oldest === undefined
@@ -1213,12 +1116,11 @@ function buildProjectedDashboardViewModel(snapshot, includeBodies, options) {
         brokerActivity,
         peers,
         routes,
-        pairs,
+        consentEdges,
         watches,
         watchEvents,
         graph,
         connectors,
-        compatibilityChecks,
         accounting: {
             accepted: normalizedInteger(snapshot.accounting.accepted) ?? 0,
             duplicates: normalizedInteger(snapshot.accounting.duplicates) ?? 0,