agent-tempo 1.0.1

package/dist/tui/components/Splash.js

@@ -0,0 +1,221 @@
+"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.Splash = Splash;
+/**
+ * Splash screen — landing/home screen with animated metronome, connection
+ * status, and ensemble picker.
+ *
+ * Uses a single Text element with nested virtual-text nodes to minimize
+ * Yoga layout nodes (target: <10 total).
+ */
+const react_1 = __importStar(require("react"));
+const ink_context_1 = require("../ink-context");
+const platform_1 = require("../utils/platform");
+const theme_1 = require("../utils/theme");
+const SPINNER_FRAMES = ['\u280B', '\u2819', '\u2839', '\u2838', '\u283C', '\u2834', '\u2826', '\u2827', '\u2807', '\u280F'];
+const PING_PONG = [0, 1, 2, 1];
+const MAX_ENSEMBLES_SHOWN = 5;
+function Splash({ status, version, connected, ensembles, onContinue, onCreateEnsemble }) {
+    const { Text, useInput } = (0, ink_context_1.useInk)();
+    const [metronomeTick, setMetronomeTick] = (0, react_1.useState)(0);
+    const [spinnerTick, setSpinnerTick] = (0, react_1.useState)(0);
+    const [selectedIdx, setSelectedIdx] = (0, react_1.useState)(0);
+    const brailleFrames = (0, react_1.useMemo)(() => (0, platform_1.metronomeBrailleFrames)(), []);
+    const ensembleCount = ensembles?.length ?? 0;
+    // Total selectable items: ensembles + "create new" item (when loaded)
+    const totalItems = ensembles !== undefined ? ensembleCount + 1 : (ensembleCount || 1);
+    const hasNavigation = totalItems > 1;
+    const isCreateSelected = ensembles !== undefined && selectedIdx === ensembleCount;
+    // Handle keys: ↑↓ to select, Enter to continue/create
+    const inputRef = react_1.default.useRef({ connected, onContinue, onCreateEnsemble, ensembles, selectedIdx, isCreateSelected, totalItems });
+    inputRef.current = { connected, onContinue, onCreateEnsemble, ensembles, selectedIdx, isCreateSelected, totalItems };
+    useInput(react_1.default.useCallback((_input, key) => {
+        const r = inputRef.current;
+        if (!r.connected)
+            return;
+        if (key.return) {
+            if (r.isCreateSelected) {
+                r.onCreateEnsemble?.();
+            }
+            else {
+                const selected = r.ensembles?.[r.selectedIdx]?.name;
+                r.onContinue?.(selected);
+            }
+            return;
+        }
+        if (key.upArrow) {
+            setSelectedIdx(i => Math.max(0, i - 1));
+            return;
+        }
+        if (key.downArrow) {
+            setSelectedIdx(i => Math.min(r.totalItems - 1, i + 1));
+            return;
+        }
+    }, []));
+    // Metronome animation — cleanup stops timer on unmount/transition
+    (0, react_1.useEffect)(() => {
+        const timer = setInterval(() => {
+            setMetronomeTick((t) => (t + 1) % PING_PONG.length);
+        }, 300);
+        return () => clearInterval(timer);
+    }, []);
+    // Spinner animation — stops once connected
+    (0, react_1.useEffect)(() => {
+        if (connected)
+            return;
+        const timer = setInterval(() => {
+            setSpinnerTick((t) => (t + 1) % SPINNER_FRAMES.length);
+        }, 80);
+        return () => clearInterval(timer);
+    }, [connected]);
+    // ── Metronome frame (needed for line count) ──
+    const frameIndex = PING_PONG[metronomeTick];
+    const frame = brailleFrames[frameIndex];
+    // ── Centering calculations ──
+    const cols = process.stdout.columns || 80;
+    const rows = process.stdout.rows || 24;
+    /** Center a string horizontally based on its visible width. */
+    const center = (text) => {
+        const pad = Math.max(0, Math.floor((cols - text.length) / 2));
+        return ' '.repeat(pad) + text;
+    };
+    // Count actual content lines for accurate vertical centering
+    const metroLines = frame.length; // ~10 lines
+    const titleLines = 5; // 2 blank + title + tagline + version
+    const statusLines = 3; // 2 blank + status line
+    const ensembleLines = connected && ensembles !== undefined
+        ? 1 + Math.min(ensembleCount, MAX_ENSEMBLES_SHOWN) + 1 + (ensembleCount === 0 ? 1 : 0) // gap + items + create + optional "none"
+        : (connected ? 3 : 0); // loading or not connected
+    const promptLines = 3; // 2 blank + prompt
+    const contentHeight = metroLines + titleLines + statusLines + ensembleLines + promptLines;
+    const vPad = Math.max(0, Math.floor((rows - contentHeight - 3) / 2));
+    // ── Build single Text element with all content as nested virtual-text ──
+    const children = [];
+    // Vertical centering
+    for (let i = 0; i < vPad; i++)
+        children.push('\n');
+    // Metronome logo (braille characters as nested Text — 0 Yoga nodes)
+    for (let li = 0; li < frame.length; li++) {
+        if (li > 0)
+            children.push('\n');
+        const lineWidth = frame[li].reduce((w, seg) => w + seg.char.length, 0);
+        const metroPad = ' '.repeat(Math.max(0, Math.floor((cols - lineWidth) / 2)));
+        children.push(metroPad);
+        for (let si = 0; si < frame[li].length; si++) {
+            const seg = frame[li][si];
+            children.push(react_1.default.createElement(Text, { key: `m-${li}-${si}`, color: seg.color || undefined }, seg.char));
+        }
+    }
+    // Title + tagline + version
+    children.push('\n\n');
+    children.push(react_1.default.createElement(Text, { key: 'title', bold: true, color: theme_1.THEME.accent }, center('agent-tempo')));
+    children.push('\n');
+    children.push(react_1.default.createElement(Text, { key: 'tagline', color: theme_1.THEME.dim }, center('Multi-session orchestration via Temporal')));
+    children.push('\n');
+    children.push(react_1.default.createElement(Text, { key: 'version', color: theme_1.THEME.muted }, center(`v${version}`)));
+    // Connection status
+    children.push('\n\n');
+    if (connected) {
+        children.push(react_1.default.createElement(Text, { key: 'status', color: theme_1.THEME.success }, center('\u2713 Connected')));
+    }
+    else {
+        children.push(react_1.default.createElement(Text, { key: 'status', color: theme_1.THEME.warning }, center(`${SPINNER_FRAMES[spinnerTick]} ${status}`)));
+    }
+    // Ensemble list + create option (when connected)
+    if (connected && ensembles !== undefined) {
+        children.push('\n');
+        if (ensembles.length > 0) {
+            let startIdx = 0;
+            if (ensembles.length > MAX_ENSEMBLES_SHOWN) {
+                startIdx = Math.max(0, Math.min(selectedIdx - Math.floor(MAX_ENSEMBLES_SHOWN / 2), ensembles.length - MAX_ENSEMBLES_SHOWN));
+            }
+            const visible = ensembles.slice(startIdx, startIdx + MAX_ENSEMBLES_SHOWN);
+            if (startIdx > 0) {
+                children.push('\n');
+                children.push(react_1.default.createElement(Text, { key: 'sup', color: theme_1.THEME.dim }, center(`\u2191 ${startIdx} more`)));
+            }
+            for (let i = 0; i < visible.length; i++) {
+                const ens = visible[i];
+                const actualIdx = startIdx + i;
+                const isSelected = actualIdx === selectedIdx;
+                const icon = ens.hasConductor ? '\u2605' : '\u2022';
+                const indicator = isSelected ? '\u25B8 ' : '  ';
+                children.push('\n');
+                children.push(react_1.default.createElement(Text, {
+                    key: `ens-${ens.name}`,
+                    color: isSelected ? theme_1.THEME.accent : theme_1.THEME.textMuted,
+                    bold: isSelected,
+                }, center(`${indicator}${icon} ${ens.name} (${ens.playerCount} player${ens.playerCount !== 1 ? 's' : ''})`)));
+            }
+            if (startIdx + MAX_ENSEMBLES_SHOWN < ensembles.length) {
+                children.push('\n');
+                children.push(react_1.default.createElement(Text, { key: 'sdn', color: theme_1.THEME.dim }, center(`\u2193 ${ensembles.length - startIdx - MAX_ENSEMBLES_SHOWN} more`)));
+            }
+        }
+        else {
+            // Loaded but empty
+            children.push('\n');
+            children.push(react_1.default.createElement(Text, { key: 'none', color: theme_1.THEME.dim }, center('No ensembles running.')));
+        }
+        // "+ Create new ensemble" — always selectable
+        children.push('\n');
+        const createIndicator = isCreateSelected ? '\u25B8 ' : '  ';
+        children.push(react_1.default.createElement(Text, {
+            key: 'create',
+            color: isCreateSelected ? theme_1.THEME.accent : theme_1.THEME.dim,
+            bold: isCreateSelected,
+        }, center(`${createIndicator}+ Create new ensemble`)));
+    }
+    else if (connected) {
+        // Connected but ensembles not yet loaded
+        children.push('\n\n');
+        children.push(react_1.default.createElement(Text, { key: 'loading', color: theme_1.THEME.dim }, center('\u27F3 Discovering ensembles...')));
+    }
+    // Bottom prompt
+    children.push('\n\n');
+    if (connected) {
+        children.push(react_1.default.createElement(Text, { key: 'prompt', bold: true, color: theme_1.THEME.accent }, ensembles === undefined
+            ? center('Press Ctrl+C to exit')
+            : hasNavigation
+                ? center('\u2191\u2193 to select, Enter to continue')
+                : center('Press Enter to continue')));
+    }
+    else {
+        children.push(react_1.default.createElement(Text, { key: 'prompt', color: theme_1.THEME.muted }, center('Press Ctrl+C to cancel')));
+    }
+    // Single Text element wrapping everything (1 Yoga node)
+    return react_1.default.createElement(Text, null, ...children);
+}

