omkit 0.8.23 → 0.8.25

package/dist/cli/ui/views/OmList.js

@@ -22,8 +22,11 @@ function truncate(text, max) {
  * Rows are ordered by {@link byNesting} from the working directory — the same root the paths
  * are rendered from, so the oms nearest the top of the project come first, deeper ones after,
  * and any shown as an absolute path last.
+ *
+ * `status` goes on the header line (the shell's "rediscovering…"), and `hint` replaces the key
+ * line under the list, for a caller that binds more keys than the list does.
  */
-export function OmList({ oms, onSelect, }) {
+export function OmList({ oms, onSelect, status, hint = "↑↓ move · enter run · esc clears search · ctrl+c quit", }) {
     const root = process.cwd();
     const sorted = useMemo(() => [...oms].sort(byNesting(root)), [oms, root]);
     const { stdout } = useStdout();
@@ -31,9 +34,34 @@ export function OmList({ oms, onSelect, }) {
     // Column width so summaries line up; capped so one long name can't push them off-screen.
     const nameWidth = Math.min(30, oms.reduce((w, o) => Math.max(w, o.name.length), 0));
     const restWidth = Math.max(20, columns - nameWidth - 6);
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: [_jsx(Text, { bold: true, children: "omkit" }), _jsx(Text, { dimColor: true, children: ` · ${oms.length} om${oms.length === 1 ? "" : "s"}` })] }), _jsx(SearchableList, { items: sorted, getKey: (o) => `${o.file}\0${o.name}`, getSearchText: (o) => `${o.name} ${o.summary ?? ""}`, onSelect: onSelect, alwaysShowSearch: true, searchLabel: "search \u203A ", searchPlaceholder: "type to filter by name or summary", renderRow: (o, selected) => (_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { color: selected ? "cyan" : undefined, children: selected ? "❯ " : "  " }), _jsx(Text, { bold: selected, color: selected ? "cyan" : undefined, children: o.name.padEnd(nameWidth) }), "  ", _jsx(Text, { dimColor: true, children: truncate(o.summary ?? displayPath(o.file, root), restWidth) })] })), renderDetail: (o) => (o ? _jsx(OmDetail, { om: o, root: root }) : null) }), _jsx(Text, { dimColor: true, children: "\u2191\u2193 move \u00B7 enter run \u00B7 esc clears search \u00B7 ctrl+c quit" })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: [_jsx(Text, { bold: true, children: "omkit" }), _jsx(Text, { dimColor: true, children: ` · ${oms.length} om${oms.length === 1 ? "" : "s"}` }), status ? _jsx(Text, { dimColor: true, children: "  " }) : null, status ?? null] }), _jsx(SearchableList, { items: sorted, getKey: (o) => `${o.file}\0${o.name}`, getSearchText: (o) => `${o.name} ${o.summary ?? ""}`, onSelect: onSelect, alwaysShowSearch: true, searchLabel: "search \u203A ", searchPlaceholder: "type to filter by name or summary", renderRow: (o, selected) => (_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { color: selected ? "cyan" : undefined, children: selected ? "❯ " : "  " }), _jsx(Text, { bold: selected, color: selected ? "cyan" : undefined, children: o.name.padEnd(nameWidth) }), "  ", _jsx(Text, { dimColor: true, children: truncate(o.summary ?? displayPath(o.file, root), restWidth) })] })), renderDetail: (o) => (o ? _jsx(OmDetail, { om: o, root: root }) : null) }), _jsx(Text, { dimColor: true, children: hint })] }));
+}
+/** Steps listed before the rest collapse into `+N more`, so the box keeps a steady height. */
+const MAX_STEPS = 10;
+/** A description key as a label: `docsUrl` / `docs-url` / `docs_url` → `Docs url`. */
+export function labelOf(key) {
+    const words = key
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .replace(/[-_]+/g, " ")
+        .trim()
+        .toLowerCase();
+    return words.charAt(0).toUpperCase() + words.slice(1);
+}
+/** One label/value row; the value wraps under itself, not under the label. */
+function Field({ label, width, children, }) {
+    return (_jsxs(Box, { children: [_jsx(Box, { width: width + 2, flexShrink: 0, children: _jsx(Text, { dimColor: true, children: label }) }), _jsx(Box, { flexGrow: 1, children: children })] }));
 }
