omkit 0.8.22 → 0.8.24

package/README.md

@@ -83,7 +83,7 @@ om("dev")
 Run it:
 
 ```sh
-npx omkit            # interactive picker: browse, run, watch milestones live
+npx omkit            # interactive shell: pick, run, watch, stop, rerun — until you quit
 npx omkit run dev    # or run one om directly
 ```
 

package/dist/actions/command.js

@@ -1,6 +1,7 @@
 import { spawn } from "node:child_process";
 import path from "node:path";
-import { action } from "../core/action.js";
+import { action, launchedFrom } from "../core/action.js";
+import { callerSite } from "../foundation/callsite.js";
 import { debuggerFreeEnv, killTree, streamLines } from "../system/proc.js";
 /**
  * Build a zx tagged template that runs `cmd` verbatim.
@@ -24,19 +25,31 @@ export function commandName(cmdOrFile, options = {}) {
 export function command(cmdOrFile, options = {}) {
     const cwd = path.resolve(options.cwd ?? ".");
     const name = commandName(cmdOrFile, options);
+    // Built per call, so each launch below is in this file; record the user's line instead.
+    const site = callerSite();
+    // What the run record shows as this call's args. `env` is left out on purpose: it is a whole
+    // environment, secrets included, and the record is written to disk and into the report.
+    const shown = [
+        cmdOrFile,
+        {
+            ...(options.args && { args: options.args }),
+            ...(options.cwd && { cwd: options.cwd }),
+            ...(options.inheritDebugger && { inheritDebugger: true }),
+        },
+    ];
     // Shell command — the command string is the action (and proc) name.
     if (options.args === undefined) {
-        return action(name).run((ctx) => ctx.proc(cmdOrFile, {
+        return launchedFrom(site, () => action(name).run((ctx, ..._shown) => ctx.proc(cmdOrFile, {
             cwd,
             ...(options.env && { env: options.env }),
             ...(options.inheritDebugger && {
                 inheritDebugger: true,
             }),
-        })(verbatim(cmdOrFile)))();
+        })(verbatim(cmdOrFile)))(...shown));
     }
     // Direct executable — the file plus its args form the action name.
     const args = options.args;
-    return action(name).run(async (ctx) => {
+    return launchedFrom(site, () => action(name).run(async (ctx, ..._shown) => {
         const inherit = options.inheritDebugger;
         const env = inherit
             ? (options.env ?? process.env)
@@ -83,5 +96,5 @@ export function command(cmdOrFile, options = {}) {
             finished = true;
             ctx.signal.removeEventListener("abort", onAbort);
         }
-    })();
+    })(...shown));
 }

package/dist/actions/poll-until.js

@@ -1,5 +1,6 @@
 import { setTimeout as sleep } from "node:timers/promises";
-import { action } from "../core/action.js";
+import { action, launchedFrom } from "../core/action.js";
+import { callerSite } from "../foundation/callsite.js";
 /**
  * Gate: calls `predicate` every `intervalMs` until it returns something other than `false`,
  * `null` or `undefined`, and resolves with that value — so it can find a thing as well as wait
@@ -9,7 +10,11 @@ import { action } from "../core/action.js";
  */
 export function pollUntil(description, predicate, options = {}) {
     const { intervalMs = 200, timeoutMs = 30_000 } = options;
-    return action(description).run(async ({ signal }) => {
+    // Built per call, so the launch below is in this file; record the user's line instead.
+    const site = callerSite();
+    return launchedFrom(site, () => 
+    // The call's own arguments go through the launch, so the run record shows them as args.
+    action(description).run(async ({ signal }, ..._call) => {
         const deadline = Date.now() + timeoutMs;
         let attempts = 0;
         for (;;) {
@@ -26,5 +31,5 @@ export function pollUntil(description, predicate, options = {}) {
             }
             await sleep(Math.min(intervalMs, remaining), undefined, { signal });
         }
-    })();
+    })(description, predicate, options));
 }

package/dist/cli/commands/ui.d.ts

