ralphflow 0.1.0

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

@@ -0,0 +1,135 @@
+# Story Loop — Break Stories into Structured Tasks
+
+Read `.ralph-flow/00-story-loop/tracker.md` FIRST to determine where you are.
+
+> **Describe the destination, not the route.** Focus on what the user will experience, not how you'll build it. Surface anything that could go wrong — broken flows, overlooked edge cases, data at risk.
+
+> **READ-ONLY FOR SOURCE CODE.** Only write to: `01-tasks-loop/tasks.md`, `01-tasks-loop/tracker.md`, `00-story-loop/tracker.md`, `00-story-loop/stories.md`.
+
+**Pipeline:** `stories.md → YOU → tasks.md → 01-tasks-loop → code`
+
+---
+
+## No Stories? Collect Them
+
+If `stories.md` has no unprocessed stories and the tracker queue is empty/all done:
+1. Tell the user: *"No stories queued. 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)
+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
+
+---
+
+## State Machine (3 stages per story)
+
+Pick the lowest-numbered `ready` story. NEVER process a `blocked` story. If none are `ready`: `<promise>ALL STORIES PROCESSED</promise>`.
+
+```
+ANALYZE   → Read story, explore codebase, map scope → stage: clarify
+CLARIFY   → Ask user up to 20 questions (5 at a time) → stage: decompose
+DECOMPOSE → Break into TASK-GROUP(s) + tasks, append to tasks.md, mark done → kill
+```
+
+## First-Run Handling
+
+If Stories Queue in tracker is empty: read `stories.md`, scan `## STORY-{N}:` headers + `**Depends on:**` tags, populate queue as `- [ ] STORY-{N}: {title}`, build Dependency Graph.
+
+---
+
+## STAGE 1: ANALYZE
+
+1. Read tracker → pick lowest-numbered `ready` story
+2. Read the story from `stories.md` (+ any referenced screenshots)
+3. **Explore the codebase** — read `CLAUDE.md` for project context, then **20+ key files** across the areas this story touches. Understand current behavior, patterns, conventions, and what needs to change.
+4. Update tracker: `active_story: STORY-{N}`, `stage: clarify`, log entry
+
+## STAGE 2: CLARIFY
+
+1. Formulate questions about scope, priorities, edge cases, design choices
+2. **Ask up to 20 questions, 5 at a time** via `AskUserQuestion` (with options where possible):
+   - Round 1: Scope, intent, must-haves
+   - Round 2+: Design choices, edge cases, preferences — based on prior answers
+   - Stop early if clear enough
+3. Save Q&A summary in tracker log
+4. Update tracker: `stage: decompose`, log entry with key decisions
+
+## STAGE 3: DECOMPOSE
+
+1. Find next TASK-GROUP and TASK numbers (check existing in `01-tasks-loop/tasks.md`)
+2. **Read already-written tasks** — if sibling tasks exist, read them to align scope boundaries
+3. Break story into TASK-GROUP(s) — one per distinct functional area, 2-6 tasks each
+4. For each task, ask yourself: *What does success look like? How would someone confirm? What could silently break?*
+5. **Sanity-check:** Do NOT embed specific file paths in tasks — describe *what* changes, not *where*. The tasks loop will explore the codebase itself.
+6. Append to `01-tasks-loop/tasks.md` (format below)
+7. **Update `01-tasks-loop/tracker.md` (with lock protocol):**
+   1. Acquire `.ralph-flow/01-tasks-loop/.tracker-lock`:
+      - Exists + < 60s old → sleep 2s, retry up to 5 times
+      - Exists + ≥ 60s old → stale, delete it
+      - Not exists → continue
+      - Write lock: `echo "story-loop $(date -u +%Y-%m-%dT%H:%M:%SZ)" > .ralph-flow/01-tasks-loop/.tracker-lock`
+      - Sleep 500ms, re-read lock, verify `story-loop` is in it
+   2. Add new Task Groups to `## Task Groups`
+   3. Add new tasks to `## Tasks Queue` with multi-agent metadata:
+      - Compute status: check if each task's `**Depends on:**` targets are all in `completed_tasks`
+      - All deps satisfied or `Depends on: None` → `{agent: -, status: pending}`
+      - Any dep not satisfied → `{agent: -, status: blocked}`
+      - Example: `- [ ] TASK-15: New Task Title {agent: -, status: pending}`
+   4. Add dependency entries to `## Dependencies` section (for tasks with dependencies only):
+      - Example: `- TASK-15: [TASK-12]`
+      - Tasks with `Depends on: None` are NOT added to Dependencies
+   5. Release lock: `rm .ralph-flow/01-tasks-loop/.tracker-lock`
+8. Mark done in tracker: check off queue, completed mapping, `active_story: none`, `stage: analyze`, update Dependency Graph, log
+9. Exit: `kill -INT $PPID`
+
+**TASK-GROUP header:**
+```markdown
+# TASK-GROUP-{X}: {Title}
+
+**Source:** STORY-{N}
+**Goal:** {1-3 sentences — the outcome, not the implementation}
+**Milestones:**
+- [ ] {Checkpoint} (TASK-{A}, TASK-{B})
+**Shared Context:**
+{Domain knowledge, constraints, relationships between tasks in this group}
+```
+
+**Task format:**
+```markdown
+## TASK-{N}: {Concise title}
+
+**Source:** STORY-{M}
+**Task-Group:** TASK-GROUP-{X}
+**Depends on:** {TASK-{Y} or "None"}
+
+### Intent
+{The purpose — the problem being solved and who benefits. 2-4 sentences.}
+
+### Today
+{How things work right now. Reference behavior, not file paths.}
+
+### After
+{The end-user experience once delivered. Describe the outcome, not the implementation.}
+
+### Verification
+{Concrete steps to confirm the change works — navigate here, do this, expect that.}
+
+### Acceptance Criteria
+- [ ] {Specific, observable condition — at least 3}
+```
+
+---
+
+## Rules
+
+- One story at a time. All 3 stages run in one iteration, one `kill` at the end.
+- Read tracker first, update tracker last.
+- Append to `tasks.md` — never overwrite. Numbers globally unique and sequential.
+- Tasks must be self-contained — the tasks loop never reads `stories.md`.
+- Split into multiple groups when story spans distinct areas.
+- Each task ≈ one implementable unit. No Scope or Risks sections — the tasks loop handles those in phase plans.
+- Mark inter-task dependencies explicitly.
+
+---
+
+Read `.ralph-flow/00-story-loop/tracker.md` now and begin.

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