-/** The highlighted om in full. */
+/**
+ * The highlighted om in full: its name, then a field per thing it says about itself — the
+ * summary, any further `.describe(…)` props, where it is defined — then its steps, numbered.
+ * The steps are the static outline, an approximation (see `outlineBody`), and say so.
+ */
 function OmDetail({ om, root }) {
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, marginTop: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: om.name }), om.summary ? (_jsx(Text, { children: om.summary })) : (_jsxs(Text, { dimColor: true, italic: true, children: ["No summary. Add .describe(", "{ summary }", ") to the om."] })), _jsx(Text, { dimColor: true, children: `${displayPath(om.file, root)}:${om.line}` }), om.calls?.length ? (_jsxs(Text, { wrap: "wrap", children: [_jsx(Text, { dimColor: true, children: "calls " }), om.calls.map((c, i) => (_jsxs(Text, { children: [i > 0 ? _jsx(Text, { dimColor: true, children: " \u2192 " }) : null, c.name, c.tag ? _jsx(Text, { dimColor: true, children: ` [${c.tag}]` }) : null] }, `${c.name}\0${c.tag ?? ""}`)))] })) : null] }));
+    const details = (om.details ?? []).map((d) => ({ label: labelOf(d.key), value: d.value }));
+    const width = Math.max("Summary".length, "Defined".length, ...details.map((d) => d.label.length));
+    const steps = om.calls ?? [];
+    const shown = steps.slice(0, MAX_STEPS);
+    const stepWidth = Math.min(24, Math.max(0, ...shown.map((c) => c.name.length)));
+    const numWidth = String(shown.length).length;
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, marginTop: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: om.name }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Field, { label: "Summary", width: width, children: om.summary ? (_jsx(Text, { wrap: "wrap", children: om.summary })) : (_jsxs(Text, { dimColor: true, italic: true, children: ["none \u00B7 add .describe(", "{ summary }", ") to the om"] })) }), details.map((d) => (_jsx(Field, { label: d.label, width: width, children: _jsx(Text, { wrap: "wrap", children: d.value }) }, d.label))), _jsx(Field, { label: "Defined", width: width, children: _jsx(Text, { dimColor: true, wrap: "truncate-start", children: `${displayPath(om.file, root)}:${om.line}` }) })] }), shown.length ? (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "Steps" }), _jsx(Text, { dimColor: true, italic: true, children: "  read from source · approximate" })] }), shown.map((c, i) => (_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { dimColor: true, children: `  ${String(i + 1).padStart(numWidth)}  ` }), c.tag ? c.name.padEnd(stepWidth) : c.name, c.tag ? _jsx(Text, { color: "cyan", children: `  ${c.tag}` }) : null] }, `${c.name}\0${c.tag ?? ""}`))), steps.length > shown.length ? (_jsx(Text, { dimColor: true, children: `  ${" ".repeat(numWidth)}  +${steps.length - shown.length} more` })) : null] })) : null] }));
 }

package/dist/cli/ui/views/RunView.d.ts

@@ -1,16 +1,40 @@
 import { type ReactElement } from "react";
-import type { RunSummary } from "../../../output/RunModel.ts";
-import type { PromptRequest, Verdict } from "../../../client/types.ts";
+import type { RunNode, RunSummary } from "../../../output/RunModel.ts";
+import type { PromptRequest } from "../../../client/types.ts";
 /** Answer one pending prompt — free-text input, or searchable choices. */
 export declare function PromptView({ request, onAnswer, }: {
     request: PromptRequest;
     onAnswer: (value: string) => void;
 }): ReactElement;