package/dist/tui/components/StatusBar.d.ts

@@ -0,0 +1,48 @@
+/**
+ * StatusBar — persistent one-line status summary.
+ * Renders as a SINGLE Text element (1 Yoga node). Nested Text = ink-virtual-text (0 nodes).
+ */
+import React from 'react';
+import type { MaestroPlayerInfo } from '../../types';
+export interface StatusBarProps {
+    ensemble: string | null;
+    players: MaestroPlayerInfo[];
+    /** True after the first player poll completes. False = still loading. */
+    playersLoaded: boolean;
+    scheduleCount: number;
+    connected: boolean;
+    /**
+     * Bug B: Whether the active ensemble's maestro hub is paused. Drives a
+     * yellow "paused" segment so users see why a conductor is silently
+     * swallowing typed messages (the session-level `paused` flag gates the
+     * outbox dispatcher).
+     */
+    ensemblePaused?: boolean;
+    /**
+     * #306 follow-up: Whether at least one session in the active ensemble
+     * has its outbox locked (`held`). Drives a yellow "held" segment.
+     * Independent of `ensemblePaused` because `/load_lineup` flips both
+     * flags at once but `/play` only clears pause — users would otherwise
+     * see "no paused indicator" and assume the ensemble is fully resumed
+     * when held players were still frozen behind the locked outbox.
+     */
+    ensembleHeld?: boolean;
+}
+/**
+ * One rendered text segment of the status bar. Returned by
+ * {@link buildStatusBarSegments} so tests can inspect the bar's contents
+ * without spinning up Ink. Each segment becomes a nested ink-virtual-text
+ * inside the single outer Text element.
+ */
+export interface StatusBarSegment {
+    key: string;
+    color: string;
+    text: string;
+}
+/**
+ * Pure helper: compute the StatusBar's segment list from props. Keeps the
+ * render-path logic testable without an Ink context. The component below
+ * just maps each segment to a `<Text>` element.
+ */
+export declare function buildStatusBarSegments(props: StatusBarProps): StatusBarSegment[];
+export declare function StatusBar(props: StatusBarProps): React.DetailedReactHTMLElement<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>;

