agent-embassy 1.6.1 → 1.7.1

package/dist/src/gateway/live-dashboard-app/app.js

@@ -111,7 +111,9 @@ var Embassy;
     function chipKindFor(state, direction, safeErrorCode) {
         const semantics = window.EMBASSY_BOOT.semantics;
         return (deliveryOverride(semantics.deliveryChipBySafeErrorCode, state, safeErrorCode) ??
-            deliveryOverride(semantics.deliveryChipByDirection, state, direction) ??
+            deliveryOverride(semantics.deliveryChipByTargetProvider, state, direction === undefined
+                ? undefined
+                : Embassy.parseDirection(direction)?.targetProvider) ??
             presentation("delivery", state));
     }
     Embassy.chipKindFor = chipKindFor;
@@ -127,10 +129,6 @@ var Embassy;
         return presentation("health", state);
     }
     Embassy.healthChipKind = healthChipKind;
-    function compatibilityChipKind(state) {
-        return presentation("compatibility", state);
-    }
-    Embassy.compatibilityChipKind = compatibilityChipKind;
     function overallChipKind(state) {
         return presentation("overall", state);
     }
@@ -163,7 +161,10 @@ var Embassy;
             return semantics.deliveryMeaningBySafeErrorCode.SENDER_NOT_PAIRED;
         }
         if (state === "delivered" && direction !== undefined) {
-            return semantics.deliveryMeaningByDirection[direction];
+            const target = Embassy.parseDirection(direction)?.targetProvider;
+            if (target !== undefined) {
+                return semantics.deliveryMeaningByTargetProvider[target];
+            }
         }
         if (state === "abandoned" && safeErrorCode !== undefined) {
             const byCode = semantics.deliveryMeaningBySafeErrorCode;
@@ -185,8 +186,6 @@ var Embassy;
                 return `peer.meaning.${camelCaseToken(state)}`;
             case "health":
                 return `health.meaning.${camelCaseToken(state)}`;
-            case "compatibility":
-                return `compatibility.meaning.${camelCaseToken(state)}`;
             case "overall":
                 return `overall.${camelCaseToken(state)}`;
             case "party":
@@ -244,6 +243,24 @@ var Embassy;
 })(Embassy || (Embassy = {}));
 var Embassy;
 (function (Embassy) {
+    Embassy.GATEWAY_PROVIDERS = ["claude", "codex", "deepseek", "grok"];
+    function parseDirection(direction) {
+        const separator = direction.indexOf("_to_");
+        if (separator < 1 || separator !== direction.lastIndexOf("_to_")) {
+            return undefined;
+        }
+        const sourceProvider = direction.slice(0, separator);
+        const targetProvider = direction.slice(separator + 4);
+        const providers = Embassy.GATEWAY_PROVIDERS;
+        if (sourceProvider === targetProvider || !providers.includes(sourceProvider) ||
+            !providers.includes(targetProvider))
+            return undefined;
+        return {
+            sourceProvider: sourceProvider,
+            targetProvider: targetProvider,
+        };
+    }
+    Embassy.parseDirection = parseDirection;
     Embassy.TERMINAL_DELIVERY_STATES = [
         "delivered",
         "unconfirmed",
@@ -258,17 +275,10 @@ var Embassy;
     Embassy.PULSE_WINDOW_MS = 3_600_000;
     const HEALTH_WORST_FIRST = [
         "offline",
-        "incompatible",
         "degraded",
         "connecting",
         "healthy",
     ];
-    const COMPATIBILITY_WORST_FIRST = [
-        "incompatible",
-        "expired",
-        "unknown",
-        "compatible",
-    ];
     function compareText(left, right) {
         return left < right ? -1 : left > right ? 1 : 0;
     }
@@ -334,18 +344,6 @@ var Embassy;
         return worst;
     }
     Embassy.worstConnectorHealth = worstConnectorHealth;
-    function worstCompatibility(model) {
-        let worst;
-        for (const connector of model.connectors) {
-            if (worst === undefined ||
-                COMPATIBILITY_WORST_FIRST.indexOf(connector.compatibility) <
-                    COMPATIBILITY_WORST_FIRST.indexOf(worst)) {
-                worst = connector.compatibility;
-            }
-        }
-        return worst;
-    }
-    Embassy.worstCompatibility = worstCompatibility;
     function pulse(model) {
         const generatedMs = parseTimestampMs(model.generatedAt);
         const cutoffMs = generatedMs === undefined ? undefined : generatedMs - Embassy.PULSE_WINDOW_MS;
@@ -369,10 +367,6 @@ var Embassy;
         };
     }
     Embassy.pulse = pulse;
-    function isMonitorOnly(route) {
-        return route.safeErrorCode === "CODEX_WRITES_DISABLED";
-    }
-    Embassy.isMonitorOnly = isMonitorOnly;
     function hasLifecycleTruncation(group) {
         for (let index = 1; index < group.events.length; index += 1) {
             const previous = group.events[index - 1];
@@ -436,24 +430,22 @@ var Embassy;
     }
     Embassy.extractSuccessions = extractSuccessions;
     function overviewProps(model, nowMs) {
-        const nonReadyPairCount = model.graph.pairCount - model.graph.readyPairCount;
+        const nonReadyConsentEdgeCount = model.graph.consentEdgeCount - model.graph.readyConsentEdgeCount;
         return {
             generatedAt: model.generatedAt,
             inboundMode: model.inboundMode,
             overall: model.overall,
             statusStrip: {
                 broker: model.health,
-                claudeConnector: worstConnectorHealth(model, "claude"),
-                codexConnector: worstConnectorHealth(model, "codex"),
-                compatibility: worstCompatibility(model),
+                providers: Embassy.GATEWAY_PROVIDERS.map((provider) => ({ provider, health: worstConnectorHealth(model, provider) })),
             },
             exchange: model.exchange,
-            queueClaudeToCodex: queueSplit(model, "codex", nowMs),
-            queueCodexToClaude: queueSplit(model, "claude", nowMs),
+            providerQueues: Embassy.GATEWAY_PROVIDERS.map((provider) => ({ provider, queue: queueSplit(model, provider, nowMs) })),
             graph: model.graph,
-            degradedPairCopyKey: nonReadyPairCount <= 0
+            degradedConsentEdgeCopyKey: nonReadyConsentEdgeCount <= 0
                 ? undefined
-                : nonReadyPairCount === 1 && !model.graph.pairCountIsLowerBound
+                : nonReadyConsentEdgeCount === 1 &&
+                    !model.graph.consentEdgeCountIsLowerBound
                     ? "app.overview.degradedEdge"
                     : "app.overview.degradedEdges",
             attention: attentionViews(model),
@@ -463,30 +455,40 @@ var Embassy;
     }
     Embassy.overviewProps = overviewProps;
     function deliveriesGroups(model) {
-        return model.activity.map((group) => ({
-            key: deliveryGroupKey(group),
-            group,
-            routePair: `${group.sourceAlias} → ${group.targetAlias}`,
-            eventsTruncated: hasLifecycleTruncation(group),
-        }));
+        return model.activity.map((group) => {
+            const parsed = parseDirection(group.direction);
+            if (parsed === undefined)
+                throw new Error("INVALID_MESSAGE_DIRECTION");
+            return {
+                key: deliveryGroupKey(group),
+                group,
+                routePair: `${group.sourceAlias} → ${group.targetAlias}`,
+                sourceProvider: parsed.sourceProvider,
+                targetProvider: parsed.targetProvider,
+                eventsTruncated: hasLifecycleTruncation(group),
+            };
+        });
     }
     Embassy.deliveriesGroups = deliveriesGroups;
+    function matchesProviderFilters(view, from, to) {
+        const parsed = parseDirection(view.group.direction);
+        return parsed !== undefined && (from === "all" || parsed.sourceProvider === from) &&
+            (to === "all" || parsed.targetProvider === to);
+    }
+    Embassy.matchesProviderFilters = matchesProviderFilters;
     function routesProps(model, nowMs) {
-        const codexRoutes = model.routes
-            .filter((route) => route.provider === "codex")
-            .map((route) => ({
+        const routes = model.routes.map((route) => ({
             route,
-            monitorOnly: isMonitorOnly(route),
             oldestAgeMs: routeOldestAgeMs(route, nowMs),
         }));
         return {
             inboundMode: model.inboundMode,
             peers: model.peers,
             peersOmitted: model.omissions.availablePeers,
-            codexRoutes,
+            routes,
             routesOmitted: model.omissions.routes,
-            pairs: model.pairs,
-            pairsOmitted: model.omissions.pairs,
+            consentEdges: model.consentEdges,
+            consentEdgesOmitted: model.omissions.consentEdges,
             graph: model.graph,
             successions: extractSuccessions(model),
         };
@@ -527,7 +529,6 @@ var Embassy;
         return {
             connectors: model.connectors,
             connectorsOmitted: model.omissions.connectors,
-            compatibilityChecks: model.compatibilityChecks ?? [],
             expiredCount: model.accounting.expired,
             ...(model.deadlinePressure === undefined
                 ? {}
@@ -542,6 +543,7 @@ var Embassy;
     Embassy.adapter = {
         overviewProps,
         deliveriesGroups,
+        matchesProviderFilters,
         routesProps,
         activityRows,
         diagnosticsProps,
@@ -549,9 +551,7 @@ var Embassy;
         routeOldestAgeMs,
         pulse,
         worstConnectorHealth,
-        worstCompatibility,
         extractSuccessions,
-        isMonitorOnly,
         hasLifecycleTruncation,
         deliveriesTruncated,
         deliveryGroupKey,
@@ -935,14 +935,6 @@ var Embassy;
         }
         return (React.createElement(StatusCard, { label: props.label, detail: t(`health.meaning.${Embassy.camelCaseToken(health)}`), chip: React.createElement(Embassy.StateChip, { domain: "health", state: health, small: true }) }));
     }
-    function CompatStatusCard(props) {
-        const t = Embassy.useT();
-        const compatibility = props.compatibility;
-        if (compatibility === undefined) {
-            return (React.createElement(StatusCard, { label: t("app.overview.compat"), detail: undefined, chip: React.createElement("span", { className: "chip chip--small", "data-kind": "inert" }, t("app.overview.connectorMissing")) }));
-        }
-        return (React.createElement(StatusCard, { label: t("app.overview.compat"), detail: t(`compatibility.meaning.${Embassy.camelCaseToken(compatibility)}`), chip: React.createElement(Embassy.StateChip, { domain: "compatibility", state: compatibility, small: true }) }));
-    }
     function ExchangeNode(props) {
         const party = props.party;
         return (React.createElement("div", { className: "exchange-node" },
@@ -980,7 +972,7 @@ var Embassy;
     function attentionScopeParts(item, t) {
         const parts = [];
         if (item.provider !== undefined) {
-            parts.push(item.provider === "claude" ? t("provider.claude") : t("provider.codex"));
+            parts.push(t(`provider.${item.provider}`));
         }
         if (item.alias !== undefined)
             parts.push(item.alias);
@@ -1032,25 +1024,9 @@ var Embassy;
     function OverviewTab(props) {
         const t = Embassy.useT();
         const { data, onViewDeliveries } = props;
-        const strip = data.statusStrip;
-        const queueOut = data.queueClaudeToCodex;
-        const queueIn = data.queueCodexToClaude;
         const openInbound = data.inboundMode === "open";
-        const hasPair = data.graph.pairCount > 0 || data.graph.pairCountIsLowerBound;
-        const showEdges = hasPair || queueOut.depth > 0 || queueIn.depth > 0;
-        const nextActionLine = (who, action) => action === "none"
-            ? null
-            : `${t("next.label")} · ${who}: ${t(window.EMBASSY_BOOT.semantics.nextActionCopyKeys[action])}`;
-        const boardNotes = [
-            !openInbound && !hasPair && showEdges
-                ? `${t("app.overview.noPair.title")} — ${t("app.overview.noPair.body")}`
-                : null,
-            data.degradedPairCopyKey === undefined
-                ? null
-                : t(data.degradedPairCopyKey),
-            nextActionLine(t("provider.claude"), data.exchange.claude.nextAction),
-            nextActionLine(t("provider.codex"), data.exchange.codex.nextAction),
-        ].filter((line) => line !== null);
+        const hasConsentEdge = data.graph.consentEdgeCount > 0 ||
+            data.graph.consentEdgeCountIsLowerBound;
         const showAttention = data.attention.length > 0 || data.attentionOmitted > 0;
         const maxPulse = data.pulse.bars.reduce((largest, bar) => Math.max(largest, bar.count), 1);
         const selectPulseState = React.useCallback((state) => {
@@ -1065,10 +1041,8 @@ var Embassy;
             React.createElement("section", { className: "section", "aria-labelledby": stripId },
                 React.createElement("h2", { className: "mono-label section-label", id: stripId }, t("app.overview.statusStrip")),
                 React.createElement("div", { className: "status-strip" },
-                    React.createElement(HealthStatusCard, { label: t("app.overview.broker"), health: strip.broker }),
-                    React.createElement(HealthStatusCard, { label: t("app.overview.claudeConn"), health: strip.claudeConnector }),
-                    React.createElement(HealthStatusCard, { label: t("app.overview.codexConn"), health: strip.codexConnector }),
-                    React.createElement(CompatStatusCard, { compatibility: strip.compatibility }))),
+                    React.createElement(HealthStatusCard, { label: t("app.overview.broker"), health: data.statusStrip.broker }),
+                    data.statusStrip.providers.map(({ provider, health }) => (React.createElement(HealthStatusCard, { key: provider, label: t(`provider.${provider}`), health: health }))))),
             React.createElement("section", { className: "section", "aria-labelledby": exchangeId },
                 React.createElement("div", { className: "row section-label section-head" },
                     React.createElement("h2", { className: "mono-label", id: exchangeId }, t("exchange.eyebrow")),
@@ -1080,30 +1054,12 @@ var Embassy;
                         : "inbound.paired.badge")),
                     React.createElement("p", null, t(openInbound
                         ? "inbound.open.body"
-                        : hasPair
+                        : hasConsentEdge
                             ? "inbound.paired.body"
                             : "inbound.noPair.body"))),
-                React.createElement("div", { className: "exchange-board" },
-                    React.createElement(ExchangeNode, { title: t("app.overview.node.claude.title"), sub: t("app.overview.node.claude.sub"), party: data.exchange.claude, countLine: t("exchange.count.claude", {
-                            ready: data.exchange.claude.ready,
-                            selectable: data.exchange.claude.selectable ?? "—",
-                            total: data.exchange.claude.total,
-                        }) }),
-                    showEdges ? (React.createElement("div", { className: "exchange-edges" },
-                        React.createElement(ExchangeEdge, { direction: "out", label: t("app.overview.queueC2x"), queue: queueOut }),
-                        React.createElement(ExchangeEdge, { direction: "in", label: t("app.overview.queueX2c"), queue: queueIn }))) : (React.createElement("div", { className: "no-pair" },
-                        React.createElement("span", { className: "no-pair__label" }, t(openInbound
-                            ? "inbound.open.badge"
-                            : "app.overview.noPair.title")),
-                        React.createElement("span", { className: "no-pair__body" }, t(openInbound
-                            ? "inbound.open.body"
-                            : "app.overview.noPair.body")))),
-                    React.createElement(ExchangeNode, { title: t("app.overview.node.codex.title"), sub: t("app.overview.node.codex.sub"), party: data.exchange.codex, countLine: t("app.overview.count.codex", {
-                            ready: data.exchange.codex.ready,
-                            total: data.exchange.codex.total,
-                            monitorOnly: data.exchange.codex.monitorOnly ?? 0,
-                        }) })),
-                boardNotes.length === 0 ? null : (React.createElement("div", { className: "exchange-notes stack-sm" }, boardNotes.map((line) => (React.createElement("p", { className: "text-xs text-body-muted", key: line }, line)))))),
+                React.createElement("div", { className: "exchange-board" }, data.exchange.parties.map((party) => (React.createElement(ExchangeNode, { key: party.kind, title: t(`provider.${party.kind}`), sub: party.kind, party: party, countLine: `${party.ready}/${party.total}` })))),
+                React.createElement("div", { className: "exchange-edges" }, data.providerQueues.map(({ provider, queue }) => (React.createElement(ExchangeEdge, { key: provider, direction: "in", label: t(`provider.${provider}`), queue: queue })))),
+                data.degradedConsentEdgeCopyKey === undefined ? null : (React.createElement("p", { className: "text-xs text-body-muted" }, t(data.degradedConsentEdgeCopyKey)))),
             showAttention ? (React.createElement("section", { className: "section", "aria-labelledby": attentionId },
                 React.createElement("div", { className: "row section-label section-head" },
                     React.createElement("h2", { className: "mono-label", id: attentionId }, t("attention.eyebrow")),
@@ -1139,18 +1095,6 @@ var Embassy;
         "abandoned",
     ];
     const DELIVERY_STATE_FILTERS_COVER_THE_UNION = true;
-    const DIRECTION_FILTERS = [
-        "claude_to_codex",
-        "codex_to_claude",
-    ];
-    const DIRECTION_COPY_KEYS = {
-        claude_to_codex: "direction.claudeToCodex",
-        codex_to_claude: "direction.codexToClaude",
-    };
-    const DIRECTION_PILL_COPY_KEYS = {
-        claude_to_codex: "direction.claudeToCodex",
-        codex_to_claude: "app.deliveries.dir.codexToClaude",
-    };
     const SEND_TO_CODEX_CMD = "embassy send-to-codex --from <alias> --to <alias>";
     const countFormatters = new Map();
     function fmtCount(locale, value) {
@@ -1273,7 +1217,9 @@ var Embassy;
                 React.createElement("div", { className: "detail-pane__sub" },
                     props.view.routePair,
                     " \u00B7 ",
-                    t(DIRECTION_COPY_KEYS[group.direction]))),
+                    t(`provider.${props.view.sourceProvider}`),
+                    " \u2192 ",
+                    t(`provider.${props.view.targetProvider}`))),
             React.createElement("div", null,
                 React.createElement(Embassy.MonoLabel, { className: "section-label section-label--lifecycle" }, t("app.deliveries.lifecycle")),
                 React.createElement(DeliveryLifecycle, { group: group }),
@@ -1326,8 +1272,6 @@ var Embassy;
         pair_removed: "watches.reason.pairRemoved",
         endpoint_retired: "watches.reason.endpointRetired",
         tracking_disabled: "watches.reason.trackingDisabled",
-        legacy_upgrade: "watches.reason.legacyUpgrade",
-        legacy_done: "watches.reason.legacyDone",
     };
     function ProgressWatchRegister(props) {
         const t = Embassy.useT();
@@ -1385,7 +1329,8 @@ var Embassy;
         const [locale] = Embassy.useLocale();
         const captionId = React.useId();
         const searchId = React.useId();
-        const [directionFilter, setDirectionFilter] = React.useState("all");
+        const [fromProvider, setFromProvider] = React.useState("all");
+        const [toProvider, setToProvider] = React.useState("all");
         const [stateFilter, setStateFilter] = React.useState("all");
         const [viewMode, setViewMode] = React.useState("byRoute");
         const [query, setQuery] = React.useState("");
@@ -1409,10 +1354,9 @@ var Embassy;
             clearPreset?.();
         }, [preset]);
         const needle = query.trim().toLowerCase();
-        const filtered = React.useMemo(() => groups.filter((view) => (directionFilter === "all" ||
-            view.group.direction === directionFilter) &&
+        const filtered = React.useMemo(() => groups.filter((view) => Embassy.adapter.matchesProviderFilters(view, fromProvider, toProvider) &&
             (stateFilter === "all" || view.group.state === stateFilter) &&
-            matchesQuery(view, needle)), [groups, directionFilter, stateFilter, needle]);
+            matchesQuery(view, needle)), [groups, fromProvider, toProvider, stateFilter, needle]);
         const pairs = React.useMemo(() => groupByRoutePair(filtered), [filtered]);
         const ordered = React.useMemo(() => (viewMode === "flat" ? filtered : pairs.flatMap((pair) => pair.rows)), [viewMode, filtered, pairs]);
         const selectedView = ordered.find((view) => view.key === selectedKey);
@@ -1483,14 +1427,19 @@ var Embassy;
                     }))) : null),
                 React.createElement("div", { className: "filters" },
                     React.createElement("div", { className: "filter-group" },
-                        React.createElement(Embassy.MonoLabel, null, t("app.deliveries.dir.label")),
-                        React.createElement("div", { className: "pill-row", role: "group", "aria-label": t("app.deliveries.dir.label") },
-                            React.createElement(Embassy.FilterPill, { active: directionFilter === "all", onClick: () => {
-                                    setDirectionFilter("all");
-                                } }, t("app.deliveries.dir.all")),
-                            DIRECTION_FILTERS.map((direction) => (React.createElement(Embassy.FilterPill, { key: direction, active: directionFilter === direction, onClick: () => {
-                                    setDirectionFilter(direction);
-                                } }, t(DIRECTION_PILL_COPY_KEYS[direction])))))),
+                        React.createElement(Embassy.MonoLabel, null, t("app.deliveries.fromProvider")),
+                        React.createElement("div", { className: "pill-row", role: "group", "aria-label": t("app.deliveries.fromProvider") },
+                            React.createElement(Embassy.FilterPill, { active: fromProvider === "all", onClick: () => {
+                                    setFromProvider("all");
+                                } }, t("app.deliveries.providerAll")),
+                            Embassy.GATEWAY_PROVIDERS.map((provider) => (React.createElement(Embassy.FilterPill, { key: provider, active: fromProvider === provider, onClick: () => {
+                                    setFromProvider(provider);
+                                } }, t(`provider.${provider}`)))))),
+                    React.createElement("div", { className: "filter-group" },
+                        React.createElement(Embassy.MonoLabel, null, t("app.deliveries.toProvider")),
+                        React.createElement("div", { className: "pill-row", role: "group", "aria-label": t("app.deliveries.toProvider") },
+                            React.createElement(Embassy.FilterPill, { active: toProvider === "all", onClick: () => { setToProvider("all"); } }, t("app.deliveries.providerAll")),
+                            Embassy.GATEWAY_PROVIDERS.map((provider) => (React.createElement(Embassy.FilterPill, { key: provider, active: toProvider === provider, onClick: () => { setToProvider(provider); } }, t(`provider.${provider}`)))))),
                     React.createElement("div", { className: "filter-group" },
                         React.createElement(Embassy.MonoLabel, null, t("app.deliveries.view.label")),
                         React.createElement("div", { className: "pill-row", role: "group", "aria-label": t("app.deliveries.view.label") },
@@ -1528,464 +1477,92 @@ var Embassy;
 })(Embassy || (Embassy = {}));
 var Embassy;
 (function (Embassy) {
-    const TOPOLOGY_ROW_HEIGHT_PX = 64;
-    const TOPOLOGY_PADDING_PX = 18;
-    const TOPOLOGY_EDGE_WIDTH_PX = 220;
-    const SELECT_CLAUDE_COMMAND = "embassy select-claude --alias <alias>";
-    const REGISTER_CODEX_COMMAND = "embassy register-codex --alias codex-<name>@<host>";
-    const SUCCEEDS_COMMAND = "embassy register-codex --alias <new> --succeeds <old>";
-    const ROUTE_COUNTER_ROWS = [
-        ["accepted", "diagnostics.accepted"],
-        ["delivered", "diagnostics.delivered"],
-        ["unconfirmed", "diagnostics.unconfirmed"],
-        ["failed", "diagnostics.failed"],
-        ["ambiguous", "diagnostics.ambiguous"],
-        ["expired", "diagnostics.expired"],
-        ["cancelled", "diagnostics.cancelled"],
-        ["abandoned", "diagnostics.abandoned"],
-        ["rejected", "diagnostics.rejected"],
-        ["bytesAccepted", "diagnostics.bytesAccepted"],
-    ];
-    const countFormatters = new Map();
-    function formatCount(value, locale) {
-        const existing = countFormatters.get(locale);
-        if (existing !== undefined)
-            return existing.format(value);
-        const formatter = new Intl.NumberFormat(locale);
-        countFormatters.set(locale, formatter);
-        return formatter.format(value);
-    }
-    function isReadyCodexRoute(route) {
-        return (route.enabled &&
-            route.compatibility === "compatible" &&
-            (route.state === "idle" || route.state === "busy"));
-    }
-    function rowIdentity(alias, host) {
-        return `${alias}\u0000${host}`;
-    }
     function canRequestStaleCodexRegistrationRemoval(route) {
         return route.provider === "codex" && route.state === "stale";
     }
     Embassy.canRequestStaleCodexRegistrationRemoval = canRequestStaleCodexRegistrationRemoval;
-    function topologyRowCenterY(index) {
-        return (TOPOLOGY_PADDING_PX +
-            index * TOPOLOGY_ROW_HEIGHT_PX +
-            TOPOLOGY_ROW_HEIGHT_PX / 2);
-    }
-    function topologyEdges(data) {
-        const claudeIndices = new Map(data.peers.map((peer, index) => [peer.alias, index]));
-        const codexIndices = new Map(data.codexRoutes.map((view, index) => [view.route.alias, index]));
-        const edges = [];
-        for (const pair of data.pairs) {
-            const claudeIndex = claudeIndices.get(pair.claudeAlias);
-            const codexIndex = codexIndices.get(pair.codexAlias);
-            if (claudeIndex === undefined || codexIndex === undefined)
-                continue;
-            edges.push({
-                claudeIndex,
-                codexIndex,
-                claudeAlias: pair.claudeAlias,
-                codexAlias: pair.codexAlias,
-                state: pair.state,
-            });
-        }
-        return edges;
-    }
-    function isEdgeEndpoint(edge, side, index) {
-        return side === "claude"
-            ? index === edge.claudeIndex
-            : index === edge.codexIndex;
-    }
-    function chipHighlight(focus, edges, side, index) {
-        if (focus === undefined)
-            return undefined;
-        if (focus.side === side && focus.index === index)
-            return "on";
-        if (focus.side !== side &&
-            edges.some((edge) => isEdgeEndpoint(edge, focus.side, focus.index) &&
-                isEdgeEndpoint(edge, side, index))) {
-            return "on";
-        }
-        return "off";
-    }
-    function edgeHighlight(focus, edge) {
-        if (focus === undefined)
-            return undefined;
-        return isEdgeEndpoint(edge, focus.side, focus.index) ? "on" : "off";
-    }
-    function TopologyColumn(props) {
-        const { side, highlightAt, onFocusChange } = props;
-        if (props.items.length === 0) {
-            return (React.createElement("div", { className: "topology__col" },
-                React.createElement("p", { className: "topology__empty" }, props.emptyText)));
-        }
-        return (React.createElement("div", { className: "topology__col" },
-            React.createElement("div", { role: "list", "aria-label": props.listLabel }, props.items.map((item, index) => (React.createElement("div", { key: item.key, role: "listitem", className: side === "claude"
-                    ? "topo-row topo-row--left"
-                    : "topo-row topo-row--right", onMouseEnter: () => {
-                    onFocusChange({ side, index });
-                }, onMouseLeave: () => {
-                    onFocusChange(undefined);
-                } },
-                React.createElement("span", { className: "topo-chip", "data-side": side, "data-candidate": item.candidate ? "true" : undefined, "data-highlight": highlightAt(side, index), tabIndex: 0, onFocus: () => {
-                        onFocusChange({ side, index });
-                    }, onBlur: () => {
-                        onFocusChange(undefined);
-                    } }, item.alias),
-                React.createElement("span", { className: "sr-only" }, item.srLabel)))))));
-    }
-    function TopologyEdgeSvg(props) {
-        const height = TOPOLOGY_PADDING_PX * 2 + props.rows * TOPOLOGY_ROW_HEIGHT_PX;
-        return (React.createElement("svg", { className: "topology__svg", width: TOPOLOGY_EDGE_WIDTH_PX, height: height, viewBox: `0 0 ${TOPOLOGY_EDGE_WIDTH_PX} ${height}`, "aria-hidden": "true", focusable: "false" }, props.edges.map((edge) => {
-            const highlight = edgeHighlight(props.focus, edge);
-            const stroke = highlight === "on"
-                ? props.focusSide === "codex"
-                    ? "var(--action-blue)"
-                    : "var(--coral-accent, var(--coral))"
-                : edge.state === "ready"
-                    ? "var(--hairline)"
-                    : "var(--warning)";
-            return (React.createElement("path", { key: `${edge.claudeAlias}\0${edge.codexAlias}`, fill: "none", d: `M 0 ${topologyRowCenterY(edge.claudeIndex)} C 80 ${topologyRowCenterY(edge.claudeIndex)} 140 ${topologyRowCenterY(edge.codexIndex)} ${TOPOLOGY_EDGE_WIDTH_PX} ${topologyRowCenterY(edge.codexIndex)}`, style: {
-                    stroke,
-                    strokeDasharray: edge.state === "ready" ? undefined : "5 4",
-                    strokeWidth: highlight === "on" ? 2 : 1.25,
-                    opacity: highlight === "off" ? 0.2 : 1,
-                } }));
-        })));
-    }
-    function DetailRow(props) {
-        return (React.createElement("p", { className: "detail-row" },
-            React.createElement("span", { className: "detail-label" },
-                props.label,
-                ": "),
-            props.children));
-    }
-    function AbsentDetail(props) {
-        const t = Embassy.useT();
-        return (React.createElement("p", { className: "detail-row" },
-            React.createElement("span", { className: "detail-value detail-value--mono" }, props.fields.join(" · ")),
-            React.createElement("span", { className: "detail-label" },
-                " \u2014 ",
-                t("app.routes.detail.absent"))));
+    Embassy.canOfferConsentEdgeCandidate = (route) => route.enabled && (route.state === "idle" || route.state === "busy" || route.state === "awaiting_approval");
+    function sameEdge(edge, aliases) {
+        const actual = edge.endpoints.map(({ alias }) => alias);
+        return aliases.every((alias) => actual.includes(alias));
     }
-    function LowerBoundBadge(props) {
-        const t = Embassy.useT();
-        return (React.createElement("span", { className: "lower-bound" }, t("app.lowerBound", { count: props.count })));
-    }
-    function AccordionRow(props) {
-        const t = Embassy.useT();
-        const baseId = React.useId();
-        const buttonId = `${baseId}-summary`;
-        const panelId = `${baseId}-panel`;
-        return (React.createElement("div", { className: "accordion" },
-            React.createElement("button", { type: "button", id: buttonId, className: "accordion__row", "aria-label": t(props.open
-                    ? "app.routes.collapseDetails"
-                    : "app.routes.expandDetails", { alias: props.alias }), "aria-expanded": props.open, "aria-controls": props.open ? panelId : undefined, onClick: props.onToggle },
-                React.createElement("span", { className: "accordion__alias" }, props.alias),
-                props.head,
-                React.createElement("span", { className: "accordion__marker", "aria-hidden": "true" }, props.open ? "−" : "+")),
-            props.open ? (React.createElement("div", { className: "accordion__panel", id: panelId, role: "region", "aria-labelledby": buttonId },
-                React.createElement("div", { className: "detail-list" }, props.children))) : null));
-    }
-    function PeerAccordionRow(props) {
-        const t = Embassy.useT();
-        const peer = props.peer;
-        const selectionLabel = peer.selected
-            ? t("status.selected")
-            : peer.selectable
-                ? t("status.available")
-                : t("status.notSelectable");
-        return (React.createElement(AccordionRow, { alias: peer.alias, open: props.open, onToggle: props.onToggle, head: React.createElement(React.Fragment, null,
-                peer.selected ? (React.createElement("span", { className: "status-dot", title: t("status.selected"), "aria-hidden": "true" })) : null,
-                React.createElement(Embassy.StateChip, { domain: "peer", state: peer.state, small: true }),
-                peer.selected ? (React.createElement("span", { className: "chip chip--small", "data-kind": "positive" }, selectionLabel)) : null) },
-            React.createElement(DetailRow, { label: t("column.state") },
-                React.createElement(Embassy.StateChip, { domain: "peer", state: peer.state, small: true })),
-            React.createElement(DetailRow, { label: t("column.compatibility") },
-                React.createElement(Embassy.StateChip, { domain: "compatibility", state: peer.compatibility, small: true })),
-            React.createElement(DetailRow, { label: t("column.validation") },
-                React.createElement("span", { className: "chip chip--small", "data-kind": peer.validated ? "positive" : "warning" }, t(peer.validated
-                    ? "status.validated"
-                    : "status.validationRejected"))),
-            React.createElement(DetailRow, { label: t("column.selection") },
-                React.createElement("span", { className: "chip chip--small", "data-kind": peer.selected ? "positive" : "inert" }, selectionLabel)),
-            peer.selectionGuidance === undefined ? null : (React.createElement("p", { className: "detail-row" }, t(`peer.reason.${Embassy.camelCaseToken(peer.selectionGuidance)}`))),
-            React.createElement(DetailRow, { label: t("column.host") },
-                React.createElement("span", { className: "detail-value detail-value--mono" }, peer.host)),
-            React.createElement(DetailRow, { label: t("column.observed") }, peer.lastSeenAt === undefined ? (t("time.unavailable")) : (React.createElement(Embassy.TimeAgo, { iso: peer.lastSeenAt }))),
-            peer.safeErrorCode === undefined ? null : (React.createElement(DetailRow, { label: t("column.issue") },
-                React.createElement("span", { className: "detail-value detail-value--mono" }, peer.safeErrorCode))),
-            React.createElement(AbsentDetail, { fields: ["binding", "renames", "discovery"] }),
-            peer.selected || peer.selectable
-                ? props.codexRoutes.map((view) => {
-                    const codexAlias = view.route.alias;
-                    const paired = props.pairs.some((pair) => pair.claudeAlias === peer.alias &&
-                        pair.codexAlias === codexAlias);
-                    return (React.createElement(ActionControl, { key: codexAlias, action: {
-                            action: paired ? "unpair" : "pair",
-                            claudeAlias: peer.alias,
-                            codexAlias,
-                        }, consequence: t(paired
-                            ? "app.routes.unpairCmd.consequence"
-                            : "app.routes.pairCmd.consequence", { claude: peer.alias, codex: codexAlias }), enabled: props.actionsEnabled, onAction: props.onAction }));
-                })
-                : null));
-    }
-    function RouteCountersTable(props) {
-        const t = Embassy.useT();
-        const [locale] = Embassy.useLocale();
-        return (React.createElement("details", { className: "details-block" },
-            React.createElement("summary", null, t("app.routes.counters")),
-            React.createElement("div", { className: "details-block__content" },
-                React.createElement("div", { className: "table-wrap" },
-                    React.createElement("table", { className: "data-table" },
-                        React.createElement("caption", { className: "table-caption" }, `${t("app.routes.counters")} — ${props.alias}`),
-                        React.createElement("tbody", null, ROUTE_COUNTER_ROWS.map(([field, copyKey]) => (React.createElement("tr", { key: field },
-                            React.createElement("th", { scope: "row" }, t(copyKey)),
-                            React.createElement("td", { className: "cell-mono" }, formatCount(props.counters[field], locale)))))))))));
-    }
-    function CodexAccordionRow(props) {
-        const t = Embassy.useT();
-        const [locale] = Embassy.useLocale();
-        const route = props.view.route;
-        return (React.createElement(AccordionRow, { alias: route.alias, open: props.open, onToggle: props.onToggle, head: React.createElement(React.Fragment, null,
-                React.createElement("span", { className: "status-dot", title: t("app.routes.registered"), "aria-hidden": "true" }),
-                React.createElement(Embassy.StateChip, { domain: "route", state: route.state, small: true }),
-                props.view.monitorOnly ? (React.createElement("span", { className: "chip chip--small", "data-kind": "warning" }, t("app.routes.monitorOnly"))) : null) },
-            React.createElement(DetailRow, { label: t("column.state") },
-                React.createElement(Embassy.StateChip, { domain: "route", state: route.state, small: true })),
-            React.createElement(DetailRow, { label: t("column.compatibility") },
-                React.createElement(Embassy.StateChip, { domain: "compatibility", state: route.compatibility, small: true })),
-            React.createElement(DetailRow, { label: t("column.selection") },
-                React.createElement("span", { className: "chip chip--small", "data-kind": route.enabled ? "positive" : "inert" }, route.enabled ? t("status.enabled") : t("status.disabled"))),
-            React.createElement(DetailRow, { label: t("app.routes.queueDepth") },
-                React.createElement("span", { className: "detail-value detail-value--mono" }, formatCount(route.queueDepth, locale))),
-            props.view.oldestAgeMs === undefined ? null : (React.createElement(DetailRow, { label: t("app.overview.oldest") },
-                React.createElement("span", { className: "detail-value detail-value--mono" }, Embassy.fmtAge(props.view.oldestAgeMs)))),
-            props.view.monitorOnly ? (React.createElement("p", { className: "detail-row" }, t("app.routes.monitorOnlyReason"))) : null,
-            React.createElement(DetailRow, { label: t("column.host") },
-                React.createElement("span", { className: "detail-value detail-value--mono" }, route.host)),
-            React.createElement(DetailRow, { label: t("column.observed") }, route.lastSeenAt === undefined ? (t("time.unavailable")) : (React.createElement(Embassy.TimeAgo, { iso: route.lastSeenAt }))),
-            route.safeErrorCode === undefined ? null : (React.createElement(DetailRow, { label: t("column.issue") },
-                React.createElement("span", { className: "detail-value detail-value--mono" }, route.safeErrorCode))),
-            React.createElement(AbsentDetail, { fields: ["policy", "identity lock", "registered"] }),
-            React.createElement(RouteCountersTable, { alias: route.alias, counters: route.counters }),
-            canRequestStaleCodexRegistrationRemoval(route) ? (React.createElement(ActionControl, { action: {
-                    action: "remove_stale_codex_registration",
-                    alias: route.alias,
-                }, consequence: t("app.routes.removeStaleCodex.consequence", {
-                    alias: route.alias,
-                }), enabled: props.actionsEnabled, onAction: props.onAction })) : null));
-    }
-    function successionScope(item, t) {
-        const parts = [];
-        if (item.provider !== undefined)
-            parts.push(t(`provider.${item.provider}`));
-        if (item.alias !== undefined)
-            parts.push(item.alias);
-        if (item.host !== undefined)
-            parts.push(item.host);
-        if (item.code !== undefined)
-            parts.push(item.code);
-        return parts.join(" · ");
-    }
-    function SuccessionCard(props) {
-        const t = Embassy.useT();
-        const item = props.view.item;
-        const scope = successionScope(item, t);
-        return (React.createElement("article", { className: "succession-card" },
-            React.createElement("div", { className: "succession-card__head" },
-                React.createElement("div", { className: "chip-row" },
-                    React.createElement(Embassy.MonoLabel, null, "succession"),
-                    React.createElement(Embassy.StateChip, { domain: "severity", state: item.severity, small: true })),
-                item.timestamp === undefined ? null : (React.createElement(Embassy.TimeAgo, { iso: item.timestamp }))),
-            React.createElement("h3", { className: "card__title succession-card__title" }, t(`guidance.${props.view.guidanceKey}.title`)),
-            React.createElement("p", { className: "card__body" }, t(`guidance.${props.view.guidanceKey}.body`)),
-            scope === "" ? null : (React.createElement("p", { className: "attention-item__scope" },
-                t("attention.scope"),
-                ": ",
-                scope)),
-            React.createElement("p", { className: "card__body" }, t(`guidance.${props.view.guidanceKey}.action`)),
-            React.createElement(AbsentDetail, { fields: ["predecessor", "successor", "drain outcome"] }),
-            React.createElement("p", { className: "succession-note" }, t("app.routes.successions.note")),
-            React.createElement(Embassy.CopyCmd, { cmd: props.view.command })));
-    }
-    function actionLabelKey(action) {
-        switch (action.action) {
-            case "pair":
-                return "live.action.pair";
-            case "unpair":
-                return "live.action.unpair";
-            case "remove_stale_codex_registration":
-                return "live.action.removeStaleCodexRegistration";
-            case "refresh_dashboard":
-                return "live.action.refresh";
-        }
-    }
-    function ActionControl(props) {
+    function ActionButton(props) {
         const t = Embassy.useT();
         const [confirming, setConfirming] = React.useState(false);
         const [pending, setPending] = React.useState(false);
-        const [result, setResult] = React.useState(undefined);
-        const actionIdentity = (() => {
-            switch (props.action.action) {
-                case "refresh_dashboard":
-                    return props.action.action;
-                case "remove_stale_codex_registration":
-                    return `${props.action.action}:${props.action.alias}`;
-                case "pair":
-                case "unpair":
-                    return `${props.action.action}:${props.action.claudeAlias}:${props.action.codexAlias}`;
-            }
-        })();
-        React.useEffect(() => {
-            setConfirming(false);
-            setPending(false);
-            setResult(undefined);
-        }, [actionIdentity]);
-        const baseLabel = t(actionLabelKey(props.action));
-        const label = (() => {
-            switch (props.action.action) {
-                case "refresh_dashboard":
-                    return baseLabel;
-                case "remove_stale_codex_registration":
-                    return `${baseLabel}: ${props.action.alias}`;
-                case "pair":
-                case "unpair":
-                    return `${baseLabel}: ${props.action.claudeAlias} ↔ ${props.action.codexAlias}`;
-            }
-        })();
-        const confirm = async () => {
-            if (!props.enabled || pending)
-                return;
+        const [result, setResult] = React.useState();
+        const run = () => {
             setPending(true);
-            setResult(undefined);
-            const next = await props.onAction(props.action);
-            setPending(false);
-            setConfirming(false);
-            setResult(next);
+            props.onAction(props.action).then((next) => {
+                setResult(next);
+                setPending(false);
+                setConfirming(false);
+            });
         };
-        return (React.createElement("section", { className: "action-card", "aria-label": label },
-            React.createElement("h3", { className: "action-card__title" }, label),
-            React.createElement("p", { className: "action-card__consequence" }, props.consequence),
-            !props.enabled ? (React.createElement("p", { className: "action-card__status", role: "status" }, t("live.action.requiresConnected"))) : null,
-            result === undefined ? null : (React.createElement("p", { className: "action-card__status", "data-action-result": result.ok ? "success" : "failure", role: "status" }, t(result.ok ? "live.action.succeeded" : "live.action.failed", {
-                code: result.code,
-            }))),
-            confirming ? (React.createElement("div", { className: "action-card__buttons", role: "group", "aria-label": label },
-                React.createElement("button", { type: "button", className: "btn btn--primary", disabled: !props.enabled || pending, onClick: () => {
-                        void confirm();
-                    } }, pending ? t("live.action.pending") : t("live.action.confirm")),
-                React.createElement("button", { type: "button", className: "btn btn--ghost", disabled: pending, onClick: () => {
-                        setConfirming(false);
-                    } }, t("live.action.cancel")))) : (React.createElement("button", { type: "button", className: "btn btn--ghost", disabled: !props.enabled, onClick: () => {
-                    setResult(undefined);
-                    setConfirming(true);
-                } }, label))));
+        if (confirming)
+            return React.createElement("span", { className: "row-baseline" },
+                React.createElement("button", { type: "button", disabled: pending, onClick: run }, pending ? t("live.action.pending") : t("live.action.confirm")),
+                React.createElement("button", { type: "button", disabled: pending, onClick: () => { setConfirming(false); } }, t("live.action.cancel")));
+        return React.createElement("span", { className: "stack-sm" },
+            React.createElement("button", { type: "button", disabled: !props.enabled, onClick: () => { setResult(undefined); setConfirming(true); } }, props.label),
+            result === undefined ? null : React.createElement("span", { className: "footnote" }, t(result.ok ? "live.action.succeeded" : "live.action.failed", { code: result.code })));
+    }
+    function edgeLabel(edge, t) {
+        const labels = edge.endpoints.map(({ provider, alias }) => t("app.routes.consentEndpoint", { provider: t(`provider.${provider}`), alias }));
+        return t("app.routes.consentEdge", { left: labels[0] ?? "", right: labels[1] ?? "" });
     }
     function RoutesTab(props) {
         const t = Embassy.useT();
-        const data = props.data;
-        const openInbound = data.inboundMode === "open";
-        const [focus, setFocus] = React.useState(undefined);
-        const [openPeer, setOpenPeer] = React.useState(undefined);
-        const [openRoute, setOpenRoute] = React.useState(undefined);
-        const edges = topologyEdges(data);
-        const hasPair = data.graph.pairCount > 0 || data.graph.pairCountIsLowerBound;
-        const highlightAt = (side, index) => chipHighlight(focus, edges, side, index);
-        const claudeItems = data.peers.map((peer, index) => ({
-            key: `${rowIdentity(peer.alias, peer.host)}|${index}`,
-            alias: peer.alias,
-            candidate: !data.pairs.some((pair) => pair.claudeAlias === peer.alias),
-            srLabel: data.pairs.some((pair) => pair.claudeAlias === peer.alias)
-                ? t("status.selected")
-                : peer.selectable
-                    ? t("status.available")
-                    : t("status.notSelectable"),
-        }));
-        const codexItems = data.codexRoutes.map((view, index) => ({
-            key: `${rowIdentity(view.route.alias, view.route.host)}|${index}`,
-            alias: view.route.alias,
-            candidate: !data.pairs.some((pair) => pair.codexAlias === view.route.alias),
-            srLabel: t(`route.${Embassy.camelCaseToken(view.route.state)}`),
-        }));
-        return (React.createElement("div", { className: "tab-panel" },
-            React.createElement("section", { className: "section", "aria-label": t("app.routes.topology") },
-                React.createElement(Embassy.MonoLabel, { className: "section-label" }, t("app.routes.topology")),
-                React.createElement("div", { className: "inbound-policy", "data-inbound-mode": data.inboundMode },
-                    React.createElement("span", { className: "chip chip--small", "data-kind": openInbound ? "warning" : "inert" }, t(openInbound
-                        ? "inbound.open.badge"
-                        : "inbound.paired.badge")),
-                    React.createElement("p", null, t(openInbound
-                        ? "inbound.open.body"
-                        : hasPair
-                            ? "inbound.paired.body"
-                            : "inbound.noPair.body"))),
-                React.createElement("div", { className: "topology" },
-                    React.createElement("div", { className: "topology__heads" },
-                        React.createElement(Embassy.MonoLabel, { className: "topology__head--claude" }, t("provider.claude")),
-                        React.createElement(Embassy.MonoLabel, { className: "topology__head--codex" }, t("provider.codex"))),
-                    React.createElement("div", { className: "topology__cols" },
-                        React.createElement(TopologyColumn, { side: "claude", items: claudeItems, listLabel: t("app.routes.candidates"), emptyText: t("app.routes.noPeers"), highlightAt: highlightAt, onFocusChange: setFocus }),
-                        React.createElement(TopologyEdgeSvg, { rows: Math.max(claudeItems.length, codexItems.length), edges: edges, focus: focus, focusSide: focus === undefined ? undefined : focus.side }),
-                        React.createElement(TopologyColumn, { side: "codex", items: codexItems, listLabel: t("app.routes.codexRoutes"), emptyText: t("app.routes.noCodex"), highlightAt: highlightAt, onFocusChange: setFocus })),
-                    !hasPair ? (React.createElement("p", { className: "topology__empty" }, t(openInbound
-                        ? "inbound.open.body"
-                        : "app.routes.noPairInline"))) : (React.createElement("ul", { className: "topology__edge-list", "aria-label": t("app.routes.pairs") }, data.pairs.map((pair) => (React.createElement("li", { key: `${pair.claudeAlias}\0${pair.codexAlias}` },
-                        t("app.routes.pairDescription", {
-                            claude: pair.claudeAlias,
-                            codex: pair.codexAlias,
-                        }),
+        const { data } = props;
+        const candidates = [];
+        for (let left = 0; left < data.routes.length; left += 1) {
+            for (let right = left + 1; right < data.routes.length; right += 1) {
+                const a = data.routes[left]?.route;
+                const b = data.routes[right]?.route;
+                if (a === undefined || b === undefined || !Embassy.canOfferConsentEdgeCandidate(a) || !Embassy.canOfferConsentEdgeCandidate(b) || a.provider === b.provider || a.host !== b.host)
+                    continue;
+                if (!data.consentEdges.some((edge) => sameEdge(edge, [a.alias, b.alias])))
+                    candidates.push([a, b]);
+            }
+        }
+        return React.createElement("div", { className: "tab-panel" },
+            React.createElement("section", { className: "section" },
+                React.createElement("h2", { className: "mono-label section-label" }, t("app.routes.topology")),
+                React.createElement("p", null, t("app.routes.pairSummary", { ready: data.graph.readyConsentEdgeCount, total: data.graph.consentEdgeCount })),
+                React.createElement("ul", { className: "pair-list" }, data.consentEdges.map((edge) => {
+                    const aliases = edge.endpoints.map(({ alias }) => alias);
+                    return React.createElement("li", { key: aliases.join("\0") },
+                        React.createElement("code", null, edgeLabel(edge, t)),
                         " ",
-                        React.createElement(Embassy.StateChip, { domain: "route", state: pair.state === "ready" ? "idle" : "stale", label: pair.state === "ready"
-                                ? t("status.ready")
-                                : t(pair.state === "degraded"
-                                    ? "app.routes.pairState.degraded"
-                                    : "app.routes.pairState.unavailable"), small: true }),
-                        pair.state === "ready" ? null : (React.createElement("span", { className: "text-body-muted" }, t(pair.state === "degraded"
-                            ? "app.routes.pairDegradedReason"
-                            : "app.routes.pairUnavailableReason")))))))),
-                    data.pairsOmitted > 0 ? (React.createElement("p", { className: "topology__empty" }, t("app.omitted.pairs", { count: data.pairsOmitted }))) : null),
-                React.createElement("section", { className: "section section__sub", "aria-label": t("live.action.sectionTitle") },
-                    React.createElement("div", { className: "row-baseline section-label" },
-                        React.createElement(Embassy.MonoLabel, null, t("live.action.sectionTitle"))),
-                    React.createElement("p", { className: "section-teaching" }, t("live.action.scope")),
-                    React.createElement("div", { className: "action-panel" },
-                        React.createElement(ActionControl, { action: { action: "refresh_dashboard" }, consequence: t("app.routes.refreshCmd"), enabled: props.actionsEnabled, onAction: props.onAction })))),
-            React.createElement("section", { className: "section", "aria-label": t("app.routes.claudeSessions") },
-                React.createElement("div", { className: "row-baseline row-baseline--split section-label" },
-                    React.createElement(Embassy.MonoLabel, null, t("app.routes.claudeSessions")),
-                    data.peersOmitted > 0 ? (React.createElement(LowerBoundBadge, { count: data.peers.length })) : null),
-                data.peers.length === 0 ? (React.createElement("div", { className: "empty-state" },
-                    React.createElement("p", { className: "empty-state__text" }, t("app.routes.noPeers")),
-                    React.createElement(Embassy.CopyCmd, { cmd: SELECT_CLAUDE_COMMAND }))) : (React.createElement("div", null, data.peers.map((peer, index) => {
-                    const identity = rowIdentity(peer.alias, peer.host);
-                    return (React.createElement(PeerAccordionRow, { key: `${identity}|${index}`, peer: peer, open: openPeer === identity, pairs: data.pairs, codexRoutes: data.codexRoutes, actionsEnabled: props.actionsEnabled, onAction: props.onAction, onToggle: () => {
-                            setOpenPeer(openPeer === identity ? undefined : identity);
-                        } }));
-                }))),
-                React.createElement(Embassy.Rule, null)),
-            React.createElement("section", { className: "section", "aria-label": t("app.routes.codexRoutes") },
-                React.createElement("div", { className: "row-baseline row-baseline--split section-label" },
-                    React.createElement(Embassy.MonoLabel, null, t("app.routes.codexRoutes")),
-                    data.routesOmitted > 0 ? (React.createElement(LowerBoundBadge, { count: data.codexRoutes.length })) : null),
-                data.codexRoutes.length === 0 ? (React.createElement("div", { className: "empty-state" },
-                    React.createElement("p", { className: "empty-state__text" }, t("app.routes.noCodex")))) : (React.createElement("div", null, data.codexRoutes.map((view, index) => {
-                    const identity = rowIdentity(view.route.alias, view.route.host);
-                    return (React.createElement(CodexAccordionRow, { key: `${identity}|${index}`, view: view, open: openRoute === identity, actionsEnabled: props.actionsEnabled, onAction: props.onAction, onToggle: () => {
-                            setOpenRoute(openRoute === identity ? undefined : identity);
-                        } }));
-                }))),
-                React.createElement(Embassy.Rule, null),
-                React.createElement("div", { className: "stack routes-register" },
-                    React.createElement("p", { className: "text-xs text-body-muted" }, t("app.routes.registerHint")),
-                    React.createElement(Embassy.CopyCmd, { cmd: REGISTER_CODEX_COMMAND }))),
-            React.createElement("section", { className: "section", "aria-label": t("app.routes.successions") },
-                React.createElement(Embassy.MonoLabel, { className: "section-label" }, t("app.routes.successions")),
-                data.successions.length === 0 ? (React.createElement("div", { className: "empty-state" },
-                    React.createElement("p", { className: "empty-state__text" }, t("app.routes.successions.empty")),
-                    React.createElement("p", { className: "succession-note" }, t("app.routes.successions.note")),
-                    React.createElement(Embassy.CopyCmd, { cmd: SUCCEEDS_COMMAND }))) : (React.createElement("div", { className: "stack-lg" }, data.successions.map((view, index) => (React.createElement(SuccessionCard, { key: `${view.guidanceKey}|${view.item.alias ?? ""}|${index}`, view: view }))))))));
+                        React.createElement(Embassy.StateChip, { domain: "route", state: edge.state === "ready" ? "idle" : "stale", small: true }),
+                        React.createElement(ActionButton, { action: { action: "unpair", aliases }, label: t("live.action.unpair"), enabled: props.actionsEnabled, onAction: props.onAction }));
+                })),
+                data.consentEdgesOmitted > 0 ? React.createElement("p", { className: "footnote" }, t("app.omitted.pairs", { count: data.consentEdgesOmitted })) : null),
+            Embassy.GATEWAY_PROVIDERS.map((provider) => {
+                const routes = data.routes.filter((view) => view.route.provider === provider);
+                return React.createElement("section", { className: "section", key: provider, "aria-label": t(`provider.${provider}`) },
+                    React.createElement("h2", { className: "mono-label section-label" }, t(`provider.${provider}`)),
+                    React.createElement("ul", null, routes.map(({ route, oldestAgeMs }) => React.createElement("li", { key: `${route.alias}\0${route.host}` },
+                        React.createElement("code", null, route.alias),
+                        " \u00B7 ",
+                        React.createElement(Embassy.StateChip, { domain: "route", state: route.state, small: true }),
+                        " \u00B7 ",
+                        t("app.routes.queueDepth"),
+                        ": ",
+                        route.queueDepth,
+                        oldestAgeMs === undefined ? "" : ` · ${Embassy.fmtAge(oldestAgeMs)}`,
+                        canRequestStaleCodexRegistrationRemoval(route) ? React.createElement(ActionButton, { action: { action: "remove_stale_codex_registration", alias: route.alias }, label: t("live.action.removeStaleCodexRegistration"), enabled: props.actionsEnabled, onAction: props.onAction }) : null))),
+                    React.createElement("p", { className: "footnote" }, t("app.routes.unpairedProvider", { provider: t(`provider.${provider}`), count: data.graph.unpairedReadyByProvider[provider] })));
+            }),
+            React.createElement("section", { className: "section" },
+                React.createElement("h2", { className: "mono-label section-label" }, t("app.routes.candidates")),
+                React.createElement("ul", null, candidates.map(([left, right]) => React.createElement("li", { key: `${left.alias}\0${right.alias}` },
+                    React.createElement("code", null,
+                        left.alias,
+                        " \u2194 ",
+                        right.alias),
+                    React.createElement(ActionButton, { action: { action: "pair", aliases: [left.alias, right.alias] }, label: t("live.action.pair"), enabled: props.actionsEnabled, onAction: props.onAction })))),
+                React.createElement(ActionButton, { action: { action: "refresh_dashboard" }, label: t("live.action.refresh"), enabled: props.actionsEnabled, onAction: props.onAction })));
     }
     Embassy.RoutesTab = RoutesTab;
 })(Embassy || (Embassy = {}));
@@ -2078,7 +1655,7 @@ var Embassy;
     function alertScope(item, t) {
         const parts = [];
         if (item.provider !== undefined) {
-            parts.push(t(item.provider === "claude" ? "provider.claude" : "provider.codex"));
+            parts.push(t(`provider.${item.provider}`));
         }
         if (item.alias !== undefined)
             parts.push(item.alias);
@@ -2235,7 +1812,7 @@ var Embassy;
                         React.createElement("th", { scope: "col" }, t("app.diag.col.protocol")),
                         React.createElement("th", { scope: "col" }, t("app.diag.col.version")),
                         React.createElement("th", { scope: "col" }, t("diagnostics.health")),
-                        React.createElement("th", { scope: "col" }, t("app.diag.col.compat")),
+                        React.createElement("th", { scope: "col" }, t("column.observed")),
                         React.createElement("th", { scope: "col" }, t("diagnostics.registry.title")),
                         React.createElement("th", { scope: "col" }, t("column.issue")))),
                 React.createElement("tbody", null, connectors.length === 0 ? (React.createElement("tr", null,
@@ -2249,16 +1826,13 @@ var Embassy;
                                 ? "diagnostics.registry.state.emptySinceBoot"
                                 : "diagnostics.registry.state.noParseableRecordSinceBoot";
                     return (React.createElement("tr", { key: `${connector.provider}|${connector.host}|${index}` },
-                        React.createElement("th", { scope: "row" }, connector.provider === "claude"
-                            ? t("provider.claude")
-                            : t("provider.codex")),
+                        React.createElement("th", { scope: "row" }, t(`provider.${connector.provider}`)),
                         React.createElement("td", { className: "cell-mono" }, connector.host),
                         React.createElement("td", { className: "cell-mono" }, connector.protocol ?? DIAGNOSTICS_ABSENT_FIELD),
                         React.createElement("td", { className: "cell-mono" }, connector.protocolVersion ?? DIAGNOSTICS_ABSENT_FIELD),
                         React.createElement("td", null,
                             React.createElement(Embassy.StateChip, { domain: "health", state: connector.health, small: true })),
-                        React.createElement("td", null,
-                            React.createElement(Embassy.StateChip, { domain: "compatibility", state: connector.compatibility, small: true })),
+                        React.createElement("td", null, connector.lastSeenAt === undefined ? (DIAGNOSTICS_ABSENT_FIELD) : (React.createElement(Embassy.TimeAgo, { iso: connector.lastSeenAt }))),
                         React.createElement("td", null, observation === undefined || stateKey === undefined ? (DIAGNOSTICS_ABSENT_FIELD) : (React.createElement("div", { className: "stack-sm" },
                             React.createElement("span", null, t(stateKey)),
                             React.createElement("span", { className: "cell-note" },
@@ -2282,39 +1856,16 @@ var Embassy;
                             observation.rejectedCodesOmitted === 0 ? null : (React.createElement("span", { className: "cell-note" }, t("diagnostics.registry.rejectedCodesOmitted", {
                                 count: formatDiagnosticsCount(observation.rejectedCodesOmitted, locale),
                             })))))),
-                        React.createElement("td", { className: "cell-mono" }, connector.safeErrorCode ?? DIAGNOSTICS_ABSENT_FIELD)));
+                        React.createElement("td", { className: "cell-mono" }, connector.safeErrorCode === undefined &&
+                            connector.codexDoctor === undefined
+                            ? DIAGNOSTICS_ABSENT_FIELD
+                            : (React.createElement("div", { className: "stack-sm" },
+                                connector.safeErrorCode === undefined
+                                    ? null
+                                    : React.createElement("code", null, connector.safeErrorCode),
+                                connector.codexDoctor?.conditions.map((condition) => (React.createElement("span", { key: condition, className: "cell-note" }, t(`diagnostics.codexDoctor.${condition}`)))))))));
                 }))))));
     }
