agent-tempo 1.0.1

package/dist/http/event-types.d.ts

@@ -0,0 +1,348 @@
+/**
+ * SSE event-source wire types — shared by the daemon (server, PR-1/PR-2) and
+ * the TempoClient subscribe wrapper (PR-3). The drift detector at
+ * `test/sse/wire-protocol.test.ts` (PR-2 deliverable) cross-checks
+ * `SSE_EVENT_KINDS` against the §6 table in `docs/SSE-PROTOCOL.md`.
+ *
+ * **Reference**: [`docs/SSE-PROTOCOL.md`](../../docs/SSE-PROTOCOL.md).
+ *
+ * **Stability**: every name and field shape here is part of the v1 wire
+ * contract. Renaming or removing requires a major version bump (path prefix
+ * `/v1/` → `/v2/`). Adding new event types or additive payload fields is
+ * non-breaking.
+ *
+ * **PR-1 scope**: the snapshot endpoints (`/v1/health`, `/v1/state/:ensemble`,
+ * `/v1/ensembles`, `/v1/hosts`) consume `HealthV1`, `EnsembleStateV1`, and
+ * `PlayerSummaryV1`. The SSE event union and `TempoClient.subscribe`
+ * interface are defined here for PR-2/PR-3 to import without duplication.
+ */
+import type { AttachmentPhase, EnsembleChatMessage, HostProfile, HostInfo, ScheduleEntry } from '../types';
+import type { EnsembleSummary } from '../client/interface';
+/** §4.1 — `/v1/health` — never authenticated. */
+export interface HealthV1 {
+    ok: true;
+    /** Temporal namespace the daemon is connected to. */
+    namespace: string;
+    /**
+     * Shared task queue the daemon's workers poll. Mirrors `config.taskQueue`
+     * (e.g. `agent-tempo` in production, `agent-tempo-dev` in dev mode).
+     * Surfaced for the dashboard's Settings → Connection panel so the displayed
+     * value reflects the live runtime instead of a hard-coded default. (#444)
+     */
+    taskQueue: string;
+    /** Daemon package version. */
+    version: string;
+    uptimeMs: number;
+    /** Count of distinct ensembles known to the daemon at request time. */
+    ensembleCount: number;
+    /**
+     * Open SSE connections (`/v1/events*`). Always `0` in PR-1 — the daemon
+     * has no streaming endpoints yet. PR-2 wires this to the live subscriber set.
+     */
+    subscriberCount: number;
+    /**
+     * #336 memory diagnostics — exposes `process.memoryUsage()` at request
+     * time so external monitors and `agent-tempo daemon stats` can spot
+     * leaks without attaching a debugger. Bytes; see Node docs for field
+     * semantics. Optional so legacy clients ignoring the field don't break.
+     */
+    memory?: MemoryUsageV1;
+}
+/** Snapshot of `process.memoryUsage()` at request time. All values in bytes. */
+export interface MemoryUsageV1 {
+    /** Resident Set Size — the total memory the OS has allocated for the process. */
+    rss: number;
+    /** V8 heap total. */
+    heapTotal: number;
+    /** V8 heap used. */
+    heapUsed: number;
+    /** Memory used by native C++ objects bound to JS (e.g. Temporal SDK). */
+    external: number;
+    /** Memory allocated for ArrayBuffers + SharedArrayBuffers. */
+    arrayBuffers: number;
+}
+/**
+ * §4.3 — `/v1/state/:ensemble` — single-ensemble snapshot.
+ *
+ * `lastEventId` is the snapshot/stream bridge token. PR-1 returns the
+ * sentinel `"0:0"`; PR-2 pairs this with the live aggregate so consumers
+ * passing it back as `Last-Event-ID` to `/v1/events/:ensemble` resume from
+ * the exact tick the snapshot reflects.
+ */
+export interface EnsembleStateV1 {
+    v: 1;
+    ensemble: string;
+    /** ISO timestamp recorded when the snapshot was assembled. */
+    capturedAt: string;
+    /**
+     * Opaque event-id token of the form `"<bootEpoch>:<seq>"` (see §5).
+     *
+     * **Atomicity contract**: the snapshot reflects state as of this id.
+     * Every event with a `(bootEpoch, seq)` lexicographically greater than
+     * `lastEventId` is NOT yet reflected in `players`, `chat`, `schedules`,
+     * `flags`, or `hostProfiles`.
+     *
+     * **PR-1 sentinel**: the snapshot endpoints ship before any event source
+     * exists, so PR-1 returns `"0:0"`. PR-2 subscribers passing this back
+     * see an `epoch-mismatch` `gap` event and re-fetch — correct behavior.
+     */
+    lastEventId: string;
+    state: 'online' | 'paused' | 'offline';
+    hasConductor: boolean;
+    flags: {
+        paused: boolean;
+        held: boolean;
+    };
+    players: PlayerSummaryV1[];
+    schedules: ScheduleEntry[];
+    /**
+     * Bounded slice of the maestro hub's chat ring (most-recent-first per
+     * the hub's `maestroEnsembleChat` query). Consumers paging older
+     * messages drop down to `recall` / `getEnsembleChat` direct.
+     */
+    chat: {
+        messages: EnsembleChatMessage[];
+        total: number;
+        hasMore: boolean;
+    };
+    /**
+     * Snapshot of the global hostname → `HostProfile` map. Embedded so a
+     * consumer rendering one ensemble doesn't need a parallel `/v1/hosts`
+     * call to label players by host capabilities. Same shape as the global
+     * map; daemons do not partition by ensemble.
+     */
+    hostProfiles: Record<string, HostProfile>;
+    /**
+     * Issue #399 W1 wire extensions — projected from the per-ensemble maestro
+     * hub's `getEnsembleDescriptionQuery` / `getEnsembleStartTimeQuery` /
+     * `getCurrentBpmQuery` / `getTempoSeriesQuery`. Consumers (Hosts/Workspace
+     * dashboard) render these without further round-trips.
+     */
+    /** Free-form description of what the ensemble is working on. `''` when the
+     * conductor hasn't set one. */
+    description: string;
+    /** ISO timestamp of when the maestro hub workflow first started. Used by
+     * the dashboard to compute uptime client-side. `''` when the hub isn't
+     * reachable. */
+    startedAt: string;
+    /** Current beats-per-minute (msgs/min activity rate). `0` baseline when
+     * activity hasn't accrued yet or the hub is unreachable. */
+    currentBpm: number;
+    /** 60-element ring of recent activity counts (one per minute, most recent
+     * last). Powers the `<TempoStrip>` sparkline. Empty array when the hub
+     * isn't reachable. */
+    tempoSeries: number[];
+}
+/**
+ * §4.3 — per-player projection used inside `EnsembleStateV1.players` and
+ * the `player.added` event payload (§6).
+ */
+export interface PlayerSummaryV1 {
+    playerId: string;
+    ensemble: string;
+    hostname: string;
+    isConductor: boolean;
+    /**
+     * Adapter family the player runs on. Mirrors {@link AgentType} from
+     * `src/types.ts` — every shipped adapter is exposed verbatim so dashboards
+     * can render the actual backend instead of coercing headless adapters into
+     * `'claude'`. `'mock'` is dev-mode-only (recruit gate rejects it in
+     * production); the headless adapters (`'claude-api'`, `'opencode'`,
+     * `'claude-code-headless'`) ship as additive `/v1/` extensions per the
+     * stability rule at §6 — adding new adapters in future versions remains
+     * non-breaking, removing one requires `/v2/`. See #535.
+     */
+    agentType: 'claude' | 'copilot' | 'mock' | 'claude-api' | 'opencode' | 'claude-code-headless';
+    playerType?: string;
+    /** Authoritative attachment phase (post-v0.26 — see WIRE-PROTOCOL.md). */
+    phase?: AttachmentPhase;
+    part: string;
+    workDir: string;
+    gitBranch?: string;
+    /** Absent on `detached` / `gone` phases. ISO timestamp. */
+    lastHeartbeatAt?: string;
+    /** Present only when `phase === 'processing'`. ISO timestamp. */
+    processingSince?: string;
+    /**
+     * Issue #399 W2 wire extensions — projected from per-session queries
+     * (`getRunIdQuery` / `getMessagingStateQuery` / `getLeaseStateQuery`)
+     * during snapshot fan-out. Optional everywhere — when the session
+     * workflow is unreachable or a query soft-fails the field is absent
+     * (or set to a sentinel for objects), and the dashboard renders `—`.
+     */
+    /** Q5.2 — current execution's runId. UUID; dashboard truncates client-side. */
+    runId?: string;
+    /** Q5.5 — messaging counters + outbox status string. */
+    messaging?: {
+        received: number;
+        sent: number;
+        /** `'empty'` / `'N pending'` / `'N pending (oldest 2m)'`. Server-rendered. */
+        outbox: string;
+    };
+    /** Q5.7 — current attachment lease window. `null` when no active lease
+     * (phase ∈ booting / detached / gone). */
+    lease?: {
+        /** Epoch ms when the lease expires, or `null` when no active lease. */
+        expiresAt: number | null;
+        /** Lease window length in ms, or `null` when no active lease. */
+        leaseMs: number | null;
+    };
+    /** Q5.6 — monotonic activity counter (cue + outbox push + report + recruit
+     * + restart + destroy + migrate). Already on `MaestroPlayerInfo`; passed
+     * through verbatim by `toPlayerSummaryV1`. */
+    activityCount?: number;
+    /** Q5.6 — ISO timestamp of the most recent activity. Already on
+     * `MaestroPlayerInfo`; passed through verbatim by `toPlayerSummaryV1`. */
+    lastActivityAt?: string;
+}
+/**
+ * The eventId token used in the `id:` line of the SSE frame and as the
+ * `Last-Event-ID` header round-trip. Format `"<bootEpoch>:<seq>"`:
+ *
+ * - `bootEpoch` — daemon process boot time as Unix epoch milliseconds,
+ *   frozen for the process lifetime. A daemon restart advances the epoch;
+ *   a worker restart (e.g. Temporal connection reset) does NOT.
+ * - `seq` — uint64 monotonic counter starting at 0, incrementing once per
+ *   event emitted to the bus.
+ *
+ * Comparison rule: server compares the client-supplied `Last-Event-ID` to
+ * the live `(bootEpoch, seq)` pair as a numeric tuple — `clientEpoch`
+ * first, then `clientSeq`. Mismatched epoch → `gap` event with reason
+ * `epoch-mismatch`. Matched epoch with `seq < ringStart` → `gap` with
+ * reason `overflow`.
+ */
+export type EventIdToken = string;
+/**
+ * The PR-1 sentinel `lastEventId` value — emitted on `/v1/state/:ensemble`
+ * before PR-2 lights up the aggregate poll loop. Subscribers passing this
+ * back as `Last-Event-ID` once PR-2 ships will see an `epoch-mismatch`
+ * gap event (because the live daemon's `bootEpoch` is non-zero) and
+ * re-fetch — correct behavior.
+ */
+export declare const PR1_SENTINEL_EVENT_ID: EventIdToken;
+/**
+ * Canonical list of every SSE event `type` the daemon emits. The drift
+ * detector (PR-2) reads this array and asserts every `## row` in
+ * `docs/SSE-PROTOCOL.md` §6 has a matching entry — and vice versa.
+ *
+ * **Append-only**. Do not remove. New event types ship as additive `/v1/`
+ * additions; removals require `/v2/`.
+ */
+export declare const SSE_EVENT_KINDS: readonly ["snapshot", "gap", "throttled", "heartbeat", "ensemble.created", "ensemble.destroyed", "player.added", "player.removed", "player.phase_changed", "chat.appended", "chat.compressed", "flags.changed", "schedules.changed", "host_profile.changed"];
+export type SseEventKind = (typeof SSE_EVENT_KINDS)[number];
+/** Common envelope for every event. */
+export interface SseEventBase {
+    v: 1;
+    /** §5 — `"<bootEpoch>:<seq>"`. */
+    eventId: EventIdToken;
+}
+/**
+ * Discriminated union of every event payload exposed by the daemon's
+ * `/v1/events*` endpoints. PR-3's `TempoClient.subscribe` returns
+ * `AsyncIterable<TempoEvent>`.
+ */
+export type TempoEvent = (SseEventBase & {
+    type: 'snapshot';
+    payload: EnsembleStateV1;
+}) | (SseEventBase & {
+    type: 'gap';
+    payload: {
+        from: string;
+        to: string;
+        reason: 'epoch-mismatch' | 'overflow';
+    };
+}) | (SseEventBase & {
+    type: 'throttled';
+    payload: {
+        droppedSince: string;
+        count: number;
+    };
+}) | (SseEventBase & {
+    type: 'heartbeat';
+    payload: {
+        at: string;
+    };
+}) | (SseEventBase & {
+    type: 'ensemble.created';
+    payload: {
+        ensemble: string;
+        createdAt: string;
+        hasConductor: boolean;
+    };
+}) | (SseEventBase & {
+    type: 'ensemble.destroyed';
+    payload: {
+        ensemble: string;
+        destroyedAt: string;
+    };
+}) | (SseEventBase & {
+    type: 'player.added';
+    payload: PlayerSummaryV1;
+}) | (SseEventBase & {
+    type: 'player.removed';
+    payload: {
+        playerId: string;
+        ensemble: string;
+        removedAt: string;
+        reason: 'destroyed' | 'gone';
+    };
+}) | (SseEventBase & {
+    type: 'player.phase_changed';
+    payload: {
+        playerId: string;
+        ensemble: string;
+        phase: AttachmentPhase;
+        lastHeartbeatAt?: string;
+        processingSince?: string;
+        at: string;
+    };
+}) | (SseEventBase & {
+    type: 'chat.appended';
+    payload: EnsembleChatMessage;
+}) | (SseEventBase & {
+    type: 'chat.compressed';
+    payload: {
+        dropped: number;
+        since: string;
+    };
+}) | (SseEventBase & {
+    type: 'flags.changed';
+    payload: {
+        ensemble: string;
+        paused: boolean;
+        held: boolean;
+        at: string;
+    };
+}) | (SseEventBase & {
+    type: 'schedules.changed';
+    payload: {
+        ensemble: string;
+        schedules: ScheduleEntry[];
+        at: string;
+    };
+}) | (SseEventBase & {
+    type: 'host_profile.changed';
+    payload: HostProfile;
+});
+/**
+ * Subset of event categories the server can pre-filter on `?topics=...`.
+ * Maps roughly to `phase → player.phase_changed`, `chat → chat.*`,
+ * `flags → flags.changed`, `schedules → schedules.changed`,
+ * `heartbeat → heartbeat`. Setup events (`snapshot`, `gap`, `throttled`,
+ * `player.added`, `player.removed`, ensemble lifecycle, `host_profile.*`)
+ * are always included — they're the bare minimum for correctness.
+ */
+export type SubscribeTopic = 'phase' | 'chat' | 'flags' | 'schedules' | 'heartbeat';
+export interface SubscribeOptions {
+    /**
+     * Aborts the iterator and tears down the underlying transport. See
+     * SSE-PROTOCOL.md §7.4.
+     */
+    signal?: AbortSignal;
+    /**
+     * Server-side topic filter. Server drops other event kinds before they
+     * hit the wire. Setup/correctness events are always emitted regardless.
+     */
+    topics?: SubscribeTopic[];
+}
+export type { EnsembleSummary, HostInfo, AttachmentPhase, HostProfile, EnsembleChatMessage, ScheduleEntry };

