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

package/dist/regenerate/prompt.js

@@ -1,10 +1,10 @@
 import { modulesScratchDir } from "./paths.js";
-import { ACCEPTANCE_TESTS, DEFINITIONS, FUNCTIONAL_REQUIREMENTS, NON_FUNCTIONAL_REQUIREMENTS, REQUIRED_FUNCTIONAL_SPECS, TEST_REQUIREMENTS, } from "../plain/spec.js";
+import { ACCEPTANCE_TESTS, CONFORMANCE_TESTS, DEFINITIONS, FUNCTIONAL_REQUIREMENTS, NON_FUNCTIONAL_REQUIREMENTS, REQUIRED_FUNCTIONAL_SPECS, TEST_REQUIREMENTS, } from "../plain/spec.js";
 import { codeCopyOf, isCodeResource } from "./resources.js";
-import { acceptanceLabel, acceptanceText, conformanceLabel } from "./test-kinds.js";
+import { conformanceLabel, scenarioLabel, scenariosOf, scenarioText } from "./test-kinds.js";
 import { codeCasesBlock, conformanceCasesBlock } from "./cases.js";
 import { marksRegenerateAgain } from "./records.js";
-import { resourcesChanged } from "./spec-steps.js";
+import { resourcesChanged, scenarioLines } from "./spec-steps.js";
 /**
  * Everything already in the code: the required modules' functional specs, bottom of the
  * chain first, then this module's own earlier ones. Null when there is nothing.
@@ -13,17 +13,17 @@ import { resourcesChanged } from "./spec-steps.js";
  * that does not know what exists re-implements it; a test writer that does not know it
  * cannot set up what a functionality depends on; a fixer that does not know it breaks it.
  */
