projectinator 0.3.1 → 0.4.0

package/src/bakeoff.ts

@@ -1,214 +0,0 @@
-// Model bake-off — the founding idea: run ONE task across several models, then
-// compare cost, latency, and quality so you can pick the best model per role and
-// feed that back into the routing registry.
-//
-// v1 covers TEXT roles (plan, design, test-reasoning) where the deliverable is
-// text a judge can score. Code bake-off (per-candidate sandbox + real test
-// scoring) is a later step.
-
-import {
-  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 { piRuntime, resolvePiModel } from "./executor.js"
-import { buildRolePrompt } from "./roles.js";
-import { estimateTokens } from "./estimate.js";
-import { addSessionCost } from "./session-cost.js";
-
-export interface Candidate {
-  provider: Provider;
-  model: string;
-}
-
-export interface BakeoffEntry {
-  provider: Provider;
-  model: string;
-  output: string;
-  cost: number;
-  ms: number;
-  outputTokens: number;
-  error?: string;
-}
-
-export interface JudgeScore {
-  model: string;
-  score: number; // 0-10
-  reason: string;
-}
-
-export interface BakeoffResult {
-  task: Task;
-  entries: BakeoffEntry[];
-  scores: JudgeScore[];
-  winner?: string; // "provider/model"
-  judge?: string; // judge model id
-}
-
-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("")
-        .trim();
-    }
-  }
-  return "";
-}
-
-const id = (c: Candidate) => `${c.provider}/${c.model}`;
-
-/** Run one candidate on the task, capturing output, cost, and latency. */
-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 runtime = await piRuntime();
-    const model = resolvePiModel(runtime, cand.provider, cand.model);
-    const { session } = await createAgentSession({
-      model,
-      modelRuntime: runtime,
-      thinkingLevel: "medium",
-      noTools: "all",
-    });
-    try {
-      const t0 = Date.now();
-      await session.prompt(buildRolePrompt(task, ""));
-      const ms = Date.now() - t0;
-      const stats = session.getSessionStats();
-      addSessionCost(stats.cost);
-      const out: BakeoffEntry = {
-        ...base,
-        output: lastAssistantText(session),
-        cost: Math.round(stats.cost * 10000) / 10000,
-        ms,
-        outputTokens: stats.tokens.output,
-      };
-      if (stats.tokens.total === 0) out.error = "returned 0 tokens (invalid key, no credit/balance, or no model access)";
-      return out;
-    } finally {
-      session.dispose(); // dispose even when prompt() throws (expected for inaccessible models)
-    }
-  } catch (e) {
-    return { ...base, error: e instanceof Error ? e.message : String(e) };
-  }
-}
-
-// ---- judge: score every output on one rubric, forced structured output ----
-
-const JudgeSchema = Type.Object(
-  {
-    scores: Type.Array(
-      Type.Object({
-        option: Type.String({ description: "the option letter, e.g. A" }),
-        score: Type.Number({ description: "0-10 quality for this deliverable" }),
-        reason: Type.String({ description: "one sentence" }),
-      }),
-    ),
-    winner: Type.String({ description: "the option letter of the best output" }),
-  },
-  { additionalProperties: true },
-);
-type JudgeRaw = Static<typeof JudgeSchema>;
-
-function buildJudgeTool() {
-  let captured: JudgeRaw | undefined;
-  const tool = defineTool({
-    name: "submit_scores",
-    label: "Submit Scores",
-    description: "Submit a 0-10 quality score and one-sentence reason for every option, plus the winning option letter.",
-    parameters: JudgeSchema,
-    execute: async (_id, params: JudgeRaw) => {
-      captured = params;
-      return { content: [{ type: "text", text: `Scored ${params.scores.length} options; winner ${params.winner}.` }], details: {} };
-    },
-  });
-  return { tool, get: () => captured };
-}
-
-/** Judge anonymised outputs (A, B, C…) on one rubric for the task's capability. */
-async function judge(task: Task, entries: BakeoffEntry[], judgeCand: Candidate): Promise<{ scores: JudgeScore[]; winner?: string; judgeId: string }> {
-  const scored = entries.filter((e) => !e.error && e.output);
-  if (scored.length < 2) return { scores: [], winner: undefined, judgeId: id(judgeCand) };
-
-  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 runtime = await piRuntime();
-  const model = resolvePiModel(runtime, judgeCand.provider, judgeCand.model);
-  const { tool, get } = buildJudgeTool();
-  const { session } = await createAgentSession({
-    model,
-    modelRuntime: runtime,
-    thinkingLevel: "medium",
-    noTools: "all",
-    customTools: [tool],
-    tools: ["submit_scores"],
-  });
-
-  const prompt = [
-    `You are judging ${scored.length} anonymous attempts at the same ${task.capability} task. Be a strict, fair critic.`,
-    `Task: ${task.title}`,
-    "",
-    `Score each option 0-10 on how well it delivers a high-quality ${task.capability} result (correctness, completeness, clarity, usefulness). Then pick the single best.`,
-    "Call submit_scores exactly once with a score+reason for EVERY option letter and the winner.",
-    "",
-    blocks,
-  ].join("\n");
-
-  try {
-    await session.prompt(prompt);
-    let raw = get();
-    for (let i = 0; i < 2 && !raw; i++) {
-      await session.prompt("Call submit_scores now with a score for every option letter and the winner.");
-      raw = get();
-    }
-    addSessionCost(session.getSessionStats().cost);
-    if (!raw) return { scores: [], winner: undefined, judgeId: id(judgeCand) };
-
-    const byLetter = new Map(letters.map((l, i) => [l, scored[i]!]));
-    const scores: JudgeScore[] = raw.scores
-      .map((s) => {
-        const e = byLetter.get(s.option.trim().toUpperCase().slice(0, 1));
-        return e ? { model: id(e), score: s.score, reason: s.reason } : undefined;
-      })
-      .filter((x): x is JudgeScore => !!x);
-    const winEntry = byLetter.get(String(raw.winner).trim().toUpperCase().slice(0, 1));
-    return { scores, winner: winEntry ? id(winEntry) : undefined, judgeId: id(judgeCand) };
-  } finally {
-    session.dispose();
-  }
-}
-
-export interface BakeoffOptions {
-  /** Model that scores the outputs. Defaults to the first candidate. */
-  judge?: Candidate;
-  onProgress?: (msg: string) => void;
-}
-
-/** Run the full bake-off: every candidate on the task, then judge. */
-export async function runBakeoff(task: Task, candidates: Candidate[], opts: BakeoffOptions = {}): Promise<BakeoffResult> {
-  const log = opts.onProgress ?? (() => {});
-  const entries: BakeoffEntry[] = [];
-  for (const c of candidates) {
-    log(`running ${id(c)}…`);
-    const e = await runCandidate(task, c);
-    log(e.error ? `  ${id(c)}: ERROR ${e.error}` : `  ${id(c)}: $${e.cost.toFixed(4)}  ${(e.ms / 1000).toFixed(1)}s  ${e.outputTokens} tok`);
-    entries.push(e);
-  }
-  const judgeCand = opts.judge ?? candidates[0]!;
-  log(`judging with ${id(judgeCand)}…`);
-  const { scores, winner, judgeId } = await judge(task, entries, judgeCand);
-  return { task, entries, scores, winner, judge: judgeId };
-}
-
-/** Convenience: build a one-off Task for a capability/difficulty from a prompt. */
-export function bakeoffTask(prompt: string, capability: Capability, difficulty: Difficulty = "medium"): Task {
-  return { id: "BAKE", title: prompt, capability, difficulty, dependsOn: [], estTokens: estimateTokens(capability, difficulty) };
-}