-    function DiagnosticsCompatibilityTable(props) {
-        const t = Embassy.useT();
-        return (React.createElement("div", { className: "table-wrap" },
-            React.createElement("table", { className: "data-table" },
-                React.createElement("caption", { className: "sr-only" }, t("diagnostics.compatibilityChecks.caption")),
-                React.createElement("thead", null,
-                    React.createElement("tr", null,
-                        React.createElement("th", { scope: "col" }, t("app.diag.col.provider")),
-                        React.createElement("th", { scope: "col" }, t("diagnostics.version")),
-                        React.createElement("th", { scope: "col" }, t("diagnostics.testedVersion")),
-                        React.createElement("th", { scope: "col" }, t("diagnostics.supportedMajor")),
-                        React.createElement("th", { scope: "col" }, t("diagnostics.tier")),
-                        React.createElement("th", { scope: "col" }, t("diagnostics.checkedAt")),
-                        React.createElement("th", { scope: "col" }, t("diagnostics.failure")),
-                        React.createElement("th", { scope: "col" }, t("column.issue")))),
-                React.createElement("tbody", null, props.checks.length === 0 ? (React.createElement("tr", null,
-                    React.createElement("td", { colSpan: 8 }, t("diagnostics.compatibilityChecks.empty")))) : (props.checks.map((check) => (React.createElement("tr", { key: check.surface },
-                    React.createElement("th", { scope: "row" }, t(`provider.${check.surface}`)),
-                    "notDetected" in check ? (React.createElement("td", { colSpan: 7 }, t("compatibilityTier.notDetected"))) : (React.createElement(React.Fragment, null,
-                        React.createElement("td", { className: "cell-mono" }, check.version),
-                        React.createElement("td", { className: "cell-mono" }, check.testedVersion ?? DIAGNOSTICS_ABSENT_FIELD),
-                        React.createElement("td", { className: "cell-mono" }, check.supportedMajor ?? DIAGNOSTICS_ABSENT_FIELD),
-                        React.createElement("td", null, t(check.tier === "schema_attested" && check.writesCovered
-                            ? "compatibilityTier.schema_attested.writesCovered"
-                            : `compatibilityTier.${check.tier}`)),
-                        React.createElement("td", null,
-                            React.createElement(Embassy.TimeAgo, { iso: check.checkedAt })),
-                        React.createElement("td", { className: "cell-mono" }, check.failure ?? DIAGNOSTICS_ABSENT_FIELD),
-                        React.createElement("td", { className: "cell-mono" }, check.safeErrorCode ?? DIAGNOSTICS_ABSENT_FIELD)))))))))));
-    }
     function DiagnosticsCounterTable(props) {
         return (React.createElement("div", { className: "table-wrap counters-list" },
             React.createElement("table", { className: "data-table data-table--counters" },
@@ -2457,6 +2008,12 @@ var Embassy;
                     count: formatDiagnosticsCount(omissions.routes, locale),
                 }),
             },
+            {
+                field: "consentEdges",
+                text: t("diagnostics.omissions.consentEdges", {
+                    count: formatDiagnosticsCount(omissions.consentEdges, locale),
+                }),
+            },
             {
                 field: "upstreamMessageEvents",
                 text: t("diagnostics.omissions.upstreamMessageEvents", {
@@ -2491,6 +2048,7 @@ var Embassy;
         const nothingOmitted = omissions.connectors === 0 &&
             omissions.availablePeers === 0 &&
             omissions.routes === 0 &&
+            omissions.consentEdges === 0 &&
             omissions.upstreamMessageEvents === 0 &&
             omissions.messageGroups === 0 &&
             omissions.messageEvents === 0 &&
@@ -2577,10 +2135,6 @@ var Embassy;
                     React.createElement(DiagnosticsConnectorTable, { connectors: data.connectors }),
                     React.createElement("p", { className: "footnote" }, t("app.diag.versions.rangeAbsent")))),
             React.createElement("div", { className: "grid-2" },
-                React.createElement("section", { className: "card", "aria-labelledby": "provider-compatibility-title" },
-                    React.createElement("div", { className: "card__head" },
-                        React.createElement("h3", { className: "card__title", id: "provider-compatibility-title" }, t("app.diag.providerCompatibility.title"))),
-                    React.createElement(DiagnosticsCompatibilityTable, { checks: data.compatibilityChecks })),
                 React.createElement(Embassy.AbsentFeature, { title: t("app.diag.lease.title"), body: t("app.diag.lease.absent"), cmd: "embassy status" })),
             React.createElement("section", { className: "section", "aria-labelledby": limitsHeadingId },
                 React.createElement("h2", { className: "mono-label section-label", id: limitsHeadingId }, t("app.diag.limits")),