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

package/dist/regenerate/renames.d.ts

@@ -0,0 +1,42 @@
+import { type MarshalledPlainSource } from "../plain/spec.ts";
+import { type LedgerPlace } from "./ledger.ts";
+export type PureRename = {
+    kind: "func-id";
+    module: string;
+    from: string;
+    to: string;
+} | {
+    kind: "scenario-id";
+    module: string;
+    funcId: string;
+    scenario: "conformance" | "acceptance";
+    from: string;
+    to: string;
+};
+/** The renames found, and the records as they are once made - in memory: nothing is written here. */
+export interface Renamed {
+    renames: PureRename[];
+    code: MarshalledPlainSource | null;
+    tests: MarshalledPlainSource | null;
+}
+/**
+ * The pure renames from what the code and its tests are built for to the spec now, in the codebase of `module`. `code`
+ * and `tests` are its records, `spec` its chain's spec with the scenarios on each functional spec.
+ */
+export declare function pureRenames(code: MarshalledPlainSource | null, tests: MarshalledPlainSource | null, spec: MarshalledPlainSource, module: string): Renamed;
+/** A rename as a person reads it. */
+export declare function renameText(rename: PureRename): string;
+/** A test file's text with the labels of the renames rewritten to the new names - matched on the whole key. */
+export declare function relabelled(text: string, renames: PureRename[]): string;
+/**
+ * Make the renames in a codebase, as one unit of work: the code record and the tests record rewritten to the new names,
+ * the tests relabelled, committed together - or, failing anywhere, rolled back whole. No agent runs, and the code is not
+ * touched. Returns whether it landed.
+ */
+export declare function makeRenames(options: {
+    buildDir: string;
+    testsDir: string;
+    moduleName: string;
+    renamed: Renamed;
+    place?: LedgerPlace;
+}): boolean;

package/dist/regenerate/renames.js

