@turri-dev/cli 0.1.27 → 0.2.0

package/dist/regenerate/records.d.ts

@@ -3,11 +3,14 @@ import { type MarshalledPlainSource } from "../plain/spec.ts";
  * What a module is built from, in two records - see docs/regenerating.md.
  *
  * - The code record, `code/.turri.json`: the spec the code is built from, without what is only
- *   for conformance - the test reqs, and the acceptance tests under each functional spec.
+ *   for conformance - the test reqs, the test plain files, and each functional spec's scenarios.
  * - The tests record, `tests/.turri.json`: the functional specs the conformance tests are
- *   written for - a subset of the code record's, each with its number and its acceptance tests - the
+ *   written for - a subset of the code record's, each with its func-id and its scenarios - the
  *   definitions and implementation reqs they were written against, and the test reqs they follow.
  *
+ * A functional spec is known by its func-id - with its module, for one a module below has - in both: a record
+ * written when functional specs were numbered is old (`isOldRecord`), and its codebase is regenerated from scratch.
+ *
  * The tests record is always a substate of the code record: a conformance test exercises
  * functionality, and only functionality in the code can be tested. Each record is committed with
  * what it describes, in the module's `.plaingit`, so rolling a unit of work back puts it back too.
@@ -21,8 +24,20 @@ export { RECORD_FILE } from "./paths.ts";
 export declare const REGENERATE_AGAIN = "regenerate_again";
 /** Whether a record's item is marked to regenerate again. */
 export declare function marksRegenerateAgain(item: unknown): boolean;
-/** The spec as the code is built from it: no test reqs, and no acceptance tests under the functional specs. */
+/**
+ * Whether a functional spec has scenarios - conformance or acceptance - and so is tested: one with an empty test plain
+ * file is not.
+ */
+export declare function hasScenarios(item: unknown): boolean;
+/** The func-ids of a tree's own functional specs that have scenarios: those its conformance tests are written for. */
+export declare function testedFuncIds(tree: MarshalledPlainSource | null | undefined): string[];
+/** The spec as the code is built from it: no test reqs, no test plain files, and no scenarios on the functional specs. */
 export declare function codeTree(tree: MarshalledPlainSource): MarshalledPlainSource;
+/** A functional spec's identity in a tree: its func-id, with its module for one a module below has. */
+export declare function identityOf(item: {
+    id?: string;
+    module?: string;
+}): string;
 /**
  * A module's tree with the hash of each linked resource's content beside its link: the file is part of the spec,
  * so a change to what it holds is a change to the item that links it - and, a definition linking it, to every
@@ -55,12 +70,11 @@ export declare function chainTree(trees: Array<{
  * specs among the ones inherited. The new module has built nothing of its own yet.
  */
 export declare function inheritedRecord(source: MarshalledPlainSource, sourceModule: string): MarshalledPlainSource;
-/** Which functional specs are to have conformance tests, by number. Default: every one. */
-export type Chosen = (frid: string) => boolean;
 /**
  * What the conformance tests are to be written for, now: of the functional specs the code is built
- * from, those chosen, each as the spec has it now with its acceptance tests - and the code's
- * definitions and implementation reqs, with the test reqs as the spec has them now.
+ * from, those with scenarios, each as the spec has it now with its scenarios - and the code's
+ * definitions and implementation reqs, with the test reqs as the spec has them now. In the spec's order, a functional
+ * spec matched to the code and the tests by its func-id. One whose scenarios are all taken out loses its tests.
  *
  * Conformance follows the code, never goes ahead of it: a functional spec whose code is not caught up
  * with the spec - its text in the code record is not the spec's, the code record does not have it at
@@ -69,13 +83,30 @@ export type Chosen = (frid: string) => boolean;
  * (`regenerateAgain`) differ from the target once the code lands: written against the code it replaced, they are
  * conformance work again, though the spec's text never changed.
  */
-export declare function conformanceTarget(code: MarshalledPlainSource | null, tests: MarshalledPlainSource | null, spec: MarshalledPlainSource, chosen?: Chosen): MarshalledPlainSource;
+export declare function conformanceTarget(code: MarshalledPlainSource | null, tests: MarshalledPlainSource | null, spec: MarshalledPlainSource): MarshalledPlainSource;
+/** A functional spec as a person names it: its func-id, with its module - the codebase's own, when the item names none. */
+export interface SpecRef {
+    module?: string;
+    funcId: string;
+}
+/**
+ * Of the functional specs given, those the code record does not have as `tree` has them - not built, or built from
+ * other text: no conformance test can be written for them yet. `tree` is a spec, or what conformance tests are written
+ * for; `module` the codebase's own, whose functional specs carry no module of their own.
+ */
+export declare function notBuilt(code: MarshalledPlainSource | null, tree: MarshalledPlainSource, specs: SpecRef[], module?: string): SpecRef[];
+/**
+ * What a new module's conformance tests start from, copied up with the code below: that module's tests record, as a
+ * lower module's - what they were written against tagged with it, its functional specs among those inherited, each with
+ * the scenarios its tests carry out. The tip's suite holds the tests of the whole chain, and they are kept up to date there.
+ */
+export declare function inheritedTestsRecord(source: MarshalledPlainSource, sourceModule: string): MarshalledPlainSource;
 /**
- * Of the functional specs given, by number, those the code record does not have as `tree` has them - not built,
- * or built from other text: no conformance test can be written for them yet. `tree` is a spec, its functional
- * specs numbered by place, or what conformance tests are written for, each with its number.
+ * Whether a record was written when functional specs were numbered, before they had func-ids: a functional spec without
+ * one, or one a module below has named by its number. Nothing is built on such a record - the codebase is regenerated
+ * from scratch, with its chain, once the person agrees.
  */
