agent-tempo 1.0.1

package/dist/tui/components/EnsembleListView.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.EnsembleListView = EnsembleListView;
+/**
+ * Ensemble list view — landing screen showing all ensembles.
+ * Arrow keys to navigate, Enter to drill in, q to quit.
+ */
+const react_1 = __importDefault(require("react"));
+const ink_context_1 = require("../ink-context");
+const platform_1 = require("../utils/platform");
+function EnsembleListView({ ensembles, selectedIndex }) {
+    const { Box, Text } = (0, ink_context_1.useInk)();
+    const icons = (0, platform_1.statusIcons)();
+    return react_1.default.createElement(Box, { flexDirection: 'column', padding: 1 }, react_1.default.createElement(Text, { bold: true, color: 'cyan' }, 'claude-tempo ensembles'), react_1.default.createElement(Text, { dimColor: true }, 'Arrow keys to navigate, Enter to open, q to quit\n'), ensembles.length === 0
+        ? react_1.default.createElement(Box, { marginTop: 1 }, react_1.default.createElement(Text, { dimColor: true }, 'No running ensembles found. Start one with `claude-tempo up`.'))
+        : react_1.default.createElement(Box, { flexDirection: 'column' }, 
+        // Header
+        react_1.default.createElement(Box, null, react_1.default.createElement(Text, { bold: true, dimColor: true }, '  Ensemble                 Players  Conductor  Maestro')), 
+        // Rows
+        ...ensembles.map((e, i) => {
+            const selected = i === selectedIndex;
+            const cursor = selected ? icons.arrow : ' ';
+            const conductorIcon = e.conductorOnline ? icons.active : icons.stale;
+            const maestroIcon = e.maestroRunning ? icons.active : icons.stale;
+            const conductorColor = e.conductorOnline ? 'green' : 'gray';
+            const maestroColor = e.maestroRunning ? 'green' : 'gray';
+            return react_1.default.createElement(Box, { key: e.name }, react_1.default.createElement(Text, { color: selected ? 'cyan' : 'white', bold: selected }, `${cursor} ${e.name.padEnd(25)} ${String(e.playerCount).padEnd(9)}`), react_1.default.createElement(Text, { color: conductorColor }, `${conductorIcon}`.padEnd(11)), react_1.default.createElement(Text, { color: maestroColor }, maestroIcon));
+        })));
+}

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

@@ -0,0 +1,12 @@
+/**
+ * Ensemble panel — shows all players with status icons and parts.
+ */
+import React from 'react';
+import type { MaestroPlayerInfo } from '../../types';
+export interface EnsemblePanelProps {
+    players: MaestroPlayerInfo[];
+    maxWidth?: number;
+}
+export declare function EnsemblePanel({ players, maxWidth }: EnsemblePanelProps): React.FunctionComponentElement<{
+    flexDirection: string;
+}>;

package/dist/tui/components/EnsemblePanel.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnsemblePanel = EnsemblePanel;
+/**
+ * Ensemble panel — shows all players with status icons and parts.
+ */
+const react_1 = __importDefault(require("react"));
+const ink_context_1 = require("../ink-context");
+const platform_1 = require("../utils/platform");
+const format_1 = require("../utils/format");
+function EnsemblePanel({ players, maxWidth = 40 }) {
+    const { Box, Text } = (0, ink_context_1.useInk)();
+    const icons = (0, platform_1.statusIcons)();
+    const partMaxLen = Math.max(maxWidth - 25, 10);
+    if (players.length === 0) {
+        return react_1.default.createElement(Box, { flexDirection: 'column' }, react_1.default.createElement(Text, { dimColor: true }, 'No players connected'));
+    }
+    return react_1.default.createElement(Box, { flexDirection: 'column' }, ...players.map((p) => {
+        const icon = p.isConductor ? icons.conductor
+            : p.status === 'active' ? icons.active
+                : p.status === 'stale' ? icons.stale
+                    : p.status === 'pending' ? icons.pending
+                        : p.status === 'blocked' ? icons.blocked
+                            : p.status === 'terminated' ? icons.terminated
+                                : icons.player;
+        const color = p.isConductor ? 'yellow'
+            : p.status === 'active' ? 'green'
+                : p.status === 'stale' ? 'gray'
+                    : p.status === 'blocked' ? 'red'
+                        : p.status === 'pending' ? 'cyan'
+                            : 'white';
+        const typeSuffix = p.playerType ? ` (${p.playerType})` : '';
+        const name = `${p.playerId}${typeSuffix}`;
+        const part = (0, format_1.truncate)(p.part, partMaxLen);
+        return react_1.default.createElement(Box, { key: p.playerId, flexDirection: 'column' }, react_1.default.createElement(Box, null, react_1.default.createElement(Text, { color }, `${icon} `), react_1.default.createElement(Text, { bold: true, color }, name)), react_1.default.createElement(Text, { dimColor: true }, `  ${part}`));
+    }));
+}

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

