agent-embassy 2.0.1 → 3.1.0

package/dist/src/gateway/control.js

@@ -4,10 +4,10 @@ import { chmod, lstat, mkdtemp, realpath, rename, rmdir, unlink } from "node:fs/
 import net from "node:net";
 import path from "node:path";
 import { TextDecoder } from "node:util";
-import { CONNECTOR_OBSERVATION_STALE_AFTER_MS, GATEWAY_PUBLIC_SNAPSHOT_BYTE_BUDGET, gatewayProviders, gatewayPublicSnapshotLimits, isGatewayProvider, isMessageDirection, isPublicRegistryObservationSnapshot, } from "./types.js";
-import { decodePeerParams, decodePeerResult } from "./peer-protocol.js";
+import { CONNECTOR_OBSERVATION_STALE_AFTER_MS, GATEWAY_PUBLIC_SNAPSHOT_BYTE_BUDGET, gatewayPublicSnapshotLimits, isGatewayProvider, isMessageDirection, isPublicRegistryObservationSnapshot, } from "./types.js";
+import { decodePeerParams, decodePeerResult, isPeerHandoffRefusal } from "./peer-protocol.js";
 import { isPeerMailboxAwaitResult } from "./peer-mailbox.js";
-export const GATEWAY_CONTROL_PROTOCOL_VERSION = 2;
+export const GATEWAY_CONTROL_PROTOCOL_VERSION = 4;
 export const GATEWAY_CONTROL_MAX_FRAME_BYTES = 32 * 1024;
 export const GATEWAY_CONTROL_MAX_RESPONSE_BYTES = 256 * 1024;
 export const GATEWAY_CONTROL_MAX_MESSAGE_BYTES = 16 * 1024;
@@ -30,12 +30,16 @@ const MESSAGE_SUFFIX_PATTERN = /^[0-9a-f]{8}$/;
 const CONVERSATION_SUFFIX_PATTERN = /^[A-Za-z0-9_-]{8}$/;
 const ISO_TIMESTAMP_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/;
 export const gatewayControlMethods = [
-    "health", "register_codex", "unregister_codex", "remove_codex_registration",
-    "select_claude", "unselect_claude", "pair", "unpair", "list_snapshot",
-    "observe_snapshot", "delivery_status", "untrack", "send", "reply",
-    "refresh_dashboard", "peer_catalog", "peer_handoff",
+    "health", "register_codex", "unregister_codex", "list_snapshot",
+    "observe_snapshot", "delivery_status", "send",
+    "refresh_discovery", "peer_catalog", "peer_handoff",
     "register_peer", "unregister_peer", "await_peer", "peer_receipt",
+    "retire_route",
 ];
+/** Bounds on an ephemeral peer registration's lifetime, in milliseconds. */
+export const GATEWAY_EPHEMERAL_PEER_TTL_DEFAULT_MS = 300_000;
+export const GATEWAY_EPHEMERAL_PEER_TTL_MIN_MS = 1_000;
+export const GATEWAY_EPHEMERAL_PEER_TTL_MAX_MS = 3_600_000;
 const WIRE_ERROR_MESSAGES = {
     INVALID_JSON: "The control frame is not valid JSON.", FRAME_TOO_LARGE: "The control frame exceeds the size limit.",
     INVALID_REQUEST: "The control request is invalid.", UNSUPPORTED_VERSION: "The control protocol version is unsupported.",
@@ -129,12 +133,6 @@ function isNonNegativeInteger(value) {
         value >= 0 &&
         value <= MAX_REVISION);
 }