@@ -0,0 +1,185 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { ACCEPTANCE_TESTS, CONFORMANCE_TESTS, FUNCTIONAL_REQUIREMENTS, REQUIRED_FUNCTIONAL_SPECS } from "../plain/spec.js";
+import { reportActivity } from "./activity.js";
+import { record } from "./ledger.js";
+import { abandonWork, landWork, moduleDirOf, startWork } from "./lineage.js";
+import { hasScenarios, marksRegenerateAgain, writeCodeRecord, writeTestsRecord } from "./records.js";
+import { listFiles } from "./testing.js";
+const SECTIONS = [REQUIRED_FUNCTIONAL_SPECS, FUNCTIONAL_REQUIREMENTS];
+const KINDS = [
+    ["conformance", CONFORMANCE_TESTS],
+    ["acceptance", ACCEPTANCE_TESTS],
+];
+/** A value as text with its keys sorted: two items alike whatever order their keys came in. */
+function stable(value) {
+    const sorted = (entry) => {
+        if (Array.isArray(entry))
+            return entry.map(sorted);
+        if (entry !== null && typeof entry === "object")
+            return Object.fromEntries(Object.keys(entry).sort().map((key) => [key, sorted(entry[key])]));
+        return entry;
+    };
+    return JSON.stringify(sorted(value));
+}
+/** What of a functional spec the code is built from, but its func-id: its text, its links. */
+function codeOf(item) {
+    const { id: _id, [CONFORMANCE_TESTS]: _conformance, [ACCEPTANCE_TESTS]: _acceptance, regenerate_again: _again, ...rest } = item;
+    return stable({ ...rest, markdown: String(rest.markdown ?? "").trim() });
+}
+const scenariosOf = (item, key) => item?.[key] ?? [];
+/** A scenario as it reads, but its scenario-id: its text and its links. */
+const readsAs = (scenario) => stable({ text: scenario.text.trim(), linked_resources: scenario.linked_resources ?? [] });
+/** Every scenario of a functional spec, by kind and scenario-id, as it reads. */
+function scenarioKeys(item) {
+    return stable(KINDS.map(([kind, key]) => scenariosOf(item, key).map((scenario) => `${kind} ${scenario.id} ${readsAs(scenario)}`).sort()));
+}
+const sectionOf = (tree, heading) => (tree?.[heading] ?? []).slice();
+/**
+ * The pure renames from what the code and its tests are built for to the spec now, in the codebase of `module`. `code`
+ * and `tests` are its records, `spec` its chain's spec with the scenarios on each functional spec.
+ */
+export function pureRenames(code, tests, spec, module) {
+    const renames = [];
+    let codeNow = code;
+    let testsNow = tests;
+    for (const heading of SECTIONS) {
+        const own = heading === FUNCTIONAL_REQUIREMENTS;
+        const moduleOf = (item) => (own ? module : (item.module ?? ""));
+        const key = (item) => `${moduleOf(item)}:${item.id ?? ""}`;
+        const built = sectionOf(codeNow, heading);
+        const now = sectionOf(spec, heading);
+        const tested = sectionOf(testsNow, heading);
+        const inSpec = new Set(now.map(key));
+        const inCode = new Set(built.map(key));
+        const fresh = now.filter((item) => !inCode.has(key(item)));
+        const taken = new Set();
+        const renamed = new Map();
+        for (const gone of built.filter((item) => !inSpec.has(key(item)) && !marksRegenerateAgain(item))) {
+            const testedItem = tested.find((item) => key(item) === key(gone));
+            // Its tests, when it has them, written for it as it is built: the same text, not marked to be written again.
+            if (testedItem !== undefined && (marksRegenerateAgain(testedItem) || codeOf(testedItem) !== codeOf(gone)))
+                continue;
+            const match = fresh.find((item) => !taken.has(item) &&
+                moduleOf(item) === moduleOf(gone) &&
+                codeOf(item) === codeOf(gone) &&
+                (testedItem !== undefined ? scenarioKeys(testedItem) === scenarioKeys(item) : !hasScenarios(item)));
+            if (match === undefined)
+                continue;
+            taken.add(match);
+            renamed.set(key(gone), match.id ?? "");
+            renames.push({ kind: "func-id", module: moduleOf(gone), from: gone.id ?? "", to: match.id ?? "" });
+        }
+        if (renamed.size > 0) {
+            const rename = (item) => (renamed.has(key(item)) ? { ...item, id: renamed.get(key(item)) } : item);
+            codeNow = { ...codeNow, [heading]: built.map(rename) };
+            if (testsNow !== null)
+                testsNow = { ...testsNow, [heading]: tested.map(rename) };
+        }
+        // Scenario-ids renamed, under a functional spec whose code and tests are caught up and nothing else of it changed.
+        const builtNow = new Map(sectionOf(codeNow, heading).map((item) => [key(item), item]));
+        const nowByKey = new Map(now.map((item) => [key(item), item]));
+        let changed = false;
+        const testedNow = sectionOf(testsNow, heading).map((item) => {
+            const current = nowByKey.get(key(item));
+            const have = builtNow.get(key(item));
+            if (current === undefined || have === undefined || marksRegenerateAgain(item) || marksRegenerateAgain(have))
+                return item;
+            if (codeOf(item) !== codeOf(current) || codeOf(have) !== codeOf(current))
+                return item;
+            const pairs = [];
+            for (const [kind, scenarioKey] of KINDS) {
+                const was = scenariosOf(item, scenarioKey);
+                const is = scenariosOf(current, scenarioKey);
+                const wasIds = new Set(was.map((scenario) => scenario.id));
+                const isIds = new Set(is.map((scenario) => scenario.id));
+                // A scenario kept under its id must read as it did: one changed is no rename.
+                for (const scenario of was) {
+                    const kept = is.find((other) => other.id === scenario.id);
+                    if (kept !== undefined && readsAs(kept) !== readsAs(scenario))
+                        return item;
+                }
+                const removed = was.filter((scenario) => !isIds.has(scenario.id));
+                const added = is.filter((scenario) => !wasIds.has(scenario.id));
+                if (removed.length !== added.length)
+                    return item;
+                const used = new Set();
+                for (const scenario of removed) {
+                    const match = added.find((other) => !used.has(other) && readsAs(other) === readsAs(scenario));
+                    if (match === undefined)
+                        return item;
+                    used.add(match);
+                    pairs.push({ kind: "scenario-id", module: moduleOf(item), funcId: item.id ?? "", scenario: kind, from: scenario.id, to: match.id });
+                }
+            }
+            if (pairs.length === 0)
+                return item;
+            renames.push(...pairs);
+            changed = true;
+            return { ...item, [CONFORMANCE_TESTS]: current[CONFORMANCE_TESTS], [ACCEPTANCE_TESTS]: current[ACCEPTANCE_TESTS] };
+        });
+        if (changed && testsNow !== null)
+            testsNow = { ...testsNow, [heading]: testedNow };
+    }
+    return { renames, code: codeNow, tests: testsNow };
+}
+/** A rename as a person reads it. */
+export function renameText(rename) {
+    return rename.kind === "func-id"
+        ? `${rename.module}:${rename.from} to ${rename.module}:${rename.to}`
+        : `${rename.scenario} scenario ${rename.from} of ${rename.module}:${rename.funcId} to ${rename.to}`;
+}
+const escaped = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/** Where a label's key ends: never inside a longer func-id or scenario-id. */
+const END = "(?![a-z0-9_]|-[a-z0-9])";
+/** A test file's text with the labels of the renames rewritten to the new names - matched on the whole key. */
+export function relabelled(text, renames) {
+    let out = text;
+    for (const rename of renames) {
+        if (rename.kind === "func-id") {
+            const id = "[a-z0-9]+(?:-[a-z0-9]+)*";
+            out = out.replace(new RegExp(`\\b(conformance tests of|(?:conformance|acceptance) scenario ${id} of) ${escaped(rename.module)}:${escaped(rename.from)}${END}`, "g"), `$1 ${rename.module}:${rename.to}`);
+        }
+        else {
+            out = out.replace(new RegExp(`\\b${rename.scenario} scenario ${escaped(rename.from)} of ${escaped(rename.module)}:${escaped(rename.funcId)}${END}`, "g"), `${rename.scenario} scenario ${rename.to} of ${rename.module}:${rename.funcId}`);
+        }
+    }
+    return out;
+}
+/**
+ * Make the renames in a codebase, as one unit of work: the code record and the tests record rewritten to the new names,
+ * the tests relabelled, committed together - or, failing anywhere, rolled back whole. No agent runs, and the code is not
+ * touched. Returns whether it landed.
+ */
+export function makeRenames(options) {
+    const { buildDir, testsDir, moduleName, renamed } = options;
+    if (renamed.renames.length === 0)
+        return true;
+    const said = renamed.renames.map(renameText).join(", ");
+    const unit = startWork([buildDir, testsDir], moduleName);
+    try {
+        if (renamed.code !== null)
+            writeCodeRecord(buildDir, renamed.code);
+        if (renamed.tests !== null)
+            writeTestsRecord(testsDir, renamed.tests);
+        for (const file of listFiles(testsDir)) {
+            const path = join(testsDir, file);
+            const text = readFileSync(path, "utf8");
+            const now = relabelled(text, renamed.renames);
+            if (now !== text)
+                writeFileSync(path, now);
+        }
+        const subject = `renamed ${said}`;
+        landWork(buildDir, subject);
+        if (moduleDirOf(buildDir) !== moduleDirOf(testsDir))
+            landWork(testsDir, subject);
+    }
+    catch (error) {
+        abandonWork(unit, moduleName, `renaming ${said} failed: ${error instanceof Error ? error.message : String(error)}`);
+        return false;
+    }
+    for (const rename of renamed.renames)
+        record({ kind: "loop.renamed", what: rename.kind, from: rename.from, to: rename.to, spec: rename.kind === "func-id" ? `${rename.module}:${rename.to}` : `${rename.module}:${rename.funcId}` }, options.place);
+    reportActivity(`  ${moduleName}: renamed ${said} - the records and the tests' labels, nothing regenerated`);
+    return true;
+}

