agent-tempo 1.2.0 → 1.4.0

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

@@ -0,0 +1,48 @@
+/** Env var holding the daemon admin (T3) token (writes + gate + inner tail). */
+export declare const ADMIN_TOKEN_ENV = "AGENT_TEMPO_HTTP_ADMIN_TOKEN";
+export type ActionFetch = (url: string, init: {
+    method: string;
+    headers: Record<string, string>;
+    body?: string;
+}) => Promise<{
+    status: number;
+    text(): Promise<string>;
+}>;
+export type ActionResult = {
+    ok: true;
+    status: number;
+} | {
+    ok: false;
+    error: string;
+};
+export interface MissionControlActionsOptions {
+    ensemble: string;
+    /** Admin (T3) token. Defaults to `process.env[ADMIN_TOKEN_ENV]`. */
+    adminToken?: string;
+    /** Daemon base URL. Defaults to `http://127.0.0.1:${readPortFile() ?? 8473}`. */
+    baseUrl?: string;
+    /** HTTP transport. Defaults to global `fetch`. */
+    fetchFn?: ActionFetch;
+}
+/** HTTP client for the daemon operator-action surface. All calls bearer-authed. */
+export declare class MissionControlActions {
+    private readonly ensemble;
+    private readonly adminToken;
+    private readonly baseUrlOverride;
+    private readonly fetchFn;
+    constructor(opts: MissionControlActionsOptions);
+    /** Whether the client is usable (token + transport present). */
+    get ready(): boolean;
+    private baseUrl;
+    private post;
+    private ens;
+    private player;
+    cue(to: string, message: string): Promise<ActionResult>;
+    pause(): Promise<ActionResult>;
+    play(release?: boolean): Promise<ActionResult>;
+    restart(playerId: string, reason?: string): Promise<ActionResult>;
+    destroy(playerId: string, reason?: string): Promise<ActionResult>;
+    gateArm(playerId: string): Promise<ActionResult>;
+    gateDisarm(playerId: string): Promise<ActionResult>;
+    gateDecide(playerId: string, requestId: string, decision: 'allow' | 'deny'): Promise<ActionResult>;
+}

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

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissionControlActions = exports.ADMIN_TOKEN_ENV = void 0;
+/**
+ * Mission-control action client (3f) — DRIVE = HTTP (decision 1). Operator
+ * controls POST to the daemon's write surface (T2) + gate endpoints (T3), the
+ * SAME surface the dashboard uses — NOT in-Pi MCP tools. The widget holds the
+ * ADMIN token (T3) and presents it as a bearer.
+ *
+ * Injected fetch / readPort / token so it's unit-testable without a daemon.
+ */
+const port_file_1 = require("../../http/port-file");
+/** Env var holding the daemon admin (T3) token (writes + gate + inner tail). */
+exports.ADMIN_TOKEN_ENV = 'AGENT_TEMPO_HTTP_ADMIN_TOKEN';
+const DEFAULT_PORT = 8473;
+function resolveFetch() {
+    const g = globalThis.fetch;
+    return typeof g === 'function' ? g : null;
+}
+/** HTTP client for the daemon operator-action surface. All calls bearer-authed. */
+class MissionControlActions {
+    ensemble;
+    adminToken;
+    baseUrlOverride;
+    fetchFn;
+    constructor(opts) {
+        this.ensemble = opts.ensemble;
+        this.adminToken = opts.adminToken ?? process.env[exports.ADMIN_TOKEN_ENV];
+        this.baseUrlOverride = opts.baseUrl;
+        this.fetchFn = opts.fetchFn ?? resolveFetch();
+    }
+    /** Whether the client is usable (token + transport present). */
+    get ready() {
+        return Boolean(this.adminToken) && this.fetchFn !== null;
+    }
+    baseUrl() {
+        if (this.baseUrlOverride)
+            return this.baseUrlOverride.replace(/\/$/, '');
+        const port = (0, port_file_1.readPortFile)() ?? DEFAULT_PORT;
+        return `http://127.0.0.1:${port}`;
+    }
+    async post(pathSuffix, body) {
+        if (!this.adminToken)
+            return { ok: false, error: `no admin token (set ${exports.ADMIN_TOKEN_ENV})` };
+        if (!this.fetchFn)
+            return { ok: false, error: 'no fetch transport available' };
+        const base = this.baseUrl();
+        if (base === null)
+            return { ok: false, error: 'daemon HTTP not reachable (no port)' };
+        try {
+            const res = await this.fetchFn(`${base}${pathSuffix}`, {
+                method: 'POST',
+                headers: { Authorization: `Bearer ${this.adminToken}`, 'Content-Type': 'application/json' },
+                body: JSON.stringify(body ?? {}),
+            });
+            if (res.status >= 200 && res.status < 300)
+                return { ok: true, status: res.status };
+            const detail = (await res.text().catch(() => '')).slice(0, 200);
+            return { ok: false, error: `HTTP ${res.status}${detail ? `: ${detail}` : ''}` };
+        }
+        catch (err) {
+            return { ok: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    ens() {
+        return encodeURIComponent(this.ensemble);
+    }
+    player(p) {
+        return `${this.ens()}/${encodeURIComponent(p)}`;
+    }
+    // ── Ensemble write surface (T2) ──
+    cue(to, message) {
+        return this.post(`/v1/ensembles/${this.ens()}/cue`, { to, message });
+    }
+    pause() {
+        return this.post(`/v1/ensembles/${this.ens()}/pause`, {});
+    }
+    play(release) {
+        return this.post(`/v1/ensembles/${this.ens()}/play`, release ? { release } : {});
+    }
+    restart(playerId, reason) {
+        return this.post(`/v1/ensembles/${this.ens()}/restart`, { playerId, ...(reason ? { reason } : {}) });
+    }
+    destroy(playerId, reason) {
+        return this.post(`/v1/ensembles/${this.ens()}/destroy`, { playerId, ...(reason ? { reason } : {}) });
+    }
+    // ── Operator gate plane (T3) ──
+    gateArm(playerId) {
+        return this.post(`/v1/players/${this.player(playerId)}/gate-arm`, {});
+    }
+    gateDisarm(playerId) {
+        return this.post(`/v1/players/${this.player(playerId)}/gate-disarm`, {});
+    }
+    gateDecide(playerId, requestId, decision) {
+        return this.post(`/v1/players/${this.player(playerId)}/gate/${encodeURIComponent(requestId)}`, { decision });
+    }
+}
+exports.MissionControlActions = MissionControlActions;

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

@@ -0,0 +1,53 @@
+/**
+ * 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;
+    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;
+/** 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,104 @@
+"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.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,
+        ...(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;
+}
+/** 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,44 @@
+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;
+}
+/**
+ * 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;
+    /** 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);
+    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,251 @@
+"use strict";
+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 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;
+    /** Set by the extension so /tail can (re)open the fine SSE; null in unit tests. */
+    onTailRequest = null;
+    constructor(ensemble, actions) {
+        this.model = (0, board_1.initBoard)(ensemble);
+        this.actions = actions;
+    }
+    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;
+        }
+        if (!(0, board_1.selectPlayer)(this.model, target)) {
+            this.notify(ctx, `No such player: ${target}`);
+            return;
+        }
+        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 baseUrl = resolveBaseUrl(deps.baseUrl);
+        const throttleMs = deps.renderThrottleMs ?? DEFAULT_RENDER_THROTTLE_MS;
+        const actions = new actions_1.MissionControlActions({ ensemble, ...(adminToken ? { adminToken } : {}), baseUrl });
+        const ctrl = new Controller(ensemble, actions);
+        // 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), { placement: 'aboveEditor' });
+        };
+        const startCoarse = () => {
+            if (!adminToken) {
+                log(`no admin token (${actions_1.ADMIN_TOKEN_ENV}) — board limited / disabled`);
+            }
+            coarseAbort = new AbortController();
+            const subscribe = (0, subscribe_1.createSubscribe)({ baseUrl, ...(adminToken ? { token: adminToken } : {}) });
+            void (async () => {
+                try {
+                    for await (const ev of subscribe(ensemble, { signal: coarseAbort.signal })) {
+                        (0, board_1.applyTempoEvent)(ctrl.model, ev);
+                    }
+                }
+                catch (err) {
+                    if (!coarseAbort?.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();
+            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; } });