@@ -1,8 +1,9 @@
 import type { OmkitClient } from "../../client/index.ts";
 /**
- * Render the interactive Ink app. Ink's own Ctrl+C handling is disabled so the app can tear the
- * run down gracefully first; the final verdict + run-folder path are printed here, after Ink
- * unmounts (it erases its own frame), so the pointer to the on-disk record survives on screen.
+ * Render the interactive shell, which stays up across runs until the user quits. Ink's own Ctrl+C
+ * handling is disabled so the app can tear a live run down gracefully first. Each run's verdict
+ * and recap block are already in the scrollback by then (the app writes them there as each run
+ * settles), so nothing is reprinted here; the exit code is the last run's verdict.
  *
  * Discovery runs first, before Ink takes the terminal: a fatal config problem throws here and the
  * bin's error boundary turns it into a clean crash rather than an empty list. With no oms to show,

package/dist/cli/commands/ui.js

@@ -4,9 +4,10 @@ import { App } from "../ui/app.js";
 import { renderDiagnostics, withSpinner } from "../ui/Report.js";
 import { reportNoOms } from "./run.js";
 /**
- * Render the interactive Ink app. Ink's own Ctrl+C handling is disabled so the app can tear the
- * run down gracefully first; the final verdict + run-folder path are printed here, after Ink
- * unmounts (it erases its own frame), so the pointer to the on-disk record survives on screen.
+ * Render the interactive shell, which stays up across runs until the user quits. Ink's own Ctrl+C
+ * handling is disabled so the app can tear a live run down gracefully first. Each run's verdict
+ * and recap block are already in the scrollback by then (the app writes them there as each run
+ * settles), so nothing is reprinted here; the exit code is the last run's verdict.
  *
  * Discovery runs first, before Ink takes the terminal: a fatal config problem throws here and the
  * bin's error boundary turns it into a clean crash rather than an empty list. With no oms to show,
@@ -27,19 +28,12 @@ export async function launchUi(client) {
         });
     }
     let finalVerdict;
-    const app = render(_jsx(App, { client: client, oms: registry.oms, onExit: (v) => (finalVerdict = v) }), {
+    const app = render(_jsx(App, { client: client, oms: registry.oms, warnings: registry.warnings, onExit: (v) => (finalVerdict = v) }), {
         exitOnCtrlC: false,
     });
     void app.waitUntilExit().then(() => {
-        if (finalVerdict) {
-            // Ink erased its frame on unmount; reprint the verdict marker plus the run's recap block
-            // (the same summary a bare run prints) so the pointers to the on-disk record survive.
-            console.log("");
-            console.log(finalVerdict.ok ? "✓ ok" : "✗ failed");
-            for (const line of finalVerdict.summary)
-                console.log(line);
+        if (finalVerdict)
             process.exitCode = finalVerdict.ok ? 0 : 1;
-        }
         // Backstop: the runner disconnects the supervised child so both processes can exit, but if
         // anything (a wedged pipe, a lingering handle) keeps the event loop alive past the grace,
         // force the exit. Unref'd, so it only fires when the process is genuinely stuck — a clean

package/dist/cli/ui/app.d.ts

@@ -1,12 +1,27 @@
 import { type ReactElement } from "react";
 import type { OmkitClient, Verdict } from "../../client/types.ts";
 import type { DiscoveredOm } from "../../client/registry.ts";
-/** The interactive app: discover → list/search → run → live milestones + prompts. */
-export declare function App({ client, onExit, oms: initialOms, }: {
+/**
+ * The interactive shell: pick an om, watch it run, stop it, and come back to the picker for the
+ * next — the process stays up until you quit. Every run is a fresh supervised child, so a rerun
+ * always executes the current code of the om and its actions; only the picker's list comes from
+ * discovery, which is redone in the background each time a run ends.
+ *
+ * The screen is two parts. Above, the scrollback ({@link Scrollback}): each run's header, its
+ * milestones, and its verdict with the recap block a bare run prints — written once, kept by the
+ * terminal. Below, the live part, the only thing redrawn: the picker, or the run box
+ * ({@link RunView}) with the running nodes, a prompt, and the key line.
+ *
+ * Stopping is always a graceful teardown — the child reaps its process tree and reports a verdict
+ * — and nothing here exits or moves on before that verdict. `esc` stops and returns to the
+ * picker; `ctrl+c` stops and then quits, and quits straight away from the picker.
+ */
+export declare function App({ client, onExit, oms: initialOms, warnings: initialWarnings, }: {
     client: OmkitClient;
-    /** Called with the run's verdict (if any) just before Ink unmounts, so the caller can print
-     *  a durable summary — Ink erases its own frame on exit. */
+    /** Called with the last run's verdict (if any) just before Ink unmounts. */
     onExit?: (verdict: Verdict | undefined) => void;
-    /** Oms discovered by the caller (pre-flight). When given, the app skips its own discovery. */
+    /** Oms discovered by the caller (pre-flight). When given, the app skips its own first scan. */
     oms?: DiscoveredOm[];
+    /** Warnings the caller already printed for that scan, so a rediscovery repeats only new ones. */
+    warnings?: readonly string[];
 }): ReactElement;

package/dist/cli/ui/app.js

@@ -1,143 +1,308 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import fs from "node:fs";
+import path from "node:path";
 import { useEffect, useRef, useState } from "react";
-import { useApp, useInput } from "ink";
+import { Box, Text, useApp, useInput } from "ink";
 import { RunModel } from "../../output/RunModel.js";
 import { OmList } from "./views/OmList.js";
-import { RunView } from "./views/RunView.js";
+import { RunView, formatDuration } from "./views/RunView.js";
+import { recapLines, shellLine } from "./views/shellLines.js";
+import { Scrollback } from "./views/Scrollback.js";
 import { Spinner } from "./Spinner.js";
 import { redrawLoop } from "./redrawLoop.js";
+import { openFile } from "./openFile.js";
 /**
  * How often the run screen redraws while the log streams in.
  *
- * An Ink frame costs ~25ms at minimum and grows with the milestone tail, so redrawing per log
- * entry caps the app at roughly 40 entries/second — far under what a build, a test suite, or a
- * dev server emits. The app then falls permanently behind: `settled` is the *last* message on
- * the channel, so it only arrives once every backlogged entry has been drawn, and the run looks
- * hung long after the child has finished. Folding into the model is cheap; drawing is not, so
- * the two run at different rates — and the gap is kept *after* each frame (see {@link redrawLoop}),
+ * An Ink frame costs ~25ms at minimum and grows with what it draws, so redrawing per log entry
+ * caps the app at roughly 40 entries/second — far under what a build, a test suite, or a dev
+ * server emits. The app then falls permanently behind: the verdict is the *last* message on the
+ * channel, so it only arrives once every backlogged entry has been drawn, and the run looks hung
+ * long after the child has finished. Folding into the model is cheap; drawing is not, so the two
+ * run at different rates — and the gap is kept *after* each frame (see {@link redrawLoop}),
  * since a frame slower than this would otherwise leave no time between frames for the log at all.
  */
 const REDRAW_MS = 80;
-/** The interactive app: discover → list/search → run → live milestones + prompts. */
-export function App({ client, onExit, oms: initialOms, }) {
+const sameOm = (a, b) => a.file === b.file && a.name === b.name;
+const clock = (at) => new Date(at).toTimeString().slice(0, 8);
+/**
+ * The interactive shell: pick an om, watch it run, stop it, and come back to the picker for the
+ * next — the process stays up until you quit. Every run is a fresh supervised child, so a rerun
+ * always executes the current code of the om and its actions; only the picker's list comes from
+ * discovery, which is redone in the background each time a run ends.
+ *
+ * The screen is two parts. Above, the scrollback ({@link Scrollback}): each run's header, its
+ * milestones, and its verdict with the recap block a bare run prints — written once, kept by the
+ * terminal. Below, the live part, the only thing redrawn: the picker, or the run box
+ * ({@link RunView}) with the running nodes, a prompt, and the key line.
+ *
+ * Stopping is always a graceful teardown — the child reaps its process tree and reports a verdict
+ * — and nothing here exits or moves on before that verdict. `esc` stops and returns to the
+ * picker; `ctrl+c` stops and then quits, and quits straight away from the picker.
+ */
+export function App({ client, onExit, oms: initialOms, warnings: initialWarnings = [], }) {
     const { exit } = useApp();
     const [oms, setOms] = useState(initialOms ?? []);
-    const [session, setSession] = useState(null);
-    // A per-run RunModel folds the log stream into a capped milestone tail plus a live node summary;
-    // these snapshots are what the view renders. The cap is what keeps a long run from growing forever.
-    const [lines, setLines] = useState([]);
-    const [status, setStatus] = useState();
+    const [discovering, setDiscovering] = useState(false);
+    const [chunks, setChunks] = useState([]);
+    const [current, setCurrent] = useState();
+    const [phase, setPhase] = useState("running");
+    const [upAt, setUpAt] = useState();
+    const [nodes, setNodes] = useState([]);
+    const [summary, setSummary] = useState();
     const [prompt, setPrompt] = useState();
-    const [verdict, setVerdict] = useState();
-    const [tearing, setTearing] = useState(false);
-    // Refs so the Ctrl+C handler always sees the live session/verdict, not a stale render closure.
-    const sessionRef = useRef(null);
-    const verdictRef = useRef(undefined);
-    const tearingRef = useRef(false);
+    const [last, setLast] = useState();
+    const [quitting, setQuitting] = useState(false);
+    // Refs so key handlers and session callbacks see live values, not a stale render closure.
+    const currentRef = useRef(undefined);
+    const phaseRef = useRef("running");
+    const quitRef = useRef(false);
+    const lastRef = useRef(undefined);
+    const omsRef = useRef(initialOms ?? []);
+    const warningsRef = useRef(initialWarnings.join("\n"));
+    const chunkId = useRef(0);
+    const mounted = useRef(true);
     const redrawTimer = useRef(undefined);
+    const say = (lines) => {
+        if (lines.length === 0)
+            return;
+        const chunk = { id: chunkId.current++, lines };
+        setChunks((c) => [...c, chunk]);
+    };
+    const enterPhase = (p) => {
+        phaseRef.current = p;
+        setPhase(p);
+    };
     const stopRedraw = () => {
         redrawTimer.current?.stop();
         redrawTimer.current = undefined;
     };
     // The redraw timer holds the event loop open, so it must not outlive the app — an unmount
     // for any reason other than the run settling would otherwise keep the CLI from exiting.
-    useEffect(() => stopRedraw, []);
-    useEffect(() => {
-        if (initialOms)
-            return; // provided by the caller's pre-flight discovery
-        let live = true;
-        void client.discover().then((r) => {
-            if (live)
-                setOms(r.oms);
+    useEffect(() => () => {
+        mounted.current = false;
+        stopRedraw();
+    }, []);
+    /**
+     * Scan for oms again — after every run, since the om files may have changed while it ran. The
+     * old list stays usable meanwhile, and stays put if the scan fails: a broken edit is reported,
+     * not a reason to empty the picker.
+     */
+    const rediscover = () => {
+        setDiscovering(true);
+        void client
+            .discover()
+            .then((registry) => {
+            if (!mounted.current)
+                return;
+            omsRef.current = registry.oms;
+            setOms(registry.oms);
+            const key = registry.warnings.join("\n");
+            if (key !== warningsRef.current) {
+                warningsRef.current = key;
+                say(registry.warnings.map((w) => ({ text: `⚠ ${w}`, color: "yellow" })));
+            }
+        })
+            .catch((err) => {
+            if (!mounted.current)
+                return;
+            const message = err instanceof Error ? err.message : String(err);
+            say([{ text: `✗ discovery failed — keeping the previous list: ${message}`, color: "red" }]);
+        })
+            .finally(() => {
+            if (mounted.current)
+                setDiscovering(false);
         });
-        return () => {
-            live = false;
-        };
-    }, [client, initialOms]);
+    };
+    useEffect(() => {
+        if (!initialOms)
+            rediscover();
+        // first scan only; later ones follow runs
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    const quit = () => {
+        onExit?.(lastRef.current?.verdict);
+        exit();
+    };
+    /** The run settled: its verdict and recap go to the scrollback, then the picker comes back. */
+    const finish = (cur, v) => {
+        const stopped = phaseRef.current === "stopping";
+        const took = formatDuration(Date.now() - cur.startedAt);
+        const [icon, word, color] = !v.ok
+            ? ["✗", "failed", "red"]
+            : stopped
+                ? ["⊘", "stopped", "yellow"]
+                : ["✓", "ok", "green"];
+        say([
+            { text: `${icon} ${cur.om.name} · ${word} · ${took}`, color, bold: true },
+            ...recapLines(v.summary),
+            { text: " " }, // a blank line before the next run's rule; Ink drops an empty one
+        ]);
+        const done = { om: cur.om, verdict: v };
+        lastRef.current = done;
+        setLast(done);
+        currentRef.current = undefined;
+        setCurrent(undefined);
+        setPrompt(undefined);
+        setNodes([]);
+        setSummary(undefined);
+        setUpAt(undefined);
+        enterPhase("running");
+        if (quitRef.current) {
+            quit();
+            return;
+        }
+        rediscover();
+    };
     const run = (om) => {
+        if (currentRef.current)
+            return;
         const model = new RunModel();
-        const s = client.run(om.file);
-        sessionRef.current = s;
+        const startedAt = Date.now();
+        say([{ text: om.name, bold: true, rule: { right: clock(startedAt) } }]);
+        const session = client.run(om.file);
+        const cur = { om, session, startedAt };
+        currentRef.current = cur;
+        enterPhase("running");
         // Every entry lands in the model immediately; the screen catches up on its own cadence.
         // `dirty` keeps an idle run from redrawing over nothing — see REDRAW_MS for why the two
-        // are separated at all.
+        // are separated at all. Scrollback lines (see shellLine for which entries earn one) wait in
+        // `pending` and reach the scrollback as one chunk per tick.
         let dirty = false;
+        let tearingDown = false;
+        const pending = [];
         const redraw = () => {
             if (!dirty)
                 return;
             dirty = false;
-            setLines(model.milestones());
-            setStatus(model.summary());
+            setNodes(model.nodes());
+            setSummary(model.summary());
+            say(pending.splice(0));
         };
         redrawTimer.current = redrawLoop(redraw, REDRAW_MS);
-        s.on("log", (entry) => {
+        session.on("log", (entry) => {
             model.apply(entry);
+            // the run narrates its own teardown — a stop, or the end of a body that left daemons up
+            if (entry.level === "run" && entry.message.startsWith("tearing down"))
+                tearingDown = true;
+            const line = shellLine(entry, model.node(entry.nodeId), tearingDown);
+            if (line)
+                pending.push(line);
             dirty = true;
         });
         // A prompt blocks the child until it's answered, so it must not wait for the next tick —
         // and the milestones that led to it are the context the question is read in.
-        s.on("prompt", (req) => {
+        session.on("prompt", (req) => {
             redraw();
             setPrompt(req);
         });
         // The child gave up on the prompt (timed out or torn down). Withdraw its box so a stale,
         // unanswerable prompt doesn't linger — but only if it's still the one on screen, so a late
         // withdrawal can't clobber a fresh prompt.
-        s.on("promptDone", (id) => setPrompt((p) => (p?.id === id ? undefined : p)));
-        s.on("settled", (v) => {
-            redraw(); // the run's closing milestones, before its verdict
-            setVerdict(v);
-            setPrompt(undefined);
+        session.on("promptDone", (id) => setPrompt((p) => (p?.id === id ? undefined : p)));
+        // The body returned with something still running: a stack that stays up until stopped.
+        // A body cut short by a stop returns too, and reports `up` on its way down — not a stack up.
+        session.on("up", () => {
+            if (phaseRef.current === "stopping")
+                return;
+            const at = Date.now();
+            pending.push({ text: `  ● up · ${formatDuration(at - startedAt)}`, color: "green" });
+            dirty = true;
+            setUpAt(at);
+            enterPhase("up");
         });
-        // The single exit point. `result` resolves when the run ends — a natural completion (a build
-        // that settles on its own), a teardown after Ctrl+C, or a crash that closes the channel — and
-        // stays pending for a live daemon stack until Ctrl+C. Record the verdict, hand it to the caller
-        // so it can print the durable summary block, and unmount. Without this a self-completing run
-        // would show its verdict line but never exit or render the summary.
-        void s.result.then((v) => {
+        // The single end of a run: a natural completion, a teardown after a stop, or a crash that
+        // closes the channel. A live stack never gets here on its own — only after a stop.
+        void session.result.then((v) => {
             stopRedraw();
+            dirty = true;
             redraw(); // last pass: whatever arrived since the final tick
-            verdictRef.current = v;
-            setVerdict(v);
-            onExit?.(v);
-            exit();
+            if (mounted.current)
+                finish(cur, v);
         });
-        setSession(s);
+        setCurrent(cur);
     };
-    const answer = (value) => {
-        if (session && prompt)
-            session.answer(prompt.id, value);
-        setPrompt(undefined);
+    /** Ask the run to tear down. Idempotent: the child owns the teardown and reports when done. */
+    const stop = (thenQuit) => {
+        const cur = currentRef.current;
+        if (!cur)
+            return;
+        if (thenQuit && !quitRef.current) {
+            quitRef.current = true;
+            setQuitting(true);
+        }
+        if (phaseRef.current === "stopping")
+            return;
+        enterPhase("stopping");
+        cur.session.cancel();
     };
-    // Ctrl+C: in raw mode this is a keystroke, not a signal. Cancel the run and wait for the child
-    // to tear down and report its verdict, then quit — leaving the durable summary to `onExit`.
-    //
-    // Repeated presses are a deliberate no-op (see the `tearing` guard below): the child owns the
-    // teardown and is guaranteed to report `settled` within its grace window, so we let it finish
-    // rather than force-exiting. This mirrors the normal om run, where SIGINT is caught with
-    // `process.on` and smashing Ctrl+C just re-triggers an idempotent teardown — the process never
-    // exits before the tree is reaped. Force-exiting here (the old second-press escape hatch) killed
-    // the parent mid-teardown and orphaned the child's process tree (vite, watchers, Chrome).
-    useInput((input, key) => {
-        if (!(key.ctrl && input === "c"))
+    const rerun = () => {
+        const prev = lastRef.current;
+        if (!prev)
             return;
-        const s = sessionRef.current;
-        // Nothing running or already settled → quit now.
-        if (!s || verdictRef.current) {
-            onExit?.(verdictRef.current);
-            exit();
+        // Rerun what discovery still finds; the run itself reads the current code either way.
+        const om = omsRef.current.find((o) => sameOm(o, prev.om));
+        if (!om) {
+            say([{ text: `⚠ ${prev.om.name} is no longer discovered — not rerunning`, color: "yellow" }]);
             return;
         }
-        // Already tearing down → ignore. The child is reaping its tree and will report `settled` (or
-        // the channel closes and resolves a failed verdict); either way `result` resolves and the
-        // handler wired in `run()` records the verdict and unmounts. Just request the teardown here.
-        if (tearingRef.current)
+        run(om);
+    };
+    const openReport = () => {
+        const folder = lastRef.current?.verdict.folder;
+        const file = folder ? path.join(folder, "report.html") : undefined;
+        if (!file || !fs.existsSync(file)) {
+            say([{ text: "⚠ the last run wrote no report.html", color: "yellow" }]);
+            return;
+        }
+        openFile(file).then(() => say([{ text: `↗ ${file}`, dim: true }]), (err) => say([
+            {
+                text: `✗ could not open ${file}: ${err instanceof Error ? err.message : String(err)}`,
+                color: "red",
+            },
+        ]));
+    };
+    // In raw mode Ctrl+C is a keystroke, not a signal. During a run every stop key only *requests*
+    // the teardown: repeated presses are a deliberate no-op, and nothing exits before the child has
+    // reaped its tree and reported — force-exiting mid-teardown would orphan its process tree
+    // (vite, watchers, Chrome). This mirrors a bare om run, where SIGINT re-triggers an idempotent
+    // teardown and the process never exits before the tree is reaped.
+    useInput((input, key) => {
+        const running = currentRef.current !== undefined;
+        if (key.ctrl && input === "c") {
+            if (running)
+                stop(true);
+            else
+                quit();
+            return;
+        }
+        if (running) {
+            // with a prompt up, esc belongs to the prompt (it clears a choice search)
+            if (key.escape && !prompt)
+                stop(false);
             return;
-        tearingRef.current = true;
-        setTearing(true);
-        s.cancel();
+        }
+        if (key.ctrl && input === "r")
+            rerun();
+        else if (key.ctrl && input === "o")
+            openReport();
     });
-    if (!session)
-        return _jsx(OmList, { oms: oms, onSelect: run });
-    return (_jsxs(_Fragment, { children: [_jsx(RunView, { lines: lines, status: status, prompt: prompt, verdict: verdict, onAnswer: answer }), !verdict && tearing ? _jsx(Spinner, { label: "tearing down\u2026 (stopping the run cleanly)" }) : null, !verdict && !tearing && !prompt ? _jsx(Spinner, { label: "running\u2026" }) : null] }));
+    const hint = current
+        ? phase === "stopping"
+            ? `stopping cleanly — waiting for the run to tear down${quitting ? ", then quitting" : ""}`
+            : prompt
+                ? "enter answer · ctrl+c stop and quit"
+                : "esc stop · ctrl+c stop and quit"
+        : [
+            "↑↓ move · enter run",
+            last ? `ctrl+r rerun ${last.om.name} · ctrl+o report` : "",
+            "ctrl+c quit",
+        ]
+            .filter(Boolean)
+            .join(" · ");
+    return (_jsxs(_Fragment, { children: [_jsx(Scrollback, { chunks: chunks }), current ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(RunView, { name: current.om.name, phase: phase, startedAt: current.startedAt, upAt: upAt, nodes: nodes, summary: summary, prompt: prompt, onAnswer: (value) => {
+                            if (prompt)
+                                current.session.answer(prompt.id, value);
+                            setPrompt(undefined);
+                        } }), _jsx(Text, { dimColor: true, children: hint })] })) : (_jsx(OmList, { oms: oms, onSelect: run, hint: hint, status: discovering ? _jsx(Spinner, { label: "rediscovering\u2026" }) : undefined }))] }));
 }

package/dist/cli/ui/openFile.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Open `file` with the OS's default handler (a browser, for `report.html`) without waiting on it.
+ * Resolves once the opener has launched, or rejects with why it couldn't — a Linux box without
+ * `xdg-open`, say — so the caller can say so instead of the key press doing nothing.
+ */
+export declare function openFile(file: string): Promise<void>;

package/dist/cli/ui/openFile.js

@@ -0,0 +1,21 @@
+import { spawn } from "node:child_process";
+/**
+ * Open `file` with the OS's default handler (a browser, for `report.html`) without waiting on it.
+ * Resolves once the opener has launched, or rejects with why it couldn't — a Linux box without
+ * `xdg-open`, say — so the caller can say so instead of the key press doing nothing.
+ */
+export function openFile(file) {
+    const [cmd, args] = process.platform === "win32"
+        ? ["cmd", ["/c", "start", "", file]]
+        : process.platform === "darwin"
+            ? ["open", [file]]
+            : ["xdg-open", [file]];
+    return new Promise((resolve, reject) => {
+        const child = spawn(cmd, args, { detached: true, stdio: "ignore", windowsHide: true });
+        child.once("error", reject);
+        child.once("spawn", () => {
+            child.unref();
+            resolve();
+        });
+    });
+}

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

@@ -1,4 +1,4 @@
-import { type ReactElement } from "react";
+import { type ReactElement, type ReactNode } from "react";
 import type { DiscoveredOm } from "../../../client/registry.ts";
 /**
  * The picker: a searchable, arrow-navigable list of oms; Enter runs the highlighted one.
@@ -10,8 +10,13 @@ import type { DiscoveredOm } from "../../../client/registry.ts";
  * 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 declare function OmList({ oms, onSelect, }: {
+export declare function OmList({ oms, onSelect, status, hint, }: {
     oms: DiscoveredOm[];
     onSelect: (om: DiscoveredOm) => void;
+    status?: ReactNode;
+    hint?: string;
 }): ReactElement;

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,7 +34,7 @@ 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 })] }));
 }
 /** The highlighted om in full. */
 function OmDetail({ om, root }) {

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: 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,61 @@
+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: 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("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/core/action.d.ts

@@ -1,4 +1,12 @@
 import type { ActionBuilderEvents, NoEvents } from "./types.ts";
+/**
+ * Run `launch` (which must launch exactly one action, synchronously) with `site` recorded as
+ * that launch's `calledAt`. For batteries that build their action per call inside a factory
+ * (`command`, `pollUntil`): the launch then happens in omkit's own file, so the frame the
+ * launch would record is the factory, not the user's line. The factory captures its caller
+ * with `callerSite()` and hands it over here.
+ */
+export declare function launchedFrom<T>(site: string | undefined, launch: () => T): T;
 /**
  * Define an action. Provide the impl via `.run(…)`, optionally after declaring
  * metadata (`.describe(…)`), events (`.emits<…>()`), an imperative handle

package/dist/core/action.js

@@ -2,6 +2,29 @@ import { ExecutionTree } from "./ExecutionTree.js";
 import { callerSite } from "../foundation/callsite.js";
 import { describeSchema } from "./discovery-mode.js";
 import { formatIssues } from "./args.js";
+/** A call site handed over by {@link launchedFrom}, taken by the very next launch. */
+let handedSite;
+const takeHandedSite = () => {
+    const site = handedSite;
+    handedSite = undefined;
+    return site;
+};
+/**
+ * Run `launch` (which must launch exactly one action, synchronously) with `site` recorded as
+ * that launch's `calledAt`. For batteries that build their action per call inside a factory
+ * (`command`, `pollUntil`): the launch then happens in omkit's own file, so the frame the
+ * launch would record is the factory, not the user's line. The factory captures its caller
+ * with `callerSite()` and hands it over here.
+ */
+export function launchedFrom(site, launch) {
+    handedSite = site;
+    try {
+        return launch();
+    }
+    finally {
+        handedSite = undefined;
+    }
+}
 /**
  * The builder returned by `action(name)`: declare metadata (`.describe(…)`), events
  * (`.emits<…>()`), an imperative handle (`.ref<…>()`), and/or pin the args type
@@ -56,7 +79,7 @@ class Builder {
         const exec = body;
         const create = (...args) => {
             // where this launch was written — for a battery, the user's call rather than its definition
-            const calledAt = callerSite();
+            const calledAt = takeHandedSite() ?? callerSite();
             const spec = { name, args, tags: [], body: exec, definedAt, calledAt, meta };
             return ExecutionTree.require().launch(spec);
         };
@@ -124,7 +147,7 @@ class ArgsBuilder {
         const exec = body;
         const create = (...args) => {
             // where this launch was written — for a battery, the user's call rather than its definition
-            const calledAt = callerSite();
+            const calledAt = takeHandedSite() ?? callerSite();
             const spec = { name, args, tags: [], body: exec, definedAt, calledAt, meta };
             return ExecutionTree.require().launch(spec);
         };

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";
 }

package/dist/output/writers/report/report.js

@@ -752,7 +752,8 @@
         const need = text.length * 6.6 + 14;
         const inside = w >= need;
         const clipX = Math.max(x0, 0);
-        const outside = !inside && w <= 60;
+        // outside, too, when inside would cut it to a stub (`port =…`): a call label needs room
+        const outside = !inside && w < 16 * 6.6 + 14;
         const shown = inside || outside ? text : truncate(text, (w - 14) / 6.6);
         const tw = shown.length * 6.6;
         // an outside label that would run off the chart hangs left of its bar instead

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omkit",
-  "version": "0.8.22",
+  "version": "0.8.24",
   "description": "A tiny runtime for developer workflows: typed actions that pass runtime capabilities and emit typed events, under one run and one shared log. The operational/runtime layer to tskb's knowledge layer.",
   "type": "module",
   "main": "./dist/index.js",