@turri-dev/cli 0.1.2 → 0.1.3-next.162a2c3

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/stop-report.js

@@ -89,6 +89,19 @@ export function describeStop(facts) {
                 `though they were sent back for it again and again. Still missing:\n${facts.conformance.unlabelled.map((line) => `    - ${line}`).join("\n")}`;
         todo = ["If the test reqs leave open where the tests go or how they are built, say so exactly - the folder, the files, the build."];
     }
+    else if (facts.at === "conformance" && facts.conformance?.escalation !== undefined) {
+        const { error, reason, evidence, changedNothing } = facts.conformance.escalation;
+        why =
+            `its conformance tests kept failing with ${error}. The conformance agent's fix of the tests did not make it go away, so ` +
+                `a judge looked again and found it the code's; the coding agent ${changedNothing === true ? "changed nothing for it" : "fixed the code, and the run still failed the same way"}. ` +
+                `Why the judge found it the code's:\n${reason.trim().split("\n").map((line) => `    ${line}`).join("\n")}` +
+                (evidence.length > 0 ? `\n  On the evidence:\n${evidence.map((item) => `    - ${item.source.trim()}: ${item.shows.trim().replace(/\s+/g, " ")}`).join("\n")}` : "");
+        todo = [
+            "If the code has to produce something the spec leaves open - a build output, an entry point, a module the conformance testing " +
+                "script runs or checks for - say exactly what in the implementation reqs: its path and how it is built.",
+            "If the conformance testing script expects something the spec does not ask for, change the script or the test reqs so the two agree.",
+        ];
+    }
     else if (facts.at === "conformance" && facts.conformance?.stuck !== undefined) {
         const { error, times, rounds, changedNothing } = facts.conformance.stuck;
         why =

package/dist/regenerate/test-scripts.js

@@ -335,7 +335,15 @@ async function runScript(cwd, script, args, logDir, options = {}) {
     const noted = withScriptLineNote(text, script);
     // Its failures, counts and end are what the agent is shown; the whole is kept, a read_output away.
     const log = keepTestOutput(logDir, basename(script), noted);
-    return { command: shown(script), exitCode: timedOut === true ? 124 : exitCode, output: shownTestOutput(noted, log), timedOut: timedOut === true, timeoutMs, ...(log !== undefined ? { log } : {}) };
+    return {
+        command: shown(script),
+        exitCode: timedOut === true ? 124 : exitCode,
+        output: shownTestOutput(noted, log),
+        timedOut: timedOut === true,
+        timeoutMs,
+        elapsedMs: Date.now() - started,
+        ...(log !== undefined ? { log } : {}),
+    };
 }
 /** What bash says when a line of the script itself cannot run: a command or file that is not there, or not runnable. */
 const OWN_LINE_FAILURE = /: (No such file or directory|command not found|Permission denied)$/;
@@ -589,6 +597,19 @@ function loopNotice(loop) {
         "the failure with fresh eyes, and you will be given what it finds.",
     ].join("\n");
 }
+/**
+ * How long a run took against its time limit, in a line: for whoever judges it or works out its cause - so a run that
+ * ended on its own is never taken for one the limit stopped, nor the other way.
+ */
+export function runTiming(run) {
+    const seconds = (ms) => `${(ms / 1000).toFixed(1)}s`;
+    const limit = seconds(run.timeoutMs);
+    if (run.timedOut === true) {
+        return `The time limit stopped this run: it had run ${seconds(run.elapsedMs ?? run.timeoutMs)} of the ${limit} a test run may take, and had not finished.`;
+    }
+    const took = run.elapsedMs !== undefined ? `after ${seconds(run.elapsedMs)} of the ${limit} a test run may take` : `well within the ${limit} a test run may take`;
+    return `This run ended on its own - exit ${run.exitCode}, ${took}. The time limit did not stop it and played no part in how it ended.`;
+}
 /** A run the time limit stopped: failed, and what most often keeps a test run from ending. */
 function timedOutFailure(run, what) {
     const limit = Math.round(run.timeoutMs / 1000);
@@ -609,19 +630,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/unit-review.js

@@ -63,6 +63,17 @@ export function unitReviewTask(options) {
         options.spec.trim(),
         "</specification>",
         "",
+        ...(options.testingScript !== undefined
+            ? [
+                "The harness runs the unit tests with this script, and it decides whether they pass. Read it for which tests it",
+                "runs and how: a test it never reaches - a file it does not pick up, a folder it does not look in - is not run, and",
+                "checks nothing.",
+                `<unit testing script path="${options.testingScript.path}">`,
+                options.testingScript.content.trimEnd(),
+                "</unit testing script>",
+                "",
+            ]
+            : []),
         ...(options.cases !== undefined ? [...codeReviewCasesBlock(options.cases), ""] : []),
         // A job that touches no functional spec is held only to that: the checks of behaviour are not its.
         ...(mechanical ? [] : ["Check that the code does what the specification states for this work:"]),

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 and the conformance chooser
+  --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/resume-line.js

@@ -0,0 +1,4 @@
+/** pi's line on the way out that says how to resume the session, with turri in place of pi as the command to run. */
+export function resumeLine(text) {
+    return text.replace(/^((?:\x1b\[[0-9;]*m)*To resume this session:(?:\x1b\[[0-9;]*m)*\s+)pi(?= )/m, "$1turri");
+}

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,
+    };
+}