@turri-dev/cli 0.1.2 → 0.1.3-next.04c4f71

package/dist/regenerate/panel-dock.js

@@ -0,0 +1,86 @@
+import { HStack } from "@earendil-works/pi-tui";
+/**
+ * The side panel beside the chat rather than over it: the chat drawn on the left in what the panel leaves it, the panel
+ * laid over the columns on the right.
+ *
+ * pi draws its screen one of two ways, and the chat is narrowed in each as it is drawn: full screen (pi's default), a
+ * layout - its root put in a row beside a filler as wide as the panel; the regular screen, the lines its render gives -
+ * asked for in fewer columns.
+ */
+/** Narrower than this, the chat and the panel have no room side by side: the panel takes the whole screen. */
+const SHARED_FROM = 100;
+/** The columns the panel takes beside the chat: half the screen, the rule between them in the middle - 0 when the terminal is too narrow to share. */
+export function dockedWidth(columns) {
+    return columns < SHARED_FROM ? 0 : Math.floor(columns / 2);
+}
+/**
+ * The chat narrowed by `panelWidth()` columns, read at each frame - 0 gives it the whole width. Returns what gives it the
+ * whole width back for good.
+ */
+export function narrowChat(tui, panelWidth) {
+    const screen = tui;
+    if (typeof screen.setLayoutRoot === "function" && screen.layoutRoot !== undefined) {
+        const root = screen.layoutRoot;
+        // A line as wide as the panel: the row gives the filler what it measures, the chat the rest.
+        const filler = { render: () => [" ".repeat(panelWidth())], invalidate() { } };
+        screen.setLayoutRoot(new HStack([{ component: root, basis: 0, grow: 1 }, { component: filler }]));
+        return () => screen.setLayoutRoot(root);
+    }
+    // Read from the prototype: the screen's own render, not one laid over it.
+    const render = Object.getPrototypeOf(tui).render;
+    screen.render = function (width) {
+        return render.call(this, Math.max(1, width - panelWidth()));
+    };
+    return () => {
+        screen.render = render;
+    };
+}
+/**
+ * A press of a mouse button, as pi's full screen takes it - `side` told whether it was in the chat, left of `chatWidth()`
+ * columns, or in the panel - before the press goes on as it would have. Motion and the wheel are not presses. pi's
+ * regular screen reads no mouse: nothing is done there. Returns what takes the watch off.
+ */
+export function clickToFocus(tui, chatWidth, side) {
+    const screen = tui;
+    const handle = screen.handleMouseEvent;
+    if (typeof handle !== "function")
+        return () => { };
+    screen.handleMouseEvent = function (raw) {
+        // 32: motion; 64: the wheel.
+        if (raw.release !== true && (raw.button & (32 | 64)) === 0)
+            side(raw.x < chatWidth() ? "chat" : "panel");
+        return handle.call(this, raw);
+    };
+    return () => {
+        screen.handleMouseEvent = handle;
+    };
+}
+/**
+ * A line drawn faint - the side that does not have the keys, in the shade. Faint (SGR 2) holds through a line's colours;
+ * only a reset - SGR 0, or 22 - ends it, so it is set again after each one. A line holding an image is left as it is.
+ */
+export function shade(line) {
+    // Kitty's image escape, or iTerm2's.
+    if (line.includes("\x1b_G") || line.includes("\x1b]1337;File="))
+        return line;
+    const again = line.replace(/\x1b\[([\d;]*)m/g, (sgr, params) => (params.split(";").some((param) => param === "" || param === "0" || param === "22") ? `${sgr}${FAINT}` : sgr));
+    return `${FAINT}${again}${NOT_FAINT}`;
+}
+const FAINT = "\x1b[2m";
+const NOT_FAINT = "\x1b[22m";
+/**
+ * The chat in the shade while `shaded()`: each of its rows drawn faint as the screen lays the overlays over it - the
+ * docked panel the last of them, which covers its own columns. Returns what takes the shade off.
+ */
+export function shadeChat(tui, shaded) {
+    const screen = tui;
+    const composite = screen.compositeLineAt;
+    if (typeof composite !== "function")
+        return () => { };
+    screen.compositeLineAt = function (base, overlay, col, width, total) {
+        return composite.call(this, shaded() ? shade(base) : base, overlay, col, width, total);
+    };
+    return () => {
+        screen.compositeLineAt = composite;
+    };
+}

package/dist/regenerate/prompt.js

@@ -24,7 +24,7 @@ function alreadyImplemented(moduleName, own, required) {
  * one another, the current module marked - and each tagged with its module and its id there. A codebase holds the
  * functionalities of every module it is built on, and each module numbers its own from 1, so
  * "functionality 1" alone is ambiguous: the first listed may be base's 1 and the next top's 3.
- * (plain2code's _get_implemented_functional_requirements_prompt_section, as tags.)
+ * (the reference implementation's implemented functional requirements prompt section, as tags.)
  */
 export function functionalitiesByModule(entries, currentModule, status) {
     // In the order given: the bottom of the chain first. A regeneration in a later module's

package/dist/regenerate/release.js

@@ -1,5 +1,5 @@
 import { spawn, spawnSync } from "node:child_process";
-import { closeSync, existsSync, mkdirSync, openSync, readFileSync, rmSync } from "node:fs";
+import { closeSync, existsSync, mkdirSync, openSync, readdirSync, readFileSync, rmSync } from "node:fs";
 import { connect } from "node:net";
 import { dirname, join, relative } from "node:path";
 import { HISTORY_DIR } from "./lineage.js";
@@ -38,15 +38,17 @@ export function deployTarget(plainFile, inModule) {
     throw new Error(`Nothing is built yet for ${tip.moduleName}${candidates.length > 1 ? " or the modules it requires" : ""}: there is no code to deploy. Render it first.`);
 }
 /**
- * Export the module's code at its last commit into `dist/<module>`, replacing whatever was there - the
- * harness's own files (what the code is built from, the agents' notes) left out.
+ * Export the module's code at its last commit into `dist/<module>` - or `into`, `turri regenerate --build-dir` -
+ * replacing whatever was there, the harness's own files (what the code is built from, the agents' notes) left out.
  */
-export function exportModule(plainFile, inModule) {
+export function exportModule(plainFile, inModule, into) {
     const { entry, commit, instead } = deployTarget(plainFile, inModule);
     const moduleDir = dirname(entry.buildDir);
-    const dir = distDirFor(projectDirOf(entry.plainFile), entry.moduleName);
-    rmSync(dir, { recursive: true, force: true });
+    const dir = into ?? distDirFor(projectDirOf(entry.plainFile), entry.moduleName);
+    // Emptied, not removed: the folder may be a mount point - a container's volume - that cannot be removed.
     mkdirSync(dir, { recursive: true });
+    for (const entry of readdirSync(dir))
+        rmSync(join(dir, entry), { recursive: true, force: true });
     const exported = spawnSync("bash", ["-o", "pipefail", "-c", 'git --git-dir "$1" archive --format=tar "$2" | tar -x -f - -C "$3"', "export", join(moduleDir, HISTORY_DIR), `${commit}:code`, dir], { encoding: "utf8" });
     if (exported.status !== 0)
         throw new Error(`Could not export ${entry.moduleName}'s code at ${commit.slice(0, 8)}: ${(exported.stderr ?? "").trim()}`);

package/dist/regenerate/side-panel.js

@@ -12,6 +12,12 @@ export function createSidePanel(options) {
     let drawnTree = { rows: [], rowStarts: [], lineCount: 0 };
     let drawnMap = { rows: [], rowStarts: [], lineCount: 0 };
     let pages = [];
+    /** The keys back to the chat - and `s`, from over the screen to beside the chat and back. */
+    const backKeys = () => {
+        if (options.dock === undefined)
+            return [`esc or ${options.key} back to the chat`];
+        return options.dock.docked() ? ["s full screen", "esc or ⌥⌘← to the chat", `${options.key} close`] : ["s beside the chat", `esc or ${options.key} back to the chat`];
+    };
     const waitingNote = () => 
     // A question asked while it showed waits in the chat, unanswered: the person is told it is there.
     options.waiting?.() === true ? `   ${style.warning?.("your question is waiting") ?? style.accent("your question is waiting")} - ${options.key} or esc to answer it, as you left it` : "";
@@ -59,7 +65,7 @@ export function createSidePanel(options) {
     /** The rule under the top. */
     const rule = (width) => style.muted("─".repeat(Math.max(1, width)));
     const renderPulses = (width, rows) => {
-        const keys = ["↑↓ move", "enter open/close", "←→", "o/c all", "pgup pgdn scroll", ...(options.map !== undefined ? ["p regen"] : []), `esc or ${options.key} back to the chat`];
+        const keys = ["↑↓ move", "enter open/close", "←→", "o/c all", "pgup pgdn scroll", ...(options.map !== undefined ? ["p regen"] : []), ...backKeys()];
         const top = topBlock([`${style.heading("pulses")}${waitingNote()}`], keys, width);
         // Under the top: the rule, and a line of space - as the map has.
         const bodyHeight = Math.max(3, rows - top.length - 2);
@@ -77,7 +83,7 @@ export function createSidePanel(options) {
         pages = options.map();
         const now = Date.now();
         if (pages.length === 0) {
-            const top = topBlock([`${style.heading("regen")}${waitingNote()}`], ["p pulses", `esc or ${options.key} back to the chat`], width);
+            const top = topBlock([`${style.heading("regen")}${waitingNote()}`], ["p pulses", ...backKeys()], width);
             lastBodyHeight = Math.max(3, rows - top.length - 1);
             drawnMap = { rows: [], rowStarts: [], lineCount: 0 };
             const body = [style.muted("  No .plain file to map: name one to regenerate, or set module: in config.turri.yaml."), ...new Array(Math.max(0, lastBodyHeight - 1)).fill("")];
@@ -87,7 +93,7 @@ export function createSidePanel(options) {
         const tabbed = pages.length > 1;
         const page = shownPage(pages, map);
         const discuss = page.stuck && options.discuss !== undefined ? [`${DISCUSS_KEY} talk it through in the chat`] : [];
-        const keys = [...discuss, "↑↓ move", "enter open/close", ...(tabbed ? ["←→ module"] : []), "o/c all", "pgup pgdn", "p pulses", `esc or ${options.key} back to the chat`];
+        const keys = [...discuss, "↑↓ move", "enter open/close", ...(tabbed ? ["←→ module"] : []), "o/c all", "pgup pgdn", "p pulses", ...backKeys()];
         // The legend's box in the upper right corner, over what is under it; too narrow a panel has none.
         const box = width >= 60 ? legendBox(legendLines(page, style)) : [];
         const room = box.length > 0 ? width - visibleWidth(box[0]) - 1 : width;
@@ -210,7 +216,7 @@ export function createSidePanel(options) {
             }
             catch (error) {
                 // A frame that throws is never drawn - nor is anything after it: the screen would freeze. What failed is shown instead.
-                const top = topBlock([`${style.heading(map.view === "map" ? "regen" : "pulses")}${waitingNote()}`], [...(options.map !== undefined ? ["p the other view"] : []), `esc or ${options.key} back to the chat`], width);
+                const top = topBlock([`${style.heading(map.view === "map" ? "regen" : "pulses")}${waitingNote()}`], [...(options.map !== undefined ? ["p the other view"] : []), ...backKeys()], width);
                 const lines = (error instanceof Error ? (error.stack ?? error.message) : String(error)).split("\n").slice(0, Math.max(1, rows - top.length - 1));
                 return [
                     ...top,
@@ -225,6 +231,10 @@ export function createSidePanel(options) {
                 options.back();
                 return;
             }
+            if (options.dock !== undefined && data === "s") {
+                options.dock.toggle();
+                return;
+            }
             if (options.map !== undefined && data === "p") {
                 if (map.view === "map")
                     toPulses();

package/dist/regenerate/test-scripts.js

@@ -609,19 +609,34 @@ function timedOutFailure(run, what) {
         `the same ${limit} seconds, and a skipped or deleted test does not count as a fix.`,
     ].join("\n");
 }
+/** A command `timeout` could not start, or a shell could not find - on a line of its own. */
+const COULD_NOT_RUN = /^(?:[^:]*: )?failed to run command [‘'`"]?([\w.+-]+)[’'`"]?: No such file or directory$/;
+const NOT_FOUND = /^(?:[^:]*: )?(?:line \d+: )?([\w.+-]+): command not found$/;
 /**
  * What a failed run says is not installed where it ran - the command, when its output names it - or undefined when
- * the run failed for another reason. Exit 69 is the testing scripts' own way to say a toolchain is missing; exit 127,
- * or a shell or `timeout` that could not find the command, says it as well.
+ * the run failed for another reason. A missing command is the cause only on evidence that it ended the run: exit 69,
+ * the testing scripts' own way to say a toolchain is missing, or 127, what a shell or `timeout` gives for a command it
+ * could not find - else a command not found on the last line the run printed, nothing having run after it. Earlier in
+ * the output it is a warning, not the failure: a shell profile's, an optional tool probed for, a fallback taken - and a
+ * run that failed for its own reasons is the agent's to fix, not a stop for the person.
  */
 export function missingToolchain(run) {
-    const named = /failed to run command [‘'`"]?([\w.+-]+)[’'`"]?: No such file or directory/.exec(run.output) ??
-        /(?:^|\n)(?:[^\n:]*: )?(?:line \d+: )?([\w.+-]+): command not found/.exec(run.output);
-    if (named !== null)
-        return { command: named[1] };
-    if (run.exitCode === 69 || run.exitCode === 127)
+    if (run.exitCode === 0)
+        return undefined;
+    const lines = run.output.split("\n").map((line) => line.trim()).filter((line) => line !== "");
+    const named = (line) => COULD_NOT_RUN.exec(line)?.[1] ?? NOT_FOUND.exec(line)?.[1];
+    if (run.exitCode === 69 || run.exitCode === 127) {
+        // The command is the last one named: the one the run stopped on.
+        for (let at = lines.length - 1; at >= 0; at -= 1) {
+            const command = named(lines[at]);
+            if (command !== undefined)
+                return { command };
+        }
         return {};
-    return undefined;
+    }
+    const last = lines.at(-1);
+    const command = last !== undefined ? named(last) : undefined;
+    return command !== undefined ? { command } : undefined;
 }
 /** Where `command` is on this machine's PATH, or undefined when it is not there. */
 export function onThisMachine(command) {

package/dist/regenerate-cli.js

@@ -1,6 +1,6 @@
 import { CONFIG_FILE, readProjectConfig } from "./config.js";
-import { c } from "./module-report.js";
-import { parseArgs, runLoop } from "./loop-cli.js";
+import { parseArgs } from "./cli-options.js";
+import { headlessOptions, runLoop } from "./loop-cli.js";
 const USAGE = `usage: turri regenerate [file.plain] [frid ...] [options]
 
 Regenerates the module's code from its spec as it is now, and everything it requires, bottom first, as
@@ -12,33 +12,27 @@ does in the chat with functionalities named: their code rewritten or started ove
 
 The project's config.turri.yaml, in the current directory, gives the defaults: module (the file to
 build when none is given), coding-model (the agents that build), harness-model (the planner), and
-conformance-tests.
+conformance-tests. It exits 0 only when every module is complete: regenerated from the spec as it is,
+its conformance tests too when they are on.
 
   --dry-run                plan the work and print the prompt of the first job, and run nothing (turri glimpse)
-  --start-over             start over, without asking, a codebase regenerated without a module it now requires
+  --start-over             start over, without asking, a codebase regenerated without a module it now requires -
+                           with no terminal to ask and without it, the run stops there
   --from-scratch           delete the module's code and conformance tests (its lineage keeps them) and regenerate all of it
-  --build-dir <dir>        default: plain_modules/<module>/code
-  --model <provider/id>    model for the agents
+  --harness-model <p/id>   config.turri.yaml's harness-model for this run: the planner, the conformance chooser, a diagnosis
+  --coding-model <p/id>    its coding-model, --model too: the agents that build; p/id:level for how hard a model thinks
+  --judge-model <p/id>     its judge-model: the judge and the test review
+  --review <true|false>    its review: whether the code and its tests are reviewed once they pass
+  --conformance-tests <all|chosen|module|false>
+                           its conformance-tests: which conformance tests are written and run
+  --build-dir <dir>        as the run ends, however it ends, export the code there: the furthest-built codebase's
+                           last commit, which holds every module it requires - the folder's contents are replaced
+  --report <file.json>     write a report of the run there - outcome, usage, pulses, functional specs completed -
+                           as it starts, as each pulse ends and as it exits (docs/headless.md)
 
   PLAIN_TEMPLATE_DIRS      colon-separated template directories`;
-/** Options of the build this replaced, and what to do instead. */
-const GONE = {
-    force: "to regenerate a functionality again, name it: turri regenerate <file.plain> <frid>",
-    only: "every module the spec requires is built, bottom first",
-    to: "the whole spec is built: stop the jobs to stop partway",
-    from: "every functionality not built is queued; built ones are skipped",
-    "conformance-root": "conformance tests are in plain_modules/<module>/tests",
-    "max-regression-rounds": "each conformance job runs the whole suite",
-    "try-it": "run turri release to try what is regenerated",
-    conformance: `set conformance-tests: in ${CONFIG_FILE}, or turri conform`,
-    "no-conformance": `set conformance-tests: false in ${CONFIG_FILE}`,
-    "template-dir": "set PLAIN_TEMPLATE_DIRS",
-};
-const { positional, options } = parseArgs(process.argv.slice(2), ["--only", "--force", "--conformance", "--no-conformance", "--try-it", "--dry-run", "--start-over", "--from-scratch"], USAGE);
-for (const [name, instead] of Object.entries(GONE)) {
-    if (options[name] !== undefined)
-        console.log(c.dim(`--${name} is no longer an option: ${instead}.`));
-}
+const { positional, options } = parseArgs(process.argv.slice(2), ["--dry-run", "--start-over", "--from-scratch"], USAGE, ["--build-dir", "--report", "--conformance-tests", "--harness-model", "--judge-model", "--review"]);
+const { report, buildDir } = headlessOptions(options, true);
 const named = positional[0] ?? readProjectConfig(process.cwd()).module;
 // Functional specs named after the file: regenerated again though their spec did not change.
 const again = positional.slice(1);
@@ -53,15 +47,16 @@ if (options["from-scratch"] !== undefined && options["dry-run"] !== undefined) {
 }
 runLoop({
     plainFile: named,
-    ...(options.model !== undefined ? { model: options.model } : {}),
-    ...(options["build-dir"] !== undefined ? { buildDir: options["build-dir"] } : {}),
+    ...(buildDir !== undefined ? { buildDir } : {}),
+    ...(report !== undefined ? { report } : {}),
+    command: ["regenerate", ...process.argv.slice(2)],
     dryRun: options["dry-run"] !== undefined,
     startOver: options["start-over"] !== undefined,
     ask: (loop) => again.length > 0
-        ? loop.regenerateAgain(named, again, options.model !== undefined ? { model: options.model } : {})
+        ? loop.regenerateAgain(named, again)
         : options["from-scratch"] !== undefined
-            ? loop.fromScratch(named, options.model !== undefined ? { model: options.model } : {})
-            : loop.bringUp(named, options.model !== undefined ? { model: options.model } : {}),
+            ? loop.fromScratch(named)
+            : loop.bringUp(named),
 }).catch((error) => {
     console.error(error instanceof Error ? error.message : error);
     process.exit(1);

package/dist/run-report.js

@@ -0,0 +1,289 @@
+import { mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import { turriIdentity } from "./environment.js";
+import { onModelEvent } from "./regenerate/activity.js";
+/**
+ * A headless run's report: one JSON file, `turri regenerate --report <file>`, saying what the run did - how it ended,
+ * what it spent, which pulses landed, how many functional specs are completed - for a benchmark or CI to read rather
+ * than the log. See docs/headless.md for every field.
+ *
+ * Written when the run starts, again as each pulse ends, and last as the process exits - however it exits: done, a
+ * pulse failed, a crash, a signal. A process killed outright (SIGKILL) leaves the one written as the last pulse ended.
+ * Each write is atomic: the file is written beside it and renamed over it, so a reader never sees half of one.
+ */
+export const REPORT_SCHEMA_VERSION = 1;
+const SIGNALS = { 129: "SIGHUP", 130: "SIGINT", 143: "SIGTERM" };
+const emptyTotals = () => ({
+    input_tokens: 0,
+    output_tokens: 0,
+    cache_read_tokens: 0,
+    cache_write_tokens: 0,
+    cost_usd: 0,
+    llm_calls: 0,
+    agent_turns: 0,
+    compactions: 0,
+    model_seconds: 0,
+});
+function addUsage(totals, usage) {
+    if (usage === undefined)
+        return;
+    totals.input_tokens += usage.input;
+    totals.output_tokens += usage.output;
+    totals.cache_read_tokens += usage.cacheRead;
+    totals.cache_write_tokens += usage.cacheWrite;
+    totals.cost_usd += usage.cost;
+}
+/** An event's counts - a call, a turn, a compaction, the model's time - and, with `tokens`, its usage too. */
+function addEvent(totals, event, tokens) {
+    if (event.kind === "call") {
+        totals.llm_calls += 1;
+        totals.model_seconds += (event.ms ?? 0) / 1000;
+        if (tokens)
+            addUsage(totals, event.usage);
+    }
+    else if (event.kind === "turn")
+        totals.agent_turns += 1;
+    else
+        totals.compactions += 1;
+}
+function sumTotals(a, b) {
+    const sum = emptyTotals();
+    for (const key of Object.keys(sum))
+        sum[key] = a[key] + b[key];
+    return sum;
+}
+/** Tidied for reading: the cost to a millionth of a dollar, the time to a tenth of a second - float sums otherwise show their noise. */
+function rounded(totals) {
+    return { ...totals, cost_usd: Math.round(totals.cost_usd * 1e6) / 1e6, model_seconds: Math.round(totals.model_seconds * 10) / 10 };
+}
+const pulseKind = (job) => (job.kind === "regenerate" ? "code" : job.kind);
+const firstLines = (text) => {
+    const trimmed = text?.trim();
+    return trimmed === undefined || trimmed === "" ? null : trimmed.length > 1000 ? `${trimmed.slice(0, 1000)}…` : trimmed;
+};
+/** Write a file whole or not at all: beside it first, then renamed over it. */
+export function writeAtomically(file, text) {
+    mkdirSync(dirname(file), { recursive: true });
+    const temporary = join(dirname(file), `.${basename(file)}.${process.pid}.tmp`);
+    try {
+        writeFileSync(temporary, text);
+        renameSync(temporary, file);
+    }
+    catch (error) {
+        rmSync(temporary, { force: true });
+        throw error;
+    }
+}
+export function startRunReport(options) {
+    const file = resolve(options.file);
+    const startedAt = Date.now();
+    const identity = turriIdentity();
+    const events = [];
+    const stopListening = onModelEvent((event) => events.push(event));
+    let sources = { jobs: () => [] };
+    let ended;
+    let crash;
+    let exitParts;
+    let finishedAt;
+    const fromProject = (path) => relative(options.projectDir, path) || ".";
+    const attempt = (read) => {
+        if (read === undefined)
+            return undefined;
+        try {
+            return read();
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const usageOf = (jobs) => {
+        const ids = new Set(jobs.map((job) => job.id));
+        const kindOf = new Map(jobs.map((job) => [job.id, pulseKind(job)]));
+        // In pulses: their tokens as each job adds them up - what its pulse line prints - and their calls from the events.
+        const inPulses = emptyTotals();
+        for (const job of jobs)
+            addUsage(inPulses, job.usage);
+        const outside = emptyTotals();
+        const byModel = {};
+        const byRole = {};
+        const byKind = {};
+        for (const job of jobs)
+            addUsage((byKind[pulseKind(job)] ??= emptyTotals()), job.usage);
+        for (const event of events) {
+            const inPulse = event.job !== undefined && ids.has(event.job);
+            addEvent(inPulse ? inPulses : outside, event, !inPulse);
+            addEvent((byModel[event.model ?? "unknown"] ??= emptyTotals()), event, true);
+            addEvent((byRole[event.role ?? "unknown"] ??= emptyTotals()), event, true);
+            if (inPulse)
+                addEvent((byKind[kindOf.get(event.job)] ??= emptyTotals()), event, false);
+        }
+        const each = (table) => Object.fromEntries(Object.entries(table).map(([key, totals]) => [key, rounded(totals)]));
+        return {
+            total: rounded(sumTotals(inPulses, outside)),
+            in_pulses: rounded(inPulses),
+            outside_pulses: rounded(outside),
+            by_model: each(byModel),
+            by_role: each(byRole),
+            by_pulse_kind: each(byKind),
+        };
+    };
+    const pulsesOf = (jobs, now) => {
+        const callsOf = new Map();
+        for (const event of events)
+            if (event.job !== undefined)
+                addEvent(callsOf.get(event.job) ?? callsOf.set(event.job, emptyTotals()).get(event.job), event, false);
+        const list = jobs.map((job) => {
+            const landed = job.status === "succeeded" && job.details?.landed === true;
+            const ran = job.status !== "queued";
+            const usage = sumTotals(callsOf.get(job.id) ?? emptyTotals(), (() => {
+                const tokens = emptyTotals();
+                addUsage(tokens, job.usage);
+                return tokens;
+            })());
+            return {
+                id: job.id,
+                module: job.module ?? null,
+                number: job.pulse ?? null,
+                kind: pulseKind(job),
+                title: job.title ?? job.summary,
+                status: job.status,
+                landed,
+                failed_for_good: job.failedForGood === true,
+                started_at: ran ? new Date(job.startedAt).toISOString() : null,
+                duration_seconds: ran ? Math.round(((job.finishedAt ?? now) - job.startedAt) / 100) / 10 : null,
+                usage: rounded(usage),
+                agents: job.agents.map((agent) => ({
+                    label: agent.label,
+                    model: agent.model ?? null,
+                    turns: agent.turns,
+                    compactions: agent.compactions,
+                    input_tokens: agent.usage.input,
+                    output_tokens: agent.usage.output,
+                    cache_read_tokens: agent.usage.cacheRead,
+                    cache_write_tokens: agent.usage.cacheWrite,
+                    cost_usd: Math.round(agent.usage.cost * 1e6) / 1e6,
+                })),
+                log_file: job.logFile !== undefined ? fromProject(job.logFile) : null,
+                error: job.status === "failed" || job.status === "stopped" ? firstLines(job.error) : null,
+            };
+        });
+        const ran = list.filter((pulse) => pulse.status !== "queued");
+        return {
+            counts: {
+                total: ran.length,
+                landed: ran.filter((pulse) => pulse.landed).length,
+                failed: ran.filter((pulse) => pulse.status === "failed").length,
+                stopped: ran.filter((pulse) => pulse.status === "stopped").length,
+                rolled_back: ran.filter((pulse) => !pulse.landed && pulse.status !== "running").length,
+                running: ran.filter((pulse) => pulse.status === "running").length,
+                not_started: list.length - ran.length,
+            },
+            list,
+        };
+    };
+    const functionalitiesOf = (counts) => {
+        if (counts === undefined)
+            return null;
+        const modules = counts.flatMap((chain) => chain.modules.map((module) => ({
+            module: module.module,
+            specified: module.specified,
+            completed: module.completed,
+            conformance_tested: module.conformanceTested,
+            incomplete_frids: module.incomplete,
+        })));
+        return {
+            total: {
+                specified: modules.reduce((sum, module) => sum + module.specified, 0),
+                completed: modules.reduce((sum, module) => sum + module.completed, 0),
+                conformance_tested: modules.reduce((sum, module) => sum + module.conformance_tested, 0),
+            },
+            modules,
+            codebases: counts.map((chain) => fromProject(chain.codebase)),
+        };
+    };
+    const statusAt = (exitCode) => {
+        const signal = exitCode !== undefined ? (SIGNALS[exitCode] ?? null) : null;
+        if (crash !== undefined)
+            return { status: "crashed", signal: null, error: crash };
+        if (ended !== undefined)
+            return { status: ended.status, signal: null, error: ended.error ?? null };
+        if (exitCode === undefined)
+            return { status: "running", signal: null, error: null };
+        if (signal !== null)
+            return { status: "interrupted", signal, error: null };
+        return { status: exitCode === 0 ? "completed" : "crashed", signal: null, error: exitCode === 0 ? null : `exited with ${exitCode} before the run ended` };
+    };
+    const build = (exitCode) => {
+        const now = finishedAt ?? Date.now();
+        // In the order they started; one queued again as another never ran, and is not a pulse of its own.
+        const jobs = (attempt(sources.jobs) ?? []).filter((job) => job.replacedBy === undefined).sort((a, b) => a.sequence - b.sequence);
+        const outcome = statusAt(exitCode);
+        const projectRoot = options.projectDir;
+        return {
+            schema_version: REPORT_SCHEMA_VERSION,
+            turri: identity,
+            command: options.command,
+            spec_file: resolve(options.specFile),
+            project_dir: projectRoot,
+            build_dir: options.buildDir !== undefined ? resolve(options.buildDir) : null,
+            conformance_tests: options.conformanceTests,
+            review: options.review ?? null,
+            models: {
+                ...Object.fromEntries(Object.entries(options.models).map(([role, choice]) => [role, { model: choice.model ?? null, thinking: choice.thinking ?? null }])),
+                observed: Object.fromEntries([...new Set(events.map((event) => event.role ?? "unknown"))].sort().map((role) => [role, [...new Set(events.filter((event) => (event.role ?? "unknown") === role).map((event) => event.model ?? "unknown"))].sort()])),
+            },
+            started_at: new Date(startedAt).toISOString(),
+            finished_at: finishedAt !== undefined ? new Date(finishedAt).toISOString() : null,
+            duration_seconds: Math.round((now - startedAt) / 100) / 10,
+            outcome: {
+                status: outcome.status,
+                exit_code: exitCode ?? null,
+                signal: outcome.signal,
+                error: outcome.error,
+                modules: attempt(sources.modules) ?? null,
+            },
+            usage: usageOf(jobs),
+            pulses: pulsesOf(jobs, now),
+            functionalities: functionalitiesOf(attempt(sources.completion)),
+            ...(exitParts ?? {}),
+            logs: {
+                jobs_dir: fromProject(join(projectRoot, ".turri", "jobs")),
+                debug_dir: fromProject(join(projectRoot, ".turri", "debug")),
+                sessions_dir: fromProject(join(projectRoot, ".turri", "sessions")),
+            },
+        };
+    };
+    const write = (exitCode) => {
+        try {
+            writeAtomically(file, `${JSON.stringify(build(exitCode), null, 2)}\n`);
+        }
+        catch (error) {
+            console.error(`Could not write the run report ${file}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    };
+    if (options.onExit !== false) {
+        process.on("uncaughtExceptionMonitor", (error) => {
+            crash ??= error instanceof Error ? (error.stack ?? error.message) : String(error);
+        });
+        process.once("exit", (code) => {
+            finishedAt = Date.now();
+            exitParts = attempt(sources.atExit);
+            stopListening();
+            write(code);
+        });
+    }
+    write();
+    return {
+        attach(given) {
+            sources = given;
+        },
+        end(status, error) {
+            ended = { status, ...(error !== undefined ? { error } : {}) };
+        },
+        crashed(error) {
+            crash ??= error instanceof Error ? error.message : String(error);
+        },
+        write: () => write(),
+        build,
+    };
+}