@@ -0,0 +1,3 @@
+# Stories
+
+<!-- Add stories below. Format: ## STORY-{N}: {Title} + **Depends on:** tag -->

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

@@ -0,0 +1,16 @@
+# Story Loop — Tracker
+
+- active_story: none
+- stage: analyze
+- completed_stories: []
+- pending_stories: []
+
+---
+
+## Stories Queue
+
+## Dependency Graph
+
+## Completed Mapping
+
+## Log

package/src/templates/code-implementation/loops/01-tasks-loop/loop.md

@@ -0,0 +1,60 @@
+# Tasks Loop — Execution
+
+## Using RalphFlow CLI
+
+```bash
+# Single agent
+npx ralphflow run tasks
+
+# Multi-agent (3 parallel agents)
+npx ralphflow run tasks --agents 3
+```
+
+## Manual (without CLI)
+
+### Single Agent
+
+#### Option 1: ralph-loop slash command
+
+```
+/ralph-loop "$(cat .ralph-flow/01-tasks-loop/prompt.md)" --max-iterations 50 --completion-promise "ALL TASKS COMPLETE"
+```
+
+#### Option 2: while loop
+
+```bash
+while :; do cat .ralph-flow/01-tasks-loop/prompt.md | claude --dangerously-skip-permissions --model claude-opus-4-6; done
+```
+
+---
+
+### Multi-Agent (2+ terminals)
+
+Each terminal runs a named agent. `{{AGENT_NAME}}` is injected via `sed`.
+
+#### Terminal 1
+
+```bash
+AGENT=agent-1 && while :; do sed "s/{{AGENT_NAME}}/$AGENT/g" .ralph-flow/01-tasks-loop/prompt.md | claude --dangerously-skip-permissions --model claude-opus-4-6; done
+```
+
+#### Terminal 2
+
+```bash
+AGENT=agent-2 && while :; do sed "s/{{AGENT_NAME}}/$AGENT/g" .ralph-flow/01-tasks-loop/prompt.md | claude --dangerously-skip-permissions --model claude-opus-4-6; done
+```
+
+#### Terminal 3 (optional)
+
+```bash
+AGENT=agent-3 && while :; do sed "s/{{AGENT_NAME}}/$AGENT/g" .ralph-flow/01-tasks-loop/prompt.md | claude --dangerously-skip-permissions --model claude-opus-4-6; done
+```
+
+---
+
+## Notes
+
+- Single agent mode uses `cat` — no `{{AGENT_NAME}}` substitution needed (prompt defaults to `agent-1`)
+- Multi-agent mode uses `sed` to inject the agent name into the prompt
+- Each agent gets its own terminal — they coordinate via `tracker.md`
+- Up to 4 agents can run concurrently depending on task dependency chains

