projectinator 0.1.5 → 0.2.0

package/src/tui/Kanban.tsx

@@ -16,9 +16,11 @@ export interface BoardTask {
   dependsOn?: string[];
   status: "pending" | "running" | "done" | "failed" | "skipped";
   cost?: number;
-  verdict?: "PASS" | "FAIL";
+  verdict?: "PASS" | "PASS*" | "FAIL";
   /** The teammate (model) working this task, when known. */
   assignee?: string;
+  /** Human annotation from the board editor. */
+  notes?: string;
 }
 
 type Col = "backlog" | "notStarted" | "inProgress" | "done";
@@ -62,11 +64,12 @@ function Card({ t }: { t: BoardTask }): React.ReactElement {
         <Text>{ROLE_META[t.capability].emoji} </Text>
         <Text color={C.dim}>{t.id} </Text>
         <Text color={C.accent}>{t.capability}</Text>
-        {t.verdict ? <Text> <Badge color={t.verdict === "PASS" ? "green" : "red"}>{t.verdict}</Badge></Text> : null}
+        {t.verdict ? <Text> <Badge color={t.verdict === "FAIL" ? "red" : t.verdict === "PASS*" ? "yellow" : "green"}>{t.verdict}</Badge></Text> : null}
         {t.cost ? <Text color={C.dim}> ${t.cost.toFixed(2)}</Text> : null}
       </Box>
       <Text color={failed ? C.bad : C.text} wrap="truncate-end">{t.title}</Text>
       {t.assignee ? <Text color={C.dim}>{t.assignee}</Text> : null}
+      {t.notes ? <Text color={C.dim} wrap="truncate-end">✎ {t.notes}</Text> : null}
     </Box>
   );
 }

package/src/tui/Settings.tsx

@@ -10,7 +10,7 @@ import { WebAccounts } from "./WebAccounts.js";
 import { connectedProviders } from "../web/session.js";
 import { estimateAccuracy } from "../estimate.js";
 import { availableProviders, effectiveRoster, allModels, setRoleModel, PROVIDER_LABEL } from "./engine.js";
-import { setKey, getPrefs, setPrefs, loadConfig, setPreferredProvider, getDefaultMode, setDefaultMode, getNotify, setNotify, getPreferredStack, setPreferredStack, ENV_VAR } from "./config.js";
+import { setKey, getPrefs, setPrefs, loadConfig, setPreferredProvider, getDefaultMode, setDefaultMode, getNotify, setNotify, getPreferredStack, setPreferredStack, ENV_VAR, type Prefs } from "./config.js";
 import { validateKey } from "./validate.js";
 import { openRouterModels, refreshOpenRouterModels } from "../openrouter.js";
 