package/dist/regenerate/requires.d.ts

@@ -16,7 +16,7 @@ export interface ChainEntry {
     buildDir: string;
     /** The module whose code is copied in before this one is built. */
     requires: string | null;
-    frids: string[];
+    funcIds: string[];
 }
 /** A required module's file: the first template folder that has it. */
 export declare function locateModule(moduleName: string, templateDirs: string[]): string;

package/dist/regenerate/requires.js

@@ -5,9 +5,10 @@ import { getFrids, getInheritedFunctionalSpecs } from "../plain/spec.js";
 import { buildDirUnder, modulesRoot, projectDirOf } from "./paths.js";
 import { notesPath } from "./notes.js";
 import { resolveTemplateDirs } from "./paths.js";
-import { inheritedRecord, readRecord, RECORD_FILE, writeCodeRecord } from "./records.js";
+import { inheritedRecord, inheritedTestsRecord, readRecord, RECORD_FILE, writeCodeRecord, writeTestsRecord } from "./records.js";
 import { head, historyLog, recordHistory } from "./lineage.js";
 import { listFiles } from "./testing.js";
+import { carryBaseRecord } from "./base-folder.js";
 /** A required module's file: the first template folder that has it. */
 export function locateModule(moduleName, templateDirs) {
     for (const dir of templateDirs) {
@@ -48,7 +49,7 @@ options = {}) {
             plainFile: resolve(file),
             buildDir: buildDirUnder(root, moduleName),
             requires: previous,
-            frids: [...getFrids(tree)],
+            funcIds: [...getFrids(tree)],
         });
         return moduleName;
     };