package/dist/http/event-types.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SSE_EVENT_KINDS = exports.PR1_SENTINEL_EVENT_ID = void 0;
+/**
+ * The PR-1 sentinel `lastEventId` value — emitted on `/v1/state/:ensemble`
+ * before PR-2 lights up the aggregate poll loop. Subscribers passing this
+ * back as `Last-Event-ID` once PR-2 ships will see an `epoch-mismatch`
+ * gap event (because the live daemon's `bootEpoch` is non-zero) and
+ * re-fetch — correct behavior.
+ */
+exports.PR1_SENTINEL_EVENT_ID = '0:0';
+// ── §6. Event types — drift-detector contract ────────────────────────────
+/**
+ * Canonical list of every SSE event `type` the daemon emits. The drift
+ * detector (PR-2) reads this array and asserts every `## row` in
+ * `docs/SSE-PROTOCOL.md` §6 has a matching entry — and vice versa.
+ *
+ * **Append-only**. Do not remove. New event types ship as additive `/v1/`
+ * additions; removals require `/v2/`.
+ */
+exports.SSE_EVENT_KINDS = [
+    'snapshot',
+    'gap',
+    'throttled',
+    'heartbeat',
+    'ensemble.created',
+    'ensemble.destroyed',
+    'player.added',
+    'player.removed',
+    'player.phase_changed',
+    'chat.appended',
+    'chat.compressed',
+    'flags.changed',
+    'schedules.changed',
+    'host_profile.changed',
+];

