agent-tempo 1.0.1

package/dist/tui/hooks/useEnsembleDiscovery.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useEnsembleDiscovery = useEnsembleDiscovery;
+/**
+ * Hook that polls for all running ensembles across the Temporal namespace.
+ * Used by the ensemble list view.
+ */
+const react_1 = require("react");
+const DISCOVERY_INTERVAL_MS = 5000;
+function useEnsembleDiscovery(api, taskQueue, dispatch, enabled) {
+    const apiRef = (0, react_1.useRef)(api);
+    apiRef.current = api;
+    (0, react_1.useEffect)(() => {
+        if (!enabled)
+            return;
+        const poll = async () => {
+            try {
+                const ensembles = await apiRef.current.discoverEnsembles(taskQueue);
+                dispatch({ type: 'DISCOVER_ENSEMBLES', ensembles });
+            }
+            catch {
+                // Silently skip failed polls
+            }
+        };
+        // Initial poll
+        poll();
+        const interval = setInterval(poll, DISCOVERY_INTERVAL_MS);
+        return () => clearInterval(interval);
+    }, [taskQueue, dispatch, enabled]);
+}

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

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

package/dist/tui/hooks/useMaestroPoller.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMaestroPoller = useMaestroPoller;
+/**
+ * Hook that polls the Maestro workflow for player state and events.
+ * Dispatches REFRESH_ALL on each successful poll.
+ */
+const react_1 = require("react");
+const platform_1 = require("../utils/platform");
+/** 3s for local terminals, 5s over SSH to reduce latency impact. */
+const POLL_INTERVAL_MS = (0, platform_1.isSSH)() ? 5000 : 3000;
+function useMaestroPoller(api, dispatch, enabled) {
+    const apiRef = (0, react_1.useRef)(api);
+    apiRef.current = api;
+    (0, react_1.useEffect)(() => {
+        if (!enabled)
+            return;
+        const poll = async () => {
+            try {
+                const [players, events, history] = await Promise.all([
+                    apiRef.current.getPlayers(),
+                    apiRef.current.getEvents(50),
+                    apiRef.current.getConductorHistory(),
+                ]);
+                dispatch({ type: 'REFRESH_ALL', players, events, history });
+            }
+            catch {
+                // Silently skip failed polls
+            }
+        };
+        // Initial poll
+        poll();
+        const interval = setInterval(poll, POLL_INTERVAL_MS);
+        return () => clearInterval(interval);
+    }, [dispatch, enabled]);
+}

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

@@ -0,0 +1,7 @@
+import type { TuiApi } from '../core-api';
+export interface SendCommandResult {
+    sending: boolean;
+    error: string | null;
+    send: (text: string) => Promise<void>;
+}
+export declare function useSendCommand(api: TuiApi): SendCommandResult;

package/dist/tui/hooks/useSendCommand.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSendCommand = useSendCommand;
+/**
+ * Hook for sending commands to the conductor via the Maestro workflow.
+ */
+const react_1 = require("react");
+function useSendCommand(api) {
+    const [sending, setSending] = (0, react_1.useState)(false);
+    const [error, setError] = (0, react_1.useState)(null);
+    const apiRef = (0, react_1.useRef)(api);
+    apiRef.current = api;
+    const send = (0, react_1.useCallback)(async (text) => {
+        if (!text.trim())
+            return;
+        setSending(true);
+        setError(null);
+        try {
+            await apiRef.current.sendCommand(text.trim(), 'tui');
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : String(err));
+        }
+        finally {
+            setSending(false);
+        }
+    }, []);
+    return { sending, error, send };
+}

package/dist/tui/index.d.ts

@@ -0,0 +1,15 @@
+import { Config } from '../config';
+import type { BootstrapResult } from '../cli/startup';
+export interface TuiOpts {
+    config: Config;
+    /** If provided, start in single-ensemble view. If omitted, start in home (multi-ensemble) view. */
+    ensemble?: string;
+    /**
+     * #289: pre-computed bootstrap result fed in from the CLI default path.
+     * When present, the TUI skips its own daemon/connection probing and
+     * hands the result straight to HomeView as initial props (S5 / #290).
+     * Absent for the subcommand paths that don't run bootstrap.
+     */
+    bootstrap?: BootstrapResult;
+}
+export declare function run(opts: TuiOpts): Promise<void>;