-function alreadyImplemented(moduleName, own, required) {
+function alreadyImplemented(moduleName, own, funcIds, required) {
     if (own.length === 0 && required.length === 0)
         return null;
-    const entries = [...required, ...own.map((spec, index) => ({ module: moduleName, frid: String(index + 1), spec }))];
+    const entries = [...required, ...own.map((spec, index) => ({ module: moduleName, funcId: funcIds[index] ?? "", spec }))];
     return `<already implemented>\n${functionalitiesByModule(entries, moduleName, "implemented")}\n</already implemented>`;
 }
 /**
  * Functional specs grouped by the module they belong to - in the order the modules are built on
- * one another, the current module marked - and each tagged with its module and its id there. A codebase holds the
- * functionalities of every module it is built on, and each module numbers its own from 1, so
- * "functionality 1" alone is ambiguous: the first listed may be base's 1 and the next top's 3.
+ * one another, the current module marked - and each tagged with its module and its func-id there. A codebase holds the
+ * functionalities of every module it is built on, and a func-id is unique only in its module, so a func-id alone can
+ * be ambiguous: `base` and `app` may each have an `export`.
  * (the reference implementation's implemented functional requirements prompt section, as tags.)
  */
 export function functionalitiesByModule(entries, currentModule, status) {
@@ -34,14 +34,14 @@ export function functionalitiesByModule(entries, currentModule, status) {
         .map((module) => {
         const items = entries
             .filter((entry) => entry.module === module)
-            .map((entry) => `<functionality module="${entry.module}" id="${entry.frid}"${status !== undefined ? ` status="${status}"` : ""}>\n${entry.spec}\n</functionality>`);
+            .map((entry) => `<functionality module="${entry.module}" id="${entry.funcId}"${status !== undefined ? ` status="${status}"` : ""}>\n${entry.spec}\n</functionality>`);
         return `<module name="${module}"${module === currentModule ? ' role="current"' : ""}>\n${items.join("\n\n")}\n</module>`;
     })
         .join("\n\n");
 }
-/** "functionality 3 of module `app`": a functionality, named so that no other module's can be meant. */
-export function functionalityOf(frid, moduleName) {
-    return `functionality ${frid} of module \`${moduleName}\``;
+/** "functional spec `app:add-task`": a functional spec, named so that no other module's can be meant. */
+export function functionalityOf(funcId, moduleName) {
+    return `functional spec \`${moduleName}:${funcId}\``;
 }
 /**
  * How to read a ***plain specification: what each section is, and what the predefined concepts
@@ -66,24 +66,29 @@ export function specPrimer(options) {
             ? "- <test reqs>: how the conformance tests are written and run."
             : "- <test reqs>: how the conformance tests are written and run. They are not given to you: the conformance tests\n" +
                 "  are written apart from the code, from the specification.",
-        "- <functional specs>: what the system does, one functionality at a time, numbered in order, each built on the ones",
-        '  before it. Each functional spec is a <functionality module="..." id="...">; those in <already implemented> are',
-        "  in the code.",
+        "- <functional specs>: what the system does, one functionality at a time, in order, each built on the ones before",
+        '  it. Each functional spec is a <functionality module="..." id="...">, its id the func-id it has in its module; those',
+        "  in <already implemented> are in the code.",
         "- Modules: a ***plain specification is split into modules, each a .plain file of its own. Modules are how the",
         "  specification is written, in ***plain's own syntax - not how the code is laid out. A module can require others:",
         "  it is built on their code, in one codebase with them, so the codebase holds their definitions, implementation",
         "  reqs and functionalities as well as its own. A module can also import others: those hold only definitions and",
         "  reqs - shared ones, never functional specs or code of their own - and what a module imports is its own. Every",
         "  section reaches you grouped under the module each item belongs to - <module name=\"...\">, the modules in the",
-        "  order they are built on one another, the current one marked role=\"current\". Each module numbers its",
-        "  functional specs from 1, so a functionality is always given with its module and its id there: functionality 1",
-        "  of `base` and functionality 1 of `app` are two different functionalities.",
+        "  order they are built on one another, the current one marked role=\"current\". A func-id is unique only in its",
+        "  module, so a functional spec is always given with its module and its func-id there, `<module>:<func-id>`:",
+        "  `base:export` and `app:export` are two different functionalities.",
         "- You work only in the codebase of the current module: it is all you can reach, and it already holds the code of",
         "  every module it requires. Organise and write the code as the <implementation reqs> say - its layout, its",
         "  structure, its conventions - never by the ***plain modules: they say where the specification puts an item,",
         "  not where its code goes.",
-        "- <acceptance tests>: under a functional spec, specific checks that functionality's implementation must pass.",
-        "  They carry the same authority as the functional spec itself.",
+        ...(options.testReqs
+            ? [
+                "- <conformance tests> and <acceptance tests>: under a functional spec, its scenarios, each under its",
+                "  `# <scenario-id>`: what its conformance tests check, and the checks its implementation must pass end to end.",
+                "  They carry the same authority as the functional spec itself.",
+            ]
+            : []),
         "- <linked resources>: files the specification refers to as `[resource]name`. They are part of the specification.",
         "  A linked resource is not in your workspace. When the code needs what one holds while it runs - a schema it",
         "  validates against, a version it reports - it keeps exactly one copy, at the path its code-copy names in the",
@@ -93,6 +98,8 @@ export function specPrimer(options) {
         "  code-copy - is code that lives elsewhere, linked so you know what your code plugs into: build on it as the",
         "  specification says, and never copy it, nor recreate it or what it belongs to.",
         "  An image among them is attached to your first message, numbered in the order they are listed: look at it.",
+        "  One marked in-codebase is in your codebase already, at that path - it came from the base folder: use it from",
+        "  there, and never copy it or make another.",
         "- <spec change>: a change to the specification, section by section, each section in its own tag - what it adds,",
         "  what it changes (before and now), and what it removes.",
         "",
@@ -165,7 +172,7 @@ export const ERROR_CAUSE_RULES = [
 ];
 /** A section's tag - its name in every prompt: `<implementation reqs>`, `<acceptance tests>`. */
 export function sectionTag(key) {
-    return key === ACCEPTANCE_TESTS ? "acceptance tests" : key;
+    return key === ACCEPTANCE_TESTS ? "acceptance tests" : key === CONFORMANCE_TESTS ? "conformance tests" : key;
 }
 export function section(key, items) {
     if (items.length === 0)
@@ -196,9 +203,35 @@ function linkedResourcesSection(resources) {
         return null;
     // An image is not text: the prompt says where it is - attached to the first message, by number - and what type.
     // A text resource has one home in the codebase, should the code need it: its path, made relative to the codebase.
-    const rendered = resources.map((resource) => `<resource name="${resource.text}" path="${resource.target}"${resource.image !== undefined ? ` type="${resource.image.mimeType}"` : isCodeResource(resource.target) ? ' kind="code"' : ` code-copy="${codeCopyOf(resource.target)}"`}>\n${resource.content}\n</resource>`);
+    const rendered = resources.map((resource) => `<resource name="${resource.text}" path="${resource.target}"${resource.image !== undefined ? ` type="${resource.image.mimeType}"` : ""}${resource.inCodebase !== undefined ? ` in-codebase="${resource.inCodebase}"` : resource.image !== undefined ? "" : isCodeResource(resource.target) ? ' kind="code"' : ` code-copy="${codeCopyOf(resource.target)}"`}>\n${resource.content}\n</resource>`);
     return `<linked resources>\n${rendered.join("\n\n")}\n</linked resources>`;
 }
+/** How many files of the base folder a coding agent is shown by name: the rest are counted. */
+const BASE_LISTING = 200;
+/**
+ * The base folder a codebase started from, for its coding agents (base-folder.ts): that it did, and the files that came
+ * from it - code to build on, files to use, or both: the block says neither, for it may be either.
+ */
+export function baseFolderBlock(base) {
+    if (base === undefined)
+        return null;
+    const shown = base.files.slice(0, BASE_LISTING);
+    const more = base.files.length - shown.length;
+    return [
+        `<base folder name="${base.folder}">`,
+        `This codebase started from a copy of the base folder ${base.folder}. Whatever it holds - code to build on, files to`,
+        "use, or both - the specification may refer to, in words or by linking into it. These files came from it, and are here still:",
+        ...shown.map((file) => `- ${file}`),
+        ...(more > 0 ? [`- ... and ${more} more`] : []),
+        "</base folder>",
+    ].join("\n");
+}
+/** The rule for what came from the base folder, for an agent that changes the code: it stays, used where it is. */
+export const BASE_FOLDER_RULES = [
+    "- What came from the base folder stays, used where it is, unless a functional spec asks otherwise: code in it is",
+    "  built on - its structure, conventions and tests kept, its tests passing - and a file in it is used from its path,",
+    "  never copied, moved or made again.",
+];
 /** How to work, for any agent writing code in this codebase from a spec. `mechanical`: the job writes no new tests. */
 function workingRules(hasCodebase, mechanical = false) {
     return [
@@ -235,7 +268,15 @@ export function reviewedSpec(input) {
         "",
         moduleSection(DEFINITIONS, specifications[DEFINITIONS] ?? [], input.moduleName, input.modules),
         moduleSection(NON_FUNCTIONAL_REQUIREMENTS, specifications[NON_FUNCTIONAL_REQUIREMENTS] ?? [], input.moduleName, input.modules),
-        alreadyImplemented(input.moduleName, functionalities, required),
+        alreadyImplemented(input.moduleName, functionalities, input.funcIds, required),
+        // What came from the base folder is the codebase's start, not this work: kept, it is neither scope crept in nor left over.
+        ...(input.base !== undefined
+            ? [
+                baseFolderBlock(input.base),
+                "What came from the base folder is not this work's: a file from it that no functional spec names is kept as it is -",
+                "not scope crept in, nor something left to clean up. A change to it, or its removal, that no functional spec asks for is.",
+            ]
+            : []),
         "<new in this work>",
         specChangeBlock(input.change ?? "(the change is not known)"),
         "</new in this work>",
@@ -249,12 +290,28 @@ export function reviewedSpec(input) {
  */
 const RAW_CHANGE_NOTE = "The change could not be told section by section, so it is the diff of the .plain files, as the person made it. There,\n" +
     "each section is headed by its name in stars: ***definitions*** is <definitions>, ***implementation reqs*** is\n" +
-    "<implementation reqs>, ***test reqs*** is <test reqs>, ***functional specs*** is <functional specs>, and\n" +
-    "***acceptance tests*** under a functional spec is its <acceptance tests>.";
+    "<implementation reqs>, ***test reqs*** is <test reqs>, and ***functional specs*** is <functional specs>, where each\n" +
+    "functional spec is a `# <func-id>` heading and its text under it.";
+/** The same, for a conformance agent: a functional spec's scenarios are in a test plain file of their own. */
+const RAW_CHANGE_NOTE_SCENARIOS = `${RAW_CHANGE_NOTE}\nA test plain file - tests/<module>/<func-id>.plain, its module: and func_id: at its top - holds one functional\n` +
+    "spec's scenarios: ***conformance tests*** is its <conformance tests> and ***acceptance tests*** its <acceptance tests>,\n" +
+    "each scenario a `# <scenario-id>` heading and its text.";
+/**
+ * A raw diff of the .plain files without the hunks of test plain files: a coding agent never sees scenarios, which are
+ * the conformance tests'. A test plain file is told by its own frontmatter - `func_id:` - since its folder is the
+ * project's to name.
+ */
+export function withoutTestPlainFiles(diff) {
+    return diff
+        .split(/^(?=diff --git )/m)
+        .filter((file) => !/^[ +-]func_id:/m.test(file))
+        .join("");
+}
 /** A change in its tag: told section by section, or - when it could not be - the raw diff, with which tag each heading is. */
-export function specChangeBlock(change) {
+export function specChangeBlock(change, scenarios = false) {
     const raw = /^diff --git |^@@ |^[+-]{3} /m.test(change);
-    return `<spec change>\n${raw ? `${RAW_CHANGE_NOTE}\n\n` : ""}${change.trim()}\n</spec change>`;
+    const shown = raw && !scenarios ? withoutTestPlainFiles(change) : change;
+    return `<spec change>\n${raw ? `${scenarios ? RAW_CHANGE_NOTE_SCENARIOS : RAW_CHANGE_NOTE}\n\n` : ""}${shown.trim()}\n</spec change>`;
 }
 /** The sections as the change is told, in the order a spec has them. Test reqs are the conformance tests', not the code's. */
 const CHANGE_SECTIONS = [
@@ -263,7 +320,7 @@ const CHANGE_SECTIONS = [
     { key: FUNCTIONAL_REQUIREMENTS, title: "functional specs" },
     { key: "required functional specs", title: "functional specs of the modules this one requires" },
 ];
-/** A changed item's text: its markdown, and its acceptance tests under it. */
+/** A changed item's text: its markdown - a functional spec's body, named above it - and its scenarios under it, where the tree has them. */
 function itemText(serialized) {
     if (serialized === undefined)
         return "";
@@ -276,13 +333,8 @@ function itemText(serialized) {
     }
     if (typeof item === "string")
         return item;
-    const { markdown, [ACCEPTANCE_TESTS]: tests } = (item ?? {});
-    const lines = [markdown ?? JSON.stringify(item)];
-    // Each test is an item of the tree, its text in its markdown - as spec-steps.ts `itemText` reads it.
-    const testText = (test) => (typeof test === "string" ? test : (test?.markdown ?? JSON.stringify(test)));
-    if (Array.isArray(tests) && tests.length > 0)
-        lines.push("  <acceptance tests>", ...tests.map((test) => `  ${testText(test).replace(/\n/g, "\n  ")}`), "  </acceptance tests>");
-    return lines.join("\n");
+    const { markdown, [CONFORMANCE_TESTS]: conformance, [ACCEPTANCE_TESTS]: acceptance } = (item ?? {});
+    return [markdown ?? JSON.stringify(item), ...scenarioLines("conformance tests", conformance), ...scenarioLines("acceptance tests", acceptance)].join("\n");
 }
 const indent = (text, by) => text.split("\n").map((line) => `${by}${line}`).join("\n");
 /** A changed item, read back: undefined when its line is not one. */
@@ -297,7 +349,7 @@ const parsed = (serialized) => {
 /**
  * A spec change as an agent reads it: section by section, what was added, what changed - before and now - and what
  * was removed. A definition taken out and put back reworded, or moved, is one change to it, not two. Every item is
- * named so no other module's can be meant: a functional spec by its module and number, and a definition or req of a
+ * named so no other module's can be meant: a functional spec by its module and func-id, and a definition or req of a
  * module below by its module; `moduleName` is the module whose codebase it is - whose own items carry no module.
  */
 export function describeSpecChange(changes, moduleName) {
@@ -309,14 +361,14 @@ export function describeSpecChange(changes, moduleName) {
         const here = changes.filter((change) => change.section === key);
         if (here.length === 0)
             continue;
-        /** Which item it is: a functional spec by its module and number, a definition by its concept, and one of a module below with that module. */
+        /** Which item it is: a functional spec by its module and func-id, a definition by its concept, and one of a module below with that module. */
         const labelOf = (change, line) => {
             const item = parsed(line);
             const below = item?.module !== undefined && item.module !== moduleName ? ` of module \`${item.module}\`` : "";
             if (key === FUNCTIONAL_REQUIREMENTS)
-                return moduleName !== undefined ? functionalityOf(String(change.position), moduleName) : `functionality ${change.position}`;
+                return moduleName !== undefined ? functionalityOf(item?.id ?? "", moduleName) : `functional spec \`${item?.id ?? ""}\``;
             if (key === REQUIRED_FUNCTIONAL_SPECS)
-                return item?.module !== undefined && item.frid !== undefined ? functionalityOf(item.frid, item.module) : `functionality ${change.position}${below}`;
+                return item?.module !== undefined && item.id !== undefined ? functionalityOf(item.id, item.module) : `functional spec \`${item?.id ?? ""}\`${below}`;
             if (key === DEFINITIONS)
                 return `${conceptOf(itemText(line)) ?? `item ${change.position}`}${below}`;
             return `item ${change.position}${below}`;
@@ -417,7 +469,7 @@ export function buildSpecDiffPrompt(input) {
         ...input.required,
         ...specifications[FUNCTIONAL_REQUIREMENTS].map((spec, index) => ({
             module: input.moduleName,
-            frid: String(index + 1),
+            funcId: input.funcIds[index] ?? "",
             spec,
         })),
     ];
@@ -427,7 +479,9 @@ export function buildSpecDiffPrompt(input) {
         "",
         input.empty
             ? "Nothing is built yet: the working directory is empty, and the change is the whole specification."
-            : "The working directory holds the code built so far, from the specs below - the specs before the change.",
+            : input.base !== undefined && input.funcIds.length === 0 && input.required.length === 0
+                ? "Nothing is built from the specification yet: the working directory holds what the base folder had (<base folder> below), and the change is the whole specification."
+                : "The working directory holds the code built so far, from the specs below - the specs before the change.",
         "The specification the code is built from follows - its functional specs in <already implemented> - and then",
         "<spec change>, the change to it, section by section: the specification below with the change applied is what the",
         "code has to do once you are done. Your task is to apply the change to the code - everything it adds, changes and",
@@ -437,19 +491,21 @@ export function buildSpecDiffPrompt(input) {
         moduleSection(NON_FUNCTIONAL_REQUIREMENTS, specifications[NON_FUNCTIONAL_REQUIREMENTS], input.moduleName, input.modules),
         all.length === 0 ? null : `<already implemented>\n${functionalitiesByModule(all, input.moduleName, "implemented")}\n</already implemented>`,
         input.codebase ? `<codebase>\n${input.codebase}\n</codebase>` : null,
+        baseFolderBlock(input.base),
         linkedResourcesSection(input.linkedResources),
         input.changes !== undefined && input.changes.length > 0
             ? specChangeBlock(describeSpecChange(input.changes, input.moduleName))
-            : `<spec change>\n${RAW_CHANGE_NOTE}\n\n${input.diff.trim()}\n</spec change>`,
+            : `<spec change>\n${RAW_CHANGE_NOTE}\n\n${withoutTestPlainFiles(input.diff).trim()}\n</spec change>`,
         "",
         ...(input.cases !== undefined
-            ? codeCasesBlock(input.cases)
+            ? codeCasesBlock(input.cases, input.base !== undefined)
             : [
                 "- Implement what the change adds. Update what it changes. Remove what it removes - its code and its",
                 "  unit tests - where nothing that remains still needs it.",
                 "- A change to a definition or an implementation req reaches every functional spec that relies on it. Follow it there.",
             ]),
         "- Everything the change does not touch must keep working, and its tests passing.",
+        ...(input.base !== undefined ? BASE_FOLDER_RULES : []),
         ...workingRules(Boolean(input.codebase), input.cases?.mechanical === true),
     ];
     return parts.filter((part) => part !== null).join("\n");
@@ -468,7 +524,7 @@ export function buildConformancePrompt(input) {
     const forChange = input.diff !== undefined;
     const target = functionalities[functionalities.length - 1];
     if (target === undefined && !forChange)
-        throw new Error(`Functionality ${input.frid} has no specification text.`);
+        throw new Error(`Functional spec ${input.funcId} has no specification text.`);
     const parts = [
         specPrimer({ testReqs: true }),
         `You are writing conformance tests for the \`${input.moduleName}\` specification.`,
@@ -492,12 +548,11 @@ export function buildConformancePrompt(input) {
                         "tests folder and nothing else - so do not look for it: no searching parent folders, absolute paths or /tmp.",
                     ]),
                 "An agent that explored the code wrote down what you need of it, in <how to invoke it>: how it is",
-                "built and run, how each functionality is reached from outside, what it needs around it, and a plan for",
-                "these tests. Write the conformance tests from this prompt - the specification, that account and its",
-                "plan - and what is in your tests folder: the tests already there show how the suite is built and run.",
-                "Every assertion comes from the specification, never from what the account says the code does. Where the",
-                "code and the specification disagree, the test follows the specification and fails. The plan is a",
-                "starting point: where it and the specification differ, the specification is right.",
+                "built and run, how each functionality is reached from outside, and what it needs around it. Write the",
+                "conformance tests from this prompt - the specification, its scenarios and that account - and what is in your",
+                "tests folder: the tests already there show how the suite is built and run. Every assertion comes from the",
+                "scenarios and the specification, never from what the account says the code does. Where the code and the",
+                "specification disagree, the test follows the specification and fails.",
                 "The conformance testing script at the top of this prompt is how your tests are built and run: read what it",
                 "builds or installs before your tests run, and so what they can depend on or start to reach the software.",
                 "Write the tests' own build - its dependencies, how it starts the software - to fit that script.",
@@ -530,24 +585,24 @@ export function buildConformancePrompt(input) {
         // user registered before one logs in - so its tests can set that up through the same
         // public entry points. Only the functionality below is under test. For a diff, every
         // functionality is the spec as it now stands.
-        alreadyImplemented(input.moduleName, input.diff !== undefined ? functionalities : functionalities.slice(0, -1), input.required ?? []),
+        alreadyImplemented(input.moduleName, input.diff !== undefined ? functionalities : functionalities.slice(0, -1), input.funcIds, input.required ?? []),
     ];
     const resources = linkedResourcesSection(input.linkedResources);
     if (resources !== null)
         parts.push(resources);
     parts.push(input.diff !== undefined
-        ? specChangeBlock(input.diff)
-        : `<functionality module="${input.moduleName}" id="${input.frid}">\n${target}\n</functionality>`, input.diff !== undefined
-        ? touchedAcceptanceTests(input.touched ?? [])
-        : numberedAcceptanceTests(input.frid, specifications[ACCEPTANCE_TESTS] ?? []), `<files in the build>\n${input.manifest.join("\n")}\n</files in the build>`, input.existingTests && input.existingTests.length > 0
+        ? specChangeBlock(input.diff, true)
+        : `<functionality module="${input.moduleName}" id="${input.funcId}">\n${target}\n</functionality>`, input.diff !== undefined
+        ? touchedScenarios(input.moduleName, input.touched ?? [])
+        : scenariosBlock(input.moduleName, [{ funcId: input.funcId, conformance: specifications[CONFORMANCE_TESTS] ?? [], acceptance: specifications[ACCEPTANCE_TESTS] ?? [] }]), `<files in the build>\n${input.manifest.join("\n")}\n</files in the build>`, input.existingTests && input.existingTests.length > 0
         ? [
             `<conformance tests already here>\n${input.existingTests.join("\n")}\n</conformance tests already here>`,
             "",
             "This directory holds the conformance tests of every functionality built so far - this module's",
             "and those of the modules it requires, copied up with their code. Tests for other functionalities",
             "must keep passing: leave them as they are. If tests for this functionality are among them, from an",
-            "earlier version of the specification, update them to it: keep the coverage, change only what the",
-            "specification changed.",
+            "earlier version of the specification, bring them in line with its scenarios as they are now: a test for",
+            "each scenario, and none for a scenario taken out.",
         ].join("\n")
         : null, "", ...(input.diff !== undefined
         ? [
@@ -555,24 +610,23 @@ export function buildConformancePrompt(input) {
             "conformance tests in line with the specs as they now stand.",
             "",
             ...(input.cases !== undefined
-                ? conformanceCasesBlock(input.cases)
+                ? conformanceCasesBlock(input.cases, input.moduleName)
                 : [
-                    "- Add tests for behaviour the change adds, change the tests of behaviour it changes, and remove the",
-                    "  tests of behaviour it removes. Leave the tests of everything the change does not touch as they are.",
-                    "- The change is tested whatever it touches: a definition, an implementation req, the test reqs, as",
-                    "  well as a functional spec. Where it changes what built software must do or how the tests reach it,",
-                    "  the tests check that - with or without a functional spec that uses it yet.",
+                    "- Write tests for the scenarios the change adds, change the tests of the scenarios it changes, and remove",
+                    "  the tests of the scenarios it removes. Leave the tests of everything the change does not touch as they are.",
+                    "- Where the change is to a definition, an implementation req or the test reqs, adapt the tests there are",
+                    "  to it: write no test that is not a scenario's.",
                 ]),
-            "- A test is removed only because the spec no longer asks for what it checks. Say which, and why.",
+            "- A test is removed only because its scenario is gone, or no longer asks for what it checks. Say which, and why.",
         ]
         : [
-            `Write conformance tests for ${functionalityOf(input.frid, input.moduleName)}.`,
+            `Write conformance tests for ${functionalityOf(input.funcId, input.moduleName)}.`,
             "",
-            `- Test ${functionalityOf(input.frid, input.moduleName)} only. What is listed as already implemented is there to be`,
+            `- Test ${functionalityOf(input.funcId, input.moduleName)} only. What is listed as already implemented is there to be`,
             "  used - to set up the state a test needs - not tested again.",
         ]), "- Write them in your working directory - the module's tests folder - and nowhere else: never in the", "  code folder, never beside the unit tests. That folder is the conformance suite; the harness runs it,", "  and nothing else, as one. When it runs, the tests are put together with a copy of the build, so refer", "  to the built files by the paths in <files in the build>, resolved against the current working", "  directory rather than against your test file's own location.", "- Organise the tests however suits them - files, folders, shared helpers. Make it clear which", forChange
         ? "  functionality a test covers, so its tests can be found and updated later."
-        : `  functionality a test covers, so the tests of ${functionalityOf(input.frid, input.moduleName)} can be found and updated later.`, ...(forChange ? changeTestKinds() : testKinds(input.frid, (specifications[ACCEPTANCE_TESTS] ?? []).length)), "- Test observable behaviour only: output, exit codes, files produced, values returned by the", "  public entry point. Never assert on internal names, private helpers or implementation detail.", "- <test reqs> say how conformance tests must be written and run. Follow them.", ...(input.invocation !== undefined
+        : `  functionality a test covers, so the tests of ${functionalityOf(input.funcId, input.moduleName)} can be found and updated later.`, ...scenarioRules(input.moduleName, forChange ? undefined : input.funcId), "- Test observable behaviour only: output, exit codes, files produced, values returned by the", "  public entry point. Never assert on internal names, private helpers or implementation detail.", "- <test reqs> say how conformance tests must be written and run. Follow them.", ...(input.invocation !== undefined
         ? [
             "- Your shell holds the tests folder, and the code read only. Run the tests with run_conformance_tests:",
             "  it puts the whole suite together with a copy of the build and runs the project's conformance",
@@ -603,67 +657,46 @@ export function buildConformancePrompt(input) {
     return parts.filter((part) => part !== null).join("\n");
 }
 /**
- * For a spec change: the acceptance tests of the functionalities it touches, numbered as their tests
- * are labelled - each implemented as a test of its own, as a functionality's own run has them.
+ * Functional specs' scenarios as the conformance agent carries them out: each under its label, the conformance
+ * scenarios and then the acceptance ones, in the tag of each kind.
  */
-function touchedAcceptanceTests(touched) {
-    const withTests = touched.filter((item) => item.acceptanceTests.length > 0);
-    if (withTests.length === 0)
-        return null;
-    const rendered = withTests.flatMap((item) => item.acceptanceTests.map((test, index) => `${acceptanceLabel(item.frid, index + 1)}: ${acceptanceText(test)}`));
-    return [
-        "The acceptance tests of the functional specs the change touches:",
-        `<acceptance tests>\n${rendered.join("\n\n")}\n</acceptance tests>`,
-        "Each of these is implemented as a test of its own, doing every step it lists and asserting every expectation it",
-        "states, and labelled as it is numbered here - bring the ones already there in line with the change.",
-    ].join("\n");
+export function scenariosBlock(module, specs) {
+    const kind = (name) => specs.flatMap((spec) => scenariosOf(spec).filter((scenario) => scenario.kind === name).map((scenario) => scenarioText(spec.module ?? module, spec.funcId, scenario)));
+    const conformance = kind("conformance");
+    const acceptance = kind("acceptance");
+    const blocks = [
+        ...(conformance.length > 0 ? [`<conformance tests>\n${conformance.join("\n\n")}\n</conformance tests>`] : []),
+        ...(acceptance.length > 0 ? [`<acceptance tests>\n${acceptance.join("\n\n")}\n</acceptance tests>`] : []),
+    ];
+    return blocks.length > 0 ? blocks.join("\n\n") : null;
 }
-/** The functionality's acceptance tests, numbered as their tests are labelled. */
-function numberedAcceptanceTests(frid, items) {
-    if (items.length === 0)
+/** For a spec change: the scenarios of the functional specs it touches - each carried out, and labelled as it is here. */
+function touchedScenarios(module, touched) {
+    const block = scenariosBlock(module, touched);
+    if (block === null)
         return null;
-    const rendered = items.map((item, i) => `${acceptanceLabel(frid, i + 1)}: ${acceptanceText(item)}`);
-    return `<acceptance tests>\n${rendered.join("\n\n")}\n</acceptance tests>`;
-}
-/** The two kinds of test, for a spec change: each labelled with what it covers. */
-function changeTestKinds() {
     return [
-        "- Conformance tests come from the specs themselves: what they say the software does, its edge cases, its",
-        "  errors - written as if no acceptance tests had been given. They do not copy the acceptance tests.",
-        `- Label them: files whose names say conformance, each with a comment at its top naming the functionality it`,
-        `  covers - "${conformanceLabel("<id>")}" - or, for one that covers no functional spec yet, "${CHANGE_LABEL}".`,
-        "- Acceptance tests - the ones in <acceptance tests> - are implemented separately from the conformance tests,",
-        "  each as its own test, doing what it says, in files whose names say acceptance.",
-        `- Label each acceptance test with a comment right above it: "${acceptanceLabel("<id>", 1)}:" and the text`,
-        "  of the acceptance test, numbered as the spec lists them.",
-    ];
+        "The scenarios of the functional specs the change touches, as they are now:",
+        block,
+        "Each of these is carried out by at least one test of its own, doing every step it lists and asserting every",
+        "expectation it states, and labelled as it is here - bring the tests already there in line with the change.",
+    ].join("\n");
 }
-/** What a conformance test covering no functional spec yet - a definition, a req - is labelled. */
-export const CHANGE_LABEL = "conformance tests of the spec";
 /**
- * The two kinds of test, kept apart and labelled (see test-kinds.ts). `acceptance` is how many
- * acceptance tests the functionality has; for a spec change, it is left to the change.
+ * What the tests are, and how they are labelled (see test-kinds.ts): exactly the scenarios, at least one test each,
+ * and nothing invented beside them. `funcId`: the functional spec under test; for a spec change, those it touches.
  */
-function testKinds(frid, acceptance) {
-    const conformance = [
-        "- Conformance tests come from the functional spec itself: what it says the functionality does, its edge",
-        "  cases, its errors - written as if no acceptance tests had been given. They do not copy the acceptance",
-        "  tests, and do not stop where the acceptance tests stop.",
-        `- Label them: files whose names say conformance, each with a comment "${conformanceLabel(frid)}" at its top`,
-        "  (for a spec change, the functionality each covers).",
-    ];
-    if (acceptance === 0)
-        return conformance;
+function scenarioRules(module, funcId) {
+    const id = funcId ?? "<func-id>";
     return [
-        ...conformance,
-        acceptance === undefined
-            ? "- Acceptance tests - the ones in <acceptance tests> - are implemented separately from the"
-            : `- Separately from them, implement each of the ${acceptance} acceptance test${acceptance === 1 ? "" : "s"} above as its own test, doing what it`,
-        acceptance === undefined
-            ? "  conformance tests, each as its own test, doing what it says, in files whose names say acceptance."
-            : "  says, in files whose names say acceptance. Never fold one into a conformance test, even where they overlap.",
-        `- Label each acceptance test with a comment right above it: "${acceptanceLabel(frid, 1)}:" and the text`,
-        "  of the acceptance test, numbered as above.",
+        "- The tests carry out the scenarios - those in <conformance tests> and <acceptance tests> - exactly: at least one",
+        "  test for each, doing what it says and asserting what it expects. Write no test that is not a scenario's: no",
+        "  edge case, error or behaviour of your own beyond them, however much the functional spec says - the scenarios",
+        "  are what is tested.",
+        `- Label each file with a comment at its top naming the functional spec it tests: "${conformanceLabel(module, id)}" -`,
+        "  a file that tests several has one such line for each.",
+        `- Label each test with a comment right above it naming the scenario it carries out: "${scenarioLabel("conformance", "<scenario-id>", module, id)}"`,
+        `  or "${scenarioLabel("acceptance", "<scenario-id>", module, id)}".`,
     ];
 }
 /**
@@ -679,14 +712,15 @@ export function buildRegressionFixPrompt(input) {
         specPrimer({ testReqs: false }),
         `The conformance suite for \`${input.moduleName}\` is failing.`,
         "",
-        `It covers functionalities ${input.frids.join(", ")} of module \`${input.moduleName}\` together. A functionality that passed`,
+        `It covers functional specs ${input.funcIds.join(", ")} of module \`${input.moduleName}\` together. A functional spec that passed`,
         "on its own can still be broken by a later one, which is what this run is for.",
         "",
         moduleSection(DEFINITIONS, specifications[DEFINITIONS], input.moduleName, input.modules),
         moduleSection(NON_FUNCTIONAL_REQUIREMENTS, specifications[NON_FUNCTIONAL_REQUIREMENTS], input.moduleName, input.modules),
         // All of it is in the code, the required modules' functionalities included, and any of it
         // may be what the latest change broke.
-        alreadyImplemented(input.moduleName, specifications[FUNCTIONAL_REQUIREMENTS], input.required ?? []),
+        alreadyImplemented(input.moduleName, specifications[FUNCTIONAL_REQUIREMENTS], input.funcIds, input.required ?? []),
+        baseFolderBlock(input.base),
         `<conformance failure>\n${input.failure}\n</conformance failure>`,
         "",
         "Change the implementation so every functionality listed as already implemented works at the same time.",
@@ -696,6 +730,7 @@ export function buildRegressionFixPrompt(input) {
         "- Do not special-case the test. Make the behaviour the specification describes actually true.",
         "- Keep the existing unit tests passing. Run any tests you like with bash; before you finish, call",
         "  run_conformance_tests and run_unit_tests - the project's scripts, run as the harness runs them.",
+        ...(input.base !== undefined ? BASE_FOLDER_RULES : []),
         ...INTEGRITY_RULES,
         ...ERROR_CAUSE_RULES,
         "- Keep the build's identity as it is: its name, coordinates, version, package and main class. Change one only",