agent-embassy 1.4.0 → 1.5.0

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

@@ -1,5 +1,4 @@
-import { arePublicAvailablePeerSnapshots } from "./types.js";
-import { isCompatibilityAttestation, } from "./compatibility.js";
+import { arePublicAvailablePeerSnapshots, isPublicCompatibilityCheckSnapshot, isPublicRegistryObservationSnapshot, } from "./types.js";
 export const DASHBOARD_MODEL_LIMITS = Object.freeze({
     connectors: 16,
     availablePeers: 64,
@@ -12,6 +11,235 @@ export const DASHBOARD_MODEL_LIMITS = Object.freeze({
     activityEvents: 64,
     alerts: 32,
 });
+const presentation = (values) => values;
+const statePresentation = {
+    delivery: presentation({
+        queued: { tone: "info", chip: "progress" },
+        duplicate: { tone: "quiet", chip: "inert" },
+        dispatching: { tone: "info", chip: "progress" },
+        transport_written: { tone: "info", chip: "progress" },
+        held: { tone: "warning", chip: "progress" },
+        delivered: { tone: "good", chip: "positive" },
+        unconfirmed: { tone: "warning", chip: "indeterminate" },
+        failed: { tone: "danger", chip: "failure" },
+        ambiguous: { tone: "warning", chip: "indeterminate" },
+        expired: { tone: "danger", chip: "failure" },
+        cancelled: { tone: "danger", chip: "inert" },
+        abandoned: { tone: "danger", chip: "inert" },
+        rejected: { tone: "danger", chip: "warning" },
+    }),
+    route: presentation({
+        stale: { tone: "danger", chip: "failure" },
+        idle: { tone: "good", chip: "progress" },
+        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({
+        idle: { tone: "good", chip: "progress" },
+        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" },
+        setup: { tone: "info", chip: "progress" },
+        attention: { tone: "danger", chip: "failure" },
+    }),
+    party: presentation({
+        ready: { tone: "good", chip: "positive" },
+        busy: { tone: "info", chip: "active" },
+        waiting: { tone: "warning", chip: "warning" },
+        missing: { tone: "quiet", chip: "inert" },
+        attention: { tone: "danger", chip: "failure" },
+    }),
+    severity: presentation({
+        info: { tone: "info", chip: "active" },
+        warning: { tone: "warning", chip: "warning" },
+        error: { tone: "danger", chip: "failure" },
+    }),
+    connection: presentation({
+        connected: { tone: "good", chip: "positive" },
+        connecting: { tone: "info", chip: "progress" },
+        paused: { tone: "quiet", chip: "inert" },
+        unavailable: { tone: "warning", chip: "warning" },
+        capacity: { tone: "warning", chip: "warning" },
+        disconnected: { tone: "warning", chip: "warning" },
+        stopped: { tone: "warning", chip: "warning" },
+    }),
+};
+const guidanceCopyKeys = {
+    reobserve_claude: "reobserveClaude",
+    reobserve_codex: "reobserveCodex",
+    codex_reactivation_required: "codexReactivationRequired",
+    consent_edge_unavailable: "consentEdgeUnavailable",
+    claude_not_observed: "claudeNotObserved",
+    codex_stale: "codexStale",
+    connector_offline: "connectorOffline",
+    route_stale: "routeStale",
+    queue_stalled: "queueStalled",
+    recipient_waiting_input: "recipientWaitingInput",
+    unconfirmed: "unconfirmed",
+    degraded: "degraded",
+    codex_succession_busy: "codexSuccessionBusy",
+    codex_succession_recovery: "codexSuccessionRecovery",
+    progress_watch: "progressWatch",
+    registry_empty: "registryEmpty",
+    registry_rejected: "registryRejected",
+    provider_incompatible: "providerIncompatible",
+    generic: "generic",
+};
+const nextActionCopyKeys = {
+    discover_claude: "next.discoverClaude",
+    select_claude: "next.selectClaude",
+    pair_routes: "next.pairRoutes",
+    restore_claude: "next.restoreClaude",
+    repair_claude_inventory: "next.repairClaude",
+    register_codex: "next.registerCodex",
+    restore_codex: "next.restoreCodex",
+    review_compatibility: "next.reviewCompatibility",
+    none: "next.none",
+};
+const attentionCommands = {
+    reobserve_claude: "embassy select-claude --alias {alias}",
+    reobserve_codex: "embassy register-codex --alias {alias}",
+    codex_reactivation_required: "embassy register-codex --alias {alias}",
+    consent_edge_unavailable: "embassy refresh-dashboard",
+    claude_not_observed: "embassy select-claude --alias {alias}",
+    codex_stale: "embassy register-codex --alias {alias}",
+    connector_offline: "embassy status",
+    route_stale: "embassy status",
+    queue_stalled: "embassy status",
+    recipient_waiting_input: "embassy status",
+    unconfirmed: "embassy status",
+    degraded: "embassy status",
+    codex_succession_busy: "embassy register-codex --alias <new> --succeeds {alias}",
+    codex_succession_recovery: "embassy register-codex --alias <new> --succeeds {alias}",
+    progress_watch: "embassy status",
+    registry_empty: "embassy refresh-dashboard",
+    registry_rejected: "embassy status",
+    provider_incompatible: "embassy refresh-dashboard",
+    generic: "embassy status",
+};
+const deliveryMeaningKeys = {
+    queued: "activity.meaning.queued",
+    duplicate: "activity.meaning.duplicate",
+    dispatching: "activity.meaning.dispatching",
+    transport_written: "activity.meaning.transportWritten",
+    held: "activity.meaning.held",
+    delivered: "activity.meaning.delivered",
+    unconfirmed: "activity.meaning.unconfirmed",
+    failed: "activity.meaning.failed",
+    ambiguous: "activity.meaning.ambiguous",
+    expired: "activity.meaning.expired",
+    cancelled: "activity.meaning.cancelled",
+    abandoned: "activity.meaning.abandoned.generic",
+    rejected: "activity.meaning.rejected",
+};
+/** JSON-safe semantics embedded once in the live dashboard boot payload. */
+export const DASHBOARD_SEMANTICS = Object.freeze({
+    statePresentation,
+    deliveryChipByDirection: {
+        delivered: { codex_to_claude: "qualified" },
+    },
+    deliveryChipBySafeErrorCode: {
+        rejected: { SENDER_NOT_PAIRED: "inert" },
+    },
+    deliveryToneBySafeErrorCode: {
+        rejected: { SENDER_NOT_PAIRED: "quiet" },
+    },
+    guidanceCopyKeys,
+    nextActionCopyKeys,
+    attentionCommands,
+    attentionCommandFallbacks: {
+        codex_succession_busy: "<old>",
+        codex_succession_recovery: "<old>",
+    },
+    deliveryMeaningKeys,
+    deliveryMeaningByDirection: {
+        codex_to_claude: "activity.meaning.delivered.codexToClaude",
+        claude_to_codex: "activity.meaning.delivered.claudeToCodex",
+    },
+    deliveryMeaningBySafeErrorCode: {
+        SENDER_NOT_PAIRED: "activity.meaning.senderNotPaired",
+        CONTROLLER_RESTARTED: "activity.meaning.abandoned.controllerRestarted",
+        TRANSIENT_BODY_UNAVAILABLE: "activity.meaning.abandoned.transientBody",
+        ROUTE_UNREGISTERED: "activity.meaning.abandoned.routeTerminated",
+        MESSAGE_EXPIRED: "activity.meaning.abandoned.routeTerminated",
+    },
+});
+function semanticPresentation(domain, state) {
+    const table = DASHBOARD_SEMANTICS.statePresentation[domain];
+    return Object.prototype.hasOwnProperty.call(table, state)
+        ? table[state]
+        : undefined;
+}
+export function dashboardChipKind(domain, state, direction, safeErrorCode) {
+    if (domain === "delivery") {
+        const byCode = DASHBOARD_SEMANTICS.deliveryChipBySafeErrorCode;
+        const byDirection = DASHBOARD_SEMANTICS.deliveryChipByDirection;
+        if (safeErrorCode !== undefined) {
+            const override = byCode[state]?.[safeErrorCode];
+            if (override !== undefined)
+                return override;
+        }
+        if (direction !== undefined) {
+            const override = byDirection[state]?.[direction];
+            if (override !== undefined)
+                return override;
+        }
+    }
+    return semanticPresentation(domain, state)?.chip ?? "unknown";
+}
+export function dashboardTone(domain, state, safeErrorCode) {
+    if (domain === "delivery" && safeErrorCode !== undefined) {
+        const byCode = DASHBOARD_SEMANTICS.deliveryToneBySafeErrorCode;
+        const override = byCode[state]?.[safeErrorCode];
+        if (override !== undefined)
+            return override;
+    }
+    return semanticPresentation(domain, state)?.tone ?? "danger";
+}
+export function deliveryMeaningKey(state, direction, safeErrorCode) {
+    if (state === "rejected" && safeErrorCode === "SENDER_NOT_PAIRED") {
+        return DASHBOARD_SEMANTICS.deliveryMeaningBySafeErrorCode.SENDER_NOT_PAIRED;
+    }
+    if (state === "delivered" && direction !== undefined) {
+        return DASHBOARD_SEMANTICS.deliveryMeaningByDirection[direction];
+    }
+    if (state === "abandoned" && safeErrorCode !== undefined) {
+        const byCode = DASHBOARD_SEMANTICS.deliveryMeaningBySafeErrorCode;
+        return byCode[safeErrorCode] ?? deliveryMeaningKeys.abandoned;
+    }
+    const byState = DASHBOARD_SEMANTICS.deliveryMeaningKeys;
+    return byState[state] ?? "activity.meaning.other";
+}
+export function guidanceCopyKey(guidance) {
+    return DASHBOARD_SEMANTICS.guidanceCopyKeys[guidance];
+}
+export function nextActionCopyKey(action) {
+    return DASHBOARD_SEMANTICS.nextActionCopyKeys[action];
+}
+export function attentionCommand(item) {
+    const fallbacks = DASHBOARD_SEMANTICS.attentionCommandFallbacks;
+    return DASHBOARD_SEMANTICS.attentionCommands[item.guidance].replaceAll("{alias}", item.alias ?? fallbacks[item.guidance] ?? "<alias>");
+}
 const SAFE_CODE_PATTERN = /^[A-Z][A-Z0-9_]{0,63}$/;
 const SAFE_PROTOCOL_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._+:/-]{0,47}$/;
 const OPAQUE_SUFFIX_PATTERN = /^[a-f0-9]{6,12}$/i;
@@ -69,8 +297,15 @@ function normalizedCounters(counters) {
         bytesAccepted: normalizedInteger(counters?.bytesAccepted) ?? 0,
     };
 }
+export function buildDashboardViewModel(snapshot) {
+    return buildProjectedDashboardViewModel(snapshot, false);
+}
+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"));
 }
@@ -151,6 +386,14 @@ 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";
     }