-/** The live run surface: milestone lines, a compact status strip, a pending prompt, and the verdict. */
-export declare function RunView({ lines, status, prompt, verdict, onAnswer, }: {
-    lines: readonly string[];
-    status?: RunSummary;
+/** Where a run is: its body still going, its body returned with daemons left up, or tearing down. */
+export type RunPhase = "running" | "up" | "stopping";
+/** Rows of the live tree before the rest collapse into `+N running` — so the box never jumps. */
+export declare const MAX_TREE_ROWS = 6;
+/** `850ms`, `8.3s`, `3m12s`, `1h04m`. */
+export declare function formatDuration(ms: number): string;
+/**
+ * A node's name in the tree, with its tags — `vite [ready]`. The log stream carries only the
+ * node's path segment, the action name made file-safe plus the node's id (`tailLog_bbe803dc`),
+ * so the id is dropped and an over-long name (a `command`'s whole command line) keeps its two
+ * ends — the tag beside it is usually what tells the rows apart.
+ */
+export declare function nodeLabel(node: Pick<RunNode, "path" | "tags">): string;
+/** One-line roll-up of the live tree: what's still running and the finished tally. Empty until
+ *  something is happening, so it renders nothing at the very start of a run. */
+export declare function statusStrip(s: RunSummary): string;
+/**
+ * The live run box — the only part of the screen redrawn while a run streams (its milestones go
+ * to the scrollback above it): a header with the phase and elapsed time, the running nodes with
+ * their latest line, the finished tally, and a pending prompt, which takes the box over.
+ */
+export declare function RunView({ name, phase, startedAt, upAt, nodes, summary, prompt, onAnswer, }: {
+    name: string;
+    phase: RunPhase;
+    startedAt: number;
+    /** When the run's body returned (the `up` event), for the "up for" clock. */
+    upAt?: number;
+    nodes: readonly RunNode[];
+    summary?: RunSummary;
     prompt?: PromptRequest;
-    verdict?: Verdict;
     onAnswer: (value: string) => void;
 }): ReactElement;

package/dist/cli/ui/views/RunView.js

@@ -1,7 +1,8 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useRef, useState } from "react";
-import { Box, Text, useInput } from "ink";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from "react";
+import { Box, Text, useInput, useStdout } from "ink";
 import { SearchableList } from "./SearchableList.js";
+import { Spinner } from "../Spinner.js";
 /** A choice prompt: searchable, arrow-navigable options, Enter picks the highlighted one. */
 function ChoicePrompt({ request, onAnswer, }) {
     const { spec } = request;
@@ -35,9 +36,53 @@ function InputPrompt({ request, onAnswer, }) {
 export function PromptView({ request, onAnswer, }) {
     return request.spec.kind === "choice" ? (_jsx(ChoicePrompt, { request: request, onAnswer: onAnswer })) : (_jsx(InputPrompt, { request: request, onAnswer: onAnswer }));
 }
+/** Rows of the live tree before the rest collapse into `+N running` — so the box never jumps. */
+export const MAX_TREE_ROWS = 6;
+/** `850ms`, `8.3s`, `3m12s`, `1h04m`. */
+export function formatDuration(ms) {
+    if (!Number.isFinite(ms) || ms < 0)
+        return "";
+    if (ms < 1000)
+        return `${Math.round(ms)}ms`;
+    if (ms < 60_000)
+        return `${(ms / 1000).toFixed(1)}s`;
+    const s = Math.floor(ms / 1000);
+    if (s < 3600)
+        return `${Math.floor(s / 60)}m${String(s % 60).padStart(2, "0")}s`;
+    return `${Math.floor(s / 3600)}h${String(Math.floor(s / 60) % 60).padStart(2, "0")}m`;
+}
+/** Longest node name the tree shows before cutting out its middle. */
+const NAME_MAX = 40;
+/**
+ * A node's name in the tree, with its tags — `vite [ready]`. The log stream carries only the
+ * node's path segment, the action name made file-safe plus the node's id (`tailLog_bbe803dc`),
+ * so the id is dropped and an over-long name (a `command`'s whole command line) keeps its two
+ * ends — the tag beside it is usually what tells the rows apart.
+ */
+export function nodeLabel(node) {
+    const segment = node.path.slice(node.path.lastIndexOf("/") + 1).replace(/_[0-9a-f]{8}$/, "");
+    const name = segment.length > NAME_MAX
+        ? `${segment.slice(0, NAME_MAX / 2 - 1)}…${segment.slice(-(NAME_MAX / 2))}`
+        : segment;
+    return node.tags.length ? `${name} [${node.tags.join(", ")}]` : name;
+}
+/**
+ * The time since `since`. Read at render, so every redraw shows it current; the tick only forces
+ * one when nothing else does (an idle stack that is up). Unref'd, like {@link Spinner}'s
+ * interval, so it never holds the process open.
+ */
+function Elapsed({ since }) {
+    const [, setTick] = useState(0);
+    useEffect(() => {
+        const id = setInterval(() => setTick((t) => t + 1), 1000);
+        id.unref?.();
+        return () => clearInterval(id);
+    }, []);
+    return _jsx(_Fragment, { children: formatDuration(Date.now() - since) });
+}
 /** One-line roll-up of the live tree: what's still running and the finished tally. Empty until
  *  something is happening, so it renders nothing at the very start of a run. */
-function statusStrip(s) {
+export function statusStrip(s) {
     const parts = [];
     if (s.running.length) {
         const shown = s.running.slice(0, 3).join(", ");
@@ -55,8 +100,42 @@ function statusStrip(s) {
         parts.push(tally.join(" · "));
     return parts.join("  ·  ");
 }
-/** The live run surface: milestone lines, a compact status strip, a pending prompt, and the verdict. */
-export function RunView({ lines, status, prompt, verdict, onAnswer, }) {
-    const strip = status && !verdict ? statusStrip(status) : "";
-    return (_jsxs(Box, { flexDirection: "column", children: [lines.map((line, i) => (_jsx(Text, { children: line }, i))), strip ? _jsx(Text, { dimColor: true, children: strip }) : null, prompt ? _jsx(PromptView, { request: prompt, onAnswer: onAnswer }) : null, verdict ? (_jsxs(Text, { color: verdict.ok ? "green" : "red", children: [verdict.ok ? "✓ ok" : "✗ failed", " \u00B7 ", verdict.folder] })) : null] }));
+/**
+ * The running nodes under the root, most recently active first — the order {@link RunSummary}
+ * keeps — so whatever is talking right now stays on screen when the rest collapse.
+ */
+function liveNodes(nodes, summary) {
+    const byPath = new Map(nodes.map((n) => [n.path, n]));
+    const order = summary?.running ?? nodes.filter((n) => n.status === "running").map((n) => n.path);
+    return order
+        .map((p) => byPath.get(p))
+        .filter((n) => n !== undefined && n.path.includes("/"));
+}
+function Header({ name, phase, startedAt, upAt, }) {
+    return (_jsxs(Text, { children: [_jsx(Text, { bold: true, children: name }), _jsx(Text, { dimColor: true, children: " · " }), phase === "stopping" ? (_jsx(Text, { color: "yellow", children: "stopping\u2026" })) : phase === "up" ? (_jsxs(Text, { color: "green", children: ["\u25CF up ", _jsx(Elapsed, { since: upAt ?? startedAt })] })) : (_jsxs(Text, { color: "cyan", children: ["running ", _jsx(Elapsed, { since: startedAt })] }))] }));
+}
+/**
+ * The live run box — the only part of the screen redrawn while a run streams (its milestones go
+ * to the scrollback above it): a header with the phase and elapsed time, the running nodes with
+ * their latest line, the finished tally, and a pending prompt, which takes the box over.
+ */
+export function RunView({ name, phase, startedAt, upAt, nodes, summary, prompt, onAnswer, }) {
+    const { stdout } = useStdout();
+    const width = Math.max(30, (stdout?.columns || 100) - 4);
+    const live = liveNodes(nodes, summary);
+    const shown = live.slice(0, MAX_TREE_ROWS);
+    const root = nodes.find((n) => !n.path.includes("/"));
+    const now = Date.now();
+    const stopping = phase === "stopping";
+    const strip = summary ? statusStrip(summary) : "";
+    const tally = summary
+        ? [
+            summary.ok ? `✓ ${summary.ok} ok` : "",
+            summary.failed ? `✗ ${summary.failed} failed` : "",
+            summary.cancelled ? `⊘ ${summary.cancelled} cancelled` : "",
+        ].filter(Boolean)
+        : [];
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: stopping ? "yellow" : phase === "up" ? "green" : "gray", paddingX: 1, children: [_jsx(Header, { name: name, phase: phase, startedAt: startedAt, upAt: upAt }), prompt ? (_jsxs(_Fragment, { children: [strip ? _jsx(Text, { dimColor: true, children: strip }) : null, _jsx(PromptView, { request: prompt, onAnswer: onAnswer })] })) : (_jsxs(_Fragment, { children: [shown.map((n) => (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { wrap: "truncate-end", children: [stopping ? _jsx(Text, { color: "yellow", children: "\u25CC " }) : _jsx(Text, { color: "cyan", children: "\u25CF " }), nodeLabel(n), _jsx(Text, { dimColor: true, children: `  ${formatDuration(now - n.startedAt)}` })] }), n.last ? (_jsx(Text, { dimColor: true, wrap: "truncate-end", children: `  └ ${n.last.slice(0, width)}` })) : null] }, n.path))), live.length > shown.length ? (_jsx(Text, { dimColor: true, children: `  +${live.length - shown.length} more running` })) : null, live.length === 0 && !stopping ? (
+                    // nothing launched under the root (yet): what the om's own body last said, if anything
+                    root?.last ? (_jsx(Text, { dimColor: true, wrap: "truncate-end", children: `└ ${root.last.slice(0, width)}` })) : (_jsx(Spinner, { label: phase === "up" ? "idle" : "starting…" }))) : null, tally.length ? _jsx(Text, { dimColor: true, children: tally.join(" · ") }) : null] }))] }));
 }

