@adhdev/mesh-shared 1.0.60-rc.8 → 1.0.60

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

@@ -0,0 +1,240 @@
+/**
+ * protocol/dashboard-server — the dashboard ↔ UserSessionDO WebSocket link,
+ * plus the share-viewer ↔ SharedSessionDO link the same dashboard bundle speaks.
+ *
+ * Wiring-unification Phase A2 (docs/design/2026-09-23-wiring-unification.md §3 A2).
+ *
+ * Before this file web-cloud `ws.ts` declared its own `IncomingWSMessage`
+ * union and `WSEventType`, the server built every outbound frame as an object
+ * literal, and the two disagreed: the server's `connected` frame was missing
+ * from the dashboard's type, while the dashboard typed `plan_limit_error`,
+ * `plan_limit_warning`, `daemon_screenshot` and `agent_event` that no server
+ * path has emitted since the dashboard WS command relay was removed. Those four
+ * are gone; `connected` is in.
+ *
+ * Content boundary: this link is server WS. It carries routing metadata,
+ * signaling and the approved approval-modal text only (`modalMessage` /
+ * `modalButtons`). Chat content rides the P2P link (./dashboard-daemon-p2p.ts).
+ */
+import { type Envelope } from './envelope';
+import { type DaemonStatusEventName, type P2PIceWirePayload, type P2POfferWirePayload, type P2PStatusWireSummary, type SeqscribeStatusWireSummary, type ReleaseChannelWire, type VersionUpdatePolicyWire, type VersionUpdateReasonWire } from './daemon-server';
+/** Server-originated events the dashboard receives in addition to the daemon set. */
+export declare const SERVER_STATUS_EVENT_NAMES: readonly ["daemon:disconnect", "team:session_viewed", "team:view_request", "team:view_request_approved", "team:view_request_rejected"];
+/** Mirror of daemon-core `DashboardStatusEventName`; pinned equal by the server at compile time. */
+export declare const DASHBOARD_STATUS_EVENT_NAMES: readonly ["agent:generating_started", "agent:waiting_approval", "agent:waiting_choice", "agent:generating_completed", "agent:stopped", "monitor:no_progress", "daemon:disconnect", "team:session_viewed", "team:view_request", "team:view_request_approved", "team:view_request_rejected"];
+export type DashboardStatusEventName = DaemonStatusEventName | typeof SERVER_STATUS_EVENT_NAMES[number];
+export declare const isDashboardStatusEventName: (value: unknown) => value is "agent:generating_started" | "agent:waiting_approval" | "agent:waiting_choice" | "agent:generating_completed" | "agent:stopped" | "monitor:no_progress" | "daemon:disconnect" | "team:session_viewed" | "team:view_request" | "team:view_request_approved" | "team:view_request_rejected";
+/**
+ * Sanitized status event as the server relays it (UserSession
+ * `buildDashboardStatusEvent`). Mirror of daemon-core
+ * `DashboardStatusEventPayload` minus the P2P-only structured prompt fields
+ * (`interactivePrompt`/`promptId`/`multiSelect`), which the WS relay never
+ * carries — they are agent-authored content.
+ */
+export type DashboardStatusEventWirePayload = {
+    event: DashboardStatusEventName;
+    timestamp: number;
+    daemonId?: string;
+    providerType?: string;
+    targetSessionId?: string;
+    duration?: number;
+    elapsedSec?: number;
+    modalMessage?: string;
+    modalButtons?: string[];
+    requestId?: string;
+    requesterName?: string;
+    targetName?: string;
+    orgId?: string;
+    permission?: string;
+    shareUrl?: string;
+    shareToken?: string;
+    viewerName?: string;
+};
+/**
+ * Cold-start machine card. Mirror of daemon-core `DashboardBootstrapDaemonEntry`
+ * (which extends `Partial<CloudDaemonSummaryEntry>`), field for field, so the
+ * server's entry assigns in and the dashboard's daemon-core-typed consumer
+ * assigns out without a cast.
+ */
+export type BootstrapDaemonWireEntry = {
+    id: string;
+    type?: string;
+    machineId?: string;
+    platform?: string;
+    hostname?: string;
+    nickname?: string;
+    version?: string;
+    p2p?: P2PStatusWireSummary;
+    seqscribe?: SeqscribeStatusWireSummary;
+    cdpConnected?: boolean;
+    serverVersion?: string;
+    releaseChannel?: ReleaseChannelWire;
+    updateChannel?: ReleaseChannelWire;
+    updatePolicy?: VersionUpdatePolicyWire;
+    updateCommand?: string;
+    versionMismatch?: boolean;
+    versionUpdateRequired?: boolean;
+    versionUpdateReason?: VersionUpdateReasonWire;
+    timestamp?: number;
+};
+export declare const SYSTEM_ANNOUNCEMENT_TYPES: readonly ["info", "warning", "critical"];
+export type SystemAnnouncementTypeWire = typeof SYSTEM_ANNOUNCEMENT_TYPES[number];
+/** Admin-authored banner; `null` clears it. Mirror of server `ActiveSystemAnnouncement` / web-cloud `SystemAnnouncement`. */
+export type SystemAnnouncementWire = {
+    id: string;
+    message: string;
+    type: SystemAnnouncementTypeWire;
+    createdAt: string | null;
+    expiresAt: string | null;
+};
+export type DashboardBootstrapWirePayload = {
+    daemons: BootstrapDaemonWireEntry[];
+    announcement?: SystemAnnouncementWire | null;
+};
+export type DashboardConnectedWirePayload = {
+    message?: string;
+    peerId: string;
+    plan: string;
+    dashboardCount: number;
+};
+/** Daemon auth rejection relayed to the owner's dashboards — enum reason and counters only (no server-authored sentence). */
+export type DashboardAuthErrorWirePayload = {
+    reason: string;
+    limit?: number;
+    current?: number;
+};
+export type SystemAnnouncementWirePayload = {
+    announcement: SystemAnnouncementWire | null;
+};
+export type DashboardP2POfferWirePayload = {
+    daemonId: string;
+    peerId?: string;
+    sdp: string;
+    type: string;
+};
+export type DashboardP2PIceWirePayload = {
+    daemonId: string;
+    peerId?: string;
+    candidate: string;
+    mid?: string;
+    sdpMid?: string | null;
+    sdpMLineIndex?: number | null;
+};
+export declare const USER_SESSION_TO_DASHBOARD_TYPES: readonly ["connected", "initial_state", "daemon_status", "status_event", "system_announcement", "auth_error", "heartbeat", "p2p_offer", "p2p_ice"];
+export type UserSessionToDashboardType = typeof USER_SESSION_TO_DASHBOARD_TYPES[number];
+export declare const isUserSessionToDashboardType: (value: unknown) => value is "p2p_offer" | "p2p_ice" | "status_event" | "auth_error" | "connected" | "initial_state" | "daemon_status" | "system_announcement" | "heartbeat";
+export type DashboardConnectedMsg = Envelope<'connected', DashboardConnectedWirePayload>;
+export type DashboardInitialStateMsg = Envelope<'initial_state', DashboardBootstrapWirePayload>;
+export type DashboardDaemonStatusMsg = Envelope<'daemon_status', DashboardBootstrapWirePayload>;
+export type DashboardStatusEventMsg = Envelope<'status_event', DashboardStatusEventWirePayload>;
+export type DashboardSystemAnnouncementMsg = Envelope<'system_announcement', SystemAnnouncementWirePayload>;
+export type DashboardAuthErrorMsg = Envelope<'auth_error', DashboardAuthErrorWirePayload>;
+/**
+ * Reply to the dashboard's heartbeat. Carries the cached announcement so a
+ * stale banner self-corrects; the field is optional because the reply is first
+ * of all a liveness signal and must not be dropped by an older server's
+ * payload-less spelling.
+ */
+export type DashboardHeartbeatReplyMsg = Envelope<'heartbeat', Partial<SystemAnnouncementWirePayload>>;
+export type DashboardP2POfferMsg = Envelope<'p2p_offer', DashboardP2POfferWirePayload>;
+export type DashboardP2PIceMsg = Envelope<'p2p_ice', DashboardP2PIceWirePayload>;
+export type UserSessionToDashboardMsg = DashboardConnectedMsg | DashboardInitialStateMsg | DashboardDaemonStatusMsg | DashboardStatusEventMsg | DashboardSystemAnnouncementMsg | DashboardAuthErrorMsg | DashboardHeartbeatReplyMsg | DashboardP2POfferMsg | DashboardP2PIceMsg;
+export type UserSessionToDashboardPayloadOf<T extends UserSessionToDashboardType> = Extract<UserSessionToDashboardMsg, {
+    type: T;
+}>['payload'];
+/** Parse boundary for the dashboard. A heartbeat reply is accepted without a payload (liveness first). */
+export declare function decodeUserSessionToDashboard(raw: unknown): UserSessionToDashboardMsg | null;
+export declare const DASHBOARD_TO_USER_SESSION_TYPES: readonly ["heartbeat", "refresh", "p2p_ready", "p2p_answer", "p2p_ice"];
+export type DashboardToUserSessionType = typeof DASHBOARD_TO_USER_SESSION_TYPES[number];
+export declare const isDashboardToUserSessionType: (value: unknown) => value is "p2p_ready" | "p2p_answer" | "p2p_ice" | "heartbeat" | "refresh";
+/** Signals a dashboard (answerer) sends toward a daemon; `daemonId` routes, `peerId` identifies the tab. */
+export declare const DASHBOARD_P2P_SIGNAL_TYPES: readonly ["p2p_ready", "p2p_answer", "p2p_ice"];
+export type DashboardP2PSignalType = typeof DASHBOARD_P2P_SIGNAL_TYPES[number];
+export declare const isDashboardP2PSignalType: (value: unknown) => value is "p2p_ready" | "p2p_answer" | "p2p_ice";
+export type DashboardP2PReadyWirePayload = {
+    daemonId: string;
+    peerId: string;
+};
+export type DashboardP2PAnswerWirePayload = {
+    daemonId: string;
+    peerId: string;
+    sdp: string;
+    type: string;
+};
+export type DashboardP2PLocalIceWirePayload = {
+    daemonId: string;
+    peerId: string;
+    candidate: string;
+    sdpMid: string | null;
+    sdpMLineIndex: number | null;
+};
+export type DashboardHeartbeatMsg = {
+    type: 'heartbeat';
+    timestamp?: number;
+};
+export type DashboardRefreshMsg = {
+    type: 'refresh';
+};
+export type DashboardP2PReadyMsg = Envelope<'p2p_ready', DashboardP2PReadyWirePayload>;
+export type DashboardP2PAnswerMsg = Envelope<'p2p_answer', DashboardP2PAnswerWirePayload>;
+export type DashboardP2PLocalIceMsg = Envelope<'p2p_ice', DashboardP2PLocalIceWirePayload>;
+export type DashboardToUserSessionMsg = DashboardHeartbeatMsg | DashboardRefreshMsg | DashboardP2PReadyMsg | DashboardP2PAnswerMsg | DashboardP2PLocalIceMsg;
+export type DashboardToUserSessionPayloadOf<T extends DashboardP2PSignalType> = Extract<DashboardToUserSessionMsg, {
+    type: T;
+}>['payload'];
+/** Parse boundary for UserSessionDO. Signals need a `daemonId` to route; without one there is nothing to do. */
+export declare function decodeDashboardToUserSession(raw: unknown): DashboardToUserSessionMsg | null;
+export declare const SHARED_SESSION_TO_VIEWER_TYPES: readonly ["share:connected", "share:revoked", "share:expired", "share:error", "share:viewer_count", "p2p_offer", "p2p_ice"];
+export type SharedSessionToViewerType = typeof SHARED_SESSION_TO_VIEWER_TYPES[number];
+export declare const isSharedSessionToViewerType: (value: unknown) => value is "p2p_offer" | "p2p_ice" | "share:connected" | "share:revoked" | "share:expired" | "share:error" | "share:viewer_count";
+/** Frames on this link are FLAT (no `payload`), except the relayed signals. Kept as the viewer page reads them. */
+export type ShareConnectedMsg = {
+    type: 'share:connected';
+    viewerId: string;
+    viewerName: string;
+    permission: string;
+    mode: string;
+    providerType: string;
+    targetSessionId?: string;
+    ownerName: string;
+    daemonId: string;
+    iceServers: unknown[];
+    requiresAuth: boolean;
+};
+export type ShareRevokedMsg = {
+    type: 'share:revoked';
+};
+export type ShareExpiredMsg = {
+    type: 'share:expired';
+};
+export type ShareErrorMsg = {
+    type: 'share:error';
+    error: string;
+};
+export type ShareViewerCountMsg = {
+    type: 'share:viewer_count';
+    count: number;
+    maxViewers: number;
+};
+/**
+ * Daemon signal relayed to the addressed viewer, payload as the daemon sent it;
+ * `from` is the daemon DO id, which the viewer page folds in as `daemonId`.
+ */
+export type ShareRelayedP2POfferMsg = {
+    type: 'p2p_offer';
+    payload: P2POfferWirePayload;
+    from: string;
+};
+export type ShareRelayedP2PIceMsg = {
+    type: 'p2p_ice';
+    payload: P2PIceWirePayload;
+    from: string;
+};
+export type SharedSessionToViewerMsg = ShareConnectedMsg | ShareRevokedMsg | ShareExpiredMsg | ShareErrorMsg | ShareViewerCountMsg | ShareRelayedP2POfferMsg | ShareRelayedP2PIceMsg;
+export declare const VIEWER_TO_SHARED_SESSION_TYPES: readonly ["p2p_ready", "p2p_offer", "p2p_answer", "p2p_ice"];
+export type ViewerToSharedSessionType = typeof VIEWER_TO_SHARED_SESSION_TYPES[number];
+export declare const isViewerToSharedSessionType: (value: unknown) => value is "p2p_ready" | "p2p_offer" | "p2p_answer" | "p2p_ice";
+/** The viewer's signal as sent; the DO stamps `daemonId`/`peerId`/`sharePermission` before relaying. */
+export type ViewerToSharedSessionMsg = Envelope<ViewerToSharedSessionType, Record<string, unknown>>;
+/** Parse boundary for SharedSessionDO: signaling frames only. */
+export declare function decodeViewerToSharedSession(raw: unknown): ViewerToSharedSessionMsg | null;

