projectinator 0.3.1 → 0.4.0

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 };
-}

package/src/research.ts

@@ -1,123 +0,0 @@
-// Auto-feed the Scout — turn a research report into structured findings.
-//
-// The deep-research harness (or any benchmark write-up) produces prose. This module
-// extracts it into clean Finding[] the Scout can consume: a model reads the report and
-// calls a forced typebox tool. That's reliable because it's reformatting text we give
-// it, not recalling facts from memory.
-//
-// Flow:  research report (text)  ->  extractFindings()  ->  findings.json  ->  scout --from
-
-import {
-  createAgentSession,
-  defineTool,
-  type AgentSession,
-} from "@earendil-works/pi-coding-agent";
-import { Type, type Static } from "typebox";
-import type { Provider } from "./types.js";
-import type { Finding } from "./scout.js";
-import { piRuntime, resolvePiModel } from "./executor.js"
-import { MODELS } from "./models.js";
-
-const FindingsSchema = Type.Object({
-  findings: Type.Array(
-    Type.Object({
-      capability: Type.Union([
-        Type.Literal("plan"), Type.Literal("design"), Type.Literal("code"),
-        Type.Literal("test"), Type.Literal("ops"),
-      ]),
-      tier: Type.Union([Type.Literal("fast"), Type.Literal("mid"), Type.Literal("high")]),
-      backend: Type.Union([Type.Literal("web"), Type.Literal("api")]),
-      provider: Type.Union([Type.Literal("anthropic"), Type.Literal("openai"), Type.Literal("google")]),
-      model: Type.String({ description: "exact model id, e.g. claude-opus-4-8" }),
-      evidence: Type.String({ description: "one-line benchmark/source justification" }),
-    }),
-  ),
-});
-type FindingsRaw = Static<typeof FindingsSchema>;
-
-export interface ValidationIssue {
-  index: number;
-  model: string;
-  problem: string;
-}
-
-/** Pure check: does each finding reference a real model with a matching provider? */
-export function validateFindings(findings: Finding[]): { ok: boolean; issues: ValidationIssue[] } {
-  const issues: ValidationIssue[] = [];
-  findings.forEach((f, index) => {
-    const m = MODELS[f.model];
-    if (!m) {
-      issues.push({ index, model: f.model, problem: "model not in models.ts" });
-    } else if (m.provider !== f.provider) {
-      issues.push({ index, model: f.model, problem: `provider mismatch (models.ts says ${m.provider})` });
-    }
-  });
-  return { ok: issues.length === 0, issues };
-}
-
-function buildFindingsTool() {
-  let captured: Finding[] | undefined;
-  const tool = defineTool({
-    name: "submit_findings",
-    label: "Submit Findings",
-    description: "Submit the extracted model-per-role findings.",
-    parameters: FindingsSchema,
-    execute: async (_id, params: FindingsRaw) => {
-      captured = params.findings as Finding[];
-      return { content: [{ type: "text", text: `Extracted ${params.findings.length} findings.` }], details: {} };
-    },
-  });
-  return { tool, get: () => captured };
-}
-
-export function extractionPrompt(report: string): string {
-  return [
-    "You are a data extractor. From the research report below, extract the single best",
-    "model for each role the report covers, as structured findings.",
-    "",
-    "For each finding set: capability (plan|design|code|test|ops), tier (fast|mid|high),",
-    "backend (usually 'api' for benchmark-driven picks), provider, the EXACT model id,",
-    "and a one-line evidence note. Only include roles the report actually supports.",
-    "Do not invent models. When done, call submit_findings once.",
-    "",
-    "--- REPORT ---",
-    report,
-  ].join("\n");
-}
-
-export interface ExtractOptions {
-  model: { provider: Provider; model: string };
-  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 runtime = await piRuntime();
-  const model = resolvePiModel(runtime, opts.model.provider, opts.model.model);
-
-  const { tool, get } = buildFindingsTool();
-  const { session } = await createAgentSession({
-    model, modelRuntime: runtime,
-    thinkingLevel: "low",
-    noTools: "all",
-    customTools: [tool],
-    tools: ["submit_findings"],
-  });
-
-  const unsub = opts.onEvent ? session.subscribe(opts.onEvent) : undefined;
-  try {
-    await session.prompt(extractionPrompt(report));
-    let out = get();
-    if (!out) {
-      await session.followUp("Call submit_findings now.");
-      out = get();
-    }
-    if (!out) throw new Error("Extractor did not call submit_findings.");
-    return out;
-  } finally {
-    unsub?.();
-    session.dispose();
-  }
-}
-
-export { FindingsSchema, buildFindingsTool };

package/src/retro.ts

