agent-tempo 1.3.1 → 1.4.1

package/dist/pi/mission-control/board.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Mission-control board model + reducers (3f) — PURE, no Pi/daemon/IO.
+ *
+ * Builds an in-memory view of the ensemble from the daemon's coarse SSE stream
+ * (`TempoEvent` over `/v1/events/:ensemble`) and a fine inner-loop tail
+ * (`InnerFrame` over `/v1/players/:e/:p/inner`) for the SELECTED player. The
+ * extension applies events here, then renders the model on a throttled tick —
+ * decoupling event-rate from render-rate (decision 3). Pure so it unit-tests
+ * without Pi or the daemon.
+ */
+import type { TempoEvent, AttachmentPhase } from '../../http/event-types';
+import type { InnerFrame } from '../inner-loop-publisher';
+/** One row on the board — the coarse, always-on view of a player. */
+export interface PlayerRow {
+    playerId: string;
+    isConductor: boolean;
+    /**
+     * Daemon host the player runs on (carried from `PlayerSummaryV1.hostname`,
+     * 3f/H3a). Undefined on older pre-hostname snapshots → treated as tailable
+     * (never block on absent data). Drives {@link tailability}.
+     */
+    hostname?: string;
+    phase?: AttachmentPhase;
+    part: string;
+    /** Tool currently executing (3c coarse), `null`/undefined = idle. */
+    currentTool?: string | null;
+    /** Context-window usage fraction/percent (3c coarse). */
+    contextPercent?: number;
+    /** ISO timestamp of the last coarse activity. */
+    lastActivityAt?: string;
+}
+/** Default cap on the retained fine-tail frames for the selected player. */
+export declare const DEFAULT_TAIL_LIMIT = 200;
+export interface BoardModel {
+    ensemble: string;
+    /** playerId → row, insertion-ordered by the Map. */
+    players: Map<string, PlayerRow>;
+    /** The player whose fine inner-loop tail is shown, or null. */
+    selected: string | null;
+    /** Bounded ring of the selected player's recent inner frames (oldest→newest). */
+    innerTail: InnerFrame[];
+    /** Max retained tail frames. */
+    tailLimit: number;
+    /** Monotonic counter — bumped on every mutation so the render tick can skip no-op ticks. */
+    revision: number;
+}
+export declare function initBoard(ensemble: string, tailLimit?: number): BoardModel;
+/**
+ * Fold one coarse `TempoEvent` into the board (mutates + bumps revision). Unknown
+ * event kinds are ignored — the board only tracks the player set + phase + the
+ * 3c coarse activity fields.
+ */
+export declare function applyTempoEvent(model: BoardModel, ev: TempoEvent): void;
+/** Append a fine inner-loop frame for the selected player (bounded ring). */
+export declare function applyInnerFrame(model: BoardModel, frame: InnerFrame): void;
+/** Select a player for the fine tail (clears the prior tail). No-op if absent. */
+export declare function selectPlayer(model: BoardModel, playerId: string | null): boolean;
+/** Result of a {@link tailability} check — whether the operator can open a fine /inner tail. */
+export type Tailability = {
+    ok: true;
+} | {
+    ok: false;
+    reason: 'no-such-player';
+} | {
+    ok: false;
+    reason: 'ui-player';
+} | {
+    ok: false;
+    reason: 'cross-host';
+    playerHost: string;
+};
+/**
+ * Pure: can the local operator open `playerId`'s fine inner-loop tail? The 3f
+ * inner-loop tail is DAEMON-LOCAL — only players on this daemon's host are
+ * tailable.
+ *
+ * - missing player → `no-such-player`
+ * - the maestro/dashboard UI player (no /inner stream) → `ui-player` (H5; checked
+ *   BEFORE the host comparison so its `dashboard` sentinel isn't mis-framed as
+ *   cross-host)
+ * - a real player on another host → `cross-host` (carrying `playerHost`); actual
+ *   cross-host routing is the deferred H3(b) (#645)
+ * - a missing/older-snapshot `hostname` (undefined) → tailable; never block on
+ *   absent data
+ */
+export declare function tailability(model: BoardModel, playerId: string, localHost: string): Tailability;
+/** Sorted player ids — conductor first, then alphabetical (stable board ordering). */
+export declare function sortedPlayerIds(model: BoardModel): string[];