package/dist/tui/index.js

@@ -0,0 +1,156 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+/**
+ * TUI entry point — runs preflight checks, dynamically loads ink (ESM), and renders the app.
+ * Called from the CLI command via: const { run } = await import('../tui/index.js');
+ */
+const react_1 = __importDefault(require("react"));
+const client_1 = require("@temporalio/client");
+const connection_1 = require("../connection");
+const client_2 = require("../client");
+const ink_loader_1 = require("./ink-loader");
+const ink_context_1 = require("./ink-context");
+const App_1 = require("./App");
+const platform_1 = require("./utils/platform");
+const fullscreen_1 = require("./utils/fullscreen");
+const daemon_1 = require("../cli/daemon");
+async function run(opts) {
+    // Check terminal size
+    if (!(0, platform_1.isTerminalLargeEnough)()) {
+        console.error(`Terminal too small (minimum ${platform_1.MIN_COLUMNS}x${platform_1.MIN_ROWS}). ` +
+            `Current: ${process.stdout.columns || '?'}x${process.stdout.rows || '?'}`);
+        process.exit(1);
+    }
+    // ── Preflight: Ensure daemon is running ──
+    if (!(0, daemon_1.isDaemonRunning)()) {
+        try {
+            console.error('Starting worker daemon...');
+            await (0, daemon_1.startDaemon)(opts.config);
+        }
+        catch (err) {
+            console.error(`Warning: could not start daemon: ${err.message || err}`);
+            // Continue anyway — Temporal connection will fail gracefully in the splash
+        }
+    }
+    // Load ink dynamically (ESM)
+    const ink = await (0, ink_loader_1.loadInk)();
+    // ── Connect to Temporal (with timeout, graceful failure) ──
+    let connection;
+    try {
+        connection = await Promise.race([
+            (0, connection_1.createTemporalConnection)(opts.config),
+            new Promise((_, reject) => setTimeout(() => reject(new Error(`timeout connecting to ${opts.config.temporalAddress}`)), 5000)),
+        ]);
+    }
+    catch (err) {
+        // Don't crash — let the TUI show the ErrorView with diagnostics
+        console.error(`Warning: ${err instanceof Error ? err.message : err}`);
+        console.error('The TUI will show connection troubleshooting.');
+    }
+    // Enter fullscreen (alternate screen buffer)
+    const isFullscreen = (0, fullscreen_1.enterFullscreen)();
+    if (isFullscreen) {
+        (0, fullscreen_1.registerFullscreenCleanup)();
+    }
+    try {
+        let api;
+        if (connection) {
+            const client = new client_1.Client({ connection, namespace: opts.config.temporalNamespace });
+            // #437 — pass the resolved task queue so the TUI's `/hosts` slash
+            // command (and any future `listHosts` consumer) finds the right
+            // pollers in dev mode. Without it, dev-mode TUI silently shows zero
+            // hosts even with a healthy dev daemon.
+            api = (0, client_2.createTempoClient)(client, { taskQueue: opts.config.taskQueue });
+        }
+        else {
+            // Create a dummy client that returns empty/false for everything
+            // The splash will transition to ErrorView
+            api = createDummyClient();
+        }
+        // Render the TUI
+        const app = ink.render(
+        // The TUI recruit wizard only offers `claude` / `copilot` — `mock` is
+        // a dev-mode CLI-only path (ADR 0014 §7 gate 3); `claude-api` (#131),
+        // `opencode` (#449), and `claude-code-headless` (#520) are CLI/MCP-only
+        // paths. If the user's resolved default is one of those, fall back to
+        // `claude` for the TUI default; they can still recruit those agents
+        // via the CLI (e.g. `agent-tempo recruit ... --agent opencode`) or
+        // the MCP `recruit` tool.
+        react_1.default.createElement(ink_context_1.InkProvider, { ink, children: react_1.default.createElement(App_1.App, { api, ensemble: opts.ensemble, defaultAgent: (opts.config.defaultAgent === 'mock' || opts.config.defaultAgent === 'claude-api' || opts.config.defaultAgent === 'opencode' || opts.config.defaultAgent === 'claude-code-headless') ? 'claude' : opts.config.defaultAgent }) }));
+        await app.waitUntilExit();
+    }
+    finally {
+        if (isFullscreen) {
+            (0, fullscreen_1.exitFullscreen)();
+        }
+        if (connection) {
+            await connection.close();
+        }
+    }
+}
+/** Dummy TempoClient for when Temporal connection fails — returns empty data. */
+function createDummyClient() {
+    const fail = () => Promise.reject(new Error('Not connected to Temporal'));
+    return {
+        discoverEnsembles: async () => [],
+        listEnsembles: async () => [],
+        listEnsemblesBounded: async () => ({ items: [], timedOut: false, scanned: 0 }),
+        createEnsemble: fail,
+        spawnConductor: fail,
+        getPlayers: async () => [],
+        // Issue #399 W1/W2 wire-extension methods — return sentinel defaults
+        // matching `getEnsembleMeta` / `getPlayerWireMeta` soft-fail shapes
+        // so the dashboard renders `—` placeholders without crashing.
+        getEnsembleMeta: async () => ({ description: '', startedAt: '', currentBpm: 0, tempoSeries: [] }),
+        getPlayerWireMeta: async () => null,
+        getMessages: async () => [],
+        getConductorHistory: async () => [],
+        getPlayerMessages: async () => [],
+        getPlayerMetadata: async () => null,
+        sendCommand: fail,
+        sendMessage: fail,
+        terminatePlayer: fail,
+        // PR-D verbs — all fail in offline dummy mode.
+        recruit: fail,
+        release: fail,
+        restart: fail,
+        detach: fail,
+        destroy: fail,
+        migrate: fail,
+        attachmentInfo: fail,
+        recall: fail,
+        listHosts: async () => [],
+        disbandEnsemble: fail,
+        // #287 ensemble-scope verbs — same offline fail-fast shape.
+        pause: fail,
+        play: fail,
+        shutdown: fail,
+        restore: fail,
+        isConnected: async () => false,
+        hasGlobalMaestro: async () => false,
+        getSchedules: async () => [],
+        cancelSchedule: fail,
+        getEnsembleChat: async () => ({ messages: [], total: 0, hasMore: false, hasConductor: false }),
+        isMaestroPaused: async () => false,
+        isAnySessionHeld: async () => false,
+        getGates: async () => [],
+        getStages: async () => [],
+        getWorktrees: async () => [],
+        ensureMaestroSession: fail,
+        sendAsMaestro: fail,
+        getMaestroMessages: async () => ({ received: [], sent: [] }),
+        // PR-3 (#94/#95): SSE subscribe stub — yields nothing and completes
+        // immediately so a `for await` loop on the offline dummy doesn't hang.
+        subscribe: () => ({
+            [Symbol.asyncIterator]() {
+                return {
+                    next: () => Promise.resolve({ value: undefined, done: true }),
+                };
+            },
+        }),
+    };
+}

