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

package/dist/regenerate/drift.js

@@ -1,7 +1,7 @@
 import { DEFAULT_CONCEPTS, extractConceptsFromDefinition, extractConceptsFromSpecText } from "../plain/concepts.js";
-import { DEFINITIONS, FUNCTIONAL_REQUIREMENTS, REQUIRED_FUNCTIONAL_SPECS } from "../plain/spec.js";
+import { ACCEPTANCE_TESTS, CONFORMANCE_TESTS, DEFINITIONS, FUNCTIONAL_REQUIREMENTS, REQUIRED_FUNCTIONAL_SPECS } from "../plain/spec.js";
 import { codeTree, conformanceTarget, marksRegenerateAgain } from "./records.js";
-import { applyChanges, changesBetween, parseTree, resourcesChanged, serializeTree } from "./spec-steps.js";
+import { applyChanges, changesBetween, isMove, parseTree, resourcesChanged, serializeTree } from "./spec-steps.js";
 /**
  * The work, derived from the records - see docs/regenerating.md. Nothing here is stored: what is left
  * to build is the difference between what a record says is built and what the spec says now, worked
@@ -9,7 +9,7 @@ import { applyChanges, changesBetween, parseTree, resourcesChanged, serializeTre
  *
  * - Code work: from the code record to the spec as the code sees it.
  * - Conformance work: from the tests record to what the conformance tests are to be written for now -
- *   the chosen functional specs the code is built from.
+ *   the functional specs the code is built from that have scenarios.
  *
  * A job is a set of those changes. What it tells its agents follows from the functional specs it
  * touches - its cases - and a running job is stopped once the spec no longer wants what it makes.
@@ -19,11 +19,52 @@ export function codeWork(record, spec) {
     return changesBetween(serializeTree(codeTree(record ?? {})), serializeTree(codeTree(spec)));
 }
 /** Everything left to do in the conformance tests: from what the tests record says they are written for, to what they are to be now. */