@@ -0,0 +1,31 @@
+/**
+ * ErrorView — connection failure screen with troubleshooting.
+ *
+ * Performance: Single <Text> root with nested virtual-text children.
+ * Zero Yoga <Box> nodes — follows the pattern from StatusOverlay/ConversationStream.
+ */
+import React from 'react';
+export interface ErrorCheck {
+    label: string;
+    passed: boolean;
+    detail?: string;
+}
+export interface ErrorViewProps {
+    version: string;
+    checks: ErrorCheck[];
+    /** Error detail text (e.g., "Connection refused (ECONNREFUSED)"). */
+    errorDetail?: string;
+    /** Whether auto-retry is active. */
+    retrying?: boolean;
+    /** Seconds until next retry. */
+    retryIn?: number;
+    /** Current retry attempt number. */
+    retryAttempt?: number;
+    /** Max retry attempts. */
+    retryMax?: number;
+    /** Called when user presses 'r' to retry. */
+    onRetry?: () => void;
+    /** Called when user presses 'q' to quit. */
+    onQuit?: () => void;
+}
+export declare function ErrorView({ version, checks, retrying, retryIn, retryAttempt, retryMax, onRetry, onQuit, }: ErrorViewProps): React.CElement<{}, React.Component<{}, any, any>>;

package/dist/tui/components/ErrorView.js

