ralphie 1.0.0

package/dist/cli.js

@@ -0,0 +1,3296 @@
+#!/usr/bin/env tsx
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/cli.tsx
+import { render } from "ink";
+import { Command } from "commander";
+import { readFileSync as readFileSync6, existsSync as existsSync8, unlinkSync, copyFileSync as copyFileSync3 } from "fs";
+import { resolve, dirname as dirname3, join as join9 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+
+// src/App.tsx
+import { useState as useState3, useEffect as useEffect3, useCallback as useCallback2 } from "react";
+import { Box as Box11, Text as Text10, useApp } from "ink";
+import { StatusMessage } from "@inkjs/ui";
+
+// src/components/IterationHeader.tsx
+import { Box, Text } from "ink";
+import { ProgressBar } from "@inkjs/ui";
+
+// src/lib/colors.ts
+var COLORS = {
+  cyan: "cyan",
+  green: "green",
+  yellow: "yellow",
+  red: "red",
+  magenta: "magenta",
+  gray: "gray",
+  white: "white"
+};
+var ELEMENT_COLORS = {
+  border: COLORS.cyan,
+  success: COLORS.green,
+  warning: COLORS.yellow,
+  error: COLORS.red,
+  pending: COLORS.cyan,
+  text: COLORS.white,
+  muted: COLORS.gray
+};
+var CATEGORY_COLORS = {
+  read: COLORS.cyan,
+  write: COLORS.yellow,
+  command: COLORS.magenta,
+  meta: COLORS.gray
+};
+var STATE_COLORS = {
+  active: COLORS.cyan,
+  done: COLORS.green,
+  error: COLORS.red
+};
+
+// src/components/IterationHeader.tsx
+import { jsxDEV } from "react/jsx-dev-runtime";
+function formatElapsedTime(totalSeconds) {
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = Math.floor(totalSeconds % 60);
+  if (hours > 0) {
+    return `${hours}:${minutes.toString().padStart(2, "0")}:${seconds.toString().padStart(2, "0")}`;
+  }
+  return `${minutes}:${seconds.toString().padStart(2, "0")}`;
+}
+function IterationHeader({ current, total, elapsedSeconds }) {
+  const label = `Iteration ${current}/${total}`;
+  const elapsed = `${formatElapsedTime(elapsedSeconds)} elapsed`;
+  const progress = total > 1 ? Math.round((current - 1) / total * 100) : 0;
+  return /* @__PURE__ */ jsxDEV(Box, {
+    flexDirection: "column",
+    children: [
+      /* @__PURE__ */ jsxDEV(Box, {
+        children: [
+          /* @__PURE__ */ jsxDEV(Text, {
+            color: ELEMENT_COLORS.border,
+            children: "┌─ "
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV(Text, {
+            bold: true,
+            color: ELEMENT_COLORS.text,
+            children: label
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV(Text, {
+            color: ELEMENT_COLORS.border,
+            children: " ─── "
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV(Text, {
+            color: ELEMENT_COLORS.muted,
+            children: elapsed
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      total > 1 && /* @__PURE__ */ jsxDEV(Box, {
+        marginLeft: 3,
+        children: /* @__PURE__ */ jsxDEV(ProgressBar, {
+          value: progress
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/components/TaskTitle.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+
+// src/hooks/usePulse.ts
+import { useState, useEffect, useRef } from "react";
+var DEFAULT_INTERVAL_MS = 500;
+function usePulse(options = {}) {
+  const { intervalMs = DEFAULT_INTERVAL_MS, enabled = true } = options;
+  const [pulse, setPulse] = useState(true);
+  const intervalRef = useRef(null);
+  useEffect(() => {
+    if (!enabled) {
+      if (intervalRef.current) {
+        clearInterval(intervalRef.current);
+        intervalRef.current = null;
+      }
+      setPulse(true);
+      return;
+    }
+    intervalRef.current = setInterval(() => {
+      setPulse((prev) => !prev);
+    }, intervalMs);
+    return () => {
+      if (intervalRef.current) {
+        clearInterval(intervalRef.current);
+        intervalRef.current = null;
+      }
+    };
+  }, [intervalMs, enabled]);
+  return pulse;
+}
+
+// src/components/TaskTitle.tsx
+import { jsxDEV as jsxDEV2 } from "react/jsx-dev-runtime";
+function truncateText(text, maxLength) {
+  if (text.length <= maxLength) {
+    return text;
+  }
+  return text.slice(0, maxLength - 3) + "...";
+}
+function TaskTitle({ text, maxLength = 60, isPending = false }) {
+  const pulse = usePulse({ enabled: isPending });
+  const iconColor = isPending && !pulse ? ELEMENT_COLORS.muted : ELEMENT_COLORS.success;
+  if (!text) {
+    return /* @__PURE__ */ jsxDEV2(Box2, {
+      children: /* @__PURE__ */ jsxDEV2(Text2, {
+        color: ELEMENT_COLORS.border,
+        children: "│"
+      }, undefined, false, undefined, this)
+    }, undefined, false, undefined, this);
+  }
+  const displayText = truncateText(text.trim(), maxLength);
+  return /* @__PURE__ */ jsxDEV2(Box2, {
+    children: [
+      /* @__PURE__ */ jsxDEV2(Text2, {
+        color: ELEMENT_COLORS.border,
+        children: "│ "
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV2(Text2, {
+        color: iconColor,
+        children: "▶ "
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV2(Text2, {
+        color: ELEMENT_COLORS.text,
+        children: [
+          '"',
+          displayText,
+          '"'
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/components/ActivityFeed.tsx
+import { Box as Box7 } from "ink";
+
+// src/components/ThoughtItem.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { jsxDEV as jsxDEV3 } from "react/jsx-dev-runtime";
+function ThoughtItem({ item }) {
+  return /* @__PURE__ */ jsxDEV3(Box3, {
+    children: [
+      /* @__PURE__ */ jsxDEV3(Text3, {
+        color: ELEMENT_COLORS.border,
+        children: "│ "
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV3(Text3, {
+        color: ELEMENT_COLORS.text,
+        children: "● "
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV3(Text3, {
+        color: ELEMENT_COLORS.text,
+        children: item.text
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/components/ToolActivityItem.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+import Spinner2 from "ink-spinner";
+
+// src/lib/tool-categories.ts
+var TOOL_CATEGORIES = {
+  Read: "read",
+  Grep: "read",
+  Glob: "read",
+  WebFetch: "read",
+  WebSearch: "read",
+  LSP: "read",
+  Edit: "write",
+  Write: "write",
+  NotebookEdit: "write",
+  Bash: "command",
+  TodoWrite: "meta",
+  Task: "meta",
+  AskUserQuestion: "meta",
+  EnterPlanMode: "meta",
+  ExitPlanMode: "meta"
+};
+function getToolCategory(toolName) {
+  return TOOL_CATEGORIES[toolName] ?? "meta";
+}
+
+// src/components/ToolItem.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import Spinner from "ink-spinner";
+import { jsxDEV as jsxDEV4 } from "react/jsx-dev-runtime";
+function formatDuration(ms) {
+  const seconds = ms / 1000;
+  return `${seconds.toFixed(1)}s`;
+}
+
+// src/components/ToolActivityItem.tsx
+import { jsxDEV as jsxDEV5 } from "react/jsx-dev-runtime";
+function ToolStartItem({ item }) {
+  const category = getToolCategory(item.toolName);
+  const color = CATEGORY_COLORS[category];
+  return /* @__PURE__ */ jsxDEV5(Box5, {
+    children: [
+      /* @__PURE__ */ jsxDEV5(Text5, {
+        color: ELEMENT_COLORS.border,
+        children: "│   "
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV5(Text5, {
+        color,
+        children: /* @__PURE__ */ jsxDEV5(Spinner2, {
+          type: "dots"
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV5(Text5, {
+        children: " "
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV5(Text5, {
+        color: ELEMENT_COLORS.text,
+        children: item.displayName
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+function ToolCompleteItem({ item }) {
+  const icon = item.isError ? "✗" : "✓";
+  const iconColor = item.isError ? ELEMENT_COLORS.error : ELEMENT_COLORS.success;
+  const textColor = item.isError ? ELEMENT_COLORS.error : ELEMENT_COLORS.text;
+  const duration = formatDuration(item.durationMs);
+  return /* @__PURE__ */ jsxDEV5(Box5, {
+    children: [
+      /* @__PURE__ */ jsxDEV5(Text5, {
+        color: ELEMENT_COLORS.border,
+        children: "│   "
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV5(Text5, {
+        color: iconColor,
+        children: icon
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV5(Text5, {
+        children: " "
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV5(Text5, {
+        color: textColor,
+        children: item.displayName
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV5(Text5, {
+        color: ELEMENT_COLORS.muted,
+        children: [
+          " (",
+          duration,
+          ")"
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/components/CommitItem.tsx
+import { Box as Box6, Text as Text6 } from "ink";
+import { jsxDEV as jsxDEV6 } from "react/jsx-dev-runtime";
+function CommitItem({ item }) {
+  const shortHash = item.hash.slice(0, 7);
+  return /* @__PURE__ */ jsxDEV6(Box6, {
+    children: [
+      /* @__PURE__ */ jsxDEV6(Text6, {
+        color: ELEMENT_COLORS.border,
+        children: "│ "
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV6(Text6, {
+        color: ELEMENT_COLORS.success,
+        children: "✓ "
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV6(Text6, {
+        color: ELEMENT_COLORS.success,
+        children: shortHash
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV6(Text6, {
+        color: ELEMENT_COLORS.muted,
+        children: " - "
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV6(Text6, {
+        color: ELEMENT_COLORS.text,
+        children: item.message
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/components/ActivityFeed.tsx
+import { jsxDEV as jsxDEV7 } from "react/jsx-dev-runtime";
+function renderActivityItem(item) {
+  switch (item.type) {
+    case "thought":
+      return /* @__PURE__ */ jsxDEV7(ThoughtItem, {
+        item
+      }, undefined, false, undefined, this);
+    case "tool_start":
+      return /* @__PURE__ */ jsxDEV7(ToolStartItem, {
+        item
+      }, undefined, false, undefined, this);
+    case "tool_complete":
+      return /* @__PURE__ */ jsxDEV7(ToolCompleteItem, {
+        item
+      }, undefined, false, undefined, this);
+    case "commit":
+      return /* @__PURE__ */ jsxDEV7(CommitItem, {
+        item
+      }, undefined, false, undefined, this);
+  }
+}
+function filterCompletedToolStarts(items) {
+  const completedToolIds = new Set;
+  for (const item of items) {
+    if (item.type === "tool_complete") {
+      completedToolIds.add(item.toolUseId);
+    }
+  }
+  return items.filter((item) => {
+    if (item.type === "tool_start") {
+      return !completedToolIds.has(item.toolUseId);
+    }
+    return true;
+  });
+}
+function ActivityFeed({ activityLog, maxItems = 20 }) {
+  if (activityLog.length === 0) {
+    return null;
+  }
+  const filteredItems = filterCompletedToolStarts(activityLog);
+  const displayItems = filteredItems.length > maxItems ? filteredItems.slice(-maxItems) : filteredItems;
+  return /* @__PURE__ */ jsxDEV7(Box7, {
+    flexDirection: "column",
+    children: displayItems.map((item, index) => /* @__PURE__ */ jsxDEV7(Box7, {
+      children: renderActivityItem(item)
+    }, `${item.type}-${item.timestamp}-${index}`, false, undefined, this))
+  }, undefined, false, undefined, this);
+}
+
+// src/components/PhaseIndicator.tsx
+import { Box as Box8, Text as Text7 } from "ink";
+import { jsxDEV as jsxDEV8 } from "react/jsx-dev-runtime";
+var PHASE_ICONS = {
+  idle: "○",
+  reading: "◐",
+  editing: "✎",
+  running: "⚡",
+  thinking: "●",
+  done: "✓"
+};
+var PHASE_LABELS = {
+  idle: "Waiting",
+  reading: "Reading",
+  editing: "Editing",
+  running: "Running",
+  thinking: "Thinking",
+  done: "Done"
+};
+function getPhaseIcon(phase) {
+  return PHASE_ICONS[phase];
+}
+function getPhaseDisplayLabel(phase) {
+  return PHASE_LABELS[phase];
+}
+function getPhaseColor(phase, isPulseBright) {
+  if (phase === "done")
+    return COLORS.green;
+  if (phase === "idle")
+    return COLORS.gray;
+  return isPulseBright ? COLORS.cyan : COLORS.gray;
+}
+function PhaseIndicator({ phase }) {
+  const isActive = phase !== "done" && phase !== "idle";
+  const pulse = usePulse({ enabled: isActive });
+  const icon = getPhaseIcon(phase);
+  const label = getPhaseDisplayLabel(phase);
+  const color = getPhaseColor(phase, pulse);
+  return /* @__PURE__ */ jsxDEV8(Box8, {
+    children: [
+      /* @__PURE__ */ jsxDEV8(Text7, {
+        color: ELEMENT_COLORS.border,
+        children: "│ "
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV8(Text7, {
+        color,
+        children: icon
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV8(Text7, {
+        children: " "
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV8(Text7, {
+        color,
+        children: label
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/components/StatusBar.tsx
+import { Box as Box9, Text as Text8 } from "ink";
+import { jsxDEV as jsxDEV9 } from "react/jsx-dev-runtime";
+var PHASE_LABELS2 = {
+  idle: "Waiting...",
+  reading: "Reading...",
+  editing: "Editing...",
+  running: "Running...",
+  thinking: "Thinking...",
+  done: "Done"
+};
+function getPhaseLabel(phase) {
+  return PHASE_LABELS2[phase];
+}
+function formatCommitInfo(commit) {
+  const shortHash = commit.hash.slice(0, 7);
+  return `${shortHash} - ${commit.message}`;
+}
+function StatusBar({ phase, elapsedSeconds, summary, lastCommit }) {
+  const phaseLabel = getPhaseLabel(phase);
+  const elapsed = formatElapsedTime(elapsedSeconds);
+  const displayText = summary ?? `${phaseLabel} (${elapsed})`;
+  const minWidth = 50;
+  const contentLength = displayText.length + 4;
+  const dashCount = Math.max(4, minWidth - contentLength);
+  const dashes = "─".repeat(dashCount);
+  const textColor = phase === "done" ? ELEMENT_COLORS.success : ELEMENT_COLORS.text;
+  return /* @__PURE__ */ jsxDEV9(Box9, {
+    flexDirection: "column",
+    children: [
+      lastCommit && /* @__PURE__ */ jsxDEV9(Box9, {
+        children: [
+          /* @__PURE__ */ jsxDEV9(Text8, {
+            color: ELEMENT_COLORS.border,
+            children: "│ "
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV9(Text8, {
+            color: ELEMENT_COLORS.success,
+            children: "✓ "
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV9(Text8, {
+            color: ELEMENT_COLORS.muted,
+            children: formatCommitInfo(lastCommit)
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV9(Box9, {
+        children: [
+          /* @__PURE__ */ jsxDEV9(Text8, {
+            color: ELEMENT_COLORS.border,
+            children: "└─ "
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV9(Text8, {
+            bold: true,
+            color: textColor,
+            children: displayText
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV9(Text8, {
+            color: ELEMENT_COLORS.border,
+            children: [
+              " ",
+              dashes
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/components/CompletedIterationsList.tsx
+import { Box as Box10, Text as Text9, Static } from "ink";
+import { jsxDEV as jsxDEV10 } from "react/jsx-dev-runtime";
+function formatDuration2(ms) {
+  const seconds = Math.floor(ms / 1000);
+  if (seconds < 60) {
+    return `${seconds}s`;
+  }
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = seconds % 60;
+  return `${minutes}m ${remainingSeconds}s`;
+}
+function formatCost(costUsd) {
+  if (costUsd === null)
+    return "-";
+  if (costUsd < 0.01)
+    return "<$0.01";
+  return `$${costUsd.toFixed(2)}`;
+}
+function formatTokens(usage) {
+  if (usage === null)
+    return "";
+  const total = usage.inputTokens + usage.outputTokens;
+  if (total < 1000)
+    return `${total}`;
+  return `${(total / 1000).toFixed(1)}k`.replace(".0k", "k");
+}
+function truncateText2(text, maxLength) {
+  if (text.length <= maxLength)
+    return text;
+  return text.slice(0, maxLength - 3) + "...";
+}
+function CompletedIterationsList({ results }) {
+  if (results.length === 0)
+    return null;
+  return /* @__PURE__ */ jsxDEV10(Static, {
+    items: results,
+    children: (result, index) => /* @__PURE__ */ jsxDEV10(Box10, {
+      flexDirection: "column",
+      children: [
+        index === 0 && /* @__PURE__ */ jsxDEV10(Box10, {
+          children: /* @__PURE__ */ jsxDEV10(Text9, {
+            color: "cyan",
+            bold: true,
+            children: "Completed:"
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV10(Box10, {
+          children: [
+            /* @__PURE__ */ jsxDEV10(Text9, {
+              color: result.error ? "red" : "green",
+              children: result.error ? "✗" : "✓"
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV10(Text9, {
+              color: "cyan",
+              children: [
+                " ",
+                result.taskNumber ?? result.iteration,
+                ". "
+              ]
+            }, undefined, true, undefined, this),
+            result.phaseName && /* @__PURE__ */ jsxDEV10(Text9, {
+              color: "yellow",
+              children: [
+                "[",
+                result.phaseName,
+                "] "
+              ]
+            }, undefined, true, undefined, this),
+            /* @__PURE__ */ jsxDEV10(Text9, {
+              color: "white",
+              children: truncateText2(result.specTaskText ?? result.taskText ?? "Unknown task", result.phaseName ? 30 : 45)
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV10(Text9, {
+              color: "gray",
+              children: [
+                " ",
+                "(",
+                formatDuration2(result.durationMs),
+                ", ",
+                formatTokens(result.usage),
+                result.usage ? ", " : "",
+                formatCost(result.costUsd),
+                ")"
+              ]
+            }, undefined, true, undefined, this)
+          ]
+        }, undefined, true, undefined, this)
+      ]
+    }, result.iteration, true, undefined, this)
+  }, undefined, false, undefined, this);
+}
+
+// src/hooks/useHarnessStream.ts
+import { useState as useState2, useEffect as useEffect2, useRef as useRef2, useCallback } from "react";
+// src/lib/harness/claude.ts
+import { query } from "@anthropic-ai/claude-agent-sdk";
+var claudeHarness = {
+  name: "claude",
+  async run(prompt, options, onEvent) {
+    const startTime = Date.now();
+    if (!process.env.ANTHROPIC_API_KEY) {
+      const errorMessage = "Missing ANTHROPIC_API_KEY environment variable. Set it with: export ANTHROPIC_API_KEY=sk-ant-...";
+      onEvent({ type: "error", message: errorMessage });
+      return {
+        success: false,
+        durationMs: Date.now() - startTime,
+        error: errorMessage
+      };
+    }
+    try {
+      const queryResult = query({
+        prompt,
+        options: {
+          cwd: options.cwd,
+          permissionMode: "bypassPermissions",
+          allowedTools: options.allowedTools,
+          model: options.model,
+          systemPrompt: options.systemPrompt
+        }
+      });
+      let result = {
+        success: false,
+        durationMs: 0,
+        error: "No result received"
+      };
+      for await (const message of queryResult) {
+        if (message.type === "assistant") {
+          for (const block of message.message.content) {
+            if (block.type === "tool_use") {
+              onEvent({
+                type: "tool_start",
+                name: block.name,
+                input: JSON.stringify(block.input)
+              });
+            } else if (block.type === "text") {
+              onEvent({
+                type: "message",
+                text: block.text
+              });
+            } else if (block.type === "thinking") {
+              onEvent({
+                type: "thinking",
+                text: block.thinking
+              });
+            }
+          }
+        } else if (message.type === "user") {
+          for (const block of message.message.content) {
+            if (block.type === "tool_result") {
+              const toolResult = block;
+              onEvent({
+                type: "tool_end",
+                name: toolResult.tool_use_id,
+                output: typeof toolResult.content === "string" ? toolResult.content : JSON.stringify(toolResult.content),
+                error: toolResult.is_error
+              });
+            }
+          }
+        } else if (message.type === "result") {
+          if (message.subtype === "success") {
+            result = {
+              success: true,
+              durationMs: message.duration_ms,
+              costUsd: message.total_cost_usd,
+              usage: {
+                inputTokens: message.usage.input_tokens,
+                outputTokens: message.usage.output_tokens
+              },
+              output: message.result
+            };
+          } else {
+            const errorMsg = message;
+            result = {
+              success: false,
+              durationMs: message.duration_ms,
+              costUsd: message.total_cost_usd,
+              usage: {
+                inputTokens: message.usage.input_tokens,
+                outputTokens: message.usage.output_tokens
+              },
+              error: errorMsg.errors?.[0] ?? "Unknown error"
+            };
+          }
+        }
+      }
+      return result;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      onEvent({ type: "error", message: errorMessage });
+      return {
+        success: false,
+        durationMs: Date.now() - startTime,
+        error: errorMessage
+      };
+    }
+  }
+};
+
+// src/lib/harness/codex.ts
+import { Codex } from "@openai/codex-sdk";
+var codexHarness = {
+  name: "codex",
+  async run(prompt, options, onEvent) {
+    const startTime = Date.now();
+    if (!process.env.OPENAI_API_KEY) {
+      const errorMessage = "Missing OPENAI_API_KEY environment variable. Set it with: export OPENAI_API_KEY=sk-...";
+      onEvent({ type: "error", message: errorMessage });
+      return {
+        success: false,
+        durationMs: Date.now() - startTime,
+        error: errorMessage
+      };
+    }
+    try {
+      const codex = new Codex;
+      const thread = codex.startThread({
+        workingDirectory: options.cwd,
+        model: options.model,
+        approvalPolicy: "never",
+        sandboxMode: "workspace-write"
+      });
+      const { events } = await thread.runStreamed(prompt);
+      let result = {
+        success: false,
+        durationMs: 0,
+        error: "No result received"
+      };
+      let collectedOutput = "";
+      for await (const event of events) {
+        switch (event.type) {
+          case "item.started":
+          case "item.updated": {
+            const item = event.item;
+            if (item.type === "command_execution") {
+              onEvent({
+                type: "tool_start",
+                name: "Bash",
+                input: item.command
+              });
+            } else if (item.type === "mcp_tool_call") {
+              onEvent({
+                type: "tool_start",
+                name: item.tool,
+                input: JSON.stringify(item.arguments)
+              });
+            } else if (item.type === "reasoning") {
+              onEvent({
+                type: "thinking",
+                text: item.text
+              });
+            } else if (item.type === "agent_message") {
+              onEvent({
+                type: "message",
+                text: item.text
+              });
+            }
+            break;
+          }
+          case "item.completed": {
+            const item = event.item;
+            if (item.type === "command_execution") {
+              onEvent({
+                type: "tool_end",
+                name: "Bash",
+                output: item.aggregated_output,
+                error: item.status === "failed"
+              });
+            } else if (item.type === "mcp_tool_call") {
+              onEvent({
+                type: "tool_end",
+                name: item.tool,
+                output: item.result ? JSON.stringify(item.result.content) : item.error?.message,
+                error: item.status === "failed"
+              });
+            } else if (item.type === "file_change") {
+              onEvent({
+                type: "tool_end",
+                name: "FileChange",
+                output: item.changes.map((c) => `${c.kind}: ${c.path}`).join(`
+`),
+                error: item.status === "failed"
+              });
+            } else if (item.type === "agent_message") {
+              collectedOutput = item.text;
+            } else if (item.type === "error") {
+              onEvent({
+                type: "error",
+                message: item.message
+              });
+            }
+            break;
+          }
+          case "turn.completed": {
+            result = {
+              success: true,
+              durationMs: Date.now() - startTime,
+              usage: event.usage ? {
+                inputTokens: event.usage.input_tokens,
+                outputTokens: event.usage.output_tokens
+              } : undefined,
+              output: collectedOutput || undefined
+            };
+            break;
+          }
+          case "turn.failed": {
+            result = {
+              success: false,
+              durationMs: Date.now() - startTime,
+              error: event.error.message
+            };
+            break;
+          }
+          case "error": {
+            onEvent({
+              type: "error",
+              message: event.message
+            });
+            result = {
+              success: false,
+              durationMs: Date.now() - startTime,
+              error: event.message
+            };
+            break;
+          }
+        }
+      }
+      return result;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      onEvent({ type: "error", message: errorMessage });
+      return {
+        success: false,
+        durationMs: Date.now() - startTime,
+        error: errorMessage
+      };
+    }
+  }
+};
+
+// src/lib/harness/index.ts
+function getHarness(name = "claude") {
+  switch (name) {
+    case "claude":
+      return claudeHarness;
+    case "codex":
+      return codexHarness;
+  }
+}
+
+// src/hooks/useHarnessStream.ts
+function useHarnessStream(options) {
+  const {
+    prompt,
+    cwd,
+    harness: harnessName = "claude",
+    model,
+    iteration = 1,
+    totalIterations = 1
+  } = options;
+  const [state, setState] = useState2(() => ({
+    phase: "idle",
+    taskText: null,
+    activeTools: [],
+    toolGroups: [],
+    stats: {
+      toolsStarted: 0,
+      toolsCompleted: 0,
+      toolsErrored: 0,
+      reads: 0,
+      writes: 0,
+      commands: 0,
+      metaOps: 0
+    },
+    elapsedMs: 0,
+    result: null,
+    error: null,
+    isRunning: false,
+    activityLog: [],
+    lastCommit: null
+  }));
+  const mountedRef = useRef2(true);
+  const startTimeRef = useRef2(Date.now());
+  const toolIdRef = useRef2(0);
+  const activeToolsMapRef = useRef2(new Map);
+  const handleEvent = useCallback((event) => {
+    if (!mountedRef.current)
+      return;
+    setState((prev) => {
+      switch (event.type) {
+        case "tool_start": {
+          const toolId = `tool-${toolIdRef.current++}`;
+          const category = getToolCategory(event.name);
+          const displayName = event.input ?? event.name;
+          const activeTool = {
+            id: toolId,
+            name: event.name,
+            category,
+            startTime: Date.now(),
+            input: event.input ? { raw: event.input } : {}
+          };
+          activeToolsMapRef.current.set(toolId, activeTool);
+          const newStats = { ...prev.stats, toolsStarted: prev.stats.toolsStarted + 1 };
+          if (category === "read")
+            newStats.reads++;
+          else if (category === "write")
+            newStats.writes++;
+          else if (category === "command")
+            newStats.commands++;
+          else
+            newStats.metaOps++;
+          const newActivity = {
+            type: "tool_start",
+            toolUseId: toolId,
+            toolName: event.name,
+            displayName,
+            timestamp: Date.now()
+          };
+          return {
+            ...prev,
+            phase: category === "read" ? "reading" : category === "write" ? "editing" : "running",
+            activeTools: Array.from(activeToolsMapRef.current.values()),
+            stats: newStats,
+            activityLog: [...prev.activityLog, newActivity]
+          };
+        }
+        case "tool_end": {
+          const completedTool = Array.from(activeToolsMapRef.current.values()).find((t) => t.name === event.name);
+          const toolUseId = completedTool?.id ?? `tool-unknown-${Date.now()}`;
+          if (completedTool) {
+            activeToolsMapRef.current.delete(completedTool.id);
+          }
+          const newStats = {
+            ...prev.stats,
+            toolsCompleted: prev.stats.toolsCompleted + 1,
+            toolsErrored: event.error ? prev.stats.toolsErrored + 1 : prev.stats.toolsErrored
+          };
+          const newActivity = {
+            type: "tool_complete",
+            toolUseId,
+            toolName: event.name,
+            displayName: event.name,
+            durationMs: completedTool ? Date.now() - completedTool.startTime : 0,
+            isError: event.error ?? false,
+            timestamp: Date.now()
+          };
+          let newCommit = prev.lastCommit;
+          if (event.name === "Bash" && event.output) {
+            const commitMatch = event.output.match(/\[[\w-]+\s+([a-f0-9]{7,40})\]\s+(.+)/);
+            if (commitMatch) {
+              newCommit = { hash: commitMatch[1], message: commitMatch[2] };
+            }
+          }
+          return {
+            ...prev,
+            phase: activeToolsMapRef.current.size > 0 ? prev.phase : "thinking",
+            activeTools: Array.from(activeToolsMapRef.current.values()),
+            stats: newStats,
+            activityLog: [...prev.activityLog, newActivity],
+            lastCommit: newCommit
+          };
+        }
+        case "thinking": {
+          const newActivity = {
+            type: "thought",
+            text: event.text,
+            timestamp: Date.now()
+          };
+          return {
+            ...prev,
+            phase: "thinking",
+            taskText: prev.taskText ?? event.text.slice(0, 100),
+            activityLog: [...prev.activityLog, newActivity]
+          };
+        }
+        case "message": {
+          return {
+            ...prev,
+            taskText: prev.taskText ?? event.text.slice(0, 100)
+          };
+        }
+        case "error": {
+          return {
+            ...prev,
+            error: new Error(event.message)
+          };
+        }
+        default:
+          return prev;
+      }
+    });
+  }, []);
+  useEffect2(() => {
+    mountedRef.current = true;
+    startTimeRef.current = Date.now();
+    toolIdRef.current = 0;
+    activeToolsMapRef.current.clear();
+    const harness = getHarness(harnessName);
+    setState((prev) => ({ ...prev, isRunning: true, phase: "idle" }));
+    const tickerInterval = setInterval(() => {
+      if (mountedRef.current) {
+        setState((prev) => ({
+          ...prev,
+          elapsedMs: Date.now() - startTimeRef.current
+        }));
+      }
+    }, 1000);
+    harness.run(prompt, {
+      cwd: cwd ?? process.cwd(),
+      model
+    }, handleEvent).then((result) => {
+      if (!mountedRef.current)
+        return;
+      setState((prev) => ({
+        ...prev,
+        phase: "done",
+        isRunning: false,
+        elapsedMs: result.durationMs,
+        result: {
+          totalCostUsd: result.costUsd,
+          usage: result.usage
+        },
+        error: result.error ? new Error(result.error) : prev.error
+      }));
+    }).catch((err) => {
+      if (!mountedRef.current)
+        return;
+      setState((prev) => ({
+        ...prev,
+        phase: "done",
+        isRunning: false,
+        error: err instanceof Error ? err : new Error(String(err))
+      }));
+    });
+    return () => {
+      mountedRef.current = false;
+      clearInterval(tickerInterval);
+    };
+  }, [prompt, cwd, harnessName, model, handleEvent]);
+  return state;
+}
+
+// src/App.tsx
+import { join as join2 } from "path";
+
+// src/lib/spec-parser.ts
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+function parseSpec(specPath) {
+  if (!existsSync(specPath)) {
+    return null;
+  }
+  const content = readFileSync(specPath, "utf-8");
+  return parseSpecContent(content);
+}
+function parseSpecContent(content) {
+  const tasks = [];
+  const lines = content.split(`
+`);
+  let currentPhaseNumber = 0;
+  let currentPhaseName = "Tasks";
+  let taskCounter = 0;
+  for (const line of lines) {
+    const phaseMatch = line.match(/^#{2,3}\s+Phase\s*(\d+)\s*[:\-]\s*(.+)$/i);
+    if (phaseMatch) {
+      currentPhaseNumber = parseInt(phaseMatch[1], 10);
+      currentPhaseName = phaseMatch[2].trim();
+      continue;
+    }
+    const sectionMatch = line.match(/^#{2,3}\s+(.+)$/);
+    if (sectionMatch) {
+      const sectionTitle = sectionMatch[1].trim();
+      if (!sectionTitle.toLowerCase().includes("summary")) {
+        currentPhaseNumber++;
+        currentPhaseName = sectionTitle;
+      }
+      continue;
+    }
+    const checkboxMatch = line.match(/^-\s*\[\s*\]\s+(.+)$/);
+    if (checkboxMatch) {
+      taskCounter++;
+      const fullTaskText = checkboxMatch[1].trim();
+      const taskNumMatch = fullTaskText.match(/^(\d+\.\d+)\s*:?\s*(.*)$/);
+      let taskNumber;
+      let taskText;
+      if (taskNumMatch) {
+        taskNumber = taskNumMatch[1];
+        taskText = taskNumMatch[2] || fullTaskText;
+      } else {
+        taskNumber = `${currentPhaseNumber}.${taskCounter}`;
+        taskText = fullTaskText;
+      }
+      tasks.push({
+        taskNumber,
+        phaseNumber: currentPhaseNumber,
+        phaseName: currentPhaseName,
+        taskText
+      });
+    }
+  }
+  if (tasks.length === 0) {
+    return null;
+  }
+  return {
+    totalIterations: tasks.length,
+    tasks
+  };
+}
+function getTaskForIteration(spec, iteration) {
+  const index = iteration - 1;
+  if (index < 0 || index >= spec.tasks.length) {
+    return null;
+  }
+  return spec.tasks[index];
+}
+function loadSpecFromDir(dir) {
+  const specPath = join(dir, "SPEC.md");
+  return parseSpec(specPath);
+}
+function parseSpecTitle(content) {
+  const lines = content.split(`
+`);
+  for (const line of lines) {
+    const match = line.match(/^#\s+(.+)$/);
+    if (match) {
+      return match[1].trim();
+    }
+  }
+  return null;
+}
+function getSpecTitle(specPath) {
+  if (!existsSync(specPath)) {
+    return null;
+  }
+  const content = readFileSync(specPath, "utf-8");
+  return parseSpecTitle(content);
+}
+function isSpecComplete(specPath) {
+  if (!existsSync(specPath)) {
+    return false;
+  }
+  const content = readFileSync(specPath, "utf-8");
+  const hasUncheckedTasks = /^-\s*\[\s*\]\s+/m.test(content);
+  return !hasUncheckedTasks;
+}
+
+// src/App.tsx
+import { jsxDEV as jsxDEV11, Fragment } from "react/jsx-dev-runtime";
+function buildFailureContext(toolGroups, activityLog) {
+  const allTools = toolGroups.flatMap((g) => g.tools);
+  const lastTool = allTools[allTools.length - 1];
+  const errorTool = allTools.find((t) => t.isError) ?? lastTool;
+  const recentActivity = activityLog.slice(-5).map((item) => {
+    if (item.type === "thought")
+      return `\uD83D\uDCAD ${item.text.slice(0, 100)}`;
+    if (item.type === "tool_start")
+      return `▶ ${item.displayName}`;
+    if (item.type === "tool_complete") {
+      const icon = item.isError ? "✗" : "✓";
+      return `${icon} ${item.displayName} (${(item.durationMs / 1000).toFixed(1)}s)`;
+    }
+    if (item.type === "commit")
+      return `\uD83D\uDCDD ${item.hash.slice(0, 7)} ${item.message}`;
+    return "";
+  }).filter(Boolean);
+  return {
+    lastToolName: errorTool?.name ?? null,
+    lastToolInput: errorTool?.input ? formatToolInput(errorTool.input) : null,
+    lastToolOutput: errorTool?.output?.slice(0, 500) ?? null,
+    recentActivity
+  };
+}
+function formatToolInput(input) {
+  if (input.command)
+    return `command: ${String(input.command).slice(0, 200)}`;
+  if (input.file_path)
+    return `file: ${String(input.file_path)}`;
+  if (input.pattern)
+    return `pattern: ${String(input.pattern)}`;
+  if (input.prompt)
+    return `prompt: ${String(input.prompt).slice(0, 100)}`;
+  return JSON.stringify(input).slice(0, 200);
+}
+function AppInner({
+  state,
+  iteration,
+  totalIterations,
+  specTaskText,
+  taskNumber,
+  phaseName,
+  completedResults,
+  onIterationComplete
+}) {
+  const elapsedSeconds = Math.floor(state.elapsedMs / 1000);
+  useEffect3(() => {
+    if (state.phase === "done" && !state.isRunning && onIterationComplete) {
+      onIterationComplete({
+        iteration,
+        durationMs: state.elapsedMs,
+        stats: state.stats,
+        error: state.error,
+        taskText: state.taskText,
+        specTaskText,
+        lastCommit: state.lastCommit,
+        costUsd: state.result?.totalCostUsd ?? null,
+        usage: state.result?.usage ?? null,
+        taskNumber,
+        phaseName,
+        failureContext: state.error ? buildFailureContext(state.toolGroups, state.activityLog) : null
+      });
+    }
+  }, [state.phase, state.isRunning, iteration, state.elapsedMs, state.stats, state.error, state.taskText, specTaskText, state.lastCommit, state.result, onIterationComplete, taskNumber, phaseName, state.toolGroups, state.activityLog]);
+  const isPending = state.phase === "idle" || !state.taskText;
+  return /* @__PURE__ */ jsxDEV11(Box11, {
+    flexDirection: "column",
+    children: [
+      /* @__PURE__ */ jsxDEV11(CompletedIterationsList, {
+        results: completedResults
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV11(IterationHeader, {
+        current: iteration,
+        total: totalIterations,
+        elapsedSeconds
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV11(TaskTitle, {
+        text: state.taskText ?? undefined,
+        isPending
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV11(PhaseIndicator, {
+        phase: state.phase
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV11(ActivityFeed, {
+        activityLog: state.activityLog
+      }, undefined, false, undefined, this),
+      state.error && /* @__PURE__ */ jsxDEV11(Box11, {
+        marginLeft: 2,
+        children: /* @__PURE__ */ jsxDEV11(StatusMessage, {
+          variant: "error",
+          children: state.error.message
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV11(Box11, {
+        children: /* @__PURE__ */ jsxDEV11(Text10, {
+          color: "cyan",
+          children: "│"
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV11(StatusBar, {
+        phase: state.phase,
+        elapsedSeconds,
+        lastCommit: state.lastCommit ?? undefined
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+function App({
+  prompt,
+  iteration = 1,
+  totalIterations = 1,
+  cwd,
+  model,
+  harness = "claude",
+  _mockState,
+  onIterationComplete,
+  completedResults = [],
+  taskNumber = null,
+  phaseName = null,
+  specTaskText = null
+}) {
+  const liveState = useHarnessStream({
+    prompt,
+    cwd,
+    harness,
+    model,
+    iteration,
+    totalIterations
+  });
+  const state = _mockState ?? liveState;
+  return /* @__PURE__ */ jsxDEV11(AppInner, {
+    state,
+    iteration,
+    totalIterations,
+    specTaskText,
+    taskNumber,
+    phaseName,
+    completedResults,
+    onIterationComplete
+  }, undefined, false, undefined, this);
+}
+function formatDuration3(ms) {
+  const seconds = Math.floor(ms / 1000);
+  if (seconds < 60) {
+    return `${seconds}s`;
+  }
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = seconds % 60;
+  if (minutes < 60) {
+    return `${minutes}m ${remainingSeconds}s`;
+  }
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  return `${hours}h ${remainingMinutes}m`;
+}
+function aggregateStats(results) {
+  return results.reduce((acc, result) => ({
+    toolsStarted: acc.toolsStarted + result.stats.toolsStarted,
+    toolsCompleted: acc.toolsCompleted + result.stats.toolsCompleted,
+    toolsErrored: acc.toolsErrored + result.stats.toolsErrored,
+    reads: acc.reads + result.stats.reads,
+    writes: acc.writes + result.stats.writes,
+    commands: acc.commands + result.stats.commands,
+    metaOps: acc.metaOps + result.stats.metaOps
+  }), {
+    toolsStarted: 0,
+    toolsCompleted: 0,
+    toolsErrored: 0,
+    reads: 0,
+    writes: 0,
+    commands: 0,
+    metaOps: 0
+  });
+}
+function IterationRunner({
+  prompt,
+  totalIterations,
+  cwd,
+  idleTimeoutMs,
+  saveJsonl,
+  model,
+  harness,
+  _mockResults,
+  _mockCurrentIteration,
+  _mockIsComplete,
+  _mockState
+}) {
+  const { exit } = useApp();
+  const [currentIteration, setCurrentIteration] = useState3(_mockCurrentIteration ?? 1);
+  const [results, setResults] = useState3(_mockResults ?? []);
+  const [isComplete, setIsComplete] = useState3(_mockIsComplete ?? false);
+  const [iterationKey, setIterationKey] = useState3(0);
+  const [spec, setSpec] = useState3(null);
+  useEffect3(() => {
+    const targetDir = cwd ?? process.cwd();
+    const loadedSpec = loadSpecFromDir(targetDir);
+    setSpec(loadedSpec);
+  }, [cwd]);
+  const handleIterationComplete = useCallback2((result) => {
+    setResults((prev) => [...prev, result]);
+    if (result.error) {
+      setIsComplete(true);
+      return;
+    }
+    const targetDir = cwd ?? process.cwd();
+    const specPath = join2(targetDir, "SPEC.md");
+    if (isSpecComplete(specPath)) {
+      setIsComplete(true);
+      return;
+    }
+    const updatedSpec = loadSpecFromDir(targetDir);
+    if (updatedSpec) {
+      setSpec(updatedSpec);
+    }
+    if (currentIteration < totalIterations) {
+      setCurrentIteration((prev) => prev + 1);
+      setIterationKey((prev) => prev + 1);
+    } else {
+      setIsComplete(true);
+    }
+  }, [currentIteration, totalIterations, cwd]);
+  useEffect3(() => {
+    if (isComplete && !_mockIsComplete) {
+      const timer = setTimeout(() => {
+        exit();
+      }, 100);
+      return () => clearTimeout(timer);
+    }
+  }, [isComplete, exit, _mockIsComplete]);
+  if (isComplete) {
+    const totalDuration = results.reduce((acc, r) => acc + r.durationMs, 0);
+    const successCount = results.filter((r) => !r.error).length;
+    const errorCount = results.filter((r) => r.error).length;
+    const stats = aggregateStats(results);
+    return /* @__PURE__ */ jsxDEV11(Box11, {
+      flexDirection: "column",
+      children: [
+        /* @__PURE__ */ jsxDEV11(Box11, {
+          children: /* @__PURE__ */ jsxDEV11(Text10, {
+            color: "cyan",
+            children: "╔═══════════════════════════════════════════════════════╗"
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV11(Box11, {
+          children: [
+            /* @__PURE__ */ jsxDEV11(Text10, {
+              color: "cyan",
+              children: "║"
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV11(Text10, {
+              color: "green",
+              bold: true,
+              children: " ✓ All iterations complete"
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV11(Text10, {
+              color: "cyan",
+              children: "                              ║"
+            }, undefined, false, undefined, this)
+          ]
+        }, undefined, true, undefined, this),
+        /* @__PURE__ */ jsxDEV11(Box11, {
+          children: /* @__PURE__ */ jsxDEV11(Text10, {
+            color: "cyan",
+            children: "╠═══════════════════════════════════════════════════════╣"
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV11(Box11, {
+          children: [
+            /* @__PURE__ */ jsxDEV11(Text10, {
+              color: "cyan",
+              children: "║"
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV11(Text10, {
+              children: " Iterations: "
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV11(Text10, {
+              color: "green",
+              children: [
+                successCount,
+                " succeeded"
+              ]
+            }, undefined, true, undefined, this),
+            errorCount > 0 && /* @__PURE__ */ jsxDEV11(Fragment, {
+              children: [
+                /* @__PURE__ */ jsxDEV11(Text10, {
+                  children: ", "
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsxDEV11(Text10, {
+                  color: "red",
+                  children: [
+                    errorCount,
+                    " failed"
+                  ]
+                }, undefined, true, undefined, this)
+              ]
+            }, undefined, true, undefined, this),
+            /* @__PURE__ */ jsxDEV11(Text10, {
+              color: "cyan",
+              children: "                          ║"
+            }, undefined, false, undefined, this)
+          ]
+        }, undefined, true, undefined, this),
+        /* @__PURE__ */ jsxDEV11(Box11, {
+          children: [
+            /* @__PURE__ */ jsxDEV11(Text10, {
+              color: "cyan",
+              children: "║"
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV11(Text10, {
+              children: " Duration:   "
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV11(Text10, {
+              color: "yellow",
+              children: formatDuration3(totalDuration)
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV11(Text10, {
+              color: "cyan",
+              children: "                                        ║"
+            }, undefined, false, undefined, this)
+          ]
+        }, undefined, true, undefined, this),
+        /* @__PURE__ */ jsxDEV11(Box11, {
+          children: [
+            /* @__PURE__ */ jsxDEV11(Text10, {
+              color: "cyan",
+              children: "║"
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV11(Text10, {
+              children: " Tools:      "
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV11(Text10, {
+              children: [
+                stats.reads,
+                " reads, ",
+                stats.writes,
+                " writes, ",
+                stats.commands,
+                " commands"
+              ]
+            }, undefined, true, undefined, this),
+            /* @__PURE__ */ jsxDEV11(Text10, {
+              color: "cyan",
+              children: "    ║"
+            }, undefined, false, undefined, this)
+          ]
+        }, undefined, true, undefined, this),
+        /* @__PURE__ */ jsxDEV11(Box11, {
+          children: /* @__PURE__ */ jsxDEV11(Text10, {
+            color: "cyan",
+            children: "╚═══════════════════════════════════════════════════════╝"
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this),
+        results.map((result, idx) => {
+          const displayText = result.specTaskText ?? result.taskText ?? "Unknown task";
+          const truncatedText = displayText.length > 40 ? displayText.slice(0, 40) + "..." : displayText;
+          return /* @__PURE__ */ jsxDEV11(Box11, {
+            flexDirection: "column",
+            children: [
+              /* @__PURE__ */ jsxDEV11(Box11, {
+                children: [
+                  /* @__PURE__ */ jsxDEV11(Text10, {
+                    color: result.error ? "red" : "green",
+                    children: result.error ? "✗" : "✓"
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV11(Text10, {
+                    color: "cyan",
+                    children: [
+                      " ",
+                      result.taskNumber ?? result.iteration,
+                      ". "
+                    ]
+                  }, undefined, true, undefined, this),
+                  result.phaseName && /* @__PURE__ */ jsxDEV11(Text10, {
+                    color: "yellow",
+                    children: [
+                      "[",
+                      result.phaseName,
+                      "] "
+                    ]
+                  }, undefined, true, undefined, this),
+                  /* @__PURE__ */ jsxDEV11(Text10, {
+                    color: "gray",
+                    children: truncatedText
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV11(Text10, {
+                    color: "gray",
+                    children: [
+                      " (",
+                      formatDuration3(result.durationMs),
+                      ")"
+                    ]
+                  }, undefined, true, undefined, this)
+                ]
+              }, undefined, true, undefined, this),
+              result.error && /* @__PURE__ */ jsxDEV11(Box11, {
+                flexDirection: "column",
+                marginLeft: 2,
+                children: [
+                  /* @__PURE__ */ jsxDEV11(Box11, {
+                    children: [
+                      /* @__PURE__ */ jsxDEV11(Text10, {
+                        color: "red",
+                        children: "  Error: "
+                      }, undefined, false, undefined, this),
+                      /* @__PURE__ */ jsxDEV11(Text10, {
+                        color: "gray",
+                        children: [
+                          result.error.message.slice(0, 80),
+                          result.error.message.length > 80 ? "..." : ""
+                        ]
+                      }, undefined, true, undefined, this)
+                    ]
+                  }, undefined, true, undefined, this),
+                  result.failureContext?.lastToolName && /* @__PURE__ */ jsxDEV11(Box11, {
+                    children: [
+                      /* @__PURE__ */ jsxDEV11(Text10, {
+                        color: "yellow",
+                        children: "  Tool: "
+                      }, undefined, false, undefined, this),
+                      /* @__PURE__ */ jsxDEV11(Text10, {
+                        color: "gray",
+                        children: result.failureContext.lastToolName
+                      }, undefined, false, undefined, this)
+                    ]
+                  }, undefined, true, undefined, this),
+                  result.failureContext?.lastToolInput && /* @__PURE__ */ jsxDEV11(Box11, {
+                    children: [
+                      /* @__PURE__ */ jsxDEV11(Text10, {
+                        color: "yellow",
+                        children: "  Input: "
+                      }, undefined, false, undefined, this),
+                      /* @__PURE__ */ jsxDEV11(Text10, {
+                        color: "gray",
+                        children: [
+                          result.failureContext.lastToolInput.slice(0, 100),
+                          result.failureContext.lastToolInput.length > 100 ? "..." : ""
+                        ]
+                      }, undefined, true, undefined, this)
+                    ]
+                  }, undefined, true, undefined, this),
+                  result.failureContext?.lastToolOutput && /* @__PURE__ */ jsxDEV11(Box11, {
+                    children: [
+                      /* @__PURE__ */ jsxDEV11(Text10, {
+                        color: "yellow",
+                        children: "  Output: "
+                      }, undefined, false, undefined, this),
+                      /* @__PURE__ */ jsxDEV11(Text10, {
+                        color: "gray",
+                        children: [
+                          result.failureContext.lastToolOutput.slice(0, 150),
+                          result.failureContext.lastToolOutput.length > 150 ? "..." : ""
+                        ]
+                      }, undefined, true, undefined, this)
+                    ]
+                  }, undefined, true, undefined, this),
+                  result.failureContext?.recentActivity && result.failureContext.recentActivity.length > 0 && /* @__PURE__ */ jsxDEV11(Box11, {
+                    flexDirection: "column",
+                    children: [
+                      /* @__PURE__ */ jsxDEV11(Text10, {
+                        color: "yellow",
+                        children: "  Recent activity:"
+                      }, undefined, false, undefined, this),
+                      result.failureContext.recentActivity.map((activity, i) => /* @__PURE__ */ jsxDEV11(Box11, {
+                        marginLeft: 2,
+                        children: /* @__PURE__ */ jsxDEV11(Text10, {
+                          color: "gray",
+                          children: activity.slice(0, 80)
+                        }, undefined, false, undefined, this)
+                      }, i, false, undefined, this))
+                    ]
+                  }, undefined, true, undefined, this)
+                ]
+              }, undefined, true, undefined, this),
+              result.lastCommit && /* @__PURE__ */ jsxDEV11(Box11, {
+                marginLeft: 2,
+                children: [
+                  /* @__PURE__ */ jsxDEV11(Text10, {
+                    color: "green",
+                    children: "✓ "
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV11(Text10, {
+                    color: "yellow",
+                    children: result.lastCommit.hash.slice(0, 7)
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV11(Text10, {
+                    color: "gray",
+                    children: [
+                      " - ",
+                      result.lastCommit.message.slice(0, 50),
+                      result.lastCommit.message.length > 50 ? "..." : ""
+                    ]
+                  }, undefined, true, undefined, this)
+                ]
+              }, undefined, true, undefined, this)
+            ]
+          }, idx, true, undefined, this);
+        })
+      ]
+    }, undefined, true, undefined, this);
+  }
+  const currentTask = spec ? getTaskForIteration(spec, currentIteration) : null;
+  return /* @__PURE__ */ jsxDEV11(App, {
+    prompt,
+    iteration: currentIteration,
+    totalIterations,
+    cwd,
+    idleTimeoutMs,
+    saveJsonl,
+    model,
+    harness,
+    onIterationComplete: handleIterationComplete,
+    _mockState,
+    completedResults: results,
+    taskNumber: currentTask?.taskNumber ?? null,
+    phaseName: currentTask?.phaseName ?? null,
+    specTaskText: currentTask?.taskText ?? null
+  }, iterationKey, false, undefined, this);
+}
+
+// src/commands/init.ts
+import { existsSync as existsSync2, mkdirSync, copyFileSync, readdirSync, statSync } from "fs";
+import { join as join3, dirname } from "path";
+import { fileURLToPath } from "url";
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = dirname(__filename2);
+function getTemplatesDir() {
+  return join3(__dirname2, "..", "..", "templates");
+}
+function copyRecursive(src, dest, created, skipped) {
+  const entries = readdirSync(src);
+  for (const entry of entries) {
+    const srcPath = join3(src, entry);
+    const destPath = join3(dest, entry);
+    const stat = statSync(srcPath);
+    if (stat.isDirectory()) {
+      if (!existsSync2(destPath)) {
+        mkdirSync(destPath, { recursive: true });
+      }
+      copyRecursive(srcPath, destPath, created, skipped);
+    } else {
+      if (existsSync2(destPath)) {
+        skipped.push(destPath);
+      } else {
+        mkdirSync(dirname(destPath), { recursive: true });
+        copyFileSync(srcPath, destPath);
+        created.push(destPath);
+      }
+    }
+  }
+}
+function runInit(targetDir) {
+  const templatesDir = getTemplatesDir();
+  if (!existsSync2(templatesDir)) {
+    throw new Error(`Templates directory not found: ${templatesDir}`);
+  }
+  const created = [];
+  const skipped = [];
+  copyRecursive(templatesDir, targetDir, created, skipped);
+  return { created, skipped };
+}
+
+// src/commands/run.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join4 } from "path";
+import { execSync } from "child_process";
+function isGitRepo(cwd) {
+  try {
+    execSync("git rev-parse --is-inside-work-tree", { cwd, stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasUncommittedChanges(cwd) {
+  try {
+    const status = execSync("git status --porcelain", { cwd, encoding: "utf-8" });
+    return status.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+function validateProject(cwd) {
+  const errors = [];
+  const warnings = [];
+  if (isGitRepo(cwd) && hasUncommittedChanges(cwd)) {
+    errors.push("Uncommitted changes detected. Commit or stash before running Ralphie.");
+  }
+  const specPath = join4(cwd, "SPEC.md");
+  if (!existsSync3(specPath)) {
+    errors.push("SPEC.md not found. Create a SPEC.md with your project tasks.");
+  }
+  const ralphieMdPath = join4(cwd, ".claude", "ralphie.md");
+  if (!existsSync3(ralphieMdPath)) {
+    errors.push(".claude/ralphie.md not found. Run `ralphie init` first.");
+  }
+  const aiRalphiePath = join4(cwd, ".ai", "ralphie");
+  if (!existsSync3(aiRalphiePath)) {
+    errors.push(".ai/ralphie/ not found. Run `ralphie init` first.");
+  }
+  const valid = errors.length === 0;
+  return { valid, errors, warnings };
+}
+
+// src/commands/upgrade.ts
+import { existsSync as existsSync4, renameSync, mkdirSync as mkdirSync2, copyFileSync as copyFileSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { join as join5, dirname as dirname2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __filename3 = fileURLToPath2(import.meta.url);
+var __dirname3 = dirname2(__filename3);
+function getTemplatesDir2() {
+  return join5(__dirname3, "..", "..", "templates");
+}
+var CURRENT_VERSION = 2;
+var VERSION_DEFINITIONS = [
+  {
+    version: 1,
+    name: "v1 (PRD/progress.txt)",
+    indicators: ["PRD.md", "PRD", "progress.txt"]
+  },
+  {
+    version: 2,
+    name: "v2 (SPEC.md/STATE.txt)",
+    indicators: ["SPEC.md", "STATE.txt"]
+  }
+];
+function detectVersion(targetDir) {
+  const foundIndicators = [];
+  const legacyFiles = [];
+  let detectedVersion = null;
+  for (const versionDef of [...VERSION_DEFINITIONS].reverse()) {
+    const found = versionDef.indicators.filter((indicator) => existsSync4(join5(targetDir, indicator)));
+    if (found.length > 0) {
+      if (detectedVersion === null || versionDef.version > detectedVersion) {
+        detectedVersion = versionDef.version;
+      }
+      foundIndicators.push(...found);
+      if (versionDef.version < CURRENT_VERSION) {
+        legacyFiles.push(...found);
+      }
+    }
+  }
+  return {
+    detectedVersion,
+    foundIndicators: [...new Set(foundIndicators)],
+    isLatest: detectedVersion === CURRENT_VERSION,
+    hasLegacyFiles: legacyFiles.length > 0,
+    legacyFiles: [...new Set(legacyFiles)]
+  };
+}
+var migrations = {
+  "1->2": migrateV1ToV2
+};
+function migrateV1ToV2(targetDir, result) {
+  const prdPath = join5(targetDir, "PRD.md");
+  const prdAltPath = join5(targetDir, "PRD");
+  const specPath = join5(targetDir, "SPEC.md");
+  if (existsSync4(prdPath)) {
+    if (existsSync4(specPath)) {
+      result.warnings.push("Both PRD.md and SPEC.md exist - keeping both, please merge manually");
+    } else {
+      renameSync(prdPath, specPath);
+      result.renamed.push({ from: "PRD.md", to: "SPEC.md" });
+    }
+  } else if (existsSync4(prdAltPath)) {
+    if (existsSync4(specPath)) {
+      result.warnings.push("Both PRD and SPEC.md exist - keeping both, please merge manually");
+    } else {
+      renameSync(prdAltPath, specPath);
+      result.renamed.push({ from: "PRD", to: "SPEC.md" });
+    }
+  }
+  const progressPath = join5(targetDir, "progress.txt");
+  const statePath = join5(targetDir, "STATE.txt");
+  if (existsSync4(progressPath)) {
+    if (existsSync4(statePath)) {
+      result.warnings.push("Both progress.txt and STATE.txt exist - keeping both, please merge manually");
+    } else {
+      const progressContent = readFileSync2(progressPath, "utf-8");
+      const newContent = `# Progress Log
+
+${progressContent}`;
+      writeFileSync(statePath, newContent, "utf-8");
+      renameSync(progressPath, join5(targetDir, "progress.txt.bak"));
+      result.renamed.push({ from: "progress.txt", to: "STATE.txt" });
+    }
+  } else if (!existsSync4(statePath)) {
+    writeFileSync(statePath, `# Progress Log
+
+`, "utf-8");
+    result.created.push("STATE.txt");
+  }
+  ensureV2Structure(targetDir, result);
+}
+function ensureV2Structure(targetDir, result) {
+  const aiRalphieDir = join5(targetDir, ".ai", "ralphie");
+  if (!existsSync4(aiRalphieDir)) {
+    mkdirSync2(aiRalphieDir, { recursive: true });
+    result.created.push(".ai/ralphie/");
+  }
+  const gitkeepPath = join5(aiRalphieDir, ".gitkeep");
+  if (!existsSync4(gitkeepPath)) {
+    writeFileSync(gitkeepPath, "", "utf-8");
+    result.created.push(".ai/ralphie/.gitkeep");
+  }
+  const claudeDir = join5(targetDir, ".claude");
+  if (!existsSync4(claudeDir)) {
+    mkdirSync2(claudeDir, { recursive: true });
+  }
+  const ralphieMdDest = join5(claudeDir, "ralphie.md");
+  const templatesDir = getTemplatesDir2();
+  const ralphieMdSrc = join5(templatesDir, ".claude", "ralphie.md");
+  if (!existsSync4(ralphieMdDest)) {
+    if (existsSync4(ralphieMdSrc)) {
+      copyFileSync2(ralphieMdSrc, ralphieMdDest);
+      result.created.push(".claude/ralphie.md");
+    }
+  } else {
+    const existingContent = readFileSync2(ralphieMdDest, "utf-8");
+    const hasOldPatterns = /\bPRD\b/.test(existingContent) || /\bprogress\.txt\b/.test(existingContent);
+    if (hasOldPatterns) {
+      if (existsSync4(ralphieMdSrc)) {
+        copyFileSync2(ralphieMdSrc, ralphieMdDest);
+        result.renamed.push({ from: ".claude/ralphie.md (old)", to: ".claude/ralphie.md (v2)" });
+      }
+    } else {
+      result.skipped.push(".claude/ralphie.md (already v2)");
+    }
+  }
+  const claudeMdDest = join5(claudeDir, "CLAUDE.md");
+  if (existsSync4(claudeMdDest)) {
+    const existingContent = readFileSync2(claudeMdDest, "utf-8");
+    const hasOldPatterns = /\bPRD\b/.test(existingContent) || /\bprogress\.txt\b/.test(existingContent);
+    if (hasOldPatterns) {
+      result.warnings.push(".claude/CLAUDE.md contains old patterns (PRD/progress.txt) - update manually");
+    }
+  }
+}
+function getMigrationPath(fromVersion, toVersion) {
+  const path = [];
+  let current = fromVersion;
+  while (current < toVersion) {
+    const next = current + 1;
+    const key = `${current}->${next}`;
+    if (!migrations[key]) {
+      throw new Error(`No migration path from v${current} to v${next}`);
+    }
+    path.push(key);
+    current = next;
+  }
+  return path;
+}
+function runUpgrade(targetDir, targetVersion = CURRENT_VERSION) {
+  const detection = detectVersion(targetDir);
+  if (detection.detectedVersion === null) {
+    throw new Error("Could not detect project version. Is this a Ralphie project?");
+  }
+  if (detection.detectedVersion >= targetVersion) {
+    throw new Error(`Project is already at v${detection.detectedVersion} (target: v${targetVersion})`);
+  }
+  const result = {
+    fromVersion: detection.detectedVersion,
+    toVersion: targetVersion,
+    renamed: [],
+    created: [],
+    skipped: [],
+    warnings: []
+  };
+  const migrationPath = getMigrationPath(detection.detectedVersion, targetVersion);
+  for (const step of migrationPath) {
+    const migrationFn = migrations[step];
+    migrationFn(targetDir, result);
+  }
+  return result;
+}
+function getVersionName(version) {
+  const def = VERSION_DEFINITIONS.find((v) => v.version === version);
+  return def?.name ?? `v${version}`;
+}
+
+// src/lib/git.ts
+import { execSync as execSync2 } from "child_process";
+function getCurrentBranch(cwd) {
+  try {
+    return execSync2("git rev-parse --abbrev-ref HEAD", { cwd, encoding: "utf-8" }).trim();
+  } catch {
+    return null;
+  }
+}
+function isOnMainBranch(cwd) {
+  const branch = getCurrentBranch(cwd);
+  return branch === "main" || branch === "master";
+}
+function branchExists(cwd, branchName) {
+  try {
+    execSync2(`git rev-parse --verify ${branchName}`, { cwd, stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function slugifyTitle(title) {
+  return title.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 50);
+}
+function createFeatureBranch(cwd, title) {
+  if (!isOnMainBranch(cwd)) {
+    return { created: false, branchName: null, error: null };
+  }
+  const slug = slugifyTitle(title);
+  if (!slug) {
+    return { created: false, branchName: null, error: "Could not generate branch name from title" };
+  }
+  const branchName = `feat/${slug}`;
+  if (branchExists(cwd, branchName)) {
+    try {
+      execSync2(`git checkout ${branchName}`, { cwd, stdio: "pipe" });
+      return { created: false, branchName, error: null };
+    } catch {
+      return { created: false, branchName: null, error: `Failed to checkout ${branchName}` };
+    }
+  }
+  try {
+    execSync2(`git checkout -b ${branchName}`, { cwd, stdio: "pipe" });
+    return { created: true, branchName, error: null };
+  } catch {
+    return { created: false, branchName: null, error: `Failed to create branch ${branchName}` };
+  }
+}
+
+// src/lib/headless-emitter.ts
+function emit(event) {
+  console.log(JSON.stringify(event));
+}
+function emitStarted(spec, tasks, model, harness) {
+  emit({
+    event: "started",
+    spec,
+    tasks,
+    model,
+    harness,
+    timestamp: new Date().toISOString()
+  });
+}
+function emitIteration(n, phase) {
+  emit({ event: "iteration", n, phase });
+}
+function emitTool(type, path) {
+  emit({ event: "tool", type, path });
+}
+function emitCommit(hash, message) {
+  emit({ event: "commit", hash, message });
+}
+function emitTaskComplete(index, text) {
+  emit({ event: "task_complete", index, text });
+}
+function emitIterationDone(n, duration_ms, stats) {
+  emit({ event: "iteration_done", n, duration_ms, stats });
+}
+function emitStuck(reason, iterations_without_progress) {
+  emit({ event: "stuck", reason, iterations_without_progress });
+}
+function emitComplete(tasks_done, total_duration_ms) {
+  emit({ event: "complete", tasks_done, total_duration_ms });
+}
+function emitFailed(error) {
+  emit({ event: "failed", error });
+}
+function emitWarning(type, message, files) {
+  emit({ event: "warning", type, message, files });
+}
+
+// src/lib/headless-runner.ts
+import { readFileSync as readFileSync3, existsSync as existsSync5 } from "fs";
+import { join as join6 } from "path";
+var EXIT_CODE_COMPLETE = 0;
+var EXIT_CODE_STUCK = 1;
+var EXIT_CODE_MAX_ITERATIONS = 2;
+var EXIT_CODE_ERROR = 3;
+function getCompletedTaskTexts(cwd) {
+  const specPath = join6(cwd, "SPEC.md");
+  if (!existsSync5(specPath))
+    return [];
+  const content = readFileSync3(specPath, "utf-8");
+  const lines = content.split(`
+`);
+  const completedTasks = [];
+  for (const line of lines) {
+    const match = line.match(/^-\s*\[x\]\s+(.+)$/i);
+    if (match) {
+      completedTasks.push(match[1].trim());
+    }
+  }
+  return completedTasks;
+}
+function getTotalTaskCount(cwd) {
+  const specPath = join6(cwd, "SPEC.md");
+  if (!existsSync5(specPath))
+    return 0;
+  const content = readFileSync3(specPath, "utf-8");
+  const allTasks = content.match(/^-\s*\[[x\s]\]\s+/gim);
+  return allTasks ? allTasks.length : 0;
+}
+var TODO_PATTERNS = [
+  /\/\/\s*TODO:/i,
+  /\/\/\s*FIXME:/i,
+  /#\s*TODO:/i,
+  /#\s*FIXME:/i,
+  /throw new Error\(['"]Not implemented/i,
+  /raise NotImplementedError/i
+];
+function detectTodoStubs(cwd) {
+  const filesWithStubs = [];
+  try {
+    const { execSync: execSync3 } = __require("child_process");
+    const gitDiff = execSync3("git diff --name-only HEAD~1 HEAD 2>/dev/null || git diff --name-only HEAD", {
+      cwd,
+      encoding: "utf-8"
+    });
+    const changedFiles = gitDiff.split(`
+`).filter((f) => f.trim()).filter((f) => /\.(ts|tsx|js|jsx|py)$/.test(f));
+    for (const file of changedFiles) {
+      const filePath = join6(cwd, file);
+      if (!existsSync5(filePath))
+        continue;
+      try {
+        const content = readFileSync3(filePath, "utf-8");
+        const hasTodo = TODO_PATTERNS.some((pattern) => pattern.test(content));
+        if (hasTodo) {
+          filesWithStubs.push(file);
+        }
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+    return [];
+  }
+  return filesWithStubs;
+}
+async function runSingleIteration(options, iteration) {
+  const startTime = Date.now();
+  const harnessName = options.harness ?? "claude";
+  const harness = getHarness(harnessName);
+  const stats = {
+    toolsStarted: 0,
+    toolsCompleted: 0,
+    toolsErrored: 0,
+    reads: 0,
+    writes: 0,
+    commands: 0,
+    metaOps: 0
+  };
+  let commitHash;
+  let commitMessage;
+  let lastError;
+  const handleEvent = (event) => {
+    switch (event.type) {
+      case "tool_start": {
+        stats.toolsStarted++;
+        const category = getToolCategory(event.name);
+        if (category === "read")
+          stats.reads++;
+        else if (category === "write")
+          stats.writes++;
+        else if (category === "command")
+          stats.commands++;
+        else
+          stats.metaOps++;
+        const toolType = category === "read" ? "read" : category === "write" ? "write" : "bash";
+        emitTool(toolType, event.input);
+        break;
+      }
+      case "tool_end": {
+        stats.toolsCompleted++;
+        if (event.error)
+          stats.toolsErrored++;
+        if (event.name === "Bash" && event.output) {
+          const commitMatch = event.output.match(/\[[\w-]+\s+([a-f0-9]{7,40})\]\s+(.+)/);
+          if (commitMatch) {
+            commitHash = commitMatch[1];
+            commitMessage = commitMatch[2];
+            emitCommit(commitHash, commitMessage);
+          }
+        }
+        break;
+      }
+      case "error": {
+        lastError = new Error(event.message);
+        break;
+      }
+    }
+  };
+  try {
+    const result = await harness.run(options.prompt, {
+      cwd: options.cwd,
+      model: options.model
+    }, handleEvent);
+    if (!result.success && result.error) {
+      lastError = new Error(result.error);
+    }
+    return {
+      iteration,
+      durationMs: result.durationMs || Date.now() - startTime,
+      stats,
+      error: lastError,
+      commitHash,
+      commitMessage
+    };
+  } catch (err) {
+    return {
+      iteration,
+      durationMs: Date.now() - startTime,
+      stats,
+      error: err instanceof Error ? err : new Error(String(err)),
+      commitHash,
+      commitMessage
+    };
+  }
+}
+async function executeHeadlessRun(options) {
+  const totalTasks = getTotalTaskCount(options.cwd);
+  const harnessName = options.harness ?? "claude";
+  emitStarted("SPEC.md", totalTasks, options.model, harnessName);
+  let iterationsWithoutProgress = 0;
+  let tasksBefore = getCompletedTaskTexts(options.cwd);
+  const totalStartTime = Date.now();
+  let lastCompletedCount = tasksBefore.length;
+  for (let i = 1;i <= options.iterations; i++) {
+    emitIteration(i, "starting");
+    const result = await runSingleIteration(options, i);
+    if (result.error) {
+      emitFailed(result.error.message);
+      return EXIT_CODE_ERROR;
+    }
+    const tasksAfter = getCompletedTaskTexts(options.cwd);
+    const newlyCompleted = tasksAfter.filter((task) => !tasksBefore.includes(task));
+    for (let j = 0;j < newlyCompleted.length; j++) {
+      emitTaskComplete(lastCompletedCount + j + 1, newlyCompleted[j]);
+    }
+    if (newlyCompleted.length > 0) {
+      const filesWithStubs = detectTodoStubs(options.cwd);
+      if (filesWithStubs.length > 0) {
+        emitWarning("todo_stub", "Completed tasks contain TODO/FIXME stubs", filesWithStubs);
+      }
+    }
+    if (tasksAfter.length > tasksBefore.length) {
+      iterationsWithoutProgress = 0;
+      lastCompletedCount = tasksAfter.length;
+    } else {
+      iterationsWithoutProgress++;
+    }
+    if (result.commitHash && result.commitMessage) {
+      emitCommit(result.commitHash, result.commitMessage);
+    }
+    emitIterationDone(i, result.durationMs, result.stats);
+    if (iterationsWithoutProgress >= options.stuckThreshold) {
+      emitStuck("No task progress", iterationsWithoutProgress);
+      return EXIT_CODE_STUCK;
+    }
+    const specPath = join6(options.cwd, "SPEC.md");
+    if (isSpecComplete(specPath)) {
+      emitComplete(tasksAfter.length, Date.now() - totalStartTime);
+      return EXIT_CODE_COMPLETE;
+    }
+    tasksBefore = tasksAfter;
+  }
+  return EXIT_CODE_MAX_ITERATIONS;
+}
+
+// src/lib/spec-validator.ts
+import { readFileSync as readFileSync4, existsSync as existsSync6 } from "fs";
+import { join as join7 } from "path";
+var CODE_FENCE_PATTERN = /^```/;
+var FILE_LINE_PATTERN = /\b[\w/.-]+\.(ts|js|tsx|jsx|py|go|rs|java|rb|php|c|cpp|h|hpp):\d+/i;
+var SHELL_COMMAND_PATTERN = /^\s*[-•]\s*(npm|npx|yarn|pnpm|git|docker|kubectl|curl|wget|bash|sh|cd|mkdir|rm|cp|mv|cat|grep|awk|sed)\s+/i;
+var TECHNICAL_NOTES_PATTERN = /^#{1,4}\s*(Technical\s*Notes?|Implementation\s*Notes?|Fix\s*Approach|How\s*to\s*Fix)/i;
+var IMPLEMENTATION_KEYWORDS = [
+  /\buse\s+`[^`]+`\s+to\b/i,
+  /\bremove\s+(the|this)\s+(early\s+)?return\b/i,
+  /\badd\s+`[^`]+`\s+(flag|option|parameter)\b/i,
+  /\bchange\s+line\s+\d+\b/i,
+  /\breplace\s+`[^`]+`\s+with\s+`[^`]+`/i,
+  /\b(at|on|in)\s+line\s+\d+\b/i
+];
+function validateSpecContent(content) {
+  const violations = [];
+  const warnings = [];
+  const lines = content.split(`
+`);
+  let inCodeBlock = false;
+  let codeBlockStart = 0;
+  let codeBlockContent = [];
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    const lineNum = i + 1;
+    if (CODE_FENCE_PATTERN.test(line)) {
+      if (!inCodeBlock) {
+        inCodeBlock = true;
+        codeBlockStart = lineNum;
+        codeBlockContent = [];
+      } else {
+        if (codeBlockContent.length >= 1 && !isExampleBlock(lines, codeBlockStart - 1)) {
+          violations.push({
+            type: "code_snippet",
+            line: codeBlockStart,
+            content: codeBlockContent.slice(0, 3).join(`
+`) + (codeBlockContent.length > 3 ? `
+...` : ""),
+            message: "Code snippets belong in plan.md, not SPEC.md. Describe WHAT to build, not HOW."
+          });
+        }
+        inCodeBlock = false;
+        codeBlockContent = [];
+      }
+      continue;
+    }
+    if (inCodeBlock) {
+      codeBlockContent.push(line);
+      continue;
+    }
+    if (FILE_LINE_PATTERN.test(line)) {
+      violations.push({
+        type: "file_line_reference",
+        line: lineNum,
+        content: line.trim(),
+        message: "File:line references are implementation details. Describe the requirement instead."
+      });
+    }
+    if (SHELL_COMMAND_PATTERN.test(line)) {
+      violations.push({
+        type: "shell_command",
+        line: lineNum,
+        content: line.trim(),
+        message: "Shell commands are implementation details. Describe the outcome instead."
+      });
+    }
+    if (TECHNICAL_NOTES_PATTERN.test(line)) {
+      violations.push({
+        type: "technical_notes_section",
+        line: lineNum,
+        content: line.trim(),
+        message: '"Technical Notes" sections belong in plan.md. SPECs describe requirements only.'
+      });
+    }
+    for (const pattern of IMPLEMENTATION_KEYWORDS) {
+      if (pattern.test(line)) {
+        violations.push({
+          type: "implementation_instruction",
+          line: lineNum,
+          content: line.trim(),
+          message: "This looks like an implementation instruction. Describe the deliverable instead."
+        });
+        break;
+      }
+    }
+  }
+  return {
+    valid: violations.length === 0,
+    violations,
+    warnings
+  };
+}
+function isExampleBlock(lines, startIndex) {
+  for (let i = startIndex;i >= Math.max(0, startIndex - 3); i--) {
+    const line = lines[i].toLowerCase();
+    if (/\bexample\b/.test(line) || /^#+\s*(bad|good)\b/.test(line) || /\b(bad|good)\s+example\b/.test(line)) {
+      return true;
+    }
+  }
+  return false;
+}
+function validateSpec(specPath) {
+  if (!existsSync6(specPath)) {
+    return {
+      valid: false,
+      violations: [],
+      warnings: [`SPEC.md not found at ${specPath}`]
+    };
+  }
+  const content = readFileSync4(specPath, "utf-8");
+  return validateSpecContent(content);
+}
+function validateSpecInDir(dir) {
+  const specPath = join7(dir, "SPEC.md");
+  return validateSpec(specPath);
+}
+function formatViolation(v) {
+  return `Line ${v.line}: [${v.type}]
+  ${v.content}
+  → ${v.message}`;
+}
+function formatValidationResult(result) {
+  if (result.valid && result.warnings.length === 0) {
+    return "✓ SPEC.md follows conventions";
+  }
+  const parts = [];
+  if (result.warnings.length > 0) {
+    parts.push("Warnings:");
+    parts.push(...result.warnings.map((w) => `  ⚠ ${w}`));
+  }
+  if (result.violations.length > 0) {
+    parts.push(`
+Found ${result.violations.length} violation(s):
+`);
+    parts.push(...result.violations.map((v) => formatViolation(v)));
+  }
+  return parts.join(`
+`);
+}
+
+// src/lib/spec-generator.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync7, readFileSync as readFileSync5 } from "fs";
+import { join as join8 } from "path";
+var SPEC_GENERATION_PROMPT = `You are generating a SPEC.md for a Ralphie project. Your task is to create a well-structured specification based on the user's description.
+
+## Your Task
+
+Create a SPEC.md file based on this project description:
+
+{DESCRIPTION}
+
+## Process
+
+1. **Analyze the description** - Understand what's being requested
+2. **Explore the codebase FIRST** - Before designing tasks, understand what exists:
+   - Read README.md, CLAUDE.md, and any docs/*.md for project context
+   - Run \`ls\` and \`tree\` to see project structure
+   - Use Glob to find relevant files (e.g., \`**/*.ts\`, \`**/routes/*\`)
+   - Read key files to understand existing patterns, conventions, and architecture
+   - Identify what can be reused vs. what needs to be created
+   - Note how similar features are implemented
+3. **Design tasks that integrate** - Tasks should fit with existing code:
+   - Follow existing naming conventions
+   - Use existing shared utilities/types
+   - Match existing patterns (e.g., if all routes are in /routes, new ones go there too)
+4. **Write SPEC.md** - Create the spec file following the rules below
+5. **Validate** - Ensure the spec follows conventions
+
+## SPEC Format
+
+\`\`\`markdown
+# Project Name
+
+Brief description (1-2 sentences).
+
+## Goal
+What this project achieves when complete.
+
+## Tasks
+
+### Phase 1: Foundation
+- [ ] Task description
+  - Deliverable 1
+  - Deliverable 2
+
+### Phase 2: Core Features
+- [ ] Another task
+  - Deliverable 1
+\`\`\`
+
+## Critical Rules - What NOT to Include
+
+SPECs describe **requirements**, not solutions. NEVER include:
+
+- ❌ Code snippets or implementation examples
+- ❌ File:line references (e.g., \`auth.ts:42\`)
+- ❌ Shell commands (\`npm install X\`, \`git log\`)
+- ❌ Root cause analysis ("The bug is because...")
+- ❌ "Technical Notes" or "Fix Approach" sections
+- ❌ Implementation instructions ("Use X to...", "Change line Y")
+
+## Sub-bullets are Deliverables, NOT Instructions
+
+\`\`\`markdown
+# BAD - prescribes HOW
+- [ ] Fix auth bug
+  - Use \`bcrypt.compare()\` instead of \`===\`
+  - Add try/catch at line 50
+
+# GOOD - describes WHAT
+- [ ] Fix auth bug
+  - Password comparison should be timing-safe
+  - Handle comparison errors gracefully
+\`\`\`
+
+## Task Batching
+
+Each checkbox = one Ralphie iteration. Batch related work:
+
+\`\`\`markdown
+# BAD - 4 iterations
+- [ ] Create UserModel.ts
+- [ ] Create UserService.ts
+- [ ] Create UserController.ts
+- [ ] Create user.test.ts
+
+# GOOD - 1 iteration
+- [ ] Create User module (Model, Service, Controller) with tests
+\`\`\`
+
+## Verification Steps
+
+Each task SHOULD include a **Verify:** section with concrete checks:
+
+\`\`\`markdown
+- [ ] Implement authentication system
+  - POST /auth/register - create user with hashed password
+  - POST /auth/login - validate credentials, return JWT
+  - Tests for all auth flows
+
+  **Verify:**
+  - \`curl -X POST localhost:3000/auth/register -d '{"email":"test@test.com","password":"test123"}'\` → 201
+  - \`curl -X POST localhost:3000/auth/login -d '{"email":"test@test.com","password":"test123"}'\` → returns JWT
+  - \`npm test\` → all tests pass
+\`\`\`
+
+Good verification steps:
+- API calls with expected response codes
+- CLI commands with expected output
+- File existence checks (\`ls dist/\` → contains index.js)
+- Test commands (\`npm test\` → all pass)
+
+## Output
+
+After writing SPEC.md, output a summary:
+- Number of phases
+- Number of tasks
+- Estimated complexity`;
+var HEADLESS_ADDENDUM = `
+
+Do NOT ask questions. Make reasonable assumptions based on the description. If something is ambiguous, choose the simpler option.
+
+Write the SPEC.md now.`;
+function emitJson(event) {
+  console.log(JSON.stringify({ ...event, timestamp: new Date().toISOString() }));
+}
+async function generateSpec(options) {
+  if (options.autonomous) {
+    return generateSpecAutonomous(options);
+  }
+  const useSkill = !options.headless;
+  const prompt = useSkill ? `/create-spec
+
+Description: ${options.description}` : SPEC_GENERATION_PROMPT.replace("{DESCRIPTION}", options.description) + HEADLESS_ADDENDUM;
+  if (options.headless) {
+    emitJson({ event: "spec_generation_started", description: options.description });
+  } else {
+    console.log(`Generating SPEC for: ${options.description}
+`);
+  }
+  if (!options.headless) {
+    return generateSpecInteractive(options, prompt);
+  }
+  return generateSpecHeadless(options, prompt);
+}
+async function generateSpecInteractive(options, prompt) {
+  return new Promise((resolve) => {
+    const args = [
+      "--dangerously-skip-permissions",
+      ...options.model ? ["--model", options.model] : []
+    ];
+    const proc = spawn("claude", args, {
+      cwd: options.cwd,
+      env: process.env,
+      stdio: ["pipe", "inherit", "inherit"]
+    });
+    proc.stdin?.write(prompt + `
+`);
+    process.stdin.setRawMode?.(false);
+    process.stdin.resume();
+    process.stdin.pipe(proc.stdin);
+    const timeout = setTimeout(() => {
+      proc.kill("SIGTERM");
+      resolve({
+        success: false,
+        error: `Timeout: no progress for ${options.timeoutMs / 1000}s`
+      });
+    }, options.timeoutMs);
+    proc.on("close", (code) => {
+      clearTimeout(timeout);
+      process.stdin.unpipe(proc.stdin);
+      process.stdin.pause();
+      const specPath = join8(options.cwd, "SPEC.md");
+      if (existsSync7(specPath)) {
+        const content = readFileSync5(specPath, "utf-8");
+        const taskCount = (content.match(/^- \[ \]/gm) || []).length;
+        const validation = validateSpecInDir(options.cwd);
+        const validationOutput = formatValidationResult(validation);
+        console.log(`
+Validation:`);
+        console.log(validationOutput);
+        resolve({
+          success: true,
+          specPath,
+          taskCount,
+          validationPassed: validation.valid,
+          validationOutput
+        });
+      } else {
+        resolve({
+          success: false,
+          error: code === 0 ? "SPEC.md was not created" : `Claude exited with code ${code}`
+        });
+      }
+    });
+  });
+}
+async function generateSpecHeadless(options, prompt) {
+  return new Promise((resolve) => {
+    const args = [
+      "--dangerously-skip-permissions",
+      "--output-format",
+      "stream-json",
+      "--verbose",
+      ...options.model ? ["--model", options.model] : [],
+      "-p",
+      prompt
+    ];
+    const proc = spawn("claude", args, {
+      cwd: options.cwd,
+      env: process.env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    proc.stdin?.end();
+    let output = "";
+    let lastOutput = Date.now();
+    const timeout = setTimeout(() => {
+      proc.kill("SIGTERM");
+      resolve({
+        success: false,
+        error: `Timeout: no progress for ${options.timeoutMs / 1000}s`
+      });
+    }, options.timeoutMs);
+    proc.stdout?.on("data", (data) => {
+      lastOutput = Date.now();
+      output += data.toString();
+      if (!options.headless) {
+        const lines = data.toString().split(`
+`);
+        for (const line of lines) {
+          if (line.trim()) {
+            try {
+              const parsed = JSON.parse(line);
+              if (parsed.type === "assistant" && parsed.message?.content) {
+                for (const block of parsed.message.content) {
+                  if (block.type === "text") {
+                    process.stdout.write(".");
+                  } else if (block.type === "tool_use") {
+                    process.stdout.write(`
+[${block.name}] `);
+                  }
+                }
+              }
+            } catch {}
+          }
+        }
+      }
+    });
+    proc.stderr?.on("data", (data) => {
+      lastOutput = Date.now();
+      if (!options.headless) {
+        process.stderr.write(data);
+      }
+    });
+    proc.on("close", (code) => {
+      clearTimeout(timeout);
+      if (!options.headless) {
+        console.log(`
+`);
+      }
+      const specPath = join8(options.cwd, "SPEC.md");
+      if (!existsSync7(specPath)) {
+        if (options.headless) {
+          emitJson({ event: "spec_generation_failed", error: "SPEC.md was not created" });
+        }
+        resolve({
+          success: false,
+          error: "SPEC.md was not created"
+        });
+        return;
+      }
+      const specContent = readFileSync5(specPath, "utf-8");
+      const taskMatches = specContent.match(/^-\s*\[\s*\]\s+/gm);
+      const taskCount = taskMatches ? taskMatches.length : 0;
+      const validation = validateSpecInDir(options.cwd);
+      const validationOutput = formatValidationResult(validation);
+      if (options.headless) {
+        emitJson({
+          event: "spec_generation_complete",
+          specPath,
+          taskCount,
+          validationPassed: validation.valid,
+          violations: validation.violations.length
+        });
+      } else {
+        console.log(`SPEC.md created with ${taskCount} tasks
+`);
+        console.log("Validation:");
+        console.log(validationOutput);
+      }
+      resolve({
+        success: true,
+        specPath,
+        taskCount,
+        validationPassed: validation.valid,
+        validationOutput
+      });
+    });
+    proc.on("error", (err) => {
+      clearTimeout(timeout);
+      if (options.headless) {
+        emitJson({ event: "spec_generation_failed", error: err.message });
+      }
+      resolve({
+        success: false,
+        error: err.message
+      });
+    });
+  });
+}
+async function runReviewSpec(specPath, cwd, model) {
+  return new Promise((resolve) => {
+    const args = [
+      "--dangerously-skip-permissions",
+      "--output-format",
+      "stream-json",
+      "--verbose",
+      ...model ? ["--model", model] : [],
+      "-p",
+      `/review-spec ${specPath}`
+    ];
+    const proc = spawn("claude", args, {
+      cwd,
+      env: process.env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    proc.stdin?.end();
+    let output = "";
+    proc.stdout?.on("data", (data) => {
+      output += data.toString();
+    });
+    proc.on("close", () => {
+      const result = parseReviewOutput(output);
+      resolve(result);
+    });
+    proc.on("error", () => {
+      resolve({
+        passed: false,
+        concerns: ["Failed to run review-spec skill"],
+        fullOutput: output
+      });
+    });
+  });
+}
+function parseReviewOutput(output) {
+  const passMatch = /SPEC Review:\s*PASS/i.test(output);
+  const failMatch = /SPEC Review:\s*FAIL/i.test(output);
+  if (passMatch && !failMatch) {
+    return {
+      passed: true,
+      concerns: [],
+      fullOutput: output
+    };
+  }
+  const concerns = [];
+  const formatSection = output.match(/## Format Issues\s+([\s\S]*?)(?=##|$)/i);
+  if (formatSection) {
+    concerns.push(`Format issues found:
+` + formatSection[1].trim());
+  }
+  const contentSection = output.match(/## Content Concerns\s+([\s\S]*?)(?=##|$)/i);
+  if (contentSection) {
+    concerns.push(`Content concerns:
+` + contentSection[1].trim());
+  }
+  const recommendationsSection = output.match(/## Recommendations\s+([\s\S]*?)(?=##|$)/i);
+  if (recommendationsSection) {
+    concerns.push(`Recommendations:
+` + recommendationsSection[1].trim());
+  }
+  return {
+    passed: false,
+    concerns: concerns.length > 0 ? concerns : ["Review failed but no specific concerns extracted"],
+    fullOutput: output
+  };
+}
+async function refineSpec(description, currentSpec, concerns, cwd, model) {
+  const refinementPrompt = `You previously generated a SPEC.md that has issues. Please revise it based on this feedback:
+
+${concerns.join(`
+
+`)}
+
+Original Description: ${description}
+
+Current SPEC content:
+${currentSpec}
+
+Generate an improved SPEC.md that addresses all the concerns above. Write the updated SPEC.md to the file.`;
+  return new Promise((resolve) => {
+    const args = [
+      "--dangerously-skip-permissions",
+      "--output-format",
+      "stream-json",
+      "--verbose",
+      ...model ? ["--model", model] : [],
+      "-p",
+      refinementPrompt
+    ];
+    const proc = spawn("claude", args, {
+      cwd,
+      env: process.env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    proc.stdin?.end();
+    proc.on("close", (code) => {
+      const specPath = join8(cwd, "SPEC.md");
+      resolve(code === 0 && existsSync7(specPath));
+    });
+    proc.on("error", () => {
+      resolve(false);
+    });
+  });
+}
+async function generateSpecAutonomous(options) {
+  const maxAttempts = options.maxAttempts ?? 3;
+  const specPath = join8(options.cwd, "SPEC.md");
+  if (options.headless) {
+    emitJson({ event: "autonomous_spec_started", description: options.description, maxAttempts });
+  } else {
+    console.log(`Generating SPEC autonomously: ${options.description}`);
+    console.log(`Max attempts: ${maxAttempts}
+`);
+  }
+  if (!options.headless) {
+    console.log("Attempt 1: Generating initial SPEC...");
+  }
+  const initialPrompt = SPEC_GENERATION_PROMPT.replace("{DESCRIPTION}", options.description) + HEADLESS_ADDENDUM;
+  const initialResult = await generateSpecHeadless({ ...options, headless: true }, initialPrompt);
+  if (!initialResult.success) {
+    if (options.headless) {
+      emitJson({ event: "autonomous_spec_failed", error: initialResult.error, attempts: 1 });
+    }
+    return {
+      ...initialResult,
+      attempts: 1
+    };
+  }
+  for (let attempt = 1;attempt <= maxAttempts; attempt++) {
+    if (!options.headless) {
+      console.log(`
+Attempt ${attempt}: Running review...`);
+    }
+    if (options.headless) {
+      emitJson({ event: "autonomous_review_started", attempt });
+    }
+    const reviewResult = await runReviewSpec(specPath, options.cwd, options.model);
+    if (reviewResult.passed) {
+      if (!options.headless) {
+        console.log(`
+✓ Review passed on attempt ${attempt}!`);
+      }
+      if (options.headless) {
+        emitJson({ event: "autonomous_spec_complete", attempts: attempt, reviewPassed: true });
+      }
+      return {
+        success: true,
+        specPath,
+        taskCount: initialResult.taskCount,
+        validationPassed: initialResult.validationPassed,
+        reviewPassed: true,
+        attempts: attempt
+      };
+    }
+    if (!options.headless) {
+      console.log(`✗ Review failed on attempt ${attempt}`);
+      console.log("Concerns:");
+      for (const concern of reviewResult.concerns) {
+        console.log(`  - ${concern.split(`
+`)[0]}`);
+      }
+    }
+    if (options.headless) {
+      emitJson({
+        event: "autonomous_review_failed",
+        attempt,
+        concerns: reviewResult.concerns.length
+      });
+    }
+    if (attempt === maxAttempts) {
+      if (options.headless) {
+        emitJson({
+          event: "autonomous_spec_failed",
+          error: "Max attempts reached without passing review",
+          attempts: maxAttempts
+        });
+      } else {
+        console.log(`
+✗ Failed to generate valid SPEC after ${maxAttempts} attempts`);
+      }
+      return {
+        success: false,
+        error: `Max attempts (${maxAttempts}) reached without passing review`,
+        reviewPassed: false,
+        attempts: maxAttempts
+      };
+    }
+    if (!options.headless) {
+      console.log(`
+Attempt ${attempt + 1}: Refining SPEC...`);
+    }
+    const currentSpec = readFileSync5(specPath, "utf-8");
+    const refined = await refineSpec(options.description, currentSpec, reviewResult.concerns, options.cwd, options.model);
+    if (!refined) {
+      if (options.headless) {
+        emitJson({
+          event: "autonomous_spec_failed",
+          error: "Refinement failed",
+          attempts: attempt + 1
+        });
+      }
+      return {
+        success: false,
+        error: "Failed to refine SPEC",
+        attempts: attempt + 1
+      };
+    }
+  }
+  return {
+    success: false,
+    error: "Unexpected error in autonomous generation",
+    attempts: maxAttempts
+  };
+}
+
+// src/lib/config-loader.ts
+import fs from "fs";
+import path from "path";
+import yaml from "js-yaml";
+var VALID_HARNESSES = ["claude", "codex"];
+function getHarnessName(cliHarness, cwd) {
+  const candidates = [
+    cliHarness,
+    process.env.RALPH_HARNESS,
+    loadConfig(cwd)?.harness
+  ];
+  for (const candidate of candidates) {
+    if (candidate && VALID_HARNESSES.includes(candidate)) {
+      return candidate;
+    }
+  }
+  return "claude";
+}
+function loadConfig(cwd) {
+  const configPath = path.join(cwd, ".ralphie", "config.yml");
+  try {
+    if (!fs.existsSync(configPath)) {
+      return null;
+    }
+    const content = fs.readFileSync(configPath, "utf-8");
+    const config = yaml.load(content);
+    return config;
+  } catch (error) {
+    return null;
+  }
+}
+
+// src/cli.tsx
+import { jsxDEV as jsxDEV12 } from "react/jsx-dev-runtime";
+var __filename4 = fileURLToPath3(import.meta.url);
+var __dirname4 = dirname3(__filename4);
+function getVersion() {
+  try {
+    let pkgPath = join9(__dirname4, "..", "package.json");
+    if (!existsSync8(pkgPath)) {
+      pkgPath = join9(__dirname4, "..", "..", "package.json");
+    }
+    const pkg = JSON.parse(readFileSync6(pkgPath, "utf-8"));
+    return pkg.version || "1.0.0";
+  } catch {
+    return "1.0.0";
+  }
+}
+var DEFAULT_PROMPT = `You are Ralphie, an autonomous coding assistant.
+
+## Your Task
+Complete ONE checkbox from SPEC.md per iteration. Sub-bullets under a checkbox are implementation details - complete ALL of them before marking the checkbox done.
+
+## The Loop
+1. Read SPEC.md to find the next incomplete task (check STATE.txt if unsure)
+2. Write plan to .ai/ralphie/plan.md:
+   - Goal: one sentence
+   - Files: what you'll create/modify
+   - Tests: what you'll test
+   - Exit criteria: how you know you're done
+3. Implement the task with tests
+4. Run tests and type checks
+5. Mark checkbox complete in SPEC.md
+6. Commit with clear message
+7. Update .ai/ralphie/index.md (append commit summary) and STATE.txt
+
+## Memory Files
+- .ai/ralphie/plan.md - Current task plan (overwrite each iteration)
+- .ai/ralphie/index.md - Commit log (append after each commit)
+
+## Rules
+- Plan BEFORE coding
+- Tests BEFORE marking complete
+- Commit AFTER each task
+- No TODO/FIXME stubs in completed tasks`;
+var GREEDY_PROMPT = `You are Ralphie, an autonomous coding assistant in GREEDY MODE.
+
+## Your Task
+Complete AS MANY checkboxes as possible from SPEC.md before context fills up.
+
+## The Loop (repeat until done or context full)
+1. Read SPEC.md to find the next incomplete task
+2. Write plan to .ai/ralphie/plan.md
+3. Implement the task with tests
+4. Run tests and type checks
+5. Mark checkbox complete in SPEC.md
+6. Commit with clear message
+7. Update .ai/ralphie/index.md and STATE.txt
+8. **CONTINUE to next task** (don't stop!)
+
+## Memory Files
+- .ai/ralphie/plan.md - Current task plan (overwrite each task)
+- .ai/ralphie/index.md - Commit log (append after each commit)
+
+## Rules
+- Commit after EACH task (saves progress incrementally)
+- Keep going until all tasks done OR context is filling up
+- No TODO/FIXME stubs in completed tasks
+- The goal is maximum throughput - don't stop after one task`;
+var MAX_ALL_ITERATIONS = 100;
+function resolvePrompt(options) {
+  if (options.prompt) {
+    return options.prompt;
+  }
+  if (options.promptFile) {
+    const filePath = resolve(options.cwd, options.promptFile);
+    if (!existsSync8(filePath)) {
+      throw new Error(`Prompt file not found: ${filePath}`);
+    }
+    return readFileSync6(filePath, "utf-8");
+  }
+  return options.greedy ? GREEDY_PROMPT : DEFAULT_PROMPT;
+}
+function executeRun(options) {
+  const validation = validateProject(options.cwd);
+  if (!validation.valid) {
+    console.error("Cannot run Ralphie:");
+    for (const error of validation.errors) {
+      console.error(`  - ${error}`);
+    }
+    process.exit(1);
+  }
+  if (!options.noBranch) {
+    const specPath = join9(options.cwd, "SPEC.md");
+    const title = getSpecTitle(specPath);
+    if (title) {
+      const result = createFeatureBranch(options.cwd, title);
+      if (result.created) {
+        console.log(`Created branch: ${result.branchName}`);
+      } else if (result.branchName) {
+        console.log(`Using branch: ${result.branchName}`);
+      } else if (result.error) {
+        console.warn(`Warning: ${result.error}`);
+      }
+    }
+  }
+  const prompt = resolvePrompt(options);
+  const idleTimeoutMs = options.timeoutIdle * 1000;
+  const harness = options.harness ? getHarnessName(options.harness, options.cwd) : undefined;
+  const { waitUntilExit, unmount } = render(/* @__PURE__ */ jsxDEV12(IterationRunner, {
+    prompt,
+    totalIterations: options.iterations,
+    cwd: options.cwd,
+    idleTimeoutMs,
+    saveJsonl: options.saveJsonl,
+    model: options.model,
+    harness
+  }, undefined, false, undefined, this));
+  const handleSignal = () => {
+    unmount();
+    process.exit(0);
+  };
+  process.on("SIGINT", handleSignal);
+  process.on("SIGTERM", handleSignal);
+  waitUntilExit().then(() => {
+    process.exit(0);
+  });
+}
+async function executeHeadlessRun2(options) {
+  const validation = validateProject(options.cwd);
+  if (!validation.valid) {
+    emitFailed(`Invalid project: ${validation.errors.join(", ")}`);
+    process.exit(3);
+  }
+  const prompt = resolvePrompt(options);
+  const harness = options.harness ? getHarnessName(options.harness, options.cwd) : undefined;
+  const exitCode = await executeHeadlessRun({
+    prompt,
+    cwd: options.cwd,
+    iterations: options.iterations,
+    stuckThreshold: options.stuckThreshold,
+    idleTimeoutMs: options.timeoutIdle * 1000,
+    saveJsonl: options.saveJsonl,
+    model: options.model,
+    harness
+  });
+  process.exit(exitCode);
+}
+function main() {
+  const program = new Command;
+  program.name("ralphie").description("Autonomous AI coding loops").version(getVersion());
+  program.command("init").description("Initialize Ralphie in the current directory").argument("[directory]", "Target directory", process.cwd()).action((directory) => {
+    const targetDir = resolve(directory);
+    console.log(`Initializing Ralphie in ${targetDir}...
+`);
+    try {
+      const result = runInit(targetDir);
+      if (result.created.length > 0) {
+        console.log("Created:");
+        for (const file of result.created) {
+          console.log(`  + ${file}`);
+        }
+      }
+      if (result.skipped.length > 0) {
+        console.log(`
+Skipped (already exist):`);
+        for (const file of result.skipped) {
+          console.log(`  - ${file}`);
+        }
+      }
+      console.log(`
+Ralphie initialized! Next steps:`);
+      console.log("  1. Create SPEC.md with your project tasks");
+      console.log("  2. Run: ralphie run");
+    } catch (error) {
+      console.error("Error:", error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+  program.command("run").description("Run Ralphie iterations").option("-n, --iterations <number>", "Number of iterations to run", "1").option("-a, --all", "Run until all PRD tasks are complete (max 100 iterations)").option("-p, --prompt <text>", "Prompt to send to Claude").option("--prompt-file <path>", "Read prompt from file").option("--cwd <path>", "Working directory for Claude", process.cwd()).option("--timeout-idle <seconds>", "Kill process after N seconds of no output", "120").option("--save-jsonl <path>", "Save raw JSONL output to file").option("--quiet", "Suppress output (just run iterations)", false).option("--title <text>", "Override task title display").option("--no-branch", "Skip feature branch creation").option("--headless", "Output JSON events instead of UI").option("--stuck-threshold <n>", "Iterations without progress before stuck (headless)", "3").option("-m, --model <name>", "Claude model to use (sonnet, opus, haiku)", "sonnet").option("--harness <name>", "AI harness to use (claude, codex)").option("-g, --greedy", "Complete multiple tasks per iteration until context fills").action((opts) => {
+    let iterations = parseInt(opts.iterations, 10);
+    const all = opts.all ?? false;
+    if (all) {
+      iterations = MAX_ALL_ITERATIONS;
+      console.log(`Running until PRD complete (max ${MAX_ALL_ITERATIONS} iterations)...
+`);
+    }
+    const options = {
+      iterations,
+      all,
+      prompt: opts.prompt,
+      promptFile: opts.promptFile,
+      cwd: resolve(opts.cwd),
+      timeoutIdle: parseInt(opts.timeoutIdle, 10),
+      saveJsonl: opts.saveJsonl,
+      quiet: opts.quiet,
+      title: opts.title,
+      noBranch: opts.branch === false,
+      headless: opts.headless ?? false,
+      stuckThreshold: parseInt(opts.stuckThreshold, 10),
+      model: opts.model,
+      harness: opts.harness,
+      greedy: opts.greedy ?? false
+    };
+    if (options.headless) {
+      executeHeadlessRun2(options);
+    } else {
+      executeRun(options);
+    }
+  });
+  program.command("validate").description("Check if current directory is ready for Ralphie and validate SPEC.md conventions").option("--cwd <path>", "Working directory to check", process.cwd()).option("--spec-only", "Only validate SPEC.md content (skip project structure check)", false).action((opts) => {
+    const cwd = resolve(opts.cwd);
+    let hasErrors = false;
+    if (!opts.specOnly) {
+      const projectResult = validateProject(cwd);
+      if (!projectResult.valid) {
+        console.log("Project structure issues:");
+        for (const error of projectResult.errors) {
+          console.log(`  - ${error}`);
+        }
+        hasErrors = true;
+      } else {
+        console.log("✓ Project structure is valid");
+      }
+    }
+    const specResult = validateSpecInDir(cwd);
+    console.log(`
+SPEC.md content validation:`);
+    console.log(formatValidationResult(specResult));
+    if (!specResult.valid) {
+      hasErrors = true;
+    }
+    if (hasErrors) {
+      process.exit(1);
+    }
+  });
+  program.command("spec").description("Generate a SPEC.md autonomously from a description").argument("<description>", 'What to build (e.g., "REST API for user management")').option("--cwd <path>", "Working directory", process.cwd()).option("--headless", "Output JSON events instead of UI", false).option("--auto", "Autonomous mode with review loop (no user interaction)", false).option("--timeout <seconds>", "Timeout for generation", "300").option("--max-attempts <n>", "Max refinement attempts in autonomous mode", "3").option("-m, --model <name>", "Claude model to use (sonnet, opus, haiku)", "opus").action(async (description, opts) => {
+    const cwd = resolve(opts.cwd);
+    const result = await generateSpec({
+      description,
+      cwd,
+      headless: opts.headless ?? false,
+      autonomous: opts.auto ?? false,
+      timeoutMs: parseInt(opts.timeout, 10) * 1000,
+      maxAttempts: parseInt(opts.maxAttempts, 10),
+      model: opts.model
+    });
+    if (!result.success) {
+      if (!opts.headless) {
+        console.error(`Failed: ${result.error}`);
+      }
+      process.exit(1);
+    }
+    if (!result.validationPassed && !opts.headless) {
+      console.log("\nWarning: SPEC has convention violations. Run `ralphie validate` for details.");
+    }
+    process.exit(0);
+  });
+  program.command("upgrade").description(`Upgrade a Ralphie project to the latest version (v${CURRENT_VERSION})`).argument("[directory]", "Target directory", process.cwd()).option("--dry-run", "Show what would be changed without making changes", false).option("--clean", "Remove legacy files after confirming project is at latest version", false).action((directory, opts) => {
+    const targetDir = resolve(directory);
+    const detection = detectVersion(targetDir);
+    if (detection.detectedVersion === null) {
+      console.log("Could not detect Ralphie project version.");
+      console.log("If this is a new project, use: ralphie init");
+      return;
+    }
+    if (detection.isLatest && !detection.hasLegacyFiles) {
+      const claudeDir = resolve(targetDir, ".claude");
+      const ralphieMdPath = resolve(claudeDir, "ralphie.md");
+      if (existsSync8(ralphieMdPath)) {
+        const content = readFileSync6(ralphieMdPath, "utf-8");
+        const hasOldPatterns = /\bPRD\b/.test(content) || /\bprogress\.txt\b/.test(content);
+        if (hasOldPatterns) {
+          console.log(`Project is at ${getVersionName(detection.detectedVersion)} but .claude/ralphie.md has old patterns.`);
+          if (opts.clean) {
+            const templatesDir = resolve(__dirname4, "..", "templates");
+            const templatePath = resolve(templatesDir, ".claude", "ralphie.md");
+            if (existsSync8(templatePath)) {
+              copyFileSync3(templatePath, ralphieMdPath);
+              console.log("Updated .claude/ralphie.md to v2 template.");
+            }
+          } else {
+            console.log("Run with --clean to update it.");
+          }
+          return;
+        }
+      }
+      console.log(`Project is already at ${getVersionName(detection.detectedVersion)} (latest)`);
+      return;
+    }
+    if (detection.isLatest && detection.hasLegacyFiles) {
+      console.log(`Project is at ${getVersionName(detection.detectedVersion)} but has legacy files:`);
+      for (const file of detection.legacyFiles) {
+        console.log(`  - ${file}`);
+      }
+      console.log(`
+Run with --clean to remove them, or delete manually.`);
+      if (opts.clean) {
+        console.log(`
+Cleaning up legacy files...`);
+        for (const file of detection.legacyFiles) {
+          const filePath = resolve(targetDir, file);
+          try {
+            unlinkSync(filePath);
+            console.log(`  Removed: ${file}`);
+          } catch {
+            console.log(`  Failed to remove: ${file}`);
+          }
+        }
+        console.log(`
+Cleanup complete!`);
+      }
+      return;
+    }
+    console.log(`Detected: ${getVersionName(detection.detectedVersion)}`);
+    console.log(`Target:   ${getVersionName(CURRENT_VERSION)}
+`);
+    console.log(`Found files: ${detection.foundIndicators.join(", ")}
+`);
+    if (opts.dryRun) {
+      console.log("Dry run - would upgrade from:");
+      console.log(`  ${getVersionName(detection.detectedVersion)} → ${getVersionName(CURRENT_VERSION)}`);
+      return;
+    }
+    try {
+      const result = runUpgrade(targetDir);
+      console.log(`Upgraded: v${result.fromVersion} → v${result.toVersion}
+`);
+      if (result.renamed.length > 0) {
+        console.log("Renamed:");
+        for (const { from, to } of result.renamed) {
+          console.log(`  ${from} → ${to}`);
+        }
+      }
+      if (result.created.length > 0) {
+        console.log(`
+Created:`);
+        for (const file of result.created) {
+          console.log(`  + ${file}`);
+        }
+      }
+      if (result.skipped.length > 0) {
+        console.log(`
+Skipped:`);
+        for (const file of result.skipped) {
+          console.log(`  - ${file}`);
+        }
+      }
+      if (result.warnings.length > 0) {
+        console.log(`
+Warnings:`);
+        for (const warning of result.warnings) {
+          console.log(`  ⚠ ${warning}`);
+        }
+      }
+      console.log(`
+Upgrade complete! Run: ralphie validate`);
+    } catch (error) {
+      console.error("Error:", error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+  if (process.argv.length === 2) {
+    program.help();
+  }
+  program.parse(process.argv);
+}
+if (true) {
+  main();
+}
+export {
+  resolvePrompt,
+  executeRun,
+  executeHeadlessRun2 as executeHeadlessRun,
+  MAX_ALL_ITERATIONS,
+  GREEDY_PROMPT,
+  DEFAULT_PROMPT
+};