@turri-dev/cli 0.1.9 → 0.1.10-next.2abf2db

package/dist/model-check.d.ts

@@ -34,6 +34,29 @@ export interface ModelAccess {
     /** One short request: the error the provider gave, or nothing when it answered. */
     ask(model: unknown): Promise<string | undefined>;
 }
+/** A model in pi's catalogue: what turri chooses among, and checks a model it is given against. */
+export interface CatalogueModel {
+    provider: string;
+    id: string;
+    name: string;
+    /** chat for a model turri's agents can talk to; pi's image and classifier models are in the catalogue too. */
+    type: string;
+    reasoning: boolean;
+    /** Dollars a million tokens. */
+    cost: {
+        input: number;
+        output: number;
+    };
+}
+/** pi's model catalogue, as turri's agents have it - its built-in models and models.json's. */
+export interface ModelCatalogue {
+    /** A provider's models, every type - none for a provider pi does not know. */
+    models(provider: string): CatalogueModel[];
+}
+/** pi's catalogue, read once: no request, no model asked. */
+export declare function piModelCatalogue(): Promise<ModelCatalogue>;
+/** The ids of `known` closest to `id`, at most three: the most of its words in common - claude, haiku - then the most of its characters in order. */
+export declare function closestModels(id: string, known: string[]): string[];
 /** pi's own model runtime, with pi's credentials - auth.json, models.json and the environment - as turri's agents have them. */
 export declare function piModelAccess(): Promise<ModelAccess>;
 /** What to do about a provider's error, from what it says. */

package/dist/model-check.js

@@ -22,10 +22,47 @@ export function modelsInUse(config) {
     add(config.models?.default?.model, "models.default");
     return [...used].map(([spec, usedBy]) => ({ spec, usedBy: [...new Set(usedBy)] }));
 }