@@ -0,0 +1,129 @@
+"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.ErrorView = ErrorView;
+/**
+ * ErrorView — connection failure screen with troubleshooting.
+ *
+ * Performance: Single <Text> root with nested virtual-text children.
+ * Zero Yoga <Box> nodes — follows the pattern from StatusOverlay/ConversationStream.
+ */
+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");
+function ErrorView({ version, checks, retrying, retryIn, retryAttempt, retryMax, onRetry, onQuit, }) {
+    const { Text, useInput } = (0, ink_context_1.useInk)();
+    // Wire up keybindings
+    useInput((0, react_1.useCallback)((input) => {
+        if (input === 'r' && onRetry)
+            onRetry();
+        if (input === 'q' && onQuit)
+            onQuit();
+    }, [onRetry, onQuit]));
+    const children = [];
+    // Static metronome — always center frame (index 1), rendered dim
+    const brailleFrames = (0, platform_1.metronomeBrailleFrames)();
+    const staticFrame = brailleFrames[1];
+    for (let i = 0; i < staticFrame.length; i++) {
+        if (i > 0)
+            children.push('\n');
+        children.push(react_1.default.createElement(react_1.default.Fragment, { key: `m-${i}` }, ...staticFrame[i].map((seg, j) => react_1.default.createElement(Text, { key: j, color: theme_1.THEME.dim }, seg.char))));
+    }
+    // Title
+    children.push('\n\n');
+    children.push(react_1.default.createElement(Text, { key: 'title', bold: true, color: theme_1.THEME.accent }, '  agent-tempo'));
+    children.push('\n');
+    children.push(react_1.default.createElement(Text, { key: 'sub', color: theme_1.THEME.dim }, '  Multi-session orchestration via Temporal'));
+    children.push('\n');
+    children.push(react_1.default.createElement(Text, { key: 'ver', color: theme_1.THEME.muted }, `  v${version}`));
+    // Error header
+    children.push('\n\n');
+    children.push(react_1.default.createElement(Text, { key: 'err', bold: true, color: theme_1.THEME.error }, '  \u26A0 Connection Failed'));
+    // Checklist
+    children.push('\n');
+    for (let i = 0; i < checks.length; i++) {
+        const check = checks[i];
+        children.push('\n');
+        children.push(react_1.default.createElement(Text, { key: `c-${i}`, color: check.passed ? theme_1.THEME.success : theme_1.THEME.error }, `  ${check.passed ? '\u2713' : '\u2717'} ${check.label}`));
+        if (check.detail && !check.passed) {
+            children.push('\n');
+            children.push(react_1.default.createElement(Text, { key: `cd-${i}`, color: theme_1.THEME.dim }, `    ${check.detail}`));
+        }
+    }
+    // Troubleshooting box (text-based border)
+    const boxWidth = 56;
+    const hLine = '\u2500'.repeat(boxWidth);
+    children.push('\n\n');
+    children.push(react_1.default.createElement(Text, { key: 'bt', color: theme_1.THEME.dim }, `  \u250C${hLine}\u2510`));
+    children.push('\n');
+    children.push(react_1.default.createElement(Text, { key: 'bh', bold: true, color: theme_1.THEME.warning }, '  \u2502  Troubleshooting'));
+    children.push(react_1.default.createElement(Text, { key: 'bh2', color: theme_1.THEME.dim }, ' '.repeat(boxWidth - 17) + '\u2502'));
+    children.push('\n');
+    children.push(react_1.default.createElement(Text, { key: 'bs', color: theme_1.THEME.dim }, `  \u2502${' '.repeat(boxWidth)}\u2502`));
+    const steps = [
+        { label: '1. Start the Temporal dev server:', cmd: '   $ temporal server start-dev' },
+        { label: '2. Or specify a custom address:', cmd: '   $ TEMPORAL_ADDRESS=host:7233 agent-tempo' },
+        { label: '3. Check if Temporal is running:', cmd: '   $ temporal operator cluster health' },
+    ];
+    for (let i = 0; i < steps.length; i++) {
+        const s = steps[i];
+        const pad1 = ' '.repeat(Math.max(0, boxWidth - s.label.length - 2));
+        const pad2 = ' '.repeat(Math.max(0, boxWidth - s.cmd.length - 2));
+        children.push('\n');
+        children.push(react_1.default.createElement(Text, { key: `s${i}a`, color: theme_1.THEME.text }, `  \u2502  ${s.label}`));
+        children.push(react_1.default.createElement(Text, { key: `s${i}ap`, color: theme_1.THEME.dim }, `${pad1}\u2502`));
+        children.push('\n');
+        children.push(react_1.default.createElement(Text, { key: `s${i}b`, color: theme_1.THEME.accent }, `  \u2502  ${s.cmd}`));
+        children.push(react_1.default.createElement(Text, { key: `s${i}bp`, color: theme_1.THEME.dim }, `${pad2}\u2502`));
+    }
+    children.push('\n');
+    children.push(react_1.default.createElement(Text, { key: 'be', color: theme_1.THEME.dim }, `  \u2502${' '.repeat(boxWidth)}\u2502`));
+    const docsUrl = 'Docs: https://github.com/vinceblank/agent-tempo#setup';
+    const docsPad = ' '.repeat(Math.max(0, boxWidth - docsUrl.length - 2));
+    children.push('\n');
+    children.push(react_1.default.createElement(Text, { key: 'bd', color: theme_1.THEME.dim }, `  \u2502  ${docsUrl}${docsPad}\u2502`));
+    children.push('\n');
+    children.push(react_1.default.createElement(Text, { key: 'bb', color: theme_1.THEME.dim }, `  \u2514${hLine}\u2518`));
+    // Retry progress
+    if (retrying) {
+        children.push('\n\n');
+        children.push(react_1.default.createElement(Text, { key: 'retry', color: theme_1.THEME.dim }, `  Retrying in ${retryIn ?? '?'}s... (attempt ${retryAttempt ?? '?'}/${retryMax ?? 5})`));
+    }
+    // Keybindings
+    children.push('\n\n');
+    children.push(react_1.default.createElement(Text, { key: 'keys', color: theme_1.THEME.dim }, '  [r] retry now    [q] quit    [?] help'));
+    return react_1.default.createElement(Text, null, ...children);
+}

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

