projectinator 0.3.0 → 0.4.0

package/src/pm.ts

@@ -1,302 +0,0 @@
-// Phase 3 — the PM / Decomposer.
-// Turns a one-line idea into a tagged backlog (epic -> story -> task).
-//
-// Structured output: Pi has none built in, so we force it. The PM model is given
-// exactly ONE tool — submit_backlog, whose typebox schema IS the backlog shape —
-// and must call it. That's far more reliable than parsing JSON out of prose.
-//
-// Token estimates are NOT asked of the model (it's bad at them); we fill them from
-// code buckets after decomposition. The PM only decomposes + tags.
-
-import {
-  createAgentSession,
-  defineTool,
-  type AgentSession,
-} from "@earendil-works/pi-coding-agent";
-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 { piRuntime, resolvePiModel } from "./executor.js";
-import { addSessionCost } from "./session-cost.js";
-
-// ---- typebox schema = the backlog contract ----
-// DELIBERATELY PERMISSIVE. A forced-tool call fails INVISIBLY if the args don't
-// validate (Pi rejects it, our capture never fires). So: flat list, only id/title/
-// capability/difficulty required, capability/difficulty as free strings (coerced in
-// code), extra fields allowed. We validate/clean afterwards instead of at the gate.
-const TaskSchema = Type.Object(
-  {
-    id: Type.String({ description: "Unique task id, e.g. T-01" }),
-    title: Type.String({ description: "One concrete, buildable unit of work" }),
-    capability: Type.String({ description: "one of: plan | design | code | review | test | ops" }),
-    difficulty: Type.String({ description: "one of: trivial | low | medium | high" }),
-    dependsOn: Type.Optional(Type.Array(Type.String(), { description: "task ids that must finish first" })),
-    epic: Type.Optional(Type.String({ description: "optional grouping label" })),
-    story: Type.Optional(Type.String({ description: "optional grouping label" })),
-  },
-  { additionalProperties: true },
-);
-const BacklogSchema = Type.Object({ tasks: Type.Array(TaskSchema) }, { additionalProperties: true });
-
-const CAPS = new Set<Capability>(["plan", "design", "code", "review", "test", "ops"]);
-const DIFFS = new Set<Difficulty>(["trivial", "low", "medium", "high"]);
-function coerceCap(s: string): Capability {
-  const v = s?.toLowerCase().trim() as Capability;
-  return CAPS.has(v) ? v : "code";
-}
-function coerceDiff(s: string): Difficulty {
-  const v = s?.toLowerCase().trim() as Difficulty;
-  return DIFFS.has(v) ? v : "medium";
-}
-
-export type Backlog = Static<typeof BacklogSchema>;
-export type BacklogTask = Static<typeof TaskSchema>;
-
-// ---- the capture tool ----
-export function buildBacklogTool() {
-  let captured: Backlog | undefined;
-  const tool = defineTool({
-    name: "submit_backlog",
-    label: "Submit Backlog",
-    description: "Submit the finished backlog as a flat list of tasks. Call this exactly once.",
-    parameters: BacklogSchema,
-    execute: async (_id, params) => {
-      captured = params as Backlog;
-      return { content: [{ type: "text", text: `Backlog received: ${params.tasks.length} tasks.` }], details: {} };
-    },
-  });
-  return { tool, get: () => captured };
-}
-
-export type Scope = "full" | "change";
-
-export function pmSystemPrompt(scope: Scope = "full"): string {
-  const sizing =
-    scope === "change"
-      ? [
-          "This is a CHANGE to an EXISTING project whose files are already on disk.",
-          "Produce the FEWEST tasks that accomplish the change — usually 1 code task plus 1",
-          "`review` task that dependsOn it (cheap read-only wiring check), plus 1 test task",
-          "(dependsOn the review) only if the change is risky. Do NOT re-plan the whole project,",
-          "do NOT add design/setup/deploy tasks. One small tweak = code + review.",
-        ]
-      : [
-          "Scale the number of tasks to the request. A tiny page = a few tasks; a full app = many.",
-          "Group tasks under EPICS (big features/areas of the product). Set every task's `epic`",
-          "field to its epic name, e.g. 'Hero section', 'Contact form', 'Deployment'. Aim for",
-          "2-5 tasks per epic. Do not pad: never split one obvious unit of work into multiple",
-          "tasks. Skip design/plan/ops tasks when the request clearly doesn't need them.",
-          "For a MULTI-FILE app: name the target file(s) in each code task's title (e.g. 'Build",
-          "src/components/Header.jsx') and keep file names CONSISTENT across tasks — decide one",
-          "structure and reuse it. When several files must agree, add ONE early design task that",
-          "defines the file tree, and have the code tasks depend on it.",
-          "After EVERY code task add one `review` task that dependsOn that code task (a cheap",
-          "read-only wiring check). The test task must dependsOn the review task(s), not the code",
-          "task(s) directly. Order: design -> code -> review -> test.",
-        ];
-  return [
-    "You are the PROJECT MANAGER on an autonomous software team.",
-    "Break the user's request into a flat list of tasks.",
-    ...sizing,
-    "",
-    "Each TASK must be:",
-    "- atomic: one model can complete it in one focused turn",
-    "- tagged with a capability: plan | design | code | review | test | ops",
-    "- tagged with a difficulty: trivial | low | medium | high (how hard the thinking is)",
-    "Optional per task: dependsOn (ids that must finish first, e.g. code depends on design),",
-    "and epic/story labels for grouping. Use ids like T-01, unique across the list.",
-    "Order matters: a design task should precede the code task that implements it; tests come after code.",
-    "",
-    "CRITICAL: You have exactly ONE tool — submit_backlog — and you MUST call it with a",
-    "`tasks` array. Never reply with prose. Never ask the user a question. If anything is",
-    "unclear, make a reasonable assumption (e.g. the main file is index.html) and submit.",
-    "Always produce at least one task. Call submit_backlog exactly once.",
-  ].join("\n");
-}
-
-// ---- pure post-processing (testable, no model) ----
-
-export interface NormalizeResult {
-  backlog: Backlog;
-  diagnostics: string[];
-}
-
-/** Clean a raw backlog: drop duplicate task ids, strip dangling dependsOn refs. */
-export function normalizeBacklog(raw: Backlog): NormalizeResult {
-  const diagnostics: string[] = [];
-  const seen = new Set<string>();
-  const allIds = new Set(raw.tasks.map((t) => t.id));
-
-  const tasks = raw.tasks
-    .filter((t) => {
-      if (seen.has(t.id)) {
-        diagnostics.push(`dropped duplicate task id ${t.id}`);
-        return false;
-      }
-      seen.add(t.id);
-      return true;
-    })
-    .map((t) => {
-      const deps = (t.dependsOn ?? []).filter((d) => {
-        if (!allIds.has(d)) {
-          diagnostics.push(`task ${t.id}: dropped dangling dependsOn ${d}`);
-          return false;
-        }
-        return true;
-      });
-      return { ...t, dependsOn: deps };
-    });
-  return { backlog: { tasks }, diagnostics };
-}
-
-/** Flatten a backlog to routable Tasks, coercing loose tags + filling token estimates. */
-export function flattenBacklog(backlog: Backlog): Task[] {
-  return backlog.tasks.map((t) => {
-    const capability = coerceCap(t.capability);
-    const difficulty = coerceDiff(t.difficulty);
-    return {
-      id: t.id,
-      title: t.title,
-      capability,
-      difficulty,
-      dependsOn: t.dependsOn ?? [],
-      epic: t.epic,
-      story: t.story,
-      estTokens: estimateTokens(capability, difficulty),
-    };
-  });
-}
-
-// ---- text fallback: parse a task list out of prose if the tool wasn't used ----
-
-function lastAssistantText(session: AgentSession): string {
-  const msgs = session.messages as Array<{ role?: string; content?: unknown }>;
-  for (let i = msgs.length - 1; i >= 0; i--) {
-    const m = msgs[i];
-    if (m?.role !== "assistant") continue;
-    const c = m.content;
-    if (typeof c === "string") return c;
-    if (Array.isArray(c)) {
-      return c
-        .map((p: unknown) => (typeof p === "string" ? p : p && typeof p === "object" && "text" in p ? String((p as { text: unknown }).text) : ""))
-        .join("");
-    }
-  }
-  return "";
-}
-
-/** Best-effort: pull a { tasks: [...] } (or a bare [...]) out of a model's text reply. */
-export function extractBacklogFromText(text: string): Backlog | undefined {
-  const tryParse = (s: string): Backlog | undefined => {
-    try {
-      const p = JSON.parse(s) as unknown;
-      if (Array.isArray(p)) return { tasks: p as Backlog["tasks"] };
-      if (p && typeof p === "object" && Array.isArray((p as { tasks?: unknown }).tasks)) return p as Backlog;
-    } catch {
-      /* not json */
-    }
-    return undefined;
-  };
-  const fence = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
-  const objMatch = text.match(/\{[\s\S]*"tasks"[\s\S]*\}/);
-  const arrMatch = text.match(/\[[\s\S]*\]/);
-  for (const c of [fence?.[1], objMatch?.[0], arrMatch?.[0]]) {
-    if (!c) continue;
-    const r = tryParse(c.trim());
-    if (r?.tasks?.length) return r;
-  }
-  return undefined;
-}
-
-// ---- live decomposition (calls the PM model, spends money) ----
-
-export interface DecomposeOptions {
-  backend: Backend;
-  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). */
-  modelOverride?: { provider: Provider; model: string };
-  /** "change" = minimal tasks against an existing project; "full" = a fresh build. */
-  scope?: Scope;
-  /** Summary of the existing project (files + contents) so the PM plans with real context. */
-  projectContext?: string;
-  /** Council-approved epics: organize ALL tasks under exactly these. */
-  epics?: { name: string; rationale: string }[];
-}
-
-export interface DecomposeResult {
-  provider: Provider;
-  modelId: string;
-  backlog: Backlog;
-  tasks: Task[];
-  diagnostics: string[];
-}
-
-export async function decomposeIdea(idea: string, opts: DecomposeOptions): Promise<DecomposeResult> {
-  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(runtime, pick.provider, pick.model);
-
-  const { tool, get } = buildBacklogTool();
-  const { session } = await createAgentSession({
-    model,
-    modelRuntime: runtime,
-    thinkingLevel: opts.thinkingLevel ?? "medium",
-    noTools: "all",
-    customTools: [tool],
-    tools: ["submit_backlog"],
-  });
-
-  const unsub = opts.onEvent ? session.subscribe(opts.onEvent) : undefined;
-  try {
-    const ctx = opts.projectContext ? `\n\n--- EXISTING PROJECT (plan the change against this) ---\n${opts.projectContext}` : "";
-    const epicsBlock = opts.epics?.length
-      ? `\n\n--- APPROVED EPICS (organize ALL tasks under EXACTLY these; set each task's epic field to one of these names) ---\n${opts.epics.map((e) => `- ${e.name}: ${e.rationale}`).join("\n")}`
-      : "";
-    await session.prompt(`${pmSystemPrompt(opts.scope ?? "full")}${ctx}${epicsBlock}\n\n--- REQUEST ---\n${idea}`);
-    let raw = get();
-    // Nudge up to 3 times if the tool wasn't called (or its args failed validation).
-    for (let i = 0; i < 3 && !raw; i++) {
-      await session.prompt(
-        "You did not call submit_backlog successfully. Call submit_backlog NOW with a `tasks` " +
-          "array as the tool arguments. Do not write prose. Make reasonable assumptions if needed.",
-      );
-      raw = get();
-    }
-    // Last resort: the model may have printed the backlog as JSON text — parse it.
-    if (!raw) raw = extractBacklogFromText(lastAssistantText(session));
-    if (!raw || !raw.tasks?.length) {
-      const stats = session.getSessionStats();
-      if (stats.tokens.total === 0) {
-        // The provider call returned nothing — bad/inaccessible key, OR (very common)
-        // the account has no credit/balance so the API rejects the request.
-        throw new Error(
-          `The ${pick.provider} model returned nothing (0 tokens). Likely causes: the API key is invalid, ` +
-            `the account has no credit/balance, or the key lacks access to ${pick.model}. Add credit or set a ` +
-            `working key, or pick a different provider in Settings → Preferred provider.`,
-        );
-      }
-      const said = lastAssistantText(session).slice(0, 200).replace(/\s+/g, " ").trim();
-      throw new Error(
-        `The planner didn't return a task list.${said ? ` It said: "${said}…"` : ""} Try rephrasing the request.`,
-      );
-    }
-
-    const { backlog, diagnostics } = normalizeBacklog(raw);
-    return {
-      provider: pick.provider,
-      modelId: pick.model,
-      backlog,
-      tasks: flattenBacklog(backlog),
-      diagnostics,
-    };
-  } finally {
-    addSessionCost(session.getSessionStats().cost);
-    unsub?.();
-    session.dispose();
-  }
-}

