agent-tempo 1.3.1 → 1.4.0

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; } });

package/dist/pi/mission-control/inner-tail.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Fine inner-loop tail consumer (3f) — the OPERATOR egress side of the 3c
+ * side-channel: `GET /v1/players/:e/:p/inner` (SSE, T3 admin bearer). Distinct
+ * from `src/pi/inner-loop-client.ts` (the player→daemon INGRESS). Opened on
+ * `/tail <player>`, torn down on deselect / shutdown.
+ *
+ * The SSE-frame parser is pure + unit-tested; the stream pump is injectable
+ * (fetch) so the extension wires real `fetch` while tests drive frames directly.
+ *
+ * NOTE (cross-host): `/inner` is daemon-LOCAL to the player's host. Single-host
+ * (Meijer container) uses the local daemon; multi-host should resolve the
+ * player's `preferredHost` via `/v1/hosts` and target that daemon — the
+ * `baseUrl` option is the seam for that (don't hardcode localhost forever).
+ */
+import type { InnerFrame } from '../inner-loop-publisher';
+/**
+ * Parse the `data:` payloads out of one SSE text chunk, returning the decoded
+ * InnerFrames + any trailing partial buffer to prepend to the next chunk. Pure.
+ * Tolerates keepalive comment lines (`:`) and multi-line frames split on `\n\n`.
+ */
+export declare function parseInnerSse(chunk: string, carry?: string): {
+    frames: InnerFrame[];
+    carry: string;
+};
+export type TailFetch = (url: string, init: {
+    method: string;
+    headers: Record<string, string>;
+    signal?: AbortSignal;
+}) => Promise<{
+    status: number;
+    body: AsyncIterable<Uint8Array> | null;
+}>;
+export interface OpenInnerTailOptions {
+    baseUrl: string;
+    adminToken: string;
+    ensemble: string;
+    playerId: string;
+    onFrame: (frame: InnerFrame) => void;
+    signal: AbortSignal;
+    fetchFn: TailFetch;
+    /** Called on a non-200 / stream error (e.g. to surface in the widget). */
+    onError?: (message: string) => void;
+}
+/**
+ * Open the per-player inner SSE and pump frames to `onFrame` until `signal`
+ * aborts. Resolves when the stream ends/aborts; never throws (errors → onError).
+ */
+export declare function openInnerTail(opts: OpenInnerTailOptions): Promise<void>;

package/dist/pi/mission-control/inner-tail.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseInnerSse = parseInnerSse;
+exports.openInnerTail = openInnerTail;
+/**
+ * Parse the `data:` payloads out of one SSE text chunk, returning the decoded
+ * InnerFrames + any trailing partial buffer to prepend to the next chunk. Pure.
+ * Tolerates keepalive comment lines (`:`) and multi-line frames split on `\n\n`.
+ */
+function parseInnerSse(chunk, carry = '') {
+    const buf = carry + chunk;
+    const parts = buf.split('\n\n');
+    const rest = parts.pop() ?? ''; // last element is an incomplete event (or '')
+    const frames = [];
+    for (const evt of parts) {
+        // An SSE event may have multiple lines; collect `data:` lines, ignore `:`/`event:`/`id:`.
+        const data = evt
+            .split('\n')
+            .filter((l) => l.startsWith('data:'))
+            .map((l) => l.slice(5).trimStart())
+            .join('\n');
+        if (!data)
+            continue;
+        try {
+            const parsed = JSON.parse(data);
+            if (parsed && typeof parsed.type === 'string' && parsed.type.startsWith('inner.')) {
+                frames.push(parsed);
+            }
+        }
+        catch {
+            // ignore malformed/non-frame data
+        }
+    }
+    return { frames, carry: rest };
+}
+/**
+ * Open the per-player inner SSE and pump frames to `onFrame` until `signal`
+ * aborts. Resolves when the stream ends/aborts; never throws (errors → onError).
+ */
+async function openInnerTail(opts) {
+    const url = `${opts.baseUrl.replace(/\/$/, '')}/v1/players/` +
+        `${encodeURIComponent(opts.ensemble)}/${encodeURIComponent(opts.playerId)}/inner`;
+    let res;
+    try {
+        res = await opts.fetchFn(url, {
+            method: 'GET',
+            headers: { Authorization: `Bearer ${opts.adminToken}`, Accept: 'text/event-stream' },
+            signal: opts.signal,
+        });
+    }
+    catch (err) {
+        if (!opts.signal.aborted)
+            opts.onError?.(err instanceof Error ? err.message : String(err));
+        return;
+    }
+    if (res.status !== 200 || !res.body) {
+        opts.onError?.(`inner tail HTTP ${res.status}`);
+        return;
+    }
+    const decoder = new TextDecoder();
+    let carry = '';
+    try {
+        for await (const chunk of res.body) {
+            if (opts.signal.aborted)
+                break;
+            const { frames, carry: next } = parseInnerSse(decoder.decode(chunk, { stream: true }), carry);
+            carry = next;
+            for (const f of frames)
+                opts.onFrame(f);
+        }
+    }
+    catch (err) {
+        if (!opts.signal.aborted)
+            opts.onError?.(err instanceof Error ? err.message : String(err));
+    }
+}

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

@@ -0,0 +1,43 @@
+/**
+ * Hand-written structural slice of Pi's extension UI + command API that
+ * mission-control consumes (3f). Kept LOCAL (not in the shared `src/pi/pi-types.ts`)
+ * so this feature is self-contained and `tsc` stays green WITHOUT the optional
+ * `@earendil-works/pi-coding-agent` dep installed. Mirrors the installed SDK's
+ * `dist/core/extensions/types.d.ts` (verified 0.78.0): `ctx.ui.setWidget` /
+ * `select` / `confirm` / `input` / `notify`, `registerCommand`, `registerShortcut`.
+ */
+export interface ExtensionUIDialogOptions {
+    signal?: AbortSignal;
+    timeout?: number;
+}
+/** The `ctx.ui` surface (present only when `ctx.hasUI`). */
+export interface ExtensionUIContext {
+    /** Persistent widget: re-call with new lines to update; `undefined` clears it. */
+    setWidget(key: string, content: string[] | undefined, options?: {
+        placement?: 'aboveEditor' | 'belowEditor';
+    }): void;
+    select(title: string, options: string[], opts?: ExtensionUIDialogOptions): Promise<string | undefined>;
+    confirm(title: string, message: string, opts?: ExtensionUIDialogOptions): Promise<boolean>;
+    input(title: string, placeholder?: string, opts?: ExtensionUIDialogOptions): Promise<string | undefined>;
+    notify(message: string): void;
+}
+/** Context passed to every handler. `ui` is only safe to use when `hasUI`. */
+export interface McExtensionContext {
+    ui: ExtensionUIContext;
+    hasUI: boolean;
+}
+export type McEventHandler = (event: unknown, ctx: McExtensionContext) => void | Promise<void>;
+export type McCommandHandler = (args: string, ctx: McExtensionContext) => void | Promise<void>;
+export type McShortcutHandler = (ctx: McExtensionContext) => void | Promise<void>;
+/** The `pi` object passed to the extension's default export — slice we use. */
+export interface McExtensionAPI {
+    on(event: string, handler: McEventHandler): void;
+    registerCommand(name: string, options: {
+        description?: string;
+        handler: McCommandHandler;
+    }): void;
+    registerShortcut(shortcut: unknown, options: {
+        description?: string;
+        handler: McShortcutHandler;
+    }): void;
+}