ralphflow 0.3.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,91 +153,10 @@ import { Command as Command2 } from "commander";
 import chalk4 from "chalk";
 
 // src/core/runner.ts
-import { readFileSync as readFileSync3, existsSync as existsSync4, mkdirSync as mkdirSync2, writeFileSync, readdirSync as readdirSync3, unlinkSync } 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) {
@@ -255,8 +186,8 @@ async function spawnClaude(options) {
 
 // src/core/runner.ts
 function agentsDir(flowDir, loop) {
-  const loopDir = join4(flowDir, loop.tracker, "..");
-  return join4(loopDir, ".agents");
+  const loopDir = join3(flowDir, loop.tracker, "..");
+  return join3(loopDir, ".agents");
 }
 function isProcessAlive(pid) {
   try {
@@ -267,13 +198,13 @@ function isProcessAlive(pid) {
   }
 }
 function cleanStaleAgents(dir) {
-  if (!existsSync4(dir)) return;
-  for (const file of readdirSync3(dir)) {
+  if (!existsSync3(dir)) return;
+  for (const file of readdirSync2(dir)) {
     if (!file.endsWith(".lock")) continue;
-    const pidStr = readFileSync3(join4(dir, file), "utf-8").trim();
+    const pidStr = readFileSync2(join3(dir, file), "utf-8").trim();
     const pid = parseInt(pidStr, 10);
     if (isNaN(pid) || !isProcessAlive(pid)) {
-      unlinkSync(join4(dir, file));
+      unlinkSync(join3(dir, file));
     }
   }
 }
@@ -281,8 +212,8 @@ function acquireAgentId(dir, maxAgents) {
   mkdirSync2(dir, { recursive: true });
   cleanStaleAgents(dir);
   for (let n = 1; n <= maxAgents; n++) {
-    const lockFile = join4(dir, `agent-${n}.lock`);
-    if (!existsSync4(lockFile)) {
+    const lockFile = join3(dir, `agent-${n}.lock`);
+    if (!existsSync3(lockFile)) {
       writeFileSync(lockFile, String(process.pid));
       return `agent-${n}`;
     }
@@ -290,17 +221,39 @@ function acquireAgentId(dir, maxAgents) {
   throw new Error(`All ${maxAgents} agent slots are occupied. Wait for one to finish or increase max_agents.`);
 }
 function releaseAgentId(dir, agentName) {
-  const lockFile = join4(dir, `${agentName}.lock`);
+  const lockFile = join3(dir, `${agentName}.lock`);
   try {
     unlinkSync(lockFile);
   } catch {
   }
 }
 function checkTrackerForCompletion(flowDir, loop) {
-  const trackerPath = join4(flowDir, loop.tracker);
-  if (!existsSync4(trackerPath)) return false;
-  const content = readFileSync3(trackerPath, "utf-8");
-  return content.includes(`<promise>${loop.completion}</promise>`);
+  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);
@@ -341,8 +294,18 @@ async function runLoop(loopName, options) {
     cleanup();
   }
 }
-async function iterationLoop(loop, flowDir, options, agentName) {
+async function iterationLoop(loop, flowDir, options, agentName, db, flowName) {
+  const loopKey = loop.name;
   for (let i = 1; i <= options.maxIterations; i++) {
+    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);
@@ -351,7 +314,9 @@ async function iterationLoop(loop, flowDir, options, agentName) {
       model: options.model,
       cwd: options.cwd
     });
-    if (checkTrackerForCompletion(flowDir, loop)) {
+    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;
@@ -371,9 +336,56 @@ async function iterationLoop(loop, flowDir, options, agentName) {
   }
   console.log(chalk3.yellow(`  Max iterations (${options.maxIterations}) reached.`));
 }
+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();
+  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 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 (checkTrackerForCompletion(flowDir, loop) || checkTrackerCheckboxes(flowDir, loop) || checkTrackerMetadataCompletion(flowDir, loop)) {
+      markLoopComplete(db, flowName, loopKey);
+      console.log(chalk3.green(`  \u2713 ${loop.name} \u2014 complete, skipping`));
+      continue;
+    }
+    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.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) {
@@ -384,8 +396,13 @@ 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("--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)").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, {
       multiAgent: !!opts.multiAgent,
       model: opts.model,
@@ -402,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 existsSync5 } 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 (!existsSync5(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) {
@@ -544,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()}`));
     }
   }
 });