@turri-dev/cli 0.1.4 → 0.1.5-next.6df6879

package/README.md

@@ -160,7 +160,7 @@ It runs the interview skill, asks you about the problem, the stack and the produ
 - **`/halt`** halts a pulse, **`/lineage`** shows every generation of a module, and the **`drift`** tool says what is left to regenerate;
 - **`/btw <question>`** asks turri something on the side - answered at once, even in the middle of a skill's interview (typed as the answer, under "Something else…"), and left out of the conversation;
 - **`/turri-config`** changes any setting of the project's `config.turri.yaml` - the models, review, conformance tests, how many pulses at once - and says when it takes effect: now, at your next message, or at the next pulse. No restart: `/turri-config review false`, or `/turri-config` alone to pick from the list;
-- **`/stack`** chooses the stack to build with, in a project whose backend and frontend each have their own testing scripts in `config.turri.<stack>.yaml` - `/stack backend`, `/stack none` - for the session (`--stack <name>` on the command line).
+- **`/stack`** chooses the stack to build with, in a project whose backend and frontend each have their own testing scripts in `config.turri.<stack>.yaml` - `/stack backend`, `/stack none` - for the session (`--stack <name>` on the command line). The chat's model builds each part with its own stack by itself, pinned to that module's pulses.
 
 Other things to ask for:
 

package/dist/config.js

@@ -157,6 +157,23 @@ export function chooseStack(stack) {
 export function withStack(stack, work) {
     return pinnedStack.run({ stack }, work);
 }
+/** The words that choose no stack: the project's config alone. */
+export const NO_STACK = ["none", "off", "base", "-"];
+/**
+ * The stack `name` names for the project at `root` - undefined for none - refused when the project has no file for
+ * it, with the stacks it has.
+ */
+export function stackNamed(root, name) {
+    const wanted = name.trim();
+    if (wanted === "" || NO_STACK.includes(wanted.toLowerCase()))
+        return undefined;
+    const stacks = stacksOf(root);
+    if (stacks.includes(wanted))
+        return wanted;
+    throw new Error(stacks.length > 0
+        ? `There is no stack ${wanted} in ${root}. Its stacks: ${stacks.join(", ")} - or none.`
+        : `${root} has no stacks: a stack is a ${stackConfigFile("<stack>")} beside config.turri.yaml.`);
+}
 /** The stack a project folder is built with now: the one chosen, when the folder has a file for it. */
 export function stackOf(root) {
     const stack = chosenStack();

package/dist/extension.js

@@ -16,7 +16,7 @@ import { readScript, scriptAgainstMachine, stackOnMachine, toolchainsBlock } fro
 import { sandboxAvailable, sandboxSummary } from "./regenerate/os-sandbox.js";
 import { findTestScripts } from "./regenerate/test-scripts.js";
 import { createAskUserTool } from "./tools.js";
-import { asksFromScratch, asksWholeChain, driftTool, fromWorkingDir, haltTool, loopReply, MODEL_PARAM, regenerateTool, stopJob, WAIT_PARAM, WORKING_DIR_PARAM } from "./loop-tools.js";
+import { asksFromScratch, asksWholeChain, driftTool, fromWorkingDir, haltTool, loopReply, MODEL_PARAM, regenerateTool, STACK_PARAM, stopJob, WAIT_PARAM, withCallStack, WORKING_DIR_PARAM } from "./loop-tools.js";
 import { createWebTools } from "./regenerate/web.js";
 import { describeGates, interruptedRun, runSkill } from "./genome.js";
 import { skillStatus } from "./skill.js";
@@ -694,11 +694,12 @@ function registerRegenerate(pi, cwd, jobs) {
                     : `Planning ${module}'s pulses…`, "info");
             await nextFrame();
             try {
-                const statuses = scratch
-                    ? await loop.fromScratch(plainFile, { ...request, chain })
+                // Built with the stack chosen now - pinned to its pulses - or refused, a project of stacks built with none.
+                const statuses = await withCallStack(plainFile, undefined, () => scratch
+                    ? loop.fromScratch(plainFile, { ...request, chain })
                     : again.length > 0
-                        ? await loop.regenerateAgain(plainFile, again, request)
-                        : await loop.bringUp(plainFile, request);
+                        ? loop.regenerateAgain(plainFile, again, request)
+                        : loop.bringUp(plainFile, request));
                 // Nothing to do: say how to build it again anyway.
                 const hint = statuses.length > 0 && statuses.every(isUpToDate)
                     ? `\nTo regenerate parts of it anyway, name their functionalities - /regenerate ${basename(plainFile)} 2.1 - or start over with /regenerate ${basename(plainFile)} from scratch.`
@@ -817,21 +818,24 @@ function conformTool(options) {
                 description: "Only when the user asks for them in pulses of their own grouping: the functional specs by id, a list a pulse - [[\"1\",\"2\",\"3\"],[\"4\",\"5\",\"6\"]]. Each is tested in a pulse of its own; they are added to those chosen, as frids are",
             })),
             one_by_one: Type.Optional(Type.Boolean({ description: "Only when the user asks for it: a pulse a functional spec. Omitted: every functional spec tested in one pulse, as far as the size guardrail lets" })),
+            stack: STACK_PARAM,
             model: MODEL_PARAM,
             wait: WAIT_PARAM,
         }),
         async execute(_id, given, _signal, _onUpdate, ctx) {
             const params = fromWorkingDir(cwd, given);
             const plainFile = resolve(params.base, params.plain_file);
-            const model = options.model(ctx, plainFile, params.model);
-            const loop = options.loop(ctx);
-            const statuses = await loop.conformance(plainFile, {
-                ...(params.frids !== undefined ? { frids: params.frids } : {}),
-                ...(params.groups !== undefined ? { groups: params.groups } : {}),
-                ...(model !== undefined ? { model } : {}),
-                ...(params.one_by_one === true ? { separately: true } : {}),
+            return withCallStack(plainFile, params.stack, async () => {
+                const model = options.model(ctx, plainFile, params.model);
+                const loop = options.loop(ctx);
+                const statuses = await loop.conformance(plainFile, {
+                    ...(params.frids !== undefined ? { frids: params.frids } : {}),
+                    ...(params.groups !== undefined ? { groups: params.groups } : {}),
+                    ...(model !== undefined ? { model } : {}),
+                    ...(params.one_by_one === true ? { separately: true } : {}),
+                });
+                return loopReply(loop, statuses, options.wait(ctx, params.wait));
             });
-            return loopReply(loop, statuses, options.wait(ctx, params.wait));
         },
     });
 }
@@ -849,34 +853,37 @@ function registerGlimpse(pi, cwd, jobs) {
         parameters: Type.Object({
             plain_file: Type.String({ description: "Path to the .plain file" }),
             working_dir: WORKING_DIR_PARAM,
+            stack: STACK_PARAM,
         }),
         async execute(_id, given, _signal, _onUpdate, ctx) {
             const params = fromWorkingDir(cwd, given);
             const plainFile = resolve(params.base, params.plain_file);
-            const running = new Set(workLoopFor(jobs, cwd, ctx).status().filter((status) => status.running !== undefined).map((status) => status.module));
-            const planner = chatModelOf(ctx);
-            const model = modelFor(chosenModels, "spec_changes", projectModel(ctx, plainFile) ?? planner);
-            const { statuses, previews, busy } = await previewJobs({
-                plainFile,
-                cwd,
-                ...(model !== undefined ? { model } : {}),
-                ...(planner !== undefined ? { plannerModel: planner } : {}),
-                steering: (file) => steeringFor(file, cwd, steeringStore),
-                busy: (module) => running.has(module),
-            });
-            const text = [
-                describeModules(statuses),
-                ...busy.map((module) => `\n${module} has a pulse running: its next pulse is planned from what that one lands - preview it once it has.`),
-                ...previews.map((preview) => [
+            return withCallStack(plainFile, params.stack, async () => {
+                const running = new Set(workLoopFor(jobs, cwd, ctx).status().filter((status) => status.running !== undefined).map((status) => status.module));
+                const planner = chatModelOf(ctx);
+                const model = modelFor(chosenModels, "spec_changes", projectModel(ctx, plainFile) ?? planner);
+                const { statuses, previews, busy } = await previewJobs({
+                    plainFile,
+                    cwd,
+                    ...(model !== undefined ? { model } : {}),
+                    ...(planner !== undefined ? { plannerModel: planner } : {}),
+                    steering: (file) => steeringFor(file, cwd, steeringStore),
+                    busy: (module) => running.has(module),
+                });
+                const text = [
+                    describeModules(statuses),
+                    ...busy.map((module) => `\n${module} has a pulse running: its next pulse is planned from what that one lands - preview it once it has.`),
+                    ...previews.map((preview) => [
+                        "",
+                        `<next pulse module="${preview.module}" track="${preview.track}" title="${preview.title}">`,
+                        preview.task ?? "A conformance pulse's prompt is built from what the code it tests holds once it is built: it is not shown before.",
+                        "</next pulse>",
+                    ].join("\n")),
                     "",
-                    `<next pulse module="${preview.module}" track="${preview.track}" title="${preview.title}">`,
-                    preview.task ?? "A conformance pulse's prompt is built from what the code it tests holds once it is built: it is not shown before.",
-                    "</next pulse>",
-                ].join("\n")),
-                "",
-                "Nothing was started. Tell the user what the next pulse is and what it will be told - the parts they are likely to care about, not the whole prompt unless they ask.",
-            ].join("\n");
-            return { content: [{ type: "text", text }], details: {} };
+                    "Nothing was started. Tell the user what the next pulse is and what it will be told - the parts they are likely to care about, not the whole prompt unless they ask.",
+                ].join("\n");
+                return { content: [{ type: "text", text }], details: {} };
+            });
         },
     });
 }