package/src/build-state.ts

@@ -1,47 +0,0 @@
-// Build persistence — checkpoint a run so a halt/crash/cancel can resume without
-// re-paying for finished tasks. The orchestrator itself stays fs-free; this module
-// (and run-build) own the disk I/O.
-
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import type { Task, TaskOutcome } from "./types.js";
-
-export interface BuildState {
-  id: string;
-  /** The original idea/request text, for display in the projects list. */
-  idea?: string;
-  /** Workflow used: auto-run, or approval-gated. */
-  mode?: "auto" | "approval";
-  tasks: Task[];
-  /** Full record of every task run, including feedback-loop retries (append-only). */
-  outcomes: TaskOutcome[];
-  totalCost: number;
-  status: "running" | "complete" | "halted";
-  haltReason?: string;
-  /** Per-project budget cap (USD). Overrides the global default when set. */
-  budgetCapUSD?: number;
-  /** Cached AI retro narrative (generated on demand). */
-  retroNarrative?: string;
-}
-
-export function newBuildState(id: string, tasks: Task[], idea?: string, mode?: "auto" | "approval"): BuildState {
-  return { id, idea, mode, tasks, outcomes: [], totalCost: 0, status: "running" };
-}
-
-export function saveState(state: BuildState, path: string): void {
-  writeFileSync(path, JSON.stringify(state, null, 2) + "\n");
-}
-
-export function loadState(path: string): BuildState | undefined {
-  if (!existsSync(path)) return undefined;
-  try {
-    return JSON.parse(readFileSync(path, "utf-8")) as BuildState;
-  } catch (e) {
-    throw new Error(`Bad build state at ${path}: ${e instanceof Error ? e.message : e}`);
-  }
-}
-
-/** Which task ids are already finished (last outcome wins; a failed attempt does not
- *  count). Used to skip on resume. */
-export function completedIds(state: BuildState): Set<string> {
-  return new Set(state.outcomes.filter((o) => !o.error).map((o) => o.taskId));
-}

