@higherdev/cli 0.3.0 → 0.5.0

package/dist/tui/Panels.js

@@ -0,0 +1,195 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { BOARD_COLUMNS, availabilityLabel, statusLabel, statusTone, } from "./data.js";
+import { elapsed, pad, relativeTime, truncate } from "../out/format.js";
+import { inkColor } from "../out/theme.js";
+import { UI } from "./theme.js";
+import { BoundedPanel as Panel, Heading, More, contentRows } from "./bounded.js";
+const DOT = "●";
+/**
+ * The single-purpose views behind /board, /agents, /feed and /inbox. Each is
+ * handed a row budget and draws inside it, heading and overflow row included,
+ * because the live frame's height is the sum of those budgets. See
+ * `bounded.tsx` for why the bound is structural rather than arithmetic.
+ */
+export function AgentsPanel({ board, width = 80, rows = 12, }) {
+    const shown = board.agents.slice(0, contentRows(rows, board.agents.length));
+    return (_jsx(Panel, { width: width, rows: rows, children: [
+            _jsx(Heading, { text: "Agents", note: `${board.agents.length}` }, "h"),
+            ...(board.agents.length === 0
+                ? [
+                    _jsx(Text, { color: UI.dim, children: "No agents yet." }, "empty"),
+                ]
+                : []),
+            ...shown.map((agent) => {
+                const run = board.runs.find((row) => row.agent_id === agent.id && row.status === "running");
+                const ticket = run?.ticket_id
+                    ? board.tickets.find((item) => item.id === run.ticket_id)
+                    : undefined;
+                const availability = board.availability.find((row) => row.provider === agent.provider);
+                const blocked = availability && !availability.available ? availabilityLabel(availability) : "";
+                const tone = !agent.enabled ? "muted" : run ? "blue" : blocked ? "warning" : "muted";
+                return (_jsxs(Text, { wrap: "truncate", children: [_jsxs(Text, { color: inkColor(tone), children: [DOT, " "] }), _jsx(Text, { color: UI.text, children: pad(truncate(agent.display_name, 13), 14) }), _jsx(Text, { color: UI.dim, children: pad(agent.role, 13) }), _jsx(Text, { color: UI.dim, children: pad(truncate(agent.model, 23), 24) }), _jsx(Text, { color: UI.text, children: pad(run ? "running" : blocked ? "blocked" : "idle", 9) }), _jsxs(Text, { color: UI.dim, children: [ticket ? `${ticket.key} ` : "", run ? elapsed(run.started_at ?? run.created_at) : blocked] })] }, agent.id));
+            }),
+            _jsx(More, { count: board.agents.length - shown.length }, "more"),
+        ] }));
+}
+export function BoardPanel({ board, width = 80, rows = 12, cursor, }) {
+    const active = BOARD_COLUMNS.filter((status) => board.tickets.some((ticket) => ticket.status === status));
+    // A group costs its heading before it costs a ticket, so both come out of
+    // the same budget.
+    const budget = contentRows(rows, board.tickets.length + active.length);
+    const lines = [];
+    let dropped = 0;
+    for (const status of active) {
+        const tickets = board.tickets.filter((ticket) => ticket.status === status);
+        if (lines.length + 1 >= budget) {
+            dropped += tickets.length;
+            continue;
+        }
+        lines.push(_jsxs(Text, { color: inkColor(statusTone(status)), wrap: "truncate", children: [statusLabel(status), " ", _jsxs(Text, { color: UI.dim, children: ["(", tickets.length, ")"] })] }, status));
+        for (const ticket of tickets) {
+            if (lines.length >= budget) {
+                dropped += 1;
+                continue;
+            }
+            lines.push(_jsx(TicketLine, { ticket: ticket, width: width, selected: ticket.id === cursor }, ticket.id));
+        }
+    }
+    return (_jsx(Panel, { width: width, rows: rows, children: [
+            _jsx(Heading, { text: "Board", note: `${board.tickets.length}` }, "h"),
+            ...(board.tickets.length === 0
+                ? [
+                    _jsx(Text, { color: UI.dim, children: "No tickets yet." }, "empty"),
+                ]
+                : lines),
+            _jsx(More, { count: dropped }, "more"),
+        ] }));
+}
+function TicketLine({ ticket, width, selected, }) {
+    return (_jsxs(Text, { wrap: "truncate", children: [_jsx(Text, { color: selected ? UI.accent : UI.dim, children: selected ? " > " : "   " }), _jsx(Text, { color: UI.text, bold: true, children: pad(ticket.key, 8) }), _jsx(Text, { color: UI.text, children: pad(truncate(ticket.title, 43), 44) }), _jsx(Text, { color: UI.dim, children: pad(ticket.agent_name ?? "", 14) }), ticket.stuck ? (_jsx(Text, { color: UI.warn, children: truncate(ticket.stuck, Math.max(8, width - 70)) })) : null] }));
+}
+export function FeedPanel({ entries, width = 80, rows = 12, }) {
+    const shown = entries.slice(0, contentRows(rows, entries.length));
+    return (_jsx(Panel, { width: width, rows: rows, children: [
+            _jsx(Heading, { text: "Feed", note: `${entries.length}` }, "h"),
+            ...(entries.length === 0
+                ? [
+                    _jsx(Text, { color: UI.dim, children: "Nothing yet." }, "empty"),
+                ]
+                : []),
+            ...shown.map((row, index) => (_jsxs(Text, { wrap: "truncate", children: [_jsx(Text, { color: UI.dim, children: pad(relativeTime(row.at), 10) }), _jsx(Text, { color: UI.dim, children: pad(row.kind ?? "", 18) }), _jsx(Text, { color: UI.text, children: truncate(row.summary ?? "", Math.max(8, width - 30)) })] }, row.id ?? index))),
+            _jsx(More, { count: entries.length - shown.length }, "more"),
+        ] }));
+}
+/**
+ * The whole queue, one row each, numbered the way `/decide` reaches them: the
+ * one on screen is 1.
+ */
+export function InboxPanel({ board, width = 80, rows = 12, }) {
+    const shown = board.decisions.slice(0, contentRows(rows, board.decisions.length));
+    return (_jsx(Panel, { width: width, rows: rows, children: [
+            _jsx(Heading, { text: "Decisions", note: `${board.decisions.length}` }, "h"),
+            ...(board.decisions.length === 0
+                ? [
+                    _jsx(Text, { color: UI.dim, children: "Nothing waiting on you." }, "empty"),
+                ]
+                : []),
+            ...shown.map((decision, index) => {
+                const ticket = board.tickets.find((row) => row.id === decision.ticket_id);
+                return (_jsxs(Text, { wrap: "truncate", children: [_jsx(Text, { color: index === 0 ? UI.warn : UI.dim, children: pad(`${index + 1})`, 3) }), _jsx(Text, { color: UI.dim, children: pad(ticket?.key ?? decision.id.slice(0, 8), 9) }), _jsx(Text, { color: UI.text, children: truncate(decision.question_md, Math.max(12, width - 14)) })] }, decision.id));
+            }),
+            _jsx(More, { count: board.decisions.length - shown.length }, "more"),
+        ] }));
+}
+/**
+ * One ticket in full, inside the rows it was given.
+ *
+ * Built as a list and sliced rather than reasoned about line by line. Every
+ * header line truncates, so each costs exactly one row, and the body takes
+ * whatever is left. Counting rows by hand is what let a wrapping title spend
+ * rows nothing had budgeted, and a frame past the window is one Ink stops
+ * repainting in place.
+ */
+export function TicketPanel({ ticket, width = 80, rows = 24, }) {
+    const lines = [
+        _jsxs(Text, { color: UI.text, bold: true, wrap: "truncate", children: [ticket.key, " ", ticket.title] }, "title"),
+        _jsxs(Box, { flexWrap: "nowrap", children: [_jsx(Text, { color: inkColor(statusTone(ticket.status)), wrap: "truncate", children: statusLabel(ticket.status) }), _jsxs(Text, { color: UI.dim, wrap: "truncate", children: [ticket.area ? `  ${ticket.area}` : "", ticket.agent_name ? `  ${ticket.agent_name}` : "  unassigned", ticket.attempts ? `  attempt ${ticket.attempts}` : ""] })] }, "status"),
+    ];
+    if (ticket.stuck) {
+        lines.push(_jsxs(Text, { color: UI.warn, wrap: "truncate", children: ["why: ", ticket.stuck] }, "stuck"));
+    }
+    if (ticket.blocker_keys.length) {
+        lines.push(_jsxs(Text, { color: UI.dim, wrap: "truncate", children: ["blocked by ", ticket.blocker_keys.join(", ")] }, "blocked"));
+    }
+    if (ticket.pr_url) {
+        lines.push(_jsx(Text, { color: UI.accent, wrap: "truncate", children: ticket.pr_url }, "pr"));
+    }
+    // The blank row before the body comes out of the body's own allowance.
+    const drawable = Math.max(0, rows);
+    const body = clipToRows(ticket.body_md.trim(), Math.max(20, width), Math.max(0, drawable - lines.length - 1));
+    if (body) {
+        lines.push(_jsx(Box, { height: 1 }, "gap"));
+        lines.push(_jsx(Text, { color: UI.text, wrap: "wrap", children: body }, "body"));
+    }
+    return (_jsx(Panel, { width: width, rows: drawable, children: lines }));
+}
+/**
+ * Text cut to the rows it may occupy once wrapped.
+ *
+ * Wrapped the way Ink wraps it, on word boundaries. Counting characters
+ * instead under-counts every time, because a word that will not fit ends the
+ * line early: 240 characters of prose is five rows of 48 columns by division
+ * and six rows on screen. That difference is a panel drawing past its budget.
+ */
+export function clipToRows(text, width, rows) {
+    if (rows <= 0 || !text || width <= 0)
+        return "";
+    const out = [];
+    let dropped = false;
+    for (const paragraph of text.split("\n")) {
+        if (out.length >= rows) {
+            dropped = true;
+            break;
+        }
+        let line = "";
+        for (const word of paragraph.split(/\s+/).filter(Boolean)) {
+            const candidate = line ? `${line} ${word}` : word;
+            if (candidate.length <= width) {
+                line = candidate;
+                continue;
+            }
+            if (line) {
+                out.push(line);
+                line = "";
+                if (out.length >= rows)
+                    break;
+            }
+            // A single word wider than the column is broken, the way Ink breaks it.
+            let rest = word;
+            while (rest.length > width) {
+                if (out.length >= rows)
+                    break;
+                out.push(rest.slice(0, width));
+                rest = rest.slice(width);
+            }
+            if (out.length >= rows)
+                break;
+            line = rest;
+        }
+        if (out.length >= rows) {
+            dropped = true;
+            break;
+        }
+        out.push(line);
+    }
+    if (out.length > rows) {
+        out.length = rows;
+        dropped = true;
+    }
+    if (dropped && out.length > 0) {
+        const last = out[out.length - 1];
+        out[out.length - 1] = last.length >= width ? `${last.slice(0, width - 1)}…` : `${last}…`;
+    }
+    return out.join("\n");
+}