package/dist/http/fixtures/chat-stress.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Fixture: 100 `chat.appended` events in rapid succession followed by
+ * a `chat.compressed` event. Exercises the dashboard's chat-window
+ * virtualisation / scroll behaviour and the "older messages dropped"
+ * banner the maestro hub emits when its in-memory ring overflows.
+ */
+import type { FixtureScenario } from './index';
+export declare const chatStress: FixtureScenario;

package/dist/http/fixtures/chat-stress.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chatStress = void 0;
+const constants_1 = require("./constants");
+const ENSEMBLE = 'demo-chat-stress';
+const STRESS_COUNT = 100;
+const COMPRESS_DROP = 50;
+const BASE_MS = Number(constants_1.FIXTURE_BOOT_EPOCH);
+const stressEvents = Array.from({ length: STRESS_COUNT }, (_, i) => ({
+    v: 1,
+    type: 'chat.appended',
+    eventId: `${constants_1.FIXTURE_BOOT_EPOCH}:${i + 1}`,
+    payload: {
+        id: `msg-stress-${i + 1}`,
+        from: i % 2 === 0 ? 'maestro' : 'conductor',
+        to: i % 2 === 0 ? 'conductor' : 'maestro',
+        text: `Stress message ${i + 1}/${STRESS_COUNT}`,
+        timestamp: new Date(BASE_MS + i * 10).toISOString(),
+        role: i % 2 === 0 ? 'maestro-out' : 'conductor-in',
+    },
+}));
+const compressedEvent = {
+    v: 1,
+    type: 'chat.compressed',
+    eventId: `${constants_1.FIXTURE_BOOT_EPOCH}:${STRESS_COUNT + 1}`,
+    payload: {
+        dropped: COMPRESS_DROP,
+        since: new Date(BASE_MS).toISOString(),
+    },
+};
+exports.chatStress = {
+    name: 'chat-stress',
+    description: `${STRESS_COUNT} chat.appended in rapid succession, then chat.compressed (${COMPRESS_DROP} dropped). Tests dashboard chat virtualisation + ring-overflow banner.`,
+    snapshot: {
+        v: 1,
+        ensemble: ENSEMBLE,
+        capturedAt: '2026-04-27T00:00:00.000Z',
+        lastEventId: `${constants_1.FIXTURE_BOOT_EPOCH}:0`,
+        state: 'online',
+        hasConductor: true,
+        flags: { paused: false, held: false },
+        players: [{
+                playerId: 'conductor',
+                ensemble: ENSEMBLE,
+                hostname: 'demo-host',
+                isConductor: true,
+                agentType: 'claude',
+                phase: 'attached',
+                part: 'Chat stress demo',
+                workDir: '/repo/demo',
+            }],
+        schedules: [],
+        chat: { messages: [], total: 0, hasMore: false },
+        hostProfiles: {},
+        description: '',
+        startedAt: '',
+        currentBpm: 0,
+        tempoSeries: [],
+    },
+    events: [...stressEvents, compressedEvent],
+    // Tight cadence to actually stress the consumer; not zero so timing is observable.
+    eventCadenceMs: 5,
+};