@@ -0,0 +1,54 @@
+/**
+ * HomeView — three-list landing surface (Online / Paused / Offline). Polls
+ * `listEnsembles` every 10s; `r` forces an immediate refresh.
+ *
+ * Offline rows whose ensemble name matches the cwd's git-root basename are
+ * pinned to the top of the offline list with a `⬡` badge — the visual
+ * affordance for "press Enter to restore the ensemble you created here".
+ * Online and Paused rows are not cwd-pinned — entering them is a no-op
+ * navigation, not a restore that needs a per-cwd hint.
+ */
+import React from 'react';
+import type { BootstrapBadges } from '../bootstrap-types';
+import type { EnsembleSummary, TempoClient } from '../../client';
+/**
+ * Initial snapshot — structurally a subset of `BootstrapResult` so callers
+ * can pass the full bootstrap result directly.
+ */
+export interface HomeViewInitial {
+    ensembles: EnsembleSummary[];
+    cwdGitRoot: string | null;
+    badges: BootstrapBadges;
+}
+export interface HomeViewProps {
+    initial: HomeViewInitial;
+    client: TempoClient;
+    onEnterEnsemble: (name: string) => void;
+    onCreateEnsemble: () => void;
+    onLoadLineup: () => void;
+    onRestoreEnsemble: (name: string) => void;
+    onQuit: () => void;
+}
+interface SortedLists {
+    online: EnsembleSummary[];
+    paused: EnsembleSummary[];
+    offline: EnsembleSummary[];
+    /**
+     * Flat sequence used for keyboard navigation. Order matches render
+     * order: Online → Paused → Offline (cwd-match offline rows first).
+     */
+    flat: Array<{
+        ensemble: EnsembleSummary;
+        isCwdMatch: boolean;
+    }>;
+    /** Count of cwd-matched offline ensembles pinned at the top of the offline list. */
+    cwdMatchCount: number;
+}
+/**
+ * Split + sort ensembles into Online / Paused / Offline lists with
+ * cwd-match rows pinned to the top of the Offline list. Pure function for
+ * testability.
+ */
+export declare function partitionEnsembles(ensembles: readonly EnsembleSummary[], cwdGitRoot: string | null, cwdMatcher?: (ensemble: EnsembleSummary, gitRoot: string) => boolean): SortedLists;
+export declare function HomeView(props: HomeViewProps): React.ReactElement;
+export {};

package/dist/tui/components/HomeView.js