-export declare function notBuilt(code: MarshalledPlainSource | null, tree: MarshalledPlainSource, frids: string[]): string[];
+export declare function isOldRecord(record: MarshalledPlainSource | null): boolean;
 /**
  * A record in `dir`: as the module's last commit has it, by default - what the harness itself wrote
  * when the last unit of work landed, never what an agent's shell changed since - or, with `onDisk`,

package/dist/regenerate/records.js

@@ -1,17 +1,20 @@
 import { createHash } from "node:crypto";
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
-import { ACCEPTANCE_TESTS, DEFINITIONS, FUNCTIONAL_REQUIREMENTS, NON_FUNCTIONAL_REQUIREMENTS, REQUIRED_FUNCTIONAL_SPECS, TEST_REQUIREMENTS, } from "../plain/spec.js";
+import { ACCEPTANCE_TESTS, CONFORMANCE_TESTS, DEFINITIONS, FUNCTIONAL_REQUIREMENTS, NON_FUNCTIONAL_REQUIREMENTS, REQUIRED_FUNCTIONAL_SPECS, TEST_PLAIN_FILES, TEST_REQUIREMENTS, } from "../plain/spec.js";
 import { committedText } from "./lineage.js";
 /**
  * What a module is built from, in two records - see docs/regenerating.md.
  *
  * - The code record, `code/.turri.json`: the spec the code is built from, without what is only
- *   for conformance - the test reqs, and the acceptance tests under each functional spec.
+ *   for conformance - the test reqs, the test plain files, and each functional spec's scenarios.
  * - The tests record, `tests/.turri.json`: the functional specs the conformance tests are
- *   written for - a subset of the code record's, each with its number and its acceptance tests - the
+ *   written for - a subset of the code record's, each with its func-id and its scenarios - the
  *   definitions and implementation reqs they were written against, and the test reqs they follow.
  *
+ * A functional spec is known by its func-id - with its module, for one a module below has - in both: a record
+ * written when functional specs were numbered is old (`isOldRecord`), and its codebase is regenerated from scratch.
+ *
  * The tests record is always a substate of the code record: a conformance test exercises
  * functionality, and only functionality in the code can be tested. Each record is committed with
  * what it describes, in the module's `.plaingit`, so rolling a unit of work back puts it back too.
@@ -34,21 +37,37 @@ const itemsOf = (tree, heading) => (tree?.[heading] ?? []).slice();
 function withoutEmpty(tree) {
     return Object.fromEntries(Object.entries(tree).filter(([, value]) => !Array.isArray(value) || value.length > 0));
 }
-/** A functional spec as the code sees it: without its acceptance tests. */
-function withoutAcceptanceTests(item) {
-    const { [ACCEPTANCE_TESTS]: _tests, ...rest } = item;
+/**
+ * Whether a functional spec has scenarios - conformance or acceptance - and so is tested: one with an empty test plain
+ * file is not.
+ */
+export function hasScenarios(item) {
+    const scenarios = (key) => item?.[key] ?? [];
+    return scenarios(CONFORMANCE_TESTS).length + scenarios(ACCEPTANCE_TESTS).length > 0;
+}
+/** The func-ids of a tree's own functional specs that have scenarios: those its conformance tests are written for. */
+export function testedFuncIds(tree) {
+    return itemsOf(tree, FUNCTIONAL_REQUIREMENTS).filter(hasScenarios).map((item) => item.id ?? "");
+}
+/** A functional spec as the code sees it: without its scenarios, which are the conformance tests' alone. */
+function withoutScenarios(item) {
+    const { [CONFORMANCE_TESTS]: _conformance, [ACCEPTANCE_TESTS]: _acceptance, ...rest } = item;
     return rest;
 }
-/** The spec as the code is built from it: no test reqs, and no acceptance tests under the functional specs. */
+/** The spec as the code is built from it: no test reqs, no test plain files, and no scenarios on the functional specs. */
 export function codeTree(tree) {
-    const { [TEST_REQUIREMENTS]: _testReqs, ...rest } = tree;
+    const { [TEST_REQUIREMENTS]: _testReqs, [TEST_PLAIN_FILES]: _testPlainFiles, ...rest } = tree;
     return withoutEmpty({
         ...rest,
-        [FUNCTIONAL_REQUIREMENTS]: itemsOf(tree, FUNCTIONAL_REQUIREMENTS).map(withoutAcceptanceTests),
-        [REQUIRED_FUNCTIONAL_SPECS]: itemsOf(tree, REQUIRED_FUNCTIONAL_SPECS).map(withoutAcceptanceTests),
+        [FUNCTIONAL_REQUIREMENTS]: itemsOf(tree, FUNCTIONAL_REQUIREMENTS).map(withoutScenarios),
+        [REQUIRED_FUNCTIONAL_SPECS]: itemsOf(tree, REQUIRED_FUNCTIONAL_SPECS).map(withoutScenarios),
     });
 }
-/** Every linked resource in a tree, wherever an item has them - a functional spec, its acceptance tests, a definition, a req. */
+/** A functional spec's identity in a tree: its func-id, with its module for one a module below has. */
+export function identityOf(item) {
+    return `${item.module ?? ""}:${item.id ?? ""}`;
+}
+/** Every linked resource in a tree, wherever an item has them - a functional spec, its scenarios, a definition, a req. */
 function mapResources(value, map) {
     if (Array.isArray(value))
         return value.map((entry) => mapResources(entry, map));
@@ -143,7 +162,7 @@ export function chainTree(trees) {
 export function inheritedRecord(source, sourceModule) {
     const inherited = [
         ...itemsOf(source, REQUIRED_FUNCTIONAL_SPECS),
-        ...itemsOf(source, FUNCTIONAL_REQUIREMENTS).map((item, index) => ({ ...withoutAcceptanceTests(item), module: sourceModule, frid: String(index + 1) })),
+        ...itemsOf(source, FUNCTIONAL_REQUIREMENTS).map((item) => ({ ...withoutScenarios(item), module: sourceModule })),
     ];
     return withoutEmpty({
         [DEFINITIONS]: taggedWith(itemsOf(source, DEFINITIONS), sourceModule),
@@ -153,8 +172,9 @@ export function inheritedRecord(source, sourceModule) {
 }
 /**
  * What the conformance tests are to be written for, now: of the functional specs the code is built
- * from, those chosen, each as the spec has it now with its acceptance tests - and the code's
- * definitions and implementation reqs, with the test reqs as the spec has them now.
+ * from, those with scenarios, each as the spec has it now with its scenarios - and the code's
+ * definitions and implementation reqs, with the test reqs as the spec has them now. In the spec's order, a functional
+ * spec matched to the code and the tests by its func-id. One whose scenarios are all taken out loses its tests.
  *
  * Conformance follows the code, never goes ahead of it: a functional spec whose code is not caught up
  * with the spec - its text in the code record is not the spec's, the code record does not have it at
@@ -163,94 +183,89 @@ export function inheritedRecord(source, sourceModule) {
  * (`regenerateAgain`) differ from the target once the code lands: written against the code it replaced, they are
  * conformance work again, though the spec's text never changed.
  */
-export function conformanceTarget(code, tests, spec, chosen = () => true) {
-    const built = itemsOf(code, FUNCTIONAL_REQUIREMENTS);
-    const now = itemsOf(spec, FUNCTIONAL_REQUIREMENTS);
-    const tested = new Map(itemsOf(tests, FUNCTIONAL_REQUIREMENTS).map((item) => [item.frid, item]));
-    const inCode = new Set(built.map((item) => item.markdown.trim()));
-    const specs = [];
-    for (let index = 0; index < Math.max(built.length, now.length); index += 1) {
-        const frid = String(index + 1);
-        const current = now[index];
-        if (current !== undefined && built[index]?.markdown.trim() === current.markdown.trim() && !marksRegenerateAgain(built[index])) {
-            if (chosen(frid))
-                specs.push({ ...current, frid });
-            continue;
+export function conformanceTarget(code, tests, spec) {
+    // The codebase's own functional specs, and - in their own section - those of the modules below it: the tip's
+    // conformance suite holds the tests of the whole chain.
+    const section = (heading) => {
+        const built = new Map(itemsOf(code, heading).map((item) => [identityOf(item), item]));
+        const now = itemsOf(spec, heading);
+        const inSpec = new Set(now.map(identityOf));
+        const tested = itemsOf(tests, heading);
+        const testedById = new Map(tested.map((item) => [identityOf(item), item]));
+        const specs = [];
+        for (const current of now) {
+            const have = built.get(identityOf(current));
+            if (have !== undefined && have.markdown.trim() === current.markdown.trim() && !marksRegenerateAgain(have)) {
+                if (hasScenarios(current))
+                    specs.push(current);
+                continue;
+            }
+            // The code is behind the spec here - built from other text, not built, or being regenerated again: its tests stay
+            // as they are until it catches up.
+            const kept = testedById.get(identityOf(current));
+            if (kept !== undefined)
+                specs.push(kept);
         }
-        // The code is behind the spec here - built from other text, not built, or being regenerated again: its tests stay
-        // as they are until it catches up. Taken out of the spec, they go once the code has dropped it too.
-        const kept = tested.get(frid);
-        if (kept === undefined)
-            continue;
-        if (current !== undefined || inCode.has(kept.markdown.trim()))
-            specs.push(kept);
-    }
+        // Taken out of the spec, its tests go once the code has dropped it too.
+        for (const kept of tested)
+            if (!inSpec.has(identityOf(kept)) && built.has(identityOf(kept)))
+                specs.push(kept);
+        return specs;
+    };
     return withoutEmpty({
         [DEFINITIONS]: itemsOf(code, DEFINITIONS),
         [NON_FUNCTIONAL_REQUIREMENTS]: itemsOf(code, NON_FUNCTIONAL_REQUIREMENTS),
         [TEST_REQUIREMENTS]: itemsOf(spec, TEST_REQUIREMENTS),
-        [FUNCTIONAL_REQUIREMENTS]: specs,
+        [FUNCTIONAL_REQUIREMENTS]: section(FUNCTIONAL_REQUIREMENTS),
+        [REQUIRED_FUNCTIONAL_SPECS]: section(REQUIRED_FUNCTIONAL_SPECS),
     });
 }
 /**
- * Of the functional specs given, by number, those the code record does not have as `tree` has them - not built,
- * or built from other text: no conformance test can be written for them yet. `tree` is a spec, its functional
- * specs numbered by place, or what conformance tests are written for, each with its number.
+ * Of the functional specs given, those the code record does not have as `tree` has them - not built, or built from
+ * other text: no conformance test can be written for them yet. `tree` is a spec, or what conformance tests are written
+ * for; `module` the codebase's own, whose functional specs carry no module of their own.
  */
-export function notBuilt(code, tree, frids) {
-    const built = itemsOf(code, FUNCTIONAL_REQUIREMENTS);
-    const wanted = itemsOf(tree, FUNCTIONAL_REQUIREMENTS);
-    const numbered = wanted.some((item) => item.frid !== undefined);
-    return frids.filter((frid) => {
-        const item = numbered ? wanted.find((entry) => entry.frid === frid) : wanted[Number(frid) - 1];
-        const have = built[Number(frid) - 1];
+export function notBuilt(code, tree, specs, module) {
+    const keyed = (items, own) => items.map((item) => [`${own ? (module ?? "") : (item.module ?? "")}:${item.id ?? ""}`, item]);
+    const all = (from) => new Map([...keyed(itemsOf(from, FUNCTIONAL_REQUIREMENTS), true), ...keyed(itemsOf(from, REQUIRED_FUNCTIONAL_SPECS), false)]);
+    const built = all(code);
+    const wanted = all(tree);
+    return specs.filter((spec) => {
+        const key = `${spec.module ?? module ?? ""}:${spec.funcId}`;
+        const item = wanted.get(key);
+        const have = built.get(key);
         return item === undefined || have === undefined || have.markdown.trim() !== item.markdown.trim();
     });
 }
-const asItem = (markdown, acceptanceTests) => ({
-    markdown,
-    ...(acceptanceTests !== undefined && acceptanceTests.length > 0 ? { [ACCEPTANCE_TESTS]: acceptanceTests.map((test) => ({ markdown: test })) } : {}),
-});
 /**
- * An older record, as the tree it describes. Its own functional specs are taken up to the first
- * that did not build: the tree says what is built, and the one that failed is not.
+ * What a new module's conformance tests start from, copied up with the code below: that module's tests record, as a
+ * lower module's - what they were written against tagged with it, its functional specs among those inherited, each with
+ * the scenarios its tests carry out. The tip's suite holds the tests of the whole chain, and they are kept up to date there.
  */
-function treeFromV2(stored) {
-    const own = stored[FUNCTIONAL_REQUIREMENTS].filter((entry) => entry.module === stored.module).sort((a, b) => Number(a.frid) - Number(b.frid));
-    const built = [];
-    for (const [index, entry] of own.entries()) {
-        if (Number(entry.frid) !== index + 1 || entry.unitTests !== "passed")
-            break;
-        built.push(asItem(entry.spec, entry["acceptance tests"]));
-    }
-    const required = stored[FUNCTIONAL_REQUIREMENTS]
-        .filter((entry) => entry.module !== stored.module)
-        .map((entry) => ({ ...asItem(entry.spec, entry["acceptance tests"]), module: entry.module, frid: entry.frid }));
+export function inheritedTestsRecord(source, sourceModule) {
     return withoutEmpty({
-        [DEFINITIONS]: (stored[DEFINITIONS] ?? []).map((text) => asItem(text)),
-        [NON_FUNCTIONAL_REQUIREMENTS]: (stored[NON_FUNCTIONAL_REQUIREMENTS] ?? []).map((text) => asItem(text)),
-        [TEST_REQUIREMENTS]: (stored[TEST_REQUIREMENTS] ?? []).map((text) => asItem(text)),
-        [FUNCTIONAL_REQUIREMENTS]: built,
-        [REQUIRED_FUNCTIONAL_SPECS]: required,
+        [DEFINITIONS]: taggedWith(itemsOf(source, DEFINITIONS), sourceModule),
+        [NON_FUNCTIONAL_REQUIREMENTS]: taggedWith(itemsOf(source, NON_FUNCTIONAL_REQUIREMENTS), sourceModule),
+        [TEST_REQUIREMENTS]: itemsOf(source, TEST_REQUIREMENTS),
+        [REQUIRED_FUNCTIONAL_SPECS]: [...itemsOf(source, REQUIRED_FUNCTIONAL_SPECS), ...itemsOf(source, FUNCTIONAL_REQUIREMENTS).map((item) => ({ ...item, module: sourceModule }))],
     });
 }
-function treeFromLegacy(stored) {
-    const entries = Object.values(stored.functionalities).sort((a, b) => Number(a.frid) - Number(b.frid));
-    const latest = entries.at(-1)?.specifications;
-    const built = [];
-    for (const [index, entry] of entries.entries()) {
-        if (Number(entry.frid) !== index + 1 || entry.unitTests !== "passed")
-            break;
-        built.push(asItem(entry.specifications[FUNCTIONAL_REQUIREMENTS]?.at(-1) ?? "", entry.specifications[ACCEPTANCE_TESTS]));
-    }
-    return withoutEmpty({
-        [DEFINITIONS]: (latest?.[DEFINITIONS] ?? []).map((text) => asItem(text)),
-        [NON_FUNCTIONAL_REQUIREMENTS]: (latest?.[NON_FUNCTIONAL_REQUIREMENTS] ?? []).map((text) => asItem(text)),
-        [TEST_REQUIREMENTS]: (latest?.[TEST_REQUIREMENTS] ?? []).map((text) => asItem(text)),
-        [FUNCTIONAL_REQUIREMENTS]: built,
-    });
+/**
+ * Whether a record was written when functional specs were numbered, before they had func-ids: a functional spec without
+ * one, or one a module below has named by its number. Nothing is built on such a record - the codebase is regenerated
+ * from scratch, with its chain, once the person agrees.
+ */
+export function isOldRecord(record) {
+    if (record === null)
+        return false;
+    if (record[OLD] === true)
+        return true;
+    const items = [...itemsOf(record, FUNCTIONAL_REQUIREMENTS), ...itemsOf(record, REQUIRED_FUNCTIONAL_SPECS)];
+    return items.some((item) => typeof item.id !== "string" || "frid" in item);
 }
-/** A record's text as the tree it holds, whatever layout wrote it - or null when it is not one. */
+/** What an older layout of a record is read as: old, and nothing else of it. */
+const OLD = "old record";
+/** A record's text as the tree it holds - an older layout as an old record - or null when it is not one. */
 function readRecordText(text) {
     if (text === undefined)
         return null;
@@ -263,10 +278,9 @@ function readRecordText(text) {
     }
     if (raw === null || typeof raw !== "object" || Array.isArray(raw))
         return null;
-    if (typeof raw.version === "number")
-        return treeFromV2(raw);
-    if ("functionalities" in raw)
-        return treeFromLegacy(raw);
+    // A layout from before the tree was all a record held: older still than numbered functional specs.
+    if (typeof raw.version === "number" || "functionalities" in raw)
+        return { [OLD]: true };
     return raw;
 }
 function readFileText(path) {

package/dist/regenerate/regenerate.js

@@ -4,7 +4,7 @@ import { tmpdir } from "node:os";
 import { basename, dirname, join, relative, resolve } from "node:path";
 import { IMPORT_DIRECTIVE, plainFileParser, readPlainSourceMetadata, withParseCache } from "../plain/parser.js";
 import { isStdlibModule, STDLIB_ROOT } from "../plain/stdlib.js";
-import { FUNCTIONAL_REQUIREMENTS, getFrids, getInheritedFunctionalSpecs, getSpecificationsForFrid, TEST_REQUIREMENTS, } from "../plain/spec.js";
+import { CONFORMANCE_TESTS, ACCEPTANCE_TESTS, FUNCTIONAL_REQUIREMENTS, getFrids, getInheritedFunctionalSpecs, getSpecificationsForFrid, TEST_REQUIREMENTS, } from "../plain/spec.js";
 import { ask, BEGIN, createExecutor, refuseIfModelIsBlind } from "../pi.js";
 import { reportActivity, reportLogNote, reportStage, unitOf } from "./activity.js";
 import { debugFailure, diagnosisText } from "./debugger.js";
@@ -28,14 +28,15 @@ import { summarizeDiff } from "./job-panel.js";
 import { conversationWriting } from "./conversation-writes.js";
 import { resolveTemplateDirs } from "./paths.js";
 import { copyRequiredCode, findCodebaseTip, newlyRequired } from "./requires.js";
-import { createCopyResourceTool, loadLinkedResources, resourceImages } from "./resources.js";
+import { baseOfCodebase, inCodebaseOf, seedFromBaseFolder } from "./base-folder.js";
+import { createCopyResourceTool, loadLinkedResources, resourceFile, resourceImages } from "./resources.js";
 import { markTold, waitingSteer } from "./steering.js";
 import { misplacedConformanceTests, misplacedTestsPrompt } from "./test-kinds.js";
 import { sectionsOf } from "./state.js";
-import { inheritedRecord, readRecord, withResourceDigests, writeCodeRecord } from "./records.js";
+import { codeTree, inheritedRecord, readRecord, withResourceDigests, writeCodeRecord } from "./records.js";
 import { changesBetween, sameSpec, serializeTree } from "./spec-steps.js";
 import { untilUnitTestsReviewed } from "./unit-review.js";
-import { configForSpec, inheritModel, modelOnly, modelSpec } from "../config.js";
+import { configForSpec, inheritModel, modelOnly, modelSpec, testDirOf } from "../config.js";
 import { findTestRemovals, inventoryTests, listFiles, removalChallengePrompt, AGAIN_ASKS, againPrompt, draftPrompt, DRAFT_ASKS, } from "./testing.js";
 /**
  * Render a change to the specs, given as a git diff of the .plain files.
@@ -157,7 +158,7 @@ export function snapshotSpec(plainFile, options = {}) {
     // yet is still a module to build.
     const { tip, chain } = withParseCache(() => findCodebaseTip(resolve(cwd, plainFile), { templateDirs, inModule: options.inModule, allowNoFunctionalities: true }));
     const dirs = resolveTemplateDirs(tip.plainFile, templateDirs);
-    const [moduleName, parsed] = plainFileParser(basename(tip.plainFile), dirs, { allowNoFunctionalities: true });
+    const [moduleName, parsed] = plainFileParser(basename(tip.plainFile), dirs, { allowNoFunctionalities: true, testDir: testDirOf(tip.plainFile) });
     // What a linked resource holds is part of the spec: hashed beside its link, as the work loop has it.
     return { moduleName, plainFile: tip.plainFile, tree: withResourceDigests(parsed, dirs), chain };
 }
@@ -191,7 +192,7 @@ export async function renderSpecDiff(options) {
     // of the chain: the code already is what the spec says. Nothing to render; the spec is recorded
     // as it is now laid out.
     const builtBefore = readRecord(tip.buildDir, { onDisk: true });
-    if (builtBefore !== null && sameSpec(builtBefore, tree) && !dryRun) {
+    if (builtBefore !== null && sameSpec(builtBefore, codeTree(tree)) && !dryRun) {
         stage("the specs were only restructured - nothing to render; recording the spec as it is now laid out");
         writeCodeRecord(tip.buildDir, tree);
         landWork(tip.buildDir, `spec restructured: ${summarizeDiff(options.diff)}`, options.diff);
@@ -216,7 +217,7 @@ export async function renderSpecDiff(options) {
     const scripts = withoutConformance(findTestScripts(root, tip.plainFile, tip.buildDir));
     requireTestScripts(moduleName, scripts, { conformance: false });
     reportLogNote(`  unit testing script: ${relative(root, scripts.unit)}`);
-    const lastFrid = [...getFrids(tree)].at(-1);
+    const lastFuncId = [...getFrids(tree)].at(-1);
     const buildDir = tip.buildDir;
     // From scratch there is no build directory yet, and everything the agent runs runs in it.
     if (!dryRun)
@@ -227,6 +228,12 @@ export async function renderSpecDiff(options) {
         stage(`no code here yet - starting from ${source.moduleName}'s code`);
         copyRequiredCode(source.buildDir, buildDir, moduleName, source.moduleName);
     }
+    // A codebase that requires nothing starts from its base folder, when the config names one: code to build on, files to use.
+    if (empty && tip.requires === null && !dryRun) {
+        const seeded = seedFromBaseFolder(buildDir, tip.plainFile, moduleName);
+        if (seeded !== undefined)
+            stage(`no code here yet - starting from the base folder ${seeded.folder}, ${seeded.files.length} file${seeded.files.length === 1 ? "" : "s"}`);
+    }
     // What the agent is shown it starts from: a dry run copies nothing, and reads the code it would start from where it is.
     const seen = dryRun && source !== undefined ? source.buildDir : buildDir;
     stage("mapping the codebase and writing the prompt");
@@ -252,21 +259,32 @@ export async function renderSpecDiff(options) {
         const now = changesBetween(serializeTree(builtNow), serializeTree(options.steering.agent)).filter((change) => change.section !== TEST_REQUIREMENTS);
         return now.length > 0 ? describeSpecChange(now, moduleName) : undefined;
     };
-    const builtFrids = [...getFrids(builtNow)];
-    const specificationsBefore = builtFrids.length > 0 ? getSpecificationsForFrid(builtNow, builtFrids.at(-1))[0] : { ...sectionsOf(builtNow), [FUNCTIONAL_REQUIREMENTS]: [] };
-    const linkedResources = loadLinkedResources(tree, lastFrid ?? null, resolveTemplateDirs(tip.plainFile, templateDirs));
+    const builtFuncIds = [...getFrids(builtNow)];
+    const specificationsBefore = builtFuncIds.length > 0
+        ? getSpecificationsForFrid(builtNow, builtFuncIds.at(-1))[0]
+        : { ...sectionsOf(builtNow), [FUNCTIONAL_REQUIREMENTS]: [], [CONFORMANCE_TESTS]: [], [ACCEPTANCE_TESTS]: [] };
+    const resourceDirs = resolveTemplateDirs(tip.plainFile, templateDirs);
+    // A linked file the base folder held, in the codebase still, is used from there: its path is said, and it is not copied.
+    const linkedResources = loadLinkedResources(tree, lastFuncId ?? null, resourceDirs).map((resource) => {
+        const file = resourceFile(resource.target, resourceDirs);
+        const inCodebase = file === null ? undefined : inCodebaseOf(file, seen, tip.plainFile);
+        return inCodebase !== undefined ? { ...resource, inCodebase } : resource;
+    });
+    const startedFrom = baseOfCodebase(seen);
     const prompt = buildSpecDiffPrompt({
         moduleName,
         diff: options.diff,
         // The change as it is to the code: from what it is built from to the spec this job records, section by section.
         changes: codingChanges,
         specifications: specificationsBefore,
+        funcIds: builtFuncIds,
         modules: sectionModules(builtNow, moduleName),
         required: getInheritedFunctionalSpecs(builtNow),
         linkedResources,
         codebase: codebaseMap(seen),
         empty: listFiles(seen).length === 0,
         ...(options.cases !== undefined ? { cases: options.cases } : {}),
+        ...(startedFrom !== undefined ? { base: startedFrom } : {}),
     });
     const digestsBefore = digestFiles(buildDir);
     // The spec gaps its agents report from here on are told with the result.
@@ -528,7 +546,7 @@ export async function renderSpecDiff(options) {
                 what: `the spec change to module \`${moduleName}\``,
                 // As the coding agent had it: the spec the code was built from, and the change.
                 // Steered before the review, the change as the agent has it now.
-                spec: reviewedSpec({ moduleName, specifications: specificationsBefore, modules: sectionModules(builtNow, moduleName), required: getInheritedFunctionalSpecs(builtNow), change: steeredChange() ?? codingText ?? changeText ?? options.diff }),
+                spec: reviewedSpec({ moduleName, specifications: specificationsBefore, funcIds: builtFuncIds, modules: sectionModules(builtNow, moduleName), required: getInheritedFunctionalSpecs(builtNow), change: steeredChange() ?? codingText ?? changeText ?? options.diff, ...(startedFrom !== undefined ? { base: startedFrom } : {}) }),
                 forChange: true,
                 ...(options.cases !== undefined ? { cases: options.cases } : {}),
                 label: `${moduleName} spec change`,

package/dist/regenerate/regression.d.ts

@@ -8,14 +8,14 @@ export type RegressionEvent = {
     type: "run";
     command: string;
     exitCode: number;
-    frids?: string[];
+    funcIds?: string[];
 } | {
     type: "repair";
-    frids: string[];
+    funcIds: string[];
 };
 export interface RegressionRun extends TestRun {
     /** Functionalities whose tests took part in this run. */
-    frids: string[];
+    funcIds: string[];
 }
 export interface RegressionResult {
     passed: boolean;
@@ -38,7 +38,7 @@ export declare function ensureRegressionPasses(input: {
     buildDir: string;
     conformanceRoot: string;
     moduleName: string;
-    frids: string[];
+    funcIds: string[];
     tree: MarshalledPlainSource;
     /** The required modules' functional specs, for the repair agent. */
     required: RequiredSpec[];

package/dist/regenerate/regression.js

@@ -6,6 +6,7 @@ import { reportActivity, reportStage, unitOf } from "./activity.js";
 import { confinedTools } from "./confine.js";
 import { projectRootOf } from "./paths.js";
 import { buildRegressionFixPrompt, sectionModules } from "./prompt.js";
+import { baseOfCodebase } from "./base-folder.js";
 import { abandonWork, landWork, markWork } from "./lineage.js";
 import { record } from "./ledger.js";
 import { missingToolchainError } from "./environment-error.js";
@@ -31,9 +32,11 @@ function conformanceDirs(conformanceRoot, moduleName) {
 }
 /** Repair the implementation after the merged suite went red. */
 async function repairRegression(input) {
-    const [specifications] = getSpecificationsForFrid(input.tree, input.frids[input.frids.length - 1]);
+    const [specifications] = getSpecificationsForFrid(input.tree, input.funcIds[input.funcIds.length - 1]);
     const runs = [];
     const fence = confinedTools({ workdir: input.buildDir, reportsEnvironment: true });
+    // What came from the base folder its codebase started from: the repair keeps it.
+    const startedFrom = baseOfCodebase(input.buildDir);
     const notes = notesForSession(input.buildDir, `${input.step} regression repair`);
     reportStage(`${unitOf(input.moduleName)}: starting the repair agent${input.model ? ` (${input.model})` : ""}`);
     const session = await createExecutor({
@@ -58,10 +61,11 @@ async function repairRegression(input) {
         system: `${fence.note}\n\n${workspaceBlock({ dir: input.buildDir, hasMyDiff: FIX_TOOLS.includes("my_diff") })}`,
         task: withNotes(withTestingScripts(buildRegressionFixPrompt({
             moduleName: input.moduleName,
-            frids: input.frids,
+            funcIds: input.funcIds,
             specifications,
             modules: sectionModules(input.tree, input.moduleName),
             required: input.required,
+            ...(startedFrom !== undefined ? { base: startedFrom } : {}),
             failure: input.failure,
         }), input.scripts, ["conformance", "unit"], projectRootOf(input.buildDir)), input.buildDir),
         compaction: { instructions: CODER_COMPACTION },
@@ -113,7 +117,7 @@ export async function ensureRegressionPasses(input) {
     const maxRounds = input.maxRounds ?? DEFAULT_MAX_REGRESSION_ROUNDS;
     for (let round = 0; round <= maxRounds; round += 1) {
         reportStage(round === 0
-            ? `${unitOf(input.moduleName)}: running the codebase's whole conformance suite - every functionality's tests together (${input.frids.join(", ")})`
+            ? `${unitOf(input.moduleName)}: running the codebase's whole conformance suite - every functionality's tests together (${input.funcIds.join(", ")})`
             : `${unitOf(input.moduleName)}: repair ${round} done - running the whole conformance suite again`);
         const result = await runConformanceScript(input.buildDir, dirs, input.scripts);
         // The script cannot find its toolchain: no repair would pass it - the pulse stops, and the person is told.
@@ -123,7 +127,7 @@ export async function ensureRegressionPasses(input) {
             throw lacking;
         }
         command = result.command;
-        runs.push({ command, exitCode: result.exitCode, frids: input.frids });
+        runs.push({ command, exitCode: result.exitCode, funcIds: input.funcIds });
         // The suite passes and its static checks do not: the findings are in the tests, which no repair may touch - the
         // conformance tests' own job fixes them.
         if (staticChecksOnly(result)) {
@@ -132,7 +136,7 @@ export async function ensureRegressionPasses(input) {
             return { passed: false, runs, repairs, command };
         }
         reportActivity(result.exitCode === 0 ? "  ✓ whole suite passing" : `  ✗ whole suite failing (exit ${result.exitCode})`);
-        input.onEvent?.({ type: "run", command, exitCode: result.exitCode, frids: input.frids });
+        input.onEvent?.({ type: "run", command, exitCode: result.exitCode, funcIds: input.funcIds });
         // The whole suite passing is half of it: the unit tests have to pass with it.
         let failure = result.output;
         let passing = result.exitCode === 0;
@@ -144,8 +148,8 @@ export async function ensureRegressionPasses(input) {
                 abandonWork(start, input.moduleName, "the unit testing script could not run");
                 throw lackingUnit;
             }
-            runs.push({ command: unit.command, exitCode: unit.exitCode, frids: input.frids });
-            input.onEvent?.({ type: "run", command: unit.command, exitCode: unit.exitCode, frids: input.frids });
+            runs.push({ command: unit.command, exitCode: unit.exitCode, funcIds: input.funcIds });
+            input.onEvent?.({ type: "run", command: unit.command, exitCode: unit.exitCode, funcIds: input.funcIds });
             if (unit.exitCode !== 0) {
                 reportActivity(`  ✗ unit tests failing (exit ${unit.exitCode}) with the conformance suite passing`);
                 passing = false;
@@ -161,18 +165,18 @@ export async function ensureRegressionPasses(input) {
         }
         if (round === maxRounds)
             break;
-        input.onEvent?.({ type: "repair", frids: input.frids });
+        input.onEvent?.({ type: "repair", funcIds: input.funcIds });
         record({ kind: "gate.round", gate: "regression", round: round + 1, of: maxRounds });
         reportStage(`${unitOf(input.moduleName)}: an earlier functionality broke - repairing (round ${round + 1} of ${maxRounds})`);
         repairs.push(await repairRegression({
             testsDirs: dirs,
             buildDir: input.buildDir,
             moduleName: input.moduleName,
-            frids: input.frids,
+            funcIds: input.funcIds,
             tree: input.tree,
             required: input.required,
             failure,
-            step: input.step ?? `${input.moduleName} ${input.frids.at(-1)}`,
+            step: input.step ?? `${input.moduleName} ${input.funcIds.at(-1)}`,
             scripts: input.scripts,
             model: input.model,
             onDelta: input.onDelta,