@adhdev/mesh-shared 1.0.60-rc.70 → 1.0.60-rc.72

package/dist/interpolation.d.ts

@@ -1,10 +1 @@
-/**
- * Pure {{key}} template interpolation shared by the mesh command paths.
- *
- * Hoisted from packages/daemon-cloud/src/mesh/mesh-interpolation.ts — the
- * substitution is transport-agnostic (plain string/object work), so it belongs
- * in the dependency-free mesh-shared leaf where standalone can reuse it too.
- * The substitution semantics are byte-for-byte identical to the prior cloud copy.
- */
-export declare function interpolateArgs(args: Record<string, unknown>, context: Record<string, unknown>): Record<string, unknown>;
 export declare function interpolateString(template: string, ctx: Record<string, unknown>): string;

package/dist/keyed-doc-delta.d.ts

@@ -1,32 +1,40 @@
 /**
- * Keyed document delta — the diff/fold pair behind the `mesh.status` lane
- * (the dashboard's mesh view; data-path audit 2026-09-29 P1-5).
+ * Keyed document delta — THE diff/fold engine behind every keyed dashboard
+ * lane: `daemon.metadata` (the daemon's state, sessions keyed by id) and
+ * `mesh.status` (the coordinator's mesh view, nodes / queue tasks / missions
+ * keyed) — data-path audit 2026-09-29 P1-4 (one engine, one spec per lane).
  *
- * A document is plain top-level fields plus named keyed COLLECTIONS (arrays of
- * rows identified by an id field, possibly nested one object deep, e.g.
- * `queue.tasks`). The daemon digests every body it would have sent, diffs it
- * against the digest of the last body DELIVERED to a subscription, and sends
- * only the difference: changed top-level fields, and per collection the rows
- * whose content changed (changed fields only), the fields a row lost, and the
- * rows that disappeared. An unchanged document diffs to `null` — zero bytes on
- * the wire. The dashboard folds each delta into its held snapshot; the fold of
- * every delta since a snapshot equals the latest snapshot (pinned by
- * keyed-doc-delta.test.ts).
+ * A document is plain top-level fields, optional SPLIT objects (an object whose
+ * fields are diffed one by one, e.g. daemon.metadata's `status`), and named
+ * keyed COLLECTIONS (arrays of rows identified by an id field, possibly nested
+ * one object deep, e.g. `queue.tasks` / `status.sessions`). The daemon digests
+ * every body it would have sent, diffs it against the digest of the last body
+ * DELIVERED to a subscription, and sends only the difference: changed fields,
+ * and per collection the rows whose content changed (changed fields only), the
+ * fields a row lost, and the rows that disappeared. An unchanged document
+ * diffs to `null` — zero bytes on the wire. The dashboard folds each delta
+ * into its held snapshot; the fold of every delta since a snapshot equals the
+ * latest snapshot apart from `ignore`d fields (pinned by keyed-doc-delta.test.ts).
  *
- * `volatileTopLevel` fields (a build stamp, live process counters) are not a
- * change by themselves; when something else changed they ride along.
+ * Volatile fields (a build stamp, live process counters, a row's per-build
+ * stamps via `stableRow`) are not a change by themselves; when something else
+ * changed they ride along.
  *
  * Pure leaf: plain objects in, plain objects out; no transport, no clock.
  */
 export interface KeyedDocSpec {
-    /** Collection path (`nodes`, `queue.tasks`) → the id field of its rows. */
+    /** Collection path (`nodes`, `queue.tasks`, `status.sessions`) → the id field of its rows. */
     collections: Readonly<Record<string, string>>;
-    /** Top-level fields that change on every build without meaning anything. */
+    /** Top-level objects whose own fields are diffed one by one (the rest of the object is not re-sent). */
+    splitObjects?: readonly string[];
+    /** Field paths (`daemonId`, `status.timestamp`) that are never diffed — envelope identity / clock. */
+    ignore?: readonly string[];
+    /** Field paths (top-level or inside a split object) that change on every build without meaning anything. */
     volatileTopLevel?: readonly string[];
     /**
      * The part of a collection row that decides whether it CHANGED (drop the
      * per-build stamps inside it). A row whose stable view is unchanged sends
-     * nothing; a changed field is sent with its full current value, stamps
+     * nothing; a changed row sends every field whose value differs, stamps
      * included. Must not mutate `row`.
      */
     stableRow?: (collection: string, row: Record<string, unknown>) => Record<string, unknown>;
@@ -44,6 +52,7 @@ interface CollectionDigest {
     readonly order: readonly string[];
 }
 export interface KeyedDocDigest {
+    /** Field signatures by path (`field`, or `object.field` for a split object). */
     readonly top: ReadonlyMap<string, string>;
     readonly topValues: Readonly<Record<string, unknown>>;
     readonly collections: ReadonlyMap<string, CollectionDigest>;
@@ -62,6 +71,11 @@ export interface KeyedCollectionDelta {
 export interface KeyedDocDelta {
     set?: Record<string, unknown>;
     unset?: string[];
+    /** Per split object: its changed / lost fields. */
+    objects?: Record<string, {
+        set?: Record<string, unknown>;
+        unset?: string[];
+    }>;
     collections?: Record<string, KeyedCollectionDelta>;
 }
 /** Digest one document. Cheap to hold: values are referenced, not copied. */
@@ -73,6 +87,14 @@ export declare function digestKeyedDoc(doc: Record<string, unknown>, spec: Keyed
 export declare function diffKeyedDoc(prev: KeyedDocDigest, next: KeyedDocDigest, spec: KeyedDocSpec): KeyedDocDelta | null;
 /** Rebuild the full document from a held one plus a delta. Never mutates `held`. */
 export declare function foldKeyedDoc<T extends Record<string, unknown>>(held: T, delta: KeyedDocDelta, spec: KeyedDocSpec): T;
+/**
+ * The `daemon.metadata` document (the snapshot body minus its envelope):
+ * `status` is split field by field, its sessions keyed by `id`. `daemonId` is
+ * envelope identity and `status.timestamp` the build clock — never diffed (the
+ * fold re-stamps them from the frame); a session's `lastUpdated` build stamp is
+ * not a change by itself.
+ */
+export declare const DAEMON_METADATA_DOC_SPEC: KeyedDocSpec;
 /**
  * The `mesh.status` document: nodes keyed by `nodeId`, queue tasks and missions
  * by `id`. `refreshedAt` and `sourceOfTruth` (its aggregate-cache age /

package/dist/mesh-vocabulary.d.ts

@@ -54,11 +54,8 @@ export declare const isMeshTaskStatus: (value: unknown) => value is "failed" | "
 export declare const isMeshTerminalTaskStatus: (value: unknown) => value is "failed" | "completed" | "cancelled";
 export declare const isMeshTaskMode: (value: unknown) => value is "code_change" | "validation" | "live_debug_readonly" | "launch_app" | "convergence";
 export declare const isMeshTaskPriority: (value: unknown) => value is "low" | "high" | "normal";
-export declare const isMeshThinkingLevel: (value: unknown) => value is "medium" | "low" | "high";
 export declare const isMeshDeliveryMode: (value: unknown) => value is "when_idle" | "interrupt";
-export declare const isMeshSessionCleanupMode: (value: unknown) => value is "preserve" | "stop" | "delete_stopped" | "stop_and_delete";
 export declare const isWorkerReportOutcome: (value: unknown) => value is "failed" | "blocked" | "completed";
-export declare const isWorkerBranchState: (value: unknown) => value is "merged_to_main" | "pushed_feature_branch_needs_merge" | "blocked_review" | "cleanup_candidate" | "not_mergeable";
 /**
  * JSON-schema fragment for a string enum, derived from the tuple. Use this in
  * every MCP tool schema instead of spelling the member list again.

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

@@ -32,9 +32,9 @@ import { type CommandPayload, type Envelope, type MessageId } from './envelope';
  * 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 declare const DAEMON_STATUS_EVENT_NAMES: readonly ["agent:generating_started", "agent:waiting_approval", "agent:waiting_choice", "agent:generating_completed", "agent:stopped", "monitor:no_progress"];
 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";
+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";
 /**
  * Server-bound status event. Content boundary: identifiers, enums, counters
  * and booleans only — plus the approved approval-modal exception
@@ -102,8 +102,6 @@ export type SeqscribeStatusWireSummary = {
     transcriptDedupedBucket?: number;
     transcriptOversizedBucket?: number;
     transcriptDroppedBucket?: number;
-    transcriptParityRan?: boolean;
-    transcriptParityMismatchBucket?: number;
 };
 export type CloudStatusReportWirePayload = {
     sessions: RoutingSessionWireEntry[];

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

@@ -9,8 +9,7 @@
  * (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.
+ * matched them by `id` as a fallthrough. They are now `response` frames.
  *
  * Chunking: any request frame may be split by the sender into
  * `<kind>_chunk` frames (`id`, `chunkId`, `index`, `total`, `data`) when it
@@ -82,12 +81,16 @@ export type P2PScreenshotStopMsg = {
     type: 'screenshot_stop';
     targetSessionId?: string;
 };
-/** Topic subscription. `params` is topic-specific (daemon-core `SubscribeRequestMap`); `object` keeps every topic's interface assignable. */
+/**
+ * Topic subscription. `params` is topic-specific (daemon-core `SubscribeRequestMap`); `object` keeps every topic's interface assignable.
+ * `wireVersion` is the dashboard wire version the page speaks (./dashboard-wire-version.ts).
+ */
 export type P2PSubscribeMsg = {
     type: 'subscribe';
     topic: string;
     key: string;
     params: object;
+    wireVersion?: number;
 };
 export type P2PUnsubscribeMsg = {
     type: 'unsubscribe';
@@ -204,13 +207,7 @@ export type P2PTranscriptTopicsAvailableMsg = {
     topics: string[];
 };
 export type DaemonToDashboardP2PMsg = P2PPingMsg | P2PPongMsg | P2PEvictedMsg | P2PStatusEventMsg | P2PTopicUpdateMsg | P2PTopicUpdateChunkMsg | P2PSessionOutputMsg | P2PSessionOutputChunkMsg | P2PSessionIoErrorMsg | P2PCommandResultMsg | P2PCommandResultChunkMsg | P2PResponseMsg | P2PTranscriptTopicsAvailableMsg;
-/**
- * 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.
- */
+/** Parse boundary for the dashboard (after chunk reassembly). */
 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>;

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

@@ -21,9 +21,9 @@ import { type DaemonStatusEventName, type P2PIceWirePayload, type P2POfferWirePa
 /** 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", "monitor:long_generating", "daemon:disconnect", "team:session_viewed", "team:view_request", "team:view_request_approved", "team:view_request_rejected"];
+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" | "monitor:long_generating" | "daemon:disconnect" | "team:session_viewed" | "team:view_request" | "team:view_request_approved" | "team:view_request_rejected";
+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

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/index.d.ts

@@ -13,3 +13,4 @@ export * from './envelope';
 export * from './daemon-server';
 export * from './dashboard-server';
 export * from './dashboard-daemon-p2p';
+export * from './dashboard-wire-version';

package/dist/session-status.d.ts

@@ -59,3 +59,17 @@ export declare function isDeadStatus(raw: unknown): boolean;
  */
 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/turn-evidence.d.ts

@@ -361,11 +361,9 @@ export declare const TURN_EVIDENCE_FIELD_SPECS: TurnEvidenceFieldSpecs;
 export declare const TURN_EVIDENCE_KINDS: readonly TurnEvidenceKind[];
 /** Evidence kinds that, on their own, can end a turn (the ones R18/R19/R27 reason about). */
 export declare const TERMINAL_CLASS_EVIDENCE_KINDS: readonly ["turn_end", "transcript_final", "no_progress", "worker_report", "session_error", "process_exit", "cancel", "operator_status"];
-export declare const isEvidenceSourceId: (value: unknown) => value is "fsm_edge" | "short_gen_inline" | "completion_flush_genuine" | "completion_flush_weak" | "monitor_final_summary" | "pre_cleanup_transcript" | "stall_transcript" | "startup_grace_collapse" | "acp_prompt_response" | "cdp_state" | "approval_gate" | "modal_button" | "mesh_stall_watchdog" | "status_monitor" | "pty_exit" | "provider_error" | "coordinator_probe" | "mcp_probe" | "worker_tool" | "dispatch" | "input_service" | "operator" | "intentional_cleanup" | "scheduler" | "git_probe" | "session_registry";
 export declare const isTurnEvidenceKind: (value: unknown) => value is "no_progress" | "delivered" | "liveness" | "turn_end" | "transcript_final" | "session_error" | "dispatch_failed" | "dispatch_accepted" | "delivery_refused" | "duplicate_dispatch_refusal" | "session_rebound" | "turn_started" | "suspension" | "suspension_resolved" | "transcript_activity" | "process_exit" | "worker_report" | "worker_progress" | "git_side_effect" | "cancel" | "operator_status" | "coordinator_ack" | "hold_expired";
 export declare const isTurnReason: (value: unknown) => value is "intentional_cleanup" | "operator_cancel" | "task_removed" | "mission_abandoned" | "superseded" | "operator_update" | "refine_terminal" | "validation_terminal" | "hard_ceiling" | "turn_end" | "weak_end_confirmed" | "transcript_final" | "worker_reported" | "finalization_timeout_no_response" | "session_error" | "provider_auth_failed" | "provider_billing_failed" | "reclaim_budget_exhausted" | "hollow_max_retries" | "migration_orphan" | "dispatch_refused_session_exited" | "dispatch_refused_no_target" | "dispatch_refused_unsupported_input" | "dispatch_failed" | "session_exit" | "session_exit_before_turn" | "session_dead" | "hollow_completion" | "assigned_stranded_dispatch_unconfirmed" | "delivered_not_consumed_redrive" | "delivered_no_turn_deadline";
 export declare const isNotifyKind: (value: unknown) => value is "stopped" | "failed" | "no_progress" | "completed" | "cancelled" | "approval" | "choice" | "approval_resolved" | "candidate" | "progress" | "late_completion" | "mesh_event";
-export declare const isHoldReason: (value: unknown) => value is "await_delivery" | "await_consume" | "await_turn" | "liveness" | "hard_ceiling" | "live_pending" | "transcript_quiet" | "weak_candidate" | "suspension_before_consumed" | "await_report" | "await_end";
 export declare const isTurnOutcome: (value: unknown) => value is "failed" | "completed" | "cancelled";
 export declare const isCommitStrength: (value: unknown) => value is "operator" | "genuine" | "weak" | "tool_report";
 export declare function isEvidenceIdentifier(value: unknown): value is string;
@@ -376,7 +374,6 @@ export declare function isTurnAttemptRef(value: unknown): value is TurnAttemptRe
  * and NO undeclared field (an unknown key is how free text would sneak in).
  */
 export declare function isTurnEvidence(value: unknown): value is TurnEvidence;
-export declare function isTerminalClassEvidenceKind(kind: TurnEvidenceKind): kind is typeof TERMINAL_CLASS_EVIDENCE_KINDS[number];
 export declare const TURN_EVIDENCE_FLAGS: readonly ["hollow", "afterFinalizationTimeout", "nativeMarker", "selfAttributing"];
 export type TurnEvidenceFlag = typeof TURN_EVIDENCE_FLAGS[number];
 /** Scalar-only payload for `mesh.record` (the existing allow-list projection's output). */
@@ -422,7 +419,6 @@ export type MeshTopicEntry = {
     taskId?: string;
     payload: ProjectedScalars;
 });
-export declare const isMeshTopicEntryKind: (value: unknown) => value is "turn.evidence" | "turn.committed" | "turn.notify" | "mesh.record";
 export declare function isMeshTopicEntry(value: unknown): value is MeshTopicEntry;
 /**
  * Project evidence onto its `turn.evidence` topic entry. Pure; the attempt

package/dist/ws-protocol.d.ts

@@ -29,8 +29,6 @@ export type P2PSignalingWsMsg = P2PSignalType | MeshP2PSignalType;
 export type DashboardP2PMessageKind = DashboardToDaemonP2PType | DaemonToDashboardP2PType;
 export declare const DAEMON_TO_SERVER_WS_MSGS: readonly DaemonToServerWsMsg[];
 export declare const SERVER_TO_DAEMON_WS_MSGS: readonly ServerToDaemonWsMsg[];
-export declare const isDaemonToServerWsMsg: (value: unknown) => value is DaemonToServerWsMsg;
-export declare const isServerToDaemonWsMsg: (value: unknown) => value is ServerToDaemonWsMsg;
 /**
  * `auth_ok.payload.limits` — the plan-limit contract the server sends DOWN to
  * the daemon for client-side enforcement.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/mesh-shared",
-  "version": "1.0.60-rc.70",
+  "version": "1.0.60-rc.72",
   "description": "ADHDev mesh-shared — pure mesh/git status normalizers shared by daemon-core and web-core",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/index.ts

@@ -39,5 +39,4 @@ export * from './session-launch'
 export * from './turn-ipc'
 export * from './path-ownership'
 export * from './mission-brief'
-export * from './keyed-status-delta'
 export * from './keyed-doc-delta'

package/src/interpolation.ts

@@ -1,21 +1,3 @@
-/**
- * Pure {{key}} template interpolation shared by the mesh command paths.
- *
- * Hoisted from packages/daemon-cloud/src/mesh/mesh-interpolation.ts — the
- * substitution is transport-agnostic (plain string/object work), so it belongs
- * in the dependency-free mesh-shared leaf where standalone can reuse it too.
- * The substitution semantics are byte-for-byte identical to the prior cloud copy.
- */
-export function interpolateArgs(
-  args: Record<string, unknown>,
-  context: Record<string, unknown>,
-): Record<string, unknown> {
-  const result: Record<string, unknown> = {};
-  for (const [k, v] of Object.entries(args)) {
-    result[k] = typeof v === 'string' ? interpolateString(v, context) : v;
-  }
-  return result;
-}
 
 export function interpolateString(template: string, ctx: Record<string, unknown>): string {
   return template.replace(/\{\{(\w+)\}\}/g, (_, key) => {

package/src/keyed-doc-delta.ts

@@ -1,33 +1,41 @@
 /**
- * Keyed document delta — the diff/fold pair behind the `mesh.status` lane
- * (the dashboard's mesh view; data-path audit 2026-09-29 P1-5).
+ * Keyed document delta — THE diff/fold engine behind every keyed dashboard
+ * lane: `daemon.metadata` (the daemon's state, sessions keyed by id) and
+ * `mesh.status` (the coordinator's mesh view, nodes / queue tasks / missions
+ * keyed) — data-path audit 2026-09-29 P1-4 (one engine, one spec per lane).
  *
- * A document is plain top-level fields plus named keyed COLLECTIONS (arrays of
- * rows identified by an id field, possibly nested one object deep, e.g.
- * `queue.tasks`). The daemon digests every body it would have sent, diffs it
- * against the digest of the last body DELIVERED to a subscription, and sends
- * only the difference: changed top-level fields, and per collection the rows
- * whose content changed (changed fields only), the fields a row lost, and the
- * rows that disappeared. An unchanged document diffs to `null` — zero bytes on
- * the wire. The dashboard folds each delta into its held snapshot; the fold of
- * every delta since a snapshot equals the latest snapshot (pinned by
- * keyed-doc-delta.test.ts).
+ * A document is plain top-level fields, optional SPLIT objects (an object whose
+ * fields are diffed one by one, e.g. daemon.metadata's `status`), and named
+ * keyed COLLECTIONS (arrays of rows identified by an id field, possibly nested
+ * one object deep, e.g. `queue.tasks` / `status.sessions`). The daemon digests
+ * every body it would have sent, diffs it against the digest of the last body
+ * DELIVERED to a subscription, and sends only the difference: changed fields,
+ * and per collection the rows whose content changed (changed fields only), the
+ * fields a row lost, and the rows that disappeared. An unchanged document
+ * diffs to `null` — zero bytes on the wire. The dashboard folds each delta
+ * into its held snapshot; the fold of every delta since a snapshot equals the
+ * latest snapshot apart from `ignore`d fields (pinned by keyed-doc-delta.test.ts).
  *
- * `volatileTopLevel` fields (a build stamp, live process counters) are not a
- * change by themselves; when something else changed they ride along.
+ * Volatile fields (a build stamp, live process counters, a row's per-build
+ * stamps via `stableRow`) are not a change by themselves; when something else
+ * changed they ride along.
  *
  * Pure leaf: plain objects in, plain objects out; no transport, no clock.
  */
 
 export interface KeyedDocSpec {
-    /** Collection path (`nodes`, `queue.tasks`) → the id field of its rows. */
+    /** Collection path (`nodes`, `queue.tasks`, `status.sessions`) → the id field of its rows. */
     collections: Readonly<Record<string, string>>
-    /** Top-level fields that change on every build without meaning anything. */
+    /** Top-level objects whose own fields are diffed one by one (the rest of the object is not re-sent). */
+    splitObjects?: readonly string[]
+    /** Field paths (`daemonId`, `status.timestamp`) that are never diffed — envelope identity / clock. */
+    ignore?: readonly string[]
+    /** Field paths (top-level or inside a split object) that change on every build without meaning anything. */
     volatileTopLevel?: readonly string[]
     /**
      * The part of a collection row that decides whether it CHANGED (drop the
      * per-build stamps inside it). A row whose stable view is unchanged sends
-     * nothing; a changed field is sent with its full current value, stamps
+     * nothing; a changed row sends every field whose value differs, stamps
      * included. Must not mutate `row`.
      */
     stableRow?: (collection: string, row: Record<string, unknown>) => Record<string, unknown>
@@ -49,6 +57,7 @@ interface CollectionDigest {
 }
 
 export interface KeyedDocDigest {
+    /** Field signatures by path (`field`, or `object.field` for a split object). */
     readonly top: ReadonlyMap<string, string>
     readonly topValues: Readonly<Record<string, unknown>>
     readonly collections: ReadonlyMap<string, CollectionDigest>
@@ -69,6 +78,8 @@ export interface KeyedCollectionDelta {
 export interface KeyedDocDelta {
     set?: Record<string, unknown>
     unset?: string[]
+    /** Per split object: its changed / lost fields. */
+    objects?: Record<string, { set?: Record<string, unknown>; unset?: string[] }>
     collections?: Record<string, KeyedCollectionDelta>
 }
 
@@ -135,11 +146,21 @@ function fieldSigsOf(digest: RowDigest): Map<string, string> {
 export function digestKeyedDoc(doc: Record<string, unknown>, spec: KeyedDocSpec): KeyedDocDigest {
     const top = new Map<string, string>()
     const topValues: Record<string, unknown> = {}
-    for (const [key, value] of Object.entries(stripCollections(doc, spec))) {
+    const ignore = new Set(spec.ignore ?? [])
+    const split = new Set(spec.splitObjects ?? [])
+    const add = (path: string, value: unknown) => {
+        if (ignore.has(path)) return
         const s = sig(value)
-        if (s === undefined) continue
-        top.set(key, s)
-        topValues[key] = value
+        if (s === undefined) return
+        top.set(path, s)
+        topValues[path] = value
+    }
+    for (const [key, value] of Object.entries(stripCollections(doc, spec))) {
+        if (split.has(key) && isRecord(value)) {
+            for (const [field, fieldValue] of Object.entries(value)) add(`${key}.${field}`, fieldValue)
+            continue
+        }
+        add(key, value)
     }
     const collections = new Map<string, CollectionDigest>()
     for (const [path, idField] of Object.entries(spec.collections)) {
@@ -187,6 +208,13 @@ function diffCollection(prev: CollectionDigest | undefined, next: CollectionDige
             change[key] = nextRow.value[key]
             changed = true
         }
+        // A real change carries the row's volatile fields (dropped by stableRow) along.
+        if (changed) {
+            for (const [key, value] of Object.entries(nextRow.value)) {
+                if (key in nextRow.stable || key in change) continue
+                if (sig(prevRow.value[key]) !== sig(value)) change[key] = value
+            }
+        }
         const gone: string[] = []
         for (const key of prevSigs.keys()) if (!nextSigs.has(key) && !(key in nextRow.value)) gone.push(key)
         if (changed) (delta.upsert ??= []).push(change)
@@ -208,15 +236,27 @@ export function diffKeyedDoc(prev: KeyedDocDigest, next: KeyedDocDigest, spec: K
     let meaningful = false
     let set: Record<string, unknown> | undefined
     let unset: string[] | undefined
-    for (const [key, s] of next.top) {
-        if (prev.top.get(key) === s) continue
-        ;(set ??= {})[key] = next.topValues[key]
-        if (!next.volatile.has(key)) meaningful = true
+    const split = spec.splitObjects ?? []
+    const objectOf = (path: string): [string, string] | null => {
+        for (const object of split) {
+            if (path.startsWith(`${object}.`)) return [object, path.slice(object.length + 1)]
+        }
+        return null
     }
-    for (const key of prev.top.keys()) {
-        if (next.top.has(key)) continue
-        ;(unset ??= []).push(key)
-        if (!next.volatile.has(key)) meaningful = true
+    const objects: NonNullable<KeyedDocDelta['objects']> = {}
+    for (const [path, s] of next.top) {
+        if (prev.top.get(path) === s) continue
+        const inObject = objectOf(path)
+        if (inObject) ((objects[inObject[0]] ??= {}).set ??= {})[inObject[1]] = next.topValues[path]
+        else (set ??= {})[path] = next.topValues[path]
+        if (!next.volatile.has(path)) meaningful = true
+    }
+    for (const path of prev.top.keys()) {
+        if (next.top.has(path)) continue
+        const inObject = objectOf(path)
+        if (inObject) ((objects[inObject[0]] ??= {}).unset ??= []).push(inObject[1])
+        else (unset ??= []).push(path)
+        if (!next.volatile.has(path)) meaningful = true
     }
     for (const [path, idField] of Object.entries(spec.collections)) {
         const change = diffCollection(prev.collections.get(path), next.collections.get(path), idField)
@@ -227,6 +267,7 @@ export function diffKeyedDoc(prev: KeyedDocDigest, next: KeyedDocDigest, spec: K
     if (!meaningful) return null
     if (set) delta.set = set
     if (unset) delta.unset = unset
+    if (Object.keys(objects).length > 0) delta.objects = objects
     return delta
 }
 
@@ -274,6 +315,12 @@ export function foldKeyedDoc<T extends Record<string, unknown>>(held: T, delta:
     const next: Record<string, unknown> = stripCollections(held, spec)
     for (const key of delta.unset ?? []) delete next[key]
     Object.assign(next, delta.set ?? {})
+    for (const [object, change] of Object.entries(delta.objects ?? {})) {
+        const folded: Record<string, unknown> = isRecord(next[object]) ? { ...(next[object] as Record<string, unknown>) } : {}
+        for (const key of change.unset ?? []) delete folded[key]
+        Object.assign(folded, change.set ?? {})
+        next[object] = folded
+    }
     for (const [path, idField] of Object.entries(spec.collections)) {
         const change = delta.collections?.[path]
         const heldList = heldCollections.get(path)
@@ -296,6 +343,24 @@ export function foldKeyedDoc<T extends Record<string, unknown>>(held: T, delta:
     return next as T
 }
 
+/**
+ * The `daemon.metadata` document (the snapshot body minus its envelope):
+ * `status` is split field by field, its sessions keyed by `id`. `daemonId` is
+ * envelope identity and `status.timestamp` the build clock — never diffed (the
+ * fold re-stamps them from the frame); a session's `lastUpdated` build stamp is
+ * not a change by itself.
+ */
+export const DAEMON_METADATA_DOC_SPEC: KeyedDocSpec = {
+    collections: { 'status.sessions': 'id' },
+    splitObjects: ['status'],
+    ignore: ['daemonId', 'status.timestamp'],
+    stableRow: (_collection, row) => {
+        if (!('lastUpdated' in row)) return row
+        const { lastUpdated: _stamp, ...stable } = row
+        return stable
+    },
+}
+
 /**
  * The `mesh.status` document: nodes keyed by `nodeId`, queue tasks and missions
  * by `id`. `refreshedAt` and `sourceOfTruth` (its aggregate-cache age /

package/src/mesh-vocabulary.ts

@@ -76,11 +76,8 @@ export const isMeshTaskStatus = makeGuard(MESH_TASK_STATUSES)
 export const isMeshTerminalTaskStatus = makeGuard(MESH_TERMINAL_TASK_STATUSES)
 export const isMeshTaskMode = makeGuard(MESH_TASK_MODES)
 export const isMeshTaskPriority = makeGuard(MESH_TASK_PRIORITIES)
-export const isMeshThinkingLevel = makeGuard(MESH_THINKING_LEVELS)
 export const isMeshDeliveryMode = makeGuard(MESH_DELIVERY_MODES)
-export const isMeshSessionCleanupMode = makeGuard(MESH_SESSION_CLEANUP_MODES)
 export const isWorkerReportOutcome = makeGuard(WORKER_REPORT_OUTCOMES)
-export const isWorkerBranchState = makeGuard(WORKER_BRANCH_STATES)
 
 /**
  * JSON-schema fragment for a string enum, derived from the tuple. Use this in

package/src/protocol/daemon-server.ts

@@ -52,8 +52,6 @@ export const DAEMON_STATUS_EVENT_NAMES = [
     'agent:generating_completed',
     'agent:stopped',
     'monitor:no_progress',
-    /** Legacy alias for `monitor:no_progress`, still emitted by older daemons. */
-    'monitor:long_generating',
 ] as const
 export type DaemonStatusEventName = typeof DAEMON_STATUS_EVENT_NAMES[number]
 export const isDaemonStatusEventName = makeTypeGuard(DAEMON_STATUS_EVENT_NAMES)
@@ -130,8 +128,6 @@ export type SeqscribeStatusWireSummary = {
     transcriptDedupedBucket?: number
     transcriptOversizedBucket?: number
     transcriptDroppedBucket?: number
-    transcriptParityRan?: boolean
-    transcriptParityMismatchBucket?: number
 }
 
 export type CloudStatusReportWirePayload = {

package/src/protocol/dashboard-daemon-p2p.ts

@@ -9,8 +9,7 @@
  * (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.
+ * matched them by `id` as a fallthrough. They are now `response` frames.
  *
  * Chunking: any request frame may be split by the sender into
  * `<kind>_chunk` frames (`id`, `chunkId`, `index`, `total`, `data`) when it
@@ -98,8 +97,11 @@ export type P2PPtyInputMsg = { type: 'pty_input'; sessionId?: string; targetSess
 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 }
+/**
+ * Topic subscription. `params` is topic-specific (daemon-core `SubscribeRequestMap`); `object` keeps every topic's interface assignable.
+ * `wireVersion` is the dashboard wire version the page speaks (./dashboard-wire-version.ts).
+ */
+export type P2PSubscribeMsg = { type: 'subscribe'; topic: string; key: string; params: object; wireVersion?: number }
 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[] }
@@ -228,18 +230,9 @@ export type DaemonToDashboardP2PMsg =
 const _daemonToDashboardNamesCoverUnion: AssertSameMembers<typeof DAEMON_TO_DASHBOARD_P2P_TYPES, DaemonToDashboardP2PMsg['type']> = true
 void _daemonToDashboardNamesCoverUnion
 
-/**
- * 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.
- */
+/** Parse boundary for the dashboard (after chunk reassembly). */
 export function decodeDaemonToDashboardP2P(raw: unknown): DaemonToDashboardP2PMsg | null {
     if (!isRecord(raw)) return null
-    if (raw.type === undefined && isNonEmptyString(raw.id) && typeof raw.success === 'boolean') {
-        return { ...raw, type: 'response' } as P2PResponseMsg
-    }
     if (!isDaemonToDashboardP2PType(raw.type)) return null
     switch (raw.type) {
         case 'ping':