@@ -0,0 +1,306 @@
+"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.partitionEnsembles = partitionEnsembles;
+exports.HomeView = HomeView;
+/**
+ * HomeView — three-list landing surface (Online / Paused / Offline). Polls
+ * `listEnsembles` every 10s; `r` forces an immediate refresh.
+ *
+ * Offline rows whose ensemble name matches the cwd's git-root basename are
+ * pinned to the top of the offline list with a `⬡` badge — the visual
+ * affordance for "press Enter to restore the ensemble you created here".
+ * Online and Paused rows are not cwd-pinned — entering them is a no-op
+ * navigation, not a restore that needs a per-cwd hint.
+ */
+const react_1 = __importStar(require("react"));
+const ink_context_1 = require("../ink-context");
+const theme_1 = require("../utils/theme");
+const platform_1 = require("../utils/platform");
+const REFRESH_INTERVAL_MS = 10_000;
+/**
+ * Split + sort ensembles into Online / Paused / Offline lists with
+ * cwd-match rows pinned to the top of the Offline list. Pure function for
+ * testability.
+ */
+function partitionEnsembles(ensembles, cwdGitRoot, cwdMatcher = defaultCwdMatcher) {
+    const online = [];
+    const paused = [];
+    const offlineMatch = [];
+    const offlineOther = [];
+    for (const e of ensembles) {
+        if (e.state === 'online') {
+            online.push(e);
+        }
+        else if (e.state === 'paused') {
+            paused.push(e);
+        }
+        else if (e.state === 'offline') {
+            if (cwdGitRoot && cwdMatcher(e, cwdGitRoot))
+                offlineMatch.push(e);
+            else
+                offlineOther.push(e);
+        }
+    }
+    // Alphabetical — recency-desc will replace this once `lastActivityAt` is
+    // threaded through `EnsembleSummary`.
+    online.sort((a, b) => a.name.localeCompare(b.name));
+    paused.sort((a, b) => a.name.localeCompare(b.name));
+    offlineMatch.sort((a, b) => a.name.localeCompare(b.name));
+    offlineOther.sort((a, b) => a.name.localeCompare(b.name));
+    const offline = [...offlineMatch, ...offlineOther];
+    const flat = [
+        ...online.map((ensemble) => ({ ensemble, isCwdMatch: false })),
+        ...paused.map((ensemble) => ({ ensemble, isCwdMatch: false })),
+        ...offlineMatch.map((ensemble) => ({ ensemble, isCwdMatch: true })),
+        ...offlineOther.map((ensemble) => ({ ensemble, isCwdMatch: false })),
+    ];
+    return { online, paused, offline, flat, cwdMatchCount: offlineMatch.length };
+}
+/**
+ * Shallow equality over the fields HomeView renders. Keeps the 10s poll
+ * from thrashing referential identity when the backend snapshot is
+ * unchanged.
+ */
+function ensemblesEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        const x = a[i];
+        const y = b[i];
+        if (x.name !== y.name || x.state !== y.state
+            || x.playerCount !== y.playerCount
+            || x.hasConductor !== y.hasConductor
+            || x.conductorStatus !== y.conductorStatus)
+            return false;
+    }
+    return true;
+}
+/** Matches the `agent-tempo up` default: ensemble named after the repo root. */
+function defaultCwdMatcher(ensemble, gitRoot) {
+    const basename = gitRoot.split(/[\\/]/).filter(Boolean).pop() ?? '';
+    return basename.length > 0 && ensemble.name === basename;
+}
+function HomeView(props) {
+    const { initial, client, onEnterEnsemble, onCreateEnsemble, onLoadLineup, onRestoreEnsemble, onQuit, } = props;
+    const { Box, Text, useInput } = (0, ink_context_1.useInk)();
+    const [ensembles, setEnsembles] = (0, react_1.useState)(initial.ensembles);
+    const [selectedIdx, setSelectedIdx] = (0, react_1.useState)(0);
+    const [refreshing, setRefreshing] = (0, react_1.useState)(false);
+    const [error, setError] = (0, react_1.useState)(null);
+    // #306: Track whether the first refresh has completed so the empty state
+    // doesn't flash "No ensembles yet" before the discovery query returns.
+    // Bootstrap may pass a stale or empty `initial.ensembles`; only after the
+    // mount-time refresh do we trust an empty list as "really empty."
+    const [firstRefreshDone, setFirstRefreshDone] = (0, react_1.useState)(initial.ensembles.length > 0);
+    const lists = (0, react_1.useMemo)(() => partitionEnsembles(ensembles, initial.cwdGitRoot), [ensembles, initial.cwdGitRoot]);
+    // Clamp selection whenever the list shrinks underneath the cursor.
+    (0, react_1.useEffect)(() => {
+        if (selectedIdx >= lists.flat.length) {
+            setSelectedIdx(Math.max(0, lists.flat.length - 1));
+        }
+    }, [lists.flat.length, selectedIdx]);
+    // Debounced refresh: setInterval fires every 10s; `r` key calls refresh()
+    // immediately. In-flight refreshes short-circuit via `refreshing` flag so
+    // a slow query doesn't stack behind a fast one.
+    const refreshingRef = (0, react_1.useRef)(false);
+    const refresh = (0, react_1.useCallback)(async () => {
+        if (refreshingRef.current)
+            return;
+        refreshingRef.current = true;
+        setRefreshing(true);
+        try {
+            const next = await client.listEnsembles();
+            // Identity-stable: skip the setState when the 10s poll returns an
+            // equivalent snapshot (common case on an idle host), so HomeView's
+            // memoized `partitionEnsembles` result doesn't re-compute.
+            setEnsembles((prev) => ensemblesEqual(prev, next) ? prev : next);
+            setError(null);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : String(err));
+        }
+        finally {
+            refreshingRef.current = false;
+            setRefreshing(false);
+            setFirstRefreshDone(true);
+        }
+    }, [client]);
+    (0, react_1.useEffect)(() => {
+        // #306: Kick an immediate refresh on mount so the user doesn't see
+        // "No ensembles yet" while waiting for the 10s polling timer's first
+        // tick. The timer continues polling at the regular cadence after.
+        refresh();
+        const timer = setInterval(refresh, REFRESH_INTERVAL_MS);
+        return () => clearInterval(timer);
+    }, [refresh]);
+    useInput((0, react_1.useCallback)((input, key) => {
+        const total = lists.flat.length;
+        if (key.upArrow && total > 0) {
+            setSelectedIdx((i) => Math.max(0, i - 1));
+            return;
+        }
+        if (key.downArrow && total > 0) {
+            setSelectedIdx((i) => Math.min(total - 1, i + 1));
+            return;
+        }
+        if (key.return && total > 0) {
+            const row = lists.flat[selectedIdx];
+            if (!row)
+                return;
+            // Online + Paused both navigate into the ensemble — paused ensembles
+            // are signal-paused but their workflows are alive and the user can
+            // run `/play` from inside. Offline requires the full restore path.
+            if (row.ensemble.state === 'online' || row.ensemble.state === 'paused') {
+                onEnterEnsemble(row.ensemble.name);
+            }
+            else if (row.ensemble.state === 'offline') {
+                onRestoreEnsemble(row.ensemble.name);
+            }
+            return;
+        }
+        if (input === 'n' || input === 'N') {
+            onCreateEnsemble();
+            return;
+        }
+        if (input === 'l' || input === 'L') {
+            onLoadLineup();
+            return;
+        }
+        if (input === 'r' || input === 'R') {
+            void refresh();
+            return;
+        }
+        if (input === 'q' || input === 'Q') {
+            onQuit();
+            return;
+        }
+    }, [lists.flat, selectedIdx, onEnterEnsemble, onRestoreEnsemble, onCreateEnsemble, onLoadLineup, onQuit, refresh]));
+    return renderBody({
+        Box, Text,
+        lists, selectedIdx,
+        refreshing, error,
+        badges: initial.badges,
+        firstRefreshDone,
+    });
+}
+function renderBody(props) {
+    const { Box, Text, lists, selectedIdx, refreshing, error, badges, firstRefreshDone } = props;
+    const icons = (0, platform_1.statusIcons)((0, platform_1.supportsUnicode)());
+    const isEmpty = lists.flat.length === 0;
+    const header = react_1.default.createElement(Text, { bold: true, color: theme_1.THEME.accent, key: 'home-header' }, ' agent-tempo');
+    const statusLine = react_1.default.createElement(Text, { key: 'home-status', color: theme_1.THEME.dim }, `  N new · L lineup · ↵ enter/restore · r refresh${refreshing ? ' …' : ''} · Q quit`);
+    const children = [header, statusLine, ...renderBadges(Text, badges)];
+    if (error) {
+        children.push(react_1.default.createElement(Text, { key: 'home-err', color: theme_1.THEME.error }, `  refresh failed: ${error}`));
+    }
+    if (isEmpty) {
+        // #306: Until the first refresh completes, show a loading state instead
+        // of "No ensembles yet" — bootstrap may pass an empty initial list while
+        // discovery is in flight, and flashing the "no ensembles" copy is jarring.
+        children.push(react_1.default.createElement(Box, { key: 'home-empty', marginTop: 1 }, firstRefreshDone
+            ? react_1.default.createElement(Text, { color: theme_1.THEME.dim }, '  No ensembles yet. Press ', react_1.default.createElement(Text, { bold: true, color: theme_1.THEME.text }, 'N'), ' to create one, or ', react_1.default.createElement(Text, { bold: true, color: theme_1.THEME.text }, 'L'), ' to load a lineup.')
+            : react_1.default.createElement(Text, { color: theme_1.THEME.dim }, '  Loading ensembles …')));
+    }
+    else {
+        // Three sections in priority order: Online → Paused → Offline.
+        // Each section's header is skipped when the section is empty so the
+        // landing page stays compact on a fresh ensemble (no "Paused (none)"
+        // / "Offline (none)" noise). Cursor offsets must mirror the flat
+        // sequence built by `partitionEnsembles`.
+        let cursorOffset = 0;
+        if (lists.online.length > 0) {
+            const start = cursorOffset;
+            children.push(react_1.default.createElement(Box, { key: 'home-online', marginTop: 1, flexDirection: 'column' }, react_1.default.createElement(Text, { bold: true, color: theme_1.THEME.text }, ' Online'), ...lists.online.map((e, i) => renderRow({
+                Text, key: `online-${e.name}`, icons,
+                ensemble: e,
+                selected: (start + i) === selectedIdx,
+                isCwdMatch: false,
+            }))));
+            cursorOffset += lists.online.length;
+        }
+        if (lists.paused.length > 0) {
+            const start = cursorOffset;
+            children.push(react_1.default.createElement(Box, { key: 'home-paused', marginTop: 1, flexDirection: 'column' }, react_1.default.createElement(Text, { bold: true, color: theme_1.THEME.text }, ' Paused'), ...lists.paused.map((e, i) => renderRow({
+                Text, key: `paused-${e.name}`, icons,
+                ensemble: e,
+                selected: (start + i) === selectedIdx,
+                isCwdMatch: false,
+            }))));
+            cursorOffset += lists.paused.length;
+        }
+        if (lists.offline.length > 0) {
+            const start = cursorOffset;
+            children.push(react_1.default.createElement(Box, { key: 'home-offline', marginTop: 1, flexDirection: 'column' }, react_1.default.createElement(Text, { bold: true, color: theme_1.THEME.text }, ' Offline'), ...lists.offline.map((e, i) => renderRow({
+                Text, key: `offline-${e.name}`, icons,
+                ensemble: e,
+                selected: (start + i) === selectedIdx,
+                isCwdMatch: i < lists.cwdMatchCount,
+            }))));
+        }
+    }
+    return react_1.default.createElement(Box, { flexDirection: 'column' }, ...children);
+}
+function renderRow({ Text, key, icons, ensemble, selected, isCwdMatch }) {
+    const cursor = selected ? '\u276F' : ' ';
+    // Online uses the active glyph; paused + offline both use the stale
+    // glyph (no live attachment activity). Color disambiguates: warning
+    // for paused (transient, fast resume via /play) vs dim for offline
+    // (needs /restore to come back).
+    const glyph = ensemble.state === 'online' ? icons.active : icons.stale;
+    const glyphColor = ensemble.state === 'online' ? theme_1.THEME.success
+        : ensemble.state === 'paused' ? theme_1.THEME.warning
+            : theme_1.THEME.dim;
+    const cwdBadge = isCwdMatch ? '\u2B21 ' : '';
+    const playerSuffix = ` (${ensemble.playerCount} player${ensemble.playerCount === 1 ? '' : 's'})`;
+    return react_1.default.createElement(Text, { key, color: selected ? theme_1.THEME.text : theme_1.THEME.textMuted }, ` ${cursor} `, react_1.default.createElement(Text, { color: glyphColor }, `${glyph} `), isCwdMatch
+        ? react_1.default.createElement(Text, { color: theme_1.THEME.accent, bold: true }, cwdBadge)
+        : null, react_1.default.createElement(Text, { bold: selected, color: selected ? theme_1.THEME.text : theme_1.THEME.textMuted }, ensemble.name), react_1.default.createElement(Text, { color: theme_1.THEME.dim }, playerSuffix));
+}
+function renderBadges(Text, badges) {
+    const parts = [];
+    if (badges.orphanCount > 0) {
+        parts.push(react_1.default.createElement(Text, { key: 'b-orph', color: theme_1.THEME.warning }, `  ${badges.orphanCount} orphan${badges.orphanCount === 1 ? '' : 's'} on this host`));
+    }
+    if (badges.daemonLogErrors && badges.daemonLogErrors.count > 0) {
+        parts.push(react_1.default.createElement(Text, { key: 'b-log', color: theme_1.THEME.error }, `  daemon log: ${badges.daemonLogErrors.count} recent error${badges.daemonLogErrors.count === 1 ? '' : 's'}`));
+    }
+    if (badges.outdatedVersion) {
+        parts.push(react_1.default.createElement(Text, { key: 'b-ver', color: theme_1.THEME.warning }, `  upgrade available: v${badges.outdatedVersion.latest} (${badges.outdatedVersion.severity})`));
+    }
+    return parts;
+}

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

@@ -0,0 +1,13 @@
+/**
+ * Input bar — text input for sending commands to the conductor.
+ */
+import React from 'react';
+export interface InputBarProps {
+    onSubmit: (text: string) => void;
+    sending: boolean;
+    error: string | null;
+    placeholder?: string;
+}
+export declare function InputBar({ onSubmit, sending, error, placeholder }: InputBarProps): React.FunctionComponentElement<{
+    flexDirection: string;
+}>;