package/dist/protocol/dashboard-wire-version.d.ts

@@ -0,0 +1,21 @@
+/**
+ * protocol/dashboard-wire-version — the dashboard ↔ daemon wire version.
+ *
+ * Both dashboards (cloud over P2P, standalone over WS) state the version they
+ * speak on every topic subscribe; the daemon states its own on the standalone
+ * hello, on every keyed snapshot frame, and in the `protocol_mismatch` reply it
+ * sends INSTEAD of state when the two differ. There is no dual-format serving:
+ * a mismatched pair renders no state at all —
+ *   - the page is older than the daemon → the page must reload (its bundle
+ *     cannot read the daemon's frames);
+ *   - the daemon is older than the page → the daemon must be updated.
+ *
+ * Bump this whenever a frame shape changes incompatibly; one release carries
+ * the same value on both ends.
+ *   1 — implicit (frames before versioning).
+ *   2 — daemon.metadata deltas on the keyed-doc engine (2026-09-29).
+ */
+export declare const DASHBOARD_WIRE_VERSION = 2;
+export type DashboardWireCompat = 'ok' | 'reload_required' | 'daemon_update_required';
+/** How a page speaking `pageVersion` relates to a daemon speaking `daemonVersion` (absent = 1). */
+export declare function compareDashboardWireVersion(pageVersion: number, daemonVersion: number | null | undefined): DashboardWireCompat;