package/dist/pi/mission-control/board.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_TAIL_LIMIT = void 0;
+exports.initBoard = initBoard;
+exports.applyTempoEvent = applyTempoEvent;
+exports.applyInnerFrame = applyInnerFrame;
+exports.selectPlayer = selectPlayer;
+exports.tailability = tailability;
+exports.sortedPlayerIds = sortedPlayerIds;
+/** Default cap on the retained fine-tail frames for the selected player. */
+exports.DEFAULT_TAIL_LIMIT = 200;
+function initBoard(ensemble, tailLimit = exports.DEFAULT_TAIL_LIMIT) {
+    return { ensemble, players: new Map(), selected: null, innerTail: [], tailLimit, revision: 0 };
+}
+/** Project a PlayerSummaryV1 (snapshot / player.added) into a row. */
+function rowFromSummary(p) {
+    return {
+        playerId: p.playerId,
+        isConductor: p.isConductor,
+        // H3a: carry the host through — the board previously DROPPED it. Drives
+        // cross-host tail refusal in `tailability`.
+        ...(p.hostname !== undefined ? { hostname: p.hostname } : {}),
+        ...(p.phase !== undefined ? { phase: p.phase } : {}),
+        part: p.part ?? '',
+        ...(p.currentTool !== undefined ? { currentTool: p.currentTool } : {}),
+        ...(p.contextPercent !== undefined ? { contextPercent: p.contextPercent } : {}),
+        ...(p.lastActivityAt !== undefined ? { lastActivityAt: p.lastActivityAt } : {}),
+    };
+}
+/**
+ * Fold one coarse `TempoEvent` into the board (mutates + bumps revision). Unknown
+ * event kinds are ignored — the board only tracks the player set + phase + the
+ * 3c coarse activity fields.
+ */
+function applyTempoEvent(model, ev) {
+    switch (ev.type) {
+        case 'snapshot': {
+            // Authoritative rebuild from the snapshot's player list.
+            model.players = new Map(ev.payload.players.map((p) => [p.playerId, rowFromSummary(p)]));
+            // Drop a selection that no longer exists.
+            if (model.selected && !model.players.has(model.selected)) {
+                model.selected = null;
+                model.innerTail = [];
+            }
+            break;
+        }
+        case 'player.added': {
+            model.players.set(ev.payload.playerId, rowFromSummary(ev.payload));
+            break;
+        }
+        case 'player.removed': {
+            model.players.delete(ev.payload.playerId);
+            if (model.selected === ev.payload.playerId) {
+                model.selected = null;
+                model.innerTail = [];
+            }
+            break;
+        }
+        case 'player.phase_changed': {
+            const row = model.players.get(ev.payload.playerId);
+            if (row) {
+                row.phase = ev.payload.phase;
+                row.lastActivityAt = ev.payload.at;
+            }
+            break;
+        }
+        case 'player.activity': {
+            const row = model.players.get(ev.payload.playerId);
+            if (row) {
+                row.currentTool = ev.payload.currentTool;
+                if (ev.payload.contextPercent !== undefined)
+                    row.contextPercent = ev.payload.contextPercent;
+                row.lastActivityAt = ev.payload.at;
+            }
+            break;
+        }
+        default:
+            return; // not board-relevant — no revision bump
+    }
+    model.revision++;
+}
+/** Append a fine inner-loop frame for the selected player (bounded ring). */
+function applyInnerFrame(model, frame) {
+    model.innerTail.push(frame);
+    if (model.innerTail.length > model.tailLimit) {
+        model.innerTail.splice(0, model.innerTail.length - model.tailLimit);
+    }
+    model.revision++;
+}
+/** Select a player for the fine tail (clears the prior tail). No-op if absent. */
+function selectPlayer(model, playerId) {
+    if (playerId !== null && !model.players.has(playerId))
+        return false;
+    model.selected = playerId;
+    model.innerTail = [];
+    model.revision++;
+    return true;
+}
+/**
+ * Sentinel hostname the TUI's own maestro/dashboard session stamps on its
+ * metadata (see `ensureMaestroSession` in `client/core.ts`). It's a UI player
+ * with NO /inner stream — non-tailable, but NOT a cross-host case (the sentinel
+ * is not a real daemon host). Mirrored locally to avoid a client→mission-control
+ * import; the maestro-tail test trips if it ever drifts. (H5)
+ */
+const UI_PLAYER_HOSTNAME = 'dashboard';
+/**
+ * Pure: can the local operator open `playerId`'s fine inner-loop tail? The 3f
+ * inner-loop tail is DAEMON-LOCAL — only players on this daemon's host are
+ * tailable.
+ *
+ * - missing player → `no-such-player`
+ * - the maestro/dashboard UI player (no /inner stream) → `ui-player` (H5; checked
+ *   BEFORE the host comparison so its `dashboard` sentinel isn't mis-framed as
+ *   cross-host)
+ * - a real player on another host → `cross-host` (carrying `playerHost`); actual
+ *   cross-host routing is the deferred H3(b) (#645)
+ * - a missing/older-snapshot `hostname` (undefined) → tailable; never block on
+ *   absent data
+ */
+function tailability(model, playerId, localHost) {
+    const row = model.players.get(playerId);
+    if (!row)
+        return { ok: false, reason: 'no-such-player' };
+    if (row.hostname === UI_PLAYER_HOSTNAME)
+        return { ok: false, reason: 'ui-player' };
+    if (row.hostname && row.hostname !== localHost) {
+        return { ok: false, reason: 'cross-host', playerHost: row.hostname };
+    }
+    return { ok: true };
+}
+/** Sorted player ids — conductor first, then alphabetical (stable board ordering). */
+function sortedPlayerIds(model) {
+    return [...model.players.values()]
+        .sort((a, b) => {
+        if (a.isConductor !== b.isConductor)
+            return a.isConductor ? -1 : 1;
+        return a.playerId.localeCompare(b.playerId);
+    })
+        .map((r) => r.playerId);
+}

