@mingchuno/agent-workflows 0.1.0 → 0.3.0

package/dist/src/tui/log-file.js

@@ -0,0 +1,156 @@
+import { open, stat } from "node:fs/promises";
+import { matchIndex, terminalText } from "./text.js";
+const chunkSize = 64 * 1024;
+const checkpointInterval = 256;
+const lineFeedByte = 0x0a;
+export function presentLogLine(line, raw) {
+    if (raw)
+        return terminalText(line);
+    try {
+        const event = JSON.parse(line);
+        const body = event.item ?? event.data ?? event;
+        const label = body.type ?? event.type ?? "event";
+        const content = body.text ??
+            body.content ??
+            body.deltaContent ??
+            body.message ??
+            body.command;
+        const output = body.aggregated_output ?? body.output;
+        if (typeof body.toolName === "string")
+            return terminalText(`${event.type ?? "tool"}: ${body.toolName} ${JSON.stringify(body.arguments ?? body.result ?? "")}`);
+        if (typeof content === "string")
+            return terminalText(`${label}: ${content}${typeof output === "string" ? ` | ${output}` : ""}`).replaceAll("\n", " ↵ ");
+    }
+    catch {
+        // Validation output and incomplete JSON records remain readable as text.
+    }
+    return terminalText(line);
+}
+/** Sparse byte offsets index the file; only requested pages hold decoded text. */
+export class LogFile {
+    path;
+    checkpoints = [0];
+    size = 0;
+    completeLines = 0;
+    tail = false;
+    identity = "";
+    modified = 0;
+    revision = 0;
+    refreshTask = Promise.resolve();
+    constructor(path) {
+        this.path = path;
+    }
+    get count() {
+        return this.completeLines + Number(this.tail);
+    }
+    refresh(signal) {
+        const task = this.refreshTask.then(() => this.updateIndex(signal));
+        this.refreshTask = task.catch(() => { });
+        return task;
+    }
+    async updateIndex(signal) {
+        signal.throwIfAborted();
+        const metadata = await stat(this.path);
+        const identity = `${metadata.dev}:${metadata.ino}`;
+        if (identity !== this.identity ||
+            metadata.size < this.size ||
+            (metadata.size === this.size && metadata.mtimeMs !== this.modified)) {
+            this.checkpoints = [0];
+            this.size = 0;
+            this.completeLines = 0;
+            this.tail = false;
+            this.revision++;
+        }
+        this.identity = identity;
+        this.modified = metadata.mtimeMs;
+        const file = await open(this.path, "r");
+        try {
+            const buffer = Buffer.alloc(chunkSize);
+            while (this.size < metadata.size) {
+                signal.throwIfAborted();
+                const { bytesRead } = await file.read(buffer, 0, Math.min(chunkSize, metadata.size - this.size), this.size);
+                signal.throwIfAborted();
+                if (!bytesRead)
+                    break;
+                for (let i = 0; i < bytesRead; i++) {
+                    this.tail = buffer[i] !== lineFeedByte;
+                    if (buffer[i] === lineFeedByte) {
+                        this.completeLines++;
+                        if (this.completeLines % checkpointInterval === 0)
+                            this.checkpoints[this.completeLines / checkpointInterval] =
+                                this.size + i + 1;
+                    }
+                }
+                this.size += bytesRead;
+            }
+        }
+        finally {
+            await file.close();
+        }
+    }
+    async *lines(start, signal) {
+        const checkpoint = Math.floor(Math.max(0, start) / checkpointInterval);
+        let position = this.checkpoints[checkpoint] ?? this.size;
+        let number = checkpoint * checkpointInterval;
+        const file = await open(this.path, "r");
+        try {
+            const buffer = Buffer.alloc(chunkSize);
+            let parts = [];
+            while (position < this.size) {
+                signal.throwIfAborted();
+                const { bytesRead } = await file.read(buffer, 0, Math.min(chunkSize, this.size - position), position);
+                if (!bytesRead)
+                    break;
+                let beginning = 0;
+                for (let i = 0; i < bytesRead; i++) {
+                    if (buffer[i] !== lineFeedByte)
+                        continue;
+                    parts.push(Buffer.from(buffer.subarray(beginning, i)));
+                    if (number >= start)
+                        yield {
+                            number,
+                            text: Buffer.concat(parts).toString("utf8").replace(/\r$/, ""),
+                        };
+                    number++;
+                    parts = [];
+                    beginning = i + 1;
+                }
+                if (beginning < bytesRead)
+                    parts.push(Buffer.from(buffer.subarray(beginning, bytesRead)));
+                position += bytesRead;
+            }
+            if (parts.length && number >= start)
+                yield { number, text: Buffer.concat(parts).toString("utf8") };
+        }
+        finally {
+            await file.close();
+        }
+    }
+    async page(start, count, signal) {
+        const result = [];
+        for await (const line of this.lines(start, signal)) {
+            result.push(line.text);
+            if (result.length >= count)
+                break;
+        }
+        return result;
+    }
+    async search(options) {
+        const { query, from, direction, raw, signal } = options;
+        let first;
+        let last;
+        let previous;
+        for await (const line of this.lines(0, signal)) {
+            const text = presentLogLine(line.text, raw);
+            if (matchIndex(text, query) < 0)
+                continue;
+            first ??= line.number;
+            last = line.number;
+            if (line.number < from)
+                previous = line.number;
+            if (direction === 1 && line.number > from)
+                return line.number;
+        }
+        return direction === 1 ? first : (previous ?? last);
+    }
+}