package/src/preview.ts

@@ -1,206 +0,0 @@
-// Static-serving + headless render check for built web apps.
-//
-// Two uses:
-//  - renderCheck(): load the built app in a headless browser, collect JS/console
-//    errors + the rendered text, so the TESTER role verifies the app actually
-//    RUNS (not just that the code reads correctly).
-//  - startStaticServer(): a tiny local file server, reused by live preview.
-//
-// A real http server (not file://) so ES modules, fetch of local assets, and
-// relative paths all resolve the way they will in production.
-
-import { createServer, type Server } from "node:http";
-import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import { extname, join, normalize } from "node:path";
-import { pathToFileURL } from "node:url";
-
-const TYPES: Record<string, string> = {
-  ".html": "text/html", ".htm": "text/html", ".css": "text/css",
-  ".js": "text/javascript", ".mjs": "text/javascript", ".json": "application/json",
-  ".svg": "image/svg+xml", ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg",
-  ".gif": "image/gif", ".webp": "image/webp", ".ico": "image/x-icon",
-  ".woff": "font/woff", ".woff2": "font/woff2", ".ttf": "font/ttf",
-};
-
-export interface StaticServer {
-  url: string; // http://127.0.0.1:<port>
-  port: number;
-  close: () => Promise<void>;
-}
-
-// Injected into served HTML when liveReload is on: polls /__mtime and reloads
-// when any file in the directory changes (so the page refreshes as a build runs).
-const RELOAD_SNIPPET = `<script>(function(){let last=null;setInterval(async function(){try{var r=await fetch('/__mtime');var t=await r.text();if(last!==null&&t!==last){location.reload();}last=t;}catch(e){}},1000);})();</script>`;
-
-/** Newest mtime (ms) across all files in dir — a cheap change signal. */
-function maxMtime(dir: string): number {
-  let max = 0;
-  const walk = (d: string) => {
-    let entries: string[];
-    try { entries = readdirSync(d); } catch { return; }
-    for (const name of entries) {
-      if (name.startsWith(".")) continue;
-      const full = join(d, name);
-      let st;
-      try { st = statSync(full); } catch { continue; }
-      if (st.isDirectory()) walk(full);
-      else if (st.mtimeMs > max) max = st.mtimeMs;
-    }
-  };
-  walk(dir);
-  return max;
-}
-
-/** Serve `dir` on a random loopback port. Path traversal is blocked.
- *  opts.liveReload injects a poller that reloads the page when files change. */
-export function startStaticServer(dir: string, opts: { liveReload?: boolean } = {}): Promise<StaticServer> {
-  return new Promise((resolve, reject) => {
-    const server: Server = createServer((req, res) => {
-      try {
-        const reqPath = decodeURIComponent((req.url ?? "/").split("?")[0] ?? "/");
-        if (opts.liveReload && reqPath === "/__mtime") {
-          res.writeHead(200, { "Content-Type": "text/plain" });
-          res.end(String(maxMtime(dir)));
-          return;
-        }
-        // Resolve within dir; reject anything that escapes it.
-        const rel = normalize(reqPath).replace(/^(\.\.[/\\])+/, "");
-        let filePath = join(dir, rel);
-        if (!filePath.startsWith(dir)) { res.writeHead(403).end("forbidden"); return; }
-        let st;
-        try { st = statSync(filePath); } catch { res.writeHead(404).end("not found"); return; }
-        if (st.isDirectory()) filePath = join(filePath, "index.html");
-        const type = TYPES[extname(filePath).toLowerCase()] ?? "application/octet-stream";
-        if (opts.liveReload && type === "text/html") {
-          let html = readFileSync(filePath, "utf8");
-          html = html.includes("</body>") ? html.replace("</body>", `${RELOAD_SNIPPET}</body>`) : html + RELOAD_SNIPPET;
-          res.writeHead(200, { "Content-Type": type });
-          res.end(html);
-          return;
-        }
-        res.writeHead(200, { "Content-Type": type });
-        res.end(readFileSync(filePath));
-      } catch {
-        res.writeHead(500).end("error");
-      }
-    });
-    server.on("error", reject);
-    server.listen(0, "127.0.0.1", () => {
-      const addr = server.address();
-      const port = typeof addr === "object" && addr ? addr.port : 0;
-      resolve({
-        url: `http://127.0.0.1:${port}`,
-        port,
-        close: () => new Promise<void>((r) => server.close(() => r())),
-      });
-    });
-  });
-}
-
-export interface RenderReport {
-  ok: boolean; // rendered over http with no JS/console errors
-  file: string;
-  title: string;
-  text: string; // rendered body text (trimmed)
-  errors: string[]; // console errors + uncaught page errors (http)
-  screenshotPath?: string;
-  // The way a non-technical user opens the folder: double-click → file://.
-  // ES modules + relative imports (and fetch of local assets) die here even
-  // though they work over a server — so we render BOTH and compare.
-  fileOk: boolean; // rendered over file:// with no errors AND real content
-  fileText: string; // rendered body text via file://
-  fileErrors: string[]; // errors seen via file://
-  // True when the app clearly works over a server but is broken on double-click
-  // (renders content over http, but blank/erroring over file://). The classic
-  // "AI shipped an app that only runs behind a server the user won't start".
-  doubleClickBroken: boolean;
-}
-
-interface OneRender { title: string; text: string; errors: string[]; }
-
-/** Render a single URL and capture title, visible text, and errors. */
-async function renderOne(
-  browser: import("playwright").Browser,
-  url: string,
-  opts: { screenshotPath?: string; timeoutMs?: number } = {},
-): Promise<OneRender> {
-  const errors: string[] = [];
-  const page = await browser.newPage();
-  page.on("console", (m) => { if (m.type() === "error") errors.push(`console.error: ${m.text()}`); });
-  page.on("pageerror", (e) => errors.push(`uncaught: ${e.message}`));
-  page.on("requestfailed", (r) => {
-    const u = r.url();
-    if (!u.endsWith("/favicon.ico")) errors.push(`failed request: ${u} (${r.failure()?.errorText ?? "?"})`);
-  });
-  try {
-    await page.goto(url, { waitUntil: "networkidle", timeout: opts.timeoutMs ?? 15_000 });
-    const title = await page.title().catch(() => "");
-    const text = (await page.locator("body").innerText().catch(() => "")).trim().slice(0, 800);
-    if (opts.screenshotPath) {
-      try { await page.screenshot({ path: opts.screenshotPath, fullPage: true }); } catch { /* non-fatal */ }
-    }
-    return { title, text, errors };
-  } finally {
-    await page.close();
-  }
-}
-
-/** Whether the tester can actually run apps: Playwright's Chromium is installed.
- *  No launch, just the executable lookup — cheap enough to call per task.
- *  Dynamic import on purpose (same as renderCheck): playwright is optional. */
-export async function chromiumAvailable(): Promise<boolean> {
-  try {
-    const { chromium } = await import("playwright");
-    return existsSync(chromium.executablePath());
-  } catch {
-    return false;
-  }
-}
-
-export const CHROMIUM_INSTALL_HINT = "run `npx playwright install chromium` to enable real test execution";
-
-/** Load a built page in headless Chromium and report what actually happened —
- *  over http (production-like) AND over file:// (how a user double-clicks it). */
-export async function renderCheck(
-  dir: string,
-  file = "index.html",
-  opts: { screenshotPath?: string; timeoutMs?: number } = {},
-): Promise<RenderReport> {
-  const { chromium } = await import("playwright");
-  const server = await startStaticServer(dir);
-  let browser;
-  try {
-    browser = await chromium.launch({ headless: true });
-  } catch (e) {
-    await server.close(); // don't leak the port if Chromium can't launch
-    throw e;
-  }
-  try {
-    const http = await renderOne(browser, `${server.url}/${file}`, opts);
-    // file:// gets no screenshot — the http render is the one we keep.
-    const fileUrl = pathToFileURL(join(dir, file)).href;
-    const fileR = await renderOne(browser, fileUrl, { timeoutMs: opts.timeoutMs });
-
-    const ok = http.errors.length === 0;
-    const fileHasContent = fileR.text.length > 0;
-    const fileOk = fileR.errors.length === 0 && fileHasContent;
-    // Broken-on-double-click = works served, but blank or erroring as a file.
-    const doubleClickBroken = ok && http.text.length > 0 && !fileOk;
-
-    return {
-      ok,
-      file,
-      title: http.title,
-      text: http.text,
-      errors: http.errors,
-      screenshotPath: opts.screenshotPath,
-      fileOk,
-      fileText: fileR.text,
-      fileErrors: fileR.errors,
-      doubleClickBroken,
-    };
-  } finally {
-    await browser.close();
-    await server.close();
-  }
-}