package/dist/cli/ui/views/Scrollback.d.ts

@@ -0,0 +1,30 @@
+/** One line of scrollback, with an optional accent. */
+export interface ScrollLine {
+    readonly text: string;
+    readonly color?: string;
+    readonly dim?: boolean;
+    readonly bold?: boolean;
+    /**
+     * Draw the line as a rule across the terminal, `text` set into it and `right` (if any) at its
+     * end — `── tskb:build ──────── 14:21:17`. What opens each run, so runs read as sections.
+     */
+    readonly rule?: {
+        readonly right?: string;
+    };
+}
+/**
+ * A batch of lines appended to the scrollback at once — one per redraw tick, not one per line,
+ * so the item array {@link Scrollback} hands `<Static>` grows with ticks rather than with output.
+ */
+export interface ScrollChunk {
+    readonly id: number;
+    readonly lines: readonly ScrollLine[];
+}
+/**
+ * Everything the session has said, written once into the terminal's own scrollback by Ink's
+ * `<Static>` and never redrawn: run headers, outcomes, verdicts and their recap. That is what
+ * keeps the live frame below it small — a frame costs in proportion to what it draws.
+ */
+export declare const Scrollback: import("react").NamedExoticComponent<{
+    chunks: readonly ScrollChunk[];
+}>;

