@turri-dev/cli 0.0.0-stage → 0.1.1

package/dist/btw.js

@@ -0,0 +1,174 @@
+/**
+ * /btw: a question on the side, answered while the conversation is busy - a skill's interview, its long steps - without
+ * waiting for it, and without changing it.
+ *
+ * A skill runs inside one tool call, so the chat model can answer nothing until the skill returns, and whatever the
+ * person types meanwhile waits for it as a message. pi runs an extension's command at once, even mid-turn: /btw starts
+ * an agent of its own - fresh, read only - that is shown the conversation, what the running skill has done and said so
+ * far, and what is regenerating, and answers. Its answer is shown and kept out of every model's context: the
+ * conversation and the skill go on as if nothing was asked. While a question of the skill's has the keys, the same is
+ * typed into its "Something else…" - answered, and the question asked again with the answer above it.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { confinedTools } from "./regenerate/confine.js";
+import { TURRI_IDENTITY } from "./identity.js";
+import { ask, BEGIN, createExecutor } from "./pi.js";
+/** How many tool calls the side agent may make before it is told to answer. */
+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. */
+export function sideQuestionOf(text) {
+    const match = /^\s*\/btw(?:\s+|$)([\s\S]*)$/i.exec(text);
+    return match === null ? undefined : match[1].trim();
+}
+let running;
+/** Says a skill is running, until the function it returns is called. */
+export function skillRunStarted(run) {
+    running = run;
+    return () => {
+        if (running === run)
+            running = undefined;
+    };
+}
+export function runningSkill() {
+    return running;
+}
+/**
+ * A session's messages as plain text - who said what, tool calls named - its last `maxChars`. Thinking and tool
+ * results are left out: what was said, and what was done, is what a side question is about.
+ */
+export function transcriptOf(entries, maxChars) {
+    const lines = [];
+    for (const entry of entries) {
+        const { type, message } = entry;
+        if (type !== "message" || message === undefined)
+            continue;
+        const who = message.role === "user" ? "user" : message.role === "assistant" ? "assistant" : undefined;
+        if (who === undefined)
+            continue;
+        const parts = typeof message.content === "string" ? [{ type: "text", text: message.content }] : Array.isArray(message.content) ? message.content : [];
+        for (const part of parts) {
+            if (part.type === "text" && part.text !== undefined && part.text.trim() !== "")
+                lines.push(`${who}: ${part.text.trim()}`);
+            else if (part.type === "toolCall" && part.name !== undefined)
+                lines.push(`${who} called ${part.name}`);
+        }
+    }
+    const text = lines.join("\n\n");
+    return text.length > maxChars ? `…${text.slice(-maxChars)}` : text;
+}
+/** The running skill's agent's session, as text: its last turns, read from the session file run.json names. */
+export function skillSessionText(runDir, maxChars = SKILL_SESSION_CHARS) {
+    try {
+        const manifest = JSON.parse(readFileSync(join(runDir, "run.json"), "utf8"));
+        if (manifest.sessionFile === undefined)
+            return "";
+        const entries = readFileSync(manifest.sessionFile, "utf8")
+            .split("\n")
+            .filter((line) => line.trim() !== "")
+            .flatMap((line) => {
+            try {
+                return [JSON.parse(line)];
+            }
+            catch {
+                return [];
+            }
+        });
+        return transcriptOf(entries, maxChars);
+    }
+    catch {
+        return "";
+    }
+}
+export function sideQuestionPrompt(side) {
+    return [
+        TURRI_IDENTITY,
+        "",
+        "The person is in the middle of something with you - a skill, a pulse - and has asked you a question on the side",
+        "with /btw. Answer it as turri: in the first person, to them, in whole sentences - briefly and plainly, from what is",
+        "below and what you can read. Never speak of turri as someone else, and never give them a message to pass on to",
+        "turri: they are talking to turri. You can read the project and your own source, and change nothing. Nothing you",
+        "say here reaches the conversation or the skill: they go on as they were. If the question is really a change of",
+        "course - do something else, stop, change an answer - say how: answer the skill's next question that way, /halt a",
+        "pulse, or ask you for it in the conversation once the skill is done; then say what you will do when they do.",
+        "",
+        `The project is ${side.projectDir}: its .plain specs, config.turri.yaml, plain_modules. You are ${side.harnessDir}:`,
+        "your source (src/), your skills (genome/skills/), the ***plain authoring rules (genome/rules/) and your docs (docs/).",
+        "",
+        "Reply with the answer alone, as you would say it - no preamble about how you found it.",
+        "",
+        "<conversation>",
+        side.conversation.trim() !== "" ? side.conversation : "(nothing yet)",
+        "</conversation>",
+        ...(side.skill !== undefined
+            ? [
+                "",
+                `A skill is running now: ${side.skill.name}${side.skill.step !== "" ? `, in its ${side.skill.step}` : ""}. Its own folder is`,
+                `${side.skill.dir}. What it has done - steps, gates, every question and answer:`,
+                "<skill-trace>",
+                ...side.skill.trace,
+                "</skill-trace>",
+                ...(side.skill.session.trim() !== ""
+                    ? ["", "Its agent's own session, the end of it - what it said and did:", "<skill-session>", side.skill.session, "</skill-session>"]
+                    : []),
+            ]
+            : []),
+        ...(side.pulses.length > 0 ? ["", "Pulses this session:", ...side.pulses.map((line) => `- ${line}`)] : []),
+        "",
+        "<question>",
+        side.question,
+        "</question>",
+    ].join("\n");
+}
+/** Answers a side question with an agent of its own, read only, on `model`. */
+export async function answerSideQuestion(side, model) {
+    const fence = confinedTools({ workdir: side.projectDir, read: [side.projectDir, side.harnessDir], write: [], noBash: true });
+    const session = await createExecutor({
+        cwd: side.projectDir,
+        customTools: fence.tools,
+        tools: fence.names,
+        model,
+        label: "side question",
+        role: "chat",
+        system: fence.note,
+        task: sideQuestionPrompt(side),
+        budget: { calls: SIDE_CALLS, finish: [] },
+    });
+    try {
+        const answer = (await ask(session, BEGIN)).trim();
+        return answer !== "" ? answer : "(no answer came back)";
+    }
+    finally {
+        session.dispose();
+    }
+}
+/** The answer to a side question, as it is shown above the question it was asked under. */
+export function asideBlock(question, answer) {
+    return `btw: ${question}\n${answer}`;
+}
+export const BTW_HOW = "Type your question after /btw - /btw what does this step do?";
+/**
+ * A question put to the person, where "/btw ..." typed as the answer is a side question: answered, and the same
+ * question asked again with the answer above it - the asker never sees it. Only the latest is kept above the question.
+ */
+export async function askWithAsides(request, askUser, aside) {
+    let current = request;
+    for (;;) {
+        const answer = await askUser(current);
+        const side = sideQuestionOf(answer);
+        if (side === undefined)
+            return answer;
+        let reply;
+        try {
+            reply = side === "" ? BTW_HOW : await aside(side);
+        }
+        catch (error) {
+            reply = `The side question could not be answered: ${error instanceof Error ? error.message : String(error)}`;
+        }
+        const above = side === "" ? reply : asideBlock(side, reply);
+        current = { ...request, context: [above, request.context?.trim() ?? ""].filter((part) => part !== "").join("\n\n") };
+    }
+}