package/dist/src/tui/log.d.ts

@@ -0,0 +1,11 @@
+export interface LogSource {
+    path: string;
+    label: string;
+}
+export declare function LogViewer({ sources, initial, columns, rows, onBack, }: {
+    sources: LogSource[];
+    initial: number;
+    columns: number;
+    rows: number;
+    onBack: () => void;
+}): import("react").JSX.Element;

package/dist/src/tui/log.js

@@ -0,0 +1,90 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput } from "ink";
+import { useState } from "react";
+import { HelpDialog } from "./dialogs.js";
+import { cells, colorFor } from "./format.js";
+import { presentLogLine } from "./log-file.js";
+import { matchIndex } from "./text.js";
+import { useLogController } from "./use-log-controller.js";
+const horizontalPanColumns = 20;
+export function LogViewer({ sources, initial, columns, rows, onBack, }) {
+    const [index, setIndex] = useState(initial);
+    const source = sources[index] ?? sources[0];
+    if (!source)
+        return _jsx(Text, { children: "No logs recorded. Esc back" });
+    return (_jsx(LogScreen, { source: source, columns: columns, rows: rows, onBack: onBack, onNext: () => setIndex((value) => (value + 1) % sources.length), multiple: sources.length > 1 }, source.path));
+}
+function Highlight({ text, query }) {
+    const at = query ? matchIndex(text, query) : -1;
+    if (at < 0)
+        return _jsx(Text, { children: text });
+    return (_jsxs(Text, { children: [text.slice(0, at), _jsx(Text, { inverse: true, bold: true, children: text.slice(at, at + query.length) }), text.slice(at + query.length)] }));
+}
+function LogScreen({ source, columns, rows, onBack, onNext, multiple, }) {
+    const log = useLogController(source.path, columns, rows);
+    const { height, following, horizontal, raw, lines, total, message, editing, draft, query, searching, position, } = log;
+    const [help, setHelp] = useState(false);
+    useInput((input, key) => {
+        if (key.ctrl || key.meta || key.eventType === "release")
+            return;
+        if (help)
+            return;
+        if (key.escape) {
+            if (!log.dismissSearch())
+                onBack();
+            return;
+        }
+        if (editing) {
+            if (key.return)
+                log.applySearch();
+            else if (key.backspace || key.delete)
+                log.eraseDraft();
+            else if (!key.ctrl &&
+                !key.meta &&
+                !key.upArrow &&
+                !key.downArrow &&
+                !key.leftArrow &&
+                !key.rightArrow &&
+                !key.tab)
+                log.appendDraft(input);
+            return;
+        }
+        if (input === "/")
+            log.beginSearch();
+        else if (input === "n" || input === "N")
+            log.repeatSearch(input === "n" ? 1 : -1);
+        else if (input === "f")
+            log.follow();
+        else if (input === "R")
+            log.toggleRaw();
+        else if (key.tab && multiple)
+            onNext();
+        else if (input === "?")
+            setHelp(true);
+        else if (key.upArrow || input === "k")
+            log.scroll(-1);
+        else if (key.downArrow || input === "j")
+            log.scroll(1);
+        else if (key.pageUp)
+            log.scroll(-height);
+        else if (key.pageDown || input === " ")
+            log.scroll(height);
+        else if (key.home || input === "g")
+            log.firstPage();
+        else if (key.end || input === "G")
+            log.lastPage();
+        else if (key.leftArrow)
+            log.pan(-horizontalPanColumns);
+        else if (key.rightArrow)
+            log.pan(horizontalPanColumns);
+    });
+    if (help)
+        return (_jsx(HelpDialog, { columns: columns, rows: rows, initialPage: 2, onClose: () => setHelp(false) }));
+    return (_jsxs(Box, { width: columns, height: rows, flexDirection: "column", children: [_jsx(Text, { bold: true, color: colorFor("running"), wrap: "truncate", children: cells(`Logs · ${source.label}`, columns) }), _jsx(Text, { wrap: "truncate", children: cells(source.path, columns) }), _jsxs(Text, { children: [following ? "LIVE FOLLOW" : "SCROLLING", " \u00B7 ", raw ? "Raw" : "Readable", " \u00B7 lines ", total ? position + 1 : 0, "\u2013", Math.min(total, position + height), "/", total, searching ? " · Searching…" : ""] }), _jsx(Box, { height: height, flexDirection: "column", overflow: "hidden", children: lines.map((line, index) => (_jsx(Text, { wrap: "truncate", children: _jsx(Highlight, { text: cells(presentLogLine(line, raw), columns, horizontal), query: query }) }, `${position + index}`))) }), _jsx(Text, { wrap: "truncate", children: cells(editing
+                    ? `/${draft}▏`
+                    : query
+                        ? `Search: ${query}${message ? ` · ${message}` : ""}`
+                        : message, columns) }), _jsx(Text, { color: colorFor("running"), wrap: "truncate", children: editing
+                    ? "Enter search · Esc cancel"
+                    : `/ search · n/N match · f follow · R ${raw ? "readable" : "raw"} · ${multiple ? "Tab log · " : ""}Esc back · ? help` }), _jsx(Text, { dimColor: true, wrap: "truncate", children: cells("↑↓ scroll · PgUp/PgDn page · ←→ pan · workflow continues in background", columns) })] }));
+}