package/dist/pi/mission-control/extension.d.ts

@@ -0,0 +1,51 @@
+import { type BoardModel } from './board';
+import { MissionControlActions } from './actions';
+import type { McExtensionAPI, McExtensionContext } from './pi-ui';
+/** Injectable seams (production defaults; tests override). */
+export interface MissionControlDeps {
+    ensemble?: string;
+    adminToken?: string;
+    baseUrl?: string;
+    renderThrottleMs?: number;
+    /** Local daemon host for tailability (test override; defaults to `os.hostname()`). */
+    localHost?: string;
+}
+/**
+ * The operator-command + board controller. Holds the model + the action client;
+ * command methods are independently unit-testable with a fake actions + ctx.
+ * The lifecycle (SSE/render/teardown) lives in {@link createMissionControlExtension}.
+ */
+export declare class Controller {
+    readonly model: BoardModel;
+    readonly actions: MissionControlActions;
+    /**
+     * This daemon's host (`os.hostname()`). The fine /inner tail is daemon-local,
+     * so only same-host players are tailable — see {@link tailability}.
+     */
+    readonly localHost: string;
+    /** Set by the extension so /tail can (re)open the fine SSE; null in unit tests. */
+    onTailRequest: ((playerId: string | null) => void) | null;
+    constructor(ensemble: string, actions: MissionControlActions, localHost?: string);
+    private notify;
+    private report;
+    /** First whitespace-delimited token + the remainder. */
+    private static splitFirst;
+    cmdPlayers(ctx: McExtensionContext): Promise<void>;
+    cmdTail(args: string, ctx: McExtensionContext): Promise<void>;
+    cmdCue(args: string, ctx: McExtensionContext): Promise<void>;
+    cmdPause(_args: string, ctx: McExtensionContext): Promise<void>;
+    cmdPlay(args: string, ctx: McExtensionContext): Promise<void>;
+    cmdRestart(args: string, ctx: McExtensionContext): Promise<void>;
+    cmdDestroy(args: string, ctx: McExtensionContext): Promise<void>;
+    cmdReset(args: string, ctx: McExtensionContext): Promise<void>;
+    cmdArm(args: string, ctx: McExtensionContext): Promise<void>;
+    cmdGate(args: string, ctx: McExtensionContext): Promise<void>;
+}
+/**
+ * Build the mission-control extension (default-export shape). The operator's Pi
+ * loads it in OBSERVER mode. `deps` overrides config/token/baseUrl for tests.
+ */
+export declare function createMissionControlExtension(deps?: MissionControlDeps): (pi: McExtensionAPI) => void;
+/** Default export — the loadable Pi extension. */
+declare const missionControlExtension: (pi: McExtensionAPI) => void;
+export default missionControlExtension;

