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

package/dist/regenerate/loop.js

@@ -1,8 +1,9 @@
-import { existsSync, readFileSync, rmSync } from "node:fs";
+import { existsSync, readFileSync, rmSync, statSync } from "node:fs";
 import { basename, dirname, join, relative, resolve } from "node:path";
 import { plainFileParser, withParseCache } from "../plain/parser.js";
 import { STDLIB_ROOT } from "../plain/stdlib.js";
-import { ACCEPTANCE_TESTS, FUNCTIONAL_REQUIREMENTS, REQUIRED_FUNCTIONAL_SPECS, TEST_REQUIREMENTS } from "../plain/spec.js";
+import { ACCEPTANCE_TESTS, CONFORMANCE_TESTS, FUNCTIONAL_REQUIREMENTS, REQUIRED_FUNCTIONAL_SPECS, TEST_PLAIN_FILES, TEST_REQUIREMENTS } from "../plain/spec.js";
+import { testPlainFilesOf } from "../test-plain-files.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, landWork, recordHistory, resetToLastCommit } from "./lineage.js";
@@ -10,11 +11,11 @@ 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 { adoptDigests, chainTree, codeTree, conformanceTarget, marksRegenerateAgain, REGENERATE_AGAIN, inheritedRecord, isOldRecord, notBuilt, readRecord, RECORD_FILE, withResourceDigests, writeCodeRecord, writeTestsRecord, hasScenarios, identityOf, testedFuncIds, } from "./records.js";
 import { describeSpecDiffConformance, renderSpecDiffConformance } from "./conform.js";
 import { conformanceDirFor } from "./conformance.js";
 import { modulesRoot, projectRootOf } from "./paths.js";
-import { budgetFor, choosingWhen, configForSpec, conformanceSwitchedOn, stackForModule, stackPinned, withStack } from "../config.js";
+import { configForSpec, stackForModule, stackPinned, testDirOf, withStack } from "../config.js";
 import { describeSpecChange } from "./prompt.js";
 import { resolveTemplateDirs } from "./paths.js";
 import { builtTips, copyRequiredCode, importingModules, isImportModule, newlyRequired, resolveRequiresChain, startFromScratch } from "./requires.js";
@@ -25,7 +26,14 @@ import { createSteering, MAX_STEERS, markTold, steer, waitingSteer } from "./ste
 import { projectDirOf } from "./paths.js";
 import { changesBetween, parseTree, serializeTree } from "./spec-steps.js";
 import { listFiles } from "./testing.js";
+import { makeRenames, pureRenames, renameText } from "./renames.js";
 import { casesOf, codeWork, stillWanted, whyNotWanted } from "./drift.js";