package/src/registry-store.ts

@@ -1,41 +0,0 @@
-// Registry persistence — makes the "swappable brain" actually swappable at runtime.
-// The in-code REGISTRY is the seed. An optional registry.overrides.json (written by
-// the Scout) merges on top by (capability, tier) key. New frontier model next month
-// => Scout edits the JSON => every route updates. No code change.
-
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import type { RegistryEntry } from "./types.js";
-import { REGISTRY } from "./registry.js";
-
-export const OVERRIDES_FILENAME = "registry.overrides.json";
-
-const key = (e: Pick<RegistryEntry, "capability" | "tier">) => `${e.capability}/${e.tier}`;
-
-/** Merge overrides onto the seed registry, replacing entries by (capability, tier). */
-export function mergeRegistry(seed: RegistryEntry[], overrides: RegistryEntry[]): RegistryEntry[] {
-  const map = new Map(seed.map((e) => [key(e), e]));
-  for (const o of overrides) map.set(key(o), o);
-  return [...map.values()];
-}
-
-/** Load the effective registry: seed + overrides file if present. */
-export function loadRegistry(overridesPath: string, seed: RegistryEntry[] = REGISTRY): RegistryEntry[] {
-  if (!existsSync(overridesPath)) return seed;
-  try {
-    const parsed = JSON.parse(readFileSync(overridesPath, "utf-8")) as { entries?: RegistryEntry[] };
-    if (!parsed.entries?.length) return seed;
-    return mergeRegistry(seed, parsed.entries);
-  } catch (e) {
-    throw new Error(`Bad ${OVERRIDES_FILENAME}: ${e instanceof Error ? e.message : e}`);
-  }
-}
-
-/** Persist override entries (the full set the Scout wants applied). */
-export function saveOverrides(entries: RegistryEntry[], overridesPath: string): void {
-  writeFileSync(overridesPath, JSON.stringify({ updated: nowStamp(), entries }, null, 2) + "\n");
-}
-
-// Deterministic-ish stamp without Date.now (kept simple; callers may override).
-function nowStamp(): string {
-  return "scout";
-}

