@turri-dev/cli 0.1.26 → 0.1.27-next.763d091

package/dist/host.d.ts

@@ -25,7 +25,7 @@ export { conceptBeingTyped, findConcepts } from "./plain/concepts.ts";
 export { plainGraph, type PlainConceptNode, type PlainGraph, type PlainItemNode, type PlainLink, type PlainModuleNode, type PlainSection } from "./plain/graph.ts";
 export { isStack, STDLIB_KINDS, stdlibTemplates, type StdlibKind, type StdlibTemplate } from "./stdlib.ts";
 export { createWorkLoop, describeModules, functionalityCompletion, promptOf, type DriftReport, type ModuleStatus, type WorkLoop } from "./regenerate/loop.ts";
-export { createJobRegistry, defaultParallelJobs, type Job, type JobRegistry } from "./regenerate/jobs.ts";
+export { createJobRegistry, defaultParallelJobs, type Job, type JobRegistry, type PulseCases, type PulseSpec } from "./regenerate/jobs.ts";
 export { describeTurnIncident, onModelEvent, type TranscriptEntry } from "./regenerate/activity.ts";
 export { sweepOrphanedGroups } from "./regenerate/shell.ts";
 export { ledgerDir, onLedgerEvent, readLedger, type AgentRef, type LedgerEntry, type LedgerEvent, type LedgerKind, type LedgerQuery } from "./regenerate/ledger.ts";

package/dist/regenerate/cases.js

@@ -65,7 +65,7 @@ export function conformanceCasesBlock(cases) {
         lines.push(`- Changed - its text, its acceptance tests, or a concept it uses: ${named(cases.patch)}.`, "  Its conformance tests exist: rewrite them to what it says now. The tests of everything else stay as they are.");
     }
     if (cases.again.length > 0) {
-        lines.push(`- Regenerated again - its code was built anew, and its conformance tests were written against the code it replaced: ${named(cases.again)}.`, "  Its text did not change, but the code did. Run its tests against the new code. What they check that the", "  specification says stays checked: rewrite such a test only as the new code needs it reached. What they check", "  that the specification leaves open - a path, a field, a message, a format the old code chose and the", "  specification never names - is the new code's choice now: rewrite those checks to what the new code does,", "  or take them out. No test may hold the new code to what only the old code did. The tests of everything else", "  stay as they are.");
+        lines.push(`- Regenerated again - its code was built anew, and its conformance tests were written against the code it replaced: ${named(cases.again)}.`, "  Its text did not change, but the code did: write its tests again for the new code - that they still pass is", "  no sign they fit it. What they check that the specification says stays checked, as the new code is reached.", "  What they check that the specification leaves open - a path, a field, a message, a format the old code chose", "  and the specification never names - is the new code's choice now: rewrite those checks to what the new code", "  does, or take them out. No test may hold the new code to what only the old code did. A run that leaves every", "  test file labelled with it as it was is sent back. The tests of everything else stay as they are.");
     }
     if (cases.delete.length > 0)
         lines.push(`- Taken out - remove its conformance tests: ${named(cases.delete)}.`);

package/dist/regenerate/conformance.d.ts

@@ -109,6 +109,11 @@ export interface RenderConformanceTestsResult {
     };
     /** The tests were sent back to be written and labelled, and never were: what was missing the last time. */
     unlabelled?: string[];
+    /**
+     * Of the functional specs the job regenerates again, those whose tests this run wrote - a test file labelled with it
+     * added or changed. Only these have tests for the new code; the rest are still marked to regenerate again.
+     */
+    rewritten?: string[];
     /** The tests were optimised as far as REVIEW_ROUNDS reviews could take them: what the last one still suggested. */
     reviewWaived?: ReviewProblem[];
     /** The suite passed, but the tests never passed review: what the review last found. */