package/dist/tui/Settings.js

@@ -0,0 +1,45 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text } from "ink";
+import { pad, truncate } from "../out/format.js";
+import { BoundedPanel as Panel, Heading } from "./bounded.js";
+import { scrollWindow } from "./Dashboard.js";
+import { UI } from "./theme.js";
+/**
+ * The settings screen. One row per thing you can change, scrolling under the
+ * cursor the way the board does, and bounded the way every panel here is: the
+ * live frame's height is the sum of the budgets its panels were given.
+ */
+export function SettingsPanel({ entries, width, rows, title = "Settings", cursor, editing, }) {
+    const inner = Math.max(0, rows - 1);
+    const focus = cursor ? entries.findIndex((row) => row.key === cursor) : -1;
+    const { start, end } = scrollWindow(entries.length, inner, focus);
+    const label = Math.max(10, Math.min(18, Math.round(width / 4)));
+    return (_jsx(Panel, { width: width, rows: rows, children: [
+            _jsx(Heading, { text: title, note: hidden(entries.length, start, end) }, "h"),
+            ...entries.slice(start, end).map((row) => {
+                if (row.kind === "heading") {
+                    return (_jsxs(Text, { wrap: "truncate", children: [_jsx(Text, { color: UI.text, bold: true, children: row.label }), _jsx(Text, { color: UI.dim, children: `  ${row.value}` })] }, row.key));
+                }
+                const selected = row.key === cursor;
+                const typing = editing?.key === row.key;
+                if (row.kind === "action") {
+                    return (_jsxs(Text, { wrap: "truncate", children: [_jsx(Text, { color: UI.accent, children: selected ? " › " : "   " }), _jsx(Text, { color: UI.cream, bold: true, inverse: selected, children: pad(truncate(row.label, label - 1), label) }), _jsx(Text, { color: UI.dim, children: truncate(row.value, Math.max(8, width - label - 6)) })] }, row.key));
+                }
+                return (_jsxs(Text, { wrap: "truncate", children: [_jsx(Text, { color: UI.accent, children: selected ? " › " : "   " }), _jsx(Text, { color: UI.dim, children: pad(truncate(row.label, label - 1), label) }), _jsx(Text, { color: typing ? UI.cream : UI.text, inverse: selected && !typing, children: truncate(typing ? `${editing.draft}▏` : row.value || "-", valueWidth(width, label, row, selected)) }), selected && row.hint && !typing ? (_jsx(Text, { color: UI.dim, children: `  ${row.hint}` })) : null] }, row.key));
+            }),
+        ] }));
+}
+/** The value gives up room to the hint, on the one row showing a hint. */
+function valueWidth(width, label, row, selected) {
+    const room = Math.max(8, width - label - 6);
+    if (!selected || !row.hint)
+        return room;
+    return Math.max(8, room - row.hint.length - 2);
+}
+function hidden(count, start, end) {
+    const above = start;
+    const below = count - end;
+    if (above === 0 && below === 0)
+        return `${count}`;
+    return `${count}  ${above > 0 ? `${above}↑ ` : ""}${below > 0 ? `${below}↓` : ""}`.trimEnd();
+}