package/src/registry.ts

@@ -1,132 +0,0 @@
-// The Model Registry — the swappable brain.
-// Maps capability + tier -> model, per backend. Change an entry, re-route everything.
-// Seeded from the September-2026 verified roster. This is the ONE file the scout edits.
-
-import type { Capability, RegistryEntry, Tier } from "./types.js";
-
-const TIER_ORDER: Tier[] = ["fast", "mid", "high"];
-
-// Backend intent:
-//   web  = user's free web subscription -> use the strongest brand model.
-//   api  = metered -> use the cost-appropriate model; ask the user when it matters.
-export const REGISTRY: RegistryEntry[] = [
-  // --- PLAN (PM / decomposition, long-horizon planning) ---
-  {
-    capability: "plan",
-    tier: "mid",
-    byBackend: {
-      web: { provider: "openai", model: "gpt-5.6-sol" },
-      api: { provider: "openai", model: "gpt-5.6-terra" },
-    },
-    evidence: "OpenAI leads DeepPlanning long-horizon planning; Terra repriced to $2/$12 (Sept 2026)",
-    updated: "2026-09-15",
-  },
-
-  // --- DESIGN (UI/UX) ---
-  {
-    capability: "design",
-    tier: "high",
-    byBackend: {
-      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; Sol repriced to $4/$20 (Sept 2026)",
-    updated: "2026-09-15",
-  },
-
-  // --- CODE (development) ---
-  {
-    capability: "code",
-    tier: "high",
-    byBackend: {
-      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 — 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-5" },
-      api: { provider: "anthropic", model: "claude-sonnet-5" },
-    },
-    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-5" },
-      api: { provider: "google", model: "gemini-3.8-flash" },
-    },
-    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) ---
-  {
-    capability: "review",
-    tier: "fast",
-    byBackend: {
-      web: { provider: "google", model: "gemini-3.8-flash" },
-      api: { provider: "google", model: "gemini-3.8-flash" },
-    },
-    evidence: "Read-only wiring check; strongest cheap model, same pick as test",
-    updated: "2026-09-15",
-  },
-
-  // --- TEST (QA / review, high volume -> cheap) ---
-  {
-    capability: "test",
-    tier: "fast",
-    byBackend: {
-      web: { provider: "google", model: "gemini-3.1-pro-preview" },
-      api: { provider: "google", model: "gemini-3.8-flash" },
-    },
-    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) ---
-  {
-    capability: "ops",
-    tier: "high",
-    byBackend: {
-      web: { provider: "openai", model: "gpt-5.6-sol" },
-      api: { provider: "openai", model: "gpt-5.6-sol" },
-    },
-    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",
-  },
-];
-
-/** Find the best registry entry for a capability at (or near) a tier.
- *  Exact tier wins; otherwise fall back to the nearest available tier. */
-export function findEntry(
-  capability: Capability,
-  tier: Tier,
-  registry: RegistryEntry[] = REGISTRY,
-): { entry: RegistryEntry; exactTier: boolean } {
-  const forCap = registry.filter((e) => e.capability === capability);
-  if (forCap.length === 0) {
-    throw new Error(`No registry entry for capability "${capability}".`);
-  }
-
-  const exact = forCap.find((e) => e.tier === tier);
-  if (exact) return { entry: exact, exactTier: true };
-
-  // Nearest tier by distance in TIER_ORDER.
-  const want = TIER_ORDER.indexOf(tier);
-  const nearest = forCap
-    .slice()
-    .sort(
-      (a, b) =>
-        Math.abs(TIER_ORDER.indexOf(a.tier) - want) - Math.abs(TIER_ORDER.indexOf(b.tier) - want),
-    )[0]!;
-  return { entry: nearest, exactTier: false };
-}