@@ -221,9 +222,10 @@ fromModule) {
         copyFileSync(join(from, file), target);
         copied.push(file);
     }
-    // The working notes describe this code, so they come up with it.
+    // The working notes describe this code, so they come up with it - and so does what it started from, a base folder's files.
     if (existsSync(notesPath(from)) && !existsSync(notesPath(to)))
         copyFileSync(notesPath(from), notesPath(to));
+    carryBaseRecord(from, to);
     // What the code is built from comes with it, as what the new module inherits - not as its own work.
     const built = readRecord(from);
     writeCodeRecord(to, built !== null ? inheritedRecord(built, fromModule) : {});
@@ -245,6 +247,11 @@ fromModule) {
         // And their notes, which listFiles leaves out as it does the code's.
         if (existsSync(notesPath(testsFrom)) && !existsSync(notesPath(testsTo)))
             copyFileSync(notesPath(testsFrom), notesPath(testsTo));
+        // What they are written for comes with them, as what the new module inherits: its conformance suite is the chain's,
+        // kept up to date here from now on.
+        const tested = readRecord(testsFrom);
+        if (tested !== null)
+            writeTestsRecord(testsTo, inheritedTestsRecord(tested, fromModule));
     }
     recordStart();
     return copied;

package/dist/regenerate/resources.d.ts

@@ -9,6 +9,8 @@ export interface LoadedResource {
     image?: ResourceImage;
     /** Where the file is: copy_resource copies it whole from here. */
     source?: string;
+    /** It is in the codebase already, at this path - a file the base folder held: used from there, never copied. */
+    inCodebase?: string;
     /** Its text was cut for the prompt: how long it is whole. */
     cutFrom?: number;
 }