package/dist/tui/Splash.js

@@ -0,0 +1,15 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Banner } from "./Banner.js";
+import { Help, HelpHint } from "./Help.js";
+/**
+ * What the app shows before you have done anything: the wordmark, and the
+ * commands under it.
+ *
+ * The measuring and the drawing live together on purpose. They were two pieces
+ * of code that had to agree about which form of the command list was on
+ * screen, and when they stopped agreeing the frame silently outgrew the window
+ * while the arithmetic still claimed it fitted.
+ */
+export function Splash({ columns, rows, width, ready, helpFull, animate, onDone, }) {
+    return (_jsxs(_Fragment, { children: [_jsx(Banner, { animate: animate, onDone: onDone, columns: columns, rows: rows }), ready ? helpFull ? _jsx(Help, { width: width }) : _jsx(HelpHint, { width: width }) : null] }));
+}

package/dist/tui/TextInput.js

@@ -0,0 +1,137 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from "react";
+import { Text, useInput, usePaste } from "ink";
+import { UI } from "./theme.js";
+/**
+ * A single-line editor with the things a hand-rolled `value + ch` prompt never
+ * has: a real cursor, word operations, and bracketed paste. Adapted from the
+ * same component in gtm2-cli, which had already learned the edge cases.
+ *
+ * Readline bindings are supported because that is what muscle memory expects in
+ * a terminal: ctrl+a / ctrl+e for ends, ctrl+w to rub out a word, ctrl+u and
+ * ctrl+k to kill to either end.
+ */
+/**
+ * Never let stray control bytes into the value; they corrupt the layout and
+ * are invisible to whoever is typing.
+ */
+function printableOf(text) {
+    // eslint-disable-next-line no-control-regex
+    return text.replace(/[\x00-\x1f\x7f]/g, "");
+}
+export default function TextInput({ value, onChange, onSubmit, onCancel, onUp, onDown, isActive = true, placeholder = "", prompt, color, }) {
+    const [cursor, setCursor] = useState(value.length);
+    // The last value this component produced. Anything else arriving in `value`
+    // was swapped in by the caller.
+    const ours = useRef(value);
+    /**
+     * A value replaced from outside takes the cursor to its end. History recall
+     * and opening a settings field both swap the whole value in, and leaving the
+     * cursor where the old one left it put the next character typed in front of
+     * what had just been recalled.
+     */
+    useEffect(() => {
+        if (value === ours.current)
+            return;
+        ours.current = value;
+        setCursor(value.length);
+    }, [value]);
+    /** Reports a change this component made, so the effect above ignores it. */
+    const change = (next) => {
+        ours.current = next;
+        onChange(next);
+    };
+    const insert = (text) => {
+        const next = value.slice(0, cursor) + text + value.slice(cursor);
+        change(next);
+        setCursor(cursor + text.length);
+    };
+    usePaste((text) => {
+        // Newlines would break a single-line field, so flatten them to spaces.
+        insert(text.replace(/[\r\n]+/g, " "));
+    }, { isActive });
+    useInput((input, key) => {
+        // Ink only flags key.return for CR. A bare LF reaches us as ordinary
+        // input, which some terminals and pty layers do send, and inserting it
+        // would put a literal newline in a single-line field.
+        if (key.return || input === "\r" || input === "\n" || input === "\r\n")
+            return onSubmit?.(value);
+        if (key.escape)
+            return onCancel?.();
+        if (key.upArrow)
+            return onUp?.();
+        if (key.downArrow)
+            return onDown?.();
+        // A whole line and its Enter can arrive as a single chunk. Unbracketed
+        // paste does it, and so does any link that buffers, which over ssh is
+        // most of them. Ink reports that as ordinary input with key.return
+        // false, so without this the Enter is filtered out with the other
+        // control bytes and the line just sits at the prompt unsent.
+        if (input.length > 1 && /[\r\n]/.test(input)) {
+            const parts = input.split(/\r\n|\r|\n/);
+            const submits = parts.length === 2 && parts[1] === "";
+            if (submits) {
+                const next = value.slice(0, cursor) + printableOf(parts[0]) + value.slice(cursor);
+                change(next);
+                setCursor(next.length);
+                return onSubmit?.(next);
+            }
+            // Several lines in a single-line field. Running the first and dropping
+            // the rest loses what someone meant to send, so they are joined.
+            const flat = printableOf(input.replace(/[\r\n]+/g, " "));
+            change(value.slice(0, cursor) + flat + value.slice(cursor));
+            return setCursor(cursor + flat.length);
+        }
+        if (key.leftArrow)
+            return setCursor((c) => Math.max(0, c - 1));
+        if (key.rightArrow)
+            return setCursor((c) => Math.min(value.length, c + 1));
+        if (key.home)
+            return setCursor(0);
+        if (key.end)
+            return setCursor(value.length);
+        if (key.backspace) {
+            if (cursor === 0)
+                return;
+            change(value.slice(0, cursor - 1) + value.slice(cursor));
+            return setCursor(cursor - 1);
+        }
+        if (key.delete) {
+            if (cursor >= value.length)
+                return;
+            return change(value.slice(0, cursor) + value.slice(cursor + 1));
+        }
+        if (key.ctrl) {
+            switch (input) {
+                case "a":
+                    return setCursor(0);
+                case "e":
+                    return setCursor(value.length);
+                case "u": // kill to start
+                    change(value.slice(cursor));
+                    return setCursor(0);
+                case "k": // kill to end
+                    return change(value.slice(0, cursor));
+                case "w": {
+                    // Rub out the word before the cursor, plus any spaces run into.
+                    const head = value.slice(0, cursor);
+                    const trimmed = head.replace(/\s*\S*$/, "");
+                    change(trimmed + value.slice(cursor));
+                    return setCursor(trimmed.length);
+                }
+                default:
+                    return;
+            }
+        }
+        if (key.meta || !input)
+            return;
+        const printable = printableOf(input);
+        if (printable)
+            insert(printable);
+    }, { isActive });
+    const showPlaceholder = value.length === 0 && placeholder.length > 0;
+    const before = value.slice(0, cursor);
+    const at = value[cursor] ?? " ";
+    const after = value.slice(cursor + 1);
+    return (_jsxs(Text, { children: [prompt, showPlaceholder ? (_jsxs(_Fragment, { children: [isActive ? _jsx(Text, { inverse: true, children: placeholder[0] }) : _jsx(Text, { children: placeholder[0] }), _jsx(Text, { color: UI.dim, children: placeholder.slice(1) })] })) : (_jsxs(_Fragment, { children: [_jsx(Text, { color: color, children: before }), isActive ? (_jsx(Text, { inverse: true, color: color, children: at })) : (_jsx(Text, { color: color, children: at === " " ? "" : at })), _jsx(Text, { color: color, children: after })] }))] }));
+}

