@adhdev/mesh-shared 1.0.60-rc.6 → 1.0.60-rc.61

package/dist/protocol/daemon-server.d.ts

@@ -0,0 +1,388 @@
+/**
+ * protocol/daemon-server — the daemon ↔ Workers-server WebSocket link.
+ *
+ * Wiring-unification Phase A2 (docs/design/2026-09-23-wiring-unification.md §3 A2).
+ *
+ * Before this file the link shared NAME lists only (`ws-protocol.ts`), payloads
+ * were `any` on both ends, `daemon_mesh_command` was sent by a raw `ws.send`
+ * outside the typed funnel, and the P2P signaling names in the shared list
+ * (`offer|answer|ice`) had drifted from the wire (`p2p_offer|p2p_answer|p2p_ice`)
+ * without anything noticing, because nothing imported them.
+ *
+ * Two directions:
+ *   - `DaemonToServerMsg`  — every frame the daemon writes to the server WS.
+ *   - `ServerToDaemonMsg`  — every frame the server writes to a daemon WS. This
+ *     is a CLOSED control set plus one OPEN namespace: the public REST API
+ *     (`POST /api/v1/daemons/:id/command`, `daemonCommandSchema` = any string)
+ *     relays a caller-chosen command name as the frame `type`, so that member is
+ *     typed with a branded string rather than a literal list. The brand is what
+ *     keeps `msg.type === 'auth_ok'` narrowing to the control member instead of
+ *     collapsing into "some string".
+ *
+ * Payloads are structural mirrors of the daemon-core types the two ends assign
+ * into them (see ./envelope.ts for why mesh-shared cannot import daemon-core).
+ */
+import type { AuthOkPlanLimits } from '../ws-protocol';
+import type { SessionStatus } from '../session-status';
+import { type CommandPayload, type Envelope, type MessageId } from './envelope';
+/**
+ * Daemon-originated status events. The daemon relays these to the server
+ * (push notifications, webhooks) AND over P2P (dashboard). Mirror of
+ * daemon-core `DaemonStatusEventName`; the server pins the two equal at compile
+ * time (UserSession.ts), so adding a member here without adding it there — or
+ * vice versa — fails `tsc`.
+ */
+export declare const DAEMON_STATUS_EVENT_NAMES: readonly ["agent:generating_started", "agent:waiting_approval", "agent:waiting_choice", "agent:generating_completed", "agent:stopped", "monitor:no_progress", "monitor:long_generating"];
+export type DaemonStatusEventName = typeof DAEMON_STATUS_EVENT_NAMES[number];
+export declare const isDaemonStatusEventName: (value: unknown) => value is "agent:generating_started" | "agent:waiting_approval" | "agent:waiting_choice" | "agent:generating_completed" | "agent:stopped" | "monitor:no_progress" | "monitor:long_generating";
+/**
+ * Server-bound status event. Content boundary: identifiers, enums, counters
+ * and booleans only — plus the approved approval-modal exception
+ * (`modalMessage`/`modalButtons`, CLAUDE.md "Push notification exception").
+ * Mirror of daemon-core `DaemonStatusEventPayload`.
+ */
+export type DaemonStatusEventWirePayload = {
+    event: DaemonStatusEventName;
+    timestamp: number;
+    targetSessionId?: string;
+    providerType?: string;
+    providerSessionId?: string;
+    workspaceName?: string;
+    duration?: number;
+    elapsedSec?: number;
+    modalMessage?: string;
+    modalButtons?: string[];
+    surfaceHidden?: boolean;
+    muted?: boolean;
+};
+/** Routing-only session entry the daemon reports over the server WS. Mirror of daemon-core `RoutingSessionEntry`. */
+export type RoutingSessionWireEntry = {
+    id: string;
+    parentId: string | null;
+    providerType: string;
+    providerName: string;
+    kind: string;
+    transport: string;
+    status: SessionStatus;
+    workspace: string | null;
+    cdpConnected?: boolean;
+    surfaceHidden?: boolean;
+    muted?: boolean;
+};
+/** Counters and enums only — never a peer id or address. Mirror of daemon-core `P2PStatusSummary`. */
+export type P2PStatusWireSummary = {
+    available: boolean;
+    state: string;
+    peers: number;
+    screenshotActive?: boolean;
+    direct?: number;
+    relay?: number;
+    unknownTransport?: number;
+    directTotal?: number;
+    relayTotal?: number;
+};
+/**
+ * seqscribe replication health — pre-bucketed counters and booleans only,
+ * never a topic name or peer id. Mirror of daemon-core `SeqscribeStatusSummary`
+ * (which should derive from this once shared-types is on the protocol).
+ */
+export type SeqscribeStatusWireSummary = {
+    topics: number;
+    peers: number;
+    peersReady: number;
+    pendingBucket: number;
+    consumerLagBucket: number;
+    queueBucket: number;
+    fgenAgeBucket: number;
+    quarantined: boolean;
+    authority: boolean;
+    dualWrite?: boolean;
+    dualWriteFailedBucket?: number;
+    dualWriteDroppedBucket?: number;
+    dualWriteBackfilledBucket?: number;
+    parityMismatchBucket?: number;
+    parityRan?: boolean;
+    parityMissingInShadowBucket?: number;
+    parityExtraInShadowBucket?: number;
+    parityFieldMismatchBucket?: number;
+    transcriptPublish?: boolean;
+    transcriptPublishedBucket?: number;
+    transcriptPublishFailedBucket?: number;
+    transcriptDedupedBucket?: number;
+    transcriptOversizedBucket?: number;
+    transcriptDroppedBucket?: number;
+    transcriptParityRan?: boolean;
+    transcriptParityMismatchBucket?: number;
+};
+export type CloudStatusReportWirePayload = {
+    sessions: RoutingSessionWireEntry[];
+    p2p?: P2PStatusWireSummary;
+    seqscribe?: SeqscribeStatusWireSummary;
+    timestamp: number;
+};
+export declare const RELEASE_CHANNELS: readonly ["stable", "preview"];
+export type ReleaseChannelWire = typeof RELEASE_CHANNELS[number];
+export declare const NPM_UPDATE_TAGS: readonly ["latest", "next"];
+export type NpmUpdateTagWire = typeof NPM_UPDATE_TAGS[number];
+export declare const VERSION_UPDATE_REASONS: readonly ["force_update_below", "major_minor_mismatch", "patch_mismatch", "daemon_ahead"];
+export type VersionUpdateReasonWire = typeof VERSION_UPDATE_REASONS[number];
+/** Mirror of daemon-core `VersionUpdatePolicy`. */
+export type VersionUpdatePolicyWire = {
+    channel: ReleaseChannelWire;
+    npmTag: NpmUpdateTagWire;
+    targetVersion: string;
+    minVersion?: string;
+    updateCommand: string;
+};
+export type StatusHeartbeatWirePayload = {
+    timestamp?: number;
+    p2pPeers?: number;
+};
+/** What the daemon says about itself at auth time (`ServerConnectionOptions.cliInfo`). */
+export type DaemonAuthIdentity = {
+    type: string;
+    version: string;
+    platform: string;
+    hostname?: string;
+    machineId?: string;
+    /** Canonical mesh identity `daemon_<machineId>`; the server keys its DO and status by it. */
+    instanceId: string;
+};
+export type DaemonAuthWirePayload = {
+    token: string;
+    daemon: DaemonAuthIdentity;
+};
+export type IceServerWireEntry = {
+    urls: string | string[];
+    username?: string;
+    credential?: string;
+};
+export type AuthOkWirePayload = {
+    message?: string;
+    plan: string;
+    iceServers: IceServerWireEntry[];
+    turnenabled: boolean;
+    serverVersion: string;
+    releaseChannel?: ReleaseChannelWire;
+    updatePolicy?: VersionUpdatePolicyWire;
+    machineNickname: string | null;
+    seqscribeFleetSecret?: string;
+    seqscribeFleetSecretVersion?: number;
+    /** Beacon board seed for cold start (advisory, may be absent). */
+    beaconSeed?: {
+        reports: unknown[];
+        truncated: number;
+    };
+    limits: AuthOkPlanLimits;
+};
+export type AuthErrorWirePayload = {
+    reason: string;
+    message: string;
+    limit?: number;
+    current?: number;
+};
+/** `machine_evicted` / `force_disconnect` / `token_revoked` — a reason token plus human text, then the socket closes. */
+export type DisconnectNoticeWirePayload = {
+    reason: string;
+    message: string;
+};
+export type VersionMismatchWirePayload = {
+    current: string;
+    latest: string;
+    required: false;
+    reason: VersionUpdateReasonWire;
+    channel: ReleaseChannelWire;
+    npmTag: NpmUpdateTagWire;
+    updatePolicy: VersionUpdatePolicyWire;
+    updateCommand: string;
+};
+export type ForceUpdateRequiredWirePayload = {
+    current: string;
+    latest: string;
+    minVersion: string;
+    required: true;
+    reason: VersionUpdateReasonWire;
+    channel: ReleaseChannelWire;
+    npmTag: NpmUpdateTagWire;
+    updatePolicy: VersionUpdatePolicyWire;
+    updateCommand: string;
+    forceUpdateBelow?: string;
+    message: string;
+};
+export type CommandResultWirePayload = {
+    requestId: MessageId;
+    success: boolean;
+    source?: string;
+} & Record<string, unknown>;
+export type DaemonErrorWirePayload = {
+    message?: string;
+    detail?: unknown;
+};
+export type BeaconVectorsWirePayload = {
+    op: 'put';
+    report: unknown;
+} | {
+    op: 'get';
+    topics: string[];
+    requestId: string;
+};
+export declare const P2P_SIGNAL_TYPES: readonly ["p2p_ready", "p2p_offer", "p2p_answer", "p2p_ice"];
+export type P2PSignalType = typeof P2P_SIGNAL_TYPES[number];
+export declare const isP2PSignalType: (value: unknown) => value is "p2p_ready" | "p2p_offer" | "p2p_answer" | "p2p_ice";
+/** Signals the daemon originates (it is the WebRTC offerer). */
+export declare const DAEMON_P2P_SIGNAL_TYPES: readonly ["p2p_offer", "p2p_ice"];
+export type DaemonP2PSignalType = typeof DAEMON_P2P_SIGNAL_TYPES[number];
+export declare const isDaemonP2PSignalType: (value: unknown) => value is "p2p_offer" | "p2p_ice";
+export type P2POfferWirePayload = {
+    sdp: string;
+    type: string;
+    peerId: string;
+};
+export type P2PIceWirePayload = {
+    candidate: string;
+    mid: string;
+    peerId: string;
+};
+/**
+ * A dashboard-originated signal as relayed to the daemon. `peerId` is stamped
+ * by UserSession/SharedSession, `sharePermission` only by SharedSession (server
+ * authority, never the client). Field names follow the browser/node-datachannel
+ * spellings both ends already read.
+ */
+export type RelayedP2PSignalWirePayload = {
+    peerId?: string;
+    daemonId?: string;
+    sharePermission?: string;
+    sdp?: string;
+    type?: string;
+    candidate?: string;
+    mid?: string;
+    sdpMid?: string | null;
+    sdpMLineIndex?: number | null;
+};
+export declare const MESH_P2P_SIGNAL_TYPES: readonly ["mesh_p2p_ready", "mesh_p2p_offer", "mesh_p2p_answer", "mesh_p2p_ice"];
+export type MeshP2PSignalType = typeof MESH_P2P_SIGNAL_TYPES[number];
+export declare const isMeshP2PSignalType: (value: unknown) => value is "mesh_p2p_ready" | "mesh_p2p_offer" | "mesh_p2p_answer" | "mesh_p2p_ice";
+/** Daemon→daemon signal as delivered to the target daemon: the sender's args plus the server-stamped canonical sender id. */
+export type MeshP2PSignalWirePayload = {
+    senderDaemonId: string;
+} & Record<string, unknown>;
+export declare const DAEMON_TO_SERVER_TYPES: readonly ["auth", "status_report", "status_heartbeat", "status_event", "command_result", "error", "agent_event", "beacon_vectors", "daemon_mesh_command", "p2p_offer", "p2p_ice"];
+export type DaemonToServerType = typeof DAEMON_TO_SERVER_TYPES[number];
+export declare const isDaemonToServerType: (value: unknown) => value is "error" | "p2p_offer" | "p2p_ice" | "auth" | "status_report" | "status_heartbeat" | "status_event" | "command_result" | "agent_event" | "beacon_vectors" | "daemon_mesh_command";
+export type DaemonAuthMsg = Envelope<'auth', DaemonAuthWirePayload>;
+export type StatusReportMsg = Envelope<'status_report', CloudStatusReportWirePayload>;
+export type StatusHeartbeatMsg = Envelope<'status_heartbeat', StatusHeartbeatWirePayload>;
+export type DaemonStatusEventMsg = Envelope<'status_event', DaemonStatusEventWirePayload>;
+export type CommandResultMsg = Envelope<'command_result', CommandResultWirePayload>;
+export type DaemonErrorMsg = Envelope<'error', DaemonErrorWirePayload>;
+/** Agent-level event forwarded verbatim to the `agent:status` webhook (throttled server-side). Dynamic by design. */
+export type AgentEventMsg = Envelope<'agent_event', CommandPayload>;
+export type BeaconVectorsMsg = Envelope<'beacon_vectors', BeaconVectorsWirePayload>;
+export type DaemonP2POfferMsg = Envelope<'p2p_offer', P2POfferWirePayload>;
+export type DaemonP2PIceMsg = Envelope<'p2p_ice', P2PIceWirePayload>;
+/**
+ * Daemon→daemon signaling relay request. Fields are TOP-LEVEL (no `payload`):
+ * this is the wire shape the live fleet speaks, kept as-is so mixed-version
+ * daemons and servers keep interoperating during a rollout.
+ */
+export type DaemonMeshCommandMsg = {
+    type: 'daemon_mesh_command';
+    requestId: string;
+    targetDaemonId: string;
+    command: MeshP2PSignalType;
+    args: Record<string, unknown>;
+    timestamp: number;
+};
+export type DaemonToServerMsg = DaemonAuthMsg | StatusReportMsg | StatusHeartbeatMsg | DaemonStatusEventMsg | CommandResultMsg | DaemonErrorMsg | AgentEventMsg | BeaconVectorsMsg | DaemonMeshCommandMsg | DaemonP2POfferMsg | DaemonP2PIceMsg;
+/** Members that carry a `payload` object (everything except `daemon_mesh_command`). */
+export type DaemonToServerPayloadType = Exclude<DaemonToServerMsg, DaemonMeshCommandMsg>['type'];
+export type DaemonToServerPayloadOf<T extends DaemonToServerPayloadType> = Extract<DaemonToServerMsg, {
+    type: T;
+}>['payload'];
+/**
+ * Parse boundary for the server: is `raw` a frame this link accepts from a daemon?
+ * Checks membership and the minimal envelope shape; `auth` additionally needs a
+ * token string because nothing downstream can proceed without one.
+ */
+export declare function decodeDaemonToServer(raw: unknown): DaemonToServerMsg | null;
+export declare const SERVER_TO_DAEMON_CONTROL_TYPES: readonly ["auth_ok", "auth_error", "machine_evicted", "force_disconnect", "token_revoked", "version_mismatch", "force_update_required", "command", "agent_command", "resolve_action", "beacon_vectors_result", "daemon_mesh_result", "p2p_ready", "p2p_offer", "p2p_answer", "p2p_ice", "mesh_p2p_ready", "mesh_p2p_offer", "mesh_p2p_answer", "mesh_p2p_ice"];
+export type ServerToDaemonControlType = typeof SERVER_TO_DAEMON_CONTROL_TYPES[number];
+export declare const isServerToDaemonControlType: (value: unknown) => value is "p2p_ready" | "p2p_offer" | "p2p_answer" | "p2p_ice" | "mesh_p2p_ready" | "mesh_p2p_offer" | "mesh_p2p_answer" | "mesh_p2p_ice" | "command" | "auth_ok" | "auth_error" | "machine_evicted" | "force_disconnect" | "token_revoked" | "version_mismatch" | "force_update_required" | "agent_command" | "resolve_action" | "beacon_vectors_result" | "daemon_mesh_result";
+/** Optional routing fields the server stamps on relayed commands. */
+type ServerRelayFields = {
+    id?: MessageId;
+    source?: string;
+    timestamp?: number;
+};
+export type AuthOkMsg = Envelope<'auth_ok', AuthOkWirePayload>;
+export type AuthErrorMsg = Envelope<'auth_error', AuthErrorWirePayload>;
+export type MachineEvictedMsg = Envelope<'machine_evicted', DisconnectNoticeWirePayload>;
+export type ForceDisconnectMsg = Envelope<'force_disconnect', DisconnectNoticeWirePayload>;
+export type TokenRevokedMsg = Envelope<'token_revoked', DisconnectNoticeWirePayload>;
+export type VersionMismatchMsg = Envelope<'version_mismatch', VersionMismatchWirePayload>;
+export type ForceUpdateRequiredMsg = Envelope<'force_update_required', ForceUpdateRequiredWirePayload>;
+/** Wrapped command: `payload.command` names the command, `payload.args` carries it. */
+export type ServerCommandMsg = Envelope<'command', {
+    command: string;
+    args?: CommandPayload;
+} & Record<string, unknown>> & ServerRelayFields;
+export type ServerAgentCommandMsg = Envelope<'agent_command', {
+    action: string;
+} & Record<string, unknown>> & ServerRelayFields;
+export type ServerResolveActionMsg = Envelope<'resolve_action', CommandPayload> & ServerRelayFields;
+export type ServerP2PSignalMsg = Envelope<P2PSignalType, RelayedP2PSignalWirePayload> & ServerRelayFields;
+export type ServerMeshP2PSignalMsg = Envelope<MeshP2PSignalType, MeshP2PSignalWirePayload> & ServerRelayFields;
+/** Reply to a `beacon_vectors` GET, correlated by `requestId` (top-level, no payload). A PUT gets no reply. */
+export type BeaconVectorsResultMsg = {
+    type: 'beacon_vectors_result';
+    requestId: string;
+    success: boolean;
+    reports?: unknown[];
+    truncated?: number;
+    error?: string;
+};
+/** Correlated ack/nack of a `daemon_mesh_command` (top-level, no payload). */
+export type DaemonMeshResultMsg = {
+    type: 'daemon_mesh_result';
+    requestId: string;
+    success: boolean;
+    result?: unknown;
+    error?: string;
+};
+export type ServerToDaemonControlMsg = AuthOkMsg | AuthErrorMsg | MachineEvictedMsg | ForceDisconnectMsg | TokenRevokedMsg | VersionMismatchMsg | ForceUpdateRequiredMsg | ServerCommandMsg | ServerAgentCommandMsg | ServerResolveActionMsg | BeaconVectorsResultMsg | DaemonMeshResultMsg | ServerP2PSignalMsg | ServerMeshP2PSignalMsg;
+declare const directCommandBrand: unique symbol;
+/**
+ * A command name relayed as the frame `type` — the OPEN namespace the REST API
+ * and `shortcuts` routes feed (`read_chat`, `send_chat`, `stop_cli`, `git_*`,
+ * `clone_mesh_node`, `terminal_exec`, ...). The daemon routes it by name
+ * through its command router. Branded so it cannot be confused with a control
+ * member at the type level; `decodeServerToDaemon` is the only producer.
+ */
+export type DaemonDirectCommandType = string & {
+    readonly [directCommandBrand]?: true;
+};
+export type ServerDirectCommandMsg = {
+    type: DaemonDirectCommandType;
+    payload: CommandPayload;
+    id?: MessageId;
+    source?: string;
+    timestamp?: number;
+};
+export type ServerToDaemonMsg = ServerToDaemonControlMsg | ServerDirectCommandMsg;
+export type ServerToDaemonType = ServerToDaemonMsg['type'];
+export declare function isServerDirectCommandMsg(msg: ServerToDaemonMsg): msg is ServerDirectCommandMsg;
+/** Members of the control set that carry a `payload` object. */
+export type ServerToDaemonPayloadType = Exclude<ServerToDaemonControlMsg, BeaconVectorsResultMsg | DaemonMeshResultMsg>['type'];
+export type ServerToDaemonPayloadOf<T extends ServerToDaemonPayloadType> = Extract<ServerToDaemonControlMsg, {
+    type: T;
+}>['payload'];
+export declare function isDaemonDirectCommandType(value: unknown): value is DaemonDirectCommandType;
+/**
+ * Parse boundary for the daemon: is `raw` a frame this link accepts from the server?
+ * Control members are checked for their discriminant and envelope shape; the
+ * two payload-less replies need their `requestId`; any other well-formed
+ * command name becomes a `ServerDirectCommandMsg`.
+ */
+export declare function decodeServerToDaemon(raw: unknown): ServerToDaemonMsg | null;
+export {};

