@turri-dev/cli 0.1.8-next.bcca62a → 0.1.8-next.bfcb24e

package/dist/regenerate/chunk-plan.js

@@ -4,6 +4,7 @@ import { DEFAULT_CONCEPTS, extractConceptsFromDefinition, extractConceptsFromSpe
 import { ACCEPTANCE_TESTS, DEFINITIONS, FUNCTIONAL_REQUIREMENTS, NON_FUNCTIONAL_REQUIREMENTS, REQUIRED_FUNCTIONAL_SPECS, TEST_REQUIREMENTS } from "../plain/spec.js";
 import { ask, BEGIN, createExecutor } from "../pi.js";
 import { reportActivity, reportStage } from "./activity.js";
+import { firstLine, record } from "./ledger.js";
 import { steeringBlock } from "./steer.js";
 import { marksRegenerateAgain } from "./records.js";
 import { validateConcepts } from "../plain/concepts.js";
@@ -245,6 +246,11 @@ function titleOf(change) {
  * the plan did not do as asked - the person's wishes an agent did not follow and why, an answer that did not hold, a
  * group split for its size - for the conversation to say, rather than guess.
  */
+/** A planner agent that failed: the plan falls back, and the ledger says why. */
+function plannerFailed(step, error) {
+    record({ kind: "planner.failed", step, error: firstLine(error instanceof Error ? error.message : String(error), 300) });
+    return undefined;
+}
 export async function planChunks(input, agents, notes) {
     if (input.track !== "conformance")
         return cut(input, agents, notes);
@@ -370,7 +376,7 @@ async function cut(input, agents, notes) {
         ...list.map((group) => ({ title: group.title, specs: group.specs.map((number) => bySpec.get(number)), definitions: [], reqs: [] })),
     ];
     const conformance = input.track === "conformance";
-    const grouped = conformance ? undefined : ((await agents?.group(numbered, (answer) => groupProblems(numbered, answer, maxSpecs), input.steering, maxSpecs).catch(() => undefined)) ?? undefined);
+    const grouped = conformance ? undefined : ((await agents?.group(numbered, (answer) => groupProblems(numbered, answer, maxSpecs), input.steering, maxSpecs).catch((error) => plannerFailed("group", error))) ?? undefined);
     const groups = conformance
         ? conformanceGroups(numbered, input.separately === true, maxLines, (list) => {
             const trial = chunksFor(list);
@@ -386,10 +392,14 @@ async function cut(input, agents, notes) {
     if (grouped?.notes !== undefined && grouped.notes.trim() !== "")
         say(`the grouping: ${grouped.notes.trim()}`);
     if (!conformance && agents !== undefined) {
-        if (grouped === undefined)
+        if (grouped === undefined) {
+            record({ kind: "planner.fellBack", step: "group", why: "no grouping was given" });
             say("the grouping was not given - a functional spec a pulse");
-        else if (groupProblems(numbered, grouped, maxSpecs).length > 0)
+        }
+        else if (groupProblems(numbered, grouped, maxSpecs).length > 0) {
+            record({ kind: "planner.fellBack", step: "group", why: firstLine(groupProblems(numbered, grouped, maxSpecs).join(" "), 300) });
             say(`the grouping did not hold (${groupProblems(numbered, grouped, maxSpecs).join(" ")}) - a functional spec a pulse`);
+        }
     }
     let chunks = chunksFor(groups);
     // 2. The definitions each group uses.
@@ -407,10 +417,12 @@ async function cut(input, agents, notes) {
             implementationReqs: implementationReqs.map((change, index) => ({ number: index + 1, text: textOf(change) })),
             testReqs: testReqs.map((change, index) => ({ number: index + 1, text: textOf(change) })),
         };
-        const answer = (await agents?.place(placeInput, (given) => placeProblems(placeInput, given)).catch(() => undefined)) ?? undefined;
+        const answer = (await agents?.place(placeInput, (given) => placeProblems(placeInput, given)).catch((error) => plannerFailed("place", error))) ?? undefined;
         if (answer?.notes !== undefined && answer.notes.trim() !== "")
             say(`the placement: ${answer.notes.trim()}`);
         placement = answer !== undefined && placeProblems(placeInput, answer).length === 0 ? answer : undefined;
+        if (placement === undefined && agents !== undefined)
+            record({ kind: "planner.fellBack", step: "place", why: answer === undefined ? "no placement was given" : firstLine(placeProblems(placeInput, answer).join(" "), 300) });
         if (placement === undefined && agents !== undefined)
             say("the placement did not hold - every implementation req with the first pulse, every test req with the first conformance pulse");
     }

package/dist/regenerate/conformance.js

@@ -6,6 +6,7 @@ import { ACCEPTANCE_TESTS, DEFINITIONS, FUNCTIONAL_REQUIREMENTS, NON_FUNCTIONAL_
 import { reportActivity, reportLogNote, reportSpec, reportStage, unitOf } from "./activity.js";
 import { confinedTools } from "./confine.js";
 import { abandonWork, diffSinceSnapshot, landWork, moduleDirOf, startWork, workDiff, workSnapshot } from "./lineage.js";
+import { firstLine, record } from "./ledger.js";
 import { createWorkLedger, describeAccounts, SUBMIT_WORK_NOTE, unanswered, unansweredPrompt } from "./submit-work.js";
 import { CONFORMANCE_COMPACTION } from "./compaction.js";
 import { NOTES_TURN, notesForSession, passedOutcome, readNotes, reflectOnReview, withNotes } from "./notes.js";
@@ -417,6 +418,7 @@ export async function renderConformanceTests(options) {
             // every functionality's tests - and the code's unit testing script.
             stage(`running the conformance testing script on the whole suite (attempt ${rounds + 1} of ${maxRounds})`);
             rounds += 1;
+            record({ kind: "gate.round", gate: "conformance", round: rounds, of: maxRounds });
             let recheck = await runConformanceScript(buildDir, [conformanceDir], scripts);
             runs.push({ command: recheck.command, exitCode: recheck.exitCode });
             options.onRun?.(recheck.command, recheck.exitCode);
@@ -537,6 +539,7 @@ export async function renderConformanceTests(options) {
                     onDelta: options.onDelta,
                 });
                 const reason = verdict.reason.split("\n")[0].slice(0, 160);
+                record({ kind: "judge.verdict", culprit: verdict.culprit, round: rounds, reason: firstLine(verdict.reason, 300) });
                 // Stopped by the time limit while it was still getting on: no agent can give it more time. The pulse stops now -
                 // rolled back, no retry - and the person is told how to raise the limit.
                 if (verdict.culprit === "environment" && recheck.timedOut === true) {

package/dist/regenerate/diagnose.js

@@ -49,8 +49,10 @@ export async function diagnoseFailure(options) {
         if (diagnosis === undefined)
             await ask(session, "You have not called submit_diagnosis. Call it now, with what you know.");
     }
-    catch {
-        // Without a diagnosis the person still gets both failures, as they were.
+    catch (error) {
+        // Without a diagnosis the person still gets both failures, as they were - and the ledger why there is none.
+        if (diagnosis === undefined)
+            throw error;
     }
     finally {
         session.dispose();

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,92 @@
+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;
+/** What to count in the ledger: kinds - whole, or a group by what comes before the dot - a module, since when. */
+export interface EventQuery {
+    /** `healer.failed`, or `healer` for every healer event. */
+    kinds?: string[];
+    module?: string;
+    /** Only events at or after this time. */
+    since?: Date;
+    /** How many of the most recent to list, a line each. */
+    limit?: number;
+}
+/** One event in a line: when, its pulse and module, its kind, its own fields - the agent's role when it has one. */
+export declare function eventLine(entry: LedgerEntry): string;
+/**
+ * The events of these projects' ledgers that `query` asks for: how many of each kind, and the most recent, a line each -
+ * or, when no kind asked for is in the ledger, the kinds it has.
+ */
+export declare function describeEvents(projects: string[], query?: EventQuery): string;
+/** `24h`, `7d`, `30m`, or a date and time: the moment it means, or undefined when it means none. */
+export declare function sinceOf(text: string, now?: number): Date | undefined;
+export {};