@@ -1034,7 +1041,7 @@ export function projectConfigBlock(root) {
         return [
             ...settings(readProjectConfig(dir), withStack(undefined, () => findTestScripts(dir)), dir === root ? `${projectConfigFile(dir)}, for the specs here:` : `${relative(root, dir)}/${projectConfigFile(dir)}, for the specs in ${relative(root, dir)}/ - built in ${relative(root, dir)}/plain_modules:`, where, stacks.length > 0 ? "project of stacks" : "project"),
             ...(stacks.length > 0
-                ? ["", `Stacks: ${stacks.join(", ")} - chosen now: ${chosen ?? "none, so the project's file alone"}. Everything is built with the chosen one; switch with the stack tool when the user asks.`]
+                ? ["", `Stacks: ${stacks.join(", ")} - chosen now: ${chosen ?? "none, so the project's file alone"}. Each module is built with the stack of its part - a backend's spec with the backend stack: pass it as stack to regenerate, conform and glimpse, and it is pinned to that module's pulses, whatever is chosen after. Choose one for the whole session with the stack tool when the user asks.`]
                 : []),
             // A stack: its file over the project's, for everything built while it is chosen.
             ...stacks.flatMap((stack) => [

package/dist/loop-tools.js

@@ -1,12 +1,14 @@
 import { existsSync } from "node:fs";
-import { relative, resolve } from "node:path";
+import { basename, relative, resolve } from "node:path";
 import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-import { CONFIG_FILE, readProjectConfig } from "./config.js";
+import { chosenStack, CONFIG_FILE, readProjectConfig, stackConfigFile, stackNamed, stackOf, stacksOf, withStack } from "./config.js";
 import { checkPlainFile } from "./plain/check.js";
 import { describeDrift, describeModules } from "./regenerate/loop.js";
 import { pulseName } from "./regenerate/jobs.js";
 import { stopDeployed } from "./regenerate/release.js";
+import { projectDirOf } from "./regenerate/paths.js";
+import { findTestScripts } from "./regenerate/test-scripts.js";
 /** How the queue is to be planned, for the work this call queues - see regenerate/steer.ts. */
 export const GUIDANCE_PARAM = Type.Optional(Type.String({
     description: "How to plan the queue for this work, in a sentence or two - which functional specs go together, what first - as " +
@@ -23,6 +25,33 @@ export const MODEL_PARAM = Type.Optional(Type.String({
         "Omitted: the model chosen for this kind of work with engine, else the conversation's. " +
         "To change it for every later render, use engine instead.",
 }));
+export const STACK_PARAM = Type.Optional(Type.String({
+    description: "In a project of stacks: the stack that builds this module - its config.turri.<stack>.yaml over config.turri.yaml, " +
+        "its testing scripts, toolchains and models - for every pulse of it, whatever stack is chosen later. \"none\": " +
+        "config.turri.yaml alone. Omitted: the stack chosen now.",
+}));
+/**
+ * `work` with the stack a call names - or, none named, the one chosen now - chosen for it: what it asks for is built with
+ * that stack. A project of stacks that would be built with none, when config.turri.yaml alone names no unit testing
+ * script, is refused before anything is planned: its pulses would all stop for want of one.
+ */
+export function withCallStack(plainFile, named, work) {
+    const root = projectDirOf(plainFile);
+    const stack = named !== undefined ? stackNamed(root, named) : chosenStack();
+    return withStack(stack, () => {
+        const stacks = stacksOf(root);
+        if (named === undefined && stackOf(root) === undefined && stacks.length > 0 && findTestScripts(root).unit === undefined) {
+            const scripts = stacks.map((each) => {
+                const unit = withStack(each, () => findTestScripts(root).unit);
+                return `${each}${unit !== undefined ? ` (${stackConfigFile(each)}: ${relative(root, unit)})` : ""}`;
+            });
+            throw new Error(`Nothing was started: ${basename(plainFile)} would be built with no stack - ${CONFIG_FILE} alone - and that names no unit testing ` +
+                `script, so every pulse would stop. The project's stacks: ${scripts.join(", ")}. Pass the stack that builds ` +
+                `${basename(plainFile)} as stack - or ask the user which, when the spec does not make it plain.`);
+        }
+        return work();
+    });
+}
 export const WAIT_PARAM = Type.Optional(Type.Boolean({
     description: "Block until the work finishes instead of returning a pulse id. Defaults to false in the " +
         "interactive TUI and true elsewhere, where a pulse would not outlive the turn.",
@@ -135,6 +164,7 @@ export function regenerateTool(options) {
             "A change to a file the spec links - an API surface, a mapping document - is a change to the spec: regenerate sees it by itself, and regenerates every functional spec that uses what links it.",
             "Never stop pulses and start them again yourself to follow a spec change: regenerate does it.",
             "Set from_scratch only when the user asks for the module to be regenerated from scratch - started over, its code deleted - in this conversation, or agrees to it when a module's status says it has to start over: never to fix a pulse that did not land.",
+            "In a project of stacks - a backend and a frontend, each with its config.turri.<stack>.yaml - pass stack: the one that builds this module's part, the backend's spec with the backend stack. It is pinned to the module's pulses: regenerate a backend and a frontend side by side, each with its own, without switching the stack chosen. What it says back names the stack each module is built with.",
             'from_scratch "module" takes out the code where the module is built; the modules below keep theirs, and the module starts from a copy of the code below it. "chain" takes out every codebase of its requires chain, the base\'s too, and builds all of it again from the bottom: use it after modules were split, merged or moved (refactor-module), or when the user asks for the whole chain.',
         ],
         parameters: Type.Object({
@@ -148,28 +178,31 @@ export function regenerateTool(options) {
                 description: "Only when the user asks for it: the module's code and conformance tests deleted - committed first, so its lineage keeps them - and the whole module regenerated from its spec. " +
                     '"chain": every module of its requires chain too, built again from the bottom',
             })),
+            stack: STACK_PARAM,
             model: MODEL_PARAM,
             wait: WAIT_PARAM,
         }),
         async execute(_id, given, _signal, _onUpdate, ctx) {
             const plainFile = plainFileOf(options.cwd, given, "regenerate");
-            const check = checkPlainFile(plainFile);
-            if (!check.ok)
-                throw new Error(`${relative(options.cwd, plainFile) || plainFile} does not parse, so nothing can be regenerated from it yet: ${check.error}`);
-            const again = given.functionalities ?? [];
-            if (again.length > 0 && given.from_scratch !== undefined)
-                throw new Error("Name functionalities or set from_scratch, not both: from scratch regenerates every one of them.");
-            // Named functionalities are work on functionalities, as engine chooses a model for it; the rest, spec changes.
-            const work = again.length > 0 ? "functionalities" : "spec_changes";
-            const model = options.model !== undefined ? options.model(ctx, plainFile, given.model, work) : given.model;
-            const loop = options.loop(ctx);
-            const request = { ...(model !== undefined ? { model } : {}), ...(given.guidance !== undefined ? { guidance: given.guidance } : {}) };
-            const statuses = given.from_scratch !== undefined
-                ? await loop.fromScratch(plainFile, { ...request, chain: given.from_scratch === "chain" })
-                : again.length > 0
-                    ? await loop.regenerateAgain(plainFile, again, request)
-                    : await loop.bringUp(plainFile, request);
-            return loopReply(loop, statuses, options.wait !== undefined ? options.wait(ctx, given.wait) : given.wait === true);
+            return withCallStack(plainFile, given.stack, async () => {
+                const check = checkPlainFile(plainFile);
+                if (!check.ok)
+                    throw new Error(`${relative(options.cwd, plainFile) || plainFile} does not parse, so nothing can be regenerated from it yet: ${check.error}`);
+                const again = given.functionalities ?? [];
+                if (again.length > 0 && given.from_scratch !== undefined)
+                    throw new Error("Name functionalities or set from_scratch, not both: from scratch regenerates every one of them.");
+                // Named functionalities are work on functionalities, as engine chooses a model for it; the rest, spec changes.
+                const work = again.length > 0 ? "functionalities" : "spec_changes";
+                const model = options.model !== undefined ? options.model(ctx, plainFile, given.model, work) : given.model;
+                const loop = options.loop(ctx);
+                const request = { ...(model !== undefined ? { model } : {}), ...(given.guidance !== undefined ? { guidance: given.guidance } : {}) };
+                const statuses = given.from_scratch !== undefined
+                    ? await loop.fromScratch(plainFile, { ...request, chain: given.from_scratch === "chain" })
+                    : again.length > 0
+                        ? await loop.regenerateAgain(plainFile, again, request)
+                        : await loop.bringUp(plainFile, request);
+                return loopReply(loop, statuses, options.wait !== undefined ? options.wait(ctx, given.wait) : given.wait === true);
+            });
         },
     });
 }

package/dist/regenerate/jobs.js

@@ -52,6 +52,9 @@ export function createJobRegistry(options) {
         },
         start(input) {
             const id = randomUUID().slice(0, 8);
+            // The stack chosen as it is queued - or pinned for the work that queues it - not as it starts: a job that waits
+            // for a slot is built with the stack it was asked for, whatever is chosen meanwhile.
+            const stack = chosenStack();
             const claimed = [...new Set(input.lanes ?? [])];
             const blockers = [
                 ...new Set(claimed
@@ -70,6 +73,7 @@ export function createJobRegistry(options) {
                 ...(input.title !== undefined ? { title: input.title } : {}),
                 diff: input.diff,
                 model: input.model,
+                ...(stack !== undefined ? { stack } : {}),
                 ...(input.follows !== undefined ? { follows: input.follows } : {}),
                 status: blockers.length > 0 || (limit !== undefined && active >= limit) ? "queued" : "running",
                 sequence: (sequence += 1),
@@ -273,9 +277,9 @@ export function createJobRegistry(options) {
                 log = startJobLog(job, claimed);
                 if (log !== undefined)
                     job.logFile = log.file;
-                // What the job's agents start runs until it ends, and no longer (withPulse) - with the stack chosen as it
-                // starts, whatever is chosen while it runs.
-                return withStack(chosenStack(), () => (guarded ? runGuarded() : runOnce()));
+                // What the job's agents start runs until it ends, and no longer (withPulse) - with the stack it was queued
+                // with, whatever is chosen while it waits or runs.
+                return withStack(stack, () => (guarded ? runGuarded() : runOnce()));
             })
                 .then((outcome) => {
                 // Asked to stop, it is stopped - whether its work threw as it unwound or returned what it had.
@@ -385,10 +389,11 @@ export function pulseName(job) {
 }
 /** What the agent is told when it checks on a job. */
 export function describeJob(job) {
+    const name = `${pulseName(job)}${job.stack !== undefined ? ` (stack ${job.stack})` : ""}`;
     if (job.status === "queued") {
-        return `${pulseName(job)}: queued behind ${job.waitingOn.map((id) => `pulse ${id}`).join(" and ")}. It starts when that finishes.`;
+        return `${name}: queued behind ${job.waitingOn.map((id) => `pulse ${id}`).join(" and ")}. It starts when that finishes.`;
     }
-    const header = `${pulseName(job)}: ${job.status}, ${formatDuration(job)}`;
+    const header = `${name}: ${job.status}, ${formatDuration(job)}`;
     if (job.status === "running") {
         return [
             header,

package/dist/regenerate/loop.js

@@ -13,7 +13,7 @@ import { adoptDigests, chainTree, codeTree, conformanceTarget, REGENERATE_AGAIN,
 import { describeSpecDiffConformance, renderSpecDiffConformance } from "./conform.js";
 import { conformanceDirFor } from "./conformance.js";
 import { modulesRoot } from "./paths.js";
-import { budgetFor, choosingWhen, configForSpec, conformanceSwitchedOn } from "../config.js";
+import { budgetFor, chosenStack, choosingWhen, configForSpec, conformanceSwitchedOn, withStack } from "../config.js";
 import { describeSpecChange } from "./prompt.js";
 import { resolveTemplateDirs } from "./paths.js";
 import { builtTips, copyRequiredCode, importingModules, isImportModule, newlyRequired, resolveRequiresChain, startFromScratch } from "./requires.js";
@@ -189,6 +189,8 @@ export function createWorkLoop(options) {
     // One tick at a time: each reads the records and the spec, and decides.
     let ticking = Promise.resolve();
     const tipEntry = (state) => tipOf(state.chain);
+    /** `work` with the codebase's stack chosen - the one it was asked for with - when it has one pinned. */
+    const inStack = (state, work) => (state.stack !== undefined ? withStack(state.stack.name, work) : work());
     const keyOf = (spec) => serializeTree(codeTree(spec.tree));
     /** What a codebase is built from: its record, or - nothing built - what it starts from, the code of the module it requires. */
     const builtOf = (state) => {
@@ -811,7 +813,7 @@ export function createWorkLoop(options) {
             // A codebase left behind - built on since - is not looked at, unless a job of it is still running; what it had
             // planned, or waited for, is no longer shown.
             if (now.has(state) || state.running !== undefined)
-                await look(state);
+                await inStack(state, () => look(state));
             else {
                 state.why = "left behind: the code is built on further up the chain, where changes to it are made";
                 state.waitsFor = undefined;
@@ -963,7 +965,8 @@ export function createWorkLoop(options) {
     };
     const statusOf = (state) => describe(state).status;
     /** A codebase's status, and beside each job it lists as planned, the planned job it is - none for one being planned or scheduled. */
-    const describe = (state) => {
+    const describe = (state) => inStack(state, () => describeIn(state));
+    const describeIn = (state) => {
         // What runs next: the code's jobs, then the conformance tests' - the module's, once its code is built - the running job first.
         const running = state.running?.planned;
         const own = (jobs) => (jobs ?? []).filter((job) => job !== running);
@@ -1011,6 +1014,7 @@ export function createWorkLoop(options) {
         const status = {
             module: tip.moduleName,
             plainFile: tip.plainFile,
+            ...(state.stack?.name !== undefined ? { stack: state.stack.name } : {}),
             ...(state.running !== undefined
                 ? {
                     running: {
@@ -1027,8 +1031,11 @@ export function createWorkLoop(options) {
         };
         return { status, jobs: (state.running !== undefined ? listed.slice(1) : listed).map((item) => item.job), scheduled: (state.running !== undefined ? listed.slice(1) : listed).map((item) => (item.entry.waitsFor !== undefined ? { title: item.entry.title, specs: item.entry.cases.add.map((touched) => touched.text) } : undefined)) };
     };
-    /** Look after a codebase - its chain up to it - from now on; says its state. */
-    const track = (chain, askedFile, request) => {
+    /**
+     * Look after a codebase - its chain up to it - from now on; says its state. `pin`: the stack it is built with from now
+     * on - kept, when `keep` and it has one already.
+     */
+    const track = (chain, askedFile, request, pin) => {
         const tip = tipOf(chain);
         let state = modules.get(tip.buildDir);
         if (state === undefined) {
@@ -1043,7 +1050,10 @@ export function createWorkLoop(options) {
         }
         state.chain = chain;
         state.askedFile = askedFile;
-        const model = request.model ?? options.modelFor?.(tip.plainFile);
+        if (pin !== undefined && (pin.keep !== true || state.stack === undefined))
+            state.stack = { name: pin.name };
+        // Its model as its stack has it: a stack's file can name a coding model of its own.
+        const model = request.model ?? inStack(state, () => options.modelFor?.(tip.plainFile));
         if (model !== undefined)
             state.model = model;
         if (request.guidance !== undefined && !state.guidance.includes(request.guidance))
@@ -1056,7 +1066,10 @@ export function createWorkLoop(options) {
             const files = codebasesOf(resolve(options.cwd, plainFile));
             for (const file of files)
                 asked.set(file, { ...asked.get(file), ...request });
-            const states = withParseCache(() => files.flatMap((file) => chainsFor(file).flatMap((chain) => toBuild(chain).map((entry) => track(chain.slice(0, chain.indexOf(entry) + 1), file, request)))));
+            // Asked for, it is built with the stack chosen now - pinned, whatever is chosen later; a spec change keeps the one
+            // it was asked for with.
+            const pin = { name: chosenStack(), keep: specChange === true };
+            const states = withParseCache(() => files.flatMap((file) => chainsFor(file).flatMap((chain) => toBuild(chain).map((entry) => track(chain.slice(0, chain.indexOf(entry) + 1), file, request, pin)))));
             // Asked again, a halted codebase is tried again - one the person halted too, unless only its spec changed.
             for (const state of states) {
                 state.halted = undefined;
@@ -1110,32 +1123,34 @@ export function createWorkLoop(options) {
                 const tip = tipOf(codebase);
                 // The codebase as the loop knows it, or - never asked for - as its records have it.
                 const state = modules.get(tip.buildDir) ?? { chain: codebase, askedFile: file, guidance: [] };
-                const report = { module: tip.moduleName, plainFile: tip.plainFile, code: undefined, conformance: undefined, scheduled: [] };
-                let spec;
-                try {
-                    spec = chainSpec(codebase);
-                }
-                catch (error) {
-                    return { ...report, why: `its spec does not parse: ${error instanceof Error ? error.message : String(error)}` };
-                }
-                const from = builtOf(state);
-                const fresh = tip.requires === null && !started(tip);
-                const code = codeWork(from, spec.tree);
-                report.code = code.length === 0 ? null : casesOf(from, code, { fresh, module: tip.moduleName });
-                if (conformanceWanted(state, spec)) {
-                    const tested = testedOf(state);
-                    const tests = workOf("conformance", tested, state, spec);
-                    report.conformance = tests.length === 0 ? null : casesOf(tested, tests, { module: tip.moduleName });
-                }
-                report.scheduled = (state.scheduled ?? []).map((group) => ({ frids: group.specs.map((touched) => touched.frid), unbuilt: group.unbuilt }));
-                if (state.running !== undefined)
-                    report.running = { jobId: state.running.jobId, title: state.running.planned.title };
-                const halted = state.held?.why ?? state.halted?.why ?? state.conformanceHalted?.why;
-                if (halted !== undefined)
-                    report.why = halted;
-                if (state.startOver !== undefined)
-                    report.startOver = state.startOver;
-                return report;
+                return inStack(state, () => {
+                    const report = { module: tip.moduleName, plainFile: tip.plainFile, code: undefined, conformance: undefined, scheduled: [] };
+                    let spec;
+                    try {
+                        spec = chainSpec(codebase);
+                    }
+                    catch (error) {
+                        return { ...report, why: `its spec does not parse: ${error instanceof Error ? error.message : String(error)}` };
+                    }
+                    const from = builtOf(state);
+                    const fresh = tip.requires === null && !started(tip);
+                    const code = codeWork(from, spec.tree);
+                    report.code = code.length === 0 ? null : casesOf(from, code, { fresh, module: tip.moduleName });
+                    if (conformanceWanted(state, spec)) {
+                        const tested = testedOf(state);
+                        const tests = workOf("conformance", tested, state, spec);
+                        report.conformance = tests.length === 0 ? null : casesOf(tested, tests, { module: tip.moduleName });
+                    }
+                    report.scheduled = (state.scheduled ?? []).map((group) => ({ frids: group.specs.map((touched) => touched.frid), unbuilt: group.unbuilt }));
+                    if (state.running !== undefined)
+                        report.running = { jobId: state.running.jobId, title: state.running.planned.title };
+                    const halted = state.held?.why ?? state.halted?.why ?? state.conformanceHalted?.why;
+                    if (halted !== undefined)
+                        report.why = halted;
+                    if (state.startOver !== undefined)
+                        report.startOver = state.startOver;
+                    return report;
+                });
             })));
         },
         async conformance(plainFile, request = {}) {
@@ -1176,7 +1191,7 @@ export function createWorkLoop(options) {
                     }
                 }
             }
-            const tracked = withParseCache(() => (wentBack ? [own] : chainsFor(file)).flatMap((chain) => toBuild(chain).map((entry) => track(chain.slice(0, chain.indexOf(entry) + 1), file, request))));
+            const tracked = withParseCache(() => (wentBack ? [own] : chainsFor(file)).flatMap((chain) => toBuild(chain).map((entry) => track(chain.slice(0, chain.indexOf(entry) + 1), file, request, { name: chosenStack() }))));
             // The module asked for, in its own codebase - and those below it: never the codebases built on it.
             const asking = tracked.find((state) => tipEntry(state).buildDir === self.buildDir);
             const states = asking !== undefined ? tracked.filter((state) => own.some((entry) => entry.buildDir === tipEntry(state).buildDir)) : tracked;
@@ -1194,7 +1209,7 @@ export function createWorkLoop(options) {
             // On for the whole module already - asked for before, or by the config: asked again, nothing changes, and it is said.
             const already = new Set(states.filter((state) => {
                 const file = tipEntry(state).plainFile;
-                return (state.conformance !== undefined && state.conformance.chosen === undefined) || (configConformance(file) && !configChosen(file));
+                return (state.conformance !== undefined && state.conformance.chosen === undefined) || inStack(state, () => configConformance(file) && !configChosen(file));
             }));
             // Only the module asked for: the modules below it keep their conformance tests as their config and choices have them.
             for (const state of tip !== undefined ? [tip] : []) {
@@ -1402,7 +1417,7 @@ export function createWorkLoop(options) {
                         plainFile: tip.plainFile,
                         buildDir: tip.buildDir,
                         pulses,
-                        conformance: state.conformance !== undefined || configConformance(tip.plainFile),
+                        conformance: state.conformance !== undefined || inStack(state, () => configConformance(tip.plainFile)),
                         ...(state.planning !== undefined ? { planning: state.planning } : {}),
                         ...(running === undefined && state.waitsFor !== undefined ? { waitsFor: state.waitsFor } : {}),
                         ...(running === undefined && state.why !== undefined ? { why: state.why } : {}),
@@ -1413,7 +1428,11 @@ export function createWorkLoop(options) {
         },
         async drain() {
             for (;;) {
-                await ticking;
+                // A pulse that settles meanwhile ticks again: its next pulse is started by that tick, so it is waited for too.
+                const looking = ticking;
+                await looking;
+                if (looking !== ticking)
+                    continue;
                 const running = order.map((key) => modules.get(key).running?.jobId).filter((id) => id !== undefined);
                 if (running.length === 0)
                     return;
@@ -1530,7 +1549,7 @@ export function describeModules(statuses, options = {}) {
         // Nothing to do there: said in a sentence, not as a status.
         if (isUpToDate(status))
             return `${status.module} is up to date: its code is built from the spec as it is now in ${basename(status.plainFile)}, so there is nothing to regenerate.`;
-        const lines = [`${status.module} (${basename(status.plainFile)}):`];
+        const lines = [`${status.module} (${basename(status.plainFile)}${status.stack !== undefined ? `, stack ${status.stack}` : ""}):`];
         if (status.running !== undefined) {
             lines.push(`  running: pulse ${status.running.jobId} - ${status.running.title}`);
             // Steered, not stopped or planned again: what changed went to its agent.

package/dist/regenerate/test-scripts.js

@@ -2,7 +2,7 @@ import { fixMethod } from "./prompt.js";
 import { randomUUID } from "node:crypto";
 import { accessSync, constants, copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { basename, delimiter, dirname, join, resolve, sep } from "node:path";
-import { CONFIG_FILE, CONFIG_KEYS, projectConfigFile, readProjectConfig, stackConfigFileIn, stackOf } from "../config.js";
+import { CONFIG_FILE, CONFIG_KEYS, projectConfigFile, readProjectConfig, stackConfigFile, stackConfigFileIn, stackOf, stacksOf } from "../config.js";
 import { reportActivity, reportLogNote, reportNote } from "./activity.js";
 import { ensureInModulesScratch, modulesScratchDir } from "./paths.js";
 import { defineTool } from "@earendil-works/pi-coding-agent";
@@ -85,8 +85,14 @@ export function findTestScripts(root, plainFile, buildDir) {
     const stack = stackOf(root);
     const config = readProjectConfig(root, stack);
     const file = stack !== undefined ? `${stackConfigFileIn(root, stack)} (over ${projectConfigFile(root)})` : projectConfigFile(root);
-    // Where a script is named: the stack's file, once one is chosen.
-    const nameIn = stack !== undefined ? stackConfigFileIn(root, stack) : `${CONFIG_FILE} - or, for a project of several stacks, the stack's config.turri.<stack>.yaml`;
+    // A project of stacks with none chosen: its scripts are named in the stacks' files.
+    const stacks = stack === undefined ? stacksOf(root) : [];
+    // Where a script is named: the stack's file, once one is chosen - in a project of stacks, the one of the stack that builds it.
+    const nameIn = stack !== undefined
+        ? stackConfigFileIn(root, stack)
+        : stacks.length > 0
+            ? "the config.turri.<stack>.yaml of the stack that builds it"
+            : `${CONFIG_FILE} - or, for a project of several stacks, the stack's config.turri.<stack>.yaml`;
     if (config.testingScriptsRunOn !== undefined)
         found.runOn = config.testingScriptsRunOn;
     for (const kind of Object.keys(SCRIPT_KEYS)) {
@@ -139,6 +145,22 @@ export function findTestScripts(root, plainFile, buildDir) {
             }
         }
     }
+    // A project of stacks, none chosen: the scripts are likely in a stack's file - the note says which, and how to choose it.
+    if (stacks.length > 0) {
+        for (const kind of Object.keys(SCRIPT_KEYS)) {
+            if (found[kind] !== undefined)
+                continue;
+            const named = stacks.flatMap((each) => {
+                const script = kind === "unit" ? readProjectConfig(root, each).unittestsScript : readProjectConfig(root, each).conformanceTestsScript;
+                return script !== undefined ? [`${stackConfigFile(each)} names ${script.trim()}`] : [];
+            });
+            notes[kind] = [
+                ...(notes[kind] !== undefined ? [notes[kind]] : []),
+                `No stack is chosen, so ${CONFIG_FILE} alone is read - this project's stacks are ${stacks.join(", ")}${named.length > 0 ? `, and ${named.join("; ")}` : ""}. ` +
+                    "Choose the stack that builds this module: stack on regenerate, or /stack, in the chat; --stack <name> on the command line.",
+            ].join(" ");
+        }
+    }
     if (Object.keys(notes).length > 0)
         found.notes = notes;
     return found;

package/dist/stacks.js

@@ -7,9 +7,7 @@ import { readdirSync } from "node:fs";
 import { join } from "node:path";
 import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-import { chooseStack, chosenStack, hasProjectConfig, stackConfigFile, stacksOf } from "./config.js";
-/** The words that choose no stack: the project's config alone. */
-const NONE = ["none", "off", "base", "-"];
+import { chooseStack, chosenStack, hasProjectConfig, NO_STACK, stackConfigFile, stacksOf } from "./config.js";
 /** The stacks of the projects here: the folder's own, and those of the projects one folder down (specs kept in plain/). */
 export function knownStacks(root) {
     const below = (() => {
@@ -29,7 +27,7 @@ export function knownStacks(root) {
 export function switchStack(root, name) {
     const stacks = knownStacks(root);
     const wanted = name?.trim() ?? "";
-    if (wanted === "" || NONE.includes(wanted.toLowerCase())) {
+    if (wanted === "" || NO_STACK.includes(wanted.toLowerCase())) {
         chooseStack(undefined);
         return "No stack chosen: everything is built with the project's config.turri.yaml alone, from now on.";
     }
@@ -79,7 +77,7 @@ export function registerStacks(pi, cwd) {
             "For the session; a pulse already running keeps the stack it started with. Without a name, says the stacks and the one chosen.",
         promptSnippet: "choose the stack - its testing scripts and settings - that everything is built with",
         promptGuidelines: [
-            "Switch the stack only when the user asks for it, or for work on a part of the project another stack builds - a backend's, a frontend's - and say which you chose.",
+            "Switch the stack only when the user asks for it, and say which you chose. To build a part of the project another stack builds - a backend's, a frontend's - pass that stack as stack to regenerate, conform or glimpse instead: it is pinned to that module's pulses, and the session's choice stays as it is.",
         ],
         parameters: Type.Object({
             name: Type.Optional(Type.String({ description: "The stack to choose, or none. Omitted: the stacks there are, and the one chosen" })),

package/docs/config.md

@@ -218,7 +218,8 @@ coding-model:
 
 A stack is chosen, never worked out from the spec:
 
-- **In the chat**, with `/stack` - a list of the project's stacks and none - or `/stack backend`, `/stack none`. The chat's model has a `stack` tool too, and switches the stack when you ask it to, or for work on a part another stack builds. `/stack` alone says which is chosen now.
+- **In the chat, for a module**, by the chat's model: `regenerate`, `conform` and `glimpse` take a `stack`, and it builds each module with the stack of its part - `backend.plain` with `backend` - leaving the session's choice as it is. A backend and a frontend can be regenerated side by side this way, each with its own.
+- **In the chat, for the session**, with `/stack` - a list of the project's stacks and none - or `/stack backend`, `/stack none`. The chat's model has a `stack` tool too, and switches the stack when you ask it to. `/stack` alone says which is chosen now; a module asked for without a stack of its own is built with it.
 - **On the command line**, with `--stack <name>` on any command - `turri regenerate`, `conform`, `spec-diff`, `glimpse`, `release`, `cultivate` - and on `turri --stack backend` for the chat; or with `TURRI_STACK` in the environment.
 
 The choice lasts for the session only: nothing remembers it, and turri started again has none chosen. A stack the project has no file for is refused, with the stacks it has. With none chosen, `config.turri.yaml` alone is used.
@@ -226,7 +227,8 @@ The choice lasts for the session only: nothing remembers it, and turri started a
 How a stack's config is made:
 
 - **Laid over `config.turri.yaml`, key by key.** What the stack's file gives wins; what it leaves out is the project's. A model it names takes what it leaves out from the project's same model - above, with the stack frontend chosen, everything renders on the project's coding model, thinking `high`.
-- **For everything built while it is chosen.** Every pulse that starts, every test run and every script found from then on is the chosen stack's; a pulse already running keeps the stack it started with. Choose the stack before building the part it is for: `/stack backend`, then `regenerate backend.plain`.
+- **Pinned to a module when it is asked for.** A module is built with the stack chosen - or named in the call - when it is asked for, from its first pulse to its last: the pulses planned after it, its test runs, the scripts found, its plans and its conformance tests, whatever stack is chosen meanwhile. A pulse waiting for a free slot keeps the stack it was queued with. A change to its spec keeps its stack; asked for again, it takes the one chosen then. What `regenerate` says back names each module's stack, and so does a pulse's report.
+- **Refused with none, when that cannot build.** In a project of stacks, a module asked for with no stack - none named, none chosen - is refused before anything is planned when `config.turri.yaml` alone names no unit testing script: every pulse would stop for want of one. The refusal names the stacks and the script each names. `stack: none` builds with `config.turri.yaml` alone all the same.
 - **The project's alone.** `module:`, `harness-model:`, `parallel-jobs:`, `rules-off:` and `compact-at:` are read only from `config.turri.yaml` - there is one conversation, one module built when none is named, one machine. `agent-env:` and `toolchains:` in a stack's file add to the project's.
 
 The chat is told each stack's config and the one chosen. The skills that write testing scripts put each stack's in its own file once a project has two stacks, and say which stack to choose before building each part.

package/docs/regenerating.md

@@ -45,7 +45,7 @@ The harness's scratch - each ignores itself, and is never part of a module's his
 
 ### Parts on different stacks
 
-One project can hold modules that share nothing but a common module - a Python backend and a React frontend side by side, each importing `base`, neither requiring the other. Each stack gets its testing scripts, models and conformance in its own `config.turri.<stack>.yaml`, laid over `config.turri.yaml` while it is chosen - `/stack backend` in the chat, `--stack backend` on the command line: see [the project config](config.md#stacks).
+One project can hold modules that share nothing but a common module - a Python backend and a React frontend side by side, each importing `base`, neither requiring the other. Each stack gets its testing scripts, models and conformance in its own `config.turri.<stack>.yaml`, laid over `config.turri.yaml` for the modules built with it - in the chat, `regenerate` with `stack: backend`, pinned to that module's pulses, or `/stack backend` for the session; `--stack backend` on the command line: see [the project config](config.md#stacks).
 
 ## One job
 
@@ -218,7 +218,7 @@ The `implement-unit-testing-script` and `implement-conformance-testing-script` s
 2. the root itself: the one `run_unittests*.sh` and `run_conformance_tests*.sh` there;
 3. `test_scripts/`: the one of each there.
 
-The same `config.turri.yaml` holds the project's other defaults - `module`, `model`, `conformance-tests` - for [unattended runs](headless.md). A folder holding two of a kind is not guessed between: name the one to use in `config.turri.yaml`, or in each stack's own file. The scripts are not linked from the specs; a link to one is ignored.
+The same `config.turri.yaml` holds the project's other defaults - `module`, `model`, `conformance-tests` - for [unattended runs](headless.md). A folder holding two of a kind is not guessed between: name the one to use in `config.turri.yaml` - or, in a project of stacks, in each stack's own file, and build each module with its stack. A module of such a project built with none says so when it stops: which stacks there are, and which script each names. The scripts are not linked from the specs; a link to one is ignored.
 
 They are required: a build with no unit testing script, or with conformance on and no conformance testing script, stops before it starts and says which skill adds it.
 

package/docs/using.md

@@ -85,7 +85,7 @@ A render takes minutes, so in the TUI every render tool starts the work as a pul
   `ctrl+h` again, or `esc`, closes it and goes back to the chat. Beside the chat, one side has the keys and the other is drawn faint: `ctrl+h` switches sides - from the chat to the panel, from the panel to the chat, the panel staying and following the pulses - `esc` gives the chat the keys too, and a click gives them to the side clicked. `ctrl+c` closes the panel; so do `s`, over the whole screen, then `esc`. (pi's regular screen, `--tui-mode regular`, reads no mouse: there it is the keys alone.) While the panel has the keys, every key is the panel's, whatever else happens: a question the chat model asks in the background (`ask_user`) waits in the chat, unanswered - an `enter` in the panel never answers it - and the panel's top line says "the chat is waiting for your answer". Back in the chat, the question is there, with the keys.
 - `turri` runs pi in fullscreen mode, so the conversation stays where you scroll it while the pulses redraw (PgUp/PgDn, the wheel); `--tui-mode regular` goes back to the terminal's own scrollback.
 - **`/turri-config`** changes a setting of the project's `config.turri.yaml` - the models, review, conformance tests, any key - and says when it takes effect: now, at your next message, or at the next pulse; never only after a restart. See [changing it from the chat](config.md#changing-it-from-the-chat).
-- **`/stack`** chooses the stack everything is built with from then on, in a project whose parts are on different stacks: a list of the project's stacks, or `/stack backend`, `/stack none`. The stack's `config.turri.<stack>.yaml` is laid over `config.turri.yaml` - its testing scripts, toolchains, models - for the session; a pulse already running keeps the stack it started with. The chat model switches it too when you ask. See [stacks](config.md#stacks).
+- **`/stack`** chooses the stack everything is built with from then on, in a project whose parts are on different stacks: a list of the project's stacks, or `/stack backend`, `/stack none`. The stack's `config.turri.<stack>.yaml` is laid over `config.turri.yaml` - its testing scripts, toolchains, models - for the session; a module already asked for keeps the stack it was asked for with. The chat model switches it too when you ask - and, to build one part, passes that part's stack to `regenerate` instead, leaving the session's as it is. See [stacks](config.md#stacks).
 - **`/regenerate [module | file.plain] [functionality ...] [from scratch [whole chain]] [how to cut the work]`** regenerates a module from its spec as it is now, as the `regenerate` tool does: what is left to regenerate is planned into pulses - one functional spec at a time, a few together or the whole module in one, as the planner judges - and the first starts. Words after the module are guidance for that plan (`/regenerate app models first`). A module's name typed with spaces for its underscores is that module - `/regenerate d365_function executor` is `d365_function_executor`. With no module named: the one `module:` in `config.turri.yaml` names, else the folder's top modules, to pick from. Asked for from scratch - `from scratch`, `start over`, `delete the module` - it asks first, then deletes the module's code and conformance tests in every codebase where they live, committed so `/lineage` keeps them, and regenerates the whole module from its spec, built though nothing in it changed: `/regenerate shorty from scratch`. The modules below it keep their code, and the module starts again from a copy of the code below it. Asked for its chain too - `/regenerate shorty from scratch, the whole chain` - the code of every module of its requires chain is deleted, the base's included, and the whole chain is regenerated from the bottom: what to do after modules were split, merged or moved, when the code below was laid out for modules that are no more. The chat's `regenerate` does the same with `from_scratch: "module"` or `"chain"`, when you ask for it; `turri regenerate --from-scratch` or `--from-scratch-chain` on the command line, not with `--dry-run`. Functionalities named after the module - `/regenerate shorty 3 5` - are regenerated though their spec did not change, on the model chosen for functionalities: as `turri regenerate shorty.plain 3 5` does, and the chat's `regenerate` with `functionalities`.
 - **`/halt <id>`** halts a pulse - a queued one never starts - **`/halt <module>`** (or a planned row's id) halts a module's planned pulses until you ask for it again, a spec change not starting it, and **`/halt activated <name>`** halts a server `activate` started; it lists all three when no id is given.
 - **What these commands show you, the chat knows.** What `/regenerate` and `/halt activated` tell you - a spec that does not parse, the pulses planned, a server halted - stays in the chat under the command, and since a slash command runs outside the conversation, it is put in the conversation as well: say "fix it" next and turri knows what you are looking at. A halted pulse reaches it as every pulse's end does.
@@ -102,7 +102,7 @@ In `print`, `json` and `rpc` modes the process ends when the answer is written,
 
 The chat reads the project's `config.turri.yaml` afresh every turn and follows it: its agent is told what it sets, and the render tools default to it - `module` when you ask to build without naming one, `conformance-tests: false` to render without conformance tests (none written, none of the existing ones run) unless you ask for them, `coding-model` for what renders run on, and the testing scripts. `harness-model` is what `turri` starts on. What you ask for in the conversation wins. Every key, what happens without it, and how the models inherit: [the project config](config.md).
 
-A project whose parts are on different stacks gives each stack its own `config.turri.<stack>.yaml` beside `config.turri.yaml` - `config.turri.backend.yaml`, `config.turri.frontend.yaml` - with its testing scripts, models and conformance over the project's. A stack is chosen, never worked out: `/stack backend` before building the backend, `/stack frontend` before the frontend, and every render from then on follows the chosen one's; the chat is told each stack's and which is chosen, and the status bar shows it. See [stacks](config.md#stacks).
+A project whose parts are on different stacks gives each stack its own `config.turri.<stack>.yaml` beside `config.turri.yaml` - `config.turri.backend.yaml`, `config.turri.frontend.yaml` - with its testing scripts, models and conformance over the project's. A stack is chosen, never worked out: ask for the backend and the chat's model regenerates it with `stack: backend`, the frontend with `stack: frontend` - each pinned to its module's pulses, so both can be built side by side - or choose one for the session with `/stack backend`. The chat is told each stack's and which is chosen, and the status bar shows it. See [stacks](config.md#stacks).
 
 A project with only a `config.yaml` - turri's file before it had its own name, or another tool's - is read from it until turri first writes a setting, which copies it to `config.turri.yaml`; see [the old config.yaml](config.md#the-old-configyaml).
 

package/genome/skills/brood/SKILL.md

@@ -102,7 +102,7 @@ Create the module structure and frontmatter so there is a `.plain` file to build
 
 Write no definitions, no functional specs, no `***test reqs***` and no `***acceptance tests***`.
 
-End the phase with the unit tests: their framework, as a `:UnitTests:` requirement, and the unit testing script, which every build needs from the first one on. If turri already finds a script - named by `unittests-script:` in `config.turri.yaml` at the project root, or the one `run_unittests*.sh` in the root or in `test_scripts/` - keep it. Otherwise write `test_scripts/run_unittests_<language>.sh` with the `implement-unit-testing-script` skill, for the language and framework just settled. Do not link it from the specs. Without it, every build stops before it starts. When this module sits in a project beside another on a different stack - a frontend beside a backend, sharing only an imported module - its script is its stack's: name it in that stack's `config.turri.<stack>.yaml` beside `config.turri.yaml` (`unittests-script:`) - `config.turri.frontend.yaml` for the stack `frontend` - not in `config.turri.yaml`, which is the project's and holds what the stacks share. A stack is chosen, never worked out: tell the user to choose it with `/stack <stack>` (`--stack <stack>` on the command line) before building this module.
+End the phase with the unit tests: their framework, as a `:UnitTests:` requirement, and the unit testing script, which every build needs from the first one on. If turri already finds a script - named by `unittests-script:` in `config.turri.yaml` at the project root, or the one `run_unittests*.sh` in the root or in `test_scripts/` - keep it. Otherwise write `test_scripts/run_unittests_<language>.sh` with the `implement-unit-testing-script` skill, for the language and framework just settled. Do not link it from the specs. Without it, every build stops before it starts. When this module sits in a project beside another on a different stack - a frontend beside a backend, sharing only an imported module - its script is its stack's: name it in that stack's `config.turri.<stack>.yaml` beside `config.turri.yaml` (`unittests-script:`) - `config.turri.frontend.yaml` for the stack `frontend` - not in `config.turri.yaml`, which is the project's and holds what the stacks share. A stack is chosen, never worked out: this module is built with its own - in the chat, `regenerate` with `stack: <stack>`, pinned to its pulses whatever stack is chosen after; `--stack <stack>` on the command line - so say which stack builds it.
 
 The unit testing script runs the static checks too - the formatter, linter and type checker the stack names, which count as the unit tests do; `implement-unit-testing-script` says which for each language. There is no separate static checks script.
 

package/genome/skills/brood/references/testing.md

@@ -19,7 +19,7 @@ Write no `***acceptance tests***`, no functional specs and no `***implementation
 3. **How the tests reach the software** - as a subprocess of the CLI, over HTTP against a server the tests start, through the public entry point it exports. Author it.
 4. **Setup and outside services** - fixtures, test data, databases, third-party APIs: started for real, faked, or mocked at the boundary. Author each decision as its own requirement.
 5. **How the whole suite is run** - the one command that discovers every test. Author it.
-6. **The conformance testing script** - if turri already finds one (named by `conformance-tests-script:` in `config.turri.yaml`, or the one `run_conformance_tests*.sh` in the project root or in `test_scripts/`), check it runs the suite the way the test reqs now say, and keep it. Otherwise write `test_scripts/run_conformance_tests_<language>.sh` with `implement-conformance-testing-script`, to match the test reqs. Never link it from the specs. If `test_scripts/` would hold two of a kind, name the one to use in `config.turri.yaml`. In a project whose parts are on different stacks, name each stack's script in its own `config.turri.<stack>.yaml` (`conformance-tests-script:`), and tell the user to choose the stack with `/stack <stack>` (`--stack <stack>` on the command line) before building that part.
+6. **The conformance testing script** - if turri already finds one (named by `conformance-tests-script:` in `config.turri.yaml`, or the one `run_conformance_tests*.sh` in the project root or in `test_scripts/`), check it runs the suite the way the test reqs now say, and keep it. Otherwise write `test_scripts/run_conformance_tests_<language>.sh` with `implement-conformance-testing-script`, to match the test reqs. Never link it from the specs. If `test_scripts/` would hold two of a kind, name the one to use in `config.turri.yaml`. In a project whose parts are on different stacks, name each stack's script in its own `config.turri.<stack>.yaml` (`conformance-tests-script:`), and build each part with its own stack - in the chat, `regenerate` with `stack: <stack>`, pinned to that part's pulses; `--stack <stack>` on the command line.
 7. **Anything else** - anything about testing the user wants to add or change.
 
 Run `validate` on every module you changed. The product phase's first build needs the test reqs and the conformance testing script both there: without them it stops before it starts.

package/genome/skills/implement-conformance-testing-script/SKILL.md

@@ -208,7 +208,7 @@ The harness never runs `.ps1` scripts. These notes apply only to an optional cop
 4. Pick the right row from the [Dependency isolation](#dependency-isolation) table — use the same flag/env var in steps 7, 7b and 8 — and the checks from [Static checks of the tests](#static-checks-of-the-tests).
 5. Add the language-appropriate "no tests discovered" guard from [No tests discovered detection](#no-tests-discovered-detection), and the guard against conformance tests in the build folder from [Tests in the build folder](#tests-in-the-build-folder).
 6. Save the new script as `test_scripts/run_conformance_tests_<lang>.sh` and `chmod +x` it. Write a `.ps1` copy only if the user wants to run it by hand on Windows.
-7. **Make sure turri finds the script.** Do not link it from the specs - turri finds the conformance testing script in the project root (the folder that holds `plain_modules/`) and puts it, whole, into the prompts of the agents that write and review the conformance tests itself, whenever conformance tests are written for a build; a link to it from a spec is ignored. It looks, in order, at `config.turri.yaml` in the root (`conformance-tests-script: <path relative to the root>`) - with the chosen stack's `config.turri.<stack>.yaml` over it, then for the one `run_conformance_tests*.sh` in the root, then for the one in `test_scripts/`. Saving the script in `test_scripts/` (or the root) is enough when it is the only one there. If the project keeps it elsewhere, name it in `config.turri.yaml` as `conformance-tests-script:` - and when the project has only a `config.yaml`, copy it to `config.turri.yaml` first (and each `config.<name>.yaml` to `config.turri.<name>.yaml`) and edit the copy; `config.yaml` may be another tool's, and is never written. If the project has modules on different stacks - e.g. a Python backend and a React frontend side by side, sharing only an imported module - each part is on a stack of its own, and each stack names its own script in its own file beside `config.turri.yaml`: `conformance-tests-script:` in `config.turri.backend.yaml` for the stack `backend`, in `config.turri.frontend.yaml` for the stack `frontend`. A stack is chosen, never worked out: tell the user to choose it with `/stack <stack>` (`--stack <stack>` on the command line) before building that part. turri never guesses between two. The script is required: with conformance testing on, a build without one stops before it starts. The `***test reqs***` still describe the conformance framework and command in words; do not paraphrase the script into them.
+7. **Make sure turri finds the script.** Do not link it from the specs - turri finds the conformance testing script in the project root (the folder that holds `plain_modules/`) and puts it, whole, into the prompts of the agents that write and review the conformance tests itself, whenever conformance tests are written for a build; a link to it from a spec is ignored. It looks, in order, at `config.turri.yaml` in the root (`conformance-tests-script: <path relative to the root>`) - with the chosen stack's `config.turri.<stack>.yaml` over it, then for the one `run_conformance_tests*.sh` in the root, then for the one in `test_scripts/`. Saving the script in `test_scripts/` (or the root) is enough when it is the only one there. If the project keeps it elsewhere, name it in `config.turri.yaml` as `conformance-tests-script:` - and when the project has only a `config.yaml`, copy it to `config.turri.yaml` first (and each `config.<name>.yaml` to `config.turri.<name>.yaml`) and edit the copy; `config.yaml` may be another tool's, and is never written. If the project has modules on different stacks - e.g. a Python backend and a React frontend side by side, sharing only an imported module - each part is on a stack of its own, and each stack names its own script in its own file beside `config.turri.yaml`: `conformance-tests-script:` in `config.turri.backend.yaml` for the stack `backend`, in `config.turri.frontend.yaml` for the stack `frontend`. A stack is chosen, never worked out: each part is built with its own - in the chat, `regenerate` with `stack: <stack>`, pinned to that part's pulses whatever stack is chosen after; `--stack <stack>` on the command line - so say which stack builds which part. turri never guesses between two. The script is required: with conformance testing on, a build without one stops before it starts. The `***test reqs***` still describe the conformance framework and command in words; do not paraphrase the script into them.
 
 ## Anti-Patterns
 

package/genome/skills/implement-unit-testing-script/SKILL.md

@@ -139,7 +139,7 @@ Notes:
 3. Translate each of the eight steps above into the equivalent commands for the target language **and** shell. The toolchain check, dependency install, static checks and test invocation are the language-specific parts; the rest is mechanical translation between Bash and PowerShell syntax.
 4. Pick the dependency-isolation mechanism from the [Dependency isolation](#dependency-isolation) table and use it consistently in steps 6, 7 and 8, and the checks from the [Static checks](#static-checks) table.
 5. Save the new script as `test_scripts/run_unittests_<lang>.sh` (a `.ps1` copy next to it only if the user wants to run it by hand on Windows). For Bash, `chmod +x` it.
-6. **Make sure turri finds the script.** Do not link it from the specs - turri finds the unit testing script in the project root (the folder that holds `plain_modules/`) and puts it, whole, into the prompt of the coding agent itself; a link to it from a spec is ignored. It looks, in order, at `config.turri.yaml` in the root (`unittests-script: <path relative to the root>`) - with the chosen stack's `config.turri.<stack>.yaml` over it, then for the one `run_unittests*.sh` in the root, then for the one in `test_scripts/`. Saving the script in `test_scripts/` (or the root) is enough when it is the only one there. If the project keeps it elsewhere, name it in `config.turri.yaml` as `unittests-script:` - and when the project has only a `config.yaml`, copy it to `config.turri.yaml` first (and each `config.<name>.yaml` to `config.turri.<name>.yaml`) and edit the copy; `config.yaml` may be another tool's, and is never written. If the project has modules on different stacks - e.g. a Python backend and a React frontend side by side, sharing only an imported module - each part is on a stack of its own, and each stack names its own script in its own file beside `config.turri.yaml`: `unittests-script:` in `config.turri.backend.yaml` for the stack `backend`, in `config.turri.frontend.yaml` for the stack `frontend`. A stack is chosen, never worked out: tell the user to choose it with `/stack <stack>` (`--stack <stack>` on the command line) before building that part. turri never guesses between two. The script is required: a build without one stops before it starts.
+6. **Make sure turri finds the script.** Do not link it from the specs - turri finds the unit testing script in the project root (the folder that holds `plain_modules/`) and puts it, whole, into the prompt of the coding agent itself; a link to it from a spec is ignored. It looks, in order, at `config.turri.yaml` in the root (`unittests-script: <path relative to the root>`) - with the chosen stack's `config.turri.<stack>.yaml` over it, then for the one `run_unittests*.sh` in the root, then for the one in `test_scripts/`. Saving the script in `test_scripts/` (or the root) is enough when it is the only one there. If the project keeps it elsewhere, name it in `config.turri.yaml` as `unittests-script:` - and when the project has only a `config.yaml`, copy it to `config.turri.yaml` first (and each `config.<name>.yaml` to `config.turri.<name>.yaml`) and edit the copy; `config.yaml` may be another tool's, and is never written. If the project has modules on different stacks - e.g. a Python backend and a React frontend side by side, sharing only an imported module - each part is on a stack of its own, and each stack names its own script in its own file beside `config.turri.yaml`: `unittests-script:` in `config.turri.backend.yaml` for the stack `backend`, in `config.turri.frontend.yaml` for the stack `frontend`. A stack is chosen, never worked out: each part is built with its own - in the chat, `regenerate` with `stack: <stack>`, pinned to that part's pulses whatever stack is chosen after; `--stack <stack>` on the command line - so say which stack builds which part. turri never guesses between two. The script is required: a build without one stops before it starts.
 
 ## Anti-Patterns
 

package/genome/skills/init-plain-project/SKILL.md

@@ -96,7 +96,7 @@ Call the corresponding implementation skills in order. Each skill writes a Bash
 
 ### 6. Check turri finds the scripts
 
-turri finds the testing scripts in the project root, not through the specs: first in `config.turri.yaml` (`unittests-script:`, `conformance-tests-script:`, paths relative to the root), then the one `run_unittests*.sh` / `run_conformance_tests*.sh` in the root, then the one of each kind in `test_scripts/`. It puts them into the prompts of the agents that write and run the tests itself, so do not link them from `template/base.plain` (a link to one is ignored). Confirm every generated script is in `test_scripts/` and is the only one of its kind there - or, if the project wants it, that a `config.turri.yaml` at the root names the one to use and the path resolves. A project with parts on different stacks (e.g. a Python backend and a React frontend sharing an imported `base`) keeps one `config.turri.yaml` for what they share and gives each stack its own `config.turri.<stack>.yaml` beside it - `config.turri.backend.yaml`, `config.turri.frontend.yaml` - naming that stack's `unittests-script:` and `conformance-tests-script:`. A stack is chosen, never worked out: tell the user to choose it with `/stack <stack>` (`--stack <stack>` on the command line) before building that part. When the project has only a `config.yaml`, copy it to `config.turri.yaml` first - and each `config.<name>.yaml` to `config.turri.<name>.yaml` - and write the copies; never write `config.yaml`.
+turri finds the testing scripts in the project root, not through the specs: first in `config.turri.yaml` (`unittests-script:`, `conformance-tests-script:`, paths relative to the root), then the one `run_unittests*.sh` / `run_conformance_tests*.sh` in the root, then the one of each kind in `test_scripts/`. It puts them into the prompts of the agents that write and run the tests itself, so do not link them from `template/base.plain` (a link to one is ignored). Confirm every generated script is in `test_scripts/` and is the only one of its kind there - or, if the project wants it, that a `config.turri.yaml` at the root names the one to use and the path resolves. A project with parts on different stacks (e.g. a Python backend and a React frontend sharing an imported `base`) keeps one `config.turri.yaml` for what they share and gives each stack its own `config.turri.<stack>.yaml` beside it - `config.turri.backend.yaml`, `config.turri.frontend.yaml` - naming that stack's `unittests-script:` and `conformance-tests-script:`. A stack is chosen, never worked out: each part is built with its own - in the chat, `regenerate` with `stack: <stack>`, pinned to that part's pulses whatever stack is chosen after; `--stack <stack>` on the command line - so say which stack builds which part. When the project has only a `config.yaml`, copy it to `config.turri.yaml` first - and each `config.<name>.yaml` to `config.turri.<name>.yaml` - and write the copies; never write `config.yaml`.
 
 Do **not** run `validate` here — keeping this skill light is the whole point. The user can run it when they want validation.
 

package/genome/skills/spawn/SKILL.md

@@ -38,7 +38,7 @@ Read what is already there first: an existing `.plain` file, `config.turri.yaml`
 
 - Templates go in `template/`; import paths omit the `template/` prefix. Resources go in `resources/`.
 - Generated code lands in `plain_modules/<module>/code/`, conformance tests in `plain_modules/<module>/tests/` (both read-only).
-- One module, unless the intent needs two stacks - a web frontend and an API backend. Then two modules side by side, neither requiring the other, sharing what they both mean through one imported module in `template/`. Each is on a stack of its own, whose testing scripts are named in `config.turri.<stack>.yaml` beside `config.turri.yaml` (`unittests-script:`, `conformance-tests-script:`) - `config.turri.backend.yaml`, `config.turri.frontend.yaml`. A stack is chosen, never worked out: tell the user to choose one with `/stack <stack>` (`--stack <stack>` on the command line) before building its part.
+- One module, unless the intent needs two stacks - a web frontend and an API backend. Then two modules side by side, neither requiring the other, sharing what they both mean through one imported module in `template/`. Each is on a stack of its own, whose testing scripts are named in `config.turri.<stack>.yaml` beside `config.turri.yaml` (`unittests-script:`, `conformance-tests-script:`) - `config.turri.backend.yaml`, `config.turri.frontend.yaml`. A stack is chosen, never worked out: each part is built with its own - in the chat, `regenerate` with `stack: <stack>`, pinned to that part's pulses whatever stack is chosen after; `--stack <stack>` on the command line - so say which stack builds which part.
 
 ## Steps
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turri-dev/cli",
-  "version": "0.1.4",
+  "version": "0.1.5-next.6df6879",
   "license": "MIT",
   "type": "module",
   "repository": {