-function isTrackIdleMinutes(value) {
-    return (typeof value === "number" &&
-        Number.isSafeInteger(value) &&
-        value >= 1 &&
-        value <= 24 * 60);
-}
 function isIsoTimestamp(value) {
     if (typeof value !== "string" || !ISO_TIMESTAMP_PATTERN.test(value)) {
         return false;
@@ -159,7 +157,6 @@ function isMessageText(value) {
 }
 const exact = hasExactKeys;
 const nonNegative = isNonNegativeInteger;
-const trackMinutes = isTrackIdleMinutes;
 const iso = isIsoTimestamp;
 const uuid = isUuid;
 const alias = isAlias;
@@ -200,9 +197,20 @@ function decodePeerHandoff(value) {
     }
 }
 function decodeRegisterPeer(value) {
-    if (!shape(value, { alias: peerAlias }, { token: peerToken }))
+    // `ephemeral` belongs only to a first registration: re-presenting a token
+    // proves an existing route, and an existing route's lifetime is already
+    // fixed. `ttlMs` without `ephemeral` would name a lifetime nothing honours.
+    if (!shape(value, { alias: peerAlias }, { token: peerToken, ephemeral: oneOf(true),
+        ttlMs: (item) => Number.isSafeInteger(item) &&
+            Number(item) >= GATEWAY_EPHEMERAL_PEER_TTL_MIN_MS &&
+            Number(item) <= GATEWAY_EPHEMERAL_PEER_TTL_MAX_MS }) ||
+        (value.ephemeral !== undefined && value.token !== undefined) ||
+        (value.ttlMs !== undefined && value.ephemeral === undefined))
         invalid();
-    return { alias: value.alias, ...(value.token === undefined ? {} : { token: value.token }) };
+    return { alias: value.alias,
+        ...(value.token === undefined ? {} : { token: value.token }),
+        ...(value.ephemeral === undefined ? {} : { ephemeral: true }),
+        ...(value.ttlMs === undefined ? {} : { ttlMs: value.ttlMs }) };
 }
 function decodePeerPrincipal(value) {
     if (!shape(value, { alias: peerAlias, token: peerToken }))
@@ -225,6 +233,8 @@ const isPeerCatalog = (value) => {
     }
 };
 const isPeerHandoffResult = (value) => {
+    if (isPeerHandoffRefusal(value))
+        return true;
     try {
         decodePeerResult("handoff", value);
         return true;
@@ -251,79 +261,40 @@ function decodeUnregister(value) {
         invalid();
     return { alias: value.alias, threadId: value.threadId.toLowerCase() };
 }
-function decodeRemoval(value) {
-    if (!shape(value, { alias }) || !value.alias.startsWith("codex-"))
-        invalid();
-    return { alias: value.alias };
-}
-function decodeSelection(value) {
-    if (!isRecord(value) || !exact(value, ["alias"]) ||
-        typeof value.alias !== "string" || !isClaudeSessionSelector(value.alias))
-        invalid();
-    return { alias: UUID_PATTERN.test(value.alias) ? value.alias.toLowerCase() : value.alias };
-}
-function decodePair(value) {
-    if (!isRecord(value) || !exact(value, ["aliases"]) || !Array.isArray(value.aliases) ||
-        value.aliases.length !== 2 || !alias(value.aliases[0]) || !alias(value.aliases[1]) ||
-        value.aliases[0] === value.aliases[1])
-        invalid();
-    return { aliases: [value.aliases[0], value.aliases[1]] };
-}
 function decodeSend(value) {
-    if (!isRecord(value) || !exact(value, ["fromAlias", "toAlias", "text"], ["threadId", "replyAddress", "peerToken", "expectsReply", "trackIdleMinutes"]) ||
-        !alias(value.fromAlias) || typeof value.toAlias !== "string" || !isClaudeSessionSelector(value.toAlias) ||
-        !messageText(value.text) || [value.threadId, value.replyAddress, value.peerToken].filter((item) => item !== undefined).length !== 1 ||
+    if (!isRecord(value) || !exact(value, ["fromAlias", "text"], ["toAlias", "conversationId", "threadId", "replyAddress", "peerToken", "expectsReply"]) ||
+        !alias(value.fromAlias) || !messageText(value.text) ||
+        [value.toAlias, value.conversationId].filter((item) => item !== undefined).length !== 1 ||
+        (value.toAlias !== undefined && (typeof value.toAlias !== "string" || !isClaudeSessionSelector(value.toAlias))) ||
+        (value.conversationId !== undefined && (typeof value.conversationId !== "string" || !isGatewayConversationId(value.conversationId))) ||
+        [value.threadId, value.replyAddress, value.peerToken].filter((item) => item !== undefined).length !== 1 ||
         (value.threadId !== undefined && !uuid(value.threadId)) ||
         (value.replyAddress !== undefined && (typeof value.replyAddress !== "string" || !isGatewayReplyAddress(value.replyAddress))) ||
         (value.peerToken !== undefined && !peerToken(value.peerToken)) ||
-        (value.expectsReply !== undefined && typeof value.expectsReply !== "boolean") ||
-        (value.trackIdleMinutes !== undefined && !trackMinutes(value.trackIdleMinutes)))
+        (value.expectsReply !== undefined &&
+            (typeof value.expectsReply !== "boolean" || value.conversationId !== undefined)))
         invalid();
     const authority = value.threadId !== undefined ? { threadId: value.threadId.toLowerCase() }
         : value.replyAddress !== undefined ? { replyAddress: value.replyAddress }
             : { peerToken: value.peerToken };
-    return { fromAlias: value.fromAlias, toAlias: UUID_PATTERN.test(value.toAlias) ? value.toAlias.toLowerCase() : value.toAlias,
-        text: value.text, ...authority, expectsReply: value.expectsReply === true,
-        ...(value.trackIdleMinutes === undefined ? {} : { trackIdleMinutes: value.trackIdleMinutes }) };
-}
-function normalizeReplyCaller(value) {
-    if (!isRecord(value))
-        invalid();
-    if (value.kind === "codex" && shape(value, { kind: oneOf("codex"), alias, threadId: uuid }))
-        return { kind: "codex", alias: value.alias,
-            threadId: value.threadId.toLowerCase() };
-    if (value.kind === "claude" && isRecord(value) && exact(value, ["kind", "alias"], ["replyAddress"]) &&
-        alias(value.alias) && (value.replyAddress === undefined ||
-        (typeof value.replyAddress === "string" && isGatewayReplyAddress(value.replyAddress))))
-        return { kind: "claude", alias: value.alias,
-            ...(value.replyAddress === undefined ? {} : { replyAddress: value.replyAddress }) };
-    if (value.kind === "peer" && shape(value, { kind: oneOf("peer"), alias: peerAlias, token: peerToken }))
-        return { kind: "peer", alias: value.alias, token: value.token };
-    return invalid();
-}
-function decodeReply(value) {
-    if (!isRecord(value) || !exact(value, ["conversationId", "text", "caller"], ["trackIdleMinutes"]) ||
-        typeof value.conversationId !== "string" || !isGatewayConversationId(value.conversationId) ||
-        !messageText(value.text) ||
-        (value.trackIdleMinutes !== undefined && !trackMinutes(value.trackIdleMinutes)))
-        invalid();
-    return { conversationId: value.conversationId, text: value.text, caller: normalizeReplyCaller(value.caller),
-        ...(value.trackIdleMinutes === undefined ? {} : { trackIdleMinutes: value.trackIdleMinutes }) };
+    const target = value.conversationId !== undefined
+        ? { conversationId: value.conversationId }
+        : { toAlias: UUID_PATTERN.test(value.toAlias) ? value.toAlias.toLowerCase() : value.toAlias,
+            expectsReply: value.expectsReply === true };
+    return { fromAlias: value.fromAlias, text: value.text, ...target, ...authority };
 }
 function decodeDeliveryStatus(value) {
     if (!shape(value, { token: (item) => typeof item === "string" && DELIVERY_TOKEN_PATTERN.test(item) }))
         invalid();
     return { token: value.token };
 }
-function decodeUntrack(value) {
-    if (!shape(value, { conversationId: (item) => typeof item === "string" && CONVERSATION_ID_PATTERN.test(item) }))
+function decodeRetire(value) {
+    if (!shape(value, { alias }))
         invalid();
-    return { conversationId: value.conversationId };
+    return { alias: value.alias };
 }
 function isDecision(value) {
-    return shape(value, { accepted: (item) => typeof item === "boolean", code: oneOf("ok", "not_found", "conflict", "watch_owner_conflict", "route_mismatch", "busy", "unavailable", "rejected") }, { ownerHost: host }) && (value.accepted === true
-        ? value.code === "ok" && value.ownerHost === undefined
-        : value.code !== "ok" && (value.ownerHost === undefined || value.code === "conflict"));
+    return shape(value, { accepted: (item) => typeof item === "boolean", code: oneOf("ok", "not_found", "conflict", "route_mismatch", "busy", "unavailable", "rejected") }) && (value.accepted === true ? value.code === "ok" : value.code !== "ok");
 }
 function isRegisterPeerResult(value) {
     return isDecision(value) || shape(value, { accepted: oneOf(true), code: oneOf("ok"), token: peerToken });
@@ -332,14 +303,21 @@ function isHealthResult(value) {
     return shape(value, { status: oneOf("ok", "degraded"), revision: nonNegative });
 }
 function isSendResult(value) {
-    if (!isRecord(value) || value.accepted !== true)
-        return isDecision(value);
+    if (!isRecord(value) || value.accepted !== true) {
+        return shape(value, { accepted: oneOf(false), code: oneOf("not_found", "conflict", "route_mismatch", "busy", "unavailable", "rejected") }, { reason: safeCode });
+    }
     return shape(value, { accepted: oneOf(true), code: oneOf("ok"),
         conversationId: (item) => typeof item === "string" && CONVERSATION_ID_PATTERN.test(item),
         deliveryToken: (item) => typeof item === "string" && DELIVERY_TOKEN_PATTERN.test(item) });
 }
+function isRetireResult(value) {
+    if (isRecord(value) && value.accepted === false)
+        return isSendResult(value);
+    return shape(value, { accepted: oneOf(true), code: oneOf("ok"),
+        settlements: (counts) => shape(counts, { cancelled: nonNegative, ambiguous: nonNegative, unconfirmed: nonNegative }) });
+}
 function isRefreshResult(value) {
-    return shape(value, { accepted: (item) => typeof item === "boolean", code: oneOf("ok", "not_found", "conflict", "watch_owner_conflict", "route_mismatch", "busy", "unavailable", "rejected"), revision: nonNegative }) && isDecision({ accepted: value.accepted, code: value.code });
+    return shape(value, { accepted: (item) => typeof item === "boolean", code: oneOf("ok", "not_found", "conflict", "route_mismatch", "busy", "unavailable", "rejected"), revision: nonNegative }) && isDecision({ accepted: value.accepted, code: value.code });
 }
 const TERMINAL = new Set(["delivered", "unconfirmed", "expired", "failed", "ambiguous", "cancelled"]);
 function isDeliveryStatusResult(value) {
@@ -359,13 +337,9 @@ function isConnectorSnapshot(value) {
     if (!shape(value, { provider: isGatewayProvider, host, health: isConnectorHealth,
         protocol: (item) => typeof item === "string" && PROTOCOL_PATTERN.test(item),
         protocolVersion: (item) => typeof item === "string" && PROTOCOL_VERSION_PATTERN.test(item) }, { lastSeenAt: iso, observationAgeMs: nonNegative, safeErrorCode: safeCode,
-        registry: isPublicRegistryObservationSnapshot, codexDoctor: (item) => shape(item, {
-            conditions: (rows) => Array.isArray(rows) && rows.length > 0 && rows.length <= 2 &&
-                rows.every(oneOf("split_brain", "orphaned", "attached", "observation_stale", "managed_layout_missing", "unknown")),
-        }) }))
+        registry: isPublicRegistryObservationSnapshot }))
         return false;
-    return (value.codexDoctor === undefined || value.provider === "codex") &&
-        (value.registry === undefined || value.provider === "claude");
+    return value.registry === undefined || value.provider === "claude";
 }
 function isRouteSnapshot(value) {
     if (!shape(value, { alias, provider: isGatewayProvider, host, enabled: (item) => typeof item === "boolean",
@@ -376,24 +350,10 @@ function isRouteSnapshot(value) {
     return row.alias.endsWith(`@${row.host}`) &&
         (row.oldestQueuedAt === undefined ? row.queueDepth === 0 : row.queueDepth > 0);
 }
-function compareConsentEndpoints(left, right) {
-    return gatewayProviders.indexOf(left.provider) -
-        gatewayProviders.indexOf(right.provider) || left.alias.localeCompare(right.alias);
-}
-function isConsentEdgeSnapshot(value) {
-    const endpoint = (item) => shape(item, { alias, provider: isGatewayProvider });
-    if (!shape(value, { endpoints: (rows) => Array.isArray(rows) && rows.length === 2 && rows.every(endpoint),
-        host, counters: isRouteCounters }, { mutable: (item) => typeof item === "boolean" }))
-        return false;
-    const [left, right] = value.endpoints;
-    const hosts = [left.alias.slice(left.alias.lastIndexOf("@") + 1), right.alias.slice(right.alias.lastIndexOf("@") + 1)];
-    return left.alias !== right.alias && compareConsentEndpoints(left, right) < 0 &&
-        (left.provider !== right.provider || hosts[0] !== hosts[1]) && value.host === [...hosts].sort()[0];
-}
 function isAvailablePeerSnapshot(value) {
     return shape(value, { alias, provider: oneOf("claude"), host,
         state: oneOf("idle", "busy", "awaiting_approval", "offline"),
-        validated: (item) => typeof item === "boolean", selected: (item) => typeof item === "boolean" }, { lastSeenAt: iso, safeErrorCode: safeCode }) &&
+        validated: (item) => typeof item === "boolean", routed: (item) => typeof item === "boolean" }, { lastSeenAt: iso, safeErrorCode: safeCode }) &&
         value.alias.endsWith(`@${String(value.host)}`);
 }
 function isNormalizedMessageEvent(value) {
@@ -415,40 +375,17 @@ function isAccounting(value) {
 function isSafeAlert(value) {
     return shape(value, { code: safeCode, severity: oneOf("info", "warning", "error"), timestamp: iso }, { provider: isGatewayProvider, host, alias });
 }
-function isProgressWatchSnapshot(value) {
-    return shape(value, {
-        conversationIdSuffix: (item) => typeof item === "string" && CONVERSATION_SUFFIX_PATTERN.test(item),
-        ownerAlias: alias, workerAlias: alias, lastActivityAt: iso, nextActionAt: iso,
-        nudgeCount: oneOf(0, 1, 2),
-    }) && value.ownerAlias !== value.workerAlias;
-}
-function isProgressWatchEventSnapshot(value) {
-    if (!shape(value, { sequence: nonNegative, timestamp: iso,
-        conversationIdSuffix: (item) => typeof item === "string" && CONVERSATION_SUFFIX_PATTERN.test(item),
-        ownerAlias: alias, workerAlias: alias, kind: oneOf("opened", "replaced", "settled"),
-        actor: oneOf("owner", "worker", "operator", "gateway", "unknown") }, { reason: oneOf("done", "untracked", "idle_timeout", "tracking_disabled", "endpoint_retired", "pair_removed") }))
-        return false;
-    if (value.kind === "opened")
-        return value.actor === "owner" && value.reason === undefined;
-    if (value.kind === "replaced")
-        return (value.actor === "owner" || value.actor === "unknown") && value.reason === undefined;
-    return (value.reason === "done" && (value.actor === "owner" || value.actor === "worker")) ||
-        (value.reason === "untracked" && value.actor === "operator") ||
-        ((value.reason === "idle_timeout" || value.reason === "tracking_disabled") && value.actor === "gateway") ||
-        (value.reason === "endpoint_retired" && (value.actor === "gateway" || value.actor === "operator")) ||
-        (value.reason === "pair_removed" && value.actor === "operator");
-}
 function isGatewayActivityEvent(value) {
     if (!shape(value, { sequence: positive, timestamp: iso,
-        kind: oneOf("discovery", "selection", "registration", "pairing", "watch"),
-        action: oneOf("discovery_refreshed", "claude_selected", "claude_unselected", "codex_registered", "codex_succeeded", "codex_unregistered", "routes_paired", "routes_unpaired", "watch_ended"),
+        kind: oneOf("discovery", "registration"),
+        action: oneOf("discovery_refreshed", "codex_registered", "codex_succeeded", "codex_unregistered", "claude_route_installed", "claude_route_retired", "route_retired"),
         outcome: oneOf("accepted", "rejected"), aliases: (rows) => arrayOf(rows, 2, alias),
         operatorAction: oneOf(true) }, { safeErrorCode: safeCode }))
         return false;
     const allowed = {
-        discovery: ["discovery_refreshed"], selection: ["claude_selected", "claude_unselected"],
-        registration: ["codex_registered", "codex_succeeded", "codex_unregistered"],
-        pairing: ["routes_paired", "routes_unpaired"], watch: ["watch_ended"],
+        discovery: ["discovery_refreshed"],
+        registration: ["codex_registered", "codex_succeeded", "codex_unregistered",
+            "claude_route_installed", "claude_route_retired", "route_retired"],
     };
     return new Set(value.aliases).size === value.aliases.length &&
         (allowed[value.kind]?.includes(value.action) ?? false);
@@ -466,23 +403,20 @@ function isDeadlinePressure(value) {
         rows.reduce((sum, row) => sum + Number(row.expired), 0) === value.expiredEvents;
 }
 function isSnapshotTruncation(value) {
-    const required = ["connectors", "availablePeers", "routes", "consentEdges", "messages", "alerts"];
-    const optional = ["progressWatches", "progressWatchEvents", "activityEvents"];
+    const required = ["connectors", "availablePeers", "routes", "messages", "alerts"];
+    const optional = ["activityEvents"];
     return isRecord(value) && exact(value, required, optional) &&
         [...required, ...optional].every((key) => value[key] === undefined || nonNegative(value[key]));
 }
 export function isGatewaySnapshot(value) {
-    if (!shape(value, { schemaVersion: oneOf(2), generatedAt: iso, inboundMode: oneOf("paired", "open"),
+    if (!shape(value, { schemaVersion: oneOf(2), generatedAt: iso,
         health: isConnectorHealth,
         connectors: (rows) => arrayOf(rows, gatewayPublicSnapshotLimits.connectors, isConnectorSnapshot),
         availablePeers: (rows) => arrayOf(rows, gatewayPublicSnapshotLimits.availablePeers, isAvailablePeerSnapshot),
         routes: (rows) => arrayOf(rows, gatewayPublicSnapshotLimits.routes, isRouteSnapshot),
-        consentEdges: (rows) => arrayOf(rows, gatewayPublicSnapshotLimits.consentEdges, isConsentEdgeSnapshot),
         messages: (rows) => arrayOf(rows, gatewayPublicSnapshotLimits.messages, isNormalizedMessageEvent),
         accounting: isAccounting, alerts: (rows) => arrayOf(rows, gatewayPublicSnapshotLimits.alerts, isSafeAlert),
-        truncation: isSnapshotTruncation }, { progressWatches: (rows) => arrayOf(rows, gatewayPublicSnapshotLimits.progressWatches, isProgressWatchSnapshot),
-        progressWatchEvents: (rows) => arrayOf(rows, gatewayPublicSnapshotLimits.progressWatchEvents, isProgressWatchEventSnapshot),
-        activityEvents: (rows) => arrayOf(rows, gatewayPublicSnapshotLimits.activityEvents, isGatewayActivityEvent),
+        truncation: isSnapshotTruncation }, { activityEvents: (rows) => arrayOf(rows, gatewayPublicSnapshotLimits.activityEvents, isGatewayActivityEvent),
         deadlinePressure: isDeadlinePressure }))
         return false;
     const snapshot = value;
@@ -491,16 +425,13 @@ export function isGatewaySnapshot(value) {
     const connectorKeys = snapshot.connectors.map((row) => `${row.provider}@${row.host}`);
     const aliases = snapshot.routes.map((row) => row.alias);
     const peers = snapshot.availablePeers.map((row) => row.alias);
-    const edgeKeys = snapshot.consentEdges.map((row) => `${row.endpoints[0].alias}\0${row.endpoints[1].alias}`);
-    const routeByAlias = new Map(snapshot.routes.map((row) => [row.alias, row]));
     const honest = snapshot.connectors.every((row) => {
         const seen = row.lastSeenAt === undefined ? undefined : Date.parse(row.lastSeenAt);
         const age = seen === undefined ? undefined : Math.min(MAX_REVISION, Math.max(0, generated - seen));
         return (row.observationAgeMs === undefined || row.observationAgeMs === age) &&
             (row.health !== "healthy" || (age !== undefined && age <= CONNECTOR_OBSERVATION_STALE_AFTER_MS));
     });
-    return honest && unique(connectorKeys) && unique(aliases) && unique(peers) && unique(edgeKeys) &&
-        snapshot.consentEdges.every((edge) => edge.endpoints.every((endpoint) => routeByAlias.get(endpoint.alias)?.provider === endpoint.provider)) &&
+    return honest && unique(connectorKeys) && unique(aliases) && unique(peers) &&
         Buffer.byteLength(JSON.stringify(snapshot), "utf8") <= GATEWAY_PUBLIC_SNAPSHOT_BYTE_BUDGET;
 }
 function isSnapshotObservation(value) {
@@ -508,19 +439,18 @@ function isSnapshotObservation(value) {
 }
 const descriptors = {
     health: { handler: "health", decode: emptyParams, result: isHealthResult, mutation: false }, register_codex: { handler: "registerCodex", decode: decodeRegister, result: isDecision, mutation: true },
-    unregister_codex: { handler: "unregisterCodex", decode: decodeUnregister, result: isDecision, mutation: true }, remove_codex_registration: { handler: "removeCodexRegistration", decode: decodeRemoval, result: isDecision, mutation: true },
-    select_claude: { handler: "selectClaude", decode: decodeSelection, result: isDecision, mutation: true }, unselect_claude: { handler: "unselectClaude", decode: decodeSelection, result: isDecision, mutation: true },
-    pair: { handler: "pair", decode: decodePair, result: isDecision, mutation: true }, unpair: { handler: "unpair", decode: decodePair, result: isDecision, mutation: true },
+    unregister_codex: { handler: "unregisterCodex", decode: decodeUnregister, result: isDecision, mutation: true },
     list_snapshot: { handler: "listSnapshot", decode: emptyParams, result: isGatewaySnapshot, mutation: false }, observe_snapshot: { handler: "observeSnapshot", decode: emptyParams, result: isSnapshotObservation, mutation: false },
-    delivery_status: { handler: "deliveryStatus", decode: decodeDeliveryStatus, result: isDeliveryStatusResult, mutation: false }, untrack: { handler: "untrack", decode: decodeUntrack, result: isDecision, mutation: false },
+    delivery_status: { handler: "deliveryStatus", decode: decodeDeliveryStatus, result: isDeliveryStatusResult, mutation: false },
     send: { handler: "send", decode: decodeSend, result: isSendResult, mutation: true },
-    reply: { handler: "reply", decode: decodeReply, result: isSendResult, mutation: true }, refresh_dashboard: { handler: "refreshDashboard", decode: emptyParams, result: isRefreshResult, mutation: false },
+    refresh_discovery: { handler: "refreshDiscovery", decode: emptyParams, result: isRefreshResult, mutation: false },
     peer_catalog: { handler: "peerCatalog", decode: decodePeerCatalog, result: isPeerCatalog, mutation: false },
     peer_handoff: { handler: "peerHandoff", decode: decodePeerHandoff, result: isPeerHandoffResult, mutation: true },
     register_peer: { handler: "registerPeer", decode: decodeRegisterPeer, result: isRegisterPeerResult, mutation: true },
     unregister_peer: { handler: "unregisterPeer", decode: decodePeerPrincipal, result: isDecision, mutation: true },
     await_peer: { handler: "awaitPeer", decode: decodePeerPrincipal, result: isPeerMailboxAwaitResult, mutation: false },
     peer_receipt: { handler: "peerReceipt", decode: decodePeerReceipt, result: isDecision, mutation: true },
+    retire_route: { handler: "retireRoute", decode: decodeRetire, result: isRetireResult, mutation: true },
 };
 function parseRequestObject(value) {
     if (!isRecord(value) || !exact(value, ["protocolVersion", "method", "params"]))
@@ -974,13 +904,28 @@ export async function sendGatewayControlRequest(options) {
         }, (error) => {
             const kind = error instanceof FrameFault ? error.kind : "error";
             const systemCode = !writeStarted && error instanceof FrameFault ? error.systemCode : undefined;
-            const code = kind === "timeout" ? "CONTROL_TIMEOUT" :
-                kind === "too_large" ? "CONTROL_RESPONSE_TOO_LARGE" :
-                    kind === "closed" ? "CONTROL_CONNECTION_CLOSED" :
-                        systemCode === "EPERM" || systemCode === "EACCES"
-                            ? "CONTROL_CONNECT_DENIED" : systemCode === "ENOENT"
-                            ? "CONTROL_SOCKET_MISSING" : systemCode === "ECONNREFUSED"
-                            ? "CONTROL_LISTENER_UNAVAILABLE" : "CONTROL_CONNECT_FAILED";
+            let code;
+            if (kind === "timeout") {
+                code = "CONTROL_TIMEOUT";
+            }
+            else if (kind === "too_large") {
+                code = "CONTROL_RESPONSE_TOO_LARGE";
+            }
+            else if (kind === "closed") {
+                code = "CONTROL_CONNECTION_CLOSED";
+            }
+            else if (systemCode === "EPERM" || systemCode === "EACCES") {
+                code = "CONTROL_CONNECT_DENIED";
+            }
+            else if (systemCode === "ENOENT") {
+                code = "CONTROL_SOCKET_MISSING";
+            }
+            else if (systemCode === "ECONNREFUSED") {
+                code = "CONTROL_LISTENER_UNAVAILABLE";
+            }
+            else {
+                code = "CONTROL_CONNECT_FAILED";
+            }
             fail(controlTransportError(code));
         });
     });