package/dist/tui/components/StatusBar.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildStatusBarSegments = buildStatusBarSegments;
+exports.StatusBar = StatusBar;
+/**
+ * StatusBar — persistent one-line status summary.
+ * Renders as a SINGLE Text element (1 Yoga node). Nested Text = ink-virtual-text (0 nodes).
+ */
+const react_1 = __importDefault(require("react"));
+const ink_context_1 = require("../ink-context");
+const theme_1 = require("../utils/theme");
+const format_1 = require("../utils/format");
+/**
+ * Pure helper: compute the StatusBar's segment list from props. Keeps the
+ * render-path logic testable without an Ink context. The component below
+ * just maps each segment to a `<Text>` element.
+ */
+function buildStatusBarSegments(props) {
+    const { ensemble, players, playersLoaded, scheduleCount, connected, ensemblePaused, ensembleHeld } = props;
+    const healthColor = connected ? theme_1.THEME.success : theme_1.THEME.error;
+    const healthDot = connected ? '●' : '○';
+    const healthLabel = connected ? 'Connected' : 'Disconnected';
+    const ensembleLabel = ensemble || 'no ensemble';
+    const segments = [
+        { key: 'lead', color: theme_1.THEME.dim, text: ' ' },
+        { key: 'ens', color: ensemble ? theme_1.THEME.accent : theme_1.THEME.dim, text: ensembleLabel },
+        { key: 's1', color: theme_1.THEME.dim, text: ' · ' },
+    ];
+    if (ensemble && !playersLoaded) {
+        // Still loading — don't show incorrect counts
+        segments.push({ key: 'pl', color: theme_1.THEME.dim, text: 'Loading...' });
+    }
+    else {
+        // Exclude the maestro session from headline counts — it is the TUI's own
+        // dashboard attachment, not a peer agent. The full list (including the
+        // maestro) is still surfaced in `/players` and the status overlay so the
+        // user can see internal state honestly.
+        const realPlayers = (0, format_1.filterRealPlayers)(players);
+        // Player breakdown by phase label (Option-B five buckets collapsed to four
+        // meaningful ones for the bar — `gone` players are terminal and not
+        // shown in the ensemble list).
+        let active = 0;
+        let idle = 0;
+        let disconnected = 0;
+        let pending = 0;
+        for (const p of realPlayers) {
+            switch ((0, format_1.phaseToLabel)(p.phase)) {
+                case 'active':
+                    active++;
+                    break;
+                case 'idle':
+                    idle++;
+                    break;
+                case 'disconnected':
+                    disconnected++;
+                    break;
+                case 'pending':
+                    pending++;
+                    break;
+                // 'gone' / 'unknown' intentionally not counted in the summary line.
+            }
+        }
+        const parts = [];
+        if (active > 0)
+            parts.push(`${active} active`);
+        if (idle > 0)
+            parts.push(`${idle} idle`);
+        if (disconnected > 0)
+            parts.push(`${disconnected} disconnected`);
+        if (pending > 0)
+            parts.push(`${pending} pending`);
+        const breakdown = parts.length > 0 ? ` (${parts.join(', ')})` : '';
+        const playerLabel = `${realPlayers.length} player${realPlayers.length !== 1 ? 's' : ''}${breakdown}`;
+        segments.push({ key: 'pl', color: theme_1.THEME.dim, text: playerLabel });
+        if (scheduleCount > 0) {
+            segments.push({ key: 's2', color: theme_1.THEME.dim, text: ' · ' }, { key: 'sc', color: theme_1.THEME.dim, text: `${scheduleCount} schedule${scheduleCount !== 1 ? 's' : ''}` });
+        }
+        // Bug B + #306 follow-up: yellow `paused`/`held`/`paused + held` segment
+        // when the maestro hub is paused or any session has its outbox locked
+        // (or both — `/load_lineup` flips both flags at once). Placed before
+        // the "No conductor" warning so the most actionable state reads first
+        // when both apply. The same guard (`ensemble && …`) keeps the segment
+        // off the home view.
+        //
+        // Combined-glyph variant for paused + held picks `⏸⊕ paused + held`
+        // over two separate segments — scans cleaner at terminal density and
+        // lets the matching tip below the input ("Tip: type /play to unpause
+        // + /go to release held players.") read as one instruction.
+        if (ensemble && (ensemblePaused || ensembleHeld)) {
+            let label;
+            if (ensemblePaused && ensembleHeld) {
+                label = '⏸⊕ paused + held';
+            }
+            else if (ensemblePaused) {
+                // U+23F8 PAUSE SYMBOL — single glyph, mirrors the U+26A0 warning below.
+                label = '⏸ paused';
+            }
+            else {
+                // U+2295 CIRCLED PLUS — distinct from pause, suggests "more buffered".
+                label = '⊕ held';
+            }
+            segments.push({ key: 'sp', color: theme_1.THEME.dim, text: ' · ' }, { key: 'pa', color: theme_1.THEME.warning, text: label });
+        }
+        // #358: derive from `players` (single source of truth) so the badge
+        // updates on incremental SSE events (`player.added`/`player.removed`)
+        // without waiting for the next snapshot. Pre-#358 this depended on a
+        // separate `conductorName` cache populated only by the snapshot path,
+        // so a `/destroy conductor` mid-session left "No conductor" stuck off
+        // until the next snapshot intervened.
+        if (ensemble && !players.some(p => p.isConductor)) {
+            segments.push({ key: 's3', color: theme_1.THEME.dim, text: ' · ' }, { key: 'nc', color: theme_1.THEME.warning, text: '⚠ No conductor' });
+        }
+    }
+    segments.push({ key: 's4', color: theme_1.THEME.dim, text: ' · ' }, { key: 'hd', color: healthColor, text: healthDot }, { key: 'hl', color: theme_1.THEME.dim, text: ` ${healthLabel}` });
+    return segments;
+}
+function StatusBar(props) {
+    const { Text } = (0, ink_context_1.useInk)();
+    const segments = buildStatusBarSegments(props);
+    // Single Text element — all children are ink-virtual-text (0 Yoga nodes)
+    const children = segments.map((s) => s.key === 'lead'
+        ? s.text
+        : react_1.default.createElement(Text, { key: s.key, color: s.color }, s.text));
+    return react_1.default.createElement(Text, null, ...children);
+}