+/** pi's own model runtime: its catalogue with models.json's, and pi's credentials - auth.json and the environment. */
+async function piRuntime() {
+    const agentDir = getAgentDir();
+    return ModelRuntime.create({ authPath: join(agentDir, "auth.json"), modelsPath: join(agentDir, "models.json") });
+}
+/** pi's catalogue, read once: no request, no model asked. */
+export async function piModelCatalogue() {
+    const runtime = await piRuntime();
+    return {
+        models: (provider) => runtime.getAllModels(provider).map((model) => {
+            const entry = model;
+            return {
+                provider: model.provider,
+                id: model.id,
+                name: entry.name ?? model.id,
+                type: entry.type ?? "chat",
+                reasoning: entry.reasoning === true,
+                cost: { input: entry.cost?.input ?? 0, output: entry.cost?.output ?? 0 },
+            };
+        }),
+    };
+}
+/** The ids of `known` closest to `id`, at most three: the most of its words in common - claude, haiku - then the most of its characters in order. */
+export function closestModels(id, known) {
+    const words = id.toLowerCase().split(/[^a-z0-9]+/).filter((word) => word !== "");
+    const score = (other) => {
+        const theirs = other.toLowerCase().split(/[^a-z0-9]+/);
+        return words.filter((word) => theirs.includes(word)).length * 100 + commonPrefix(id.toLowerCase(), other.toLowerCase());
+    };
+    const scored = known.map((other) => ({ other, score: score(other) })).filter((entry) => entry.score >= 100);
+    // Only those sharing as many words as the best: claude-haiku-* for claude-haiku-9-9, not every claude.
+    const most = Math.max(0, ...scored.map((entry) => Math.floor(entry.score / 100)));
+    return scored
+        .filter((entry) => Math.floor(entry.score / 100) === most)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, 3)
+        .map((entry) => entry.other);
+}
 /** pi's own model runtime, with pi's credentials - auth.json, models.json and the environment - as turri's agents have them. */
 export async function piModelAccess() {
-    const agentDir = getAgentDir();
-    const runtime = await ModelRuntime.create({ authPath: join(agentDir, "auth.json"), modelsPath: join(agentDir, "models.json") });
+    const runtime = await piRuntime();
     const registry = new ModelRegistry(runtime);
     return {
         find: (provider, id) => registry.find(provider, id),
@@ -91,20 +128,7 @@ export async function checkModels(models, access) {
             const known = access.known(provider);
             if (known.length === 0)
                 return { ok: false, spec, usedBy, problem: `pi knows no provider ${provider}`, fix: "use a provider pi supports - https://pi.dev" };
-            // The closest first: the most of its words in common - claude, haiku - then the most of its characters in order.
-            const words = id.toLowerCase().split(/[^a-z0-9]+/).filter((word) => word !== "");
-            const score = (other) => {
-                const theirs = other.toLowerCase().split(/[^a-z0-9]+/);
-                return words.filter((word) => theirs.includes(word)).length * 100 + commonPrefix(id.toLowerCase(), other.toLowerCase());
-            };
-            const scored = known.map((other) => ({ other, score: score(other) })).filter((entry) => entry.score >= 100);
-            // Only those sharing as many words as the best: claude-haiku-* for claude-haiku-9-9, not every claude.
-            const most = Math.max(0, ...scored.map((entry) => Math.floor(entry.score / 100)));
-            const close = scored
-                .filter((entry) => Math.floor(entry.score / 100) === most)
-                .sort((a, b) => b.score - a.score)
-                .slice(0, 3)
-                .map((entry) => entry.other);
+            const close = closestModels(id, known);
             return { ok: false, spec, usedBy, problem: `pi knows no model ${id} at ${provider}`, fix: close.length > 0 ? `did you mean ${close.map((other) => `${provider}/${other}`).join(", ")}?` : `change it in config.turri.yaml to a model pi knows at ${provider}` };
         }
         const started = Date.now();

package/dist/regenerate/os-sandbox.d.ts

@@ -80,6 +80,8 @@ export declare function setSandboxForTests(wall: Wall | undefined): void;
  * and how to give it one.
  */
 export declare function sandboxAvailable(): Wall;
+/** Which wall would be up with `env`'s PATH - doctor's for a host whose engine runs with another PATH; tried each time. */
+export declare function sandboxWith(env: NodeJS.ProcessEnv): Wall;
 /** Whether `path` is one of the fence's roots or under one - for the tests and the audit. */
 export declare function underAny(path: string, roots: string[]): boolean;
 /** Where the agents' commands run, in one line for the person: which walls are up, or that only the shared ones are. */

package/dist/regenerate/os-sandbox.js

@@ -203,7 +203,11 @@ export function sandboxAvailable() {
     probed = probe();
     return probed;
 }
-function probe() {
+/** Which wall would be up with `env`'s PATH - doctor's for a host whose engine runs with another PATH; tried each time. */
+export function sandboxWith(env) {
+    return env === process.env ? sandboxAvailable() : probe(env);
+}
+function probe(env = process.env) {
     if (process.platform === "darwin") {
         if (!existsSync("/usr/bin/sandbox-exec"))
             return { kind: "none", why: "this macOS has no sandbox-exec (Seatbelt)" };
@@ -214,6 +218,7 @@ function probe() {
         const tryProc = (proc) => spawnSync("bwrap", ["--ro-bind", "/", "/", ...(proc === "mount" ? ["--proc", "/proc"] : ["--ro-bind", "/proc", "/proc"]), "--dev", "/dev", "--unshare-pid", "--", "true"], {
             encoding: "utf8",
             timeout: 10_000,
+            env,
         });
         const mounted = tryProc("mount");
         if (mounted.status === 0)

package/dist/regenerate/test-scripts.d.ts

@@ -208,8 +208,8 @@ export declare function runTiming(run: Pick<ScriptRun, "exitCode" | "timedOut" |
 export declare function missingToolchain(run: Pick<ScriptRun, "exitCode" | "output">): {
     command?: string;
 } | undefined;
-/** Where `command` is on this machine's PATH, or undefined when it is not there. */
-export declare function onThisMachine(command: string): string | undefined;
+/** Where `command` is on this machine's PATH - `env`'s, by default turri's own - or undefined when it is not there. */
+export declare function onThisMachine(command: string, env?: NodeJS.ProcessEnv): string | undefined;
 /** What a failed script run means, for the agent that has to fix it. */
 export declare function scriptFailure(run: ScriptRun, what: string): string;
 /** How many rounds running the same failure, taken the same way, is nothing changing. */

package/dist/regenerate/test-scripts.js

@@ -738,9 +738,9 @@ export function missingToolchain(run) {
     const command = last !== undefined ? named(last) : undefined;
     return command !== undefined ? { command } : undefined;
 }
-/** Where `command` is on this machine's PATH, or undefined when it is not there. */
-export function onThisMachine(command) {
-    for (const dir of (process.env.PATH ?? "").split(delimiter)) {
+/** Where `command` is on this machine's PATH - `env`'s, by default turri's own - or undefined when it is not there. */
+export function onThisMachine(command, env = process.env) {
+    for (const dir of (env.PATH ?? "").split(delimiter)) {
         if (dir === "")
             continue;
         const path = join(dir, command);

package/dist/setup.d.ts

@@ -8,8 +8,10 @@ import { type ModelAccess } from "./model-check.ts";
  * implementation reqs name and what its testing scripts run, and whether each model its config names answers with this
  * machine's credentials - one short request a model (model-check.ts). It changes one thing, asked first: a plain `pi`
  * that an older turri made load turri too is put back to plain pi.
+ *
+ * `doctor()` is the checks alone, for the CLI and for a host (src/host.ts): it prints nothing and asks nothing.
  */
-type Level = "ok" | "missing" | "limited" | "info";
+export type Level = "ok" | "missing" | "limited" | "info";
 export interface Check {
     level: Level;
     name: string;
@@ -39,5 +41,25 @@ export declare function checkProject(project: string, machine?: {
  * request. A model that answers is ready; one that does not says what the provider said, and what to do about it.
  */
 export declare function checkProjectModels(project: string, access?: ModelAccess): Promise<Check[]>;
+export interface DoctorOptions {
+    /** The project to check. Without it, only the machine. */
+    dir?: string;
+    /** Ask each model the project's config names for a word - a request a model, which costs money. Off by default. */
+    models?: boolean;
+    /** The environment whose PATH is looked in - bash, git, the sandbox, the toolchains, what the testing scripts run. */
+    env?: NodeJS.ProcessEnv;
+}
+/**
+ * Whether this machine - and, with `dir`, that project - is ready for turri, as checks. It prints nothing and asks
+ * nothing, so a host can show them in its own way; `turri doctor` prints the same.
+ */
+export declare function doctor(options?: DoctorOptions): Promise<Check[]>;
+/** What the checks add up to: whether turri can run here, and a line saying so - with its marks, uncoloured. */
+export declare function verdictOf(checks: Check[]): {
+    ready: boolean;
+    limited: boolean;
+    text: string;
+};
+/** The checks as plain text, a line each and what to do under it, and the verdict - for a reader that is not a terminal. */
+export declare function describeChecks(checks: Check[]): string;
 export declare function main(args: string[]): Promise<number>;
-export {};

package/dist/setup.js

@@ -4,8 +4,8 @@ import { join, relative } from "node:path";
 import { createInterface } from "node:readline/promises";
 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 { sandboxAvailable, sandboxWith } from "./regenerate/os-sandbox.js";
+import { findTestScripts, onThisMachine } 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";
@@ -168,20 +168,52 @@ 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()];
+/** Whether doctor asks the models: asked to, and a config that names them - or models named on the command line. */
+function asksModels(options) {
+    return options.models === true && options.dir !== undefined && (hasProjectConfig(options.dir) || options.modelsGiven === true);
+}
+/** Whether `command` runs with `env` - its PATH looked in, as the agents' shells and the testing scripts would. */
+function runs(command, env) {
+    return spawnSync(command, ["--version"], { stdio: "ignore", windowsHide: true, env }).status === 0;
+}
+/**
+ * Whether this machine - and, with `dir`, that project - is ready for turri, as checks. It prints nothing and asks
+ * nothing, so a host can show them in its own way; `turri doctor` prints the same.
+ */
+export async function doctor(options = {}) {
+    return allChecks({ ...options, cli: false, modelsGiven: false });
+}
+async function allChecks(options) {
+    const env = options.env ?? process.env;
+    const checks = [checkNode(), checkShell(runs("bash", env)), checkGit(runs("git", env)), checkSandbox(sandboxWith(env)), await checkProvider()];
+    if (options.cli === true)
+        checks.push(checkPath(), ...checkGlobal());
     // In a project: what it needs of this machine, and whether its models answer.
-    const project = process.cwd();
-    const inProject = hasProjectConfig(project) || existsSync(join(project, "plain_modules"));
-    if (inProject)
-        checks.push(...checkProject(project));
-    if (options.models !== false && (hasProjectConfig(project) || options.modelsGiven === true)) {
-        console.log(brand.muted("Asking each model the config names for a word..."));
+    const project = options.dir;
+    if (project === undefined)
+        return checks;
+    if (hasProjectConfig(project) || existsSync(join(project, "plain_modules")))
+        checks.push(...checkProject(project, { has: (command) => onThisMachine(command, env) !== undefined }));
+    if (asksModels(options))
         checks.push(...(await checkProjectModels(project)));
-    }
     return checks;
 }
+/** What the checks add up to: whether turri can run here, and a line saying so - with its marks, uncoloured. */
+export function verdictOf(checks) {
+    const missing = checks.filter((check) => check.level === "missing").length;
+    if (missing > 0)
+        return { ready: false, limited: false, text: `Not ready: ${missing} thing${missing === 1 ? "" : "s"} to fix (✗ above).` };
+    return checks.some((check) => check.level === "limited") ? { ready: true, limited: true, text: "Ready, with limits (! above)." } : { ready: true, limited: false, text: "Ready." };
+}
+/** The checks as plain text, a line each and what to do under it, and the verdict - for a reader that is not a terminal. */
+export function describeChecks(checks) {
+    const lines = checks.flatMap((check) => [
+        `${MARK[check.level]} ${check.name}: ${check.detail}`,
+        ...(check.more ?? []).map((line) => `    ${line}`),
+        ...(check.fix && check.level !== "ok" ? [`    → ${check.fix}`] : []),
+    ]);
+    return `${lines.join("\n")}\n\n${verdictOf(checks).text}`;
+}
 function report(checks) {
     const paint = { ok: brand.success, missing: brand.error, limited: brand.warning, info: brand.muted };
     // The names in one column, however long the longest - `judge-model, models.judge` - is.
@@ -196,15 +228,10 @@ function report(checks) {
         if (check.fix && check.level !== "ok")
             console.log(`${under}${brand.accent(`→ ${check.fix}`)}`);
     }
-    const missing = checks.filter((check) => check.level === "missing");
-    const limited = checks.filter((check) => check.level === "limited");
+    const verdict = verdictOf(checks);
     console.log("");
-    if (missing.length > 0) {
-        console.log(brand.error(`Not ready: ${missing.length} thing${missing.length === 1 ? "" : "s"} to fix (✗ above).`));
-        return 1;
-    }
-    console.log(limited.length > 0 ? brand.warning("Ready, with limits (! above).") : brand.success("Ready."));
-    return 0;
+    console.log((verdict.ready ? (verdict.limited ? brand.warning : brand.success) : brand.error)(verdict.text));
+    return verdict.ready ? 0 : 1;
 }
 /**
  * Ask a yes/no question. With --yes, yes. With no terminal to ask on, no - nothing is changed
@@ -254,7 +281,10 @@ export async function main(args) {
     if (!nodeVersionOk())
         return report([checkNode()]);
     const modelsGiven = ["harness-model", "model", "judge-model"].some((name) => options[name] !== undefined);
-    const code = report(await allChecks({ models: options["no-models"] === undefined, modelsGiven }));
+    const checking = { dir: process.cwd(), models: options["no-models"] === undefined, cli: true, modelsGiven };
+    if (asksModels(checking))
+        console.log(brand.muted("Asking each model the config names for a word..."));
+    const code = report(await allChecks(checking));
     // 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, options.yes !== undefined || args.includes("-y")))) {

package/docs/config.md

@@ -13,7 +13,9 @@ A project says how its specs are built in `config.turri.yaml`, at the project ro
 | `amazon-bedrock`, OpenAI | `amazon-bedrock/<region>.openai.gpt-6-astra` | `amazon-bedrock/<region>.openai.gpt-6-luna` | `AWS_PROFILE` or `AWS_BEARER_TOKEN_BEDROCK`, and `AWS_REGION` |
 | `other` | `anthropic/claude-opus-5-5` | `google/gemini-3.1-flash-lite` | `ANTHROPIC_API_KEY`, `GEMINI_API_KEY` |
 
-Amazon Bedrock asks two more things - whose models, Anthropic's or OpenAI's (`--maker`), and the region of the inference profile they run in (`--region`): `global`, `us`, `eu`, `jp` or `au` for Anthropic's, `global` or `us` for OpenAI's. It says which `AWS_REGION` to set for it - pi calls Bedrock in `us-east-1` when none is. A `config.turri.yaml` already there keeps everything but its two models, which it sets; `--force` writes the whole file again.
+Amazon Bedrock asks three more things, from pi's catalogue: whose models (`--maker`) - any maker pi has there, Anthropic, OpenAI, xAI, Meta, Mistral, Qwen, DeepSeek, Amazon, Moonshot, Z.ai, ... - the geography of the inference profile they run in (`--region`) - `global`, `us`, `eu`, `jp`, `au`, `apac`, `in`, `ca` or `us-gov`, as the maker's models are served, or `in-region`, a model served in the AWS region it is called in - and which two. The pair offered is turri's own where it has one - the table's, for Anthropic's and OpenAI's in the geographies they are served in - and otherwise the catalogue's: the strongest model that reasons to talk to, by price, and the cheapest costing at least a fifth of it to code, ties to the newest. Enter takes it; `c` chooses each from the maker's models there. It says which `AWS_REGION` to set for the geography: pi calls Bedrock in `AWS_REGION`, else the profile's region, else `us-east-1` - so every geography but `global`, `us` and `in-region` needs it set (`eu-central-1` for `eu`, `ap-northeast-1` for `jp`, `ap-southeast-2` for `au`, `ap-southeast-1` for `apac`, `ap-south-1` for `in`, `ca-central-1` for `ca`, `us-gov-west-1` for `us-gov`). A `config.turri.yaml` already there keeps everything but its two models, which it sets; `--force` writes the whole file again.
+
+`--harness-model` and `--coding-model` name the two models instead, for any vendor: provider/model-id without a thinking level - `turri init-config --harness-model amazon-bedrock/global.xai.grok-4.7 --coding-model amazon-bedrock/global.xai.grok-4.6`. They are written wherever the vendor's own would be - the two models with their thinking, the commented-out `judge-model` and `models:` examples - and the vendor, maker and geography are read from them. `--judge-model` names the strong one the judging examples use, the harness model unless given. Each is checked against pi's catalogue first: one it does not have, or that is not a chat model, is named, with the closest it has, and nothing is written.
 
 Each is written with how hard it thinks - `harness-model: openai/gpt-6-astra:medium`, `coding-model: openai/gpt-6-luna:low` - so the file shows it. The reviews and judges run on the coding model but think medium (see [models per role](#models-per-role)).
 

package/docs/development.md

@@ -32,7 +32,7 @@ The workflow signs in to npm with npm's trusted publishing (OIDC), not a token:
 |---|---|
 | `bin/turri.mjs` | the launcher: checks the Node version, then loads `src/cli.ts` |
 | `src/cli.ts` | the `turri` command and its subcommands |
-| `src/setup.ts`, `src/environment.ts`, `src/stack.ts` | `turri doctor`, and what it checks - this machine, and in a project what its modules need of it |
+| `src/setup.ts`, `src/doctor-tool.ts`, `src/environment.ts`, `src/stack.ts` | `turri doctor` and the chat's `doctor` tool, and what they check - this machine, and in a project what its modules need of it |
 | `src/extension.ts` | the pi extension: every tool and command the conversation has |
 | `src/skill.ts` | parses `SKILL.md` into steps and gates |
 | `src/graph.ts` | compiles a skill into a LangGraph `StateGraph`: step -> gate -> route |

package/docs/hosting.md

@@ -12,16 +12,57 @@
 | `pi` | pi itself, as turri's extension is built against it. Make the session with this one - `pi.createAgentSession`, `pi.DefaultResourceLoader` - not another copy. |
 | `readProjectConfig`, `projectModels`, `modelSpec`, `configForSpec`, `hasProjectConfig`, `stacksOf` | the project's settings, as [config.turri.yaml](config.md) has them. |
 | `debugMode` | whether turri keeps, in a project, what it writes only for debugging it - `debug:`, or `TURRI_DEBUG` over it (see [debug mode](config.md#debug-mode)). |
-| `initConfig(dir, { vendor, bedrock, force })`, `VENDORS`, `BEDROCK_REGIONS`, `BEDROCK_DEFAULT`, `bedrockModels` | a project's first config.turri.yaml, as `turri init-config` writes it: the host asks which vendor's models - `VENDORS` has each one's label and its two models, `BEDROCK_REGIONS` where Bedrock serves each maker's - and `initConfig` writes it, saying what it did. One already there keeps everything but its two models. |
+| `initConfig(dir, { vendor, bedrock, models, force, catalogue })`, `VENDORS`, `BEDROCK_REGIONS`, `BEDROCK_DEFAULT` | a project's first config.turri.yaml, as `turri init-config` writes it - async, it may read pi's catalogue - see [a project's first config](#a-projects-first-config). |
+| `piModelCatalogue`, `bedrockMakers`, `bedrockModelsIn`, `bedrockDefaultModels`, `bedrockModels`, `bedrockPlaceOf`, `makerLabel`, `BEDROCK_GEOGRAPHIES`, `BEDROCK_IN_REGION` | pi's model catalogue, read without a request, and Bedrock in it: whose models it serves, in which geographies, which two turri offers for a maker and geography. |
+| `bedrockAwsRegion`, `bedrockNeedsAwsRegion` | the AWS region to set `AWS_REGION` to for a Bedrock geography, and whether it has to be set. |
 | `checkPlainFile`, `plainFileParser`, `resolveTemplateDirs`, `iterateFunctionalSpecs`, `FUNCTIONAL_REQUIREMENTS` | a spec checked and parsed, its functional specs one by one - as `turri validate` reads it. |
 | `highlightLines`, `roleOf` | a spec's lines coloured by turri's own \*\*\*plain grammar. |
 | `functionalityCompletion`, `createWorkLoop`, `createJobRegistry`, `promptOf`, `describeModules` | how far each functional spec is built, and - on a loop of the host's own with `dryRun` - the work a spec change would plan, as `turri glimpse` does. |
 | `onModelEvent`, `describeTurnIncident` | a provider failing and waited out, a turn turri ended itself. |
 | `onLedgerEvent`, `readLedger`, `ledgerDir`, `runViews`, `pulseView`, `describePulseView`, `describeRuns`, `ledgerProjects`, `earlierPulses`, `asJob` | what turri did, as facts - the [ledger](using.md#the-ledger): each event heard as it is recorded, and every run and pulse read back, earlier sessions' too - see [the ledger in a host](#the-ledger-in-a-host). |
+| `doctor({ dir, models, env })`, `Check`, `Level` | whether the machine - and, with `dir`, that project - is ready for turri, as `turri doctor` checks it: a list of checks to show in the host's own way - see [doctor in a host](#doctor-in-a-host). |
 | `sweepOrphanedGroups` | stop what a turri killed outright left running, before anything starts. |
 
 It is turri's own code, as the terminal runs it: a 0.x release may change any of it.
 
+## A project's first config
+
+```js
+import { initConfig, piModelCatalogue, bedrockMakers, bedrockModelsIn, bedrockDefaultModels } from "@turri-dev/cli/host";
+
+const catalogue = await piModelCatalogue();
+bedrockMakers(catalogue);                                     // [{ maker: "xai", label: "xAI", regions: ["global", "us", "in-region"] }, ...]
+bedrockModelsIn(catalogue, { maker: "xai", region: "global" }); // the maker's chat models there, with their prices
+const offered = bedrockDefaultModels(catalogue, { maker: "xai", region: "global" });
+const { written, message } = await initConfig(project, { models: { harness, coding }, catalogue });
+```
+
+`initConfig` writes config.turri.yaml as `turri init-config` does, and returns what it did - `written`, and `message`, the lines the terminal prints. It is async.
+
+- `vendor` - `anthropic`, `openai`, `google`, `amazon-bedrock` or `other` - fills in that vendor's own two models (`VENDORS` has each one's label and models).
+- `bedrock: { maker?, region }`, on Amazon Bedrock, says whose and where. turri's own pair is written where it has one - Anthropic's and OpenAI's in `BEDROCK_REGIONS` - and otherwise the pair `bedrockDefaultModels` offers from pi's catalogue: any maker and geography it has.
+- `models: { harness, coding, strong? }` writes those two instead - any pair pi's catalogue has as chat models, full specs without a thinking level (`amazon-bedrock/global.xai.grok-4.7`). They go wherever the vendor's own would: the two models with the thinking turri writes, the commented-out `judge-model` and `models:` examples, `strong` - the judging examples' model - being `harness` unless given. The vendor, the Bedrock maker and the geography are read from them, so neither `vendor` nor `bedrock` is needed. A model the catalogue does not have, or that is not a chat model, writes nothing: `written` is false and `message` says which, with the closest the catalogue has.
+- `catalogue`, the one the host already read, saves reading it again.
+
+The message says whose models were written - "with xAI's models on Amazon Bedrock (global)" - and how to sign in, with the `AWS_REGION` for the geography: `bedrockAwsRegion(geography)` is that region, and `bedrockNeedsAwsRegion(geography)` whether it has to be set - every geography but `global`, `us` and `in-region`, pi calling Bedrock in `us-east-1` unless `AWS_REGION` or the profile names another.
+
+## doctor in a host
+
+```js
+import { doctor } from "@turri-dev/cli/host";
+
+const checks = await doctor({ dir: project, env: engineEnv });
+// [{ level: "ok" | "missing" | "limited" | "info", name, detail, more?, fix? }, ...]
+```
+
+`doctor` runs the checks `turri doctor` prints, and returns them: Node, bash, git, which OS sandbox is up under the agents' commands, and whether any model provider has credentials. With `dir`, the project too: whether this machine has the toolchains its modules' implementation reqs name, and what in its testing scripts it does not have. It prints nothing and asks nothing; each check's `fix` is plain text, to show as it is. A check `missing` means turri cannot run until it is fixed, `limited` that it runs with less.
+
+- `dir` is the project to check - not the process's working folder, which in a host is not the project. Without it, only the machine is checked.
+- `models: true` asks each model the project's config.turri.yaml names for a word, with this machine's credentials - a request a model, which costs money. It is off by default: run it when the person asks.
+- `env` is the environment whose PATH is looked in - for bash, git, the sandbox, the toolchains and what the testing scripts run - by default the process's own. A Mac app opened from Finder runs with `/usr/bin:/bin:/usr/sbin:/sbin`, not the person's shell's PATH: pass the environment the host's engine runs turri with, so doctor checks the PATH turri will actually have.
+
+What matters only in a terminal - `turri` on the PATH, a plain `pi` an older turri made load turri - is left to `turri doctor`.
+
 ## The conversation in a host
 
 ```js

package/docs/installation.md

@@ -58,7 +58,7 @@ In a project - a folder with `config.turri.yaml` (or the old `config.yaml`) or `
 | 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. `--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; `turri doctor --no-models` leaves out the models' requests.
+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; `turri doctor --no-models` leaves out the models' requests. In the chat, ask for a self check: the `doctor` tool runs the same checks, the models only when you ask. A host - a desktop app - runs the same checks through `doctor` and shows them itself (see [doctor in a host](hosting.md#doctor-in-a-host)).
 
 The chat is told every turn which wall is up and what the project's modules need of this machine that it lacks. What they need is worked out from every spec of the project - seconds, on a project of long requires chains - so it is worked out once the chat is up and again after a turn in which a spec changed, never while your message waits: a turn is told what was known last.
 

package/docs/using.md

@@ -38,6 +38,7 @@ While a skill runs, a line above the input shows its phases, every one by name -
 | `halt` | halt a pulse, a module's planned pulses, or what `activate` started |
 | `diagnose` | why a pulse did not land, from its transcript: how it ended, the stages that went wrong, the last failing test run, the last review, the tool calls that failed - and what the [ledger](#the-ledger) recorded of it |
 | `ledger` | what turri did, from the [ledger](#the-ledger), this session's and every earlier one's: a pulse as facts, by its id - its rounds, test runs, verdicts, healers, refusals and commits; events of some kinds counted and listed, for a module or since a time - `healer.failed`, or `healer` for the group; or the last runs, a line a pulse |
+| `doctor` | turri's self check, as `turri doctor` runs it: Node, bash, git, the OS sandbox, a model provider, and the project's toolchains and testing scripts - against the PATH turri's pulses run with, not the agent's shell's. The project's models are asked for a word only when you ask (a request a model); it changes nothing |
 | `lineage` | a module's lineage: what each regeneration and conformance run changed in it, and what it was regenerated from |
 | `cultivate` | run a gated skill, its steps and review gates enforced |
 | `release`, `activate` | try what is regenerated: release it to `dist/<module>` and activate it on this machine, installing what it needs - see [deploy](deploy.md) |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turri-dev/cli",
-  "version": "0.1.9",
+  "version": "0.1.10-next.2abf2db",
   "license": "MIT",
   "type": "module",
   "repository": {