package/dist/tui/alert.js

@@ -0,0 +1,19 @@
+/** BEL, built from its code point so the source holds no control characters. */
+const BELL = String.fromCharCode(7);
+/**
+ * The terminal bell, for a decision that has just started blocking work.
+ *
+ * A bell is a single control character with no cursor movement, so it does not
+ * disturb the frame Ink is painting around it. It is the only way this app can
+ * reach someone whose window is behind something else, which is where an
+ * operator usually is when a decision arrives. `HIGHERDEV_NO_BELL` turns it
+ * off, since some terminals answer a bell by flashing the whole screen.
+ */
+export function alertOnce(stream = process.stdout, env = process.env) {
+    if (env.HIGHERDEV_NO_BELL)
+        return false;
+    if (!stream.isTTY)
+        return false;
+    stream.write(BELL);
+    return true;
+}

package/dist/tui/bounded.js

@@ -0,0 +1,37 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { UI } from "./theme.js";
+/**
+ * Panels that cannot draw more rows than they were given.
+ *
+ * Every panel in this app is handed a row budget and the live frame's height
+ * is the sum of those budgets, because past the window's height Ink stops
+ * erasing and appends a full copy of the screen on every keystroke. Getting
+ * that arithmetic right by hand has failed once per panel: a heading counted
+ * twice, an overflow row added after the budget was spent, a wrapped line
+ * costing two rows. So the bound is structural here rather than arithmetic.
+ * The slice is what makes it a guarantee.
+ */
+export function BoundedPanel({ width, rows, children, }) {
+    return (_jsx(Box, { flexDirection: "column", width: width, children: children.filter(Boolean).slice(0, Math.max(0, rows)) }));
+}
+/**
+ * Rows left for content after the heading, and after the row that says what
+ * did not fit. The overflow line comes out of the budget rather than being
+ * added to it, which is the mistake worth naming: a panel that reports its own
+ * truncation in an extra row is one row taller than it claimed.
+ */
+export function contentRows(rows, items) {
+    const forContent = Math.max(0, rows - 1);
+    return items <= forContent ? forContent : Math.max(0, forContent - 1);
+}
+/** A row saying what the panel could not fit, so nothing goes missing silently. */
+export function More({ count }) {
+    if (count <= 0)
+        return null;
+    return _jsx(Text, { color: UI.dim, children: `  +${count} more` });
+}
+/** A panel's heading, which never wraps, so it always costs exactly one row. */
+export function Heading({ text, note }) {
+    return (_jsxs(Box, { flexWrap: "nowrap", children: [_jsx(Text, { color: UI.text, bold: true, wrap: "truncate", children: text }), note ? (_jsxs(Text, { color: UI.dim, wrap: "truncate", children: [" ", note] })) : null] }));
+}