package/src/templates/code-implementation/loops/01-tasks-loop/prompt.md

@@ -0,0 +1,162 @@
+# Tasks Loop — Implement Tasks
+
+**You are agent `{{AGENT_NAME}}`.** Multiple agents may work in parallel.
+Coordinate via `tracker.md` — the single source of truth.
+*(If you see the literal text `{{AGENT_NAME}}` above — i.e., it was not substituted — treat your name as `agent-1`.)*
+
+Read `.ralph-flow/01-tasks-loop/tracker.md` FIRST to determine where you are.
+
+> **PROJECT CONTEXT.** Read `CLAUDE.md` for architecture, stack, conventions, commands, and URLs.
+
+**Pipeline:** `tasks.md → YOU → code changes + skills`
+
+---
+
+## Tracker Lock Protocol
+
+Before ANY write to `tracker.md`, you MUST acquire the lock:
+
+**Lock file:** `.ralph-flow/01-tasks-loop/.tracker-lock`
+
+### Acquire Lock
+1. Check if `.tracker-lock` exists
+   - Exists AND file is < 60 seconds old → sleep 2s, retry (up to 5 retries)
+   - Exists AND file is ≥ 60 seconds old → stale lock, delete it (agent crashed mid-write)
+   - Does not exist → continue
+2. Write lock: `echo "{{AGENT_NAME}} $(date -u +%Y-%m-%dT%H:%M:%SZ)" > .ralph-flow/01-tasks-loop/.tracker-lock`
+3. Sleep 500ms (`sleep 0.5`)
+4. Re-read `.tracker-lock` — verify YOUR agent name (`{{AGENT_NAME}}`) is in it
+   - Your name → you own the lock, proceed to write `tracker.md`
+   - Other name → you lost the race, retry from step 1
+5. Write your changes to `tracker.md`
+6. Delete `.tracker-lock` immediately: `rm .ralph-flow/01-tasks-loop/.tracker-lock`
+7. Never leave a lock held — if your write fails, delete the lock in your error handler
+
+### When to Lock
+- Claiming a task (pending → in_progress)
+- Completing a task (in_progress → completed, unblocking dependents)
+- Updating stage transitions (understand → execute → verify)
+- Heartbeat updates (bundled with other writes, not standalone)
+
+### When NOT to Lock
+- Reading `tracker.md` — read-only access needs no lock
+- Reading `tasks.md` — always read-only
+
+---
+
+## Task Selection Algorithm
+
+Instead of "pick next unchecked task", follow this algorithm:
+
+1. **Parse tracker** — read `completed_tasks`, `## Dependencies`, Tasks Queue metadata `{agent, status}`, Agent Status table
+2. **Update blocked→pending** — for each task with `status: blocked`, check if ALL its dependencies (from `## Dependencies`) are in `completed_tasks`. If yes, acquire lock and update to `status: pending`
+3. **Resume own work** — if any task has `{agent: {{AGENT_NAME}}, status: in_progress}`, resume it (skip to the current stage)
+4. **Find claimable** — filter tasks where `status: pending` AND `agent: -`
+5. **Apply task-group affinity** — prefer tasks in groups where `{{AGENT_NAME}}` already completed work (preserves codebase context). If no affinity match, pick any claimable task
+6. **Claim** — acquire lock, set `{agent: {{AGENT_NAME}}, status: in_progress}`, update your Agent Status row, update `last_heartbeat`, release lock, log the claim
+7. **Nothing available:**
+   - All tasks completed → emit `<promise>ALL TASKS COMPLETE</promise>`
+   - All remaining tasks are blocked or claimed by others → log "{{AGENT_NAME}}: waiting — all tasks blocked or claimed", exit: `kill -INT $PPID` (the `while` loop restarts and re-checks)
+
+### New Task Discovery
+
+If you find a task in the Tasks Queue without `{agent, status}` metadata (e.g., added by the story loop while agents were running):
+1. Read the task's `**Depends on:**` field in `tasks.md`
+2. Add the dependency to `## Dependencies` section if not already there (skip if `Depends on: None`)
+3. Set status to `pending` (all deps in `completed_tasks`) or `blocked` (deps incomplete)
+4. Set agent to `-`
+
+---
+
+## Anti-Hijacking Rules
+
+1. **Never touch another agent's `in_progress` task** — do not modify, complete, or reassign it
+2. **Respect task-group ownership** — if another agent has an active `in_progress` task in a group, leave remaining group tasks for them (affinity will naturally guide this). Only claim from that group if the other agent has finished all their group tasks
+3. **Note file overlap conflicts** — if your task modifies files that another agent's active task also modifies, log a WARNING in the tracker and coordinate carefully
+
+---
+
+## Heartbeat Protocol
+
+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 task — user must manually reset.
+
+---
+
+## Crash Recovery (Self)
+
+On fresh start, if your agent name has an `in_progress` task but you have no memory of it:
+- Code committed for that task → resume at VERIFY stage
+- No commits found → restart from UNDERSTAND stage
+
+---
+
+## State Machine (2 stages per task)
+
+```
+UNDERSTAND & EXECUTE → Read task, explore, implement, deploy, commit        → stage: verify
+VERIFY & DOCUMENT    → Check logs/health, update CLAUDE.md, skills, mark done → next task
+```
+
+When ALL done: `<promise>ALL TASKS COMPLETE</promise>`
+
+After completing ANY stage, exit: `kill -INT $PPID`
+
+---
+
+## STAGE 1: UNDERSTAND & EXECUTE
+
+1. Read tracker → **run task selection algorithm** (see above)
+2. Read task in `tasks.md` + its TASK-GROUP header
+3. If sibling tasks are done, read their commits/diffs to align
+4. Read `CLAUDE.md` for project context
+5. Explore codebase — **40+ files:** affected areas, dependencies, patterns
+6. Acquire lock → update tracker: your Agent Status row `active_task: TASK-{N}`, `stage: execute`, `last_heartbeat`, log entry → release lock
+7. Implement changes. Match existing patterns per `CLAUDE.md`.
+8. Deploy/rebuild (commands in `CLAUDE.md`)
+9. **Quick verify:** check container logs for errors, hit health endpoints, confirm no crashes
+10. Commit with a clear message
+11. Acquire lock → update tracker: `stage: verify`, `last_heartbeat`, log entry → release lock
+
+## STAGE 2: VERIFY & DOCUMENT
+
+1. Deploy if not already running. Check container logs, hit health endpoints (commands in `CLAUDE.md`)
+2. Run lint/type checks if applicable (see `CLAUDE.md`)
+3. **Functional verify:** test the actual change — hit new/modified endpoints, check DB state, verify expected behavior through CLI/curl/API calls
+4. **FAIL** → fix the issue, re-deploy, re-verify. If stuck, log details in tracker and move on
+5. **PASS** → continue to documentation
+6. Update `CLAUDE.md` (≤150 words net). Commit separately.
+7. Create/update `.claude/skills/` if this task produced reusable knowledge. Skip if nothing reusable.
+8. **Mark done & unblock dependents:**
+   - Acquire lock
+   - Add task to `completed_tasks` list
+   - Check off task in Tasks Queue: `[x]`, set `{completed}`
+   - Add commit hash to Completed Mapping
+   - **Unblock dependents:** for each task in `## Dependencies` that lists the just-completed task, check if ALL its dependencies are now in `completed_tasks`. If yes, update that task's status from `blocked` → `pending` in the Tasks Queue
+   - Update your Agent Status row: clear `active_task`
+   - Update `last_heartbeat`
+   - Log entry
+   - Release lock
+9. **Run task selection algorithm again:**
+   - Claimable task found → claim it, set `stage: understand`, exit: `kill -INT $PPID`
+   - All tasks completed → `<promise>ALL TASKS COMPLETE</promise>`
+   - All blocked/claimed → log "waiting", exit: `kill -INT $PPID`
+
+---
+
+## First-Run Handling
+
+If Tasks Queue in tracker is empty: read `tasks.md`, scan `## TASK-{N}:` headers, populate queue with `{agent: -, status: pending|blocked}` metadata (compute from Dependencies), then start.
+
+## Rules
+
+- One task at a time per agent. One stage per iteration.
+- Read tracker first, update tracker last. Always use lock protocol for writes.
+- Read `CLAUDE.md` for all project-specific context.
+- Align with sibling tasks via TASK-GROUP context.
+- Thorough exploration: 40+ files (Stage 1).
+- Create skills in `.claude/skills/` for reusable patterns.
+- **Multi-agent: never touch another agent's in_progress task. Coordinate via tracker.md.**
+
+---
+
+Read `.ralph-flow/01-tasks-loop/tracker.md` now and begin.

