ralphflow 0.4.0 → 0.5.0

package/src/templates/code-implementation/loops/00-story-loop/prompt.md

@@ -15,8 +15,10 @@ Read `.ralph-flow/{{APP_NAME}}/00-story-loop/tracker.md` FIRST to determine wher
 ## State Machine (3 stages per story)
 
 **FIRST — Check completion.** Read the tracker. If the Stories Queue has entries
-AND every entry is `[x]`, write `<promise>ALL STORIES PROCESSED</promise>` to
-the bottom of the tracker and `kill -INT $PPID`. Do NOT collect new stories.
+AND every entry is `[x]` (no pending stories), do NOT write the completion promise yet.
+Instead, go to **"No Stories? Collect Them"** to ask the user for new stories.
+Only write `<promise>ALL STORIES PROCESSED</promise>` when the user explicitly
+confirms they have no more stories to add.
 
 Pick the lowest-numbered `ready` story. NEVER process a `blocked` story.
 
@@ -24,12 +26,16 @@ Pick the lowest-numbered `ready` story. NEVER process a `blocked` story.
 
 ## No Stories? Collect Them
 
-If `stories.md` has no stories at all (first run, empty queue with no entries):
-1. Tell the user: *"No stories queued. Tell me what you want to build — describe features, problems, or goals in your own words."*
+**Triggers when:**
+- `stories.md` has no stories at all (first run, empty queue with no entries), OR
+- All stories in the queue are completed (`[x]`) and there are no `pending` stories left
+
+**Flow:**
+1. Tell the user: *"No pending stories. Tell me what you want to build — describe features, problems, or goals in your own words."*
 2. Use `AskUserQuestion` to prompt: "What do you want to build or fix next?" (open-ended)
-3. As the user narrates, capture each distinct idea as a `## STORY-{N}: {Title}` in `stories.md` with description and `**Depends on:** None` (or dependencies if mentioned)
+3. As the user narrates, capture each distinct idea as a `## STORY-{N}: {Title}` in `stories.md` (continue numbering from existing stories) with description and `**Depends on:** None` (or dependencies if mentioned)
 4. **Confirm stories & dependencies** — present all captured stories back. Use `AskUserQuestion` (up to 5 questions) to validate: correct stories? right dependency order? any to split/merge? priority adjustments?
-5. Apply corrections, finalize `stories.md`, proceed to normal flow
+5. Apply corrections, finalize `stories.md`, add new entries to tracker queue, proceed to normal flow
 
 ---
 

package/src/templates/code-implementation/ralphflow.yaml

@@ -27,6 +27,7 @@ loops:
     completion: "ALL STORIES PROCESSED"
     feeds: [tasks-loop]
     multi_agent: false
+    model: claude-sonnet-4-6
     cadence: 0
 
   tasks-loop:
@@ -44,6 +45,7 @@ loops:
     completion: "ALL TASKS COMPLETE"
     fed_by: [story-loop]
     feeds: [delivery-loop]
+    model: claude-sonnet-4-6
     multi_agent:
       enabled: true
       max_agents: 4
@@ -68,4 +70,5 @@ loops:
     completion: "ALL DELIVERABLES PRESENTED"
     fed_by: [tasks-loop]
     multi_agent: false
+    model: claude-sonnet-4-6
     cadence: 0

package/src/templates/research/ralphflow.yaml

@@ -27,6 +27,7 @@ loops:
     completion: "ALL TOPICS DISCOVERED"
     feeds: [research-loop]
     multi_agent: false
+    model: claude-sonnet-4-6
     cadence: 0
 
   research-loop:
@@ -41,6 +42,7 @@ loops:
     completion: "ALL TOPICS RESEARCHED"
     fed_by: [discovery-loop]
     feeds: [story-loop]
+    model: claude-sonnet-4-6
     multi_agent:
       enabled: true
       max_agents: 4
@@ -65,6 +67,7 @@ loops:
     fed_by: [research-loop]
     feeds: [document-loop]
     multi_agent: false
+    model: claude-sonnet-4-6
     cadence: 0
 
   document-loop:
@@ -77,4 +80,5 @@ loops:
     completion: "DOCUMENT COMPLETE"
     fed_by: [story-loop]
     multi_agent: false
+    model: claude-sonnet-4-6
     cadence: 0

package/dist/chunk-GVOJO5IN.js