package/dist/chat-models.js

@@ -0,0 +1,37 @@
+import { modelSpec, projectModels } from "./config.js";
+/**
+ * The two models of `turri`, from its arguments and the project's config.turri.yaml.
+ *
+ * The harness model is the one the person talks to: pi's own `--model`, which `--harness-model`
+ * is another name for, or else `harness-model:` in config.turri.yaml. The coding model is the one
+ * every render runs on: `--coding-model`, or else `coding-model:` in config.turri.yaml - pi knows
+ * nothing of it, so it reaches the extension through the environment. Either can still be
+ * changed in the conversation: pi's /model, engine.
+ */
+/** The environment variable a chat's --coding-model reaches the extension through. */
+export const CODING_MODEL_ENV = "TURRI_CODING_MODEL";
+/** Take a `--name value` or `--name=value` out of the arguments: its value, and the rest. The last one wins. */
+export function takeOption(args, name) {
+    const rest = [];
+    let value;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === name && i + 1 < args.length)
+            value = args[++i];
+        else if (arg.startsWith(`${name}=`))
+            value = arg.slice(name.length + 1);
+        else
+            rest.push(arg);
+    }
+    return { value, rest };
+}
+/** pi's arguments, with the harness model in them, and the coding model for the extension. */
+export function chatModels(args, config) {
+    const coding = takeOption(args, "--coding-model");
+    const harness = takeOption(coding.rest, "--harness-model");
+    const piArgs = harness.rest;
+    // pi's own flags win: a --model or --provider given as they are is left alone.
+    const given = piArgs.some((arg) => /^--(model|provider)(=|$)/.test(arg));
+    const harnessModel = given ? undefined : (harness.value ?? modelSpec(projectModels(config).harness));
+    return { piArgs: harnessModel !== undefined ? ["--model", harnessModel, ...piArgs] : piArgs, codingModel: coding.value };
+}