package/dist/tui/components/StatusOverlay.d.ts

@@ -0,0 +1,15 @@
+/**
+ * StatusOverlay — dismissible overlay showing ensemble player cards.
+ *
+ * Performance: Single <Text> root with nested virtual-text children.
+ * Zero Yoga <Box> nodes.
+ */
+import React from 'react';
+import type { MaestroPlayerInfo } from '../../types';
+export interface StatusOverlayProps {
+    players: MaestroPlayerInfo[];
+    ensemble: string;
+    scrollOffset: number;
+    contentHeight: number;
+}
+export declare function StatusOverlay({ players, ensemble, scrollOffset, contentHeight }: StatusOverlayProps): React.CElement<{}, React.Component<{}, any, any>>;

package/dist/tui/components/StatusOverlay.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatusOverlay = StatusOverlay;
+/**
+ * StatusOverlay — dismissible overlay showing ensemble player cards.
+ *
+ * Performance: Single <Text> root with nested virtual-text children.
+ * Zero Yoga <Box> nodes.
+ */
+const react_1 = __importDefault(require("react"));
+const ink_context_1 = require("../ink-context");
+const theme_1 = require("../utils/theme");
+const format_1 = require("../utils/format");
+const platform_1 = require("../utils/platform");
+function StatusOverlay({ players, ensemble, scrollOffset, contentHeight }) {
+    const { Text } = (0, ink_context_1.useInk)();
+    const icons = (0, platform_1.statusIcons)((0, platform_1.supportsUnicode)());
+    const cols = process.stdout.columns || 80;
+    const indent = 4;
+    const maxWidth = Math.max(20, cols - indent);
+    const wrap = (text) => {
+        if (text.length <= maxWidth)
+            return text;
+        const prefix = ' '.repeat(indent);
+        const chunks = [];
+        let rem = text;
+        while (rem.length > maxWidth) {
+            let brk = rem.lastIndexOf(' ', maxWidth);
+            if (brk <= 0)
+                brk = maxWidth;
+            chunks.push(rem.slice(0, brk));
+            rem = rem.slice(brk).trimStart();
+        }
+        if (rem)
+            chunks.push(rem);
+        return chunks.join('\n' + prefix);
+    };
+    const maxVisible = Math.max(2, Math.floor((contentHeight - 3) / 4));
+    const clampedOffset = Math.min(scrollOffset, Math.max(0, players.length - maxVisible));
+    const visiblePlayers = players.slice(clampedOffset, clampedOffset + maxVisible);
+    const children = [];
+    children.push(react_1.default.createElement(Text, { key: 'h', bold: true, color: theme_1.THEME.accent }, `  Ensemble: ${ensemble} (${players.length} player${players.length !== 1 ? 's' : ''})`));
+    if (clampedOffset > 0) {
+        children.push('\n');
+        children.push(react_1.default.createElement(Text, { key: 'sup', color: theme_1.THEME.dim }, `  \u2191 ${clampedOffset} more above`));
+    }
+    for (const p of visiblePlayers) {
+        // Attachment-phase → icon/color lookup (post-#177 Option-B mapping).
+        const icon = icons[(0, format_1.phaseToIconName)(p.phase)];
+        const iconColor = (0, format_1.phaseToColor)(p.phase);
+        const conductor = p.isConductor ? ' \u2605' : '';
+        children.push('\n\n');
+        children.push(react_1.default.createElement(react_1.default.Fragment, { key: `${p.playerId}-1` }, react_1.default.createElement(Text, { color: iconColor }, `  ${icon} `), react_1.default.createElement(Text, { bold: true, color: theme_1.THEME.text }, p.playerId), conductor ? react_1.default.createElement(Text, { color: theme_1.THEME.warning }, conductor) : null));
+        const details = [(0, format_1.phaseToLabel)(p.phase)];
+        if (p.gitBranch)
+            details.push(p.gitBranch);
+        if (p.playerType || p.agentType)
+            details.push(p.playerType || p.agentType || '');
+        children.push('\n');
+        children.push(react_1.default.createElement(Text, { key: `${p.playerId}-2`, color: theme_1.THEME.dim }, `    ${wrap(details.join(' \u00B7 '))}`));
+        if (p.part) {
+            children.push('\n');
+            children.push(react_1.default.createElement(Text, { key: `${p.playerId}-3`, color: theme_1.THEME.textMuted }, `    ${wrap(p.part)}`));
+        }
+    }
+    if (clampedOffset + maxVisible < players.length) {
+        children.push('\n\n');
+        children.push(react_1.default.createElement(Text, { key: 'sdn', color: theme_1.THEME.dim }, `  \u2193 ${players.length - clampedOffset - maxVisible} more below`));
+    }
+    children.push('\n\n');
+    children.push(react_1.default.createElement(Text, { key: 'hint', color: theme_1.THEME.dim }, '  \u2191\u2193 scroll, Esc to dismiss'));
+    return react_1.default.createElement(Text, null, ...children);
+}

