@turri-dev/cli 0.1.8-next.01c7342 → 0.1.8-next.b03162b

package/dist/regenerate/job-log.d.ts

@@ -17,7 +17,9 @@ export interface JobLog {
     /** `agents`: a line per agent - its turns, compactions and cost. */
     end(status: string, report: string | undefined, agents?: string[]): void;
 }
-/** The folder a job's log goes in: the project of the first module it writes, from its lanes. */
+/** The project a job works in: the one of the first module it writes, from its lanes. */
+export declare function projectOfLanes(lanes: string[]): string | undefined;
+/** The folder a job's log goes in: `.turri/jobs` in its project. */
 export declare function jobLogDir(lanes: string[]): string | undefined;
 export declare function startJobLog(job: {
     id: string;

package/dist/regenerate/job-log.js

@@ -2,12 +2,15 @@ import { appendFileSync, existsSync } from "node:fs";
 import { maskSecrets } from "./masking.js";
 import { dirname, isAbsolute, join, sep } from "node:path";
 import { ensureInScratch, MODULES_DIR, projectRootOf, scratchDir } from "./paths.js";
-/** The folder a job's log goes in: the project of the first module it writes, from its lanes. */
-export function jobLogDir(lanes) {
+/** The project a job works in: the one of the first module it writes, from its lanes. */
+export function projectOfLanes(lanes) {
     const lane = lanes.find((candidate) => isAbsolute(candidate) && candidate.split(sep).includes(MODULES_DIR));
-    if (lane === undefined)
-        return undefined;
-    return join(scratchDir(join(projectRootOf(lane), MODULES_DIR)), "jobs");
+    return lane !== undefined ? projectRootOf(lane) : undefined;
+}
+/** The folder a job's log goes in: `.turri/jobs` in its project. */
+export function jobLogDir(lanes) {
+    const project = projectOfLanes(lanes);
+    return project !== undefined ? join(scratchDir(join(project, MODULES_DIR)), "jobs") : undefined;
 }
 export function startJobLog(job, lanes) {
     const dir = jobLogDir(lanes);

package/dist/regenerate/jobs-tree.d.ts

@@ -3,15 +3,17 @@ import type { TranscriptStyle } from "./transcript-view.ts";
 /**
  * The side panel's Jobs view: the queue as a tree, read one job at a time.
  *
- * Three sections - running, queued, finished - each opened and closed on its own, and under them one line per job:
+ * Four sections - running, queued, finished, and earlier sessions' from the ledger - each opened and closed on its own,
+ * and under them one line per job:
  * its module, its time and its cost. A job opened shows all of what it builds - the diff, or the spec - and, running,
- * what it is doing; finished, what went on in it. So what is planned can be read without every diff on the screen at once.
+ * what it is doing; finished, what went on in it; earlier, what the ledger says of it. So what is planned can be read
+ * without every diff on the screen at once.
  *
  * A cursor moves over the sections and the jobs; it stays on its row, whatever moves under it - a job that finishes
  * leaves its row to the one after it. A job opened stays open while it stays where it is: moving to another section
  * it closes, and turns up there collapsed. The state is the conversation's, kept while the panel is closed.
  */
-export type JobSection = "running" | "queued" | "finished";
+export type JobSection = "running" | "queued" | "finished" | "earlier";
 export declare const SECTIONS: JobSection[];
 export interface JobsTreeState {
     /** Which sections are open. */
@@ -24,6 +26,8 @@ export interface JobsTreeState {
     cursor: number;
     /** The first line shown. */
     top: number;
+    /** How many runs the ledger has beyond the earlier sessions shown: said under them. */
+    earlierMore?: number;
 }
 export declare function createJobsTreeState(): JobsTreeState;
 export declare function sectionOf(job: Job): JobSection;

package/dist/regenerate/jobs-tree.js

@@ -3,11 +3,15 @@ import { describeAgents } from "./activity.js";
 import { didNotPass, finishedMark, pulseCost, spinner } from "./job-panel.js";
 import { formatDuration, pulseName } from "./jobs.js";
 import { diffFiles, fileHeader, PLAIN_PAINT } from "./diff-view.js";
-export const SECTIONS = ["running", "queued", "finished"];
+export const SECTIONS = ["running", "queued", "finished", "earlier"];
+/** A section as its header says it. */
+const SECTION_NAMES = { running: "running", queued: "queued", finished: "finished", earlier: "earlier sessions" };
 export function createJobsTreeState() {
-    return { open: { running: true, queued: true, finished: false }, openJobs: new Map(), openFiles: new Map(), cursor: 0, top: 0 };
+    return { open: { running: true, queued: true, finished: false, earlier: false }, openJobs: new Map(), openFiles: new Map(), cursor: 0, top: 0 };
 }
 export function sectionOf(job) {
+    if (job.earlier !== undefined)
+        return "earlier";
     return job.status === "running" ? "running" : job.status === "queued" ? "queued" : "finished";
 }
 /** The files of a job's diff, in the order they are shown - read once for each diff, not on every frame. */
@@ -47,7 +51,7 @@ export function selectJob(jobs, state, id) {
     const job = jobs.find((entry) => entry.id === id);
     if (job === undefined)
         return false;
-    const section = job.status === "running" ? "running" : job.status === "queued" ? "queued" : "finished";
+    const section = sectionOf(job);
     state.open[section] = true;
     state.openJobs.set(id, section);
     const at = jobsTreeRows(jobs, state).findIndex((row) => row.kind === "job" && row.job.id === id);
@@ -60,13 +64,16 @@ export function jobsTreeRows(jobs, state) {
     const bySequence = jobs.filter((job) => job.replacedBy === undefined).sort((a, b) => a.sequence - b.sequence);
     const of = (section) => {
         const inSection = bySequence.filter((job) => sectionOf(job) === section);
-        return section === "finished" ? inSection.sort((a, b) => (b.finishedAt ?? b.sequence) - (a.finishedAt ?? a.sequence) || b.sequence - a.sequence) : inSection;
+        return section === "finished" || section === "earlier" ? inSection.sort((a, b) => (b.finishedAt ?? b.sequence) - (a.finishedAt ?? a.sequence) || b.sequence - a.sequence) : inSection;
     };
     // Forget what is open for jobs that moved on - they close as they leave.
     for (const job of jobs)
         isOpen(state, job);
     return SECTIONS.flatMap((section) => {
         const inSection = of(section);
+        // Earlier sessions are there only when the ledger has some.
+        if (section === "earlier" && inSection.length === 0)
+            return [];
         const jobRows = (job) => [
             { kind: "job", section, job },
             // An open job's diff, a row a file: each opens and closes on its own.
@@ -82,7 +89,8 @@ export function jobsTreeRows(jobs, state) {
 const MARK = { running: spinner, queued: () => "·", succeeded: () => "✓", failed: () => "✗", stopped: () => "■" };
 /** A pulse's mark: running or queued as it is; finished, in the colour of how it ended - green it passed, red it failed or did not pass, stopped amber. */
 function markOf(job, style) {
-    if (sectionOf(job) !== "finished")
+    const section = sectionOf(job);
+    if (section !== "finished" && section !== "earlier")
         return MARK[job.status]?.(Date.now()) ?? "·";
     return finishedMark(job, { success: style.success ?? style.added, error: style.error, warning: style.warning ?? style.accent });
 }
@@ -106,6 +114,9 @@ function named(jobs, id) {
 /** All of a job, opened: what it builds, and - running - what it is doing; waiting, what it waits on; done, how it ended. */
 function detailLines(job, jobs, width, style) {
     const indent = "        ";
+    // An earlier session's: what the ledger says of it - its transcript is its log's alone.
+    if (job.earlier !== undefined)
+        return job.earlier.lines.flatMap((line) => wrap(line, width, indent, /FAILED|ended with/.test(line) ? style.error : style.muted));
     const lines = [];
     // A diff is shown a file at a time, in rows of their own after these.
     if ((job.diff === undefined || job.diff.trim() === "") && job.building !== undefined) {
@@ -170,7 +181,7 @@ export function jobsTreeLines(jobs, state, width, style) {
                 lines.push("");
                 rowStarts[index] = lines.length;
             }
-            const header = `${pointer} ${state.open[row.section] ? "▾" : "▸"} ${row.section} (${row.count})`;
+            const header = `${pointer} ${state.open[row.section] ? "▾" : "▸"} ${SECTION_NAMES[row.section]} (${row.count})`;
             lines.push(here ? style.heading(header) : style.muted(header));
             return;
         }
@@ -197,6 +208,10 @@ export function jobsTreeLines(jobs, state, width, style) {
         if (open)
             lines.push(...detailLines(job, jobs, width, style));
     });
+    // The ledger has more than the runs shown: where to find them.
+    if (state.open.earlier && (state.earlierMore ?? 0) > 0) {
+        lines.push(style.muted(`      ${state.earlierMore} earlier run${state.earlierMore === 1 ? "" : "s"} in the ledger - turri ledger lists them`));
+    }
     return { lines, rowStarts, rows };
 }
 /** How far a job's files, and their lines, are indented under it. */

package/dist/regenerate/jobs.d.ts

@@ -84,6 +84,15 @@ export interface Job {
     announce?: string;
     error?: string;
     details?: unknown;
+    /**
+     * A pulse of an earlier session, as the ledger recorded it - not this session's registry's: shown, never run, halted or
+     * waited for. Its run, how and when that run was started, and what the ledger says of it, a line each.
+     */
+    earlier?: {
+        run: string;
+        runMode?: string;
+        lines: string[];
+    };
 }
 export interface JobOutcome {
     report: string;

package/dist/regenerate/jobs.js

@@ -3,7 +3,8 @@ import { availableParallelism } from "node:os";
 import { withPulse } from "./shell.js";
 import { describeEnvironmentError, EnvironmentError, missingCredentials } from "./environment-error.js";
 import { addAgentReport, describeAgents, JobStoppedError, withActivity } from "./activity.js";
-import { startJobLog } from "./job-log.js";
+import { projectOfLanes, startJobLog } from "./job-log.js";
+import { firstLine, healing, record } from "./ledger.js";
 import { chosenStack, withStack } from "../config.js";
 const DEFAULT_TAIL_CHARS = 4000;
 const ACTIVITY_LINES = 10;
@@ -88,6 +89,20 @@ export function createJobRegistry(options) {
             };
             jobs.set(job.id, job);
             let transcriptChars = 0;
+            // Where what it does is recorded: its project, from the modules it writes.
+            const project = projectOfLanes(claimed);
+            const place = { job: id, ...(project !== undefined ? { project } : {}), ...(input.module !== undefined ? { module: input.module } : {}) };
+            record({
+                kind: "job.queued",
+                jobKind: input.kind,
+                summary: firstLine(input.summary, 300),
+                ...(input.pulse !== undefined ? { pulse: input.pulse } : {}),
+                ...(input.title !== undefined ? { title: input.title } : {}),
+                ...(input.model !== undefined ? { model: input.model } : {}),
+                ...(stack !== undefined ? { stack } : {}),
+                waitingOn: blockers,
+                ...(input.follows !== undefined ? { follows: input.follows } : {}),
+            }, place);
             const changed = () => {
                 // Like onFinish: a display that throws must not take the job down.
                 try {
@@ -105,6 +120,8 @@ export function createJobRegistry(options) {
             const sink = {
                 signal: controller.signal,
                 job: { id, kind: input.kind, summary: input.summary },
+                ...(project !== undefined ? { project } : {}),
+                ...(input.module !== undefined ? { module: input.module } : {}),
                 specConflict(conflict) {
                     job.specConflict = conflict;
                     this.transcript({ kind: "stage", text: `the spec contradicts itself: functionalities ${conflict.specs.map((spec) => `${spec.module} ${spec.frid}`).join(" and ")} cannot both hold` });
@@ -112,6 +129,7 @@ export function createJobRegistry(options) {
                 },
                 stage(label) {
                     job.stage = label;
+                    record({ kind: "job.stage", label: firstLine(label, 300) }, place);
                     this.transcript({ kind: "stage", text: label });
                     changed();
                 },
@@ -213,22 +231,24 @@ export function createJobRegistry(options) {
                     // and the person is told. What the harness found itself is worked out at once; what an agent said goes as it is.
                     if (error instanceof EnvironmentError) {
                         job.failedForGood = true;
+                        record({ kind: "environment.error", missing: firstLine(error.missing, 300), source: error.source, sandbox: error.sandbox !== undefined }, place);
                         if (error.source === "harness" && options?.diagnose !== undefined) {
                             sink.stage("the environment lacks something - working out what to do about it");
-                            job.diagnosis = await withActivity(sink, () => options.diagnose(job, [error.message, describeEnvironmentError(error, input.rerun)], log?.file)).catch(() => undefined);
+                            job.diagnosis = await withActivity(sink, () => healing("diagnosis", () => options.diagnose(job, [error.message, describeEnvironmentError(error, input.rerun)], log?.file), (found) => found));
                         }
                         job.environment = describeEnvironmentError(error, input.rerun);
                         throw new Error([job.environment, ...(job.diagnosis !== undefined ? ["", job.diagnosis] : [])].join("\n"));
                     }
                     failures.push(error !== undefined ? (error instanceof Error ? error.message : String(error)) : outcome.report);
                     if (attempt < retries) {
+                        record({ kind: "job.retried", attempt: attempt + 1, of: retries, failure: firstLine(failures.at(-1), 300) }, place);
                         sink.stage(`the pulse failed - trying it once more (${attempt + 1} of ${retries})`);
                         continue;
                     }
                     job.failedForGood = true;
                     if (options?.diagnose !== undefined) {
                         sink.stage("the pulse failed again - working out why, and what has to be done");
-                        job.diagnosis = await withActivity(sink, () => options.diagnose(job, failures, log?.file)).catch(() => undefined);
+                        job.diagnosis = await withActivity(sink, () => healing("diagnosis", () => options.diagnose(job, failures, log?.file), (found) => found));
                     }
                     throw new Error([
                         `Failed ${failures.length} time${failures.length === 1 ? "" : "s"}, so it and every pulse queued behind it have stopped.`,
@@ -277,6 +297,7 @@ export function createJobRegistry(options) {
                 log = startJobLog(job, claimed);
                 if (log !== undefined)
                     job.logFile = log.file;
+                record({ kind: "job.started", waitedMs: job.startedAt - job.queuedAt, ...(log !== undefined ? { logFile: log.file } : {}) }, place);
                 // What the job's agents start runs until it ends, and no longer (withPulse) - with the stack it was queued
                 // with, whatever is chosen while it waits or runs.
                 return withStack(stack, () => (guarded ? runGuarded() : runOnce()));
@@ -302,6 +323,20 @@ export function createJobRegistry(options) {
                     giveSlot();
                 }
                 finished.finishedAt = Date.now();
+                const outcome = finished.details;
+                const stopReason = stopReasons.get(id);
+                record({
+                    kind: "job.finished",
+                    status: finished.status,
+                    ...(typeof outcome?.landed === "boolean" ? { landed: outcome.landed } : {}),
+                    ...(typeof outcome?.passed === "boolean" ? { passed: outcome.passed } : {}),
+                    ms: finished.finishedAt - finished.startedAt,
+                    usage: finished.usage,
+                    ...(finished.failedForGood === true ? { failedForGood: true } : {}),
+                    ...(finished.status === "stopped" ? { stoppedBy: stopReason !== undefined ? "turri" : "person" } : {}),
+                    ...(finished.error !== undefined ? { error: firstLine(finished.error, 300) } : {}),
+                    ...(finished.logFile !== undefined ? { logFile: finished.logFile } : {}),
+                }, place);
                 log?.end(finished.status === "succeeded" ? "finished" : finished.status === "stopped" ? "stopped" : "finished - failed", finished.announce ?? finished.report ?? finished.error, describeAgents(finished.agents));
                 // A failing listener must not take the job down with it; the result is
                 // already recorded and can still be collected by asking.

package/dist/regenerate/ledger-view.d.ts

@@ -0,0 +1,73 @@
+import { type UsageReport } from "./activity.ts";
+import { type Job } from "./jobs.ts";
+import { type LedgerEntry } from "./ledger.ts";
+/**
+ * What the ledger says of pulses, read back: one pulse - from this session or an earlier one - as the chat and
+ * `turri ledger` are told it, and the runs a project has had, each with its pulses.
+ */
+type Of<K extends LedgerEntry["kind"]> = Extract<LedgerEntry, {
+    kind: K;
+}>;
+/** The projects whose ledgers a folder's pulses may be in: its own, and those of the projects in folders under it. */
+export declare function ledgerProjects(cwd: string, depth?: number): string[];
+/** One pulse, as its events tell it. */
+export interface PulseView {
+    id: string;
+    run: string;
+    /** How its run was started - chat, host, regenerate - and when. */
+    runMode?: string;
+    queued?: Of<"job.queued"> & {
+        module?: string;
+    };
+    started?: Of<"job.started">;
+    finished?: Of<"job.finished">;
+    stages: string[];
+    retried: Array<Of<"job.retried">>;
+    rounds: Map<string, {
+        round: number;
+        of: number;
+    }>;
+    scripts: Array<Of<"script.run">>;
+    judge: Map<string, number>;
+    reviews: Array<Of<"review.verdict">>;
+    healers: Array<Of<"healer.ended"> | Of<"healer.failed">>;
+    provider: {
+        retries: number;
+        stalls: number;
+        errors: string[];
+    };
+    refused: Map<string, number>;
+    stopped: string[];
+    history: Array<Of<"history.committed"> | Of<"history.failed"> | Of<"history.reset"> | Of<"history.rolledBack">>;
+    environment?: Of<"environment.error">;
+    usage?: UsageReport;
+}
+/** A pulse's events, gathered: undefined when the ledger has none of it. `entries` are its run's, oldest first. */
+export declare function pulseView(id: string, entries: LedgerEntry[]): PulseView | undefined;
+/** A pulse from the ledger, for the chat and `turri ledger <pulse>`: what happened in it, as facts. */
+export declare function describePulseView(view: PulseView): string;
+/** A pulse the ledger of any of these projects knows, described - or undefined. */
+export declare function describePastPulse(projects: string[], id: string): string | undefined;
+/** A run of the project's, and its pulses: the most recent first. */
+export interface RunView {
+    run: string;
+    started?: Of<"run.started">;
+    ended?: Of<"run.ended">;
+    pulses: PulseView[];
+}
+export declare function runViews(project: string): RunView[];
+/** The project's last runs, a line a pulse: what `turri ledger` prints. */
+export declare function describeRuns(runs: RunView[]): string;
+/**
+ * The pulses of earlier sessions, for a list beside this session's: the last `runs` runs of these projects that are not
+ * this one, the most recent first, each pulse as a job of its own marked `earlier` - none `known` to this session's
+ * registry. `more`: how many runs the ledger has beyond them.
+ */
+export declare function earlierPulses(projects: string[], known: Set<string>, runs?: number): {
+    jobs: Job[];
+    runs: RunView[];
+    more: number;
+};
+/** A pulse of the ledger's, as the lists show a job: finished as it ended, its time and cost - and nothing to run. */
+export declare function asJob(view: PulseView): Job;
+export {};

package/dist/regenerate/ledger-view.js

@@ -0,0 +1,286 @@
+import { existsSync, readdirSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { describeUsage } from "./activity.js";
+import { formatElapsed } from "./jobs.js";
+import { LEDGER_DIR, ledgerRun, readLedger } from "./ledger.js";
+/** The projects whose ledgers a folder's pulses may be in: its own, and those of the projects in folders under it. */
+export function ledgerProjects(cwd, depth = 3) {
+    const found = [];
+    const visit = (dir, left) => {
+        if (existsSync(join(dir, ".turri", LEDGER_DIR)))
+            found.push(dir);
+        if (left === 0)
+            return;
+        let names;
+        try {
+            names = readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+        }
+        catch {
+            return;
+        }
+        for (const name of names) {
+            if (name.startsWith(".") || name === "node_modules" || name === "plain_modules" || name === "dist")
+                continue;
+            visit(join(dir, name), left - 1);
+        }
+    };
+    visit(resolve(cwd), depth);
+    return found;
+}
+/** A pulse's events, gathered: undefined when the ledger has none of it. `entries` are its run's, oldest first. */
+export function pulseView(id, entries) {
+    const own = entries.filter((entry) => entry.job !== undefined && entry.job.startsWith(id));
+    if (own.length === 0)
+        return undefined;
+    const fullId = own[0].job;
+    const view = {
+        id: fullId,
+        run: own[0].run,
+        stages: [],
+        retried: [],
+        rounds: new Map(),
+        scripts: [],
+        judge: new Map(),
+        reviews: [],
+        healers: [],
+        provider: { retries: 0, stalls: 0, errors: [] },
+        refused: new Map(),
+        stopped: [],
+        history: [],
+    };
+    const started = entries.find((entry) => entry.kind === "run.started" && entry.run === view.run);
+    if (started !== undefined)
+        view.runMode = `${started.mode}, ${started.ts.slice(0, 16).replace("T", " ")}`;
+    for (const entry of own) {
+        if (entry.job !== fullId)
+            continue;
+        switch (entry.kind) {
+            case "job.queued":
+                view.queued = { ...entry, ...(entry.module !== undefined ? { module: entry.module } : {}) };
+                break;
+            case "job.started":
+                view.started = entry;
+                break;
+            case "job.finished":
+                view.finished = entry;
+                view.usage = entry.usage;
+                break;
+            case "job.stage":
+                view.stages.push(entry.label);
+                break;
+            case "job.retried":
+                view.retried.push(entry);
+                break;
+            case "gate.round":
+                view.rounds.set(entry.gate, { round: Math.max(entry.round, view.rounds.get(entry.gate)?.round ?? 0), of: entry.of });
+                break;
+            case "script.run":
+                view.scripts.push(entry);
+                break;
+            case "judge.verdict":
+                view.judge.set(entry.culprit, (view.judge.get(entry.culprit) ?? 0) + 1);
+                break;
+            case "review.verdict":
+                view.reviews.push(entry);
+                break;
+            case "healer.ended":
+            case "healer.failed":
+                view.healers.push(entry);
+                break;
+            case "provider.retry":
+                view.provider.retries += 1;
+                break;
+            case "provider.stall":
+                view.provider.stalls += 1;
+                break;
+            case "provider.error":
+                view.provider.errors.push(entry.error);
+                break;
+            case "guard.refused":
+                view.refused.set(entry.rule, (view.refused.get(entry.rule) ?? 0) + 1);
+                break;
+            case "command.refused":
+                view.refused.set("command check", (view.refused.get("command check") ?? 0) + 1);
+                break;
+            case "turn.stopped":
+                view.stopped.push(entry.reason);
+                break;
+            case "history.committed":
+            case "history.failed":
+            case "history.reset":
+            case "history.rolledBack":
+                view.history.push(entry);
+                break;
+            case "environment.error":
+                view.environment = entry;
+                break;
+        }
+    }
+    return view;
+}
+/** What a pulse is called: its module, kind and number - as pulseName says it for a live one. */
+function nameOf(view) {
+    const queued = view.queued;
+    if (queued === undefined)
+        return view.id;
+    if (queued.module === undefined)
+        return queued.summary;
+    return queued.pulse !== undefined ? `${queued.module} · ${queued.jobKind} pulse ${queued.pulse}` : `${queued.module} ${queued.jobKind}`;
+}
+function outcomeOf(view) {
+    const finished = view.finished;
+    if (finished === undefined)
+        return view.started !== undefined ? "never ended - its run stopped while it ran" : "never started";
+    const landed = finished.landed === true ? ", landed" : finished.landed === false ? ", did not land" : "";
+    const stopped = finished.stoppedBy !== undefined ? ` by ${finished.stoppedBy === "turri" ? "turri" : "the person"}` : "";
+    return `${finished.status}${stopped}${landed}, after ${formatElapsed(finished.ms)}`;
+}
+/** A pulse from the ledger, for the chat and `turri ledger <pulse>`: what happened in it, as facts. */
+export function describePulseView(view) {
+    const lines = [`${view.id} · ${nameOf(view)}${view.queued?.title !== undefined ? ` - ${view.queued.title}` : ""}`];
+    lines.push(`  run ${view.run}${view.runMode !== undefined ? ` (${view.runMode})` : ""}`);
+    lines.push(`  ${outcomeOf(view)}${view.usage !== undefined && describeUsage(view.usage) !== "" ? ` · ${describeUsage(view.usage)}` : ""}${view.queued?.model !== undefined ? ` · ${view.queued.model}` : ""}`);
+    if (view.finished?.error !== undefined)
+        lines.push(`  ended with: ${view.finished.error}`);
+    if (view.environment !== undefined)
+        lines.push(`  the environment lacks ${view.environment.missing} (found by ${view.environment.source === "harness" ? "turri" : "an agent"})`);
+    for (const retry of view.retried)
+        lines.push(`  tried again (${retry.attempt} of ${retry.of}) after: ${retry.failure}`);
+    if (view.rounds.size > 0)
+        lines.push(`  rounds: ${[...view.rounds].map(([gate, { round, of }]) => `${gate} ${round} of ${of}`).join("; ")}`);
+    if (view.scripts.length > 0) {
+        const failing = view.scripts.filter((run) => run.exit !== 0);
+        const signatures = new Map();
+        for (const run of failing)
+            if (run.signature !== undefined)
+                signatures.set(run.signature, (signatures.get(run.signature) ?? 0) + 1);
+        const most = Math.max(0, ...signatures.values());
+        const timedOut = view.scripts.filter((run) => run.timedOut).length;
+        lines.push(`  test runs: ${view.scripts.length}, ${failing.length} failing` +
+            (most > 1 ? ` - ${most} of them the same way` : "") +
+            (timedOut > 0 ? `, ${timedOut} stopped at the time limit` : ""));
+    }
+    if (view.judge.size > 0)
+        lines.push(`  the judge blamed: ${[...view.judge].map(([culprit, times]) => `${culprit} ${times}x`).join(", ")}`);
+    if (view.reviews.length > 0)
+        lines.push(`  reviews: ${view.reviews.map((review) => (review.pass ? "passed" : `${review.problems} problem${review.problems === 1 ? "" : "s"}`)).join(", ")}`);
+    // The same outcome again is counted, not said again: a debugger failing for want of a key fails every time.
+    const healed = new Map();
+    for (const healer of view.healers) {
+        const line = healer.kind === "healer.failed" ? `the ${healer.healer} FAILED: ${healer.error}` : `the ${healer.healer}${healer.found !== undefined ? `: ${healer.found}` : " found nothing"}`;
+        healed.set(line, (healed.get(line) ?? 0) + 1);
+    }
+    for (const [line, times] of healed)
+        lines.push(`  ${times > 1 ? line.replace(/^(the \S+( FAILED)?)/, `$1 ${times}x`) : line}`);
+    const provider = view.provider;
+    if (provider.retries + provider.stalls + provider.errors.length > 0) {
+        lines.push(`  the model provider: ${provider.retries} retries, ${provider.stalls} stalls${provider.errors.length > 0 ? `, ${provider.errors.length} errors - last: ${provider.errors.at(-1)}` : ""}`);
+    }
+    if (view.refused.size > 0)
+        lines.push(`  turri refused calls: ${[...view.refused].map(([rule, times]) => `${rule} ${times}x`).join(", ")}`);
+    if (view.stopped.length > 0)
+        lines.push(`  turri stopped ${view.stopped.length} turn${view.stopped.length === 1 ? "" : "s"} - last: ${view.stopped.at(-1)}`);
+    for (const event of view.history) {
+        if (event.kind === "history.committed")
+            lines.push(`  committed: ${event.subject}`);
+        else if (event.kind === "history.failed")
+            lines.push(`  a commit FAILED${event.landing ? " (landing work)" : ""}: ${event.said}`);
+        else if (event.kind === "history.reset")
+            lines.push(`  put back to the last commit: ${event.undone} change${event.undone === 1 ? "" : "s"} undone`);
+        else
+            lines.push(`  rolled back: ${event.why}`);
+    }
+    if (view.stages.length > 0)
+        lines.push("  last stages:", ...view.stages.slice(-8).map((stage) => `    ${stage}`));
+    const log = view.finished?.logFile ?? view.started?.logFile;
+    if (log !== undefined)
+        lines.push(`  log: ${log}`);
+    return lines.join("\n");
+}
+/** A pulse the ledger of any of these projects knows, described - or undefined. */
+export function describePastPulse(projects, id) {
+    for (const project of projects) {
+        const entries = readLedger(project);
+        const view = pulseView(id, entries);
+        if (view !== undefined)
+            return describePulseView(view);
+    }
+    return undefined;
+}
+export function runViews(project) {
+    const entries = readLedger(project);
+    const runs = new Map();
+    for (const entry of entries)
+        runs.set(entry.run, [...(runs.get(entry.run) ?? []), entry]);
+    return [...runs]
+        .map(([run, own]) => {
+        const ids = [...new Set(own.filter((entry) => entry.kind === "job.queued").map((entry) => entry.job))];
+        const started = own.find((entry) => entry.kind === "run.started");
+        const ended = own.find((entry) => entry.kind === "run.ended");
+        return { run, ...(started !== undefined ? { started } : {}), ...(ended !== undefined ? { ended } : {}), pulses: ids.map((id) => pulseView(id, own)).filter(Boolean) };
+    })
+        .reverse();
+}
+/** The project's last runs, a line a pulse: what `turri ledger` prints. */
+export function describeRuns(runs) {
+    if (runs.length === 0)
+        return "The ledger is empty: nothing has run here since it began.";
+    return runs
+        .map((view) => {
+        const started = view.started;
+        const when = started?.ts !== undefined ? started.ts.slice(0, 19).replace("T", " ") : "";
+        const version = started?.version !== undefined && started.version !== null ? ` · turri ${started.version}${started.commit !== null && started.commit !== undefined ? ` (${started.commit.slice(0, 7)}${started.dirty === true ? ", changed" : ""})` : ""}` : "";
+        const head = `run ${view.run} · ${started?.mode ?? "?"} · ${when}${view.ended !== undefined ? ` · ${formatElapsed(view.ended.ms)}` : " · still running, or killed"}${version}`;
+        const pulses = view.pulses.map((pulse) => `  ${pulse.id} ${nameOf(pulse).padEnd(32)} ${outcomeOf(pulse)}${pulse.usage !== undefined && describeUsage(pulse.usage) !== "" ? ` · ${describeUsage(pulse.usage)}` : ""}`);
+        return [head, ...(pulses.length > 0 ? pulses : ["  no pulses"])].join("\n");
+    })
+        .join("\n\n");
+}
+/**
+ * The pulses of earlier sessions, for a list beside this session's: the last `runs` runs of these projects that are not
+ * this one, the most recent first, each pulse as a job of its own marked `earlier` - none `known` to this session's
+ * registry. `more`: how many runs the ledger has beyond them.
+ */
+export function earlierPulses(projects, known, runs = 3) {
+    const own = ledgerRun();
+    const all = projects
+        .flatMap((project) => runViews(project))
+        .filter((view) => view.run !== own && view.pulses.some((pulse) => !known.has(pulse.id)))
+        .sort((a, b) => (b.started?.ts ?? "").localeCompare(a.started?.ts ?? ""));
+    const shown = all.slice(0, runs);
+    return { jobs: shown.flatMap((view) => view.pulses.filter((pulse) => !known.has(pulse.id)).map(asJob)), runs: shown, more: all.length - shown.length };
+}
+/** A pulse of the ledger's, as the lists show a job: finished as it ended, its time and cost - and nothing to run. */
+export function asJob(view) {
+    const at = (entry) => (entry?.ts !== undefined ? Date.parse(entry.ts) : undefined);
+    const queuedAt = at(view.queued) ?? 0;
+    const startedAt = at(view.started) ?? queuedAt;
+    const finished = view.finished;
+    // A pulse whose run ended before it did never finished: it was stopped with its run.
+    const status = finished !== undefined && ["succeeded", "failed", "stopped"].includes(finished.status) ? finished.status : "stopped";
+    const logFile = finished?.logFile ?? view.started?.logFile;
+    return {
+        id: view.id,
+        kind: view.queued?.jobKind ?? "regenerate",
+        summary: view.queued?.summary ?? view.id,
+        ...(view.queued?.module !== undefined ? { module: view.queued.module } : {}),
+        ...(view.queued?.pulse !== undefined ? { pulse: view.queued.pulse } : {}),
+        ...(view.queued?.title !== undefined ? { title: view.queued.title } : {}),
+        ...(view.queued?.model !== undefined ? { model: view.queued.model } : {}),
+        status,
+        sequence: 0,
+        queuedAt,
+        startedAt,
+        finishedAt: finished !== undefined ? startedAt + finished.ms : startedAt,
+        waitingOn: [],
+        tail: "",
+        activity: [],
+        usage: view.usage ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 },
+        agents: [],
+        transcript: [],
+        ...(logFile !== undefined ? { logFile } : {}),
+        ...(finished?.error !== undefined ? { error: finished.error } : {}),
+        details: { ...(finished?.landed !== undefined ? { landed: finished.landed } : {}), ...(finished?.passed !== undefined ? { passed: finished.passed } : {}) },
+        earlier: { run: view.run, ...(view.runMode !== undefined ? { runMode: view.runMode } : {}), lines: describePulseView(view).split("\n").slice(1).map((line) => line.replace(/^  /, "")) },
+    };
+}