@turri-dev/cli 0.1.27 → 0.2.0

package/dist/config-edit.js

@@ -21,7 +21,6 @@ const ROLE_ABOUT = {
     default: "every role not named",
     chat: "the conversation - as harness-model, which it wins over",
     sentinel: "the sentinel: checks every finished pulse and tests the release",
-    chooser: "chooses what gets conformance tests under turri regenerate",
     planner: "cuts the work into pulses",
     diagnosis: "looks into a pulse that failed for good",
     release: "the release agent",
@@ -33,6 +32,7 @@ const ROLE_ABOUT = {
     judge: "judges a failing conformance run - as judge-model, which it wins over",
     arbiter: "weighs a second review",
     debugger: "a fresh look at unit tests that keep failing the same way",
+    advisor: "the test advisor: whether a new or changed functional spec needs scenarios",
 };
 /** Every setting, in the order the list shows them. */
 export function settings(rules = []) {
@@ -60,13 +60,15 @@ export function settings(rules = []) {
         { key: "coding-model", about: "the model that writes the code", kind: "model", unset: "harness-model", effect: "next-pulse" },
         { key: "judge-model", about: "the judge and the test review of a conformance run", kind: "model", unset: "coding-model", effect: "next-pulse" },
         { key: "module", about: "the .plain file turri regenerate builds when none is named", kind: "path", unset: "the folder's .plain files", effect: "next-regenerate", projectOnly: true },
-        { key: "conformance-tests", about: "which functional specs get conformance tests", kind: "choice", options: ["all", "chosen", "module", "false"], unset: "all, where a module has test reqs", effect: "next-plan" },
-        { key: "conformance-budget", about: "under conformance-tests: chosen or module, how many may be chosen - a count or a share", kind: "budget", options: ["10%", "30%", "50%", "5", "10"], unset: "no limit", effect: "next-plan" },
         { key: "review", about: "whether the code and its tests are reviewed once they pass", kind: "boolean", unset: "true", effect: "next-pulse" },
         { key: "mutation-testing", about: "whether the coding agent and the reviewer can put a bug in the code for one test run (can_it_fail)", kind: "boolean", unset: "true", effect: "next-pulse" },
         { key: "allow-to-stop-jobs", about: "whether turri stops a running pulse the ***plain has moved on from", kind: "boolean", unset: "true", effect: "now" },
         { key: "release-after-pulse", about: "whether every pulse that lands code releases it", kind: "boolean", unset: "false", effect: "next-landing" },
         { key: "sentinel", about: "whether a chat of its own checks every finished pulse, tests the release, and tells you what is wrong - ask: you are asked before it first opens", kind: "choice", options: ["ask", "true", "false"], unset: "ask", effect: "next-landing" },
+        { key: "test-advisor", about: "whether turri checks each new or changed functional spec with no scenarios in the background, to see whether it needs scenarios - on a yes, the chat writes them", kind: "boolean", unset: "true", effect: "now" },
+        { key: "conformance-tests", about: "whether functional specs' scenarios are written and conformance tested - false: none, the test advisor and conform off", kind: "boolean", unset: "false", effect: "now" },
+        { key: "test-dir", about: "the folder of the test plain files, a folder per module in it, by path from the project root", kind: "path", unset: "tests", effect: "now" },
+        { key: "base-folder", about: "a folder a codebase that requires no other module starts from, by path from the project root - code to build on, files to use, copied in once", kind: "path", unset: "none: it starts empty", effect: "next-pulse" },
         { key: "unittests-script", about: "the unit testing script, by path from the project root", kind: "path", unset: "the one run_unittests*.sh found", effect: "next-test-run" },
         { key: "conformance-tests-script", about: "the conformance testing script, by path from the project root", kind: "path", unset: "the one run_conformance_tests*.sh found", effect: "next-test-run" },
         { key: "prepare-environment-script", about: "run on the build before every conformance testing script run, by path from the project root - optional", kind: "path", unset: "the one prepare_environment*.sh found, else none", effect: "next-test-run" },
@@ -128,14 +130,6 @@ export function parseValue(setting, typed, known) {
                 return { error: `${setting.key} is a whole number of at least ${setting.min ?? 0}.` };
             return { value: number };
         }
-        case "budget": {
-            if (/^\d+$/.test(text))
-                return { value: Number(text) };
-            const share = /^(\d+(?:\.\d+)?)\s*%$/.exec(text);
-            if (share !== null && Number(share[1]) <= 100)
-                return { value: `${share[1]}%` };
-            return { error: `${setting.key} is a count, such as 5, or a share, such as 30%.` };
-        }
         case "model": {
             const { model, thinking } = splitModelSpec(text);
             const colon = text.lastIndexOf(":");
@@ -351,7 +345,7 @@ export function writeSetting(dir, key, value) {
     writeFileSync(join(dir, CONFIG_FILE), text);
     return text;
 }
-/** The files a path setting is offered: the testing scripts in the root and test_scripts/, or the .plain files of the folder. */
+/** The files a path setting is offered: the testing scripts in the root and test_scripts/, the .plain files of the folder, or - the test folder - its folders. */
 export function pathOptions(dir, key) {
     const list = (folder, test) => {
         try {
@@ -365,6 +359,16 @@ export function pathOptions(dir, key) {
     };
     if (key === "module")
         return list("", (name) => name.endsWith(".plain")).sort();
+    if (key === "test-dir" || key === "base-folder") {
+        const own = key === "test-dir" ? ["tests"] : [];
+        try {
+            const folders = readdirSync(dir).filter((name) => !name.startsWith(".") && name !== "plain_modules" && name !== "node_modules" && statSync(join(dir, name)).isDirectory());
+            return [...new Set([...own, ...folders])].sort();
+        }
+        catch {
+            return own;
+        }
+    }
     const prefix = key === "unittests-script" ? "run_unittests" : key === "conformance-tests-script" ? "run_conformance_tests" : "prepare_environment";
     const script = (name) => name.startsWith(prefix) && /\.(sh|ps1)$/.test(name);
     return [...list("", script), ...list("test_scripts", script)].sort();

package/dist/config.d.ts

@@ -5,6 +5,9 @@
  *
  * ```yaml
  * module: prism_cli.plain                                   # what `turri regenerate` builds by default
+ * conformance-tests: false                                  # whether scenarios are written and conformance tested - false: none, the test advisor off (default: false)
+ * test-dir: tests                                           # where the test plain files are, a folder per module: tests/<module>/ (default: tests)
+ * base-folder: existing-app                                 # a codebase that requires none starts as a copy of it - code to build on, assets to use
  * harness-model:                                            # the model you chat with in `turri`
  *   model: anthropic/claude-opus-5-5
  *   thinking: high
@@ -13,12 +16,11 @@
  *   thinking: medium
  * judge-model:                                              # the judge and the test review (default: coding-model)
  *   model: google/gemini-3.1-pro
- * conformance-tests: chosen                                 # all, chosen (those with acceptance tests, and those the chooser picks after each pulse), module (the chooser picks, and plans, once the module is regenerated) or false (default: false)
- * conformance-budget: 30%                                   # under chosen or module: how many functional specs a module may have chosen, beside those with acceptance tests - a count or a share (default: no limit)
  * review: false                                             # review the code and its tests once they pass (default: true)
  * mutation-testing: false                                   # give the coding agent and the reviewer can_it_fail (default: true)
  * allow-to-stop-jobs: false                                 # stop a running job the spec moved on from (default: true)
  * release-after-pulse: true                                 # release what each pulse lands, as its last stage, before the next pulse (default: false)
+ * test-advisor: false                                       # check each new or changed functional spec with no scenarios for whether it needs them - on a yes, the chat writes them (default: true)
  * sentinel: true                                            # a chat of its own every finished pulse goes to, which tests the release and tells you what is wrong: true, false, or ask - the person asked before it first opens in a session (default: ask)
  * rules-off: [integrations]                                 # ***plain rules to leave out of the prompts, by name (default: none)
  * unittests-script: test_scripts/run_unittests.sh           # the testing scripts - see test-scripts.ts
@@ -126,9 +128,10 @@ export interface ModelChoice {
 /**
  * The agents turri starts, by what they do - each can be given its own model, thinking and turn limit (`models:`).
  * The code fixer of a conformance run and the repair agent are coding agents; the unit-test and conformance arbiters
- * are both `arbiter`.
+ * are both `arbiter`. The test advisor's calls - classifying a functional spec, its probes, its readers, its verifier -
+ * are `advisor`.
  */
-export declare const AGENT_ROLES: readonly ["chat", "sentinel", "chooser", "planner", "diagnosis", "release", "coding", "conformance", "explorer", "reviewer", "test-reviewer", "judge", "arbiter", "debugger"];
+export declare const AGENT_ROLES: readonly ["chat", "sentinel", "planner", "diagnosis", "release", "coding", "conformance", "explorer", "reviewer", "test-reviewer", "judge", "arbiter", "debugger", "advisor"];
 export type AgentRole = (typeof AGENT_ROLES)[number];
 /**
  * How hard each role thinks when nothing names a level - not the config's `models:`, nor a `:level` on the model it is
@@ -165,6 +168,12 @@ export declare function projectModels(config: Pick<ProjectConfig, "harnessModel"
     coding?: ModelChoice;
     judge?: ModelChoice;
 };
+/**
+ * What a skill run from the command line runs on: the project's harness model, as a skill in the chat runs on the
+ * chat's - or its coding model, for a skill that names it (`metadata.model: coding`) - undefined, and pi's default,
+ * when the project names none.
+ */
+export declare function skillModel(root: string, role?: "harness" | "coding"): string | undefined;
 /**
  * What the config itself says a role runs on - its own entry, the legacy key that names it (judge-model for the judge
  * and the test review), then `default` (the chat's side: the chat's model instead) - or nothing when it says nothing
@@ -172,6 +181,11 @@ export declare function projectModels(config: Pick<ProjectConfig, "harnessModel"
  * The coding role always runs on what it is given: its config is already in it (projectModels).
  */
 export declare function roleModel(config: Pick<ProjectConfig, "harnessModel" | "judgeModel" | "models">, role: AgentRole): ModelChoice | undefined;
+/**
+ * What the test advisor's calls run on: `models.advisor` - else `default` - and without either the coding
+ * model alone, thinking as the role has it (ROLE_THINKING). Undefined when the config names no model at all.
+ */
+export declare function advisorModel(config: ProjectConfig): string | undefined;
 /** How long each turn of a role's agents may take, in milliseconds: its own, `default`'s, `turn-limit:`'s - or undefined, the harness's default. */
 export declare function roleTurnLimitMs(config: Pick<ProjectConfig, "models" | "turnLimit">, role: AgentRole | undefined): number | undefined;
 /** `sentinel:` - on, off, or `ask`: on once the person says so, asked before it first opens in a session. */
@@ -188,24 +202,6 @@ export interface ProjectConfig {
      * the code, the tests or the spec is wrong, and the test review. Unset: the coding model.
      */
     judgeModel?: ModelChoice;
-    /**
-     * Whether conformance tests are written and run, and for what. true (`all`): every functional spec the code is built
-     * from. "chosen": the ones with acceptance tests, and those the chooser picks from what each code pulse regenerated, as
-     * the pulse ends. "module": the same, but the chooser is asked once, when the whole module is regenerated - what to test,
-     * and in which pulses. Under both, those the person asks for with conform too, and a choice is kept once its tests land.
-     * false: none, unless the person asks. Unset: none, as with false.
-     */
-    conformanceTests?: boolean | "chosen" | "module";
-    /**
-     * Under `conformance-tests: chosen`: how many of a module's functional specs may be chosen for conformance tests, beside
-     * those with acceptance tests - a count, or a share of the module's functional specs (rounded up, at least one).
-     * Every choice for the module counts, whenever it was made; the person's own conform is not limited. Unset: no limit.
-     */
-    conformanceBudget?: {
-        count: number;
-    } | {
-        share: number;
-    };
     /**
      * Whether the code and its unit tests - and the conformance tests - are reviewed once they pass: two reviews at
      * most, the second weighed by the arbiter. false: the work goes on once its tests pass. Unset: false.
@@ -234,6 +230,30 @@ export interface ProjectConfig {
      * asked, before it first opens in a session, whether to start it. Unset: ask.
      */
     sentinel?: SentinelSetting;
+    /**
+     * Whether the test advisor starts by itself: in the chat and a host, each new or changed functional spec with no
+     * scenarios is classified in the background, and on a yes the chat writes its scenarios (docs/test-advisor.md). false
+     * turns off only that: the chat's evaluate_tests still works, and asked for scenarios, the chat writes them as before.
+     * Unset: true.
+     */
+    testAdvisor?: boolean;
+    /**
+     * The folder of the test plain files, from the project's folder: a functional spec's scenarios are in its test plain
+     * file in `<test-dir>/<module>/`. Unset: `tests`.
+     */
+    testDir?: string;
+    /**
+     * Whether functional specs' scenarios are written and conformance tested (conformance-switch.ts). False: none - no
+     * conformance pulse, no conformance testing script, the test advisor and the chat's conform and evaluate_tests off; the
+     * test plain files there are kept, and not tested. The person asking for tests, or agreeing to the chat's offer, turns it
+     * on. Unset: false.
+     */
+    conformanceTests?: boolean;
+    /**
+     * A folder, from the project's folder, that a codebase requiring no other module starts from - a copy of it, once,
+     * before its first pulse: code to build on, files to use (src/regenerate/base-folder.ts). Unset: it starts empty.
+     */
+    baseFolder?: string;
     /** Path from the root to the unit testing script. */
     unittestsScript?: string;
     /** Path from the root to the conformance testing script. */
@@ -303,13 +323,15 @@ export declare const CONFIG_KEYS: {
     readonly harnessModel: "harness-model";
     readonly codingModel: "coding-model";
     readonly judgeModel: "judge-model";
-    readonly conformanceTests: "conformance-tests";
-    readonly conformanceBudget: "conformance-budget";
     readonly review: "review";
     readonly mutationTesting: "mutation-testing";
     readonly allowToStopJobs: "allow-to-stop-jobs";
     readonly releaseAfterPulse: "release-after-pulse";
     readonly sentinel: "sentinel";
+    readonly testAdvisor: "test-advisor";
+    readonly testDir: "test-dir";
+    readonly conformanceTests: "conformance-tests";
+    readonly baseFolder: "base-folder";
     readonly unittestsScript: "unittests-script";
     readonly conformanceTestsScript: "conformance-tests-script";
     readonly prepareEnvironmentScript: "prepare-environment-script";
@@ -327,12 +349,6 @@ export declare const CONFIG_KEYS: {
     readonly models: "models";
     readonly turnLimit: "turn-limit";
 };
-/** Whether `conformance-tests:` turns the conformance tests on: all (true), chosen or module. Not set, they are off, as with false. */
-export declare function conformanceSwitchedOn(setting: ProjectConfig["conformanceTests"]): boolean;
-/** When the chooser decides which functional specs get conformance tests: after each code pulse, once the module is regenerated, or never - every one, or none. */
-export declare function choosingWhen(setting: ProjectConfig["conformanceTests"]): "pulse" | "module" | undefined;
-/** How many functional specs a module of `count` may have chosen under a budget: the count, or the share rounded up - at least one. */
-export declare function budgetFor(budget: NonNullable<ProjectConfig["conformanceBudget"]>, count: number): number;
 /**
  * The project's config - with a stack's over it, when one is named - or nothing of it when there is no file or it does
  * not parse.
@@ -340,12 +356,12 @@ export declare function budgetFor(budget: NonNullable<ProjectConfig["conformance
 export declare function readProjectConfig(root: string, stack?: string): ProjectConfig;
 /**
  * What a command's own options say of the config's keys - `turri regenerate --harness-model`, `--coding-model`,
- * `--judge-model`, `--conformance-tests`, `--review`, `--mutation-testing` - read as if the file had them: each takes its key's value, and
+ * `--judge-model`, `--review`, `--mutation-testing` - read as if the file had them: each takes its key's value, and
  * every key keeps its place in the order, so a run is the same as one with them in config.turri.yaml - a `models:`
  * entry still winning over `harness-model`, `coding-model` or `judge-model`. A headless run needs no config file
  * edited. Never set in the conversation.
  */
-type RunOverrides = Partial<Pick<ProjectConfig, "harnessModel" | "codingModel" | "judgeModel" | "conformanceTests" | "review" | "mutationTesting">>;
+type RunOverrides = Partial<Pick<ProjectConfig, "harnessModel" | "codingModel" | "judgeModel" | "review" | "mutationTesting">>;
 /** Megabytes of package caches a project keeps when `cache-keep:` does not say. */
 export declare const DEFAULT_CACHE_KEEP_MB = 4096;
 /**
@@ -355,10 +371,14 @@ export declare const DEFAULT_CACHE_KEEP_MB = 4096;
 export declare function debugMode(project: string): boolean;
 /** Read a command's options as the config's keys for the rest of this process. */
 export declare function overrideConfig(overrides: RunOverrides): void;
-/** `--conformance-tests <value>`: the config's own values - all (or true), chosen, module, false. Undefined for anything else. */
-export declare function conformanceOption(value: string): ProjectConfig["conformanceTests"] | undefined;
 /** `--review <value>`, `--mutation-testing <value>`: the config's own, true or false. Undefined for anything else. */
 export declare function booleanOption(value: string): boolean | undefined;
+/** Where the test plain files are when `test-dir:` does not say. */
+export declare const DEFAULT_TEST_DIR = "tests";
+/** The folder of a module's project's test plain files: `test-dir:` - its stack's over the project's - from the project's folder. */
+export declare function testDirOf(plainFile: string): string;
 /** The config a spec is built with: its project's, with its module's stack over it (`stackForModule`). */
 export declare function configForSpec(plainFile: string): ProjectConfig;
+/** One config file, read, or nothing of it when it is not there or does not parse. */
+export declare function readConfigFile(path: string): ProjectConfig;
 export {};

package/dist/config.js

@@ -11,6 +11,9 @@ import { projectDirOf } from "./regenerate/paths.js";
  *
  * ```yaml
  * module: prism_cli.plain                                   # what `turri regenerate` builds by default
+ * conformance-tests: false                                  # whether scenarios are written and conformance tested - false: none, the test advisor off (default: false)
+ * test-dir: tests                                           # where the test plain files are, a folder per module: tests/<module>/ (default: tests)
+ * base-folder: existing-app                                 # a codebase that requires none starts as a copy of it - code to build on, assets to use
  * harness-model:                                            # the model you chat with in `turri`
  *   model: anthropic/claude-opus-5-5
  *   thinking: high
@@ -19,12 +22,11 @@ import { projectDirOf } from "./regenerate/paths.js";
  *   thinking: medium
  * judge-model:                                              # the judge and the test review (default: coding-model)
  *   model: google/gemini-3.1-pro
- * conformance-tests: chosen                                 # all, chosen (those with acceptance tests, and those the chooser picks after each pulse), module (the chooser picks, and plans, once the module is regenerated) or false (default: false)
- * conformance-budget: 30%                                   # under chosen or module: how many functional specs a module may have chosen, beside those with acceptance tests - a count or a share (default: no limit)
  * review: false                                             # review the code and its tests once they pass (default: true)
  * mutation-testing: false                                   # give the coding agent and the reviewer can_it_fail (default: true)
  * allow-to-stop-jobs: false                                 # stop a running job the spec moved on from (default: true)
  * release-after-pulse: true                                 # release what each pulse lands, as its last stage, before the next pulse (default: false)
+ * test-advisor: false                                       # check each new or changed functional spec with no scenarios for whether it needs them - on a yes, the chat writes them (default: true)
  * sentinel: true                                            # a chat of its own every finished pulse goes to, which tests the release and tells you what is wrong: true, false, or ask - the person asked before it first opens in a session (default: ask)
  * rules-off: [integrations]                                 # ***plain rules to leave out of the prompts, by name (default: none)
  * unittests-script: test_scripts/run_unittests.sh           # the testing scripts - see test-scripts.ts
@@ -214,9 +216,10 @@ export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhig
 /**
  * The agents turri starts, by what they do - each can be given its own model, thinking and turn limit (`models:`).
  * The code fixer of a conformance run and the repair agent are coding agents; the unit-test and conformance arbiters
- * are both `arbiter`.
+ * are both `arbiter`. The test advisor's calls - classifying a functional spec, its probes, its readers, its verifier -
+ * are `advisor`.
  */
-export const AGENT_ROLES = ["chat", "sentinel", "chooser", "planner", "diagnosis", "release", "coding", "conformance", "explorer", "reviewer", "test-reviewer", "judge", "arbiter", "debugger"];
+export const AGENT_ROLES = ["chat", "sentinel", "planner", "diagnosis", "release", "coding", "conformance", "explorer", "reviewer", "test-reviewer", "judge", "arbiter", "debugger", "advisor"];
 /**
  * How hard each role thinks when nothing names a level - not the config's `models:`, nor a `:level` on the model it is
  * given. The agents that do the work - write the code and the tests, explore, release - think little: they work from a
@@ -228,19 +231,19 @@ export const ROLE_THINKING = {
     conformance: "low",
     explorer: "low",
     release: "low",
+    advisor: "low",
     reviewer: "medium",
     "test-reviewer": "medium",
     judge: "medium",
     arbiter: "medium",
     debugger: "medium",
     planner: "medium",
-    chooser: "medium",
     diagnosis: "medium",
 };
 /** The roles on the conversation's side: without their own entry they take the chat's model, not `default`. */
 // The release is not: it follows steps - a script, a start command - and runs on the coding model, thinking low. Nor
 // is the diagnosis: a post-mortem of a job that failed, read by the person - it runs on the coding model, thinking medium.
-const CHAT_SIDE = ["chat", "sentinel", "chooser", "planner"];
+const CHAT_SIDE = ["chat", "sentinel", "planner"];
 function isThinkingLevel(value) {
     return typeof value === "string" && THINKING_LEVELS.includes(value);
 }
@@ -295,6 +298,14 @@ export function projectModels(config) {
     const codingModel = coding?.model !== undefined ? { model: coding.model } : undefined;
     return { harness, coding, judge: inheritModel(choiceOf(models.judge), inheritModel(config.judgeModel, inheritModel(choiceOf(models.default), codingModel))) };
 }
+/**
+ * What a skill run from the command line runs on: the project's harness model, as a skill in the chat runs on the
+ * chat's - or its coding model, for a skill that names it (`metadata.model: coding`) - undefined, and pi's default,
+ * when the project names none.
+ */
+export function skillModel(root, role = "harness") {
+    return modelSpec(projectModels(readProjectConfig(root, stackOf(root)))[role]);
+}
 /** A role entry's model and thinking alone. */
 function choiceOf(entry) {
     if (entry === undefined || (entry.model === undefined && entry.thinking === undefined))
@@ -320,6 +331,14 @@ export function roleModel(config, role) {
     const legacy = role === "judge" || role === "test-reviewer" ? config.judgeModel : undefined;
     return inheritModel(own, inheritModel(legacy, choiceOf(models.default)));
 }
+/**
+ * What the test advisor's calls run on: `models.advisor` - else `default` - and without either the coding
+ * model alone, thinking as the role has it (ROLE_THINKING). Undefined when the config names no model at all.
+ */
+export function advisorModel(config) {
+    const coding = projectModels(config).coding?.model;
+    return modelSpec(inheritModel(roleModel(config, "advisor"), coding !== undefined ? { model: coding } : undefined));
+}
 /** How long each turn of a role's agents may take, in milliseconds: its own, `default`'s, `turn-limit:`'s - or undefined, the harness's default. */
 export function roleTurnLimitMs(config, role) {
     const models = config.models ?? {};
@@ -377,13 +396,15 @@ export const CONFIG_KEYS = {
     harnessModel: "harness-model",
     codingModel: "coding-model",
     judgeModel: "judge-model",
-    conformanceTests: "conformance-tests",
-    conformanceBudget: "conformance-budget",
     review: "review",
     mutationTesting: "mutation-testing",
     allowToStopJobs: "allow-to-stop-jobs",
     releaseAfterPulse: "release-after-pulse",
     sentinel: "sentinel",
+    testAdvisor: "test-advisor",
+    testDir: "test-dir",
+    conformanceTests: "conformance-tests",
+    baseFolder: "base-folder",
     unittestsScript: "unittests-script",
     conformanceTestsScript: "conformance-tests-script",
     prepareEnvironmentScript: "prepare-environment-script",
@@ -404,34 +425,6 @@ export const CONFIG_KEYS = {
 function whatScriptsRunOn(value) {
     return value === "copy" || value === "in-place" ? value : undefined;
 }
-/** `conformance-tests:` - true or all, chosen, module, false. Anything else is not read. */
-function conformanceSetting(value) {
-    if (typeof value === "boolean")
-        return value;
-    const word = typeof value === "string" ? value.trim().toLowerCase() : undefined;
-    return word === "all" ? true : word === "chosen" ? "chosen" : word === "module" ? "module" : word === "false" ? false : word === "true" ? true : undefined;
-}
-/** Whether `conformance-tests:` turns the conformance tests on: all (true), chosen or module. Not set, they are off, as with false. */
-export function conformanceSwitchedOn(setting) {
-    return setting === true || setting === "chosen" || setting === "module";
-}
-/** When the chooser decides which functional specs get conformance tests: after each code pulse, once the module is regenerated, or never - every one, or none. */
-export function choosingWhen(setting) {
-    return setting === "chosen" ? "pulse" : setting === "module" ? "module" : undefined;
-}
-/** `conformance-budget:` - a whole number, or a share such as `30%`. Anything else is not read. */
-function budgetSetting(value) {
-    if (typeof value === "number" && Number.isInteger(value) && value >= 0)
-        return { count: value };
-    const share = typeof value === "string" ? /^\s*(\d+(?:\.\d+)?)\s*%\s*$/.exec(value) : null;
-    if (share !== null && Number(share[1]) <= 100)
-        return { share: Number(share[1]) / 100 };
-    return undefined;
-}
-/** How many functional specs a module of `count` may have chosen under a budget: the count, or the share rounded up - at least one. */
-export function budgetFor(budget, count) {
-    return "count" in budget ? budget.count : Math.max(1, Math.ceil(budget.share * count));
-}
 function text(value) {
     return typeof value === "string" && value.trim() !== "" ? value.trim() : undefined;
 }
@@ -483,10 +476,6 @@ export function debugMode(project) {
 export function overrideConfig(overrides) {
     runOverrides = { ...overrides };
 }
-/** `--conformance-tests <value>`: the config's own values - all (or true), chosen, module, false. Undefined for anything else. */
-export function conformanceOption(value) {
-    return conformanceSetting(value);
-}
 /** `--review <value>`, `--mutation-testing <value>`: the config's own, true or false. Undefined for anything else. */
 export function booleanOption(value) {
     const word = value.trim().toLowerCase();
@@ -530,13 +519,19 @@ function agentEnvSetting(value) {
 function withoutUndefined(config) {
     return Object.fromEntries(Object.entries(config).filter(([, value]) => value !== undefined));
 }
+/** Where the test plain files are when `test-dir:` does not say. */
+export const DEFAULT_TEST_DIR = "tests";
+/** The folder of a module's project's test plain files: `test-dir:` - its stack's over the project's - from the project's folder. */
+export function testDirOf(plainFile) {
+    return resolve(projectDirOf(resolve(plainFile)), configForSpec(plainFile).testDir ?? DEFAULT_TEST_DIR);
+}
 /** The config a spec is built with: its project's, with its module's stack over it (`stackForModule`). */
 export function configForSpec(plainFile) {
     const root = projectDirOf(resolve(plainFile));
     return readProjectConfig(root, stackForModule(plainFile));
 }
 /** One config file, read, or nothing of it when it is not there or does not parse. */
-function readConfigFile(path) {
+export function readConfigFile(path) {
     let parsed;
     try {
         if (!statSync(path).isFile())
@@ -549,19 +544,20 @@ function readConfigFile(path) {
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
         return {};
     const raw = Object.fromEntries(Object.entries(parsed).map(([key, value]) => [key.replace(/_/g, "-"), value]));
-    const conformance = raw[CONFIG_KEYS.conformanceTests];
     return {
         module: text(raw[CONFIG_KEYS.module]),
         harnessModel: modelChoice(raw[CONFIG_KEYS.harnessModel]),
         codingModel: modelChoice(raw[CONFIG_KEYS.codingModel]) ?? modelChoice(raw.model),
         judgeModel: modelChoice(raw[CONFIG_KEYS.judgeModel]),
-        conformanceTests: conformanceSetting(conformance),
-        conformanceBudget: budgetSetting(raw[CONFIG_KEYS.conformanceBudget]),
         review: typeof raw[CONFIG_KEYS.review] === "boolean" ? raw[CONFIG_KEYS.review] : undefined,
         mutationTesting: typeof raw[CONFIG_KEYS.mutationTesting] === "boolean" ? raw[CONFIG_KEYS.mutationTesting] : undefined,
         allowToStopJobs: typeof raw[CONFIG_KEYS.allowToStopJobs] === "boolean" ? raw[CONFIG_KEYS.allowToStopJobs] : undefined,
         releaseAfterPulse: typeof raw[CONFIG_KEYS.releaseAfterPulse] === "boolean" ? raw[CONFIG_KEYS.releaseAfterPulse] : undefined,
         sentinel: typeof raw[CONFIG_KEYS.sentinel] === "boolean" || raw[CONFIG_KEYS.sentinel] === "ask" ? raw[CONFIG_KEYS.sentinel] : undefined,
+        testAdvisor: typeof raw[CONFIG_KEYS.testAdvisor] === "boolean" ? raw[CONFIG_KEYS.testAdvisor] : undefined,
+        testDir: text(raw[CONFIG_KEYS.testDir]),
+        conformanceTests: typeof raw[CONFIG_KEYS.conformanceTests] === "boolean" ? raw[CONFIG_KEYS.conformanceTests] : undefined,
+        baseFolder: text(raw[CONFIG_KEYS.baseFolder]),
         unittestsScript: text(raw[CONFIG_KEYS.unittestsScript]),
         conformanceTestsScript: text(raw[CONFIG_KEYS.conformanceTestsScript]),
         prepareEnvironmentScript: text(raw[CONFIG_KEYS.prepareEnvironmentScript]),

package/dist/conform-cli.js

@@ -1,23 +1,25 @@
 import { parseArgs } from "./cli-options.js";
 import { headlessOptions, runLoop } from "./loop-cli.js";
-const USAGE = `usage: turri conform <file.plain> [frid ...] [options]
+const USAGE = `usage: turri conform <file.plain> [module:func-id ...] [options]
 
-Writes and runs the black-box conformance tests of a module's functional specs - those named, or
-every one - on the code as it is built, as the chat's conform does, whatever the config's
-conformance-tests says: from the spec's test reqs and acceptance tests, with the whole suite the
-module inherits, a failure fixed in the test or the code, whichever is wrong. Every functional spec
-tested goes in one pulse, as far as the size guardrail lets.
+Writes and runs the black-box conformance tests of a module's functional specs - those named, each
+as module:func-id, or every one with scenarios - on the code as it is built, as the chat's conform does:
+exactly their conformance and acceptance scenarios, following the spec's test reqs, with the whole suite
+the module inherits, a failure fixed in the test or the code, whichever is wrong. A functional spec with
+no scenarios is refused: write them first. So is a module with no test reqs, or no conformance testing
+script for its stack: the refusal names the next step. Every functional spec tested goes in one pulse,
+as far as the size guardrail lets.
 
   --one-by-one             a pulse a functional spec instead
-  --harness-model <p/id>   config.turri.yaml's harness-model for this run: the planner, the conformance chooser, a diagnosis
+  --harness-model <p/id>   config.turri.yaml's harness-model for this run: the planner, a diagnosis
   --coding-model <p/id>    its coding-model, --model too: the agents that build
   --judge-model <p/id>     its judge-model: the judge and the test review
   --review <true|false>    its review: whether the code and its tests are reviewed once they pass
   --build-dir <dir>        as the run ends, export the code there (see turri regenerate --help)
   --report <file.json>     write a report of the run there (see turri regenerate --help)`;
 const { positional, options } = parseArgs(process.argv.slice(2), ["--one-by-one"], USAGE, ["--build-dir", "--report", "--harness-model", "--judge-model", "--review"]);
-const { report, buildDir } = headlessOptions(options, false);
-const [plainFile, ...frids] = positional;
+const { report, buildDir } = headlessOptions(options);
+const [plainFile, ...funcIds] = positional;
 if (plainFile === undefined) {
     console.error(USAGE);
     process.exit(1);
@@ -28,7 +30,7 @@ runLoop({
     ...(report !== undefined ? { report } : {}),
     command: ["conform", ...process.argv.slice(2)],
     ask: (loop) => loop.conformance(plainFile, {
-        ...(frids.length > 0 ? { frids } : {}),
+        ...(funcIds.length > 0 ? { funcIds } : {}),
         ...(options["one-by-one"] !== undefined ? { separately: true } : {}),
     }),
 }).catch((error) => {

package/dist/conformance-switch.d.ts

@@ -0,0 +1,34 @@
+import { type ToolDefinition } from "@earendil-works/pi-coding-agent";
+/**
+ * Whether a project's functional specs are conformance tested: `conformance-tests:` in its config, a stack's own over the
+ * project's, false when unset. Off, nothing of conformance testing runs - no conformance pulse, no conformance testing
+ * script, the test advisor and the chat's conform and evaluate_tests off; the test plain files there are kept, and not
+ * tested. The chat always knows it, and how they are turned on: the person asking for tests, or agreeing to the chat's
+ * offer of them, turns them on - for this session and the next, written into the config.
+ */
+/** The chat's tools that run conformance testing: there while the tests are on. */
+export declare const CONFORMANCE_TOOLS: string[];
+/** The chat's tool that turns them on: there while they are off. */
+export declare const TURN_ON_TOOL = "turn_on_conformance_tests";
+/** Whether a module's functional specs are conformance tested: its stack's `conformance-tests:` over the project's. */
+export declare function conformanceTestsOn(plainFile: string): boolean;
+/** Whether the project conformance tests anything: its own config, or a stack's - for the chat's tools, which are the project's. */
+export declare function conformanceTestsOnIn(project: string): boolean;
+/**
+ * Turn conformance testing on: `conformance-tests: true` written where the module's value comes from - its stack's file
+ * when that names the key, else config.turri.yaml - and in effect at once. Says which file.
+ */
+export declare function turnOnConformanceTests(project: string, plainFile?: string): string;
+/**
+ * What the chat is told of conformance testing, every turn: what it is, whether it is on here, and - off - how it is
+ * turned on, and that it may offer it.
+ */
+export declare function conformanceBlock(on: boolean): string;
+/**
+ * turn_on_conformance_tests: the chat turns conformance testing on, the person having asked for it or agreed to it.
+ * `turnOn` is the session's (extension.ts `turnOnConformance`): the setting written, every chat's tools switched - the
+ * file written, from the project.
+ */
+export declare function turnOnConformanceTestsTool(options: {
+    turnOn: (plainFile?: string) => string;
+}): ToolDefinition;