+import { testingGap } from "./testing-steps.js";
+import { baseFolderDrift, baseOfCodebase, seedFromBaseFolder } from "./base-folder.js";
+import { BASE_RECORD_FILE } from "./paths.js";
+import { onScriptRunEnded, scriptBeingWritten } from "./scripts-being-written.js";
+import { conformanceTestsOn } from "../conformance-switch.js";
+import { findTestScripts, projectRootFor } from "./test-scripts.js";
 /** What is left to regenerate, as the conversation and the command line read it. */
 export function describeDrift(reports) {
     if (reports.length === 0)
@@ -35,8 +43,8 @@ export function describeDrift(reports) {
     // the spec as it is, nothing regenerating or waiting, and nothing holding the codebase back. A pulse that did not
     // land leaves its work undone, so it shows as drift.
     // conformance: null is no drift, undefined none written here - either is regenerated; a case list is work left.
-    const regenerated = reports.every((report) => report.code === null && (report.conformance === null || report.conformance === undefined));
-    const settled = reports.every((report) => report.running === undefined && report.why === undefined && report.startOver === undefined && report.scheduled.length === 0);
+    const regenerated = reports.every((report) => report.code === null && (report.conformance === null || report.conformance === undefined) && (report.renames ?? []).length === 0);
+    const settled = reports.every((report) => report.running === undefined && report.why === undefined && report.startOver === undefined);
     const verdict = regenerated && settled ? "\nFully regenerated: every codebase is regenerated from the spec as it is, and nothing is regenerating." : "";
     return reports
         .map((report) => {
@@ -47,23 +55,40 @@ export function describeDrift(reports) {
             lines.push(`  code: drifted from the spec - to regenerate: ${cases(report.code)}`);
         if (report.conformance === null)
             lines.push("  conformance tests: written for what is built - no drift");
-        else if (report.conformance !== undefined)
-            lines.push(`  conformance tests: to write or change - ${cases(report.conformance)}`);
+        else if (report.conformance !== undefined) {
+            lines.push(report.conformanceOnly !== undefined
+                ? `  conformance tests: to write or change - conform asked for ${report.conformanceOnly.join(", ")} alone: the others wait for conform with no names, or the module asked for again`
+                : "  conformance tests: to write or change - written once the code is built, or now with conform", ...conformanceLines(report.module, report.conformance));
+        }
         else
-            lines.push("  conformance tests: none written here");
-        for (const group of report.scheduled)
-            lines.push(`  conformance tests ahead of their code: fs ${group.frids.join(", fs ")} - once ${group.unbuilt.map((frid) => `fs ${frid}`).join(", ")} ${group.unbuilt.length === 1 ? "is" : "are"} regenerated`);
+            lines.push(report.conformanceOff === true ? "  conformance tests: off (conformance-tests: false) - none written or run" : "  conformance tests: none written here");
+        for (const rename of report.renames ?? [])
+            lines.push(`  renames ${rename} - the records and the tests' labels only, nothing regenerated`);
+        if (report.baseFolder !== undefined)
+            lines.push(`  ${report.baseFolder}`);
         if (report.running !== undefined)
             lines.push(`  regenerating now: pulse ${report.running.jobId} - ${report.running.title}`);
         if (report.why !== undefined)
             lines.push(`  ${report.why}`);
-        if (report.startOver !== undefined)
-            lines.push(`  it has to be regenerated from scratch on ${report.startOver.requires.join(", ")} before anything more is regenerated there`);
+        if (report.startOver !== undefined) {
+            lines.push(report.startOver.old === true
+                ? `  it has to be regenerated from scratch, with its whole chain, before anything more is regenerated there: ${OLD_RECORDS_WHY(report.startOver.codebases)}`
+                : `  it has to be regenerated from scratch on ${report.startOver.requires.join(", ")} before anything more is regenerated there`);
+        }
         return lines.join("\n");
     })
         .join("\n") + verdict;
 }
 const tipOf = (chain) => chain.at(-1);
+/** When a file was last written, as a key - none when it is not there. */
+const modifiedAt = (path) => {
+    try {
+        return String(statSync(path).mtimeMs);
+    }
+    catch {
+        return "-";
+    }
+};
 /** Whether a module's codebase has been started: code in it, or a record. */
 const started = (entry) => listFiles(entry.buildDir).length > 0 || readRecord(entry.buildDir) !== null;
 /** The spec a codebase is built from, as the .plain files have it now: its whole requires chain's. */
@@ -71,7 +96,8 @@ export function chainSpec(chain) {
     // Each module's linked resources hashed where its links point: what a file holds is part of the spec.
     const trees = chain.map((entry) => {
         const dirs = resolveTemplateDirs(entry.plainFile);
-        return { module: entry.moduleName, tree: withResourceDigests(plainFileParser(basename(entry.plainFile), dirs, { allowNoFunctionalities: true })[1], dirs) };
+        // Its test plain files bound to it: each functional spec with its scenarios, and every one of them with a test plain file.
+        return { module: entry.moduleName, tree: withResourceDigests(plainFileParser(basename(entry.plainFile), dirs, { allowNoFunctionalities: true, testDir: testDirOf(entry.plainFile) })[1], dirs) };
     });
     const tip = tipOf(chain);
     return { moduleName: tip.moduleName, plainFile: tip.plainFile, tree: chainTree(trees), chain };
@@ -121,7 +147,24 @@ export function functionalityCompletion(plainFile) {
             if (readRecord(entry.buildDir) !== null)
                 delivered = index;
         });
-        const counts = chain.map((entry) => ({ module: entry.moduleName, specified: entry.frids.length, completed: 0, conformanceTested: 0, tested: [], incomplete: [...entry.frids] }));
+        // Of each module's functional specs, those with scenarios: what "tested of specified" counts over.
+        let whole;
+        try {
+            whole = chainSpec(chain).tree;
+        }
+        catch {
+            whole = undefined;
+        }
+        const ownItems = (tree, module, own) => (tree?.[own ? FUNCTIONAL_REQUIREMENTS : REQUIRED_FUNCTIONAL_SPECS] ?? []).filter((item) => own || item.module === module);
+        const counts = chain.map((entry, index) => ({
+            module: entry.moduleName,
+            specified: entry.funcIds.length,
+            withScenarios: ownItems(whole, entry.moduleName, index === chain.length - 1).filter(hasScenarios).length,
+            completed: 0,
+            conformanceTested: 0,
+            tested: [],
+            incomplete: [...entry.funcIds],
+        }));
         if (delivered === -1)
             return { codebase: tipOf(chain).buildDir, modules: counts };
         const codebase = chain.slice(0, delivered + 1);
@@ -131,34 +174,39 @@ export function functionalityCompletion(plainFile) {
         const changes = codeWork(record, spec);
         // Its own: what the work loop would regenerate - new, changed, a concept it uses changed, or marked again.
         const cases = casesOf(codeTree(record ?? {}), changes, { module: tip.moduleName });
-        const touched = new Set([...cases.add, ...cases.patch, ...cases.again].map((spec) => `${spec.module ?? tip.moduleName}:${spec.frid}`));
+        const touched = new Set([...cases.add, ...cases.patch, ...cases.again].map((spec) => `${spec.module ?? tip.moduleName}:${spec.funcId}`));
         // The modules' below it: an item the record does not have as the spec has it.
         for (const change of changes) {
             if (change.section !== REQUIRED_FUNCTIONAL_SPECS || change.after === undefined)
                 continue;
             try {
                 const item = JSON.parse(change.after);
-                if (item.module !== undefined && item.frid !== undefined)
-                    touched.add(`${item.module}:${item.frid}`);
+                if (item.module !== undefined && item.id !== undefined)
+                    touched.add(`${item.module}:${item.id}`);
             }
             catch {
                 /* not an item */
             }
         }
-        const specText = (module, frid) => {
-            const own = module === tip.moduleName;
-            const items = spec[own ? FUNCTIONAL_REQUIREMENTS : REQUIRED_FUNCTIONAL_SPECS] ?? [];
-            return (own ? items[Number(frid) - 1] : items.find((item) => item.module === module && item.frid === frid))?.markdown.trim();
+        // A functional spec as the tests are written for it: its text and its scenarios.
+        const reads = (item) => {
+            if (item === undefined)
+                return undefined;
+            const scenarios = (key) => (item[key] ?? []).map((scenario) => [scenario.id, scenario.text]);
+            return JSON.stringify([String(item.markdown ?? "").trim(), scenarios(CONFORMANCE_TESTS), scenarios(ACCEPTANCE_TESTS)]);
         };
+        const specText = (module, funcId) => reads(ownItems(spec, module, module === tip.moduleName).find((item) => item.id === funcId));
+        // What the conformance tests are written for, in the same codebase: its suite holds the chain's.
+        const testsRecord = readRecord(conformanceDirFor(tip.moduleName, modulesRoot(projectDirOf(tip.plainFile))));
         codebase.forEach((entry, index) => {
             const count = counts[index];
-            const completed = entry.frids.filter((frid) => !touched.has(`${entry.moduleName}:${frid}`));
+            const completed = entry.funcIds.filter((funcId) => !touched.has(`${entry.moduleName}:${funcId}`));
             // 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));
+            const tested = ownItems(testsRecord ?? undefined, entry.moduleName, entry.moduleName === tip.moduleName).filter((item) => item.id !== undefined && !marksRegenerateAgain(item) && reads(item) === specText(entry.moduleName, item.id));
             count.completed = completed.length;
-            count.tested = completed.filter((frid) => tested.some((item) => item.frid === frid));
+            count.tested = completed.filter((funcId) => tested.some((item) => item.id === funcId));
             count.conformanceTested = count.tested.length;
-            count.incomplete = entry.frids.filter((frid) => !completed.includes(frid));
+            count.incomplete = entry.funcIds.filter((funcId) => !completed.includes(funcId));
         });
         return { codebase: tip.buildDir, modules: counts };
     }));
@@ -177,17 +225,6 @@ export function createWorkLoop(options) {
     const order = [];
     const run = options.run ?? defaultRunner;
     const runConformance = options.runConformance ?? defaultConformanceRunner;
-    // Off unless the config turns it on: all (true), or chosen.
-    const configConformance = options.conformanceOn ?? ((plainFile) => conformanceSwitchedOn(configForSpec(plainFile).conformanceTests));
-    /** When the chooser decides: after each code pulse (chosen), once the module is regenerated (module), or never. */
-    const chooseWhen = (plainFile) => options.conformanceChoosing !== undefined
-        ? options.conformanceChoosing(plainFile)
-        : options.conformanceChosen !== undefined
-            ? options.conformanceChosen(plainFile)
-                ? "pulse"
-                : undefined
-            : choosingWhen(configForSpec(plainFile).conformanceTests);
-    const configChosen = (plainFile) => chooseWhen(plainFile) !== undefined;
     // One tick at a time: each reads the records and the spec, and decides.
     let ticking = Promise.resolve();
     const tipEntry = (state) => tipOf(state.chain);
@@ -219,159 +256,123 @@ export function createWorkLoop(options) {
     /** What the code is built from, as a key: a conformance plan made against other code is made again. */
     const codeKeyOf = (state) => serializeTree(readRecord(tipEntry(state).buildDir) ?? {});
     /**
-     * What the conformance tests are to be written for now: of what the code is built from, what is chosen, with the test
-     * reqs as the spec has them. `from`: the tests the work starts from - what a running pulse will land, when the work
+     * What the conformance tests are to be written for now: of what the code is built from, the functional specs with
+     * scenarios, with the test reqs as the spec has them. `from`: the tests the work starts from - what a running pulse will land, when the work
      * after it is planned ahead - else the tests record as it is. Read from the record alone, a pulse still writing a
      * functional spec's tests would not count them: one whose code is behind the spec would be planned out, its tests
      * taken out again once they landed.
      */
-    const conformanceOf = (state, spec, from) => {
+    const conformanceOf = (state, spec, from, narrowed = true) => {
         const tests = from ?? readRecord(testsDirOf(state));
-        const target = conformanceTarget(readRecord(tipEntry(state).buildDir), tests, spec.tree, chosenOf(state, spec, tests));
+        const whole = conformanceTarget(readRecord(tipEntry(state).buildDir), tests, spec.tree);
+        const target = narrowed ? onlyNamed(state, whole, tests, spec.tree) : whole;
         // No functional spec to test, and none tested: nothing to write - the reqs alone are no conformance job.
-        const specsIn = (tree) => (tree?.[FUNCTIONAL_REQUIREMENTS] ?? []).length;
+        const specsIn = (tree) => (tree?.[FUNCTIONAL_REQUIREMENTS] ?? []).length + (tree?.[REQUIRED_FUNCTIONAL_SPECS] ?? []).length;
         return specsIn(target) === 0 && specsIn(tests) === 0 ? (tests ?? {}) : target;
     };
     /**
-     * Which functional specs the conformance tests are for: every one - unless the config has them for the chosen ones,
-     * or the conversation named some over a config that has them off. Then: those named, those with acceptance tests
-     * when the config chooses, and those tested already - a choice is kept, and tests are never taken out because
-     * other functional specs were named.
+     * Whether a codebase's conformance tests are written: with test reqs to write them by, and code to test. What they are
+     * written for is the functional specs with scenarios (conformanceOf): a scenario added, changed or taken out, the
+     * functional spec's text changed, regenerated again or taken out - the tests of each are behind, and are written.
      */
-    const chosenOf = (state, spec, tests) => {
-        const named = state.conformance?.chosen;
-        const choosing = configChosen(tipEntry(state).plainFile);
-        if (!choosing && (state.conformance === undefined || named === undefined || configConformance(tipEntry(state).plainFile)))
-            return undefined;
-        if (choosing && state.conformance !== undefined && named === undefined)
-            return undefined;
-        const tested = new Set((tests?.[FUNCTIONAL_REQUIREMENTS] ?? []).map((item) => item.frid));
-        const specs = spec.tree[FUNCTIONAL_REQUIREMENTS] ?? [];
-        const accepted = (frid) => (specs[Number(frid) - 1]?.[ACCEPTANCE_TESTS] ?? []).length > 0;
-        return (frid) => tested.has(frid) || named?.has(frid) === true || (choosing && accepted(frid));
-    };
+    const conformanceWanted = (state, spec) => conformanceTestsOn(tipEntry(state).plainFile) &&
+        (spec.tree[TEST_REQUIREMENTS] ?? []).length > 0 && readRecord(tipEntry(state).buildDir) !== null && gapOf(state, spec) === undefined;
     /**
-     * Under `conformance-tests: chosen`: the functional specs a code job built or changed that no conformance test is
-     * for or is to be for - for the conversation to choose from.
+     * The step of adding tests a codebase skipped - its functional specs have scenarios, and it has no test reqs or no
+     * conformance testing script for its stack: no conformance pulse of it starts, in the loop or from conform, and it
+     * waits on that step until the spec or the scripts change.
      */
-    const toChoose = (state, planned, spec) => {
-        if (planned.track !== "code" || !configChosen(tipEntry(state).plainFile))
-            return [];
-        const chosen = chosenOf(state, spec, readRecord(testsDirOf(state)));
-        if (chosen === undefined)
-            return [];
-        const scheduled = new Set((state.scheduled ?? []).flatMap((group) => group.specs.map((touched) => touched.frid)));
-        return [...planned.cases.add, ...planned.cases.patch].filter((touched) => !chosen(touched.frid) && !scheduled.has(touched.frid));
+    const gapOf = (state, spec) => {
+        const tip = tipEntry(state);
+        return testingGap({ moduleName: tip.moduleName, plainFile: tip.plainFile, tree: spec.tree, buildDir: tip.buildDir });
     };
     /**
-     * Under `conformance-budget:`: how many more of the module's functional specs may be chosen - the budget less every
-     * one chosen for it already, tested or scheduled, whenever that was; those with acceptance tests do not count. Undefined:
-     * no budget.
+     * The functional specs conform is asked for, as the spec has them now - refused when one is not in the spec, or has no
+     * scenarios to test.
      */
-    const budgetLeft = (state, spec) => {
-        const budget = configForSpec(tipEntry(state).plainFile).conformanceBudget;
-        if (budget === undefined)
-            return undefined;
-        const items = spec.tree[FUNCTIONAL_REQUIREMENTS] ?? [];
-        const tests = readRecord(testsDirOf(state));
-        const tested = new Set((tests?.[FUNCTIONAL_REQUIREMENTS] ?? []).map((item) => item.frid));
-        const named = state.conformance?.chosen ?? new Set();
-        const scheduled = new Set((state.scheduled ?? []).flatMap((group) => group.specs.map((touched) => touched.frid)));
-        const used = items.filter((item, index) => {
-            const frid = String(index + 1);
-            return (item[ACCEPTANCE_TESTS] ?? []).length === 0 && (tested.has(frid) || named.has(frid) || scheduled.has(frid));
-        }).length;
-        return Math.max(0, budgetFor(budget, items.length) - used);
+    const askedSpecs = (moduleName, spec, funcIds) => {
+        const items = spec[FUNCTIONAL_REQUIREMENTS] ?? [];
+        const unknown = funcIds.filter((funcId) => !items.some((item) => item.id === funcId));
+        if (unknown.length > 0)
+            throw new Error(`${moduleName} has no functional spec ${namesOf(moduleName, unknown)}. Nothing was started.`);
+        const untested = funcIds.filter((funcId) => !hasScenarios(items.find((item) => item.id === funcId)));
+        if (untested.length > 0) {
+            throw new Error(`${namesOf(moduleName, untested)} ${untested.length === 1 ? "has" : "have"} no scenarios - no test plain file - so there is nothing to test: ` +
+                "write the conformance or acceptance scenarios first, with change_plain, and their tests are written once the code is built. Nothing was started.");
+        }
     };
     /**
-     * Under `conformance-tests: chosen`: every functional spec of the module that is built and that no conformance test
-     * is for, chosen or scheduled - the module's whole choice, once its code is built.
+     * Whether a codebase lacks a testing script of this kind that is being written in the background now: it waits for it,
+     * rather than fail for want of it, and is looked at again once the run ends.
      */
-    const moduleToChoose = (state, spec) => {
-        if (!configChosen(tipEntry(state).plainFile))
-            return [];
-        const chosen = chosenOf(state, spec, readRecord(testsDirOf(state)));
-        if (chosen === undefined)
-            return [];
-        const scheduled = new Set((state.scheduled ?? []).flatMap((group) => group.specs.map((touched) => touched.frid)));
-        const items = spec.tree[FUNCTIONAL_REQUIREMENTS] ?? [];
-        const frids = items.map((_, index) => String(index + 1));
-        const unbuilt = new Set(notBuilt(readRecord(tipEntry(state).buildDir), spec.tree, frids));
-        return frids
-            .filter((frid) => !unbuilt.has(frid) && !chosen(frid) && !scheduled.has(frid))
-            .map((frid) => ({ frid, text: items[Number(frid) - 1].markdown.trim().split("\n")[0].replace(/^-\s*/, "").trim() }));
+    const awaitsScript = (state, kind) => {
+        const tip = tipEntry(state);
+        const root = projectRootFor(tip.plainFile, tip.buildDir);
+        return scriptBeingWritten(root, kind, stackForModule(tip.plainFile)) && findTestScripts(root, tip.plainFile, tip.buildDir)[kind] === undefined;
     };
     /**
-     * The groups scheduled whose functional specs are all built, as the spec has them: chosen, so their tests are
-     * written. A functional spec taken out of the spec is dropped from its group.
+     * The base folder a codebase started from, as its status says it. Counting the files still there looks at each, and the
+     * status is read often: so it is read again only when the base record or the code record moved - a pulse landed.
      */
-    const promote = (state, spec) => {
-        const chosen = state.conformance?.chosen;
-        if (state.scheduled === undefined || chosen === undefined)
-            return;
-        const count = (spec.tree[FUNCTIONAL_REQUIREMENTS] ?? []).length;
-        const code = readRecord(tipEntry(state).buildDir);
-        state.scheduled = state.scheduled.flatMap((group) => {
-            const specs = group.specs.filter((touched) => Number(touched.frid) <= count);
-            const unbuilt = notBuilt(code, spec.tree, specs.map((touched) => touched.frid));
-            if (specs.length === 0)
-                return [];
-            if (unbuilt.length > 0)
-                return [{ specs, unbuilt }];
-            for (const touched of specs)
-                chosen.add(touched.frid);
-            state.together = [...(state.together ?? []), specs];
-            // What the tests are to be written for changed: planned again - after the running job, when one runs.
-            state.conformancePlan = undefined;
-            return [];
-        });
+    const baseOfState = (state) => {
+        const dir = tipEntry(state).buildDir;
+        const at = [BASE_RECORD_FILE, RECORD_FILE].map((name) => modifiedAt(join(dir, name))).join(":");
+        if (state.base?.at !== at) {
+            const started = baseOfCodebase(dir);
+            state.base = { at, base: started !== undefined ? { folder: started.folder, files: started.files.length } : undefined };
+        }
+        return state.base.base;
     };
-    /** Whether a codebase's conformance tests are written: asked for, or on in the config - with test reqs to write them from, and code to test. */
-    const conformanceWanted = (state, spec) => (state.conformance !== undefined || configConformance(tipEntry(state).plainFile)) &&
-        (spec.tree[TEST_REQUIREMENTS] ?? []).length > 0 &&
-        readRecord(tipEntry(state).buildDir) !== null;
     /**
-     * The functional specs a conformance job is scheduled for, as the spec has them now - refused when one is not in
-     * the spec, or the module has no test reqs to write tests from: no code job would build it, or no test be written.
+     * What the conformance tests are to be written for, as conform narrowed it to the functional specs it named: every other
+     * functional spec as the tests are written for it now - its tests neither written, changed nor taken out. One whose text
+     * or scenarios changed since joins those named: a change to it is work again.
      */
-    const scheduledSpecs = (state, frids) => {
-        const tip = tipEntry(state);
-        const spec = chainSpec(state.chain);
-        const items = spec.tree[FUNCTIONAL_REQUIREMENTS] ?? [];
-        const unknown = frids.filter((frid) => !/^[1-9]\d*$/.test(frid) || Number(frid) > items.length);
-        if (unknown.length > 0) {
-            throw new Error(`${tip.moduleName} has ${items.length} functional spec${items.length === 1 ? "" : "s"}, and ${unknown.map((frid) => `fs ${frid}`).join(", ")} ` +
-                `${unknown.length === 1 ? "is not one of them" : "are not among them"}: no code pulse builds ${unknown.length === 1 ? "it" : "them"}, so no conformance ` +
-                "test could ever be written for it. Nothing was scheduled.");
+    const onlyNamed = (state, target, tests, tree) => {
+        const only = state.conformanceOnly;
+        if (only === undefined)
+            return target;
+        for (const section of [FUNCTIONAL_REQUIREMENTS, REQUIRED_FUNCTIONAL_SPECS]) {
+            for (const item of tree[section] ?? []) {
+                const key = identityOf(item);
+                if (!only.specs.has(key) && only.read.get(key) !== JSON.stringify(item))
+                    only.specs.add(key);
+            }
         }
-        if ((spec.tree[TEST_REQUIREMENTS] ?? []).length === 0) {
-            throw new Error(`${tip.moduleName} has no ***test reqs***: conformance tests are written from them, so none can be. Nothing was scheduled.`);
+        const narrowed = { ...target };
+        for (const section of [FUNCTIONAL_REQUIREMENTS, REQUIRED_FUNCTIONAL_SPECS]) {
+            const tested = new Map(((tests?.[section] ?? [])).map((item) => [identityOf(item), item]));
+            const wanted = (target[section] ?? []).flatMap((item) => {
+                if (only.specs.has(identityOf(item)))
+                    return [item];
+                // Not named: as its tests are written for it now, or - none written - not at all.
+                const kept = tested.get(identityOf(item));
+                return kept !== undefined ? [kept] : [];
+            });
+            // Taken out of the target and not named: its tests are kept, as they are.
+            const inTarget = new Set(wanted.map(identityOf));
+            for (const [key, item] of tested)
+                if (!only.specs.has(key) && !inTarget.has(key))
+                    wanted.push(item);
+            if (wanted.length > 0)
+                narrowed[section] = wanted;
+            else
+                delete narrowed[section];
         }
-        return frids.map((frid) => ({ frid, text: items[Number(frid) - 1].markdown.trim().split("\n")[0].replace(/^-\s*/, "").trim() }));
+        return narrowed;
     };
-    /** Functional specs of a module scheduled for conformance tests, beside those chosen before - as conform does for the module's own - in the chooser's pulses, when it planned them. */
-    const schedule = (state, frids, groups) => {
-        const before = state.conformance;
-        // Every one is tested already: nothing to add.
-        if (before !== undefined && before.chosen === undefined)
-            return;
-        let specs;
-        try {
-            specs = scheduledSpecs(state, frids);
-        }
-        catch (error) {
-            reportActivity(`  ${tipEntry(state).moduleName}: the conformance tests chosen were not scheduled - ${error instanceof Error ? error.message : String(error)}`);
-            return;
-        }
-        state.conformance = { chosen: before?.chosen ?? new Set() };
-        state.scheduled = [...(state.scheduled ?? []), { specs, unbuilt: specs.map((touched) => touched.frid) }];
-        if (groups !== undefined && groups.length > 0) {
-            state.conformanceGroups = [...(state.conformanceGroups ?? []), ...groups];
-            state.conformancePlan = undefined;
+    /** The functional specs conform named - its own module's func-ids - and every functional spec as it reads now, to tell a change to one after. */
+    const namedOnly = (state, funcIds) => {
+        const tree = chainSpec(state.chain).tree;
+        const read = new Map();
+        for (const section of [FUNCTIONAL_REQUIREMENTS, REQUIRED_FUNCTIONAL_SPECS]) {
+            for (const item of tree[section] ?? [])
+                read.set(identityOf(item), JSON.stringify(item));
         }
+        return { specs: new Set(funcIds.map((id) => identityOf({ id }))), read };
     };
-    /** The work of a track, from where it is built from to what it is to be. */
-    const workOf = (track, from, state, spec) => track === "code" ? codeWork(from, spec.tree) : changesBetween(serializeTree(from), serializeTree(conformanceOf(state, spec, from)));
+    /** The work of a track, from where it is built from to what it is to be - for the conformance tests, as conform narrowed them unless `narrowed` is false. */
+    const workOf = (track, from, state, spec, narrowed = true) => track === "code" ? codeWork(from, spec.tree) : changesBetween(serializeTree(from), serializeTree(conformanceOf(state, spec, from, narrowed)));
     /** The codebases brought up in this look: one left behind is never waited for. */
     let looking = new Set();
     /**
@@ -394,8 +395,6 @@ export function createWorkLoop(options) {
                 return waiting("the code it is built on is not built yet");
             if (below.conformanceHalted !== undefined)
                 return waiting(`its conformance tests did not pass - ${below.conformanceHalted.why}`);
-            if ((below.scheduled ?? []).length > 0)
-                return waiting("the conformance tests chosen for it are not written yet");
             if (conformanceWanted(below, spec) && workOf("conformance", testedOf(below), below, spec).length > 0)
                 return waiting("its conformance tests are not written yet");
         }
@@ -462,9 +461,11 @@ export function createWorkLoop(options) {
         // How big a pulse may be: the module's config, else the defaults.
         const config = configForSpec(tip.plainFile);
         const limits = { specs: config.maxSpecsPerPulse ?? MAX_SPECS_PER_JOB, lines: config.maxLinesPerPulse ?? MAX_LINES_PER_JOB };
-        // The conformance tests the person asked for in groups of their own - 1-3, then 4-6: a group never shares a job with another.
-        const groups = track === "conformance" && state.conformanceGroups !== undefined && state.conformanceGroups.length > 0 ? state.conformanceGroups : undefined;
-        const input = { base: from, current, specFile, specText, steering, track, moduleName: tip.moduleName, limits, ...(separately ? { separately } : {}), ...(groups !== undefined ? { groups } : {}) };
+        const testPlainPath = track === "conformance" ? testPlainPathOf(spec.tree, tip.moduleName, tip.plainFile, dirname(specFile)) : undefined;
+        // A pure rename is turri's to make before the next pulse, not a delete and an add: the work is planned from the code as renamed.
+        const renamed = track === "code" ? pureRenames(from, readRecord(testsDirOf(state)), spec.tree, tip.moduleName) : undefined;
+        const base = renamed !== undefined && renamed.renames.length > 0 && renamed.code !== null ? codeTree(renamed.code) : from;
+        const input = { base, current, specFile, specText, steering, track, moduleName: tip.moduleName, limits, ...(separately ? { separately } : {}), ...(testPlainPath !== undefined ? { testPlainPath } : {}) };
         const model = typeof options.plannerModel === "function" ? options.plannerModel() : options.plannerModel;
         const agents = options.planner === false ? undefined : (options.planner ?? llmChunkAgents({ cwd: options.cwd, model: model ?? state.model, label: `${basename(tip.plainFile)} planner` }));
         reportStage(`${tip.moduleName}: planning the ${track === "code" ? "work" : "conformance tests"} into pulses`);
@@ -510,8 +511,10 @@ export function createWorkLoop(options) {
         const conformance = planned.track === "conformance";
         // A code job can be steered while it regenerates: its target moves with the spec, inside what it regenerates.
         const steering = conformance ? undefined : createSteering(planned.step.tree, tip.moduleName);
-        // Shown as its agent is given it: the job's own items, from whichever file they are written in - its imports too.
-        const shown = changeDiffInFiles(agentChanges(planned.step.changes, planned.track), relative(projectDirOf(tip.plainFile), tip.plainFile) || basename(tip.plainFile), (diff) => whereInFiles(diff, state.chain));
+        // Shown as its agent is given it: the job's own items, from whichever file they are written in - its imports too, and
+        // for the conformance tests the test plain files of the functional specs whose scenarios it carries out.
+        const moduleFile = relative(projectDirOf(tip.plainFile), tip.plainFile) || basename(tip.plainFile);
+        const shown = changeDiffInFiles(agentChanges(planned.step.changes, planned.track), moduleFile, (diff) => whereInFiles(diff, state.chain), conformance ? { module: tip.moduleName, pathOf: testPlainPathOf(spec.tree, tip.moduleName, tip.plainFile, dirname(moduleFile)) } : undefined);
         const job = options.registry.start({
             kind: conformance ? "conformance" : "regenerate",
             summary: `${basename(tip.plainFile)} ${conformance ? "conformance: " : ""}${planned.title}`,
@@ -530,13 +533,13 @@ 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, ...planned.cases.again].map((touched) => touched.frid);
-                    const missing = notBuilt(readRecord(tip.buildDir), planned.step.tree, testing);
+                    const testing = [...planned.cases.add, ...planned.cases.patch, ...planned.cases.again];
+                    const missing = notBuilt(readRecord(tip.buildDir), planned.step.tree, testing, tip.moduleName);
                     if (missing.length > 0) {
                         const record = relative(options.cwd, join(tip.buildDir, RECORD_FILE));
-                        const notBuiltText = `${missing.map((frid) => `fs ${frid}`).join(", ")} ${missing.length === 1 ? "is" : "are"} not built`;
+                        const notBuiltText = `${refsOf(tip.moduleName, missing)} ${missing.length === 1 ? "is" : "are"} not built`;
                         return {
-                            report: `Not started: this conformance pulse is to test ${testing.map((frid) => `fs ${frid}`).join(", ")}, and ${notBuiltText} - ` +
+                            report: `Not started: this conformance pulse is to test ${refsOf(tip.moduleName, testing)}, and ${notBuiltText} - ` +
                                 `${record} does not have ${missing.length === 1 ? "it" : "them"} as the spec has ${missing.length === 1 ? "it" : "them"}. ` +
                                 "No conformance test is written for code that is not built. Tell the user, and see with drift which code pulse regenerates it.",
                             details: { passed: false, landed: false, notBuilt: notBuiltText },
@@ -548,13 +551,14 @@ export function createWorkLoop(options) {
                     const below = state.chain.find((entry) => entry.moduleName === tip.requires);
                     const source = below === undefined ? null : readRecord(below.buildDir);
                     if (below !== undefined && source !== null) {
+                        // Its conformance tests come with the code, and what they are written for, as what it inherits.
                         copyRequiredCode(below.buildDir, tip.buildDir, tip.moduleName, below.moduleName);
-                        // Its conformance tests come with the code, the ones below's: none of its own is written yet.
-                        if (existsSync(join(testsDirOf(state), RECORD_FILE)))
-                            writeTestsRecord(testsDirOf(state), {});
                     }
                 }
-                // A conformance job is shown the spec whole - its test reqs and acceptance tests are its to write from.
+                // Nothing here yet, and nothing below: the codebase starts from its base folder, when the config names one.
+                if (tip.requires === null && !started(tip))
+                    inStack(state, () => seedFromBaseFolder(tip.buildDir, tip.plainFile, tip.moduleName));
+                // A conformance job is shown the spec whole - its test reqs and scenarios are its to write from.
                 const result = await (conformance ? runConformance : run)({
                     plainFile: tip.plainFile,
                     moduleName: tip.moduleName,
@@ -565,35 +569,7 @@ export function createWorkLoop(options) {
                     cwd: options.cwd,
                     ...(steering !== undefined ? { steering } : {}),
                 }, onDelta);
-                // Under conformance-tests: chosen or module, the chooser decides as the pulse's last stage - before it ends, so the
-                // choice is made, and its conformance pulse scheduled, before anything can be built on the module. Under chosen, of
-                // what this pulse regenerated; under module, once the module is regenerated, of all of it - and in which pulses.
-                let chose;
-                const when = chooseWhen(tip.plainFile);
-                if (result.landed && planned.track === "code" && when !== undefined && options.onChoose !== undefined) {
-                    const now = chainSpec(state.chain);
-                    const candidates = when === "pulse" ? toChoose(state, planned, now) : codeWork(builtOf(state), now.tree).length === 0 ? moduleToChoose(state, now) : [];
-                    const left = budgetLeft(state, now);
-                    if (candidates.length > 0 && left === 0)
-                        chose = `conformance: the module's conformance budget is spent - none of fs ${candidates.map((touched) => touched.frid).join(", ")} is chosen`;
-                    else if (candidates.length > 0) {
-                        reportStage(`module ${tip.moduleName}: choosing its conformance tests`);
-                        const picked = await options.onChoose(tip.plainFile, candidates, left, when);
-                        // Within the budget, whatever was answered: the first that fit.
-                        const frids = picked === undefined ? [] : left !== undefined ? picked.frids.slice(0, left) : picked.frids;
-                        const groups = picked?.groups?.map((group) => group.filter((frid) => frids.includes(frid))).filter((group) => group.length > 0);
-                        if (frids.length > 0)
-                            schedule(state, frids, groups);
-                        const why = picked?.why !== undefined ? ` - ${picked.why.replace(/\s+/g, " ").trim()}` : "";
-                        chose =
-                            frids.length > 0
-                                ? `conformance: fs ${frids.join(", ")} chosen${groups !== undefined && groups.length > 1 ? `, in ${groups.length} pulses (${groups.map((group) => group.join(", ")).join(" / ")})` : ""}${why}`
-                                : `conformance: none of fs ${candidates.map((touched) => touched.frid).join(", ")} chosen${why}`;
-                    }
-                    if (chose !== undefined)
-                        reportActivity(`  ${tip.moduleName}: ${chose}`);
-                }
-                const report = chose !== undefined ? `${result.report}\n\n${chose}` : result.report;
+                const report = result.report;
                 // Released as its last stage, when the config says so: the module's next pulse starts on what is released.
                 let released;
                 if (result.landed && options.release !== undefined && configForSpec(tip.plainFile).releaseAfterPulse === true) {
@@ -647,7 +623,6 @@ export function createWorkLoop(options) {
             return;
         state.plan = undefined;
         state.conformancePlan = undefined;
-        // What the person asked of it - conformance tests chosen or scheduled - stays: it is asked of the code regenerated.
         state.halted = undefined;
         state.conformanceHalted = undefined;
         state.startOver = undefined;
@@ -780,6 +755,11 @@ export function createWorkLoop(options) {
             .catch((error) => reportActivity(`  the work loop: ${error instanceof Error ? error.message : String(error)}`));
         return ticking;
     };
+    // A testing script written in the background, or not: what waited for it is looked at again - started, or failed for want of it.
+    onScriptRunEnded(() => {
+        if (asked.size > 0 && options.dryRun !== true)
+            void tick();
+    });
     /** The files asked for, each with how: what the loop brings up, worked out again each look. */
     const asked = new Map();
     /**
@@ -840,19 +820,28 @@ export function createWorkLoop(options) {
         }
         const now = active();
         looking = now;
-        for (const key of order) {
-            const state = modules.get(key);
-            // A codebase left behind - built on since - is not looked at, unless a job of it is still running; what it had
-            // planned, or waited for, is no longer shown.
-            if (now.has(state) || state.running !== undefined)
-                await inStack(state, () => look(state));
-            else {
-                state.why = "left behind: the code is built on further up the chain, where changes to it are made";
-                state.waitsFor = undefined;
-                state.plan = undefined;
-                state.conformancePlan = undefined;
+        // Why each codebase stands as it does, before this look: one that changed is told, as a plan that changed is - a
+        // module that starts or stops waiting moves no job, and would otherwise go unseen until something else did.
+        const whyBefore = new Map([...modules.values()].map((state) => [state, state.why]));
+        try {
+            for (const key of order) {
+                const state = modules.get(key);
+                // A codebase left behind - built on since - is not looked at, unless a job of it is still running; what it had
+                // planned, or waited for, is no longer shown.
+                if (now.has(state) || state.running !== undefined)
+                    await inStack(state, () => look(state));
+                else {
+                    state.why = "left behind: the code is built on further up the chain, where changes to it are made";
+                    state.waitsFor = undefined;
+                    state.plan = undefined;
+                    state.conformancePlan = undefined;
+                }
             }
         }
+        finally {
+            if ([...modules.values()].some((state) => state.why !== whyBefore.get(state)))
+                options.registry.notify?.();
+        }
     };
     const look = async (state) => {
         const tip = tipEntry(state);
@@ -872,7 +861,14 @@ export function createWorkLoop(options) {
         }
         const specKey = keyOf(spec);
         state.seen = spec;
-        promote(state, spec);
+        if (options.onSpec !== undefined) {
+            try {
+                options.onSpec({ chain: state.chain, tree: spec.tree, built: builtOf(state) });
+            }
+            catch {
+                /* what watches the spec never stops the loop */
+            }
+        }
         if (state.running !== undefined) {
             if (state.running.stopping === true)
                 return;
@@ -933,8 +929,15 @@ export function createWorkLoop(options) {
             }
             state.halted = undefined;
         }
-        const fresh = newlyRequired(state.chain);
         state.startOver = undefined;
+        // Built when functional specs were numbered, before func-ids: nothing is built on it - its chain starts over.
+        const old = oldCodebases(state.chain);
+        if (old.length > 0) {
+            state.startOver = { requires: [], codebases: old.map((entry) => entry.moduleName), old: true };
+            state.why = OLD_RECORDS_WHY(old.map((entry) => entry.moduleName));
+            return;
+        }
+        const fresh = newlyRequired(state.chain);
         if (fresh !== undefined && fresh.rebuild.some((entry) => entry.buildDir === tip.buildDir)) {
             const codebases = fresh.rebuild.map((entry) => entry.moduleName);
             state.startOver = { requires: fresh.modules, codebases };
@@ -949,6 +952,19 @@ export function createWorkLoop(options) {
             state.why = below.why;
             return;
         }
+        // A func-id or a scenario-id renamed, and nothing else with it: turri renames it in the records and relabels the tests
+        // itself, as one unit of work - no pulse, the code untouched. Failing, it is rolled back whole, and the codebase halts
+        // rather than build the functional spec anew.
+        const renamed = options.dryRun === true || readRecord(tip.buildDir) === null ? undefined : pureRenames(readRecord(tip.buildDir), readRecord(testsDirOf(state)), spec.tree, tip.moduleName);
+        if (renamed !== undefined && renamed.renames.length > 0) {
+            const made = makeRenames({ buildDir: tip.buildDir, testsDir: testsDirOf(state), moduleName: tip.moduleName, renamed, place: { project: projectRootOf(tip.buildDir), module: tip.moduleName } });
+            if (!made) {
+                state.halted = { why: `renaming ${renamed.renames.map(renameText).join(", ")} failed, and was rolled back - it is tried again once the spec changes, or the module is asked for again`, specKey };
+                state.why = state.halted.why;
+                record({ kind: "loop.halted", why: firstLine(state.halted.why, 300), track: "code" }, { project: projectRootOf(tip.buildDir), module: tip.moduleName });
+                return;
+            }
+        }
         // The module's code first, every job of it; then its conformance tests - once, for the module as built, with one
         // explorer and one run of the whole suite - and only then is anything built on it (waitingOn).
         const from = builtOf(state);
@@ -974,13 +990,19 @@ export function createWorkLoop(options) {
             }
             else {
                 state.conformancePlan = undefined;
-                state.together = undefined;
-                state.conformanceGroups = undefined;
             }
         }
         if (!codeLeft) {
             state.plan = undefined;
-            state.why = state.conformanceHalted?.why ?? UP_TO_DATE;
+            // Its scenarios untested for a step of adding tests it skipped: no conformance pulse starts - it waits on that step.
+            const gap = state.conformanceHalted === undefined && readRecord(tip.buildDir) !== null ? gapOf(state, spec) : undefined;
+            state.why =
+                state.conformanceHalted?.why ??
+                    (gap === undefined
+                        ? UP_TO_DATE
+                        : gap.step === "conformance testing script" && awaitsScript(state, "conformance")
+                            ? SCRIPT_BEING_WRITTEN("conformance testing script")
+                            : `waiting for its ${gap.step}: ${gap.text}`);
             return;
         }
         const fromKey = serializeTree(from);
@@ -993,6 +1015,10 @@ export function createWorkLoop(options) {
                 return;
             }
         }
+        if (awaitsScript(state, "unit")) {
+            state.why = SCRIPT_BEING_WRITTEN("unit testing script");
+            return;
+        }
         state.why = undefined;
         startJob(state, spec, from, state.plan.jobs[0]);
     };
@@ -1024,43 +1050,48 @@ export function createWorkLoop(options) {
             ...(replanning === "code" ? [] : own(state.plan?.jobs)),
             ...(replanning === "conformance" ? [] : own(state.conformancePlan?.jobs)),
         ];
-        // A scheduled conformance job comes after the module's last code job - last, when none is planned.
         const lastCode = jobs.findLastIndex((job) => job.track === "code");
-        const after = (state.scheduled ?? []).map(() => lastCode);
-        const scheduledAt = (index) => (state.scheduled ?? []).flatMap((group, at) => after[at] !== index
-            ? []
-            : [{ title: group.specs.map((touched) => `fs ${touched.frid}`).join(", "), cases: { fresh: false, add: group.specs, patch: [], again: [], delete: [], mechanical: false }, track: "conformance", waitsFor: group.unbuilt }]);
-        // Being planned, nothing running: what is next - for the conformance tests, the groups chosen that it plans - not nothing.
-        const together = (state.together ?? []).flat().map((touched) => `fs ${touched.frid}`);
         const planningNow = planningTrack !== undefined
             ? [
                 {
-                    title: planningTrack === "conformance" ? (together.length > 0 ? together.join(", ") : "the conformance tests") : "the work",
+                    title: planningTrack === "conformance" ? "the conformance tests" : "the work",
                     cases: { fresh: false, add: [], patch: [], again: [], delete: [], mechanical: false },
                     track: planningTrack,
                     planning: true,
                 },
             ]
             : [];
-        // The module's conformance tests, wanted for all of it while code is still to build: planned once it is built, shown now.
+        // The conformance tests that follow the code still to build - of its functional specs with scenarios whose tests
+        // are not written for them as they read now: planned once the code is built, shown now.
         const codeToBuild = lastCode !== -1 || planningTrack === "code";
-        const testReqs = (state.seen?.tree[TEST_REQUIREMENTS] ?? []).length > 0;
-        const plainFile = tipEntry(state).plainFile;
-        const wholeModule = (state.conformance !== undefined && state.conformance.chosen === undefined) || (configConformance(plainFile) && !configChosen(plainFile));
-        const afterCode = codeToBuild && testReqs && wholeModule && state.conformanceHalted === undefined && !jobs.some((job) => job.track === "conformance")
-            ? [{ title: "conformance tests", cases: { fresh: false, add: [], patch: [], again: [], delete: [], mechanical: false }, track: "conformance", afterCode: true }]
+        const seen = state.seen?.tree;
+        // Not with a step of adding tests skipped: they are not planned until it is taken.
+        const testReqs = (seen?.[TEST_REQUIREMENTS] ?? []).length > 0 &&
+            codeToBuild &&
+            testingGap({ moduleName: tipEntry(state).moduleName, plainFile: tipEntry(state).plainFile, tree: seen, buildDir: tipEntry(state).buildDir }) === undefined;
+        // Those of the modules below too: the tip's suite holds the chain's.
+        const tested = testedOf(state);
+        const sections = [REQUIRED_FUNCTIONAL_SPECS, FUNCTIONAL_REQUIREMENTS];
+        const written = new Set(sections.flatMap((section) => (tested[section] ?? []).map((item) => JSON.stringify(item))));
+        const behind = sections.flatMap((section) => (seen?.[section] ?? []).filter((item) => hasScenarios(item) && !written.has(JSON.stringify(item))));
+        const afterCode = codeToBuild && testReqs && behind.length > 0 && state.conformanceHalted === undefined && !jobs.some((job) => job.track === "conformance")
+            ? [{ title: "conformance tests", cases: { fresh: false, add: [], patch: [], again: [], delete: [], mechanical: false }, track: "conformance", afterCode: true, specs: behind.map((item) => `${item.module ?? tipEntry(state).moduleName}:${item.id}`) }]
             : [];
         const listed = [
             ...planningNow.map((entry) => ({ entry })),
-            ...jobs.flatMap((job, index) => [{ entry: { title: job.title, cases: job.cases, track: job.track }, job }, ...scheduledAt(index).map((entry) => ({ entry }))]),
-            ...scheduledAt(-1).map((entry) => ({ entry })),
+            ...jobs.map((job) => ({ entry: { title: job.title, cases: job.cases, track: job.track }, job })),
             ...afterCode.map((entry) => ({ entry })),
         ];
         const planned = listed.map((item) => item.entry);
         const tip = tipEntry(state);
+        // While a pulse runs, the renames made once it ends: shown as renames, never as a functional spec taken out and one added.
+        const renames = state.running !== undefined && state.running.planned.track === "code" && seen !== undefined ? pureRenames(readRecord(tip.buildDir), readRecord(testsDirOf(state)), seen, tip.moduleName).renames : [];
+        const base = baseOfState(state);
         const status = {
             module: tip.moduleName,
             plainFile: tip.plainFile,
+            ...(base !== undefined ? { base } : {}),
+            ...(renames.length > 0 ? { renames: renames.map(renameText) } : {}),
             ...(state.stack?.name !== undefined ? { stack: state.stack.name } : {}),
             ...(state.running !== undefined
                 ? {
@@ -1076,7 +1107,8 @@ export function createWorkLoop(options) {
             ...(state.running === undefined && state.why !== undefined ? { why: state.why } : {}),
             ...(state.running === undefined && state.startOver !== undefined ? { startOver: state.startOver } : {}),
         };
-        return { status, jobs: (state.running !== undefined ? listed.slice(1) : listed).map((item) => item.job), scheduled: (state.running !== undefined ? listed.slice(1) : listed).map((item) => (item.entry.waitsFor !== undefined ? { title: item.entry.title, specs: item.entry.cases.add.map((touched) => touched.text) } : undefined)) };
+        const shown = state.running !== undefined ? listed.slice(1) : listed;
+        return { status, jobs: shown.map((item) => item.job), ahead: shown.map((item) => (item.entry.afterCode === true ? { title: item.entry.title, specs: item.entry.specs ?? [] } : undefined)) };
     };
     /**
      * Look after a codebase - its chain up to it - from now on; says its state. `pin`: its stack is worked out again - its
@@ -1125,6 +1157,9 @@ export function createWorkLoop(options) {
                     state.halted = undefined;
                     if (specChange !== true)
                         state.held = undefined;
+                    // Asked for again: its conformance tests are written for every functional spec with scenarios, not only those conform named.
+                    if (specChange !== true)
+                        state.conformanceOnly = undefined;
                 }
                 await tick();
                 return [...new Set(states)].map(statusOf);
@@ -1134,10 +1169,10 @@ export function createWorkLoop(options) {
         },
         async regenerateAgain(plainFile, given, request = {}) {
             return preparingFor(plainFile, async () => {
-                const frids = [...new Set(Array.isArray(given) ? given : [given])];
                 const asked = resolve(options.cwd, plainFile);
                 const own = resolveRequiresChain(asked, [], undefined, { allowNoFunctionalities: true });
                 const module = tipOf(own).moduleName;
+                const funcIds = funcIdsNamed(module, [...new Set(Array.isArray(given) ? given : [given])]);
                 const chains = chainsFor(asked);
                 for (const chain of chains) {
                     const tip = tipOf(chain);
@@ -1152,33 +1187,32 @@ export function createWorkLoop(options) {
                         continue;
                     const section = tip.moduleName === module ? FUNCTIONAL_REQUIREMENTS : REQUIRED_FUNCTIONAL_SPECS;
                     const items = record[section] ?? [];
-                    const named = (item, index) => section === FUNCTIONAL_REQUIREMENTS ? String(index + 1) : item.module === module ? (item.frid ?? "") : "";
-                    const taken = items.flatMap((item, index) => (frids.includes(named(item, index)) ? [named(item, index)] : []));
+                    const named = (item) => (section === FUNCTIONAL_REQUIREMENTS || item.module === module ? (item.id ?? "") : "");
+                    const taken = items.flatMap((item) => (funcIds.includes(named(item)) ? [named(item)] : []));
                     if (taken.length === 0)
                         continue;
-                    for (const frid of taken)
-                        found.add(frid);
-                    const marked = items.map((item, index) => (frids.includes(named(item, index)) ? { ...item, [REGENERATE_AGAIN]: true } : item));
+                    for (const funcId of taken)
+                        found.add(funcId);
+                    const marked = items.map((item) => (funcIds.includes(named(item)) ? { ...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 });
-                        }
+                    // Its conformance tests were written against the code being replaced: marked with it, in the tests record of the
+                    // same codebase - the tip's suite holds the chain's - they are written again, checked against the new code, and
+                    // rewritten where they relied on what the old code chose, once it lands.
+                    const testsDir = conformanceDirFor(tip.moduleName, modulesRoot(projectDirOf(tip.plainFile)));
+                    const tests = readRecord(testsDir);
+                    const tested = tests?.[section] ?? [];
+                    if (tested.some((item) => taken.includes(named(item)))) {
+                        const again = tested.map((item) => (taken.includes(named(item)) ? { ...item, [REGENERATE_AGAIN]: true } : item));
+                        writeTestsRecord(testsDir, { ...tests, [section]: again });
                     }
-                    recordHistory(tip.buildDir, `${module} functional spec${taken.length === 1 ? "" : "s"} ${taken.join(", ")} to regenerate again`);
+                    recordHistory(tip.buildDir, `${namesOf(module, taken)} to regenerate again`);
                 }
-                const missing = frids.filter((frid) => !found.has(frid));
+                const missing = funcIds.filter((funcId) => !found.has(funcId));
                 if (found.size === 0)
-                    throw new Error(`${module} has no functional spec ${missing.join(", ")} built anywhere, so there is nothing to regenerate again: regenerate builds what is not built.`);
+                    throw new Error(`${namesOf(module, missing)} ${missing.length === 1 ? "is" : "are"} not built anywhere, so there is nothing to regenerate again: regenerate builds what is not built.`);
                 const statuses = await loop.bringUp(plainFile, request);
                 if (missing.length > 0)
-                    reportActivity(`  ${module}: functional spec ${missing.join(", ")} is not built anywhere - nothing to regenerate again there`);
+                    reportActivity(`  ${namesOf(module, missing)} ${missing.length === 1 ? "is" : "are"} not built anywhere - nothing to regenerate again there`);
                 return statuses;
             });
         },
@@ -1190,7 +1224,7 @@ export function createWorkLoop(options) {
                 // The codebase as the loop knows it, or - never asked for - as its records have it.
                 const state = modules.get(tip.buildDir) ?? { chain: codebase, askedFile: file, guidance: [] };
                 return inStack(state, () => {
-                    const report = { module: tip.moduleName, plainFile: tip.plainFile, code: undefined, conformance: undefined, scheduled: [] };
+                    const report = { module: tip.moduleName, plainFile: tip.plainFile, code: undefined, conformance: undefined, ...(conformanceTestsOn(tip.plainFile) ? {} : { conformanceOff: true }) };
                     let spec;
                     try {
                         spec = chainSpec(codebase);
@@ -1198,23 +1232,47 @@ export function createWorkLoop(options) {
                     catch (error) {
                         return { ...report, why: `its spec does not parse: ${error instanceof Error ? error.message : String(error)}` };
                     }
-                    const from = builtOf(state);
+                    // A pure rename is no work: shown as one, and the work worked out as though it were made.
+                    const record = readRecord(tip.buildDir);
+                    const renamed = record === null ? undefined : pureRenames(record, readRecord(testsDirOf(state)), spec.tree, tip.moduleName);
+                    if (renamed !== undefined && renamed.renames.length > 0)
+                        report.renames = renamed.renames.map(renameText);
+                    const from = renamed?.code !== undefined && renamed.code !== null ? codeTree(renamed.code) : builtOf(state);
                     const fresh = tip.requires === null && !started(tip);
+                    // A codebase that requires nothing starts from its base folder: one changed since, or missing, is said.
+                    const base = tip.requires === null ? baseFolderDrift(tip.buildDir, tip.plainFile) : undefined;
+                    if (base !== undefined)
+                        report.baseFolder = base;
                     const code = codeWork(from, spec.tree);
                     report.code = code.length === 0 ? null : casesOf(from, code, { fresh, module: tip.moduleName });
                     if (conformanceWanted(state, spec)) {
-                        const tested = testedOf(state);
-                        const tests = workOf("conformance", tested, state, spec);
+                        const tested = renamed?.tests ?? testedOf(state);
+                        // Against the code record as renamed, when a rename is to be made: the tests follow it.
+                        const tests = renamed !== undefined && renamed.renames.length > 0
+                            ? changesBetween(serializeTree(tested), serializeTree(conformanceTarget(renamed.code, tested, spec.tree)))
+                            : workOf("conformance", tested, state, spec, false);
                         report.conformance = tests.length === 0 ? null : casesOf(tested, tests, { module: tip.moduleName });
+                        // Narrowed by conform to the functional specs it named: the others wait, and why is said.
+                        const only = state.conformanceOnly;
+                        if (only !== undefined && tests.length > 0)
+                            report.conformanceOnly = [...only.specs].map((key) => (key.startsWith(":") ? `${tip.moduleName}${key}` : key));
                     }
-                    report.scheduled = (state.scheduled ?? []).map((group) => ({ frids: group.specs.map((touched) => touched.frid), unbuilt: group.unbuilt }));
                     if (state.running !== undefined)
                         report.running = { jobId: state.running.jobId, title: state.running.planned.title };
                     const halted = state.held?.why ?? state.halted?.why ?? state.conformanceHalted?.why;
                     if (halted !== undefined)
                         report.why = halted;
+                    else {
+                        // Its scenarios untested for a step of adding tests it skipped: said, as the loop says it.
+                        const gap = gapOf(state, spec);
+                        if (gap !== undefined)
+                            report.why = `waiting for its ${gap.step}: ${gap.text}`;
+                    }
                     if (state.startOver !== undefined)
                         report.startOver = state.startOver;
+                    const old = oldCodebases(codebase);
+                    if (old.length > 0)
+                        report.startOver = { requires: [], codebases: old.map((entry) => entry.moduleName), old: true };
                     return report;
                 });
             })));
@@ -1228,10 +1286,26 @@ export function createWorkLoop(options) {
             // a codebase built on it - by a module above - is disposable, and is deleted, a pulse running there stopped first;
             // the module above is regenerated from it once they pass. Only when there are tests to write: asked again for tests
             // it has, nothing is touched.
-            const wanted = new Set([...(request.frids ?? []), ...(request.groups ?? []).flat()]);
-            const tested = new Set((readRecord(conformanceDirFor(self.moduleName, modulesRoot(projectDirOf(self.plainFile))))?.[FUNCTIONAL_REQUIREMENTS] ?? []).map((item) => item.frid));
-            const ownSpecs = (chainSpec(own).tree[FUNCTIONAL_REQUIREMENTS] ?? []).map((_, index) => String(index + 1));
-            const toWrite = (wanted.size > 0 ? [...wanted] : ownSpecs).some((frid) => !tested.has(frid));
+            if (!conformanceTestsOn(self.plainFile)) {
+                throw new Error(`Conformance tests are off for ${self.moduleName} (conformance-tests: false, or unset): nothing is conformance tested. ` +
+                    "They are turned on in the chat - by asking for them - or with conformance-tests: true in config.turri.yaml. Nothing was started.");
+            }
+            const named = request.funcIds === undefined ? undefined : funcIdsNamed(self.moduleName, [...new Set(request.funcIds)]);
+            const ownSpec = chainSpec(own).tree;
+            const withScenarios = testedFuncIds(ownSpec);
+            // Refused before anything is touched: nothing to test, a functional spec not there, or one with no scenarios.
+            if (withScenarios.length === 0) {
+                throw new Error(`No functional spec of ${self.moduleName} has scenarios - none has a test plain file - so there is nothing to test: ` +
+                    "write the conformance or acceptance scenarios first, with change_plain, and their tests are written once the code is built. Nothing was started.");
+            }
+            if (named !== undefined && named.length > 0)
+                askedSpecs(self.moduleName, ownSpec, named);
+            // A step of adding tests skipped - its test reqs, or the conformance testing script for its stack: refused, naming it.
+            const gap = testingGap({ moduleName: self.moduleName, plainFile: self.plainFile, tree: ownSpec, buildDir: self.buildDir });
+            if (gap !== undefined)
+                throw new Error(`${gap.text} Nothing was started.`);
+            const tested = new Set((readRecord(conformanceDirFor(self.moduleName, modulesRoot(projectDirOf(self.plainFile))))?.[FUNCTIONAL_REQUIREMENTS] ?? []).map((item) => item.id));
+            const toWrite = (named !== undefined && named.length > 0 ? named : withScenarios).some((funcId) => !tested.has(funcId));
             let wentBack = false;
             if (readRecord(self.buildDir) !== null && toWrite) {
                 const why = `${self.moduleName}'s conformance tests were asked for, and they come before anything is built on it`;
@@ -1262,40 +1336,20 @@ export function createWorkLoop(options) {
             const asking = tracked.find((state) => tipEntry(state).buildDir === self.buildDir);
             const states = asking !== undefined ? tracked.filter((state) => own.some((entry) => entry.buildDir === tipEntry(state).buildDir)) : tracked;
             const tip = asking ?? states.at(-1);
-            // In groups of the person's own - 1-3 and 4-6: every functional spec of them asked for, each group a pulse of its own.
-            const groups = request.groups?.map((group) => [...new Set(group)]).filter((group) => group.length > 0);
-            const named = [...(request.frids ?? []), ...(groups ?? []).flat()];
-            const asks = named.length > 0 ? [...new Set(named)] : undefined;
+            const asks = named !== undefined && named.length > 0 ? named : undefined;
             // Its tests are written already, and a codebase built on it holds its code: nothing to write, nothing touched.
             if (asking === undefined && asks !== undefined && tip !== undefined) {
-                throw new Error(`${self.moduleName}'s conformance tests for fs ${asks.join(", ")} are written already. Nothing was scheduled.`);
+                throw new Error(`${self.moduleName}'s conformance tests for ${namesOf(self.moduleName, asks)} are written already. Nothing was started.`);
             }
-            // Refused before anything is chosen: a functional spec the spec does not have is built by no code job, so its tests could never be written.
-            const specs = tip !== undefined && asks !== undefined ? scheduledSpecs(tip, asks) : undefined;
-            // On for the whole module already - asked for before, or by the config: asked again, nothing changes, and it is said.
-            const already = new Set(states.filter((state) => {
-                const file = tipEntry(state).plainFile;
-                return (state.conformance !== undefined && state.conformance.chosen === undefined) || inStack(state, () => configConformance(file) && !configChosen(file));
-            }));
-            // Only the module asked for: the modules below it keep their conformance tests as their config and choices have them.
+            // Only the module asked for: one job for all of its tests, or one a functional spec, as this request asks; a halt cleared.
             for (const state of tip !== undefined ? [tip] : []) {
-                // The functional specs named are the module's own: they are scheduled in its codebase, beside those chosen before.
-                const named = specs;
-                const before = state.conformance;
-                // Asked for every one before, or now: every one.
-                const all = (before !== undefined && before.chosen === undefined) || named === undefined;
-                state.conformance = all ? {} : { chosen: before?.chosen ?? new Set() };
-                // Scheduled now, chosen once all of them are built - at once, those that are.
-                state.scheduled = all ? undefined : [...(state.scheduled ?? []), { specs: named, unbuilt: named.map((touched) => touched.frid) }];
-                // One job for all of them, or one a functional spec: as this request asks. Changed, the plan is made again.
                 const separately = request.separately === true;
                 if ((state.conformanceSeparately === true) !== separately)
                     state.conformancePlan = undefined;
                 state.conformanceSeparately = separately;
-                if (state === tip && groups !== undefined && groups.length > 0) {
-                    state.conformanceGroups = [...(state.conformanceGroups ?? []), ...groups];
-                    state.conformancePlan = undefined;
-                }
+                // Named: their tests alone - the others left as they are until the module is asked for again, or conform names none.
+                state.conformanceOnly = asks !== undefined ? namedOnly(state, asks) : undefined;
+                state.conformancePlan = undefined;
                 state.conformanceHalted = undefined;
                 state.halted = undefined;
                 state.held = undefined;
@@ -1303,10 +1357,15 @@ export function createWorkLoop(options) {
             await tick();
             return [...new Set(states)].map((state) => {
                 const status = statusOf(state);
-                if (!already.has(state))
+                const writing = status.running !== undefined || status.planned.some((job) => job.track === "conformance");
+                if (state !== tip || writing)
                     return status;
-                const built = status.planned.some((job) => job.afterCode === true) ? "they are planned into pulses once its code is built" : "every functional spec of it is tested";
-                return { ...status, conformanceNote: `conformance tests were on for the whole of ${status.module} already: ${built}` };
+                return {
+                    ...status,
+                    conformanceNote: asks !== undefined
+                        ? `the conformance tests of ${namesOf(status.module, asks)} are written for ${asks.length === 1 ? "it" : "them"} as built: there is nothing to write`
+                        : `the conformance tests of ${status.module} are written for every functional spec with scenarios, as built: there is nothing to write`,
+                };
             });
         },
         async startOver(plainFile, request = {}) {
@@ -1318,8 +1377,12 @@ export function createWorkLoop(options) {
                 for (const entry of fresh?.rebuild ?? [])
                     rebuild.set(entry.buildDir, { entry, requires: fresh.modules });
             }
-            if (rebuild.size === 0)
+            if (rebuild.size === 0) {
+                // Built when functional specs were numbered: the whole chain is regenerated from scratch.
+                if ([...chainsFor(file), own].some((chain) => oldCodebases(chain).length > 0))
+                    return loop.fromScratch(plainFile, { ...request, chain: true });
                 throw new Error(`Nothing of ${tipOf(own).moduleName} has to be started over: its code is built on every module it requires.`);
+            }
             for (const { entry } of rebuild.values()) {
                 if (modules.get(entry.buildDir)?.running !== undefined)
                     throw new Error(`${entry.moduleName} has a pulse running: ask again once it is done.`);
@@ -1453,13 +1516,11 @@ export function createWorkLoop(options) {
                         ];
                     }
                     return status.planned.map((job, index) => {
-                        const planned = row(`planned-${tip.moduleName}-${index + 1}`, `${basename(tip.plainFile)} ${job.track === "conformance" ? "conformance: " : ""}${job.title}`, job.waitsFor !== undefined
-                            ? `Scheduled, not started: the conformance tests of ${job.title}, once ${waitsText(job.waitsFor)} built - the code record has to have them first.`
-                            : job.afterCode === true
-                                ? "Not planned yet: the module's conformance tests are planned into pulses once its code is built."
-                                : job.planning === true
-                                    ? `Being planned into pulses now: ${job.title}. The first starts as soon as the plan is made.`
-                                    : `Planned, not started: ${casesText(job.cases)}. It is planned again whenever the spec changes or a pulse before it ends.`, before !== undefined ? [before] : [], job.track === "conformance");
+                        const planned = row(`planned-${tip.moduleName}-${index + 1}`, `${basename(tip.plainFile)} ${job.track === "conformance" ? "conformance: " : ""}${job.title}`, job.afterCode === true
+                            ? `Not planned yet: the conformance tests${job.specs !== undefined && job.specs.length > 0 ? ` of ${job.specs.join(", ")}` : ""} are planned into pulses once the module's code is built.`
+                            : job.planning === true
+                                ? `Being planned into pulses now: ${job.title}. The first starts as soon as the plan is made.`
+                                : `Planned, not started: ${casesText(job.cases)}. It is planned again whenever the spec changes or a pulse before it ends.`, before !== undefined ? [before] : [], job.track === "conformance");
                         if (job.planning === true)
                             planned.planning = { since: state.planningSince ?? preparing.get(tip.moduleName)?.since ?? now };
                         before = planned.id;
@@ -1481,7 +1542,7 @@ export function createWorkLoop(options) {
                 codebases: order.map((key) => {
                     const state = modules.get(key);
                     const tip = tipEntry(state);
-                    const { jobs, scheduled } = describe(state);
+                    const { jobs, ahead } = describe(state);
                     const running = state.running;
                     let next = running?.number ?? state.pulses ?? 0;
                     const pulses = [
@@ -1490,10 +1551,10 @@ export function createWorkLoop(options) {
                             : []),
                         ...jobs.flatMap((job, index) => {
                             const rowId = `planned-${tip.moduleName}-${index + 1}`;
-                            // Scheduled ahead of its code: numbered among the rest, its functional specs by their text.
-                            const ahead = scheduled[index];
-                            if (ahead !== undefined)
-                                return [{ number: (next += 1), title: ahead.title, track: "conformance", running: false, rowId, before: "", after: "", specs: ahead.specs }];
+                            // The conformance tests that follow the code still to build: numbered among the rest, their functional specs by name.
+                            const following = ahead[index];
+                            if (following !== undefined)
+                                return [{ number: (next += 1), title: following.title, track: "conformance", running: false, rowId, before: "", after: "", specs: following.specs }];
                             return job === undefined ? [] : [{ number: (next += 1), title: job.title, track: job.track, running: false, rowId, before: job.step.before, after: job.step.after }];
                         }),
                     ];
@@ -1504,7 +1565,7 @@ export function createWorkLoop(options) {
                         plainFile: tip.plainFile,
                         buildDir: tip.buildDir,
                         pulses,
-                        conformance: state.conformance !== undefined || inStack(state, () => configConformance(tip.plainFile)),
+                        conformance: testedFuncIds(state.seen?.tree).length > 0,
                         ...(state.planning !== undefined ? { planning: state.planning } : {}),
                         ...(running === undefined && state.waitsFor !== undefined ? { waitsFor: state.waitsFor } : {}),
                         ...(running === undefined && state.why !== undefined ? { why: state.why } : {}),
@@ -1531,14 +1592,36 @@ export function createWorkLoop(options) {
     };
     return loop;
 }
+/** The codebases of a chain built when functional specs were numbered, before func-ids: their code or tests record is old. */
+function oldCodebases(chain) {
+    return chain.filter((entry) => isOldRecord(readRecord(entry.buildDir)) || isOldRecord(readRecord(conformanceDirFor(entry.moduleName, modulesRoot(projectDirOf(entry.plainFile))))));
+}
+/** Why nothing is built on codebases with old records. */
+const OLD_RECORDS_WHY = (codebases) => `${codebases.join(", ")} ${codebases.length === 1 ? "was" : "were"} built when functional specs were numbered, before they had func-ids: nothing more is built on ${codebases.length === 1 ? "it" : "them"} - the whole chain is regenerated from scratch once you agree`;
 /** Why nothing runs in a codebase whose code - and conformance tests, where they are wanted - is built from its spec as it is. */
 export const UP_TO_DATE = "built from the ***plain as it is";
 /** Why a codebase with work left has no plan: the planner found none. */
+/** Why a codebase waits for a testing script being written in the background. */
+const SCRIPT_BEING_WRITTEN = (what) => `waiting for its ${what}, which is being written`;
 const NO_PLAN = "the planner found no way to cut the work into pulses that hold together";
+/**
+ * Where the functional specs' test plain files of a module's chain are, by func-id and module - the module's own when none
+ * is named - under `base`, the folder the module's file is named in: as the parse bound them, else where one is to be,
+ * `<test-dir>/<module>/<func-id>.plain`.
+ */
+function testPlainPathOf(tree, moduleName, plainFile, base) {
+    const bound = Object.entries(tree[TEST_PLAIN_FILES] ?? {});
+    const fallback = relative(dirname(plainFile), testDirOf(plainFile));
+    return (funcId, module = moduleName) => {
+        const name = bound.find(([, binding]) => binding.module === module && binding.func_id === funcId)?.[0] ?? join(fallback, module, `${funcId}.plain`);
+        return join(base, name);
+    };
+}
 /** A diff's lines placed in the .plain files of a chain - the tip's first - named as they are from the project. */
 function whereInFiles(diff, chain) {
     try {
-        const files = [...chain].reverse().flatMap((entry) => specFilesOf(entry.plainFile));
+        // The test plain files too: a conformance pulse's diff has their lines.
+        const files = [...chain].reverse().flatMap((entry) => [...specFilesOf(entry.plainFile), ...testPlainFilesOf(entry.plainFile)]);
         // A standard library template by its import path, not by where turri happens to be.
         const nameOf = (path) => (path.startsWith(`${STDLIB_ROOT}/stdlib/`) ? relative(STDLIB_ROOT, path) : relative(projectDirOf(chain.at(-1).plainFile), path) || basename(path));
         const unique = [...new Set(files)].map((path) => ({ name: nameOf(path), text: readFileSync(path, "utf8") }));
@@ -1548,18 +1631,69 @@ function whereInFiles(diff, chain) {
         return {};
     }
 }
-/** The functional specs a scheduled conformance job waits for: "fs 2 is", "fs 2, fs 3 are". */
-function waitsText(frids) {
-    return `${frids.map((frid) => `fs ${frid}`).join(", ")} ${frids.length === 1 ? "is" : "are"}`;
+/**
+ * The conformance tests' work, a line a functional spec, each with its scenarios counted by case and why else its tests
+ * are behind: "todo:add-task   1 added, 1 changed". What a case is follows from the tests record, by scenario-id: a
+ * scenario added there is new to the tests, one changed reads otherwise, one removed is taken out - and a functional spec
+ * whose code changed under scenarios unchanged has their tests run on the new code.
+ */
+function conformanceLines(module, cases) {
+    const name = (touched) => `${touched.module ?? module}:${touched.funcId}`;
+    const why = { text: "its code changed", again: "its code was regenerated again", concept: "a concept it uses changed" };
+    const counted = (spec) => {
+        const parts = [
+            ...(spec.added.length > 0 ? [`${spec.added.length} added`] : []),
+            ...(spec.changed.length > 0 ? [`${spec.changed.length} changed`] : []),
+            ...(spec.removed.length > 0 ? [`${spec.removed.length} removed`] : []),
+            ...(spec.codeChanged !== undefined ? [`${why[spec.codeChanged]} - ${spec.unchanged.length} to run on it`] : []),
+        ];
+        return parts.length > 0 ? parts.join(", ") : "its text changed";
+    };
+    const rows = cases.scenarios !== undefined
+        ? cases.scenarios.map((spec) => [name(spec), cases.delete.some((gone) => name(gone) === name(spec)) ? `taken out - its tests go (${spec.removed.length} removed)` : counted(spec)])
+        : [
+            ...cases.add.map((touched) => [name(touched), "scenarios to write tests for"]),
+            ...cases.patch.map((touched) => [name(touched), "its text or its scenarios changed"]),
+            ...cases.again.map((touched) => [name(touched), "its code was regenerated again"]),
+            ...cases.delete.map((touched) => [name(touched), "taken out - its tests go"]),
+        ];
+    if (rows.length === 0)
+        return ["    the test reqs or what they are written against changed"];
+    const width = Math.max(...rows.map(([name]) => name.length));
+    return rows.map(([name, why]) => `    ${name.padEnd(width)}   ${why}`);
+}
+/** Functional specs as a person names them: `module:func-id`, each. */
+export function namesOf(module, funcIds) {
+    return funcIds.map((funcId) => `${module}:${funcId}`).join(", ");
+}
+/** Functional specs of a chain as a person names them: `module:func-id`, each - the codebase's own with `module`. */
+function refsOf(module, specs) {
+    return specs.map((spec) => `${spec.module ?? module}:${spec.funcId}`).join(", ");
+}
+/**
+ * The func-ids a person names in a module, each as `module:func-id` - a bare func-id, or another module's, is refused:
+ * a func-id is unique in its module only.
+ */
+export function funcIdsNamed(module, names) {
+    return names.map((name) => {
+        const at = name.lastIndexOf(":");
+        if (at === -1)
+            throw new Error(`Name the functional spec as ${module}:${name} - a func-id with its module. Nothing was done.`);
+        const [named, funcId] = [name.slice(0, at), name.slice(at + 1)];
+        if (named !== module)
+            throw new Error(`${name} is not a functional spec of ${module}: name ${named}'s .plain file for it. Nothing was done.`);
+        return funcId;
+    });
 }
-/** What a job does, in a few words: its cases. */
+/** What a job does, in a few words: its cases, each functional spec by its func-id - with its module, a module below's. */
 function casesText(cases) {
+    const named = (specs) => specs.map((spec) => (spec.module !== undefined ? `${spec.module}:${spec.funcId}` : spec.funcId)).join(", ");
     const parts = [
         ...(cases.fresh ? ["sets the project up"] : []),
-        ...(cases.add.length > 0 ? [`adds ${cases.add.map((spec) => `fs ${spec.frid}`).join(", ")}`] : []),
-        ...(cases.patch.length > 0 ? [`changes ${cases.patch.map((spec) => `fs ${spec.frid}`).join(", ")}`] : []),
-        ...(cases.again.length > 0 ? [`regenerates ${cases.again.map((spec) => `fs ${spec.frid}`).join(", ")} again`] : []),
-        ...(cases.delete.length > 0 ? [`takes out ${cases.delete.map((spec) => `fs ${spec.frid}`).join(", ")}`] : []),
+        ...(cases.add.length > 0 ? [`adds ${named(cases.add)}`] : []),
+        ...(cases.patch.length > 0 ? [`changes ${named(cases.patch)}`] : []),
+        ...(cases.again.length > 0 ? [`regenerates ${named(cases.again)} again`] : []),
+        ...(cases.delete.length > 0 ? [`takes out ${named(cases.delete)}`] : []),
     ];
     return parts.length > 0 ? parts.join(", ") : "no functional spec - reqs or definitions only";
 }
@@ -1622,6 +1756,16 @@ export function describeModules(statuses, options = {}) {
         if (status.startOver === undefined)
             return [];
         const { requires, codebases } = status.startOver;
+        if (status.startOver.old === true) {
+            return options.for === "command line"
+                ? [`  turri regenerate ${basename(status.plainFile)} --start-over regenerates it from scratch, with its whole chain`]
+                : [
+                    `  Ask the user whether to regenerate ${status.module} from scratch, with its whole chain, and say why: ${codebases.join(", ")} ` +
+                        `${codebases.length === 1 ? "was" : "were"} built when functional specs were numbered, before they had func-ids, so nothing more ` +
+                        "can be built on it - its code and conformance tests are taken out, kept in its history, and every module of the chain " +
+                        `is built again from the bottom. Only if they agree, call regenerate with ${basename(status.plainFile)} and from_scratch: "chain".`,
+                ];
+        }
         return options.for === "command line"
             ? [`  turri regenerate ${basename(status.plainFile)} --start-over starts ${codebases.join(", ")} over`]
             : [
@@ -1643,13 +1787,13 @@ export function describeModules(statuses, options = {}) {
             for (const why of status.running.steered ?? [])
                 lines.push(`    ⇢ steered: ${why} - its agent was told, and it lands the ***plain as it is now there`);
         }
+        for (const rename of status.renames ?? [])
+            lines.push(`  renames ${rename} once the running pulse ends - the records and the tests' labels, nothing regenerated`);
         status.planned.forEach((job, index) => lines.push(job.afterCode === true
-            ? `  ${index + 1}. conformance tests - planned once the code is built`
-            : job.waitsFor !== undefined
-                ? `  ${index + 1}. conformance tests: ${job.title} - scheduled, starts once ${waitsText(job.waitsFor)} built`
-                : job.planning === true
-                    ? `  ${index + 1}. ${job.track === "conformance" ? "conformance tests: " : ""}${job.title} - being planned into pulses`
-                    : `  ${index + 1}. ${job.track === "conformance" ? "conformance tests: " : ""}${job.title} - ${casesText(job.cases)}`));
+            ? `  ${index + 1}. conformance tests${job.specs !== undefined && job.specs.length > 0 ? ` of ${job.specs.join(", ")}` : ""} - planned once the code is built`
+            : job.planning === true
+                ? `  ${index + 1}. ${job.track === "conformance" ? "conformance tests: " : ""}${job.title} - being planned into pulses`
+                : `  ${index + 1}. ${job.track === "conformance" ? "conformance tests: " : ""}${job.title} - ${casesText(job.cases)}`));
         if (status.planNotes !== undefined)
             lines.push("  what the plan did not do as asked:", ...status.planNotes.map((note) => `    - ${note}`));
         if (status.why !== undefined)
@@ -1675,32 +1819,21 @@ const defaultConformanceRunner = async (job, onDelta) => {
         applied: "already applied",
         spec: job.spec,
         cases: job.planned.cases,
+        recorded: job.planned.step.tree,
         ...(job.model !== undefined ? { model: job.model } : {}),
         onDelta,
     });
     if (result.passed) {
-        writeTestsRecord(result.conformanceDir, keepAgainMarks(job.planned.step.tree, job.planned.cases, job.moduleName, result.conformance.rewritten ?? []));
+        writeTestsRecord(result.conformanceDir, job.planned.step.tree);
         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 }));
+    const of = (specs) => specs.map((spec) => ({ module: spec.module ?? moduleName, funcId: spec.funcId }));
     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