@@ -1,274 +0,0 @@
-// src/core/config.ts
-import { readFileSync, existsSync, readdirSync } from "fs";
-import { join } 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 listFlows(cwd) {
-  const baseDir = join(cwd, ".ralph-flow");
-  if (!existsSync(baseDir)) return [];
-  return readdirSync(baseDir, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".")).filter((d) => existsSync(join(baseDir, d.name, "ralphflow.yaml"))).map((d) => d.name);
-}
-function resolveFlowDir(cwd, flowName) {
-  const baseDir = join(cwd, ".ralph-flow");
-  if (!existsSync(baseDir)) {
-    throw new Error("No .ralph-flow/ found. Run `npx ralphflow init` first.");
-  }
-  const flows = listFlows(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 join(baseDir, flowName);
-  }
-  if (flows.length === 1) {
-    return join(baseDir, flows[0]);
-  }
-  throw new Error(
-    `Multiple flows found: ${flows.join(", ")}. Use --flow <name> to specify which one.`
-  );
-}
-function loadConfig(flowDir) {
-  const configPath = join(flowDir, "ralphflow.yaml");
-  if (!existsSync(configPath)) {
-    throw new Error(`No ralphflow.yaml found in ${flowDir}`);
-  }
-  const raw = readFileSync(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/db.ts
-import Database from "better-sqlite3";
-import { join as join2 } from "path";
-import { existsSync as existsSync2, mkdirSync } from "fs";
-var SCHEMA = `
-CREATE TABLE IF NOT EXISTS loop_state (
-  flow_name TEXT NOT NULL,
-  loop_key TEXT NOT NULL,
-  status TEXT NOT NULL DEFAULT 'pending',
-  iterations_run INTEGER NOT NULL DEFAULT 0,
-  completed_at TEXT,
-  PRIMARY KEY (flow_name, loop_key)
-);
-`;
-var _db = null;
-function getDb(cwd) {
-  if (_db) return _db;
-  const dir = join2(cwd, ".ralph-flow");
-  if (!existsSync2(dir)) mkdirSync(dir, { recursive: true });
-  _db = new Database(join2(dir, ".ralphflow.db"));
-  _db.pragma("journal_mode = WAL");
-  _db.exec(SCHEMA);
-  return _db;
-}
-function getLoopStatus(db, flow, loopKey) {
-  const row = db.prepare("SELECT status FROM loop_state WHERE flow_name = ? AND loop_key = ?").get(flow, loopKey);
-  return row ? row.status : "pending";
-}
-function isLoopComplete(db, flow, loopKey) {
-  return getLoopStatus(db, flow, loopKey) === "complete";
-}
-function markLoopRunning(db, flow, loopKey) {
-  db.prepare(`
-    INSERT INTO loop_state (flow_name, loop_key, status, iterations_run)
-    VALUES (?, ?, 'running', 0)
-    ON CONFLICT(flow_name, loop_key) DO UPDATE SET status = 'running'
-  `).run(flow, loopKey);
-}
-function incrementIteration(db, flow, loopKey) {
-  db.prepare(`
-    UPDATE loop_state SET iterations_run = iterations_run + 1
-    WHERE flow_name = ? AND loop_key = ?
-  `).run(flow, loopKey);
-}
-function markLoopComplete(db, flow, loopKey) {
-  db.prepare(`
-    UPDATE loop_state SET status = 'complete', completed_at = datetime('now')
-    WHERE flow_name = ? AND loop_key = ?
-  `).run(flow, loopKey);
-}
-function getAllLoopStates(db, flow) {
-  return db.prepare("SELECT * FROM loop_state WHERE flow_name = ?").all(flow);
-}
-
-// src/core/status.ts
-import { readFileSync as readFileSync2, existsSync as existsSync3 } from "fs";
-import { join as join3 } from "path";
-import chalk from "chalk";
-import Table from "cli-table3";
-async function showStatus(cwd, flowName) {
-  const flows = flowName ? [flowName] : listFlows(cwd);
-  if (flows.length === 0) {
-    console.log();
-    console.log(chalk.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(chalk.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: [
-        chalk.dim("Loop"),
-        chalk.dim("Stage"),
-        chalk.dim("Active"),
-        chalk.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([
-            chalk.dim(`  ${agent.name}`),
-            chalk.dim(agent.stage),
-            chalk.dim(agent.activeTask),
-            chalk.dim(agent.lastHeartbeat)
-          ]);
-        }
-      }
-    }
-    console.log(table.toString());
-  }
-  console.log();
-}
-function parseTracker(trackerPath, flowDir, loopName) {
-  const fullPath = join3(flowDir, trackerPath);
-  const status = {
-    loop: loopName,
-    stage: "\u2014",
-    active: "none",
-    completed: 0,
-    total: 0
-  };
-  if (!existsSync3(fullPath)) {
-    return status;
-  }
-  const content = readFileSync2(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;
-    }
-  }
-  return status;
-}
-
-export {
-  listFlows,
-  resolveFlowDir,
-  loadConfig,
-  resolveLoop,
-  getDb,
-  isLoopComplete,
-  markLoopRunning,
-  incrementIteration,
-  markLoopComplete,
-  getAllLoopStates,
-  showStatus,
-  parseTracker
-};

package/dist/server-O6J52DZT.js

@@ -1,323 +0,0 @@
-import {
-  getAllLoopStates,
-  getDb,
-  listFlows,
-  loadConfig,
-  parseTracker,
-  resolveFlowDir
-} from "./chunk-GVOJO5IN.js";
-
-// src/dashboard/server.ts
-import { Hono as Hono2 } from "hono";
-import { cors } from "hono/cors";
-import { serve } from "@hono/node-server";
-import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
-import { join as join3, dirname } from "path";
-import { fileURLToPath } from "url";
-import { WebSocketServer as WebSocketServer2 } from "ws";
-import chalk from "chalk";
-
-// src/dashboard/api.ts
-import { Hono } from "hono";
-import { readFileSync, writeFileSync, readdirSync, existsSync } from "fs";
-import { resolve } from "path";
-function createApiRoutes(cwd) {
-  const api = new Hono();
-  api.get("/api/apps", (c) => {
-    const flows = listFlows(cwd);
-    const apps = flows.map((appName) => {
-      const flowDir = resolveFlowDir(cwd, appName);
-      const config = loadConfig(flowDir);
-      const sortedLoops = Object.entries(config.loops).sort(([, a], [, b]) => a.order - b.order);
-      return {
-        appName,
-        appType: config.name,
-        description: config.description || "",
-        loops: sortedLoops.map(([key, loop]) => ({
-          key,
-          name: loop.name,
-          order: loop.order,
-          stages: loop.stages
-        }))
-      };
-    });
-    return c.json(apps);
-  });
-  api.get("/api/apps/:app/status", (c) => {
-    const appName = c.req.param("app");
-    const flowDir = resolveFlowDir(cwd, appName);
-    const config = loadConfig(flowDir);
-    const sortedLoops = Object.entries(config.loops).sort(([, a], [, b]) => a.order - b.order);
-    const statuses = sortedLoops.map(([key, loop]) => ({
-      key,
-      ...parseTracker(loop.tracker, flowDir, loop.name)
-    }));
-    return c.json(statuses);
-  });
-  api.get("/api/apps/:app/config", (c) => {
-    const appName = c.req.param("app");
-    const flowDir = resolveFlowDir(cwd, appName);
-    const config = loadConfig(flowDir);
-    return c.json(config);
-  });
-  api.get("/api/apps/:app/db", (c) => {
-    const appName = c.req.param("app");
-    const db = getDb(cwd);
-    const rows = getAllLoopStates(db, appName);
-    return c.json(rows);
-  });
-  api.get("/api/apps/:app/loops/:loop/prompt", (c) => {
-    const { app: appName, loop: loopKey } = c.req.param();
-    const flowDir = resolveFlowDir(cwd, appName);
-    const config = loadConfig(flowDir);
-    const loopConfig = config.loops[loopKey];
-    if (!loopConfig) return c.json({ error: `Loop "${loopKey}" not found` }, 404);
-    const promptPath = resolve(flowDir, loopConfig.prompt);
-    if (!validatePath(promptPath, cwd)) {
-      return c.json({ error: "Invalid path" }, 403);
-    }
-    if (!existsSync(promptPath)) {
-      return c.json({ error: "prompt.md not found" }, 404);
-    }
-    const content = readFileSync(promptPath, "utf-8");
-    return c.json({ path: loopConfig.prompt, content });
-  });
-  api.put("/api/apps/:app/loops/:loop/prompt", async (c) => {
-    const { app: appName, loop: loopKey } = c.req.param();
-    const flowDir = resolveFlowDir(cwd, appName);
-    const config = loadConfig(flowDir);
-    const loopConfig = config.loops[loopKey];
-    if (!loopConfig) return c.json({ error: `Loop "${loopKey}" not found` }, 404);
-    const promptPath = resolve(flowDir, loopConfig.prompt);
-    if (!validatePath(promptPath, cwd)) {
-      return c.json({ error: "Invalid path" }, 403);
-    }
-    const body = await c.req.json();
-    writeFileSync(promptPath, body.content, "utf-8");
-    return c.json({ ok: true });
-  });
-  api.get("/api/apps/:app/loops/:loop/tracker", (c) => {
-    const { app: appName, loop: loopKey } = c.req.param();
-    const flowDir = resolveFlowDir(cwd, appName);
-    const config = loadConfig(flowDir);
-    const loopConfig = config.loops[loopKey];
-    if (!loopConfig) return c.json({ error: `Loop "${loopKey}" not found` }, 404);
-    const trackerPath = resolve(flowDir, loopConfig.tracker);
-    if (!validatePath(trackerPath, cwd)) {
-      return c.json({ error: "Invalid path" }, 403);
-    }
-    if (!existsSync(trackerPath)) {
-      return c.json({ error: "tracker.md not found", content: "" }, 404);
-    }
-    const content = readFileSync(trackerPath, "utf-8");
-    return c.json({ path: loopConfig.tracker, content });
-  });
-  api.get("/api/apps/:app/loops/:loop/files", (c) => {
-    const { app: appName, loop: loopKey } = c.req.param();
-    const flowDir = resolveFlowDir(cwd, appName);
-    const config = loadConfig(flowDir);
-    const loopConfig = config.loops[loopKey];
-    if (!loopConfig) return c.json({ error: `Loop "${loopKey}" not found` }, 404);
-    const loopDir = resolve(flowDir, loopConfig.prompt, "..");
-    if (!validatePath(loopDir, cwd)) {
-      return c.json({ error: "Invalid path" }, 403);
-    }
-    if (!existsSync(loopDir)) {
-      return c.json({ files: [] });
-    }
-    const files = readdirSync(loopDir, { withFileTypes: true }).map((d) => ({
-      name: d.name,
-      isDirectory: d.isDirectory()
-    }));
-    return c.json({ files });
-  });
-  return api;
-}
-function validatePath(resolvedPath, cwd) {
-  const ralphFlowDir = resolve(cwd, ".ralph-flow");
-  return resolvedPath.startsWith(ralphFlowDir) && !resolvedPath.includes("..");
-}
-
-// src/dashboard/watcher.ts
-import { watch } from "chokidar";
-import { join as join2, relative, sep } from "path";
-import { WebSocket } from "ws";
-function setupWatcher(cwd, wss) {
-  const ralphFlowDir = join2(cwd, ".ralph-flow");
-  const debounceTimers = /* @__PURE__ */ new Map();
-  const watcher = watch(ralphFlowDir, {
-    ignoreInitial: true
-  });
-  watcher.on("change", (filePath) => {
-    if (!filePath.endsWith(".md") && !filePath.endsWith(".yaml")) return;
-    const existing = debounceTimers.get(filePath);
-    if (existing) clearTimeout(existing);
-    debounceTimers.set(filePath, setTimeout(() => {
-      debounceTimers.delete(filePath);
-      handleFileChange(filePath, cwd, wss);
-    }, 300));
-  });
-  let cachedDbState = "";
-  const dbPollInterval = setInterval(() => {
-    try {
-      const db = getDb(cwd);
-      const flows = listFlows(cwd);
-      const allStates = {};
-      for (const flow of flows) {
-        allStates[flow] = getAllLoopStates(db, flow);
-      }
-      const stateStr = JSON.stringify(allStates);
-      if (stateStr !== cachedDbState) {
-        cachedDbState = stateStr;
-        const fullStatus = buildFullStatus(cwd);
-        broadcast(wss, { type: "status:full", apps: fullStatus });
-      }
-    } catch {
-    }
-  }, 2e3);
-  wss.on("connection", (ws) => {
-    const fullStatus = buildFullStatus(cwd);
-    ws.send(JSON.stringify({ type: "status:full", apps: fullStatus }));
-  });
-  return {
-    close() {
-      watcher.close();
-      clearInterval(dbPollInterval);
-      for (const timer of debounceTimers.values()) clearTimeout(timer);
-      debounceTimers.clear();
-    }
-  };
-}
-function handleFileChange(filePath, cwd, wss) {
-  const ralphFlowDir = join2(cwd, ".ralph-flow");
-  const rel = relative(ralphFlowDir, filePath);
-  const parts = rel.split(sep);
-  if (parts.length < 2) return;
-  const appName = parts[0];
-  if (filePath.endsWith("tracker.md")) {
-    try {
-      const flowDir = resolveFlowDir(cwd, appName);
-      const config = loadConfig(flowDir);
-      for (const [key, loop] of Object.entries(config.loops)) {
-        const trackerFullPath = join2(flowDir, loop.tracker);
-        if (trackerFullPath === filePath) {
-          const status = parseTracker(loop.tracker, flowDir, loop.name);
-          broadcast(wss, {
-            type: "tracker:updated",
-            app: appName,
-            loop: key,
-            status: { key, ...status }
-          });
-          return;
-        }
-      }
-    } catch {
-    }
-  }
-  broadcast(wss, {
-    type: "file:changed",
-    app: appName,
-    path: rel
-  });
-}
-function buildFullStatus(cwd) {
-  const flows = listFlows(cwd);
-  return flows.map((appName) => {
-    try {
-      const flowDir = resolveFlowDir(cwd, appName);
-      const config = loadConfig(flowDir);
-      const sortedLoops = Object.entries(config.loops).sort(([, a], [, b]) => a.order - b.order);
-      return {
-        appName,
-        appType: config.name,
-        description: config.description || "",
-        loops: sortedLoops.map(([key, loop]) => ({
-          key,
-          name: loop.name,
-          order: loop.order,
-          stages: loop.stages,
-          status: parseTracker(loop.tracker, flowDir, loop.name)
-        }))
-      };
-    } catch {
-      return {
-        appName,
-        appType: "unknown",
-        description: "",
-        loops: []
-      };
-    }
-  });
-}
-function broadcast(wss, event) {
-  const data = JSON.stringify(event);
-  for (const client of wss.clients) {
-    if (client.readyState === WebSocket.OPEN) {
-      client.send(data);
-    }
-  }
-}
-
-// src/dashboard/server.ts
-var __dirname = dirname(fileURLToPath(import.meta.url));
-function resolveUiPath() {
-  const candidates = [
-    join3(__dirname, "..", "dashboard", "ui", "index.html"),
-    // dev: src/dashboard/ -> src/dashboard/ui/
-    join3(__dirname, "..", "src", "dashboard", "ui", "index.html")
-    // bundled: dist/ -> src/dashboard/ui/
-  ];
-  for (const candidate of candidates) {
-    if (existsSync2(candidate)) return candidate;
-  }
-  throw new Error(
-    `Dashboard UI not found. Searched:
-${candidates.join("\n")}`
-  );
-}
-async function startDashboard(options) {
-  const { cwd, port = 4242 } = options;
-  const app = new Hono2();
-  app.use("*", cors({
-    origin: (origin) => origin || "*",
-    allowMethods: ["GET", "PUT", "POST", "DELETE"]
-  }));
-  const apiRoutes = createApiRoutes(cwd);
-  app.route("/", apiRoutes);
-  app.get("/", (c) => {
-    const htmlPath = resolveUiPath();
-    const html = readFileSync2(htmlPath, "utf-8");
-    return c.html(html);
-  });
-  const server = serve({
-    fetch: app.fetch,
-    port,
-    hostname: "127.0.0.1"
-  });
-  const wss = new WebSocketServer2({ noServer: true });
-  server.on("upgrade", (request, socket, head) => {
-    const url = new URL(request.url || "/", `http://${request.headers.host}`);
-    if (url.pathname === "/ws") {
-      wss.handleUpgrade(request, socket, head, (ws) => {
-        wss.emit("connection", ws, request);
-      });
-    } else {
-      socket.destroy();
-    }
-  });
-  const watcherHandle = setupWatcher(cwd, wss);
-  console.log();
-  console.log(chalk.bold(`  Dashboard ${chalk.dim("\u2192")} http://localhost:${port}`));
-  console.log(chalk.dim(`  Watching ${cwd}/.ralph-flow/`));
-  console.log();
-  return {
-    close() {
-      watcherHandle.close();
-      wss.close();
-      server.close();
-    }
-  };
-}
-export {
-  startDashboard
-};