@@ -1,99 +0,0 @@
-// Build retro — a free, data-driven summary of a finished build, computed from
-// build-state: what passed, what the tester flagged, cost per epic and per
-// model, retries, and the priciest tasks. No model call.
-
-import { completedIds, type BuildState } from "./build-state.js";
-import type { Bug, Difficulty } from "./types.js";
-import { baselineTokens } from "./estimate.js";
-import { estimateCost } from "./cost.js";
-import { getModel } from "./models.js";
-
-export interface RetroReport {
-  idea: string;
-  status: BuildState["status"];
-  totalCost: number;
-  estCost: number; // baseline predicted cost for the tasks that ran
-  taskCount: number;
-  doneCount: number;
-  tests: { passed: number; failed: number };
-  bugs: Bug[]; // everything the tester flagged during the build
-  retries: { taskId: string; title: string; rounds: number }[];
-  byEpic: { epic: string; cost: number; tasks: number }[];
-  byModel: { model: string; cost: number; tasks: number }[];
-  topCost: { taskId: string; title: string; cost: number }[];
-}
-
-const round2 = (n: number) => Math.round(n * 100) / 100;
-
-export function computeRetro(state: BuildState): RetroReport {
-  const titleById = new Map(state.tasks.map((t) => [t.id, t.title]));
-  const epicById = new Map(state.tasks.map((t) => [t.id, t.epic || "General"]));
-  const diffById = new Map(state.tasks.map((t) => [t.id, t.difficulty]));
-  const outcomes = state.outcomes;
-  const doneIds = completedIds(state);
-
-  // Baseline-predicted cost for each run: static token budget × the model that ran it.
-  let estCost = 0;
-  for (const o of outcomes) {
-    const diff = (diffById.get(o.taskId) ?? "medium") as Difficulty;
-    try {
-      const model = getModel(o.modelId);
-      const tokens = baselineTokens(o.capability, diff);
-      estCost += estimateCost({ input: tokens.input, output: tokens.output, cachedInputFraction: 0.55 }, model);
-    } catch {
-      /* unknown model — skip its estimate */
-    }
-  }
-
-  // Tests: judge each test task by its LAST outcome (final state after retries).
-  const lastTestByTask = new Map<string, (typeof outcomes)[number]>();
-  for (const o of outcomes) if (o.capability === "test") lastTestByTask.set(o.taskId, o);
-  let passed = 0;
-  let failed = 0;
-  for (const o of lastTestByTask.values()) {
-    if (o.verdict?.passed) passed++;
-    else if (o.verdict) failed++;
-  }
-
-  // Bugs the tester flagged anywhere during the build (signal, even if later fixed).
-  const bugs: Bug[] = [];
-  for (const o of outcomes) if (o.verdict?.bugs) bugs.push(...o.verdict.bugs);
-
-  // Retries: any outcome past round 0 means a Tester→Developer rebuild happened.
-  const roundsByTask = new Map<string, number>();
-  for (const o of outcomes) if (o.round > 0) roundsByTask.set(o.taskId, Math.max(roundsByTask.get(o.taskId) ?? 0, o.round));
-  const retries = [...roundsByTask.entries()].map(([taskId, rounds]) => ({ taskId, title: titleById.get(taskId) ?? taskId, rounds }));
-
-  // Cost per epic + per model.
-  const epicCost = new Map<string, { cost: number; tasks: number }>();
-  const modelCost = new Map<string, { cost: number; tasks: number }>();
-  for (const o of outcomes) {
-    const e = epicById.get(o.taskId) ?? "General";
-    const ec = epicCost.get(e) ?? { cost: 0, tasks: 0 };
-    epicCost.set(e, { cost: ec.cost + o.cost, tasks: ec.tasks + 1 });
-    const mc = modelCost.get(o.modelId) ?? { cost: 0, tasks: 0 };
-    modelCost.set(o.modelId, { cost: mc.cost + o.cost, tasks: mc.tasks + 1 });
-  }
-  const byEpic = [...epicCost.entries()].map(([epic, v]) => ({ epic, cost: round2(v.cost), tasks: v.tasks })).sort((a, b) => b.cost - a.cost);
-  const byModel = [...modelCost.entries()].map(([model, v]) => ({ model, cost: round2(v.cost), tasks: v.tasks })).sort((a, b) => b.cost - a.cost);
-
-  const topCost = [...outcomes]
-    .sort((a, b) => b.cost - a.cost)
-    .slice(0, 3)
-    .map((o) => ({ taskId: o.taskId, title: titleById.get(o.taskId) ?? o.taskId, cost: round2(o.cost) }));
-
-  return {
-    idea: state.idea ?? state.id,
-    status: state.status,
-    totalCost: round2(state.totalCost),
-    estCost: round2(estCost),
-    taskCount: state.tasks.length,
-    doneCount: doneIds.size,
-    tests: { passed, failed },
-    bugs,
-    retries,
-    byEpic,
-    byModel,
-    topCost,
-  };
-}