package/dist/tui/ink-context.d.ts

@@ -0,0 +1,18 @@
+/**
+ * React context for Ink components.
+ *
+ * Since ink is ESM-only and our project is CJS, ink components are
+ * dynamically loaded at startup and provided via context. Components
+ * use the useInk() hook to access Box, Text, etc.
+ */
+import React from 'react';
+import type { InkExports } from './ink-loader';
+export declare function InkProvider({ ink, children }: {
+    ink: InkExports;
+    children: React.ReactNode;
+}): React.FunctionComponentElement<React.ProviderProps<InkExports | null>>;
+/**
+ * Access dynamically-loaded Ink components.
+ * Must be called inside an InkProvider.
+ */
+export declare function useInk(): InkExports;

package/dist/tui/ink-context.js

@@ -0,0 +1,59 @@
+"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.InkProvider = InkProvider;
+exports.useInk = useInk;
+/**
+ * React context for Ink components.
+ *
+ * Since ink is ESM-only and our project is CJS, ink components are
+ * dynamically loaded at startup and provided via context. Components
+ * use the useInk() hook to access Box, Text, etc.
+ */
+const react_1 = __importStar(require("react"));
+const InkContext = (0, react_1.createContext)(null);
+function InkProvider({ ink, children }) {
+    return react_1.default.createElement(InkContext.Provider, { value: ink }, children);
+}
+/**
+ * Access dynamically-loaded Ink components.
+ * Must be called inside an InkProvider.
+ */
+function useInk() {
+    const ctx = (0, react_1.useContext)(InkContext);
+    if (!ctx)
+        throw new Error('useInk() must be used inside InkProvider');
+    return ctx;
+}

