terminal-agent-workboard 0.0.1

package/dist/ui.js

@@ -0,0 +1,450 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { Box, Text, useApp, useStdout } from "ink";
+import { orderedStatuses } from "./status.js";
+import { discoverHistory } from "./history.js";
+import { EMPTY_BUFFER, backspace, deleteForward, deleteWordBefore, getCurrentSlashToken, insertText, killLine, moveDown, moveLeft, moveLineEnd, moveLineStart, moveRight, moveUp, moveWordLeft, moveWordRight } from "./promptBuffer.js";
+import { useTerminalInput } from "./terminalInput.js";
+import { SlashCommandMenu } from "./SlashCommandMenu.js";
+import { buildSlashCommands, filterSlashCommands, isExactSlashCommand } from "./slashCommands.js";
+import { runWorkboardCommand } from "./workboardCommands.js";
+import { decideCtrlC } from "./ctrlCBehavior.js";
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+export function WorkboardApp({ workboard, config }) {
+    const { exit } = useApp();
+    const { stdout } = useStdout();
+    const [sessions, setSessions] = useState(() => workboard.list());
+    const [history, setHistory] = useState(() => discoverHistory());
+    const [selected, setSelected] = useState(0);
+    const [buffer, setBuffer] = useState(EMPTY_BUFFER);
+    const [message, setMessage] = useState("");
+    const [review, setReview] = useState(null);
+    const [agentIndex, setAgentIndex] = useState(0);
+    const [menuIndex, setMenuIndex] = useState(0);
+    const [historyOpen, setHistoryOpen] = useState(false);
+    const [historyIndex, setHistoryIndex] = useState(0);
+    const [pendingExitAt, setPendingExitAt] = useState(null);
+    const [spinnerIndex, setSpinnerIndex] = useState(0);
+    const [attaching, setAttaching] = useState(false);
+    const agents = useMemo(() => Object.keys(config.agents), [config.agents]);
+    const currentAgent = agents[agentIndex] ?? config.defaultAgent;
+    const visibleSessions = useMemo(() => buildVisibleSessions(sessions), [sessions]);
+    const selectedSession = visibleSessions[selected];
+    const selectedWorking = selectedSession?.status === "Working";
+    const slashCommands = useMemo(() => buildSlashCommands(agents), [agents]);
+    const slashToken = getCurrentSlashToken(buffer);
+    const slashMenu = useMemo(() => (slashToken ? filterSlashCommands(slashCommands, slashToken) : []), [slashCommands, slashToken]);
+    const showSlashMenu = slashMenu.length > 0;
+    const refresh = useCallback(() => {
+        const next = workboard.list();
+        setSessions(next);
+        setHistory(discoverHistory());
+        setSelected((current) => Math.min(current, Math.max(0, buildVisibleSessions(next).length - 1)));
+    }, [workboard]);
+    useEffect(() => {
+        const timer = setInterval(refresh, 1000);
+        return () => clearInterval(timer);
+    }, [refresh]);
+    useEffect(() => {
+        const hide = () => stdout.write("[?25l");
+        const show = () => stdout.write("[?25h");
+        hide();
+        process.on("exit", show);
+        return () => {
+            show();
+            process.off("exit", show);
+        };
+    }, [stdout]);
+    useEffect(() => {
+        refresh();
+    }, [refresh]);
+    useEffect(() => {
+        if (!selectedWorking) {
+            setSpinnerIndex(0);
+            return;
+        }
+        const timer = setInterval(() => {
+            setSpinnerIndex((index) => (index + 1) % SPINNER_FRAMES.length);
+        }, 80);
+        return () => clearInterval(timer);
+    }, [selectedWorking]);
+    const rows = useMemo(() => buildRows(sessions), [sessions]);
+    useEffect(() => {
+        if (!showSlashMenu) {
+            setMenuIndex(0);
+            return;
+        }
+        if (menuIndex >= slashMenu.length) {
+            setMenuIndex(Math.max(0, slashMenu.length - 1));
+        }
+    }, [menuIndex, showSlashMenu, slashMenu.length]);
+    useEffect(() => {
+        setHistoryIndex((index) => Math.min(index, Math.max(0, history.length - 1)));
+    }, [history.length]);
+    const restoreHistoryAt = useCallback((index) => {
+        const entry = history[index];
+        if (!entry) {
+            setMessage("no history session selected");
+            return;
+        }
+        try {
+            const restored = workboard.restore(entry);
+            setHistoryOpen(false);
+            setBuffer(EMPTY_BUFFER);
+            setMessage(`restored ${restored.id}`);
+            refresh();
+        }
+        catch (error) {
+            setMessage(error instanceof Error ? error.message : String(error));
+        }
+    }, [history, refresh, workboard]);
+    const attachSession = useCallback((sessionId) => {
+        const session = sessions.find((candidate) => candidate.id === sessionId || candidate.tmuxSession === sessionId);
+        if (!session) {
+            setMessage(`unknown session ${sessionId}`);
+            return;
+        }
+        setAttaching(true);
+        setMessage(`attached to ${session.id}; detach tmux to return`);
+        setTimeout(() => {
+            try {
+                stdout.write("\u001B[2J\u001B[3J\u001B[H");
+                workboard.attach(session.id);
+                stdout.write("[?25l");
+                setMessage(`returned from ${session.id}`);
+                refresh();
+            }
+            catch (error) {
+                setMessage(error instanceof Error ? error.message : String(error));
+            }
+            finally {
+                setAttaching(false);
+            }
+        }, 20);
+    }, [refresh, sessions, stdout, workboard]);
+    const submit = useCallback(() => {
+        const value = buffer.text.trim();
+        if (!value)
+            return;
+        setBuffer(EMPTY_BUFFER);
+        try {
+            if (value.startsWith("/")) {
+                if (value === "/history") {
+                    const nextHistory = discoverHistory();
+                    setHistory(nextHistory);
+                    setHistoryOpen(true);
+                    setMessage(nextHistory.length > 0 ? "history browser opened" : "no history sessions found");
+                    return;
+                }
+                runWorkboardCommand(value, {
+                    sessions: visibleSessions,
+                    history,
+                    selected,
+                    currentAgent,
+                    agents,
+                    workboard: {
+                        create: workboard.create.bind(workboard),
+                        restore: workboard.restore.bind(workboard),
+                        send: workboard.send.bind(workboard),
+                        setStatus: workboard.setStatus.bind(workboard),
+                        review: workboard.review.bind(workboard),
+                        kill: workboard.kill.bind(workboard),
+                        attach: attachSession
+                    },
+                    setSelected,
+                    setAgentIndex,
+                    setMessage,
+                    setReview: (title, content) => setReview({ title, content }),
+                    exit
+                });
+            }
+            else if (selectedSession?.exists) {
+                workboard.send(selectedSession.id, value);
+                setMessage(`sent to ${selectedSession.id}`);
+            }
+            else {
+                const created = workboard.create(currentAgent, value);
+                setMessage(`created ${created.id}`);
+            }
+            refresh();
+        }
+        catch (error) {
+            setMessage(error instanceof Error ? error.message : String(error));
+        }
+    }, [agents, attachSession, buffer.text, currentAgent, exit, history, refresh, selected, selectedSession, visibleSessions, workboard]);
+    const openSelected = useCallback(() => {
+        const session = selectedSession;
+        if (!session)
+            return;
+        attachSession(session.id);
+    }, [attachSession, selectedSession]);
+    const killSelected = useCallback(() => {
+        const session = selectedSession;
+        if (!session)
+            return;
+        workboard.kill(session.id);
+        setMessage(`stopped ${session.id}`);
+        refresh();
+    }, [refresh, selectedSession, workboard]);
+    const applySlashCommand = useCallback((item) => {
+        if (item.kind === "history") {
+            const nextHistory = discoverHistory();
+            setHistory(nextHistory);
+            setHistoryOpen(true);
+            setBuffer(EMPTY_BUFFER);
+            setMessage(nextHistory.length > 0 ? "history browser opened" : "no history sessions found");
+            return;
+        }
+        if (item.insertText) {
+            setBuffer({ text: item.insertText, cursor: item.insertText.length });
+            return;
+        }
+        setBuffer({ text: item.label, cursor: item.label.length });
+    }, []);
+    useTerminalInput((value, key) => {
+        if (historyOpen) {
+            if (key.escape) {
+                setHistoryOpen(false);
+                setMessage("history browser closed");
+                return;
+            }
+            if (key.upArrow || value === "k") {
+                setHistoryIndex((index) => Math.max(0, index - 1));
+                return;
+            }
+            if (key.downArrow || value === "j") {
+                setHistoryIndex((index) => Math.min(Math.max(0, history.length - 1), index + 1));
+                return;
+            }
+            if (key.return) {
+                restoreHistoryAt(historyIndex);
+                return;
+            }
+            if (key.ctrl && value === "c") {
+                setHistoryOpen(false);
+                setMessage("history browser closed");
+                return;
+            }
+            return;
+        }
+        if (key.ctrl && value === "c") {
+            const decision = decideCtrlC(buffer.text, pendingExitAt, Date.now());
+            setMessage(decision.message);
+            setPendingExitAt(decision.pendingExitAt);
+            if (decision.action === "clearPrompt") {
+                setBuffer(EMPTY_BUFFER);
+            }
+            else if (decision.action === "exit") {
+                exit();
+            }
+            return;
+        }
+        setPendingExitAt(null);
+        if (key.escape) {
+            setBuffer(EMPTY_BUFFER);
+            setMenuIndex(0);
+            setReview(null);
+            setHistoryOpen(false);
+            return;
+        }
+        if (key.ctrl && value === "n") {
+            setBuffer({ text: `/new ${currentAgent} `, cursor: `/new ${currentAgent} `.length });
+            return;
+        }
+        if (key.ctrl && value === "o") {
+            openSelected();
+            return;
+        }
+        if (key.ctrl && value === "x") {
+            killSelected();
+            return;
+        }
+        if (showSlashMenu && key.tab) {
+            setMenuIndex((index) => (index + 1) % slashMenu.length);
+            return;
+        }
+        if (!showSlashMenu && key.tab) {
+            setAgentIndex((index) => (index + 1) % Math.max(1, agents.length));
+            return;
+        }
+        if (key.return) {
+            if (showSlashMenu && slashMenu[menuIndex] && !key.shift) {
+                if (isExactSlashCommand(buffer.text, slashMenu[menuIndex])) {
+                    submit();
+                    return;
+                }
+                applySlashCommand(slashMenu[menuIndex]);
+                return;
+            }
+            if (key.shift) {
+                setBuffer((current) => insertText(current, "\n"));
+                return;
+            }
+            submit();
+            return;
+        }
+        if (key.backspace) {
+            setBuffer((current) => backspace(current));
+            return;
+        }
+        if (key.delete) {
+            setBuffer((current) => deleteForward(current));
+            return;
+        }
+        if (key.ctrl && value === "w") {
+            setBuffer((current) => deleteWordBefore(current));
+            return;
+        }
+        if (key.ctrl && value === "k") {
+            setBuffer((current) => killLine(current));
+            return;
+        }
+        if (key.home || (key.ctrl && value === "a")) {
+            setBuffer((current) => moveLineStart(current));
+            return;
+        }
+        if (key.end || (key.ctrl && value === "e")) {
+            setBuffer((current) => moveLineEnd(current));
+            return;
+        }
+        if (key.leftArrow) {
+            setBuffer((current) => (key.ctrl || key.meta ? moveWordLeft(current) : moveLeft(current)));
+            return;
+        }
+        if (key.rightArrow) {
+            setBuffer((current) => (key.ctrl || key.meta ? moveWordRight(current) : moveRight(current)));
+            return;
+        }
+        if (showSlashMenu && key.upArrow) {
+            setMenuIndex((index) => (index - 1 + slashMenu.length) % slashMenu.length);
+            return;
+        }
+        if (showSlashMenu && key.downArrow) {
+            setMenuIndex((index) => (index + 1) % slashMenu.length);
+            return;
+        }
+        if (key.upArrow && buffer.text.includes("\n")) {
+            setBuffer((current) => moveUp(current));
+            return;
+        }
+        if (key.downArrow && buffer.text.includes("\n")) {
+            setBuffer((current) => moveDown(current));
+            return;
+        }
+        if ((key.upArrow || value === "k") && buffer.text.length === 0) {
+            setSelected((index) => Math.max(0, index - 1));
+            return;
+        }
+        if ((key.downArrow || value === "j") && buffer.text.length === 0) {
+            setSelected((index) => Math.min(Math.max(0, visibleSessions.length - 1), index + 1));
+            return;
+        }
+        if (value >= " " && !key.ctrl && !key.meta) {
+            setBuffer((current) => insertText(current, value));
+        }
+    }, { isActive: !attaching });
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { bold: true, children: "Agent Workboard" }), _jsxs(Text, { color: "gray", children: [" tmux router / target: ", currentAgent, " / Tab cycles agent"] })] }), _jsx(Box, { flexDirection: "column", minHeight: 18, children: rows.length === 0 ? (_jsx(Text, { color: "gray", children: "No sessions yet. Type a task and press enter to create one." })) : (rows.map((row, rowIndex) => {
+                    if (row.kind === "heading") {
+                        return _jsx(StatusHeading, { status: row.status }, `heading-${row.status}-${rowIndex}`);
+                    }
+                    return (_jsx(SessionRow, { session: row.session, agentLabel: config.agents[row.session.agent]?.label ?? row.session.agent, selected: row.index === selected }, row.session.id));
+                })) }), historyOpen ? (_jsx(HistoryPicker, { history: history, selected: historyIndex })) : (_jsx(CurrentSessionPane, { session: selectedSession })), review ? _jsx(ReviewPane, { title: review.title, content: review.content }) : null, _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "gray", children: "─".repeat(Math.max(20, stdout.columns || 80)) }) }), showSlashMenu ? _jsx(SlashCommandMenu, { items: slashMenu, activeIndex: menuIndex, width: stdout.columns || 80 }) : null, _jsx(PromptMeta, { session: selectedSession, fallbackAgent: currentAgent }), _jsxs(Box, { children: [_jsx(PromptPrefix, { working: selectedWorking, spinnerIndex: spinnerIndex }), _jsx(PromptText, { buffer: buffer, placeholder: "describe a task or type / for commands" })] }), _jsx(Box, { children: _jsx(Text, { color: "gray", children: "─".repeat(Math.max(20, stdout.columns || 80)) }) }), _jsxs(Text, { color: "gray", children: ["enter send/create \u00B7 shift+enter newline \u00B7 / commands \u00B7 arrows edit/select \u00B7 ctrl+x stop", message ? ` · ${message}` : ""] })] }));
+}
+function StatusHeading({ status }) {
+    return (_jsx(Box, { marginTop: 1, children: _jsx(Text, { bold: status === "Working", color: status === "Working" ? "white" : "gray", children: status }) }));
+}
+function SessionRow({ session, agentLabel, selected }) {
+    const content = `${iconFor(session.status)} ${session.id.padEnd(30)} ${agentLabel.padEnd(13)} ${session.summary}`;
+    return (_jsxs(Box, { children: [_jsx(Text, { inverse: selected, bold: selected, color: selected ? "white" : colorFor(session.status), children: content }), _jsxs(Text, { inverse: selected, color: "gray", children: [" ", session.ageLabel] })] }));
+}
+function CurrentSessionPane({ session }) {
+    const title = session ? `${session.id} · ${session.status}` : "No session selected";
+    const lines = session?.latestMessageLines.length ? session.latestMessageLines : [session?.summary || "No current session message."];
+    const maxLines = 8;
+    const visibleLines = lines.slice(0, maxLines);
+    const truncated = lines.length > maxLines;
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", marginTop: 1, paddingX: 1, children: [_jsx(Text, { bold: true, children: "Current Session" }), _jsx(Text, { color: "gray", children: title }), visibleLines.map((line, index) => (_jsx(Text, { wrap: "truncate-end", children: line || " " }, `${index}-${line}`))), _jsx(Text, { color: "gray", children: truncated ? "… truncated · Ctrl+O or /open to view full tmux session." : "Ctrl+O or /open to view tmux session · /history for JSONL history." })] }));
+}
+function HistoryPicker({ history, selected }) {
+    const maxVisible = 10;
+    const visibleStart = Math.min(Math.max(0, selected - Math.floor((maxVisible - 1) / 2)), Math.max(0, history.length - maxVisible));
+    const visible = history.slice(visibleStart, visibleStart + maxVisible);
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "cyan", marginTop: 1, paddingX: 1, children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Text, { bold: true, children: "Discovered History" }), _jsx(Text, { color: "gray", children: "\u2191\u2193 select \u00B7 Enter resume \u00B7 Esc close" })] }), history.length === 0 ? (_jsx(Text, { color: "gray", children: "No JSONL history sessions found." })) : (visible.map((entry, index) => {
+                const actualIndex = visibleStart + index;
+                const active = actualIndex === selected;
+                return (_jsxs(Box, { children: [_jsxs(Text, { inverse: active, color: entry.agent === "codex" ? "cyan" : "magenta", children: [active ? "› " : "  ", entry.agent.padEnd(7)] }), _jsxs(Text, { inverse: active, color: "gray", children: [" ", entry.id.slice(0, 8).padEnd(10)] }), _jsx(Text, { inverse: active, wrap: "truncate-end", children: entry.title }), _jsxs(Text, { inverse: active, color: "gray", children: [" ", entry.ageLabel] })] }, `${entry.agent}-${entry.id}`));
+            })), history.length > 0 ? (_jsxs(Text, { color: "gray", children: [selected + 1, "/", history.length] })) : null] }));
+}
+function ReviewPane({ title, content }) {
+    const lines = content.split(/\r?\n/).slice(-18);
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", marginTop: 1, paddingX: 1, children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsxs(Text, { bold: true, children: ["Review ", title] }), _jsx(Text, { color: "gray", children: "Esc clears prompt \u00B7 /review refreshes" })] }), lines.map((line, index) => (_jsx(Text, { color: line.trim() ? undefined : "gray", wrap: "truncate-end", children: line || " " }, `${index}-${line}`))), _jsx(Box, { children: _jsx(Text, { color: "gray", children: "Type /open to attach \u00B7 Esc closes preview." }) })] }));
+}
+function PromptText({ buffer, placeholder }) {
+    if (buffer.text.length === 0) {
+        return (_jsxs(Text, { children: [_jsx(Text, { inverse: true, children: " " }), _jsx(Text, { color: "gray", children: placeholder })] }));
+    }
+    const before = buffer.text.slice(0, buffer.cursor);
+    const cursorChar = buffer.text[buffer.cursor] ?? " ";
+    const after = buffer.text.slice(buffer.cursor + (buffer.cursor < buffer.text.length ? 1 : 0));
+    return (_jsxs(Text, { children: [before, _jsx(Text, { inverse: true, children: cursorChar }), after] }));
+}
+function PromptPrefix({ working, spinnerIndex }) {
+    if (working) {
+        return (_jsxs(Text, { bold: true, color: "yellow", children: [SPINNER_FRAMES[spinnerIndex] ?? SPINNER_FRAMES[0], " "] }));
+    }
+    return (_jsxs(Text, { bold: true, color: "green", children: ["\u203A", " "] }));
+}
+function PromptMeta({ session, fallbackAgent }) {
+    if (session?.exists) {
+        return (_jsxs(Text, { color: "gray", children: ["session: ", session.id, " agent: ", session.agent] }));
+    }
+    return _jsxs(Text, { color: "gray", children: ["session: new agent: ", fallbackAgent] });
+}
+export function buildRows(sessions) {
+    const rows = [];
+    let displayIndex = 0;
+    for (const status of orderedStatuses()) {
+        const group = sessions.filter((session) => session.status === status);
+        if (group.length === 0)
+            continue;
+        rows.push({ kind: "heading", status });
+        for (const session of group) {
+            rows.push({ kind: "session", session, index: displayIndex });
+            displayIndex += 1;
+        }
+    }
+    return rows;
+}
+export function buildVisibleSessions(sessions) {
+    return orderedStatuses().flatMap((status) => sessions.filter((session) => session.status === status));
+}
+function iconFor(status) {
+    if (status === "Needs input")
+        return "*";
+    if (status === "Rate limited")
+        return "!";
+    if (status === "Completed")
+        return "*";
+    if (status === "Return pending")
+        return "*";
+    if (status === "human handoff")
+        return "!";
+    if (status === "agent routing")
+        return ">";
+    return "+";
+}
+function colorFor(status) {
+    if (status === "Needs input")
+        return "yellow";
+    if (status === "Rate limited")
+        return "red";
+    if (status === "Completed")
+        return "green";
+    if (status === "Return pending")
+        return "magenta";
+    if (status === "human handoff")
+        return "red";
+    if (status === "agent routing")
+        return "cyan";
+    return "gray";
+}