package/dist/cli/ui/views/Scrollback.js

@@ -0,0 +1,21 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { memo } from "react";
+import { Box, Static, Text, useStdout } from "ink";
+/** Widest a rule runs, so it stays a separator on a very wide terminal rather than a horizon. */
+const RULE_MAX = 100;
+function Rule({ line, columns }) {
+    const right = line.rule?.right ? ` ${line.rule.right}` : "";
+    const width = Math.min(columns, RULE_MAX);
+    const fill = Math.max(3, width - 3 - line.text.length - 1 - right.length);
+    return (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "── " }), _jsx(Text, { bold: line.bold, color: line.color, children: line.text }), _jsx(Text, { dimColor: true, children: ` ${"─".repeat(fill)}${right}` })] }));
+}
+/**
+ * Everything the session has said, written once into the terminal's own scrollback by Ink's
+ * `<Static>` and never redrawn: run headers, outcomes, verdicts and their recap. That is what
+ * keeps the live frame below it small — a frame costs in proportion to what it draws.
+ */
+export const Scrollback = memo(function Scrollback({ chunks, }) {
+    const { stdout } = useStdout();
+    const columns = stdout?.columns || 80;
+    return (_jsx(Static, { items: chunks, children: (chunk) => (_jsx(Box, { flexDirection: "column", children: chunk.lines.map((l, i) => l.rule ? (_jsx(Rule, { line: l, columns: columns }, i)) : (_jsx(Text, { color: l.color, dimColor: l.dim, bold: l.bold, children: l.text }, i))) }, chunk.id)) }));
+});

package/dist/cli/ui/views/shellLines.d.ts

@@ -0,0 +1,21 @@
+import type { LogEntry } from "../../../foundation/LogEntry.ts";
+import type { RunNode } from "../../../output/RunModel.ts";
+import type { ScrollLine } from "./Scrollback.tsx";
+/**
+ * The shell's scrollback line for one log entry, or `null` to keep it out.
+ *
+ * The scrollback is a record of outcomes, not a transcript: a node that finished (with how long
+ * it took), a failure, an error, a failed assert. What is merely happening — launches, events,
+ * output, snapshots, the run's own narration — shows in the live box while it happens and is in
+ * the run's logs and report afterwards. The root's own end is left to the verdict line, and
+ * once the run is tearing down the cancellations that teardown causes are expected, so they are
+ * left to the verdict too.
+ */
+export declare function shellLine(e: LogEntry, node: RunNode | undefined, tearingDown: boolean): ScrollLine | null;
+/**
+ * The verdict's recap, cut to what you reach for next: `main.log` and the report, and the assert
+ * tally when the run asserted anything. The full block (every sibling log) is in the run folder
+ * and at the foot of `main.log`. A summary of any other shape — the output of a child that died before it could
+ * report — is the only account of what went wrong, so it is kept whole.
+ */
+export declare function recapLines(summary: readonly string[]): ScrollLine[];

package/dist/cli/ui/views/shellLines.js