@@ -126,6 +131,8 @@ export interface RenderConformanceTestsResult {
  * and this refuses to start without one.
  */
 export declare function renderConformanceTests(options: RenderConformanceTestsOptions): Promise<RenderConformanceTestsResult>;
+/** Sent back when the tests of a functional spec regenerated again are as they were: they are to be written for the new code. */
+export declare function againPrompt(frids: string[]): string;
 /**
  * Why conformance tests did not land, in a line. Tests sent back to be labelled and never labelled may well pass: the
  * line says so, rather than that they failed.

package/dist/regenerate/conformance.js

@@ -10,7 +10,7 @@ import { firstLine, record } from "./ledger.js";
 import { createWorkLedger, describeAccounts, SUBMIT_WORK_NOTE, unanswered, unansweredPrompt } from "./submit-work.js";
 import { CONFORMANCE_COMPACTION } from "./compaction.js";
 import { NOTES_TURN, notesForSession, passedOutcome, readNotes, reflectOnReview, withNotes } from "./notes.js";
-import { acceptanceLabel, acceptanceText, labelsPrompt, labelsPromptFor, misplacedConformanceTests, misplacedTestsPrompt, missingTestLabels } from "./test-kinds.js";
+import { acceptanceLabel, acceptanceText, labelledFiles, labelsPrompt, labelsPromptFor, misplacedConformanceTests, misplacedTestsPrompt, missingTestLabels } from "./test-kinds.js";
 import { createScriptTool, findTestScripts, projectRootFor, requireTestScripts, runConformanceScript, runUnitScript, failureSignature, STUCK_ROUNDS, scriptFailure, staticChecksOnly, withTestingScripts, } from "./test-scripts.js";
 import { createWebTools, WEB_TOOLS } from "./web.js";
 import { createMyDiffTool } from "./self-check.js";
@@ -345,6 +345,19 @@ export async function renderConformanceTests(options) {
                 ? "turri is bringing the conformance tests in line with the spec change"
                 : "turri is writing conformance tests from the spec");
         let response = await askConformance(BEGIN, options.onDelta);
+        // The functional specs of this module the job regenerates again, and of those, the ones whose tests this run has
+        // not written yet: no test file labelled with it added or changed since the run began.
+        const againFrids = (options.cases?.again ?? []).filter((spec) => spec.module === undefined || spec.module === moduleName).map((spec) => spec.frid);
+        const rewrittenAgain = () => {
+            const changes = diffFiles(testsAtStart, digestFiles(conformanceDir));
+            const touchedFiles = new Set([...changes.added, ...changes.changed]);
+            return againFrids.filter((id) => labelledFiles(conformanceDir, id).some((file) => touchedFiles.has(file)));
+        };
+        const staleAgain = () => {
+            const done = new Set(rewrittenAgain());
+            return againFrids.filter((id) => !done.has(id));
+        };
+        let againAsks = 0;
         const maxRounds = options.maxRounds ?? DEFAULT_MAX_ROUNDS;
         let verified = false;
         let rounds = 0;
@@ -405,6 +418,20 @@ export async function renderConformanceTests(options) {
                     continue;
                 }
             }
+            // Regenerated again: its tests were written against the code it replaced, and their passing says nothing of the new
+            // code - they pass on what only the old code did as readily. Its tests have to be written again in this run.
+            const stale = staleAgain();
+            if (stale.length > 0) {
+                if (againAsks >= LABEL_ASKS) {
+                    stage(`the tests of functionalit${stale.length === 1 ? "y" : "ies"} ${stale.join(", ")}, regenerated again, were sent back ${LABEL_ASKS} times to be written again, and still are not - stopping`);
+                    unlabelled = stale.map((id) => `The tests of functionality ${id}, regenerated again, were not written again for the new code: no test file labelled with it changed.`);
+                    break;
+                }
+                againAsks += 1;
+                stage(`the tests of functionalit${stale.length === 1 ? "y" : "ies"} ${stale.join(", ")}, regenerated again, are as they were - the conformance agent writes them again`);
+                response = await askConformance(againPrompt(stale), options.onDelta);
+                continue;
+            }
             // The suite is the tests folder: a conformance test in the code folder is in the wrong place,
             // and not the coding agent's to write.
             const misplaced = misplacedConformanceTests(buildDir);
@@ -830,6 +857,7 @@ export async function renderConformanceTests(options) {
             ...(stuck !== undefined ? { stuck } : {}),
             ...(escalation !== undefined ? { escalation } : {}),
             ...(unlabelled !== undefined ? { unlabelled } : {}),
+            ...(againFrids.length > 0 ? { rewritten: rewrittenAgain() } : {}),
             ...(reviewWaived !== undefined ? { reviewWaived } : {}),
             ...(verified && green !== undefined ? { green } : {}),
             ...(!verified && lastReview !== undefined ? { review: lastReview } : {}),
@@ -842,6 +870,18 @@ export async function renderConformanceTests(options) {
         await fixerServices.stopAll();
     }
 }
+/** Sent back when the tests of a functional spec regenerated again are as they were: they are to be written for the new code. */
+export function againPrompt(frids) {
+    const which = frids.length === 1 ? `functionality ${frids[0]}` : `functionalities ${frids.join(", ")}`;
+    return [
+        `${which[0].toUpperCase()}${which.slice(1)} ${frids.length === 1 ? "is" : "are"} regenerated again: ${frids.length === 1 ? "its" : "their"} code was built anew, and no test file labelled with ${frids.length === 1 ? "it" : "them"} has changed.`,
+        "Tests that pass prove nothing here: they were written against the code it replaced, and pass on what only the old",
+        "code did as readily as on what the specification says. Read the new code, and write the tests again for it: what",
+        "the specification says, checked as the new code is reached; what it leaves open - a path, a field, a message, a",
+        "format the old code chose - checked as the new code does it, or taken out. Keep each label. The tests of",
+        "everything else stay as they are.",
+    ].join("\n");
+}
 /**
  * Why conformance tests did not land, in a line. Tests sent back to be labelled and never labelled may well pass: the
  * line says so, rather than that they failed.

package/dist/regenerate/jobs.d.ts

@@ -8,6 +8,21 @@ import { type AgentTally, type BuildingSpec, type SpecConflict, type TranscriptE
  * carries on while the agents work.
  */
 export type JobStatus = "queued" | "running" | "succeeded" | "failed" | "stopped";
+/** A functional spec a pulse covers: the module whose spec it is - the pulse's own, or one below it - and its number there. */
+export interface PulseSpec {
+    module: string;
+    frid: string;
+}
+/**
+ * The functional specs a pulse covers, by what it does to each (`cases.ts`): new, changed, regenerated again - its text
+ * unchanged - or taken out. A pulse of none is mechanical: reqs, or definitions none uses.
+ */
+export interface PulseCases {
+    add: PulseSpec[];
+    patch: PulseSpec[];
+    again: PulseSpec[];
+    delete: PulseSpec[];
+}
 export interface Job {
     id: string;
     kind: string;
@@ -23,6 +38,8 @@ export interface Job {
     diff?: string;
     /** Where its diff's lines are in the .plain files - their files and line numbers there - when they could be placed. */
     diffWhere?: import("./diff-view.ts").DiffWhere;
+    /** The functional specs it covers, by case: what it does to each. */
+    cases?: PulseCases;
     /** For a conformance job: the render job it is the conformance of. */
     follows?: string;
     /** A note on it, for the person: why it did not run, or what became of it. */
@@ -118,6 +135,8 @@ export interface StartJobInput {
     diff?: string;
     /** Where the diff's lines are in the .plain files, when they could be placed. */
     diffWhere?: import("./diff-view.ts").DiffWhere;
+    /** The functional specs it covers, by case. */
+    cases?: PulseCases;
     /** "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. */

package/dist/regenerate/jobs.js

@@ -79,6 +79,7 @@ export function createJobRegistry(options) {
                 ...(input.title !== undefined ? { title: input.title } : {}),
                 diff: input.diff,
                 ...(input.diffWhere !== undefined ? { diffWhere: input.diffWhere } : {}),
+                ...(input.cases !== undefined ? { cases: input.cases } : {}),
                 model: input.model,
                 ...(stack !== undefined ? { stack } : {}),
                 ...(chat !== undefined ? { chat } : {}),
@@ -107,6 +108,7 @@ export function createJobRegistry(options) {
                 ...(input.title !== undefined ? { title: input.title } : {}),
                 ...(input.model !== undefined ? { model: input.model } : {}),
                 ...(stack !== undefined ? { stack } : {}),
+                ...(input.cases !== undefined ? { cases: input.cases } : {}),
                 waitingOn: blockers,
                 ...(input.follows !== undefined ? { follows: input.follows } : {}),
             }, place);

package/dist/regenerate/ledger-view.js

@@ -133,10 +133,17 @@ function nameOf(view) {
         return queued.summary;
     return queued.pulse !== undefined ? `${queued.module} · ${queued.jobKind} pulse ${queued.pulse}` : `${queued.module} ${queued.jobKind}`;
 }
+/**
+ * How a pulse ended. One not ended yet is still running, or waiting, when it is this run's - the run that is reading the
+ * ledger; another run's never will: that run stopped while it ran.
+ */
 function outcomeOf(view) {
     const finished = view.finished;
-    if (finished === undefined)
+    if (finished === undefined) {
+        if (view.run === ledgerRun())
+            return view.started !== undefined ? "still running" : "queued - not started yet";
         return view.started !== undefined ? "never ended - its run stopped while it ran" : "never started";
+    }
     const landed = finished.landed === true ? ", landed" : finished.landed === false ? ", did not land" : "";
     const stopped = finished.stoppedBy !== undefined ? ` by ${finished.stoppedBy === "turri" ? "turri" : "the person"}` : "";
     return `${finished.status}${stopped}${landed}, after ${formatElapsed(finished.ms)}`;
@@ -251,7 +258,7 @@ export function describeRuns(runs) {
         const started = view.started;
         const when = started?.ts !== undefined ? started.ts.slice(0, 19).replace("T", " ") : "";
         const version = started?.version !== undefined && started.version !== null ? ` · turri ${started.version}${started.commit !== null && started.commit !== undefined ? ` (${started.commit.slice(0, 7)}${started.dirty === true ? ", changed" : ""})` : ""}` : "";
-        const head = `run ${view.run} · ${started?.mode ?? "?"} · ${when}${view.ended !== undefined ? ` · ${formatElapsed(view.ended.ms)}` : " · still running, or killed"}${version}`;
+        const head = `run ${view.run} · ${started?.mode ?? "?"} · ${when}${view.ended !== undefined ? ` · ${formatElapsed(view.ended.ms)}` : view.run === ledgerRun() ? " · this run, still running" : " · still running, or killed"}${version}`;
         const pulses = view.pulses.map((pulse) => `  ${pulse.id} ${nameOf(pulse).padEnd(32)} ${outcomeOf(pulse)}${pulse.usage !== undefined && describeUsage(pulse.usage) !== "" ? ` · ${describeUsage(pulse.usage)}` : ""}`);
         return [head, ...(pulses.length > 0 ? pulses : ["  no pulses"])].join("\n");
     })
@@ -288,6 +295,7 @@ 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 } : {}),
+        ...(view.queued?.cases !== undefined ? { cases: view.queued.cases } : {}),
         // 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,

package/dist/regenerate/ledger.d.ts

@@ -1,4 +1,5 @@
 import type { DiffWhere } from "./diff-view.ts";
+import type { PulseCases } from "./jobs.ts";
 import { type UsageReport } from "./activity.ts";
 /**
  * The ledger: what turri does, as typed facts, one JSON line each, written as it happens - to
@@ -78,6 +79,7 @@ export type LedgerEvent = {
     title?: string;
     model?: string;
     stack?: string;
+    cases?: PulseCases;
     waitingOn: string[];
     follows?: string;
 } | {

package/dist/regenerate/loop.d.ts

@@ -1,6 +1,7 @@
+import { type MarshalledPlainSource } from "../plain/spec.ts";
 import { type ChunkAgents } from "./chunk-plan.ts";
 import { type SpecGap } from "./notes.ts";
-import { type Job, type JobRegistry } from "./jobs.ts";
+import { type Job, type JobRegistry, type PulseCases } from "./jobs.ts";
 import type { Steering } from "./steer.ts";
 import { type ChainEntry } from "./requires.ts";
 import { type SpecSnapshot } from "./regenerate.ts";
@@ -385,6 +386,14 @@ export declare function isUpToDate(status: ModuleStatus): boolean;
 export declare function describeModules(statuses: ModuleStatus[], options?: {
     for?: "chat" | "command line";
 }): string;
+/** The functional specs a pulse covers, by case, each with the module whose spec it is: a host's to light and mark. */
+export declare function pulseCases(cases: JobCases, moduleName: string): PulseCases;
+/**
+ * What a conformance job records its tests are written for: its step's tree, but a functional spec of the module it
+ * regenerates again keeps its mark unless the run wrote its tests - tests that passed as they were are still the old
+ * code's, and still conformance work.
+ */
+export declare function keepAgainMarks(tree: MarshalledPlainSource, cases: JobCases, moduleName: string, rewritten: string[]): MarshalledPlainSource;
 /**
  * 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

package/dist/regenerate/loop.js

@@ -522,6 +522,8 @@ export function createWorkLoop(options) {
             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,
+            // The functional specs it covers, by case - its own module's, and those of modules below it.
+            cases: pulseCases(planned.cases, tip.moduleName),
             ...(state.model !== undefined ? { model: state.model } : {}),
             lanes: [...moduleLanes(tip.plainFile)],
             rerun: `turri regenerate ${relative(options.cwd, tip.plainFile) || basename(tip.plainFile)}`,
@@ -1677,11 +1679,28 @@ const defaultConformanceRunner = async (job, onDelta) => {
         onDelta,
     });
     if (result.passed) {
-        writeTestsRecord(result.conformanceDir, job.planned.step.tree);
+        writeTestsRecord(result.conformanceDir, keepAgainMarks(job.planned.step.tree, job.planned.cases, job.moduleName, result.conformance.rewritten ?? []));
         landWork(job.buildDir, `conformance tests: ${job.planned.title}`);
     }
     return { landed: result.passed, report: describeSpecDiffConformance(result), ...(result.specGaps !== undefined ? { specGaps: result.specGaps } : {}) };
 };
+/** The functional specs a pulse covers, by case, each with the module whose spec it is: a host's to light and mark. */
+export function pulseCases(cases, moduleName) {
+    const of = (specs) => specs.map((spec) => ({ module: spec.module ?? moduleName, frid: spec.frid }));
+    return { add: of(cases.add), patch: of(cases.patch), again: of(cases.again), delete: of(cases.delete) };
+}
+/**
+ * What a conformance job records its tests are written for: its step's tree, but a functional spec of the module it
+ * regenerates again keeps its mark unless the run wrote its tests - tests that passed as they were are still the old
+ * code's, and still conformance work.
+ */
+export function keepAgainMarks(tree, cases, moduleName, rewritten) {
+    const stale = new Set(cases.again.filter((spec) => (spec.module ?? moduleName) === moduleName && !rewritten.includes(spec.frid)).map((spec) => spec.frid));
+    if (stale.size === 0)
+        return tree;
+    const items = tree[FUNCTIONAL_REQUIREMENTS] ?? [];
+    return { ...tree, [FUNCTIONAL_REQUIREMENTS]: items.map((item) => (item.frid !== undefined && stale.has(item.frid) ? { ...item, [REGENERATE_AGAIN]: true } : item)) };
+}
 /**
  * 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

package/dist/regenerate/test-kinds.d.ts

@@ -21,6 +21,11 @@ export declare function acceptanceText(item: string): string;
  * test file carries it, and each acceptance test no test is labelled as implementing.
  */
 export declare function missingTestLabels(testsDir: string, frid: string, acceptanceTests: string[]): string[];
+/**
+ * The test files that carry a functionality's labels - its conformance tests' or any of its acceptance tests'. The
+ * harness's own files beside them - the notes, the record - are not tests, whatever they mention.
+ */
+export declare function labelledFiles(testsDir: string, frid: string): string[];
 /** Sent back when the labels are missing: which, and how to label them. */
 export declare function labelsPrompt(frid: string, missing: string[], empty?: boolean, hasAcceptance?: boolean): string;
 /**

package/dist/regenerate/test-kinds.js

@@ -54,6 +54,24 @@ export function missingTestLabels(testsDir, frid, acceptanceTests) {
     });
     return missing;
 }
+/**
+ * The test files that carry a functionality's labels - its conformance tests' or any of its acceptance tests'. The
+ * harness's own files beside them - the notes, the record - are not tests, whatever they mention.
+ */
+export function labelledFiles(testsDir, frid) {
+    const id = frid.replace(/\./g, "\\.");
+    const label = new RegExp(`(conformance tests|acceptance test \\d+) of functionality ${id}(?![0-9.]*[0-9])`);
+    return listFiles(testsDir).filter((file) => {
+        if (file.split(/[\\/]/).at(-1).startsWith(".turri"))
+            return false;
+        try {
+            return label.test(normalise(readFileSync(join(testsDir, file), "utf8")));
+        }
+        catch {
+            return false;
+        }
+    });
+}
 /** Sent back when the labels are missing: which, and how to label them. */
 export function labelsPrompt(frid, missing, empty = false, hasAcceptance = true) {
     return labelsPromptFor([{ frid, missing }], empty, hasAcceptance);

package/docs/hosting.md

@@ -113,7 +113,7 @@ await turri.dispose();                 // every chat let go, what activate start
 - **Interrupting.** `interrupt(id)` is the terminal's ctrl+c for a host's key or button: it stops what that chat is doing - its turn, a skill or a tool in it, a `!` command, a compaction - and nothing in the other chats (`stopped`). A skill stopped keeps its run, to be continued. A question of the chat's open in the host's dialogs when its turn is stopped is over - declined - and its dialog's `signal` aborted, for the host to close it. A chat doing nothing ends the session, every chat with it, as `dispose` does (`ended`): turri never exits the host's process, so the host closes what showed it. An interrupt straight after one that stopped something is `ignored`, so pressing twice to be sure ends nothing. `session.abort()` is the chat's turn alone, and never ends the session.
 - **Declining a question.** `decline(id)` is ctrl+c at a question in turri's terminal: the question the chat asks now - its ask_user, a skill's interview, a review gate's escalation, whatever goes through the host's dialogs - declined. The asker is told "The user declined to answer the question." and the turn goes on; a review gate declined stands. It declines each question it is called at, however many in a row, and never stops the turn - that is `interrupt`. `none` when the chat asks nothing now, `missing` for a chat not open. A dialog that resolves with `undefined` is something else - dismissed, and in a question of several answers "done" with the boxes ticked so far.
 - **The record.** The chats are recorded in `.turri/chats.json` as the terminal records them, and `restore: true` reopens the last ended session's - without it, a host starts with none and deletes nothing. A chat closed is deleted; a session's chats are kept until five newer sessions have recorded theirs.
-- **The jobs.** The host is told of each job as it changes, and has the registry and the loop themselves, so it shows the very jobs the chats run. Its buttons are best a chat's commands - `session.prompt("/regenerate app.plain")` - so the plan is the chats'. A job's \*\*\*plain diff is `job.diff`, and `job.diffWhere` places its lines in the `.plain` files: by a line's place in the diff, its `file`, its `line` there, the `section` it is in and `written` - the line as the file has it. The diff is \*\*\*plain as read, a link `[text](path)` in it as `` `[resource]text` ``, so a host that finds the lines again in a file's text - after an edit since the pulse started - matches them by `written`, never by the diff's text. A `job.diff` in a ledger written before `written` was added has none.
+- **The jobs.** The host is told of each job as it changes, and has the registry and the loop themselves, so it shows the very jobs the chats run. Its buttons are best a chat's commands - `session.prompt("/regenerate app.plain")` - so the plan is the chats'. A job's \*\*\*plain diff is `job.diff`, and `job.diffWhere` places its lines in the `.plain` files: by a line's place in the diff, its `file`, its `line` there, the `section` it is in and `written` - the line as the file has it. The diff is \*\*\*plain as read, a link `[text](path)` in it as `` `[resource]text` ``, so a host that finds the lines again in a file's text - after an edit since the pulse started - matches them by `written`, never by the diff's text. A `job.diff` in a ledger written before `written` was added has none. `job.cases` is the functional specs the pulse covers, as planned, by what it does to each - `{ add, patch, again, delete }`, each a list of `{ module, frid }`, `module` the pulse's own or one below it: new, changed, regenerated again with its text unchanged, taken out. A host lights those specs from it, and marks a line of the diff as regenerated again from `again` - never from the diff, where such a line is unchanged. A pulse of none is mechanical - reqs, or definitions none uses; a job that is not a pulse has no `cases`. The ledger's `job.queued` carries them too.
 - **The questions.** `dialogs(chat)` gives a chat's two dialogs: `select(title, options, context, at, { signal })` and `input(title, context, { signal })`, each resolving with the answer, or undefined when the person dismissed it. `signal` is aborted when the question is over without the dialog's answer - declined by `decline`, or its turn stopped (`interrupt`, `session.abort()`): the host closes the dialog it opened for it, whatever it resolves with then being ignored. A host may leave it unread. The chat's questions, a skill's interview and a review gate's escalation are put in them; without them, in the `uiContext`'s own dialogs.
 - **The surface.** What turri tells the model of where the person watches the work is the terminal's by default: regen, the side panel on `ctrl+h`, `/pulses`. In a host none of that is there, and the model would send the person to keys and panels that do not exist. `surface` is the host's own description of its UI - the views it has in place of the terminal's, what its marks and buttons mean, where questions appear - in its own words. Given, turri leaves every terminal instruction out of what the model is told and puts the surface in turri's identity, as a `<surface>` block, where the identity speaks of regen. It reaches the side questions and the tools' own words too: a pulse not found says the `pulses` tool lists them, not `/pulses`. Text only the person sees in the terminal - the job panel, the side panel - is the terminal's and stays as it is. Without `surface`, the prompt is the terminal's, byte for byte. What the conversation is to do once something is released belongs there too - open it in the host's preview, say what to test: with `sentinel: false`, after a pulse released under `release-after-pulse`, the conversation does what it was told to do once something is released. With the sentinel on, the sentinel tests the release, and the conversation only says it landed.
 - **The system prompt.** `systemPrompt(prompt)` gets the whole system prompt for the turn - [pi](https://pi.dev)'s, turri's identity and blocks, the rules - after turri's own `before_agent_start` work, and returns what is sent. It is for what `surface` does not cover; to describe the UI, use `surface`, rather than words appended after turri's that contradict them.
@@ -192,7 +192,7 @@ const { jobs, more } = earlierPulses(ledgerProjects(projectDir), new Set(turri.j
 ```
 
 - **Live.** `onLedgerEvent(listener)` is told every event as turri records it, with the project it is about, until what it returns is called; a listener that throws misses that event and nothing else. It is the pulse's own detail - its stages, test runs, verdicts, refusals - where `onJobChange` is the job as a whole.
-- **Read back.** `readLedger(project, { job, run, kinds, since })` is the project's events, oldest first, the gzipped runs too; `runViews` and `pulseView` gather them into runs and pulses, and `describePulseView` and `describeRuns` say them in lines, as `turri ledger` prints them. `ledgerProjects(dir)` finds the ledgers of a folder and the projects under it. `earlierPulses(projects, known, runs = 3)` gives the last runs before this one as `Job`s - the shape a host already draws for this session's - each marked `earlier: { run, runMode, lines }`, `lines` what the ledger says of it, and with its `diff` and `diffWhere` - the \*\*\*plain diff it regenerated, as last steered, and where its lines are written - as a pulse of this session has them (a pulse recorded before `job.diff` was has none); `more` is how many runs are beyond them. They are read only: never started, halted or waited for. turri's own side panel lists them so, as **earlier sessions**.
+- **Read back.** `readLedger(project, { job, run, kinds, since })` is the project's events, oldest first, the gzipped runs too; `runViews` and `pulseView` gather them into runs and pulses, and `describePulseView` and `describeRuns` say them in lines, as `turri ledger` prints them. `ledgerProjects(dir)` finds the ledgers of a folder and the projects under it. `earlierPulses(projects, known, runs = 3)` gives the last runs before this one as `Job`s - the shape a host already draws for this session's - each marked `earlier: { run, runMode, lines }`, `lines` what the ledger says of it, and with its `cases`, `diff` and `diffWhere` - the \*\*\*plain diff it regenerated, as last steered, and where its lines are written - as a pulse of this session has them (a pulse recorded before `job.diff` was has none); `more` is how many runs are beyond them. They are read only: never started, halted or waited for. turri's own side panel lists them so, as **earlier sessions**.
 - **What it is for.** Looking up, never deciding: what is built and what is left come from the records and the work loop, as before. Its events and their fields are `LedgerEvent`'s - a kind is added, never changed, and every event carries `v: 1`.
 
 ## Running it

package/docs/regenerating.md

@@ -284,11 +284,11 @@ It is told, too, what to do with each functional spec the job touches, by its ca
 | fresh | the module requires none and nothing is built | set up the project and its unit tests where the unit testing script runs them, then build | set up `tests/` so the conformance testing script, which brings the tests together with `code/`, runs them, then write |
 | add | a functional spec is new | build it and write its unit tests | write its tests |
 | patch | its text changed, or a concept it uses did | change the existing code and tests to match - never build it again from scratch | rewrite its existing tests to match |
-| again | `regenerate` named it: it is built, and marked in the code record to be regenerated again | take its implementation out and build it anew, doing what \*\*\*plain says now - the old code already doing it is no reason to keep it; no second implementation beside the old, nothing of it left unused; its unit tests written anew. A coding agent that writes nothing is sent back twice to build it anew, and then the pulse does not land | its tests were written against the code it replaced: run against the new code, what they check that \*\*\*plain says stays checked, and what they check that \*\*\*plain leaves open - a path, a field, a message the old code chose - is rewritten to what the new code does, or taken out |
+| again | `regenerate` named it: it is built, and marked in the code record to be regenerated again | take its implementation out and build it anew, doing what \*\*\*plain says now - the old code already doing it is no reason to keep it; no second implementation beside the old, nothing of it left unused; its unit tests written anew. A coding agent that writes nothing is sent back twice to build it anew, and then the pulse does not land | its tests were written against the code it replaced, and pass on what only the old code did as readily: written again for the new code - what they check that \*\*\*plain says stays checked, and what they check that \*\*\*plain leaves open - a path, a field, a message the old code chose - is rewritten to what the new code does, or taken out. A run that leaves every test file labelled with it as it was is sent back, three times at most, and then does not land |
 | delete | a functional spec is gone | take out its code and the tests only it had | take out its tests |
 | mechanical | no functional spec is touched - only reqs, or definitions none uses | adapt the code; write no new test; an existing one may change only mechanically - an import, a fixture, its setup - never what it asserts | the same, for test reqs, definitions or implementation reqs alone |
 
-**Regenerating again.** `regenerate` with functionalities named regenerates them again though their \*\*\*plain did not change - made better, on another model, after many patches. Each is marked in the code record of every codebase it is built in (`regenerate_again`, committed), and nothing else changes: the record now differs from \*\*\*plain at that item, so the work loop plans it as it plans any change. A functional spec of a module below is regenerated again where its code lives - the codebase at the tip of each chain built on it, never the module's own codebase left behind - marked among that codebase's required functional specs. The planner groups the ones regenerated again as it groups new ones - up to three a job, only those next to each other in one module together - and the job is given the definitions and implementation reqs as every job is; `<spec change>` lists each under "To regenerate again", with its text as it is now. The job that regenerates it records it as \*\*\*plain has it, without the mark. Its conformance tests are marked with it, in the tests record of the codebase whose own functional spec it is: they were written against the code being replaced, and may hold the new code to what only the old code chose - `/healthcheck` where \*\*\*plain says only that there is a health check, and the new code answers `/health`. While the code regenerates they stay as they are; once it lands, the mark is conformance work like any change, and a conformance job writes them again, in the again case above, and runs the whole suite. Until it lands, regen shows its tests as written for an earlier build, and they are not counted as conformance tested.
+**Regenerating again.** `regenerate` with functionalities named regenerates them again though their \*\*\*plain did not change - made better, on another model, after many patches. Each is marked in the code record of every codebase it is built in (`regenerate_again`, committed), and nothing else changes: the record now differs from \*\*\*plain at that item, so the work loop plans it as it plans any change. A functional spec of a module below is regenerated again where its code lives - the codebase at the tip of each chain built on it, never the module's own codebase left behind - marked among that codebase's required functional specs. The planner groups the ones regenerated again as it groups new ones - up to three a job, only those next to each other in one module together - and the job is given the definitions and implementation reqs as every job is; `<spec change>` lists each under "To regenerate again", with its text as it is now. The job that regenerates it records it as \*\*\*plain has it, without the mark. Its conformance tests are marked with it, in the tests record of the codebase whose own functional spec it is: they were written against the code being replaced, and may hold the new code to what only the old code chose - `/healthcheck` where \*\*\*plain says only that there is a health check, and the new code answers `/health`. While the code regenerates they stay as they are; once it lands, the mark is conformance work like any change, and a conformance job writes them again, in the again case above, and runs the whole suite. That they pass is not taken for written again: the run lands only once a test file labelled with it was added or changed in it, and the tests record drops the mark only of a functional spec whose tests the run wrote. Until it lands, regen shows its tests as written for an earlier build, and they are not counted as conformance tested.
 
 A functional spec is patched when a concept it uses changed as well as when its own text did: the harness follows each functional spec's concepts through the definitions. Fresh is only where nothing exists: a module that requires another starts from what it inherits, and its first job adds or patches.
 
@@ -473,7 +473,7 @@ What goes into them:
 - **A code job landed:** the code record becomes the \*\*\*plain description the job ends on.
 - **A conformance job landed:** the tests record becomes what its tests are written for.
 - **A module started from another's code:** that code's record, as a lower module's - see [where things go](#where-things-go) - and an empty tests record: the tests it inherits are the module below's.
-- **A functional spec named to `regenerate`:** it is marked to be regenerated again in the code record, so the next job regenerates it again; that job's record drops the mark. Its conformance tests, when it has them, are marked in the tests record too, and the conformance job that writes them again for the new code drops that mark.
+- **A functional spec named to `regenerate`:** it is marked to be regenerated again in the code record, so the next job regenerates it again; that job's record drops the mark. Its conformance tests, when it has them, are marked in the tests record too, and the conformance job that writes them again for the new code drops that mark - only once a test file labelled with it changed in the run, never because the old tests still pass.
 
 A unit of work - a code job, a conformance job - lands whole or is undone whole. It starts from the module's last commit, putting back whatever an interrupted run left; a module with no commit yet is given one first. When it does not pass, the module goes back to that commit: its changes, the files it added and any commit it made on the way are gone, with the record they came with. Installed dependencies and caches stay. So the code, its tests and the records of what they were built from never disagree.
 

package/docs/using.md

@@ -178,7 +178,7 @@ It is in `.turri/ledger/` in the project, a JSON line an event, one file a run -
 | | |
 | --- | --- |
 | runs | `run.started` (how it was started, turri's version and commit, the machine), `run.ended` |
-| pulses | `job.queued`, `job.diff` (its \*\*\*plain diff, whole, and where its lines are written - again each time steering moves it), `job.started`, every `job.stage`, `job.retried`, `job.finished` - its status, whether it landed, how long it ran, what it cost, how it ended |
+| pulses | `job.queued` (with the functional specs it covers, by case), `job.diff` (its \*\*\*plain diff, whole, and where its lines are written - again each time steering moves it), `job.started`, every `job.stage`, `job.retried`, `job.finished` - its status, whether it landed, how long it ran, what it cost, how it ended |
 | the work loop | `loop.halted`, `loop.stopped` (a pulse \*\*\*plain moved on from), `planner.failed`, `planner.fellBack` |
 | the model | `model.call` (time and tokens), `model.turn`, `model.compaction`, `provider.retry`, `provider.stall`, `provider.error`, `turn.stopped` (a turn turri ended itself, and why) |
 | tools and tests | `tool.call` (the tool, how long, whether it failed - never its arguments or result), `script.run` (the testing script, its exit, how long, whether the time limit stopped it, the failure's fingerprint, and `mutated` for a `can_it_fail` run on code broken on purpose) |
@@ -191,7 +191,7 @@ It is in `.turri/ledger/` in the project, a JSON line an event, one file a run -
 
 Never in it: prompts, replies, thinking, tool arguments and results, file contents - the one body it keeps is each pulse's \*\*\*plain diff, so what an earlier session regenerated can be read back. What an event does carry - a stage, an error's first line - is masked as the logs are.
 
-`turri ledger` prints the last runs, a line a pulse - runs and pulses newest first, as every list of the ledger's is, the events and a pulse's history and stages too; `turri ledger <pulse>` one pulse - its rounds, its test runs and how many failed the same way, the verdicts, the healers, what turri refused, what its history recorded, its log, and the \*\*\*plain diff it regenerated; `--json` the events themselves, for `jq`. In the chat, `ledger` is the way in - a pulse of this session or an earlier one, the events of some kinds counted (how often the debugger failed this week: `kinds: [healer.failed], since: 7d`), the last runs - and `pulses` lists the last three earlier runs under this session's pulses, `pulses` and `diagnose` tell one of them by its id, and `diagnose` adds the ledger's facts to a pulse of this session; the side panel's pulses list has them as **earlier sessions** (see [the side panel](#in-a-conversation)).
+`turri ledger` prints the last runs, a line a pulse - runs and pulses newest first, as every list of the ledger's is, the events and a pulse's history and stages too; `turri ledger <pulse>` one pulse - its rounds, its test runs and how many failed the same way, the verdicts, the healers, what turri refused, what its history recorded, its log, and the \*\*\*plain diff it regenerated; `--json` the events themselves, for `jq`. A pulse not ended is still running when it is of the run reading the ledger, and never ended - its run stopped while it ran - when it is another's. In the chat, `ledger` is the way in - a pulse of this session or an earlier one, the events of some kinds counted (how often the debugger failed this week: `kinds: [healer.failed], since: 7d`), the last runs - and `pulses` lists the last three earlier runs under this session's pulses, `pulses` and `diagnose` tell one of them by its id, and `diagnose` adds the ledger's facts to a pulse of this session; the side panel's pulses list has them as **earlier sessions** (see [the side panel](#in-a-conversation)).
 
 It is for looking up, never for deciding: what to build comes from the records alone (see [what the code is built from](regenerating.md#what-the-code-is-built-from)), so deleting `.turri/ledger/` loses nothing but what can be looked up. When a run first writes to the project, the files of runs that have ended are gzipped and the oldest pruned past `ledger-keep:` megabytes - 100 unset, `0` for none at all; a run still going is never touched. `.turri` ignores itself, so the ledger is never committed, and nothing of it is sent anywhere. A ledger that cannot be written is said once and given up on, never failing the work.
 

package/genome/rules/turri-regeneration.md

@@ -26,7 +26,7 @@ The other rules say what a spec means. This one says what turri does with a chan
 - A definition changed patches every functional spec that uses its concept, directly or through other definitions. So does a change to a linked resource: the spec or definition linking it is changed though its text is not. A widely used definition is the costly edit - not a spec's position
 - Implementation reqs alone, or definitions no functional spec uses, are a mechanical change: the code adapts, and no test is written or changes what it asserts
 - Test reqs and acceptance tests reach the conformance tests only, never the code
-- A functional spec regenerated again by name has its code taken out and built anew - never left as it was, even where it already does what the spec says; a pulse that changes nothing does not land. Its conformance tests are written again once its new code lands: what they check that the spec leaves open - a path, a field, a message the old code chose - goes by the new code
+- A functional spec regenerated again by name has its code taken out and built anew - never left as it was, even where it already does what the spec says; a pulse that changes nothing does not land. Its conformance tests are written again once its new code lands: what they check that the spec leaves open - a path, a field, a message the old code chose - goes by the new code. Old tests that still pass are not enough: a conformance pulse that leaves them as they were does not land
 - Definitions moved to a common module and reqs reordered are recorded, not rendered
 - A functional spec written on its happy path and hardened later - its validation, edge cases and errors added to it - is patched in place each time: growing a spec a step at a time costs no more than writing it whole up front
 - A module's first pulse, when it builds one functional spec - the project set up and the smallest thing that runs - lands on its unit tests with no review

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turri-dev/cli",
-  "version": "0.1.26",
+  "version": "0.1.27-next.763d091",
   "license": "MIT",
   "type": "module",
   "repository": {