package/src/burndown.ts

@@ -1,35 +0,0 @@
-// Burndown — tasks remaining and cumulative spend across the build. There are no
-// timestamps in build-state, so the X axis is task-completion order (step 1..N),
-// which is the natural timeline for a build. Retries add a step (and cost) without
-// burning down a task, so they show up as flat-remaining / rising-cost.
-
-import type { BuildState } from "./build-state.js";
-
-export interface BurndownStep {
-  taskId: string;
-  remaining: number; // distinct tasks still to do after this step
-  cumCost: number; // cumulative spend through this step
-  retry: boolean; // this step re-ran an already-done task
-}
-
-export interface Burndown {
-  taskCount: number;
-  totalCost: number;
-  steps: BurndownStep[];
-}
-
-const round2 = (n: number) => Math.round(n * 100) / 100;
-
-export function computeBurndown(state: BuildState): Burndown {
-  const taskCount = state.tasks.length;
-  const done = new Set<string>();
-  let cum = 0;
-  const steps: BurndownStep[] = [];
-  for (const o of state.outcomes) {
-    const retry = done.has(o.taskId);
-    done.add(o.taskId);
-    cum += o.cost;
-    steps.push({ taskId: o.taskId, remaining: taskCount - done.size, cumCost: round2(cum), retry });
-  }
-  return { taskCount, totalCost: round2(cum), steps };
-}

package/src/calibration.ts

@@ -1,88 +0,0 @@
-// Self-calibrating token estimates. After each real task, we record its measured
-// token usage per (capability, difficulty). estimateTokens uses the running average
-// once there are enough samples, so estimates sharpen with use. Persisted globally.
-
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import type { Capability, Difficulty } from "./types.js";
-
-interface Sample {
-  input: number; // total input tokens (fresh + cache-read)
-  output: number;
-  cachedFraction: number; // share of input served from cache
-  n: number; // sample count (capped so recent runs still move the average)
-}
-
-type Calibration = Record<string, Sample>;
-
-const MIN_SAMPLES = 2; // trust calibration only after a couple of runs
-const MAX_N = 20; // cap so old runs don't dominate
-
-function calPath(): string {
-  return join(homedir(), ".projectinator", "calibration.json");
-}
-const key = (c: Capability, d: Difficulty) => `${c}/${d}`;
-
-function load(): Calibration {
-  try {
-    if (!existsSync(calPath())) return {};
-    return JSON.parse(readFileSync(calPath(), "utf-8")) as Calibration;
-  } catch {
-    return {};
-  }
-}
-
-function save(cal: Calibration): void {
-  try {
-    mkdirSync(join(homedir(), ".projectinator"), { recursive: true });
-    writeFileSync(calPath(), JSON.stringify(cal, null, 2) + "\n");
-  } catch {
-    /* best effort — never break a build on a calibration write */
-  }
-}
-
-/** Fold a real measurement into the running average for its bucket. */
-export function recordActual(
-  capability: Capability,
-  difficulty: Difficulty,
-  inputTotal: number,
-  output: number,
-  cachedFraction: number,
-): void {
-  if (!(inputTotal > 0)) return;
-  const cal = load();
-  const k = key(capability, difficulty);
-  const prev = cal[k];
-  if (!prev) {
-    cal[k] = { input: inputTotal, output, cachedFraction, n: 1 };
-  } else {
-    const n = Math.min(prev.n, MAX_N);
-    cal[k] = {
-      input: (prev.input * n + inputTotal) / (n + 1),
-      output: (prev.output * n + output) / (n + 1),
-      cachedFraction: (prev.cachedFraction * n + cachedFraction) / (n + 1),
-      n: prev.n + 1,
-    };
-  }
-  save(cal);
-}
-
-/** All recorded samples keyed "capability/difficulty" (for the accuracy view). */
-export function allSamples(): Record<string, { input: number; output: number; cachedFraction: number; n: number }> {
-  return load();
-}
-
-/** Calibrated estimate for a bucket, once enough samples exist. */
-export function calibratedTokens(
-  capability: Capability,
-  difficulty: Difficulty,
-): { input: number; output: number; cachedInputFraction: number } | undefined {
-  const s = load()[key(capability, difficulty)];
-  if (!s || s.n < MIN_SAMPLES) return undefined;
-  return {
-    input: Math.round(s.input),
-    output: Math.round(s.output),
-    cachedInputFraction: Math.min(0.95, Math.max(0, s.cachedFraction)),
-  };
-}

package/src/cli.ts

@@ -1,263 +0,0 @@
-// 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));
-}