ralphflow 0.4.0 → 0.5.0

package/dist/ralphflow.js

@@ -1,69 +1,32 @@
 #!/usr/bin/env node
 import {
+  copyTemplate,
   getDb,
   incrementIteration,
   isLoopComplete,
-  listFlows,
   loadConfig,
   markLoopComplete,
   markLoopRunning,
+  resetLoopState,
   resolveFlowDir,
   resolveLoop,
   showStatus
-} from "./chunk-GVOJO5IN.js";
+} from "./chunk-TCCMQDVT.js";
 
 // src/cli/index.ts
 import { Command as Command6 } from "commander";
-import chalk8 from "chalk";
+import chalk7 from "chalk";
+import { exec } from "child_process";
 
 // src/cli/init.ts
 import { Command } from "commander";
 import chalk2 from "chalk";
 
 // src/core/init.ts
-import { existsSync as existsSync2, readdirSync } from "fs";
-import { join as join2 } from "path";
+import { existsSync, readdirSync } from "fs";
+import { join } from "path";
 import { createInterface } from "readline";
 import chalk from "chalk";
-
-// src/core/template.ts
-import { readFileSync, mkdirSync, cpSync, existsSync } from "fs";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
-var __dirname = dirname(fileURLToPath(import.meta.url));
-function resolveTemplatePath(templateName) {
-  const candidates = [
-    join(__dirname, "..", "templates", templateName),
-    // dev: src/core/ -> src/templates/
-    join(__dirname, "..", "src", "templates", templateName)
-    // bundled: dist/ -> src/templates/
-  ];
-  for (const candidate of candidates) {
-    if (existsSync(candidate)) {
-      return candidate;
-    }
-  }
-  throw new Error(
-    `Template "${templateName}" not found. Searched:
-${candidates.join("\n")}`
-  );
-}
-function copyTemplate(templateName, targetDir) {
-  const templatePath = resolveTemplatePath(templateName);
-  const loopsDir = join(templatePath, "loops");
-  if (!existsSync(loopsDir)) {
-    throw new Error(`Template "${templateName}" has no loops/ directory`);
-  }
-  mkdirSync(targetDir, { recursive: true });
-  cpSync(loopsDir, targetDir, { recursive: true });
-  const yamlSrc = join(templatePath, "ralphflow.yaml");
-  if (existsSync(yamlSrc)) {
-    const yamlDest = join(targetDir, "ralphflow.yaml");
-    cpSync(yamlSrc, yamlDest);
-  }
-}
-
-// src/core/init.ts
 function ask(rl, question) {
   return new Promise((resolve) => {
     rl.question(chalk.cyan("? ") + question + " ", (answer) => {
@@ -73,9 +36,9 @@ function ask(rl, question) {
 }
 var TEMPLATES = ["code-implementation", "research"];
 async function initProject(cwd, options = {}) {
-  const ralphFlowDir = join2(cwd, ".ralph-flow");
-  const claudeMdPath = join2(cwd, "CLAUDE.md");
-  if (!existsSync2(claudeMdPath)) {
+  const ralphFlowDir = join(cwd, ".ralph-flow");
+  const claudeMdPath = join(cwd, "CLAUDE.md");
+  if (!existsSync(claudeMdPath)) {
     console.log();
     console.log(chalk.yellow("  No CLAUDE.md found."));
     console.log(chalk.dim('  Create one with: claude "Initialize CLAUDE.md for this project"'));
@@ -83,8 +46,8 @@ async function initProject(cwd, options = {}) {
     console.log();
     return;
   }
-  if (existsSync2(ralphFlowDir)) {
-    const existing = listFlows2(ralphFlowDir);
+  if (existsSync(ralphFlowDir)) {
+    const existing = listFlows(ralphFlowDir);
     if (existing.length > 0 && !options.template) {
       console.log();
       console.log(chalk.bold("  Existing flows:"));
@@ -116,8 +79,8 @@ async function initProject(cwd, options = {}) {
   }
   rl.close();
   console.log();
-  const flowDir = join2(ralphFlowDir, flowName);
-  if (existsSync2(flowDir)) {
+  const flowDir = join(ralphFlowDir, flowName);
+  if (existsSync(flowDir)) {
     console.log(chalk.yellow(`  Flow "${flowName}" already exists at .ralph-flow/${flowName}/`));
     return;
   }
@@ -127,7 +90,7 @@ async function initProject(cwd, options = {}) {
   console.log(chalk.dim(`  Next: npx ralphflow run story --flow ${flowName}`));
   console.log();
 }
-function listFlows2(ralphFlowDir) {
+function listFlows(ralphFlowDir) {
   try {
     return readdirSync(ralphFlowDir, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".")).map((d) => d.name);
   } catch {
@@ -153,14 +116,14 @@ import { Command as Command2 } from "commander";
 import chalk4 from "chalk";
 
 // src/core/runner.ts
-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 { readFileSync, existsSync as existsSync2, mkdirSync, writeFileSync, readdirSync as readdirSync2, unlinkSync } from "fs";
+import { join as join2, basename } from "path";
 import chalk3 from "chalk";
 
 // src/core/claude.ts
 import { spawn } from "child_process";
 async function spawnClaude(options) {
-  const { prompt, model, cwd } = options;
+  const { prompt, model, cwd, env: extraEnv } = options;
   const args = ["--dangerously-skip-permissions", prompt];
   if (model) {
     args.unshift("--model", model);
@@ -169,7 +132,7 @@ async function spawnClaude(options) {
     const child = spawn("claude", args, {
       cwd,
       stdio: "inherit",
-      env: { ...process.env }
+      env: { ...process.env, ...extraEnv }
     });
     child.on("error", (err) => {
       reject(new Error(`Failed to spawn claude: ${err.message}`));
@@ -186,8 +149,8 @@ async function spawnClaude(options) {
 
 // src/core/runner.ts
 function agentsDir(flowDir, loop) {
-  const loopDir = join3(flowDir, loop.tracker, "..");
-  return join3(loopDir, ".agents");
+  const loopDir = join2(flowDir, loop.tracker, "..");
+  return join2(loopDir, ".agents");
 }
 function isProcessAlive(pid) {
   try {
@@ -198,22 +161,22 @@ function isProcessAlive(pid) {
   }
 }
 function cleanStaleAgents(dir) {
-  if (!existsSync3(dir)) return;
+  if (!existsSync2(dir)) return;
   for (const file of readdirSync2(dir)) {
     if (!file.endsWith(".lock")) continue;
-    const pidStr = readFileSync2(join3(dir, file), "utf-8").trim();
+    const pidStr = readFileSync(join2(dir, file), "utf-8").trim();
     const pid = parseInt(pidStr, 10);
     if (isNaN(pid) || !isProcessAlive(pid)) {
-      unlinkSync(join3(dir, file));
+      unlinkSync(join2(dir, file));
     }
   }
 }
 function acquireAgentId(dir, maxAgents) {
-  mkdirSync2(dir, { recursive: true });
+  mkdirSync(dir, { recursive: true });
   cleanStaleAgents(dir);
   for (let n = 1; n <= maxAgents; n++) {
-    const lockFile = join3(dir, `agent-${n}.lock`);
-    if (!existsSync3(lockFile)) {
+    const lockFile = join2(dir, `agent-${n}.lock`);
+    if (!existsSync2(lockFile)) {
       writeFileSync(lockFile, String(process.pid));
       return `agent-${n}`;
     }
@@ -221,22 +184,27 @@ 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 = join3(dir, `${agentName}.lock`);
+  const lockFile = join2(dir, `${agentName}.lock`);
   try {
     unlinkSync(lockFile);
   } catch {
   }
 }
+function isMultiAgentLoop(loop) {
+  return loop.multi_agent !== false && loop.multi_agent.enabled === true;
+}
 function checkTrackerForCompletion(flowDir, loop) {
-  const trackerPath = join3(flowDir, loop.tracker);
-  if (!existsSync3(trackerPath)) return false;
-  const content = readFileSync2(trackerPath, "utf-8");
+  const trackerPath = join2(flowDir, loop.tracker);
+  if (!existsSync2(trackerPath)) return false;
+  const content = readFileSync(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 trackerPath = join2(flowDir, loop.tracker);
+  if (!existsSync2(trackerPath)) return false;
+  const content = readFileSync(trackerPath, "utf-8");
+  const unchecked = (content.match(/- \[ \]/g) || []).length;
+  if (unchecked > 0) return false;
   const completedMatch = content.match(/^- completed_(?:tasks|stories): \[(.+)\]$/m);
   if (!completedMatch) return false;
   const completedItems = completedMatch[1].split(",").map((s) => s.trim()).filter(Boolean);
@@ -247,10 +215,10 @@ function checkTrackerMetadataCompletion(flowDir, loop) {
   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");
+function checkTrackerAllChecked(flowDir, loop) {
+  const trackerPath = join2(flowDir, loop.tracker);
+  if (!existsSync2(trackerPath)) return false;
+  const content = readFileSync(trackerPath, "utf-8");
   const checked = (content.match(/- \[x\]/gi) || []).length;
   const unchecked = (content.match(/- \[ \]/g) || []).length;
   return checked > 0 && unchecked === 0;
@@ -261,7 +229,7 @@ async function runLoop(loopName, options) {
   const { key, loop } = resolveLoop(config, loopName);
   let agentName;
   let agentDir;
-  if (options.multiAgent) {
+  if (options.multiAgent || isMultiAgentLoop(loop)) {
     if (loop.multi_agent === false) {
       throw new Error(`Loop "${loop.name}" does not support multi-agent mode.`);
     }
@@ -289,33 +257,41 @@ async function runLoop(loopName, options) {
     process.exit(143);
   });
   try {
-    await iterationLoop(loop, flowDir, options, agentName);
+    await iterationLoop(key, loop, flowDir, options, agentName);
   } finally {
     cleanup();
   }
 }
-async function iterationLoop(loop, flowDir, options, agentName, db, flowName) {
+async function iterationLoop(configKey, loop, flowDir, options, agentName, db, flowName, forceFirstIteration) {
   const loopKey = loop.name;
+  const appName = basename(flowDir);
   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;
+    if (!(forceFirstIteration && i === 1)) {
+      if (db && flowName && isLoopComplete(db, flowName, loopKey)) {
+        console.log(chalk3.green(`  \u2713 ${loop.name} \u2014 already complete`));
+        return;
+      }
+      if (checkTrackerForCompletion(flowDir, loop) || checkTrackerMetadataCompletion(flowDir, loop) || checkTrackerAllChecked(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 effectiveModel = options.model || loop.model;
     const result = await spawnClaude({
       prompt,
-      model: options.model,
-      cwd: options.cwd
+      model: effectiveModel,
+      cwd: options.cwd,
+      env: {
+        RALPHFLOW_APP: appName,
+        RALPHFLOW_LOOP: configKey
+      }
     });
     if (db && flowName) incrementIteration(db, flowName, loopKey);
-    if (checkTrackerForCompletion(flowDir, loop) || checkTrackerCheckboxes(flowDir, loop) || checkTrackerMetadataCompletion(flowDir, loop)) {
+    if (checkTrackerForCompletion(flowDir, loop) || checkTrackerMetadataCompletion(flowDir, loop) || checkTrackerAllChecked(flowDir, loop)) {
       if (db && flowName) markLoopComplete(db, flowName, loopKey);
       console.log();
       console.log(chalk3.green(`  Loop complete: ${loop.completion}`));
@@ -336,54 +312,145 @@ async function iterationLoop(loop, flowDir, options, agentName, db, flowName) {
   }
   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;
+  for (const loop of Object.values(config.loops)) {
+    resetLoopState(db, flowName, loop.name);
+  }
+  let cycle = 1;
+  while (true) {
+    const sortedLoops = Object.entries(config.loops).sort(([, a], [, b]) => a.order - b.order);
+    console.log();
+    console.log(chalk3.bold(`  RalphFlow \u2014 E2E` + (cycle > 1 ? ` (cycle ${cycle})` : "")));
+    console.log();
+    let anyLoopRan = false;
+    for (let idx = 0; idx < sortedLoops.length; idx++) {
+      const [key, loop] = sortedLoops[idx];
+      const loopKey = loop.name;
+      const isFirstLoop = idx === 0;
+      if (!isFirstLoop) {
+        if (isLoopComplete(db, flowName, loopKey)) {
+          console.log(chalk3.green(`  \u2713 ${loop.name} \u2014 complete, skipping`));
+          continue;
+        }
+        if (checkTrackerForCompletion(flowDir, loop) || checkTrackerMetadataCompletion(flowDir, loop) || checkTrackerAllChecked(flowDir, loop)) {
+          markLoopComplete(db, flowName, loopKey);
+          console.log(chalk3.green(`  \u2713 ${loop.name} \u2014 complete, skipping`));
+          continue;
+        }
+      }
+      anyLoopRan = true;
+      markLoopRunning(db, flowName, loopKey);
+      console.log(chalk3.bold(`  \u2192 ${loop.name}`));
+      let agentName;
+      let agentDir;
+      if (isMultiAgentLoop(loop)) {
+        agentDir = agentsDir(flowDir, loop);
+        agentName = acquireAgentId(agentDir, loop.multi_agent.max_agents);
+      }
+      try {
+        await iterationLoop(key, loop, flowDir, options, agentName, db, flowName, isFirstLoop);
+      } finally {
+        if (agentDir && agentName) releaseAgentId(agentDir, agentName);
+      }
+      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();
     }
-    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`));
+    if (!hasUndeliveredStories(flowDir, config)) {
+      break;
     }
-    console.log();
+    console.log(chalk3.cyan("  \u21BB Undelivered stories found \u2014 starting new cycle"));
+    prepareNextCycle(flowDir, config, db, flowName);
+    cycle++;
   }
   console.log(chalk3.green("  \u2713 E2E complete"));
 }
+function hasUndeliveredStories(flowDir, config) {
+  const storyEntity = config.entities?.STORY;
+  if (!storyEntity) return false;
+  const storiesPath = join2(flowDir, storyEntity.data_file);
+  if (!existsSync2(storiesPath)) return false;
+  const storiesContent = readFileSync(storiesPath, "utf-8");
+  const storyIds = [...storiesContent.matchAll(/^## (STORY-\d+):/gm)].map((m) => m[1]);
+  if (storyIds.length === 0) return false;
+  const sortedLoops = Object.values(config.loops).sort((a, b) => a.order - b.order);
+  const deliveryLoop = sortedLoops[sortedLoops.length - 1];
+  if (!deliveryLoop) return false;
+  const deliveryTrackerPath = join2(flowDir, deliveryLoop.tracker);
+  if (!existsSync2(deliveryTrackerPath)) return true;
+  const deliveryContent = readFileSync(deliveryTrackerPath, "utf-8");
+  const deliveredSection = deliveryContent.split("## Delivered")[1] || "";
+  const deliveredIds = [...deliveredSection.matchAll(/\[x\]\s*(STORY-\d+)/gi)].map((m) => m[1]);
+  return storyIds.some((id) => !deliveredIds.includes(id));
+}
+function prepareNextCycle(flowDir, config, db, flowName) {
+  const sortedLoops = Object.entries(config.loops).sort(([, a], [, b]) => a.order - b.order);
+  for (const [, loop] of sortedLoops) {
+    resetLoopState(db, flowName, loop.name);
+  }
+  const storyLoop = sortedLoops.find(([key]) => key.includes("story"));
+  if (storyLoop) {
+    const [, storyLoopConfig] = storyLoop;
+    const trackerPath = join2(flowDir, storyLoopConfig.tracker);
+    if (existsSync2(trackerPath)) {
+      let content = readFileSync(trackerPath, "utf-8");
+      content = content.replace(new RegExp(`<promise>${storyLoopConfig.completion}</promise>`, "g"), "");
+      content = content.replace(new RegExp(storyLoopConfig.completion, "g"), "");
+      const storyEntity = config.entities?.STORY;
+      if (storyEntity) {
+        const storiesPath = join2(flowDir, storyEntity.data_file);
+        if (existsSync2(storiesPath)) {
+          const storiesContent = readFileSync(storiesPath, "utf-8");
+          const allStories = [...storiesContent.matchAll(/^## (STORY-\d+): (.+)$/gm)].map((m) => ({ id: m[1], title: m[2] }));
+          const existingIds = [...content.matchAll(/\[[ x]\]\s*(STORY-\d+)/gi)].map((m) => m[1]);
+          const newStories = allStories.filter((s) => !existingIds.includes(s.id));
+          if (newStories.length > 0) {
+            const queueSection = "## Stories Queue";
+            const queueIdx = content.indexOf(queueSection);
+            if (queueIdx !== -1) {
+              const afterQueue = content.indexOf("\n##", queueIdx + queueSection.length);
+              const insertPos = afterQueue !== -1 ? afterQueue : content.length;
+              const newEntries = newStories.map((s) => `- [ ] ${s.id}: ${s.title}`).join("\n");
+              content = content.slice(0, insertPos) + "\n" + newEntries + "\n" + content.slice(insertPos);
+            }
+          }
+        }
+      }
+      content = content.replace(/^- active_story: .+$/m, "- active_story: none");
+      content = content.replace(/^- stage: .+$/m, "- stage: analyze");
+      content = content.replace(/^- pending_stories: .+$/m, "- pending_stories: []");
+      writeFileSync(trackerPath, content);
+    }
+  }
+  const deliveryLoop = sortedLoops[sortedLoops.length - 1];
+  if (deliveryLoop) {
+    const [, deliveryLoopConfig] = deliveryLoop;
+    const trackerPath = join2(flowDir, deliveryLoopConfig.tracker);
+    if (existsSync2(trackerPath)) {
+      let content = readFileSync(trackerPath, "utf-8");
+      content = content.replace(new RegExp(`<promise>${deliveryLoopConfig.completion}</promise>`, "g"), "");
+      content = content.replace(new RegExp(deliveryLoopConfig.completion, "g"), "");
+      content = content.replace(
+        /(## Delivery Queue\n)[\s\S]*?(## Delivered)/,
+        "$1\n$2"
+      );
+      content = content.replace(/^- active_story: .+$/m, "- active_story: none");
+      content = content.replace(/^- stage: .+$/m, "- stage: idle");
+      content = content.replace(/^- feedback: .+$/m, "- feedback: none");
+      writeFileSync(trackerPath, content);
+    }
+  }
+}
 function readPrompt(loop, flowDir, agentName) {
-  const promptPath = join3(flowDir, loop.prompt);
-  let prompt = readFileSync2(promptPath, "utf-8");
+  const promptPath = join2(flowDir, loop.prompt);
+  let prompt = readFileSync(promptPath, "utf-8");
   const appName = basename(flowDir);
   prompt = prompt.replaceAll("{{APP_NAME}}", appName);
   if (agentName && loop.multi_agent !== false) {
@@ -400,7 +467,7 @@ var runCommand = new Command2("run").description("Run a loop").argument("<loop>"
   try {
     let dashboardHandle;
     if (opts.ui) {
-      const { startDashboard } = await import("./server-O6J52DZT.js");
+      const { startDashboard } = await import("./server-DOSLU36L.js");
       dashboardHandle = await startDashboard({ cwd: process.cwd() });
     }
     await runLoop(loop, {
@@ -426,7 +493,7 @@ var e2eCommand = new Command3("e2e").description("Run all loops end-to-end with
   try {
     let dashboardHandle;
     if (opts.ui) {
-      const { startDashboard } = await import("./server-O6J52DZT.js");
+      const { startDashboard } = await import("./server-DOSLU36L.js");
       dashboardHandle = await startDashboard({ cwd: process.cwd() });
     }
     await runE2E({
@@ -463,167 +530,32 @@ var statusCommand = new Command4("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");
+  const { startDashboard } = await import("./server-DOSLU36L.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 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());
+  const port = 4242;
+  const { startDashboard } = await import("./server-DOSLU36L.js");
+  await startDashboard({ cwd: process.cwd(), port });
+  const url = `http://localhost:${port}`;
+  exec(`open "${url}"`, (err) => {
+    if (err) {
+      console.log(chalk7.dim(`  Open ${url} in your browser`));
+    }
+  });
 });
 process.on("SIGINT", () => {
   console.log();
-  console.log(chalk8.dim("  Interrupted."));
+  console.log(chalk7.dim("  Interrupted."));
   process.exit(130);
 });
 program.configureOutput({
   writeErr: (str) => {
     const clean = str.replace(/^error: /, "");
     if (clean.trim()) {
-      console.error(chalk8.red(`  ${clean.trim()}`));
+      console.error(chalk7.red(`  ${clean.trim()}`));
     }
   }
 });