projectinator 0.2.0 → 0.3.1

package/README.md

@@ -6,8 +6,8 @@
 
 [![npm](https://img.shields.io/npm/v/projectinator.svg?color=e0a72d&label=npm)](https://www.npmjs.com/package/projectinator)
 ![license: MIT](https://img.shields.io/badge/license-MIT-blue.svg)
-![node](https://img.shields.io/badge/node-%E2%89%A520-brightgreen.svg)
-![tests: 157 passing](https://img.shields.io/badge/tests-157%20passing-brightgreen.svg)
+![node](https://img.shields.io/badge/node-%E2%89%A522.19-brightgreen.svg)
+![tests: 187 passing](https://img.shields.io/badge/tests-187%20passing-brightgreen.svg)
 ![TypeScript](https://img.shields.io/badge/TypeScript-strict-3178c6.svg)
 ![built on Pi](https://img.shields.io/badge/built%20on-Pi%20agent%20harness-e0a72d.svg)
 
@@ -22,7 +22,7 @@ watch it happen from a terminal cockpit: a live board, budget bar, and a standup
 
 Built on the [Pi](https://pi.dev) agent harness (Node/TypeScript). Bring your own API key.
 
-**Install & run** (Node ≥ 20):
+**Install & run** (Node ≥ 22.19):
 
 ```bash
 npx projectinator                 # run without installing
@@ -30,6 +30,8 @@ npx projectinator                 # run without installing
 npm install -g projectinator      # then just: projectinator
 ```
 
+`projectinator --help` / `--version` work without opening the app; `projectinator doctor` checks your setup.
+
 > **It's a CLI, not a library.** `npm install projectinator` (without `-g`) only drops it into a
 > project's `node_modules` — it won't create a runnable command. Use `npx projectinator` or
 > `npm install -g projectinator`. (If `-g` installs but the command isn't found, npm's global
@@ -120,16 +122,32 @@ Real, unedited output from a full build, kept in [`examples/`](examples/):
 
 ## CLI (same engine, for scripting/CI)
 
+Everything below uses the same workspace as the cockpit, so headless builds show up in the app.
+
 ```bash
-npm start                                         # the cockpit (the normal way to use it)
-npm run build -- --live --mini                    # cheap end-to-end proof (~$0.10)
-npm run build -- --live --lock anthropic "idea"   # full pipeline on one provider
-npm run build -- --live --mini --resume           # resume a halted/finished build (skips done tasks)
-npm run build -- --live --mini --task-cap 0.5 --task-timeout 5   # per-task limits (USD / minutes)
+projectinator doctor                                  # Node, keys, Chromium, Pi catalog, git
+projectinator build "a tip calculator" --dry-run      # plan + estimate only (one PM call)
+projectinator build "a tip calculator" --yes          # build without the confirmation prompt
+projectinator build "…" --json --budget 2 --provider anthropic   # NDJSON events; cap; lock provider
+projectinator build "…" --task-cap 0.5 --task-timeout 5           # per-task limits (USD / minutes)
+projectinator projects                                # past builds, status, cost
+projectinator models                                  # the roster as it will run, with prices
+```
+
+Exit codes: `0` ok · `1` environment problem · `2` bad usage · `3` build halted (resume it in the app).
+
+<details>
+<summary>Developer scripts (from a clone)</summary>
+
+```bash
+npm start                                         # the cockpit
+npm run build -- --live --mini                    # fixed 4-task build, cheap end-to-end proof (~$0.10)
+npm run build -- --live --mini --resume           # resume a halted run
 npm run bakeoff -- --capability design "Design a pricing page"   # model bake-off
-npm test                                          # 157 tests
+npm test                                          # 187 tests
 npm run typecheck
 ```
+</details>
 
 ## Configuration & data
 

package/bin/projectinator.mjs

@@ -2,14 +2,52 @@
 // Launcher for `projectinator` / `npx github:smanookian/projectinator`.
 // Runs the Ink TUI (TypeScript) through tsx — no build step, no compiled dist.
 import { spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
 
 const root = dirname(dirname(fileURLToPath(import.meta.url)));
 const entry = join(root, "src", "tui.tsx");
 
+const args = process.argv.slice(2);
+const { version } = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+
+if (args.includes("--version") || args.includes("-v")) {
+  console.log(version);
+  process.exit(0);
+}
+if (args.includes("--help") || args.includes("-h") || args[0] === "help") {
+  console.log(`projectinator ${version} — your AI build team in the terminal
+
+Usage
+  projectinator                        open the cockpit (TUI)
+  projectinator doctor                 check Node, API keys, Chromium, Pi catalog, git
+  projectinator build "<idea>" [...]   plan + build headless (--dry-run, --yes, --json,
+                                       --budget, --provider, --concurrency, --task-cap, --task-timeout)
+  projectinator projects               list past builds with status and cost
+  projectinator models                 the roster as it will run, with prices
+  projectinator --version | --help
+
+Setup
+  Inside the app: Settings → API keys (Anthropic, OpenAI, Gemini, OpenRouter).
+  Keys live in ~/.projectinator/config.json (chmod 0600).
+  Optional: npx playwright install chromium  → lets the tester run the app headless.
+
+Exit codes: 0 ok · 1 environment problem · 2 bad usage · 3 build halted
+Docs: https://github.com/smanookian/projectinator#readme`);
+  process.exit(0);
+}
+
+const COMMANDS = new Set(["doctor", "build", "projects", "models"]);
+if (args.length && !COMMANDS.has(args[0])) {
+  console.error(`projectinator: unknown ${args[0].startsWith("-") ? "option" : "command"} "${args[0]}". Try --help.`);
+  process.exit(2);
+}
+
 // `node --import tsx <entry>` registers tsx's loader, then runs the TS entry.
-const res = spawnSync(process.execPath, ["--import", "tsx", entry], {
+// No command → the TUI; a command → the headless CLI with the remaining args.
+const target = args.length ? join(root, "src", "cli.ts") : entry;
+const res = spawnSync(process.execPath, ["--import", "tsx", target, ...args], {
   stdio: "inherit",
   cwd: root,
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "projectinator",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Your AI build team in the terminal — hand it an app idea, a PM model plans a Scrum backlog, and the best model per role designs, codes, and tests it into working files. Bring your own API key.",
   "type": "module",
   "private": false,
@@ -36,7 +36,7 @@
     "src"
   ],
   "engines": {
-    "node": ">=20"
+    "node": ">=22.19.0"
   },
   "scripts": {
     "start": "tsx src/tui.tsx",
@@ -61,13 +61,13 @@
     "vitest": "^2.1.8"
   },
   "dependencies": {
-    "@earendil-works/pi-coding-agent": "0.80.7",
+    "@earendil-works/pi-coding-agent": "0.85.1",
     "@inkjs/ui": "2.0.0",
     "ink": "7.1.0",
     "ink-spinner": "5.0.0",
     "playwright": "1.61.1",
     "react": "19.2.7",
     "tsx": "4.23.1",
-    "typebox": "1.1.38"
+    "typebox": "1.3.7"
   }
 }

package/src/bakeoff.ts

@@ -7,15 +7,13 @@
 // scoring) is a later step.
 
 import {
-  AuthStorage,
-  ModelRegistry,
   createAgentSession,
   defineTool,
   type AgentSession,
 } from "@earendil-works/pi-coding-agent";
 import { Type, type Static } from "typebox";
 import type { Capability, Difficulty, Provider, Task } from "./types.js";
-import { resolvePiModel } from "./executor.js";
+import { piRuntime, resolvePiModel } from "./executor.js"
 import { buildRolePrompt } from "./roles.js";
 import { estimateTokens } from "./estimate.js";
 import { addSessionCost } from "./session-cost.js";
@@ -72,13 +70,11 @@ const id = (c: Candidate) => `${c.provider}/${c.model}`;
 async function runCandidate(task: Task, cand: Candidate): Promise<BakeoffEntry> {
   const base: BakeoffEntry = { provider: cand.provider, model: cand.model, output: "", cost: 0, ms: 0, outputTokens: 0 };
   try {
-    const authStorage = AuthStorage.create();
-    const registry = ModelRegistry.create(authStorage);
-    const model = resolvePiModel(registry, cand.provider, cand.model);
+    const runtime = await piRuntime();
+    const model = resolvePiModel(runtime, cand.provider, cand.model);
     const { session } = await createAgentSession({
       model,
-      authStorage,
-      modelRegistry: registry,
+      modelRuntime: runtime,
       thinkingLevel: "medium",
       noTools: "all",
     });
@@ -144,14 +140,12 @@ async function judge(task: Task, entries: BakeoffEntry[], judgeCand: Candidate):
 
   const letters = scored.map((_, i) => String.fromCharCode(65 + i)); // A, B, C…
   const blocks = scored.map((e, i) => `### Option ${letters[i]}\n${e.output}`).join("\n\n");
-  const authStorage = AuthStorage.create();
-  const registry = ModelRegistry.create(authStorage);
-  const model = resolvePiModel(registry, judgeCand.provider, judgeCand.model);
+  const runtime = await piRuntime();
+  const model = resolvePiModel(runtime, judgeCand.provider, judgeCand.model);
   const { tool, get } = buildJudgeTool();
   const { session } = await createAgentSession({
     model,
-    authStorage,
-    modelRegistry: registry,
+    modelRuntime: runtime,
     thinkingLevel: "medium",
     noTools: "all",
     customTools: [tool],

package/src/cli.ts

@@ -0,0 +1,263 @@
+// Headless CLI — `projectinator <command>`. Same engine as the cockpit (engine.ts),
+// same workspace root, so builds started here show up in the TUI's project list.
+//
+//   doctor                 check Node, keys, Chromium, Pi catalog, git
+//   build "<idea>" [...]   plan + build without the TUI
+//   projects               list past builds
+//   models                 the roster as it will actually run, with prices
+//
+// The launcher (bin/projectinator.mjs) handles --version/--help itself and only
+// spawns this file for a real command, so those stay instant.
+
+import { createInterface } from "node:readline";
+import { spawnSync } from "node:child_process";
+import { accessSync, constants, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { OrchestratorEvent } from "./orchestrator.js";
+import type { Provider } from "./types.js";
+import { MODELS, getModel } from "./models.js";
+import { REGISTRY } from "./registry.js";
+import { piRuntime, resolvePiModel } from "./executor.js";
+import { chromiumAvailable, CHROMIUM_INSTALL_HINT } from "./preview.js";
+import { applyKeysToEnv, getPrefs, loadConfig, ENV_VAR } from "./tui/config.js";
+import {
+  availableProviders,
+  effectiveRoster,
+  listProjects,
+  planBuild,
+  startBuild,
+  PROVIDER_LABEL,
+} from "./tui/engine.js";
+
+const NODE_MIN = "22.19.0";
+const money = (n: number) => `$${n.toFixed(2)}`;
+
+// ---- tiny argv parser: `--flag value`, `--flag=value`, `--bool`, positionals ----
+
+interface Argv {
+  positional: string[];
+  flags: Record<string, string | true>;
+}
+
+export function parseArgv(args: string[]): Argv {
+  const out: Argv = { positional: [], flags: {} };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i]!;
+    if (!a.startsWith("--")) { out.positional.push(a); continue; }
+    const eq = a.indexOf("=");
+    if (eq > 0) { out.flags[a.slice(2, eq)] = a.slice(eq + 1); continue; }
+    const next = args[i + 1];
+    if (next !== undefined && !next.startsWith("--")) { out.flags[a.slice(2)] = next; i++; }
+    else out.flags[a.slice(2)] = true;
+  }
+  return out;
+}
+
+function num(v: string | true | undefined, fallback: number): number {
+  if (v === undefined || v === true) return fallback;
+  const n = parseFloat(v);
+  return Number.isFinite(n) ? n : fallback;
+}
+
+export function semverGte(a: string, b: string): boolean {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] ?? 0) > (pb[i] ?? 0)) return true;
+    if ((pa[i] ?? 0) < (pb[i] ?? 0)) return false;
+  }
+  return true;
+}
+
+// ---- doctor ----
+
+type Check = { label: string; ok: boolean; detail: string; fatal?: boolean };
+
+async function doctor(): Promise<number> {
+  const checks: Check[] = [];
+
+  const node = process.versions.node;
+  checks.push({ label: "Node", ok: semverGte(node, NODE_MIN), detail: `v${node} (need ≥ ${NODE_MIN})`, fatal: true });
+
+  const cfg = loadConfig();
+  const providers = availableProviders();
+  for (const p of Object.keys(ENV_VAR) as Provider[]) {
+    const has = providers.includes(p);
+    const src = cfg.keys[p] ? "~/.projectinator/config.json" : has ? "env" : "";
+    checks.push({ label: `Key: ${PROVIDER_LABEL[p]}`, ok: has, detail: has ? `set (${src})` : `not set — Settings → API keys, or export ${ENV_VAR[p]}` });
+  }
+  if (providers.length === 0) checks.push({ label: "Any provider key", ok: false, detail: "no keys at all — nothing can run", fatal: true });
+
+  try {
+    const runtime = await piRuntime();
+    const bad: string[] = [];
+    for (const e of REGISTRY) for (const b of ["api", "web"] as const) {
+      try { resolvePiModel(runtime, e.byBackend[b].provider, e.byBackend[b].model); } catch { bad.push(`${e.capability}/${e.tier}/${b}`); }
+    }
+    checks.push({ label: "Pi model catalog", ok: bad.length === 0, detail: bad.length ? `unresolved: ${bad.join(", ")}` : `${Object.keys(MODELS).length} models priced, every registry pick resolves`, fatal: true });
+  } catch (e) {
+    checks.push({ label: "Pi model catalog", ok: false, detail: e instanceof Error ? e.message : String(e), fatal: true });
+  }
+
+  const chromium = await chromiumAvailable();
+  checks.push({ label: "Headless Chromium", ok: chromium, detail: chromium ? "installed — tester runs the app" : `missing — tests will be code-reading only (PASS*); ${CHROMIUM_INSTALL_HINT}` });
+
+  const git = spawnSync("git", ["--version"], { encoding: "utf8" });
+  checks.push({ label: "git", ok: git.status === 0, detail: git.status === 0 ? git.stdout.trim() : "not found — builds won't be versioned (undo/history disabled)" });
+
+  const home = join(homedir(), ".projectinator");
+  try { mkdirSync(home, { recursive: true }); accessSync(home, constants.W_OK); checks.push({ label: "Data dir", ok: true, detail: home }); }
+  catch { checks.push({ label: "Data dir", ok: false, detail: `${home} not writable`, fatal: true }); }
+
+  const prefs = getPrefs();
+  checks.push({ label: "Prefs", ok: true, detail: `budget cap ${money(prefs.budgetCapUSD)} · ${prefs.concurrency} at once · task limits ${prefs.taskTimeoutMin || "∞"} min / ${prefs.taskCostCapUSD ? money(prefs.taskCostCapUSD) : "∞"}` });
+
+  console.log("\n  projectinator doctor\n");
+  for (const c of checks) console.log(`  ${c.ok ? "✓" : c.fatal ? "✗" : "!"}  ${c.label.padEnd(22)} ${c.detail}`);
+  const fatal = checks.filter((c) => !c.ok && c.fatal);
+  const warn = checks.filter((c) => !c.ok && !c.fatal);
+  console.log(`\n  ${fatal.length ? `${fatal.length} blocking problem${fatal.length === 1 ? "" : "s"}` : "Ready"}${warn.length ? ` · ${warn.length} warning${warn.length === 1 ? "" : "s"}` : ""}\n`);
+  return fatal.length ? 1 : 0;
+}
+
+// ---- projects ----
+
+function projects(): number {
+  const list = listProjects();
+  if (!list.length) { console.log("\n  No projects yet. Run `projectinator` or `projectinator build \"an idea\"`.\n"); return 0; }
+  console.log("");
+  for (const p of list) {
+    const done = p.state.outcomes.filter((o) => !o.error).length;
+    const mark = p.status === "complete" ? "✓" : p.status === "halted" ? "⚠" : "…";
+    console.log(`  ${mark} ${p.slug.padEnd(40)} ${p.status.padEnd(9)} ${money(p.totalCost).padStart(8)}  ${done}/${p.taskCount} tasks`);
+    console.log(`      ${p.idea.slice(0, 90)}${p.idea.length > 90 ? "…" : ""}`);
+  }
+  console.log(`\n  ${list.length} project${list.length === 1 ? "" : "s"} · ${money(list.reduce((a, p) => a + p.totalCost, 0))} all time · ${join(homedir(), "…")}\n`);
+  return 0;
+}
+
+// ---- models ----
+
+function models(): number {
+  const providers = availableProviders();
+  console.log(`\n  Roster as it will run now${providers.length ? ` (keys: ${providers.join(", ")})` : " (no keys — best-of-breed picks shown)"}\n`);
+  for (const r of effectiveRoster()) {
+    const m = r.model ? getModel(r.model) : undefined;
+    const price = m ? `$${m.cost.input}/$${m.cost.output} per 1M` : "";
+    console.log(`  ${r.label.padEnd(18)} ${(r.model ?? "—").padEnd(28)} ${(r.provider ?? "").padEnd(11)} ${price}`);
+  }
+  console.log("\n  Change in the app: Settings → Models. Prices are from Pi's catalog; actual cost is measured per run.\n");
+  return 0;
+}
+
+// ---- build ----
+
+function ask(question: string): Promise<string> {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const { promise, resolve } = Promise.withResolvers<string>();
+  rl.question(question, (a) => { rl.close(); resolve(a.trim()); });
+  return promise;
+}
+
+async function build(argv: Argv): Promise<number> {
+  const idea = argv.positional.join(" ").trim();
+  const json = argv.flags.json === true;
+  const yes = json || argv.flags.yes === true || argv.flags.y === true;
+  const dry = argv.flags["dry-run"] === true;
+  const emit = (o: Record<string, unknown>) => { if (json) process.stdout.write(JSON.stringify(o) + "\n"); };
+  const say = (s: string) => { if (!json) console.log(s); };
+
+  if (!idea) { console.error("  build: give an idea, e.g. projectinator build \"a tip calculator\""); return 2; }
+
+  let providers = availableProviders();
+  const lock = argv.flags.provider;
+  if (typeof lock === "string") {
+    if (!(lock in PROVIDER_LABEL)) { console.error(`  build: unknown provider "${lock}" (anthropic | openai | google | openrouter)`); return 2; }
+    if (!providers.includes(lock as Provider)) { console.error(`  build: no key for ${lock} — export ${ENV_VAR[lock as Provider]} or set it in the app`); return 1; }
+    providers = [lock as Provider];
+  }
+  if (!providers.length) { console.error("  build: no API key found. Run `projectinator doctor`."); return 1; }
+
+  const prefs = getPrefs();
+  const budget = num(argv.flags.budget, prefs.budgetCapUSD);
+  const concurrency = Math.max(1, Math.floor(num(argv.flags.concurrency, prefs.concurrency)));
+  const taskLimits = {
+    timeoutMs: num(argv.flags["task-timeout"], prefs.taskTimeoutMin) * 60_000,
+    costCapUSD: num(argv.flags["task-cap"], prefs.taskCostCapUSD),
+  };
+
+  say(`\n  Planning with the PM (${providers.join("/")})…`);
+  const plan = await planBuild(idea, providers);
+  emit({ event: "plan", provider: plan.provider, modelId: plan.modelId, estCost: plan.estCost, tasks: plan.tasks });
+  say(`\n  ${plan.tasks.length} tasks · estimated ${money(plan.estCost)} · cap ${money(budget)}${plan.lock ? ` · locked to ${plan.lock}` : ""}\n`);
+  for (const t of plan.tasks) {
+    const dep = t.dependsOn?.length ? `  ← ${t.dependsOn.join(", ")}` : "";
+    say(`    ${t.id.padEnd(6)} ${t.capability.padEnd(7)} ${t.difficulty.padEnd(8)} ${t.title}${dep}`);
+  }
+  if (plan.estCost > budget) say(`\n  ⚠ Estimate exceeds the cap — the build may halt partway.`);
+
+  if (dry) { say("\n  Dry run — nothing built (the PM call above was the only spend).\n"); return 0; }
+  if (!yes) {
+    const a = await ask(`\n  Build it for ~${money(plan.estCost)}? [y/N] `);
+    if (!/^y(es)?$/i.test(a)) { say("  Cancelled.\n"); return 0; }
+  }
+
+  const onEvent = (e: OrchestratorEvent) => {
+    emit({ event: e.type, ...e });
+    if (json) return;
+    if (e.type === "task_start") console.log(`  ▶ ${e.task.id} [${e.task.capability}] → ${e.provider}/${e.modelId}${e.round ? ` (round ${e.round})` : ""}`);
+    else if (e.type === "task_done") console.log(`    ✓ ${e.outcome.taskId} ${money(e.outcome.cost)}  running ${money(e.runningTotal)}${e.outcome.verdict ? `  ${e.outcome.verdict.passed ? (e.outcome.verdict.runtimeChecked || e.outcome.capability !== "test" ? "PASS" : "PASS* (app not executed)") : "FAIL"}` : ""}`);
+    else if (e.type === "task_failed") console.log(`    ⛔ ${e.outcome.taskId} aborted: ${e.outcome.error} — billed ${money(e.outcome.cost)}`);
+    else if (e.type === "task_skipped") console.log(`    · ${e.taskId} skipped`);
+    else if (e.type === "test_failed") console.log(`    ✗ ${e.taskId} failed (${e.bugs} bugs) — round ${e.round}`);
+    else if (e.type === "retry_dev") console.log(`    ↻ re-running ${e.taskId} to fix ${e.forTest}`);
+    else if (e.type === "budget_halt") console.log(`    ⚠ budget halt at ${money(e.runningTotal)} (cap ${money(e.cap)})`);
+    else if (e.type === "cycle_or_error") console.log(`    ✗ ${e.message}`);
+  };
+
+  say(`\n  Building…\n`);
+  const handle = startBuild(idea, plan, { concurrency, budgetCapUSD: budget, taskLimits, onEvent, mode: "auto" });
+  const r = await handle.promise;
+  emit({ event: "done", halted: r.halted, haltReason: r.haltReason, totalCost: r.totalCost, files: r.files, workspace: handle.workspace });
+  say(`\n  ${r.halted ? `⚠ Halted (${r.haltReason ?? "?"})` : "✓ Complete"} · ${money(r.totalCost)} · ${r.files.length} file${r.files.length === 1 ? "" : "s"}`);
+  say(`  ${handle.workspace}\n`);
+  return r.halted ? 3 : 0;
+}
+
+// ---- main ----
+
+const USAGE = `Usage: projectinator <command> [options]
+
+  doctor                        check Node, API keys, Chromium, Pi catalog, git
+  build "<idea>" [options]      plan + build headless (same workspace as the app)
+      --dry-run                 plan and estimate only (spends one PM call)
+      --yes, -y                 don't ask before building
+      --json                    NDJSON events on stdout (implies --yes)
+      --budget <usd>            cap for this build       (default: your prefs)
+      --provider <name>         anthropic|openai|google|openrouter (default: prefs / keys)
+      --concurrency <n>         tasks at once            (default: your prefs)
+      --task-cap <usd>          per-task cost ceiling    (default: your prefs; 0 = off)
+      --task-timeout <min>      per-task timeout         (default: your prefs; 0 = off)
+  projects                      list past builds with status and cost
+  models                        the roster as it will run, with prices
+
+Exit codes: 0 ok · 1 environment problem · 2 bad usage · 3 build halted`;
+
+export async function main(args: string[]): Promise<number> {
+  applyKeysToEnv();
+  const argv = parseArgv(args);
+  const cmd = argv.positional.shift();
+  switch (cmd) {
+    case "doctor": return doctor();
+    case "projects": return projects();
+    case "models": return models();
+    case "build": return build(argv);
+    case undefined: case "help": console.log(USAGE); return cmd ? 0 : 2;
+    default: console.error(`projectinator: unknown command "${cmd}".\n\n${USAGE}`); return 2;
+  }
+}
+
+if (process.argv[1] && import.meta.url === new URL(process.argv[1], "file://").href) {
+  process.exitCode = await main(process.argv.slice(2));
+}

package/src/council.ts

@@ -4,8 +4,6 @@
 // via the normal decomposer seeded with these epics.
 
 import {
-  AuthStorage,
-  ModelRegistry,
   createAgentSession,
   defineTool,
   type AgentSession,
@@ -13,7 +11,7 @@ import {
 import { Type, type Static } from "typebox";
 import type { Backend, Provider } from "./types.js";
 import { findEntry } from "./registry.js";
-import { resolvePiModel } from "./executor.js";
+import { piRuntime, resolvePiModel } from "./executor.js"
 import { addSessionCost } from "./session-cost.js";
 
 export interface Epic {
@@ -67,17 +65,15 @@ interface Ctx {
 }
 
 async function runEpicAgent(idea: string, system: string, toolName: string, ctx: Ctx): Promise<Epic[]> {
-  const authStorage = AuthStorage.create();
-  const registry = ModelRegistry.create(authStorage);
+  const runtime = await piRuntime();
   const { entry } = findEntry("plan", "mid");
   const pick = ctx.modelOverride ?? entry.byBackend[ctx.backend];
   try {
-    const model = resolvePiModel(registry, pick.provider, pick.model);
+    const model = resolvePiModel(runtime, pick.provider, pick.model);
     const { tool, get } = buildEpicsTool(toolName);
     const { session } = await createAgentSession({
       model,
-      authStorage,
-      modelRegistry: registry,
+      modelRuntime: runtime,
       thinkingLevel: "low",
       noTools: "all",
       customTools: [tool],
@@ -145,15 +141,14 @@ export async function councilEpics(idea: string, ctx: Ctx): Promise<CouncilResul
   if (!proposals.length) return { epics: [], proposals: [] };
 
   // Synthesize.
-  const authStorage = AuthStorage.create();
-  const registry = ModelRegistry.create(authStorage);
+  const runtime = await piRuntime();
   const { entry } = findEntry("plan", "mid");
   const pick = ctx.modelOverride ?? entry.byBackend[ctx.backend];
   try {
-    const model = resolvePiModel(registry, pick.provider, pick.model);
+    const model = resolvePiModel(runtime, pick.provider, pick.model);
     const { tool, get } = buildEpicsTool("submit_epics");
     const { session } = await createAgentSession({
-      model, authStorage, modelRegistry: registry, thinkingLevel: "low",
+      model, modelRuntime: runtime, thinkingLevel: "low",
       noTools: "all", customTools: [tool], tools: ["submit_epics"],
     });
     try {

package/src/executor.ts

@@ -6,8 +6,7 @@
 // hits the provider API and spends money — that path is guarded by the caller.
 
 import {
-  AuthStorage,
-  ModelRegistry,
+  ModelRuntime,
   createAgentSession,
   type AgentSession,
   type AgentSessionEvent,
@@ -20,17 +19,23 @@ import { getModel } from "./models.js";
 import { addSessionCost } from "./session-cost.js";
 
 /** Pi's own Model type, derived so we don't depend on a deep sub-path import. */
-type PiModel = NonNullable<ReturnType<ModelRegistry["find"]>>;
+export type PiModel = NonNullable<ReturnType<ModelRuntime["getModel"]>>;
+
+/** Pi's model/auth runtime: built-in catalog + env keys / ~/.pi/agent/auth.json.
+ *  Created per call on purpose — a key added in Settings must apply to the next session. */
+export function piRuntime(): Promise<ModelRuntime> {
+  return ModelRuntime.create();
+}
 
 /** Resolve a Projectinator (provider, modelId) to Pi's executable Model.
  *  Offline + free — reads Pi's built-in registry. Throws with a clear message
  *  if the id isn't one Pi knows (our ids are kept identical to Pi's on purpose). */
 export function resolvePiModel(
-  registry: ModelRegistry,
+  runtime: ModelRuntime,
   provider: Provider,
   modelId: string,
 ): PiModel {
-  const m = registry.find(provider, modelId);
+  const m = runtime.getModel(provider, modelId);
   if (!m) {
     throw new Error(
       `Pi has no model "${provider}/${modelId}". ` +
@@ -47,8 +52,6 @@ export interface ExecuteOptions {
   thinkingLevel?: "off" | "low" | "medium" | "high";
   /** Optional progress hook — receives raw Pi session events. */
   onEvent?: (event: AgentSessionEvent) => void;
-  /** Override auth (tests). Default resolves env keys / ~/.pi/agent/auth.json. */
-  authStorage?: AuthStorage;
   /** Tools the agent may use. Default: the coding set. */
   tools?: string[];
 }
@@ -95,15 +98,13 @@ export async function executeTask(
   decision: RouteDecision,
   opts: ExecuteOptions,
 ): Promise<ExecuteResult> {
-  const authStorage = opts.authStorage ?? AuthStorage.create();
-  const registry = ModelRegistry.create(authStorage);
-  const model = resolvePiModel(registry, decision.provider, decision.model.id);
+  const runtime = await piRuntime();
+  const model = resolvePiModel(runtime, decision.provider, decision.model.id);
 
   const { session } = await createAgentSession({
     model,
     cwd: opts.workspace,
-    authStorage,
-    modelRegistry: registry,
+    modelRuntime: runtime,
     thinkingLevel: opts.thinkingLevel ?? "medium",
     tools: opts.tools ?? ["read", "write", "edit", "bash", "ls", "grep", "find"],
   });

package/src/intake.ts

@@ -6,15 +6,13 @@
 // schema, coerced/validated in code.
 
 import {
-  AuthStorage,
-  ModelRegistry,
   createAgentSession,
   defineTool,
 } from "@earendil-works/pi-coding-agent";
 import { Type, type Static } from "typebox";
 import type { Backend, Provider } from "./types.js";
 import { findEntry } from "./registry.js";
-import { resolvePiModel } from "./executor.js";
+import { piRuntime, resolvePiModel } from "./executor.js"
 import { addSessionCost } from "./session-cost.js";
 
 const IntakeSchema = Type.Object(
@@ -78,18 +76,16 @@ export interface AssessOptions {
 /** Ask the PM whether the request needs clarification; returns up to 4 questions
  *  (empty = clear enough to plan directly). Never throws — returns [] on trouble. */
 export async function assessIntake(idea: string, opts: AssessOptions): Promise<IntakeQuestion[]> {
-  const authStorage = AuthStorage.create();
-  const registry = ModelRegistry.create(authStorage);
+  const runtime = await piRuntime();
   const { entry } = findEntry("plan", "mid");
   const pick = opts.modelOverride ?? entry.byBackend[opts.backend];
 
   try {
-    const model = resolvePiModel(registry, pick.provider, pick.model);
+    const model = resolvePiModel(runtime, pick.provider, pick.model);
     const { tool, get } = buildIntakeTool();
     const { session } = await createAgentSession({
       model,
-      authStorage,
-      modelRegistry: registry,
+      modelRuntime: runtime,
       thinkingLevel: "low",
       noTools: "all",
       customTools: [tool],

package/src/models.ts

@@ -1,36 +1,42 @@
-// Model pricing table. Rates USD per 1,000,000 tokens (verified July 2026).
-// Shape mirrors Pi's models.json `cost` block so this ports to Pi later.
-// cacheRead ~= 0.1x input, cacheWrite ~= 1.25x input (Anthropic-style; approximations
-// for models whose exact cache rates we haven't pinned — refine against provider docs).
+// Model pricing table. Rates USD per 1,000,000 tokens — copied verbatim from Pi's
+// bundled catalog (pi-coding-agent 0.85.1, Sept 2026); test/executor.test.ts pins every
+// entry against it. Shape mirrors Pi's models.json `cost` block.
 
 import type { Model } from "./types.js";
 import { findOpenRouterModel } from "./openrouter.js";
 
 export const MODELS: Record<string, Model> = {
-  // ---- OpenAI: GPT-5.6 family ----
+  // ---- OpenAI: GPT-5.6 family (prices cut Sept 2026; past 272k input costs 2x) ----
   "gpt-5.6-sol": {
     id: "gpt-5.6-sol",
     provider: "openai",
     name: "GPT-5.6 Sol",
     contextWindow: 272_000,
-    cost: { input: 5, output: 30, cacheRead: 0.5, cacheWrite: 6.25 },
+    cost: { input: 4, output: 20, cacheRead: 0.4, cacheWrite: 5, tiers: [{ inputTokensAbove: 272_000, input: 8, output: 30, cacheRead: 0.8, cacheWrite: 10 }] },
   },
   "gpt-5.6-terra": {
     id: "gpt-5.6-terra",
     provider: "openai",
     name: "GPT-5.6 Terra",
     contextWindow: 272_000,
-    cost: { input: 2.5, output: 15, cacheRead: 0.25, cacheWrite: 3.125 },
+    cost: { input: 2, output: 12, cacheRead: 0.2, cacheWrite: 2.5, tiers: [{ inputTokensAbove: 272_000, input: 4, output: 18, cacheRead: 0.4, cacheWrite: 5 }] },
   },
   "gpt-5.6-luna": {
     id: "gpt-5.6-luna",
     provider: "openai",
     name: "GPT-5.6 Luna",
     contextWindow: 272_000,
-    cost: { input: 1, output: 6, cacheRead: 0.1, cacheWrite: 1.25 },
+    cost: { input: 0.2, output: 1.2, cacheRead: 0.02, cacheWrite: 0.25, tiers: [{ inputTokensAbove: 272_000, input: 0.4, output: 1.8, cacheRead: 0.04, cacheWrite: 0.5 }] },
   },
 
   // ---- Anthropic: Claude ----
+  "claude-fable-5-1": {
+    id: "claude-fable-5-1",
+    provider: "anthropic",
+    name: "Claude Fable 5.1",
+    contextWindow: 1_000_000,
+    cost: { input: 10, output: 50, cacheRead: 0.25, cacheWrite: 12.5 },
+  },
   "claude-fable-5": {
     id: "claude-fable-5",
     provider: "anthropic",
@@ -38,6 +44,13 @@ export const MODELS: Record<string, Model> = {
     contextWindow: 1_000_000,
     cost: { input: 10, output: 50, cacheRead: 1, cacheWrite: 12.5 },
   },
+  "claude-opus-5": {
+    id: "claude-opus-5",
+    provider: "anthropic",
+    name: "Claude Opus 5",
+    contextWindow: 1_000_000,
+    cost: { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
+  },
   "claude-opus-4-8": {
     id: "claude-opus-4-8",
     provider: "anthropic",
@@ -45,6 +58,13 @@ export const MODELS: Record<string, Model> = {
     contextWindow: 1_000_000,
     cost: { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
   },
+  "claude-sonnet-5": {
+    id: "claude-sonnet-5",
+    provider: "anthropic",
+    name: "Claude Sonnet 5",
+    contextWindow: 1_000_000,
+    cost: { input: 2, output: 10, cacheRead: 0.2, cacheWrite: 2.5 },
+  },
   "claude-sonnet-4-6": {
     id: "claude-sonnet-4-6",
     provider: "anthropic",
@@ -77,6 +97,13 @@ export const MODELS: Record<string, Model> = {
       tiers: [{ inputTokensAbove: 200_000, input: 4, output: 18, cacheRead: 0.4, cacheWrite: 5 }],
     },
   },
+  "gemini-3.8-flash": {
+    id: "gemini-3.8-flash",
+    provider: "google",
+    name: "Gemini 3.8 Flash",
+    contextWindow: 1_000_000,
+    cost: { input: 0.75, output: 3.75, cacheRead: 0.075 },
+  },
   "gemini-3-flash-preview": {
     id: "gemini-3-flash-preview",
     provider: "google",
@@ -88,6 +115,13 @@ export const MODELS: Record<string, Model> = {
   // ---- OpenRouter (one key → frontier models). ids are Pi's OpenRouter-catalog
   // slugs (vendor/model). Pricing mirrors the underlying model (OpenRouter passes
   // it through, ~small margin); ACTUAL cost still comes from Pi per run.
+  "anthropic/claude-opus-5": {
+    id: "anthropic/claude-opus-5",
+    provider: "openrouter",
+    name: "Claude Opus 5 (OpenRouter)",
+    contextWindow: 1_000_000,
+    cost: { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
+  },
   "anthropic/claude-opus-4.8": {
     id: "anthropic/claude-opus-4.8",
     provider: "openrouter",
@@ -95,6 +129,13 @@ export const MODELS: Record<string, Model> = {
     contextWindow: 1_000_000,
     cost: { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
   },
+  "anthropic/claude-sonnet-5": {
+    id: "anthropic/claude-sonnet-5",
+    provider: "openrouter",
+    name: "Claude Sonnet 5 (OpenRouter)",
+    contextWindow: 1_000_000,
+    cost: { input: 2, output: 10, cacheRead: 0.2, cacheWrite: 2.5 },
+  },
   "anthropic/claude-sonnet-4.6": {
     id: "anthropic/claude-sonnet-4.6",
     provider: "openrouter",
@@ -102,12 +143,19 @@ export const MODELS: Record<string, Model> = {
     contextWindow: 1_000_000,
     cost: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
   },
+  "google/gemini-3.8-flash": {
+    id: "google/gemini-3.8-flash",
+    provider: "openrouter",
+    name: "Gemini 3.8 Flash (OpenRouter)",
+    contextWindow: 1_000_000,
+    cost: { input: 0.75, output: 3.75, cacheRead: 0.075 },
+  },
   "openai/gpt-5.6-luna": {
     id: "openai/gpt-5.6-luna",
     provider: "openrouter",
     name: "GPT-5.6 Luna (OpenRouter)",
-    contextWindow: 272_000,
-    cost: { input: 1, output: 6, cacheRead: 0.1, cacheWrite: 1.25 },
+    contextWindow: 1_050_000,
+    cost: { input: 0.2, output: 1.2, cacheRead: 0.02, cacheWrite: 0.25 },
   },
 };
 

package/src/narrate.ts

@@ -3,15 +3,13 @@
 // (costs a small call) and cached on the build state by the caller.
 
 import {
-  AuthStorage,
-  ModelRegistry,
   createAgentSession,
   type AgentSession,
 } from "@earendil-works/pi-coding-agent";
 import type { Backend, Provider } from "./types.js";
 import type { RetroReport } from "./retro.js";
 import { findEntry } from "./registry.js";
-import { resolvePiModel } from "./executor.js";
+import { piRuntime, resolvePiModel } from "./executor.js"
 import { addSessionCost } from "./session-cost.js";
 
 function lastAssistantText(session: AgentSession): string {
@@ -66,16 +64,14 @@ export interface NarrateOptions {
 
 /** Generate the narrative. Throws on failure (caller shows the error). */
 export async function narrateRetro(report: RetroReport, opts: NarrateOptions): Promise<string> {
-  const authStorage = AuthStorage.create();
-  const registry = ModelRegistry.create(authStorage);
+  const runtime = await piRuntime();
   const { entry } = findEntry("plan", "mid");
   const pick = opts.modelOverride ?? entry.byBackend[opts.backend];
-  const model = resolvePiModel(registry, pick.provider, pick.model);
+  const model = resolvePiModel(runtime, pick.provider, pick.model);
 
   const { session } = await createAgentSession({
     model,
-    authStorage,
-    modelRegistry: registry,
+    modelRuntime: runtime,
     thinkingLevel: "low",
     noTools: "all",
   });

package/src/openrouter.ts

@@ -6,7 +6,7 @@
 //  - openRouterModels() / findOpenRouterModel(): SYNC reads (disk cache, else Pi's
 //    built-in list) so cost estimation (getModel) can price any picked model.
 
-import { AuthStorage, ModelRegistry } from "@earendil-works/pi-coding-agent";
+import { piRuntime } from "./executor.js";
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
@@ -20,19 +20,25 @@ const CACHE = join(homedir(), ".projectinator", "openrouter-models.json");
 let builtinMemo: ORModel[] | null = null;
 let diskMemo: ORModel[] | null | undefined; // undefined = not read yet, null = no cache
 
-/** Pi's built-in OpenRouter catalog — offline, always available, names + pricing. */
+/** Pi's built-in OpenRouter catalog — offline, names + pricing. Sync read of the memo;
+ *  call warmBuiltinOpenRouterModels() once at startup to fill it (Pi's runtime is async). */
 export function builtinOpenRouterModels(): ORModel[] {
+  return builtinMemo ?? [];
+}
+
+/** Load Pi's built-in OpenRouter list into the memo. Safe to call repeatedly. */
+export async function warmBuiltinOpenRouterModels(): Promise<ORModel[]> {
   if (builtinMemo) return builtinMemo;
   try {
-    const reg = ModelRegistry.create(AuthStorage.create());
-    const all = (reg.getAll() as unknown as Array<{ id: string; provider: string; name?: string; contextWindow?: number; cost?: ModelCost }>);
-    builtinMemo = all
-      .filter((m) => m.provider === "openrouter" && m.cost)
+    const runtime = await piRuntime();
+    builtinMemo = runtime
+      .getModels("openrouter")
+      .filter((m) => !!m.cost)
       .map((m) => ({
         id: m.id,
         name: m.name ?? m.id,
         contextWindow: m.contextWindow ?? 200_000,
-        cost: m.cost as ModelCost,
+        cost: m.cost,
       }))
       .sort((a, b) => a.name.localeCompare(b.name));
   } catch {

package/src/pm.ts

@@ -9,8 +9,6 @@
 // code buckets after decomposition. The PM only decomposes + tags.
 
 import {
-  AuthStorage,
-  ModelRegistry,
   createAgentSession,
   defineTool,
   type AgentSession,
@@ -19,7 +17,7 @@ import { Type, type Static } from "typebox";
 import type { Backend, Capability, Difficulty, Provider, Task } from "./types.js";
 import { estimateTokens } from "./estimate.js";
 import { findEntry } from "./registry.js";
-import { resolvePiModel } from "./executor.js";
+import { piRuntime, resolvePiModel } from "./executor.js";
 import { addSessionCost } from "./session-cost.js";
 
 // ---- typebox schema = the backlog contract ----
@@ -215,7 +213,6 @@ export function extractBacklogFromText(text: string): Backlog | undefined {
 
 export interface DecomposeOptions {
   backend: Backend;
-  authStorage?: AuthStorage;
   thinkingLevel?: "off" | "low" | "medium" | "high";
   onEvent?: Parameters<import("@earendil-works/pi-coding-agent").AgentSession["subscribe"]>[0];
   /** Override the PM model (else resolved from registry plan/mid). */
@@ -237,19 +234,17 @@ export interface DecomposeResult {
 }
 
 export async function decomposeIdea(idea: string, opts: DecomposeOptions): Promise<DecomposeResult> {
-  const authStorage = opts.authStorage ?? AuthStorage.create();
-  const registry = ModelRegistry.create(authStorage);
+  const runtime = await piRuntime();
 
   // PM = plan capability, mid tier — unless the caller overrides the model.
   const { entry } = findEntry("plan", "mid");
   const pick = opts.modelOverride ?? entry.byBackend[opts.backend];
-  const model = resolvePiModel(registry, pick.provider, pick.model);
+  const model = resolvePiModel(runtime, pick.provider, pick.model);
 
   const { tool, get } = buildBacklogTool();
   const { session } = await createAgentSession({
     model,
-    authStorage,
-    modelRegistry: registry,
+    modelRuntime: runtime,
     thinkingLevel: opts.thinkingLevel ?? "medium",
     noTools: "all",
     customTools: [tool],

package/src/registry.ts

@@ -1,6 +1,6 @@
 // The Model Registry — the swappable brain.
 // Maps capability + tier -> model, per backend. Change an entry, re-route everything.
-// Seeded from the July-2026 verified roster. This is the ONE file the scout edits.
+// Seeded from the September-2026 verified roster. This is the ONE file the scout edits.
 
 import type { Capability, RegistryEntry, Tier } from "./types.js";
 
@@ -18,8 +18,8 @@ export const REGISTRY: RegistryEntry[] = [
       web: { provider: "openai", model: "gpt-5.6-sol" },
       api: { provider: "openai", model: "gpt-5.6-terra" },
     },
-    evidence: "OpenAI leads DeepPlanning long-horizon planning",
-    updated: "2026-07-15",
+    evidence: "OpenAI leads DeepPlanning long-horizon planning; Terra repriced to $2/$12 (Sept 2026)",
+    updated: "2026-09-15",
   },
 
   // --- DESIGN (UI/UX) ---
@@ -27,12 +27,12 @@ export const REGISTRY: RegistryEntry[] = [
     capability: "design",
     tier: "high",
     byBackend: {
-      web: { provider: "anthropic", model: "claude-fable-5" },
+      web: { provider: "anthropic", model: "claude-fable-5-1" },
       api: { provider: "openai", model: "gpt-5.6-sol" },
     },
     ask: true,
-    evidence: "Design Arena Elo — Fable 5 #2, GPT-5.6 Sol #3",
-    updated: "2026-07-15",
+    evidence: "Design Arena Elo — Fable 5 #2, GPT-5.6 Sol #3; Sol repriced to $4/$20 (Sept 2026)",
+    updated: "2026-09-15",
   },
 
   // --- CODE (development) ---
@@ -40,30 +40,32 @@ export const REGISTRY: RegistryEntry[] = [
     capability: "code",
     tier: "high",
     byBackend: {
-      web: { provider: "anthropic", model: "claude-fable-5" }, // free -> 95% SWE-bench ceiling
-      api: { provider: "anthropic", model: "claude-opus-4-8" }, // paid -> 88.6% value pick
+      web: { provider: "anthropic", model: "claude-fable-5-1" },
+      api: { provider: "anthropic", model: "claude-opus-5" }, // same price as Opus 4.8, 96% SWE-bench V
     },
     ask: true,
-    evidence: "SWE-bench Verified — Fable 5 95%, Opus 4.8 88.6%",
-    updated: "2026-07-15",
+    evidence: "SWE-bench Verified — Opus 5 96% (Opus 4.8 was 88.6%), same $5/$25",
+    updated: "2026-09-15",
   },
   {
     capability: "code",
     tier: "mid",
     byBackend: {
-      web: { provider: "anthropic", model: "claude-opus-4-8" },
-      api: { provider: "anthropic", model: "claude-sonnet-4-6" },
+      web: { provider: "anthropic", model: "claude-opus-5" },
+      api: { provider: "anthropic", model: "claude-sonnet-5" },
     },
-    updated: "2026-07-15",
+    evidence: "Sonnet 5 — 85.2% SWE-bench V, beats Opus 4.8 on Terminal-Bench 2.1, $2/$10 in Pi's table",
+    updated: "2026-09-15",
   },
   {
     capability: "code",
     tier: "fast",
     byBackend: {
-      web: { provider: "anthropic", model: "claude-sonnet-4-6" },
-      api: { provider: "anthropic", model: "claude-haiku-4-5" },
+      web: { provider: "anthropic", model: "claude-sonnet-5" },
+      api: { provider: "google", model: "gemini-3.8-flash" },
     },
-    updated: "2026-07-15",
+    evidence: "Gemini 3.8 Flash — 90.8% Terminal-Bench 2.1 at $0.75/$3.75",
+    updated: "2026-09-15",
   },
 
   // --- REVIEW (read-only wiring check before the tester; one row -> every difficulty is cheap) ---
@@ -71,10 +73,10 @@ export const REGISTRY: RegistryEntry[] = [
     capability: "review",
     tier: "fast",
     byBackend: {
-      web: { provider: "google", model: "gemini-3.1-pro-preview" },
-      api: { provider: "google", model: "gemini-3-flash-preview" },
+      web: { provider: "google", model: "gemini-3.8-flash" },
+      api: { provider: "google", model: "gemini-3.8-flash" },
     },
-    evidence: "Read-only static check; cheapest tier is adequate, same picks as test",
+    evidence: "Read-only wiring check; strongest cheap model, same pick as test",
     updated: "2026-09-15",
   },
 
@@ -84,10 +86,10 @@ export const REGISTRY: RegistryEntry[] = [
     tier: "fast",
     byBackend: {
       web: { provider: "google", model: "gemini-3.1-pro-preview" },
-      api: { provider: "google", model: "gemini-3-flash-preview" },
+      api: { provider: "google", model: "gemini-3.8-flash" },
     },
-    evidence: "Fast tier ~5x cheaper for high-volume review",
-    updated: "2026-07-15",
+    evidence: "Gemini 3.8 Flash — 90.8% Terminal-Bench 2.1; +50% over 3 Flash for a much stronger tester",
+    updated: "2026-09-15",
   },
 
   // --- OPS (Runner: terminal / CI / file-driving autonomy) ---
@@ -98,8 +100,8 @@ export const REGISTRY: RegistryEntry[] = [
       web: { provider: "openai", model: "gpt-5.6-sol" },
       api: { provider: "openai", model: "gpt-5.6-sol" },
     },
-    evidence: "GPT-5.6 Sol leads Terminal-Bench 2.1",
-    updated: "2026-07-15",
+    evidence: "GPT-5.6 Sol on Terminal-Bench; GPT-6 Astra scores higher (57.9 vs 37.3 on TB 4.0) but 2.5x the price — ops tasks are rare",
+    updated: "2026-09-15",
   },
 ];
 

package/src/research.ts

@@ -8,8 +8,6 @@
 // Flow:  research report (text)  ->  extractFindings()  ->  findings.json  ->  scout --from
 
 import {
-  AuthStorage,
-  ModelRegistry,
   createAgentSession,
   defineTool,
   type AgentSession,
@@ -17,7 +15,7 @@ import {
 import { Type, type Static } from "typebox";
 import type { Provider } from "./types.js";
 import type { Finding } from "./scout.js";
-import { resolvePiModel } from "./executor.js";
+import { piRuntime, resolvePiModel } from "./executor.js"
 import { MODELS } from "./models.js";
 
 const FindingsSchema = Type.Object({
@@ -89,19 +87,17 @@ export function extractionPrompt(report: string): string {
 
 export interface ExtractOptions {
   model: { provider: Provider; model: string };
-  authStorage?: AuthStorage;
   onEvent?: Parameters<AgentSession["subscribe"]>[0];
 }
 
 /** Extract findings from a report via a model. Spends money (one model call). */
 export async function extractFindings(report: string, opts: ExtractOptions): Promise<Finding[]> {
-  const authStorage = opts.authStorage ?? AuthStorage.create();
-  const registry = ModelRegistry.create(authStorage);
-  const model = resolvePiModel(registry, opts.model.provider, opts.model.model);
+  const runtime = await piRuntime();
+  const model = resolvePiModel(runtime, opts.model.provider, opts.model.model);
 
   const { tool, get } = buildFindingsTool();
   const { session } = await createAgentSession({
-    model, authStorage, modelRegistry: registry,
+    model, modelRuntime: runtime,
     thinkingLevel: "low",
     noTools: "all",
     customTools: [tool],

package/src/roles.ts

@@ -5,8 +5,6 @@
 // the orchestrator's feedback loop depends on.
 
 import {
-  AuthStorage,
-  ModelRegistry,
   createAgentSession,
   defineTool,
   type AgentSession,
@@ -24,7 +22,7 @@ import {
   type TaskLimits,
   type Verdict,
 } from "./types.js";
-import { resolvePiModel } from "./executor.js";
+import { piRuntime, resolvePiModel } from "./executor.js"
 import { renderCheck, chromiumAvailable, CHROMIUM_INSTALL_HINT } from "./preview.js";
 import { estimateCost } from "./cost.js";
 import { getModel } from "./models.js";
@@ -161,10 +159,10 @@ function buildVerdictTool(runtimeChecked: () => boolean) {
 // that provider's sensible model, so route() resolves everything to it.
 
 const PROVIDER_MODELS: Record<Provider, { strong: string; mid: string; cheap: string }> = {
-  anthropic: { strong: "claude-opus-4-8", mid: "claude-sonnet-4-6", cheap: "claude-haiku-4-5" },
+  anthropic: { strong: "claude-opus-5", mid: "claude-sonnet-5", cheap: "claude-haiku-4-5" },
   openai: { strong: "gpt-5.6-sol", mid: "gpt-5.6-terra", cheap: "gpt-5.6-luna" },
-  google: { strong: "gemini-3.1-pro-preview", mid: "gemini-3.1-pro-preview", cheap: "gemini-3-flash-preview" },
-  openrouter: { strong: "anthropic/claude-opus-4.8", mid: "anthropic/claude-sonnet-4.6", cheap: "openai/gpt-5.6-luna" },
+  google: { strong: "gemini-3.1-pro-preview", mid: "gemini-3.1-pro-preview", cheap: "gemini-3.8-flash" },
+  openrouter: { strong: "anthropic/claude-opus-5", mid: "anthropic/claude-sonnet-5", cheap: "google/gemini-3.8-flash" },
 };
 
 const CAP_STRENGTH: Record<Capability, "strong" | "mid" | "cheap"> = {
@@ -201,7 +199,6 @@ export function lockRegistryToProvider(provider: Provider): RegistryEntry[] {
 export interface PiExecutorOptions {
   workspace: string;
   backend: Backend;
-  authStorage?: AuthStorage;
   thinkingLevel?: "off" | "low" | "medium" | "high";
   onEvent?: Parameters<AgentSession["subscribe"]>[0];
   /** Called when a task falls back from its routed provider to another one. */
@@ -280,8 +277,6 @@ function listFiles(dir: string): string[] {
 /** Build a real RoleExecutor backed by Pi. Each call spends money. Falls back to
  *  another key-holding provider when the routed one errors or returns 0 tokens. */
 export function makePiExecutor(opts: PiExecutorOptions): RoleExecutor {
-  const authStorage = opts.authStorage ?? AuthStorage.create();
-
   // One attempt on a specific provider/model. Returns the result + total tokens
   // (0 tokens = the provider call didn't really happen → treat as a failure).
   const runOnce = async (
@@ -291,8 +286,8 @@ export function makePiExecutor(opts: PiExecutorOptions): RoleExecutor {
     modelId: string,
     limits: TaskLimits,
   ): Promise<{ result: RoleResult; tokensTotal: number }> => {
-    const registry = ModelRegistry.create(authStorage);
-    const model = resolvePiModel(registry, provider, modelId);
+    const runtime = await piRuntime();
+    const model = resolvePiModel(runtime, provider, modelId);
 
     const isTest = task.capability === "test";
     const isReview = task.capability === "review";
@@ -303,8 +298,7 @@ export function makePiExecutor(opts: PiExecutorOptions): RoleExecutor {
     const { session } = await createAgentSession({
       model,
       cwd: opts.workspace,
-      authStorage,
-      modelRegistry: registry,
+      modelRuntime: runtime,
       thinkingLevel: opts.thinkingLevel ?? "medium",
       ...(isTest
         ? { customTools: [verdictTool!.tool, checkTool!.tool], tools: ["read", "bash", "ls", "grep", "find", "check_app", "submit_verdict"] }

package/src/run-build.ts

@@ -11,7 +11,6 @@
 import { mkdirSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
-import { AuthStorage } from "@earendil-works/pi-coding-agent";
 import type { AgentSessionEvent } from "@earendil-works/pi-coding-agent";
 import type { Provider, Task } from "./types.js";
 import { DEFAULT_POLICY } from "./router.js";

package/src/run-dev.ts

@@ -8,11 +8,10 @@
 import { mkdirSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
-import { AuthStorage, ModelRegistry } from "@earendil-works/pi-coding-agent";
 import type { AgentSessionEvent } from "@earendil-works/pi-coding-agent";
 import type { Task } from "./types.js";
 import { DEFAULT_POLICY, route } from "./router.js";
-import { buildDeveloperPrompt, executeTask, resolvePiModel } from "./executor.js";
+import { buildDeveloperPrompt, executeTask, piRuntime, resolvePiModel } from "./executor.js";
 
 const TASK: Task = {
   id: "T-DEV1",
@@ -29,9 +28,7 @@ const live = process.argv.includes("--live");
 const policy = { ...DEFAULT_POLICY, backendMode: "api" as const };
 const decision = route(TASK, { policy });
 
-const auth = AuthStorage.create();
-const registry = ModelRegistry.create(auth);
-const piModel = resolvePiModel(registry, decision.provider, decision.model.id); // offline, free
+const piModel = resolvePiModel(await piRuntime(), decision.provider, decision.model.id); // offline, free
 
 const money = (n: number) => `$${n.toFixed(2)}`;
 

package/src/run-pm.ts

@@ -5,11 +5,10 @@
 //
 // Live decomposition needs an API key (PM routes to an OpenAI model by default).
 
-import { AuthStorage, ModelRegistry } from "@earendil-works/pi-coding-agent";
 import type { AgentSessionEvent } from "@earendil-works/pi-coding-agent";
 import { DEFAULT_POLICY, routeBacklog } from "./router.js";
 import { findEntry } from "./registry.js";
-import { resolvePiModel } from "./executor.js";
+import { piRuntime, resolvePiModel } from "./executor.js"
 import { decomposeIdea, pmSystemPrompt } from "./pm.js";
 
 const args = process.argv.slice(2);
@@ -26,13 +25,12 @@ const idea = args.filter((a) => !consumed.has(a)).join(" ").trim() ||
 const backend = "api" as const; // web-login backend not built yet
 const money = (n: number) => `$${n.toFixed(2)}`;
 
-const auth = AuthStorage.create();
-const registry = ModelRegistry.create(auth);
+const runtime = await piRuntime();
 const { entry } = findEntry("plan", "mid");
 const pick = pmOverride
   ? { provider: pmOverride.split("/")[0] as typeof entry.byBackend[typeof backend]["provider"], model: pmOverride.split("/").slice(1).join("/") }
   : entry.byBackend[backend];
-const pm = resolvePiModel(registry, pick.provider, pick.model); // offline
+const pm = resolvePiModel(runtime, pick.provider, pick.model); // offline
 
 console.log(`\n  Projectinator — Phase 3 PM decomposer   [${live ? "LIVE" : "DRY"}]\n`);
 console.log(`  Idea:    ${idea}`);

package/src/tui.tsx

@@ -8,9 +8,13 @@ import { applyKeysToEnv } from "./tui/config.js";
 import { listProjects } from "./tui/engine.js";
 import { sessionCost } from "./session-cost.js";
 import { closeWebSessions } from "./web/session.js";
+import { warmBuiltinOpenRouterModels } from "./openrouter.js";
 
 // Load any keys saved via Settings into the environment so Pi picks them up.
 applyKeysToEnv();
+// Pi's catalog is async; fill the OpenRouter pricing memo in the background so the
+// sync cost estimator can price OpenRouter slugs by the time a plan is shown.
+void warmBuiltinOpenRouterModels();
 
 const AMBER = "\x1b[38;2;224;167;45m";
 const DIM = "\x1b[2m";