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

package/dist/regenerate/conformance.js

@@ -2,7 +2,7 @@ import { existsSync, mkdirSync, readFileSync } from "node:fs";
 import { basename, extname, join, relative, resolve } from "node:path";
 import { ask, BEGIN, createExecutor, refuseIfModelIsBlind } from "../pi.js";
 import { PLAIN_SOURCE_FILE_EXTENSION, plainFileParser } from "../plain/parser.js";
-import { ACCEPTANCE_TESTS, DEFINITIONS, FUNCTIONAL_REQUIREMENTS, NON_FUNCTIONAL_REQUIREMENTS, getFrids, getInheritedFunctionalSpecs, getSpecificationsForFrid, TEST_REQUIREMENTS, } from "../plain/spec.js";
+import { ACCEPTANCE_TESTS, CONFORMANCE_TESTS, DEFINITIONS, FUNCTIONAL_REQUIREMENTS, NON_FUNCTIONAL_REQUIREMENTS, getFrids, getInheritedFunctionalSpecs, getSpecificationsForFrid, TEST_REQUIREMENTS, } from "../plain/spec.js";
 import { reportActivity, reportLogNote, reportSpec, reportStage, unitOf } from "./activity.js";
 import { confinedTools } from "./confine.js";
 import { abandonWork, diffSinceSnapshot, landWork, moduleDirOf, startWork, workDiff, workSnapshot } from "./lineage.js";
@@ -10,7 +10,7 @@ import { firstLine, record } from "./ledger.js";
 import { createWorkLedger, describeAccounts, SUBMIT_WORK_NOTE, unanswered, unansweredPrompt } from "./submit-work.js";
 import { CONFORMANCE_COMPACTION } from "./compaction.js";
 import { NOTES_TURN, notesForSession, passedOutcome, readNotes, reflectOnReview, withNotes } from "./notes.js";
-import { acceptanceLabel, acceptanceText, labelsPrompt, labelsPromptFor, misplacedConformanceTests, misplacedTestsPrompt, missingTestLabels } from "./test-kinds.js";
+import { labelsPrompt, labelsPromptFor, misplacedConformanceTests, misplacedTestsPrompt, missingTestLabels, orphanedLabels, orphansPrompt, testedSpecsOf } from "./test-kinds.js";
 import { createScriptTool, findTestScripts, projectRootFor, requireTestScripts, runConformanceScript, runUnitScript, failureSignature, STUCK_ROUNDS, scriptFailure, staticChecksOnly, withTestingScripts, } from "./test-scripts.js";
 import { createWebTools, WEB_TOOLS } from "./web.js";
 import { createMyDiffTool } from "./self-check.js";
@@ -24,9 +24,9 @@ import { reportSpecConflict } from "./activity.js";
 import { ATTEMPTS } from "./stop-report.js";
 import { ARBITER_AFTER, arbitrateReview, dismissedNote, REVIEW_LIMIT } from "./arbiter.js";
 import { sectionsOf } from "./state.js";
-import { configForSpec, inheritModel, modelOnly, modelSpec } from "../config.js";
+import { configForSpec, inheritModel, modelOnly, modelSpec, testDirOf } from "../config.js";
 import { defaultBuildDir, modulesRoot, testsDirUnder, projectDirOf } from "./paths.js";
-import { buildConformancePrompt, functionalitiesByModule, moduleSection, section, sectionModules, specChangeBlock } from "./prompt.js";
+import { buildConformancePrompt, functionalitiesByModule, moduleSection, scenariosBlock, section, sectionModules, specChangeBlock } from "./prompt.js";
 import { diffFiles, digestFiles } from "./codebase.js";
 import { createCopyResourceTool, loadLinkedResources, resourceImages } from "./resources.js";
 import { resolveTemplateDirs } from "./paths.js";