package/dist/http/fixtures/conductor-leaving.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Fixture: an ensemble with a conductor + one soloist; the conductor
+ * detaches mid-stream. Exercises the dashboard's "conductor left" UI
+ * (#358 analog) — the ensemble continues to exist, but `hasConductor`
+ * flips to false after the `player.removed` event lands.
+ */
+import type { FixtureScenario } from './index';
+export declare const conductorLeaving: FixtureScenario;

package/dist/http/fixtures/conductor-leaving.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.conductorLeaving = void 0;
+const constants_1 = require("./constants");
+const ENSEMBLE = 'demo-conductor-leaving';
+exports.conductorLeaving = {
+    name: 'conductor-leaving',
+    description: 'Conductor + 1 soloist; conductor leaves mid-stream (player.phase_changed → player.removed).',
+    snapshot: {
+        v: 1,
+        ensemble: ENSEMBLE,
+        capturedAt: '2026-04-27T00:00:00.000Z',
+        lastEventId: `${constants_1.FIXTURE_BOOT_EPOCH}:0`,
+        state: 'online',
+        hasConductor: true,
+        flags: { paused: false, held: false },
+        players: [
+            {
+                playerId: 'conductor',
+                ensemble: ENSEMBLE,
+                hostname: 'demo-host',
+                isConductor: true,
+                agentType: 'claude',
+                playerType: 'tempo-conductor',
+                phase: 'attached',
+                part: 'About to leave',
+                workDir: '/repo/demo',
+            },
+            {
+                playerId: 'tempo-eng',
+                ensemble: ENSEMBLE,
+                hostname: 'demo-host',
+                isConductor: false,
+                agentType: 'claude',
+                playerType: 'tempo-engineer',
+                phase: 'processing',
+                part: 'Implementing PR-3',
+                workDir: '/repo/demo',
+                processingSince: '2026-04-26T23:55:00.000Z',
+            },
+        ],
+        schedules: [],
+        chat: { messages: [], total: 0, hasMore: false },
+        hostProfiles: {
+            'demo-host': {
+                hostname: 'demo-host', version: '0.28.0',
+                defaultAgent: 'claude', platform: 'linux', capabilities: [],
+            },
+        },
+        description: '',
+        startedAt: '',
+        currentBpm: 0,
+        tempoSeries: [],
+    },
+    events: [
+        {
+            v: 1,
+            type: 'player.phase_changed',
+            eventId: `${constants_1.FIXTURE_BOOT_EPOCH}:1`,
+            payload: {
+                playerId: 'conductor',
+                ensemble: ENSEMBLE,
+                phase: 'detached',
+                at: '2026-04-27T00:00:01.000Z',
+            },
+        },
+        {
+            v: 1,
+            type: 'player.removed',
+            eventId: `${constants_1.FIXTURE_BOOT_EPOCH}:2`,
+            payload: {
+                playerId: 'conductor',
+                ensemble: ENSEMBLE,
+                removedAt: '2026-04-27T00:00:02.000Z',
+                reason: 'gone',
+            },
+        },
+    ],
+    eventCadenceMs: 500,
+};

package/dist/http/fixtures/constants.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Shared constants used by every fixture file. Kept separate so a single
+ * boot-epoch change updates the whole registry atomically.
+ */
+/**
+ * Synthetic boot epoch — the `<bootEpoch>` half of every fixture's
+ * `<bootEpoch>:<seq>` event-id token. Picked once and frozen so every
+ * fixture's events sort consistently.
+ */
+export declare const FIXTURE_BOOT_EPOCH = "1735000000000";

package/dist/http/fixtures/constants.js

@@ -0,0 +1,13 @@
+"use strict";
+/**
+ * Shared constants used by every fixture file. Kept separate so a single
+ * boot-epoch change updates the whole registry atomically.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FIXTURE_BOOT_EPOCH = void 0;
+/**
+ * Synthetic boot epoch — the `<bootEpoch>` half of every fixture's
+ * `<bootEpoch>:<seq>` event-id token. Picked once and frozen so every
+ * fixture's events sort consistently.
+ */
+exports.FIXTURE_BOOT_EPOCH = '1735000000000';

package/dist/http/fixtures/eight-player-broadcast.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Fixture: a conductor plus 8 receivers, simulating a single
+ * `broadcast` invocation that fans out to all players. All eight
+ * `chat.appended` events share the same `broadcastId` so dashboard UI
+ * can verify the #357 collapse — the TUI's `ConversationStream` (and
+ * the dashboard's analogue) renders consecutive chat entries with the
+ * same non-null `broadcastId` as a single row.
+ */
+import type { FixtureScenario } from './index';
+export declare const eightPlayerBroadcast: FixtureScenario;

package/dist/http/fixtures/eight-player-broadcast.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eightPlayerBroadcast = void 0;
+const constants_1 = require("./constants");
+const ENSEMBLE = 'demo-broadcast';
+const BROADCAST_ID = 'bcast-87654321';
+const AT = '2026-04-27T00:00:01.000Z';
+const RECEIVERS = [
+    'soloist-1', 'soloist-2', 'soloist-3', 'soloist-4',
+    'soloist-5', 'soloist-6', 'soloist-7', 'soloist-8',
+];
+const players = [
+    {
+        playerId: 'conductor',
+        ensemble: ENSEMBLE,
+        hostname: 'demo-host',
+        isConductor: true,
+        agentType: 'claude',
+        playerType: 'tempo-conductor',
+        phase: 'attached',
+        part: 'Orchestrating the broadcast',
+        workDir: '/repo/demo',
+    },
+    ...RECEIVERS.map((id) => ({
+        playerId: id,
+        ensemble: ENSEMBLE,
+        hostname: 'demo-host',
+        isConductor: false,
+        agentType: 'claude',
+        playerType: 'tempo-soloist',
+        phase: 'attached',
+        part: 'Soloing',
+        workDir: '/repo/demo',
+    })),
+];
+const broadcastChatEvents = RECEIVERS.map((id, i) => ({
+    id: `msg-bcast-${i + 1}`,
+    from: 'conductor',
+    to: id,
+    text: 'Beta-3 release rehearsal: please run /smoke and report blockers.',
+    timestamp: AT,
+    role: 'conductor-out',
+    broadcastId: BROADCAST_ID,
+}));
+exports.eightPlayerBroadcast = {
+    name: 'eight-player-broadcast',
+    description: 'Conductor + 8 receivers; one broadcast fan-out (8 chat.appended share broadcastId). Verifies #357 collapse.',
+    snapshot: {
+        v: 1,
+        ensemble: ENSEMBLE,
+        capturedAt: '2026-04-27T00:00:00.000Z',
+        lastEventId: `${constants_1.FIXTURE_BOOT_EPOCH}:0`,
+        state: 'online',
+        hasConductor: true,
+        flags: { paused: false, held: false },
+        players,
+        schedules: [],
+        chat: { messages: [], total: 0, hasMore: false },
+        hostProfiles: {
+            'demo-host': {
+                hostname: 'demo-host',
+                version: '0.28.0',
+                defaultAgent: 'claude',
+                platform: 'linux',
+                capabilities: [],
+            },
+        },
+        description: '',
+        startedAt: '',
+        currentBpm: 0,
+        tempoSeries: [],
+    },
+    events: broadcastChatEvents.map((msg, i) => ({
+        v: 1,
+        type: 'chat.appended',
+        eventId: `${constants_1.FIXTURE_BOOT_EPOCH}:${i + 1}`,
+        payload: msg,
+    })),
+    // Mild cadence so the dashboard can render the collapse animation if any.
+    eventCadenceMs: 25,
+};

package/dist/http/fixtures/empty-ensemble.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Fixture: an ensemble with no players, no chat, no schedules. Useful
+ * for verifying empty-state UI rendering.
+ */
+import type { FixtureScenario } from './index';
+export declare const emptyEnsemble: FixtureScenario;