@@ -0,0 +1,62 @@
+import { formatDuration, nodeLabel } from "./RunView.js";
+const firstLine = (message) => message.split("\n", 1)[0] ?? message;
+/**
+ * The shell's scrollback line for one log entry, or `null` to keep it out.
+ *
+ * The scrollback is a record of outcomes, not a transcript: a node that finished (with how long
+ * it took), a failure, an error, a failed assert. What is merely happening — launches, events,
+ * output, snapshots, the run's own narration — shows in the live box while it happens and is in
+ * the run's logs and report afterwards. The root's own end is left to the verdict line, and
+ * once the run is tearing down the cancellations that teardown causes are expected, so they are
+ * left to the verdict too.
+ */
+export function shellLine(e, node, tearingDown) {
+    if (!node)
+        return null;
+    const label = nodeLabel(node);
+    const isRoot = !node.path.includes("/");
+    if (e.level === "event" && e.source === "lifecycle" && e.message.startsWith("done · ")) {
+        if (isRoot)
+            return null;
+        const took = node.endedAt === undefined ? "" : ` · ${formatDuration(node.endedAt - node.startedAt)}`;
+        if (node.status === "ok")
+            return { text: `  ✓ ${label}${took}`, color: "green" };
+        if (node.status === "failed")
+            return { text: `  ✗ ${label} · failed${took}`, color: "red" };
+        return tearingDown ? null : { text: `  ⊘ ${label} · cancelled`, dim: true };
+    }
+    if (e.level === "error" && e.source === "error") {
+        return { text: `  ✗ ${isRoot ? "om" : label} · ${firstLine(e.message)}`, color: "red" };
+    }
+    if (e.level === "assert" && e.message.includes("⊭")) {
+        return { text: `  ✗ ${isRoot ? "om" : label} · ${e.message}`, color: "red" };
+    }
+    return null;
+}
+/**
+ * The verdict's recap, cut to what you reach for next: `main.log` and the report, and the assert
+ * tally when the run asserted anything. The full block (every sibling log) is in the run folder
+ * and at the foot of `main.log`. A summary of any other shape — the output of a child that died before it could
+ * report — is the only account of what went wrong, so it is kept whole.
+ */
+export function recapLines(summary) {
+    if (!summary[0]?.startsWith("om → ")) {
+        return summary.map((line) => ({ text: `  ${line}`, dim: true }));
+    }
+    const lines = [];
+    for (const line of summary) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("main log ") || trimmed.startsWith("report ")) {
+            lines.push({ text: `  ${trimmed}`, dim: true });
+        }
+        const tally = /⊨ (\d+) passed · ⊭ (\d+) failed/.exec(trimmed);
+        if (tally && Number(tally[1]) + Number(tally[2]) > 0) {
+            lines.push({
+                text: `  asserts   ${tally[0]}`,
+                color: Number(tally[2]) ? "red" : undefined,
+                dim: !Number(tally[2]),
+            });
+        }
+    }
+    return lines;
+}

package/dist/client/discovery.js

@@ -6,7 +6,7 @@ import { omHash } from "../foundation/ids.js";
 import { fsSafe } from "../foundation/fsSafe.js";
 import { canonicalPath } from "../foundation/canonicalPath.js";
 import { tsxLoader } from "./runner.js";
-import { chainRoot, importedNames, outlineBody, summaryOf } from "./outline.js";
+import { chainRoot, detailsOf, importedNames, outlineBody, summaryOf } from "./outline.js";
 import { checkedProgram } from "./tsCache.js";
 /**
  * Statically scan the project described by `tsconfigPath` for runnable oms and inspectable
@@ -43,12 +43,13 @@ export function discover(tsconfigPath) {
                 node.expression.text === names.om) {
                 const arg = node.arguments[0];
                 if (arg && ts.isStringLiteralLike(arg)) {
-                    const { calls, summary } = outlines.get(arg.text) ?? {};
+                    const { calls, summary, details } = outlines.get(arg.text) ?? {};
                     oms.push({
                         name: arg.text,
                         file,
                         line: lineOf(sf, node),
                         ...(summary !== undefined ? { summary } : {}),
+                        ...(details?.length ? { details } : {}),
                         ...(calls?.length ? { calls } : {}),
                     });
                 }
@@ -80,7 +81,7 @@ export function discover(tsconfigPath) {
 }
 /**
  * Outline every `om("name")…​.run(body)` chain in a file, keyed by om name, along with the
- * chain's literal `.describe({ summary })`.
+ * chain's literal `.describe({ summary, … })`.
  *
  * Collected in its own pass rather than alongside the `om(...)` match, because a body is only
  * reachable from the `.run` end of the chain and the om name only from the other — and the
@@ -99,9 +100,11 @@ function outlinesIn(sf, omName, imported) {
             const name = root?.call.arguments[0];
             if (root?.name === omName && name && ts.isStringLiteralLike(name)) {
                 const summary = summaryOf(root);
+                const details = detailsOf(root);
                 outlines.set(name.text, {
                     ...(body && ts.isFunctionLike(body) ? { calls: outlineBody(body, imported) } : {}),
                     ...(summary !== undefined ? { summary } : {}),
+                    ...(details.length ? { details } : {}),
                 });
             }
         }

package/dist/client/outline.d.ts

@@ -1,5 +1,5 @@
 import ts from "typescript";
-import type { OmCall } from "./registry.ts";
+import type { DescriptionDetail, OmCall } from "./registry.ts";
 /**
  * Every identifier a file binds through an import — the whole allow-list for the outline.
  * An action always arrives by import (`omkit/actions`, or a local actions module), so
@@ -40,3 +40,10 @@ export declare function outlineBody(body: ts.Node, imported: ReadonlySet<string>
  */
 /** The `summary` of a `.describe({ summary: "…" })` in the chain, when it is a string literal. */
 export declare function summaryOf(chain: ChainRoot): string | undefined;