@@ -53,16 +53,16 @@ export async function renderConformanceTests(options) {
     const templateDirs = resolveTemplateDirs(options.plainFile, options.templateDirs);
     const [moduleName, tree] = options.spec
         ? [options.spec.moduleName, options.spec.tree]
-        : plainFileParser(basename(options.plainFile), templateDirs);
+        : plainFileParser(basename(options.plainFile), templateDirs, { testDir: testDirOf(options.plainFile) });
     // For a spec change, the tests follow the change, whatever it touches - a definition, a req -
     // with or without a functional spec yet; for one functionality, they are that functionality's.
     const forChange = options.diff !== undefined;
-    const frids = [...getFrids(tree)];
-    const frid = options.frid ?? (forChange ? frids.at(-1) : frids[0]);
-    if (frid === undefined && !forChange)
+    const funcIds = [...getFrids(tree)];
+    const funcId = options.funcId ?? (forChange ? funcIds.at(-1) : funcIds[0]);
+    if (funcId === undefined && !forChange)
         throw new Error(`Module '${moduleName}' has no functionalities.`);
-    if (frid !== undefined && !frids.includes(frid)) {
-        throw new Error(`Functionality ${frid} does not exist. Available: ${frids.join(", ")}.`);
+    if (funcId !== undefined && !funcIds.includes(funcId)) {
+        throw new Error(`Functionality ${funcId} does not exist. Available: ${funcIds.join(", ")}.`);
     }
     const buildDir = resolve(options.buildDir ?? defaultBuildDir(moduleName, projectDirOf(options.plainFile)));
     // The agents that give a verdict - the judge, the test review - may run on a stronger model than the rest.
@@ -70,11 +70,11 @@ export async function renderConformanceTests(options) {
     const conformanceDir = resolve(options.conformanceDir ?? conformanceDirFor(moduleName, modulesRoot(projectDirOf(options.plainFile))));
     const stage = (label) => {
         if (!options.dryRun)
-            reportStage(`${forChange ? unitOf(moduleName) : unitOf(moduleName, frid)}: ${label}`);
+            reportStage(`${forChange ? unitOf(moduleName) : unitOf(moduleName, funcId)}: ${label}`);
     };
-    stage(options.diff !== undefined ? "conformance tests for the spec change" : `conformance tests for functionality ${frid}`);
+    stage(options.diff !== undefined ? "conformance tests for the spec change" : `conformance tests for functionality ${funcId}`);
     if (!options.dryRun && !forChange)
-        reportSpec(buildingSpec(moduleName, frid, frids.length, getSpecificationsForFrid(tree, frid)[0]));
+        reportSpec(buildingSpec(moduleName, funcId, funcIds.length, getSpecificationsForFrid(tree, funcId)[0]));
     // From the last known good state, unless this step continues work not yet committed.
     // On its own it is one unit - its tests, and any change to the code - landed whole or undone
     // whole. Continuing work already under way, it is part of that work's unit instead.
@@ -90,9 +90,9 @@ export async function renderConformanceTests(options) {
     }
     // The spec as it stands: every section, and the functional specs - none, for a change made
     // before any was written.
-    const specifications = frid !== undefined
-        ? getSpecificationsForFrid(tree, frid)[0]
-        : { ...sectionsOf(tree), [FUNCTIONAL_REQUIREMENTS]: [], [ACCEPTANCE_TESTS]: [] };
+    const specifications = funcId !== undefined
+        ? getSpecificationsForFrid(tree, funcId)[0]
+        : { ...sectionsOf(tree), [FUNCTIONAL_REQUIREMENTS]: [], [CONFORMANCE_TESTS]: [], [ACCEPTANCE_TESTS]: [] };
     // Conformance tests are written from the test reqs: they say how the suite is built and
     // run. Without them there is nothing to write tests against, and an agent asked anyway
     // would invent a convention that nothing else in the project shares.
@@ -101,6 +101,11 @@ export async function renderConformanceTests(options) {
             `Add a ${TEST_REQUIREMENTS} section saying how conformance tests are written and run, or render ` +
             "with conformance turned off.");
     }
+    // A functional spec's tests are its scenarios': one with none - no test plain file - has nothing to test.
+    if (!forChange && (specifications[CONFORMANCE_TESTS] ?? []).length + (specifications[ACCEPTANCE_TESTS] ?? []).length === 0) {
+        throw new Error(`${moduleName}:${funcId} has no scenarios - no test plain file - so there is nothing to test: write its conformance or ` +
+            "acceptance scenarios first.");
+    }
     // Whether the tests pass is the project's conformance testing script - and, when the code is
     // changed, its unit testing script: without them, nothing is written.
     stage("finding the project's testing scripts");
@@ -108,7 +113,7 @@ export async function renderConformanceTests(options) {
     const scripts = findTestScripts(root, options.plainFile, buildDir);
     if (!options.dryRun)
         requireTestScripts(moduleName, scripts, { conformance: true });
-    const linkedResources = loadLinkedResources(tree, forChange ? null : frid, templateDirs);
+    const linkedResources = loadLinkedResources(tree, forChange ? null : funcId, templateDirs);
     // The spec's images need a model that reads them: refused before any of its agents starts.
     if (!options.dryRun)
         await refuseIfModelIsBlind(options.model, resourceImages(linkedResources).length);
@@ -116,8 +121,9 @@ export async function renderConformanceTests(options) {
     const prompt = withTestingScripts(buildConformancePrompt({
         ...(options.cases !== undefined ? { cases: options.cases } : {}),
         moduleName,
-        frid,
+        funcId,
         specifications,
+        funcIds,
         modules: sectionModules(tree, moduleName),
         linkedResources,
         manifest,
@@ -129,7 +135,7 @@ export async function renderConformanceTests(options) {
     if (options.dryRun) {
         return {
             moduleName,
-            frid: frid ?? "",
+            funcId: funcId ?? "",
             buildDir,
             conformanceDir,
             prompt,
@@ -157,18 +163,18 @@ export async function renderConformanceTests(options) {
     // The code and its tests are rendered apart: the tests in their own folder, by an agent that
     // may read the code but writes only tests. An explorer reads the code first and writes down how the
     // software is invoked, which is what the tests are written against.
-    const label = `${moduleName} ${options.diff !== undefined ? "spec change" : frid}`;
-    // For a spec change: the functionalities it touches, whose acceptance tests are labelled, checked and reviewed.
-    const touched = forChange ? touchedFunctionalities(tree, frids, options.diff) : [];
-    // The acceptance tests the run's tests carry out: every functionality the change touches, or the one under test.
-    const carriedOut = forChange ? touched : [{ frid: frid, acceptanceTests: specifications[ACCEPTANCE_TESTS] ?? [] }];
-    const specContext = { moduleName, text: specText(specifications, moduleName, frids, required, carriedOut, options.change ?? options.diff, sectionModules(tree, moduleName)) };
+    const label = `${moduleName} ${options.diff !== undefined ? "spec change" : funcId}`;
+    // For a spec change: the functionalities it touches, whose scenarios are carried out, labelled, checked and reviewed.
+    const touched = forChange ? touchedFunctionalities(tree, funcIds, options.diff, moduleName, options.cases) : [];
+    // The scenarios the run's tests carry out: those of every functionality the change touches, or of the one under test.
+    const carriedOut = forChange ? touched : [testedSpecOf(specifications, funcId)];
+    const specContext = { moduleName, text: specText(specifications, moduleName, funcIds, required, carriedOut, options.change ?? options.diff, sectionModules(tree, moduleName)) };
     // Any functionality of the codebase - this module's, and those of the modules it requires. A
     // functionality's run may raise a spec conflict only with that functionality; a spec diff's, between any two.
-    const own = (forChange ? frids : frids.slice(0, frids.indexOf(frid) + 1)).map((id) => ({ module: moduleName, frid: id }));
+    const own = (forChange ? funcIds : funcIds.slice(0, funcIds.indexOf(funcId) + 1)).map((id) => ({ module: moduleName, funcId: id }));
     const scope = {
-        functionalities: [...required.map((spec) => ({ module: spec.module, frid: spec.frid })), ...own],
-        ...(forChange ? {} : { tested: { module: moduleName, frid: frid } }),
+        functionalities: [...required.map((spec) => ({ module: spec.module, funcId: spec.funcId })), ...own],
+        ...(forChange ? { touchedModules: [...new Set(touched.map((item) => item.module ?? moduleName))] } : { tested: { module: moduleName, funcId: funcId } }),
     };
     /** How many times each spec conflict has been raised in this run, by the two functionalities it names. */
     const conflicts = new Map();
@@ -232,17 +238,14 @@ export async function renderConformanceTests(options) {
             : []),
         { path: relative(root, scripts.conformance), runs: "<script> <copy of the build> <copy of the whole conformance suite>", content: readFileSync(scripts.conformance, "utf8") },
     ];
-    // The acceptance tests the explorer's plan has to carry out, step by step.
-    const toCarryOut = carriedOut
-        .map((item) => ({ module: moduleName, frid: item.frid, count: item.acceptanceTests.length }))
-        .filter((item) => item.count > 0);
-    let invocation = await exploreInvocation({ buildDir, spec: specContext, scope, testingScripts, acceptance: toCarryOut, label, model: options.model, onDelta: options.onDelta });
+    let invocation = await exploreInvocation({ buildDir, spec: specContext, scope, testingScripts, label, model: options.model, onDelta: options.onDelta });
     reportActivity(`  how to invoke it: ${invocation.split("\n")[0].slice(0, 120)}`);
     const agentPrompt = withTestingScripts(buildConformancePrompt({
         ...(options.cases !== undefined ? { cases: options.cases } : {}),
         moduleName,
-        frid,
+        funcId,
         specifications,
+        funcIds,
         modules: sectionModules(tree, moduleName),
         linkedResources,
         manifest,
@@ -337,13 +340,10 @@ export async function renderConformanceTests(options) {
         // What the tests were when this run began: what it adds or changes is what the review gate reads.
         const testsAtStart = digestFiles(conformanceDir);
         let unitInventory = inventoryTests(buildDir);
-        // Acceptance tests only when the spec has them for this functionality.
-        const acceptance = options.diff === undefined ? (specifications[ACCEPTANCE_TESTS] ?? []).length : 0;
-        stage(acceptance > 0
-            ? `turri is writing conformance tests from the spec, and its ${acceptance} acceptance test${acceptance === 1 ? "" : "s"} apart from them`
-            : options.diff !== undefined
-                ? "turri is bringing the conformance tests in line with the spec change"
-                : "turri is writing conformance tests from the spec");
+        const scenarios = carriedOut.reduce((count, item) => count + item.conformance.length + item.acceptance.length, 0);
+        stage(options.diff !== undefined
+            ? "turri is bringing the conformance tests in line with the spec change"
+            : `turri is writing the conformance tests of its ${scenarios} scenario${scenarios === 1 ? "" : "s"}`);
         let response = await askConformance(BEGIN, options.onDelta);
         const maxRounds = options.maxRounds ?? DEFAULT_MAX_ROUNDS;
         let verified = false;
@@ -370,10 +370,9 @@ export async function renderConformanceTests(options) {
                 await askFixer(removalChallengePrompt(unitRemovals, "unit tests"));
                 continue;
             }
-            // The conformance tests and each acceptance test have to be there, and labelled as what
-            // they are, before anything else counts.
+            // A test for each scenario has to be there, and labelled as the scenario it carries out, before anything else counts.
             if (options.diff === undefined) {
-                const missing = missingTestLabels(conformanceDir, frid, specifications[ACCEPTANCE_TESTS] ?? []);
+                const missing = missingTestLabels(conformanceDir, moduleName, carriedOut[0]);
                 if (missing.length > 0) {
                     if (labelAsks >= LABEL_ASKS) {
                         stage(`the tests were sent back ${LABEL_ASKS} times to be written and labelled, and still are not - stopping`);
@@ -381,16 +380,19 @@ export async function renderConformanceTests(options) {
                         break;
                     }
                     labelAsks += 1;
-                    stage(listFiles(conformanceDir).length === 0 ? "no tests in the tests folder - the conformance agent writes them" : "labelling the conformance and acceptance tests");
-                    response = await askConformance(labelsPrompt(frid, missing, listFiles(conformanceDir).length === 0, (specifications[ACCEPTANCE_TESTS] ?? []).length > 0), options.onDelta);
+                    stage(listFiles(conformanceDir).length === 0 ? "no tests in the tests folder - the conformance agent writes them" : "labelling the tests of the scenarios");
+                    response = await askConformance(labelsPrompt(moduleName, funcId, missing, listFiles(conformanceDir).length === 0), options.onDelta);
                     continue;
                 }
             }
             else {
                 // A spec change: every functionality it touches, as a functionality's own run would have it - every one missing
                 // asked for in one request, checked whole again after each answer, so none is asked for in place of another.
-                const pending = touched
-                    .map((item) => ({ frid: item.frid, missing: missingTestLabels(conformanceDir, item.frid, item.acceptanceTests) }))
+                // And every other functional spec the tests are written for: each of its scenarios has its labelled test too.
+                const touchedKeys = new Set(touched.map((item) => `${item.module ?? moduleName}:${item.funcId}`));
+                const others = testedSpecsOf(options.recorded).filter((item) => !touchedKeys.has(`${item.module ?? moduleName}:${item.funcId}`));
+                const pending = [...touched, ...others]
+                    .map((item) => ({ funcId: item.funcId, ...(item.module !== undefined ? { module: item.module } : {}), missing: missingTestLabels(conformanceDir, moduleName, item) }))
                     .filter((item) => item.missing.length > 0);
                 if (pending.length > 0) {
                     if (labelAsks >= LABEL_ASKS) {
@@ -399,9 +401,22 @@ export async function renderConformanceTests(options) {
                         break;
                     }
                     labelAsks += 1;
-                    stage(`labelling the conformance and acceptance tests of functionalit${pending.length === 1 ? "y" : "ies"} ${pending.map((item) => item.frid).join(", ")}, which the change touches`);
-                    const acceptance = touched.some((item) => item.acceptanceTests.length > 0);
-                    response = await askConformance(labelsPromptFor(pending, listFiles(conformanceDir).length === 0, acceptance), options.onDelta);
+                    stage(`labelling the tests of the scenarios of ${pending.map((item) => `${item.module ?? moduleName}:${item.funcId}`).join(", ")}, which the change touches`);
+                    response = await askConformance(labelsPromptFor(moduleName, pending, listFiles(conformanceDir).length === 0), options.onDelta);
+                    continue;
+                }
+                // A label that names nothing the tests are written for - a scenario or a functional spec taken out, a label
+                // mistyped, a test invented beside the scenarios: sent back to be removed or relabelled.
+                const orphans = options.recorded !== undefined ? orphanedLabels(conformanceDir, moduleName, testedSpecsOf(options.recorded)) : [];
+                if (orphans.length > 0) {
+                    if (labelAsks >= LABEL_ASKS) {
+                        stage(`the tests were sent back ${LABEL_ASKS} times to be written and labelled, and still are not - stopping`);
+                        unlabelled = orphans.map((orphan) => `${orphan.file} is labelled "${orphan.label}", which names nothing the tests are written for.`);
+                        break;
+                    }
+                    labelAsks += 1;
+                    stage(`${orphans.length} label${orphans.length === 1 ? "" : "s"} in the tests name${orphans.length === 1 ? "s" : ""} nothing they are written for - the conformance agent removes or relabels them`);
+                    response = await askConformance(orphansPrompt(orphans), options.onDelta);
                     continue;
                 }
             }
@@ -462,7 +477,6 @@ export async function renderConformanceTests(options) {
                         scope,
                         testingScripts,
                         question: { failure: shownOutput(buildDir, "conformance-stuck", recheck.output), account: invocation },
-                        acceptance: toCarryOut,
                         label,
                         model: options.model,
                         onDelta: options.onDelta,
@@ -598,8 +612,8 @@ export async function renderConformanceTests(options) {
                                 ...ref,
                                 plainFile: files.get(ref.module) ?? options.plainFile,
                                 text: ref.module === moduleName
-                                    ? (ownSpecs[frids.indexOf(ref.frid)] ?? "")
-                                    : (required.find((spec) => spec.module === ref.module && spec.frid === ref.frid)?.spec ?? ""),
+                                    ? (ownSpecs[funcIds.indexOf(ref.funcId)] ?? "")
+                                    : (required.find((spec) => spec.module === ref.module && spec.funcId === ref.funcId)?.spec ?? ""),
                             })),
                             reasons: said,
                         });
@@ -696,7 +710,7 @@ export async function renderConformanceTests(options) {
             // After the last review's problems were worked on, the tests go on once they pass: not reviewed again. With
             // the review off in the config, they go on once they pass from the first.
             if (reviewOn && changedTests.length > 0 && failedReviews < REVIEW_LIMIT) {
-                stage(`optimising the tests (review ${failedReviews + 1} of at most ${REVIEW_LIMIT}): black box, and the acceptance tests doing what the spec says`);
+                stage(`optimising the tests (review ${failedReviews + 1} of at most ${REVIEW_LIMIT}): black box, and every scenario carried out`);
                 // One reviewer for the run, made the first time the tests are reviewed.
                 reviewer ??= await createTestReviewer({
                     ...(options.cases !== undefined ? { cases: options.cases } : {}),
@@ -730,11 +744,11 @@ export async function renderConformanceTests(options) {
                     if (failedReviews > REVIEW_ROUNDS) {
                         stage(`the review sent the tests back ${failedReviews === 1 ? "once" : `${failedReviews} times`} - the arbiter weighs what it found`);
                         const ruling = await arbitrateReview({
-                            subject: `the conformance tests of ${forChange ? `the spec change in module \`${moduleName}\`` : `functionality ${frid} of module \`${moduleName}\``}`,
+                            subject: `the conformance tests of ${forChange ? `the spec change in module \`${moduleName}\`` : `functional spec ${moduleName}:${funcId}`}`,
                             workdir: conformanceDir,
                             read: [conformanceDir, buildDir],
                             uphold: [
-                                "- uphold it when because of it the functionality is not tested black box - a test or an acceptance test",
+                                "- uphold it when because of it the functionality is not tested black box - a scenario's test",
                                 "  the specification states missing, cut down or skipping what it checks, the software mocked or not reached",
                                 "  from outside, a test that cannot fail. Then the reviewer is right, and the conformance agent fixes it.",
                             ],
@@ -802,20 +816,20 @@ export async function renderConformanceTests(options) {
         const changed = codeChanged();
         if (verified) {
             // The tests, and the code when it changed: one commit if they share a module folder.
-            const subject = `conformance ${moduleName} ${options.diff !== undefined ? "for a spec change" : `fs ${frid}`}${changed ? " (code changed)" : ""}`;
+            const subject = `conformance ${moduleName} ${options.diff !== undefined ? "for a spec change" : `fs ${funcId}`}${changed ? " (code changed)" : ""}`;
             stage(`committing the conformance tests${changed ? " and the code changes" : ""}`);
             landWork(conformanceDir, subject);
             if (moduleDirOf(buildDir) !== moduleDirOf(conformanceDir))
                 landWork(buildDir, subject);
         }
         else if (start !== undefined) {
-            const why = notLandedWhy(options.diff !== undefined ? "for the spec change" : `of functionality ${frid}`, unlabelled);
+            const why = notLandedWhy(options.diff !== undefined ? "for the spec change" : `of functionality ${funcId}`, unlabelled);
             stage(`${why} - undoing them`);
             abandonWork(start, moduleName, why);
         }
         return {
             moduleName,
-            frid: frid ?? "",
+            funcId: funcId ?? "",
             buildDir,
             conformanceDir,
             prompt: agentPrompt,
@@ -861,23 +875,41 @@ function plainFilesOf(plainFile, templateDirs) {
     }
 }
 /**
- * The functionalities a spec change touches - its functional spec, or one of its acceptance tests,
- * has a line the change adds or removes - with their acceptance tests: what a spec diff's
+ * The functionalities with scenarios a spec change touches - by the job's cases, else those whose functional spec, or one of
+ * whose scenarios, has a line the change adds or removes - with their scenarios: what a spec diff's
  * conformance run labels, checks and reviews, as a functionality's run does for its one.
  */
-export function touchedFunctionalities(tree, frids, diff) {
+export function touchedFunctionalities(tree, funcIds, diff, moduleName, cases) {
+    const tested = (funcId) => {
+        const spec = testedSpecOf(getSpecificationsForFrid(tree, funcId)[0], funcId);
+        return spec.conformance.length + spec.acceptance.length > 0 ? spec : undefined;
+    };
+    // The job's cases say which: what it adds, changes or regenerates again - the modules' below first, in the chain's
+    // order, as the tip's suite holds their tests too, then the module's own.
+    if (cases !== undefined) {
+        const own = (touched) => touched.module === undefined || touched.module === moduleName;
+        const touched = [...cases.add, ...cases.patch, ...cases.again];
+        const named = new Set(touched.filter(own).map((spec) => spec.funcId));
+        const below = new Set(touched.filter((spec) => !own(spec)).map((spec) => `${spec.module}:${spec.funcId}`));
+        const inherited = getInheritedFunctionalSpecs(tree)
+            .filter((spec) => below.has(`${spec.module}:${spec.funcId}`) && spec.conformanceTests.length + spec.acceptanceTests.length > 0)
+            .map((spec) => ({ funcId: spec.funcId, module: spec.module, conformance: spec.conformanceTests, acceptance: spec.acceptanceTests }));
+        return [...inherited, ...funcIds.filter((funcId) => named.has(funcId)).flatMap((funcId) => tested(funcId) ?? [])];
+    }
+    // Else what the diff's lines touch: a functional spec's text, or one of its scenarios'.
     const bare = (line) => line.trim().replace(/^-\s+/, "").replace(/\s+/g, " ");
     const changed = new Set(diff
         .split("\n")
         .filter((line) => /^[+-]/.test(line) && !/^(\+\+\+|---)/.test(line))
         .map((line) => bare(line.slice(1)))
         .filter((line) => line.length > 12));
-    return frids.flatMap((frid) => {
-        const specifications = getSpecificationsForFrid(tree, frid)[0];
-        const spec = specifications[FUNCTIONAL_REQUIREMENTS].at(-1) ?? "";
-        const acceptanceTests = specifications[ACCEPTANCE_TESTS] ?? [];
-        const lines = [spec, ...acceptanceTests].flatMap((text) => text.split("\n")).map(bare);
-        return lines.some((line) => changed.has(line)) ? [{ frid, acceptanceTests }] : [];
+    return funcIds.flatMap((funcId) => {
+        const spec = tested(funcId);
+        if (spec === undefined)
+            return [];
+        const text = getSpecificationsForFrid(tree, funcId)[0][FUNCTIONAL_REQUIREMENTS].at(-1) ?? "";
+        const lines = [text, ...spec.conformance.map((scenario) => scenario.text), ...spec.acceptance.map((scenario) => scenario.text)].flatMap((item) => item.split("\n")).map(bare);
+        return lines.some((line) => changed.has(line)) ? [spec] : [];
     });
 }
 /** From the how-manieth review that sends the tests back the arbiter weighs each one (see arbiter.ts). */
@@ -962,14 +994,14 @@ export function failureLine(run) {
 }
 /**
  * The spec as the explorer, the judge and the coding agent are shown it - its functional specs
- * numbered with their ids, so a spec conflict can name them, and the acceptance tests the run carries
+ * named by their func-ids, so a spec conflict can name them, and the scenarios the run carries
  * out labelled as their tests are, so a verdict can quote them.
  */
-function specText(specifications, moduleName, frids, required, acceptance, diff, modules) {
+function specText(specifications, moduleName, funcIds, required, carriedOut, diff, modules) {
     // Every functionality in the codebase, each with its module: the required modules' first, then this one's.
     const numbered = (key, items) => key === FUNCTIONAL_REQUIREMENTS
         ? [
-            functionalitiesByModule([...required, ...items.map((item, index) => ({ module: moduleName, frid: frids[index] ?? String(index + 1), spec: item }))], moduleName),
+            functionalitiesByModule([...required, ...items.map((item, index) => ({ module: moduleName, funcId: funcIds[index] ?? String(index + 1), spec: item }))], moduleName),
         ]
         : items;
     // Each section in its tag, as every agent is shown it (see specPrimer).
@@ -977,22 +1009,27 @@ function specText(specifications, moduleName, frids, required, acceptance, diff,
         .map((key) => [key, specifications[key] ?? []])
         .filter(([, items]) => items.length > 0)
         .map(([key, items]) => (key === FUNCTIONAL_REQUIREMENTS ? section(key, numbered(key, items)) : moduleSection(key, items, moduleName, modules)));
-    // Not only the last functionality's: a spec change's run carries out the acceptance tests of every one it touches.
-    const tests = acceptance.flatMap((item) => item.acceptanceTests.map((test, index) => `${acceptanceLabel(item.frid, index + 1)}: ${acceptanceText(test)}`));
-    if (tests.length > 0)
-        sections.push(section(ACCEPTANCE_TESTS, tests));
+    // Not only the last functionality's: a spec change's run carries out the scenarios of every one it touches.
+    const scenarios = scenariosBlock(moduleName, carriedOut);
+    if (scenarios !== null)
+        sections.push(scenarios);
     if (diff !== undefined)
-        sections.push(specChangeBlock(diff));
+        sections.push(specChangeBlock(diff, true));
     return sections.join("\n\n");
 }
+/** A functional spec's scenarios, as its specifications carry them: those its conformance tests carry out. */
+function testedSpecOf(specifications, funcId) {
+    return { funcId, conformance: specifications[CONFORMANCE_TESTS] ?? [], acceptance: specifications[ACCEPTANCE_TESTS] ?? [] };
+}
 /**
  * The functional spec a conformance run writes tests for, for the person watching: which one of how
- * many, and its text as the spec has it, with its acceptance tests after it.
+ * many, and its text as the spec has it, with its scenarios after it.
  */
-export function buildingSpec(moduleName, frid, total, specifications) {
-    const acceptance = specifications[ACCEPTANCE_TESTS] ?? [];
+export function buildingSpec(moduleName, funcId, total, specifications) {
+    const kind = (name, scenarios) => (scenarios ?? []).length > 0 ? ["", `${name}:`, ...(scenarios ?? []).map((scenario) => `# ${scenario.id}\n${scenario.text.trim()}`)] : [];
     return {
-        label: `${moduleName} functionality ${frid} of ${total}`,
-        text: [(specifications["functional specs"].at(-1) ?? "").trim(), ...(acceptance.length > 0 ? ["", "acceptance tests:", ...acceptance.map((test) => test.trim())] : [])].join("\n"),
+        spec: { module: moduleName, funcId },
+        label: `${moduleName}:${funcId}, functional spec of ${total}`,
+        text: [(specifications["functional specs"].at(-1) ?? "").trim(), ...kind("conformance tests", specifications[CONFORMANCE_TESTS]), ...kind("acceptance tests", specifications[ACCEPTANCE_TESTS])].join("\n"),
     };
 }

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

@@ -1,6 +1,6 @@
 import { type PlainRole } from "../plain/highlight.ts";
 /**
- * A spec diff as the panels show it: each line's ***plain highlighted as plyn highlights it
+ * A spec diff as the panels show it: each line's ***plain highlighted by turri's own grammar
  * (`plain/highlight.ts`), an added line on a green band and a removed one on a red, the band the width
  * of the panel - as an editor shows a diff. Each file is named once, quietly, above its hunks - not
  * git's headers - and a hunk header is a quiet rule between hunks.

package/dist/regenerate/diff-view.js

@@ -36,6 +36,10 @@ export function locateDiffLines(diff, files) {
     });
     const used = new Set();
     let last;
+    // A test plain file's part of the diff is that file's alone: its `---` and its section headers are in every one of
+    // them, and in the module's frontmatter - found by text anywhere, they would be placed in the wrong file.
+    const testPlainFile = texts.map((file) => /^---\n(?:.*\n)*?func_id:/.test(file.written.join("\n")));
+    let only;
     const take = (file, line, index) => {
         used.add(`${file}:${line}`);
         const section = sections[file][line];
@@ -46,14 +50,23 @@ export function locateDiffLines(diff, files) {
         .replace(/\n+$/, "")
         .split("\n")
         .forEach((line, index) => {
-        if (HEADER.test(line) || line.startsWith("+++ ") || line.startsWith("@@") || line.startsWith("\\"))
+        const named = /^\+\+\+ (?:b\/)?(.+)$/.exec(line);
+        if (named !== null) {
+            const file = texts.findIndex((candidate, at) => testPlainFile[at] === true && (candidate.name === named[1] || candidate.name.endsWith(`/${named[1]}`) || named[1].endsWith(`/${candidate.name}`)));
+            only = file === -1 ? undefined : file;
+            return;
+        }
+        if (line.startsWith("diff --git "))
+            only = undefined;
+        if (HEADER.test(line) || line.startsWith("@@") || line.startsWith("\\"))
             return;
         if (line.startsWith("-")) {
             // A removed line still written in a file - taken out of what is compared, not out of the spec - is that file's.
             const removed = asRead(line.slice(1).trimEnd());
             if (removed.trim() === "" || SECTION.test(removed.trim()))
                 return;
-            const file = texts.findIndex((candidate) => candidate.lines.includes(removed));
+            // In a test plain file a removed line is gone: no line of it is that line any more.
+            const file = only !== undefined ? -1 : texts.findIndex((candidate) => candidate.lines.includes(removed));
             if (file !== -1) {
                 const at = texts[file].lines.indexOf(removed);
                 const section = sections[file][at];
@@ -64,11 +77,11 @@ export function locateDiffLines(diff, files) {
         const text = (line.startsWith("+") || line.startsWith(" ") ? line.slice(1) : line).trimEnd();
         if (text === "") {
             // A blank line: the one right after the line before it, when that is blank.
-            if (last !== undefined && texts[last.file].lines[last.line + 1] === "" && !used.has(`${last.file}:${last.line + 1}`))
+            if (last !== undefined && (only === undefined || last.file === only) && texts[last.file].lines[last.line + 1] === "" && !used.has(`${last.file}:${last.line + 1}`))
                 take(last.file, last.line + 1, index);
             return;
         }
-        const order = last === undefined ? texts.map((_, file) => file) : [last.file, ...texts.map((_, file) => file).filter((file) => file !== last.file)];
+        const order = only !== undefined ? [only] : last === undefined ? texts.map((_, file) => file) : [last.file, ...texts.map((_, file) => file).filter((file) => file !== last.file)];
         for (const file of order) {
             const lines = texts[file].lines;
             const from = last !== undefined && file === last.file ? last.line + 1 : 0;
@@ -112,6 +125,9 @@ export function diffFiles(diff, width, paint = PLAIN_PAINT, where) {
             rendered ??= headerFile;
             before = [];
             after = [];
+            // A new file starts in no section: a test plain file never has the module's.
+            sectionBefore = undefined;
+            sectionAfter = undefined;
             continue;
         }
         if (HEADER.test(line) || line.startsWith("@@") || line.startsWith("\\"))

package/dist/regenerate/drift.d.ts

@@ -1,5 +1,4 @@
 import { type MarshalledPlainSource } from "../plain/spec.ts";
-import { type Chosen } from "./records.ts";
 import { type SpecChange } from "./spec-steps.ts";
 /**
  * The work, derived from the records - see docs/regenerating.md. Nothing here is stored: what is left
@@ -8,7 +7,7 @@ import { type SpecChange } from "./spec-steps.ts";
  *
  * - Code work: from the code record to the spec as the code sees it.
  * - Conformance work: from the tests record to what the conformance tests are to be written for now -
- *   the chosen functional specs the code is built from.
+ *   the functional specs the code is built from that have scenarios.
  *
  * A job is a set of those changes. What it tells its agents follows from the functional specs it
  * touches - its cases - and a running job is stopped once the spec no longer wants what it makes.
@@ -16,13 +15,13 @@ import { type SpecChange } from "./spec-steps.ts";
 /** Everything left to build in the code: from what the code record says it is built from, to the spec now. */
 export declare function codeWork(record: MarshalledPlainSource | null, spec: MarshalledPlainSource): SpecChange[];
 /** Everything left to do in the conformance tests: from what the tests record says they are written for, to what they are to be now. */
-export declare function conformanceWork(tests: MarshalledPlainSource | null, code: MarshalledPlainSource | null, spec: MarshalledPlainSource, chosen?: Chosen): SpecChange[];
+export declare function conformanceWork(tests: MarshalledPlainSource | null, code: MarshalledPlainSource | null, spec: MarshalledPlainSource): SpecChange[];
 /**
- * A functional spec a job touches: its number - in the spec after the job, or, taken out, before it - its first line,
- * and the module it belongs to: each module numbers its own from 1, so a number alone can mean two.
+ * A functional spec a job touches: its func-id, its first line, and the module it belongs to - a func-id is unique in its
+ * module, so a func-id alone can mean two.
  */
 export interface TouchedSpec {
-    frid: string;
+    funcId: string;
     text: string;
     module?: string;
 }
@@ -30,17 +29,19 @@ export interface TouchedSpec {
  * What a job does to the functional specs, and so what its agents are told:
  *
  * - fresh: the module requires none and nothing is built - the project is set up first.
- * - add: functional specs that are new.
- * - patch: functional specs changed - their text, their acceptance tests, or a concept they use: a
- *   change to what is built, never built again from scratch.
+ * - add: functional specs that are new - a func-id the spec did not have.
+ * - patch: functional specs changed - their text, their scenarios, or a concept they use: a
+ *   change to what is built, never built again from scratch. A functional spec moved, and nothing else, is none.
  * - again: functional specs marked to regenerate again (`regenerate` with functionalities named): their code is built, and is regenerated again - rewritten
- *   or started over, doing what the spec says now - with what it replaces taken out. A functional spec of a module
- *   this one requires, regenerated again here, is one too.
- * - delete: functional specs taken out.
- * - mechanical: none of those - only reqs, or definitions no functional spec uses. Existing tests may
- *   change only mechanically, and no new ones are written.
+ *   or started over, doing what the spec says now - with what it replaces taken out.
+ * - delete: functional specs taken out - a func-id the spec no longer has. One renamed with any other change is a delete
+ *   and an add; renamed and nothing else, turri renames it itself, and it is no job's (renames.ts).
+ * - mechanical: none of those - no functional spec of any module of the chain touched: only reqs, or definitions no
+ *   functional spec uses. Existing tests may change only mechanically, and no new ones are written.
  *
- * A job can hold several of add, patch and delete at once: its prompt has a section for each.
+ * The functional specs of the modules below are cased as the codebase's own are, each with its module: the codebase at
+ * the tip of a chain holds their code. A job can hold several of add, patch and delete at once: its prompt has a section
+ * for each.
  */
 export interface JobCases {
     fresh: boolean;
@@ -49,6 +50,37 @@ export interface JobCases {
     again: TouchedSpec[];
     delete: TouchedSpec[];
     mechanical: boolean;
+    /**
+     * A conformance job's: each functional spec it touches, its scenarios by case - in the order of add, patch, again and
+     * delete. None for a code job: the code record holds no scenario.
+     */
+    scenarios?: ScenarioCases[];
+}
+/** A scenario as a conformance job names it: its kind, its scenario-id, its text. */
+export interface ScenarioRef {
+    kind: "conformance" | "acceptance";
+    id: string;
+    text: string;
+}
+/**
+ * What a conformance job does to the tests of one functional spec, scenario by scenario - compared with the tests record
+ * by kind and scenario-id, as functional specs are by func-id:
+ *
+ * - added: write its tests; changed: rewrite them to the scenario as it reads now; removed: delete the tests labelled
+ *   with it; unchanged: its tests stay as they are.
+ * - A scenario-id renamed with any other change, or a scenario moved between conformance and acceptance - its label
+ *   changes - is one removed and one added; one renamed and nothing else turri relabels itself (renames.ts). One moved
+ *   between test plain files of the same functional spec is nothing.
+ * - `codeChanged`: the functional spec's code moved under its unchanged scenarios - its text or a file it links changed
+ *   (`text`), it was regenerated again (`again`), or a concept it uses changed (`concept`): their tests are run on the
+ *   new code, and those that fail are fixed against the scenario.
+ */
+export interface ScenarioCases extends TouchedSpec {
+    added: ScenarioRef[];
+    changed: ScenarioRef[];
+    removed: ScenarioRef[];
+    unchanged: ScenarioRef[];
+    codeChanged?: "text" | "again" | "concept";
 }
 /**
  * Every concept a functional spec uses: those its text names, and those their definitions name in