@turri-dev/cli 0.1.27 → 0.2.0

package/dist/bedrock-region.js

@@ -0,0 +1,144 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { readProjectConfig, stacksOf } from "./config.js";
+import { bedrockAwsRegion, bedrockNeedsAwsRegion, bedrockPlaceOf } from "./init-config.js";
+import { modelsInUse } from "./model-check.js";
+/** The variable turri marks its own AWS_REGION with, so the pi it starts - and a reload - tells it from the person's. */
+export const TURRI_AWS_REGION = "TURRI_AWS_REGION";
+/** pi's region when nothing names one. */
+const DEFAULT_REGION = "us-east-1";
+/** Whether a region is in a geography: one of the regions Bedrock serves that geography's inference profiles from. */
+export function regionInGeography(region, geography) {
+    const exact = {
+        jp: ["ap-northeast-1", "ap-northeast-3"],
+        au: ["ap-southeast-2", "ap-southeast-4"],
+        in: ["ap-south-1", "ap-south-2"],
+    };
+    if (exact[geography] !== undefined)
+        return exact[geography].includes(region);
+    const prefix = { eu: "eu-", apac: "ap-", ca: "ca-", "us-gov": "us-gov-", us: "us-" };
+    if (prefix[geography] !== undefined)
+        return region.startsWith(prefix[geography]) && (geography !== "us" || !region.startsWith("us-gov-"));
+    // global and in-region: any region serves them.
+    return true;
+}
+/** The region an AWS profile names, from AWS_CONFIG_FILE or ~/.aws/config - undefined when it names none, or the file cannot be read. */
+export function profileRegion(profile, env = process.env) {
+    const file = env.AWS_CONFIG_FILE?.trim() || join(homedir(), ".aws", "config");
+    if (!existsSync(file))
+        return undefined;
+    let text;
+    try {
+        text = readFileSync(file, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+    const wanted = profile === "default" ? ["default", "profile default"] : [`profile ${profile}`];
+    let inside = false;
+    for (const raw of text.split(/\r?\n/)) {
+        const line = raw.trim();
+        const section = /^\[\s*(.+?)\s*\]$/.exec(line);
+        if (section !== null) {
+            inside = wanted.includes(section[1].replace(/\s+/g, " "));
+            continue;
+        }
+        if (!inside)
+            continue;
+        const setting = /^region\s*=\s*(\S+)/.exec(line);
+        if (setting !== null)
+            return setting[1];
+    }
+    return undefined;
+}
+/** The Bedrock models a project uses: every model its config names - each stack's too - and those given. */
+function bedrockModels(projectDir, also) {
+    const configs = [readProjectConfig(projectDir), ...stacksOf(projectDir).map((stack) => readProjectConfig(projectDir, stack))];
+    const specs = [...configs.flatMap((config) => modelsInUse(config).map((used) => used.spec)), ...also];
+    return [...new Set(specs.filter((spec) => spec.startsWith("amazon-bedrock/")))];
+}
+/**
+ * What turri does about the AWS region for a project, from the environment as it is - reading it, setting nothing.
+ * `also`: models used besides the config's - named on the command line, chosen in this session.
+ */
+export function bedrockRegionFor(projectDir, options = {}) {
+    const env = options.env ?? process.env;
+    const models = bedrockModels(projectDir, options.also ?? []);
+    // The regions the models need, by region: a model served in global, us or in-region needs none.
+    const needed = new Map();
+    for (const model of models) {
+        const { geography } = bedrockPlaceOf(model);
+        if (!bedrockNeedsAwsRegion(geography))
+            continue;
+        const region = bedrockAwsRegion(geography);
+        needed.set(region, { geography, models: [...(needed.get(region)?.models ?? []), model] });
+    }
+    const conflict = needed.size > 1 ? [...needed].map(([region, { geography, models }]) => ({ region, geography, models })) : undefined;
+    const [only] = needed.size === 1 ? [...needed] : [];
+    const needs = only !== undefined ? { region: only[0], geography: only[1].geography } : undefined;
+    const withConflict = { ...(conflict !== undefined ? { conflict } : {}), ...(needs !== undefined ? { needs } : {}) };
+    // The person's region wins, always; turri's own is worked out again.
+    const ours = env[TURRI_AWS_REGION];
+    const set = env.AWS_REGION?.trim() || env.AWS_DEFAULT_REGION?.trim();
+    if (set !== undefined && set !== "" && !(ours !== undefined && env.AWS_REGION === ours))
+        return { region: set, source: "set", models, ...withConflict };
+    const profile = env.AWS_PROFILE?.trim();
+    const fromProfile = profile !== undefined && profile !== "" ? profileRegion(profile, env) : undefined;
+    // One region needed: the profile's, when it is in that geography; otherwise turri's.
+    if (needs !== undefined) {
+        if (fromProfile !== undefined && regionInGeography(fromProfile, needs.geography))
+            return { region: fromProfile, source: "profile", models, needs };
+        return { region: needs.region, source: "turri", models, needs };
+    }
+    // None needed, or two: pi goes by the profile, or its default - with two, which is not one of them for every model.
+    if (fromProfile !== undefined)
+        return { region: fromProfile, source: "profile", models, ...withConflict };
+    return { ...(models.length > 0 && conflict === undefined ? { region: DEFAULT_REGION } : {}), source: "default", models, ...withConflict };
+}
+/**
+ * Set AWS_REGION for a project's Bedrock models, as `bedrockRegionFor` says: when they need a region and the person
+ * set none. Done again when the models change, it moves or takes back what turri set before, never the person's.
+ */
+export function applyBedrockRegion(projectDir, options = {}) {
+    const env = options.env ?? process.env;
+    let decided;
+    try {
+        decided = bedrockRegionFor(projectDir, { ...options, env });
+    }
+    catch {
+        // A config that does not read is the model check's to say: nothing is set from it.
+        return { source: "default", models: [] };
+    }
+    if (decided.source === "turri" && decided.region !== undefined) {
+        env.AWS_REGION = decided.region;
+        env[TURRI_AWS_REGION] = decided.region;
+    }
+    else if (decided.source !== "set" && env[TURRI_AWS_REGION] !== undefined) {
+        // What turri set before is needed no more - or two regions are now: taken back, not guessed.
+        if (env.AWS_REGION === env[TURRI_AWS_REGION])
+            delete env.AWS_REGION;
+        delete env[TURRI_AWS_REGION];
+    }
+    return decided;
+}
+/** A line on the region, for a model check: what turri set and how to override it - or the conflict it would not guess. */
+export function describeBedrockRegion(decided) {
+    if (decided.conflict !== undefined) {
+        const needs = decided.conflict.map((each) => `${each.models.join(", ")} need${each.models.length === 1 ? "s" : ""} ${each.region} (${each.geography})`).join("; ");
+        return `the Bedrock models need two AWS regions - ${needs} - and one AWS_REGION serves every model: turri set none. Use models of one geography, or global ones.`;
+    }
+    if (decided.region === undefined)
+        return undefined;
+    if (decided.source === "turri")
+        return `turri calls Bedrock in ${decided.region}, the region the models' geography needs - AWS_REGION, set, overrides it`;
+    if (decided.source === "set") {
+        const outside = decided.needs !== undefined && !regionInGeography(decided.region, decided.needs.geography);
+        return outside
+            ? `pi calls Bedrock in ${decided.region}, set in AWS_REGION or AWS_DEFAULT_REGION - but the models are served in ${decided.needs.geography}: set it to a region there, ${decided.needs.region}, or unset it and turri sets it`
+            : `pi calls Bedrock in ${decided.region}, set in AWS_REGION or AWS_DEFAULT_REGION - the models have to be served there`;
+    }
+    if (decided.source === "profile")
+        return `pi calls Bedrock in ${decided.region}, the AWS profile's region - AWS_REGION, set, overrides it`;
+    return `pi calls Bedrock in ${decided.region}, its default - AWS_REGION, set, overrides it`;
+}

package/dist/btw.d.ts

@@ -12,7 +12,7 @@
 import type { AskUser, AskUserRequest } from "./ask.ts";
 /** How many tool calls the side agent may make before it is told to answer. */
 export declare const SIDE_CALLS = 20;
-/** "/btw what is a frid?" -> "what is a frid?"; "/btw" alone -> ""; anything else is not a side question. */
+/** "/btw what is a func-id?" -> "what is a func-id?"; "/btw" alone -> ""; anything else is not a side question. */
 export declare function sideQuestionOf(text: string): string | undefined;
 /** The skill running now, as the side agent is told of it. */
 export interface SkillRunNow {

package/dist/btw.js

@@ -19,7 +19,7 @@ export const SIDE_CALLS = 20;
 /** How much of a transcript the side agent is shown, from its end. */
 const CONVERSATION_CHARS = 24_000;
 const SKILL_SESSION_CHARS = 16_000;
-/** "/btw what is a frid?" -> "what is a frid?"; "/btw" alone -> ""; anything else is not a side question. */
+/** "/btw what is a func-id?" -> "what is a func-id?"; "/btw" alone -> ""; anything else is not a side question. */
 export function sideQuestionOf(text) {
     const match = /^\s*\/btw(?:\s+|$)([\s\S]*)$/i.exec(text);
     return match === null ? undefined : match[1].trim();

package/dist/change-plain-cli.js

@@ -1,38 +1,45 @@
 import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
-import { checkPlainFile } from "./plain/check.js";
-import { applySpecDiff, revertSpecDiff } from "./regenerate/regenerate.js";
+import { checkTouchedPlain, formatCheckResults } from "./plain/check.js";
+import { applySpecDiff, plainFilesOf, revertSpecDiff } from "./regenerate/regenerate.js";
+import { testPlainFileRefusal } from "./test-plain-files.js";
 import { parseArgs } from "./cli-options.js";
 import { headlessOptions, runLoop } from "./loop-cli.js";
 const USAGE = `usage: turri change-plain <file.plain> <diff-file> [options]
 
-Applies a change to ***plain, given as a git diff of the .plain files, and builds it: the headless
+Applies a change to ***plain, given as a git diff of the .plain files - modules and test plain files - and
+builds it: the headless
 counterpart of regenerate, given a diff. The diff is applied first, unless it is already in; then, as
 turri regenerate does, what is left to build is planned into jobs and built.
 
-  --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
   --start-over             start over, without asking, a codebase regenerated without a module it now requires
   --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
-  --conformance-tests <all|chosen|module|false>
-                           its conformance-tests: which conformance tests are written and run
   --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), ["--start-over"], USAGE, ["--build-dir", "--report", "--conformance-tests", "--harness-model", "--judge-model", "--review"]);
-const { report, buildDir } = headlessOptions(options, true);
+const { positional, options } = parseArgs(process.argv.slice(2), ["--start-over"], USAGE, ["--build-dir", "--report", "--harness-model", "--judge-model", "--review"]);
+const { report, buildDir } = headlessOptions(options);
 const [plainFile, diffFile] = positional;
 if (plainFile === undefined || diffFile === undefined) {
     console.error(USAGE);
     process.exit(1);
 }
+const refusal = testPlainFileRefusal(plainFile);
+if (refusal !== undefined) {
+    console.error(refusal);
+    process.exit(1);
+}
 const diff = readFileSync(diffFile, "utf8");
 const cwd = process.cwd();
-applySpecDiff(diff, cwd);
-const check = checkPlainFile(resolve(plainFile));
-if (!check.ok) {
-    revertSpecDiff(diff, cwd);
-    console.error(`Nothing was changed: with this diff ${plainFile} no longer parses. ${check.error}`);
+const applied = applySpecDiff(diff, cwd);
+// Every file the diff touched is checked - a test plain file as its module - not only the one named.
+const failed = checkTouchedPlain([plainFile, ...plainFilesOf(diff)].map((file) => resolve(cwd, file))).filter((check) => !check.ok);
+if (failed.length > 0) {
+    if (applied === "applied")
+        revertSpecDiff(diff, cwd);
+    console.error(`Nothing was changed: with this diff the ***plain no longer checks.\n${formatCheckResults(failed)}`);
     process.exit(1);
 }
 runLoop({

package/dist/chat-idle.d.ts

@@ -0,0 +1,7 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ChatLink } from "./chats.ts";
+/**
+ * Whether a chat is busy, for what turri tells it of its own accord - a test advisor's verdict, a background skill run's
+ * end - and so waits: its agent working, or the person typing - or no session to tell yet. Nothing told so interrupts.
+ */
+export declare function chatBusy(link: ChatLink, context: () => ExtensionContext | undefined): boolean;

package/dist/chat-idle.js

@@ -0,0 +1,20 @@
+/**
+ * Whether a chat is busy, for what turri tells it of its own accord - a test advisor's verdict, a background skill run's
+ * end - and so waits: its agent working, or the person typing - or no session to tell yet. Nothing told so interrupts.
+ */
+export function chatBusy(link, context) {
+    const session = link.session();
+    if (session === undefined || session.isStreaming || session.isCompacting || session.isRetrying)
+        return true;
+    const ctx = context();
+    try {
+        if (ctx !== undefined && (!ctx.isIdle() || ctx.hasPendingMessages()))
+            return true;
+        if (ctx?.hasUI === true && ctx.ui.getEditorText().trim() !== "")
+            return true;
+    }
+    catch {
+        /* a context let go: the session says enough */
+    }
+    return false;
+}

package/dist/chats.d.ts

@@ -6,6 +6,7 @@ import { type SentinelSetting } from "./config.ts";
 import type { AskUserIO } from "./ask.ts";
 import type { Job, JobRegistry } from "./regenerate/jobs.ts";
 import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
+import type { AdvisorVerdict } from "./regenerate/advisor-runs.ts";
 import { type ChatRole, type Conclusion, type Notice, type NoticeAnswer, type NoticeInput } from "./notice.ts";
 /**
  * The chats of a turri session.
@@ -110,12 +111,19 @@ export interface ChatInstance {
     concluded(conclusion: Conclusion): void;
     /** The person answered a notice with something to do: the chat's agent started on it. */
     act(task: string): void;
+    /**
+     * The test advisor's verdict: once the chat is idle - its agent done, nothing typed - a yes starts a turn that writes its
+     * scenarios, and a no is a line. Those that arrive meanwhile are delivered together.
+     */
+    advised(verdict: AdvisorVerdict): void;
     /** The jobs changed: what it draws of them is drawn again. */
     jobsChanged(): void;
     /** How hard the chat's model thinks now: sub-agents started from it think as hard. */
     thinkingLevel(): string | undefined;
     /** The chat's context, as its tools get it - for its model and its providers. */
     context(): ExtensionContext | undefined;
+    /** Conformance tests turned on or off: the chat's tools switched to match - conform and evaluate_tests, or the tool that turns them on. */
+    conformanceSwitched?(): void;
 }
 /** A chat's extension, linked to its chat. */
 export interface ChatLink {
@@ -213,6 +221,8 @@ export interface TurriCore {
     notice(input: NoticeInput): Notice | undefined;
     /** The sentinel done with a pulse: told to the chat the person looks at. Undefined: no chat to tell. */
     concluded(conclusion: Conclusion): string | undefined;
+    /** The test advisor's verdict, for the chat the person looks at - held until there is one. Undefined: no chat to hand it to yet. */
+    advised(verdict: AdvisorVerdict): string | undefined;
     /** The notices put to the person and not yet answered. */
     notices(): Notice[];
     /**

package/dist/chats.js

@@ -104,6 +104,8 @@ export function createChats(options) {
     let consent = "unasked";
     let asking;
     const held = [];
+    /** The test advisor's verdicts that came with no chat of the person's to hand them to: handed on as one comes up. */
+    const unplaced = [];
     const run = { run: randomUUID().slice(0, 8), pid: process.pid, started: new Date().toISOString(), chats: [] };
     const changed = () => {
         for (const listener of listeners) {
@@ -357,6 +359,10 @@ export function createChats(options) {
                 session: () => chat.session,
                 live: (instance) => {
                     chat.instance = instance;
+                    // The advisor's verdicts that waited for a chat of the person's.
+                    if (unplaced.length > 0 && personFacing() !== undefined)
+                        for (const verdict of unplaced.splice(0))
+                            core.advised(verdict);
                 },
             };
         },
@@ -456,6 +462,23 @@ export function createChats(options) {
             changed();
             return target.id;
         },
+        advised(verdict) {
+            const target = personFacing();
+            if (target?.instance === undefined) {
+                unplaced.push(verdict);
+                return undefined;
+            }
+            if (target.id !== shownId)
+                target.unread = true;
+            try {
+                target.instance.advised(verdict);
+            }
+            catch {
+                /* a chat let go as it was told: a yes stays undelivered in the advisor's file, for the next start */
+            }
+            changed();
+            return target.id;
+        },
         answer(id, answer) {
             const notice = open.find((candidate) => candidate.id === id);
             if (notice === undefined)

package/dist/cli-options.d.ts

@@ -15,11 +15,10 @@ export declare function parseArgs(argv: string[], flags: string[], usage: string
 export declare function optionValue(options: Record<string, string | undefined>, name: string): string | undefined;
 /**
  * The options that stand for the config's own keys - `--harness-model`, `--coding-model` (`--model`), `--judge-model`
- * and, as asked, `--review`, `--mutation-testing` and `--conformance-tests` - read as if config.turri.yaml had them, in their place in the
+ * and, as asked, `--review` and `--mutation-testing` - read as if config.turri.yaml had them, in their place in the
  * order the config resolves them in (overrideConfig): a run, or doctor, with them is the same as one with them in the
  * file. Exits on a value it cannot read.
  */
 export declare function configKeyOptions(options: Record<string, string | undefined>, take?: {
-    conformance?: boolean;
     review?: boolean;
 }): void;

package/dist/cli-options.js

@@ -1,4 +1,4 @@
-import { booleanOption, conformanceOption, overrideConfig, splitModelSpec } from "./config.js";
+import { booleanOption, overrideConfig, splitModelSpec } from "./config.js";
 /**
  * The command line of turri's commands: their words, and the options that stand for the config's own keys - kept apart
  * from the commands that use them, so a light one (doctor) reads them as a regenerate does without loading it.
@@ -51,7 +51,7 @@ export function optionValue(options, name) {
 }
 /**
  * The options that stand for the config's own keys - `--harness-model`, `--coding-model` (`--model`), `--judge-model`
- * and, as asked, `--review`, `--mutation-testing` and `--conformance-tests` - read as if config.turri.yaml had them, in their place in the
+ * and, as asked, `--review` and `--mutation-testing` - read as if config.turri.yaml had them, in their place in the
  * order the config resolves them in (overrideConfig): a run, or doctor, with them is the same as one with them in the
  * file. Exits on a value it cannot read.
  */
@@ -63,10 +63,6 @@ export function configKeyOptions(options, take = {}) {
             failOption(`--${name} takes true or false, not ${given}`);
         return value;
     };
-    const tests = take.conformance === true ? optionValue(options, "conformance-tests") : undefined;
-    const setting = tests !== undefined ? conformanceOption(tests) : undefined;
-    if (tests !== undefined && setting === undefined)
-        failOption(`--conformance-tests takes all, chosen, module or false, not ${tests}`);
     const review = flag("review");
     const mutationTesting = flag("mutation-testing");
     const model = (name, key) => {
@@ -77,7 +73,6 @@ export function configKeyOptions(options, take = {}) {
         ...model("harness-model", "harnessModel"),
         ...model("model", "codingModel"),
         ...model("judge-model", "judgeModel"),
-        ...(setting !== undefined ? { conformanceTests: setting } : {}),
         ...(review !== undefined ? { review } : {}),
         ...(mutationTesting !== undefined ? { mutationTesting } : {}),
     });

package/dist/cli.js

@@ -72,12 +72,12 @@ function chat(args) {
     process.exit(result.status ?? 1);
 }
 const COMMANDS = {
-    regenerate: { module: "./regenerate-cli.ts", blurb: "regenerate a module and its chain from the spec as it is (with frids: regenerate those again)" },
+    regenerate: { module: "./regenerate-cli.ts", blurb: "regenerate a module and its chain from the spec as it is (with module:func-ids: regenerate those again)" },
     glimpse: { module: "./regenerate-cli.ts", blurb: "plan the work and print the first job's prompt, starting nothing", args: ["--dry-run"] },
     drift: { module: "./drift-cli.ts", blurb: "what is left to regenerate: how far the code has drifted from its spec" },
     conform: { module: "./conform-cli.ts", blurb: "write and run a module's conformance tests" },
     "change-plain": { module: "./change-plain-cli.ts", blurb: "apply a change to ***plain, given as a git diff, and regenerate it" },
-    validate: { module: "./validate-cli.ts", blurb: "validate a ***plain spec, regenerating nothing" },
+    parse: { module: "./parse-cli.ts", blurb: "parse ***plain - its syntax and structure, never its code or tests - regenerating nothing" },
     lineage: { module: "./lineage-cli.ts", blurb: "a module's lineage: what was regenerated into it, and when" },
     ledger: { module: "./ledger-cli.ts", blurb: "what turri did here: the last runs and their pulses, or one pulse, from the ledger" },
     release: { module: "./release-cli.ts", blurb: "release what is regenerated to dist/<module> and activate it on this machine" },
@@ -147,6 +147,14 @@ if (command === "-v" || command === "--version") {
     console.log(versionLine());
     process.exit(0);
 }
+// The AWS region the project's Bedrock models need, set before any model is called - here, and in the pi the chat starts,
+// which inherits it - unless the person set one (bedrock-region.ts). The models named on the command line count too. A
+// command that calls no model is left alone.
+if (!["parse", "drift", "lineage", "ledger", "init-config"].includes(command ?? "")) {
+    const { applyBedrockRegion } = await import("./bedrock-region.js");
+    const named = argv.flatMap((arg, at) => ["--harness-model", "--coding-model", "--model"].includes(arg) ? [argv[at + 1] ?? ""] : arg.startsWith("--harness-model=") || arg.startsWith("--coding-model=") || arg.startsWith("--model=") ? [arg.slice(arg.indexOf("=") + 1)] : []);
+    applyBedrockRegion(process.cwd(), { also: named.filter((model) => model !== "") });
+}
 // turri alone is the conversation, and so is turri with pi's options - `turri -c`, `turri --harness-model <m>`. A word
 // turri does not know is an error below, not a conversation started on it.
 if (command === undefined || command.startsWith("-"))
@@ -175,7 +183,7 @@ process.argv = [
 // A headless run is stopped by a signal - SIGTERM, SIGHUP, Ctrl-C - whatever else listens for it: it exits, and what
 // its agents left running goes with it (shell.ts kills every process group on exit). Left to the libraries' own
 // handlers, one ran on for minutes after it was told to stop, building in the same codebase as the run after it.
-if (!["validate", "check", "drift", "lineage", "ledger"].includes(command)) {
+if (!["parse", "drift", "lineage", "ledger"].includes(command)) {
     for (const [signal, code] of [["SIGTERM", 143], ["SIGHUP", 129], ["SIGINT", 130]]) {
         process.on(signal, () => {
             console.error(`\nstopped (${signal})`);

package/dist/config-command.d.ts

@@ -1,4 +1,5 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { type Setting } from "./config-edit.ts";
 /**
  * `/turri-config`: every setting of the project's config.turri.yaml from the chat - `/turri-config` alone lists them,
  * `/turri-config review` asks for review's value, `/turri-config review false` sets it. Each is written into the file
@@ -23,4 +24,17 @@ export interface TurriConfigOptions {
     chatSpec: () => string | undefined;
     live: LiveHooks;
 }
+/** The models pi can reach here, signed in: provider/id - from a chat's context, the model registry the chats use. */
+export declare function reachable(ctx: ExtensionContext | undefined): string[];
+/**
+ * Every value /turri-config offers for a setting after what is typed, in its order - "unset" left out, and uncapped: what
+ * its completions show, the first of them, and what a host's settings list shows (host-session.ts `settingChoices`).
+ * A model setting's are every model pi can reach, signed in - `models` - and after a colon, that model's thinking levels.
+ */
+export declare function settingCandidates(setting: Setting, typed: string, where: {
+    cwd: string;
+    models: () => string[];
+}): string[];
+/** The ***plain rules there are, by name - what rules-off takes, and its values. */
+export declare function ruleNames(): string[];
 export declare function registerTurriConfig(pi: ExtensionAPI, options: TurriConfigOptions): void;

package/dist/config-command.js

@@ -1,12 +1,16 @@
+import { join } from "node:path";
+import { applyBedrockRegion } from "./bedrock-region.js";
 import { CONFIG_FILE, LEGACY_CONFIG_FILE, THINKING_LEVELS, usesLegacyConfig } from "./config.js";
 import { currentValue, dotenvFiles, EFFECT_TEXT, overriddenBy, parseValue, pathOptions, readConfigText, settingOf, settings, shownValue, writeSetting, } from "./config-edit.js";
+import { PACKAGE_ROOT } from "./environment.js";
+import { loadRules } from "./rules.js";
 /** The option that unsets a setting, for a setting. */
 const unsetOption = (setting) => `unset - ${setting.unset}`;
 const TYPE_ANOTHER = "type another…";
 const DONE = "done";
 const ROLES_ENTRY = "models.<role> - each agent role's own model, thinking and turn limit…";
-/** The models pi can reach here, signed in: provider/id. */
-function reachable(ctx) {
+/** The models pi can reach here, signed in: provider/id - from a chat's context, the model registry the chats use. */
+export function reachable(ctx) {
     try {
         return (ctx?.modelRegistry.getAvailable() ?? []).map((model) => `${model.provider}/${model.id}`).sort();
     }
@@ -14,6 +18,31 @@ function reachable(ctx) {
         return [];
     }
 }
+/** How many values the terminal's autocomplete shows for a setting: a host reads them whole (`settingCandidates`). */
+const COMPLETIONS_SHOWN = 40;
+/**
+ * Every value /turri-config offers for a setting after what is typed, in its order - "unset" left out, and uncapped: what
+ * its completions show, the first of them, and what a host's settings list shows (host-session.ts `settingChoices`).
+ * A model setting's are every model pi can reach, signed in - `models` - and after a colon, that model's thinking levels.
+ */
+export function settingCandidates(setting, typed, where) {
+    const candidates = setting.kind === "boolean"
+        ? ["true", "false"]
+        : setting.kind === "model"
+            ? typed.includes(":")
+                ? THINKING_LEVELS.map((level) => `${typed.slice(0, typed.lastIndexOf(":"))}:${level}`)
+                : where.models()
+            : setting.kind === "path"
+                ? pathOptions(where.cwd, setting.key)
+                : setting.key === "agent-env.files"
+                    ? dotenvFiles(where.cwd)
+                    : (setting.options ?? []);
+    return candidates.filter((candidate) => candidate.startsWith(typed));
+}
+/** The ***plain rules there are, by name - what rules-off takes, and its values. */
+export function ruleNames() {
+    return loadRules(join(PACKAGE_ROOT, "genome", "rules")).map((rule) => rule.name);
+}
 /** A setting's line in the list: its key, what it is now - or what it is unset - and what it does. */
 function listLine(setting, text) {
     const value = currentValue(text, setting.key);
@@ -39,6 +68,9 @@ export function registerTurriConfig(pi, options) {
         const adopting = usesLegacyConfig(cwd);
         const text = writeSetting(cwd, setting.key, value);
         const notes = [];
+        // A model changed: the AWS region its Bedrock models need is worked out again - set, moved or taken back by turri.
+        if (setting.key.endsWith("-model") || setting.key.startsWith("models."))
+            applyBedrockRegion(cwd);
         // What turri fixed at its start, changed now.
         if (setting.key === "harness-model" || setting.key === "models.chat") {
             const said = await options.live.chatModel(options.chatSpec(), ctx);
@@ -83,7 +115,6 @@ export function registerTurriConfig(pi, options) {
             case "choice":
                 return pick(setting.options ?? [], false);
             case "number":
-            case "budget":
                 return pick(setting.options ?? []);
             case "path":
                 return pick(pathOptions(cwd, setting.key));
@@ -182,18 +213,7 @@ export function registerTurriConfig(pi, options) {
             if (setting === undefined)
                 return null;
             const typed = prefix.slice(space + 1).trimStart();
-            const candidates = setting.kind === "boolean"
-                ? ["true", "false"]
-                : setting.kind === "model"
-                    ? typed.includes(":")
-                        ? THINKING_LEVELS.map((level) => `${typed.slice(0, typed.lastIndexOf(":"))}:${level}`)
-                        : reachable(seen)
-                    : setting.kind === "path"
-                        ? pathOptions(cwd, setting.key)
-                        : setting.key === "agent-env.files"
-                            ? dotenvFiles(cwd)
-                            : (setting.options ?? []);
-            const items = [...candidates, "unset"].filter((candidate) => candidate.startsWith(typed)).slice(0, 40);
+            const items = [...settingCandidates(setting, typed, { cwd, models: () => reachable(seen) }), ...("unset".startsWith(typed) ? ["unset"] : [])].slice(0, COMPLETIONS_SHOWN);
             return items.length === 0 ? null : items.map((candidate) => ({ value: `${setting.key} ${candidate}`, label: candidate }));
         },
         handler: async (args, ctx) => {

package/dist/config-edit.d.ts

@@ -6,7 +6,7 @@
  */
 /** When a change takes effect. Nothing turri reads needs a restart: what is fixed at its start is changed live. */
 export type Effect = "now" | "next-message" | "next-pulse" | "next-plan" | "next-test-run" | "next-landing" | "next-regenerate" | "next-start";
-export type SettingKind = "boolean" | "choice" | "number" | "model" | "list" | "path" | "budget";
+export type SettingKind = "boolean" | "choice" | "number" | "model" | "list" | "path";
 export interface Setting {
     /** As written in the file - a nested one by its path: `models.coding`, `models.coding.turn-limit`, `agent-env.files`. */
     key: string;
@@ -16,7 +16,7 @@ export interface Setting {
     /** What it is when it is not set. */
     unset: string;
     effect: Effect;
-    /** The words it takes (choice), or the values offered first (number, budget, list). */
+    /** The words it takes (choice), or the values offered first (number, list). */
     options?: string[];
     /** The least a number may be. */
     min?: number;
@@ -65,7 +65,7 @@ export declare function overriddenBy(dir: string, text: string, setting: Setting
  * file in the old naming when they are what the project is read from - and give back the file as written.
  */
 export declare function writeSetting(dir: string, key: string, value: unknown): string;
-/** 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 declare function pathOptions(dir: string, key: string): string[];
 /** The dotenv files of the project root, for agent-env.files. */
 export declare function dotenvFiles(dir: string): string[];