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

package/dist/regenerate/test-kinds.js

@@ -1,38 +1,32 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
+import { ACCEPTANCE_TESTS, CONFORMANCE_TESTS, FUNCTIONAL_REQUIREMENTS, REQUIRED_FUNCTIONAL_SPECS } from "../plain/spec.js";
 import { listFiles } from "./testing.js";
-/**
- * The two kinds of test the conformance step writes, and how each is told apart in the code.
- *
- * Conformance tests are written from the functional spec itself: what the functionality does,
- * its edge cases, its errors - as if no acceptance tests had been given. Acceptance tests are the
- * ones the spec's author wrote, each implemented as a test of its own, doing what it says. The
- * two are kept apart even when the acceptance tests would seem to cover the functionality: tests
- * derived only from the acceptance tests check what the author thought to check, and nothing
- * the spec says beyond it.
- *
- * Each kind is labelled where anyone reading the tests can see it - in its file names, and in a
- * comment the harness looks for - so which test is which, and which acceptance test a test
- * implements, never has to be guessed.
- */
-export function conformanceLabel(frid) {
-    return `conformance tests of functionality ${frid}`;
+/** The label of a file of a functional spec's conformance tests. */
+export function conformanceLabel(module, funcId) {
+    return `conformance tests of ${module}:${funcId}`;
 }
-export function acceptanceLabel(frid, n) {
-    return `acceptance test ${n} of functionality ${frid}`;
+/** The label right above a test that carries out a scenario. */
+export function scenarioLabel(kind, scenarioId, module, funcId) {
+    return `${kind} scenario ${scenarioId} of ${module}:${funcId}`;
 }
-/** An acceptance test as the spec gives it, without its bullet. */
-export function acceptanceText(item) {
-    return item.trim().replace(/^[-*]\s+/, "");
+/** Every scenario of a functional spec, each with its kind, in its file's order: the conformance ones, then the acceptance ones. */
+export function scenariosOf(spec) {
+    return [...spec.conformance.map((scenario) => ({ ...scenario, kind: "conformance" })), ...spec.acceptance.map((scenario) => ({ ...scenario, kind: "acceptance" }))];
+}
+/** A scenario as the agents are given it: its label, and its text under it. */
+export function scenarioText(module, funcId, scenario) {
+    return `${scenarioLabel(scenario.kind, scenario.id, module, funcId)}:\n${scenario.text.trim()}`;
 }
 function normalise(text) {
     return text.toLowerCase().replace(/\s+/g, " ");
 }
 /**
- * What is missing from the labelling of a functionality's tests: the conformance label, when no
- * test file carries it, and each acceptance test no test is labelled as implementing.
+ * What is missing from the labelling of a functional spec's tests: the file label, when no test file carries it, and each
+ * scenario no test is labelled as carrying out.
  */
-export function missingTestLabels(testsDir, frid, acceptanceTests) {
+export function missingTestLabels(testsDir, codebase, spec) {
+    const module = spec.module ?? codebase;
     const text = normalise(listFiles(testsDir)
         .map((file) => {
         try {
@@ -43,74 +37,110 @@ export function missingTestLabels(testsDir, frid, acceptanceTests) {
         }
     })
         .join("\n"));
-    // Functionality 2's label must not be found in functionality 2.1's.
-    const has = (label) => new RegExp(`${normalise(label).replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?![0-9.]*[0-9])`).test(text);
+    // Matched on the whole key: the label of `todo:log-in` must not be found in that of `todo:log-in-2`.
+    const has = (label) => new RegExp(`${normalise(label).replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?![a-z0-9_]|-[a-z0-9])`).test(text);
     const missing = [];
-    if (!has(conformanceLabel(frid)))
-        missing.push(`No test file is labelled "${conformanceLabel(frid)}".`);
-    acceptanceTests.forEach((item, i) => {
-        if (!has(acceptanceLabel(frid, i + 1)))
-            missing.push(`No test is labelled "${acceptanceLabel(frid, i + 1)}": ${acceptanceText(item)}`);
-    });
+    if (!has(conformanceLabel(module, spec.funcId)))
+        missing.push(`No test file is labelled "${conformanceLabel(module, spec.funcId)}".`);
+    for (const scenario of scenariosOf(spec)) {
+        const label = scenarioLabel(scenario.kind, scenario.id, module, spec.funcId);
+        if (!has(label))
+            missing.push(`No test is labelled "${label}": ${scenario.text.trim().split("\n")[0]}`);
+    }
     return missing;
 }
 /**
- * The test files that carry a functionality's labels - its conformance tests' or any of its acceptance tests'. The
- * harness's own files beside them - the notes, the record - are not tests, whatever they mention.
+ * Sent back when the labels of functional specs are missing - one, or every one a spec change touches: every one that
+ * is missing, in one request, so none is asked for in place of another.
  */
-export function labelledFiles(testsDir, frid) {
-    const id = frid.replace(/\./g, "\\.");
-    const label = new RegExp(`(conformance tests|acceptance test \\d+) of functionality ${id}(?![0-9.]*[0-9])`);
-    return listFiles(testsDir).filter((file) => {
-        if (file.split(/[\\/]/).at(-1).startsWith(".turri"))
-            return false;
+export function labelsPromptFor(codebase, items, empty = false) {
+    const pending = items.filter((item) => item.missing.length > 0);
+    const names = pending.map((item) => `${item.module ?? codebase}:${item.funcId}`);
+    const module = pending[0]?.module ?? codebase;
+    const which = names.length === 1 ? `functional spec ${names[0]}` : `functional specs ${names.slice(0, -1).join(", ")} and ${names.at(-1)}`;
+    const first = pending[0]?.funcId ?? "<func-id>";
+    return [
+        empty
+            ? "There are no tests in your tests folder - nothing ran. Whatever a build folder or an earlier report there says, write " +
+                `the conformance tests of ${which} now, as files in your tests folder, labelled as below:`
+            : `The tests are not labelled yet as the scenarios they carry out. Missing, for ${which}:`,
+        "",
+        ...pending.flatMap((item) => item.missing.map((line) => `- ${line}`)),
+        "",
+        `Every file of a functional spec's tests carries its label, in a comment of its own line: "${conformanceLabel(module, first)}". ` +
+            "A file that tests several functional specs has one such line for each.",
+        `Every scenario is carried out by at least one test, with a comment right above it: "${scenarioLabel("conformance", "<scenario-id>", module, first)}" or ` +
+            `"${scenarioLabel("acceptance", "<scenario-id>", module, first)}" - one not carried out yet is written as a test of its own.`,
+        "Add every label missing above. Keep every label and every test that is there already: adding one scenario's label never takes another's away. Then run the tests again.",
+    ].join("\n");
+}
+/**
+ * The functional specs of a tree of what conformance tests are written for, with their scenarios - those of the modules
+ * below with their module, the codebase's own after them.
+ */
+export function testedSpecsOf(tree) {
+    const of = (section, below) => (tree?.[section] ?? []).map((item) => ({
+        funcId: item.id ?? "",
+        ...(below && item.module !== undefined ? { module: item.module } : {}),
+        conformance: (item[CONFORMANCE_TESTS] ?? []).map(({ id, text }) => ({ id, text })),
+        acceptance: (item[ACCEPTANCE_TESTS] ?? []).map(({ id, text }) => ({ id, text })),
+    }));
+    return [...of(REQUIRED_FUNCTIONAL_SPECS, true), ...of(FUNCTIONAL_REQUIREMENTS, false)];
+}
+const ID = "[a-z0-9]+(?:-[a-z0-9]+)*";
+const END = "(?![a-z0-9_]|-[a-z0-9])";
+/**
+ * The labels in the tests folder that name nothing the tests are written for: a functional spec, or a scenario of one,
+ * that `specs` does not have - left over from a scenario or a functional spec taken out or renamed, mistyped, or
+ * invented. Each with the file it is in.
+ */
+export function orphanedLabels(testsDir, codebase, specs) {
+    const known = new Set();
+    for (const spec of specs) {
+        const module = spec.module ?? codebase;
+        known.add(conformanceLabel(module, spec.funcId).toLowerCase());
+        for (const scenario of scenariosOf(spec))
+            known.add(scenarioLabel(scenario.kind, scenario.id, module, spec.funcId).toLowerCase());
+    }
+    const pattern = new RegExp(`\\b(?:conformance tests of|(?:conformance|acceptance) scenario ${ID} of) [\\w./-]+:${ID}${END}`, "gi");
+    const found = [];
+    for (const file of listFiles(testsDir)) {
+        let text;
         try {
-            return label.test(normalise(readFileSync(join(testsDir, file), "utf8")));
+            text = readFileSync(join(testsDir, file), "utf8");
         }
         catch {
-            return false;
+            continue;
         }
-    });
-}
-/** Sent back when the labels are missing: which, and how to label them. */
-export function labelsPrompt(frid, missing, empty = false, hasAcceptance = true) {
-    return labelsPromptFor([{ frid, missing }], empty, hasAcceptance);
+        for (const match of new Set(text.match(pattern) ?? []))
+            if (!known.has(match.replace(/\s+/g, " ").toLowerCase()))
+                found.push({ file, label: match });
+    }
+    return found;
 }
-/**
- * Sent back when the labels of several functionalities are missing - a spec change that touches them: every one that is
- * missing, in one request, so none is asked for in place of another.
- */
-export function labelsPromptFor(items, empty = false, hasAcceptance = true) {
-    const pending = items.filter((item) => item.missing.length > 0);
-    const frids = pending.map((item) => item.frid);
-    const which = frids.length === 1 ? `functionality ${frids[0]}` : `functionalities ${frids.slice(0, -1).join(", ")} and ${frids.at(-1)}`;
+/** Sent back when labels name nothing the tests are written for. */
+export function orphansPrompt(orphans) {
     return [
-        empty
-            ? "There are no tests in your tests folder - nothing ran. Whatever a build folder or an earlier report there says, write " +
-                `the conformance tests of ${which} now, as files in your tests folder, labelled as the kinds they are:`
-            : `The tests are not labelled yet as the kinds they must be kept apart as. Missing, for ${which}:`,
+        "These labels name no functional spec, or no scenario of one, that the tests are written for - a scenario or a functional spec",
+        "taken out or renamed, a label mistyped, or a test of your own beside the scenarios:",
         "",
-        ...pending.flatMap((item) => item.missing.map((line) => `- ${line}`)),
+        ...orphans.map((orphan) => `- ${orphan.file}: "${orphan.label}"`),
         "",
-        "Every functionality's conformance tests carry its own label, in a comment of its own line: " +
-            `"${conformanceLabel(frids[0] ?? "1")}"${frids.length > 1 ? `, "${conformanceLabel(frids[1])}", and so on - one line a functionality` : ""}. ` +
-            `A file that tests several functionalities has one such line for each. A label naming several at once - "conformance tests of functionality 1, 2 and 3" - counts for the first alone.`,
-        ...(hasAcceptance
-            ? [
-                `Every acceptance test is its own test, with a comment right above it: "${acceptanceLabel(frids[0] ?? "1", 1)}:" and the acceptance test's text - one not implemented yet is written as a test of its own, not folded into a conformance test.`,
-            ]
-            : []),
-        "Add every label missing above. Keep every label and every test that is there already: adding one functionality's label never takes another's away. Then run the tests again.",
+        "Remove each such test and its label - or, where it carries out a scenario that is there under another label, relabel it with",
+        "that scenario's label. Every test carries out a scenario, labelled as it is now. Then run the tests again.",
     ].join("\n");
 }
+/** Sent back when the labels of one functional spec are missing. */
+export function labelsPrompt(module, funcId, missing, empty = false) {
+    return labelsPromptFor(module, [{ funcId, missing }], empty);
+}
 /**
- * Conformance and acceptance tests in the code folder, where they do not belong: they live in the
- * module's tests folder, which the harness runs as the conformance suite. Found by their label, or
- * by a test file under a name or folder that says conformance or acceptance - one written without
- * a label is misplaced all the same.
+ * Conformance tests in the code folder, where they do not belong: they live in the module's tests folder, which the
+ * harness runs as the conformance suite. Found by their label, or by a test file under a name or folder that says
+ * conformance or acceptance - one written without a label is misplaced all the same.
  */
 export function misplacedConformanceTests(codeDir) {
-    const label = /conformance tests of (functionality [0-9]|the spec)|acceptance test [0-9]+ of functionality/i;
+    const label = /conformance tests of [a-z0-9_]+:[a-z0-9]|(conformance|acceptance) scenario \S+ of [a-z0-9_]+:[a-z0-9]/i;
     return listFiles(codeDir).filter((file) => {
         const parts = file.toLowerCase().split("/");
         const named = parts.some((part) => /conformance|acceptance/.test(part)) && /test/.test(parts.at(-1));
@@ -128,15 +158,14 @@ export function misplacedConformanceTests(codeDir) {
 /** Sent back when there are: to the agent writing the code, or to the one writing the tests. */
 export function misplacedTestsPrompt(files, codeDir, testsDir) {
     return [
-        `These are conformance or acceptance tests, in the code folder (${codeDir}), where they do not belong:`,
+        `These are conformance tests, in the code folder (${codeDir}), where they do not belong:`,
         "",
         ...files.map((file) => `- ${file}`),
         "",
         testsDir === undefined
-            ? "Conformance and acceptance tests are not yours to write: the conformance step writes them, in the module's " +
-                "tests folder. Remove these from the code folder. Your tests are the unit tests - write them as unit tests."
-            : `Conformance and acceptance tests live in your working directory, ${testsDir}, and nowhere else. Move these ` +
-                "there - labelled as they must be - and remove them from the code folder; the harness runs only that folder as " +
-                "the conformance suite.",
+            ? "Conformance tests are not yours to write: the conformance step writes them, in the module's tests folder. " +
+                "Remove these from the code folder. Your tests are the unit tests - write them as unit tests."
+            : `Conformance tests live in your working directory, ${testsDir}, and nowhere else. Move these there - labelled as ` +
+                "they must be - and remove them from the code folder; the harness runs only that folder as the conformance suite.",
     ].join("\n");
 }

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

@@ -84,6 +84,8 @@ export declare function staticChecksOnly(run: {
     exitCode: number;
     timedOut?: boolean;
 }): boolean;
+/** The kind of testing script a skill writes, by its name - one that writes none, undefined. */
+export declare function scriptKindOfSkill(skill: string): ScriptKind | undefined;
 /** Raised before a build starts when the script that would decide it is done is missing. */
 export declare class MissingTestScriptError extends Error {
     readonly moduleName: string;

package/dist/regenerate/test-scripts.js

@@ -181,6 +181,10 @@ const SKILL = {
     unit: { skill: "implement-unit-testing-script", file: "run_unittests", what: "unit testing script" },
     conformance: { skill: "implement-conformance-testing-script", file: "run_conformance_tests", what: "conformance testing script" },
 };
+/** The kind of testing script a skill writes, by its name - one that writes none, undefined. */
+export function scriptKindOfSkill(skill) {
+    return Object.keys(SKILL).find((kind) => SKILL[kind].skill === skill);
+}
 /** Raised before a build starts when the script that would decide it is done is missing. */
 export class MissingTestScriptError extends Error {
     // Declared fields, not parameter properties: node's own type stripping cannot run those.

package/dist/regenerate/testing-steps.d.ts

@@ -0,0 +1,41 @@
+import { type MarshalledPlainSource } from "../plain/spec.ts";
+/**
+ * The steps of adding tests to a module, and the one it skipped. Nothing about testing exists until the person asks
+ * for it; then, in order: its test reqs - the stack's conformance template, or its own - the conformance testing script
+ * for its stack, and the scenarios in its test plain files. A module whose functional specs have scenarios but which
+ * skipped one of the first two has its conformance pulses refused - by the work loop and by `conform` alike - and
+ * `parse` and the map say what is missing. A module with no scenarios skipped nothing: it is not tested.
+ */
+export interface TestingGap {
+    /** The first step skipped. */
+    step: "test reqs" | "conformance testing script";
+    /** What is missing, and the next step - a refusal's, a warning's and the loop's why. */
+    text: string;
+    /** In a few words, for the map's row. */
+    short: string;
+}
+/**
+ * The standard library's conformance template for a module's stack, `stdlib/<kind>/conformance/<stack>`, when the module
+ * imports a stack template that has one - nothing otherwise.
+ */
+export declare function conformanceTemplateOf(plainFile: string): string | undefined;
+/**
+ * The conformance testing script a module's tests would run with, looked for under its stack - the one pinned, else
+ * the one `stackForModule` gives it - or nothing, with why when there is a why.
+ */
+export declare function conformanceScriptOf(plainFile: string, buildDir?: string): {
+    script?: string;
+    note?: string;
+};
+/**
+ * The step of adding tests a module skipped, when its functional specs have scenarios: no test reqs - its own or
+ * imported - or no conformance testing script for its stack. `tree` is what its conformance tests would be written from:
+ * the codebase's spec, the module's own sections with its imports in, and the functional specs it inherits. The script
+ * is looked for under the module's stack - the one pinned, else the one `stackForModule` gives it.
+ */
+export declare function testingGap(input: {
+    moduleName: string;
+    plainFile: string;
+    tree: MarshalledPlainSource;
+    buildDir?: string;
+}): TestingGap | undefined;

package/dist/regenerate/testing-steps.js

@@ -0,0 +1,110 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { conformanceTestsOn } from "../conformance-switch.js";
+import { stackForModule, stackPinned, withStack } from "../config.js";
+import { IMPORT_DIRECTIVE, readPlainSourceMetadata } from "../plain/parser.js";
+import { FUNCTIONAL_REQUIREMENTS, REQUIRED_FUNCTIONAL_SPECS, TEST_REQUIREMENTS } from "../plain/spec.js";
+import { isStdlibModule, STDLIB_ROOT } from "../plain/stdlib.js";
+import { projectDirOf, resolveTemplateDirs } from "./paths.js";
+import { hasScenarios } from "./records.js";
+import { findTestScripts, projectRootFor } from "./test-scripts.js";
+/** The stack template a module imports, `stdlib/<kind>/<stack>`, through its imports - none, when it imports none. */
+function stdlibStackOf(plainFile) {
+    const dirs = resolveTemplateDirs(resolve(plainFile));
+    const seen = new Set();
+    const visit = (path) => {
+        if (seen.has(path) || !existsSync(path))
+            return undefined;
+        seen.add(path);
+        let imports;
+        try {
+            imports = readPlainSourceMetadata(readFileSync(path, "utf8")).metadata[IMPORT_DIRECTIVE] ?? [];
+        }
+        catch {
+            return undefined;
+        }
+        for (const name of imports) {
+            const bare = name.replace(/^\.\//, "");
+            if (isStdlibModule(bare)) {
+                const [, kind, stack, more] = bare.split("/");
+                if (kind !== undefined && stack !== undefined && more === undefined && kind !== "lang" && stack !== "common")
+                    return { kind, stack };
+                continue;
+            }
+            const found = [dirname(path), ...dirs].map((dir) => join(dir, `${bare}.plain`)).find((candidate) => existsSync(candidate));
+            const stack = found !== undefined ? visit(resolve(found)) : undefined;
+            if (stack !== undefined)
+                return stack;
+        }
+        return undefined;
+    };
+    return visit(resolve(plainFile));
+}
+/**
+ * The standard library's conformance template for a module's stack, `stdlib/<kind>/conformance/<stack>`, when the module
+ * imports a stack template that has one - nothing otherwise.
+ */
+export function conformanceTemplateOf(plainFile) {
+    const template = stdlibStackOf(plainFile);
+    const conformance = template !== undefined ? `stdlib/${template.kind}/conformance/${template.stack}` : undefined;
+    return conformance !== undefined && existsSync(join(STDLIB_ROOT, `${conformance}.plain`)) ? conformance : undefined;
+}
+/**
+ * The conformance testing script a module's tests would run with, looked for under its stack - the one pinned, else
+ * the one `stackForModule` gives it - or nothing, with why when there is a why.
+ */
+export function conformanceScriptOf(plainFile, buildDir) {
+    const stack = stackPinned() ? undefined : stackForModule(plainFile);
+    const scripts = () => {
+        const root = buildDir !== undefined ? projectRootFor(plainFile, buildDir) : projectDirOf(plainFile);
+        return findTestScripts(root, plainFile, buildDir);
+    };
+    const found = stackPinned() ? scripts() : withStack(stack, scripts);
+    return { ...(found.conformance !== undefined ? { script: found.conformance } : {}), ...(found.notes?.conformance !== undefined ? { note: found.notes.conformance } : {}) };
+}
+/** The functional specs of a codebase's tree - its own, or ones it inherits - that have scenarios, as `module:func-id`, a module below's first. */
+function withScenarios(tree, moduleName) {
+    const items = (section) => (tree[section] ?? []);
+    return [...items(REQUIRED_FUNCTIONAL_SPECS), ...items(FUNCTIONAL_REQUIREMENTS)].filter(hasScenarios).map((item) => `${item.module ?? moduleName}:${item.id}`);
+}
+/** Specs named in a line: the first three, and how many more. */
+function named(specs) {
+    return specs.length <= 3 ? specs.join(", ") : `${specs.slice(0, 3).join(", ")} and ${specs.length - 3} more`;
+}
+/**
+ * The step of adding tests a module skipped, when its functional specs have scenarios: no test reqs - its own or
+ * imported - or no conformance testing script for its stack. `tree` is what its conformance tests would be written from:
+ * the codebase's spec, the module's own sections with its imports in, and the functional specs it inherits. The script
+ * is looked for under the module's stack - the one pinned, else the one `stackForModule` gives it.
+ */
+export function testingGap(input) {
+    const { moduleName, plainFile } = input;
+    // Conformance tests off: none is written, so no step of adding them is skipped.
+    if (!conformanceTestsOn(plainFile))
+        return undefined;
+    const tested = withScenarios(input.tree, moduleName);
+    if (tested.length === 0)
+        return undefined;
+    const found = conformanceScriptOf(plainFile, input.buildDir);
+    const scriptStep = "write the conformance testing script with the implement-conformance-testing-script skill";
+    if ((input.tree[TEST_REQUIREMENTS] ?? []).length === 0) {
+        const conformance = conformanceTemplateOf(plainFile);
+        const reqs = conformance !== undefined ? `import the stack's conformance template, ${conformance}` : "write the module's own ***test reqs***";
+        return {
+            step: "test reqs",
+            text: `${moduleName} has scenarios to test - ${named(tested)} - but no ***test reqs***, so its conformance tests cannot be written - the test reqs are ` +
+                `the first step of adding tests. Next step: ${reqs}, with change_plain${found.script === undefined ? `; then ${scriptStep}` : ""}.`,
+            short: "scenarios not tested: no test reqs",
+        };
+    }
+    if (found.script === undefined) {
+        const note = found.note;
+        return {
+            step: "conformance testing script",
+            text: `${moduleName} has scenarios to test - ${named(tested)} - and ***test reqs*** but no conformance testing script, so nothing can run its conformance ` +
+                `tests - the script is the second step of adding tests. Next step: ${scriptStep}.${note !== undefined ? ` ${note}` : ""}`,
+            short: "scenarios not tested: no conformance testing script",
+        };
+    }
+    return undefined;
+}

package/dist/regenerate/testing.d.ts

@@ -93,7 +93,7 @@ export declare function draftPrompt(): string;
 export declare const AGAIN_ASKS = 2;
 /** For a coding agent regenerating functional specs again that has written nothing: no change is no answer. */
 export declare function againPrompt(again: Array<{
-    frid: string;
+    funcId: string;
     module?: string;
 }>): string;
 export type UnitVerdict = {

package/dist/regenerate/testing.js

@@ -6,7 +6,7 @@ import { reportActivity } from "./activity.js";
 import { maskSecrets } from "./masking.js";
 import { NOTES_FILE } from "./notes.js";
 import { modulesScratchDir } from "./paths.js";
-import { RECORD_FILE } from "./paths.js";
+import { BASE_RECORD_FILE, RECORD_FILE } from "./paths.js";
 import { missingToolchain, runUnitScript, scriptFailure } from "./test-scripts.js";
 import { COMMAND_TIMEOUT_MS } from "./shell.js";
 import { pulseWrote } from "./pulse-files.js";
@@ -210,6 +210,7 @@ export const NOT_CODE = new Set([
     // Working notes for the agents: not part of the codebase either (see notes.ts).
     NOTES_FILE,
     RECORD_FILE,
+    BASE_RECORD_FILE,
 ]);
 export function listFiles(root) {
     const found = [];
@@ -305,8 +306,8 @@ export function draftPrompt() {
     return [
         "You have not written anything yet: the code folder is as it was when you started.",
         "",
-        "If the change needs code - anything it adds to or changes in a functional spec, an implementation req or an",
-        "acceptance test - stop planning and write it now: your best guess at what the change asks, the code and its",
+        "If the change needs code - anything it adds to or changes in a functional spec, a definition or an implementation",
+        "req - stop planning and write it now: your best guess at what the change asks, the code and its",
         "unit tests, as a draft. If you are sure it needs no code at all - it only rewords, describes or renames - say so",
         "in one line, and why.",
         "Where the specification leaves something open, pick the most likely reading, write it, and note the assumption",
@@ -317,7 +318,7 @@ export function draftPrompt() {
 export const AGAIN_ASKS = 2;
 /** For a coding agent regenerating functional specs again that has written nothing: no change is no answer. */
 export function againPrompt(again) {
-    const named = again.map((spec) => `fs ${spec.frid}${spec.module !== undefined ? ` of module \`${spec.module}\`` : ""}`).join(", ");
+    const named = again.map((spec) => (spec.module !== undefined ? `\`${spec.module}:${spec.funcId}\`` : `\`${spec.funcId}\``)).join(", ");
     return [
         "You have not written anything yet: the code folder is as it was when you started.",
         "",

package/dist/regenerate/unit-review.d.ts

@@ -47,7 +47,7 @@ export declare function changedUnitTests(buildDir: string, atStart: Map<string,
  */
 export declare function unitReviewTask(options: {
     buildDir: string;
-    /** What the work built: "functionality 3 of module `m`", "the spec change to module `m`". */
+    /** What the work built: "functional spec `m:add-task`", "the spec change to module `m`". */
     what: string;
     /** The specification it built, as the coding agent had it, what is new in this work apart (`reviewedSpec`). */
     spec: string;

package/dist/regenerate/unit-review.js

@@ -111,7 +111,7 @@ export function unitReviewTask(options) {
                         "This work is the <spec change> in <new in this work>, section by section: what it adds or changes is what needs",
                         "testing, and the tests it changed still have to test the rest as they did. A change that adds no behaviour - a",
                         "description, a renamed concept, a reworded spec - needs no new test.",
-                        "Behaviour is what a functional spec, an acceptance test or an implementation req states. A definition says what",
+                        "Behaviour is what a functional spec or an implementation req states. A definition says what",
                         "a word means: a page, a component or a record that only <definitions> name, and no functional spec or",
                         "implementation req of this codebase asks for, has no code yet, and a test for it is not missing.",
                     ]
@@ -303,8 +303,8 @@ async function reviewLoop(options, reviewer) {
                 workdir: options.buildDir,
                 read: [options.buildDir],
                 uphold: [
-                    "- uphold it when because of it a behaviour this work's specification states - in a functional spec, an",
-                    "  acceptance test or an implementation req - is not implemented, is implemented other than it says, is not tested, or a",
+                    "- uphold it when because of it a behaviour this work's specification states - in a functional spec or an",
+                    "  implementation req - is not implemented, is implemented other than it says, is not tested, or a",
                     "  test cannot fail when that behaviour breaks. Then the reviewer is right, and the coding agent fixes it.",
                 ],
                 changed,

package/dist/regenerate-cli.js

@@ -1,19 +1,20 @@
 import { CONFIG_FILE, readProjectConfig } from "./config.js";
 import { parseArgs } from "./cli-options.js";
 import { headlessOptions, runLoop } from "./loop-cli.js";
-const USAGE = `usage: turri regenerate [file.plain] [frid ...] [options]
+const USAGE = `usage: turri regenerate [file.plain] [module:func-id ...] [options]
 
 Regenerates the module's code from its spec as it is now, and everything it requires, bottom first, as
 the chat does: what is left to regenerate - from what each module's code was regenerated from to its
 spec now - is planned into jobs, and they run one after the other until the code is regenerated from
-the spec, each followed by the conformance tests of what it regenerated when they are on. Then it says
-how each went. With functional specs named, those are regenerated though their spec did not change - as regenerate
-does in the chat with functionalities named: their code taken out and built anew, doing what the spec says.
+the spec, then the conformance tests of every functional spec with scenarios whose tests are behind. Then it says
+how each went. With functional specs named - each as module:func-id - those are regenerated though their spec did
+not change, as regenerate does in the chat with funcIds named: their code taken out and built anew, doing what the
+spec says.
 
 The project's config.turri.yaml, in the current directory, gives the defaults: module (the file to
-build when none is given), coding-model (the agents that build), harness-model (the planner), and
-conformance-tests. It exits 0 only when every module is complete: regenerated from the spec as it is,
-its conformance tests too when they are on.
+build when none is given), coding-model (the agents that build) and harness-model (the planner). It exits
+0 only when every module is complete: regenerated from the spec as it is, and its conformance tests written
+for every functional spec's scenarios.
 
   --dry-run                plan the work and print the prompt of the first job, and run nothing (turri glimpse)
   --start-over             start over, without asking, a codebase regenerated without a module it now requires -
@@ -21,23 +22,21 @@ its conformance tests too when they are on.
   --from-scratch           delete the module's code and conformance tests (its lineage keeps them) and regenerate all of it
   --from-scratch-chain     the same for every module of its requires chain, built again from the bottom - after
                            modules were split or moved
-  --harness-model <p/id>   config.turri.yaml's harness-model for this run: the planner and the conformance chooser
+  --harness-model <p/id>   config.turri.yaml's harness-model for this run: the planner
   --coding-model <p/id>    its coding-model, --model too: the agents that build; p/id:level for how hard a model thinks
   --judge-model <p/id>     its judge-model: the judge and the test review
   --review <true|false>    its review: whether the code and its tests are reviewed once they pass
   --mutation-testing <true|false>
                            its mutation-testing: whether the coding agent and the reviewer can put a bug in the code
                            for one test run (can_it_fail), to see that a test catches it
-  --conformance-tests <all|chosen|module|false>
-                           its conformance-tests: which conformance tests are written and run
   --build-dir <dir>        as the run ends, however it ends, export the code there: the furthest-built codebase's
                            last commit, which holds every module it requires - the folder's contents are replaced
   --report <file.json>     write a report of the run there - outcome, usage, pulses, functional specs completed -
                            as it starts, as each pulse ends and as it exits (docs/headless.md)
 
   PLAIN_TEMPLATE_DIRS      colon-separated template directories`;
-const { positional, options } = parseArgs(process.argv.slice(2), ["--dry-run", "--start-over", "--from-scratch", "--from-scratch-chain"], USAGE, ["--build-dir", "--report", "--conformance-tests", "--harness-model", "--judge-model", "--review", "--mutation-testing"]);
-const { report, buildDir } = headlessOptions(options, true);
+const { positional, options } = parseArgs(process.argv.slice(2), ["--dry-run", "--start-over", "--from-scratch", "--from-scratch-chain"], USAGE, ["--build-dir", "--report", "--harness-model", "--judge-model", "--review", "--mutation-testing"]);
+const { report, buildDir } = headlessOptions(options);
 const named = positional[0] ?? readProjectConfig(process.cwd()).module;
 // Functional specs named after the file: regenerated again though their spec did not change.
 const again = positional.slice(1);

package/dist/release-agent.js

@@ -22,6 +22,10 @@ function outsideBuiltCode(tool, dir) {
             if (relative(dir, path).split(sep).includes("plain_modules")) {
                 throw new Error(`Not written: ${shortPath(path)} is built code. A release never changes it - a fix belongs in the spec.`);
             }
+            // The ***plain - a module, a test plain file - is the person's: a release that finds it wrong says so, never rewrites it.
+            if (path.endsWith(".plain")) {
+                throw new Error(`Not written: ${shortPath(path)} is ***plain. A release never changes it - say what is wrong with it instead.`);
+            }
             return tool.execute(toolCallId, params, signal, onUpdate, ctx);
         },
     };

package/dist/release-cli.js

@@ -1,4 +1,5 @@
 import { closeSync, openSync, readSync, statSync } from "node:fs";
+import { refuseTestPlainFile } from "./test-plain-files.js";
 import { resolve } from "node:path";
 import { configForSpec, modelSpec, projectModels, readProjectConfig } from "./config.js";
 import { createDeployState } from "./release-tools.js";
@@ -90,6 +91,7 @@ async function main() {
         process.exit(1);
     }
     const plainFile = resolve(named);
+    refuseTestPlainFile(plainFile);
     // A release follows steps - a script, a start command: the coding model does that well, thinking low.
     const model = args.model ?? modelSpec(projectModels(configForSpec(plainFile)).coding);
     const state = createDeployState();

package/dist/release-tools.js

@@ -1,4 +1,5 @@
 import { isAbsolute, relative, resolve } from "node:path";
+import { refuseTestPlainFile } from "./test-plain-files.js";
 import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { deployLogDir, deployTarget, describeDeployment, exportModule, hostDirOf, shortPath, startDeployed, stopDeployed, } from "./regenerate/release.js";
@@ -88,6 +89,7 @@ export function createDeployTools(options) {
             if (named === undefined)
                 throw new Error("Which spec? config.turri.yaml names no module: pass plain_file.");
             const plainFile = resolve(options.cwd, named);
+            refuseTestPlainFile(plainFile);
             const target = deployTarget(plainFile, params.in_module);
             const guidance = params.guidance?.trim() || undefined;
             // Released already: the module's last commit is what the last release shipped. Nothing is exported or stopped -

package/dist/run-report.d.ts

@@ -8,7 +8,7 @@ import { type Job } from "./regenerate/jobs.ts";
  * pulse failed, a crash, a signal. A process killed outright (SIGKILL) leaves the one written as the last pulse ended.
  * Each write is atomic: the file is written beside it and renamed over it, so a reader never sees half of one.
  */
-export declare const REPORT_SCHEMA_VERSION = 1;
+export declare const REPORT_SCHEMA_VERSION = 2;
 /** What the usage of some model calls adds up to, as the report gives it. */
 export interface UsageTotals {
     input_tokens: number;
@@ -42,6 +42,7 @@ export interface CompletionCounts {
     modules: Array<{
         module: string;
         specified: number;
+        withScenarios: number;
         completed: number;
         conformanceTested: number;
         incomplete: string[];
@@ -71,7 +72,6 @@ export interface RunReportOptions {
     specFile: string;
     projectDir: string;
     buildDir?: string;
-    conformanceTests: string;
     /** Whether the code and its tests are reviewed once they pass. */
     review?: boolean;
     /** Whether the coding agent and the reviewer had can_it_fail. */