@turri-dev/cli 0.1.27 → 0.2.0

package/dist/extension.js

@@ -1,5 +1,6 @@
 // Whether the terminal shows images, before anything draws: the banner's jellyfish is a picture or text.
 import "./terminal-images.js";
+import { moduleOfTestPlainFile, refuseTestPlainFile, testPlainFileRefusal } from "./test-plain-files.js";
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { basename, dirname, join, relative, resolve } from "node:path";
 import { conversationCommand, conversationSettled, conversationWriting } from "./regenerate/conversation-writes.js";
@@ -8,12 +9,16 @@ import { allocateImageId, Box, getCapabilities, getPngDimensions, isKeyRelease,
 import { defineTool, getMarkdownTheme, UserMessageComponent } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { CODING_MODEL_ENV } from "./chat-models.js";
-import { AGENT_ROLES, CONFIG_FILE, configForSpec, hasProjectConfig, LEGACY_CONFIG_FILE, projectConfigFile, stackConfigFileIn, stackOf, stacksOf, withStack, modelOnly, modelSpec, projectModels, readProjectConfig, roleModel, splitModelSpec } from "./config.js";
-import { skillRunDir } from "./regenerate/paths.js";
+import { AGENT_ROLES, chosenStack, CONFIG_FILE, configForSpec, stackForModule, hasProjectConfig, LEGACY_CONFIG_FILE, projectConfigFile, stackConfigFileIn, stackOf, stacksOf, withStack, modelOnly, modelSpec, projectModels, readProjectConfig, roleModel, splitModelSpec } from "./config.js";
+import { projectDirOf, skillRunDir } from "./regenerate/paths.js";
 import { sweepOrphanedGroups } from "./regenerate/shell.js";
 import { readScript, scriptAgainstMachine, stackOnMachine, toolchainsBlock } from "./stack.js";
 import { sandboxAvailable, sandboxSummary } from "./regenerate/os-sandbox.js";
-import { findTestScripts } from "./regenerate/test-scripts.js";
+import { findTestScripts, scriptKindOfSkill } from "./regenerate/test-scripts.js";
+import { writingScript } from "./regenerate/scripts-being-written.js";
+import { applyBedrockRegion } from "./bedrock-region.js";
+import { conformanceBlock, conformanceTestsOnIn, CONFORMANCE_TOOLS, TURN_ON_TOOL, turnOnConformanceTests, turnOnConformanceTestsTool } from "./conformance-switch.js";
+import { BACKGROUND_NOTE, doneLine, failedTask, ownChanges, runDetails, skillRunDelivery, startedText } from "./background-skills.js";
 import { createAskUserTool } from "./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";
@@ -27,10 +32,14 @@ import { createSteeringStore, EVERY_MODULE, moduleNameOf, queueSectionOf, steeri
 import { askedForCommandLine, refusal, selfInvocation, TOOLS_NOT_CLI } from "./self-invocation.js";
 import { NEW_PROJECT } from "./new-project.js";
 import { describeChoices, describeResolution, modelFor, resolveModel } from "./regenerate/engine.js";
-import { checkPlainFile, checkPlainTargets, formatCheckResults } from "./plain/check.js";
+import { checkPlainFile, formatCheckResults } from "./plain/check.js";
+import { checkPlainTool } from "./parse-tool.js";
 import { changedFiles, projectFiles } from "./plain-files.js";
 import { whyFailed } from "./regenerate/diagnose-job.js";
 import { createWorkLoop, describeModules, isUpToDate, previewJobs } from "./regenerate/loop.js";
+import { createTestAdvisor } from "./regenerate/advisor-runs.js";
+import { advisorDir } from "./regenerate/advisor-records.js";
+import { bindAdvisor, evaluateTestsTool, TEST_ADVISOR_BLOCK, verdictDelivery } from "./advisor-chat.js";
 import { brandNeon, brandPink, plainPaint } from "./regenerate/plain-palette.js";
 import { halfBlocks, JELLYFISH_FRAME_MS, JELLYFISH_REST, JELLYFISH_SEQUENCE, JELLYFISH_TEXT_FRAMES } from "./jellyfish.js";
 import { createJobPanel, didNotPass, keyPressed, PANEL_KEY, spinner } from "./regenerate/job-panel.js";
@@ -54,7 +63,7 @@ import { describeSpecConflict } from "./regenerate/stop-report.js";
 import { inheritProviders, inheritThinkingLevel } from "./pi.js";
 import { beginCapture, captureConsole, describeCaptured, dropNoise } from "./quiet.js";
 import { loadRules, renderRulesBlock } from "./rules.js";
-import { registerTurriConfig } from "./config-command.js";
+import { registerTurriConfig, ruleNames } from "./config-command.js";
 import { writeSetting } from "./config-edit.js";
 import { describeStdlib } from "./stdlib.js";
 import { DECLINED, peekKeyListener, runAsk } from "./ask.js";
@@ -70,7 +79,6 @@ import { noticeDialogs, registerSentinel } from "./sentinel-chat.js";
 import { currentChat } from "./chat-scope.js";
 import { registerChats } from "./chat-commands.js";
 import { turriIdentity } from "./environment.js";
-import { conformanceChooser } from "./regenerate/choose-conformance.js";
 import { answerSideQuestion, askWithAsides, BTW_HOW, runningSkill, skillRunStarted, skillSessionText, transcriptOf } from "./btw.js";
 import { createJobRegistry, defaultParallelJobs, describeJob, firstRegeneration, formatDuration, formatElapsed, pulseName, shouldWait, STOPPED_ON_REQUEST, } from "./regenerate/jobs.js";
 /**
@@ -274,6 +282,8 @@ const hosts = new WeakMap();
 export function createTurriCore(host = {}, options = {}) {
     dropNoise();
     const cwd = process.cwd();
+    // The AWS region the project's Bedrock models need, before any model is called - a host has no shell to export it in.
+    applyBedrockRegion(cwd);
     let core;
     // Finished work is announced twice, to two audiences, because pi treats them differently - see ChatInstance.announce:
     // in the chat that asked for it, or the one shown when that is closed.
@@ -337,6 +347,30 @@ export function createTurriCore(host = {}, options = {}) {
     setSurface(jobs, host.surface);
     // What release has shipped, module by module: release does nothing for a module whose last commit it already shipped.
     deployStates.set(jobs, createDeployState());
+    // The test advisor watches what the work loop looks at, and picks up what it left pending when turri last quit.
+    if (options.advisor === true) {
+        // The conversation's own words on how the work is to be planned - AGENTS.md the advisor reads itself.
+        const context = (plainFile) => [...steeringStore.get(EVERY_MODULE), ...steeringStore.get(moduleNameOf(plainFile))];
+        const advisor = createTestAdvisor({
+            context,
+            // A verdict goes to the chat the person looks at - a host's too - which writes the scenarios on a yes.
+            onVerdict: (verdict) => void session.advised(verdict),
+        });
+        advisors.set(jobs, advisor);
+        // Where it may have left work pending: the folder turri runs in, and a project in a folder of it - ***plain kept in plain/.
+        const projects = () => {
+            try {
+                return [cwd, ...readdirSync(cwd, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".") && existsSync(advisorDir(join(cwd, entry.name)))).map((entry) => join(cwd, entry.name))];
+            }
+            catch {
+                return [cwd];
+            }
+        };
+        setTimeout(() => {
+            for (const project of projects())
+                advisor.resume(project);
+        }, 0).unref?.();
+    }
     // What this session does, as facts, in the project's .turri/ledger - a pulse's own in its project. Said once, in the
     // chat shown, when it cannot be written.
     if (ledgerWanted()) {
@@ -469,6 +503,8 @@ function turriExtension(api, session, link) {
         void pi.sendMessage({ customType: "turri_job_landed", content: landedNote(job, runningDeployed(job.module)), display: false, details: { jobId: job.id, status: job.status } }, { triggerTurn: true, deliverAs: "followUp" });
     };
     const notices = noticeDialogs(pi, session, link, contextNow);
+    // The test advisor's verdicts, once the chat is idle: a yes starts a turn that writes its scenarios, a no is a line.
+    const verdicts = verdictDelivery(pi, link, contextNow);
     link.live({
         announce,
         landed,
@@ -476,12 +512,14 @@ function turriExtension(api, session, link) {
         notice: notices.put,
         noticeOver: notices.over,
         concluded: notices.concluded,
+        advised: verdicts.put,
         act: (task) => {
             void pi.sendMessage({ customType: "turri_notice_answer", content: task, display: false }, { triggerTurn: true, deliverAs: "followUp" });
         },
         jobsChanged: () => panel.refresh(),
         thinkingLevel: () => pi.getThinkingLevel(),
         context: contextNow,
+        conformanceSwitched: () => conformanceTools(),
     });
     pi.on("session_start", (_event, ctx) => {
         lastContext = ctx;
@@ -529,7 +567,18 @@ function turriExtension(api, session, link) {
             return { systemPrompt: host.systemPrompt !== undefined ? host.systemPrompt(prompt) : prompt };
         }
         return {
-            systemPrompt: conversationSystemPrompt(event.systemPrompt, host, [TOOLS_NOT_CLI, NEW_PROJECT, pulseEndsBlock(session.sentinelOn()), projectConfigBlock(cwd), machineBlock(cwd, machine.now()), rulesBlock()]),
+            systemPrompt: conversationSystemPrompt(event.systemPrompt, host, [
+                TOOLS_NOT_CLI,
+                NEW_PROJECT,
+                pulseEndsBlock(session.sentinelOn()),
+                // Conformance tests - what they are, whether they are on here, and how they are turned on: every turn, read afresh.
+                conformanceBlock(conformanceTestsOnIn(cwd)),
+                // The test advisor, and that the chat alone writes scenarios - while the session has one the project wants.
+                ...(sessionAdvisor(session) !== undefined && conformanceTestsOnIn(cwd) && readProjectConfig(cwd).testAdvisor !== false ? [TEST_ADVISOR_BLOCK] : []),
+                projectConfigBlock(cwd),
+                machineBlock(cwd, machine.now()),
+                rulesBlock(),
+            ]),
         };
     });
     // The conversation's agent does not run turri again through its shell, unless the person
@@ -641,6 +690,33 @@ function turriExtension(api, session, link) {
     registerSteering(pi, cwd);
     registerSideQuestions(pi, cwd, jobs);
     registerStacks(pi, cwd);
+    // The chat's own way to the test advisor, while the session has one - whatever test-advisor says.
+    if (sessionAdvisor(session) !== undefined)
+        pi.registerTool(evaluateTestsTool({ cwd, advisor: () => sessionAdvisor(session) }));
+    // Conformance tests on or off: conform and evaluate_tests are the chat's while they are on, the tool that turns them on
+    // while they are off - set as each turn starts, and at once when the chat turns them on. Not the sentinel's: it has its own.
+    const conformanceTools = () => {
+        if (isSentinel)
+            return;
+        try {
+            const on = conformanceTestsOnIn(cwd);
+            const registered = new Set(pi.getAllTools().map((tool) => tool.name));
+            const active = pi.getActiveTools();
+            const wanted = [
+                ...active.filter((name) => !CONFORMANCE_TOOLS.includes(name) && name !== TURN_ON_TOOL),
+                ...(on ? CONFORMANCE_TOOLS : [TURN_ON_TOOL]).filter((name) => registered.has(name)),
+            ];
+            if (wanted.length !== active.length || wanted.some((name) => !active.includes(name)))
+                pi.setActiveTools(wanted);
+        }
+        catch {
+            /* not bound to a session yet: the next turn sets them */
+        }
+    };
+    if (!isSentinel)
+        pi.registerTool(turnOnConformanceTestsTool({ turnOn: (plainFile) => turnOnConformance(session, plainFile) }));
+    pi.on("session_start", () => conformanceTools());
+    pi.on("before_agent_start", () => conformanceTools());
     // More chats beside this one, in the terminal: /chat, alt+n, alt+1…9 (chat-commands.ts).
     if (session.terminal)
         registerChats(pi, session);