package/dist/tui/ink-loader.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Dynamic loader for ink — bridges CJS to ESM.
+ *
+ * Ink 6 is ESM-only. Our project is CJS. This module dynamically imports ink
+ * at runtime via import(), which handles ESM from CJS contexts.
+ *
+ * React 19 is CJS and works with normal require().
+ */
+export interface InkExports {
+    render: any;
+    Text: any;
+    Box: any;
+    Newline: any;
+    useInput: any;
+    useApp: any;
+    useStdout: any;
+    Static: any;
+    Spacer: any;
+    TextInput: any;
+    Spinner: any;
+}
+/**
+ * Dynamically import ink.
+ * Cached after first call.
+ */
+export declare function loadInk(): Promise<InkExports>;

package/dist/tui/ink-loader.js

@@ -0,0 +1,42 @@
+"use strict";
+/**
+ * Dynamic loader for ink — bridges CJS to ESM.
+ *
+ * Ink 6 is ESM-only. Our project is CJS. This module dynamically imports ink
+ * at runtime via import(), which handles ESM from CJS contexts.
+ *
+ * React 19 is CJS and works with normal require().
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadInk = loadInk;
+let cached = null;
+/**
+ * Dynamically import ink.
+ * Cached after first call.
+ */
+async function loadInk() {
+    if (cached)
+        return cached;
+    // Use indirect import() to prevent TypeScript from converting it to require()
+    // when compiling to CommonJS. ink 6+ is ESM-only and needs a real import().
+    const dynamicImport = new Function('specifier', 'return import(specifier)');
+    const [ink, inkTextInput, inkSpinner] = await Promise.all([
+        dynamicImport('ink'),
+        dynamicImport('ink-text-input'),
+        dynamicImport('ink-spinner'),
+    ]);
+    cached = {
+        render: ink.render,
+        Text: ink.Text,
+        Box: ink.Box,
+        Newline: ink.Newline,
+        useInput: ink.useInput,
+        useApp: ink.useApp,
+        useStdout: ink.useStdout,
+        Static: ink.Static,
+        Spacer: ink.Spacer,
+        TextInput: inkTextInput.default || inkTextInput.TextInput,
+        Spinner: inkSpinner.default || inkSpinner.Spinner,
+    };
+    return cached;
+}

package/dist/tui/removed-commands.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Migration hints for slash commands removed or renamed in the S6
+ * rewrite. Every entry maps a legacy name to a one-liner pointing at
+ * the replacement, so users who rely on muscle memory get a clear
+ * correction instead of a generic "unknown command" error.
+ */
+export declare const REMOVED_SLASH_COMMANDS: Record<string, string>;
+/** Build the help-text suffix appended after a migration-hint line. */
+export declare function removedSlashCommandHelp(name: string): string | null;