package/src/templates/code-implementation/loops/01-tasks-loop/tasks.md

@@ -0,0 +1,3 @@
+# Tasks
+
+<!-- Add tasks below. Format: ## TASK-{N}: {Title} -->

package/src/templates/code-implementation/loops/01-tasks-loop/tracker.md

@@ -0,0 +1,18 @@
+# Tasks Loop — Tracker
+
+- completed_tasks: []
+
+## Agent Status
+
+| agent | active_task | stage | last_heartbeat |
+|-------|-------------|-------|----------------|
+
+---
+
+## Dependencies
+
+## Task Groups
+
+## Tasks Queue
+
+## Log

package/src/templates/code-implementation/loops/02-delivery-loop/loop.md

@@ -0,0 +1,21 @@
+# Delivery Loop — Execution
+
+## Using RalphFlow CLI
+
+```bash
+npx ralphflow run delivery
+```
+
+## Manual (without CLI)
+
+### Option 1: ralph-loop slash command
+
+```
+/ralph-loop "$(cat .ralph-flow/02-delivery-loop/prompt.md)" --max-iterations 20 --completion-promise "ALL DELIVERABLES PRESENTED"
+```
+
+### Option 2: while loop
+
+```bash
+while :; do cat .ralph-flow/02-delivery-loop/prompt.md | claude --dangerously-skip-permissions --model claude-opus-4-6; done
+```

