@snoglobe/helios 0.1.0 → 0.2.0

package/dist/ui/layout.js

@@ -5,22 +5,24 @@ import { useScreenSize } from "fullscreen-ink";
 import { ScrollView } from "ink-scroll-view";
 import { ConversationPanel } from "./panels/conversation.js";
 import { TaskListPanel } from "./panels/task-list.js";
-import { MetricsDashboard, sparkline } from "./panels/metrics-dashboard.js";
+import { MetricsDashboard } from "./panels/metrics-dashboard.js";
 import { StatusBar } from "./components/status-bar.js";
 import { InputBar } from "./components/input-bar.js";
 import { C, G, HRule } from "./theme.js";
 import { KeyHintRule } from "./components/key-hint-rule.js";
 import { TaskOverlay } from "./overlays/task-overlay.js";
 import { MetricsOverlay } from "./overlays/metrics-overlay.js";
-import { formatMetricValue, formatError } from "./format.js";
-import { loadMachines, addMachine as addMachineConfig, removeMachine as removeMachineConfig, parseMachineSpec, } from "../remote/config.js";
 import { StickyNotesPanel } from "./panels/sticky-notes.js";
-import { savePreferences } from "../store/preferences.js";
 import { VERSION, checkForUpdate } from "../version.js";
+import { handleSlashCommand } from "./commands.js";
+import { pollTaskStatuses, handleFinishedTasks, buildMonitorMessage } from "../core/task-poller.js";
 let messageIdCounter = 0;
