@turri-dev/cli 0.1.3-next.17f0f7f → 0.1.3-next.26f08c5

package/dist/cli-options.js

@@ -0,0 +1,82 @@
+import { conformanceOption, overrideConfig, reviewOption, 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.
+ */
+/**
+ * A command's arguments: the positional ones, `--flag`s and `--name value` options (`--name=value` too) -
+ * `--coding-model` is `--model`. An option it does not take is refused, rather than taking the word after it, and so is an
+ * option with no value - the end of the words, or another option where its value should be.
+ */
+export function parseArgs(argv, flags, usage, valued = []) {
+    const positional = [];
+    const options = {};
+    const takes = new Set(["--model", ...valued]);
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        const [name, inline] = arg.startsWith("--") && arg.includes("=") ? [arg.slice(0, arg.indexOf("=")), arg.slice(arg.indexOf("=") + 1)] : [arg, undefined];
+        const option = name === "--coding-model" ? "--model" : name;
+        if (arg === "-h" || arg === "--help") {
+            console.log(usage);
+            process.exit(0);
+        }
+        else if (flags.includes(option) && inline === undefined)
+            options[option.slice(2)] = "yes";
+        else if (takes.has(option)) {
+            // Its value is the next word - never another option, which would be taken as the value and lost.
+            const value = inline ?? argv[i + 1];
+            if (value === undefined || (inline === undefined && value.startsWith("--"))) {
+                console.error(`${usage}\n\n${name} needs a value${value !== undefined ? `, not the option ${value}` : ""} - ${name}=<value> gives one that starts with --.`);
+                process.exit(1);
+            }
+            if (inline === undefined)
+                i += 1;
+            options[option.slice(2)] = value;
+        }
+        else if (arg.startsWith("-")) {
+            console.error(`${usage}\n\nNo such option: ${name}.`);
+            process.exit(1);
+        }
+        else
+            positional.push(arg);
+    }
+    return { positional, options };
+}
+/** An option's value, as parseArgs left it: refused when it was given with none. */
+export function optionValue(options, name) {
+    const value = options[name];
+    if (name in options && (value === undefined || value.trim() === ""))
+        failOption(`--${name} needs a value`);
+    return value;
+}
+/**
+ * The options that stand for the config's own keys - `--harness-model`, `--coding-model` (`--model`), `--judge-model`
+ * and, as asked, `--review` and `--conformance-tests` - 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 function configKeyOptions(options, take = {}) {
+    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 reviewed = take.review === true ? optionValue(options, "review") : undefined;
+    const review = reviewed !== undefined ? reviewOption(reviewed) : undefined;
+    if (reviewed !== undefined && review === undefined)
+        failOption(`--review takes true or false, not ${reviewed}`);
+    const model = (name, key) => {
+        const spec = optionValue(options, name);
+        return spec !== undefined ? { [key]: splitModelSpec(spec) } : {};
+    };
+    overrideConfig({
+        ...model("harness-model", "harnessModel"),
+        ...model("model", "codingModel"),
+        ...model("judge-model", "judgeModel"),
+        ...(setting !== undefined ? { conformanceTests: setting } : {}),
+        ...(review !== undefined ? { review } : {}),
+    });
+}
+function failOption(message) {
+    console.error(message);
+    process.exit(1);
+}

package/dist/conform-cli.js

@@ -1,4 +1,5 @@
-import { headlessOptions, parseArgs, runLoop } from "./loop-cli.js";
+import { parseArgs } from "./cli-options.js";
+import { headlessOptions, runLoop } from "./loop-cli.js";
 const USAGE = `usage: turri conform <file.plain> [frid ...] [options]
 
 Writes and runs the black-box conformance tests of a module's functional specs - those named, or

package/dist/environment.js

@@ -68,3 +68,22 @@ export function turriOnPath() {
     const found = which.status === 0 ? which.stdout.trim().split("\n")[0] : undefined;
     return found === "" ? undefined : found;
 }
+/** turri's version, and the commit when it runs from a clone. */
+export function turriIdentity() {
+    let version = null;
+    try {
+        version = JSON.parse(readFileSync(join(PACKAGE_ROOT, "package.json"), "utf8")).version ?? null;
+    }
+    catch {
+        /* no package.json: left out */
+    }
+    if (!existsSync(join(PACKAGE_ROOT, ".git")))
+        return { version, git_commit: null, git_dirty: null };
+    const commit = spawnSync("git", ["-C", PACKAGE_ROOT, "rev-parse", "HEAD"], { encoding: "utf8" });
+    const status = spawnSync("git", ["-C", PACKAGE_ROOT, "status", "--porcelain", "--untracked-files=no"], { encoding: "utf8" });
+    return {
+        version,
+        git_commit: commit.status === 0 ? commit.stdout.trim() : null,
+        git_dirty: status.status === 0 ? status.stdout.trim() !== "" : null,
+    };
+}

