@turri-dev/cli 0.1.27 → 0.2.0

package/dist/regenerate/conformance-agents.js

@@ -1,5 +1,6 @@
 import { readFileSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
+import { scenariosOf, scenarioText } from "./test-kinds.js";
 import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { ask, BEGIN, createExecutor } from "../pi.js";
@@ -10,7 +11,8 @@ import { reportActivity } from "./activity.js";
 import { runTiming, withTestingScripts } from "./test-scripts.js";
 import { createWebTools, WEB_TOOLS } from "./web.js";
 import { diffFiles, digestFiles } from "./codebase.js";
-import { ERROR_CAUSE_RULES, fixMethod, INTEGRITY_RULES, specPrimer } from "./prompt.js";
+import { BASE_FOLDER_RULES, baseFolderBlock, ERROR_CAUSE_RULES, fixMethod, INTEGRITY_RULES, specPrimer } from "./prompt.js";
+import { baseOfCodebase } from "./base-folder.js";
 import { conformanceReviewCasesBlock } from "./cases.js";
 import { REVIEW_LESSON } from "./notes.js";
 import { CODER_COMPACTION, REVIEWER_COMPACTION } from "./compaction.js";
@@ -20,9 +22,8 @@ export function explorationText(exploration, replies = []) {
     const sections = [
         `## How to build and run it\n\n${exploration.buildAndRun.trim()}`,
         `## How the conformance tests reach it, run by the testing script\n\n${exploration.testsReachIt.trim()}`,
-        `## How each functionality is reached\n\n${exploration.interfaces.map((item) => `### ${item.module} ${item.frid}\n\n${item.how.trim()}`).join("\n\n")}`,
+        `## How each functionality is reached\n\n${exploration.interfaces.map((item) => `### ${item.module} ${item.funcId}\n\n${item.how.trim()}`).join("\n\n")}`,
         `## What it needs around it\n\n${exploration.environment.trim()}`,
-        `## Plan for the conformance tests\n\n${exploration.plan.map((item) => `### ${item.module} ${item.frid}\n\n${item.tests.trim()}`).join("\n\n")}`,
         ...(exploration.other?.trim() ? [`## Anything else\n\n${exploration.other.trim()}`] : []),
         // An account it could not complete is passed on with what it wrote, so nothing it found is lost.
         ...(replies.length > 0 ? [`## What the explorer wrote as it worked\n\n${replies.map((reply) => reply.trim()).join("\n\n")}`] : []),
@@ -32,7 +33,7 @@ export function explorationText(exploration, replies = []) {
 /**
  * What an exploration lacks for the conformance tests to be written from it alone, or nothing when
  * it is whole: how to build and run it, and - for every functionality the tests are for - how it
- * is reached and what to test.
+ * is reached.
  */
 /**
  * How many tool calls the agents with one thing to decide may make before they are told to decide:
@@ -47,9 +48,7 @@ export const JUDGE_CALLS = 30;
 export const MAX_EXPLORATION_CHARS = 12_000;
 /** How many times the explorer may hand an exploration over: each ends its turn, and is checked. */
 export const EXPLORATION_SUBMISSIONS = 3;
-export function explorationProblems(exploration, scope, moduleName, 
-/** The functionalities whose acceptance tests the plan has to carry out, and how many each has. */
-acceptance = []) {
+export function explorationProblems(exploration, scope, moduleName) {
     if (exploration === undefined)
         return ["You have not called submit_exploration."];
     const problems = [];
@@ -58,11 +57,11 @@ acceptance = []) {
         problems.push(`It is ${size} characters - keep it under ${MAX_EXPLORATION_CHARS}. Hand over the interface, not the code: the routes, ` +
             "commands, fields and their types, and the setup - no code listings, no files pasted whole.");
     }
-    const unknown = [...exploration.interfaces, ...exploration.plan].filter((item) => item.frid !== "" && !scope.functionalities.some((ref) => ref.module === item.module && ref.frid === item.frid));
+    const unknown = exploration.interfaces.filter((item) => item.funcId !== "" && !scope.functionalities.some((ref) => ref.module === item.module && ref.funcId === item.funcId));
     if (unknown.length > 0 && scope.tested === undefined) {
-        const names = [...new Set(unknown.map((item) => `${item.module} ${item.frid}`))];
-        problems.push(`${names.join(", ")} ${names.length === 1 ? "is not a functionality" : "are not functionalities"}: give module and id as ` +
-            `the specification numbers them - ${scope.functionalities.filter((ref) => ref.module === moduleName).map(refLabel).join(", ") || "none yet"}.`);
+        const names = [...new Set(unknown.map((item) => `${item.module} ${item.funcId}`))];
+        problems.push(`${names.join(", ")} ${names.length === 1 ? "is not a functionality" : "are not functionalities"}: give module and func-id as ` +
+            `the specification has them - ${scope.functionalities.filter((ref) => ref.module === moduleName).map(refLabel).join(", ") || "none yet"}.`);
     }
     const short = (text) => (text ?? "").trim().length < 40;
     if (short(exploration.buildAndRun))
@@ -75,46 +74,26 @@ acceptance = []) {
     if (short(exploration.environment))
         problems.push("environment says too little: every variable, configuration file, service, database and fixture it needs, and how each test gets a fresh one - or say plainly it needs none.");
     const reached = exploration.interfaces.filter((item) => !short(item.how));
-    const planned = exploration.plan.filter((item) => !short(item.tests));
     if (scope.tested !== undefined) {
-        // A functionality's run: the one under test, reached and planned for.
+        // A functionality's run: the one under test, reached.
         const tested = scope.tested;
-        const has = (list) => list.some((item) => item.module === tested.module && item.frid === tested.frid);
+        const has = (list) => list.some((item) => item.module === tested.module && item.funcId === tested.funcId);
         if (!has(reached))
             problems.push(`interfaces does not say how ${refLabel(tested)} is reached: the command and its arguments, or the route, method, headers and the request and response fields.`);
-        if (!has(planned))
-            problems.push(`plan has no tests for ${refLabel(tested)}: the cases to write, how each is set up and invoked, and what it checks as the specification says.`);
     }
     else {
-        // A spec change's: what it touches is for the explorer to say, but some of this module has to be reached and planned.
-        if (!reached.some((item) => item.module === moduleName))
-            problems.push(`interfaces says nothing of how \`${moduleName}\`'s functionalities the change touches are reached - one entry each.`);
-        if (!planned.some((item) => item.module === moduleName))
-            problems.push(`plan has no tests for \`${moduleName}\`: the cases the change adds, changes or removes, for each functionality it touches.`);
-    }
-    // Every acceptance test is carried out, step by step, from outside: a plan that leaves one out
-    // leaves its author to write a placeholder.
-    for (const item of acceptance) {
-        const text = exploration.plan
-            .filter((entry) => entry.module === item.module && entry.frid === item.frid)
-            .map((entry) => entry.tests)
-            .join("\n");
-        const named = new Set([...text.matchAll(/acceptance test\s*(\d+)/gi)].map((match) => Number(match[1])));
-        const missing = Array.from({ length: item.count }, (_, index) => index + 1).filter((n) => !named.has(n));
-        if (missing.length > 0) {
-            problems.push(`plan does not carry out ${missing.map((n) => `acceptance test ${n}`).join(", ")} of ${item.module} ${item.frid}: name each ` +
-                '"acceptance test N" as the specification numbers them, and say how each of its steps is done from outside - through ' +
-                "which endpoint, or which class and method where the test reqs let the tests call a component directly - with what, " +
-                "and what it asserts. A long acceptance test is planned whole, never cut down.");
+        // A spec change's: what it touches is for the explorer to say, but some of a module it touches has to be reached.
+        const modules = scope.touchedModules !== undefined && scope.touchedModules.length > 0 ? scope.touchedModules : [moduleName];
+        if (!reached.some((item) => modules.includes(item.module))) {
+            problems.push(`interfaces says nothing of how the functionalities of ${modules.map((module) => `\`${module}\``).join(" or ")} the change touches are reached - one entry each.`);
         }
     }
     return problems;
 }
 /**
- * How the built software is invoked from outside, and a plan for its conformance tests, as an agent
- * that explored the code writes it - everything the tests' author works
- * from. Checked before it is used: it has to cover every functionality the tests are for, and is sent
- * back until it does. What the explorer wrote in its replies goes with an account it never completed.
+ * How the built software is invoked from outside, as an agent that explored the code writes it - everything of the code
+ * the tests' author works from; what to test is the scenarios'. Checked before it is used: it has to cover every
+ * functionality the tests are for, and is sent back until it does. What the explorer wrote in its replies goes with an account it never completed.
  */
 export async function exploreInvocation(options) {
     // The codebase's account from an earlier run, and what of the code changed since: the explorer starts from it.
@@ -126,14 +105,14 @@ export async function exploreInvocation(options) {
         module: Type.Optional(Type.String({ description: "The module the functionality is in" })),
         id: Type.Optional(Type.String({
             description: target !== undefined
-                ? `The functionality's id as the specification numbers it, e.g. "${target.frid}" - leave both out for ${refLabel(target)}, the one under test`
-                : 'The functionality\'s id as the specification numbers it, e.g. "3" - never a name of your own',
+                ? `The functionality's func-id as the specification has it, e.g. "${target.funcId}" - leave both out for ${refLabel(target)}, the one under test`
+                : 'The functionality\'s func-id as the specification has it, e.g. "add-task" - never a name of your own',
         })),
     };
     /** An entry's functionality: as given when it is one, otherwise - in a functionality's run - the one under test. */
     const owner = (item) => {
-        const given = { module: (item.module ?? "").trim() || options.spec.moduleName, frid: (item.id ?? "").trim() };
-        const known = options.scope.functionalities.some((known) => known.module === given.module && known.frid === given.frid);
+        const given = { module: (item.module ?? "").trim() || options.spec.moduleName, funcId: (item.id ?? "").trim() };
+        const known = options.scope.functionalities.some((known) => known.module === given.module && known.funcId === given.funcId);
         return known || target === undefined ? given : { ...target };
     };
     const submit = defineTool({
@@ -158,12 +137,6 @@ export async function exploreInvocation(options) {
             environment: Type.String({
                 description: "What it needs around it: environment variables, configuration, services, databases, files, fixtures - and how each test gets a fresh one",
             }),
-            plan: Type.Array(Type.Object({
-                ...ref,
-                tests: Type.String({
-                    description: "The conformance tests to write for it, from the specification and its acceptance tests: each case, how it is set up and invoked, what it checks as the specification says, and where its files go as the test reqs say - and every acceptance test, named \"acceptance test N\", with how each of its steps is done from outside and what it asserts",
-                }),
-            })),
             other: Type.Optional(Type.String({ description: "Anything else the test author needs" })),
         }),
         async execute(_id, params) {
@@ -174,7 +147,6 @@ export async function exploreInvocation(options) {
                 testsReachIt: given.tests_reach_it ?? "",
                 interfaces: given.interfaces.map((item) => ({ ...owner(item), how: item.how })),
                 environment: given.environment,
-                plan: given.plan.map((item) => ({ ...owner(item), tests: item.tests })),
                 other: given.other,
             };
             // Every hand-over ends the turn and is checked: the harness says what is missing, a few times at most.
@@ -199,7 +171,7 @@ export async function exploreInvocation(options) {
     try {
         replies.push(await ask(session, BEGIN, options.onDelta));
         for (let again = 0; again < EXPLORATION_SUBMISSIONS; again += 1) {
-            const problems = explorationProblems(exploration, options.scope, options.spec.moduleName, options.acceptance);
+            const problems = explorationProblems(exploration, options.scope, options.spec.moduleName);
             if (problems.length === 0 || submissions >= EXPLORATION_SUBMISSIONS)
                 break;
             reportActivity(`  the exploration is not complete yet: ${problems[0].slice(0, 120)}`);
@@ -209,7 +181,7 @@ export async function exploreInvocation(options) {
     finally {
         session.dispose();
     }
-    const complete = explorationProblems(exploration, options.scope, options.spec.moduleName, options.acceptance).length === 0;
+    const complete = explorationProblems(exploration, options.scope, options.spec.moduleName).length === 0;
     const found = replies.filter((reply) => reply.trim() !== "");
     if (exploration === undefined) {
         return found.length > 0
@@ -332,7 +304,7 @@ export function createAskExplorerTool(options) {
 }
 export function explorePrompt(buildDir, spec, scope, testingScripts, question, previous) {
     const target = scope.tested !== undefined
-        ? `functionality ${refLabel(scope.tested)}`
+        ? `functional spec ${refLabel(scope.tested)}`
         : `the spec change - every functionality of \`${spec.moduleName}\` it can reach`;
     return [
         specPrimer({ testReqs: true }),
@@ -358,17 +330,11 @@ export function explorePrompt(buildDir, spec, scope, testingScripts, question, p
         "  reached from outside: the command and its arguments, or the route, method and headers, and the fields",
         "  of its request and response and their types, as the code takes them;",
         "- environment: environment variables, configuration, services and databases it talks to, files and",
-        "  fixtures - and how each test gets a fresh one;",
-        `- plan: the conformance tests to write for ${target}, from the specification and its acceptance tests:`,
-        "  each case, how it is set up and invoked, what it checks as the specification says, and where the files",
-        "  go as the test reqs say. Every acceptance test, named \"acceptance test N\" as the specification numbers",
-        "  them, with how each of its steps is done from outside - through which endpoint, or which class and",
-        "  method where the test reqs let the tests call a component directly - and what it asserts. A long one is",
-        "  planned whole, never cut down;",
+        "  fixtures - and how each test gets a fresh one.",
         "",
+        "What to test is not yours to say: the tests carry out the functional specs' scenarios, and nothing else.",
         "Describe how to call it, never what it answers: what it returns in each case is for the tests to check",
-        "against the specification, not to copy from the code - so the plan's expectations come from the",
-        "specification, and the code only tells you how to reach it. Read the code - its build files, its entry points, its",
+        "against the scenarios, not to copy from the code - the code only tells you how to reach it. Read the code - its build files, its entry points, its",
         "configuration - with the file tools: you have no shell, and run nothing. Change nothing. Then call submit_exploration - once, with the whole of it: it ends your turn, and",
         `you are told if anything is missing. You can hand it over ${EXPLORATION_SUBMISSIONS} times at most.`,
         "",
@@ -397,7 +363,7 @@ export function explorePrompt(buildDir, spec, scope, testingScripts, question, p
                 "This codebase was explored before, for an earlier conformance run, and the account below was handed over then.",
                 "Start from it - do not explore again what it already says. Check what it says against the files that changed",
                 "since, listed below, and read further only for what it does not cover yet: how the functionality under test",
-                "now is reached, and the plan for its tests. Then hand over the whole account, updated - what still holds kept,",
+                "now is reached. Then hand over the whole account, updated - what still holds kept,",
                 "what changed corrected, what is new added.",
                 "",
                 `<the account handed over before>
@@ -450,7 +416,7 @@ export async function createTestReviewer(options) {
                 }),
                 what: Type.String({ description: "Exactly what is missing or bad, and what the specification says instead" }),
                 blocking: Type.Boolean({
-                    description: "True when the functionality is not yet tested black box because of it: a test or an acceptance test missing, cut down or " +
+                    description: "True when the functionality is not yet tested black box because of it: a scenario's test missing, cut down or " +
                         "skipping what it checks, the software mocked or not reached from outside, a test that cannot fail. False for a way to make " +
                         "tests that already do that better",
                 }),
@@ -502,10 +468,10 @@ function problemText(problem) {
 }
 /** The reviewer's task, for its instructions: word for word through every review of the run. */
 export function testReviewTask(options) {
-    const withAcceptance = options.functionalities.filter((item) => item.acceptanceTests.length > 0);
+    const scenarios = options.functionalities.flatMap((item) => scenariosOf(item).map((scenario) => ({ module: item.module ?? options.spec.moduleName, funcId: item.funcId, scenario })));
     const whose = options.forChange
-        ? `the functionalities of module \`${options.spec.moduleName}\` the change touches (${options.functionalities.map((item) => item.frid).join(", ") || "none"})`
-        : `functionality ${options.functionalities[0]?.frid ?? ""} of module \`${options.spec.moduleName}\``;
+        ? `the functionalities the change touches (${options.functionalities.map((item) => `${item.module ?? options.spec.moduleName}:${item.funcId}`).join(", ") || "none"})`
+        : `functional spec ${options.spec.moduleName}:${options.functionalities[0]?.funcId ?? ""}`;
     return [
         specPrimer({ testReqs: true }),
         `You review the conformance tests of the \`${options.spec.moduleName}\` specification a conformance run adds or changes, each time`,
@@ -524,7 +490,9 @@ export function testReviewTask(options) {
         "check it against the diff and the files. A problem it says is fixed that the tests do not fix is still a problem;",
         "one it declined, weigh its reason - it may be right.",
         "",
-        ...(options.cases !== undefined && options.cases.mechanical ? [...conformanceReviewCasesBlock(options.cases), "", "And, of every test the run changed:"] : ["Check every test the run added or changed:"]),
+        ...(options.cases !== undefined && options.cases.mechanical
+            ? [...conformanceReviewCasesBlock(options.cases), "", "And, of every test the run changed:"]
+            : [...(options.cases !== undefined ? conformanceReviewCasesBlock(options.cases, options.spec.moduleName) : []), "Check every test the run added or changed:"]),
         "- Black box: it reaches the software only the way the test reqs have it - its API, its command, its public",
         "  classes where the test reqs say so - and never mocks, stubs or replaces any part of the software under test:",
         "  no mocked beans, services or clients of its own. A real external service the test reqs say not to mock is",
@@ -532,33 +500,33 @@ export function testReviewTask(options) {
         "- It tests something: every test asserts what the specification says, and fails when that does not hold. No",
         "  placeholder, no `assertTrue(true)`, no empty or skipped test, no failure caught and swallowed, no assertion",
         "  so loose any answer passes.",
-        ...(withAcceptance.length > 0
+        ...(scenarios.length > 0
             ? [
-                `- The acceptance tests of ${whose}, each implemented as a test of its own, doing every step it lists, in`,
-                "  order, with what it names, and asserting every expectation it states. A step left out, replaced by a",
-                "  stand-in, or said to be impossible to run is missing, not done:",
+                `- The scenarios of ${whose}, each carried out by at least one test, doing every step it lists, in order, with`,
+                "  what it names, and asserting every expectation it states. A step left out, replaced by a stand-in, or said",
+                "  to be impossible to run is missing, not done:",
                 "",
-                ...withAcceptance.flatMap((item) => item.acceptanceTests.map((test, index) => `<acceptance test ${index + 1} of functionality ${item.frid}>\n${test.trim()}\n</acceptance test>`)),
+                ...scenarios.map(({ module, funcId, scenario }) => `<scenario>\n${scenarioText(module, funcId, scenario)}\n</scenario>`),
                 "",
             ]
             : []),
-        `- The conformance tests cover what the specification says ${options.forChange ? "the change does" : `${whose} does`} - its behaviour, its`,
-        "  edge cases, its errors - each checked against the specification, not against what the code happens to do.",
-        "  Only what can be seen from outside: where the specification says one part calls or uses another, the test",
-        "  checks the outcome that follows - what comes back, what is stored, what the other service received - never",
-        "  that the call was made. Asking for a test of how the code works inside is not a problem to raise.",
+        "- The tests are the scenarios', and only theirs: a test that carries out no scenario is not one to ask for, and a",
+        "  missing edge case the scenarios do not name is not a problem to raise. Each is checked against the",
+        "  specification, not against what the code happens to do - only what can be seen from outside: where the",
+        "  specification says one part calls or uses another, the test checks the outcome that follows - what comes back,",
+        "  what is stored, what the other service received - never that the call was made.",
         "",
         "The first review finds every problem, in that one review - the tests go back once with all of them. A review after",
         "it checks each problem you raised last first - fixed, or still there - and raises a new one only when it is one of",
-        "the above - a test that cannot fail, mocks the software, or leaves out or misdoes what the specification or an",
-        "acceptance test asks for. Not a matter of style or thoroughness the last review let pass: the review is not done",
+        "the above - a test that cannot fail, mocks the software, or leaves out or misdoes what the specification or a",
+        "scenario asks for. Not a matter of style or thoroughness the last review let pass: the review is not done",
         "again from the start.",
         "",
         "Each review ends with submit_review, once: pass when nothing is missing and nothing is bad; otherwise every problem",
         '- the file, the test, its kind - "missing" for a test that is not there, "bad" for one that is weak, wrong or not',
         "black box - and exactly what, with what the specification says instead. Be specific: the agent that fixes them gets",
         "your list and nothing else. Mark a problem blocking when because of it the functionality is not yet tested black",
-        "box - a test or an acceptance test missing, cut down or skipping what it checks, the software mocked or not reached",
+        "box - a scenario's test missing, cut down or skipping what it checks, the software mocked or not reached",
         "from outside, a test that cannot fail. Those are worked on first; the rest - ways to make tests that already do",
         "that better - are let go after a few reviews.",
         "",
@@ -614,15 +582,15 @@ export function reviewFeedbackPrompt(problems) {
 }
 /** "billing 4": a functionality as the judge and the person read it. */
 export function refLabel(ref) {
-    return `${ref.module} ${ref.frid}`;
+    return `${ref.module} ${ref.funcId}`;
 }
-const same = (a, b) => a.module === b.module && a.frid === b.frid;
+const same = (a, b) => a.module === b.module && a.funcId === b.funcId;
 /** A conflict's functionalities as the judge gave them, tidied: trimmed, and each once. */
 export function conflictRefs(given) {
     const refs = [];
     for (const item of given ?? []) {
-        const ref = { module: (item.module ?? "").trim(), frid: (item.frid ?? item.id ?? "").trim() };
-        if (ref.module !== "" && ref.frid !== "" && !refs.some((known) => same(known, ref)))
+        const ref = { module: (item.module ?? "").trim(), funcId: (item.funcId ?? item.id ?? "").trim() };
+        if (ref.module !== "" && ref.funcId !== "" && !refs.some((known) => same(known, ref)))
             refs.push(ref);
     }
     return refs;
@@ -648,7 +616,7 @@ export function conflictKey(functionalities) {
     return sortedRefs(functionalities).map(refLabel).join(" & ");
 }
 export function sortedRefs(functionalities) {
-    return conflictRefs(functionalities).sort((a, b) => a.module.localeCompare(b.module) || a.frid.localeCompare(b.frid, undefined, { numeric: true }));
+    return conflictRefs(functionalities).sort((a, b) => a.module.localeCompare(b.module) || a.funcId.localeCompare(b.funcId, undefined, { numeric: true }));
 }
 /** How many times a spec conflict between the same two functionalities is raised before it counts. */
 export const SPEC_CONFLICT_RAISES = 3;
@@ -749,7 +717,7 @@ export async function judgeFailure(options) {
             functionalities: Type.Optional(Type.Array(Type.Object({
                 module: Type.String({ description: "The module the functionality is in" }),
                 id: Type.String({ description: "Its id in that module" }),
-            }), { description: 'For spec: the two functionalities that cannot both hold, e.g. [{"module": "billing", "id": "4"}, {"module": "accounts", "id": "1"}]' })),
+            }), { description: 'For spec: the two functionalities that cannot both hold, e.g. [{"module": "billing", "id": "refund"}, {"module": "accounts", "id": "register"}]' })),
         }),
         async execute(_id, params) {
             const given = params;
@@ -1041,6 +1009,7 @@ export async function createCodeFixer(options) {
  * word for word through every fix of the run; each failure comes as a message (`codeFixPrompt`).
  */
 export function codeFixerTask(options) {
+    const base = baseOfCodebase(options.buildDir);
     return [
         specPrimer({ testReqs: false }),
         `You are the coding agent of the \`${options.spec.moduleName}\` specification. Its code is in ${options.buildDir}. When its`,
@@ -1050,6 +1019,8 @@ export function codeFixerTask(options) {
         options.spec.text.trim(),
         "</specification>",
         "",
+        // What came from the base folder its codebase started from: a fix keeps it.
+        ...(base !== undefined ? [baseFolderBlock(base), ""] : []),
         ...fixMethod({ what: "conformance tests", fixes: "code", runTool: "run_conformance_tests" }),
         "",
         "run_conformance_tests runs the project's conformance testing script on the code as it now is, with the whole",
@@ -1072,6 +1043,7 @@ export function codeFixerTask(options) {
         "Keep the build's identity as it is - its name, coordinates, version, package and main class - unless the",
         "specification asks for another: the tests and other builds point at them. Leave in your notes what holds about",
         "the code for the next agent, not an account of this fix: the harness records the attempts itself.",
+        ...(base !== undefined ? BASE_FOLDER_RULES : []),
         ...INTEGRITY_RULES,
         ...ERROR_CAUSE_RULES,
     ].join("\n");

package/dist/regenerate/conformance.d.ts

@@ -1,6 +1,7 @@
-import { ACCEPTANCE_TESTS, type MarshalledPlainSource } from "../plain/spec.ts";
+import { ACCEPTANCE_TESTS, CONFORMANCE_TESTS, type MarshalledPlainSource } from "../plain/spec.ts";
 import { type BuildingSpec } from "./activity.ts";
 import type { JobCases } from "./drift.ts";
+import { type TestedSpec } from "./test-kinds.ts";
 import { type ScriptRun, failureSignature, STUCK_ROUNDS } from "./test-scripts.ts";
 import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
 import { type Evidence, type ReviewProblem } from "./conformance-agents.ts";
@@ -15,7 +16,7 @@ export interface RenderConformanceTestsOptions {
     /** What the job does to each functional spec (work.ts): its agents are told case by case. */
     cases?: JobCases;
     plainFile: string;
-    frid?: string;
+    funcId?: string;
     templateDirs?: string[];
     /** The rendered code under test. Must exist and be non-empty. */
     buildDir?: string;
@@ -32,6 +33,11 @@ export interface RenderConformanceTestsOptions {
     dryRun?: boolean;
     /** Update the tests for a spec change, given as a diff, rather than for one functionality. */
     diff?: string;
+    /**
+     * For a spec change: what the tests are written for once it lands - the tests record it writes. Every scenario in it
+     * has a labelled test before a run counts, and a label naming nothing in it sends the agent back.
+     */
+    recorded?: MarshalledPlainSource;
     /** That change section by section, as the agents are shown it in place of the diff. */
     change?: string;
     /**
@@ -50,7 +56,7 @@ export interface RenderConformanceTestsOptions {
 }
 export interface RenderConformanceTestsResult {
     moduleName: string;
-    frid: string;
+    funcId: string;
     buildDir: string;
     conformanceDir: string;
     prompt: string;
@@ -80,7 +86,7 @@ export interface RenderConformanceTestsResult {
     specConflict?: {
         functionalities: Array<{
             module: string;
-            frid: string;
+            funcId: string;
         }>;
         reason: string;
     };
@@ -132,14 +138,11 @@ export declare function renderConformanceTests(options: RenderConformanceTestsOp
  */
 export declare function notLandedWhy(what: string, unlabelled?: string[]): string;
 /**
- * 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 declare function touchedFunctionalities(tree: MarshalledPlainSource, frids: string[], diff: string): Array<{
-    frid: string;
-    acceptanceTests: string[];
-}>;
+export declare function touchedFunctionalities(tree: MarshalledPlainSource, funcIds: string[], diff: string, moduleName?: string, cases?: JobCases): TestedSpec[];
 /** From the how-manieth review that sends the tests back the arbiter weighs each one (see arbiter.ts). */
 export declare const REVIEW_ROUNDS = 1;
 /** How many times the tests are sent back to be written and labelled before the run stops. */
@@ -173,9 +176,16 @@ export declare function buildManifests(buildDir: string): Array<{
 export declare function failureLine(run: ScriptRun): string;
 /**
  * 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 declare function buildingSpec(moduleName: string, frid: string, total: number, specifications: {
+export declare function buildingSpec(moduleName: string, funcId: string, total: number, specifications: {
     "functional specs": string[];
-    [ACCEPTANCE_TESTS]?: string[];
+    [CONFORMANCE_TESTS]?: Array<{
+        id: string;
+        text: string;
+    }>;
+    [ACCEPTANCE_TESTS]?: Array<{
+        id: string;
+        text: string;
+    }>;
 }): BuildingSpec;