agent-embassy 2.0.1 → 3.0.0

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

@@ -1,1061 +0,0 @@
-import { arePublicAvailablePeerSnapshots, gatewayProviders, isPublicRegistryObservationSnapshot, parseDirection, } from "./types.js";
-export const DASHBOARD_MODEL_LIMITS = Object.freeze({
-    connectors: 16,
-    availablePeers: 64,
-    routes: 128,
-    consentEdges: 64,
-    messages: 50,
-    messageEvents: 60,
-    progressWatches: 64,
-    progressWatchEvents: 64,
-    activityEvents: 64,
-    alerts: 32,
-});
-const dashboardActivityKinds = [
-    "discovery",
-    "selection",
-    "registration",
-    "pairing",
-    "watch",
-];
-const dashboardActivityActions = [
-    "discovery_refreshed",
-    "claude_selected",
-    "claude_unselected",
-    "codex_registered",
-    "codex_succeeded",
-    "codex_unregistered",
-    "routes_paired",
-    "routes_unpaired",
-    "watch_ended",
-];
-function isDashboardActivityKind(value) {
-    return dashboardActivityKinds.some((candidate) => candidate === value);
-}
-function isDashboardActivityAction(value) {
-    return dashboardActivityActions.some((candidate) => candidate === value);
-}
-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" },
-        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" },
-    }),
-    health: presentation({
-        healthy: { tone: "good", chip: "positive" },
-        connecting: { tone: "info", chip: "progress" },
-        degraded: { tone: "warning", chip: "warning" },
-        offline: { 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",
-    consent_edge_unavailable: "consentEdgeUnavailable",
-    claude_not_observed: "claudeNotObserved",
-    connector_offline: "connectorOffline",
-    route_stale: "routeStale",
-    queue_stalled: "queueStalled",
-    recipient_waiting_input: "recipientWaitingInput",
-    unconfirmed: "unconfirmed",
-    degraded: "degraded",
-    progress_watch: "progressWatch",
-    registry_empty: "registryEmpty",
-    registry_rejected: "registryRejected",
-    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",
-    none: "next.none",
-};
-const attentionCommands = {
-    reobserve_claude: "embassy select-claude --alias {alias}",
-    consent_edge_unavailable: "embassy refresh-dashboard",
-    claude_not_observed: "embassy select-claude --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",
-    progress_watch: "embassy status",
-    registry_empty: "embassy refresh-dashboard",
-    registry_rejected: "embassy status",
-    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,
-    deliveryChipByTargetProvider: {
-        delivered: { claude: "qualified" },
-    },
-    deliveryChipBySafeErrorCode: {
-        rejected: { SENDER_NOT_PAIRED: "inert" },
-    },
-    deliveryToneBySafeErrorCode: {
-        rejected: { SENDER_NOT_PAIRED: "quiet" },
-    },
-    guidanceCopyKeys,
-    nextActionCopyKeys,
-    attentionCommands,
-    attentionCommandFallbacks: {},
-    deliveryMeaningKeys,
-    deliveryMeaningByTargetProvider: {
-        claude: "activity.meaning.delivered.toClaude",
-        codex: "activity.meaning.delivered.toCodex",
-        deepseek: "activity.meaning.delivered.toDeepSeek",
-        grok: "activity.meaning.delivered.toGrok",
-        peer: "activity.meaning.delivered.toPeer",
-    },
-    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 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) {
-        const target = parseDirection(direction)?.targetProvider;
-        if (target !== undefined) {
-            return DASHBOARD_SEMANTICS.deliveryMeaningByTargetProvider[target];
-        }
-    }
-    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;
-const CONVERSATION_SUFFIX_PATTERN = /^[A-Za-z0-9_-]{8}$/;
-function boundedText(value, maximumCharacters = 96) {
-    if (typeof value !== "string")
-        return "";
-    const characters = Array.from(value);
-    return characters.length <= maximumCharacters
-        ? value
-        : `${characters.slice(0, maximumCharacters - 1).join("")}\u2026`;
-}
-function safeCode(value) {
-    return typeof value === "string" && SAFE_CODE_PATTERN.test(value)
-        ? value
-        : undefined;
-}
-function safeProtocol(value) {
-    return typeof value === "string" && SAFE_PROTOCOL_PATTERN.test(value)
-        ? value
-        : undefined;
-}
-function normalizedInteger(value) {
-    return typeof value === "number" &&
-        Number.isSafeInteger(value) &&
-        value >= 0
-        ? value
-        : undefined;
-}
-function normalizedTimestamp(value) {
-    if (typeof value !== "string")
-        return undefined;
-    const milliseconds = Date.parse(value);
-    return Number.isFinite(milliseconds)
-        ? new Date(milliseconds).toISOString()
-        : undefined;
-}
-function compareText(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}
-function boundedAdd(left, right) {
-    return Math.min(Number.MAX_SAFE_INTEGER, left + right);
-}
-function normalizedCounters(counters) {
-    return {
-        accepted: normalizedInteger(counters?.accepted) ?? 0,
-        delivered: normalizedInteger(counters?.delivered) ?? 0,
-        unconfirmed: normalizedInteger(counters?.unconfirmed) ?? 0,
-        failed: normalizedInteger(counters?.failed) ?? 0,
-        ambiguous: normalizedInteger(counters?.ambiguous) ?? 0,
-        expired: normalizedInteger(counters?.expired) ?? 0,
-        cancelled: normalizedInteger(counters?.cancelled) ?? 0,
-        abandoned: normalizedInteger(counters?.abandoned) ?? 0,
-        rejected: normalizedInteger(counters?.rejected) ?? 0,
-        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.state === "idle" || route.state === "busy"));
-}
-function peerSelectionGuidance(peer) {
-    if (peer.safeErrorCode === "PEER_ALIAS_COLLISION")
-        return "alias_collision";
-    if (peer.safeErrorCode === "PEER_SESSION_COLLISION")
-        return "session_collision";
-    if (peer.safeErrorCode === "PEER_DISCOVERY_INCOMPLETE") {
-        return "discovery_incomplete";
-    }
-    if (peer.state === "offline")
-        return "offline";
-    return undefined;
-}
-function peerIsSelectable(peer) {
-    return peer.validated && peerSelectionGuidance(peer) === undefined;
-}
-function partyStatus(routes, ready) {
-    if (routes.length === 0)
-        return "missing";
-    if (ready === 0) {
-        return routes.some((route) => route.state === "awaiting_approval")
-            ? "waiting"
-            : "attention";
-    }
-    return routes.some((route) => route.state === "busy") ? "busy" : "ready";
-}
-function routePriority(route) {
-    if (!route.enabled || route.state === "offline") {
-        return 0;
-    }
-    if (route.state === "stale")
-        return 1;
-    if (route.state === "awaiting_approval")
-        return 2;
-    if (route.state === "busy")
-        return 3;
-    return 4;
-}
-function alertPriority(severity) {
-    return severity === "error" ? 0 : severity === "warning" ? 1 : 2;
-}
-function guidanceFor(code) {
-    switch (code) {
-        case "PEER_NOT_OBSERVED":
-        case "CLAUDE_PEER_NOT_OBSERVED":
-            return "claude_not_observed";
-        case "CONNECTOR_OFFLINE":
-            return "connector_offline";
-        case "ROUTE_STALE":
-            return "route_stale";
-        case "QUEUE_STALLED":
-            return "queue_stalled";
-        case "CLAUDE_NATIVE_ACK_UNAVAILABLE":
-        case "CLAUDE_RECEIPT_UNCONFIRMED":
-            return "unconfirmed";
-        case "ADAPTER_DEGRADED":
-        case "ROUTE_DEGRADED":
-            return "degraded";
-        default:
-            return "generic";
-    }
-}
-function recipientIsUnobserved(route) {
-    return (route.provider === "claude" &&
-        (route.safeErrorCode === "CLAUDE_PEER_NOT_OBSERVED" ||
-            route.safeErrorCode === "PEER_NOT_OBSERVED"));
-}
-function queueAge(depth, oldestQueuedAt, generatedAt) {
-    if (depth === 0 || oldestQueuedAt === undefined || generatedAt === undefined) {
-        return undefined;
-    }
-    const elapsed = Date.parse(generatedAt) - Date.parse(oldestQueuedAt);
-    return Number.isSafeInteger(elapsed) && elapsed >= 0 ? elapsed : undefined;
-}
-function messageKey(message) {
-    return [
-        message.direction,
-        boundedText(message.sourceAlias),
-        boundedText(message.targetAlias),
-        typeof message.messageIdSuffix === "string" ? message.messageIdSuffix : "",
-    ].join("\0");
-}
-function buildMessageGroups(messages, includeBodies) {
-    const grouped = new Map();
-    for (const message of messages) {
-        const key = messageKey(message);
-        const events = grouped.get(key);
-        if (events === undefined)
-            grouped.set(key, [message]);
-        else
-            events.push(message);
-    }
-    const all = [...grouped.values()]
-        .map((events) => {
-        const ordered = [...events].sort((left, right) => {
-            const byTime = compareText(normalizedTimestamp(left.timestamp) ?? "", normalizedTimestamp(right.timestamp) ?? "");
-            return byTime ||
-                (normalizedInteger(left.sequence) ?? 0) -
-                    (normalizedInteger(right.sequence) ?? 0);
-        });
-        const latest = ordered[ordered.length - 1];
-        const allEvents = ordered.map((event) => ({
-            sequence: normalizedInteger(event.sequence) ?? 0,
-            ...(normalizedTimestamp(event.timestamp) === undefined
-                ? {}
-                : { timestamp: normalizedTimestamp(event.timestamp) }),
-            state: event.state,
-            ...(normalizedInteger(event.latencyMs) === undefined
-                ? {}
-                : { latencyMs: normalizedInteger(event.latencyMs) }),
-            ...(safeCode(event.safeErrorCode) === undefined
-                ? {}
-                : { safeErrorCode: safeCode(event.safeErrorCode) }),
-            ...(typeof event.conversationIdSuffix === "string" &&
-                CONVERSATION_SUFFIX_PATTERN.test(event.conversationIdSuffix)
-                ? { conversationIdSuffix: event.conversationIdSuffix }
-                : {}),
-            ...(event.steer === true ? { steer: true } : {}),
-        }));
-        return {
-            direction: latest.direction,
-            sourceAlias: boundedText(latest.sourceAlias),
-            targetAlias: boundedText(latest.targetAlias),
-            ...(typeof latest.messageIdSuffix === "string" &&
-                OPAQUE_SUFFIX_PATTERN.test(latest.messageIdSuffix)
-                ? { messageIdSuffix: latest.messageIdSuffix.toLowerCase() }
-                : {}),
-            ...(typeof latest.conversationIdSuffix === "string" &&
-                CONVERSATION_SUFFIX_PATTERN.test(latest.conversationIdSuffix)
-                ? { conversationIdSuffix: latest.conversationIdSuffix }
-                : {}),
-            state: latest.state,
-            ...(normalizedTimestamp(latest.timestamp) === undefined
-                ? {}
-                : { timestamp: normalizedTimestamp(latest.timestamp) }),
-            ...(normalizedInteger(latest.latencyMs) === undefined
-                ? {}
-                : { latencyMs: normalizedInteger(latest.latencyMs) }),
-            bytes: normalizedInteger(latest.bytes) ?? 0,
-            ...(safeCode(latest.safeErrorCode) === undefined
-                ? {}
-                : { safeErrorCode: safeCode(latest.safeErrorCode) }),
-            ...(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.
-            ...(includeBodies &&
-                typeof latest.body === "string" && latest.body.length > 0
-                ? { body: boundedText(latest.body, 4096) }
-                : {}),
-            events: allEvents,
-        };
-    })
-        .sort((left, right) => compareText(right.timestamp ?? "", left.timestamp ?? "") ||
-        compareText(left.sourceAlias, right.sourceAlias));
-    let eventBudget = DASHBOARD_MODEL_LIMITS.messageEvents;
-    let omittedEvents = 0;
-    const displayedGroups = all.slice(0, DASHBOARD_MODEL_LIMITS.messages);
-    const visibleGroups = displayedGroups.map((group, index) => {
-        const groupsAfterThis = displayedGroups.length - index - 1;
-        const availableForThis = Math.max(1, eventBudget - groupsAfterThis);
-        const retained = Math.min(availableForThis, group.events.length);
-        eventBudget -= retained;
-        omittedEvents += group.events.length - retained;
-        return {
-            ...group,
-            events: retained === 0 ? [] : group.events.slice(-retained),
-        };
-    });
-    return {
-        groups: visibleGroups,
-        omittedGroups: Math.max(0, all.length - DASHBOARD_MODEL_LIMITS.messages),
-        omittedEvents,
-        activeGroups: all.filter((message) => ["queued", "dispatching", "transport_written", "held"].includes(message.state)).length,
-    };
-}
-function buildProjectedDashboardViewModel(snapshot, includeBodies) {
-    const generatedAt = normalizedTimestamp(snapshot.generatedAt);
-    const inboundMode = snapshot.inboundMode === "open" ? "open" : "paired";
-    const validPeers = arePublicAvailablePeerSnapshots(snapshot.availablePeers)
-        ? snapshot.availablePeers
-        : [];
-    const peers = validPeers
-        .map((peer) => ({
-        alias: boundedText(peer.alias),
-        host: boundedText(peer.host),
-        state: peer.state,
-        validated: peer.validated,
-        selected: peer.selected,
-        selectable: peerIsSelectable(peer),
-        ...(peerSelectionGuidance(peer) === undefined
-            ? {}
-            : { selectionGuidance: peerSelectionGuidance(peer) }),
-        ...(normalizedTimestamp(peer.lastSeenAt) === undefined
-            ? {}
-            : { lastSeenAt: normalizedTimestamp(peer.lastSeenAt) }),
-        ...(safeCode(peer.safeErrorCode) === undefined
-            ? {}
-            : { safeErrorCode: safeCode(peer.safeErrorCode) }),
-    }))
-        .sort((left, right) => {
-        if (left.selected !== right.selected)
-            return left.selected ? -1 : 1;
-        return compareText(left.alias, right.alias);
-    })
-        .slice(0, DASHBOARD_MODEL_LIMITS.availablePeers);
-    const allBrokerActivity = (snapshot.activityEvents ?? []).flatMap((event) => {
-        const timestamp = normalizedTimestamp(event.timestamp);
-        const sequence = normalizedInteger(event.sequence);
-        if (timestamp === undefined ||
-            sequence === undefined ||
-            sequence < 1 ||
-            !isDashboardActivityKind(event.kind) ||
-            !isDashboardActivityAction(event.action)) {
-            return [];
-        }
-        return [
-            {
-                sequence,
-                timestamp,
-                kind: event.kind,
-                action: event.action,
-                outcome: event.outcome,
-                aliases: event.aliases.map((alias) => boundedText(alias)).slice(0, 2),
-                operatorAction: event.operatorAction,
-                ...(safeCode(event.safeErrorCode) === undefined
-                    ? {}
-                    : { safeErrorCode: safeCode(event.safeErrorCode) }),
-            },
-        ];
-    });
-    const brokerActivity = allBrokerActivity.slice(-DASHBOARD_MODEL_LIMITS.activityEvents);
-    const allRoutes = snapshot.routes.map((route) => {
-        const depth = normalizedInteger(route.queueDepth) ?? 0;
-        const oldestQueuedAt = normalizedTimestamp(route.oldestQueuedAt);
-        const age = queueAge(depth, oldestQueuedAt, generatedAt);
-        return {
-            alias: boundedText(route.alias),
-            provider: route.provider,
-            host: boundedText(route.host),
-            enabled: Boolean(route.enabled),
-            state: route.state,
-            queueDepth: depth,
-            ...(oldestQueuedAt === undefined ? {} : { oldestQueuedAt }),
-            ...(age === undefined ? {} : { queueAgeMs: age }),
-            counters: normalizedCounters(route.counters),
-            ...(normalizedTimestamp(route.lastSeenAt) === undefined
-                ? {}
-                : { lastSeenAt: normalizedTimestamp(route.lastSeenAt) }),
-            ...(safeCode(route.safeErrorCode) === undefined
-                ? {}
-                : { safeErrorCode: safeCode(route.safeErrorCode) }),
-            mutable: route.mutable !== false,
-        };
-    });
-    const routes = [...allRoutes]
-        .sort((left, right) => routePriority(left) - routePriority(right) ||
-        compareText(left.alias, right.alias))
-        .slice(0, DASHBOARD_MODEL_LIMITS.routes);
-    const routeByEndpoint = new Map(allRoutes.map((route) => [`${route.provider}\0${route.alias}`, route]));
-    const allConsentEdges = snapshot.consentEdges
-        .map((edge) => {
-        const endpoints = edge.endpoints.map((endpoint) => ({
-            alias: boundedText(endpoint.alias),
-            provider: endpoint.provider,
-        }));
-        const routes = endpoints.map((endpoint) => routeByEndpoint.get(`${endpoint.provider}\0${endpoint.alias}`));
-        const bothPresent = routes.every((route) => route !== undefined);
-        return {
-            endpoints,
-            host: boundedText(edge.host),
-            state: bothPresent &&
-                routes.every((route) => route !== undefined && routeIsReady(route))
-                ? "ready"
-                : bothPresent
-                    ? "degraded"
-                    : "unavailable",
-            counters: normalizedCounters(edge.counters),
-            mutable: edge.mutable !== false,
-        };
-    })
-        .sort((left, right) => compareText(left.endpoints[0].provider, right.endpoints[0].provider) ||
-        compareText(left.endpoints[0].alias, right.endpoints[0].alias) ||
-        compareText(left.endpoints[1].provider, right.endpoints[1].provider) ||
-        compareText(left.endpoints[1].alias, right.endpoints[1].alias));
-    const consentEdges = allConsentEdges.slice(0, DASHBOARD_MODEL_LIMITS.consentEdges);
-    const allWatches = (snapshot.progressWatches ?? [])
-        .flatMap((watch) => {
-        const lastActivityAt = normalizedTimestamp(watch.lastActivityAt);
-        const nextActionAt = normalizedTimestamp(watch.nextActionAt);
-        const generatedAtMs = generatedAt === undefined ? undefined : Date.parse(generatedAt);
-        if (!CONVERSATION_SUFFIX_PATTERN.test(watch.conversationIdSuffix) ||
-            lastActivityAt === undefined ||
-            nextActionAt === undefined ||
-            generatedAtMs === undefined) {
-            return [];
-        }
-        if (watch.nudgeCount !== 0 &&
-            watch.nudgeCount !== 1 &&
-            watch.nudgeCount !== 2) {
-            return [];
-        }
-        return [
-            {
-                conversationIdSuffix: watch.conversationIdSuffix,
-                ownerAlias: boundedText(watch.ownerAlias),
-                workerAlias: boundedText(watch.workerAlias),
-                lastActivityAt,
-                nextActionAt,
-                idleForMs: Math.max(0, generatedAtMs - Date.parse(lastActivityAt)),
-                dueInMs: Math.max(0, Date.parse(nextActionAt) - generatedAtMs),
-                nudgeCount: watch.nudgeCount,
-            },
-        ];
-    })
-        .sort((left, right) => compareText(left.nextActionAt, right.nextActionAt) ||
-        compareText(left.ownerAlias, right.ownerAlias) ||
-        compareText(left.workerAlias, right.workerAlias));
-    const watches = allWatches.slice(0, DASHBOARD_MODEL_LIMITS.progressWatches);
-    const allWatchEvents = (snapshot.progressWatchEvents ?? [])
-        .flatMap((event) => {
-        const timestamp = normalizedTimestamp(event.timestamp);
-        if (timestamp === undefined ||
-            !CONVERSATION_SUFFIX_PATTERN.test(event.conversationIdSuffix) ||
-            normalizedInteger(event.sequence) === undefined) {
-            return [];
-        }
-        return [
-            {
-                sequence: event.sequence,
-                timestamp,
-                conversationIdSuffix: event.conversationIdSuffix,
-                ownerAlias: boundedText(event.ownerAlias),
-                workerAlias: boundedText(event.workerAlias),
-                kind: event.kind,
-                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) => {
-        const registry = isPublicRegistryObservationSnapshot(connector.registry)
-            ? connector.registry
-            : undefined;
-        return {
-            provider: connector.provider,
-            host: boundedText(connector.host),
-            health: connector.health,
-            ...(safeProtocol(connector.protocol) === undefined
-                ? {}
-                : { protocol: safeProtocol(connector.protocol) }),
-            ...(safeProtocol(connector.protocolVersion) === undefined
-                ? {}
-                : { protocolVersion: safeProtocol(connector.protocolVersion) }),
-            ...(normalizedTimestamp(connector.lastSeenAt) === undefined
-                ? {}
-                : { lastSeenAt: normalizedTimestamp(connector.lastSeenAt) }),
-            ...(connector.codexDoctor === undefined
-                ? {}
-                : {
-                    codexDoctor: {
-                        conditions: [...connector.codexDoctor.conditions],
-                    },
-                }),
-            ...(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 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)
-        .sort((left, right) => right.queueAgeMs - left.queueAgeMs);
-    const oldest = queuedWithAge[0];
-    const activeDeliveries = messages.activeGroups;
-    const routesByProvider = Object.fromEntries(gatewayProviders.map((provider) => [
-        provider,
-        allRoutes.filter((route) => route.provider === provider),
-    ]));
-    const readyByProvider = Object.fromEntries(gatewayProviders.map((provider) => [
-        provider,
-        routesByProvider[provider].filter(routeIsReady).length,
-    ]));
-    const pairedAliasesByProvider = Object.fromEntries(gatewayProviders.map((provider) => [provider, new Set()]));
-    for (const edge of allConsentEdges) {
-        for (const endpoint of edge.endpoints) {
-            pairedAliasesByProvider[endpoint.provider].add(endpoint.alias);
-        }
-    }
-    const readyConsentEdges = allConsentEdges.filter((edge) => edge.state === "ready");
-    const consentEdgeCountIsLowerBound = (normalizedInteger(snapshot.truncation.consentEdges) ?? 0) > 0;
-    const hasConsentEvidence = allConsentEdges.length > 0 || consentEdgeCountIsLowerBound;
-    const graph = {
-        consentEdgeCount: allConsentEdges.length,
-        readyConsentEdgeCount: readyConsentEdges.length,
-        consentEdgeCountIsLowerBound,
-        unpairedReadyByProvider: Object.fromEntries(gatewayProviders.map((provider) => [
-            provider,
-            routesByProvider[provider].filter((route) => routeIsReady(route) &&
-                !pairedAliasesByProvider[provider].has(route.alias)).length,
-        ])),
-    };
-    const selectedPeers = validPeers.filter((peer) => peer.selected && peerIsSelectable(peer));
-    const selectablePeers = validPeers.filter(peerIsSelectable);
-    const selectedClaudeCount = Math.max(selectedPeers.filter((peer) => peer.provider === "claude").length, readyByProvider.claude);
-    const readyPairedByProvider = Object.fromEntries(gatewayProviders.map((provider) => [
-        provider,
-        routesByProvider[provider].some((route) => routeIsReady(route) &&
-            pairedAliasesByProvider[provider].has(route.alias)),
-    ]));
-    const claudeNextAction = selectedClaudeCount > 0 &&
-        (readyPairedByProvider.claude ||
-            (consentEdgeCountIsLowerBound && readyByProvider.claude > 0))
-        ? "none"
-        : readyByProvider.claude > 0
-            ? "pair_routes"
-            : validPeers.length === 0
-                ? "discover_claude"
-                : selectablePeers.length > 0
-                    ? !hasConsentEvidence
-                        ? "pair_routes"
-                        : "restore_claude"
-                    : selectedPeers.length > 0
-                        ? "restore_claude"
-                        : "repair_claude_inventory";
-    const codexNextAction = readyPairedByProvider.codex ||
-        (consentEdgeCountIsLowerBound && readyByProvider.codex > 0)
-        ? "none"
-        : readyByProvider.codex > 0
-            ? "pair_routes"
-            : routesByProvider.codex.length === 0
-                ? "register_codex"
-                : "none";
-    const parties = gatewayProviders.map((provider) => {
-        const providerPeers = validPeers.filter((peer) => peer.provider === provider);
-        const providerRoutes = routesByProvider[provider];
-        const ready = provider === "claude"
-            ? selectedClaudeCount
-            : readyByProvider[provider];
-        const nextAction = provider === "claude"
-            ? claudeNextAction
-            : provider === "codex"
-                ? codexNextAction
-                : readyPairedByProvider[provider]
-                    ? "none"
-                    : ready > 0
-                        ? "pair_routes"
-                        : "none";
-        return {
-            kind: provider,
-            status: provider === "claude" && ready > 0 && partyStatus(providerRoutes, ready) === "missing"
-                ? "attention"
-                : partyStatus(providerRoutes, ready),
-            total: provider === "claude" ? providerPeers.length : providerRoutes.length,
-            ready,
-            ...(provider === "claude"
-                ? { selectable: selectablePeers.filter((peer) => peer.provider === provider).length }
-                : {}),
-            countIsLowerBound: (normalizedInteger(snapshot.truncation.routes) ?? 0) > 0 ||
-                (provider === "claude" &&
-                    (normalizedInteger(snapshot.truncation.availablePeers) ?? 0) > 0),
-            ...(providerPeers.find((peer) => peer.selected)?.alias === undefined
-                ? providerRoutes[0]?.alias === undefined
-                    ? {}
-                    : { primaryAlias: boundedText(providerRoutes[0].alias) }
-                : { primaryAlias: boundedText(providerPeers.find((peer) => peer.selected).alias) }),
-            nextAction,
-        };
-    });
-    const explicitAlerts = snapshot.alerts
-        .map((alert) => {
-        const code = safeCode(alert.code);
-        const route = code === "QUEUE_STALLED" && typeof alert.alias === "string" &&
-            alert.provider !== undefined
-            ? routeByEndpoint.get(`${alert.provider}\0${alert.alias}`)
-            : undefined;
-        return {
-            kind: "alert",
-            ...(code === undefined ? {} : { code }),
-            severity: alert.severity === "error" ||
-                alert.severity === "warning" ||
-                alert.severity === "info"
-                ? alert.severity
-                : "warning",
-            ...(normalizedTimestamp(alert.timestamp) === undefined
-                ? {}
-                : { timestamp: normalizedTimestamp(alert.timestamp) }),
-            ...(alert.provider === undefined ? {} : { provider: alert.provider }),
-            ...(typeof alert.alias === "string"
-                ? { alias: boundedText(alert.alias) }
-                : {}),
-            ...(typeof alert.host === "string"
-                ? { host: boundedText(alert.host) }
-                : {}),
-            ...(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: guidanceFor(code),
-        };
-    })
-        .sort((left, right) => alertPriority(left.severity) - alertPriority(right.severity) ||
-        compareText(right.timestamp ?? "", left.timestamp ?? ""));
-    const attentionCandidates = [...explicitAlerts];
-    const unavailableConsentEdgeScopes = new Set();
-    for (const edge of allConsentEdges) {
-        if (edge.state !== "unavailable")
-            continue;
-        for (const endpoint of edge.endpoints) {
-            if (routeByEndpoint.has(`${endpoint.provider}\0${endpoint.alias}`))
-                continue;
-            const scope = `${endpoint.provider}\0${endpoint.alias}\0${edge.host}`;
-            if (unavailableConsentEdgeScopes.has(scope))
-                continue;
-            unavailableConsentEdgeScopes.add(scope);
-            attentionCandidates.push({
-                kind: "route",
-                severity: "warning",
-                provider: endpoint.provider,
-                alias: endpoint.alias,
-                host: edge.host,
-                guidance: "consent_edge_unavailable",
-            });
-        }
-    }
-    for (const route of allRoutes) {
-        const writes = messages.groups.filter(({ direction, targetAlias, state, timestamp }) => parseDirection(direction)?.targetProvider === "claude" &&
-            targetAlias === route.alias && state === "delivered" &&
-            timestamp !== undefined);
-        // Groups arrive newest-first. The oldest unconsumed write owns the notice:
-        // a fresh write to the same recipient is not evidence that an hours-old one
-        // was ever read.
-        const write = writes[writes.length - 1];
-        if (generatedAt === undefined || write?.timestamp === undefined ||
-            !recipientIsUnobserved(route) ||
-            Date.parse(generatedAt) - Date.parse(write.timestamp) <
-                120_000)
-            continue;
-        const item = {
-            kind: "route",
-            code: route.safeErrorCode,
-            severity: "warning",
-            ...(route.lastSeenAt === undefined ? {} : { timestamp: route.lastSeenAt }),
-            provider: route.provider,
-            alias: route.alias,
-            host: route.host,
-            guidance: "recipient_waiting_input",
-        };
-        const existingIndex = attentionCandidates.findIndex((candidate) => candidate.provider === item.provider &&
-            candidate.alias === item.alias &&
-            (candidate.code === "CLAUDE_PEER_NOT_OBSERVED" ||
-                candidate.code === "PEER_NOT_OBSERVED"));
-        if (existingIndex === -1)
-            attentionCandidates.push(item);
-        else
-            attentionCandidates[existingIndex] = item;
-    }
-    for (const watch of allWatches) {
-        if (watch.nudgeCount === 0)
-            continue;
-        attentionCandidates.push({
-            kind: "watch",
-            code: "PROGRESS_WATCH_QUIET",
-            severity: "warning",
-            timestamp: watch.lastActivityAt,
-            alias: watch.workerAlias,
-            guidance: "progress_watch",
-        });
-    }
-    const representedScopes = new Set(attentionCandidates.map((item) => `${item.provider ?? ""}\0${item.alias ?? ""}\0${item.host ?? ""}`));
-    for (const route of allRoutes) {
-        if (routeIsReady(route)) {
-            continue;
-        }
-        const scope = `${route.provider}\0${route.alias}\0${route.host}`;
-        if (representedScopes.has(scope))
-            continue;
-        attentionCandidates.push({
-            kind: "route",
-            ...(route.safeErrorCode === undefined ? {} : { code: route.safeErrorCode }),
-            severity: route.state === "offline" ? "error" : "warning",
-            ...(route.lastSeenAt === undefined ? {} : { timestamp: route.lastSeenAt }),
-            provider: route.provider,
-            alias: route.alias,
-            host: route.host,
-            guidance: "route_stale",
-        });
-        representedScopes.add(scope);
-    }
-    for (const connector of connectors) {
-        if (connector.health === "healthy")
-            continue;
-        const scope = `${connector.provider}\0\0${connector.host}`;
-        if (representedScopes.has(scope))
-            continue;
-        attentionCandidates.push({
-            kind: "connector",
-            ...(connector.safeErrorCode === undefined
-                ? {}
-                : { code: connector.safeErrorCode }),
-            severity: connector.health === "degraded" ? "warning" : "error",
-            ...(connector.lastSeenAt === undefined
-                ? {}
-                : { timestamp: connector.lastSeenAt }),
-            provider: connector.provider,
-            host: connector.host,
-            guidance: connector.health === "offline"
-                ? "connector_offline"
-                : "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") &&
-        !attentionCandidates.some((item) => item.kind === "broker")) {
-        attentionCandidates.push({
-            kind: "broker",
-            severity: snapshot.health === "degraded" ? "warning" : "error",
-            guidance: snapshot.health === "offline" ? "connector_offline" : "degraded",
-        });
-    }
-    const attention = attentionCandidates.slice(0, DASHBOARD_MODEL_LIMITS.alerts);
-    const setupComplete = hasConsentEvidence;
-    const hasDegradedConsentEdge = allConsentEdges.some((edge) => edge.state !== "ready");
-    const overall = attentionCandidates.length > 0 ||
-        (normalizedInteger(snapshot.truncation.alerts) ?? 0) > 0 ||
-        hasDegradedConsentEdge
-        ? "attention"
-        : setupComplete
-            ? "ready"
-            : "setup";
-    const omissions = {
-        connectors: boundedAdd(normalizedInteger(snapshot.truncation.connectors) ?? 0, Math.max(0, snapshot.connectors.length - DASHBOARD_MODEL_LIMITS.connectors)),
-        availablePeers: boundedAdd(normalizedInteger(snapshot.truncation.availablePeers) ?? 0, Math.max(0, validPeers.length - DASHBOARD_MODEL_LIMITS.availablePeers)),
-        routes: boundedAdd(normalizedInteger(snapshot.truncation.routes) ?? 0, Math.max(0, allRoutes.length - DASHBOARD_MODEL_LIMITS.routes)),
-        consentEdges: boundedAdd(normalizedInteger(snapshot.truncation.consentEdges) ?? 0, Math.max(0, allConsentEdges.length - DASHBOARD_MODEL_LIMITS.consentEdges)),
-        progressWatches: boundedAdd(normalizedInteger(snapshot.truncation.progressWatches) ?? 0, Math.max(0, allWatches.length - DASHBOARD_MODEL_LIMITS.progressWatches)),
-        upstreamProgressWatchEvents: normalizedInteger(snapshot.truncation.progressWatchEvents) ?? 0,
-        progressWatchEvents: Math.max(0, allWatchEvents.length - DASHBOARD_MODEL_LIMITS.progressWatchEvents),
-        upstreamMessageEvents: normalizedInteger(snapshot.truncation.messages) ?? 0,
-        messageGroups: messages.omittedGroups,
-        messageEvents: messages.omittedEvents,
-        upstreamAlerts: normalizedInteger(snapshot.truncation.alerts) ?? 0,
-        attentionItems: Math.max(0, attentionCandidates.length - DASHBOARD_MODEL_LIMITS.alerts),
-        upstreamActivityEvents: normalizedInteger(snapshot.truncation.activityEvents) ?? 0,
-        activityEvents: Math.max(0, allBrokerActivity.length - DASHBOARD_MODEL_LIMITS.activityEvents),
-    };
-    return {
-        schemaVersion: 2,
-        ...(generatedAt === undefined ? {} : { generatedAt }),
-        inboundMode,
-        health: snapshot.health,
-        overall,
-        exchange: {
-            parties,
-            queuedMessages,
-            queueCountIsLowerBound: (normalizedInteger(snapshot.truncation.routes) ?? 0) > 0,
-            ...(oldest === undefined
-                ? {}
-                : {
-                    oldestQueueAgeMs: oldest.queueAgeMs,
-                    oldestQueuedAt: oldest.oldestQueuedAt,
-                }),
-        },
-        attention,
-        transit: {
-            queuedMessages,
-            activeDeliveries,
-            queueCountIsLowerBound: (normalizedInteger(snapshot.truncation.routes) ?? 0) > 0,
-            activeCountIsLowerBound: (normalizedInteger(snapshot.truncation.messages) ?? 0) > 0,
-            ...(oldest === undefined
-                ? {}
-                : {
-                    oldestQueueAgeMs: oldest.queueAgeMs,
-                    oldestQueuedAt: oldest.oldestQueuedAt,
-                }),
-        },
-        activity: messages.groups,
-        brokerActivity,
-        peers,
-        routes,
-        consentEdges,
-        watches,
-        watchEvents,
-        graph,
-        connectors,
-        accounting: {
-            accepted: normalizedInteger(snapshot.accounting.accepted) ?? 0,
-            duplicates: normalizedInteger(snapshot.accounting.duplicates) ?? 0,
-            delivered: normalizedInteger(snapshot.accounting.delivered) ?? 0,
-            unconfirmed: normalizedInteger(snapshot.accounting.unconfirmed) ?? 0,
-            failed: normalizedInteger(snapshot.accounting.failed) ?? 0,
-            ambiguous: normalizedInteger(snapshot.accounting.ambiguous) ?? 0,
-            expired: normalizedInteger(snapshot.accounting.expired) ?? 0,
-            cancelled: normalizedInteger(snapshot.accounting.cancelled) ?? 0,
-            abandoned: normalizedInteger(snapshot.accounting.abandoned) ?? 0,
-            rejected: normalizedInteger(snapshot.accounting.rejected) ?? 0,
-            bytesAccepted: normalizedInteger(snapshot.accounting.bytesAccepted) ?? 0,
-            queuedBytes: normalizedInteger(snapshot.accounting.queuedBytes) ?? 0,
-        },
-        ...(snapshot.deadlinePressure === undefined
-            ? {}
-            : { deadlinePressure: snapshot.deadlinePressure }),
-        omissions,
-    };
-}
-//# sourceMappingURL=dashboard-model.js.map