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

package/dist/host-session.d.ts

@@ -1,6 +1,7 @@
 import { type AgentSession, type ExtensionFactory, type ExtensionUIContext } from "@earendil-works/pi-coding-agent";
 import type { AskUserIO } from "./ask.ts";
 import { type ChatInfo, type TurriHost } from "./chats.ts";
+import { type EvaluateOutcome } from "./advisor-chat.ts";
 import type { JobRegistry } from "./regenerate/jobs.ts";
 import type { WorkLoop } from "./regenerate/loop.ts";
 import type { Notice, NoticeAnswer } from "./notice.ts";
@@ -66,6 +67,31 @@ export interface Turri {
      * hears each as it is put (`onNotice`) and as it ends (`onNoticeOver`).
      */
     notices(): Notice[];
+    /**
+     * The test advisor asked to evaluate functional specs, as the chat's `evaluate_tests` does - for a host's own way in,
+     * a button on a functional spec: `module:func-id`s, or func-ids of `plainFile`'s module, even a text judged already and
+     * whatever `test-advisor` says, `reason` given to it as context. It returns at once; each verdict comes to the chat the
+     * person looks at, as the advisor's verdicts do - a yes starting a turn that writes the scenarios, a no a line.
+     */
+    evaluateTests(funcIds: string[], options?: {
+        plainFile?: string;
+        reason?: string;
+    }): EvaluateOutcome;
+    /**
+     * Every value /turri-config offers for a setting after `typed` - what its completions compute, in their order, but
+     * whole: uncapped, and without "unset", which a host draws itself; the values alone, not `<key> <value>`. A model
+     * setting's are every model of every provider signed in to, from the model registry the chats use - and after a colon,
+     * `harness-model amazon-bedrock/global.anthropic.claude-opus-5-5:`, that model's thinking levels. An unknown key gives none.
+     */
+    settingChoices(key: string, typed?: string): string[];
+    /**
+     * Conformance tests turned on, as the chat's turn_on_conformance_tests does: `conformance-tests: true` written where
+     * the module's value comes from - its stack's `config.turri.<stack>.yaml` when that sets the key, else
+     * `config.turri.yaml` - and every open chat's tools switched (conform and evaluate_tests in, turn_on_conformance_tests
+     * out), the test advisor starting at its next look. `plainFile`, absolute or from the project, picks the module; omitted,
+     * the project's. Returns the file written, from the project. Starts no conformance pulse: that is `conform`'s.
+     */
+    turnOnConformanceTests(plainFile?: string): string;
     /**
      * A notice answered: one of its actions (by index or label) - the chat it is in started on it - the person's own words
      * about it, dismissed, or - `ignorable: true` - ignored for good: left as the build has it, the sentinel told not to

package/dist/host-session.js

@@ -1,12 +1,15 @@
 import { createAgentSession, DefaultResourceLoader, getAgentDir, SessionManager } from "@earendil-works/pi-coding-agent";
 import { lastRun } from "./chat-records.js";
 import { interruptChat } from "./chats.js";
-import { createTurriCore, sessionLoop } from "./extension.js";
+import { evaluateTests } from "./advisor-chat.js";
+import { reachable, ruleNames, settingCandidates } from "./config-command.js";
+import { settingOf } from "./config-edit.js";
+import { createTurriCore, sessionAdvisor, sessionLoop, turnOnConformance } from "./extension.js";
 import { stopDeployed } from "./regenerate/release.js";
 /** turri's session in a host, in the process's working folder - the project's. */
 export async function createTurri(options = {}) {
     const { dialogs, uiContext, extensions = [], agentDir = getAgentDir(), sessionDir, restore, ...host } = options;
-    const core = createTurriCore(host, { persist: true, ...(dialogs !== undefined ? { dialogs } : {}) });
+    const core = createTurriCore(host, { persist: true, advisor: true, ...(dialogs !== undefined ? { dialogs } : {}) });
     const cwd = core.cwd;
     core.setDriver({
         async create(chat, sessionFile) {
@@ -68,6 +71,31 @@ export async function createTurri(options = {}) {
         },
         decline: async (id) => core.decline(id),
         notices: () => core.notices(),
+        evaluateTests: (funcIds, options) => evaluateTests(cwd, sessionAdvisor(core), funcIds, options),
+        turnOnConformanceTests: (plainFile) => turnOnConformance(core, plainFile),
+        settingChoices: (key, typed = "") => {
+            const setting = settingOf(key, ruleNames());
+            if (setting === undefined)
+                return [];
+            // The models from a chat's own context - the one shown, else any open: the registry the chats use, whether or not one
+            // has run /turri-config.
+            const context = () => {
+                const shown = core.shownChat();
+                const states = [shown, ...core.chats().map((chat) => core.session(chat.id)).map((session) => (session !== undefined ? core.chatOfSession(session) : undefined))];
+                for (const state of states) {
+                    try {
+                        const context = state?.instance?.context();
+                        if (context !== undefined)
+                            return context;
+                    }
+                    catch {
+                        /* a context let go: the next one */
+                    }
+                }
+                return undefined;
+            };
+            return settingCandidates(setting, typed, { cwd, models: () => reachable(context()) });
+        },
         answer: async (id, answer) => core.answer(id, answer),
         onChats: (listener) => core.onChats(() => listener(core.chats())),
         dispose,

package/dist/host.d.ts

@@ -10,9 +10,10 @@ export { SENTINEL, SENTINEL_START, type Conclusion, type Notice, type NoticeActi
 export type { AskUserIO } from "./ask.ts";
 /** pi itself, as turri is built against it: a host's own extensions and UI are made with this one, not another copy. */
 export * as pi from "@earendil-works/pi-coding-agent";
-export { configForSpec, debugMode, hasProjectConfig, modelSpec, projectModels, readProjectConfig, stacksOf, type ProjectConfig } from "./config.ts";
+export { configForSpec, debugMode, DEFAULT_TEST_DIR, hasProjectConfig, modelSpec, projectModels, readProjectConfig, stacksOf, testDirOf, type ProjectConfig } from "./config.ts";
 export { MODULES_DIR, projectDirOf, resolveTemplateDirs } from "./regenerate/paths.ts";
 export { configSettings, currentValue, EFFECT_TEXT, overriddenBy, readConfigText, type Effect, type Setting, type SettingKind } from "./config-edit.ts";
+export { bedrockRegionFor, type BedrockRegion, type BedrockRegionSource } from "./bedrock-region.ts";
 export { BEDROCK_DEFAULT, BEDROCK_GEOGRAPHIES, BEDROCK_IN_REGION, BEDROCK_REGIONS, bedrockAwsRegion, bedrockDefaultModels, bedrockMakers, bedrockModels, bedrockModelsIn, bedrockNeedsAwsRegion, bedrockPlaceOf, initConfig, makerLabel, VENDORS, type BedrockChoice, type BedrockMaker, type BedrockOffer, type InitConfigOptions, type ModelChoice, type ModelSet, type Vendor, } from "./init-config.ts";
 export { piModelCatalogue, type CatalogueModel, type ModelCatalogue } from "./model-check.ts";
 export { doctor, type Check, type DoctorOptions, type Level } from "./setup.ts";
@@ -22,11 +23,13 @@ export { FUNCTIONAL_REQUIREMENTS, iterateFunctionalSpecs } from "./plain/spec.ts
 export { highlightLines, roleOf, type PlainRole } from "./plain/highlight.ts";
 export { conceptsOf, type ModuleConcept } from "./plain/module-concepts.ts";
 export { conceptBeingTyped, findConcepts } from "./plain/concepts.ts";
-export { plainGraph, type PlainConceptNode, type PlainGraph, type PlainItemNode, type PlainLink, type PlainModuleNode, type PlainSection } from "./plain/graph.ts";
+export { plainGraph, type PlainConceptNode, type PlainGraph, type PlainItemNode, type PlainLink, type PlainModuleNode, type PlainScenario, type PlainSection, type PlainTestPlainFileNode } from "./plain/graph.ts";
 export { isStack, STDLIB_KINDS, stdlibTemplates, type StdlibKind, type StdlibTemplate } from "./stdlib.ts";
 export { createWorkLoop, describeModules, functionalityCompletion, promptOf, type DriftReport, type ModuleStatus, type WorkLoop } from "./regenerate/loop.ts";
 export { createJobRegistry, defaultParallelJobs, type Job, type JobRegistry, type PulseCases, type PulseSpec } from "./regenerate/jobs.ts";
 export { describeTurnIncident, onModelEvent, type TranscriptEntry } from "./regenerate/activity.ts";
 export { sweepOrphanedGroups } from "./regenerate/shell.ts";
+export { readAdvisor, textHash, type AdvisorEntry, type AdvisorFile, type AdvisorReport, type AdvisorState } from "./regenerate/advisor-records.ts";
+export type { EvaluateOutcome } from "./advisor-chat.ts";
 export { ledgerDir, onLedgerEvent, readLedger, type AgentRef, type LedgerEntry, type LedgerEvent, type LedgerKind, type LedgerQuery } from "./regenerate/ledger.ts";
 export { asJob, describePulseView, describeRuns, earlierPulses, ledgerProjects, pulseView, runViews, type PulseView, type RunView } from "./regenerate/ledger-view.ts";

package/dist/host.js

@@ -12,11 +12,14 @@ export { SENTINEL, SENTINEL_START } from "./notice.js";
 /** pi itself, as turri is built against it: a host's own extensions and UI are made with this one, not another copy. */
 export * as pi from "@earendil-works/pi-coding-agent";
 // The project and its settings.
-export { configForSpec, debugMode, hasProjectConfig, modelSpec, projectModels, readProjectConfig, stacksOf } from "./config.js";
+export { configForSpec, debugMode, DEFAULT_TEST_DIR, hasProjectConfig, modelSpec, projectModels, readProjectConfig, stacksOf, testDirOf } from "./config.js";
 export { MODULES_DIR, projectDirOf, resolveTemplateDirs } from "./regenerate/paths.js";
 // Every setting of config.turri.yaml as /turri-config knows it - what it takes, what it is unset, when a change takes
 // effect - and what the file has now: for a host that shows them all, changing each through /turri-config.
 export { configSettings, currentValue, EFFECT_TEXT, overriddenBy, readConfigText } from "./config-edit.js";
+// The AWS region a project's Bedrock models are called in, and where it comes from - what turri sets itself, as a host's
+// session starts, when the models need one and the person set none.
+export { bedrockRegionFor } from "./bedrock-region.js";
 // A project's first config.turri.yaml, as `turri init-config` writes it - the vendor, or the two models themselves, chosen by the host.
 export { BEDROCK_DEFAULT, BEDROCK_GEOGRAPHIES, BEDROCK_IN_REGION, BEDROCK_REGIONS, bedrockAwsRegion, bedrockDefaultModels, bedrockMakers, bedrockModels, bedrockModelsIn, bedrockNeedsAwsRegion, bedrockPlaceOf, initConfig, makerLabel, VENDORS, } from "./init-config.js";
 // pi's model catalogue, read without a request: what initConfig checks the models given against, and what a host offers.
@@ -41,6 +44,9 @@ export { createWorkLoop, describeModules, functionalityCompletion, promptOf } fr
 export { createJobRegistry, defaultParallelJobs } from "./regenerate/jobs.js";
 export { describeTurnIncident, onModelEvent } from "./regenerate/activity.js";
 export { sweepOrphanedGroups } from "./regenerate/shell.js";
+// The test advisor: what it made of each functional spec of a module - pending, yes, no or failed, with its report - by
+// func-id, an entry current while its hash is textHash of the functional spec's text; and what an evaluation came to.
+export { readAdvisor, textHash } from "./regenerate/advisor-records.js";
 // What turri did, as facts: the ledger, heard live and read back - this session's pulses and every earlier one's.
 export { ledgerDir, onLedgerEvent, readLedger } from "./regenerate/ledger.js";
 export { asJob, describePulseView, describeRuns, earlierPulses, ledgerProjects, pulseView, runViews } from "./regenerate/ledger-view.js";

package/dist/init-config.d.ts

@@ -108,12 +108,12 @@ export declare function withModels(text: string, lines: [string, string]): strin
  * must stay what the code falls back to - tests/init-config.test.ts holds them to the constants they mirror.
  */
 export declare const DEFAULTS: {
-    readonly conformanceTests: false;
     readonly review: false;
     readonly mutationTesting: true;
     readonly allowToStopJobs: true;
     readonly releaseAfterPulse: true;
     readonly sentinel: "ask";
+    readonly testAdvisor: true;
     readonly testingScriptsRunOn: "in-place";
     readonly turnLimit: 120;
     readonly compactAt: 100000;

package/dist/init-config.js

@@ -215,12 +215,12 @@ export function withModels(text, lines) {
  * must stay what the code falls back to - tests/init-config.test.ts holds them to the constants they mirror.
  */
 export const DEFAULTS = {
-    conformanceTests: false,
     review: false,
     mutationTesting: true,
     allowToStopJobs: true,
     releaseAfterPulse: true,
     sentinel: "ask",
+    testAdvisor: true,
     testingScriptsRunOn: "in-place",
     turnLimit: 120,
     compactAt: 100000,
@@ -247,10 +247,10 @@ export function quickStartConfig(vendor = "other", bedrock, models) {
         "# built: change one to change it. The optional ones, which have no value of their own, are commented out - uncomment",
         "# one to use it. docs/config.md has them all.",
         "",
-        "# Conformance tests: all (or true) - every functional spec of a module with test reqs; chosen - those with acceptance",
-        "# tests and those the chooser picks as each pulse ends; module - the chooser picks, and plans them, once the whole",
-        "# module is regenerated; false - none written or run. Those you ask for are written under any of them.",
-        `conformance-tests: ${DEFAULTS.conformanceTests}`,
+        "# Whether functional specs are conformance tested: black-box tests of the built software against the scenarios of",
+        "# their test plain files, run with the whole suite as more lands. false: none - no scenarios written or tested, the",
+        "# test advisor off. Asking for them in the chat turns them on, or true here.",
+        "conformance-tests: false",
         "",
         "# Whether the code and its tests are reviewed once they pass - two reviews at most, the second weighed by the arbiter.",
         `review: ${DEFAULTS.review}`,
@@ -270,6 +270,11 @@ export function quickStartConfig(vendor = "other", bedrock, models) {
         "# before it first opens in a session; true: it opens without asking; false: none.",
         `sentinel: ${DEFAULTS.sentinel}`,
         "",
+        "# Whether turri checks, in the background, each new or changed functional spec with no scenarios - could it fail",
+        "# silently, be read two ways, cost a lot when wrong - and when it needs testing, writes its test reqs, conformance",
+        "# testing script and scenarios itself. false: only the scenarios you ask for are written.",
+        `test-advisor: ${DEFAULTS.testAdvisor}`,
+        "",
         "# What the testing scripts run on: in-place - the code itself; copy - a fresh copy of it.",
         `testing-scripts-run-on: ${DEFAULTS.testingScriptsRunOn}`,
         "",
@@ -323,9 +328,13 @@ export function quickStartConfig(vendor = "other", bedrock, models) {
         "# Optional: the .plain file turri regenerate builds when none is named.",
         "# module: app.plain",
         "",
-        "# Optional, under conformance-tests: chosen or module: how many functional specs of a module may be chosen - a count or a share.",
-        "# Without it, any number.",
-        "# conformance-budget: 30%",
+        "# Optional: the folder of the test plain files - a functional spec's conformance and acceptance scenarios - a folder",
+        "# per module in it: tests/<module>/<func-id>.plain. Without it, tests.",
+        "# test-dir: tests",
+        "",
+        "# Optional: a folder the code starts from - an existing codebase to build on, or files to use, such as images. It is",
+        "# copied in once, before the first pulse, and never written to; the ***plain can refer to it, and link into it.",
+        "# base-folder: existing-app",
         "",
         "# Optional: the judge and test review of a conformance run, when not on coding-model. A model is provider/id,",
         "# provider/id:thinking, or { model, thinking } - thinking is off, minimal, low, medium, high, xhigh or max.",
@@ -337,7 +346,6 @@ export function quickStartConfig(vendor = "other", bedrock, models) {
         `#   default: ${coding}`,
         `${column(`#   chat: ${harness}`, 72)}# the conversation - as harness-model, which it wins over`,
         `${column(`#   sentinel: ${harness}`, 72)}# the sentinel: checks every finished pulse and tests the release`,
-        role("chooser", harness, "chooses what gets conformance tests under turri regenerate"),
         role("planner", harness, "cuts the work into pulses"),
         role("diagnosis", harness, "looks into a pulse that failed for good"),
         role("release", coding, "turri release's agent, and release-after-pulse's"),
@@ -349,6 +357,7 @@ export function quickStartConfig(vendor = "other", bedrock, models) {
         role("judge", strong, "judges a failing conformance run - as judge-model, which it wins over"),
         role("arbiter", strong, "weighs a second review"),
         role("debugger", strong, "a fresh look at unit tests that keep failing the same way"),
+        role("advisor", coding, "the test advisor: which functional specs need scenarios"),
         "",
     ].join("\n");
 }
@@ -411,12 +420,12 @@ function signInText(vendor, bedrock, models) {
         return [
             brand.bold("Sign in to AWS"),
             `  ${set("AWS_PROFILE")}   ${brand.muted("your profile (aws configure, or aws sso login)")}`,
-            `  ${set("AWS_REGION", region)}`,
             `  ${brand.muted("or, instead of a profile, a Bedrock API key:")} ${set("AWS_BEARER_TOKEN_BEDROCK")}`,
             "",
             brand.muted(keep),
+            // The region is turri's to set (bedrock-region.ts): said, not asked for.
             ...(bedrockNeedsAwsRegion(geography)
-                ? [brand.muted(`AWS_REGION has to be in ${geography}'s geography, as ${region} is: pi calls Bedrock in us-east-1 unless it - or the profile - names another.`)]
+                ? [brand.muted(`turri calls ${geography}'s models in ${region}. AWS_REGION, set, overrides it - and so does your AWS profile's region, when it is in ${geography}.`)]
                 : []),
             brand.muted("Your AWS account needs access to the models: Bedrock console, model access."),
         ];

package/dist/loop-cli.d.ts

@@ -25,10 +25,10 @@ export declare function runLoop(options: {
 export declare function moduleStates(reports: DriftReport[]): ModuleState[];
 /**
  * The options every command that regenerates takes for a headless run: `--report` and `--build-dir`, and the config's
- * own keys (configKeyOptions) - `--harness-model`, `--coding-model` (`--model`), `--judge-model`, `--review`, `--mutation-testing` and, where
- * `conformance` is true, `--conformance-tests` - read as if config.turri.yaml had them. Exits on a value it cannot read.
+ * own keys (configKeyOptions) - `--harness-model`, `--coding-model` (`--model`), `--judge-model`, `--review` and
+ * `--mutation-testing` - read as if config.turri.yaml had them. Exits on a value it cannot read.
  */
-export declare function headlessOptions(options: Record<string, string | undefined>, conformance: boolean): {
+export declare function headlessOptions(options: Record<string, string | undefined>): {
     report?: string;
     buildDir?: string;
 };

package/dist/loop-cli.js

@@ -1,4 +1,5 @@
 import { sweepOrphanedGroups } from "./regenerate/shell.js";
+import { refuseTestPlainFile } from "./test-plain-files.js";
 import { createInterface } from "node:readline/promises";
 import { resolve, sep } from "node:path";
 import { configForSpec, inheritModel, modelOnly, modelSpec, projectModels, readProjectConfig, roleModel, ROLE_THINKING, splitModelSpec, } from "./config.js";
@@ -9,7 +10,6 @@ import { ledgerWanted, startLedger } from "./regenerate/ledger.js";
 import { tryItCommand } from "./regenerate/delivery.js";
 import { describeDiagnosis, diagnoseFailure } from "./regenerate/diagnose.js";
 import { createJobRegistry, pulseName } from "./regenerate/jobs.js";
-import { conformanceChooser } from "./regenerate/choose-conformance.js";
 import { createWorkLoop, describeModules, functionalityCompletion, promptOf } from "./regenerate/loop.js";
 import { MODULES_DIR, projectDirOf } from "./regenerate/paths.js";
 import { exportModule } from "./regenerate/release.js";
@@ -25,6 +25,7 @@ import { configKeyOptions, optionValue } from "./cli-options.js";
  */
 export async function runLoop(options) {
     const plainFile = resolve(options.plainFile);
+    refuseTestPlainFile(plainFile);
     // What a turri that was killed left running - commands' process groups - stopped before anything starts.
     const orphans = sweepOrphanedGroups();
     if (orphans > 0)
@@ -54,7 +55,6 @@ export async function runLoop(options) {
             specFile: plainFile,
             projectDir,
             ...(buildDir !== undefined ? { buildDir } : {}),
-            conformanceTests: conformanceLabel(project.conformanceTests),
             review: project.review === true,
             mutationTesting: project.mutationTesting !== false,
             models: reportModels(project, model),
@@ -111,9 +111,6 @@ async function runLoopReporting(options) {
         ...(model !== undefined ? { modelFor: () => model } : {}),
         ...(planner !== undefined ? { plannerModel: planner } : {}),
         ...(options.dryRun === true ? { dryRun: true } : {}),
-        // Under conformance-tests: chosen or module, the chooser decides as a pulse ends, as in the chat - on the harness
-        // model, else the coding model: never pi's own default, which may be one this account cannot reach.
-        onChoose: conformanceChooser({ model: () => planner ?? model, ...(options.dryRun === true ? { dryRun: true } : {}) }),
     });
     report?.attach({
         jobs: () => registry.list(),
@@ -130,7 +127,9 @@ async function runLoopReporting(options) {
     const toStartOver = planned.filter((status) => status.startOver !== undefined);
     if (toStartOver.length > 0 && options.dryRun !== true) {
         const why = toStartOver
-            .map(({ startOver }) => `${startOver.codebases.join(", ")} was built without ${startOver.requires.join(", ")}, which it now requires: no change to its code can bring it in.`)
+            .map(({ startOver }) => startOver.old === true
+            ? `${startOver.codebases.join(", ")} was built when functional specs were numbered, before they had func-ids: nothing more can be built on it.`
+            : `${startOver.codebases.join(", ")} was built without ${startOver.requires.join(", ")}, which it now requires: no change to its code can bring it in.`)
             .join("\n");
         // No terminal and no --start-over: no one to ask, so the run stops here rather than build nothing and say it is done.
         if (options.startOver !== true && process.stdin.isTTY !== true) {
@@ -187,11 +186,13 @@ export function moduleStates(reports) {
                 ? "start_over_needed"
                 : report.why !== undefined
                     ? "halted"
-                    : report.code === null && (report.conformance === null || report.conformance === undefined) && report.scheduled.length === 0
+                    : report.code === null && (report.conformance === null || report.conformance === undefined)
                         ? "complete"
                         : "incomplete";
         const why = state === "start_over_needed"
-            ? `built without ${report.startOver.requires.join(", ")}, which it now requires: run with --start-over`
+            ? report.startOver.old === true
+                ? "built when functional specs were numbered, before they had func-ids: run with --start-over to regenerate its chain from scratch"
+                : `built without ${report.startOver.requires.join(", ")}, which it now requires: run with --start-over`
             : state === "incomplete"
                 ? report.code !== null && report.code !== undefined
                     ? "its code is not regenerated from the spec as it is"
@@ -230,10 +231,6 @@ function exportCode(plainFile, dir) {
         return { exported: false, dir, why: error instanceof Error ? error.message : String(error) };
     }
 }
-/** `conformance-tests:` as the report says it - not set is false. */
-function conformanceLabel(setting) {
-    return setting === true ? "all" : setting === "chosen" || setting === "module" ? setting : "false";
-}
 /** The models of the three roles as this run uses them: the coding model given, the others as they fall back - each with the level it thinks at. */
 function reportModels(project, model) {
     const coding = splitModelSpec(model);
@@ -252,11 +249,11 @@ function reportModels(project, model) {
 }
 /**
  * The options every command that regenerates takes for a headless run: `--report` and `--build-dir`, and the config's
- * own keys (configKeyOptions) - `--harness-model`, `--coding-model` (`--model`), `--judge-model`, `--review`, `--mutation-testing` and, where
- * `conformance` is true, `--conformance-tests` - read as if config.turri.yaml had them. Exits on a value it cannot read.
+ * own keys (configKeyOptions) - `--harness-model`, `--coding-model` (`--model`), `--judge-model`, `--review` and
+ * `--mutation-testing` - read as if config.turri.yaml had them. Exits on a value it cannot read.
  */
-export function headlessOptions(options, conformance) {
-    configKeyOptions(options, { conformance, review: true });
+export function headlessOptions(options) {
+    configKeyOptions(options, { review: true });
     const report = optionValue(options, "report");
     const buildDir = optionValue(options, "build-dir");
     return { ...(report !== undefined ? { report } : {}), ...(buildDir !== undefined ? { buildDir } : {}) };

package/dist/loop-tools.js

@@ -1,9 +1,11 @@
 import { existsSync } from "node:fs";
+import { refuseTestPlainFile } from "./test-plain-files.js";
 import { basename, relative, resolve } from "node:path";
 import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
+import { advisingNote } from "./advisor-chat.js";
 import { CONFIG_FILE, readProjectConfig, stackConfigFile, stackForModule, stackNamed, stacksOf, withStack } from "./config.js";
-import { checkPlainFile } from "./plain/check.js";
+import { checkPlainFile, formatCheckResults } from "./plain/check.js";
 import { describeDrift, describeModules } from "./regenerate/loop.js";
 import { pulseName } from "./regenerate/jobs.js";
 import { stopDeployed } from "./regenerate/release.js";
@@ -145,7 +147,9 @@ function plainFileOf(cwd, given, what) {
     const named = located.plain_file ?? readProjectConfig(located.base).module;
     if (named === undefined)
         throw new Error(`Name the .plain file to ${what}, or set module: in ${CONFIG_FILE}.`);
-    return resolve(located.base, named);
+    const plainFile = resolve(located.base, named);
+    refuseTestPlainFile(plainFile);
+    return plainFile;
 }
 /** Whether a /regenerate's words ask for the module from scratch: its code deleted, and all of it regenerated again. */
 export function asksFromScratch(words) {
@@ -165,14 +169,14 @@ export function regenerateTool(options) {
             "requires chain first. Call it after any change to the spec, by any means: the file tools, a skill, the user in an " +
             "editor. It takes no diff: what is left to regenerate - from what each module's code was regenerated from to its spec now - is " +
             "worked out and planned into pulses, and a pulse running that regenerates something the spec no longer wants is stopped and " +
-            "rolled back. Nothing to do where the code is regenerated from the spec as it is. With functionalities named, those are " +
+            "rolled back. Nothing to do where the code is regenerated from the spec as it is. With funcIds named - each as module:func-id - those are " +
             "regenerated though their spec did not change - their code taken out and built anew, better made, never left as it was - " +
             "planned into pulses as any change is, the ones next to each other together; their conformance tests stay as they are.",
         promptSnippet: "regenerate a module's code from its spec as it is now - after any change to the spec",
         promptGuidelines: [
             "Call regenerate after editing a .plain file with the file tools - or when the user says they changed one - instead of working out a diff: turri compares what is regenerated with the spec now.",
             "regenerate returns at once with what runs and what is planned. Report it, keep talking, and use pulses when the user asks; the pulses report when they finish.",
-            "When the user wants a functionality to come out differently, change its spec - the spec is what persists - then regenerate. When they want ones already built regenerated as their spec stands - better made, on another model, after many patches - name them in functionalities, all in one call.",
+            "When the user wants a functionality to come out differently, change its spec - the spec is what persists - then regenerate. When they want ones already built regenerated as their spec stands - better made, on another model, after many patches - name them in funcIds, each as module:func-id, all in one call.",
             "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.",
@@ -183,8 +187,8 @@ export function regenerateTool(options) {
             plain_file: Type.Optional(Type.String({ description: "Path to the .plain file. Omitted: the module the project's config.turri.yaml names" })),
             working_dir: WORKING_DIR_PARAM,
             guidance: GUIDANCE_PARAM,
-            functionalities: Type.Optional(Type.Array(Type.String(), {
-                description: "Functional specs already built, by id, to regenerate though their spec did not change. Omitted: what the spec now differs from the code in",
+            funcIds: Type.Optional(Type.Array(Type.String(), {
+                description: "Functional specs already built, each as module:func-id (todo:add-task), to regenerate though their spec did not change. Omitted: what the spec now differs from the code in",
             })),
             from_scratch: Type.Optional(Type.Union([Type.Literal("module"), Type.Literal("chain")], {
                 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. " +
@@ -198,11 +202,12 @@ export function regenerateTool(options) {
             const plainFile = plainFileOf(options.cwd, given, "regenerate");
             return withCallStack(plainFile, given.stack, async () => {
                 const check = checkPlainFile(plainFile);
+                // The parser's message as it gives it, a test plain file out of place, and turri's next step for the old syntax.
                 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 ?? [];
+                    throw new Error(`${relative(options.cwd, plainFile) || plainFile} does not parse, so nothing can be regenerated from it yet:\n${formatCheckResults([check])}`);
+                const again = given.funcIds ?? [];
                 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.");
+                    throw new Error("Name funcIds 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;
@@ -213,7 +218,10 @@ export function regenerateTool(options) {
                     : 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);
+                const reply = await loopReply(loop, statuses, options.wait !== undefined ? options.wait(ctx, given.wait) : given.wait === true);
+                // The functional specs the test advisor took up, for the agent to say so rather than offer their scenarios.
+                const advising = advisingNote(loop, plainFile);
+                return advising === "" ? reply : { ...reply, content: [...reply.content, { type: "text", text: advising }] };
             });
         },
     });

package/dist/model-check.d.ts

@@ -59,7 +59,12 @@ export declare function piModelCatalogue(): Promise<ModelCatalogue>;
 export declare function closestModels(id: string, known: string[]): string[];
 /** pi's own model runtime, with pi's credentials - auth.json, models.json and the environment - as turri's agents have them. */
 export declare function piModelAccess(): Promise<ModelAccess>;
-/** What to do about a provider's error, from what it says. */
-export declare function fixFor(provider: string, problem: string): string;
+/**
+ * What to do about a provider's error, from what it says. `region`: for Bedrock, the region it is called in and where
+ * that comes from, as a line (bedrock-region.ts `describeBedrockRegion`) - turri sets it, so a person is not told to.
+ */
+export declare function fixFor(provider: string, problem: string, region?: string): string;
 /** Each model the config uses, tried: answered, or what is wrong and what to do. One request a model. */
-export declare function checkModels(models: UsedModel[], access: ModelAccess): Promise<ModelVerdict[]>;
+export declare function checkModels(models: UsedModel[], access: ModelAccess, options?: {
+    bedrockRegion?: string;
+}): Promise<ModelVerdict[]>;

package/dist/model-check.js

@@ -84,23 +84,28 @@ function signIn(provider) {
         anthropic: "ANTHROPIC_API_KEY, or /login in turri",
         openai: "OPENAI_API_KEY, or /login in turri",
         google: "GEMINI_API_KEY",
-        "amazon-bedrock": "AWS_PROFILE (aws configure, or aws sso login) or AWS_BEARER_TOKEN_BEDROCK, and AWS_REGION",
+        "amazon-bedrock": "AWS_PROFILE (aws configure, or aws sso login) or AWS_BEARER_TOKEN_BEDROCK",
     };
     return keys[provider] ?? `the key pi reads for ${provider}, or /login in turri - https://pi.dev lists them`;
 }
-/** What to do about a provider's error, from what it says. */
-export function fixFor(provider, problem) {
+/**
+ * What to do about a provider's error, from what it says. `region`: for Bedrock, the region it is called in and where
+ * that comes from, as a line (bedrock-region.ts `describeBedrockRegion`) - turri sets it, so a person is not told to.
+ */
+export function fixFor(provider, problem, region) {
     const text = problem.toLowerCase();
+    const where = region !== undefined ? ` - ${region}` : " - the region pi calls Bedrock in, which AWS_REGION, set, chooses";
     if (/access (to|denied).*model|don't have access|not authorized to (invoke|access)|model access|accessdenied/.test(text) && provider === "amazon-bedrock") {
-        return "ask for access to this model in the Bedrock console, under model access - for the region in AWS_REGION";
+        return `ask for access to this model in the Bedrock console, under model access, for its region${where}`;
     }
     if (/provider is not configured|no credentials|not logged in/.test(text))
         return `sign in to ${provider}: ${signIn(provider)}`;
     if (/401|403|unauthori[sz]ed|forbidden|invalid.*(api key|x-api-key|token|credential)|credential|security token|could not load|unable to locate|expired|no api key|missing api key|authentication/.test(text)) {
         return `check the credentials pi reads for ${provider}: ${signIn(provider)}`;
     }
-    if (/region|endpoint|enotfound|getaddrinfo/.test(text))
-        return provider === "amazon-bedrock" ? "check AWS_REGION: the model has to be served there" : "check the network, and the provider's endpoint";
+    if (/region|endpoint|enotfound|getaddrinfo/.test(text)) {
+        return provider === "amazon-bedrock" ? `the model has to be served in the region it is called in${where}` : "check the network, and the provider's endpoint";
+    }
     if (/not found|404|does not exist|unknown model|invalid model/.test(text))
         return "the provider does not serve this model id: change it in config.turri.yaml";
     if (/429|rate|quota|overloaded|capacity/.test(text))
@@ -117,7 +122,7 @@ function commonPrefix(a, b) {
     return at;
 }
 /** Each model the config uses, tried: answered, or what is wrong and what to do. One request a model. */
-export async function checkModels(models, access) {
+export async function checkModels(models, access, options = {}) {
     return Promise.all(models.map(async ({ spec, usedBy }) => {
         const slash = spec.indexOf("/");
         if (slash === -1)
@@ -136,6 +141,6 @@ export async function checkModels(models, access) {
         if (problem === undefined)
             return { ok: true, spec, usedBy, ms: Date.now() - started };
         const said = problem.split("\n").find((line) => line.trim() !== "")?.trim().slice(0, 300) ?? problem;
-        return { ok: false, spec, usedBy, problem: said, fix: fixFor(provider, problem) };
+        return { ok: false, spec, usedBy, problem: said, fix: fixFor(provider, problem, provider === "amazon-bedrock" ? options.bedrockRegion : undefined) };
     }));
 }

package/dist/new-project.js

@@ -11,16 +11,20 @@ export const NEW_PROJECT = [
     "   install, and that turri doctor checks it. Read the stack's template, its language's and its kind's common first.",
     "2. One module - a .plain file in the project's root, named after what it is (server.plain) - importing the stack and",
     "   writing only what the module needs beyond it. Two side by side, each on its stack, only when it needs two stacks.",
-    "3. config.turri.yaml: module: the new file, and conformance-tests: false unless they asked for conformance tests.",
-    "   What a config there already settles - a stack, a script, conformance - is kept, not chosen again.",
-    "4. The unit testing script: keep one turri already finds; otherwise run cultivate with implement-unit-testing-script",
-    "   for the stack's language. Conformance tests asked for: their ***test reqs*** - the stack's conformance template -",
-    "   and cultivate with implement-conformance-testing-script.",
+    "3. config.turri.yaml: module: the new file. What a config there already settles - a stack, a script - is kept, not",
+    "   chosen again.",
+    "4. The unit testing script: keep one turri already finds; otherwise start cultivate with implement-unit-testing-script,",
+    "   plainFile the new module. It runs in the background: go straight on - the module's pulses wait for the script.",
+    "   Tests only if the person asked for them: turn conformance tests on first (turn_on_conformance_tests), then in this",
+    "   order: the ***test reqs*** - the stack's conformance template - then cultivate with",
+    "   implement-conformance-testing-script, in the background too, then the scenarios.",
     "5. The first functional spec: the smallest thing that runs and shows something - the server answers GET / with the",
-    "   app's name, the CLI prints its usage. validate, fix what it finds, and regenerate at once.",
+    "   app's name, the CLI prints its usage - with no test plain file, unless they asked for tests. parse, fix",
+    "   what it finds, and regenerate at once.",
     "6. While it regenerates: the main thing they described, on its happy path, and at most one more - each a functional",
-    "   spec, with its concepts - then validate and regenerate again. Only what they described: they named only the kind of",
-    "   software, write none, and invite them to say what it does. No validation or edge cases yet.",
+    "   spec, with its concepts, and a test plain file only if they asked for tests - then parse and regenerate",
+    "   again. Only what they described: they named only the kind of software, write none, and invite them to say what",
+    "   it does. No validation or edge cases yet.",
     "Then hand over in a few lines: what you chose, what is regenerating, and the next slices you would write - they say",
     "go on, or what to change, and every change after is ***plain you write and regenerate.",
     "</new-project>",

package/dist/{validate-cli.js → parse-cli.js}

@@ -1,9 +1,13 @@
 import { checkPlainTargets, formatCheckResults } from "./plain/check.js";
 import { c } from "./module-report.js";
-const USAGE = `usage: turri validate <file.plain | directory> [options]
+const USAGE = `usage: turri parse <file.plain | directory> [options]
 
-Validates a ***plain specification statically: parses it, resolves its imports and
-required modules, and reports every error without rendering anything.
+Parses ***plain - its syntax and structure, never its code or tests: each module with its test plain files,
+its imports and required modules, every error reported without regenerating anything - and every test plain file
+outside its module's folder. A functional spec with no test plain file is not tested. A module whose
+functional specs have scenarios but which has no test reqs, or no conformance testing script for its
+stack, is a warning: its conformance tests are not written until it has them. A test plain file or
+test folder is refused: name its module.
 
   --template-dir <dir>   extra template directory (repeatable)
   --json                 machine-readable output
@@ -38,10 +42,12 @@ if (json) {
 else {
     const output = formatCheckResults(results)
         .split("\n")
-        .map((line) => line.startsWith("PASS") ? c.success(line) : line.startsWith("FAIL") ? c.error(line) : c.dim(line))
+        .map((line) => line.startsWith("PASS") ? c.success(line) : line.startsWith("FAIL") ? c.error(line) : line.startsWith("WARN") ? c.warning(line) : c.dim(line))
         .join("\n");
     console.log(output);
     const failed = results.filter((r) => !r.ok).length;
-    console.log(`\n${failed === 0 ? c.success(c.bold("all specs valid")) : c.error(c.bold(`${failed} of ${results.length} failed`))}`);
+    const warned = results.reduce((count, r) => count + (r.warnings?.length ?? 0), 0);
+    const warnings = warned > 0 ? c.warning(` - ${warned} warning${warned === 1 ? "" : "s"}`) : "";
+    console.log(`\n${failed === 0 ? c.success(c.bold("all specs valid")) + warnings : c.error(c.bold(`${failed} of ${results.length} failed`))}`);
 }
 process.exit(results.every((r) => r.ok) ? 0 : 1);

package/dist/parse-tool.d.ts

@@ -0,0 +1,9 @@
+import { Type } from "typebox";
+/** parse, for the conversation and for the skills that write specs alike: it checks the ***plain, never the code. */
+export declare function checkPlainTool(cwd: string): import("@earendil-works/pi-coding-agent").ToolDefinition<Type.TObject<{
+    target: Type.TString;
+    template_dir: Type.TOptional<Type.TArray<Type.TString>>;
+}>, {
+    failed: number;
+    checked: number;
+}, any> & import("@earendil-works/pi-coding-agent").ToolDefinition<any, any, any>;