package/dist/protocol/envelope.d.ts

@@ -0,0 +1,55 @@
+/**
+ * protocol/envelope — helpers shared by the three link protocols.
+ *
+ * Wiring-unification Phase A2 (docs/design/2026-09-23-wiring-unification.md).
+ *
+ * Every link (daemon↔server WS, dashboard↔UserSession WS, dashboard↔daemon
+ * P2P DataChannel) is described the same way:
+ *
+ *   - a `const` tuple of message-kind names per direction;
+ *   - a discriminated union of `{ type, ... }` frames derived from it;
+ *   - a `decode<Link><Direction>(raw)` parse-boundary function that checks the
+ *     `type` is a member and the frame carries the MINIMAL shape the union
+ *     promises (an object payload where one is required, the top-level fields
+ *     a payload-less frame is keyed by). Semantic validation — is this session
+ *     id known, is the SDP well formed — stays with the handler that owns it.
+ *
+ * mesh-shared is a dependency-free leaf, so payload types here are STRUCTURAL
+ * mirrors of the richer daemon-core types (`RoutingSessionEntry`,
+ * `DaemonStatusEventPayload`, ...): daemon-core, the server and the web assign
+ * their richer types into these, never the other way round. A type-only import
+ * of daemon-core would make the published `.d.ts` of this package reference a
+ * package that depends on it — a cycle a leaf must not create.
+ */
+export type MessageId = string;
+/** `{ type, payload }` frame with the optional correlation/ordering fields every link uses. */
+export type Envelope<T extends string, P> = {
+    type: T;
+    payload: P;
+    id?: MessageId;
+    timestamp?: number;
+};
+/** Genuinely dynamic payloads (command arguments and results). Allowed by design; the union stays exhaustive on `type`. */
+export type CommandPayload = Record<string, unknown>;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function isNonEmptyString(value: unknown): value is string;
+export declare function isFiniteNumber(value: unknown): value is number;
+export declare function makeTypeGuard<T extends readonly string[]>(names: T): (value: unknown) => value is T[number];
+/**
+ * Compile-time proof that a name tuple and a union have exactly the same
+ * members. Used as `const _: AssertSameMembers<typeof NAMES, Union> = true`.
+ */
+export type AssertSameMembers<Tuple extends readonly string[], Union extends string> = [
+    Exclude<Union, Tuple[number]>,
+    Exclude<Tuple[number], Union>
+] extends [never, never] ? true : never;
+/** Narrow a frame's `type` to a union member, or null. */
+export declare function decodeTypeField<T extends string>(raw: unknown, isType: (value: unknown) => value is T): {
+    type: T;
+    frame: Record<string, unknown>;
+} | null;
+/** Read the optional envelope fields a frame may carry, dropping malformed ones. */
+export declare function readEnvelopeFields(frame: Record<string, unknown>): {
+    id?: MessageId;
+    timestamp?: number;
+};