package/dist/workboard.js

@@ -0,0 +1,194 @@
+import { ageLabel, extractLatestMessageLines, inferStatus, initializationBlockedMessage, isAgentInitializationBlocked, summarize } from "./status.js";
+import { GlobalStateStore } from "./globalState.js";
+export class Workboard {
+    cwd;
+    config;
+    store;
+    tmux;
+    globalState;
+    constructor(cwd, config, store, tmux, globalState = new GlobalStateStore()) {
+        this.cwd = cwd;
+        this.config = config;
+        this.store = store;
+        this.tmux = tmux;
+        this.globalState = globalState;
+    }
+    list() {
+        return this.store.read().map((session) => {
+            const exists = this.tmux.hasSession(session.tmuxSession);
+            const capture = exists ? this.tmux.capture(session.tmuxSession) : "";
+            const initializationBlocked = isAgentInitializationBlocked(capture);
+            const status = session.statusOverride ?? inferStatus(capture, exists);
+            return {
+                ...session,
+                exists,
+                status,
+                summary: initializationBlocked ? initializationBlockedMessage() : capture.trim() ? summarize(capture) : session.title,
+                latestMessageLines: initializationBlocked
+                    ? [initializationBlockedMessage()]
+                    : capture.trim()
+                        ? extractLatestMessageLines(capture)
+                        : [],
+                ageLabel: ageLabel(session.updatedAt)
+            };
+        });
+    }
+    create(agent, task) {
+        const agentConfig = this.config.agents[agent];
+        if (!agentConfig) {
+            throw new Error(`Unknown agent "${agent}". Known agents: ${Object.keys(this.config.agents).join(", ")}`);
+        }
+        const id = makeId(task);
+        const tmuxSession = `${this.config.tmuxPrefix}-${id}`;
+        const now = new Date().toISOString();
+        const record = {
+            id,
+            title: task.slice(0, 80) || id,
+            agent,
+            tmuxSession,
+            createdAt: now,
+            updatedAt: now
+        };
+        if (!this.tmux.hasSession(tmuxSession)) {
+            this.tmux.newSession(tmuxSession, this.cwd, agentConfig.command);
+        }
+        this.store.upsert(record);
+        const startupCapture = waitForStartupCapture(this.tmux, tmuxSession);
+        if (isAgentInitializationBlocked(startupCapture)) {
+            this.store.upsert({ ...record, statusOverride: "Needs input" });
+            return record;
+        }
+        this.tmux.sendKeys(tmuxSession, task);
+        return record;
+    }
+    restore(history) {
+        const agentConfig = this.config.agents[history.agent];
+        if (!agentConfig) {
+            throw new Error(`Unknown agent "${history.agent}". Known agents: ${Object.keys(this.config.agents).join(", ")}`);
+        }
+        const mapping = this.globalState.findByHistoryId(history.id);
+        const existing = this.store.read().find((session) => session.historyId === history.id);
+        const now = new Date().toISOString();
+        const record = existing ?? {
+            id: mapping?.sessionId ?? `${history.agent}-${safeId(history.id)}`,
+            title: history.title,
+            agent: history.agent,
+            tmuxSession: mapping?.tmuxSession ?? `${this.config.tmuxPrefix}-${history.agent}-${safeId(history.id)}`,
+            createdAt: mapping?.createdAt ?? now,
+            updatedAt: now,
+            historyId: history.id,
+            historyPath: history.sourcePath
+        };
+        if (!this.tmux.hasSession(record.tmuxSession)) {
+            this.tmux.newSession(record.tmuxSession, history.cwd ?? this.cwd, renderResumeCommand(agentConfig.resumeCommand ?? agentConfig.command, history));
+        }
+        const next = {
+            ...record,
+            title: history.title,
+            updatedAt: now,
+            historyId: history.id,
+            historyPath: history.sourcePath,
+            statusOverride: undefined
+        };
+        this.store.upsert(next);
+        this.globalState.upsertMapping({
+            historyId: history.id,
+            historyPath: history.sourcePath,
+            agent: history.agent,
+            sessionId: next.id,
+            tmuxSession: next.tmuxSession,
+            cwd: history.cwd ?? this.cwd,
+            title: history.title,
+            createdAt: next.createdAt,
+            updatedAt: now
+        });
+        return next;
+    }
+    send(id, input) {
+        const session = this.find(id);
+        if (!session)
+            throw new Error(`Unknown session "${id}".`);
+        if (!this.tmux.hasSession(session.tmuxSession))
+            throw new Error(`tmux session "${session.tmuxSession}" is not running.`);
+        const capture = this.tmux.capture(session.tmuxSession);
+        if (isAgentInitializationBlocked(capture)) {
+            this.store.upsert({ ...session, updatedAt: new Date().toISOString(), statusOverride: "Needs input" });
+            throw new Error(initializationBlockedMessage());
+        }
+        this.tmux.sendKeys(session.tmuxSession, input);
+        this.store.upsert({ ...session, updatedAt: new Date().toISOString(), statusOverride: undefined });
+    }
+    setStatus(id, status) {
+        const session = this.find(id);
+        if (!session)
+            throw new Error(`Unknown session "${id}".`);
+        this.store.upsert({ ...session, statusOverride: status, updatedAt: new Date().toISOString() });
+    }
+    kill(id) {
+        const session = this.find(id);
+        if (!session)
+            return;
+        this.tmux.kill(session.tmuxSession);
+        this.store.upsert({ ...session, updatedAt: new Date().toISOString(), statusOverride: "Completed" });
+    }
+    attach(id) {
+        const session = this.find(id);
+        if (!session)
+            throw new Error(`Unknown session "${id}".`);
+        this.tmux.attach(session.tmuxSession);
+    }
+    review(id, lines = 30) {
+        const session = this.find(id);
+        if (!session)
+            throw new Error(`Unknown session "${id}".`);
+        if (!this.tmux.hasSession(session.tmuxSession)) {
+            throw new Error(`tmux session "${session.tmuxSession}" is not running.`);
+        }
+        return this.tmux.capture(session.tmuxSession, lines);
+    }
+    find(id) {
+        const sessions = this.store.read();
+        return sessions.find((session) => session.id === id || session.tmuxSession === id || session.title === id);
+    }
+}
+function renderResumeCommand(template, history) {
+    return template
+        .replaceAll("{sessionId}", shellQuote(history.id))
+        .replaceAll("{sourcePath}", shellQuote(history.sourcePath))
+        .replaceAll("{cwd}", shellQuote(history.cwd ?? ""))
+        .replaceAll("{title}", shellQuote(history.title));
+}
+function makeId(input) {
+    const base = input
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 28);
+    const suffix = Math.random().toString(36).slice(2, 6);
+    return `${base || "session"}-${suffix}`;
+}
+function safeId(input) {
+    return input
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 36) || "history";
+}
+function shellQuote(input) {
+    return `'${input.replaceAll("'", "'\\''")}'`;
+}
+function waitForStartupCapture(tmux, tmuxSession) {
+    let capture = "";
+    for (let attempt = 0; attempt < 8; attempt++) {
+        capture = tmux.capture(tmuxSession, 40);
+        if (isAgentInitializationBlocked(capture))
+            return capture;
+        if (capture.trim())
+            return capture;
+        sleep(100);
+    }
+    return capture;
+}
+function sleep(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}