+/**
+ * The props of a `.describe({ … })` in the chain besides `summary`, in source order, with each
+ * value rendered as text. Like {@link summaryOf}, only what the AST can read without evaluating:
+ * a string, number or boolean literal, or an array of those (joined with commas). A prop with
+ * any other value is left out rather than guessed at.
+ */
+export declare function detailsOf(chain: ChainRoot): DescriptionDetail[];

package/dist/client/outline.js

@@ -106,6 +106,50 @@ export function summaryOf(chain) {
     }
     return undefined;
 }
+/**
+ * The props of a `.describe({ … })` in the chain besides `summary`, in source order, with each
+ * value rendered as text. Like {@link summaryOf}, only what the AST can read without evaluating:
+ * a string, number or boolean literal, or an array of those (joined with commas). A prop with
+ * any other value is left out rather than guessed at.
+ */
+export function detailsOf(chain) {
+    const details = [];
+    for (const call of chain.calls) {
+        const callee = call.expression;
+        if (!ts.isPropertyAccessExpression(callee) || callee.name.text !== "describe")
+            continue;
+        const arg = call.arguments[0];
+        if (!arg || !ts.isObjectLiteralExpression(arg))
+            continue;
+        for (const prop of arg.properties) {
+            if (!ts.isPropertyAssignment(prop))
+                continue;
+            const key = ts.isIdentifier(prop.name) || ts.isStringLiteralLike(prop.name)
+                ? prop.name.text
+                : undefined;
+            if (key === undefined || key === "summary")
+                continue;
+            const value = literalText(prop.initializer);
+            if (value !== undefined)
+                details.push({ key, value });
+        }
+    }
+    return details;
+}
+/** A literal's value as text, or `undefined` when it needs evaluating. Arrays join with commas. */
+function literalText(node) {
+    if (ts.isStringLiteralLike(node) || ts.isNumericLiteral(node))
+        return node.text;
+    if (node.kind === ts.SyntaxKind.TrueKeyword)
+        return "true";
+    if (node.kind === ts.SyntaxKind.FalseKeyword)
+        return "false";
+    if (ts.isArrayLiteralExpression(node)) {
+        const items = node.elements.map((e) => literalText(e));
+        return items.every((i) => i !== undefined) ? items.join(", ") : undefined;
+    }
+    return undefined;
+}
 function tagOf(chain) {
     let tag;
     for (const call of chain.calls) {

package/dist/client/registry.d.ts

@@ -5,6 +5,11 @@ export interface OmCall {
     /** The `.tag("…")` literal from the same fluent chain, when the author wrote one. */
     readonly tag?: string;
 }
+/** One `.describe(…)` prop besides `summary`: its key, and its literal value as text. */
+export interface DescriptionDetail {
+    readonly key: string;
+    readonly value: string;
+}
 /** A runnable om discovered from a top-level `om("name", …)` call. */
 export interface DiscoveredOm {
     /** The om's name — its first string argument. */
@@ -19,6 +24,11 @@ export interface DiscoveredOm {
      * the import-based pass, `discoverRegistrations`.
      */
     readonly summary?: string;
+    /**
+     * The `.describe(…)` props besides `summary`, in source order, each value rendered as text
+     * (a list joined with commas). Read statically like `summary`, so only literal values appear.
+     */
+    readonly details?: readonly DescriptionDetail[];
     /**
      * A static approximation of what the body calls, in source order. Absent when the walk
      * found nothing recognisable. Never a contract — see {@link import("./outline.ts").outlineBody}

package/dist/core/types.d.ts

@@ -63,7 +63,14 @@ export interface ActionContext<Events extends object = NoEvents, Handle = void>
 export interface OmDescription {
     /** One line saying what this does. */
     summary: string;
+    /**
+     * Anything else worth knowing before running it — an owner, a docs link, what it needs.
+     * Listed under the summary, keyed by name, in the interactive picker and the run report.
+     */
+    readonly [prop: string]: DescriptionValue;
 }
+/** What a description prop can hold: values that read plainly in a terminal and a report. */
+export type DescriptionValue = string | number | boolean | readonly string[] | undefined;
 /** How an om or action behaves when a client runs it as an MCP tool. */
 export type McpMode = "settling" | "long-lived";
 /**

package/dist/output/RunModel.d.ts

@@ -7,6 +7,12 @@ export interface RunNode {
     readonly path: string;
     readonly status: RunNodeStatus;
     readonly tags: readonly string[];
+    /** Epoch millis of the node's first entry. */
+    readonly startedAt: number;
+    /** Epoch millis it settled; absent while it runs. */
+    readonly endedAt?: number;
+    /** First line of the node's latest output (console or proc), for a live "what is it doing" row. */
+    readonly last?: string;
 }
 /** A compact roll-up of the live tree, for a one-line status strip. */
 export interface RunSummary {
@@ -31,6 +37,8 @@ export declare class RunModel {
     apply(entry: LogEntry): Rendered | null;
     /** The live tree: every node touched so far, with its current status and tags. */
     nodes(): readonly RunNode[];
+    /** One node of the live tree by id, as it stands now — for a caller rendering one entry. */
+    node(nodeId: string): RunNode | undefined;
     /** The capped tail of milestone lines, oldest first. */
     milestones(): readonly string[];
     /** A compact roll-up for a status strip: who's still running, and how many finished each way. */

package/dist/output/RunModel.js

@@ -18,6 +18,11 @@ export class RunModel {
             return null; // tags decorate a node's lines; they aren't a line of their own
         }
         this.transition(node, entry);
+        if (isActivity(entry)) {
+            const line = entry.message.split("\n", 1)[0].trim();
+            if (line)
+                node.last = line;
+        }
         const rendered = format(entry, node.tags);
         if (rendered)
             this.push(rendered.text);
@@ -25,11 +30,12 @@ export class RunModel {
     }
     /** The live tree: every node touched so far, with its current status and tags. */
     nodes() {
-        return [...this._nodes.values()].map((n) => ({
-            path: n.path,
-            status: n.status,
-            tags: [...n.tags],
-        }));
+        return [...this._nodes.values()].map(view);
+    }
+    /** One node of the live tree by id, as it stands now — for a caller rendering one entry. */
+    node(nodeId) {
+        const n = this._nodes.get(nodeId);
+        return n && view(n);
     }
     /** The capped tail of milestone lines, oldest first. */
     milestones() {
@@ -60,7 +66,13 @@ export class RunModel {
             existing.order = this.seq++; // most-recent activity wins the ordering
             return existing;
         }
-        const node = { path: entry.path, status: "running", tags: [], order: this.seq++ };
+        const node = {
+            path: entry.path,
+            status: "running",
+            tags: [],
+            order: this.seq++,
+            startedAt: entry.ts,
+        };
         this._nodes.set(entry.nodeId, node);
         return node;
     }
@@ -69,10 +81,12 @@ export class RunModel {
             // A node reports `done · <status>` when it settles; "launched" leaves it running.
             if (entry.message.startsWith("done · ")) {
                 node.status = statusOf(entry.message.slice("done · ".length));
+                node.endedAt = entry.ts;
             }
         }
         else if (entry.level === "event" && entry.source === "cancel") {
             node.status = "cancelled";
+            node.endedAt ??= entry.ts;
         }
     }
     push(text) {
@@ -81,6 +95,25 @@ export class RunModel {
             this._milestones.shift();
     }
 }
+/**
+ * What a node is doing, for its "latest line": its output and its own events (a watcher's
+ * `update · …`), not its lifecycle or a cancellation, which its status already says.
+ */
+function isActivity(e) {
+    if (e.level === "info" || e.level === "error")
+        return true;
+    return e.level === "event" && e.source !== "lifecycle" && e.source !== "cancel";
+}
+function view(n) {
+    return {
+        path: n.path,
+        status: n.status,
+        tags: [...n.tags],
+        startedAt: n.startedAt,
+        ...(n.endedAt === undefined ? {} : { endedAt: n.endedAt }),
+        ...(n.last === undefined ? {} : { last: n.last }),
+    };
+}
 function statusOf(s) {
     return s === "ok" ? "ok" : s === "cancelled" ? "cancelled" : "failed";
 }