package/dist/pi/mission-control/extension.js

@@ -0,0 +1,330 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Controller = void 0;
+exports.createMissionControlExtension = createMissionControlExtension;
+/**
+ * Mission-control Pi extension (3f) — turns ONE interactive Pi TUI into an
+ * ensemble mission-control board + operator controller.
+ *
+ * Three ruled decisions:
+ *   1. DRIVE = HTTP — controls POST to the daemon write/gate surface ({@link MissionControlActions}).
+ *   2. OBSERVER-ONLY — this extension NEVER claimAttachment / registers as a player.
+ *   3. RENDER THROTTLE ~200ms — events fold into the in-memory {@link BoardModel};
+ *      a tick re-renders only when the model changed (revision bump), so the
+ *      /inner tail can't thrash the TUI.
+ *
+ * Lifecycle: `session_start` opens the coarse SSE (`/v1/events/:ensemble` via the
+ * Node `subscribe` path), starts the render tick, and registers operator
+ * commands; `session_shutdown` tears all of it down + clears the widget.
+ */
+const os = __importStar(require("os"));
+const config_1 = require("../../config");
+const port_file_1 = require("../../http/port-file");
+const subscribe_1 = require("../../client/subscribe");
+const board_1 = require("./board");
+const render_1 = require("./render");
+const actions_1 = require("./actions");
+const inner_tail_1 = require("./inner-tail");
+const WIDGET_KEY = 'mission-control';
+const DEFAULT_RENDER_THROTTLE_MS = 200;
+const DEFAULT_PORT = 8473;
+/**
+ * The operator-command + board controller. Holds the model + the action client;
+ * command methods are independently unit-testable with a fake actions + ctx.
+ * The lifecycle (SSE/render/teardown) lives in {@link createMissionControlExtension}.
+ */
+class Controller {
+    model;
+    actions;
+    /**
+     * This daemon's host (`os.hostname()`). The fine /inner tail is daemon-local,
+     * so only same-host players are tailable — see {@link tailability}.
+     */
+    localHost;
+    /** Set by the extension so /tail can (re)open the fine SSE; null in unit tests. */
+    onTailRequest = null;
+    constructor(ensemble, actions, localHost = os.hostname()) {
+        this.model = (0, board_1.initBoard)(ensemble);
+        this.actions = actions;
+        this.localHost = localHost;
+    }
+    notify(ctx, msg) {
+        if (ctx.hasUI)
+            ctx.ui.notify(msg);
+    }
+    report(ctx, label, r) {
+        this.notify(ctx, r.ok ? `${label} ✓` : `${label} failed: ${r.error}`);
+    }
+    /** First whitespace-delimited token + the remainder. */
+    static splitFirst(args) {
+        const t = args.trim();
+        const i = t.indexOf(' ');
+        return i < 0 ? [t, ''] : [t.slice(0, i), t.slice(i + 1).trim()];
+    }
+    async cmdPlayers(ctx) {
+        const ids = (0, board_1.sortedPlayerIds)(this.model);
+        this.notify(ctx, ids.length ? `Players (${ids.length}): ${ids.join(', ')}` : 'No players in the ensemble.');
+    }
+    async cmdTail(args, ctx) {
+        const target = args.trim();
+        if (!target || target === 'off') {
+            (0, board_1.selectPlayer)(this.model, null);
+            this.onTailRequest?.(null);
+            this.notify(ctx, 'Inner-loop tail off.');
+            return;
+        }
+        // H3a: the /inner tail is daemon-local — refuse a cross-host tail with an
+        // actionable message rather than silently selecting a player that would only
+        // ever show "(no inner-loop activity yet)". Decided BEFORE select/open so a
+        // cross-host player is never selected and no tail SSE is opened.
+        const t = (0, board_1.tailability)(this.model, target, this.localHost);
+        if (!t.ok) {
+            let msg;
+            if (t.reason === 'cross-host') {
+                msg = `Inner tail unavailable: ${target} runs on host ${t.playerHost}, not this daemon's host (${this.localHost}). Cross-host tail is a tracked follow-up (#645 / H3b).`;
+            }
+            else if (t.reason === 'ui-player') {
+                msg = `${target} is a UI player — nothing to tail.`;
+            }
+            else {
+                msg = `No such player: ${target}`;
+            }
+            this.notify(ctx, msg);
+            return;
+        }
+        (0, board_1.selectPlayer)(this.model, target);
+        this.onTailRequest?.(target);
+        this.notify(ctx, `Tailing ${target}.`);
+    }
+    async cmdCue(args, ctx) {
+        const [to, message] = Controller.splitFirst(args);
+        if (!to || !message) {
+            this.notify(ctx, 'Usage: /cue <player> <message>');
+            return;
+        }
+        this.report(ctx, `cue → ${to}`, await this.actions.cue(to, message));
+    }
+    async cmdPause(_args, ctx) {
+        this.report(ctx, 'pause', await this.actions.pause());
+    }
+    async cmdPlay(args, ctx) {
+        const release = args.trim() === 'release';
+        this.report(ctx, 'play', await this.actions.play(release));
+    }
+    async cmdRestart(args, ctx) {
+        const [p, reason] = Controller.splitFirst(args);
+        if (!p) {
+            this.notify(ctx, 'Usage: /restart <player> [reason]');
+            return;
+        }
+        this.report(ctx, `restart ${p}`, await this.actions.restart(p, reason || undefined));
+    }
+    async cmdDestroy(args, ctx) {
+        const [p, reason] = Controller.splitFirst(args);
+        if (!p) {
+            this.notify(ctx, 'Usage: /destroy <player> [reason]');
+            return;
+        }
+        this.report(ctx, `destroy ${p}`, await this.actions.destroy(p, reason || undefined));
+    }
+    async cmdReset(args, ctx) {
+        const p = args.trim();
+        if (!p) {
+            this.notify(ctx, 'Usage: /reset <player>');
+            return;
+        }
+        // D14 reset has NO daemon HTTP route yet (MCP/outbox only). Surface clearly
+        // rather than silently fail. Wiring a POST /v1/ensembles/:e/reset is a daemon
+        // follow-up (flagged to the conductor).
+        this.notify(ctx, `reset ${p}: not available over the daemon HTTP surface yet (MCP/outbox only). Flagged for a daemon route.`);
+    }
+    async cmdArm(args, ctx) {
+        const [p, mode] = Controller.splitFirst(args);
+        if (!p) {
+            this.notify(ctx, 'Usage: /arm <player> [off]');
+            return;
+        }
+        const off = mode.trim() === 'off';
+        this.report(ctx, `${off ? 'disarm' : 'arm'} ${p}`, off ? await this.actions.gateDisarm(p) : await this.actions.gateArm(p));
+    }
+    async cmdGate(args, ctx) {
+        const [reqId, decisionRaw] = Controller.splitFirst(args);
+        const decision = decisionRaw.trim();
+        if (!reqId || (decision !== 'allow' && decision !== 'deny')) {
+            this.notify(ctx, 'Usage: /gate <requestId> allow|deny  (decides for the tailed player)');
+            return;
+        }
+        if (!this.model.selected) {
+            this.notify(ctx, 'Select a player first with /tail <player> — gate decisions are per-player.');
+            return;
+        }
+        this.report(ctx, `gate ${reqId} ${decision}`, await this.actions.gateDecide(this.model.selected, reqId, decision));
+    }
+}
+exports.Controller = Controller;
+function resolveBaseUrl(override) {
+    if (override)
+        return override.replace(/\/$/, '');
+    return `http://127.0.0.1:${(0, port_file_1.readPortFile)() ?? DEFAULT_PORT}`;
+}
+const log = (...args) => {
+    // eslint-disable-next-line no-console
+    console.error('[agent-tempo:pi:mission-control]', ...args);
+};
+/**
+ * Build the mission-control extension (default-export shape). The operator's Pi
+ * loads it in OBSERVER mode. `deps` overrides config/token/baseUrl for tests.
+ */
+function createMissionControlExtension(deps = {}) {
+    return (pi) => {
+        const ensemble = deps.ensemble ?? (0, config_1.getConfig)().ensemble;
+        const adminToken = deps.adminToken ?? process.env[actions_1.ADMIN_TOKEN_ENV];
+        const throttleMs = deps.renderThrottleMs ?? DEFAULT_RENDER_THROTTLE_MS;
+        // H3a: mission-control is co-located with its 127.0.0.1 daemon, so this
+        // process's hostname IS the daemon's host. (HealthV1.hostname is the noted
+        // future upgrade for a baseUrl pointing at a remote daemon — not built here.)
+        const localHost = deps.localHost ?? os.hostname();
+        // H5: do NOT pre-resolve baseUrl. createSubscribe + MissionControlActions both
+        // re-read ~/.agent-tempo/daemon.port per-call when baseUrl is undefined, so a
+        // daemon restart on a new port self-heals (a once-resolved URL wedges the
+        // board). A `deps.baseUrl` override (tests / future remote daemon) still wins.
+        const actions = new actions_1.MissionControlActions({
+            ensemble,
+            ...(adminToken ? { adminToken } : {}),
+            ...(deps.baseUrl ? { baseUrl: deps.baseUrl } : {}),
+        });
+        const ctrl = new Controller(ensemble, actions, localHost);
+        // Per-session lifecycle state (re-created on each session_start).
+        let coarseAbort = null;
+        let tailAbort = null;
+        let renderTimer = null;
+        let lastRenderedRevision = -1;
+        let activeCtx = null;
+        const renderNow = () => {
+            if (!activeCtx?.hasUI)
+                return;
+            if (ctrl.model.revision === lastRenderedRevision)
+                return; // throttle: skip no-op ticks
+            lastRenderedRevision = ctrl.model.revision;
+            activeCtx.ui.setWidget(WIDGET_KEY, (0, render_1.renderBoard)(ctrl.model, ctrl.localHost), { placement: 'aboveEditor' });
+        };
+        const startCoarse = () => {
+            if (!adminToken) {
+                log(`no admin token (${actions_1.ADMIN_TOKEN_ENV}) — board limited / disabled`);
+            }
+            // H5: capture the controller locally. teardown nulls the outer `coarseAbort`,
+            // so the catch must check THIS signal — checking the nulled outer ref made an
+            // expected teardown abort log a spurious "coarse SSE ended: AbortError".
+            const ac = new AbortController();
+            coarseAbort = ac;
+            // H5: omit baseUrl → createSubscribe re-resolves the daemon port per
+            // (re)connect, so a daemon restart on a new port self-heals.
+            const subscribe = (0, subscribe_1.createSubscribe)({
+                ...(deps.baseUrl ? { baseUrl: deps.baseUrl } : {}),
+                ...(adminToken ? { token: adminToken } : {}),
+            });
+            void (async () => {
+                try {
+                    for await (const ev of subscribe(ensemble, { signal: ac.signal })) {
+                        (0, board_1.applyTempoEvent)(ctrl.model, ev);
+                    }
+                }
+                catch (err) {
+                    if (!ac.signal.aborted)
+                        log('coarse SSE ended:', err instanceof Error ? err.message : err);
+                }
+            })();
+        };
+        const openTail = (playerId) => {
+            tailAbort?.abort();
+            tailAbort = null;
+            if (playerId === null || !adminToken)
+                return;
+            tailAbort = new AbortController();
+            // H5: resolve the daemon base URL HERE (per /tail) so a port change is
+            // picked up on the next tail instead of being pinned at session start.
+            const baseUrl = resolveBaseUrl(deps.baseUrl);
+            const fetchFn = globalThis.fetch;
+            if (!fetchFn)
+                return;
+            void (0, inner_tail_1.openInnerTail)({
+                baseUrl, adminToken, ensemble, playerId,
+                signal: tailAbort.signal,
+                fetchFn: fetchFn,
+                onFrame: (f) => (0, board_1.applyInnerFrame)(ctrl.model, f),
+                onError: (m) => log(`inner tail (${playerId}):`, m),
+            });
+        };
+        ctrl.onTailRequest = openTail;
+        const teardown = () => {
+            coarseAbort?.abort();
+            coarseAbort = null;
+            tailAbort?.abort();
+            tailAbort = null;
+            if (renderTimer) {
+                clearInterval(renderTimer);
+                renderTimer = null;
+            }
+            if (activeCtx?.hasUI)
+                activeCtx.ui.setWidget(WIDGET_KEY, undefined);
+            activeCtx = null;
+        };
+        pi.on('session_start', (_event, ctx) => {
+            activeCtx = ctx;
+            lastRenderedRevision = -1;
+            startCoarse();
+            renderTimer = setInterval(renderNow, throttleMs);
+            if (typeof renderTimer.unref === 'function')
+                renderTimer.unref();
+            renderNow();
+        });
+        pi.on('session_shutdown', () => teardown());
+        // Operator commands (display-only widget → slash-commands drive everything).
+        pi.registerCommand('players', { description: 'List ensemble players', handler: (_a, ctx) => ctrl.cmdPlayers(ctx) });
+        pi.registerCommand('tail', { description: 'Tail a player\'s inner loop (/tail <player> | off)', handler: (a, ctx) => ctrl.cmdTail(a, ctx) });
+        pi.registerCommand('cue', { description: 'Send a message to a player (/cue <player> <msg>)', handler: (a, ctx) => ctrl.cmdCue(a, ctx) });
+        pi.registerCommand('pause', { description: 'Pause the ensemble', handler: (a, ctx) => ctrl.cmdPause(a, ctx) });
+        pi.registerCommand('play', { description: 'Resume the ensemble (/play [release])', handler: (a, ctx) => ctrl.cmdPlay(a, ctx) });
+        pi.registerCommand('restart', { description: 'Restart a player (/restart <player> [reason])', handler: (a, ctx) => ctrl.cmdRestart(a, ctx) });
+        pi.registerCommand('destroy', { description: 'Destroy a player (/destroy <player> [reason])', handler: (a, ctx) => ctrl.cmdDestroy(a, ctx) });
+        pi.registerCommand('reset', { description: 'Clean-wipe a player (/reset <player>)', handler: (a, ctx) => ctrl.cmdReset(a, ctx) });
+        pi.registerCommand('arm', { description: 'Arm/disarm the operator gate for a player (/arm <player> [off])', handler: (a, ctx) => ctrl.cmdArm(a, ctx) });
+        pi.registerCommand('gate', { description: 'Decide a gate request for the tailed player (/gate <reqId> allow|deny)', handler: (a, ctx) => ctrl.cmdGate(a, ctx) });
+    };
+}
+/** Default export — the loadable Pi extension. */
+const missionControlExtension = createMissionControlExtension();
+exports.default = missionControlExtension;