package/dist/chat-skills.js

@@ -0,0 +1,18 @@
+/**
+ * The pi skills the conversation is not offered, because turri has them already.
+ *
+ * pi lists for the conversation every skill it finds: `~/.pi/agent/skills`, `~/.agents/skills`, and the `.agents/skills`
+ * of every folder from the one turri started in up to its git root - so a folder above a project can hand the chat
+ * another tool's ***plain skills, a `load-plain-reference` it then loads at the start of a session. turri needs none of
+ * them: the whole ***plain reference - the authoring rules - is in the conversation's system prompt already, and turri
+ * runs its own skills, and the project's, with `cultivate`, steps and gates and all. A skill the chat followed by hand
+ * instead would skip those gates, and one from another tool may say otherwise than turri's rules. So the conversation
+ * is offered neither: no skill turri runs itself, and none about ***plain. A skill about anything else - a commit
+ * message, a deploy - is offered as pi offers it.
+ */
+/** What a skill says it is about, that turri covers: ***plain specs and their testing scripts. */
+const ABOUT_PLAIN = /\*\*\*plain|\\\*\\\*\\\*plain|\.plain\b|\bcodeplain\b|functional specs?\b|testing scripts?\b|run_unittests|run_conformance_tests/i;
+/** Whether turri has what a pi skill offers: it runs a skill of that name itself, or the skill is about ***plain. */
+export function supersededByTurri(skill, turriRuns) {
+    return turriRuns.has(skill.name) || ABOUT_PLAIN.test(`${skill.name} ${skill.description}`);
+}

package/dist/cli.js

