@turri-dev/cli 0.1.7 → 0.1.8-next.b03162b

package/dist/regenerate/lineage.js

@@ -2,6 +2,8 @@ import { spawnSync } from "node:child_process";
 import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 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.
@@ -15,7 +17,8 @@ import { projectRootOf } from "./paths.js";
  * A commit is made after every step that changes the module - a render, a regeneration, a
  * conformance run, a regression repair, a spec change, a start from the module below - with
  * a message saying what it was. History is a record of the work, never a gate on it: a git
- * failure is swallowed, not raised.
+ * failure is swallowed, not raised - except landing work (`landWork`), whose commit the next
+ * start would otherwise undo.
  */
 export const HISTORY_DIR = ".plaingit";
 const AUTHOR = ["-c", "user.name=turri", "-c", "user.email=turri@localhost", "-c", "commit.gpgsign=false"];
@@ -39,7 +42,10 @@ const EXCLUDED = [
     ".DS_Store",
 ];
 function git(moduleDir, args, input) {
-    return spawnSync("git", [...AUTHOR, "--git-dir", join(moduleDir, HISTORY_DIR), "--work-tree", moduleDir, ...args], {
+    const gitDir = join(moduleDir, HISTORY_DIR);
+    // The history is turri's, not the person's: hooks their git config names - gitleaks, husky - would refuse some of its
+    // commits, and the next start would put back what landed. Its own hooks folder holds only git's samples.
+    return spawnSync("git", [...AUTHOR, "-c", `core.hooksPath=${join(gitDir, "hooks")}`, "--git-dir", gitDir, "--work-tree", moduleDir, ...args], {
         cwd: moduleDir,
         encoding: "utf8",
         input,
@@ -79,21 +85,65 @@ function ensureHistory(moduleDir) {
  */
 export function recordHistory(dir, subject, body) {
     try {
-        const moduleDir = moduleDirOf(dir);
-        if (!existsSync(moduleDir) || !ensureHistory(moduleDir))
-            return undefined;
-        git(moduleDir, ["add", "-A"]);
-        if (git(moduleDir, ["diff", "--cached", "--quiet"]).status === 0)
-            return undefined;
-        const message = body ? `${subject}\n\n${body.trim()}\n` : subject;
-        if (git(moduleDir, ["commit", "-q", "-F", "-"], message).status !== 0)
-            return undefined;
-        return head(dir);
+        return recorded(dir, subject, commitAll(dir, subject, body), false).commit;
     }
     catch {
         return undefined;
     }
 }
+/**
+ * Commit work that landed - the code or tests a pulse passed, with the record of what they are built from. Unlike any
+ * other step's, this commit is not only a record: the next unit of work puts the module back to its last commit, and
+ * would undo what landed with it. So a commit that cannot be made is raised, as the environment's, with what git said -
+ * the work left in place, uncommitted. Nothing changed, nothing is committed. Returns the commit, if any.
+ */
+export function landWork(dir, subject, body) {
+    const moduleDir = moduleDirOf(dir);
+    let made;
+    try {
+        made = commitAll(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);
+    if (!existsSync(moduleDir))
+        return {};
+    if (!ensureHistory(moduleDir))
+        return { failed: `git could not make the module's history in ${join(moduleDir, HISTORY_DIR)}` };
+    const failed = (result) => (result.error?.message ?? `${result.stderr}${result.stdout}`.trim()) || `git exited ${result.status}`;
+    const added = git(moduleDir, ["add", "-A"]);
+    if (added.status !== 0)
+        return { failed: failed(added) };
+    if (git(moduleDir, ["diff", "--cached", "--quiet"]).status === 0)
+        return {};
+    const message = body ? `${subject}\n\n${body.trim()}\n` : subject;
+    const committed = git(moduleDir, ["commit", "-q", "-F", "-"], message);
+    if (committed.status !== 0)
+        return { failed: failed(committed) };
+    const commit = head(dir);
+    return commit !== undefined ? { commit } : {};
+}
 /**
  * The notes the harness writes once a pulse has ended, committed - or the next pulse, putting the module back to its last
  * commit, would take them away. Into the pulse's own commit when it landed one - `landedSince` (ms), when it started - so
@@ -156,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 {
@@ -235,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.d.ts

@@ -385,6 +385,12 @@ export declare function isUpToDate(status: ModuleStatus): boolean;
 export declare function describeModules(statuses: ModuleStatus[], options?: {
     for?: "chat" | "command line";
 }): string;
+/**
+ * A module's first pulse when it builds one functional spec - the project set up and the smallest thing that runs: it lands on its
+ * unit tests alone, with no review. A reviewer, and an arbiter after it, on a scaffold is time spent before anything can
+ * be tried.
+ */
+export declare function skipsReview(cases: JobCases): boolean;
 /** How a code pulse went, for its line in the notes: the rounds it took, its test runs, what the debugger found. */
 export declare function codeStory(result: {
     attempts?: number;

package/dist/regenerate/loop.js

@@ -5,14 +5,15 @@ import { STDLIB_ROOT } from "../plain/stdlib.js";
 import { ACCEPTANCE_TESTS, FUNCTIONAL_REQUIREMENTS, REQUIRED_FUNCTIONAL_SPECS, TEST_REQUIREMENTS } from "../plain/spec.js";
 import { reportActivity, reportStage } from "./activity.js";
 import { llmChunkAgents, MAX_LINES_PER_JOB, MAX_SPECS_PER_JOB, planChunks, stepsOf } from "./chunk-plan.js";
-import { commitNotes, recordHistory, resetToLastCommit } from "./lineage.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, REGENERATE_AGAIN, inheritedRecord, notBuilt, readRecord, RECORD_FILE, withResourceDigests, writeCodeRecord, writeTestsRecord, } from "./records.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";
@@ -153,7 +154,8 @@ export function functionalityCompletion(plainFile) {
         codebase.forEach((entry, index) => {
             const count = counts[index];
             const completed = entry.frids.filter((frid) => !touched.has(`${entry.moduleName}:${frid}`));
-            const tested = (readRecord(conformanceDirFor(entry.moduleName, modulesRoot(projectDirOf(entry.plainFile))))?.[FUNCTIONAL_REQUIREMENTS] ?? []).filter((item) => item.frid !== undefined && item.markdown.trim() === specText(entry.moduleName, item.frid));
+            // Tests marked to regenerate again were written against code since replaced: not conformance tested until rewritten.
+            const tested = (readRecord(conformanceDirFor(entry.moduleName, modulesRoot(projectDirOf(entry.plainFile))))?.[FUNCTIONAL_REQUIREMENTS] ?? []).filter((item) => item.frid !== undefined && !marksRegenerateAgain(item) && item.markdown.trim() === specText(entry.moduleName, item.frid));
             count.completed = completed.length;
             count.tested = completed.filter((frid) => tested.some((item) => item.frid === frid));
             count.conformanceTested = count.tested.length;
@@ -190,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));
@@ -521,7 +528,7 @@ export function createWorkLoop(options) {
             run: async (onDelta) => {
                 // The guardrail: a conformance job tests only code that is built - the code record, read as the job starts, has every functional spec it tests as it tests it.
                 if (conformance) {
-                    const testing = [...planned.cases.add, ...planned.cases.patch].map((touched) => touched.frid);
+                    const testing = [...planned.cases.add, ...planned.cases.patch, ...planned.cases.again].map((touched) => touched.frid);
                     const missing = notBuilt(readRecord(tip.buildDir), planned.step.tree, testing);
                     if (missing.length > 0) {
                         const record = relative(options.cwd, join(tip.buildDir, RECORD_FILE));
@@ -680,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) {
@@ -699,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 {
@@ -865,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;
@@ -1109,6 +1119,17 @@ export function createWorkLoop(options) {
                     found.add(frid);
                 const marked = items.map((item, index) => (frids.includes(named(item, index)) ? { ...item, [REGENERATE_AGAIN]: true } : item));
                 writeCodeRecord(tip.buildDir, { ...record, [section]: marked });
+                // Its conformance tests were written against the code being replaced: marked with it, they are written again -
+                // checked against the new code, and rewritten where they relied on what the old code chose - once it lands.
+                if (section === FUNCTIONAL_REQUIREMENTS) {
+                    const testsDir = conformanceDirFor(tip.moduleName, modulesRoot(projectDirOf(tip.plainFile)));
+                    const tests = readRecord(testsDir);
+                    const tested = tests?.[FUNCTIONAL_REQUIREMENTS] ?? [];
+                    if (tested.some((item) => item.frid !== undefined && taken.includes(item.frid))) {
+                        const again = tested.map((item) => (item.frid !== undefined && taken.includes(item.frid) ? { ...item, [REGENERATE_AGAIN]: true } : item));
+                        writeTestsRecord(testsDir, { ...tests, [FUNCTIONAL_REQUIREMENTS]: again });
+                    }
+                }
                 recordHistory(tip.buildDir, `${module} functional spec${taken.length === 1 ? "" : "s"} ${taken.join(", ")} to regenerate again`);
             }
             const missing = frids.filter((frid) => !found.has(frid));
@@ -1596,10 +1617,18 @@ const defaultConformanceRunner = async (job, onDelta) => {
     });
     if (result.passed) {
         writeTestsRecord(result.conformanceDir, job.planned.step.tree);
-        recordHistory(job.buildDir, `conformance tests: ${job.planned.title}`);
+        landWork(job.buildDir, `conformance tests: ${job.planned.title}`);
     }
     return { landed: result.passed, report: describeSpecDiffConformance(result), ...(result.specGaps !== undefined ? { specGaps: result.specGaps } : {}) };
 };
+/**
+ * A module's first pulse when it builds one functional spec - the project set up and the smallest thing that runs: it lands on its
+ * unit tests alone, with no review. A reviewer, and an arbiter after it, on a scaffold is time spent before anything can
+ * be tried.
+ */
+export function skipsReview(cases) {
+    return cases.fresh && cases.add.length <= 1 && cases.patch.length === 0 && cases.again.length === 0 && cases.delete.length === 0;
+}
 /** A job as a spec diff render, landed on its unit tests: conformance is a track of its own. */
 const defaultRunner = async (job, onDelta) => {
     const result = await renderSpecDiff({
@@ -1609,6 +1638,7 @@ const defaultRunner = async (job, onDelta) => {
         applied: "already applied",
         spec: job.spec,
         cases: job.planned.cases,
+        ...(skipsReview(job.planned.cases) ? { unitReview: false } : {}),
         ...(job.model !== undefined ? { model: job.model } : {}),
         ...(job.steering !== undefined ? { steering: job.steering } : {}),
         onDelta,

package/dist/regenerate/records.d.ts

@@ -63,9 +63,11 @@ export type Chosen = (frid: string) => boolean;
  * definitions and implementation reqs, with the test reqs as the spec has them now.
  *
  * Conformance follows the code, never goes ahead of it: a functional spec whose code is not caught up
- * with the spec - its text in the code record is not the spec's, or the code record does not have it at
- * all, as while it is regenerated again - stays as the tests record has it, until the code lands. Its tests are
- * taken out only once the spec and the code have both dropped it.
+ * with the spec - its text in the code record is not the spec's, the code record does not have it at
+ * all, or has it marked to regenerate again - stays as the tests record has it, until the code lands. Its tests are
+ * taken out only once the spec and the code have both dropped it. Tests marked to regenerate again with their code
+ * (`regenerateAgain`) differ from the target once the code lands: written against the code it replaced, they are
+ * conformance work again, though the spec's text never changed.
  */
 export declare function conformanceTarget(code: MarshalledPlainSource | null, tests: MarshalledPlainSource | null, spec: MarshalledPlainSource, chosen?: Chosen): MarshalledPlainSource;
 /**

package/dist/regenerate/records.js

@@ -155,9 +155,11 @@ export function inheritedRecord(source, sourceModule) {
  * definitions and implementation reqs, with the test reqs as the spec has them now.
  *
  * Conformance follows the code, never goes ahead of it: a functional spec whose code is not caught up
- * with the spec - its text in the code record is not the spec's, or the code record does not have it at
- * all, as while it is regenerated again - stays as the tests record has it, until the code lands. Its tests are
- * taken out only once the spec and the code have both dropped it.
+ * with the spec - its text in the code record is not the spec's, the code record does not have it at
+ * all, or has it marked to regenerate again - stays as the tests record has it, until the code lands. Its tests are
+ * taken out only once the spec and the code have both dropped it. Tests marked to regenerate again with their code
+ * (`regenerateAgain`) differ from the target once the code lands: written against the code it replaced, they are
+ * conformance work again, though the spec's text never changed.
  */
 export function conformanceTarget(code, tests, spec, chosen = () => true) {
     const built = itemsOf(code, FUNCTIONAL_REQUIREMENTS);
@@ -168,7 +170,7 @@ export function conformanceTarget(code, tests, spec, chosen = () => true) {
     for (let index = 0; index < Math.max(built.length, now.length); index += 1) {
         const frid = String(index + 1);
         const current = now[index];
-        if (current !== undefined && built[index]?.markdown.trim() === current.markdown.trim()) {
+        if (current !== undefined && built[index]?.markdown.trim() === current.markdown.trim() && !marksRegenerateAgain(built[index])) {
             if (chosen(frid))
                 specs.push({ ...current, frid });
             continue;

package/dist/regenerate/regenerate.js

@@ -11,7 +11,8 @@ import { debugFailure, diagnosisText } from "./debugger.js";
 import { codebaseMap, diffFiles, digestFiles, wroteNothing } from "./codebase.js";
 import { confinedTools } from "./confine.js";
 import { buildSpecDiffPrompt, describeSpecChange, reviewedSpec, sectionModules } from "./prompt.js";
-import { abandonWork, recordHistory, startWork } from "./lineage.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";
@@ -193,7 +194,7 @@ export async function renderSpecDiff(options) {
     if (builtBefore !== null && sameSpec(builtBefore, tree) && !dryRun) {
         stage("the specs were only restructured - nothing to render; recording the spec as it is now laid out");
         writeCodeRecord(tip.buildDir, tree);
-        recordHistory(tip.buildDir, `spec restructured: ${summarizeDiff(options.diff)}`, options.diff);
+        landWork(tip.buildDir, `spec restructured: ${summarizeDiff(options.diff)}`, options.diff);
         return {
             moduleName,
             buildDir: tip.buildDir,
@@ -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;
@@ -554,7 +556,7 @@ export async function renderSpecDiff(options) {
         stage("recording what the code is built from, and committing it");
         // Steered, it is built from the spec as it was steered to - the record the loop moved with it.
         writeCodeRecord(buildDir, steering?.target ?? tree);
-        recordHistory(buildDir, `spec diff: ${summarizeDiff(options.diff)}`, options.diff);
+        landWork(buildDir, `spec diff: ${summarizeDiff(options.diff)}`, options.diff);
     };
     if (!unitPassed) {
         stage(unitReviewStopped ? "the unit tests pass but still leave the change untested - undoing the change" : "unit tests NOT passing - undoing the change");

package/dist/regenerate/regression.js

@@ -6,7 +6,8 @@ import { reportActivity, reportStage, unitOf } from "./activity.js";
 import { confinedTools } from "./confine.js";
 import { projectRootOf } from "./paths.js";
 import { buildRegressionFixPrompt, sectionModules } from "./prompt.js";
-import { abandonWork, markWork, recordHistory } from "./lineage.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";
@@ -154,13 +155,14 @@ export async function ensureRegressionPasses(input) {
         if (passing) {
             reportStage(`${unitOf(input.moduleName)}: the whole conformance suite passes, and the unit tests with it${repairs.length > 0 ? ` after ${repairs.length} repair${repairs.length === 1 ? "" : "s"}` : ""}`);
             if (repairs.length > 0) {
-                recordHistory(input.buildDir, `regression ${input.moduleName} (pass after ${repairs.length} repair(s))`);
+                landWork(input.buildDir, `regression ${input.moduleName} (pass after ${repairs.length} repair(s))`);
             }
             return { passed: true, runs, repairs, command };
         }
         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/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)

package/dist/regenerate/spec-map.js

@@ -8,7 +8,7 @@ import { conformanceDirFor } from "./conformance.js";
 import { chainSpec } from "./loop.js";
 import { modulesRoot, projectDirOf } from "./paths.js";
 import { HISTORY_DIR } from "./lineage.js";
-import { codeTree, readRecord, RECORD_FILE } from "./records.js";
+import { codeTree, marksRegenerateAgain, readRecord, RECORD_FILE } from "./records.js";
 import { specFilesOf } from "./regenerate.js";
 import { builtTips, resolveRequiresChain } from "./requires.js";
 import { changesBetween, layoutOf, serializeTree } from "./spec-steps.js";
@@ -115,17 +115,20 @@ export function pageItems(input) {
         }
     }
     // Conformance tests: of the functional specs, those the tests record has as they read now, as they read before, or taken out.
-    const tested = new Set(itemsOf(input.tested ?? null, FUNCTIONAL_REQUIREMENTS).map((item) => item.markdown.trim()));
+    // Tests marked to regenerate again were written against code since replaced: written for an earlier build, not now.
+    const testedItems = itemsOf(input.tested ?? null, FUNCTIONAL_REQUIREMENTS);
+    const tested = new Set(testedItems.filter((item) => !marksRegenerateAgain(item)).map((item) => item.markdown.trim()));
+    const replaced = new Set(testedItems.filter((item) => marksRegenerateAgain(item)).map((item) => item.markdown.trim()));
     for (const item of items) {
-        if (item.section !== FUNCTIONAL_REQUIREMENTS || tested.size === 0)
+        if (item.section !== FUNCTIONAL_REQUIREMENTS || testedItems.length === 0)
             continue;
         if (item.state === "removed") {
-            if (tested.has(item.text.trim()))
+            if (tested.has(item.text.trim()) || replaced.has(item.text.trim()))
                 item.tests = "removed";
         }
         else if (tested.has(item.text.trim()))
             item.tests = "now";
-        else if (item.was !== undefined && tested.has(item.was.trim()))
+        else if (replaced.has(item.text.trim()) || (item.was !== undefined && (tested.has(item.was.trim()) || replaced.has(item.was.trim()))))
             item.tests = "older";
     }
     return keyed(items);

package/dist/regenerate/test-scripts.js

@@ -4,6 +4,7 @@ import { accessSync, constants, copyFileSync, existsSync, mkdirSync, readdirSync
 import { basename, delimiter, dirname, join, resolve, sep } from "node:path";
 import { CONFIG_FILE, CONFIG_KEYS, projectConfigFile, readProjectConfig, stackConfigFile, stackConfigFileIn, stackOf, stacksOf } from "../config.js";
 import { reportActivity, reportLogNote, reportNote } from "./activity.js";
+import { record, signatureHash } from "./ledger.js";
 import { ensureInModulesScratch, modulesScratchDir } from "./paths.js";
 import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
@@ -361,7 +362,7 @@ async function runScript(cwd, script, args, logDir, options = {}) {
     const noted = withScriptLineNote(text, script);
     // Its failures, counts and end are what the agent is shown; the whole is kept, a read_output away.
     const log = keepTestOutput(logDir, basename(script), noted);
-    return {
+    const run = {
         command: shown(script),
         exitCode: timedOut === true ? 124 : exitCode,
         output: shownTestOutput(noted, log),
@@ -370,6 +371,16 @@ async function runScript(cwd, script, args, logDir, options = {}) {
         elapsedMs: Date.now() - started,
         ...(log !== undefined ? { log } : {}),
     };
+    record({
+        kind: "script.run",
+        script: basename(script),
+        exit: run.exitCode,
+        ms: run.elapsedMs,
+        timedOut: run.timedOut === true,
+        inPlace: options.named === undefined,
+        ...(run.exitCode !== 0 ? { signature: signatureHash(failureSignature(run)) } : {}),
+    });
+    return run;
 }
 /** What bash says when a line of the script itself cannot run: a command or file that is not there, or not runnable. */
 const OWN_LINE_FAILURE = /: (No such file or directory|command not found|Permission denied)$/;

package/dist/regenerate/unit-review.js

@@ -3,6 +3,7 @@ import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { ask, createExecutor } from "../pi.js";
 import { reportActivity } from "./activity.js";
+import { record } from "./ledger.js";
 import { diffFiles, digestFiles } from "./codebase.js";
 import { confinedTools } from "./confine.js";
 import { REVIEWER_CALLS, reviewKind } from "./conformance-agents.js";
@@ -288,6 +289,7 @@ async function reviewLoop(options, reviewer) {
         letGo = [];
         options.stage(`reviewing the code and its unit tests (review ${reviews + 1}): does the code do what the spec says, and does each test fail when that breaks`);
         const review = await reviewer.review(request);
+        record({ kind: "review.verdict", reviewer: "unit", review: reviews + 1, pass: review.pass, problems: review.pass ? 0 : review.problems.length });
         if (review.pass) {
             options.stage("the review has nothing left to improve in the code or its unit tests");
             return waived.length > 0 ? { passed: true, waived, reviews: reviews + 1 } : { passed: true, reviews: reviews + 1 };
@@ -316,6 +318,7 @@ async function reviewLoop(options, reviewer) {
             });
             // No ruling: the review stands, as it did before there was an arbiter.
             if (ruling !== undefined) {
+                record({ kind: "arbiter.ruling", upheld: ruling.upheld.length, dismissed: ruling.dismissed.length });
                 waived.push(...ruling.dismissed.map((entry) => entry.problem));
                 if (ruling.dismissed.length > 0)
                     recordNote(options.buildDir, "pitfalls", dismissedNote(ruling, "unit test"), `${options.label} unit tests`);

package/dist/run-report.d.ts

@@ -1,4 +1,4 @@
-import type { Job } from "./regenerate/jobs.ts";
+import { type Job } from "./regenerate/jobs.ts";
 /**
  * A headless run's report: one JSON file, `turri regenerate --report <file>`, saying what the run did - how it ended,
  * what it spent, which pulses landed, how many functional specs are completed - for a benchmark or CI to read rather

package/dist/run-report.js

@@ -2,6 +2,7 @@ import { mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, relative, resolve } from "node:path";
 import { turriIdentity } from "./environment.js";
 import { onModelEvent } from "./regenerate/activity.js";
+import { firstRegeneration } from "./regenerate/jobs.js";
 /**
  * A headless run's report: one JSON file, `turri regenerate --report <file>`, saying what the run did - how it ended,
  * what it spent, which pulses landed, how many functional specs are completed - for a benchmark or CI to read rather
@@ -177,7 +178,12 @@ export function startRunReport(options) {
             };
         });
         const ran = list.filter((pulse) => pulse.status !== "queued");
+        const first = firstRegeneration(jobs, startedAt);
+        const seconds = (ms) => (ms !== undefined ? Math.round(ms / 100) / 10 : null);
         return {
+            // The time to first regeneration - the first code pulse started - and to the first one landed, from the run's start.
+            first_started_seconds: seconds(first.started),
+            first_landed_seconds: seconds(first.landed),
             counts: {
                 total: ran.length,
                 landed: ran.filter((pulse) => pulse.landed).length,

package/dist/self-invocation.d.ts

@@ -20,6 +20,6 @@ export declare function selfInvocation(command: string): string | undefined;
  */
 export declare function askedForCommandLine(message: string): boolean;
 /** What the agent is told when the call is refused. */
-export declare function refusal(what: string): string;
+export declare function refusal(what: string, surface?: string): string;
 /** The instruction that goes into the conversation's system prompt. */
 export declare const TOOLS_NOT_CLI: string;

package/dist/self-invocation.js

@@ -88,12 +88,13 @@ export function askedForCommandLine(message) {
         /(^|\s)pi\s+-p\b/.test(text));
 }
 /** What the agent is told when the call is refused. */
-export function refusal(what) {
+export function refusal(what, surface) {
     const instead = what === "pi"
         ? "Do not start another agent: do the work here, with this conversation's tools."
         : `Use ${TOOL_FOR[what] ?? "the matching turri tool"} instead.`;
     return (`Not run: that starts turri${what === "pi" ? "'s agent" : ` ${what}`} again from the shell - a separate, headless ` +
-        "run outside this conversation, its jobs, the panel and /halt. " +
+        // In a host there is no panel: the person watches the pulses where its surface says.
+        (surface !== undefined ? "run outside this conversation and its pulses, where the person can neither watch it nor halt it. " : "run outside this conversation, its jobs, the panel and /halt. ") +
         `${instead} Run turri from the command line only when the user asks for that.`);
 }
 /** The instruction that goes into the conversation's system prompt. */

package/dist/skill-progress.d.ts

@@ -6,7 +6,7 @@
  *   brood       ✓ intent ━━━━ ⠋ stack ──── ○ testing ──── ○ product       phase 2 of 4
  *                 stack - the language, frameworks, storage and architecture
  *
- * The second line says what the phase it is in does: a phase's name alone - `groundwork` - says little to someone
+ * The second line says what the phase it is in does: a phase's name alone - `skeleton` - says little to someone
  * who has not read the skill.
  *
  * A skill of one phase, or none, has nothing to be partway through: its line is the spinner and its name alone.

package/dist/skill.d.ts

@@ -85,6 +85,11 @@ export interface Skill {
      * last answer is written with `write_spec_diff`, and changes the agent decides itself need no answer before them.
      */
     diffPerAnswer: string[];
+    /**
+     * Started only by the person, with its slash command - `/brood` - never by the model on its own
+     * (`metadata.command-only: true`): cultivate runs it only when the person has just typed its command.
+     */
+    commandOnly: boolean;
 }
 export declare function loadSkill(skillDir: string): Skill;
 export declare function readRubric(skill: Skill, review: {

package/dist/skill.js

@@ -131,6 +131,7 @@ export function loadSkill(skillDir) {
         paced: data.metadata?.paced !== false,
         questioning: capped,
         diffPerAnswer,
+        commandOnly: data.metadata?.["command-only"] === true,
     };
 }
 export function readRubric(skill, review) {

package/dist/skills.d.ts

@@ -28,3 +28,17 @@ export declare function discoverSkills(packageRoot: string, projectDir: string |
 export declare function catalogueLine(skill: FoundSkill): string;
 /** What is said under the list about the skills it leaves out. */
 export declare function leftOutNote(catalogue: SkillCatalogue): string;
+/**
+ * Which skills cultivate may start now. A skill marked command-only (`/brood`) waits for the person to type its command:
+ * the command lets it start once, and the run starting uses that up - the model cannot start it again later on its own.
+ */
+export declare function createCommandGate(): {
+    /** The person typed the skill's command. */
+    typed(name: string): void;
+    /** Whether cultivate may start it now. */
+    mayStart(skill: Pick<FoundSkill, "name" | "commandOnly">): boolean;
+    /** Its run started: the command is used up. */
+    started(name: string): void;
+};
+/** What cultivate says of a command-only skill the person did not start. */
+export declare function startedByCommandOnly(name: string): string;