package/dist/tui/components/TitleBar.d.ts

@@ -0,0 +1,10 @@
+/**
+ * TitleBar — pinned top bar for the TUI shell.
+ * Renders as a SINGLE Text element (1 Yoga node). Nested Text = ink-virtual-text (0 nodes).
+ */
+import React from 'react';
+export interface TitleBarProps {
+    /** Context text displayed on the right side. */
+    context: string;
+}
+export declare function TitleBar({ context }: TitleBarProps): React.DetailedReactHTMLElement<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>;

package/dist/tui/components/TitleBar.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TitleBar = TitleBar;
+/**
+ * TitleBar — pinned top bar for the TUI shell.
+ * Renders as a SINGLE Text element (1 Yoga node). Nested Text = ink-virtual-text (0 nodes).
+ */
+const react_1 = __importDefault(require("react"));
+const ink_context_1 = require("../ink-context");
+const theme_1 = require("../utils/theme");
+function TitleBar({ context }) {
+    const { Text } = (0, ink_context_1.useInk)();
+    const cols = process.stdout.columns || 80;
+    const left = 'agent-tempo';
+    // Pad between left and right to push context to the right edge
+    const padding = Math.max(1, cols - left.length - context.length - 4); // -4 for paddingX
+    return react_1.default.createElement(Text, null, '  ', react_1.default.createElement(Text, { bold: true, color: theme_1.THEME.accent }, left), ' '.repeat(padding), react_1.default.createElement(Text, { color: theme_1.THEME.dim }, context));
+}

