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

package/dist/regenerate/ledger.js

@@ -0,0 +1,349 @@
+import { createHash, randomUUID } from "node:crypto";
+import { appendFileSync, existsSync, readdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { gunzipSync, gzipSync } from "node:zlib";
+import { readProjectConfig } from "../config.js";
+import { turriIdentity } from "../environment.js";
+import { currentPlace, onModelEvent } from "./activity.js";
+import { maskSecrets } from "./masking.js";
+import { ensureInScratch } from "./paths.js";
+/**
+ * The ledger: what turri does, as typed facts, one JSON line each, written as it happens - to
+ * `.turri/ledger/` in the project, one file a run (a conversation, a headless run, a host's session).
+ *
+ * The job and debug logs keep the bodies - every prompt, reply and tool result, whole - for reading one
+ * pulse closely. The ledger keeps the facts about them, across pulses, sessions and runs: that a pulse
+ * 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.
+ *
+ * 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.
+ *
+ * Observation, never control: turri may react to events as they happen, but never reads the ledger on
+ * disk to decide what to build - the code and tests records are that (records.ts). Deleting
+ * `.turri/ledger/` loses only what can be looked up. A ledger that cannot be written stops, and never
+ * fails the work.
+ *
+ * Closed runs are gzipped, and the oldest pruned past `ledger-keep:` megabytes (100 unset; 0 keeps none),
+ * when a run first writes to the project. `.turri` ignores itself, so none of it is ever committed.
+ */
+export const LEDGER_DIR = "ledger";
+/** Megabytes of ledger a project keeps when `ledger-keep:` does not say. */
+export const DEFAULT_LEDGER_KEEP_MB = 100;
+let current;
+let seq = 0;
+const listeners = new Set();
+/**
+ * Hear every event from now on, as it is recorded, with the project it is about - while the ledger is on. Returns
+ * what stops it. A listener that throws is left out of that event, never the work.
+ */
+export function onLedgerEvent(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+}
+function tell(entry, project) {
+    for (const listener of listeners) {
+        try {
+            listener(entry, project);
+        }
+        catch {
+            /* a listener that fails does not take the work down */
+        }
+    }
+}
+/** Whether turri turns the ledger on as it starts: always, unless TURRI_LEDGER=off. */
+export function ledgerWanted() {
+    return process.env.TURRI_LEDGER !== "off";
+}
+/** This run's id, while the ledger is on. */
+export function ledgerRun() {
+    return current?.id;
+}
+/**
+ * Start the ledger for this process: from now on, what is recorded is written. `project` is the one events about no
+ * project of their own go to. `warn` is told, once a project, when its ledger cannot be written. Returns what stops it.
+ */
+export function startLedger(options) {
+    stopLedger();
+    const run = {
+        id: randomUUID().slice(0, 8),
+        mode: options.mode,
+        started: Date.now(),
+        ...(options.project !== undefined ? { project: resolve(options.project) } : {}),
+        writers: new Map(),
+        ...(options.warn !== undefined ? { warn: options.warn } : {}),
+        unsubscribe: () => { },
+    };
+    current = run;
+    run.unsubscribe = onModelEvent((event) => recordModelEvent(event));
+    process.once("exit", endRun);
+    return stopLedger;
+}
+/** Stop the ledger: each project this run wrote to is told it ended. */
+export function stopLedger() {
+    if (current === undefined)
+        return;
+    endRun();
+}
+function endRun() {
+    const run = current;
+    if (run === undefined)
+        return;
+    process.removeListener("exit", endRun);
+    for (const project of run.writers.keys())
+        write(run, project, { kind: "run.ended", ms: Date.now() - run.started }, {});
+    run.unsubscribe();
+    current = undefined;
+}
+/** Record an event: where it happened is the job this code runs for, unless `place` says. Nothing while the ledger is off. */
+export function record(event, place = {}) {
+    const run = current;
+    if (run === undefined)
+        return;
+    const here = currentPlace();
+    const project = place.project ?? here.project ?? run.project;
+    if (project === undefined)
+        return;
+    const job = place.job ?? here.job;
+    const module = place.module ?? here.module;
+    write(run, resolve(project), event, { ...(job !== undefined ? { job } : {}), ...(module !== undefined ? { module } : {}), ...(place.agent !== undefined ? { agent: place.agent } : {}) });
+}
+/**
+ * Run a healer - the debugger, the diagnosis of a failed pulse - and record it: started, ended with what it found, or
+ * failed and why. A healer that fails gives undefined, as it did before it was recorded, but is no longer silent.
+ */
+export async function healing(healer, work, found) {
+    const started = Date.now();
+    record({ kind: "healer.started", healer });
+    try {
+        const result = await work();
+        const said = result !== undefined && found !== undefined ? found(result) : undefined;
+        record({ kind: "healer.ended", healer, ms: Date.now() - started, ...(said !== undefined ? { found: firstLine(said, 240) } : {}) });
+        return result;
+    }
+    catch (error) {
+        record({ kind: "healer.failed", healer, ms: Date.now() - started, error: firstLine(error instanceof Error ? error.message : String(error), 300) });
+        return undefined;
+    }
+}
+/** A failure's fingerprint, short: two runs failing the same way have the same one. */
+export function signatureHash(signature) {
+    return createHash("sha1").update(signature).digest("hex").slice(0, 12);
+}
+/** The first line of a text, at most `max` characters: what an event keeps of an error or a reason. */
+export function firstLine(text, max = 200) {
+    const line = text.trim().split("\n")[0] ?? "";
+    return line.length > max ? `${line.slice(0, max - 1)}…` : line;
+}
+function recordModelEvent(event) {
+    const agent = { ...(event.role !== undefined ? { role: event.role } : {}), ...(event.label !== undefined ? { label: event.label } : {}), ...(event.model !== undefined ? { model: event.model } : {}) };
+    const place = { ...(event.job !== undefined ? { job: event.job } : {}), ...(Object.keys(agent).length > 0 ? { agent } : {}) };
+    switch (event.kind) {
+        case "call":
+            record({ kind: "model.call", ...(event.ms !== undefined ? { ms: event.ms } : {}), ...(event.usage !== undefined ? { usage: event.usage } : {}) }, place);
+            break;
+        case "turn":
+            record({ kind: "model.turn" }, place);
+            break;
+        case "compaction":
+            record({ kind: "model.compaction" }, place);
+            break;
+        case "provider_retry":
+            record({ kind: "provider.retry", error: firstLine(event.error ?? "", 300), attempt: event.attempt ?? 0, of: event.of ?? 0, waitMs: event.waitMs ?? 0 }, place);
+            break;
+        case "provider_stall":
+            record({ kind: "provider.stall", waitMs: event.waitMs ?? 0 }, place);
+            break;
+        case "stopped":
+            record({ kind: "turn.stopped", reason: firstLine(event.reason ?? "", 300) }, place);
+            break;
+    }
+}
+/** The project's ledger folder. */
+export function ledgerDir(project) {
+    return join(resolve(project), ".turri", LEDGER_DIR);
+}
+/** How many megabytes of ledger the project keeps. */
+function keepOf(project) {
+    try {
+        return readProjectConfig(project).ledgerKeep ?? DEFAULT_LEDGER_KEEP_MB;
+    }
+    catch {
+        return DEFAULT_LEDGER_KEEP_MB;
+    }
+}
+function write(run, project, event, where) {
+    let writer = run.writers.get(project);
+    if (writer === undefined) {
+        writer = openWriter(run, project);
+        run.writers.set(project, writer);
+    }
+    seq += 1;
+    const entry = { v: 1, ts: new Date().toISOString(), seq, run: run.id, ...where, ...masked(event) };
+    tell(entry, project);
+    if (writer.broken || writer.file === undefined)
+        return;
+    try {
+        appendFileSync(writer.file, `${JSON.stringify(entry)}\n`);
+    }
+    catch (error) {
+        writer.broken = true;
+        run.warn?.(`turri's ledger for ${project} cannot be written, and is not from now on: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/** The run's file in the project, begun with its run.started - or none, when the project keeps no ledger. */
+function openWriter(run, project) {
+    const keep = keepOf(project);
+    const dir = ledgerDir(project);
+    const identity = turriIdentity();
+    seq += 1;
+    const started = {
+        kind: "run.started",
+        mode: run.mode,
+        version: identity.version,
+        commit: identity.git_commit,
+        dirty: identity.git_dirty,
+        pid: process.pid,
+        platform: process.platform,
+        node: process.versions.node,
+    };
+    const entry = { v: 1, ts: new Date().toISOString(), seq, run: run.id, ...started };
+    // Heard whether it is written or not: a project that keeps no ledger is still a run a host shows.
+    tell(entry, project);
+    try {
+        if (existsSync(dir))
+            tidy(dir, keep * 1024 * 1024);
+        if (keep <= 0)
+            return { broken: false };
+        ensureInScratch(join(project, ".turri"), dir);
+        const stamp = new Date(run.started).toISOString().replace(/[:.]/g, "-");
+        const file = join(dir, `${stamp}-${run.id}-p${process.pid}.jsonl`);
+        writeFileSync(file, `${JSON.stringify(entry)}\n`, { flag: "a" });
+        return { file, broken: false };
+    }
+    catch (error) {
+        run.warn?.(`turri's ledger for ${project} cannot be written: ${error instanceof Error ? error.message : String(error)}`);
+        return { broken: true };
+    }
+}
+/** Every string an event carries, masked as the logs are. */
+function masked(value) {
+    if (typeof value === "string")
+        return maskSecrets(value);
+    if (Array.isArray(value))
+        return value.map((item) => masked(item));
+    if (value !== null && typeof value === "object")
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, masked(item)]));
+    return value;
+}
+/** A run file's process, from its name: `<stamp>-<run>-p<pid>.jsonl`. */
+function pidOf(name) {
+    const match = /-p(\d+)\.jsonl(?:\.gz)?$/.exec(name);
+    return match !== null ? Number(match[1]) : undefined;
+}
+function alive(pid) {
+    if (pid === process.pid)
+        return true;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        // Not ours to signal, but there.
+        return error.code === "EPERM";
+    }
+}
+/**
+ * Keep the ledger folder within `keepBytes`: the files of runs that have ended gzipped, then the oldest pruned until
+ * the rest fit. A run still going - this one, or another turri's in the same project - is never touched.
+ */
+export function tidy(dir, keepBytes) {
+    const files = () => readdirSync(dir).filter((name) => /\.jsonl(?:\.gz)?$/.test(name)).sort();
+    const live = (name) => {
+        const pid = pidOf(name);
+        return name.endsWith(".jsonl") && (pid === undefined || alive(pid));
+    };
+    for (const name of files()) {
+        if (!name.endsWith(".jsonl") || live(name))
+            continue;
+        try {
+            const path = join(dir, name);
+            writeFileSync(`${path}.gz`, gzipSync(readFileSync(path)));
+            unlinkSync(path);
+        }
+        catch {
+            /* left as it is - pruned like any other */
+        }
+    }
+    const sized = files().map((name) => ({ name, size: sizeOf(join(dir, name)) }));
+    let total = sized.reduce((sum, file) => sum + file.size, 0);
+    for (const file of sized) {
+        if (total <= keepBytes)
+            break;
+        if (live(file.name))
+            continue;
+        try {
+            unlinkSync(join(dir, file.name));
+            total -= file.size;
+        }
+        catch {
+            /* kept */
+        }
+    }
+}
+function sizeOf(path) {
+    try {
+        return statSync(path).size;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * The project's ledger, oldest first - every run's, the gzipped ones too, as `query` narrows it. A line that does not
+ * parse, or a kind this turri does not know, is skipped: the ledger is read as it is, whatever wrote it.
+ */
+export function readLedger(project, query = {}) {
+    const dir = ledgerDir(project);
+    if (!existsSync(dir))
+        return [];
+    const since = query.since?.toISOString();
+    const entries = [];
+    for (const name of readdirSync(dir).filter((file) => /\.jsonl(?:\.gz)?$/.test(file)).sort()) {
+        let text;
+        try {
+            const raw = readFileSync(join(dir, name));
+            text = name.endsWith(".gz") ? gunzipSync(raw).toString("utf8") : raw.toString("utf8");
+        }
+        catch {
+            continue;
+        }
+        for (const line of text.split("\n")) {
+            if (line.trim() === "")
+                continue;
+            let entry;
+            try {
+                entry = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (entry.v !== 1 || typeof entry.kind !== "string")
+                continue;
+            if (query.run !== undefined && entry.run !== query.run)
+                continue;
+            if (query.job !== undefined && (entry.job === undefined || !entry.job.startsWith(query.job)))
+                continue;
+            if (query.kinds !== undefined && !query.kinds.includes(entry.kind))
+                continue;
+            if (since !== undefined && entry.ts < since)
+                continue;
+            entries.push(entry);
+        }
+    }
+    return entries;
+}

package/dist/regenerate/lineage.js

@@ -3,6 +3,7 @@ import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } fr
 import { basename, dirname, join } from "node:path";
 import { reportActivity } from "./activity.js";
 import { historyError } from "./environment-error.js";
+import { firstLine, record } from "./ledger.js";
 import { projectRootOf } from "./paths.js";
 /**
  * Version history for each module's generated code and tests.
@@ -84,7 +85,7 @@ function ensureHistory(moduleDir) {
  */
 export function recordHistory(dir, subject, body) {
     try {
-        return commitAll(dir, subject, body).commit;
+        return recorded(dir, subject, commitAll(dir, subject, body), false).commit;
     }
     catch {
         return undefined;
@@ -105,10 +106,24 @@ export function landWork(dir, subject, body) {
     catch (error) {
         made = { failed: error instanceof Error ? error.message : String(error) };
     }
+    recorded(dir, subject, made, true);
     if (made.failed !== undefined)
         throw historyError(moduleDir, made.failed);
     return made.commit;
 }
+/** A commit made or failed, in the ledger - nothing for a step that changed nothing. */
+function recorded(dir, subject, made, landing) {
+    const place = placeOf(moduleDirOf(dir));
+    if (made.failed !== undefined)
+        record({ kind: "history.failed", subject: firstLine(subject, 200), said: firstLine(made.failed, 400), landing }, place);
+    else if (made.commit !== undefined)
+        record({ kind: "history.committed", subject: firstLine(subject, 200), commit: made.commit }, place);
+    return made;
+}
+/** Where a module's history is, for the ledger: its project and its name. */
+function placeOf(moduleDir) {
+    return { project: projectRootOf(moduleDir), module: basename(moduleDir) };
+}
 /** Commit everything the step changed in the module `dir` belongs to: the commit, nothing when nothing changed, or why git failed. */
 function commitAll(dir, subject, body) {
     const moduleDir = moduleDirOf(dir);
@@ -191,6 +206,7 @@ export function resetToLastCommit(dir) {
             return [];
         git(moduleDir, ["reset", "-q", "--hard", "HEAD"]);
         git(moduleDir, ["clean", "-q", "-fd"]);
+        record({ kind: "history.reset", undone: changed.length, paths: changed.slice(0, 20) }, placeOf(moduleDir));
         return changed;
     }
     catch {
@@ -270,6 +286,7 @@ export function abandonWork(start, moduleName, why) {
             git(moduleDir, ["reset", "-q", "--hard", commit]);
             git(moduleDir, ["clean", "-q", "-fd"]);
             cleanTestsBuild(moduleDir);
+            record({ kind: "history.rolledBack", why: firstLine(why, 300) }, placeOf(moduleDir));
             reportActivity(`${moduleName}: ${why} - ${basename(moduleDir)} is back where the work started`);
         }
         catch {

package/dist/regenerate/loop.js

@@ -6,13 +6,14 @@ import { ACCEPTANCE_TESTS, FUNCTIONAL_REQUIREMENTS, REQUIRED_FUNCTIONAL_SPECS, T
 import { reportActivity, reportStage } from "./activity.js";
 import { llmChunkAgents, MAX_LINES_PER_JOB, MAX_SPECS_PER_JOB, planChunks, stepsOf } from "./chunk-plan.js";
 import { commitNotes, landWork, recordHistory, resetToLastCommit } from "./lineage.js";
+import { firstLine, record } from "./ledger.js";
 import { NOTES_FILE, recordPulse } from "./notes.js";
 import { createJobRegistry, formatDuration } from "./jobs.js";
 import { moduleLanes } from "./lanes.js";
 import { adoptDigests, chainTree, codeTree, conformanceTarget, marksRegenerateAgain, REGENERATE_AGAIN, inheritedRecord, notBuilt, readRecord, RECORD_FILE, withResourceDigests, writeCodeRecord, writeTestsRecord, } from "./records.js";
 import { describeSpecDiffConformance, renderSpecDiffConformance } from "./conform.js";
 import { conformanceDirFor } from "./conformance.js";
-import { modulesRoot } from "./paths.js";
+import { modulesRoot, projectRootOf } from "./paths.js";
 import { budgetFor, choosingWhen, configForSpec, conformanceSwitchedOn, stackForModule, stackPinned, withStack } from "../config.js";
 import { describeSpecChange } from "./prompt.js";
 import { resolveTemplateDirs } from "./paths.js";
@@ -191,6 +192,11 @@ export function createWorkLoop(options) {
     // One tick at a time: each reads the records and the spec, and decides.
     let ticking = Promise.resolve();
     const tipEntry = (state) => tipOf(state.chain);
+    /** Where what the loop decides for a module is recorded: its tip's project, the module and the pulse it is about. */
+    const loopPlace = (state, job) => {
+        const tip = tipEntry(state);
+        return { project: projectRootOf(tip.buildDir), module: tip.moduleName, job };
+    };
     /** `work` with the codebase's stack chosen - the one it was asked for with - when it has one pinned. */
     const inStack = (state, work) => (state.stack !== undefined ? withStack(state.stack.name, work) : work());
     const keyOf = (spec) => serializeTree(codeTree(spec.tree));
@@ -681,6 +687,7 @@ export function createWorkLoop(options) {
                     /* a spec that does not parse halts it all the same */
                 }
                 state.halted = { why: `${why} - nothing more is built on it until its conformance tests pass`, specKey: key, pulse: pulseOf(running), ...(settled?.status === "stopped" ? {} : causeOf(settled)) };
+                record({ kind: "loop.halted", why: firstLine(state.halted.why, 300), track: "conformance" }, loopPlace(state, running.jobId));
             }
         }
         else if (running !== undefined && !landed) {
@@ -700,6 +707,7 @@ export function createWorkLoop(options) {
                 }
                 const why = settled?.status === "stopped" ? `pulse ${running.jobId} was stopped` : `pulse ${running.jobId} ("${running.planned.title}") did not land`;
                 state.halted = { why: `${why} - it runs again once the spec changes, or the module is asked for again`, specKey: key, pulse: pulseOf(running), ...(settled?.status === "stopped" ? {} : causeOf(settled)) };
+                record({ kind: "loop.halted", why: firstLine(state.halted.why, 300), track: "code" }, loopPlace(state, running.jobId));
             }
         }
         else {
@@ -866,6 +874,7 @@ export function createWorkLoop(options) {
                 else {
                     state.running.stopping = true;
                     state.why = `pulse ${state.running.jobId} was stopped: ${why}, which it was regenerating from`;
+                    record({ kind: "loop.stopped", why: firstLine(why, 300) }, loopPlace(state, state.running.jobId));
                     reportActivity(`  ${tip.moduleName}: ${state.why}`);
                     options.registry.stop(state.running.jobId, `Stopped by turri, not by you: ${why}, which it was regenerating from. What it had done is rolled back, and the spec as it is now is regenerated instead. To have a running pulse finish first and the change regenerated on top of it, set allow-to-stop-jobs: false in config.turri.yaml.`);
                     return;

package/dist/regenerate/pulse-files.d.ts

@@ -0,0 +1,14 @@
+/** A file the running pulse wrote for a person to read - removed as it ends, unless in debug mode. Outside a pulse, nothing. */
+export declare function pulseWrote(file: string, job?: string | undefined): void;
+/**
+ * A pulse has ended. Unless the project is in debug mode, what it wrote for a person goes - its files, and its module's
+ * temporary folder - and so do the dependencies installed in the modules below its own in its chain. `lanes` are the
+ * pulse's (`plain_modules/<module>` of its whole chain), still held: no other pulse works in them. Returns whether
+ * everything was kept.
+ */
+export declare function pulseEnded(options: {
+    job: string;
+    project: string;
+    module?: string;
+    lanes: string[];
+}): boolean;

package/dist/regenerate/pulse-files.js

@@ -0,0 +1,63 @@
+import { existsSync, rmSync } from "node:fs";
+import { basename, join } from "node:path";
+import { debugMode } from "../config.js";
+import { currentJob } from "./activity.js";
+import { modulesScratchDir } from "./paths.js";
+/**
+ * What a pulse writes only for a person debugging turri, and when it goes.
+ *
+ * A pulse writes its own log, every one of its agents' whole logs, the testing scripts' and services' full outputs and
+ * its agents' temporary files. Nothing of turri reads them once the pulse is over: while it runs, its agents read their
+ * outputs (`read_output`, `service_logs`) and the diagnosis of a failure reads the logs - so they are written as before,
+ * and removed as it ends. In debug mode (`debug: true`, TURRI_DEBUG, `--debug`) they are kept, as they always were.
+ *
+ * So are the dependencies installed in the modules below a pulse's own in its chain: the chain is built in its tip, and
+ * what was installed in the codebases it left behind is only installed again - from the package cache - if one of them
+ * is ever built on again. The testing scripts install what they run with themselves.
+ */
+/** The files each pulse wrote for a person to read, by its id. */
+const written = new Map();
+/** A file the running pulse wrote for a person to read - removed as it ends, unless in debug mode. Outside a pulse, nothing. */
+export function pulseWrote(file, job = currentJob()?.id) {
+    if (job === undefined)
+        return;
+    const files = written.get(job) ?? new Set();
+    files.add(file);
+    written.set(job, files);
+}
+/** Where a codebase's dependencies are installed: what a module its chain has left behind keeps no longer. */
+const INSTALLED = ["node_modules", ".venv", "venv"];
+/**
+ * A pulse has ended. Unless the project is in debug mode, what it wrote for a person goes - its files, and its module's
+ * temporary folder - and so do the dependencies installed in the modules below its own in its chain. `lanes` are the
+ * pulse's (`plain_modules/<module>` of its whole chain), still held: no other pulse works in them. Returns whether
+ * everything was kept.
+ */
+export function pulseEnded(options) {
+    const files = written.get(options.job) ?? new Set();
+    written.delete(options.job);
+    if (debugMode(options.project))
+        return true;
+    const gone = (path) => {
+        try {
+            rmSync(path, { recursive: true, force: true });
+        }
+        catch {
+            /* what cannot be removed stays: never a reason for the pulse to fail */
+        }
+    };
+    for (const file of files)
+        gone(file);
+    for (const lane of options.lanes) {
+        // A codebase of the chain: its folder holds `code` - a lane may also be a spec file, or a build folder.
+        if (!existsSync(join(lane, "code")))
+            continue;
+        const name = basename(lane);
+        if (name === options.module)
+            gone(join(modulesScratchDir(lane), "tmp", name));
+        else
+            for (const installed of INSTALLED)
+                gone(join(lane, "code", installed));
+    }
+    return false;
+}

package/dist/regenerate/regenerate.js

@@ -12,6 +12,7 @@ import { codebaseMap, diffFiles, digestFiles, wroteNothing } from "./codebase.js
 import { confinedTools } from "./confine.js";
 import { buildSpecDiffPrompt, describeSpecChange, reviewedSpec, sectionModules } from "./prompt.js";
 import { abandonWork, landWork, startWork } from "./lineage.js";
+import { healing, record, signatureHash } from "./ledger.js";
 import { createWorkLedger, SUBMIT_WORK_NOTE } from "./submit-work.js";
 import { CODER_COMPACTION } from "./compaction.js";
 import { gapMark, gapsSince, NOTES_TURN, notesForSession, passedOutcome, recordNote, withNotes } from "./notes.js";
@@ -440,7 +441,7 @@ export async function renderSpecDiff(options) {
                             : timedOut && seen < STUCK_ROUNDS
                                 ? `the unit testing script did not finish in ${Math.round(verdict.run.timeoutMs / 1000)}s - a debugger works out whether something hangs`
                                 : `the same failure ${seen} times - a debugger looks at it with fresh eyes`);
-                        const found = await debugFailure({
+                        const found = await healing("debugger", () => debugFailure({
                             buildDir,
                             failure: verdict.run.output,
                             times,
@@ -450,7 +451,7 @@ export async function renderSpecDiff(options) {
                             label: `${moduleName} spec change`,
                             ...(debuggerModel !== undefined ? { model: debuggerModel } : {}),
                             onDelta: options.onDelta,
-                        }).catch(() => undefined);
+                        }), (finding) => finding?.rootCause);
                         // 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`);
@@ -477,6 +478,7 @@ export async function renderSpecDiff(options) {
                             ].join("\n");
                         }
                     }
+                    record({ kind: "gate.round", gate: "unit tests", round: followUp + 1, of: MAX_FOLLOW_UPS, ...(key !== undefined ? { signature: signatureHash(key) } : {}) });
                     stage(`${verdict.staticOnly ? "static checks" : "unit tests"} not passing - fixing (round ${followUp + 1} of ${MAX_FOLLOW_UPS})`);
                     response = await ask(executor, prompt, options.onDelta);
                     continue;

package/dist/regenerate/regression.js

@@ -7,6 +7,7 @@ import { confinedTools } from "./confine.js";
 import { projectRootOf } from "./paths.js";
 import { buildRegressionFixPrompt, sectionModules } from "./prompt.js";
 import { abandonWork, landWork, markWork } from "./lineage.js";
+import { record } from "./ledger.js";
 import { missingToolchainError } from "./environment-error.js";
 import { workspaceBlock } from "./workspace.js";
 import { CODER_COMPACTION } from "./compaction.js";
@@ -161,6 +162,7 @@ export async function ensureRegressionPasses(input) {
         if (round === maxRounds)
             break;
         input.onEvent?.({ type: "repair", frids: input.frids });
+        record({ kind: "gate.round", gate: "regression", round: round + 1, of: maxRounds });
         reportStage(`${unitOf(input.moduleName)}: an earlier functionality broke - repairing (round ${round + 1} of ${maxRounds})`);
         repairs.push(await repairRegression({
             testsDirs: dirs,

package/dist/regenerate/services.js

@@ -8,6 +8,7 @@ import { agentShell } from "./agent-shell.js";
 import { maskSecrets } from "./masking.js";
 import { modulesScratchDir } from "./paths.js";
 import { isRunning, startInBackground, stopGroup } from "./shell.js";
+import { pulseWrote } from "./pulse-files.js";
 /**
  * What an agent starts and keeps running while it works - a server, a worker - to try the software as someone would,
  * from outside: with curl, or what the stack's own client is. Whatever the stack: the agent gives the command that
@@ -83,6 +84,8 @@ export function createServiceTools(options) {
                 return say(`Not started: ${checked.reason}`);
             mkdirSync(logsDir, { recursive: true });
             const log = join(logsDir, `${name.replace(/[^\w.-]+/g, "_")}-${randomUUID().slice(0, 8)}.log`);
+            // Read through service_logs while the pulse runs, and by no one after it (pulse-files.ts).
+            pulseWrote(log);
             const limit = Math.min(Math.max(seconds ?? DEFAULT_READY_SECONDS, 1), MAX_READY_SECONDS);
             // Started and waited on under the audit: what it writes while it comes up, outside its role, is put back.
             const { value: outcome, note } = await fenced.audited(async () => {

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

@@ -17,6 +17,8 @@ import type { TranscriptStyle } from "./transcript-view.ts";
 export interface SidePanelOptions {
     /** Every job, oldest first. */
     jobs: () => Job[];
+    /** Earlier sessions' pulses, from the ledger: listed under this session's, in a section of their own. */
+    earlier?: () => Job[];
     /** The regeneration's pages. Not given: the pulse list alone. */
     map?: () => MarkedPage[];
     /** Rows the panel may use. */

package/dist/regenerate/side-panel.js

@@ -1,5 +1,5 @@
 import { Key, matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
-import { createJobsTreeState, jobsTreeLines, jobsTreeRows, keepCursorInView, scrollTree, treeKey } from "./jobs-tree.js";
+import { createJobsTreeState, jobsTreeLines, jobsTreeRows, keepCursorInView, scrollTree, sectionOf, treeKey } from "./jobs-tree.js";
 import { columnHeadings, createSpecMapState, DISCUSS_KEY, legendLines, minimap, shownPage, specMapHeader, specMapLines, switchTab, tabBar } from "./spec-map-view.js";
 export function createSidePanel(options) {
     const style = options.style;
@@ -71,7 +71,8 @@ export function createSidePanel(options) {
         const bodyHeight = Math.max(3, rows - top.length - 2);
         lastBodyHeight = bodyHeight;
         // The tree scrolls to keep the cursor in sight, and only that far.
-        const tree_ = jobsTreeLines(options.jobs(), tree, width, style);
+        // This session's pulses, and under them the earlier sessions' the ledger has.
+        const tree_ = jobsTreeLines([...options.jobs(), ...(options.earlier?.() ?? [])], tree, width, style);
         drawnTree = { rows: tree_.rows, rowStarts: tree_.rowStarts, lineCount: tree_.lines.length };
         keepCursorInView(tree, tree_.rowStarts, tree_.lines.length, bodyHeight);
         const visible = tree_.lines.slice(tree.top, tree.top + bodyHeight);
@@ -132,7 +133,7 @@ export function createSidePanel(options) {
         const job = jobs.find((entry) => entry.id === id);
         if (job === undefined)
             return;
-        const section = job.status === "running" ? "running" : job.status === "queued" ? "queued" : "finished";
+        const section = sectionOf(job);
         tree.open[section] = true;
         const at = jobsTreeRows(jobs, tree).findIndex((entry) => entry.kind === "job" && entry.job.id === id);
         if (at !== -1)