-export function conformanceWork(tests, code, spec, chosen) {
-    return changesBetween(serializeTree(tests ?? {}), serializeTree(conformanceTarget(code, tests, spec, chosen)));
+export function conformanceWork(tests, code, spec) {
+    return changesBetween(serializeTree(tests ?? {}), serializeTree(conformanceTarget(code, tests, spec)));
+}
+/** Whether an item of a tree carries scenarios - a tree of the conformance tests' - rather than being the code's. */
+const carriesScenarios = (item) => item !== undefined && (CONFORMANCE_TESTS in item || ACCEPTANCE_TESTS in item);
+/** Every scenario of an item, by its kind and scenario-id. */
+function scenariosIn(item) {
+    const found = new Map();
+    for (const kind of ["conformance", "acceptance"]) {
+        for (const scenario of (item?.[kind === "conformance" ? CONFORMANCE_TESTS : ACCEPTANCE_TESTS] ?? [])) {
+            found.set(`${kind} ${scenario.id}`, { kind, id: scenario.id, text: scenario.text, line: JSON.stringify([scenario.text.trim(), scenario.linked_resources ?? []]) });
+        }
+    }
+    return found;
+}
+/** What of a functional spec the code is built from: everything but its scenarios. */
+function codeOf(item) {
+    if (item === undefined)
+        return "";
+    const { [CONFORMANCE_TESTS]: _conformance, [ACCEPTANCE_TESTS]: _acceptance, regenerate_again: _again, ...rest } = item;
+    return JSON.stringify({ ...rest, markdown: rest.markdown.trim() });
+}
+/** A functional spec's scenarios by case, from the item its tests were written for to the one they are to be. */
+function scenarioCasesOf(spec, was, is, code) {
+    const before = scenariosIn(was);
+    const after = scenariosIn(is);
+    const plain = ({ kind, id, text }) => ({ kind, id, text });
+    const cases = { ...spec, added: [], changed: [], removed: [], unchanged: [] };
+    for (const [key, scenario] of after) {
+        const old = before.get(key);
+        if (old === undefined)
+            cases.added.push(plain(scenario));
+        else if (old.line !== scenario.line)
+            cases.changed.push(plain(scenario));
+        else
+            cases.unchanged.push(plain(scenario));
+    }
+    for (const [key, scenario] of before)
+        if (!after.has(key))
+            cases.removed.push(plain(scenario));
+    const moved = code ?? (was !== undefined && is !== undefined && codeOf(was) !== codeOf(is) ? "text" : undefined);
+    return moved !== undefined && cases.unchanged.length > 0 ? { ...cases, codeChanged: moved } : cases;
 }
 const functionalSpecs = (tree) => tree[FUNCTIONAL_REQUIREMENTS] ?? [];
-const firstLine = (markdown) => markdown.trim().split("\n")[0].replace(/^-\s*/, "").trim();
+const inheritedSpecs = (tree) => tree[REQUIRED_FUNCTIONAL_SPECS] ?? [];
+const firstLine = (markdown) => markdown.trim().split("\n")[0].trim();
 /** An item of a serialized tree, read back. */
 const itemOfLine = (line) => {
     if (line === undefined)
@@ -74,38 +115,44 @@ export function conceptsUsed(markdown, definitions) {
 export function casesOf(before, changes, options = {}) {
     const beforeText = serializeTree(before);
     const after = parseTree(applyChanges(beforeText, changes));
-    const numberIn = (tree, item, position) => {
-        if (item?.frid !== undefined)
-            return item.frid;
-        const specs = functionalSpecs(tree);
-        const at = item === undefined ? -1 : specs.findIndex((spec) => spec.markdown === item.markdown);
-        return String(at === -1 ? position : at + 1);
-    };
     const own = options.module !== undefined ? { module: options.module } : {};
+    const touchedOf = (item, required) => ({
+        funcId: item.id,
+        text: firstLine(item.markdown),
+        ...(required ? (item.module !== undefined ? { module: item.module } : {}) : own),
+    });
     const add = [];
     const patch = [];
     const again = [];
     const removed = [];
+    /** Each functional spec touched, as the tests record has it and as it is to be: its scenarios' cases are worked out from them. */
+    const items = new Map();
+    const keyOf = (spec) => `${spec.module ?? ""}:${spec.funcId}`;
+    const seen = (spec, was, is) => {
+        items.set(keyOf(spec), { ...(was !== undefined ? { was } : {}), ...(is !== undefined ? { is } : {}) });
+        return spec;
+    };
     for (const change of changes) {
+        // A module below's functional specs are cased as the codebase's own are: the codebase at the tip holds their code.
+        if (change.section !== FUNCTIONAL_REQUIREMENTS && change.section !== REQUIRED_FUNCTIONAL_SPECS)
+            continue;
+        const required = change.section === REQUIRED_FUNCTIONAL_SPECS;
         const was = itemOfLine(change.before);
         const is = itemOfLine(change.after);
         // Marked to regenerate again: regenerated again, whatever else changed in its text - its own or, required, another module's.
         if (change.kind === "change" && is !== undefined && marksRegenerateAgain(was)) {
-            const required = change.section === REQUIRED_FUNCTIONAL_SPECS ? is : undefined;
-            if (change.section === FUNCTIONAL_REQUIREMENTS)
-                again.push({ frid: numberIn(after, is, change.position), text: firstLine(is.markdown), ...own });
-            else if (required !== undefined)
-                again.push({ frid: `${required.frid ?? change.position}`, text: firstLine(is.markdown), ...(required.module !== undefined ? { module: required.module } : {}) });
+            again.push(seen(touchedOf(is, required), was, is));
             continue;
         }
-        if (change.section !== FUNCTIONAL_REQUIREMENTS)
+        // Moved, and nothing else: none.
+        if (isMove(change))
             continue;
         if (change.kind === "add" && is !== undefined)
-            add.push({ frid: numberIn(after, is, change.position), text: firstLine(is.markdown), ...own });
+            add.push(seen(touchedOf(is, required), undefined, is));
         else if (change.kind === "remove" && was !== undefined)
-            removed.push({ frid: numberIn(before, was, change.position), text: firstLine(was.markdown), ...own });
+            removed.push(seen(touchedOf(was, required), was, undefined));
         else if (change.kind === "change" && is !== undefined)
-            patch.push({ frid: numberIn(after, is, change.position), text: firstLine(is.markdown), ...own });
+            patch.push(seen(touchedOf(is, required), was, is));
     }
     // The concepts the job defines anew, changes or takes out.
     const redefined = new Set();
@@ -119,20 +166,43 @@ export function casesOf(before, changes, options = {}) {
                     redefined.add(concept);
         }
     }
+    // Every functional spec of the chain, as it is after the job and as it was: those of the modules below, then the
+    // codebase's own - the order every case lists them in.
+    const chainOf = (tree) => [...inheritedSpecs(tree).map((item) => ({ item, required: true })), ...functionalSpecs(tree).map((item) => ({ item, required: false }))];
+    const chain = chainOf(after);
     if (redefined.size > 0) {
-        const touched = new Set([...add, ...patch, ...again].filter((spec) => spec.module === options.module).map((spec) => spec.frid));
+        const touched = new Set([...add, ...patch, ...again].map(keyOf));
         const definitionsAfter = after[DEFINITIONS] ?? [];
         const definitionsBefore = before[DEFINITIONS] ?? [];
-        functionalSpecs(after).forEach((item, index) => {
-            const frid = item.frid ?? String(index + 1);
-            if (touched.has(frid))
-                return;
+        for (const { item, required } of chain) {
+            const spec = touchedOf(item, required);
+            if (touched.has(keyOf(spec)))
+                continue;
             const uses = new Set([...conceptsUsed(item.markdown, definitionsAfter), ...conceptsUsed(item.markdown, definitionsBefore)]);
             if ([...redefined].some((concept) => uses.has(concept)))
-                patch.push({ frid, text: firstLine(item.markdown), ...own });
-        });
-        patch.sort((a, b) => Number(a.frid) - Number(b.frid));
+                patch.push(seen(spec, item, item));
+        }
     }
+    // In the chain's order: one taken out where it was.
+    const orderIn = (specs) => new Map(specs.map(({ item, required }, index) => [keyOf(touchedOf(item, required)), index]));
+    const inOrder = (list, order) => list.sort((a, b) => (order.get(keyOf(a)) ?? Number.MAX_SAFE_INTEGER) - (order.get(keyOf(b)) ?? Number.MAX_SAFE_INTEGER));
+    const order = orderIn(chain);
+    for (const list of [add, patch, again])
+        inOrder(list, order);
+    inOrder(removed, orderIn(chainOf(before)));
+    // The conformance tests' trees carry the scenarios: each functional spec touched, scenario by scenario.
+    const touchedItems = [...items.values()];
+    const scenarios = touchedItems.some(({ was, is }) => carriesScenarios(was) || carriesScenarios(is))
+        ? [
+            ...add.map((spec) => scenarioCasesOf(spec, undefined, items.get(keyOf(spec))?.is)),
+            ...patch.map((spec) => {
+                const { was, is } = items.get(keyOf(spec)) ?? {};
+                return scenarioCasesOf(spec, was, is, was === is ? "concept" : undefined);
+            }),
+            ...again.map((spec) => scenarioCasesOf(spec, items.get(keyOf(spec))?.was, items.get(keyOf(spec))?.is, "again")),
+            ...removed.map((spec) => scenarioCasesOf(spec, items.get(keyOf(spec))?.was, undefined)),
+        ]
+        : undefined;
     return {
         fresh: options.fresh === true,
         add,
@@ -140,6 +210,7 @@ export function casesOf(before, changes, options = {}) {
         again,
         delete: removed,
         mechanical: add.length === 0 && patch.length === 0 && again.length === 0 && removed.length === 0,
+        ...(scenarios !== undefined ? { scenarios } : {}),
     };
 }
 /** Two changes are the same change when they do the same to the same item. */

package/dist/regenerate/jobs.d.ts

@@ -8,10 +8,10 @@ import { type AgentTally, type BuildingSpec, type SpecConflict, type TranscriptE
  * carries on while the agents work.
  */
 export type JobStatus = "queued" | "running" | "succeeded" | "failed" | "stopped";
-/** A functional spec a pulse covers: the module whose spec it is - the pulse's own, or one below it - and its number there. */
+/** A functional spec a pulse covers: the module whose spec it is - the pulse's own, or one below it - and its func-id there. */
 export interface PulseSpec {
     module: string;
-    frid: string;
+    funcId: string;
 }
 /**
  * The functional specs a pulse covers, by what it does to each (`cases.ts`): new, changed, regenerated again - its text

package/dist/regenerate/jobs.js

@@ -137,7 +137,7 @@ export function createJobRegistry(options) {
                 ...(input.module !== undefined ? { module: input.module } : {}),
                 specConflict(conflict) {
                     job.specConflict = conflict;
-                    this.transcript({ kind: "stage", text: `the spec contradicts itself: functionalities ${conflict.specs.map((spec) => `${spec.module} ${spec.frid}`).join(" and ")} cannot both hold` });
+                    this.transcript({ kind: "stage", text: `the spec contradicts itself: functional specs ${conflict.specs.map((spec) => `${spec.module}:${spec.funcId}`).join(" and ")} cannot both hold` });
                     changed();
                 },
                 stage(label) {

package/dist/regenerate/ledger.d.ts

@@ -117,6 +117,12 @@ export type LedgerEvent = {
 } | {
     kind: "loop.stopped";
     why: string;
+} | {
+    kind: "loop.renamed";
+    what: "func-id" | "scenario-id";
+    from: string;
+    to: string;
+    spec: string;
 } | {
     kind: "planner.failed";
     step: "group" | "place" | "title";
@@ -233,6 +239,19 @@ export type LedgerEvent = {
     missing: string;
     source: string;
     sandbox: boolean;
+} | {
+    kind: "advisor.classified";
+    spec: string;
+    verdict: "yes" | "no";
+    questions: string[];
+    asked: boolean;
+} | {
+    kind: "advisor.dropped";
+    spec: string;
+} | {
+    kind: "advisor.failed";
+    spec: string;
+    reason: string;
 };
 export type LedgerKind = LedgerEvent["kind"];
 /** One line of the ledger: the event, and where and when it happened. */

package/dist/regenerate/loop.d.ts

@@ -1,3 +1,4 @@
+import { type MarshalledPlainSource } from "../plain/spec.ts";
 import { type ChunkAgents } from "./chunk-plan.ts";
 import { type SpecGap } from "./notes.ts";
 import { type Job, type JobRegistry, type PulseCases } from "./jobs.ts";
@@ -6,7 +7,7 @@ import { type ChainEntry } from "./requires.ts";
 import { type SpecSnapshot } from "./regenerate.ts";
 import { type JobSteering } from "./steering.ts";
 import { type SpecStep } from "./spec-steps.ts";
-import { type JobCases, type TouchedSpec } from "./drift.ts";
+import { type JobCases } from "./drift.ts";
 /**
  * The work loop - see docs/regenerating.md.
  *
@@ -67,18 +68,18 @@ export interface ModuleStatus {
         steered?: string[];
     };
     /**
-     * The jobs planned after it, in order: the module's code jobs, then its conformance jobs. A conformance job scheduled
-     * for functional specs not all built yet - `waitsFor`, those that are not - comes after the module's last code job.
-     * The module's conformance tests, wanted for all of it while its code is still to build - `afterCode` - come last:
-     * they are planned into pulses only once the code is built, but are shown, so asking for them is seen to have worked.
+     * The jobs planned after it, in order: the module's code jobs, then its conformance jobs. The conformance tests of
+     * its functional specs with scenarios, behind while its code is still to build - `afterCode`, `specs` those
+     * functional specs as `module:func-id` - come last: they are planned into pulses only once the code is built, but are
+     * shown, so what follows the code is seen.
      */
     planned: Array<{
         title: string;
         cases: JobCases;
         track: Track;
-        waitsFor?: string[];
         planning?: true;
         afterCode?: true;
+        specs?: string[];
     }>;
     /**
      * What the plan of its code did not do as asked: the person's wishes its planner did not follow and why, an answer
@@ -87,19 +88,33 @@ export interface ModuleStatus {
     planNotes?: string[];
     /** Why nothing runs there, when nothing does. */
     why?: string;
-    /** What asking for conformance tests changed there, when it changed nothing: they were on for the whole module already. */
+    /** What asking for conformance tests changed there, when it changed nothing: they are written for what is built already. */
     conformanceNote?: string;
     /**
      * It now requires modules its code was not built on - `requires` - and is built only once its code is started
      * over on them: these codebases' code and tests taken out, kept in their history, and built again from the
-     * bottom of the chain. Never done unasked: `startOver` does it.
+     * bottom of the chain. Or - `old` - these codebases were built when functional specs were numbered, before they had
+     * func-ids: nothing is built on them, and the whole chain is regenerated from scratch. Never done unasked:
+     * `startOver` does it.
      */
     startOver?: {
         requires: string[];
         codebases: string[];
+        old?: true;
     };
     /** The stack it is built with - its config.turri.<stack>.yaml over config.turri.yaml - when one is. */
     stack?: string;
+    /** Pure renames turri makes once the running pulse ends - a func-id or a scenario-id, nothing else with it: nothing regenerated. */
+    renames?: string[];
+    /**
+     * The base folder its codebase started from (base-folder.ts): the folder as `base-folder:` named it, and how many of
+     * the files that came from it the codebase has still - carried up with the code to a module built on it. None when it
+     * started from none, or has no code yet.
+     */
+    base?: {
+        folder: string;
+        files: number;
+    };
 }
 /** What is left to regenerate in a codebase - see `WorkLoop.drift`. */
 export interface DriftReport {
@@ -109,11 +124,6 @@ export interface DriftReport {
     code: JobCases | null | undefined;
     /** The conformance tests' work: null, none; undefined, none are written here. */
     conformance: JobCases | null | undefined;
-    /** Conformance tests scheduled ahead of their code, and which of their functional specs are not built yet. */
-    scheduled: Array<{
-        frids: string[];
-        unbuilt: string[];
-    }>;
     running?: {
         jobId: string;
         title: string;
@@ -121,9 +131,23 @@ export interface DriftReport {
     /** Why nothing is regenerated there: halted, or its spec does not parse. */
     why?: string;
     startOver?: ModuleStatus["startOver"];
+    /** Pure renames not made yet - a func-id or a scenario-id, nothing else changed with it: made by turri, nothing regenerated. */
+    renames?: string[];
+    /** How its base folder stands against what its codebase started from, when they do not agree (base-folder.ts). */
+    baseFolder?: string;
+    /** conform named these functional specs, as `module:func-id`: the conformance tests are written for them alone until the module is asked for again. */
+    conformanceOnly?: string[];
+    /** Conformance tests are off here (`conformance-tests:`): none written or run. */
+    conformanceOff?: true;
 }
 /** What is left to regenerate, as the conversation and the command line read it. */
 export declare function describeDrift(reports: DriftReport[]): string;
+/** A codebase as the loop has just looked at it: its chain, its spec now, and what its code is built from (`codeTree` form). */
+export interface SeenSpec {
+    chain: ChainEntry[];
+    tree: MarshalledPlainSource;
+    built: MarshalledPlainSource;
+}
 export interface WorkLoop {
     /**
      * Bring a spec's module up to the spec as the .plain files have it now - in the codebases where its
@@ -138,12 +162,12 @@ export interface WorkLoop {
         specChange?: boolean;
     }): Promise<ModuleStatus[]>;
     /**
-     * Regenerate functional specs of a module again, their spec changed or not: each is marked to regenerate again in
+     * Regenerate functional specs of a module again, their spec changed or not - each named by its func-id: each is marked to regenerate again in
      * the record of every codebase it is built in - committed - and they are brought up to their spec, the marked ones
      * planned as any change is. Their code is there: the jobs that regenerate them are told to regenerate it again, not
      * to build it anew.
      */
-    regenerateAgain(plainFile: string, frids: string | string[], options?: {
+    regenerateAgain(plainFile: string, funcIds: string | string[], options?: {
         model?: string;
         guidance?: string;
     }): Promise<ModuleStatus[]>;
@@ -158,10 +182,9 @@ export interface WorkLoop {
      * again, it clears a halt. Says what it planned.
      */
     conformance(plainFile: string, options?: {
-        frids?: string[];
+        funcIds?: string[];
         model?: string;
         separately?: boolean;
-        groups?: string[][];
     }): Promise<ModuleStatus[]>;
     /**
      * Start over the codebases of a spec's module that now require a module their code was not built on (see
@@ -229,8 +252,8 @@ export interface MapPulse {
     before: string;
     after: string;
     /**
-     * A conformance pulse scheduled ahead of its code - not planned, so with no trees: the texts of the functional specs
-     * it writes tests for.
+     * The conformance tests that follow the code still to build - not planned, so with no trees: the functional specs they
+     * are written for, each as `module:func-id`.
      */
     specs?: string[];
 }
@@ -245,11 +268,11 @@ export interface MapCodebase {
     planning?: Track;
     /** The module below it that it waits for. */
     waitsFor?: string;
-    /** Its conformance tests are on: by the config, or asked for this session. */
+    /** Whether any of its functional specs has scenarios, and so conformance tests. */
     conformance: boolean;
     /** Why nothing runs there, when nothing does. */
     why?: string;
-    /** What asking for conformance tests changed there, when it changed nothing: they were on for the whole module already. */
+    /** What asking for conformance tests changed there, when it changed nothing: they are written for what is built already. */
     conformanceNote?: string;
     /**
      * Halted, or the planner found no plan: it needs the person. `pulse`, the pulse that did not land; `cause`, what went
@@ -279,11 +302,13 @@ export interface ModuleCompletion {
     specified: number;
     /** Of those, the ones the delivered codebase's code record has as the spec has them now. */
     completed: number;
-    /** Of the completed ones, those its conformance tests are recorded as written for, as the spec has them now. */
+    /** Its own functional specs with scenarios: those that are tested - one with no test plain file is not. */
+    withScenarios: number;
+    /** Of the completed ones, those its conformance tests are recorded as written for, as the spec has them now - their scenarios too. */
     conformanceTested: number;
-    /** Those conformance-tested ones, by number: for a host that shows each functional spec's state. */
+    /** Those conformance-tested ones, by func-id: for a host that shows each functional spec's state. */
     tested: string[];
-    /** Its functional specs not completed, by number. */
+    /** Its functional specs not completed, by func-id. */
     incomplete: string[];
 }
 /**
@@ -313,25 +338,6 @@ export declare function createWorkLoop(options: {
     run?: JobRunner;
     /** Writes and runs a conformance job's tests. Default: a spec diff's conformance run, the whole suite with it. */
     runConformance?: JobRunner;
-    /** Whether the config has a module's conformance tests on. Default: its `conformance-tests:`, off unless it turns them on. */
-    conformanceOn?: (plainFile: string) => boolean;
-    /**
-     * Whether a module's conformance tests are for the functional specs chosen, not every one: those with acceptance
-     * tests, those the conversation asked for, and those tested already. Default: `conformance-tests: chosen`.
-     */
-    conformanceChosen?: (plainFile: string) => boolean;
-    /**
-     * Under `conformance-tests: chosen`, asked what a code job that landed built or changed that no conformance test is
-     * for - by whoever chooses without a conversation (`turri regenerate`) - before the job ends: the functional specs it
-     * names are scheduled as conform schedules them. The conversation is told in the job's report instead.
-     */
-    onChoose?: (plainFile: string, specs: TouchedSpec[], budget: number | undefined, when: "pulse" | "module") => Promise<{
-        frids: string[];
-        groups?: string[][];
-        why?: string;
-    } | undefined>;
-    /** When the chooser is asked: after each code pulse, once the module is regenerated, or never. Default: `conformance-tests:`. */
-    conformanceChoosing?: (plainFile: string) => "pulse" | "module" | undefined;
     /**
      * Under `release-after-pulse: true`, what releases a pulse that landed, as its last stage - before the pulse ends, so
      * the module's next pulse starts on what is released. Its last reply goes in the pulse's report. Not given: nothing is.
@@ -344,9 +350,22 @@ export declare function createWorkLoop(options: {
     }) => Promise<string>;
     /** Plan, and keep the job each codebase would start (`firsts`) - but start none. */
     dryRun?: boolean;
+    /**
+     * Told each time the loop looks at a codebase whose spec parses: its chain, the spec as the .plain files have it now,
+     * and what its code is built from - what the test advisor watches (advisor-runs.ts). Nothing it does is the loop's
+     * concern: one that throws is ignored.
+     */
+    onSpec?: (seen: SeenSpec) => void;
 }): WorkLoop;
 /** Why nothing runs in a codebase whose code - and conformance tests, where they are wanted - is built from its spec as it is. */
 export declare const UP_TO_DATE = "built from the ***plain as it is";
+/** Functional specs as a person names them: `module:func-id`, each. */
+export declare function namesOf(module: string, funcIds: string[]): string;
+/**
+ * The func-ids a person names in a module, each as `module:func-id` - a bare func-id, or another module's, is refused:
+ * a func-id is unique in its module only.
+ */
+export declare function funcIdsNamed(module: string, names: string[]): string[];
 /** The codebases the loop looks after, as the person reads them: what runs, what is planned after it, and why nothing does. */
 /**
  * The coding agent's task for a dry run's first job, built as the render builds it - and all it did rolled back. Not for