@@ -0,0 +1,178 @@
+#!/usr/bin/env node
+/**
+ * One entry point, so the tools can be used from wherever the specification lives.
+ *
+ * Paths are resolved against the current working directory, and a .plain file's linked
+ * resources are too - so the intended use is to `cd` to the module and name the file,
+ * rather than to run from this repo and reach across with absolute paths.
+ */
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { spawnSync } from "node:child_process";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { CODING_MODEL_ENV, chatModels } from "./chat-models.js";
+import { readProjectConfig } from "./config.js";
+import { extensionInstalledGlobally, PACKAGE_ROOT, themesInstalledGlobally } from "./environment.js";
+import { dropNoise } from "./quiet.js";
+/**
+ * Start pi with this project's extension and themes already wired in.
+ *
+ * Saves both a global pi install and the `-e <absolute path>` that a project-local
+ * extension otherwise needs before the project is trusted.
+ */
+/**
+ * Where this file is, and how its siblings are named: the sources in a clone (`src/*.ts`), the compiled files in an
+ * installed package (`dist/*.js`).
+ */
+const HERE = dirname(fileURLToPath(import.meta.url));
+const OWN_EXTENSION = import.meta.url.endsWith(".ts") ? ".ts" : ".js";
+/** Whether pi is installed where Node finds it - beside turri, or wherever npm hoisted it. */
+function piInstalled() {
+    try {
+        import.meta.resolve("@earendil-works/pi-coding-agent");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** The theme `turri` starts in. */
+const DEFAULT_THEME = "turri-dark";
+function chat(args) {
+    if (!piInstalled()) {
+        console.error(`pi is not installed beside turri (${PACKAGE_ROOT}). Run npm install there, or install turri again.`);
+        process.exit(1);
+    }
+    // pi itself, through a launcher that leaves out pi's startup header - see pi-launch.ts.
+    const launcher = join(HERE, `pi-launch${OWN_EXTENSION}`);
+    // Loading the same extension twice is an error in pi, not a no-op, so the explicit -e is left out while an older
+    // turri's file still loads turri into every pi - turri doctor offers to remove it.
+    const extension = extensionInstalledGlobally()
+        ? []
+        : ["-e", join(HERE, `extension${OWN_EXTENSION}`)];
+    const themes = themesInstalledGlobally() ? [] : ["--theme", join(PACKAGE_ROOT, ".pi", "themes")];
+    // turri's own theme, unless this run names another. For this run only: pi's settings
+    // are left as they are, so a plain `pi` keeps its theme.
+    const useTheme = args.some((arg) => arg === "--use-theme" || arg.startsWith("--use-theme=")) ? [] : ["--use-theme", DEFAULT_THEME];
+    // The model the person talks to, and the one every render runs on - see chat-models.ts.
+    const { piArgs, codingModel } = chatModels(args, readProjectConfig(process.cwd()));
+    // Fullscreen: pi owns the viewport, so the conversation stays where it is scrolled to while the
+    // jobs redraw - in the terminal's own scrollback, every redraw pulls it back to the bottom.
+    const tuiMode = args.some((arg) => arg === "--tui-mode" || arg.startsWith("--tui-mode=")) ? [] : ["--tui-mode", "fullscreen"];
+    const result = spawnSync(process.execPath, [launcher, ...extension, ...themes, ...useTheme, ...tuiMode, ...piArgs], {
+        stdio: "inherit",
+        cwd: process.cwd(),
+        env: codingModel ? { ...process.env, [CODING_MODEL_ENV]: codingModel } : process.env,
+    });
+    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)" },
+    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" },
+    "spec-diff": { module: "./spec-diff-cli.ts", blurb: "apply a change to the specs, given as a git diff, and regenerate it" },
+    validate: { module: "./validate-cli.ts", blurb: "validate a ***plain spec, regenerating nothing" },
+    lineage: { module: "./lineage-cli.ts", blurb: "a module's lineage: what was regenerated into it, and when" },
+    release: { module: "./release-cli.ts", blurb: "release what is regenerated to dist/<module> and activate it on this machine" },
+    cultivate: { module: "./cultivate-cli.ts", blurb: "run a gated skill" },
+};
+/** Getting the machine ready, and checking it is. */
+const SETUP_COMMANDS = {
+    "init-config": "write a quick start config.turri.yaml here, from the vendor you use: a strong model to talk to, a smaller one to write the code",
+    doctor: "check what turri needs - in a project, what it needs of this machine, and that its models answer",
+};
+const USAGE = [
+    "usage: turri [options]          open the conversation here: pi, with turri's tools and themes loaded",
+    "       turri <command> [args]",
+    "",
+    `  ${"options".padEnd(12)} --harness-model <m>  the model you chat with   --coding-model <m>  the model renders run on`,
+    `  ${"".padEnd(12)} --stack <name>  build with config.turri.<name>.yaml over config.turri.yaml - here and in every command`,
+    `  ${"".padEnd(12)} --use-theme <t>  another theme than turri-dark - and every option of pi's own`,
+    "",
+    ...Object.entries(COMMANDS).map(([name, { blurb }]) => `  ${name.padEnd(12)} ${blurb}`),
+    "",
+    ...Object.entries(SETUP_COMMANDS).map(([name, blurb]) => `  ${name.padEnd(12)} ${blurb}`),
+    "",
+    "Run `turri <command> --help` for that command's options.",
+    "",
+    "Paths are relative to the current directory. Run turri from the directory holding the",
+    "specification, so that linked resources inside it resolve the way the parser expects.",
+].join("\n");
+dropNoise();
+// --stack <name>, for any command and for the conversation: the stack everything is built with (stacks.ts), taken out
+// before the rest is read - a command never sees it.
+const argv = await withoutStack(process.argv.slice(2));
+const [command, ...rest] = argv;
+async function withoutStack(args) {
+    const kept = [];
+    let stack;
+    for (let at = 0; at < args.length; at += 1) {
+        const arg = args[at];
+        if (arg === "--stack")
+            stack = args[++at] ?? "";
+        else if (arg.startsWith("--stack="))
+            stack = arg.slice("--stack=".length);
+        else
+            kept.push(arg);
+    }
+    if (stack === undefined)
+        return kept;
+    const { switchStack } = await import("./stacks.js");
+    try {
+        switchStack(process.cwd(), stack);
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+    return kept;
+}
+if (command === "-h" || command === "--help") {
+    console.log(USAGE);
+    process.exit(0);
+}
+// 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("-"))
+    chat(argv);
+if (command === "init-config") {
+    const { main } = await import("./init-config.js");
+    process.exit(await main(rest));
+}
+if (command === "doctor") {
+    const { main } = await import("./setup.js");
+    process.exit(await main(rest));
+}
+const entry = COMMANDS[command];
+if (entry === undefined) {
+    console.error(`unknown command: ${command}\n\n${USAGE}`);
+    process.exit(1);
+}
+// The subcommands parse process.argv themselves, so present it as if they were invoked
+// directly. Their agents are the coding agents: --coding-model is their --model.
+process.argv = [
+    process.argv[0],
+    process.argv[1],
+    ...rest.flatMap((arg) => arg === "--coding-model" ? ["--model"] : arg.startsWith("--coding-model=") ? ["--model", arg.slice("--coding-model=".length)] : [arg]),
+    ...(entry.args ?? []),
+];
+// 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"].includes(command)) {
+    for (const [signal, code] of [["SIGTERM", 143], ["SIGHUP", 129], ["SIGINT", 130]]) {
+        process.on(signal, () => {
+            console.error(`\nstopped (${signal})`);
+            process.exit(code);
+        });
+    }
+}
+await import(__rewriteRelativeImportExtension(entry.module));

package/dist/config-command.js

@@ -0,0 +1,197 @@
+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";
+/** 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) {
+    try {
+        return (ctx?.modelRegistry.getAvailable() ?? []).map((model) => `${model.provider}/${model.id}`).sort();
+    }
+    catch {
+        return [];
+    }
+}
+/** 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);
+    return `${setting.key}: ${value === undefined ? `(unset - ${setting.unset})` : shownValue(value)}`;
+}
+export function registerTurriConfig(pi, options) {
+    const { cwd } = options;
+    // The models for completions, which are given no context: the last one seen.
+    let seen;
+    pi.on("session_start", (_event, ctx) => {
+        seen = ctx;
+    });
+    /** Set a setting to what was typed - or unset it - and say what it did and when it takes effect. */
+    const apply = async (setting, typed, ctx) => {
+        const models = reachable(ctx);
+        const parsed = parseValue(setting, typed, models.length > 0 ? (model) => models.includes(model) : undefined);
+        if ("error" in parsed) {
+            ctx.ui.notify(parsed.error, "error");
+            return;
+        }
+        const value = "unset" in parsed ? undefined : parsed.value;
+        // The first setting written where the project is still read from config.yaml: copied to config.turri.yaml first.
+        const adopting = usesLegacyConfig(cwd);
+        const text = writeSetting(cwd, setting.key, value);
+        const notes = [];
+        // 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);
+            if (said !== undefined)
+                notes.push(said);
+        }
+        if (setting.key === "coding-model" || setting.key === "models.coding" || setting.key === "models.default") {
+            const said = options.live.codingModel();
+            if (said !== undefined)
+                notes.push(said);
+        }
+        if (setting.key === "parallel-jobs") {
+            const said = options.live.parallelJobs(typeof value === "number" ? value : undefined);
+            if (said !== undefined)
+                notes.push(said);
+        }
+        if (adopting)
+            notes.push(`${LEGACY_CONFIG_FILE} was copied to ${CONFIG_FILE} first - turri reads its own file from now on, and leaves ${LEGACY_CONFIG_FILE} as it is.`);
+        notes.push(...overriddenBy(cwd, text, setting));
+        const what = value === undefined ? `${setting.key} unset - ${setting.unset}` : `${setting.key}: ${shownValue(value)}`;
+        ctx.ui.notify([`${what} - written to ${CONFIG_FILE}, ${EFFECT_TEXT[setting.effect]}.`, ...notes].join("\n"), "info");
+    };
+    /** Ask for a setting's value, as its kind takes it: what is typed comes back, or nothing when the dialog is left. */
+    const askValue = async (setting, ctx) => {
+        const text = readConfigText(cwd);
+        const now = currentValue(text, setting.key);
+        const title = `${setting.key} - ${setting.about}\nNow: ${now === undefined ? `unset - ${setting.unset}` : shownValue(now)}`;
+        const pick = async (choices, typed = true) => {
+            const offered = [...choices, ...(typed ? [TYPE_ANOTHER] : []), unsetOption(setting)];
+            const chosen = await ctx.ui.select(title, offered);
+            if (chosen === undefined)
+                return undefined;
+            if (chosen === unsetOption(setting))
+                return "unset";
+            if (chosen === TYPE_ANOTHER)
+                return ctx.ui.input(title, setting.kind === "path" ? "path from the project root" : "value");
+            return chosen;
+        };
+        switch (setting.kind) {
+            case "boolean":
+                return pick(["true", "false"], false);
+            case "choice":
+                return pick(setting.options ?? [], false);
+            case "number":
+            case "budget":
+                return pick(setting.options ?? []);
+            case "path":
+                return pick(pathOptions(cwd, setting.key));
+            case "model": {
+                const model = await pick(reachable(ctx));
+                // Typed with its level - provider/id:low - it is whole already.
+                if (model === undefined || model === "unset" || model.includes(":"))
+                    return model;
+                const level = await ctx.ui.select(`${model} - how hard it thinks`, [...THINKING_LEVELS, "the role's own level"]);
+                if (level === undefined)
+                    return undefined;
+                return level === "the role's own level" ? model : `${model}:${level}`;
+            }
+            case "list": {
+                const choices = setting.key === "agent-env.files" ? dotenvFiles(cwd) : (setting.options ?? []);
+                if (choices.length === 0) {
+                    const typed = await ctx.ui.input(`${title}\nType them, separated by commas - or unset.`, Array.isArray(now) ? now.join(", ") : "");
+                    return typed;
+                }
+                // A tick a chosen one: pick to turn one on or off, done to keep them.
+                const chosen = new Set(Array.isArray(now) ? now.map(String) : []);
+                for (;;) {
+                    const offered = [DONE, ...choices.map((choice) => `${chosen.has(choice) ? "✓" : " "} ${choice}`), unsetOption(setting)];
+                    const picked = await ctx.ui.select(`${title}\nPick to turn one on or off, then done.`, offered);
+                    if (picked === undefined)
+                        return undefined;
+                    if (picked === unsetOption(setting))
+                        return "unset";
+                    if (picked === DONE)
+                        return chosen.size === 0 ? "unset" : [...chosen].join(", ");
+                    const name = picked.slice(2);
+                    if (chosen.has(name))
+                        chosen.delete(name);
+                    else
+                        chosen.add(name);
+                }
+            }
+        }
+    };
+    /** Pick a setting from the list - the models of each role behind one entry. */
+    const askSetting = async (ctx) => {
+        const text = readConfigText(cwd);
+        const all = settings(options.rules());
+        const top = all.filter((setting) => !setting.key.startsWith("models."));
+        const lines = [...top.map((setting) => listLine(setting, text)), ROLES_ENTRY];
+        const chosen = await ctx.ui.select(`/turri-config - the project's ${CONFIG_FILE}. Pick a setting to change:`, lines);
+        if (chosen === undefined)
+            return undefined;
+        if (chosen === ROLES_ENTRY) {
+            const roles = all.filter((setting) => setting.key.startsWith("models."));
+            const role = await ctx.ui.select("Which role's model or turn limit?", roles.map((setting) => listLine(setting, text)));
+            return role === undefined ? undefined : roles.find((setting) => role.startsWith(`${setting.key}:`));
+        }
+        return top.find((setting) => chosen.startsWith(`${setting.key}:`));
+    };
+    pi.registerCommand("turri-config", {
+        description: `Change a setting of the project's ${CONFIG_FILE}`,
+        getArgumentCompletions: (prefix) => {
+            const all = settings(options.rules());
+            const space = prefix.indexOf(" ");
+            if (space === -1) {
+                const items = all.filter((setting) => setting.key.startsWith(prefix.trim().toLowerCase()));
+                return items.length === 0 ? null : items.map((setting) => ({ value: `${setting.key} `, label: setting.key, description: setting.about }));
+            }
+            const setting = settingOf(prefix.slice(0, space), options.rules());
+            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);
+            return items.length === 0 ? null : items.map((candidate) => ({ value: `${setting.key} ${candidate}`, label: candidate }));
+        },
+        handler: async (args, ctx) => {
+            seen = ctx;
+            const typed = args.trim();
+            const space = typed.indexOf(" ");
+            const key = space === -1 ? typed : typed.slice(0, space);
+            const value = space === -1 ? "" : typed.slice(space + 1).trim();
+            if (!ctx.hasUI && (key === "" || value === ""))
+                return;
+            let setting;
+            if (key === "") {
+                setting = await askSetting(ctx);
+                if (setting === undefined)
+                    return;
+            }
+            else {
+                setting = settingOf(key, options.rules());
+                if (setting === undefined) {
+                    const near = settings(options.rules()).filter((entry) => entry.key.includes(key.toLowerCase())).map((entry) => entry.key);
+                    ctx.ui.notify(`No setting ${key}.${near.length > 0 ? ` Did you mean ${near.slice(0, 5).join(", ")}?` : " /turri-config alone lists them."}`, "error");
+                    return;
+                }
+            }
+            const given = value !== "" ? value : await askValue(setting, ctx);
+            if (given === undefined)
+                return;
+            await apply(setting, given, ctx);
+        },
+    });
+}