package/dist/src/tui/monitor.d.ts

@@ -0,0 +1,10 @@
+import { type MonitorSource } from "./data.js";
+import type { ExecutionNotificationWriter } from "./notifications.js";
+export declare function Monitor({ source, size, notificationWriter, }: {
+    source: MonitorSource;
+    size?: {
+        columns: number;
+        rows: number;
+    };
+    notificationWriter?: ExecutionNotificationWriter;
+}): import("react").JSX.Element;

package/dist/src/tui/monitor.js

@@ -0,0 +1,284 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useApp, useInput, useWindowSize } from "ink";
+import { useEffect, useState } from "react";
+import { actionAvailability } from "./actions.js";
+import { minimumTerminalSize } from "./constants.js";
+import { useMonitorData } from "./data.js";
+import { ConfirmDialog, HelpDialog } from "./dialogs.js";
+import { cells, colorFor, wrapLines } from "./format.js";
+import { monitorLayout } from "./layout.js";
+import { LogViewer } from "./log.js";
+import { detailLines, Lines, RunList, summaryLines, wrapDetailLines, } from "./views.js";
+const notificationNoticeDurationMs = 2000;
+const focuses = ["runs", "summary", "sessions"];
+const statusRefreshIntervalMs = 1_000;
+const actionDescriptions = {
+    stop: "Cancel this run and wait for its active local work to stop.",
+    retry: "Create a new run and branch; execute the workflow again.",
+    recover: "Continue the failed publication step using completed work.",
+};
+function currentExecutionSessions(run, sessions, events) {
+    const current = run?.executions?.at(-1);
+    if (!current || (run?.executions?.length ?? 0) <= 1)
+        return sessions;
+    const currentStepIds = new Set(events.flatMap((event) => {
+        const payload = event.payload;
+        return payload.executionId === current.id &&
+            typeof payload.stepId === "number"
+            ? [payload.stepId]
+            : [];
+    }));
+    if (currentStepIds.size)
+        return sessions.filter((item) => currentStepIds.has(item.stepId));
+    const executionCreatedAt = Date.parse(current.createdAt);
+    if (!Number.isFinite(executionCreatedAt))
+        return [];
+    return sessions.filter((item) => Date.parse(item.startedAt) >= executionCreatedAt);
+}
+function latestSession(sessions) {
+    const byRecency = [...sessions].sort((left, right) => Date.parse(left.startedAt) - Date.parse(right.startedAt));
+    return (byRecency.filter((item) => item.outcome === "running").at(-1) ??
+        byRecency.at(-1));
+}
+export function Monitor({ source, size, notificationWriter, }) {
+    const window = useWindowSize();
+    const { columns, rows } = size ?? window;
+    const { exit } = useApp();
+    const [selection, setSelection] = useState({});
+    const data = useMonitorData(source, selection, notificationWriter);
+    const { projects, project, projectRuns, run, sessions, events } = data;
+    const [focus, setFocus] = useState("runs");
+    const [screen, setScreen] = useState("dashboard");
+    const [sessionId, setSessionId] = useState();
+    const [stepSequence, setStepSequence] = useState();
+    const [offset, setOffset] = useState(0);
+    const [helpOpen, setHelpOpen] = useState(false);
+    const [confirmation, setConfirmation] = useState();
+    const [logs, setLogs] = useState();
+    const [now, setNow] = useState(Date.now());
+    const [notificationNoticeUntil] = useState(() => Date.now() + notificationNoticeDurationMs);
+    const showNotificationNotice = Boolean(notificationWriter) && now < notificationNoticeUntil;
+    const layout = monitorLayout(columns, rows - (showNotificationNotice ? 1 : 0), screen === "details");
+    const { wide, height, paneWidth, summaryWidth } = layout;
+    const session = sessions.find((item) => item.id === sessionId) ?? sessions[0];
+    const executionSessions = currentExecutionSessions(run, sessions, events);
+    const detailLogSession = latestSession(executionSessions);
+    const event = events.find((item) => item.sequence === stepSequence) ?? events.at(-1);
+    useEffect(() => {
+        const timer = setInterval(() => setNow(Date.now()), statusRefreshIntervalMs);
+        return () => clearInterval(timer);
+    }, []);
+    useEffect(() => {
+        // Pin default selections by identity before incoming rows can reorder them.
+        setSelection((current) => current.projectId === project?.id && current.runId === run?.id
+            ? current
+            : { projectId: project?.id, runId: run?.id });
+    }, [project?.id, run?.id]);
+    // biome-ignore lint/correctness/useExhaustiveDependencies: reset navigation when the selected run identity changes.
+    useEffect(() => {
+        setSessionId(undefined);
+        setStepSequence(undefined);
+        setOffset(0);
+        setConfirmation(undefined);
+    }, [run?.id]);
+    const selectProject = (delta) => {
+        const index = projects.findIndex((item) => item.id === project?.id);
+        const next = projects[Math.max(0, Math.min(projects.length - 1, index + delta))];
+        setSelection({ projectId: next?.id });
+        setFocus("runs");
+        setOffset(0);
+    };
+    const openAgentLog = (candidates = sessions, initialSession = session) => {
+        if (!candidates.length)
+            return;
+        setLogs({
+            sources: candidates.map((item) => ({
+                path: item.log,
+                label: `${item.step} · invocation ${item.attempt}`,
+            })),
+            initial: Math.max(0, candidates.findIndex((item) => item.id === initialSession?.id)),
+        });
+    };
+    const { recoveryReason, available } = actionAvailability({
+        run,
+        project,
+        projectRuns,
+        pending: Boolean(data.pending),
+    });
+    const detailDocument = run
+        ? detailLines(run, sessions, now, recoveryReason, layout.details.width, available)
+        : ["Run no longer available"];
+    const wrappedDetailLines = wrapDetailLines(detailDocument, layout.details.width);
+    const detailOffset = Math.min(offset, Math.max(0, wrappedDetailLines.length - layout.details.height));
+    useInput((input, key) => {
+        if (key.ctrl || key.meta || key.eventType === "release")
+            return;
+        const terminalIsLargeEnough = columns >= minimumTerminalSize.columns &&
+            rows >= minimumTerminalSize.rows;
+        if (logs && terminalIsLargeEnough)
+            return;
+        if (terminalIsLargeEnough && (confirmation || helpOpen))
+            return;
+        if (input === "q") {
+            exit();
+            return;
+        }
+        if (!terminalIsLargeEnough)
+            return;
+        if (key.escape) {
+            setScreen("dashboard");
+            setFocus("runs");
+            setOffset(0);
+            return;
+        }
+        if (input === "?") {
+            setHelpOpen(true);
+            return;
+        }
+        if (key.tab && screen === "dashboard") {
+            setFocus(focuses[(focuses.indexOf(focus) + (key.shift ? 2 : 1)) % 3]);
+            setOffset(0);
+        }
+        if (input === "a" && screen === "dashboard") {
+            setScreen("dashboard");
+            setFocus("sessions");
+        }
+        if (key.leftArrow && screen === "dashboard")
+            selectProject(-1);
+        if (key.rightArrow && screen === "dashboard")
+            selectProject(1);
+        if (key.return && run && screen === "dashboard") {
+            setScreen("details");
+            setOffset(0);
+        }
+        if (input === "l")
+            screen === "details"
+                ? openAgentLog(executionSessions, detailLogSession)
+                : openAgentLog();
+        if (input === "v" && run?.validation?.length)
+            setLogs({
+                sources: run.validation.map((item) => ({
+                    path: item.log,
+                    label: `${item.command} · exit ${item.exitCode}`,
+                })),
+                initial: 0,
+            });
+        if (screen === "dashboard" && (input === "[" || input === "]")) {
+            const index = events.findIndex((item) => item.sequence === event?.sequence);
+            setStepSequence(events[Math.max(0, Math.min(events.length - 1, index + (input === "]" ? 1 : -1)))]?.sequence);
+        }
+        if (key.end && screen === "dashboard")
+            setStepSequence(undefined);
+        if (key.upArrow || key.downArrow || key.pageUp || key.pageDown) {
+            const delta = key.upArrow || key.pageUp ? -1 : 1;
+            if (screen === "details" || focus === "summary") {
+                const lines = run
+                    ? screen === "details"
+                        ? detailDocument
+                        : summaryLines(run, now, event)
+                    : [];
+                const viewport = screen === "details" ? layout.details : layout.summary;
+                setOffset((value) => {
+                    const maximum = Math.max(0, (screen === "details"
+                        ? wrapDetailLines(lines, viewport.width)
+                        : wrapLines(lines, viewport.width)).length - viewport.height);
+                    const current = screen === "details" ? Math.min(value, maximum) : value;
+                    return Math.max(0, Math.min(maximum, current +
+                        delta *
+                            (key.pageUp || key.pageDown ? layout.details.height : 1)));
+                });
+            }
+            else if (focus === "sessions") {
+                const index = sessions.findIndex((item) => item.id === session?.id);
+                setSessionId(sessions[Math.max(0, Math.min(sessions.length - 1, index + delta))]
+                    ?.id);
+            }
+            else {
+                const index = projectRuns.findIndex((item) => item.id === run?.id);
+                setSelection({
+                    projectId: project?.id,
+                    runId: projectRuns[Math.max(0, Math.min(projectRuns.length - 1, index + delta))]?.id,
+                });
+            }
+        }
+        if (input === "p" && screen === "dashboard" && project && !data.pending)
+            void data.action(project.paused ? "resume" : "pause", project.id);
+        const kind = input === "s"
+            ? "stop"
+            : input === "r"
+                ? "retry"
+                : input === "c"
+                    ? "recover"
+                    : undefined;
+        if (kind && run && available[kind])
+            setConfirmation({
+                kind,
+                runId: run.id,
+                title: `#${run.issue.number} ${run.issue.title}`,
+            });
+    });
+    if (columns < minimumTerminalSize.columns || rows < minimumTerminalSize.rows)
+        return (_jsx(Box, { width: columns, height: rows, flexDirection: "column", children: _jsx(Text, { children: cells(`Resize terminal to at least ${minimumTerminalSize.columns}×${minimumTerminalSize.rows}. q closes monitor.`, columns) }) }));
+    if (helpOpen)
+        return (_jsx(HelpDialog, { columns: columns, rows: rows, onClose: () => setHelpOpen(false) }));
+    if (confirmation)
+        return (_jsx(ConfirmDialog, { columns: columns, rows: rows, title: `Confirm ${confirmation.kind}`, subject: confirmation.title, description: actionDescriptions[confirmation.kind], available: run?.id === confirmation.runId && available[confirmation.kind], onCancel: () => setConfirmation(undefined), onConfirm: () => {
+                void data.action(confirmation.kind, confirmation.runId);
+                setConfirmation(undefined);
+            } }));
+    if (logs)
+        return (_jsx(LogViewer, { ...logs, columns: columns, rows: rows, onBack: () => setLogs(undefined) }));
+    const freshness = data.lastUpdated
+        ? `refreshed ${Math.max(0, Math.floor((now - data.lastUpdated) / statusRefreshIntervalMs))}s ago`
+        : "freshness unavailable";
+    const status = `${data.connection} · ${freshness}`;
+    const sessionIndex = Math.max(0, sessions.findIndex((item) => item.id === session?.id));
+    const sessionLines = sessions.length
+        ? sessions
+            .slice(Math.max(0, sessionIndex - 1), sessionIndex + 3)
+            .map((item) => `${item.id === session?.id ? ">" : " "} ${item.step} · invocation ${item.attempt} · ${item.outcome}`)
+        : ["No agent sessions recorded"];
+    const detailsLogControl = detailLogSession
+        ? columns < 120
+            ? "l current log"
+            : `l log: ${detailLogSession.step} invocation ${detailLogSession.attempt} (${detailLogSession.outcome})`
+        : "";
+    const controls = [
+        screen === "details" ? detailsLogControl : sessions.length ? "l log" : "",
+        run?.validation?.length
+            ? columns < 120
+                ? "v checks"
+                : "v validation"
+            : "",
+        screen === "dashboard" && project
+            ? project.paused
+                ? "p resume"
+                : "p pause"
+            : "",
+        available.stop ? "s stop" : "",
+        available.retry ? "r retry" : "",
+        available.recover ? "c recover" : "",
+        "? help",
+        "q close",
+    ]
+        .filter(Boolean)
+        .join(" · ");
+    return (_jsxs(Box, { width: columns, height: rows, flexDirection: "column", children: [_jsx(Text, { bold: true, color: colorFor("running"), wrap: "truncate", children: cells(`Agent Workflows · ${screen === "dashboard" ? "Monitor" : "Run details"}`, columns) }), _jsx(Text, { wrap: "truncate", children: cells(project
+                    ? `${project.id} · intake ${project.paused ? "paused" : "enabled"} · ${projectRuns.filter((item) => item.outcome === "queued").length} queued${project.blocked ? ` · BLOCKED: ${project.blocked}` : ""}`
+                    : "No projects registered. Start the runner to populate this view.", columns) }), _jsx(Box, { height: height, flexDirection: "row", overflow: "hidden", children: screen === "details" ? (_jsxs(Box, { borderStyle: "round", width: columns, height: height, paddingX: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, children: wrappedDetailLines.length > layout.details.height
+                                ? `Details · lines ${detailOffset + 1}–${Math.min(detailOffset + layout.details.height, wrappedDetailLines.length)} of ${wrappedDetailLines.length}`
+                                : "Details" }), _jsx(Lines, { lines: detailDocument, width: layout.details.width, height: layout.details.height, offset: detailOffset, outcome: run?.outcome })] })) : (_jsxs(_Fragment, { children: [(wide || focus === "runs") && (_jsxs(Box, { width: paneWidth, height: height, borderStyle: "round", borderColor: focus === "runs" ? colorFor("running") : undefined, flexDirection: "column", paddingX: 1, children: [_jsxs(Text, { bold: true, children: [focus === "runs" ? "> " : "", "Runs \u00B7 ", projectRuns.length] }), _jsx(RunList, { runs: projectRuns, selected: run?.id, width: layout.runs.width, height: layout.runs.height, now: now })] })), (wide || focus !== "runs") && (_jsxs(Box, { width: summaryWidth, height: height, flexDirection: "column", children: [(wide || focus === "summary") && (_jsxs(Box, { width: summaryWidth, height: layout.summaryPanelHeight, borderStyle: "round", borderColor: focus === "summary" ? colorFor("running") : undefined, paddingX: 1, flexDirection: "column", children: [_jsxs(Text, { bold: true, children: [focus === "summary" ? "> " : "", "Summary \u00B7 Enter details"] }), _jsx(Lines, { lines: run
+                                                ? summaryLines(run, now, event)
+                                                : ["Select a run to inspect progress"], width: layout.summary.width, height: layout.summary.height, offset: offset })] })), (wide || focus === "sessions") && (_jsxs(Box, { width: summaryWidth, height: layout.sessionsPanelHeight, borderStyle: "round", borderColor: focus === "sessions" ? colorFor("running") : undefined, paddingX: 1, flexDirection: "column", children: [_jsxs(Text, { bold: true, children: [focus === "sessions" ? "> " : "", "Agent sessions \u00B7", " ", sessions.length, " \u00B7 l log"] }), _jsx(Lines, { lines: sessionLines, width: layout.sessions.width, height: layout.sessions.height })] }))] }))] })) }), showNotificationNotice && (_jsx(Text, { color: colorFor("running"), wrap: "truncate", children: cells("Notifications enabled; delivery is best-effort and depends on terminal settings", columns) })), _jsx(Text, { wrap: "truncate", color: data.connection.startsWith("Connection error")
+                    ? colorFor("failed")
+                    : undefined, children: cells(`${data.message ? `${data.message} · ` : ""}${columns < 120 ? status.replace("Database ", "DB ") : status} · runner liveness unverified · closing leaves workflows running`, columns) }), _jsx(Text, { color: colorFor("running"), wrap: "truncate", children: cells([
+                    screen === "dashboard"
+                        ? "Tab pane · ↑↓ select/scroll · ←→ project · Enter details"
+                        : columns < 120
+                            ? "↑↓/Pg · Esc"
+                            : "↑↓ scroll · PgUp/PgDn page · Esc back",
+                    controls,
+                ]
+                    .filter(Boolean)
+                    .join(" · "), columns) })] }));
+}

package/dist/src/tui/notifications.d.ts

@@ -0,0 +1,23 @@
+import type { RunRecord } from "../domain.js";
+declare const terminalOutcomes: readonly ["completed", "failed", "blocked", "cancelled", "no-change", "ineligible"];
+export type TerminalOutcome = (typeof terminalOutcomes)[number];
+export interface ExecutionNotification {
+    project: string;
+    issue: string;
+    outcome: TerminalOutcome;
+}
+export interface ExecutionNotificationWriter {
+    notify(notification: ExecutionNotification): void;
+}
+export declare class ExecutionNotificationObserver {
+    private readonly writer;
+    private seeded;
+    private readonly observedTerminalExecutionIds;
+    constructor(writer: ExecutionNotificationWriter);
+    observe(runs: RunRecord[]): void;
+}
+export declare function createTerminalNotificationWriter({ write, tmux, }?: {
+    write?: (value: string) => void | Promise<void>;
+    tmux?: boolean;
+}): ExecutionNotificationWriter;
+export {};