@@ -428,25 +428,35 @@ function PrefsEditor({
   onDone,
   onCancel,
 }: {
-  initial: { budgetCapUSD: number; concurrency: number; budgetAlertPct: number };
-  onDone: (p: { budgetCapUSD: number; concurrency: number; budgetAlertPct: number }) => void;
+  initial: Prefs;
+  onDone: (p: Prefs) => void;
   onCancel: () => void;
 }): React.ReactElement {
   const [cap, setCap] = useState(String(initial.budgetCapUSD));
   const [conc, setConc] = useState(String(initial.concurrency));
   const [pct, setPct] = useState(String(initial.budgetAlertPct));
-  const [field, setField] = useState<"cap" | "conc" | "pct">("cap");
+  const [tmo, setTmo] = useState(String(initial.taskTimeoutMin));
+  const [tcap, setTcap] = useState(String(initial.taskCostCapUSD));
+  const [field, setField] = useState<"cap" | "conc" | "pct" | "tmo" | "tcap">("cap");
 
   const commit = () => {
     const b = Math.max(1, parseFloat(cap) || initial.budgetCapUSD);
     const c = Math.max(1, Math.floor(parseFloat(conc) || initial.concurrency));
     const p = Math.min(99, Math.max(1, Math.round(parseFloat(pct) || initial.budgetAlertPct)));
-    onDone({ budgetCapUSD: b, concurrency: c, budgetAlertPct: p });
+    // "0" is a valid value here (unlimited), so only a non-number falls back.
+    const parse0 = (s: string, fallback: number) => { const n = parseFloat(s); return Number.isFinite(n) ? Math.max(0, n) : fallback; };
+    onDone({
+      budgetCapUSD: b,
+      concurrency: c,
+      budgetAlertPct: p,
+      taskTimeoutMin: parse0(tmo, initial.taskTimeoutMin),
+      taskCostCapUSD: parse0(tcap, initial.taskCostCapUSD),
+    });
   };
 
   return (
     <Box flexDirection="column">
-      <Panel title="Budget, speed & alerts">
+      <Panel title="Budget, speed, alerts & task limits">
       <Box flexDirection="column">
         <Box>
           <Box width={22}><Text color={field === "cap" ? C.accent : C.text}>Budget cap (USD)</Text></Box>
@@ -471,14 +481,30 @@ function PrefsEditor({
         <Box>
           <Box width={22}><Text color={field === "pct" ? C.accent : C.text}>Alert at % of cap</Text></Box>
           {field === "pct" ? (
-            <TextInput value={pct} onChange={setPct} onSubmit={commit} />
+            <TextInput value={pct} onChange={setPct} onSubmit={() => setField("tmo")} />
           ) : (
             <Text>{pct}%</Text>
           )}
         </Box>
+        <Box>
+          <Box width={22}><Text color={field === "tmo" ? C.accent : C.text}>Task timeout (min)</Text></Box>
+          {field === "tmo" ? (
+            <TextInput value={tmo} onChange={setTmo} onSubmit={() => setField("tcap")} />
+          ) : (
+            <Text>{tmo === "0" ? "unlimited" : tmo}</Text>
+          )}
+        </Box>
+        <Box>
+          <Box width={22}><Text color={field === "tcap" ? C.accent : C.text}>Task cost cap (USD)</Text></Box>
+          {field === "tcap" ? (
+            <TextInput value={tcap} onChange={setTcap} onSubmit={commit} />
+          ) : (
+            <Text>{tcap === "0" ? "unlimited" : tcap}</Text>
+          )}
+        </Box>
       </Box>
       <Box flexDirection="column" marginTop={1}>
-        <Text color={C.textSubtle}>Enter moves to the next field, then saves.</Text>
+        <Text color={C.textSubtle}>Enter moves to the next field, then saves. A task over its limit is aborted and the build halts (resumable); 0 = unlimited.</Text>
         <KeyHint hints={[{ keys: "Enter", label: "next / save" }, { keys: "Ctrl+C", label: "cancel" }]} />
       </Box>
       </Panel>

package/src/tui/components.tsx

@@ -261,11 +261,12 @@ export interface TaskView {
   title: string;
   cost?: number;
   model?: string;
-  verdict?: "PASS" | "FAIL";
+  /** "PASS*" = passed, but the tester never ran the app (no Chromium). */
+  verdict?: "PASS" | "PASS*" | "FAIL";
 }
 
 const CAP_LABEL: Record<Capability, string> = {
-  plan: "plan", design: "design", code: "code", test: "test", ops: "ops",
+  plan: "plan", design: "design", code: "code", review: "review", test: "test", ops: "ops",
 };
 
 /** The AI team: each capability is a role with a friendly name + icon. */
@@ -273,6 +274,7 @@ export const ROLE_META: Record<Capability, { emoji: string; label: string }> = {
   plan: { emoji: "🧭", label: "Project manager" },
   design: { emoji: "🎨", label: "Designer" },
   code: { emoji: "🧠", label: "Developer" },
+  review: { emoji: "🔍", label: "Reviewer" },
   test: { emoji: "🔎", label: "Tester" },
   ops: { emoji: "🚀", label: "Runner" },
 };
@@ -311,7 +313,7 @@ export function TaskRow({ t }: { t: TaskView }): React.ReactElement {
       </Box>
       <Box width={10} justifyContent="flex-end">
         {t.verdict ? (
-          <Text color={t.verdict === "PASS" ? C.good : C.bad}>{t.verdict}</Text>
+          <Text color={t.verdict === "FAIL" ? C.bad : t.verdict === "PASS*" ? C.warn : C.good}>{t.verdict}</Text>
         ) : t.cost !== undefined ? (
           <Text color={C.dim}>${t.cost.toFixed(2)}</Text>
         ) : (

package/src/tui/config.ts

@@ -15,6 +15,9 @@ export interface AppConfig {
   concurrency?: number;
   /** Warn (not halt) once spend crosses this % of the cap. Default 80. */
   budgetAlertPct?: number;
+  /** Per-task limits; 0 = unlimited. Defaults: 10 min, $3. */
+  taskTimeoutMin?: number;
+  taskCostCapUSD?: number;
   /** If set, always route to this provider (when it has a key), ignoring the others. */
   preferredProvider?: Provider;
   /** Default workflow for new builds: auto-run, or require PM approval before building. */
@@ -117,19 +120,31 @@ export function setKey(provider: Provider, key: string): void {
   process.env[ENV_VAR[provider]] = key;
 }
 
-export function getPrefs(): { budgetCapUSD: number; concurrency: number; budgetAlertPct: number } {
+export interface Prefs {
+  budgetCapUSD: number;
+  concurrency: number;
+  budgetAlertPct: number;
+  taskTimeoutMin: number;
+  taskCostCapUSD: number;
+}
+
+export function getPrefs(): Prefs {
   const cfg = loadConfig();
   return {
     budgetCapUSD: cfg.budgetCapUSD ?? 25,
     concurrency: cfg.concurrency ?? 3,
     budgetAlertPct: cfg.budgetAlertPct ?? 80,
+    taskTimeoutMin: cfg.taskTimeoutMin ?? 10,
+    taskCostCapUSD: cfg.taskCostCapUSD ?? 3,
   };
 }
 
-export function setPrefs(prefs: { budgetCapUSD?: number; concurrency?: number; budgetAlertPct?: number }): void {
+export function setPrefs(prefs: Partial<Prefs>): void {
   const cfg = loadConfig();
   if (prefs.budgetCapUSD !== undefined) cfg.budgetCapUSD = prefs.budgetCapUSD;
   if (prefs.concurrency !== undefined) cfg.concurrency = prefs.concurrency;
   if (prefs.budgetAlertPct !== undefined) cfg.budgetAlertPct = prefs.budgetAlertPct;
+  if (prefs.taskTimeoutMin !== undefined) cfg.taskTimeoutMin = prefs.taskTimeoutMin;
+  if (prefs.taskCostCapUSD !== undefined) cfg.taskCostCapUSD = prefs.taskCostCapUSD;
   saveConfig(cfg);
 }

package/src/tui/engine.ts

@@ -6,7 +6,7 @@ import { spawn } from "node:child_process";
 import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { basename, dirname, join } from "node:path";
-import type { Capability, Provider, RegistryEntry, Task, TaskOutcome, Tier } from "../types.js";
+import type { Capability, Provider, RegistryEntry, Task, TaskLimits, TaskOutcome, Tier } from "../types.js";
 import { DEFAULT_POLICY, route } from "../router.js";
 import { REGISTRY } from "../registry.js";
 import { MODELS } from "../models.js";
@@ -21,7 +21,7 @@ import { narrateRetro } from "../narrate.js";
 import { decomposeIdea } from "../pm.js";
 import { assessIntake, type IntakeQuestion } from "../intake.js";
 import { councilEpics, type Epic, type CouncilResult } from "../council.js";
-import { newBuildState, loadState, saveState, type BuildState } from "../build-state.js";
+import { newBuildState, loadState, saveState, completedIds, type BuildState } from "../build-state.js";
 
 const PROVIDER_KEYS: Record<Provider, string[]> = {
   anthropic: ["ANTHROPIC_API_KEY"],
@@ -81,6 +81,7 @@ export const ROLE_TIERS: { capability: Capability; tier: Tier; label: string }[]
   { capability: "plan", tier: "mid", label: "Project manager" },
   { capability: "design", tier: "high", label: "Designer" },
   { capability: "code", tier: "high", label: "Developer" },
+  { capability: "review", tier: "fast", label: "Reviewer" },
   { capability: "test", tier: "fast", label: "Tester" },
   { capability: "ops", tier: "high", label: "Runner / ops" },
 ];
@@ -332,7 +333,7 @@ export function saveProjectTasks(dir: string, tasks: Task[]): void {
 export function exportProject(dir: string): { md: string; csv: string } {
   const state = loadState(join(dir, "build-state.json"));
   if (!state) throw new Error("No project data to export.");
-  const done = new Set(state.outcomes.map((o) => o.taskId));
+  const done = completedIds(state);
   const cost = new Map<string, number>();
   for (const o of state.outcomes) cost.set(o.taskId, (cost.get(o.taskId) ?? 0) + o.cost);
 
@@ -358,13 +359,14 @@ export function exportProject(dir: string): { md: string; csv: string } {
       const c = cost.has(t.id) ? ` — $${cost.get(t.id)!.toFixed(2)}` : "";
       const dep = (t.dependsOn ?? []).length ? ` _(after ${(t.dependsOn ?? []).join(", ")})_` : "";
       md.push(`- [${mark}] \`${t.id}\` **${t.capability}/${t.difficulty}** — ${t.title}${c}${dep}`);
+      if (t.notes) md.push(`  - ✎ ${t.notes}`);
     }
     md.push("");
   }
 
   const esc = (s: string) => `"${String(s).replace(/"/g, '""')}"`;
   const csv = [
-    "id,epic,capability,difficulty,status,cost,dependsOn,title",
+    "id,epic,capability,difficulty,status,cost,dependsOn,title,notes",
     ...state.tasks.map((t) =>
       [
         t.id,
@@ -375,6 +377,7 @@ export function exportProject(dir: string): { md: string; csv: string } {
         (cost.get(t.id) ?? 0).toFixed(2),
         esc((t.dependsOn ?? []).join(" ")),
         esc(t.title),
+        esc(t.notes ?? ""),
       ].join(","),
     ),
   ].join("\n");
@@ -390,7 +393,7 @@ export function exportProject(dir: string): { md: string; csv: string } {
 function projectRows(dir: string) {
   const state = loadState(join(dir, "build-state.json"));
   if (!state) throw new Error("No project data to export.");
-  const done = new Set(state.outcomes.map((o) => o.taskId));
+  const done = completedIds(state);
   const cost = new Map<string, number>();
   for (const o of state.outcomes) cost.set(o.taskId, (cost.get(o.taskId) ?? 0) + o.cost);
   return { state, done, cost };
@@ -623,7 +626,7 @@ export async function breakdownEpic(
 
 export interface RunHandle {
   workspace: string;
-  promise: Promise<{ totalCost: number; halted: boolean; files: string[] }>;
+  promise: Promise<{ totalCost: number; halted: boolean; haltReason?: string; files: string[] }>;
 }
 
 /** Run a planned build, streaming orchestrator events to the UI. Spends money.
@@ -635,6 +638,7 @@ export function startBuild(
   opts: {
     concurrency: number;
     budgetCapUSD: number;
+    taskLimits: TaskLimits;
     onEvent: (e: OrchestratorEvent) => void;
     workspace?: string;
     seedOutcomes?: TaskOutcome[];
@@ -658,7 +662,7 @@ export function startBuild(
   state.budgetCapUSD = opts.budgetCapUSD; // remember this project's cap
 
   const executor = makePiExecutor({ workspace, backend: "api" });
-  const policy = { ...DEFAULT_POLICY, backendMode: "api" as const, budgetCapUSD: opts.budgetCapUSD };
+  const policy = { ...DEFAULT_POLICY, backendMode: "api" as const, budgetCapUSD: opts.budgetCapUSD, taskLimits: opts.taskLimits };
 
   // Version the workspace: init a repo, then commit after each finished task.
   initRepo(workspace);
@@ -691,6 +695,7 @@ export function startBuild(
     return {
       totalCost: result.totalCost,
       halted: result.halted,
+      haltReason: result.haltReason,
       files: (result.outcomes.at(-1)?.files ?? []).filter((f) => f !== "build-state.json"),
     };
   });

package/src/tui/panels.tsx

@@ -76,7 +76,7 @@ export function ListView({ tasks }: { tasks: BoardTask[] }): React.ReactElement
                 <Box width={3}><Text>{ROLE_META[t.capability].emoji}</Text></Box>
                 <Box flexGrow={1}><Text color={C.text} wrap="truncate-end">{t.title}</Text></Box>
                 <Box width={10} justifyContent="flex-end">
-                  {t.verdict ? <Text color={t.verdict === "PASS" ? C.good : C.bad}>{t.verdict}</Text>
+                  {t.verdict ? <Text color={t.verdict === "FAIL" ? C.bad : t.verdict === "PASS*" ? C.warn : C.good}>{t.verdict}</Text>
                     : t.cost ? <Text color={C.dim}>${t.cost.toFixed(2)}</Text> : <Text> </Text>}
                 </Box>
               </Box>

package/src/types.ts

@@ -6,7 +6,7 @@
 export type Backend = "api" | "web";
 
 /** What kind of work a task needs. Roles bind to capabilities, never to model names. */
-export type Capability = "plan" | "design" | "code" | "test" | "ops";
+export type Capability = "plan" | "design" | "code" | "review" | "test" | "ops";
 
 /** How hard the task is. Drives which tier of model we spend on. */
 export type Difficulty = "trivial" | "low" | "medium" | "high";
@@ -90,6 +90,8 @@ export interface Task {
   epic?: string;
   story?: string;
   dependsOn?: string[];
+  /** Human-only annotation shown on the board. Never sent to any model. */
+  notes?: string;
 }
 
 // ---------------------------------------------------------------------------
@@ -105,6 +107,29 @@ export interface RoutingPolicy {
   difficultyToTier: Record<Difficulty, Tier>;
   /** Tester -> Developer feedback loop stop condition (used later, in the orchestrator). */
   maxFeedbackRounds: number;
+  /** Per-task limits. A task that runs longer or spends more is aborted, recorded as
+   *  failed, and the build halts (resumable). 0 = unlimited. */
+  taskLimits: TaskLimits;
+}
+
+export interface TaskLimits {
+  timeoutMs: number;
+  costCapUSD: number;
+}
+
+/** Thrown by an executor when a task breaches its limits. The orchestrator turns it
+ *  into a failed outcome + halt instead of letting it escape as a crash. */
+export class TaskLimitError extends Error {
+  constructor(
+    public readonly kind: "timeout" | "cost",
+    public readonly taskId: string,
+    /** Money already spent on the aborted attempt (must still be billed). */
+    public readonly costSoFar: number,
+    message: string,
+  ) {
+    super(message);
+    this.name = "TaskLimitError";
+  }
 }
 
 // ---------------------------------------------------------------------------
@@ -141,6 +166,9 @@ export interface Bug {
 export interface Verdict {
   passed: boolean;
   bugs: Bug[];
+  /** True when the tester actually ran the app (headless Chromium). False = it could
+   *  only read the code, so a PASS is weaker than it looks. */
+  runtimeChecked: boolean;
 }
 
 /** What a role produces when it runs a task. */
@@ -153,6 +181,9 @@ export interface RoleResult {
   cost: number;
   /** Only for test tasks — the pass/fail judgement. */
   verdict?: Verdict;
+  /** Set when the task was aborted (limit breach). A failed outcome is billed but
+   *  never counts as "done": resume rebuilds it. */
+  error?: string;
 }
 
 /** Executor injected into the orchestrator. Real impl runs Pi; tests pass a fake. */
@@ -163,6 +194,8 @@ export type RoleExecutor = (input: {
   contextText: string;
   /** 0 on first attempt, 1+ during a Tester→Developer feedback round. */
   round: number;
+  /** Per-task limits the executor must enforce (throw TaskLimitError on breach). */
+  limits: TaskLimits;
 }) => Promise<RoleResult>;
 
 /** One recorded step of a build run. */