package/dist/protocol/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * protocol — typed wire contracts for the three transport links.
+ *
+ *   ./daemon-server.ts        daemon ↔ Workers server WS
+ *   ./dashboard-server.ts     dashboard ↔ UserSessionDO WS (+ share viewer ↔ SharedSessionDO)
+ *   ./dashboard-daemon-p2p.ts dashboard ↔ daemon DataChannel
+ *
+ * Each exports name tuples, discriminated unions, type guards and a
+ * `decode<Link><Direction>(raw)` parse-boundary function. ../ws-protocol.ts
+ * keeps the pre-existing name-only aliases derived from these.
+ */
+export * from './envelope';
+export * from './daemon-server';
+export * from './dashboard-server';
+export * from './dashboard-daemon-p2p';
+export * from './dashboard-wire-version';

package/dist/session-launch.d.ts

@@ -0,0 +1,105 @@
+/**
+ * session-launch — how a session was launched: provider, model and thinking
+ * level, and WHERE each value came from.
+ *
+ * Wiring-unification Phase E (docs/design/2026-09-23-wiring-unification.md §7,
+ * RC5). Before this record the only trace of a session's model was a display
+ * string in recent-activity (`buildLegacyModelModeSummaryMetadata`), so nobody
+ * could answer "did I pick this model, did the dashboard restore it from last
+ * time, did a mesh slot choose it, or is it just the provider default?" — and
+ * after a daemon restart not even the value survived.
+ *
+ * The daemon owns the record (daemon-core `SessionRegistry`); this file holds the
+ * shape and the pure readers so daemon-core, web-core, the server and the MCP
+ * server all read one definition. It is a dependency-free leaf, like the rest of
+ * mesh-shared.
+ *
+ * ★Server content boundary (CLAUDE.md): the full record rides P2P only. The
+ * server path carries exactly two derived fields — `model` (an identifier,
+ * passed through {@link sanitizeModelIdentifier}) and `modelSource` (an enum,
+ * passed through {@link isModelAxisSource}). Never widen that to the record.
+ */
+export declare const MODEL_AXIS_SOURCES: readonly ["user", "remembered", "mesh_slot", "task_override", "provider_default", "unspecified"];
+export type ModelAxisSource = typeof MODEL_AXIS_SOURCES[number];
+export declare function isModelAxisSource(value: unknown): value is ModelAxisSource;
+/**
+ * Which surface started the session. `restore` means "re-attached to a hosted
+ * runtime that outlived a daemon restart" — the axis sources are preserved.
+ */
+export declare const SESSION_LAUNCHED_BY: readonly ["dashboard", "mesh", "cli", "api", "restore"];
+export type SessionLaunchedBy = typeof SESSION_LAUNCHED_BY[number];
+export declare function isSessionLaunchedBy(value: unknown): value is SessionLaunchedBy;
+/** How a value entered the axis history. */
+export type ModelSelectionVia = 'launch' | 'change_model' | 'observed';
+export interface ModelSelectionHistoryEntry {
+    at: number;
+    value: string;
+    via: ModelSelectionVia;
+}
+/** One axis (model, or thinking level) of a session launch. */
+export interface ModelSelection {
+    /** What the caller asked for. Absent = nothing requested. */
+    requested?: string;
+    source: ModelAxisSource;
+    /**
+     * The value actually handed to the provider: after `modelLaunchValueMap`
+     * (CLI `--model` template) or the ACP `setConfigOption` call. Absent when the
+     * request was not applied (no template, the config call failed) or nothing
+     * was requested.
+     */
+    launchValue?: string;
+    /**
+     * The provider default this session is expected to run with when nothing was
+     * requested (`source === 'provider_default'` only): discovery `models[0]`,
+     * else the manifest's first option. Nothing was passed to the provider.
+     */
+    resolvedDefault?: string;
+    /** Last explicit runtime change (`change_model` / `set_thought_level`). */
+    current?: string;
+    /** Last value the provider itself reported (statusline, native history). */
+    observed?: string;
+    observedAt?: number;
+    /** Every value change in order. The last entry is the value in force. */
+    history: ModelSelectionHistoryEntry[];
+}
+export interface SessionLaunchRecord {
+    sessionId: string;
+    providerType: string;
+    providerVersion?: string;
+    providerChannel?: 'stable' | 'preview';
+    /** `restore` = re-attached after a daemon restart; the axis sources stay the original ones. */
+    launchedBy: SessionLaunchedBy;
+    launchedAt: number;
+    workspace?: string;
+    model: ModelSelection;
+    thinkingLevel: ModelSelection;
+    autoApproveModeId?: string;
+    /**
+     * Reserved by the design (§7 E1) for sanitized launch argv. Not populated:
+     * argv carries coordinator system-prompt text and config paths, and the
+     * session-host record already keeps the raw argv for restore.
+     */
+    cliArgs?: string[];
+}
+/** History is bounded; the first `launch` entry is always kept. */
+export declare const MODEL_SELECTION_HISTORY_LIMIT = 20;
+/** The value in force now: the latest change, else the launch-time value. */
+export declare function effectiveModelSelectionValue(selection: ModelSelection | null | undefined): string | undefined;
+/** The value the session started with (what was passed, else asked for, else the default). */
+export declare function launchModelSelectionValue(selection: ModelSelection | null | undefined): string | undefined;
+export interface ModelSelectionDisplay {
+    /** The value in force now. */
+    value: string;
+    /** The value the session launched with, when it differs from `value`. */
+    changedFrom?: string;
+    source: ModelAxisSource;
+}
+/** Pure projection for UI chips: "sonnet · chosen", "sonnet → opus (changed)". */
+export declare function describeModelSelection(selection: ModelSelection | null | undefined): ModelSelectionDisplay | undefined;
+export declare function sanitizeModelIdentifier(value: unknown): string | undefined;
+/**
+ * Validate a record that crossed a process or storage boundary (session-host
+ * record meta on restore, a P2P snapshot). Returns undefined for anything that
+ * is not recognisably a launch record; unknown keys are dropped.
+ */
+export declare function parseSessionLaunchRecord(raw: unknown): SessionLaunchRecord | undefined;