package/dist/tui/components/TopBar.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Top bar — shows ensemble name, player count, and keybindings.
+ */
+import React from 'react';
+export interface TopBarProps {
+    ensemble: string;
+    playerCount: number;
+    connected: boolean;
+}
+export declare function TopBar({ ensemble, playerCount, connected }: TopBarProps): React.FunctionComponentElement<{
+    paddingX: number;
+}>;

package/dist/tui/components/TopBar.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TopBar = TopBar;
+/**
+ * Top bar — shows ensemble name, player count, and keybindings.
+ */
+const react_1 = __importDefault(require("react"));
+const ink_context_1 = require("../ink-context");
+function TopBar({ ensemble, playerCount, connected }) {
+    const { Box, Text, Spacer } = (0, ink_context_1.useInk)();
+    return react_1.default.createElement(Box, { paddingX: 1 }, react_1.default.createElement(Text, { bold: true, color: 'cyan' }, 'claude-tempo'), react_1.default.createElement(Text, null, ' | '), react_1.default.createElement(Text, { color: connected ? 'green' : 'red' }, ensemble), react_1.default.createElement(Text, null, ' | '), react_1.default.createElement(Text, { dimColor: true }, `${playerCount} player${playerCount !== 1 ? 's' : ''}`), react_1.default.createElement(Spacer, null), react_1.default.createElement(Text, { dimColor: true }, 'q: quit  tab: switch panel'));
+}