package/dist/tui/capability.js

@@ -0,0 +1,4 @@
+/** Ink needs both terminal streams. Every caller shares this launch gate. */
+export function canLaunchApp(streams = { stdin: process.stdin, stdout: process.stdout }) {
+    return streams.stdin.isTTY === true && streams.stdout.isTTY === true;
+}

package/dist/tui/data.js

@@ -0,0 +1,165 @@
+import { answerDecision, getStatus, listAgents, listEpics, listFeed, listMessages, listTicketEvents, listTickets, postMessage as sendMessage, showTicket, updateAgent as patchAgent, updateCaps, } from "../api.js";
+import { loadConfig, loadStoredConfig, switchWorkspace as selectWorkspace, } from "../config.js";
+export const POLL_MS = 5_000;
+export const providers = ["claude", "codex", "gemini", "grok"];
+export const efforts = ["low", "medium", "high"];
+export const BOARD_COLUMNS = [
+    "backlog",
+    "ready",
+    "queued",
+    "running",
+    "in_review",
+    "changes_requested",
+    "approved",
+    "needs_decision",
+    "blocked",
+    "failed",
+    "merged",
+    "cancelled",
+];
+export function configuredSlugs() {
+    return Object.keys(loadStoredConfig().workspaces).sort();
+}
+export async function loadSnapshot(config = loadConfig()) {
+    const [status, ticketData, agentData, epicData, feedData] = await Promise.all([
+        getStatus(config),
+        listTickets(config),
+        listAgents(config),
+        listEpics(config),
+        listFeed(config),
+    ]);
+    const byId = new Map(ticketData.tickets.map((ticket) => [ticket.id, ticket]));
+    const agents = new Map(agentData.agents.map((agent) => [agent.id, agent]));
+    const tickets = ticketData.tickets.map((ticket) => ({
+        ...ticket,
+        agent_name: ticket.agent_id ? agents.get(ticket.agent_id)?.display_name ?? null : null,
+        blocker_keys: ticket.blocked_by.map((id) => byId.get(id)?.key).filter((key) => Boolean(key)),
+        stuck: ticket.stuck_reason,
+    }));
+    const caps = status.workspace.provider_caps ?? {};
+    const availability = providers.map((provider) => {
+        const cap = Number(caps[provider] ?? 0);
+        return { provider, available: cap > 0, reason: cap > 0 ? "available" : "cap 0" };
+    });
+    return {
+        config,
+        workspace: status.workspace,
+        board: {
+            tickets,
+            agents: agentData.agents,
+            epics: epicData.epics,
+            decisions: status.decisions,
+            availability,
+            runs: status.live_runs,
+        },
+        feed: feedData.entries,
+    };
+}
+export function pollSnapshot(config, onSnapshot, onState, onError) {
+    let closed = false;
+    let active = false;
+    const refresh = async () => {
+        if (closed || active)
+            return;
+        active = true;
+        try {
+            const snapshot = await loadSnapshot(config);
+            if (closed)
+                return;
+            onSnapshot(snapshot);
+            onState("live");
+        }
+        catch (error) {
+            if (closed)
+                return;
+            onState("offline");
+            onError(error);
+        }
+        finally {
+            active = false;
+        }
+    };
+    const timer = setInterval(() => void refresh(), POLL_MS);
+    void refresh();
+    return { refresh, close: () => { closed = true; clearInterval(timer); } };
+}
+export async function switchWorkspace(slug) {
+    return loadSnapshot(selectWorkspace(slug));
+}
+export async function postOrchestrator(body, config) {
+    await sendMessage({ body_md: body, to_role: "orchestrator", delivery: "queue" }, config);
+}
+export async function loadTicketDetail(config, key) {
+    return showTicket(key, config);
+}
+export async function waitForReply(config, since, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() <= deadline) {
+        const { messages } = await listMessages({ since, limit: 50 }, config);
+        const reply = messages.find((message) => ["orchestrator", "reviewer"].includes(message.from_role) &&
+            ["human", "operator", "all"].includes(message.to_role));
+        if (reply)
+            return reply.body_md;
+        await new Promise((resolve) => setTimeout(resolve, POLL_MS));
+    }
+    return null;
+}
+export async function resolveDecision(config, id, answer) {
+    await answerDecision(id, answer, config);
+}
+export async function updateAgent(config, id, fields) {
+    return patchAgent(id, fields, config);
+}
+export async function updateProviderCap(config, provider, cap) {
+    return updateCaps({ [provider]: cap }, config);
+}
+export async function loadLiveEvents(config, board) {
+    const liveIds = new Set(board.runs.filter((run) => run.status === "running").map((run) => run.id));
+    const keys = new Set(board.runs
+        .filter((run) => liveIds.has(run.id) && run.ticket_id)
+        .map((run) => board.tickets.find((ticket) => ticket.id === run.ticket_id)?.key)
+        .filter((key) => Boolean(key)));
+    const batches = await Promise.all([...keys].map((key) => listTicketEvents(key, undefined, undefined, config)));
+    return batches
+        .flatMap((batch) => batch.events)
+        .filter((event) => liveIds.has(event.run_id))
+        .sort((left, right) => left.at.localeCompare(right.at) || left.seq - right.seq);
+}
+export function decisionOptions(decision) {
+    if (Array.isArray(decision.options))
+        return decision.options.filter((value) => typeof value === "string");
+    return [];
+}
+export function statusLabel(status) {
+    return status.replaceAll("_", " ");
+}
+export function statusTone(status) {
+    if (["queued", "running", "in_review"].includes(status))
+        return "blue";
+    if (["ready", "approved", "merged"].includes(status))
+        return "success";
+    if (["changes_requested", "needs_decision", "blocked"].includes(status))
+        return "warning";
+    if (["failed", "cancelled"].includes(status))
+        return "danger";
+    return "muted";
+}
+export function availabilityLabel(row) {
+    return row.reason;
+}
+export function epicProgress(board) {
+    return board.epics.map((epic) => {
+        const tickets = board.tickets.filter((ticket) => ticket.epic_id === epic.id);
+        return {
+            epic,
+            merged: tickets.filter((ticket) => ticket.status === "merged").length,
+            cancelled: tickets.filter((ticket) => ticket.status === "cancelled").length,
+            total: tickets.filter((ticket) => ticket.status !== "cancelled").length,
+        };
+    });
+}
+export function epicProgressCaption(merged, total, cancelled = 0) {
+    if (total === 0 && cancelled === 0)
+        return "No tickets";
+    return `${merged}/${total} merged${cancelled ? ` +${cancelled} cancelled` : ""}`;
+}