package/dist/protocol/dashboard-daemon-p2p.d.ts

@@ -0,0 +1,212 @@
+/**
+ * protocol/dashboard-daemon-p2p — the dashboard ↔ daemon WebRTC DataChannel
+ * link (`data` channel, JSON frames; screenshots ride the same channel as
+ * binary and are not frames).
+ *
+ * Wiring-unification Phase A2 (docs/design/2026-09-23-wiring-unification.md §3 A2).
+ *
+ * Before this file ~20 kinds were matched as bare string literals on both ends
+ * (web-cloud `p2p.ts`, daemon-cloud `data-channel-router.ts`), the shared
+ * `DashboardP2PMessageKind` listed 12 of them and was imported by nothing, and
+ * the daemon's file-operation replies carried no `type` at all — the browser
+ * matched them by `id` as a fallthrough. They are now `response` frames; the
+ * browser decoder still accepts the typeless legacy shape from older daemons.
+ *
+ * Chunking: any request frame may be split by the sender into
+ * `<kind>_chunk` frames (`id`, `chunkId`, `index`, `total`, `data`) when it
+ * exceeds `MESH_MAX_INLINE_FRAME_BYTES` (../rpc-chunking.ts). Each direction
+ * reassembles BEFORE decoding, so the decoders see whole frames; the chunk
+ * envelope is typed here so the splitter and the reassembler agree.
+ *
+ * Content boundary: this is the P2P plane — rich session data (chat, prompts,
+ * transcripts, PTY output) is CORRECT here and must not be reduced.
+ */
+import { type CommandPayload, type MessageId } from './envelope';
+import type { DaemonStatusEventWirePayload } from './daemon-server';
+export type ChunkFrame<T extends string> = {
+    type: T;
+    /** Request id of the frame being split, when it has one. */
+    id?: MessageId;
+    chunkId: string;
+    index: number;
+    total: number;
+    data: string;
+};
+export declare function isChunkType(value: unknown): value is `${string}_chunk`;
+export declare const DASHBOARD_TO_DAEMON_P2P_TYPES: readonly ["ping", "pong", "command", "input", "pty_input", "pty_resize", "screenshot_start", "screenshot_stop", "subscribe", "unsubscribe", "seqscribe_session_interest", "read", "write", "list"];
+export type DashboardToDaemonP2PType = typeof DASHBOARD_TO_DAEMON_P2P_TYPES[number];
+export declare const isDashboardToDaemonP2PType: (value: unknown) => value is "list" | "command" | "ping" | "pong" | "input" | "pty_input" | "pty_resize" | "screenshot_start" | "screenshot_stop" | "subscribe" | "unsubscribe" | "seqscribe_session_interest" | "read" | "write";
+export type DashboardToDaemonChunkType = `${DashboardToDaemonP2PType}_chunk`;
+export declare function isDashboardToDaemonChunkType(value: unknown): value is DashboardToDaemonChunkType;
+export type P2PPingMsg = {
+    type: 'ping';
+    ts: number;
+};
+export type P2PPongMsg = {
+    type: 'pong';
+    ts: number;
+};
+/** A command routed through the daemon's command router; `commandType`/`data` are dynamic by design. */
+export type P2PCommandMsg = {
+    type: 'command';
+    id: MessageId;
+    commandType: string;
+    data: CommandPayload;
+};
+/** Remote-desktop input (click/type/key) for the target session's IDE surface. */
+export type P2PInputMsg = {
+    type: 'input';
+    id: MessageId;
+    action: string;
+    params: CommandPayload;
+    targetSessionId?: string;
+};
+/** Raw PTY input. `sessionId` is canonical; `targetSessionId` is the accepted alias. */
+export type P2PPtyInputMsg = {
+    type: 'pty_input';
+    sessionId?: string;
+    targetSessionId?: string;
+    data: string;
+};
+export type P2PPtyResizeMsg = {
+    type: 'pty_resize';
+    sessionId: string;
+    cols: number;
+    rows: number;
+};
+export type P2PScreenshotStartMsg = {
+    type: 'screenshot_start';
+    targetSessionId: string;
+};
+export type P2PScreenshotStopMsg = {
+    type: 'screenshot_stop';
+    targetSessionId?: string;
+};
+/** Topic subscription. `params` is topic-specific (daemon-core `SubscribeRequestMap`); `object` keeps every topic's interface assignable. */
+export type P2PSubscribeMsg = {
+    type: 'subscribe';
+    topic: string;
+    key: string;
+    params: object;
+};
+export type P2PUnsubscribeMsg = {
+    type: 'unsubscribe';
+    topic: string;
+    key: string;
+};
+/** Which sessions this peer wants replicated over the seqscribe lane; also the peer's responder proof. */
+export type P2PSessionInterestMsg = {
+    type: 'seqscribe_session_interest';
+    sessionIds: readonly string[];
+};
+export type P2PFileReadMsg = {
+    type: 'read';
+    id: MessageId;
+    path: string;
+};
+export type P2PFileWriteMsg = {
+    type: 'write';
+    id: MessageId;
+    path: string;
+    content: string;
+};
+export type P2PFileListMsg = {
+    type: 'list';
+    id: MessageId;
+    path: string;
+};
+export type DashboardToDaemonChunkMsg = ChunkFrame<DashboardToDaemonChunkType>;
+export type DashboardToDaemonP2PMsg = P2PPingMsg | P2PPongMsg | P2PCommandMsg | P2PInputMsg | P2PPtyInputMsg | P2PPtyResizeMsg | P2PScreenshotStartMsg | P2PScreenshotStopMsg | P2PSubscribeMsg | P2PUnsubscribeMsg | P2PSessionInterestMsg | P2PFileReadMsg | P2PFileWriteMsg | P2PFileListMsg;
+/** Parse boundary for the daemon's chunk reassembler: one `<kind>_chunk` piece of a split request. */
+export declare function decodeDashboardToDaemonP2PChunk(raw: unknown): DashboardToDaemonChunkMsg | null;
+/**
+ * Parse boundary for the daemon (after chunk reassembly): a whole request.
+ * Chunk pieces are not requests and decode to null here; see
+ * `decodeDashboardToDaemonP2PChunk`.
+ */
+export declare function decodeDashboardToDaemonP2P(raw: unknown): DashboardToDaemonP2PMsg | null;
+export declare const DAEMON_TO_DASHBOARD_P2P_TYPES: readonly ["ping", "pong", "p2p_evicted", "status_report", "status_event", "topic_update", "topic_update_chunk", "session_output", "session_output_chunk", "session_io_error", "command_result", "command_result_chunk", "response"];
+export type DaemonToDashboardP2PType = typeof DAEMON_TO_DASHBOARD_P2P_TYPES[number];
+export declare const isDaemonToDashboardP2PType: (value: unknown) => value is "status_report" | "status_event" | "command_result" | "ping" | "pong" | "p2p_evicted" | "topic_update" | "topic_update_chunk" | "session_output" | "session_output_chunk" | "session_io_error" | "command_result_chunk" | "response";
+/** Rich P2P status snapshot (daemon-core `StatusReportPayload`, or a `_delta` partial of it). Dynamic by design on this plane. */
+export type P2PStatusReportWirePayload = Record<string, unknown>;
+/** The server-bound event plus the P2P-only structured prompt (daemon-core `P2PStatusEventPayload`). */
+export type P2PStatusEventWirePayload = DaemonStatusEventWirePayload & {
+    interactivePrompt?: unknown;
+    promptId?: string;
+    multiSelect?: boolean;
+};
+/** One topic update (daemon-core `TopicUpdateEnvelope`); consumers narrow by `topic`. */
+export type TopicUpdateWireEnvelope = {
+    topic: string;
+    key: string;
+};
+export type P2PFileEntry = {
+    name: string;
+    type: string;
+    size?: number;
+};
+export type P2PEvictedMsg = {
+    type: 'p2p_evicted';
+    reason: string;
+    maxconnections: number;
+};
+export type P2PStatusReportMsg = {
+    type: 'status_report';
+    payload: P2PStatusReportWirePayload;
+    timestamp: number;
+};
+export type P2PStatusEventMsg = {
+    type: 'status_event';
+    payload: P2PStatusEventWirePayload;
+    timestamp: number;
+};
+export type P2PTopicUpdateMsg = {
+    type: 'topic_update';
+    update: TopicUpdateWireEnvelope;
+};
+export type P2PTopicUpdateChunkMsg = ChunkFrame<'topic_update_chunk'>;
+export type P2PSessionOutputMsg = {
+    type: 'session_output';
+    sessionId: string;
+    data: string;
+};
+export type P2PSessionOutputChunkMsg = ChunkFrame<'session_output_chunk'> & {
+    sessionId: string;
+};
+export type P2PSessionIoErrorMsg = {
+    type: 'session_io_error';
+    sessionId: string;
+    reason: string;
+    error?: string;
+};
+/** Result of a `command` frame. The router spreads the handler result in; `resultId` preserves a result-side `id`. */
+export type P2PCommandResultMsg = {
+    type: 'command_result';
+    id: MessageId;
+    success: boolean;
+    error?: string;
+    resultId?: unknown;
+} & Record<string, unknown>;
+export type P2PCommandResultChunkMsg = ChunkFrame<'command_result_chunk'>;
+/** Result of an `input` or file (`read`/`write`/`list`) frame. */
+export type P2PResponseMsg = {
+    type: 'response';
+    id: MessageId;
+    success: boolean;
+    result?: unknown;
+    error?: string;
+    content?: string;
+    entries?: P2PFileEntry[];
+};
+export type DaemonToDashboardP2PMsg = P2PPingMsg | P2PPongMsg | P2PEvictedMsg | P2PStatusReportMsg | P2PStatusEventMsg | P2PTopicUpdateMsg | P2PTopicUpdateChunkMsg | P2PSessionOutputMsg | P2PSessionOutputChunkMsg | P2PSessionIoErrorMsg | P2PCommandResultMsg | P2PCommandResultChunkMsg | P2PResponseMsg;
+/**
+ * Parse boundary for the dashboard (after chunk reassembly).
+ *
+ * A typeless `{ id, success }` frame is a file/input reply from a daemon that
+ * predates the `response` kind; it is promoted here so the union stays
+ * exhaustive while the fleet rolls forward.
+ */
+export declare function decodeDaemonToDashboardP2P(raw: unknown): DaemonToDashboardP2PMsg | null;
+/** Both directions, for the legacy `DashboardP2PMessageKind` name and the drift gate. */
+export declare const DASHBOARD_P2P_MESSAGE_KINDS: ReadonlyArray<DashboardToDaemonP2PType | DaemonToDashboardP2PType>;