package/dist/session-status.d.ts

@@ -0,0 +1,75 @@
+/**
+ * session-status — the ONE session status vocabulary.
+ *
+ * Wiring-unification Phase A1 (docs/design/2026-09-23-wiring-unification.md).
+ *
+ * Before this file, the same eleven-member union was declared three times in
+ * daemon-core (`SessionStatus`, `ManagedStatus`, and a stale `AgentStatus`) and
+ * five independent "is it busy?" sets disagreed with each other — for example
+ * `waiting_approval` counted as busy in three of them and idle in the other
+ * two. Every consumer now derives from here:
+ *
+ *   - the canonical union `SessionStatus` and its member list `SESSION_STATUSES`;
+ *   - a behavioural CLASS per status (`SESSION_STATUS_CLASS`) — the only thing
+ *     send / dispatch / UI logic may branch on;
+ *   - an alias table for the raw spellings providers and status lanes still
+ *     emit (`running`, `streaming`, `no_progress`, …) so classification is total.
+ *
+ * This lives in mesh-shared (a dependency-free leaf) because web-core must not
+ * value-import the daemon-core barrel, and the server has no daemon-core at all.
+ */
+export declare const SESSION_STATUSES: readonly ["idle", "generating", "waiting_approval", "waiting_choice", "finalizing", "error", "stopped", "starting", "panel_hidden", "not_monitored", "disconnected"];
+export type SessionStatus = typeof SESSION_STATUSES[number];
+export declare const RECENT_SESSION_BUCKETS: readonly ["needs_attention", "working", "task_complete", "idle"];
+export type RecentSessionBucket = typeof RECENT_SESSION_BUCKETS[number];
+/**
+ * Behavioural class of a status.
+ *
+ *   working  — the agent owns the turn; input is queued, not delivered.
+ *   blocked  — the agent is waiting on a human decision (approval / choice);
+ *              alive, and the turn is not over.
+ *   ready    — the agent will accept input now.
+ *   dead     — the session will never accept input again.
+ *   unknown  — the spelling is not one we classify (callers must fail safe).
+ */
+export type SessionStatusClass = 'working' | 'blocked' | 'ready' | 'dead' | 'unknown';
+export declare const SESSION_STATUS_CLASS: Record<SessionStatus, Exclude<SessionStatusClass, 'unknown'>>;
+/**
+ * Raw spellings that still reach status consumers from IDE/CDP providers, the
+ * chat-tail status lane and legacy adapters, mapped onto the canonical member
+ * that carries the same behavioural meaning. Keep this table exhaustive over
+ * what the five pre-unification busy sets accepted; a spelling missing here
+ * classifies as `unknown`, which every consumer must treat as "do not assume
+ * idle".
+ */
+export declare const SESSION_STATUS_ALIASES: Readonly<Record<string, SessionStatus>>;
+export declare function isSessionStatus(value: unknown): value is SessionStatus;
+/** Canonical member for a raw status spelling, or null when unrecognised. */
+export declare function normalizeSessionStatus(raw: unknown): SessionStatus | null;
+export declare function classifySessionStatus(raw: unknown): SessionStatusClass;
+export declare function isWorkingStatus(raw: unknown): boolean;
+export declare function isBlockedStatus(raw: unknown): boolean;
+export declare function isReadyStatus(raw: unknown): boolean;
+export declare function isDeadStatus(raw: unknown): boolean;
+/**
+ * "Busy" in the sense every pre-unification set meant: the agent cannot take a
+ * new instruction right now, whether because it is working or because it is
+ * blocked on a human. Dead sessions are NOT busy — they are gone, and callers
+ * that need to distinguish must check `isDeadStatus` first.
+ */
+export declare function isBusyStatus(raw: unknown): boolean;
+export declare function statusesOfClass(cls: Exclude<SessionStatusClass, 'unknown'>): SessionStatus[];
+/**
+ * Mesh-record terminal spellings: a session RECORD in one of these is gone
+ * (the vocabulary's `dead` class covers the canonical members; records also
+ * carry `failed` / `terminated` / `exited` / `closed`).
+ */
+export declare const TERMINAL_SESSION_RECORD_STATUSES: readonly ["stopped", "failed", "terminated", "exited", "closed"];
+export declare function isTerminalSessionRecordStatus(raw: unknown): boolean;
+/**
+ * THE "idle — can take a task now" predicate over a session state/record (its
+ * top-level `status` and chat lane). Every idle-candidate check (queue drain,
+ * auto-launch orphan sweep, dispatch pick) uses this one, so they cannot
+ * disagree about which sessions are candidates.
+ */
+export declare function isIdleSessionState(state: unknown): boolean;