package/dist/tui/core-api.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Core API for the TUI — wraps Temporal client queries to the Maestro and conductor workflows.
+ * Pure TypeScript, no Ink/React dependency. Used by hooks in the TUI layer.
+ */
+import { Client } from '@temporalio/client';
+import type { MaestroPlayerInfo, MaestroEvent, MaestroPendingCommand, HistoryEntry } from '../types';
+export interface TuiApi {
+    /** Query current player snapshot from Maestro. */
+    getPlayers(): Promise<MaestroPlayerInfo[]>;
+    /** Query event log from Maestro. */
+    getEvents(limit?: number): Promise<MaestroEvent[]>;
+    /** Query pending commands from Maestro. */
+    getPendingCommands(): Promise<MaestroPendingCommand[]>;
+    /** Send a command to the conductor via Maestro's update handler. */
+    sendCommand(text: string, source: string): Promise<string>;
+    /** Query conductor command/report history. */
+    getConductorHistory(): Promise<HistoryEntry[]>;
+    /** Check if Maestro workflow is running. */
+    isConnected(): Promise<boolean>;
+    /** Ensemble name. */
+    ensemble: string;
+}
+/**
+ * Create a TUI API instance bound to a Temporal client and ensemble.
+ */
+export declare function createTuiApi(client: Client, ensemble: string): TuiApi;

package/dist/tui/core-api.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTuiApi = createTuiApi;
+const config_1 = require("../config");
+/**
+ * Create a TUI API instance bound to a Temporal client and ensemble.
+ */
+function createTuiApi(client, ensemble) {
+    const maestroWfId = (0, config_1.maestroWorkflowId)(ensemble);
+    const conductorWfId = (0, config_1.conductorWorkflowId)(ensemble);
+    return {
+        ensemble,
+        async getPlayers() {
+            try {
+                const handle = client.workflow.getHandle(maestroWfId);
+                return await handle.query('maestroPlayers');
+            }
+            catch {
+                return [];
+            }
+        },
+        async getEvents(limit) {
+            try {
+                const handle = client.workflow.getHandle(maestroWfId);
+                const events = await handle.query('maestroEvents');
+                return limit ? events.slice(-limit) : events;
+            }
+            catch {
+                return [];
+            }
+        },
+        async getPendingCommands() {
+            try {
+                const handle = client.workflow.getHandle(maestroWfId);
+                return await handle.query('maestroPendingCommands');
+            }
+            catch {
+                return [];
+            }
+        },
+        async sendCommand(text, source) {
+            const handle = client.workflow.getHandle(maestroWfId);
+            return await handle.executeUpdate('maestroSendCommand', {
+                args: [{ text, source }],
+            });
+        },
+        async getConductorHistory() {
+            try {
+                const handle = client.workflow.getHandle(conductorWfId);
+                return await handle.query('history');
+            }
+            catch {
+                return [];
+            }
+        },
+        async isConnected() {
+            try {
+                const handle = client.workflow.getHandle(maestroWfId);
+                const desc = await handle.describe();
+                return desc.status.name === 'RUNNING';
+            }
+            catch {
+                return false;
+            }
+        },
+    };
+}

package/dist/tui/hooks/useEnsembleDiscovery.d.ts

@@ -0,0 +1,3 @@
+import type { TuiApi } from '../core-api';
+import type { TuiAction } from '../store';
+export declare function useEnsembleDiscovery(api: TuiApi, taskQueue: string, dispatch: React.Dispatch<TuiAction>, enabled: boolean): void;