package/dist/pi/mission-control/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Mission-control (3f) — a Pi extension that turns one interactive Pi TUI into
+ * an ensemble mission-control board + operator controller. Observer-only,
+ * HTTP-driven, throttled render. See ./extension.ts.
+ *
+ * The default export is the loadable Pi extension.
+ */
+export { default, createMissionControlExtension, Controller } from './extension';
+export type { MissionControlDeps } from './extension';
+export { initBoard, applyTempoEvent, applyInnerFrame, selectPlayer, sortedPlayerIds, DEFAULT_TAIL_LIMIT, } from './board';
+export type { BoardModel, PlayerRow } from './board';
+export { renderBoard } from './render';
+export { MissionControlActions, ADMIN_TOKEN_ENV } from './actions';
+export type { ActionResult } from './actions';
+export { parseInnerSse, openInnerTail } from './inner-tail';

package/dist/pi/mission-control/index.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openInnerTail = exports.parseInnerSse = exports.ADMIN_TOKEN_ENV = exports.MissionControlActions = exports.renderBoard = exports.DEFAULT_TAIL_LIMIT = exports.sortedPlayerIds = exports.selectPlayer = exports.applyInnerFrame = exports.applyTempoEvent = exports.initBoard = exports.Controller = exports.createMissionControlExtension = exports.default = void 0;
+/**
+ * Mission-control (3f) — a Pi extension that turns one interactive Pi TUI into
+ * an ensemble mission-control board + operator controller. Observer-only,
+ * HTTP-driven, throttled render. See ./extension.ts.
+ *
+ * The default export is the loadable Pi extension.
+ */
+var extension_1 = require("./extension");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(extension_1).default; } });
+Object.defineProperty(exports, "createMissionControlExtension", { enumerable: true, get: function () { return extension_1.createMissionControlExtension; } });
+Object.defineProperty(exports, "Controller", { enumerable: true, get: function () { return extension_1.Controller; } });
+var board_1 = require("./board");
+Object.defineProperty(exports, "initBoard", { enumerable: true, get: function () { return board_1.initBoard; } });
+Object.defineProperty(exports, "applyTempoEvent", { enumerable: true, get: function () { return board_1.applyTempoEvent; } });
+Object.defineProperty(exports, "applyInnerFrame", { enumerable: true, get: function () { return board_1.applyInnerFrame; } });
+Object.defineProperty(exports, "selectPlayer", { enumerable: true, get: function () { return board_1.selectPlayer; } });
+Object.defineProperty(exports, "sortedPlayerIds", { enumerable: true, get: function () { return board_1.sortedPlayerIds; } });
+Object.defineProperty(exports, "DEFAULT_TAIL_LIMIT", { enumerable: true, get: function () { return board_1.DEFAULT_TAIL_LIMIT; } });
+var render_1 = require("./render");
+Object.defineProperty(exports, "renderBoard", { enumerable: true, get: function () { return render_1.renderBoard; } });
+var actions_1 = require("./actions");
+Object.defineProperty(exports, "MissionControlActions", { enumerable: true, get: function () { return actions_1.MissionControlActions; } });
+Object.defineProperty(exports, "ADMIN_TOKEN_ENV", { enumerable: true, get: function () { return actions_1.ADMIN_TOKEN_ENV; } });
+var inner_tail_1 = require("./inner-tail");
+Object.defineProperty(exports, "parseInnerSse", { enumerable: true, get: function () { return inner_tail_1.parseInnerSse; } });
+Object.defineProperty(exports, "openInnerTail", { enumerable: true, get: function () { return inner_tail_1.openInnerTail; } });