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

package/dist/regenerate/cases.js

@@ -1,3 +1,4 @@
+import { scenarioLabel } from "./test-kinds.js";
 /**
  * What a job's agents are told to do, by its cases - see docs/regenerating.md. A job's functional specs each fall in
  * one case - fresh, added, changed (patched), regenerated again, taken out - or, with none touched, the job is
@@ -5,12 +6,18 @@
  * functional specs of that case; their reviewers, what to hold each to. A job holding several cases gets a section
  * for each.
  */
-/** Functional specs, each by its number and - each module numbering its own from 1 - the module it belongs to. */
-const named = (specs) => specs.map((spec) => `fs ${spec.frid}${spec.module !== undefined ? ` of module \`${spec.module}\`` : ""} (${spec.text})`).join("; ");
-/** What the coding agent does, case by case. */
-export function codeCasesBlock(cases) {
+/** Functional specs, each by its func-id - with the module it belongs to, a func-id being unique in its module only - and its first line. */
+const named = (specs) => specs.map((spec) => `${spec.module !== undefined ? `\`${spec.module}:${spec.funcId}\`` : `\`${spec.funcId}\``} (${spec.text})`).join("; ");
+/**
+ * What the coding agent does, case by case. `fromBase`: the codebase started from a base folder - nothing is built from
+ * the specification, but the folder is not empty, and a project in it is built on, never set up anew.
+ */
+export function codeCasesBlock(cases, fromBase = false) {
     const lines = [];
-    if (cases.fresh) {
+    if (cases.fresh && fromBase) {
+        lines.push("- Nothing is built from the specification yet, and the codebase holds what the base folder had. Where that is a", "  project - a layout, a dependency manifest, unit tests - build on it: add to them, never set them up anew. Where it", "  is files alone, set the project up around them - its layout, its dependency manifest, and its unit tests where", "  the unit testing script runs them. Then build what follows, with its unit tests.");
+    }
+    else if (cases.fresh) {
         lines.push("- Nothing is built yet: set the project up first - its layout, its dependency manifest, and its unit tests", "  where the unit testing script runs them - then build what follows, with its unit tests.");
     }
     if (cases.add.length > 0)
@@ -53,31 +60,80 @@ export function codeReviewCasesBlock(cases) {
         ...(cases.delete.length > 0 ? [`- Taken out: ${named(cases.delete)} - its code and the tests only it had removed, and nothing else.`] : []),
     ];
 }
-/** What the conformance agent does, case by case. */
-export function conformanceCasesBlock(cases) {
+/** Scenarios, each by the label its tests carry. */
+const labelled = (spec, scenarios, module) => scenarios.map((scenario) => `"${scenarioLabel(scenario.kind, scenario.id, spec.module ?? module, spec.funcId)}"`).join("; ");
+/** Why a functional spec's code moved under its unchanged scenarios, in a few words. */
+const CODE_CHANGED = {
+    text: "its text, or a file it links, changed",
+    again: "it was regenerated again",
+    concept: "a concept it uses changed",
+};
+/**
+ * What the conformance agent does with each functional spec, scenario by scenario - each scenario named by the label its
+ * tests carry - and, where the code moved under unchanged scenarios, what to do with their tests.
+ */
+function scenarioCasesLines(specs, module) {
+    const lines = ["What this job does to the tests, scenario by scenario - each named by the label its tests carry:"];
+    for (const spec of specs) {
+        lines.push(`- \`${spec.module ?? module}:${spec.funcId}\` (${spec.text}):`);
+        if (spec.added.length > 0)
+            lines.push(`  - added - write a test for each: ${labelled(spec, spec.added, module)}.`);
+        if (spec.changed.length > 0)
+            lines.push(`  - changed - rewrite its tests to the scenario as it reads now: ${labelled(spec, spec.changed, module)}.`);
+        if (spec.removed.length > 0)
+            lines.push(`  - removed - delete every test labelled with it, and its label, and nothing else: ${labelled(spec, spec.removed, module)}.`);
+        if (spec.unchanged.length > 0) {
+            lines.push(spec.codeChanged !== undefined
+                ? `  - unchanged, but its code changed - ${CODE_CHANGED[spec.codeChanged]} - run their tests on the new code: ${labelled(spec, spec.unchanged, module)}.`
+                : `  - unchanged - leave their tests exactly as they are: ${labelled(spec, spec.unchanged, module)}.`);
+        }
+    }
+    if (specs.some((spec) => spec.codeChanged !== undefined)) {
+        lines.push("- Where the code changed under unchanged scenarios: their tests were written against the code it replaced. Run them", "  against the new code. Those that pass are tests of the new code too - conformance tests are black box - and are", "  not rewritten. Fix what fails against its scenario, read with the functional spec's text: what a failing test checks", "  that the scenario says stays checked, the test changed only as the new code needs it reached; what it checks that", "  the scenario and the specification leave open - a path, a field, a message, a format the old code chose - is the", "  new code's choice now: rewrite that check to what the new code does, or take it out. No test may hold the new code", "  to what only the old code did.");
+    }
+    lines.push("- The tests of every other functional spec stay as they are.");
+    return lines;
+}
+/** What the conformance agent does, case by case - scenario by scenario, when the job has them. */
+export function conformanceCasesBlock(cases, module = "") {
     const lines = [];
     if (cases.fresh) {
         lines.push("- There are no conformance tests yet: set the tests folder up first - the tests' own build and layout, so the", "  conformance testing script, which brings the tests together with the code, runs them - then write what follows.");
     }
+    if (cases.scenarios !== undefined && cases.scenarios.length > 0)
+        return [...lines, ...scenarioCasesLines(cases.scenarios, module)];
     if (cases.add.length > 0)
-        lines.push(`- New - write its conformance tests: ${named(cases.add)}.`);
+        lines.push(`- New - write a test for each of its scenarios: ${named(cases.add)}.`);
     if (cases.patch.length > 0) {
-        lines.push(`- Changed - its text, its acceptance tests, or a concept it uses: ${named(cases.patch)}.`, "  Its conformance tests exist: rewrite them to what it says now. The tests of everything else stay as they are.");
+        lines.push(`- Changed - its text, its scenarios, or a concept it uses: ${named(cases.patch)}.`, "  Its conformance tests exist: bring them in line with its scenarios as they are now - a test for each, a", "  scenario taken out losing its tests. The tests of everything else stay as they are.");
     }
     if (cases.again.length > 0) {
-        lines.push(`- Regenerated again - its code was built anew, and its conformance tests were written against the code it replaced: ${named(cases.again)}.`, "  Its text did not change, but the code did: write its tests again for the new code - that they still pass is", "  no sign they fit it. What they check that the specification says stays checked, as the new code is reached.", "  What they check that the specification leaves open - a path, a field, a message, a format the old code chose", "  and the specification never names - is the new code's choice now: rewrite those checks to what the new code", "  does, or take them out. No test may hold the new code to what only the old code did. A run that leaves every", "  test file labelled with it as it was is sent back. The tests of everything else stay as they are.");
+        lines.push(`- Regenerated again - its code was built anew, and its conformance tests were written against the code it replaced: ${named(cases.again)}.`, "  Its text did not change, but the code did. Run its tests against the new code. Those that pass are tests of the", "  new code too - conformance tests are black box - and are not rewritten. Fix what fails against the", "  specification: what a failing test checks that the specification says stays checked, the test changed only as", "  the new code needs it reached; what it checks that the specification leaves open - a path, a field, a message,", "  a format the old code chose and the specification never names - is the new code's choice now: rewrite that", "  check to what the new code does, or take it out. No test may hold the new code to what only the old code did.", "  The tests of everything else stay as they are.");
     }
     if (cases.delete.length > 0)
-        lines.push(`- Taken out - remove its conformance tests: ${named(cases.delete)}.`);
+        lines.push(`- Taken out, or its scenarios all taken out - remove its conformance tests: ${named(cases.delete)}.`);
     if (cases.mechanical) {
         lines.push("- No functional spec is touched: the change is to the test reqs, or to definitions or implementation reqs alone.", "  Adapt the existing tests to it. Write no new tests. A test may change only mechanically - how it is built,", "  started or reaches the software - never what it asserts. Every test must still pass.");
     }
     return lines;
 }
