@turri-dev/cli 0.1.18-next.85984f7 → 0.1.19-next.ee6bc61

package/dist/regenerate/debugger.js

@@ -15,7 +15,8 @@ import { runTiming } from "./test-scripts.js";
  * this agent: a session of its own - on the `debugger` role's model, else a stronger one than the coding agent's, the
  * judge model or the harness model - that reads the code, the tests, the build files and the
  * failing run - and the web - and says what the cause is and what change fixes it. It changes nothing; the coding
- * agent is given what it found, and goes on.
+ * agent is given what it found, and goes on - unless what it found is no change the coding agent may make: the testing
+ * script itself is wrong, or this machine lacks what it runs. Then the work stops, and the person is told.
  */
 /** How many tool calls the debugger has before it must hand over what it found. */
 const DEBUGGER_CALLS = 40;
@@ -41,6 +42,16 @@ function debugPrompt(input) {
         "",
         "You change nothing - you only read. When you know, call submit_diagnosis: the root cause, with the evidence for it,",
         "and the fix - which files, and exactly what to change in them.",
+        "",
+        "The coding agent changes the code and its unit tests, nothing else: never the testing script, never this machine. The",
+        "script decides, and the code fits what it needs - a folder, a test runner, a tool in the build's dependencies. Set",
+        "at_fault when no code and no tests could pass it, and the work stops for the person to fix it:",
+        "- script: the testing script itself is wrong - it overwrites the tests' exit code, checks the wrong folder, calls a",
+        "  tool wrongly. Quote its lines in root_cause, and say in fix what to change in it.",
+        "- machine: this machine lacks what the script runs - an interpreter (`python`), a toolchain, a system library - not",
+        "  a package the build can declare, which is the coding agent's. Say in root_cause what is missing, and the output",
+        "  that shows it.",
+        "Leave it out when the code or its tests are what is wrong.",
         ...(timedOut
             ? [
                 "",
@@ -81,11 +92,19 @@ export async function debugFailure(input) {
             too_slow: Type.Optional(Type.Boolean({
                 description: "Only for a run the time limit stopped: true when nothing hangs - it was making progress up to the limit and needs more time than a test run may take",
             })),
+            at_fault: Type.Optional(Type.Union([Type.Literal("script"), Type.Literal("machine")], {
+                description: "Only when no code and no tests could pass the script: script - the testing script itself is wrong; machine - this machine lacks what it runs. Left out, the code or its tests are what is wrong",
+            })),
         }),
         async execute(_id, params) {
             const given = params;
             // Too slow is a verdict on a run the limit stopped, and on no other.
-            found = { rootCause: given.root_cause, fix: given.fix, ...(given.too_slow === true && input.run?.timedOut === true ? { tooSlow: true } : {}) };
+            found = {
+                rootCause: given.root_cause,
+                fix: given.fix,
+                ...(given.too_slow === true && input.run?.timedOut === true ? { tooSlow: true } : {}),
+                ...(given.at_fault === "script" || given.at_fault === "machine" ? { atFault: given.at_fault } : {}),
+            };
             return { content: [{ type: "text", text: "Recorded." }], details: {}, terminate: true };
         },
     });

package/dist/regenerate/environment-error.d.ts

@@ -119,6 +119,31 @@ export declare function timeLimitError(run: {
     kind: "unit" | "conformance";
     reason: string;
 }): EnvironmentError;
+/**
+ * A testing script that fails whatever the code and its tests are - judged so by the debugger or the conformance judge,
+ * from the script's own lines and the run: `script`, the script itself is wrong - it overwrites the tests' exit code, runs
+ * the wrong folder, calls a tool wrongly; `machine`, this machine lacks what it runs - an interpreter, a toolchain - and
+ * the harness's own check (`missingToolchain`) did not see it in the output. No agent may change a testing script or
+ * install a toolchain, so no round would pass it: the pulse stops, rolled back, no retry, and the person is told.
+ */
+export declare function scriptFaultError(at: "script" | "machine", details: {
+    moduleName: string;
+    script: string;
+    kind: "unit" | "conformance";
+    reason: string;
+    fix?: string;
+}): EnvironmentError;
+/**
+ * What the conformance tests' run is given is what is wrong - a credential missing or rejected, an account or a quota a
+ * service refuses - judged so by the conformance judge `times` times in a row, the tests checked in between. Only the
+ * person can fix it: the pulse stops, rolled back, no retry.
+ */
+export declare function runEnvironmentError(details: {
+    moduleName: string;
+    script: string;
+    reason: string;
+    times: number;
+}): EnvironmentError;
 /** The harness's run of a testing script, when it could not find its toolchain: the error that stops the pulse. */
 export declare function missingToolchainError(run: {
     exitCode: number;

package/dist/regenerate/environment-error.js

@@ -241,6 +241,52 @@ export function timeLimitError(run, details) {
         source: "agent",
     });
 }