@@ -26,12 +28,12 @@ export declare class LinkedImageError extends Error {
 /**
  * Load the resources linked from the specifications in scope for one functionality.
  *
- * `collectLinkedResources` stops at the requested FRID, so a resource introduced by a
- * later functionality is not pulled into this prompt.
+ * `collectLinkedResources` stops at the requested functional spec, so a resource introduced by a
+ * later one is not pulled into this prompt.
  */
 export declare function loadLinkedResources(tree: MarshalledPlainSource, 
 /** Up to and including this functionality. Null: the whole module. */
-frid: string | null, templateDirs: string[]): LoadedResource[];
+funcId: string | null, templateDirs: string[]): LoadedResource[];
 /** The file a linked resource is read from: the first template folder that has it, else the current folder - or null. */
 export declare function resourceFile(target: string, templateDirs: string[]): string | null;
 /**

package/dist/regenerate/resources.js

@@ -19,14 +19,14 @@ export class LinkedImageError extends Error {
 /**
  * Load the resources linked from the specifications in scope for one functionality.
  *
- * `collectLinkedResources` stops at the requested FRID, so a resource introduced by a
- * later functionality is not pulled into this prompt.
+ * `collectLinkedResources` stops at the requested functional spec, so a resource introduced by a
+ * later one is not pulled into this prompt.
  */
 export function loadLinkedResources(tree, 
 /** Up to and including this functionality. Null: the whole module. */
-frid, templateDirs) {
+funcId, templateDirs) {
     const collected = [];
-    collectLinkedResources(tree, collected, null, true, frid);
+    collectLinkedResources(tree, collected, null, true, funcId);
     const loaded = [];
     for (const resource of collected) {
         // A testing script reaches an agent as one - whole, and only when it is run on its work -

package/dist/regenerate/scripts-being-written.d.ts

@@ -0,0 +1,19 @@
+import type { ScriptKind } from "./test-scripts.ts";
+/**
+ * The testing scripts being written in the background - by a skill run cultivate started (docs/skills-and-gates.md): while
+ * one is, the work loop holds the modules that need it, rather than fail their pulses for the script they lack, and it
+ * looks at them again once the run ends. On `globalThis`, as the chat's scope is: pi's own loader may load this file twice.
+ */
+export interface ScriptBeingWritten {
+    /** The project's folder. */
+    project: string;
+    kind: ScriptKind;
+    /** The stack it is written for, when the run was for one. */
+    stack?: string;
+}
+/** A script being written from now: what it returns says it is no longer, written or not. */
+export declare function writingScript(run: ScriptBeingWritten): () => void;
+/** Whether a script of this kind is being written for a module of this project on this stack - one written for no stack is anyone's. */
+export declare function scriptBeingWritten(project: string, kind: ScriptKind, stack?: string): boolean;
+/** Told each time a run writing a script ends. Returns what stops it. */
+export declare function onScriptRunEnded(listener: () => void): () => void;

package/dist/regenerate/scripts-being-written.js

@@ -0,0 +1,30 @@
+import { resolve } from "node:path";
+const KEY = Symbol.for("turri.scriptsBeingWritten");
+const writing = () => (globalThis[KEY] ??= { runs: new Set(), ended: new Set() });
+/** A script being written from now: what it returns says it is no longer, written or not. */
+export function writingScript(run) {
+    const entry = { ...run, project: resolve(run.project) };
+    writing().runs.add(entry);
+    return () => {
+        if (!writing().runs.delete(entry))
+            return;
+        for (const listener of [...writing().ended]) {
+            try {
+                listener();
+            }
+            catch {
+                /* what listens never stops the run's end */
+            }
+        }
+    };
+}
+/** Whether a script of this kind is being written for a module of this project on this stack - one written for no stack is anyone's. */
+export function scriptBeingWritten(project, kind, stack) {
+    const folder = resolve(project);
+    return [...writing().runs].some((run) => run.project === folder && run.kind === kind && (run.stack === undefined || stack === undefined || run.stack === stack));
+}
+/** Told each time a run writing a script ends. Returns what stops it. */
+export function onScriptRunEnded(listener) {
+    writing().ended.add(listener);
+    return () => writing().ended.delete(listener);
+}

package/dist/regenerate/spec-map-view.d.ts

@@ -6,7 +6,7 @@ import type { TranscriptStyle } from "./transcript-view.ts";
  *
  * Each item's first line, with its one mark in the gutter - its rung on the ladder; a changed item's changed
  * sub-bullets under it, word by word; an item taken out as a struck-through ghost. Enter opens an item: all of it, its
- * acceptance tests, the pulse that brings it, its conformance tests, and - a definition - the built specs that use it.
+ * scenarios, the pulse that brings it, its conformance tests, and - a definition - the built specs that use it.
  * One module is shown at a time, a tab a module of the chain - ←→ go from one to the next: the module regenerating now, until
  * another tab is chosen, and again once another module starts regenerating. Under its own text, the files it imports, a
  * folded block each. A chain of many modules nested one in another was too deep to read, and too much to draw.
@@ -99,7 +99,7 @@ export declare function columnHeadings(page: MarkedPage, width: number, style: T
 export declare function legendLines(page: MarkedPage, style: TranscriptStyle): string[];
 /** What the person is needed for, and how: the line under a page's first `!`, and its top line's end. */
 export declare const DISCUSS_KEY = "d";
-/** A line of ***plain highlighted as plyn highlights it: the whole line read, so a span over several words keeps its colour. */
+/** A line of ***plain highlighted as turri's grammar highlights it: the whole line read, so a span over several words keeps its colour. */
 export declare function highlighted(line: string, style: TranscriptStyle): string;
 /** One line become another, word by word: what is gone struck through in red, what is new in green, the rest as it is. */
 export declare function wordDiff(was: string, now: string, style: TranscriptStyle): string;

package/dist/regenerate/spec-map-view.js

@@ -1,7 +1,7 @@
 import { basename } from "node:path";
 import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 import { highlightLine, roleOf } from "../plain/highlight.js";
-import { ACCEPTANCE_TEST_HEADING, DEFINITIONS, FUNCTIONAL_REQUIREMENTS, NON_FUNCTIONAL_REQUIREMENTS } from "../plain/spec.js";
+import { ACCEPTANCE_TEST_HEADING, CONFORMANCE_TEST_HEADING, DEFINITIONS, FUNCTIONAL_REQUIREMENTS, NON_FUNCTIONAL_REQUIREMENTS } from "../plain/spec.js";
 import { spinner } from "./job-panel.js";
 import { countOf } from "./spec-map.js";
 export function createSpecMapState() {
@@ -75,6 +75,8 @@ const needs = (style) => style.warning ?? style.error;
 const strike = (text) => `\x1b[9m${text}\x1b[29m`;
 /** How far a group, and what is in it, is indented under its module. */
 const INDENT = "  ";
+/** What the first test req of a module none of whose functional specs has scenarios says. */
+const NOT_USED = "  not used: no scenarios";
 /**
  * Where an item stands, as one mark on a ladder every item climbs: planned, working, regenerated, validating, conform - and needs
  * you, off it - named in the legend in the panel's corner. The same mark means the same thing whatever the config says
@@ -160,7 +162,7 @@ export function legendLines(page, style) {
 /** What the person is needed for, and how: the line under a page's first `!`, and its top line's end. */
 export const DISCUSS_KEY = "d";
 const needsLine = (page) => `needs you - ${page.status} · ${DISCUSS_KEY} to talk it through in the chat`;
-/** Each character's role in a line of ***plain, as plyn highlights it - kept, the map redraws every half second. */
+/** Each character's role in a line of ***plain, as turri's grammar highlights it - kept, the map redraws every half second. */
 const rolesSeen = new Map();
 function rolesOf(line) {
     const seen = rolesSeen.get(line);
@@ -193,7 +195,7 @@ function paintRoles(text, from, roles, paint) {
     }
     return out + (run === "" ? "" : role === undefined ? run : paint.syntax(role, run));
 }
-/** A line of ***plain highlighted as plyn highlights it: the whole line read, so a span over several words keeps its colour. */
+/** A line of ***plain highlighted as turri's grammar highlights it: the whole line read, so a span over several words keeps its colour. */
 export function highlighted(line, style) {
     return style.diff === undefined ? line : paintRoles(line, 0, rolesOf(line), style.diff);
 }
@@ -325,7 +327,11 @@ function wrapped(text, width, colour = (line) => line) {
         .flatMap((line) => (line === "" ? [""] : wrapTextWithAnsi(line, Math.max(10, width - CONTINUED.length))))
         .map((line) => `${CONTINUED}${colour(line)}`);
 }
-/** All of an item, opened: the rest of its text against the code's, and its acceptance tests. Where it stands is beside its mark. */
+/**
+ * All of an item, opened: the rest of its text against the code's, and a functional spec's scenarios - under
+ * `***conformance tests***` and `***acceptance tests***`, each scenario its `# <scenario-id>` and its text, as its test
+ * plain file has them. Where it stands is beside its mark.
+ */
 function detailLines(item, width, style) {
     const lines = [];
     // The rest of its text - its first line is the row - against the record's, for a change.
@@ -334,15 +340,21 @@ function detailLines(item, width, style) {
         const drawn = item.state === "removed" ? style.removed(strike(line.now ?? "")) : item.state === "changed" ? diffLine(line, style) : highlighted(line.now ?? "", style);
         lines.push(...wrapped(drawn, width));
     }
-    if (item.acceptance.length > 0) {
-        // As the spec has them: nested under the functional spec as deep as its sub-bullets, under a heading of their own
-        // drawn as a section's is.
-        const nested = /^( +)\S/m.exec(item.text.split("\n").slice(1).join("\n"))?.[1] ?? INDENT;
-        const heading = `***${ACCEPTANCE_TEST_HEADING}***`;
-        lines.push(CONTINUED.trimEnd());
-        lines.push(`${CONTINUED}${nested}${style.diff !== undefined ? style.diff.syntax("section", heading) : style.muted(heading)}`);
-        for (const test of item.acceptance)
-            lines.push(...wrapped(test.split("\n").map((line) => `${nested}${highlighted(line, style)}`).join("\n"), width));
+    // Each kind under its section heading, as the test plain file has it - the heading and its scenarios indented under the
+    // functional spec, a blank line after each scenario, so one reads apart from the next.
+    const blank = CONTINUED.trimEnd();
+    for (const [heading, scenarios] of [[CONFORMANCE_TEST_HEADING, item.scenarios.conformance], [ACCEPTANCE_TEST_HEADING, item.scenarios.acceptance]]) {
+        if (scenarios.length === 0)
+            continue;
+        const title = `***${heading}***`;
+        if (lines.at(-1) !== blank)
+            lines.push(blank);
+        lines.push(`${CONTINUED}${INDENT}${style.diff !== undefined ? style.diff.syntax("section", title) : style.muted(title)}`);
+        for (const scenario of scenarios) {
+            const text = [`# ${scenario.id}`, ...scenario.text.split("\n")].map((line) => highlighted(line, style)).join("\n");
+            lines.push(...wrapped(text, width - INDENT.length).map((line) => (line === CONTINUED ? blank : `${CONTINUED}${INDENT}${line.slice(CONTINUED.length)}`)));
+            lines.push(blank);
+        }
     }
     return lines;
 }
@@ -431,6 +443,8 @@ export function specMapLines(pages, state, width, style, _jobs = [], now = Date.
     let underImport = false;
     // Whether what the module needs the person for is said yet, under its first `!`.
     let toldWhy = false;
+    // The first test req nothing uses: it says so for them all.
+    const firstUnused = shown?.items.find((item) => item.unused === true);
     rows.forEach((row, index) => {
         const here = index === state.cursor;
         const pointer = here ? style.accent("›") : " ";
@@ -467,6 +481,11 @@ export function specMapLines(pages, state, width, style, _jobs = [], now = Date.
             add(`${CONTINUED}${style.diff !== undefined ? style.diff.syntax("section", `***${item.section}***`) : style.muted(`***${item.section}***`)}`);
         }
         underImport = false;
+        // Functional specs are written apart, as their file writes them: a line of space between one and the next - one an
+        // opened spec's scenarios end on already does.
+        const above = rows[index - 1];
+        if (item.funcId !== undefined && above?.kind === "item" && above.item.funcId !== undefined && above.item.section === item.section && lines.at(-1) !== CONTINUED.trimEnd())
+            add(CONTINUED.trimEnd());
         rowStarts.push(lines.length);
         const mark = item.state === "removed" ? "removed" : item.mark;
         const gutter = `${pointer}${markText(item, style, now)} ${BAR}`;
@@ -474,17 +493,29 @@ export function specMapLines(pages, state, width, style, _jobs = [], now = Date.
         const room = Math.max(10, width - GUTTER - BAR.length);
         const first = firstLine(item.text);
         const wasFirst = firstLine(item.was ?? "");
-        const drawn = item.state === "removed"
+        const body = item.state === "removed"
             ? style.removed(strike(first))
             : item.state === "changed" && wasFirst !== first
                 ? wordDiff(wasFirst, first, style)
                 : highlighted(first, style);
+        // A functional spec's row is as its file writes it: its `# <func-id>` heading, its body's first line under it.
+        const unused = item.unused === true && item === firstUnused ? NOT_USED : "";
+        const said = unused;
+        // A func-id renamed, nothing else: the one it is built under beside it - renamed, not regenerated.
+        const renamed = item.renamedFrom !== undefined ? ` (was ${item.renamedFrom})` : "";
+        const heading = item.funcId !== undefined ? `# ${item.funcId}` : undefined;
+        const headingDrawn = heading === undefined ? "" : item.state === "removed" ? style.removed(strike(heading)) : highlighted(heading, style);
+        const plain = heading !== undefined ? `${heading}${renamed}${said}` : `${first}${said}`;
+        const drawn = `${heading !== undefined ? `${headingDrawn}${renamed !== "" ? style.muted(renamed) : ""}` : body}${said !== "" ? style.muted(said) : ""}`;
         // Wrapped, never cut short: what follows a `…` is what a person came to read. The lines after the first hang
         // under the item's text, past its bullet.
-        const [head = "", ...rest] = hanging(drawn, first, room);
+        const [head = "", ...rest] = hanging(drawn, plain, room);
         add(`${gutter}${head}`, mark);
         for (const line of rest)
             add(`${CONTINUED}${line}`, mark);
+        if (heading !== undefined)
+            for (const line of hanging(body, first, room))
+                add(`${CONTINUED}${line}`, mark);
         // The first item that needs the person says what for, and how to go about it - opened or closed.
         if (page.stuck && !toldWhy && rungOf(item) === "needsYou") {
             toldWhy = true;

package/dist/regenerate/spec-map.d.ts

@@ -9,8 +9,9 @@ import { type MapCodebase, type MapPlan, type MapPulse } from "./loop.ts";
  * loop's plan is laid over it (`markSpecMap`): the pulse regenerating each item, the pulse planned to, or why there is
  * none.
  *
- * An item is what turri plans and diffs by: a definition, a req, a functional spec with its sub-bullets and acceptance
- * tests. Items are matched to pulses by their lines in the trees each pulse goes between, as the loop has them.
+ * An item is what turri plans and diffs by: a definition, a req, a functional spec with its body and its scenarios. Items
+ * are matched to pulses by their lines in the trees each pulse goes between, as the loop has them - a functional spec,
+ * on the conformance track, by its func-id.
  */
 /** Where an item stands against the code record. A test req is the conformance track's: it is never built. */
 export type ItemState = "built" | "new" | "changed" | "removed" | "test";
@@ -25,14 +26,31 @@ export interface MapItem {
     text: string;
     /** The code record's text, for a changed item. */
     was?: string;
-    /** Its acceptance tests, as the spec has them now. */
-    acceptance: string[];
+    /** A functional spec's func-id: what it is matched and kept by. */
+    funcId?: string;
+    /** A functional spec's scenarios, as its test plain file has them now: none, with no file - it is not tested. */
+    scenarios: MapScenarios;
     /** Its line in the code's tree now, and in the code record's: what a pulse's trees are matched by. */
     line?: string;
     wasLine?: string;
     /** A functional spec's conformance tests: written for it as it reads now, for an earlier text, or for one taken out. */
     tests?: "now" | "older" | "removed";
+    /** A functional spec whose func-id was renamed, and nothing else: the func-id it is built under - turri renames it, regenerating nothing. */
+    renamedFrom?: string;
 }
+/** A functional spec's scenarios, each its scenario-id and its text. */
+export interface MapScenarios {
+    conformance: Array<{
+        id: string;
+        text: string;
+    }>;
+    acceptance: Array<{
+        id: string;
+        text: string;
+    }>;
+}
+/** Whether a functional spec has scenarios - and so conformance tests to write. */
+export declare function hasScenarioViews(scenarios: MapScenarios): boolean;
 export interface MapPage {
     module: string;
     plainFile: string;
@@ -42,8 +60,10 @@ export interface MapPage {
     imports: string[];
     /** The module it requires - whose code it is built on - when it requires one. */
     requires?: string;
-    /** Its conformance tests are on, as its config has it: `conformance-tests:` is not false. */
+    /** Whether any of its functional specs has scenarios, and so conformance tests to write: its test reqs are used. */
     conformance?: boolean;
+    /** Its functional specs have scenarios, and a step of adding tests is skipped - the test reqs, or the conformance testing script: what is missing, in a few words. */
+    testingMissing?: string;
     items: MapItem[];
     /** Its spec does not parse, or could not be read. */
     error?: string;
@@ -60,6 +80,8 @@ export interface MarkedItem extends MapItem {
     testing?: boolean;
     /** The conformance pulse planned to write its tests, not running yet: what its provisional number is read from. */
     testsPulse?: MapPulse;
+    /** A test req of a module none of whose functional specs has scenarios: nothing uses it. */
+    unused?: boolean;
 }
 export interface MarkedPage extends MapPage {
     items: MarkedItem[];