@@ -660,6 +736,76 @@ function turriExtension(api, session, link) {
             },
         });
     }
+    // A skill that runs in the background: started, and the turn goes on; its end comes back to this chat once it is idle.
+    const skillRunEnds = skillRunDelivery(pi, link, contextNow);
+    pi.on("session_shutdown", (event) => {
+        if (event.reason === "quit")
+            for (const controller of backgroundSkillRuns.values())
+                controller.abort();
+    });
+    const startInBackground = (skill, params, plainFile, ctx) => {
+        const key = `${cwd}\0${skill.name}`;
+        if (backgroundSkillRuns.has(key)) {
+            return { text: `${skill.name} is running in the background already; what it does comes back to this chat when it ends. Nothing new was started.`, details: { background: true, started: false } };
+        }
+        const model = skill.model === "coding" ? jobModel(ctx, "spec_changes", undefined, plainFile) : conversationModel(ctx);
+        const stack = plainFile !== undefined ? stackForModule(plainFile) : chosenStack();
+        const kind = scriptKindOfSkill(skill.name);
+        const shown = plainFile !== undefined ? relative(cwd, plainFile) || basename(plainFile) : undefined;
+        // While it writes a testing script, the modules that need it wait for it rather than fail for want of it.
+        const written = kind !== undefined ? writingScript({ project: plainFile !== undefined ? projectDirOf(plainFile) : cwd, kind, ...(stack !== undefined ? { stack } : {}) }) : () => { };
+        const controller = new AbortController();
+        backgroundSkillRuns.set(key, controller);
+        const context = [
+            conversationContext(ctx, params.context),
+            shown !== undefined ? `It is for ${shown}${stack !== undefined ? `, on the stack ${stack}` : ""}.` : undefined,
+            BACKGROUND_NOTE,
+        ]
+            .filter((part) => part !== undefined && part.trim() !== "")
+            .join("\n\n");
+        const filesBefore = projectFiles(cwd);
+        const writes = ["write", "edit", "bash", "change_plain"].some((tool) => skill.allowedTools.includes(tool));
+        const quiet = { step: () => { }, artifact: () => { }, gate: () => { }, judge: () => { }, outcome: () => { } };
+        const about = runDetails(kind, shown);
+        const end = (ended) => skillRunEnds.put(ended.ok
+            ? { skill: skill.name, ok: true, line: doneLine(skill.name, ended.changed, kind), ...about }
+            : { skill: skill.name, ok: false, line: `${skill.name} ${ended.why}.`, task: failedTask(skill.name, ended.why, ended.output, kind), ...about });
+        void captureConsole(() => withStack(stack, () => runSkill({
+            skillDir: skill.dir,
+            signal: controller.signal,
+            cwd,
+            runDir: skillRunDir(cwd, skill.name),
+            report: quiet,
+            context,
+            ...(model !== undefined ? { model } : {}),
+            // Nobody is asked: a gate that cannot be satisfied stands.
+            escalate: async () => false,
+        })))
+            .then(({ result }) => {
+            // Its own: the chat went on meanwhile, and what it wrote is not the run's.
+            const changed = ownChanges(changedFiles(filesBefore, projectFiles(cwd, filesBefore.keys())), kind);
+            if (!result.ok)
+                end({ ok: false, why: "stopped at a review gate, with no approved artifact", output: result.output });
+            else if (writes && changed.length === 0)
+                end({ ok: false, why: "ended having changed no file in the project", output: result.output });
+            else
+                end({ ok: true, changed });
+        })
+            .catch((error) => {
+            // Stopped as turri quits: nobody is left to tell.
+            if (error instanceof JobStoppedError)
+                return;
+            end({ ok: false, why: `failed: ${error instanceof Error ? error.message : String(error)}` });
+        })
+            .finally(() => {
+            backgroundSkillRuns.delete(key);
+            written();
+        });
+        return {
+            text: startedText(skill.name, { ...(model !== undefined ? { model } : {}), ...(shown !== undefined ? { plainFile: shown } : {}), ...(kind !== undefined ? { kind } : {}) }),
+            details: { background: true, ...about },
+        };
+    };
     pi.registerTool({
         name: "cultivate",
         label: "Cultivate",
@@ -674,6 +820,7 @@ function turriExtension(api, session, link) {
             // pi lists .agents/skills among its own skills too: read and followed by hand, a skill's gates would be skipped.
             "A skill cultivate lists may also be among your own skills, from the project's .agents/skills: run it with cultivate all the same, never by reading its SKILL.md and following it.",
             "cultivate returns the reviewed artifact and a trace of every gate decision. Report the artifact to the user; do not rewrite it.",
+            "A skill that runs in the background returns at once: go on with the turn, without waiting or telling the person to wait. Its end comes back to this chat by itself - a line when it did its work, a message to act on when it did not.",
             "If cultivate fails, say so and stop. Never carry out the skill's work yourself in the conversation - the gates and the judges are the point of running it, and an unreviewed hand-run silently drops them.",
             "Always pass `context` to cultivate, summarising what the user has already told you.",
         ],
@@ -694,6 +841,10 @@ function turriExtension(api, session, link) {
             fresh: Type.Optional(Type.Boolean({
                 description: "Start a new run even though an interrupted one exists here, discarding it.",
             })),
+            plainFile: Type.Optional(Type.String({
+                description: "The module the skill's work is for - its .plain file, e.g. backend.plain: a testing script is written for that module's stack, " +
+                    "on its coding model. Omitted: the project's.",
+            })),
         }),
         async execute(_id, params, signal, onUpdate, ctx) {
             const skill = skills.find((s) => s.name === params.skill);
@@ -705,6 +856,23 @@ function turriExtension(api, session, link) {
             }
             if (!gate.mayStart(skill))
                 return { content: [{ type: "text", text: startedByCommandOnly(skill.name) }], details: { notStarted: true } };
+            // The conformance testing script is for conformance tests: none is written while they are off.
+            if (scriptKindOfSkill(skill.name) === "conformance" && !conformanceTestsOnIn(cwd)) {
+                return {
+                    content: [{ type: "text", text: `${skill.name} writes the conformance testing script, and conformance tests are off for this project (conformance-tests: false, or unset). Turn them on first - with ${TURN_ON_TOOL}, once the person asked for them or agreed - then run it. Nothing was started.` }],
+                    details: { notStarted: true },
+                };
+            }
+            const plainFile = params.plainFile !== undefined && params.plainFile.trim() !== "" ? resolve(cwd, params.plainFile.trim()) : undefined;
+            if (plainFile !== undefined && !existsSync(plainFile)) {
+                return { content: [{ type: "text", text: `There is no ${params.plainFile} here. Nothing was started.` }], details: { notStarted: true } };
+            }
+            // A skill that runs in the background, in a chat - where its end can come back to: started, and the turn goes on.
+            if (skill.background && !shouldWait(ctx.mode, undefined)) {
+                gate.started(skill.name);
+                const started = startInBackground(skill, params, plainFile, ctx);
+                return { content: [{ type: "text", text: started.text }], details: started.details };
+            }
             // A new run clears the run folder. An interrupted one is not thrown away by accident:
             // whether to pick it up or start over is the user's call.
             const runDir = skillRunDir(cwd, skill.name);
@@ -846,13 +1014,13 @@ function turriExtension(api, session, link) {
                     push(`  A: ${answer}`);
                     recordExchange(pi, { skill: skill.name, question, answer, ...(said !== undefined && said.trim() !== "" ? { said: said.trim() } : {}) });
                 }, (question) => askOnTheSide(pi, ctx, cwd, jobs, question), dialogs),
-                model: conversationModel(ctx),
+                model: skill.model === "coding" ? jobModel(ctx, "spec_changes", undefined, plainFile) : conversationModel(ctx),
                 // Renders queued by a step land in the same registry as everything else, so
                 // pulses sees them without knowing a skill started them.
                 // Asked per job as it is queued, so a model chosen mid-interview applies from then on.
                 renderQueue: workLoopFor(jobs, cwd, ctx),
                 // The person answers the skill's agent while it runs, so it can take "render these with ..." too.
-                // validate too: a skill validates what it wrote with the same check the conversation has.
+                // parse too: a skill parses what it wrote with the same check the conversation has.
                 sharedTools: [setRenderModelTool(pi, ctx), checkPlainTool(cwd), ...createWebTools()],
                 // The conversation's own regenerate, drift, halt and conform, on its loop: a skill waits for nothing, and regenerates on the model chosen.
                 loopTools: [
@@ -911,9 +1079,14 @@ function turriExtension(api, session, link) {
                     ? "It changed no file in the project - whatever it said it wrote is not there. Say so to the user; do not report the work as done."
                     : "It only reads: what it found is the artifact below.";
             // A skill that edits the specs with the file tools builds nothing: the change is the conversation's to render.
+            // A test plain file is its module's: the module is what regenerate is called for, its scenarios' tests brought up with it.
             const specsChanged = changes.filter((path) => path.endsWith(".plain"));
+            const named = specsChanged.map((path) => {
+                const owner = moduleOfTestPlainFile(resolve(cwd, path));
+                return owner === undefined ? path : `${path} (a test plain file of ${owner.plainFile !== undefined ? relative(cwd, owner.plainFile) : owner.module})`;
+            });
             const unrendered = specsChanged.length > 0 && !skill.allowedTools.includes("change_plain")
-                ? `${specsChanged.join(", ")} changed, and nothing is regenerated from that yet: call regenerate for it, and the code is brought up to the spec.`
+                ? `${named.join(", ")} changed, and nothing is regenerated from that yet: call regenerate for ${named.length === 1 ? "its module" : "their modules"}, and the code and its conformance tests are brought up to the spec.`
                 : "";
             const gated = skill.steps.some((step) => step.gate !== undefined);
             const first = skill.allowedTools.includes("change_plain") ? firstRegeneration(jobs.list(), began) : {};
@@ -955,7 +1128,7 @@ function registerRegenerate(pi, cwd, jobs) {
     // by the planner: one functional spec at a time, a few together or the whole module in one, as it judges. What
     // follows the module is guidance for that plan, in the person's words.
     pi.registerCommand("regenerate", {
-        description: "Regenerate a module from its ***plain as it is now, in pulses the planner cuts - named functionalities though they did not change, or all of it from scratch, its whole chain too when asked: /regenerate [module | file.plain] [functionality ...] [from scratch [whole chain]] [how to cut the work]",
+        description: "Regenerate a module from its ***plain as it is now, in pulses the planner cuts - named functional specs though they did not change, or all of it from scratch, its whole chain too when asked: /regenerate [module | file.plain] [module:func-id ...] [from scratch [whole chain]] [how to cut the work]",
         handler: async (args, ctx) => {
             const command = `/regenerate ${args.trim()}`.trim();
             await echoCommand(pi, command);
@@ -967,11 +1140,11 @@ function registerRegenerate(pi, cwd, jobs) {
                 say(`There is no ${first} here.`, "error");
                 return;
             }
-            // Functionalities named first, by id - 3, 2.1, fs 4 - as on the command line; what follows them is guidance.
+            // Functional specs named first, each as module:func-id, as on the command line; what follows them is guidance.
             const words = rest;
             const again = [];
-            while (words.length > 0 && /^(fs)?\d+(\.\d+)*,?$/i.test(words[0]))
-                again.push(words.shift().replace(/^fs/i, "").replace(/,$/, ""));
+            while (words.length > 0 && /^[^\s:]+:[a-z0-9-]+,?$/.test(words[0]))
+                again.push(words.shift().replace(/,$/, ""));
             const guidance = words.join(" ").trim();
             let plainFile = named;
             if (plainFile === undefined) {
@@ -992,7 +1165,7 @@ function registerRegenerate(pi, cwd, jobs) {
             }
             const check = checkPlainFile(plainFile);
             if (!check.ok) {
-                say(`${relative(cwd, plainFile) || plainFile} does not parse, so nothing can be regenerated from it yet: ${check.error}`, "error");
+                say(`${relative(cwd, plainFile) || plainFile} does not parse, so nothing can be regenerated from it yet:\n${formatCheckResults([check])}`, "error");
                 return;
             }
             // From scratch - started over, its code deleted - asked in the person's words: started at once, as asked.
@@ -1001,7 +1174,7 @@ function registerRegenerate(pi, cwd, jobs) {
             const chain = scratch && asksWholeChain(guidance);
             const module = basename(plainFile).replace(/\.plain$/, "");
             if (scratch && again.length > 0) {
-                say("Name functionalities or ask for it from scratch, not both: from scratch regenerates every one of them.", "warning");
+                say("Name functional specs or ask for it from scratch, not both: from scratch regenerates every one of them.", "warning");
                 return;
             }
             const loop = workLoopFor(jobs, cwd, ctx);
@@ -1012,7 +1185,7 @@ function registerRegenerate(pi, cwd, jobs) {
             say(scratch
                 ? `Deleting ${module}'s code${chain ? " and its whole chain's" : ""}, then planning all of it again…`
                 : again.length > 0
-                    ? `Planning ${module}'s functionalit${again.length === 1 ? "y" : "ies"} ${again.join(", ")} again…`
+                    ? `Planning ${again.join(", ")} again…`
                     : `Planning ${module}'s pulses…`, "info");
             await nextFrame();
             // Planned in the background: pi reads what is typed next only once a command returns, and planning takes the
@@ -1029,7 +1202,7 @@ function registerRegenerate(pi, cwd, jobs) {
                     // Nothing to do: say how to build it again anyway.
                     const upToDate = statuses.length > 0 && statuses.every(isUpToDate);
                     const hint = upToDate
-                        ? `\nTo regenerate parts of it anyway, name their functionalities - /regenerate ${basename(target)} 2.1 - or start over with /regenerate ${basename(target)} from scratch.`
+                        ? `\nTo regenerate parts of it anyway, name their functional specs - /regenerate ${basename(target)} ${module}:<func-id> - or start over with /regenerate ${basename(target)} from scratch.`
                         : "";
                     // Pulses started: the agent says so, and that the person need not wait - a plan alone leaves the chat silent.
                     shownAfterCommand(pi, ctx, command, describeModules(statuses) + hint, "info", true, upToDate ? undefined : COMMAND_STARTED_REACTION);
@@ -1109,7 +1282,8 @@ export function moduleNamedFirst(cwd, words) {
 function plainFileNamed(cwd, word) {
     for (const candidate of [word, `${word}.plain`]) {
         const path = resolve(cwd, candidate);
-        if (path.endsWith(".plain") && existsSync(path))
+        // A test plain file names no module: it is refused where the module is taken.
+        if (path.endsWith(".plain") && existsSync(path) && testPlainFileRefusal(path) === undefined)
             return path;
     }
     return undefined;
@@ -1135,31 +1309,27 @@ function conformTool(options) {
     return defineTool({
         name: "conform",
         label: "Conform",
-        description: "Write and run the black-box conformance tests of a module's functional specs - the ones named, or every one - on " +
-            "the code as it is built, in a pulse of their own - every functional spec tested in one, as far as a size guardrail " +
-            "lets, or one a functional spec when the user asks for that: each writes its tests from the spec's test reqs and acceptance " +
-            "tests, runs them with the whole suite the module inherits, and, where one fails, fixes the test or the code, " +
-            "whichever is wrong. What they are written for is recorded apart from the code. For this session, whatever the " +
-            "config's conformance-tests says. Functional specs not built yet can be named: the conformance pulse is scheduled at " +
-            "once and starts when the module's code is built - every code pulse of it landed - before anything is built on it. A functional spec " +
-            "the spec does not have, or a module without test reqs, is refused. A conformance pulse checks, as it starts, that " +
-            "the code record has every functional spec it tests, and does not start otherwise.",
-        promptSnippet: "conform: write and run conformance tests for functional specs - now, or ahead of their code",
+        description: "Write and run the black-box conformance tests of a module's functional specs - the ones named, or every one with " +
+            "scenarios - on the code as it is built, in a pulse of their own - every functional spec tested in one, as far as a size " +
+            "guardrail lets, or one a functional spec when the user asks for that: each implements exactly the functional spec's " +
+            "conformance and acceptance scenarios, at least one test each, by the spec's test reqs, runs them with the whole suite " +
+            "the module inherits, and, where one fails, fixes the test or the code, whichever is wrong. What they are written for is " +
+            "recorded apart from the code. The work loop starts these pulses by itself for every functional spec with scenarios whose " +
+            "tests are behind, once the module's code is built; conform starts them now, or for the functional specs named - those alone: the module's others stay behind until conform names none, or the module is regenerated. A " +
+            "functional spec with no scenarios - no test plain file - is refused: there is nothing to test until scenarios " +
+            "are written. So is one the spec does not have, and a module with scenarios that skipped a step of adding tests - " +
+            "no test reqs, or no conformance testing script for its stack: the refusal names the next step.",
+        promptSnippet: "conform: write and run the conformance tests of functional specs with scenarios",
         promptGuidelines: [
-            "When the user asks for conformance tests - for a module, or some of its functional specs - call conform. Never edit config.turri.yaml for it, and never regenerate a functionality to get them.",
-            "Under conformance-tests: chosen or module, the chooser decides which functional specs get conformance tests - under chosen as each code pulse ends, under module once the whole module is regenerated - and a pulse's report says what it chose and why. You do not choose them: call conform only when the user asks for conformance tests. The ones named are added to those chosen before; a functional spec tested already keeps its tests.",
-            "What the user asks for comes first: for a module already regenerated, while a module built on it is being regenerated, conform stops that pulse, deletes the codebase built on it, writes the tests, and the module above is regenerated from it after - say so. For a module not regenerated yet - one above the one being regenerated - the tests are scheduled now and written once its code is built, before anything is built on it.",
+            "What is tested is the scenarios: a functional spec's conformance and acceptance scenarios, in its test plain file, tests/<module>/<func-id>.plain. When the user asks for conformance tests, decide in a sentence or two which scenarios to write, and write them with change_plain - a test plain file's ***conformance tests*** and ***acceptance tests***, each scenario a # <scenario-id> heading and its text. Every scenario written is tested once the code is built: the loop starts the conformance pulse by itself. Never edit config.turri.yaml for it, and never regenerate a functionality to get them.",
+            "Call conform when the user asks for the conformance tests to be written or run now, for a module or some of its functional specs with scenarios.",
+            "What the user asks for comes first: for a module already regenerated, while a module built on it is being regenerated, conform stops that pulse, deletes the codebase built on it, writes the tests, and the module above is regenerated from it after - say so. For a module not regenerated yet, its tests are written once its code is built, before anything is built on it.",
             "Conformance tests go in one pulse for all the functional specs tested. Set one_by_one only when the user asks for a pulse a functional spec - one at a time, separately, or the like.",
-            "When the user asks for the conformance tests in pulses of their own grouping - 1-3 and 4-6 - pass those groups as groups, in one call: each group is a pulse of its own, never sharing one with another. Without groups, every functional spec named goes in one pulse.",
-            "A conformance pulse that did not start because its code is not built: tell the user which functional specs it waits for, and which code pulse builds them.",
         ],
         parameters: Type.Object({
             plain_file: Type.String({ description: "A .plain file of the module" }),
             working_dir: WORKING_DIR_PARAM,
-            frids: Type.Optional(Type.Array(Type.String(), { description: "The functional specs to test, by id - added to those chosen before. Omitted: every one" })),
-            groups: Type.Optional(Type.Array(Type.Array(Type.String()), {
-                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",
-            })),
+            funcIds: Type.Optional(Type.Array(Type.String(), { description: "The functional specs to test, each as module:func-id (todo:add-task) - each with scenarios. Omitted: every one with scenarios" })),
             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,
@@ -1168,12 +1338,12 @@ function conformTool(options) {
         async execute(_id, given, _signal, _onUpdate, ctx) {
             const params = fromWorkingDir(cwd, given);
             const plainFile = resolve(params.base, params.plain_file);
+            refuseTestPlainFile(plainFile);
             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 } : {}),
+                    ...(params.funcIds !== undefined ? { funcIds: params.funcIds } : {}),
                     ...(model !== undefined ? { model } : {}),
                     ...(params.one_by_one === true ? { separately: true } : {}),
                 });
@@ -1201,6 +1371,7 @@ function registerGlimpse(pi, cwd, jobs) {
         async execute(_id, given, _signal, _onUpdate, ctx) {
             const params = fromWorkingDir(cwd, given);
             const plainFile = resolve(params.base, params.plain_file);
+            refuseTestPlainFile(plainFile);
             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);
@@ -1363,15 +1534,9 @@ export function projectConfigBlock(root) {
             heading,
             ...[
                 config.module !== undefined && of !== "stack" ? `- module: ${config.module}${where} - the module to build when the user does not name one.` : undefined,
-                config.conformanceTests === false
-                    ? "- conformance-tests: false - conformance tests are OFF: no new ones are written, unless the user asks for them in this conversation. The ones there are are kept up to date: a functional spec that has conformance tests and is regenerated - changed, regenerated again or taken out - gets a conformance pulse for it alone once its code lands. A functional spec with none gets none."
-                    : config.conformanceTests === "chosen"
-                        ? "- conformance-tests: chosen - conformance tests are on for the functional specs chosen: those with acceptance tests always, those the chooser picks as each code pulse ends from what it regenerated, and those the user asks for with conform. A conformance pulse starts once the module's code is built, before anything is built on it. Once chosen, a functional spec keeps them."
-                        : config.conformanceTests === "module"
-                            ? "- conformance-tests: module - conformance tests are on for the functional specs chosen: those with acceptance tests always, those the chooser picks - and plans into pulses - once the whole module is regenerated, and those the user asks for with conform. They run before anything is built on the module. Once chosen, a functional spec keeps them."
-                            : config.conformanceTests === true
-                                ? "- conformance-tests: all - conformance tests are on, for every functional spec of every module that has test reqs."
-                                : "- conformance-tests: not set - conformance tests are OFF, as with false: no new ones are written, unless the user asks for them in this conversation; the ones there are are kept up to date - a functional spec that has them and is regenerated gets a conformance pulse for it alone once its code lands.",
+                of !== "stack"
+                    ? "- conformance tests: written for every functional spec with scenarios - the conformance and acceptance scenarios of its test plain file - once the module's code is built, before anything is built on it. A functional spec with an empty test plain file is not tested. To have one tested, write its scenarios with change_plain."
+                    : undefined,
                 config.review === true
                     ? "- review: true - the code and its tests are reviewed once they pass: two reviews at most, the arbiter weighing the second."
                     : `- review: ${config.review === false ? "false" : "not set, so off"} - the code and its tests are not reviewed: a pulse lands once its tests pass.`,
@@ -1444,6 +1609,27 @@ function chatModelOf(ctx) {
     }
 }
 let lastChatModel;
+/**
+ * Conformance tests turned on, for the session: `conformance-tests: true` written where the module's value comes from
+ * (conformance-switch.ts), and every open chat's tools switched to match - what the chat's turn_on_conformance_tests and a
+ * host's turnOnConformanceTests both do. `plainFile`, absolute or from the project, picks the module whose stack's file
+ * is written when that names the key. Returns the file written, from the project. Starts no conformance pulse.
+ */
+export function turnOnConformance(core, plainFile) {
+    const file = turnOnConformanceTests(core.cwd, plainFile !== undefined && plainFile.trim() !== "" ? resolve(core.cwd, plainFile) : undefined);
+    for (const chat of core.chats()) {
+        const live = core.session(chat.id);
+        try {
+            (live !== undefined ? core.chatOfSession(live) : undefined)?.instance?.conformanceSwitched?.();
+        }
+        catch {
+            /* a chat let go: its next turn sets its tools */
+        }
+    }
+    return file;
+}
+/** The skills running in the background, by project and skill - one at a time each, whichever chat started it - with what stops them. */
+const backgroundSkillRuns = new Map();
 /** The models chosen in this session, by kind of work - for every chat. Saved in the chat they were chosen in, so reopening it keeps them. */
 const chosenModels = {};
 /** When they were last chosen: a chat reopened with older choices of its own leaves them be. */
@@ -1459,6 +1645,17 @@ const MODEL_CHOICE_ENTRY = "turri_render_models";
  * of work, or the project's - `model:` in config.turri.yaml - or the conversation's.
  */
 function jobModel(ctx, work, named, plainFile) {
+    const model = jobModelOf(ctx, work, named, plainFile);
+    // The AWS region worked out again, with every model a job ran on this session: the config's may have changed since,
+    // and one chosen in the session counts as the config's do - two needing two regions are said, not flipped between.
+    if (model !== undefined)
+        jobModels.add(model);
+    applyBedrockRegion(plainFile !== undefined ? projectDirOf(plainFile) : process.cwd(), { also: [...jobModels] });
+    return model;
+}
+/** Every model a job ran on in this session. */
+const jobModels = new Set();
+function jobModelOf(ctx, work, named, plainFile) {
     if (named !== undefined && named.trim() !== "") {
         const resolved = resolveModel(named, ctx.modelRegistry);
         if (!resolved.ok)
@@ -1613,6 +1810,12 @@ const workLoops = new WeakMap();
 const steeringStore = createSteeringStore();
 /** What release has shipped in a conversation, by its jobs: shared by the chat's release and a pulse's own. */
 const deployStates = new WeakMap();
+/** A session's test advisor, by its jobs - only a chat's or a host's has one. */
+const advisors = new WeakMap();
+/** The session's test advisor, when it has one: the chat's and a host's - never pi's print, json and rpc modes'. */
+export function sessionAdvisor(session) {
+    return advisors.get(session.jobs);
+}
 function workLoopFor(jobs, cwd, ctx) {
     let shared = workLoops.get(jobs);
     if (shared === undefined) {
@@ -1623,11 +1826,10 @@ function workLoopFor(jobs, cwd, ctx) {
             modelFor: (plainFile) => modelFor(chosenModels, "spec_changes", projectModel(from.ctx, plainFile) ?? chatModelOf(from.ctx)),
             // The planner reasons about the whole of the work: it runs on the chat's model.
             plannerModel: () => chatModelOf(from.ctx),
-            // Under conformance-tests: chosen or module, the chooser decides as a pulse ends - on the chat's model - so the choice
-            // is made before anything is built on the module; the pulse's report says what it chose, and why.
-            onChoose: conformanceChooser({ model: () => chatModelOf(from.ctx) }),
             // How the work is to be planned: the conversation's steering, and AGENTS.md's - read afresh each plan.
             steering: (plainFile) => steeringFor(plainFile, cwd, steeringStore),
+            // What the loop looks at, the test advisor sees - in a session that has one.
+            onSpec: (seen) => advisors.get(jobs)?.seen(seen),
             // Under release-after-pulse, a pulse releases what it landed itself, before the next starts - on the model that
             // regenerated it: a release follows steps, and a small model thinking little does that well.
             release: ({ plainFile, moduleName, title, onDelta }) => {
@@ -1642,6 +1844,7 @@ function workLoopFor(jobs, cwd, ctx) {
                 });
             },
         });
+        bindAdvisor(loop, () => advisors.get(jobs));
         shared = { loop, from };
         workLoops.set(jobs, shared);
     }
@@ -1905,7 +2108,7 @@ function registerJobTools(pi, jobs, cwd) {
     // start changed here, as it runs.
     registerTurriConfig(pi, {
         cwd,
-        rules: () => loadRules(join(PACKAGE_ROOT, "genome", "rules")).map((rule) => rule.name),
+        rules: ruleNames,
         chatSpec: () => modelSpec(projectModels(readProjectConfig(cwd)).harness),
         live: {
             chatModel: async (spec, ctx) => {
@@ -2132,7 +2335,7 @@ function sidePanelOf(jobs, cwd) {
                     warning: (text) => theme.fg("warning", text),
                     added: (text) => theme.fg("toolDiffAdded", text),
                     removed: (text) => theme.fg("toolDiffRemoved", text),
-                    // A spec diff's ***plain highlighted as plyn highlights it, and its added and removed lines filled.
+                    // A spec diff's ***plain highlighted by turri's grammar, and its added and removed lines filled.
                     diff: plainPaint(theme),
                     // What conformance tests show does what its spec says: neon.
                     conforms: brandNeon(theme),
@@ -2319,7 +2522,7 @@ function jobLines(all) {
         .join("\n");
 }
 /**
- * Static validation of a ***plain specification.
+ * The ***plain parsed - its syntax and structure - regenerating nothing.
  *
  * This is the check that used to mean a renderer dry-run. It runs this repo's own parser,
  * so it needs no external tool, no API key and no credits - and it is the only honest way
@@ -2484,32 +2687,6 @@ function registerDeploy(pi, cwd, jobs, state) {
             await stopDeployed();
     });
 }
-/** validate, for the conversation and for the skills that write specs alike. */
-function checkPlainTool(cwd) {
-    return defineTool({
-        name: "validate",
-        label: "Validate spec",
-        description: "Validate one or more .plain specifications without rendering: parses each file, resolves its " +
-            "imports and required modules, and reports every syntax, concept and structure error with the " +
-            "line it is on. Pass a directory to check every .plain file in it. Fast, free, and offline.",
-        promptSnippet: "validate a .plain spec, regenerating nothing",
-        promptGuidelines: [
-            "Run validate after editing a .plain file, and before telling the user a spec is valid or ready. Never shell out to another renderer to check one.",
-        ],
-        parameters: Type.Object({
-            target: Type.String({ description: "A .plain file, or a directory holding .plain files" }),
-            template_dir: Type.Optional(Type.Array(Type.String(), { description: "Extra template directories" })),
-        }),
-        async execute(_id, params) {
-            const results = checkPlainTargets(resolve(cwd, params.target), (params.template_dir ?? []).map((dir) => resolve(cwd, dir)));
-            const failed = results.filter((result) => !result.ok).length;
-            const text = results.length === 0
-                ? `No .plain files found in ${params.target}.`
-                : `${formatCheckResults(results)}\n\n${failed === 0 ? "All specs valid." : `${failed} of ${results.length} failed.`}`;
-            return { content: [{ type: "text", text }], details: { failed, checked: results.length } };
-        },
-    });
-}
 const MILESTONE_ENTRY = "turri_milestone";
 const JOB_ENTRY = "turri_job";
 const JOBS_LIST_ENTRY = "turri_jobs";
@@ -2551,7 +2728,7 @@ function specConflictTask(conflict) {
         describeSpecConflict(conflict),
         "",
         `The render stopped on it: the conformance run's judge found them conflicting, ${conflict.reasons.length} times -`,
-        `functional spec ${one.frid} of ${one.module} (${one.plainFile}) and functional spec ${two.frid} of ${two.module} (${two.plainFile}). Now:`,
+        `functional spec ${one.module}:${one.funcId} (${one.plainFile}) and functional spec ${two.module}:${two.funcId} (${two.plainFile}). Now:`,
         "1. Run the analyze-2-func-specs skill (cultivate) on these two functional specs, to confirm they conflict.",
         "2. If they do, run the resolve-spec-conflict skill on the pair, to work out what could be changed - but change nothing yet.",
         "3. Tell the user exactly what the conflict is - both specs as they read, and the behaviour that cannot satisfy both -",
@@ -2724,7 +2901,7 @@ function registerBranding(pi, skills) {
         const lines = [
             `${brandPink(theme)("turri")}  ${theme.fg("muted", `v${data.version}`)}` +
                 (data.commit !== undefined ? theme.fg("dim", `  from a clone, ${data.commit}${data.changed ? " with changes" : ""}`) : ""),
-            theme.fg("text", "the first coding agent with the power of regenerative software"),
+            `${theme.fg("text", "the first coding agent with the power of ")}${brandPink(theme)("regenerative software")}`,
             // Where the settings are changed, without leaving the chat.
             theme.fg("muted", "configure with /turri-config"),
             // Only what is wrong: skills that did not load, and agents' commands less fenced than they should be.