ralphflow 0.5.0 → 0.5.1

package/README.md

@@ -8,6 +8,8 @@ Multi-agent AI workflow orchestration for [Claude Code](https://docs.anthropic.c
 
 Define pipelines as loops, coordinate parallel agents via file-based trackers, and ship structured work — from single-agent interactive sessions to multi-agent autonomous execution.
 
+**[Documentation](https://rahulthakur319.github.io/ralph-flow/)** | **[npm](https://www.npmjs.com/package/ralphflow)** | **[GitHub](https://github.com/rahulthakur319/ralph-flow)**
+
 ## Quick Start
 
 ```bash

package/dist/{chunk-TCCMQDVT.js → chunk-DOC64TD6.js}

@@ -138,6 +138,12 @@ function createCustomTemplate(cwd, definition) {
       model: loopDef.model || "claude-sonnet-4-6",
       cadence: loopDef.cadence ?? 0
     };
+    if (loopDef.claude_args && loopDef.claude_args.length > 0) {
+      loopConfig.claude_args = loopDef.claude_args;
+    }
+    if (loopDef.skip_permissions !== void 0) {
+      loopConfig.skip_permissions = loopDef.skip_permissions;
+    }
     if (loopDef.data_files && loopDef.data_files.length > 0) {
       loopConfig.data_files = loopDef.data_files.map((f) => `${loopDirName}/${f}`);
     }
@@ -173,10 +179,11 @@ function createCustomTemplate(cwd, definition) {
     const loopDirName = `${dirPrefix}-${loopKey}`;
     const loopDir = join(loopsDir, loopDirName);
     mkdirSync(loopDir, { recursive: true });
-    writeFileSync(join(loopDir, "prompt.md"), `# ${loopDef.name} \u2014 Prompt
+    const promptContent = loopDef.prompt && loopDef.prompt.trim() ? loopDef.prompt : `# ${loopDef.name} \u2014 Prompt
 
 <!-- Add your prompt here -->
-`, "utf-8");
+`;
+    writeFileSync(join(loopDir, "prompt.md"), promptContent, "utf-8");
     writeFileSync(join(loopDir, "tracker.md"), `# ${loopDef.name} \u2014 Tracker
 
 - stage: ${loopDef.stages[0] || "init"}
@@ -198,6 +205,28 @@ function createCustomTemplate(cwd, definition) {
     }
   });
 }
+function cloneBuiltInTemplate(cwd, sourceName, newName) {
+  if (!BUILT_IN_TEMPLATES.includes(sourceName)) {
+    throw new Error(`"${sourceName}" is not a built-in template. Only built-in templates can be cloned.`);
+  }
+  const validation = validateTemplateName(newName);
+  if (!validation.valid) {
+    throw new Error(validation.error);
+  }
+  const customDir = join(cwd, ".ralph-flow", ".templates", newName);
+  if (existsSync(customDir)) {
+    throw new Error(`Template "${newName}" already exists`);
+  }
+  const sourceDir = resolveTemplatePath(sourceName);
+  mkdirSync(customDir, { recursive: true });
+  cpSync(sourceDir, customDir, { recursive: true });
+  const yamlPath = join(customDir, "ralphflow.yaml");
+  if (existsSync(yamlPath)) {
+    const content = readFileSync(yamlPath, "utf-8");
+    const patched = content.replace(/^name:\s*.+$/m, `name: ${newName}`);
+    writeFileSync(yamlPath, patched, "utf-8");
+  }
+}
 function deleteCustomTemplate(cwd, name) {
   if (BUILT_IN_TEMPLATES.includes(name)) {
     throw new Error("Cannot delete built-in templates");
@@ -487,6 +516,7 @@ export {
   listCustomTemplates,
   getAvailableTemplates,
   createCustomTemplate,
+  cloneBuiltInTemplate,
   deleteCustomTemplate,
   listFlows,
   resolveFlowDir,

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
@@ -288,7 +296,9 @@ 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)) {
@@ -467,7 +477,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 +503,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 +540,487 @@ 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 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 += `---
+
+`;
+  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 += `---
+
+`;
+  if (loop.multi_agent) {
+    p += `## First-Run Handling
+
+`;
+    const scanFile = primaryInputFile || "input.md";
+    p += `If ${entityTitle}s Queue in tracker is empty: read \`${scanFile}\`, scan \`## ${entityKey}:\` headers, populate queue with \`{agent: -, status: pending|blocked}\` metadata (compute from Dependencies), then start.
+
+`;
+    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 (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()}`));
     }
   }
 });