+/**
+ * A testing script that fails whatever the code and its tests are - judged so by the debugger or the conformance judge,
+ * from the script's own lines and the run: `script`, the script itself is wrong - it overwrites the tests' exit code, runs
+ * the wrong folder, calls a tool wrongly; `machine`, this machine lacks what it runs - an interpreter, a toolchain - and
+ * the harness's own check (`missingToolchain`) did not see it in the output. No agent may change a testing script or
+ * install a toolchain, so no round would pass it: the pulse stops, rolled back, no retry, and the person is told.
+ */
+export function scriptFaultError(at, details) {
+    const what = `${details.kind} testing script`;
+    const name = `\`${basename(details.script)}\``;
+    const reason = details.reason.replace(/\s+/g, " ").trim().slice(0, 600);
+    const fix = details.fix?.replace(/\s+/g, " ").trim().slice(0, 600);
+    return at === "script"
+        ? new EnvironmentError({
+            moduleName: details.moduleName,
+            missing: `a ${what} that can pass - ${name} fails whatever the code and its tests are`,
+            neededBy: `every pulse of ${details.moduleName}: the ${what} decides whether its work passes`,
+            shownBy: reason,
+            fix: `change the ${what}, \`${details.script}\`${fix !== undefined && fix !== "" ? ` - ${fix}` : ""}. turri's agents may not change the testing scripts.`,
+            source: "agent",
+        })
+        : new EnvironmentError({
+            moduleName: details.moduleName,
+            missing: `what the ${what}, ${name}, runs on this machine`,
+            neededBy: `the ${what}, ${name}`,
+            shownBy: reason,
+            fix: `${fix !== undefined && fix !== "" ? `${fix} - ` : ""}install it on this machine, where the testing scripts run, so the script finds it on its PATH.`,
+            source: "agent",
+        });
+}
+/**
+ * What the conformance tests' run is given is what is wrong - a credential missing or rejected, an account or a quota a
+ * service refuses - judged so by the conformance judge `times` times in a row, the tests checked in between. Only the
+ * person can fix it: the pulse stops, rolled back, no retry.
+ */
+export function runEnvironmentError(details) {
+    return new EnvironmentError({
+        moduleName: details.moduleName,
+        missing: "what the conformance tests' run needs - a valid credential, an account, a service it can reach",
+        neededBy: `the conformance testing script, \`${basename(details.script)}\``,
+        shownBy: `judged so ${details.times} times in a row: ${details.reason.replace(/\s+/g, " ").trim().slice(0, 600)}`,
+        fix: "provide what the run is missing where the conformance testing script reads it. The testing scripts run on this machine " +
+            "in your own environment: a credential they need is read from there - your shell's variables, or a .env the script loads.",
+        source: "agent",
+    });
+}
 /** The harness's run of a testing script, when it could not find its toolchain: the error that stops the pulse. */
 export function missingToolchainError(run, details) {
     const missing = missingToolchain(run);

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

@@ -39,8 +39,8 @@ export declare function resetKeysForTests(): void;
 export declare function breath(now: number): number;
 export declare function spinner(now: number): string;
 /**
- * What finished, a line a module - its name, then its pulses oldest first - fitted to `width` from the left: the
- * newest that fit, the rest counted as earlier. The side panel lists every one.
+ * What finished, a line a module - the module that finished last on top, its name, then its pulses newest first -
+ * fitted to `width`: the newest that fit, the rest counted as earlier. The side panel lists every one.
  */
 export declare function finishedLines(finished: Job[], width: number | undefined, marks?: MarkPaint): string[];
 /** A pulse that ran to its end and whose build did not pass - stopped at a gate - is not a success. */

package/dist/regenerate/job-panel.js

@@ -67,12 +67,12 @@ function finishedItem(job, marks) {
     return `${finishedMark(job, marks)} ${job.pulse} ${job.kind}`;
 }
 /**
- * What finished, a line a module - its name, then its pulses oldest first - fitted to `width` from the left: the
- * newest that fit, the rest counted as earlier. The side panel lists every one.
+ * What finished, a line a module - the module that finished last on top, its name, then its pulses newest first -
+ * fitted to `width`: the newest that fit, the rest counted as earlier. The side panel lists every one.
  */
 export function finishedLines(finished, width, marks = PLAIN_MARKS) {
     const byModule = new Map();
-    for (const job of [...finished].sort((a, b) => a.sequence - b.sequence)) {
+    for (const job of [...finished].sort((a, b) => (b.finishedAt ?? 0) - (a.finishedAt ?? 0) || b.sequence - a.sequence)) {
         const key = job.module ?? job.kind;
         byModule.set(key, [...(byModule.get(key) ?? []), job]);
     }
@@ -80,11 +80,11 @@ export function finishedLines(finished, width, marks = PLAIN_MARKS) {
     return [...byModule].map(([name, jobs]) => {
         const head = `  ${name}${" ".repeat(pad - visibleWidth(name))}  `;
         const items = jobs.map((job) => finishedItem(job, marks));
-        const lineOf = (from) => `${head}${from > 0 ? `… ${from} earlier · ` : ""}${items.slice(from).join(" · ")}`;
-        let from = 0;
-        while (width !== undefined && from < items.length - 1 && visibleWidth(lineOf(from)) > width)
-            from += 1;
-        return lineOf(from);
+        const lineOf = (shown) => `${head}${items.slice(0, shown).join(" · ")}${shown < items.length ? ` · … ${items.length - shown} earlier` : ""}`;
+        let shown = items.length;
+        while (width !== undefined && shown > 1 && visibleWidth(lineOf(shown)) > width)
+            shown -= 1;
+        return lineOf(shown);
     });
 }
 /** A pulse that ran to its end and whose build did not pass - stopped at a gate - is not a success. */
@@ -163,8 +163,9 @@ export function wrapKeepingIndent(line, width) {
 export function jobPanelLines(jobs, options = {}) {
     const now = options.now ?? Date.now();
     const expanded = options.expanded === true;
-    const inOrder = [...jobs].sort((a, b) => a.sequence - b.sequence);
-    const running = inOrder.filter((job) => job.status === "running");
+    // Newest first, as every list of pulses is.
+    const inOrder = [...jobs].sort((a, b) => b.sequence - a.sequence);
+    const running = inOrder.filter((job) => job.status === "running").sort((a, b) => b.startedAt - a.startedAt || b.sequence - a.sequence);
     // A module whose work is being planned: the planner is an agent, and takes a while - shown at once, as work going on.
     const planning = inOrder.filter((job) => job.status === "queued" && job.planning !== undefined);
     // Nothing running or being planned: no panel - what waits and what finished are in the side panel.
@@ -172,7 +173,7 @@ export function jobPanelLines(jobs, options = {}) {
         return [];
     const finished = inOrder.filter((job) => (job.status === "succeeded" || job.status === "failed" || job.status === "stopped") && job.replacedBy === undefined);
     const lines = [];
-    // What finished, on top - a line a module, oldest first - and a rule under it: what runs now is below, by the input.
+    // What finished, on top - a line a module, newest first - and a rule under it: what runs now is below, by the input.
     if (finished.length > 0) {
         lines.push(...finishedLines(finished, options.width, options.marks ?? PLAIN_MARKS));
         lines.push(`  ${"─".repeat(Math.max(10, (options.width ?? 80) - 4))}`);

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

@@ -46,9 +46,9 @@ export type TreeRow = {
     file: string;
     first: boolean;
 };
-/** The rows, top to bottom: each section's header, and its jobs when it is open - finished ones newest first. */
 /** The pulse list put on one pulse: its section open, the pulse opened - its stages, its agents, its log - and the cursor on it. */
 export declare function selectJob(jobs: Job[], state: JobsTreeState, id: string): boolean;
+/** The rows, top to bottom: each section's header, and its jobs when it is open - newest first in every section. */
 export declare function jobsTreeRows(jobs: Job[], state: JobsTreeState): TreeRow[];
 /** The rows as lines, the cursor's marked, and where each row starts - for scrolling to it. */
 export declare function jobsTreeLines(jobs: Job[], state: JobsTreeState, width: number, style: TranscriptStyle): {

package/dist/regenerate/jobs-tree.js

@@ -45,7 +45,6 @@ function isOpen(state, job) {
     state.openJobs.delete(job.id);
     return false;
 }
-/** The rows, top to bottom: each section's header, and its jobs when it is open - finished ones newest first. */
 /** The pulse list put on one pulse: its section open, the pulse opened - its stages, its agents, its log - and the cursor on it. */
 export function selectJob(jobs, state, id) {
     const job = jobs.find((entry) => entry.id === id);
@@ -59,13 +58,13 @@ export function selectJob(jobs, state, id) {
         state.cursor = at;
     return at !== -1;
 }
+/** The rows, top to bottom: each section's header, and its jobs when it is open - newest first in every section. */
 export function jobsTreeRows(jobs, state) {
     // A job queued again as another is that other one: it is not listed apart.
-    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" || section === "earlier" ? inSection.sort((a, b) => (b.finishedAt ?? b.sequence) - (a.finishedAt ?? a.sequence) || b.sequence - a.sequence) : inSection;
-    };
+    const listed = jobs.filter((job) => job.replacedBy === undefined);
+    // Every section newest first: running by when it started, queued by when it was queued, finished by when it ended.
+    const when = (job, section) => section === "running" ? job.startedAt : section === "queued" ? job.queuedAt : (job.finishedAt ?? job.queuedAt);
+    const of = (section) => listed.filter((job) => sectionOf(job) === section).sort((a, b) => when(b, section) - when(a, section) || b.sequence - a.sequence);
     // Forget what is open for jobs that moved on - they close as they leave.
     for (const job of jobs)
         isOpen(state, job);

package/dist/regenerate/jobs.d.ts

@@ -116,6 +116,8 @@ export interface StartJobInput {
     title?: string;
     /** For a render spec diff job: the diff, to show in the panel and the transcript. */
     diff?: string;
+    /** Where the diff's lines are in the .plain files, when they could be placed. */
+    diffWhere?: import("./diff-view.ts").DiffWhere;
     /** "provider/model-id" its agents run on, to show where the job is shown. */
     model?: string;
     /** For a conformance job: the render it is the conformance of. */
@@ -146,6 +148,8 @@ export interface JobRegistry {
     notify?(): void;
     /** Resolves when the job settles. Used by callers that asked to wait. */
     wait(id: string): Promise<Job>;
+    /** A job's ***plain diff, moved - its pulse steered: shown and recorded in the ledger as it is now. */
+    setDiff(id: string, diff: string, where?: import("./diff-view.ts").DiffWhere): void;
 }
 /** What a stopped job says when the person stopped it. */
 export declare const STOPPED_ON_REQUEST = "Stopped on request.";

package/dist/regenerate/jobs.js

@@ -45,6 +45,8 @@ export function createJobRegistry(options) {
      * settles - and whatever queues behind it has to wait that long too.
      */
     const done = new Set();
+    /** Where each job's events are recorded: its id, project and module. */
+    const places = new Map();
     let sequence = 0;
     return {
         setMaxRunning(count) {
@@ -76,6 +78,7 @@ export function createJobRegistry(options) {
                 ...(input.pulse !== undefined ? { pulse: input.pulse } : {}),
                 ...(input.title !== undefined ? { title: input.title } : {}),
                 diff: input.diff,
+                ...(input.diffWhere !== undefined ? { diffWhere: input.diffWhere } : {}),
                 model: input.model,
                 ...(stack !== undefined ? { stack } : {}),
                 ...(chat !== undefined ? { chat } : {}),
@@ -107,6 +110,10 @@ export function createJobRegistry(options) {
                 waitingOn: blockers,
                 ...(input.follows !== undefined ? { follows: input.follows } : {}),
             }, place);
+            // Its ***plain diff, whole: what an earlier session's pulse regenerated is read back from the ledger.
+            if (input.diff !== undefined && input.diff.trim() !== "")
+                record({ kind: "job.diff", diff: input.diff, ...(input.diffWhere !== undefined ? { where: input.diffWhere } : {}) }, place);
+            places.set(id, place);
             const changed = () => {
                 // Like onFinish: a display that throws must not take the job down.
                 try {
@@ -376,6 +383,23 @@ export function createJobRegistry(options) {
         get(id) {
             return jobs.get(id);
         },
+        setDiff(id, diff, where) {
+            const job = jobs.get(id);
+            if (job === undefined)
+                return;
+            job.diff = diff;
+            if (where !== undefined)
+                job.diffWhere = where;
+            else
+                delete job.diffWhere;
+            record({ kind: "job.diff", diff, ...(where !== undefined ? { where } : {}) }, places.get(id) ?? { job: id });
+            try {
+                options?.onChange?.(job);
+            }
+            catch {
+                /* a display that throws must not take the job down */
+            }
+        },
         stop(id, reason) {
             const job = jobs.get(id);
             const controller = controllers.get(id);

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

@@ -21,6 +21,9 @@ export interface PulseView {
     };
     started?: Of<"job.started">;
     finished?: Of<"job.finished">;
+    /** Its ***plain diff as it last was, and how many times steering moved it. */
+    diff?: Of<"job.diff">;
+    steered: number;
     stages: string[];
     retried: Array<Of<"job.retried">>;
     rounds: Map<string, {
@@ -44,11 +47,16 @@ export interface PulseView {
 }
 /** 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 from the ledger, for the chat and `turri ledger <pulse>`: what happened in it, as facts - and, last, the
+ * ***plain diff it regenerated, unless `diff` is false.
+ */
+export declare function describePulseView(view: PulseView, options?: {
+    diff?: boolean;
+}): 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. */
+/** A run of the project's, and its pulses: runs and pulses the most recent first. */
 export interface RunView {
     run: string;
     started?: Of<"run.started">;

package/dist/regenerate/ledger-view.js

@@ -36,6 +36,7 @@ export function pulseView(id, entries) {
     const view = {
         id: fullId,
         run: own[0].run,
+        steered: 0,
         stages: [],
         retried: [],
         rounds: new Map(),
@@ -65,6 +66,11 @@ export function pulseView(id, entries) {
                 view.finished = entry;
                 view.usage = entry.usage;
                 break;
+            case "job.diff":
+                if (view.diff !== undefined)
+                    view.steered += 1;
+                view.diff = entry;
+                break;
             case "job.stage":
                 view.stages.push(entry.label);
                 break;
@@ -135,8 +141,11 @@ function outcomeOf(view) {
     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) {
+/**
+ * A pulse from the ledger, for the chat and `turri ledger <pulse>`: what happened in it, as facts - and, last, the
+ * ***plain diff it regenerated, unless `diff` is false.
+ */
+export function describePulseView(view, options = {}) {
     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}` : ""}`);
@@ -144,7 +153,7 @@ export function describePulseView(view) {
         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)
+    for (const retry of [...view.retried].reverse())
         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("; ")}`);
@@ -187,7 +196,7 @@ export function describePulseView(view) {
         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) {
+    for (const event of [...view.history].reverse()) {
         if (event.kind === "history.committed")
             lines.push(`  committed: ${event.subject}`);
         else if (event.kind === "history.failed")
@@ -197,11 +206,15 @@ export function describePulseView(view) {
         else
             lines.push(`  rolled back: ${event.why}`);
     }
+    if (view.steered > 0)
+        lines.push(`  steered ${view.steered} time${view.steered === 1 ? "" : "s"}: its ***plain diff moved with ***plain`);
     if (view.stages.length > 0)
-        lines.push("  last stages:", ...view.stages.slice(-8).map((stage) => `    ${stage}`));
+        lines.push("  last stages, newest first:", ...view.stages.slice(-8).reverse().map((stage) => `    ${stage}`));
     const log = view.finished?.logFile ?? view.started?.logFile;
     if (log !== undefined)
         lines.push(`  log: ${log}`);
+    if (options.diff !== false && view.diff !== undefined)
+        lines.push(`  its ***plain diff${view.steered > 0 ? ", as last steered" : ""}:`, ...view.diff.diff.trimEnd().split("\n").map((line) => `    ${line}`));
     return lines.join("\n");
 }
 /** A pulse the ledger of any of these projects knows, described - or undefined. */
@@ -224,7 +237,8 @@ export function runViews(project) {
         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) };
+        // Its pulses the most recent first, as its runs are.
+        return { run, ...(started !== undefined ? { started } : {}), ...(ended !== undefined ? { ended } : {}), pulses: ids.map((id) => pulseView(id, own)).filter(Boolean).reverse() };
     })
         .reverse();
 }
@@ -274,6 +288,8 @@ export function asJob(view) {
         ...(view.queued?.pulse !== undefined ? { pulse: view.queued.pulse } : {}),
         ...(view.queued?.title !== undefined ? { title: view.queued.title } : {}),
         ...(view.queued?.model !== undefined ? { model: view.queued.model } : {}),
+        // Its ***plain diff, shown a file at a time as this session's pulses' are.
+        ...(view.diff !== undefined ? { diff: view.diff.diff, ...(view.diff.where !== undefined ? { diffWhere: view.diff.where } : {}) } : {}),
         status,
         sequence: 0,
         queuedAt,
@@ -288,7 +304,7 @@ export function asJob(view) {
         ...(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(/^  /, "")) },
+        earlier: { run: view.run, ...(view.runMode !== undefined ? { runMode: view.runMode } : {}), lines: describePulseView(view, { diff: false }).split("\n").slice(1).map((line) => line.replace(/^  /, "")) },
     };
 }
 /** The envelope's fields, said apart from an event's own. */
@@ -298,7 +314,9 @@ export function eventLine(entry) {
     const fields = Object.entries(entry)
         .filter(([key]) => !ENVELOPE.has(key))
         .map(([key, value]) => {
-        const text = typeof value === "string" ? JSON.stringify(value.length > 160 ? `${value.slice(0, 159)}…` : value) : JSON.stringify(value);
+        // A long value - a ***plain diff, where its lines are - cut to the start of it: the line is a glance.
+        const whole = typeof value === "string" ? value : JSON.stringify(value);
+        const text = typeof value === "string" ? JSON.stringify(value.length > 160 ? `${value.slice(0, 159)}…` : value) : whole.length > 160 ? `${whole.slice(0, 159)}…` : whole;
         return `${key}=${text}`;
     });
     const where = [entry.job, entry.module, entry.agent?.role ?? entry.agent?.label].filter((part) => part !== undefined);
@@ -325,11 +343,11 @@ export function describeEvents(projects, query = {}) {
     const pulses = new Set(found.map((entry) => entry.job).filter((job) => job !== undefined)).size;
     const runs = new Set(found.map((entry) => entry.run)).size;
     const limit = Math.max(1, query.limit ?? 20);
-    const recent = found.slice(-limit);
+    const recent = found.slice(-limit).reverse();
     return [
         `${found.length} event${found.length === 1 ? "" : "s"}${scope !== "" ? ` ${scope}` : ""}, in ${runs} run${runs === 1 ? "" : "s"} and ${pulses} pulse${pulses === 1 ? "" : "s"}: ${[...counts].sort((a, b) => b[1] - a[1]).map(([kind, times]) => `${kind} ${times}`).join(", ")}`,
         "",
-        recent.length === found.length ? "Each, oldest first:" : `The last ${recent.length}, oldest first:`,
+        recent.length === found.length ? "Each, newest first:" : `The last ${recent.length}, newest first:`,
         ...recent.map(eventLine),
     ].join("\n");
 }

package/dist/regenerate/ledger.d.ts

@@ -1,3 +1,4 @@
+import type { DiffWhere } from "./diff-view.ts";
 import { type UsageReport } from "./activity.ts";
 /**
  * The ledger: what turri does, as typed facts, one JSON line each, written as it happens - to
@@ -8,9 +9,10 @@ import { type UsageReport } from "./activity.ts";
  * was queued, started, went through its stages and ended, and how; what each agent's model calls and
  * turns cost; each tool call and test run, how long it took and how it ended; the gates' rounds and
  * verdicts; what turri refused or stopped; what its healers did; the history's commits. What a pulse
- * from an earlier session did is looked up here (`pulses`, `diagnose`, `turri ledger`). Never stored:
- * prompts, replies, thinking, tool arguments and results, file contents - and what strings an event
- * carries are masked as the logs are.
+ * from an earlier session did is looked up here (`pulses`, `diagnose`, `turri ledger`) - and what it
+ * regenerated, its ***plain diff, kept whole as the one body the ledger has. Never stored: prompts,
+ * replies, thinking, tool arguments and results, file contents - and what strings an event carries are
+ * masked as the logs are.
  *
  * A host hears each event as it is recorded (`onLedgerEvent`), with the project it is about, rather than reading the
  * file again - written or not, so a project that keeps no ledger is heard all the same.
@@ -64,6 +66,10 @@ export type LedgerEvent = {
     kind: "job.started";
     waitedMs: number;
     logFile?: string;
+} | {
+    kind: "job.diff";
+    diff: string;
+    where?: DiffWhere;
 } | {
     kind: "job.stage";
     label: string;

package/dist/regenerate/ledger.js

@@ -17,9 +17,10 @@ import { ensureInScratch } from "./paths.js";
  * was queued, started, went through its stages and ended, and how; what each agent's model calls and
  * turns cost; each tool call and test run, how long it took and how it ended; the gates' rounds and
  * verdicts; what turri refused or stopped; what its healers did; the history's commits. What a pulse
- * from an earlier session did is looked up here (`pulses`, `diagnose`, `turri ledger`). Never stored:
- * prompts, replies, thinking, tool arguments and results, file contents - and what strings an event
- * carries are masked as the logs are.
+ * from an earlier session did is looked up here (`pulses`, `diagnose`, `turri ledger`) - and what it
+ * regenerated, its ***plain diff, kept whole as the one body the ledger has. Never stored: prompts,
+ * replies, thinking, tool arguments and results, file contents - and what strings an event carries are
+ * masked as the logs are.
  *
  * A host hears each event as it is recorded (`onLedgerEvent`), with the project it is about, rather than reading the
  * file again - written or not, so a project that keeps no ledger is heard all the same.

package/dist/regenerate/loop.js

@@ -435,8 +435,7 @@ export function createWorkLoop(options) {
         const job = options.registry.get(running.jobId);
         if (job !== undefined) {
             const shown = changeDiffInFiles(agentChanges(changesBetween(serializeTree(running.from), serializeTree(steering.agent)), "code"), relative(projectDirOf(tip.plainFile), tip.plainFile) || basename(tip.plainFile), (diff) => whereInFiles(diff, state.chain));
-            job.diff = shown.diff;
-            job.diffWhere = shown.where;
+            options.registry.setDiff(job.id, shown.diff, shown.where);
         }
         reportActivity(`  ⇢ steered pulse ${running.jobId} (${steering.steers} of ${MAX_STEERS}): ${why}`);
         return true;
@@ -521,6 +520,8 @@ export function createWorkLoop(options) {
             pulse: (state.pulses ?? 0) + 1,
             title: planned.title,
             diff: shown.diff,
+            // Its lines where they are written: the module's .plain file, those it imports, and those of the modules below it.
+            diffWhere: shown.where,
             ...(state.model !== undefined ? { model: state.model } : {}),
             lanes: [...moduleLanes(tip.plainFile)],
             rerun: `turri regenerate ${relative(options.cwd, tip.plainFile) || basename(tip.plainFile)}`,
@@ -617,8 +618,6 @@ export function createWorkLoop(options) {
                 };
             },
         });
-        // Its lines where they are written: the module's .plain file, those it imports, and those of the modules below it.
-        job.diffWhere = shown.where;
         state.pulses = (state.pulses ?? 0) + 1;
         state.running = { jobId: job.id, number: state.pulses, planned, from, after: planned.step.tree, ...(steering !== undefined ? { steering } : {}) };
         void options.registry.wait(job.id).then((settled) => settle(state, settled), () => settle(state, undefined));

package/dist/regenerate/regenerate.js

@@ -21,7 +21,7 @@ import { createWebTools, WEB_TOOLS } from "./web.js";
 import { createCanItFailTool, createMyDiffTool, selfCheckNote } from "./self-check.js";
 import { createServiceTools } from "./services.js";
 import { createUnitGate } from "./unit-gate.js";
-import { timeLimitError, toolchainError } from "./environment-error.js";
+import { scriptFaultError, timeLimitError, toolchainError } from "./environment-error.js";
 import { workspaceBlock } from "./workspace.js";
 import { ATTEMPTS, describeStop } from "./stop-report.js";
 import { summarizeDiff } from "./job-panel.js";
@@ -341,8 +341,11 @@ export async function renderSpecDiff(options) {
     let unchanged = false;
     /** What the unit testing script needs and does not find, last run. */
     let missing;
-    /** The unit testing script needs more time than a test run may take - the debugger's finding: the pulse stops on it. */
-    let slow;
+    /**
+     * What no round could change, as the debugger found it - the unit testing script needs more time than a test run may
+     * take, the script itself is wrong, this machine lacks what it runs: the pulse stops on it.
+     */
+    let blocked;
     /** The last round failed on the script's static checks alone: the unit tests passed. */
     let staticOnly = false;
     const testRemovals = [];
@@ -472,7 +475,16 @@ export async function renderSpecDiff(options) {
                         // Nothing hangs: the suite needs more time than a test run may take, and no agent can give it that.
                         if (found?.tooSlow === true) {
                             stage(`the unit testing script needs more than the ${Math.round(verdict.run.timeoutMs / 1000)}s a test run may take - stopping`);
-                            slow = timeLimitError(verdict.run, { moduleName, script: verdict.script, kind: "unit", reason: found.rootCause });
+                            blocked = { error: timeLimitError(verdict.run, { moduleName, script: verdict.script, kind: "unit", reason: found.rootCause }), why: "the unit testing script needs more time than a test run may take" };
+                            return false;
+                        }
+                        // Not the code's: no round would pass the script, the coding agent may change neither it nor this machine.
+                        if (found?.atFault !== undefined) {
+                            stage(found.atFault === "script"
+                                ? "the debugger finds the unit testing script itself is wrong - no change to the code would pass it - stopping"
+                                : "the debugger finds this machine lacks what the unit testing script runs - stopping");
+                            const error = scriptFaultError(found.atFault, { moduleName, script: verdict.script, kind: "unit", reason: found.rootCause, fix: found.fix });
+                            blocked = { error, why: found.atFault === "script" ? "the unit testing script itself is wrong" : "this machine lacks what the unit testing script runs" };
                             return false;
                         }
                         if (found !== undefined) {
@@ -582,8 +594,8 @@ export async function renderSpecDiff(options) {
             ? "the unit testing script could not run"
             : unchanged
                 ? "regenerating again, the coding agent built nothing anew"
-                : slow !== undefined
-                    ? "the unit testing script needs more time than a test run may take"
+                : blocked !== undefined
+                    ? blocked.why
                     : staticOnly
                         ? "the spec change did not pass its static checks"
                         : "the spec change did not pass its unit tests");
@@ -591,8 +603,8 @@ export async function renderSpecDiff(options) {
         if (missing !== undefined) {
             throw toolchainError(missing, { moduleName, script: scripts.unit, kind: "unit" });
         }
-        if (slow !== undefined)
-            throw slow;
+        if (blocked !== undefined)
+            throw blocked.error;
         return { ...base, passed: false, stoppedAt: "unit tests", ...(staticOnly && !unitReviewStopped ? { staticChecks: true } : {}) };
     }
     stage("unit tests pass - landing the change on them");

package/dist/regenerate/stop-report.d.ts

@@ -19,7 +19,7 @@ export interface StopFacts {
     at: StopPoint;
     /** The unit test runs, the last of which is the failing one. */
     runs?: TestRun[];
-    conformance?: Pick<RenderConformanceTestsResult, "runs" | "rounds" | "specConflict" | "stuck" | "environment" | "escalation" | "review" | "unlabelled">;
+    conformance?: Pick<RenderConformanceTestsResult, "runs" | "rounds" | "specConflict" | "stuck" | "escalation" | "review" | "unlabelled">;
     /** Repairs made to earlier functionalities' code before it gave up. */
     repairs?: number;
     /** How many times the harness judged it before it stopped - the unit tests' attempts. */