package/dist/extension.js

@@ -52,6 +52,7 @@ import { registerStacks } from "./stacks.js";
 import { catalogueLine, discoverSkills, leftOutNote } from "./skills.js";
 import { supersededByTurri } from "./chat-skills.js";
 import { TURRI_IDENTITY } from "./identity.js";
+import { turriIdentity } from "./environment.js";
 import { conformanceChooser } from "./regenerate/choose-conformance.js";
 import { answerSideQuestion, askWithAsides, BTW_HOW, runningSkill, skillRunStarted, skillSessionText, transcriptOf } from "./btw.js";
 import { createJobRegistry, defaultParallelJobs, describeJob, formatDuration, pulseName, shouldWait, STOPPED_ON_REQUEST, } from "./regenerate/jobs.js";
@@ -2158,7 +2159,8 @@ function registerBranding(pi, ruleCount, skills) {
         if (data === undefined)
             return undefined;
         const lines = [
-            `${theme.fg("accent", "turri")}  ${theme.fg("muted", `v${data.version}`)}`,
+            `${theme.fg("accent", "turri")}  ${theme.fg("muted", `v${data.version}`)}` +
+                (data.commit !== undefined ? theme.fg("dim", `  from a clone, ${data.commit}${data.changed ? " with changes" : ""}`) : ""),
             theme.fg("text", "regenerative software - the code is regenerated from the spec"),
             theme.fg("muted", `${data.rules} rules · ${data.skills} skill${data.skills === 1 ? "" : "s"}` +
                 (data.projectSkills !== undefined && data.projectSkills > 0 ? ` (${data.projectSkills} the project's)` : "") +
@@ -2180,8 +2182,11 @@ function registerBranding(pi, ruleCount, skills) {
         if (ctx.hasUI)
             animateJellyfish(ctx);
         try {
+            const identity = turriIdentity();
             pi.appendEntry(BANNER_ENTRY, {
-                version: packageVersion(),
+                version: identity.version ?? "0.0.0",
+                commit: identity.git_commit?.slice(0, 7),
+                changed: identity.git_dirty === true,
                 rules: ruleCount,
                 skills: skills.skills.length,
                 projectSkills: skills.skills.filter((skill) => skill.origin !== "turri").length,
@@ -2361,12 +2366,3 @@ function jellyfishArt(appearance, ink) {
         return undefined;
     }
 }
-function packageVersion() {
-    try {
-        const raw = readFileSync(join(PACKAGE_ROOT, "package.json"), "utf8");
-        return JSON.parse(raw).version ?? "0.0.0";
-    }
-    catch {
-        return "0.0.0";
-    }
-}

package/dist/loop-cli.js

@@ -1,7 +1,7 @@
 import { sweepOrphanedGroups } from "./regenerate/shell.js";
 import { createInterface } from "node:readline/promises";
 import { resolve, sep } from "node:path";
-import { configForSpec, conformanceOption, reviewOption, inheritModel, modelOnly, modelSpec, overrideConfig, projectModels, readProjectConfig, roleModel, ROLE_THINKING, splitModelSpec, } from "./config.js";
+import { configForSpec, inheritModel, modelOnly, modelSpec, projectModels, readProjectConfig, roleModel, ROLE_THINKING, splitModelSpec, } from "./config.js";
 import { PACKAGE_ROOT } from "./environment.js";
 import { c } from "./module-report.js";
 import { tryItCommand } from "./regenerate/delivery.js";
@@ -13,6 +13,7 @@ import { MODULES_DIR, projectDirOf } from "./regenerate/paths.js";
 import { exportModule } from "./regenerate/release.js";
 import { listFiles } from "./regenerate/testing.js";
 import { startRunReport } from "./run-report.js";
+import { configKeyOptions, optionValue } from "./cli-options.js";
 /**
  * What every command that builds - `turri regenerate`, `conform`, `spec-diff` - does around its own
  * request of the work loop, as the chat does it: the project's models, a job that fails run once more and, failing again,
@@ -235,83 +236,15 @@ function reportModels(project, model) {
 }
 /**
  * The options every command that regenerates takes for a headless run: `--report` and `--build-dir`, and the config's
- * own keys - `--harness-model`, `--coding-model` (`--model`), `--judge-model`, `--review` and, where `conformance` is
- * true, `--conformance-tests` - read as if config.turri.yaml had them, the config's order of them kept (overrideConfig).
- * Exits on a value it cannot read.
+ * own keys (configKeyOptions) - `--harness-model`, `--coding-model` (`--model`), `--judge-model`, `--review` and, where
+ * `conformance` is true, `--conformance-tests` - read as if config.turri.yaml had them. Exits on a value it cannot read.
  */
 export function headlessOptions(options, conformance) {
-    const given = (name) => {
-        const value = options[name];
-        if (name in options && (value === undefined || value.trim() === ""))
-            failOption(`--${name} needs a value`);
-        return value;
-    };
-    const tests = conformance ? given("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 reviewed = given("review");
-    const review = reviewed !== undefined ? reviewOption(reviewed) : undefined;
-    if (reviewed !== undefined && review === undefined)
-        failOption(`--review takes true or false, not ${reviewed}`);
-    const model = (name) => {
-        const spec = given(name);
-        return spec !== undefined ? { [name === "model" ? "codingModel" : name === "harness-model" ? "harnessModel" : "judgeModel"]: splitModelSpec(spec) } : {};
-    };
-    overrideConfig({
-        ...model("harness-model"),
-        ...model("model"),
-        ...model("judge-model"),
-        ...(setting !== undefined ? { conformanceTests: setting } : {}),
-        ...(review !== undefined ? { review } : {}),
-    });
-    const report = given("report");
-    const buildDir = given("build-dir");
+    configKeyOptions(options, { conformance, review: true });
+    const report = optionValue(options, "report");
+    const buildDir = optionValue(options, "build-dir");
     return { ...(report !== undefined ? { report } : {}), ...(buildDir !== undefined ? { buildDir } : {}) };
 }
-function failOption(message) {
-    console.error(message);
-    process.exit(1);
-}
-/**
- * A command's arguments: the positional ones, `--flag`s and `--name value` options (`--name=value` too) -
- * `--coding-model` is `--model`. An option it does not take is refused, rather than taking the word after it, and so is an
- * option with no value - the end of the words, or another option where its value should be.
- */
-export function parseArgs(argv, flags, usage, valued = []) {
-    const positional = [];
-    const options = {};
-    const takes = new Set(["--model", ...valued]);
-    for (let i = 0; i < argv.length; i += 1) {
-        const arg = argv[i];
-        const [name, inline] = arg.startsWith("--") && arg.includes("=") ? [arg.slice(0, arg.indexOf("=")), arg.slice(arg.indexOf("=") + 1)] : [arg, undefined];
-        const option = name === "--coding-model" ? "--model" : name;
-        if (arg === "-h" || arg === "--help") {
-            console.log(usage);
-            process.exit(0);
-        }
-        else if (flags.includes(option) && inline === undefined)
-            options[option.slice(2)] = "yes";
-        else if (takes.has(option)) {
-            // Its value is the next word - never another option, which would be taken as the value and lost.
-            const value = inline ?? argv[i + 1];
-            if (value === undefined || (inline === undefined && value.startsWith("--"))) {
-                console.error(`${usage}\n\n${name} needs a value${value !== undefined ? `, not the option ${value}` : ""} - ${name}=<value> gives one that starts with --.`);
-                process.exit(1);
-            }
-            if (inline === undefined)
-                i += 1;
-            options[option.slice(2)] = value;
-        }
-        else if (arg.startsWith("-")) {
-            console.error(`${usage}\n\nNo such option: ${name}.`);
-            process.exit(1);
-        }
-        else
-            positional.push(arg);
-    }
-    return { positional, options };
-}
 /** Yes or no at the terminal - or undefined when there is none, and so no one to ask. */
 async function askAtTerminal(title, body) {
     if (process.stdin.isTTY !== true)

package/dist/pi-launch.js

@@ -9,19 +9,28 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
 import { dirname, join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { main, SettingsManager } from "@earendil-works/pi-coding-agent";
+import { ProcessTerminal } from "@earendil-works/pi-tui";
 import "./terminal-images.js";
 /**
  * pi, started the way its own CLI starts it, for `turri`.
  *
- * The one difference: pi's startup header - its version, key hints and the list of every
- * loaded skill, extension and theme - is left out, because turri shows its own. pi only
- * takes that from the `quietStartup` setting, and a setting would quiet every `pi` on the
- * machine, so it is answered for this run instead. `--verbose` still shows it.
+ * What differs is pi's own branding, because turri shows its own: its startup header - its
+ * version, key hints and the list of every loaded skill, extension and theme - its update notice
+ * and its tab title. pi only takes the header from the `quietStartup` setting, and a setting would
+ * quiet every `pi` on the machine, so it is answered for this run instead. `--verbose` still shows it.
  */
 const args = process.argv.slice(2);
 if (!args.includes("--verbose")) {
     SettingsManager.prototype.getQuietStartup = () => true;
 }
+// pi's "Update Available" notice is left out: the pi turri runs is its pinned dependency, which `pi update`
+// does not touch - it moves when turri does.
+process.env.PI_SKIP_VERSION_CHECK = "1";
+// The terminal's tab title: pi writes `π - <folder>` (its APP_TITLE, a constant), turri a jellyfish and its name.
+const setTitle = ProcessTerminal.prototype.setTitle;
+ProcessTerminal.prototype.setTitle = function (title) {
+    setTitle.call(this, title.replace(/^π(?= |$)/, "🪼 turri"));
+};
 // pi's own keys stand: a new line is shift+enter or ctrl+j. turri's side panel is on ctrl+h (job-panel.ts PANEL_KEY).
 // What pi's CLI does before main: the process title, pi's environment markers, the HTTP
 // dispatcher. Not exported, so loaded from the file - beside pi's entry point, wherever npm put it.

package/dist/regenerate-cli.js

@@ -1,5 +1,6 @@
 import { CONFIG_FILE, readProjectConfig } from "./config.js";
-import { headlessOptions, parseArgs, runLoop } from "./loop-cli.js";
+import { parseArgs } from "./cli-options.js";
+import { headlessOptions, runLoop } from "./loop-cli.js";
 const USAGE = `usage: turri regenerate [file.plain] [frid ...] [options]
 
 Regenerates the module's code from its spec as it is now, and everything it requires, bottom first, as

package/dist/run-report.js

@@ -1,7 +1,6 @@
-import { spawnSync } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, relative, resolve } from "node:path";
-import { PACKAGE_ROOT } from "./environment.js";
+import { turriIdentity } from "./environment.js";
 import { onModelEvent } from "./regenerate/activity.js";
 /**
  * A headless run's report: one JSON file, `turri regenerate --report <file>`, saying what the run did - how it ended,
@@ -57,25 +56,6 @@ function sumTotals(a, b) {
 function rounded(totals) {
     return { ...totals, cost_usd: Math.round(totals.cost_usd * 1e6) / 1e6, model_seconds: Math.round(totals.model_seconds * 10) / 10 };
 }
-/** turri's version, and the commit when it runs from a clone. */
-function turriIdentity() {
-    let version = null;
-    try {
-        version = JSON.parse(readFileSync(join(PACKAGE_ROOT, "package.json"), "utf8")).version ?? null;
-    }
-    catch {
-        /* no package.json: left out */
-    }
-    if (!existsSync(join(PACKAGE_ROOT, ".git")))
-        return { version, git_commit: null, git_dirty: null };
-    const commit = spawnSync("git", ["-C", PACKAGE_ROOT, "rev-parse", "HEAD"], { encoding: "utf8" });
-    const status = spawnSync("git", ["-C", PACKAGE_ROOT, "status", "--porcelain", "--untracked-files=no"], { encoding: "utf8" });
-    return {
-        version,
-        git_commit: commit.status === 0 ? commit.stdout.trim() : null,
-        git_dirty: status.status === 0 ? status.stdout.trim() !== "" : null,
-    };
-}
 const pulseKind = (job) => (job.kind === "regenerate" ? "code" : job.kind);
 const firstLines = (text) => {
     const trimmed = text?.trim();

package/dist/setup.js

@@ -6,6 +6,7 @@ import { ModelRegistry, ModelRuntime } from "@earendil-works/pi-coding-agent";
 import { globalExtensionFile, MIN_NODE, nodeVersionOk, PACKAGE_ROOT, turriOnPath } from "./environment.js";
 import { sandboxAvailable } from "./regenerate/os-sandbox.js";
 import { findTestScripts } from "./regenerate/test-scripts.js";
+import { configKeyOptions, parseArgs } from "./cli-options.js";
 import { hasProjectConfig, readProjectConfig, stackOf } from "./config.js";
 import { checkModels, modelsInUse, piModelAccess } from "./model-check.js";
 import { brand } from "./brand.js";
@@ -151,7 +152,7 @@ function checkGlobal() {
 export async function checkProjectModels(project, access) {
     const used = modelsInUse(readProjectConfig(project, stackOf(project)));
     if (used.length === 0) {
-        return [{ level: "missing", name: "Models", detail: "config.turri.yaml names none", fix: "turri init-config writes the two models" }];
+        return [{ level: "missing", name: "Models", detail: "config.turri.yaml names none", fix: "turri init-config writes the two models - or name them here: --harness-model, --coding-model" }];
     }
     let verdicts;
     try {
@@ -167,16 +168,17 @@ export async function checkProjectModels(project, access) {
             : { level: "missing", name, detail: verdict.spec, more: [verdict.problem], fix: verdict.fix };
     });
 }
+/** `modelsGiven`: models named on the command line - checked wherever doctor runs, a project or not. */
 async function allChecks(options = {}) {
     const checks = [checkNode(), checkShell(), checkGit(), checkSandbox(), await checkProvider(), checkPath(), ...checkGlobal()];
     // In a project: what it needs of this machine, and whether its models answer.
     const project = process.cwd();
-    if (hasProjectConfig(project) || existsSync(join(project, "plain_modules"))) {
+    const inProject = hasProjectConfig(project) || existsSync(join(project, "plain_modules"));
+    if (inProject)
         checks.push(...checkProject(project));
-        if (options.models !== false && hasProjectConfig(project)) {
-            console.log(brand.muted("Asking each model the config names for a word..."));
-            checks.push(...(await checkProjectModels(project)));
-        }
+    if (options.models !== false && (hasProjectConfig(project) || options.modelsGiven === true)) {
+        console.log(brand.muted("Asking each model the config names for a word..."));
+        checks.push(...(await checkProjectModels(project)));
     }
     return checks;
 }
@@ -235,21 +237,27 @@ function removeGlobalExtension() {
     rmSync(file, { force: true });
     console.log(`  removed ${file}`);
 }
+const USAGE = [
+    "usage: turri doctor [--harness-model <m>] [--coding-model <m>] [--judge-model <m>] [--no-models] [--yes]",
+    "",
+    "Check everything turri needs - in a project, what its modules need of this machine too, and that",
+    "each model its config names answers with this machine's credentials (one short request a model;",
+    "--no-models skips it). The model options are read as the config's keys, as turri regenerate reads them:",
+    "a headless run's models can be checked before it starts, with no config.turri.yaml.",
+    "It changes nothing but this, asked first: a plain pi that an older turri made load turri too is put back to",
+    "plain pi. --yes answers yes.",
+].join("\n");
 export async function main(args) {
-    if (args.includes("--help") || args.includes("-h")) {
-        console.log("usage: turri doctor [--no-models] [--yes]\n\nCheck everything turri needs - in a project, what its modules need of this machine too, and that\n" +
-            "each model its config names answers with this machine's credentials (one short request a model;\n--no-models skips it).\n" +
-            "It changes nothing but this, asked first: a plain pi that an older turri made load turri too is put back to\n" +
-            "plain pi. --yes answers yes.");
-        return 0;
-    }
+    const { options } = parseArgs(args, ["--no-models", "--yes", "-y"], USAGE, ["--harness-model", "--judge-model"]);
+    configKeyOptions(options);
     console.log(brand.bold(brand.accent("Checking what turri needs.")));
     if (!nodeVersionOk())
         return report([checkNode()]);
-    const code = report(await allChecks({ models: !args.includes("--no-models") }));
+    const modelsGiven = ["harness-model", "model", "judge-model"].some((name) => options[name] !== undefined);
+    const code = report(await allChecks({ models: options["no-models"] === undefined, modelsGiven }));
     // turri and pi are kept apart: a plain pi does not start turri. An older turri's file that made it do so goes, asked.
     const global = globalExtensionFile();
-    if (global !== undefined && (await confirm(`\nA plain \`pi\` loads turri too, through ${global}. Remove it, so pi stays pi?`, true, args.includes("--yes") || args.includes("-y")))) {
+    if (global !== undefined && (await confirm(`\nA plain \`pi\` loads turri too, through ${global}. Remove it, so pi stays pi?`, true, options.yes !== undefined || args.includes("-y")))) {
         removeGlobalExtension();
     }
     return code;

package/dist/spec-diff-cli.js

@@ -2,7 +2,8 @@ import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { checkPlainFile } from "./plain/check.js";
 import { applySpecDiff, revertSpecDiff } from "./regenerate/regenerate.js";
-import { headlessOptions, parseArgs, runLoop } from "./loop-cli.js";
+import { parseArgs } from "./cli-options.js";
+import { headlessOptions, runLoop } from "./loop-cli.js";
 const USAGE = `usage: turri spec-diff <file.plain> <diff-file> [options]
 
 Applies a change to the specs, given as a git diff of the .plain files, and builds it: the headless

package/docs/development.md

@@ -18,6 +18,12 @@ which tests reach which mutant (`vitest.stryker.config.ts`, the suite without th
 mutant against those tests. `scripts/mutation.mjs` sets two things in Stryker's vitest runner the suite needs - forked
 workers, and a test-name filter that matches vitest 5's names - again after every `npm install`.
 
+The `mutation` workflow (`.github/workflows/mutation.yml`) runs it on GitHub, started by hand: Actions, mutation, Run
+workflow. It takes the parts to run, space-separated (empty for every part), each a job of its own side by side, on
+four cores (`TURRI_MUTATION_CONCURRENCY`; six here). Each part's `mutation.html` and `mutation.json` are uploaded as an
+artifact, `mutation-<part>`, and summed up on the run's page. Stryker's incremental file is cached from run to run, so
+a run tests again only the mutants whose code or tests changed; tick `fresh` to test every one again.
+
 Working on turri itself, `npm link` points the global `turri` at this clone, so edits
 take effect immediately. `npm run chat` starts pi with the extension loaded from `src/`.
 

package/docs/headless.md

@@ -14,7 +14,8 @@ Everything marked `✗` stops the run, so fix those first. Two more things matte
   a module's implementation reqs name that this machine lacks.
 - **The models.** In a project, `turri doctor` sends each model `config.turri.yaml` names one short request, as turri's
   agents will - so a key the provider refuses, a model pi does not know or an account without access to it shows now,
-  not an hour into the run.
+  not an hour into the run. Models the run is given on the command line are given to doctor the same way -
+  `--harness-model`, `--coding-model`, `--judge-model`, read as the config's keys - and are checked with the config's.
 - **Credentials that do not expire mid-run.** An API key in the environment
   (`ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, `GEMINI_API_KEY`, ...) or pi's saved login - whatever
   `doctor` shows as the model provider.
@@ -260,9 +261,16 @@ turri regenerate app.plain --harness-model amazon-bedrock/eu.anthropic.claude-op
 - **What it needs:** Node 22.19 or newer, `bash`, `git` (each module's history, and the spec diffs
   the work is planned from), `/bin/sh` with `kill` and `sleep`, a writable `HOME` (pi keeps
   `~/.pi/agent/auth.json` there, even with no login - or set `PI_CODING_AGENT_DIR`) and `TMPDIR`, and
-  the toolchains the project's testing scripts and implementation reqs name. `turri doctor --no-models`
-  in the project checks them; `--no-models` because a `config.yaml` written for another tool names no models, and
-  doctor would count that against it.
+  the toolchains the project's testing scripts and implementation reqs name. `turri doctor` in the project, given
+  the run's models, checks them all and that each model answers - at the start of the task's log, not when a pulse
+  fails:
+
+  ```bash
+  turri doctor --harness-model amazon-bedrock/eu.anthropic.claude-opus-5-5 \
+    --coding-model amazon-bedrock/eu.anthropic.claude-sonnet-5-5 --judge-model amazon-bedrock/eu.anthropic.claude-opus-5-5
+  ```
+
+  It exits 1 on anything marked `✗`.
 - **Without bubblewrap:** a container that cannot make user namespaces - no
   `--security-opt seccomp=unconfined` - has no OS sandbox. turri runs anyway, the command check and the
   audit holding alone under the agents' commands; `turri doctor` shows it as `!`, not `✗`. Installing

package/docs/installation.md

@@ -68,7 +68,7 @@ In a project - a folder with `config.turri.yaml` (or the old `config.yaml`) or `
 | --- | --- |
 | each module's toolchains | what its implementation reqs name - Python, Node, Java, Go, Rust, C/C++, Zig, ... - against this machine's PATH: the agents use this machine's toolchains and install none, so a missing one is yours to install |
 | the testing scripts | what in them this machine does not have: a program named by its whole path that is not here (a macOS-only `/usr/libexec/java_home` on Linux), a toolchain they run that is not on the PATH |
-| the models | each model `config.turri.yaml` names - `harness-model`, `coding-model`, `judge-model`, every role under `models:` - sent one short request through pi, with the credentials turri's agents will use, for any provider pi supports. One that answers is ready; for one that does not, it says what the provider said and what to do: the credentials pi reads for that provider (`AWS_PROFILE` and `AWS_REGION` for Amazon Bedrock, `OPENAI_API_KEY`, `/login`, ...), model access in the Bedrock console, the closest model ids pi knows for one it does not. `--no-models` skips it |
+| the models | each model `config.turri.yaml` names - `harness-model`, `coding-model`, `judge-model`, every role under `models:` - sent one short request through pi, with the credentials turri's agents will use, for any provider pi supports. One that answers is ready; for one that does not, it says what the provider said and what to do: the credentials pi reads for that provider (`AWS_PROFILE` and `AWS_REGION` for Amazon Bedrock, `OPENAI_API_KEY`, `/login`, ...), model access in the Bedrock console, the closest model ids pi knows for one it does not. `--harness-model`, `--coding-model` (`--model`) and `--judge-model` name models as the config's keys, as `turri regenerate` reads them - checked in a project or not. `--no-models` skips it |
 
 Removing that file is the one thing `doctor` changes, and it asks first; `turri doctor --yes` says yes. Run without a
 terminal - piped, or in CI - it asks nothing and changes nothing. Run it again whenever something breaks;

package/docs/using.md

@@ -13,8 +13,10 @@ banner - the jellyfish it is named after, swimming until the conversation fills
 terminal that shows images (Kitty, Ghostty, WezTerm, Warp, iTerm2), and drawn in text in any other, tmux
 included - swimming a stroke a loop, its tentacles following its bell, frames `scripts/jellyfish-frames.mjs`
 writes -
-where commands will run, the rules and skills loaded - rather than pi's startup header
-and resource list; `turri --verbose` shows those too. Talk to it: ask it to start a
+turri's version (and, run from a clone, the commit it is on, and whether the clone has changes), where commands
+will run, the rules and skills loaded - rather than pi's startup header and resource list; `turri --verbose` shows
+those too. pi's "Update Available" notice is left out - turri's pi is a pinned dependency `pi update` never
+touches - and the terminal's tab reads `🪼 turri - <folder>`, not pi's `π`. Talk to it: ask it to start a
 project, add a feature, render a module, fix a spec. It decides which skill or tool applies - but
 not *how* a skill runs: `cultivate` hands the work to the gated runner, which owns the steps, the
 gates and the judges (see [skills and gates](skills-and-gates.md)).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turri-dev/cli",
-  "version": "0.1.3-next.17f0f7f",
+  "version": "0.1.3-next.26f08c5",
   "license": "MIT",
   "type": "module",
   "repository": {