-/** What the conformance test reviewer holds the tests to, when the job is mechanical: in place of its checks. */
-export function conformanceReviewCasesBlock(cases) {
-    if (!cases.mechanical)
-        return [];
+/** What the conformance test reviewer holds the tests to: scenario by scenario - or, when the job is mechanical, in place of its checks. */
+export function conformanceReviewCasesBlock(cases, module = "") {
+    if (!cases.mechanical) {
+        if (cases.scenarios === undefined || cases.scenarios.length === 0)
+            return [];
+        const all = (pick) => cases.scenarios.flatMap((spec) => (pick(spec).length > 0 ? [labelled(spec, pick(spec), module)] : [])).join("; ");
+        const kept = all((spec) => (spec.codeChanged === undefined ? spec.unchanged : []));
+        const rerun = all((spec) => (spec.codeChanged !== undefined ? spec.unchanged : []));
+        const removed = all((spec) => spec.removed);
+        return [
+            "What this job does to the tests, scenario by scenario - hold it to that:",
+            ...(kept !== "" ? [`- Unchanged - their tests come out exactly as they were, not rewritten or reworded: ${kept}.`] : []),
+            ...(rerun !== "" ? [`- Unchanged, the code changed under them - a test changed only where it failed on the new code, and only to what its scenario says: ${rerun}.`] : []),
+            ...(removed !== "" ? [`- Removed - no test labelled with them is left: ${removed}.`] : []),
+            "",
+        ];
+    }
     return [
         "This work touches no functional spec - only the test reqs, or definitions or implementation reqs alone. Review",
         "only that the tests follow them, and that no test was removed or weakened: an assertion loosened or taken out, a",

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

@@ -1,16 +1,21 @@
 import type { DiffWhere } from "./diff-view.ts";
-import { type SpecChange } from "./spec-steps.ts";
+import { type SpecChange, type TestPlainPath } from "./spec-steps.ts";
 /**
  * `changes` as a diff of `file` - the module's .plain file, which the diff names - section by section: a removed
  * item's lines taken out, an added one's put in, a changed one's both. A change to what a linked file holds
  * follows, as the step's own diff has it.
  */
-export declare function changeDiff(changes: SpecChange[], file: string): string;
+export declare function changeDiff(changes: SpecChange[], file: string, testPlain?: TestPlainView): string;
+/** For a conformance job: the module, and where its functional specs' test plain files are, as the panels name them. */
+export interface TestPlainView {
+    module: string;
+    pathOf: TestPlainPath;
+}
 /**
  * `changeDiff`, each section's items in the order they are written - by file, then by line - rather than in the
  * order the spec is read in, which puts a concept after those it uses: placed by `locate`, as the panels place it.
  */
-export declare function changeDiffInFiles(changes: SpecChange[], file: string, locate: (diff: string) => DiffWhere): {
+export declare function changeDiffInFiles(changes: SpecChange[], file: string, locate: (diff: string) => DiffWhere, testPlain?: TestPlainView): {
     diff: string;
     where: DiffWhere;
 };

package/dist/regenerate/change-view.js

@@ -1,11 +1,11 @@
-import { ACCEPTANCE_TESTS, DEFINITIONS, FUNCTIONAL_REQUIREMENTS, NON_FUNCTIONAL_REQUIREMENTS, REQUIRED_FUNCTIONAL_SPECS, TEST_REQUIREMENTS } from "../plain/spec.js";
-import { resourceDiff } from "./spec-steps.js";
+import { DEFINITIONS, FUNCTIONAL_REQUIREMENTS, NON_FUNCTIONAL_REQUIREMENTS, REQUIRED_FUNCTIONAL_SPECS, TEST_REQUIREMENTS } from "../plain/spec.js";
+import { diffFileTexts, resourceDiff, testPlainFileText } from "./spec-steps.js";
 /**
  * A job's change as its agent is given it, for the panels: the same items `describeSpecChange` writes into
  * `<spec change>` - what the job's functional specs use, from the module's own file and from the files it
  * imports and requires alike - laid out as a diff the panels already show (`diff-view.ts`). Each section is
- * a block under its header, each item as its file writes it - its markdown, its acceptance tests indented
- * under it - so placed in the .plain files (`locateDiffLines`) every line is shown in the file it is written
+ * a block under its header, each item as its file writes it - a functional spec under its `# <func-id>` heading -
+ * so placed in the .plain files (`locateDiffLines`) every line is shown in the file it is written
  * in, with its line there: split by file and by block. A text diff of the module's file would show other
  * things - the lines around a change, the items no job takes yet - and leave out what an import adds.
  */
@@ -13,7 +13,7 @@ import { resourceDiff } from "./spec-steps.js";
 const ORDER = [DEFINITIONS, NON_FUNCTIONAL_REQUIREMENTS, TEST_REQUIREMENTS, REQUIRED_FUNCTIONAL_SPECS, FUNCTIONAL_REQUIREMENTS];
 /** A section's header as a .plain file writes it: a required module's functional specs are under its own `***functional specs***`. */
 const heading = (section) => `***${section === REQUIRED_FUNCTIONAL_SPECS ? FUNCTIONAL_REQUIREMENTS : section}***`;
-/** An item's lines as a .plain file writes them: its markdown, then its acceptance tests indented under it. */
+/** An item's lines as a .plain file writes them: a functional spec's `# <func-id>` heading over its text, anything else its text. */
 function itemLines(serialized) {
     if (serialized === undefined)
         return [];
@@ -26,31 +26,24 @@ function itemLines(serialized) {
     }
     if (typeof item === "string")
         return item.split("\n");
-    const { markdown, [ACCEPTANCE_TESTS]: tests } = (item ?? {});
+    const { id, markdown } = (item ?? {});
     const lines = (markdown ?? JSON.stringify(item)).split("\n");
-    if (Array.isArray(tests) && tests.length > 0) {
-        lines.push("", "    ***acceptance tests***", "");
-        for (const test of tests) {
-            const text = typeof test === "string" ? test : (test.markdown ?? JSON.stringify(test));
-            lines.push(...text.split("\n").map((line) => `    ${line}`));
-        }
-    }
-    return lines;
+    return id !== undefined ? [`# ${id}`, ...lines] : lines;
 }
 /**
  * `changes` as a diff of `file` - the module's .plain file, which the diff names - section by section: a removed
  * item's lines taken out, an added one's put in, a changed one's both. A change to what a linked file holds
  * follows, as the step's own diff has it.
  */
-export function changeDiff(changes, file) {
-    return laidOut(changes, file).diff;
+export function changeDiff(changes, file, testPlain) {
+    return laidOut(changes, file, false, testPlain).diff;
 }
 /**
  * `changeDiff`, each section's items in the order they are written - by file, then by line - rather than in the
  * order the spec is read in, which puts a concept after those it uses: placed by `locate`, as the panels place it.
  */
-export function changeDiffInFiles(changes, file, locate) {
-    const first = laidOut(changes, file);
+export function changeDiffInFiles(changes, file, locate, testPlain) {
+    const first = laidOut(changes, file, false, testPlain);
     const where = locate(first.diff);
     const placeOf = (change) => {
         const at = where[first.starts.get(change) ?? -1];
@@ -65,11 +58,14 @@ export function changeDiffInFiles(changes, file, locate) {
             return a.position - b.position;
         return x.file === y.file ? x.line - y.line : (x.file === file ? -1 : y.file === file ? 1 : x.file.localeCompare(y.file));
     });
-    const diff = laidOut(ordered, file, true).diff;
+    const diff = laidOut(ordered, file, true, testPlain).diff;
     return { diff, where: locate(diff) };
 }
-/** The diff, and the line each change starts on in it. `asGiven`: each section's items in the order given. */
-function laidOut(changes, file, asGiven = false) {
+/**
+ * The diff, and the line each change starts on in it. `asGiven`: each section's items in the order given. `testPlain`: a
+ * conformance job's - a functional spec whose scenarios changed has its test plain file's diff after the module's.
+ */
+function laidOut(changes, file, asGiven = false, testPlain) {
     const starts = new Map();
     const sections = [...new Set(changes.map((change) => change.section))].sort((a, b) => (ORDER.indexOf(a) === -1 ? ORDER.length : ORDER.indexOf(a)) - (ORDER.indexOf(b) === -1 ? ORDER.length : ORDER.indexOf(b)));
     const lines = [`diff --git a/${file} b/${file}`, `--- a/${file}`, `+++ b/${file}`];
@@ -81,6 +77,9 @@ function laidOut(changes, file, asGiven = false) {
         // Where this section's lines start in the diff: after the lines so far, its hunk header and its section header.
         const offset = lines.length + 2;
         for (const change of own) {
+            // Only its scenarios changed: they are its test plain file's, whose diff follows - the module's file shows nothing of it.
+            if (testPlain !== undefined && scenariosOnly(change))
+                continue;
             const before = change.kind === "add" ? [] : itemLines(change.before);
             const after = change.kind === "remove" ? [] : itemLines(change.after);
             // Where it is found: its first line now, or - removed - its first line as it was.
@@ -96,7 +95,57 @@ function laidOut(changes, file, asGiven = false) {
             continue;
         lines.push("@@ @@", ` ${heading(section)}`, ...body);
     }
-    return { diff: `${lines.join("\n")}\n${resourceDiff(changes, file)}`, starts };
+    // Nothing of the module's file changed - a conformance job's scenarios alone: no block for it at all.
+    const own = lines.length > 3 ? `${lines.join("\n")}\n` : "";
+    return { diff: `${own}${testPlain !== undefined ? testPlainDiffs(changes, testPlain) : ""}${resourceDiff(changes, file)}`, starts };
+}
+/** Whether a change to a functional spec is to its scenarios alone: its text, and all else of it, as it was. */
+function scenariosOnly(change) {
+    if (change.kind !== "change" || change.before === undefined || change.after === undefined)
+        return false;
+    const rest = (serialized) => {
+        try {
+            const { conformance_tests: _conformance, acceptance_tests: _acceptance, ...others } = JSON.parse(serialized);
+            return JSON.stringify(others);
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const [was, now] = [rest(change.before), rest(change.after)];
+    return was !== undefined && was === now && change.before !== change.after;
+}
+/**
+ * Each test plain file a conformance job's changes touch, as git diffs it: the lines that changed, among the lines around
+ * them - a functional spec with no scenarios has no file, so a new one is added whole and one whose scenarios all went is
+ * taken out whole.
+ */
+function testPlainDiffs(changes, testPlain) {
+    const scenarioCarrier = (line) => {
+        if (line === undefined)
+            return undefined;
+        try {
+            const item = JSON.parse(line);
+            return item.id !== undefined && (item.conformance_tests !== undefined || item.acceptance_tests !== undefined) ? item : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    return changes
+        // A module below's functional specs too: the tip's conformance suite holds the chain's.
+        .filter((change) => change.section === FUNCTIONAL_REQUIREMENTS || change.section === REQUIRED_FUNCTIONAL_SPECS)
+        .flatMap((change) => {
+        const [was, now] = [scenarioCarrier(change.kind === "add" ? undefined : change.before), scenarioCarrier(change.kind === "remove" ? undefined : change.after)];
+        const funcId = now?.id ?? was?.id;
+        if (funcId === undefined)
+            return [];
+        const module = now?.module ?? was?.module ?? testPlain.module;
+        const fileOf = (carrier) => carrier !== undefined && (carrier.conformance_tests ?? []).length + (carrier.acceptance_tests ?? []).length > 0 ? testPlainFileText(module, carrier) : "";
+        const diff = diffFileTexts(fileOf(was), fileOf(now), testPlain.pathOf(funcId, module));
+        return diff === "" ? [] : [diff];
+    })
+        .join("");
 }
 /** The changes a job's agent works from: a code job's leave out the test reqs, which are the conformance job's. */
 export function agentChanges(changes, track) {

package/dist/regenerate/chunk-plan.d.ts

@@ -1,6 +1,6 @@
 import { type MarshalledPlainSource } from "../plain/spec.ts";
 import { type Steering } from "./steer.ts";
-import { type SpecChange, type SpecStep } from "./spec-steps.ts";
+import { type SpecChange, type SpecStep, type TestPlainPath } from "./spec-steps.ts";
 /**
  * The queue's work, cut into jobs of a size worth rendering.
  *
@@ -18,8 +18,9 @@ import { type SpecChange, type SpecStep } from "./spec-steps.ts";
  * 3. Where each new implementation req goes - the group it is about, or the first, when it is about
  *    everything - and each new test req: the group whose conformance tests need it first. An agent judges it.
  *
- * Changes to what is built already - an item edited or taken out, a functional spec built changed - go first, in a
- * job of their own. Every answer is checked; one that does not hold goes back to its agent, twice at most, and then
+ * Changes to what is built already - an item edited or taken out, a functional spec built changed - go where the
+ * grouping agent places each: with the new work it is about, by default, or first, in a job of their own, when it
+ * reshapes what the new work is built on or has nothing to do with it. Every answer is checked; one that does not hold goes back to its agent, twice at most, and then
  * the plan falls back to a functional spec a job. A job past `max-lines-per-pulse` (MAX_LINES_PER_JOB unset) is split. The plan is the queue
  * master's proposal: it reviews it, and may change it, held to the same checks.
  */
@@ -47,11 +48,8 @@ export interface PlanInput {
      * in one job, as far as the guardrail (`max-lines-per-pulse`) lets.
      */
     separately?: boolean;
-    /**
-     * For the conformance tests: the functional specs asked for together, a group a request - `conform` called for 1-3, then
-     * for 4-6. Never two groups in one job; the functional specs in none are tested together, as before.
-     */
-    groups?: string[][];
+    /** For the conformance tests: where each functional spec's test plain file is, as a step's ***plain diff names it. */
+    testPlainPath?: TestPlainPath;
     /** How big a pulse may be - the config's `max-specs-per-pulse` and `max-lines-per-pulse`; unset, MAX_SPECS_PER_JOB and MAX_LINES_PER_JOB. */
     limits?: PulseLimits;
 }
@@ -90,9 +88,9 @@ export declare function shortTitle(text: string, chars?: number, words?: number)
 export declare const MAX_LINES_PER_JOB = 120;
 /**
  * A functional spec to build, for the grouping: the number the agent answers with, its text, and whether it is built
- * already and regenerated again. `id` and `module` say which it is: each module numbers its own from 1, and a codebase
- * regenerates again the functional specs of the modules it is built on too. No module: the codebase's own. No id: the
- * number.
+ * already and regenerated again. `id` and `module` say which it is: its func-id, unique in its module, and a codebase
+ * regenerates again the functional specs of the modules it is built on too. No module: the codebase's own. `place` is
+ * where it is among its module's functional specs - the ones next to it there are next to it. No place: its number.
  */
 export interface NewSpec {
     number: number;
@@ -100,12 +98,31 @@ export interface NewSpec {
     again?: boolean;
     id?: string;
     module?: string;
+    place?: number;
+}
+/**
+ * A change to what is built already, for the grouping: the number the agent answers with, whether it is changed, taken
+ * out or put in among what is built, what it is - a functional spec, a definition, a req - and its text. `id` and
+ * `module` say which functional spec it is.
+ */
+export interface BuiltChange {
+    number: number;
+    kind: "changed" | "taken out" | "added";
+    what: string;
+    text: string;
+    id?: string;
+    module?: string;
 }
 export interface GroupAnswer {
     groups: Array<{
         specs: number[];
         title: string;
     }>;
+    /** Where each change to what is built goes: with a group, by its number, or "first" - a pulse of its own, before the new work. */
+    built?: Array<{
+        change: number;
+        to: number | "first";
+    }>;
     /** What of the person's wishes it did not follow, and why. */
     notes?: string;
 }
@@ -161,18 +178,22 @@ export interface TitleAnswer {
  * first functional spec's first line; without it, they keep that.
  */
 export interface ChunkAgents {
-    group(specs: NewSpec[], check: (answer: GroupAnswer) => string[], steering?: Steering[], maxSpecs?: number): Promise<GroupAnswer | undefined>;
+    group(specs: NewSpec[], check: (answer: GroupAnswer) => string[], steering?: Steering[], maxSpecs?: number, built?: BuiltChange[]): Promise<GroupAnswer | undefined>;
     place(input: PlaceInput, check: (answer: PlaceAnswer) => string[]): Promise<PlaceAnswer | undefined>;
     title?(groups: TitleGroup[], check: (answer: TitleAnswer) => string[], track: "code" | "conformance"): Promise<TitleAnswer | undefined>;
 }
-/** What is wrong with a grouping: every new functional spec once, in order, next to each other, none too big. */
-export declare function groupProblems(specs: NewSpec[], answer: GroupAnswer, maxSpecs?: number): string[];
+/**
+ * What is wrong with a grouping: every new functional spec once, in order, next to each other, none too big - and
+ * every change to what is built placed once, with a group or first. A functional spec changed counts in its group: it
+ * is built as the new ones are. One taken out builds nothing, and does not.
+ */
+export declare function groupProblems(specs: NewSpec[], answer: GroupAnswer, maxSpecs?: number, built?: BuiltChange[]): string[];
 /** What is wrong with a titling: every group titled once, by its number, none empty, none too long. */
 export declare function titleProblems(groups: TitleGroup[], answer: TitleAnswer): string[];
 /** What is wrong with a placement: every new req once, each where there is such a job. */
 export declare function placeProblems(input: PlaceInput, answer: PlaceAnswer): string[];
 export declare function planChunks(input: PlanInput, agents?: ChunkAgents, notes?: string[]): Promise<DraftJob[]>;
-export declare function groupPrompt(specs: NewSpec[], steering?: Steering[], maxSpecs?: number): string;
+export declare function groupPrompt(specs: NewSpec[], steering?: Steering[], maxSpecs?: number, built?: BuiltChange[]): string;
 export declare function placePrompt(input: PlaceInput): string;
 export declare function titlePrompt(groups: TitleGroup[], track: "code" | "conformance"): string;
 /** The chunking's agents, on a model - fresh for every plan. */