projectinator 0.1.5 → 0.3.0

package/src/orchestrator.ts

@@ -8,12 +8,13 @@
 // The executor is INJECTED (RoleExecutor), so this entire control flow is testable
 // offline with a fake — no model, no spend. The real Pi executor lives in roles.ts.
 
-import type {
-  RegistryEntry,
-  RoleExecutor,
-  RoutingPolicy,
-  Task,
-  TaskOutcome,
+import {
+  TaskLimitError,
+  type RegistryEntry,
+  type RoleExecutor,
+  type RoutingPolicy,
+  type Task,
+  type TaskOutcome,
 } from "./types.js";
 import { route } from "./router.js";
 import { REGISTRY } from "./registry.js";
@@ -62,6 +63,7 @@ export interface RunOptions {
 export type OrchestratorEvent =
   | { type: "task_start"; task: Task; round: number; provider: string; modelId: string }
   | { type: "task_done"; outcome: TaskOutcome; runningTotal: number }
+  | { type: "task_failed"; outcome: TaskOutcome; runningTotal: number }
   | { type: "task_skipped"; taskId: string }
   | { type: "test_failed"; taskId: string; bugs: number; round: number }
   | { type: "retry_dev"; taskId: string; forTest: string; round: number }
@@ -107,14 +109,19 @@ export async function runBacklog(tasks: Task[], opts: RunOptions): Promise<RunRe
   let running = 0;
 
   // Resume: replay prior outcomes so finished tasks are skipped and cost is restored.
+  // A failed attempt is billed but never "done" — it is rebuilt.
   const seed = opts.seedOutcomes ?? [];
   for (const o of seed) {
     record.push(o);
-    outcomes.set(o.taskId, o); // last wins (retries overwrite)
+    if (o.error) outcomes.delete(o.taskId); // last wins: a later failure voids an earlier pass
+    else outcomes.set(o.taskId, o);
     running += o.cost;
   }
   running = round2(running);
-  const wasDone = new Set(seed.map((o) => o.taskId));
+  const wasDone = new Set(outcomes.keys());
+
+  let halted = false;
+  let haltReason: string | undefined;
 
   const emit = opts.onProgress ?? (() => {});
   const checkpoint = () => opts.onCheckpoint?.(record, round2(running));
@@ -132,39 +139,58 @@ export async function runBacklog(tasks: Task[], opts: RunOptions): Promise<RunRe
     const decision = route(task, { policy, registry, runningTotalBefore: running });
     emit({ type: "task_start", task, round, provider: decision.provider, modelId: decision.model.id });
     const contextText = contextOverride ?? gatherContext(task, outcomes);
-    const result = await execute({ task, decision, contextText, round });
-    const outcome: TaskOutcome = {
-      ...result,
-      taskId: task.id,
-      capability: task.capability,
-      provider: decision.provider,
-      modelId: decision.model.id,
-      round,
-    };
-    running += result.cost;
+    const meta = { taskId: task.id, capability: task.capability, provider: decision.provider, modelId: decision.model.id, round };
+    let outcome: TaskOutcome;
+    try {
+      outcome = { ...(await execute({ task, decision, contextText, round, limits: policy.taskLimits })), ...meta };
+    } catch (e) {
+      if (!(e instanceof TaskLimitError)) throw e;
+      // Limit breach: bill what was spent, record the failure, halt the build.
+      outcome = { finalText: "", files: [], cost: e.costSoFar, error: e.message, ...meta };
+      running += outcome.cost;
+      record.push(outcome);
+      halted = true;
+      haltReason = `${task.id} aborted: ${e.message}`;
+      emit({ type: "task_failed", outcome, runningTotal: round2(running) });
+      return outcome;
+    }
+    running += outcome.cost;
     outcomes.set(task.id, outcome);
     record.push(outcome);
     emit({ type: "task_done", outcome, runningTotal: round2(running) });
     return outcome;
   };
 
-  // One task's full lifecycle: run it, then its Tester->Developer feedback loop.
+  // One task's full lifecycle: run it, then its Reviewer/Tester -> Developer feedback loop.
   const runTaskUnit = async (task: Task): Promise<void> => {
     let outcome = await runOne(task, 0);
-    if (task.capability === "test" && outcome.verdict && !outcome.verdict.passed) {
-      const codeDeps = (task.dependsOn ?? [])
-        .map((id) => byId.get(id))
-        .filter((t): t is Task => !!t && t.capability === "code");
+    const judges = task.capability === "test" || task.capability === "review";
+    if (!outcome.error && judges && outcome.verdict && !outcome.verdict.passed) {
+      // The code to fix: direct code deps, plus code deps reached through a review
+      // (a test depends on the review, which depends on the code).
+      const codeDeps: Task[] = [];
+      for (const id of task.dependsOn ?? []) {
+        const dep = byId.get(id);
+        if (!dep) continue;
+        if (dep.capability === "code") codeDeps.push(dep);
+        else if (dep.capability === "review") {
+          for (const id2 of dep.dependsOn ?? []) {
+            const d2 = byId.get(id2);
+            if (d2?.capability === "code" && !codeDeps.includes(d2)) codeDeps.push(d2);
+          }
+        }
+      }
 
       let round = 1;
-      while (outcome.verdict && !outcome.verdict.passed && round <= policy.maxFeedbackRounds) {
+      fix: while (outcome.verdict && !outcome.verdict.passed && round <= policy.maxFeedbackRounds) {
         emit({ type: "test_failed", taskId: task.id, bugs: outcome.verdict.bugs.length, round });
         const fixContext = bugReport(outcome.verdict.bugs);
         for (const dep of codeDeps) {
           emit({ type: "retry_dev", taskId: dep.id, forTest: task.id, round });
-          await runOne(dep, round, fixContext);
+          if ((await runOne(dep, round, fixContext)).error) break fix;
         }
         outcome = await runOne(task, round); // re-test
+        if (outcome.error) break;
         round++;
       }
     }
@@ -201,6 +227,7 @@ export async function runBacklog(tasks: Task[], opts: RunOptions): Promise<RunRe
         return { outcomes: record, totalCost: round2(running), halted: true, haltReason: "budget cap" };
       }
       await runTaskUnit(task);
+      if (halted) return { outcomes: record, totalCost: round2(running), halted, haltReason };
     }
     return { outcomes: record, totalCost: round2(running), halted: false };
   }
@@ -215,8 +242,7 @@ export async function runBacklog(tasks: Task[], opts: RunOptions): Promise<RunRe
   const inFlight = new Map<string, Promise<void>>();
   let reserved = 0;
   let codeInFlight = 0; // code tasks are serialized (they share files) even in parallel mode
-  let halted = false;
-  let haltReason: string | undefined;
+  let failure: unknown; // first task error; rethrown after in-flight work drains
 
   const depsSatisfied = (t: Task) => (t.dependsOn ?? []).every((d) => !remaining.has(d));
   const readyTasks = () =>
@@ -235,8 +261,10 @@ export async function runBacklog(tasks: Task[], opts: RunOptions): Promise<RunRe
       if (inFlight.size >= concurrency) break;
       // Only one code task builds at a time — they write to the shared workspace.
       if (task.capability === "code" && codeInFlight >= 1) continue;
-      const est = route(task, { policy, registry, runningTotalBefore: round2(running + reserved) });
-      if (round2(running + reserved + est.cost) > policy.budgetCapUSD) {
+      // Reservations keep full precision: rounding each one to cents drops sub-cent
+      // estimates entirely, so a wide backlog of cheap tasks would under-reserve.
+      const est = route(task, { policy, registry, runningTotalBefore: running + reserved });
+      if (running + reserved + est.cost > policy.budgetCapUSD) {
         if (inFlight.size === 0) {
           emit({ type: "budget_halt", runningTotal: round2(running + est.cost), cap: policy.budgetCapUSD });
           halted = true;
@@ -244,15 +272,25 @@ export async function runBacklog(tasks: Task[], opts: RunOptions): Promise<RunRe
         }
         break; // wait for in-flight tasks to free budget/capacity
       }
-      reserved = round2(reserved + est.cost);
+      reserved += est.cost;
       const cost = est.cost;
       const isCode = task.capability === "code";
       if (isCode) codeInFlight++;
-      const p = runTaskUnit(task).then(() => {
+      const settle = () => {
         if (isCode) codeInFlight--;
-        reserved = round2(reserved - cost);
+        reserved -= cost;
         remaining.delete(task.id);
         inFlight.delete(task.id);
+      };
+      // A rejection must NOT escape through Promise.race below: that abandons the
+      // sibling promises, and their later rejections would have no handler attached
+      // (unhandled rejection -> the host process dies mid-build). Capture the first
+      // failure, stop launching, drain what's running, checkpoint, then rethrow.
+      const p = runTaskUnit(task).then(settle, (e: unknown) => {
+        settle();
+        halted = true;
+        haltReason ??= e instanceof Error ? e.message : String(e);
+        failure ??= e;
       });
       inFlight.set(task.id, p);
     }
@@ -263,6 +301,7 @@ export async function runBacklog(tasks: Task[], opts: RunOptions): Promise<RunRe
 
   await Promise.all(inFlight.values());
   checkpoint();
+  if (failure) throw failure;
   return { outcomes: record, totalCost: round2(running), halted, haltReason };
 }
 

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 ----
@@ -31,7 +29,7 @@ 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 | test | ops" }),
+    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" })),
@@ -41,7 +39,7 @@ const TaskSchema = Type.Object(
 );
 const BacklogSchema = Type.Object({ tasks: Type.Array(TaskSchema) }, { additionalProperties: true });
 
-const CAPS = new Set<Capability>(["plan", "design", "code", "test", "ops"]);
+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;
@@ -78,9 +76,10 @@ export function pmSystemPrompt(scope: Scope = "full"): string {
     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 test task only if the change is risky. Do NOT re-plan the whole project,",
-          "do NOT add design/setup/deploy tasks. One small tweak = one task.",
+          "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.",
@@ -92,6 +91,9 @@ export function pmSystemPrompt(scope: Scope = "full"): string {
           "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.",
@@ -100,7 +102,7 @@ export function pmSystemPrompt(scope: Scope = "full"): string {
     "",
     "Each TASK must be:",
     "- atomic: one model can complete it in one focused turn",
-    "- tagged with a capability: plan | design | code | test | ops",
+    "- 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.",
@@ -211,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). */
@@ -233,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/preview.ts

@@ -10,7 +10,7 @@
 // relative paths all resolve the way they will in production.
 
 import { createServer, type Server } from "node:http";
-import { readdirSync, readFileSync, statSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { extname, join, normalize } from "node:path";
 import { pathToFileURL } from "node:url";
 
@@ -145,6 +145,20 @@ async function renderOne(
   }
 }
 
+/** 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(

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,44 @@ 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) ---
+  {
+    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) ---
@@ -72,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) ---
@@ -86,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/retro.ts

@@ -2,7 +2,7 @@
 // build-state: what passed, what the tester flagged, cost per epic and per
 // model, retries, and the priciest tasks. No model call.
 
-import type { BuildState } from "./build-state.js";
+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";
@@ -30,7 +30,7 @@ export function computeRetro(state: BuildState): RetroReport {
   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 = new Set(outcomes.map((o) => o.taskId));
+  const doneIds = completedIds(state);
 
   // Baseline-predicted cost for each run: static token budget × the model that ran it.
   let estCost = 0;