package/src/templates/code-implementation/loops/02-delivery-loop/prompt.md

@@ -0,0 +1,105 @@
+# Delivery Loop — Present Completed Stories for Feedback
+
+Read `.ralph-flow/02-delivery-loop/tracker.md` FIRST to determine where you are.
+
+> **You are a service delivery agent. The user is your client.** Your job is to present completed work, gather structured feedback, and resolve it. Small bugs are fixed on the spot. Everything else becomes a new story.
+
+> Only write to: `02-delivery-loop/tracker.md`, `00-story-loop/stories.md`. Source code is writable ONLY for small bug fixes during RESOLUTION.
+
+**Pipeline:** `completed STORYs → YOU → feedback → small fixes + new stories`
+
+---
+
+## First-Run Handling
+
+If Delivery Queue is empty, build it by scanning the task tracker:
+
+1. Read `00-story-loop/tracker.md` → find the **Completed Mapping** section. This maps each STORY to its TASK-GROUPs and their TASKs.
+2. Read `01-tasks-loop/tracker.md` → find the `completed_tasks` list AND the Tasks Queue (look for cancelled tasks marked with `~~strikethrough~~`).
+3. For each STORY in the Completed Mapping:
+   - Gather ALL non-cancelled tasks across ALL its task-groups
+   - Check that every non-cancelled task appears in `completed_tasks`
+   - **Cancellation rule:** Cancelled tasks (strikethrough in tasks queue) count as "done" for readiness. A story with some cancelled task-groups is still deliverable if all remaining tasks are complete.
+4. Skip stories that already appear in the Delivered list in `02-delivery-loop/tracker.md`
+5. Add ready stories to Delivery Queue in story-number order
+
+Pick the next undelivered STORY from the queue. If none remain: `<promise>ALL DELIVERABLES PRESENTED</promise>`.
+
+---
+
+## State Machine (3 phases per STORY)
+
+```
+PHASE 1: REVIEW               → Agent reviews independently (no user interaction)
+PHASE 2: PRESENT-AND-FEEDBACK → Combined walkthrough + 3-4 questions in one pass
+PHASE 3: RESOLUTION           → Fix small bugs, create stories for changes → kill
+```
+
+Phase 1 → Phase 2 flows continuously in one iteration (no kill between them). Only one `kill` per story at the end of Phase 3.
+
+---
+
+## PHASE 1: REVIEW (agent-driven, no user interaction)
+
+1. Read all task-groups and tasks for this story from `01-tasks-loop/tasks.md`
+2. Read phase plans from `01-tasks-loop/phases/`
+3. Read `CLAUDE.md` for project context
+4. **Review independently:** Walk through each task's verification steps. Note anything wrong, broken, or inconsistent. Build a presentation narrative.
+5. For cancelled tasks/groups: note what was superseded and why
+6. Record review notes in tracker log
+7. Update tracker: `active_story: STORY-{N}`, `stage: present-and-feedback`
+8. **Flow directly into Phase 2** (no stop)
+
+## PHASE 2: PRESENT-AND-FEEDBACK (combined, one AskUserQuestion call)
+
+1. **Present structured walkthrough** of ALL task-groups in the story:
+   - Per task-group: what was built (plain language), how to verify it
+   - Any issues the agent found during Phase 1 review
+   - Cancelled tasks/groups with brief explanation of what was superseded
+2. **Ask 3-4 questions in ONE `AskUserQuestion` call:**
+   - **Q1: Working correctly?** Does everything work as expected? Note any specific issues.
+   - **Q2: Behavior or appearance?** Anything to change about look, feel, or behavior?
+   - **Q3: Missing or new ideas?** Anything missing, or new ideas sparked by what you see?
+   - **Q4: Priority?** *(optional — drop for simple stories with no issues)* What matters most?
+3. **Categorize feedback:**
+   - **BUG** — something is broken or wrong (fix it now)
+   - **CHANGE** — works but needs adjustment, or entirely new functionality (new story)
+4. Record feedback with categories in tracker log
+5. Update tracker: `stage: resolution`
+
+## PHASE 3: RESOLUTION
+
+For each feedback item, route appropriately:
+
+**BUG (small fix):** Fix it right now. Read `CLAUDE.md` for conventions, make the code change, deploy, verify, commit. Log what was fixed.
+
+**CHANGE (any size):** Create a new story in `00-story-loop/stories.md` with:
+- User-experience-level description (not implementation details)
+- `**Origin:** STORY-{M} delivery feedback — relates to TASK-GROUP-{X}`
+- `**Depends on:** STORY-{M}`
+- Do NOT create task-groups or tasks (the story loop handles decomposition)
+
+Log the story number created.
+
+**No feedback (user approves everything):** Move to Delivered, log "approved with no changes".
+
+After resolving all feedback:
+1. Move STORY to Delivered list in tracker with summary of fixes made and stories created
+2. Update tracker: `active_story: none`, `stage: review`
+3. Exit: `kill -INT $PPID`
+
+---
+
+## Rules
+
+- One STORY at a time. All 3 phases run in one iteration, one `kill` at the end.
+- Phase 1 → Phase 2 flows continuously (no kill between them).
+- Read tracker first, update tracker last.
+- **Only modify source code for small bug fixes** identified during RESOLUTION. Read `CLAUDE.md` for patterns.
+- Anything beyond a quick fix → new story. When in doubt, make it a story.
+- Present work in user-friendly language — no jargon, no implementation details unless asked.
+- Handle cancelled tasks/groups honestly — explain what was superseded and why.
+
+---
+
+Read `.ralph-flow/02-delivery-loop/tracker.md` now and begin.