package/dist/slot-proposal.d.ts

@@ -1,9 +1,9 @@
 /**
- * CLI auto-detect → capability-slot / MAGI-panel PROPOSAL generator.
+ * CLI auto-detect → capability-slot PROPOSAL generator.
  *
  * Detection of installed CLI providers already exists per node (the status
  * snapshot's `availableProviders`), and applying a slot profile already exists
- * (`mesh_node_slots_set`, dry-run by default). What was missing is the bit in
+ * (`mesh_node_slots` action "set", dry-run by default). What was missing is the bit in
  * between: turning "these CLIs are installed on this node" into a concrete
  * `NodeCapabilitySlot[]` draft the operator can review. This module is that
  * bridge, and nothing more — it is a PURE proposal generator. It never writes;
@@ -27,7 +27,6 @@
  * need it, and it is pure data + pure functions on plain objects.
  */
 import { type MeshTaskDifficulty, type NodeCapabilitySlot } from './brain-routing';
-import type { MagiSlot } from './magi';
 /**
  * One provider's seeded slot recipe. A provider may map to MORE THAN ONE slot
  * (claude-cli does: a wide sonnet slot plus a narrow opus slot for the hard
@@ -120,28 +119,3 @@ export interface SlotProposal {
  * returned proposal can report what a wholesale write would destroy.
  */
 export declare function buildSlotProposal(detected: readonly DetectedCliProvider[], currentSlots?: readonly NodeCapabilitySlot[]): SlotProposal;
-/**
- * Build a MAGI panel proposal from the same detections.
- *
- * ─── Deliberately narrow ──────────────────────────────────────────────────────
- *
- * MAGI's value is provider INDEPENDENCE: replicas from different providers
- * (ideally different machines) answering the same question, so agreement means
- * something. Detection tells us which providers exist — that is exactly enough
- * to propose one panel of distinct providers, and no more.
- *
- * What detection does NOT tell us is which provider suits which review KIND
- * (rca vs design vs claim_audit). Nothing in any manifest grades a provider for
- * root-cause analysis over design review, and inventing a per-kind assignment
- * would fabricate a rationale that does not exist. So this proposes ONE panel of
- * the detected providers and leaves the kind binding to the operator; the caller
- * decides which `task_kind` to bind it to via the existing dry-run tool.
- *
- * Ordering follows {@link CLI_SLOT_RECIPES} insertion order (recipe-known
- * providers first, in table order), so the panel leads with the providers whose
- * suitability is actually attested.
- */
-export declare function buildMagiPanelProposal(detected: readonly DetectedCliProvider[], opts?: {
-    nodeId?: string;
-    maxSlots?: number;
-}): MagiSlot[];