package/dist/tui/removed-commands.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * Migration hints for slash commands removed or renamed in the S6
+ * rewrite. Every entry maps a legacy name to a one-liner pointing at
+ * the replacement, so users who rely on muscle memory get a clear
+ * correction instead of a generic "unknown command" error.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REMOVED_SLASH_COMMANDS = void 0;
+exports.removedSlashCommandHelp = removedSlashCommandHelp;
+exports.REMOVED_SLASH_COMMANDS = {
+    pause_ensemble: '/pause_ensemble was renamed to /pause.',
+    resume_ensemble: '/resume_ensemble was renamed to /play.',
+    resume: '/resume was renamed to /play to avoid colliding with `claude --resume`.',
+    detach: '/detach was removed; /shutdown handles ensemble-scope teardown and conductor reaping.',
+    disband: '/disband was removed; /destroy <ensemble> is the replacement.',
+};
+/** Build the help-text suffix appended after a migration-hint line. */
+function removedSlashCommandHelp(name) {
+    const hint = exports.REMOVED_SLASH_COMMANDS[name];
+    return hint ? `${hint} Type /help for the current command list.` : null;
+}

package/dist/tui/sse-handler.d.ts

@@ -0,0 +1,52 @@
+/**
+ * SSE event → TUI store dispatch mapping for PR-4a (#94/#95).
+ *
+ * Pure projection from `TempoEvent` (wire shape, see `src/http/event-types.ts`)
+ * to `TuiAction`. Kept in its own module so the mapping can be tested without
+ * mounting the full `App` tree.
+ *
+ * Design notes:
+ * - `event: snapshot` resets the ensemble slice (full state replace),
+ *   matching what the legacy 2 s poll loop did per tick.
+ * - `event: player.*` and `event: chat.appended` apply incrementally —
+ *   that's the latency win from streaming over polling.
+ * - `event: gap` re-fetches the same set of slices the snapshot covers
+ *   via `TempoClient` directly. Per `docs/SSE-PROTOCOL.md` §7.5 the gap
+ *   event surfaces to the consumer; the spec leaves the recovery shape
+ *   to the consumer (we keep it conservative — refresh, don't tear down
+ *   the subscription).
+ * - `event: chat.compressed` is a soft gap scoped to chat (§7.6) — we
+ *   re-fetch the chat slice only, leaving everything else untouched.
+ * - Heartbeats, throttle notices, host-profile + global-stream events
+ *   are not relevant to the per-ensemble TUI view; they're noops here.
+ */
+import type { Dispatch } from 'react';
+import type { MaestroPlayerInfo, ScheduleEntry } from '../types';
+import type { TempoClient } from '../client';
+import type { PlayerSummaryV1, TempoEvent } from '../http/event-types';
+import type { TuiAction } from './store';
+/**
+ * Project a wire `PlayerSummaryV1` into the in-memory `MaestroPlayerInfo`
+ * shape. The wire type carries two extra ISO timestamps
+ * (`lastHeartbeatAt`, `processingSince`) the TUI doesn't render today;
+ * dropping them avoids a type cast at the call site.
+ */
+export declare function toMaestroPlayerInfo(p: PlayerSummaryV1): MaestroPlayerInfo;
+/**
+ * The minimum `TempoClient` surface this handler depends on. Narrowed so
+ * tests don't have to construct a full client — only the gap/compressed
+ * recovery paths use it.
+ */
+export interface SseRefetchClient {
+    getPlayers(ensemble: string): Promise<MaestroPlayerInfo[]>;
+    getEnsembleChat(ensemble: string, offset?: number, limit?: number): ReturnType<TempoClient['getEnsembleChat']>;
+    getSchedules(ensemble: string): Promise<ScheduleEntry[]>;
+    isMaestroPaused(ensemble: string): Promise<boolean>;
+    isAnySessionHeld(ensemble: string): Promise<boolean>;
+}
+/**
+ * Apply one SSE event to the TUI store. Returns a Promise so callers can
+ * `await` the gap / chat.compressed re-fetches; for purely-synchronous
+ * events (every other kind) the returned promise is already resolved.
+ */
+export declare function handleSseEvent(event: TempoEvent, dispatch: Dispatch<TuiAction>, ensemble: string, api: SseRefetchClient): Promise<void>;