-export function Layout({ orchestrator, sleepManager, connectionPool, executor, metricStore, metricCollector, monitorManager, experimentTracker, memoryStore, stickyManager, mouseEmitter }) {
+export function Layout({ runtime, mouseEmitter, headless, initialPrompt, initialAttachments }) {
+    const { orchestrator, sleepManager, connectionPool, executor, metricStore, metricCollector, monitorManager, experimentTracker, memoryStore, stickyManager, agentName, } = runtime;
     const { exit } = useApp();
     const [messages, setMessages] = useState([]);
+    const messagesRef = useRef(messages);
+    messagesRef.current = messages;
     const [isStreaming, setIsStreaming] = useState(false);
     const scrollRef = useRef(null);
     const [userScrolled, setUserScrolled] = useState(false);
@@ -28,6 +30,7 @@ export function Layout({ orchestrator, sleepManager, connectionPool, executor, m
     const [metricData, setMetricData] = useState(new Map());
     const [stickyNotes, setStickyNotes] = useState([]);
     const [activeOverlay, setActiveOverlay] = useState("none");
+    const [resourceData, setResourceData] = useState(new Map());
     const [updateAvailable, setUpdateAvailable] = useState(null);
     // Check for updates on mount (non-blocking)
     useEffect(() => {
@@ -38,72 +41,29 @@ export function Layout({ orchestrator, sleepManager, connectionPool, executor, m
     useEffect(() => {
         const poll = async () => {
             let didCollect = false;
-            // Update task list from executor's background processes
             if (executor && connectionPool) {
-                const procs = executor.getBackgroundProcesses();
-                // Check all processes in parallel rather than sequentially
-                const statuses = await Promise.all(procs.map(async (proc) => {
-                    try {
-                        const running = await executor.isRunning(proc.machineId, proc.pid);
-                        return { proc, running };
-                    }
-                    catch {
-                        return { proc, running: true }; // Transient error — assume still running
-                    }
-                }));
-                const finished = [];
-                const updated = [];
-                for (const { proc, running } of statuses) {
-                    const key = `${proc.machineId}:${proc.pid}`;
-                    const status = running ? "running" : "completed";
-                    if (!running)
-                        finished.push(key);
+                const { statuses, finished } = await pollTaskStatuses(executor);
+                // Build TaskInfo[] for UI state
+                const updated = statuses.map(({ proc, running }) => {
                     const shortCmd = proc.command.length > 40
                         ? proc.command.slice(0, 40) + "..."
                         : proc.command;
-                    updated.push({
-                        id: key,
+                    return {
+                        id: `${proc.machineId}:${proc.pid}`,
                         name: shortCmd,
-                        status,
+                        status: running ? "running" : "completed",
                         machineId: proc.machineId,
                         pid: proc.pid,
                         startedAt: proc.startedAt,
+                    };
+                });
+                if (finished.length > 0) {
+                    await handleFinishedTasks(finished, {
+                        executor, connectionPool, metricCollector, metricStore,
+                        experimentTracker, notifier: runtime.notifier,
                     });
-                }
-                // Collect metrics before removing finished processes (so final data is captured)
-                if (finished.length > 0 && metricCollector) {
-                    await metricCollector.collectAll().catch(() => { });
                     didCollect = true;
                 }
-                for (const key of finished) {
-                    const [machineId, pidStr] = key.split(":");
-                    const pid = parseInt(pidStr, 10);
-                    // Fetch actual exit code before cleanup
-                    let exitCode = 0;
-                    try {
-                        const result = await connectionPool.exec(machineId, `wait ${pid} 2>/dev/null; echo $?`);
-                        const parsed = parseInt(result.stdout.trim(), 10);
-                        if (!isNaN(parsed))
-                            exitCode = parsed;
-                    }
-                    catch {
-                        // Can't determine exit code — default to 0
-                    }
-                    // Update experiment tracker with final metrics
-                    if (experimentTracker && metricStore) {
-                        const names = metricStore.getMetricNames(key);
-                        const metrics = {};
-                        for (const name of names) {
-                            const latest = metricStore.getLatest(key, name);
-                            if (latest)
-                                metrics[name] = latest.value;
-                        }
-                        experimentTracker.updateExperiment(machineId, pid, exitCode, Object.keys(metrics).length > 0 ? metrics : undefined);
-                    }
-                    // Clean up collector source so it stops tailing the dead process log
-                    metricCollector?.removeSource(key);
-                    executor.removeBackgroundProcess(key);
-                }
                 setTasks(updated);
             }
             // Collect metrics from all sources (skip if we already collected for finished tasks above)
@@ -111,21 +71,24 @@ export function Layout({ orchestrator, sleepManager, connectionPool, executor, m
                 if (!didCollect) {
                     await metricCollector.collectAll().catch(() => { });
                 }
-                // Build sparkline data from ALL known metrics (not just live processes)
-                const newMetricData = new Map();
-                const allNames = metricStore.getAllMetricNames();
-                for (const name of allNames) {
-                    const series = metricStore.getSeriesAcrossTasks(name, 50);
-                    if (series.length > 0) {
-                        newMetricData.set(name, series.map((p) => p.value));
-                    }
-                }
-                setMetricData(newMetricData);
+                setMetricData(metricStore.getAllSeries(50));
+            }
+            // Collect resource usage from connected machines
+            if (runtime.resourceCollector) {
+                const res = await runtime.resourceCollector.collectAll().catch(() => new Map());
+                setResourceData(res);
             }
         };
-        poll();
-        const timer = setInterval(poll, 5000);
-        return () => clearInterval(timer);
+        let timer = null;
+        let stopped = false;
+        const loop = async () => {
+            await poll();
+            if (!stopped)
+                timer = setTimeout(loop, 5000);
+        };
+        loop();
+        return () => { stopped = true; if (timer)
+            clearTimeout(timer); };
     }, [executor, connectionPool, metricCollector, metricStore]);
     // Auto-scroll to bottom when messages change, overlay closes, or user hasn't scrolled up
     useEffect(() => {
@@ -235,17 +198,19 @@ export function Layout({ orchestrator, sleepManager, connectionPool, executor, m
     const updateMessage = useCallback((id, updates) => {
         setMessages((prev) => prev.map((m) => (m.id === id ? { ...m, ...updates } : m)));
     }, []);
-    const handleSubmit = useCallback(async (input) => {
+    const handleSubmit = useCallback(async (input, attachments) => {
         if (!input.trim())
             return;
         if (input.startsWith("/")) {
-            if (input.startsWith("/writeup")) {
-                await handleWriteup(orchestrator, messages, addMessage, updateMessage, setIsStreaming);
-                return;
-            }
-            handleSlashCommand(input, {
-                orchestrator, addMessage, setMessages, connectionPool,
-                metricStore, metricCollector, memoryStore, stickyManager, setStickyNotes,
+            await handleSlashCommand(input, {
+                orchestrator, addMessage, updateMessage, setMessages, messages: messagesRef.current, setIsStreaming,
+                connectionPool, metricStore, metricCollector, memoryStore,
+                stickyManager, setStickyNotes, executor,
+                restoreMessages: (msgs) => msgs.map((m) => ({
+                    id: ++messageIdCounter,
+                    role: m.role,
+                    content: m.content,
+                })),
             });
             return;
         }
@@ -262,7 +227,7 @@ export function Layout({ orchestrator, sleepManager, connectionPool, executor, m
             let assistantMsgId = null;
             // Map tool callId -> message id for attaching results
             const toolMsgIds = new Map();
-            for await (const event of orchestrator.send(input)) {
+            for await (const event of orchestrator.send(input, attachments)) {
                 // Feed events to experiment tracker for auto-populating /experiments/
                 experimentTracker?.onEvent(event);
                 if (event.type === "text" && event.delta) {
@@ -308,14 +273,17 @@ export function Layout({ orchestrator, sleepManager, connectionPool, executor, m
             setIsStreaming(false);
         }
     }, [orchestrator, sleepManager, addMessage, updateMessage, setMessages, connectionPool, metricStore]);
+    // Auto-submit initial prompt (from --prompt CLI flag)
+    const promptSent = useRef(false);
+    useEffect(() => {
+        if (initialPrompt && !promptSent.current) {
+            promptSent.current = true;
+            handleSubmit(initialPrompt, initialAttachments);
+        }
+    }, [initialPrompt, initialAttachments, handleSubmit]);
     // Monitor: auto-invoke model on tick
     const isStreamingRef = useRef(false);
     isStreamingRef.current = isStreaming;
-    // Use refs for tasks/metricData so the monitor effect doesn't re-subscribe every poll
-    const tasksRef = useRef(tasks);
-    tasksRef.current = tasks;
-    const metricDataRef = useRef(metricData);
-    metricDataRef.current = metricData;
     const handleSubmitRef = useRef(handleSubmit);
     handleSubmitRef.current = handleSubmit;
     useEffect(() => {
@@ -324,29 +292,8 @@ export function Layout({ orchestrator, sleepManager, connectionPool, executor, m
         const onTick = (config) => {
             if (isStreamingRef.current)
                 return;
-            const elapsed = Date.now() - config.startedAt;
-            const elapsedMin = Math.round(elapsed / 60_000);
-            const intervalMin = Math.round(config.intervalMs / 60_000);
-            const parts = [
-                `[Monitor check — ${elapsedMin}m elapsed, interval ${intervalMin}m]`,
-                `Goal: ${config.goal}`,
-            ];
-            const currentTasks = tasksRef.current;
-            if (currentTasks.length > 0) {
-                parts.push("Tasks:");
-                for (const t of currentTasks) {
-                    parts.push(`  ${t.status === "running" ? "◆" : "◇"} ${t.machineId}:${t.pid ?? "?"} ${t.status} — ${t.name}`);
-                }
-            }
-            const currentMetrics = metricDataRef.current;
-            if (currentMetrics.size > 0) {
-                parts.push("Metrics:");
-                for (const [name, values] of currentMetrics.entries()) {
-                    const latest = values[values.length - 1];
-                    parts.push(`  ${name}: ${latest}`);
-                }
-            }
-            handleSubmitRef.current(parts.join("\n"));
+            const message = buildMonitorMessage(config, executor, metricStore);
+            handleSubmitRef.current(message);
         };
         monitorManager.on("tick", onTick);
         return () => {
@@ -356,6 +303,13 @@ export function Layout({ orchestrator, sleepManager, connectionPool, executor, m
     // Sleep/wake: auto-resume model when a trigger fires
     const addMessageRef = useRef(addMessage);
     addMessageRef.current = addMessage;
+    // Route OpenAI OAuth URL display through the TUI instead of stderr
+    useEffect(() => {
+        runtime.openaiOAuth.onAuthUrl = (url) => {
+            addMessageRef.current("system", url);
+        };
+        return () => { runtime.openaiOAuth.onAuthUrl = null; };
+    }, [runtime.openaiOAuth]);
     useEffect(() => {
         const onWake = (_session, _reason, wakeMessage) => {
             if (isStreamingRef.current)
@@ -381,441 +335,15 @@ export function Layout({ orchestrator, sleepManager, connectionPool, executor, m
         return (_jsx(Box, { flexDirection: "column", height: height, width: width, children: _jsx(MetricsOverlay, { metricData: metricData, metricStore: metricStore, width: width, height: height, onClose: () => setActiveOverlay("none") }) }));
     }
     // ── Normal layout ─────────────────────────────────────────────
-    return (_jsxs(Box, { flexDirection: "column", height: height, width: width, children: [_jsx(Box, { flexShrink: 0, children: _jsx(HeaderWithPanels, { width: width }) }), _jsxs(Box, { flexShrink: 0, flexDirection: "row", children: [_jsx(Box, { flexGrow: 1, flexBasis: 0, flexDirection: "column", paddingX: 1, children: _jsx(MetricsDashboard, { metricData: metricData, width: Math.floor((width - 1) / 2) - 2 }) }), _jsx(Box, { width: 1, flexDirection: "column", alignItems: "center", children: _jsx(Text, { color: C.primary, wrap: "truncate", children: Array.from({ length: panelHeight }, () => "│").join("\n") }) }), _jsx(Box, { flexGrow: 1, flexBasis: 0, flexDirection: "column", paddingX: 1, children: _jsx(TaskListPanel, { tasks: tasks, width: Math.floor((width - 1) / 2) - 2 }) })] }), _jsx(Box, { flexShrink: 0, children: _jsx(HRule, {}) }), _jsxs(Box, { flexGrow: 1, flexShrink: 1, flexDirection: "row", children: [_jsx(Box, { flexGrow: 1, flexShrink: 1, children: messages.length === 0 ? (_jsxs(Box, { flexGrow: 1, alignItems: "center", justifyContent: "center", flexDirection: "column", children: [_jsx(Text, { color: C.primary, bold: true, children: G.brand }), _jsx(Text, { color: C.primary, bold: true, children: "H E L I O S" }), _jsx(Text, { color: C.dim, children: "autonomous ml research" }), _jsxs(Text, { color: C.dim, dimColor: true, children: ["v", VERSION] }), _jsx(Text, { color: C.dim, dimColor: true, children: "" }), _jsx(Text, { color: C.dim, dimColor: true, children: "/help for commands" }), updateAvailable && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: C.bright, children: ["update available: v", updateAvailable, " \u2014 npm i -g helios"] }) }))] })) : (_jsx(ScrollView, { ref: scrollRef, children: _jsx(ConversationPanel, { messages: messages, isStreaming: isStreaming }) })) }), stickyNotes.length > 0 && (_jsx(Box, { flexShrink: 0, children: _jsx(StickyNotesPanel, { notes: stickyNotes, width: Math.min(30, Math.floor(width * 0.25)) }) }))] }), _jsx(Box, { flexShrink: 0, children: _jsx(KeyHintRule, {}) }), _jsx(Box, { flexShrink: 0, children: _jsx(StatusBar, { orchestrator: orchestrator, sleepManager: sleepManager, monitorManager: monitorManager }) }), _jsx(Box, { flexShrink: 0, children: _jsx(InputBar, { onSubmit: handleSubmit, disabled: isStreaming, placeholder: isSleeping
+    return (_jsxs(Box, { flexDirection: "column", height: height, width: width, children: [_jsx(Box, { flexShrink: 0, children: headless && agentName ? (_jsx(HeadlessHeader, { agentName: agentName, width: width })) : (_jsx(HeaderWithPanels, { width: width })) }), _jsxs(Box, { flexShrink: 0, flexDirection: "row", children: [_jsx(Box, { flexGrow: 1, flexBasis: 0, flexDirection: "column", paddingX: 1, children: _jsx(MetricsDashboard, { metricData: metricData, width: Math.floor((width - 1) / 2) - 2 }) }), _jsx(Box, { width: 1, flexDirection: "column", alignItems: "center", children: _jsx(Text, { color: C.primary, wrap: "truncate", children: Array.from({ length: panelHeight }, () => "│").join("\n") }) }), _jsx(Box, { flexGrow: 1, flexBasis: 0, flexDirection: "column", paddingX: 1, children: _jsx(TaskListPanel, { tasks: tasks, resources: resourceData, width: Math.floor((width - 1) / 2) - 2 }) })] }), _jsx(Box, { flexShrink: 0, children: _jsx(HRule, {}) }), _jsxs(Box, { flexGrow: 1, flexShrink: 1, flexDirection: "row", children: [_jsx(Box, { flexGrow: 1, flexShrink: 1, children: messages.length === 0 && !headless ? (_jsxs(Box, { flexGrow: 1, alignItems: "center", justifyContent: "center", flexDirection: "column", children: [_jsx(Text, { color: C.primary, bold: true, children: G.brand }), _jsx(Text, { color: C.primary, bold: true, children: "H E L I O S" }), _jsx(Text, { color: C.dim, children: "autonomous ml research" }), _jsxs(Text, { color: C.dim, dimColor: true, children: ["v", VERSION] }), _jsx(Text, { color: C.dim, dimColor: true, children: "" }), _jsx(Text, { color: C.dim, dimColor: true, children: "/help for commands" }), updateAvailable && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: C.bright, children: ["update available: v", updateAvailable, " \u2014 npm i -g helios"] }) }))] })) : (_jsx(ScrollView, { ref: scrollRef, children: _jsx(ConversationPanel, { messages: messages, isStreaming: isStreaming }) })) }), stickyNotes.length > 0 && (_jsx(Box, { flexShrink: 0, children: _jsx(StickyNotesPanel, { notes: stickyNotes, width: Math.min(30, Math.floor(width * 0.25)) }) }))] }), !headless && _jsx(Box, { flexShrink: 0, children: _jsx(KeyHintRule, {}) }), _jsx(Box, { flexShrink: 0, children: _jsx(StatusBar, { orchestrator: orchestrator, sleepManager: sleepManager, monitorManager: monitorManager }) }), !headless && (_jsx(Box, { flexShrink: 0, children: _jsx(InputBar, { onSubmit: handleSubmit, disabled: isStreaming, placeholder: isSleeping
                         ? "type to wake agent..."
-                        : "send a message... (/help for commands)" }) })] }));
+                        : "send a message... (/help for commands)" }) }))] }));
 }
-function handleSlashCommand(input, ctx) {
-    const { orchestrator, addMessage, setMessages, connectionPool, metricStore, metricCollector, memoryStore, stickyManager, setStickyNotes } = ctx;
-    const parts = input.slice(1).split(" ");
-    const cmd = parts[0];
-    const args = parts.slice(1);
-    switch (cmd) {
-        case "switch": {
-            const provider = args[0];
-            if (provider !== "claude" && provider !== "openai") {
-                addMessage("system", "Usage: /switch <claude|openai>");
-                return;
-            }
-            addMessage("system", `Switching to ${provider}...`);
-            orchestrator.switchProvider(provider).then(() => addMessage("system", `Switched to ${provider}`), (err) => addMessage("error", `Failed to switch: ${formatError(err)}`));
-            break;
-        }
-        case "model": {
-            const modelId = args[0];
-            if (!modelId) {
-                addMessage("system", `Current model: ${orchestrator.currentModel ?? "default"}\nUsage: /model <model-id>`);
-                return;
-            }
-            addMessage("system", `Setting model to ${modelId}...`);
-            orchestrator.setModel(modelId).then(() => addMessage("system", `Model set to ${modelId}`), (err) => addMessage("error", `Failed to set model: ${formatError(err)}`));
-            break;
-        }
-        case "reasoning": {
-            const level = args[0];
-            const validLevels = ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
-            if (!level || !validLevels.includes(level)) {
-                const provider = orchestrator.currentProvider?.name;
-                const hint = provider === "claude"
-                    ? "Claude: medium, high, max"
-                    : "OpenAI: none, minimal, low, medium, high, xhigh";
-                addMessage("system", `Current reasoning effort: ${orchestrator.reasoningEffort ?? "medium"}\n${hint}\nUsage: /reasoning <level>`);
-                return;
-            }
-            orchestrator.setReasoningEffort(level).then(() => addMessage("system", `Reasoning effort set to ${level}`), (err) => addMessage("error", `Failed: ${formatError(err)}`));
-            break;
-        }
-        case "models": {
-            addMessage("system", "Fetching available models...");
-            orchestrator.fetchModels().then((models) => {
-                const current = orchestrator.currentModel;
-                const lines = models.map((m) => {
-                    const marker = m.id === current ? " ◆" : "";
-                    const desc = m.description ? ` — ${m.description}` : "";
-                    return `  ${m.id}${marker}${desc}`;
-                });
-                addMessage("system", `Available models:\n${lines.join("\n")}`);
-            }, (err) => addMessage("error", `Failed to fetch models: ${formatError(err)}`));
-            break;
-        }
-        case "claude-mode": {
-            const mode = args[0];
-            if (mode !== "cli" && mode !== "api") {
-                const current = orchestrator.getProvider("claude")?.currentAuthMode;
-                addMessage("system", `Current Claude mode: ${current === "cli" ? "cli (Agent SDK)" : "api (API key)"}\nUsage: /claude-mode <cli|api>`);
-                break;
-            }
-            const claude = orchestrator.getProvider("claude");
-            if (!claude) {
-                addMessage("error", "Claude provider not registered");
-                break;
-            }
-            claude.setPreferredAuthMode(mode);
-            savePreferences({ claudeAuthMode: mode });
-            // Re-authenticate to apply the new mode
-            claude.authenticate().then(() => addMessage("system", `Claude mode set to ${mode === "cli" ? "cli (Agent SDK)" : "api (API key)"}`), (err) => addMessage("error", `Failed to switch Claude mode: ${formatError(err)}`));
-            break;
-        }
-        case "machine":
-        case "machines": {
-            handleMachineCommand(args, addMessage, connectionPool);
-            break;
-        }
-        case "resume": {
-            handleResumeCommand(args, orchestrator, addMessage, setMessages);
-            break;
-        }
-        case "metric":
-        case "metrics": {
-            if (!metricStore) {
-                addMessage("error", "Metric store not available");
-                break;
-            }
-            if (args[0] === "clear") {
-                const deleted = metricStore.clear();
-                metricCollector?.reset();
-                addMessage("system", `Cleared ${deleted} metric points.`);
-            }
-            else if (args.length === 0) {
-                // /metric with no args — list all known metric names
-                const allNames = metricStore.getAllMetricNames();
-                if (allNames.length === 0) {
-                    addMessage("system", "No metrics recorded yet.");
-                }
-                else {
-                    addMessage("system", `Known metrics:\n  ${allNames.join("  ")}\n\nUsage: /metric <name1> [name2] ... | /metrics clear`);
-                }
-            }
-            else {
-                // /metric loss acc lr — show sparklines for named metrics
-                const lines = [];
-                for (const name of args) {
-                    const series = metricStore.getSeriesAcrossTasks(name, 50);
-                    if (series.length === 0) {
-                        lines.push(`  ${name}  (no data)`);
-                        continue;
-                    }
-                    const values = series.map((p) => p.value);
-                    const latest = values[values.length - 1];
-                    const min = Math.min(...values);
-                    const max = Math.max(...values);
-                    const spark = sparkline(values, 30);
-                    lines.push(`  ${name}  ${spark}  ${formatMetricValue(latest)}  (min ${formatMetricValue(min)} max ${formatMetricValue(max)})`);
-                }
-                addMessage("system", lines.join("\n"));
-            }
-            break;
-        }
-        case "help":
-            addMessage("system", [
-                "Commands:",
-                "  /switch <claude|openai>         Switch model provider",
-                "  /claude-mode <cli|api>          Switch Claude auth (cli=Agent SDK, api=API key)",
-                "  /model <model-id>               Set model",
-                "  /models                          List available models",
-                "  /reasoning <level>                Set reasoning effort",
-                "  /resume                          List recent sessions",
-                "  /resume <number>                 Resume a past session",
-                "  /metric [name1 name2 ...]        Show metric sparklines",
-                "  /metrics clear                   Clear all metrics",
-                "  /writeup                         Generate experiment writeup",
-                "  /machine add <id> <user@host>    Add remote machine",
-                "  /machine rm <id>                 Remove machine",
-                "  /machines                        List machines",
-                "  /status                          Show current state",
-                "  /clear                           Clear conversation",
-                "  /quit                            Exit Helios",
-                "",
-                "Keys:",
-                "  Tab        Autocomplete command",
-                "  ↑↓         Navigate menu / history",
-                "  ←→         Move cursor",
-                "  Ctrl+T     Task output overlay",
-                "  Ctrl+G     Metrics overlay",
-                "  Escape     Interrupt / close overlay",
-                "  Ctrl+A/E   Start / end of line",
-                "  Ctrl+W     Delete word backward",
-                "  Ctrl+U     Clear line",
-                "  Ctrl+C     Interrupt / Exit",
-            ].join("\n"));
-            break;
-        case "status":
-            addMessage("system", [
-                `Provider: ${orchestrator.currentProvider?.displayName ?? "None"}`,
-                `Model: ${orchestrator.currentModel ?? "default"}`,
-                `Reasoning: ${orchestrator.reasoningEffort ?? "medium"}`,
-                `State: ${orchestrator.currentState}`,
-                `Cost: $${orchestrator.totalCostUsd.toFixed(4)}`,
-            ].join("\n"));
-            break;
-        case "sticky": {
-            if (!stickyManager || !setStickyNotes) {
-                addMessage("system", "Sticky notes not available.");
-                break;
-            }
-            const stickyText = args.join(" ").trim();
-            if (!stickyText) {
-                addMessage("system", "Usage: /sticky <text to pin>");
-                break;
-            }
-            const note = stickyManager.add(stickyText);
-            setStickyNotes(stickyManager.list());
-            addMessage("system", `Pinned sticky #${note.num}: ${stickyText}`);
-            break;
-        }
-        case "stickies": {
-            if (!stickyManager || !setStickyNotes) {
-                addMessage("system", "Sticky notes not available.");
-                break;
-            }
-            if (args[0] === "rm" && args[1]) {
-                const num = parseInt(args[1], 10);
-                if (isNaN(num)) {
-                    addMessage("system", "Usage: /stickies rm <number>");
-                    break;
-                }
-                const removed = stickyManager.remove(num);
-                setStickyNotes(stickyManager.list());
-                addMessage("system", removed ? `Removed sticky #${num}` : `Sticky #${num} not found`);
-            }
-            else {
-                const notes = stickyManager.list();
-                if (notes.length === 0) {
-                    addMessage("system", "No sticky notes. Use /sticky <text> to add one.");
-                }
-                else {
-                    const listing = notes.map((n) => `  [${n.num}] ${n.text}`).join("\n");
-                    addMessage("system", `Sticky notes:\n${listing}`);
-                }
-            }
-            break;
-        }
-        case "memory": {
-            if (!memoryStore) {
-                addMessage("system", "Memory system not initialized.");
-                break;
-            }
-            const memPath = args[0] ?? "/";
-            const tree = memoryStore.formatTree(memPath);
-            addMessage("system", `Memory tree (${memPath}):\n${tree}`);
-            break;
-        }
-        case "clear":
-            setMessages([]);
-            break;
-        case "quit":
-        case "exit":
-            process.exit(0);
-        default:
-            addMessage("system", `Unknown command: /${cmd}. Try /help`);
-    }
-}
-function handleMachineCommand(args, addMessage, connectionPool) {
-    const subCmd = args[0];
-    if (!subCmd || subCmd === "list") {
-        const machines = loadMachines();
-        if (machines.length === 0) {
-            addMessage("system", "No machines configured.\nUsage: /machine add <id> <user@host[:port]> [--key <path>]");
-            return;
-        }
-        const lines = machines.map((m) => {
-            const status = connectionPool?.getStatus(m.id);
-            let statusText = status?.connected ? "◆ connected" : "◇ disconnected";
-            if (!status?.connected && status?.error) {
-                statusText += ` — ${status.error}`;
-            }
-            return `  ${m.id}  ${m.username}@${m.host}:${m.port}  [${m.authMethod}]  ${statusText}`;
-        });
-        addMessage("system", `Machines:\n${lines.join("\n")}`);
-        return;
-    }
-    if (subCmd === "add") {
-        const id = args[1];
-        const spec = args[2];
-        if (!id || !spec) {
-            addMessage("system", "Usage: /machine add <id> <user@host[:port]> [--key <path>]");
-            return;
-        }
-        const options = {};
-        for (let i = 3; i < args.length; i++) {
-            if (args[i] === "--key" && args[i + 1]) {
-                options.key = args[++i];
-            }
-            else if (args[i] === "--auth" && args[i + 1]) {
-                options.auth = args[++i];
-            }
-        }
-        try {
-            const machine = parseMachineSpec(id, spec, options);
-            addMachineConfig(machine);
-            connectionPool?.addMachine(machine);
-            addMessage("system", `Added machine "${id}" (${machine.username}@${machine.host}:${machine.port}). Connecting...`);
-            connectionPool?.connect(id).then(() => addMessage("system", `Machine "${id}" connected ◆`), (err) => addMessage("error", `Machine "${id}" added but connection failed: ${formatError(err)}\nThe agent can still try to connect later.`));
-        }
-        catch (err) {
-            addMessage("error", `Failed to add machine: ${formatError(err)}`);
-        }
-        return;
-    }
-    if (subCmd === "rm" || subCmd === "remove") {
-        const id = args[1];
-        if (!id) {
-            addMessage("system", "Usage: /machine rm <id>");
-            return;
-        }
-        if (removeMachineConfig(id)) {
-            connectionPool?.removeMachine(id);
-            addMessage("system", `Removed machine "${id}"`);
-        }
-        else {
-            addMessage("error", `Machine "${id}" not found`);
-        }
-        return;
-    }
-    addMessage("system", "Usage: /machine <add|rm|list>");
-}
-// Stash the last session listing so /resume <n> can look up by index
-let lastSessionListing = [];
-function handleResumeCommand(args, orchestrator, addMessage, setMessages) {
-    const index = args[0] ? Number.parseInt(args[0], 10) : NaN;
-    // --- /resume  (no args) — list recent sessions ---
-    if (Number.isNaN(index)) {
-        const sessions = orchestrator.sessionStore.listSessionSummaries(20);
-        if (sessions.length === 0) {
-            addMessage("system", "No past sessions found.");
-            return;
-        }
-        lastSessionListing = sessions;
-        const lines = sessions.map((s, i) => {
-            const date = new Date(s.lastActiveAt).toLocaleString();
-            const provider = s.provider;
-            const preview = s.firstUserMessage ?? "(no messages)";
-            const msgs = `${s.messageCount} msg${s.messageCount !== 1 ? "s" : ""}`;
-            return `  ${i + 1}. [${date}] ${provider} (${msgs})\n     ${preview}`;
-        });
-        addMessage("system", `Recent sessions:\n${lines.join("\n")}\n\nUse /resume <number> to resume a session.`);
-        return;
-    }
-    // --- /resume <number> — resume by index ---
-    if (index < 1 || index > lastSessionListing.length) {
-        addMessage("system", lastSessionListing.length === 0
-            ? "Run /resume first to list sessions."
-            : `Invalid index. Choose 1-${lastSessionListing.length}.`);
-        return;
-    }
-    const target = lastSessionListing[index - 1];
-    addMessage("system", `Resuming session from ${new Date(target.lastActiveAt).toLocaleString()}...`);
-    // Load stored messages and restore them into the UI
-    const storedMessages = orchestrator.sessionStore.getMessages(target.id, 500);
-    // Build Message[] from stored messages, resetting the id counter
-    const restored = storedMessages
-        .filter((m) => m.role === "user" || m.role === "assistant")
-        .map((m) => ({
-        id: ++messageIdCounter,
-        role: m.role,
-        content: m.content,
-    }));
-    setMessages(restored);
-    // Tell the orchestrator / provider to resume the session
-    orchestrator.resumeSession(target.id).then(() => addMessage("system", `Session resumed (${target.provider}, ${storedMessages.length} messages loaded)`), (err) => addMessage("error", `Failed to resume session: ${formatError(err)}`));
-}
-const WRITEUP_SYSTEM_PROMPT = `You are a scientific writing assistant. You will receive the full transcript of an ML experiment session — including the researcher's goals, the agent's actions, tool calls, metric results, and conclusions.
-
-Your task: produce a clean, structured experiment writeup. Write it as a practitioner's report, not an academic paper. Be concise but thorough.
-
-## Format
-
-# [Title — infer from the goal]
-
-## Objective
-What was the researcher trying to achieve?
-
-## Setup
-- Model architecture, dataset, hardware
-- Key hyperparameters and configuration
-
-## Experiments
-For each distinct experiment/run:
-- What was tried and why
-- Key metrics (include actual numbers)
-- Whether it improved over the previous best
-
-## Results
-- Best configuration found
-- Final metric values
-- Comparison to baseline / starting point
-
-## Observations
-- What worked, what didn't
-- Surprising findings
-- Hypotheses about why certain changes helped/hurt
-
-## Next Steps (if applicable)
-- Promising directions not yet explored
-- Known limitations
-
-Keep the writing direct and data-driven. Use actual metric values from the transcript. Do not invent data.`;
-async function handleWriteup(orchestrator, messages, addMessage, updateMessage, setIsStreaming) {
-    if (messages.length === 0) {
-        addMessage("system", "No conversation to write up.");
-        return;
-    }
-    // Build a transcript from the conversation
-    const transcript = messages
-        .map((m) => {
-        if (m.role === "user")
-            return `[USER] ${m.content}`;
-        if (m.role === "assistant")
-            return `[ASSISTANT] ${m.content}`;
-        if (m.role === "tool" && m.tool) {
-            const result = m.tool.result ? `\nResult: ${m.tool.result}` : "";
-            return `[TOOL: ${m.tool.name}] ${JSON.stringify(m.tool.args)}${result}`;
-        }
-        if (m.role === "system")
-            return `[SYSTEM] ${m.content}`;
-        if (m.role === "error")
-            return `[ERROR] ${m.content}`;
-        return "";
-    })
-        .filter(Boolean)
-        .join("\n\n");
-    addMessage("system", "Generating writeup...");
-    setIsStreaming(true);
-    try {
-        // Get the active provider and create a one-shot session for the writeup
-        const provider = orchestrator.currentProvider;
-        if (!provider) {
-            addMessage("error", "No active provider");
-            return;
-        }
-        const writeupSession = await provider.createSession({
-            systemPrompt: WRITEUP_SYSTEM_PROMPT,
-        });
-        try {
-            let writeupText = "";
-            let writeupMsgId = null;
-            for await (const event of provider.send(writeupSession, `Here is the full experiment session transcript:\n\n${transcript}`, [])) {
-                if (event.type === "text" && event.delta) {
-                    writeupText += event.delta;
-                    if (writeupMsgId === null) {
-                        writeupMsgId = addMessage("assistant", writeupText);
-                    }
-                    else {
-                        updateMessage(writeupMsgId, { content: writeupText });
-                    }
-                }
-            }
-        }
-        finally {
-            await provider.closeSession(writeupSession).catch(() => { });
-        }
-    }
-    catch (err) {
-        addMessage("error", `Writeup failed: ${formatError(err)}`);
-    }
-    finally {
-        setIsStreaming(false);
-    }
+/** Compact header for headless mode — shows agent name prominently. */
+function HeadlessHeader({ agentName, width }) {
+    const label = ` ${G.brand} ${agentName} `;
+    const fill = Math.max(0, width - label.length);
+    return (_jsxs(Box, { children: [_jsx(Text, { color: C.bright, bold: true, children: label }), _jsx(Text, { color: C.primary, children: G.rule.repeat(fill) })] }));
 }
 /** Single header line: logo on the left, panel labels right-aligned in each half. */
 function HeaderWithPanels({ width }) {