ralphflow 0.5.0 → 0.5.2

package/dist/ralphflow.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import {
   copyTemplate,
+  createCustomTemplate,
   getDb,
   incrementIteration,
   isLoopComplete,
@@ -11,11 +12,11 @@ import {
   resolveFlowDir,
   resolveLoop,
   showStatus
-} from "./chunk-TCCMQDVT.js";
+} from "./chunk-DOC64TD6.js";
 
 // src/cli/index.ts
-import { Command as Command6 } from "commander";
-import chalk7 from "chalk";
+import { Command as Command7 } from "commander";
+import chalk8 from "chalk";
 import { exec } from "child_process";
 
 // src/cli/init.ts
@@ -28,9 +29,9 @@ import { join } from "path";
 import { createInterface } from "readline";
 import chalk from "chalk";
 function ask(rl, question) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     rl.question(chalk.cyan("? ") + question + " ", (answer) => {
-      resolve(answer.trim());
+      resolve2(answer.trim());
     });
   });
 }
@@ -123,12 +124,19 @@ import chalk3 from "chalk";
 // src/core/claude.ts
 import { spawn } from "child_process";
 async function spawnClaude(options) {
-  const { prompt, model, cwd, env: extraEnv } = options;
-  const args = ["--dangerously-skip-permissions", prompt];
+  const { prompt, model, cwd, env: extraEnv, claudeArgs, skipPermissions } = options;
+  const args = [];
+  if (skipPermissions !== false) {
+    args.push("--dangerously-skip-permissions");
+  }
+  if (claudeArgs && claudeArgs.length > 0) {
+    args.push(...claudeArgs);
+  }
+  args.push(prompt);
   if (model) {
     args.unshift("--model", model);
   }
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const child = spawn("claude", args, {
       cwd,
       stdio: "inherit",
@@ -138,7 +146,7 @@ async function spawnClaude(options) {
       reject(new Error(`Failed to spawn claude: ${err.message}`));
     });
     child.on("close", (code, signal) => {
-      resolve({
+      resolve2({
         output: "",
         exitCode: code,
         signal
@@ -223,6 +231,48 @@ function checkTrackerAllChecked(flowDir, loop) {
   const unchecked = (content.match(/- \[ \]/g) || []).length;
   return checked > 0 && unchecked === 0;
 }
+function hasNewItemsInDataFile(flowDir, loop, config) {
+  if (!loop.entities || loop.entities.length === 0) return false;
+  const entityName = loop.entities[0];
+  const entity = config.entities?.[entityName];
+  if (!entity) return false;
+  const dataFilePath = join2(flowDir, entity.data_file);
+  if (!existsSync2(dataFilePath)) return false;
+  const trackerPath = join2(flowDir, loop.tracker);
+  if (!existsSync2(trackerPath)) return false;
+  const dataContent = readFileSync(dataFilePath, "utf-8");
+  const trackerContent = readFileSync(trackerPath, "utf-8");
+  const prefix = entity.prefix;
+  const itemRegex = new RegExp(`^## (${prefix}-\\d+):`, "gm");
+  const dataFileIds = [...dataContent.matchAll(itemRegex)].map((m) => m[1]);
+  if (dataFileIds.length === 0) return false;
+  const trackerIdRegex = new RegExp(`\\[[ x]\\]\\s*(${prefix}-\\d+)`, "gi");
+  const trackerIds = [...trackerContent.matchAll(trackerIdRegex)].map((m) => m[1]);
+  return dataFileIds.some((id) => !trackerIds.includes(id));
+}
+function stripStaleCompletion(flowDir, loop, config) {
+  if (!hasNewItemsInDataFile(flowDir, loop, config)) return false;
+  const trackerPath = join2(flowDir, loop.tracker);
+  if (!existsSync2(trackerPath)) return false;
+  let content = readFileSync(trackerPath, "utf-8");
+  const hadCompletion = content.includes(`<promise>${loop.completion}</promise>`) || content.includes(loop.completion);
+  if (!hadCompletion) return false;
+  content = content.replace(new RegExp(`<promise>${loop.completion}</promise>`, "g"), "");
+  content = content.replace(new RegExp(loop.completion, "g"), "");
+  writeFileSync(trackerPath, content);
+  console.log(chalk3.cyan(`  \u21BB New items detected in data file \u2014 cleared stale completion for ${loop.name}`));
+  return true;
+}
+function stripCompletionString(flowDir, loop) {
+  const trackerPath = join2(flowDir, loop.tracker);
+  if (!existsSync2(trackerPath)) return;
+  let content = readFileSync(trackerPath, "utf-8");
+  const had = content.includes(`<promise>${loop.completion}</promise>`) || content.includes(loop.completion);
+  if (!had) return;
+  content = content.replace(new RegExp(`<promise>${loop.completion}</promise>`, "g"), "");
+  content = content.replace(new RegExp(loop.completion, "g"), "");
+  writeFileSync(trackerPath, content);
+}
 async function runLoop(loopName, options) {
   const flowDir = resolveFlowDir(options.cwd, options.flow);
   const config = loadConfig(flowDir);
@@ -256,22 +306,25 @@ async function runLoop(loopName, options) {
     cleanup();
     process.exit(143);
   });
+  stripCompletionString(flowDir, loop);
   try {
-    await iterationLoop(key, loop, flowDir, options, agentName);
+    await iterationLoop(key, loop, flowDir, options, agentName, void 0, void 0, true, config);
   } finally {
     cleanup();
   }
 }
-async function iterationLoop(configKey, loop, flowDir, options, agentName, db, flowName, forceFirstIteration) {
+async function iterationLoop(configKey, loop, flowDir, options, agentName, db, flowName, forceFirstIteration, config) {
   const loopKey = loop.name;
   const appName = basename(flowDir);
+  if (config) stripStaleCompletion(flowDir, loop, config);
   for (let i = 1; i <= options.maxIterations; i++) {
     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)) {
+      const newItemsExist = config ? hasNewItemsInDataFile(flowDir, loop, config) : false;
+      if (!newItemsExist && (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;
@@ -288,10 +341,13 @@ async function iterationLoop(configKey, loop, flowDir, options, agentName, db, f
       env: {
         RALPHFLOW_APP: appName,
         RALPHFLOW_LOOP: configKey
-      }
+      },
+      claudeArgs: loop.claude_args,
+      skipPermissions: loop.skip_permissions
     });
     if (db && flowName) incrementIteration(db, flowName, loopKey);
-    if (checkTrackerForCompletion(flowDir, loop) || checkTrackerMetadataCompletion(flowDir, loop) || checkTrackerAllChecked(flowDir, loop)) {
+    const newItemsAfter = config ? hasNewItemsInDataFile(flowDir, loop, config) : false;
+    if (!newItemsAfter && (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,7 +392,8 @@ async function runE2E(options) {
           console.log(chalk3.green(`  \u2713 ${loop.name} \u2014 complete, skipping`));
           continue;
         }
-        if (checkTrackerForCompletion(flowDir, loop) || checkTrackerMetadataCompletion(flowDir, loop) || checkTrackerAllChecked(flowDir, loop)) {
+        const loopHasNewItems = hasNewItemsInDataFile(flowDir, loop, config);
+        if (!loopHasNewItems && (checkTrackerForCompletion(flowDir, loop) || checkTrackerMetadataCompletion(flowDir, loop) || checkTrackerAllChecked(flowDir, loop))) {
           markLoopComplete(db, flowName, loopKey);
           console.log(chalk3.green(`  \u2713 ${loop.name} \u2014 complete, skipping`));
           continue;
@@ -352,7 +409,7 @@ async function runE2E(options) {
         agentName = acquireAgentId(agentDir, loop.multi_agent.max_agents);
       }
       try {
-        await iterationLoop(key, loop, flowDir, options, agentName, db, flowName, isFirstLoop);
+        await iterationLoop(key, loop, flowDir, options, agentName, db, flowName, isFirstLoop, config);
       } finally {
         if (agentDir && agentName) releaseAgentId(agentDir, agentName);
       }
@@ -467,7 +524,7 @@ var runCommand = new Command2("run").description("Run a loop").argument("<loop>"
   try {
     let dashboardHandle;
     if (opts.ui) {
-      const { startDashboard } = await import("./server-DOSLU36L.js");
+      const { startDashboard } = await import("./server-EX5MWYW4.js");
       dashboardHandle = await startDashboard({ cwd: process.cwd() });
     }
     await runLoop(loop, {
@@ -493,7 +550,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-DOSLU36L.js");
+      const { startDashboard } = await import("./server-EX5MWYW4.js");
       dashboardHandle = await startDashboard({ cwd: process.cwd() });
     }
     await runE2E({
@@ -530,32 +587,535 @@ 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-DOSLU36L.js");
+  const { startDashboard } = await import("./server-EX5MWYW4.js");
   await startDashboard({ cwd: process.cwd(), port: parseInt(opts.port, 10) });
 });
 
+// src/cli/create-template.ts
+import { Command as Command6 } from "commander";
+import chalk7 from "chalk";
+import { readFileSync as readFileSync2 } from "fs";
+import { resolve } from "path";
+
+// src/core/prompt-generator.ts
+function defaultCapabilities() {
+  return {
+    webSearch: false,
+    mcpServers: false,
+    exploreAgents: false,
+    fileReadWrite: false,
+    codeEditing: false,
+    bashCommands: false
+  };
+}
+function buildPromptLoopConfig(loopDef) {
+  const stages = loopDef.stages;
+  const stageConfigs = stages.map((stageName, i) => {
+    const caps = defaultCapabilities();
+    if (i === 0) {
+      caps.fileReadWrite = true;
+      caps.exploreAgents = true;
+    }
+    if (i === stages.length - 1 && stages.length > 1) {
+      caps.bashCommands = true;
+      caps.fileReadWrite = true;
+    }
+    if (i > 0 && i < stages.length - 1) {
+      caps.codeEditing = true;
+      caps.bashCommands = true;
+      caps.fileReadWrite = true;
+    }
+    if (stages.length === 1) {
+      caps.codeEditing = true;
+      caps.bashCommands = true;
+    }
+    return { name: stageName, description: "", capabilities: caps };
+  });
+  return {
+    name: loopDef.name,
+    stages,
+    completion: loopDef.completion,
+    multi_agent: !!(loopDef.multi_agent && typeof loopDef.multi_agent === "object" && loopDef.multi_agent.enabled),
+    entities: loopDef.entities || [],
+    inputFiles: (loopDef.fed_by || []).join(", "),
+    outputFiles: (loopDef.feeds || []).join(", "),
+    stageConfigs
+  };
+}
+function generateVisualProtocol() {
+  let s = "";
+  s += `## Visual Communication Protocol
+
+`;
+  s += `When communicating scope, structure, relationships, or status, render **ASCII diagrams** using Unicode box-drawing characters. These help the user see the full picture at the terminal without scrolling through prose.
+
+`;
+  s += `**Character set:** \`\u250C \u2500 \u2510 \u2502 \u2514 \u2518 \u251C \u2524 \u252C \u2534 \u253C \u2550 \u25CF \u25CB \u25BC \u25B6\`
+
+`;
+  s += `**Diagram types to use:**
+
+`;
+  s += `- **Scope/Architecture Map** \u2014 components and their relationships in a bordered grid
+`;
+  s += `- **Decomposition Tree** \u2014 hierarchical breakdown with \`\u251C\u2500\u2500\` and \`\u2514\u2500\u2500\` branches
+`;
+  s += `- **Data Flow** \u2014 arrows (\`\u2500\u2500\u2192\`) showing how information moves between components
+`;
+  s += `- **Comparison Table** \u2014 bordered table for trade-offs and design options
+`;
+  s += `- **Status Summary** \u2014 bordered box with completion indicators (\`\u2713\` done, \`\u25CC\` pending)
+
+`;
+  s += `**Rules:** Keep diagrams under 20 lines and under 70 characters wide. Populate with real data from current context. Render inside fenced code blocks. Use diagrams to supplement, not replace, prose.
+
+`;
+  s += `---
+
+`;
+  return s;
+}
+function generatePromptFromConfig(loop, loopIndex, allLoops) {
+  const loopName = loop.name || "Loop " + (loopIndex + 1);
+  const inputFiles = (loop.inputFiles || "").trim();
+  const outputFiles = (loop.outputFiles || "").trim();
+  const completion = loop.completion || "LOOP COMPLETE";
+  const entity = loop.entities && loop.entities.length > 0 ? loop.entities[0] : "";
+  const entityUpper = entity ? entity.toUpperCase() : "ITEM";
+  const entityLower = entity ? entity.toLowerCase() : "item";
+  const entityTitle = entityUpper.charAt(0) + entityLower.slice(1);
+  const entityPlural = entityLower.endsWith("s") ? entityLower : entityLower + "s";
+  const entityKey = entityUpper + "-{N}";
+  const loopKey = (loopName || "loop-" + loopIndex).toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+  const loopKeyFull = loopKey.endsWith("-loop") ? loopKey : loopKey + "-loop";
+  const dirPrefix = String(loopIndex).padStart(2, "0");
+  const loopDir = dirPrefix + "-" + loopKeyFull;
+  const pipelineIn = inputFiles || "input.md";
+  const pipelineOut = outputFiles || "output.md";
+  const primaryInputFile = inputFiles ? inputFiles.split(",")[0].trim() : "";
+  let p = "";
+  p += `# ${loopName} Loop
+
+`;
+  p += `**App:** \`{{APP_NAME}}\` \u2014 all flow files live under \`.ralph-flow/{{APP_NAME}}/\`.
+
+`;
+  if (loop.multi_agent) {
+    p += `**You are agent \`{{AGENT_NAME}}\`.** Multiple agents may work in parallel.
+`;
+    p += `Coordinate via \`tracker.md\` \u2014 the single source of truth.
+`;
+    p += `*(If you see the literal text \`{{AGENT_NAME}}\` above \u2014 i.e., it was not substituted \u2014 treat your name as \`agent-1\`.)*
+
+`;
+  }
+  p += `Read \`.ralph-flow/{{APP_NAME}}/${loopDir}/tracker.md\` FIRST to determine where you are.
+
+`;
+  p += `> **PROJECT CONTEXT.** Read \`CLAUDE.md\` for architecture, stack, conventions, commands, and URLs.
+
+`;
+  p += `**Pipeline:** \`${pipelineIn} \u2192 YOU \u2192 ${pipelineOut}\`
+
+`;
+  p += `---
+
+`;
+  p += generateVisualProtocol();
+  if (loop.multi_agent) {
+    p += `## Tracker Lock Protocol
+
+`;
+    p += `Before ANY write to \`tracker.md\`, you MUST acquire the lock:
+
+`;
+    p += `**Lock file:** \`.ralph-flow/{{APP_NAME}}/${loopDir}/.tracker-lock\`
+
+`;
+    p += `### Acquire Lock
+`;
+    p += `1. Check if \`.tracker-lock\` exists
+`;
+    p += `   - Exists AND file is < 60 seconds old \u2192 sleep 2s, retry (up to 5 retries)
+`;
+    p += `   - Exists AND file is \u2265 60 seconds old \u2192 stale lock, delete it (agent crashed mid-write)
+`;
+    p += `   - Does not exist \u2192 continue
+`;
+    p += `2. Write lock: \`echo "{{AGENT_NAME}} $(date -u +%Y-%m-%dT%H:%M:%SZ)" > .ralph-flow/{{APP_NAME}}/${loopDir}/.tracker-lock\`
+`;
+    p += `3. Sleep 500ms (\`sleep 0.5\`)
+`;
+    p += `4. Re-read \`.tracker-lock\` \u2014 verify YOUR agent name (\`{{AGENT_NAME}}\`) is in it
+`;
+    p += `   - Your name \u2192 you own the lock, proceed to write \`tracker.md\`
+`;
+    p += `   - Other name \u2192 you lost the race, retry from step 1
+`;
+    p += `5. Write your changes to \`tracker.md\`
+`;
+    p += `6. Delete \`.tracker-lock\` immediately: \`rm .ralph-flow/{{APP_NAME}}/${loopDir}/.tracker-lock\`
+`;
+    p += `7. Never leave a lock held \u2014 if your write fails, delete the lock in your error handler
+
+`;
+    p += `### When to Lock
+`;
+    p += `- Claiming a ${entityLower} (pending \u2192 in_progress)
+`;
+    p += `- Completing a ${entityLower} (in_progress \u2192 completed, unblocking dependents)
+`;
+    p += `- Updating stage transitions
+`;
+    p += `- Heartbeat updates (bundled with other writes, not standalone)
+
+`;
+    p += `### When NOT to Lock
+`;
+    p += `- Reading \`tracker.md\` \u2014 read-only access needs no lock
+`;
+    if (primaryInputFile) {
+      p += `- Reading \`${primaryInputFile}\` \u2014 always read-only
+`;
+    }
+    p += `
+---
+
+`;
+    p += `## ${entityTitle} Selection Algorithm
+
+`;
+    p += `1. **Parse tracker** \u2014 read \`completed_${entityPlural}\`, \`## Dependencies\`, ${entityTitle}s Queue metadata \`{agent, status}\`, Agent Status table
+`;
+    p += `2. **Update blocked\u2192pending** \u2014 for each ${entityLower} with \`status: blocked\`, check if ALL its dependencies (from \`## Dependencies\`) are in \`completed_${entityPlural}\`. If yes, acquire lock and update to \`status: pending\`
+`;
+    p += `3. **Resume own work** \u2014 if any ${entityLower} has \`{agent: {{AGENT_NAME}}, status: in_progress}\`, resume it (skip to the current stage)
+`;
+    p += `4. **Find claimable** \u2014 filter ${entityPlural} where \`status: pending\` AND \`agent: -\`
+`;
+    p += `5. **Claim** \u2014 acquire lock, set \`{agent: {{AGENT_NAME}}, status: in_progress}\`, update your Agent Status row, update \`last_heartbeat\`, release lock, log the claim
+`;
+    p += `6. **Nothing available:**
+`;
+    p += `   - All ${entityPlural} completed \u2192 emit \`<promise>${completion}</promise>\`
+`;
+    p += `   - All remaining ${entityPlural} are blocked or claimed by others \u2192 log "{{AGENT_NAME}}: waiting \u2014 all ${entityPlural} blocked or claimed", exit: \`kill -INT $PPID\`
+
+`;
+    p += `### New ${entityTitle} Discovery
+
+`;
+    p += `If you find a ${entityLower} in the Queue without \`{agent, status}\` metadata:
+`;
+    p += `1. Read its \`**Depends on:**\` field
+`;
+    p += `2. Add the dependency to \`## Dependencies\` section if not already there (skip if \`Depends on: None\`)
+`;
+    p += `3. Set status to \`pending\` (all deps in \`completed_${entityPlural}\`) or \`blocked\` (deps incomplete)
+`;
+    p += `4. Set agent to \`-\`
+
+`;
+    p += `---
+
+`;
+    p += `## Anti-Hijacking Rules
+
+`;
+    p += `1. **Never touch another agent's \`in_progress\` ${entityLower}** \u2014 do not modify, complete, or reassign it
+`;
+    p += `2. **Respect ownership** \u2014 if another agent is active in a group, leave remaining group ${entityPlural} for them
+`;
+    p += `3. **Note file overlap conflicts** \u2014 if your ${entityLower} modifies files that another agent's active ${entityLower} also modifies, log a WARNING in the tracker
+
+`;
+    p += `---
+
+`;
+    p += `## Heartbeat Protocol
+
+`;
+    p += `Every tracker write includes updating your \`last_heartbeat\` to current ISO 8601 timestamp in the Agent Status table. If another agent's heartbeat is **30+ minutes stale**, log a WARNING in the tracker log but do NOT auto-reclaim their ${entityLower} \u2014 user must manually reset.
+
+`;
+    p += `---
+
+`;
+    p += `## Crash Recovery (Self)
+
+`;
+    p += `On fresh start, if your agent name has an \`in_progress\` ${entityLower} but you have no memory of it:
+`;
+    const lastStage = loop.stages.length > 1 ? loop.stages[loop.stages.length - 1] : "last";
+    const firstStage = loop.stages[0] || "first";
+    p += `- Work committed for that ${entityLower} \u2192 resume at ${lastStage.toUpperCase()} stage
+`;
+    p += `- No work found \u2192 restart from ${firstStage.toUpperCase()} stage
+
+`;
+    p += `---
+
+`;
+  }
+  const stageCount = loop.stages.length;
+  p += `## State Machine (${stageCount} stage${stageCount !== 1 ? "s" : ""} per ${entityLower})
+
+\`\`\`
+`;
+  loop.stages.forEach((stage, i) => {
+    const sc = loop.stageConfigs[i];
+    const desc = sc && sc.description ? sc.description.split("\n")[0].substring(0, 55) : "Complete this stage";
+    const next = i < stageCount - 1 ? `\u2192 stage: ${loop.stages[i + 1]}` : `\u2192 next ${entityLower}`;
+    p += `${stage.toUpperCase()}  \u2192 ${desc}  ${next}
+`;
+  });
+  p += `\`\`\`
+
+`;
+  p += `When ALL done: \`<promise>${completion}</promise>\`
+
+`;
+  p += `After completing ANY stage, exit: \`kill -INT $PPID\`
+
+`;
+  p += `---
+
+`;
+  {
+    const scanFile = primaryInputFile || "input.md";
+    p += `## First-Run / New ${entityTitle} Detection
+
+`;
+    if (loop.multi_agent) {
+      p += `If ${entityTitle}s Queue in tracker is empty OR all entries are \`[x]\`: read \`${scanFile}\`, scan \`## ${entityKey}:\` headers + \`**Depends on:**\` tags. For any ${entityLower} NOT already in the queue, add as \`- [ ] ${entityKey}: {title}\` with \`{agent: -, status: pending|blocked}\` metadata (compute from Dependencies), then start.
+
+`;
+    } else {
+      p += `If ${entityTitle}s Queue in tracker is empty OR all entries are \`[x]\`: read \`${scanFile}\`, scan \`## ${entityKey}:\` headers + \`**Depends on:**\` tags. For any ${entityLower} NOT already in the queue, add as \`- [ ] ${entityKey}: {title}\` and update Dependencies. If new ${entityPlural} were added, proceed to process them.
+
+`;
+    }
+    p += `---
+
+`;
+  }
+  loop.stages.forEach((stage, i) => {
+    const sc = loop.stageConfigs[i];
+    p += `## STAGE ${i + 1}: ${stage.toUpperCase()}
+
+`;
+    if (sc && sc.description) {
+      p += `${sc.description}
+
+`;
+    }
+    let step = 1;
+    if (loop.multi_agent && i === 0) {
+      p += `${step++}. Read tracker \u2192 **run ${entityLower} selection algorithm** (see above)
+`;
+    } else {
+      p += `${step++}. Read tracker \u2192 determine current state
+`;
+    }
+    if (sc && sc.capabilities) {
+      if (sc.capabilities.fileReadWrite) {
+        const files = primaryInputFile ? ` (\`${primaryInputFile}\`)` : "";
+        p += `${step++}. Read relevant input files${files} and explore affected areas
+`;
+      }
+      if (sc.capabilities.exploreAgents) {
+        p += `${step++}. Use the Agent tool to explore the codebase \u2014 read **40+ files** across affected areas, dependencies, patterns
+`;
+      }
+      if (sc.capabilities.webSearch) {
+        p += `${step++}. Use WebSearch for 5-10 queries to gather external information
+`;
+      }
+      if (sc.capabilities.mcpServers) {
+        p += `${step++}. Use MCP tools for specialized operations
+`;
+      }
+      if (sc.capabilities.codeEditing) {
+        p += `${step++}. Implement changes, matching existing patterns per \`CLAUDE.md\`
+`;
+      }
+      if (sc.capabilities.bashCommands) {
+        p += `${step++}. Run build/deploy commands to verify changes
+`;
+      }
+    }
+    if (i === 0) {
+      p += `${step++}. **Render a Scope Diagram** \u2014 output an ASCII architecture/scope map showing the areas this ${entityLower} touches, dependencies, and what needs to change
+`;
+    }
+    if (i === stageCount - 1 && stageCount > 1) {
+      p += `${step++}. **Render a Completion Summary** \u2014 output an ASCII status diagram showing what was built/changed, verification results, and how this ${entityLower} fits in overall progress
+`;
+    }
+    if (loop.multi_agent) {
+      p += `${step++}. Acquire lock \u2192 update tracker: stage, \`last_heartbeat\`, log entry \u2192 release lock
+`;
+    } else {
+      p += `${step++}. Update tracker with progress
+`;
+    }
+    p += `${step++}. Exit: \`kill -INT $PPID\`
+
+`;
+    if (i < stageCount - 1) p += `---
+
+`;
+  });
+  if (outputFiles && entity) {
+    p += `---
+
+`;
+    p += `## Output Format
+
+`;
+    p += `Write to \`${outputFiles.split(",")[0].trim()}\` using this format:
+
+`;
+    p += `\`\`\`markdown
+`;
+    p += `## ${entityKey}: {Title}
+
+`;
+    p += `**Depends on:** {dependency or "None"}
+
+`;
+    p += `### Description
+`;
+    p += `{Content for this ${entityLower}}
+
+`;
+    p += `### Acceptance Criteria
+`;
+    p += `- [ ] {Criterion 1}
+`;
+    p += `- [ ] {Criterion 2}
+`;
+    p += `\`\`\`
+
+`;
+  }
+  p += `---
+
+## Rules
+
+`;
+  p += `- One ${entityLower} at a time${loop.multi_agent ? " per agent" : ""}. One stage per iteration.
+`;
+  p += `- Read tracker first, update tracker last.${loop.multi_agent ? " Always use lock protocol for writes." : ""}
+`;
+  p += `- Read \`CLAUDE.md\` for all project-specific context.
+`;
+  p += `- Thorough exploration before making changes.
+`;
+  if (loop.multi_agent) {
+    p += `- **Multi-agent: never touch another agent's in_progress ${entityLower}. Coordinate via tracker.md.**
+`;
+  }
+  p += `
+---
+
+`;
+  p += `Read \`.ralph-flow/{{APP_NAME}}/${loopDir}/tracker.md\` now and begin.
+`;
+  return p;
+}
+
+// src/cli/create-template.ts
+var createTemplateCommand = new Command6("create-template").description("Create a custom template from a JSON definition").option("--config <json>", "Template definition as inline JSON").option("--config-file <path>", "Path to a JSON file with the template definition").action(async (opts) => {
+  try {
+    const cwd = process.cwd();
+    let raw;
+    if (opts.config) {
+      raw = opts.config;
+    } else if (opts.configFile) {
+      const filePath = resolve(cwd, opts.configFile);
+      raw = readFileSync2(filePath, "utf-8");
+    } else {
+      console.error(chalk7.red("\n  Provide --config <json> or --config-file <path>\n"));
+      process.exit(1);
+    }
+    let definition;
+    try {
+      definition = JSON.parse(raw);
+    } catch {
+      console.error(chalk7.red("\n  Invalid JSON. Check syntax and try again.\n"));
+      process.exit(1);
+    }
+    if (!definition.name) {
+      console.error(chalk7.red("\n  Template name is required.\n"));
+      process.exit(1);
+    }
+    if (!definition.loops || definition.loops.length === 0) {
+      console.error(chalk7.red("\n  At least one loop is required.\n"));
+      process.exit(1);
+    }
+    for (const loop of definition.loops) {
+      if (!loop.name) {
+        console.error(chalk7.red("\n  Each loop must have a name.\n"));
+        process.exit(1);
+      }
+      if (!loop.stages || loop.stages.length === 0) {
+        console.error(chalk7.red("\n  Each loop must have at least one stage.\n"));
+        process.exit(1);
+      }
+      if (!loop.completion) {
+        console.error(chalk7.red("\n  Each loop must have a completion string.\n"));
+        process.exit(1);
+      }
+    }
+    const allPromptLoopConfigs = definition.loops.map((l) => buildPromptLoopConfig(l));
+    for (let i = 0; i < definition.loops.length; i++) {
+      const loopDef = definition.loops[i];
+      if (!loopDef.prompt || !loopDef.prompt.trim()) {
+        loopDef.prompt = generatePromptFromConfig(allPromptLoopConfigs[i], i, allPromptLoopConfigs);
+      }
+    }
+    createCustomTemplate(cwd, definition);
+    const templatePath = `.ralph-flow/.templates/${definition.name}/`;
+    console.log();
+    console.log(chalk7.green("  \u2713 Template created: ") + chalk7.bold(definition.name));
+    console.log(chalk7.dim(`    ${templatePath}`));
+    console.log();
+    console.log(chalk7.dim("  Next steps:"));
+    console.log(chalk7.dim(`    ralphflow init -t ${definition.name} -n my-project`));
+    console.log(chalk7.dim("    ralphflow run <loop>"));
+    console.log();
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(chalk7.red(`
+  ${msg}
+`));
+    process.exit(1);
+  }
+});
+
 // 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 () => {
+var program = new Command7().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).addCommand(createTemplateCommand).action(async () => {
   const port = 4242;
-  const { startDashboard } = await import("./server-DOSLU36L.js");
+  const { startDashboard } = await import("./server-EX5MWYW4.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`));
+      console.log(chalk8.dim(`  Open ${url} in your browser`));
     }
   });
 });
 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()}`));
     }
   }
 });