@@ -219,7 +462,7 @@ function messageKey(message) {
         typeof message.messageIdSuffix === "string" ? message.messageIdSuffix : "",
     ].join("\0");
 }
-function buildMessageGroups(messages) {
+function buildMessageGroups(messages, includeBodies) {
     const grouped = new Map();
     for (const message of messages) {
         const key = messageKey(message);
@@ -282,7 +525,8 @@ function buildMessageGroups(messages) {
             ...(latest.steer === true ? { steer: true } : {}),
             // Bodies are first-class observable data (CO #36); the display copy
             // is bounded so one 16 KiB message cannot dominate the view model.
-            ...(typeof latest.body === "string" && latest.body.length > 0
+            ...(includeBodies &&
+                typeof latest.body === "string" && latest.body.length > 0
                 ? { body: boundedText(latest.body, 4096) }
                 : {}),
             events: allEvents,
@@ -311,12 +555,23 @@ function buildMessageGroups(messages) {
         activeGroups: all.filter((message) => ["queued", "dispatching", "transport_written", "held"].includes(message.state)).length,
     };
 }
-export function buildDashboardViewModel(snapshot) {
+function buildProjectedDashboardViewModel(snapshot, includeBodies) {
     const generatedAt = normalizedTimestamp(snapshot.generatedAt);
     const inboundMode = snapshot.inboundMode === "open" ? "open" : "paired";
     const validPeers = arePublicAvailablePeerSnapshots(snapshot.availablePeers)
         ? snapshot.availablePeers
         : [];
+    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")
+                .map((check) => check.surface)
+            : []),
+    ]);
     const peers = validPeers
         .map((peer) => ({
         alias: boundedText(peer.alias),
@@ -403,7 +658,11 @@ export function buildDashboardViewModel(snapshot) {
             claudeAlias,
             codexAlias,
             host: boundedText(pair.host),
-            state: bothPresent && routeIsReady(claudeRoute) && routeIsReady(codexRoute)
+            state: bothPresent &&
+                !quarantinedProviders.has("claude") &&
+                !quarantinedProviders.has("codex") &&
+                routeIsReady(claudeRoute) &&
+                routeIsReady(codexRoute)
                 ? "ready"
                 : bothPresent
                     ? "degraded"
@@ -425,9 +684,9 @@ export function buildDashboardViewModel(snapshot) {
             generatedAtMs === undefined) {
             return [];
         }
-        const idleMs = normalizedInteger(watch.idleMs);
-        if (idleMs === undefined ||
-            (watch.nudgeCount !== 0 && watch.nudgeCount !== 1 && watch.nudgeCount !== 2)) {
+        if (watch.nudgeCount !== 0 &&
+            watch.nudgeCount !== 1 &&
+            watch.nudgeCount !== 2) {
             return [];
         }
         return [
@@ -435,11 +694,8 @@ export function buildDashboardViewModel(snapshot) {
                 conversationIdSuffix: watch.conversationIdSuffix,
                 ownerAlias: boundedText(watch.ownerAlias),
                 workerAlias: boundedText(watch.workerAlias),
-                phase: watch.phase,
-                capability: watch.capability,
                 lastActivityAt,
                 nextActionAt,
-                idleMs,
                 idleForMs: Math.max(0, generatedAtMs - Date.parse(lastActivityAt)),
                 dueInMs: Math.max(0, Date.parse(nextActionAt) - generatedAtMs),
                 nudgeCount: watch.nudgeCount,
@@ -466,37 +722,52 @@ export function buildDashboardViewModel(snapshot) {
                 ownerAlias: boundedText(event.ownerAlias),
                 workerAlias: boundedText(event.workerAlias),
                 kind: event.kind,
-                ...(event.nudgeNumber === undefined
-                    ? {}
-                    : { nudgeNumber: event.nudgeNumber }),
+                actor: event.actor,
+                ...(event.reason === undefined ? {} : { reason: event.reason }),
             },
         ];
     })
         .sort((left, right) => right.sequence - left.sequence);
     const watchEvents = allWatchEvents.slice(0, DASHBOARD_MODEL_LIMITS.progressWatchEvents);
     const connectors = snapshot.connectors
-        .map((connector) => ({
-        provider: connector.provider,
-        host: boundedText(connector.host),
-        health: connector.health,
-        compatibility: connector.compatibility,
-        ...(safeProtocol(connector.protocol) === undefined
-            ? {}
-            : { protocol: safeProtocol(connector.protocol) }),
-        ...(safeProtocol(connector.protocolVersion) === undefined
-            ? {}
-            : { protocolVersion: safeProtocol(connector.protocolVersion) }),
-        ...(normalizedTimestamp(connector.lastSeenAt) === undefined
-            ? {}
-            : { lastSeenAt: normalizedTimestamp(connector.lastSeenAt) }),
-        ...(safeCode(connector.safeErrorCode) === undefined
-            ? {}
-            : { safeErrorCode: safeCode(connector.safeErrorCode) }),
-    }))
+        .map((connector) => {
+        const registry = isPublicRegistryObservationSnapshot(connector.registry)
+            ? connector.registry
+            : undefined;
+        return {
+            provider: connector.provider,
+            host: boundedText(connector.host),
+            health: connector.health,
+            compatibility: connector.compatibility,
+            ...(safeProtocol(connector.protocol) === undefined
+                ? {}
+                : { protocol: safeProtocol(connector.protocol) }),
+            ...(safeProtocol(connector.protocolVersion) === undefined
+                ? {}
+                : { protocolVersion: safeProtocol(connector.protocolVersion) }),
+            ...(normalizedTimestamp(connector.lastSeenAt) === undefined
+                ? {}
+                : { lastSeenAt: normalizedTimestamp(connector.lastSeenAt) }),
+            ...(safeCode(connector.safeErrorCode) === undefined
+                ? {}
+                : { safeErrorCode: safeCode(connector.safeErrorCode) }),
+            ...(registry === undefined
+                ? {}
+                : {
+                    registry: {
+                        entriesScanned: registry.entriesScanned,
+                        parseableRecords: registry.parseableRecords,
+                        parseableRecordSeenSinceBoot: registry.parseableRecordSeenSinceBoot,
+                        rejected: registry.rejected.map((row) => ({ ...row })),
+                        rejectedCodesOmitted: registry.rejectedCodesOmitted,
+                    },
+                }),
+        };
+    })
         .sort((left, right) => compareText(`${left.provider}\0${left.host}`, `${right.provider}\0${right.host}`))
         .slice(0, DASHBOARD_MODEL_LIMITS.connectors);
     const compatibilityChecks = (Array.isArray(snapshot.compatibilityChecks)
-        ? snapshot.compatibilityChecks.filter(isCompatibilityAttestation)
+        ? snapshot.compatibilityChecks.filter(isPublicCompatibilityCheckSnapshot)
         : [])
         .map((attestation) => {
         const failed = attestation.probes.find((probe) => probe.outcome === "fail");
@@ -504,6 +775,8 @@ export function buildDashboardViewModel(snapshot) {
         return {
             surface: attestation.surface,
             version: boundedText(attestation.version),
+            testedVersion: boundedText(attestation.testedVersion),
+            supportedMajor: boundedText(attestation.supportedMajor),
             tier: attestation.tier,
             checkedAt: attestation.checkedAt,
             ...(failed === undefined ? {} : { failure: failed.name }),
@@ -512,7 +785,7 @@ export function buildDashboardViewModel(snapshot) {
     })
         .sort((left, right) => compareText(left.surface, right.surface))
         .slice(0, 2);
-    const messages = buildMessageGroups(snapshot.messages);
+    const messages = buildMessageGroups(snapshot.messages, includeBodies);
     const queuedMessages = allRoutes.reduce((total, route) => boundedAdd(total, route.queueDepth), 0);
     const queuedWithAge = allRoutes
         .filter((route) => route.oldestQueuedAt !== undefined && route.queueAgeMs !== undefined)
@@ -521,52 +794,63 @@ export function buildDashboardViewModel(snapshot) {
     const activeDeliveries = messages.activeGroups;
     const claudeRoutes = allRoutes.filter((route) => route.provider === "claude");
     const codexRoutes = allRoutes.filter((route) => route.provider === "codex");
-    const readyClaude = claudeRoutes.filter(routeIsReady).length;
-    const readyCodex = codexRoutes.filter(routeIsReady).length;
+    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) => routeIsReady(route) && pairedClaude.has(route.alias));
-    const readyPairedCodex = codexRoutes.some((route) => routeIsReady(route) && pairedCodex.has(route.alias));
+    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 graph = {
         pairCount: allPairs.length,
         readyPairCount: readyPairs.length,
         pairCountIsLowerBound,
-        unpairedReadyClaude: claudeRoutes.filter((route) => routeIsReady(route) && !pairedClaude.has(route.alias)).length,
-        unpairedReadyCodex: codexRoutes.filter((route) => routeIsReady(route) && !pairedCodex.has(route.alias)).length,
+        unpairedReadyClaude: claudeRoutes.filter((route) => routeIsExchangeReady(route) && !pairedClaude.has(route.alias)).length,
+        unpairedReadyCodex: codexRoutes.filter((route) => routeIsExchangeReady(route) && !pairedCodex.has(route.alias)).length,
     };
     const selectedPeers = validPeers.filter((peer) => peer.selected && peerIsSelectable(peer));
     const selectablePeers = validPeers.filter(peerIsSelectable);
-    const selectedClaudeCount = Math.max(selectedPeers.length, readyClaude);
+    const selectedClaudeCount = quarantinedProviders.has("claude")
+        ? 0
+        : Math.max(selectedPeers.length, readyClaude);
     const claudeStatus = partyStatus(claudeRoutes, readyClaude);
     const codexStatus = partyStatus(codexRoutes, readyCodex);
-    const claudeNextAction = 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 = readyPairedCodex || (pairCountIsLowerBound && readyCodex > 0)
-        ? "none"
-        : readyCodex > 0
-            ? "pair_routes"
-            : codexRoutes.length === 0
-                ? "register_codex"
-                : "restore_codex";
+    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 explicitAlerts = coalesceCodexReactivationAlerts(snapshot.alerts
         .filter((alert) => alert.code !== "COMPATIBILITY_CERTIFICATION_FAILED")
         .map((alert) => {
         const code = safeCode(alert.code);
+        const route = code === "QUEUE_STALLED" && typeof alert.alias === "string"
+            ? routeByAlias.get(alert.alias)
+            : undefined;
         return {
             kind: "alert",
             ...(code === undefined ? {} : { code }),
@@ -587,7 +871,19 @@ export function buildDashboardViewModel(snapshot) {
             ...(typeof alert.host === "string"
                 ? { host: boundedText(alert.host) }
                 : {}),
-            guidance: guidanceFor(code, alert.provider),
+            ...(alert.provider === "codex" &&
+                typeof alert.host === "string" &&
+                route !== undefined &&
+                alert.host === route.host &&
+                route.provider === "codex" &&
+                route.state === "busy" &&
+                route.queueDepth > 0
+                ? { queueDepth: route.queueDepth }
+                : {}),
+            guidance: alert.provider !== undefined &&
+                quarantinedProviders.has(alert.provider)
+                ? "provider_incompatible"
+                : guidanceFor(code, alert.provider),
         };
     }), allRoutes).sort((left, right) => alertPriority(left.severity) - alertPriority(right.severity) ||
         compareText(right.timestamp ?? "", left.timestamp ?? ""));
@@ -649,13 +945,11 @@ export function buildDashboardViewModel(snapshot) {
             attentionCandidates[existingIndex] = item;
     }
     for (const watch of allWatches) {
-        if (watch.phase !== "episode" && watch.capability !== "route")
+        if (watch.nudgeCount === 0)
             continue;
         attentionCandidates.push({
             kind: "watch",
-            code: watch.capability === "route"
-                ? "PROGRESS_WATCH_CAPABILITY_DEGRADED"
-                : "PROGRESS_WATCH_QUIET",
+            code: "PROGRESS_WATCH_QUIET",
             severity: "warning",
             timestamp: watch.lastActivityAt,
             alias: watch.workerAlias,
@@ -664,7 +958,9 @@ export function buildDashboardViewModel(snapshot) {
     }
     const representedScopes = new Set(attentionCandidates.map((item) => `${item.provider ?? ""}\0${item.alias ?? ""}\0${item.host ?? ""}`));
     for (const route of allRoutes) {
-        if (routeIsReady(route)) {
+        if (routeIsReady(route) ||
+            quarantinedProviders.has(route.provider) ||
+            route.safeErrorCode === "CODEX_WRITES_DISABLED") {
             continue;
         }
         const scope = `${route.provider}\0${route.alias}\0${route.host}`;
@@ -709,13 +1005,64 @@ export function buildDashboardViewModel(snapshot) {
                 : { timestamp: connector.lastSeenAt }),
             provider: connector.provider,
             host: connector.host,
-            guidance: connector.health === "offline" ? "connector_offline" : "degraded",
+            guidance: connector.health === "offline"
+                ? "connector_offline"
+                : 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",
         });
         representedScopes.add(scope);
     }
+    for (const connector of connectors) {
+        const observation = connector.registry;
+        if (observation === undefined)
+            continue;
+        if (observation.rejected.length > 0 ||
+            observation.rejectedCodesOmitted > 0) {
+            const item = {
+                kind: "connector",
+                code: observation.rejected.some((row) => row.safeErrorCode === "CLAUDE_REGISTRY_UNAVAILABLE")
+                    ? "CLAUDE_REGISTRY_UNAVAILABLE"
+                    : "CLAUDE_REGISTRY_RECORDS_REJECTED",
+                severity: "warning",
+                provider: "claude",
+                host: connector.host,
+                guidance: "registry_rejected",
+            };
+            const duplicateIndex = attentionCandidates.findIndex((candidate) => candidate.code === item.code &&
+                candidate.provider === item.provider &&
+                candidate.alias === item.alias &&
+                candidate.host === item.host);
+            if (duplicateIndex === -1)
+                attentionCandidates.push(item);
+            else
+                attentionCandidates[duplicateIndex] = item;
+            continue;
+        }
+        if (observation.parseableRecordSeenSinceBoot)
+            continue;
+        attentionCandidates.push({
+            kind: "connector",
+            code: observation.entriesScanned === 0
+                ? "CLAUDE_REGISTRY_EMPTY_SINCE_BOOT"
+                : "CLAUDE_REGISTRY_NO_PARSEABLE_RECORD_SINCE_BOOT",
+            severity: "warning",
+            provider: "claude",
+            host: connector.host,
+            guidance: "registry_empty",
+        });
+    }
     if ((snapshot.health === "degraded" ||
         snapshot.health === "offline" ||
         snapshot.health === "incompatible") &&
+        !(snapshot.health === "degraded" && quarantinedProviders.size > 0) &&
         !attentionCandidates.some((item) => item.kind === "broker")) {
         attentionCandidates.push({
             kind: "broker",
@@ -778,6 +1125,9 @@ export function buildDashboardViewModel(snapshot) {
                 status: codexStatus,
                 total: codexRoutes.length,
                 ready: readyCodex,
+                ...(monitorOnlyCodexRoutes.length === 0
+                    ? {}
+                    : { monitorOnly: monitorOnlyCodexRoutes.length }),
                 countIsLowerBound: (normalizedInteger(snapshot.truncation.routes) ?? 0) > 0,
                 ...(codexRoutes[0]?.alias === undefined
                     ? {}