ralphflow 0.2.0 → 0.4.0

package/dist/ralphflow.js

@@ -1,8 +1,20 @@
 #!/usr/bin/env node
+import {
+  getDb,
+  incrementIteration,
+  isLoopComplete,
+  listFlows,
+  loadConfig,
+  markLoopComplete,
+  markLoopRunning,
+  resolveFlowDir,
+  resolveLoop,
+  showStatus
+} from "./chunk-GVOJO5IN.js";
 
 // src/cli/index.ts
-import { Command as Command4 } from "commander";
-import chalk7 from "chalk";
+import { Command as Command6 } from "commander";
+import chalk8 from "chalk";
 
 // src/cli/init.ts
 import { Command } from "commander";
@@ -72,7 +84,7 @@ async function initProject(cwd, options = {}) {
     return;
   }
   if (existsSync2(ralphFlowDir)) {
-    const existing = listFlows(ralphFlowDir);
+    const existing = listFlows2(ralphFlowDir);
     if (existing.length > 0 && !options.template) {
       console.log();
       console.log(chalk.bold("  Existing flows:"));
@@ -115,7 +127,7 @@ async function initProject(cwd, options = {}) {
   console.log(chalk.dim(`  Next: npx ralphflow run story --flow ${flowName}`));
   console.log();
 }
-function listFlows(ralphFlowDir) {
+function listFlows2(ralphFlowDir) {
   try {
     return readdirSync(ralphFlowDir, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".")).map((d) => d.name);
   } catch {
@@ -141,143 +153,30 @@ import { Command as Command2 } from "commander";
 import chalk4 from "chalk";
 
 // src/core/runner.ts
-import { readFileSync as readFileSync3 } from "fs";
-import { join as join4 } from "path";
+import { readFileSync as readFileSync2, existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync, readdirSync as readdirSync2, unlinkSync } from "fs";
+import { join as join3, basename } from "path";
 import chalk3 from "chalk";
 
-// src/core/config.ts
-import { readFileSync as readFileSync2, existsSync as existsSync3, readdirSync as readdirSync2 } from "fs";
-import { join as join3 } from "path";
-import { parse as parseYaml } from "yaml";
-var LOOP_ALIASES = {
-  // code-implementation aliases
-  story: "story-loop",
-  stories: "story-loop",
-  tasks: "tasks-loop",
-  task: "tasks-loop",
-  delivery: "delivery-loop",
-  deliver: "delivery-loop",
-  // research aliases
-  discovery: "discovery-loop",
-  discover: "discovery-loop",
-  research: "research-loop",
-  document: "document-loop",
-  doc: "document-loop"
-};
-function listFlows2(cwd) {
-  const baseDir = join3(cwd, ".ralph-flow");
-  if (!existsSync3(baseDir)) return [];
-  return readdirSync2(baseDir, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".")).filter((d) => existsSync3(join3(baseDir, d.name, "ralphflow.yaml"))).map((d) => d.name);
-}
-function resolveFlowDir(cwd, flowName) {
-  const baseDir = join3(cwd, ".ralph-flow");
-  if (!existsSync3(baseDir)) {
-    throw new Error("No .ralph-flow/ found. Run `npx ralphflow init` first.");
-  }
-  const flows = listFlows2(cwd);
-  if (flows.length === 0) {
-    throw new Error("No flows found in .ralph-flow/. Run `npx ralphflow init` first.");
-  }
-  if (flowName) {
-    if (!flows.includes(flowName)) {
-      throw new Error(`Flow "${flowName}" not found. Available: ${flows.join(", ")}`);
-    }
-    return join3(baseDir, flowName);
-  }
-  if (flows.length === 1) {
-    return join3(baseDir, flows[0]);
-  }
-  throw new Error(
-    `Multiple flows found: ${flows.join(", ")}. Use --flow <name> to specify which one.`
-  );
-}
-function loadConfig(flowDir) {
-  const configPath = join3(flowDir, "ralphflow.yaml");
-  if (!existsSync3(configPath)) {
-    throw new Error(`No ralphflow.yaml found in ${flowDir}`);
-  }
-  const raw = readFileSync2(configPath, "utf-8");
-  const config = parseYaml(raw);
-  if (!config.name) {
-    throw new Error('ralphflow.yaml: missing required field "name"');
-  }
-  if (!config.loops || Object.keys(config.loops).length === 0) {
-    throw new Error('ralphflow.yaml: missing required field "loops"');
-  }
-  if (!config.dir) {
-    config.dir = ".ralph-flow";
-  }
-  return config;
-}
-function resolveLoop(config, name) {
-  if (config.loops[name]) {
-    return { key: name, loop: config.loops[name] };
-  }
-  const aliased = LOOP_ALIASES[name.toLowerCase()];
-  if (aliased && config.loops[aliased]) {
-    return { key: aliased, loop: config.loops[aliased] };
-  }
-  for (const [key, loop] of Object.entries(config.loops)) {
-    if (key.startsWith(name) || loop.name.toLowerCase().includes(name.toLowerCase())) {
-      return { key, loop };
-    }
-  }
-  const available = Object.keys(config.loops).join(", ");
-  throw new Error(`Unknown loop "${name}". Available: ${available}`);
-}
-
 // src/core/claude.ts
 import { spawn } from "child_process";
 async function spawnClaude(options) {
-  const { prompt, model, printMode = false, agentName, cwd } = options;
-  const args = [];
-  if (printMode) {
-    args.push("-p");
-    args.push("--dangerously-skip-permissions");
-  }
+  const { prompt, model, cwd } = options;
+  const args = ["--dangerously-skip-permissions", prompt];
   if (model) {
-    args.push("--model", model);
+    args.unshift("--model", model);
   }
   return new Promise((resolve, reject) => {
     const child = spawn("claude", args, {
       cwd,
-      stdio: printMode ? ["pipe", "pipe", "pipe"] : ["pipe", "pipe", "inherit"],
+      stdio: "inherit",
       env: { ...process.env }
     });
-    let output = "";
-    child.stdout?.on("data", (data) => {
-      const text = data.toString();
-      output += text;
-      if (agentName) {
-        const lines = text.split("\n");
-        for (const line of lines) {
-          if (line) {
-            process.stdout.write(`[${agentName}] ${line}
-`);
-          }
-        }
-      } else {
-        process.stdout.write(text);
-      }
-    });
-    if (printMode && child.stderr) {
-      child.stderr.on("data", (data) => {
-        const text = data.toString();
-        if (agentName) {
-          process.stderr.write(`[${agentName}] ${text}`);
-        } else {
-          process.stderr.write(text);
-        }
-      });
-    }
-    child.stdin?.write(prompt);
-    child.stdin?.end();
     child.on("error", (err) => {
       reject(new Error(`Failed to spawn claude: ${err.message}`));
     });
     child.on("close", (code, signal) => {
       resolve({
-        output,
+        output: "",
         exitCode: code,
         signal
       });
@@ -286,41 +185,138 @@ async function spawnClaude(options) {
 }
 
 // src/core/runner.ts
-var AGENT_COLORS = [
-  chalk3.cyan,
-  chalk3.magenta,
-  chalk3.yellow,
-  chalk3.green,
-  chalk3.blue,
-  chalk3.red
-];
+function agentsDir(flowDir, loop) {
+  const loopDir = join3(flowDir, loop.tracker, "..");
+  return join3(loopDir, ".agents");
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function cleanStaleAgents(dir) {
+  if (!existsSync3(dir)) return;
+  for (const file of readdirSync2(dir)) {
+    if (!file.endsWith(".lock")) continue;
+    const pidStr = readFileSync2(join3(dir, file), "utf-8").trim();
+    const pid = parseInt(pidStr, 10);
+    if (isNaN(pid) || !isProcessAlive(pid)) {
+      unlinkSync(join3(dir, file));
+    }
+  }
+}
+function acquireAgentId(dir, maxAgents) {
+  mkdirSync2(dir, { recursive: true });
+  cleanStaleAgents(dir);
+  for (let n = 1; n <= maxAgents; n++) {
+    const lockFile = join3(dir, `agent-${n}.lock`);
+    if (!existsSync3(lockFile)) {
+      writeFileSync(lockFile, String(process.pid));
+      return `agent-${n}`;
+    }
+  }
+  throw new Error(`All ${maxAgents} agent slots are occupied. Wait for one to finish or increase max_agents.`);
+}
+function releaseAgentId(dir, agentName) {
+  const lockFile = join3(dir, `${agentName}.lock`);
+  try {
+    unlinkSync(lockFile);
+  } catch {
+  }
+}
+function checkTrackerForCompletion(flowDir, loop) {
+  const trackerPath = join3(flowDir, loop.tracker);
+  if (!existsSync3(trackerPath)) return false;
+  const content = readFileSync2(trackerPath, "utf-8");
+  return content.includes(`<promise>${loop.completion}</promise>`) || content.includes(loop.completion);
+}
+function checkTrackerMetadataCompletion(flowDir, loop) {
+  const trackerPath = join3(flowDir, loop.tracker);
+  if (!existsSync3(trackerPath)) return false;
+  const content = readFileSync2(trackerPath, "utf-8");
+  const completedMatch = content.match(/^- completed_(?:tasks|stories): \[(.+)\]$/m);
+  if (!completedMatch) return false;
+  const completedItems = completedMatch[1].split(",").map((s) => s.trim()).filter(Boolean);
+  if (completedItems.length === 0) return false;
+  const inProgressLines = content.match(/\{[^}]*status:\s*in_progress[^}]*\}/g);
+  if (inProgressLines && inProgressLines.length > 0) return false;
+  const pendingLines = content.match(/\{[^}]*status:\s*pending[^}]*\}/g);
+  if (pendingLines && pendingLines.length > 0) return false;
+  return true;
+}
+function checkTrackerCheckboxes(flowDir, loop) {
+  const trackerPath = join3(flowDir, loop.tracker);
+  if (!existsSync3(trackerPath)) return false;
+  const content = readFileSync2(trackerPath, "utf-8");
+  const checked = (content.match(/- \[x\]/gi) || []).length;
+  const unchecked = (content.match(/- \[ \]/g) || []).length;
+  return checked > 0 && unchecked === 0;
+}
 async function runLoop(loopName, options) {
   const flowDir = resolveFlowDir(options.cwd, options.flow);
   const config = loadConfig(flowDir);
   const { key, loop } = resolveLoop(config, loopName);
-  const isMultiAgent = options.agents > 1 && loop.multi_agent !== false;
+  let agentName;
+  let agentDir;
+  if (options.multiAgent) {
+    if (loop.multi_agent === false) {
+      throw new Error(`Loop "${loop.name}" does not support multi-agent mode.`);
+    }
+    const ma = loop.multi_agent;
+    agentDir = agentsDir(flowDir, loop);
+    agentName = acquireAgentId(agentDir, ma.max_agents);
+  }
   console.log();
   console.log(
-    chalk3.bold(`  RalphFlow \u2014 ${loop.name}`) + (isMultiAgent ? chalk3.dim(` (${options.agents} agents)`) : "")
+    chalk3.bold(`  RalphFlow \u2014 ${loop.name}`) + (agentName ? chalk3.dim(` [${agentName}]`) : "")
   );
   console.log();
-  if (isMultiAgent) {
-    await runMultiAgent(loop, flowDir, options);
-  } else {
-    await runSingleAgent(loop, flowDir, options);
+  const cleanup = () => {
+    if (agentDir && agentName) {
+      releaseAgentId(agentDir, agentName);
+    }
+  };
+  process.on("exit", cleanup);
+  process.on("SIGINT", () => {
+    cleanup();
+    process.exit(130);
+  });
+  process.on("SIGTERM", () => {
+    cleanup();
+    process.exit(143);
+  });
+  try {
+    await iterationLoop(loop, flowDir, options, agentName);
+  } finally {
+    cleanup();
   }
 }
-async function runSingleAgent(loop, flowDir, options) {
+async function iterationLoop(loop, flowDir, options, agentName, db, flowName) {
+  const loopKey = loop.name;
   for (let i = 1; i <= options.maxIterations; i++) {
-    console.log(chalk3.dim(`  Iteration ${i}/${options.maxIterations}`));
-    const prompt = readPrompt(loop, flowDir, options.agentName);
+    if (db && flowName && isLoopComplete(db, flowName, loopKey)) {
+      console.log(chalk3.green(`  \u2713 ${loop.name} \u2014 already complete`));
+      return;
+    }
+    if (checkTrackerForCompletion(flowDir, loop) || checkTrackerCheckboxes(flowDir, loop) || checkTrackerMetadataCompletion(flowDir, loop)) {
+      if (db && flowName) markLoopComplete(db, flowName, loopKey);
+      console.log(chalk3.green(`  \u2713 ${loop.name} \u2014 complete`));
+      return;
+    }
+    const label = agentName ? chalk3.dim(`  [${agentName}] Iteration ${i}/${options.maxIterations}`) : chalk3.dim(`  Iteration ${i}/${options.maxIterations}`);
+    console.log(label);
+    const prompt = readPrompt(loop, flowDir, agentName);
     const result = await spawnClaude({
       prompt,
       model: options.model,
-      printMode: false,
       cwd: options.cwd
     });
-    if (result.output.includes(`<promise>${loop.completion}</promise>`)) {
+    if (db && flowName) incrementIteration(db, flowName, loopKey);
+    if (checkTrackerForCompletion(flowDir, loop) || checkTrackerCheckboxes(flowDir, loop) || checkTrackerMetadataCompletion(flowDir, loop)) {
+      if (db && flowName) markLoopComplete(db, flowName, loopKey);
       console.log();
       console.log(chalk3.green(`  Loop complete: ${loop.completion}`));
       return;
@@ -330,68 +326,66 @@ async function runSingleAgent(loop, flowDir, options) {
       console.log();
       continue;
     }
-    if (result.exitCode !== 0 && result.exitCode !== null) {
-      console.log(chalk3.red(`  Claude exited with code ${result.exitCode}`));
-      return;
+    if (result.exitCode === 0 || result.exitCode === null) {
+      console.log(chalk3.dim(`  Iteration ${i} finished, continuing...`));
+      console.log();
+      continue;
     }
-    console.log(chalk3.dim(`  Iteration ${i} finished, continuing...`));
-    console.log();
+    console.log(chalk3.red(`  Claude exited with code ${result.exitCode}`));
+    return;
   }
   console.log(chalk3.yellow(`  Max iterations (${options.maxIterations}) reached.`));
 }
-async function runMultiAgent(loop, flowDir, options) {
-  const agentCount = options.agents;
-  let completed = false;
-  const agentRunners = Array.from({ length: agentCount }, (_, idx) => {
-    const agentNum = idx + 1;
-    const agentName = `agent-${agentNum}`;
-    const colorFn = AGENT_COLORS[idx % AGENT_COLORS.length];
-    return runAgentLoop(loop, flowDir, {
-      ...options,
-      agentName
-    }, colorFn, () => completed, () => {
-      completed = true;
-    });
-  });
-  await Promise.allSettled(agentRunners);
+async function runAllLoops(options) {
+  const flowDir = resolveFlowDir(options.cwd, options.flow);
+  const config = loadConfig(flowDir);
+  const sortedLoops = Object.entries(config.loops).sort(([, a], [, b]) => a.order - b.order);
+  console.log();
+  console.log(chalk3.bold("  RalphFlow \u2014 Running all loops"));
   console.log();
-  console.log(chalk3.green(`  All agents finished.`));
+  for (const [key, loop] of sortedLoops) {
+    console.log(chalk3.bold(`  Starting: ${loop.name}`));
+    await iterationLoop(loop, flowDir, options);
+  }
+  console.log(chalk3.green("  All loops complete."));
 }
-async function runAgentLoop(loop, flowDir, options, colorFn, isCompleted, setCompleted) {
-  const agentName = options.agentName;
-  for (let i = 1; i <= options.maxIterations; i++) {
-    if (isCompleted()) {
-      console.log(colorFn(`  [${agentName}] Stopping \u2014 completion detected.`));
-      return;
-    }
-    console.log(colorFn(`  [${agentName}] Iteration ${i}/${options.maxIterations}`));
-    const prompt = readPrompt(loop, flowDir, agentName);
-    const result = await spawnClaude({
-      prompt,
-      model: options.model,
-      printMode: true,
-      agentName,
-      cwd: options.cwd
-    });
-    if (result.output.includes(`<promise>${loop.completion}</promise>`)) {
-      console.log(colorFn(`  [${agentName}] Loop complete: ${loop.completion}`));
-      setCompleted();
-      return;
+async function runE2E(options) {
+  const flowDir = resolveFlowDir(options.cwd, options.flow);
+  const config = loadConfig(flowDir);
+  const flowName = options.flow || basename(flowDir);
+  const db = getDb(options.cwd);
+  const sortedLoops = Object.entries(config.loops).sort(([, a], [, b]) => a.order - b.order);
+  console.log();
+  console.log(chalk3.bold("  RalphFlow \u2014 E2E"));
+  console.log();
+  for (const [key, loop] of sortedLoops) {
+    const loopKey = loop.name;
+    if (isLoopComplete(db, flowName, loopKey)) {
+      console.log(chalk3.green(`  \u2713 ${loop.name} \u2014 complete, skipping`));
+      continue;
     }
-    if (result.signal === "SIGINT" || result.exitCode === 130) {
-      console.log(colorFn(`  [${agentName}] Iteration ${i} complete, restarting...`));
+    if (checkTrackerForCompletion(flowDir, loop) || checkTrackerCheckboxes(flowDir, loop) || checkTrackerMetadataCompletion(flowDir, loop)) {
+      markLoopComplete(db, flowName, loopKey);
+      console.log(chalk3.green(`  \u2713 ${loop.name} \u2014 complete, skipping`));
       continue;
     }
-    if (result.exitCode !== 0 && result.exitCode !== null) {
-      console.log(chalk3.red(`  [${agentName}] Claude exited with code ${result.exitCode}`));
-      return;
+    markLoopRunning(db, flowName, loopKey);
+    console.log(chalk3.bold(`  \u2192 ${loop.name}`));
+    await iterationLoop(loop, flowDir, options, void 0, db, flowName);
+    if (isLoopComplete(db, flowName, loopKey)) {
+      console.log(chalk3.green(`  \u2713 ${loop.name} \u2014 done`));
+    } else {
+      console.log(chalk3.yellow(`  \u26A0 ${loop.name} \u2014 max iterations, advancing`));
     }
+    console.log();
   }
-  console.log(chalk3.yellow(`  [${agentName}] Max iterations reached.`));
+  console.log(chalk3.green("  \u2713 E2E complete"));
 }
 function readPrompt(loop, flowDir, agentName) {
-  const promptPath = join4(flowDir, loop.prompt);
-  let prompt = readFileSync3(promptPath, "utf-8");
+  const promptPath = join3(flowDir, loop.prompt);
+  let prompt = readFileSync2(promptPath, "utf-8");
+  const appName = basename(flowDir);
+  prompt = prompt.replaceAll("{{APP_NAME}}", appName);
   if (agentName && loop.multi_agent !== false) {
     const ma = loop.multi_agent;
     if (ma.agent_placeholder) {
@@ -402,10 +396,15 @@ function readPrompt(loop, flowDir, agentName) {
 }
 
 // src/cli/run.ts
-var runCommand = new Command2("run").description("Run a loop").argument("<loop>", "Loop to run (story, tasks, delivery, discovery, research, document)").option("-a, --agents <n>", "Number of parallel agents", "1").option("-m, --model <model>", "Claude model to use").option("-n, --max-iterations <n>", "Maximum iterations", "30").option("-f, --flow <name>", "Which flow to run (auto-detected if only one)").action(async (loop, opts) => {
+var runCommand = new Command2("run").description("Run a loop").argument("<loop>", "Loop to run (story, tasks, delivery, discovery, research, document)").option("--multi-agent", "Run as a multi-agent instance (auto-assigns agent ID)").option("-m, --model <model>", "Claude model to use").option("-n, --max-iterations <n>", "Maximum iterations", "30").option("-f, --flow <name>", "Which flow to run (auto-detected if only one)").option("--ui", "Start web dashboard alongside execution").action(async (loop, opts) => {
   try {
+    let dashboardHandle;
+    if (opts.ui) {
+      const { startDashboard } = await import("./server-O6J52DZT.js");
+      dashboardHandle = await startDashboard({ cwd: process.cwd() });
+    }
     await runLoop(loop, {
-      agents: parseInt(opts.agents, 10),
+      multiAgent: !!opts.multiAgent,
       model: opts.model,
       maxIterations: parseInt(opts.maxIterations, 10),
       flow: opts.flow,
@@ -420,137 +419,36 @@ var runCommand = new Command2("run").description("Run a loop").argument("<loop>"
   }
 });
 
-// src/cli/status.ts
+// src/cli/e2e.ts
 import { Command as Command3 } from "commander";
-import chalk6 from "chalk";
-
-// src/core/status.ts
-import { readFileSync as readFileSync4, existsSync as existsSync4 } from "fs";
-import { join as join5 } from "path";
 import chalk5 from "chalk";
-import Table from "cli-table3";
-async function showStatus(cwd, flowName) {
-  const flows = flowName ? [flowName] : listFlows2(cwd);
-  if (flows.length === 0) {
-    console.log();
-    console.log(chalk5.yellow("  No flows found. Run `npx ralphflow init` first."));
-    console.log();
-    return;
-  }
-  for (const flow of flows) {
-    const flowDir = resolveFlowDir(cwd, flow);
-    const config = loadConfig(flowDir);
-    console.log();
-    console.log(chalk5.bold(`  RalphFlow \u2014 ${flow}`));
-    console.log();
-    const table = new Table({
-      chars: {
-        top: "",
-        "top-mid": "",
-        "top-left": "",
-        "top-right": "",
-        bottom: "",
-        "bottom-mid": "",
-        "bottom-left": "",
-        "bottom-right": "",
-        left: "  ",
-        "left-mid": "",
-        mid: "",
-        "mid-mid": "",
-        right: "",
-        "right-mid": "",
-        middle: "  "
-      },
-      style: { "padding-left": 0, "padding-right": 1 },
-      head: [
-        chalk5.dim("Loop"),
-        chalk5.dim("Stage"),
-        chalk5.dim("Active"),
-        chalk5.dim("Progress")
-      ]
-    });
-    const sortedLoops = Object.entries(config.loops).sort(([, a], [, b]) => a.order - b.order);
-    for (const [key, loop] of sortedLoops) {
-      const status = parseTracker(loop.tracker, flowDir, loop.name);
-      table.push([
-        loop.name,
-        status.stage,
-        status.active,
-        `${status.completed}/${status.total}`
-      ]);
-      if (status.agents && status.agents.length > 0) {
-        for (const agent of status.agents) {
-          table.push([
-            chalk5.dim(`  ${agent.name}`),
-            chalk5.dim(agent.stage),
-            chalk5.dim(agent.activeTask),
-            chalk5.dim(agent.lastHeartbeat)
-          ]);
-        }
-      }
-    }
-    console.log(table.toString());
-  }
-  console.log();
-}
-function parseTracker(trackerPath, flowDir, loopName) {
-  const fullPath = join5(flowDir, trackerPath);
-  const status = {
-    loop: loopName,
-    stage: "\u2014",
-    active: "none",
-    completed: 0,
-    total: 0
-  };
-  if (!existsSync4(fullPath)) {
-    return status;
-  }
-  const content = readFileSync4(fullPath, "utf-8");
-  const lines = content.split("\n");
-  for (const line of lines) {
-    const metaMatch = line.match(/^- (\w[\w_]*): (.+)$/);
-    if (metaMatch) {
-      const [, key, value] = metaMatch;
-      if (key === "stage") status.stage = value.trim();
-      if (key === "active_story" || key === "active_task") status.active = value.trim();
-      if (key === "completed_stories" || key === "completed_tasks") {
-        const arrayMatch = value.match(/\[(.+)\]/);
-        if (arrayMatch) {
-          status.completed = arrayMatch[1].split(",").filter((s) => s.trim()).length;
-        }
-      }
-    }
-  }
-  const unchecked = (content.match(/- \[ \]/g) || []).length;
-  const checked = (content.match(/- \[x\]/gi) || []).length;
-  if (unchecked + checked > 0) {
-    status.total = unchecked + checked;
-    status.completed = checked;
-  }
-  const agentTableMatch = content.match(/\| agent \|.*\n\|[-|]+\n((?:\|.*\n)*)/);
-  if (agentTableMatch) {
-    const agentRows = agentTableMatch[1].trim().split("\n");
-    status.agents = [];
-    for (const row of agentRows) {
-      const cells = row.split("|").map((s) => s.trim()).filter(Boolean);
-      if (cells.length >= 4) {
-        status.agents.push({
-          name: cells[0],
-          activeTask: cells[1],
-          stage: cells[2],
-          lastHeartbeat: cells[3]
-        });
-      }
-    }
-    if (status.agents.length === 0) {
-      status.agents = void 0;
+var e2eCommand = new Command3("e2e").description("Run all loops end-to-end with SQLite orchestration (skips completed loops)").option("-m, --model <model>", "Claude model to use").option("-n, --max-iterations <n>", "Maximum iterations per loop", "30").option("-f, --flow <name>", "Which flow to run (auto-detected if only one)").option("--ui", "Start web dashboard alongside execution").action(async (opts) => {
+  try {
+    let dashboardHandle;
+    if (opts.ui) {
+      const { startDashboard } = await import("./server-O6J52DZT.js");
+      dashboardHandle = await startDashboard({ cwd: process.cwd() });
     }
+    await runE2E({
+      multiAgent: false,
+      model: opts.model,
+      maxIterations: parseInt(opts.maxIterations, 10),
+      flow: opts.flow,
+      cwd: process.cwd()
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(chalk5.red(`
+  ${msg}
+`));
+    process.exit(1);
   }
-  return status;
-}
+});
 
 // src/cli/status.ts
-var statusCommand = new Command3("status").description("Show pipeline status").option("-f, --flow <name>", "Show status for a specific flow").action(async (opts) => {
+import { Command as Command4 } from "commander";
+import chalk6 from "chalk";
+var statusCommand = new Command4("status").description("Show pipeline status").option("-f, --flow <name>", "Show status for a specific flow").action(async (opts) => {
   try {
     await showStatus(process.cwd(), opts.flow);
   } catch (err) {
@@ -562,18 +460,170 @@ var statusCommand = new Command3("status").description("Show pipeline status").o
   }
 });
 
+// src/cli/dashboard.ts
+import { Command as Command5 } from "commander";
+var dashboardCommand = new Command5("dashboard").alias("ui").description("Start the web dashboard").option("-p, --port <port>", "Port number", "4242").action(async (opts) => {
+  const { startDashboard } = await import("./server-O6J52DZT.js");
+  await startDashboard({ cwd: process.cwd(), port: parseInt(opts.port, 10) });
+});
+
+// src/cli/menu.ts
+import { select, input, confirm } from "@inquirer/prompts";
+import chalk7 from "chalk";
+async function interactiveMenu(cwd) {
+  console.log();
+  console.log(chalk7.bold("  RalphFlow"));
+  console.log();
+  try {
+    const flows = listFlows(cwd);
+    if (flows.length === 0) {
+      const action = await select({
+        message: "What would you like to do?",
+        choices: [
+          { name: "Initialize a new app", value: "init" }
+        ]
+      });
+      if (action === "init") {
+        await handleInit(cwd);
+      }
+    } else {
+      const action = await select({
+        message: "What would you like to do?",
+        choices: [
+          { name: "Run end-to-end", value: "e2e" },
+          { name: "Run a loop", value: "run" },
+          { name: "Run all loops in sequence", value: "run-all" },
+          { name: "Initialize a new app", value: "init" },
+          { name: "Check status", value: "status" },
+          { name: "Open dashboard", value: "dashboard" }
+        ]
+      });
+      switch (action) {
+        case "e2e":
+          await handleE2E(cwd, flows);
+          break;
+        case "run":
+          await handleRunLoop(cwd, flows);
+          break;
+        case "run-all":
+          await handleRunAll(cwd, flows);
+          break;
+        case "init":
+          await handleInit(cwd);
+          break;
+        case "status":
+          await handleStatus(cwd);
+          break;
+        case "dashboard":
+          await handleDashboard(cwd);
+          break;
+      }
+    }
+  } catch (err) {
+    if (err && typeof err === "object" && "name" in err && err.name === "ExitPromptError") {
+      console.log();
+      console.log(chalk7.dim("  Cancelled."));
+      process.exit(0);
+    }
+    throw err;
+  }
+}
+var TEMPLATES2 = ["code-implementation", "research"];
+async function handleInit(cwd) {
+  const template = await select({
+    message: "Which template?",
+    choices: TEMPLATES2.map((t) => ({ name: t, value: t }))
+  });
+  const name = await input({
+    message: "Flow name?",
+    default: template
+  });
+  await initProject(cwd, { template, name });
+  const shouldRun = await confirm({
+    message: "Run the first loop now?",
+    default: true
+  });
+  if (shouldRun) {
+    const flowDir = resolveFlowDir(cwd, name);
+    const config = loadConfig(flowDir);
+    const sortedLoops = Object.entries(config.loops).sort(([, a], [, b]) => a.order - b.order);
+    if (sortedLoops.length > 0) {
+      const [firstKey] = sortedLoops[0];
+      await runLoop(firstKey, {
+        multiAgent: false,
+        maxIterations: 30,
+        cwd,
+        flow: name
+      });
+    }
+  }
+}
+async function selectFlow(flows) {
+  if (flows.length === 1) return flows[0];
+  return await select({
+    message: "Which flow?",
+    choices: flows.map((f) => ({ name: f, value: f }))
+  });
+}
+async function handleRunLoop(cwd, flows) {
+  const flow = await selectFlow(flows);
+  const flowDir = resolveFlowDir(cwd, flow);
+  const config = loadConfig(flowDir);
+  const sortedLoops = Object.entries(config.loops).sort(([, a], [, b]) => a.order - b.order);
+  const loopKey = await select({
+    message: "Which loop?",
+    choices: sortedLoops.map(([key, loop]) => ({
+      name: loop.name,
+      value: key
+    }))
+  });
+  await runLoop(loopKey, {
+    multiAgent: false,
+    maxIterations: 30,
+    cwd,
+    flow
+  });
+}
+async function handleRunAll(cwd, flows) {
+  const flow = await selectFlow(flows);
+  await runAllLoops({
+    multiAgent: false,
+    maxIterations: 30,
+    cwd,
+    flow
+  });
+}
+async function handleE2E(cwd, flows) {
+  const flow = await selectFlow(flows);
+  await runE2E({
+    multiAgent: false,
+    maxIterations: 30,
+    cwd,
+    flow
+  });
+}
+async function handleStatus(cwd) {
+  await showStatus(cwd);
+}
+async function handleDashboard(cwd) {
+  const { startDashboard } = await import("./server-O6J52DZT.js");
+  await startDashboard({ cwd });
+}
+
 // src/cli/index.ts
-var program = new Command4().name("ralphflow").description("Multi-agent AI workflow orchestration for Claude Code").version("0.1.0").addCommand(initCommand).addCommand(runCommand).addCommand(statusCommand);
+var program = new Command6().name("ralphflow").description("Multi-agent AI workflow orchestration for Claude Code").version("0.1.0").addCommand(initCommand).addCommand(runCommand).addCommand(e2eCommand).addCommand(statusCommand).addCommand(dashboardCommand).action(async () => {
+  await interactiveMenu(process.cwd());
+});
 process.on("SIGINT", () => {
   console.log();
-  console.log(chalk7.dim("  Interrupted."));
+  console.log(chalk8.dim("  Interrupted."));
   process.exit(130);
 });
 program.configureOutput({
   writeErr: (str) => {
     const clean = str.replace(/^error: /, "");
     if (clean.trim()) {
-      console.error(chalk7.red(`  ${clean.trim()}`));
+      console.error(chalk8.red(`  ${clean.trim()}`));
     }
   }
 });