package/src/templates/code-implementation/loops/02-delivery-loop/tracker.md

@@ -0,0 +1,13 @@
+# Delivery Loop — Tracker
+
+- active_story: none
+- stage: idle
+- feedback: none
+
+---
+
+## Delivery Queue
+
+## Delivered
+
+## Log

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

@@ -0,0 +1,71 @@
+name: code-implementation
+description: "Story → Task → Delivery pipeline for code projects"
+version: 1
+dir: .ralph-flow
+
+entities:
+  STORY:
+    prefix: STORY
+    data_file: 00-story-loop/stories.md
+  TASK:
+    prefix: TASK
+    data_file: 01-tasks-loop/tasks.md
+  TASK-GROUP:
+    prefix: TASK-GROUP
+    data_file: 01-tasks-loop/tasks.md
+
+loops:
+  story-loop:
+    order: 0
+    name: "Story Loop"
+    prompt: 00-story-loop/prompt.md
+    tracker: 00-story-loop/tracker.md
+    data_files:
+      - 00-story-loop/stories.md
+    entities: [STORY]
+    stages: [analyze, clarify, decompose]
+    completion: "ALL STORIES PROCESSED"
+    feeds: [tasks-loop]
+    multi_agent: false
+    cadence: 0
+
+  tasks-loop:
+    order: 1
+    name: "Tasks Loop"
+    prompt: 01-tasks-loop/prompt.md
+    tracker: 01-tasks-loop/tracker.md
+    data_files:
+      - 01-tasks-loop/tasks.md
+    directories:
+      - 01-tasks-loop/phases/
+      - 01-tasks-loop/testing/
+    entities: [TASK, TASK-GROUP]
+    stages: [understand-execute, verify-document]
+    completion: "ALL TASKS COMPLETE"
+    fed_by: [story-loop]
+    feeds: [delivery-loop]
+    multi_agent:
+      enabled: true
+      max_agents: 4
+      strategy: tracker-lock
+      agent_placeholder: "{{AGENT_NAME}}"
+    lock:
+      file: 01-tasks-loop/.tracker-lock
+      type: echo
+      stale_seconds: 60
+    worktree:
+      strategy: shared
+      auto_merge: true
+    cadence: 0
+
+  delivery-loop:
+    order: 2
+    name: "Delivery Loop"
+    prompt: 02-delivery-loop/prompt.md
+    tracker: 02-delivery-loop/tracker.md
+    entities: [STORY]
+    stages: [review, present-and-feedback, resolution]
+    completion: "ALL DELIVERABLES PRESENTED"
+    fed_by: [tasks-loop]
+    multi_agent: false
+    cadence: 0