create-merlin-brain 2.5.1 → 2.6.0

package/files/commands/merlin/execute-phase.md

@@ -205,19 +205,75 @@ After user runs `/merlin:plan-phase {Z} --gaps`:
 </offer_next>
 
 <wave_execution>
-**Parallel spawning:**
+**Worktree-isolated parallel spawning (default for 2+ plans in a wave):**
 
-Spawn all plans in a wave with a single message containing multiple Task calls:
+Before spawning, create a git worktree per plan so agents work in isolation:
 
+```bash
+REPO_ROOT=$(git rev-parse --show-toplevel)
+REPO_NAME=$(basename "$REPO_ROOT")
+CURRENT_BRANCH=$(git branch --show-current)
+
+# Create worktree for each plan
+git worktree add "${REPO_ROOT}/../${REPO_NAME}-worktree-01" -b merlin/worktree-01
+git worktree add "${REPO_ROOT}/../${REPO_NAME}-worktree-02" -b merlin/worktree-02
 ```
-Task(prompt="Execute plan at {plan_01_path}\n\nPlan: @{plan_01_path}\nProject state: @.planning/STATE.md", subagent_type="merlin-executor")
-Task(prompt="Execute plan at {plan_02_path}\n\nPlan: @{plan_02_path}\nProject state: @.planning/STATE.md", subagent_type="merlin-executor")
-Task(prompt="Execute plan at {plan_03_path}\n\nPlan: @{plan_03_path}\nProject state: @.planning/STATE.md", subagent_type="merlin-executor")
+
+Then spawn with worktree context:
+
+```
+Task(prompt="Execute plan at {plan_01_path}
+
+<worktree_context>
+Working directory: {worktree_01_dir}
+Branch: merlin/worktree-01
+Main branch: {current_branch}
+All paths relative to worktree. Commit normally. Do NOT switch branches.
+</worktree_context>
+
+Plan: @{plan_01_path}
+Project state: @.planning/STATE.md", subagent_type="merlin-executor")
+
+Task(prompt="Execute plan at {plan_02_path}
+
+<worktree_context>
+Working directory: {worktree_02_dir}
+Branch: merlin/worktree-02
+Main branch: {current_branch}
+All paths relative to worktree. Commit normally. Do NOT switch branches.
+</worktree_context>
+
+Plan: @{plan_02_path}
+Project state: @.planning/STATE.md", subagent_type="merlin-executor")
 ```
 
-All three run in parallel. Task tool blocks until all complete.
+All run in parallel. Task tool blocks until all complete.
+
+**After wave completes, merge back:**
+
+```bash
+cd "$REPO_ROOT"
+git merge merlin/worktree-01 --no-edit
+git merge merlin/worktree-02 --no-edit
+# Clean up
+git worktree remove "${REPO_ROOT}/../${REPO_NAME}-worktree-01" --force
+git worktree remove "${REPO_ROOT}/../${REPO_NAME}-worktree-02" --force
+git branch -d merlin/worktree-01 merlin/worktree-02
+```
+
+**If merge conflicts:** abort merge, report conflicting files, offer user resolution options (manual resolve, re-run sequentially, or skip).
+
+**Fallback (single plan or no git):**
+
+If wave has only 1 plan, or worktree creation fails, spawn directly in main repo:
+
+```
+Task(prompt="Execute plan at {plan_path}\n\nPlan: @{plan_path}\nProject state: @.planning/STATE.md", subagent_type="merlin-executor")
+```
 
 **No polling.** No background agents. No TaskOutput loops.
+
+**Always clean up worktrees** on success, failure, or abort.
 </wave_execution>
 
 <checkpoint_handling>

package/files/commands/merlin/help.md

@@ -220,6 +220,17 @@ Check project status and intelligently route to next action.
 
 Usage: `/merlin:progress`
 
+**`/merlin:standup`**
+Generate a daily standup summary from git history and planning state.
+
+- Shows what was done (commits grouped by feature)
+- Shows what's in progress (current phase/plan)
+- Shows blockers and issues needing attention
+- Shows overall progress with percentages
+- Scannable in under 30 seconds
+
+Usage: `/merlin:standup`
+
 ### Session Management
 
 **`/merlin:resume-work`**

package/files/commands/merlin/standup.md

@@ -0,0 +1,151 @@
+---
+name: merlin:standup
+description: Generate daily standup summary — done, in progress, blocked
+allowed-tools:
+  - Read
+  - Bash
+  - Grep
+  - Glob
+  - mcp__merlin__merlin_get_project_status
+  - mcp__merlin__merlin_get_blockers
+---
+
+<objective>
+Generate a quick daily standup summary from git history, planning state, and task status.
+
+Shows what was done, what's in progress, and what's blocked — like a dev standup but assembled automatically from the codebase state.
+
+Output is concise and actionable. No fluff.
+</objective>
+
+<execution_context>
+@~/.claude/merlin/workflows/standup.md
+</execution_context>
+
+<context>
+@.planning/STATE.md
+@.planning/ROADMAP.md
+</context>
+
+<process>
+1. **Gather git activity (last 24 hours):**
+
+   ```bash
+   # Commits in last 24h
+   git log --oneline --since="24 hours ago" --no-merges 2>/dev/null
+
+   # Files changed in last 24h
+   git log --since="24 hours ago" --no-merges --name-only --pretty=format: 2>/dev/null | sort -u | grep -v '^$'
+
+   # Lines changed summary
+   git diff --stat HEAD~$(git log --oneline --since="24 hours ago" --no-merges 2>/dev/null | wc -l | tr -d ' ')..HEAD 2>/dev/null
+   ```
+
+2. **Gather planning state:**
+
+   ```bash
+   # Current phase and status from ROADMAP
+   grep -A2 "🚧\|In Progress\|Building" .planning/ROADMAP.md 2>/dev/null
+
+   # Completed summaries (recently created)
+   find .planning/phases -name "*-SUMMARY.md" -newer .planning/STATE.md 2>/dev/null
+
+   # Pending plans
+   find .planning/phases -name "*-PLAN.md" 2>/dev/null | while read plan; do
+     summary="${plan/-PLAN.md/-SUMMARY.md}"
+     if [ ! -f "$summary" ]; then
+       echo "PENDING: $plan"
+     fi
+   done
+   ```
+
+3. **Check for blockers:**
+
+   ```
+   Call: merlin_get_blockers (if available)
+   ```
+
+   Also scan for:
+   ```bash
+   # TODO/FIXME/HACK in recently changed files
+   git log --since="24 hours ago" --no-merges --name-only --pretty=format: 2>/dev/null | sort -u | grep -v '^$' | while read f; do
+     grep -n "TODO\|FIXME\|HACK\|XXX" "$f" 2>/dev/null | head -3
+   done
+   ```
+
+4. **Get project status from Merlin Cloud:**
+
+   ```
+   Call: merlin_get_project_status
+   ```
+
+5. **Generate standup report:**
+
+   Format and display the standup (see <standup_format>).
+
+</process>
+
+<standup_format>
+```
+═══════════════════════════════════════
+📊 STANDUP — {date}
+═══════════════════════════════════════
+
+## ✅ Done (last 24h)
+
+{For each meaningful commit group:}
+- **{feature/area}**: {what was accomplished}
+  {commit count} commits, {files changed} files
+
+{If no commits:}
+- No commits in the last 24 hours.
+
+## 🚧 In Progress
+
+- **Phase {N}: {Name}** — {status from ROADMAP}
+  {Current plan being executed, if any}
+  {Task count: X done, Y pending}
+
+## 🔴 Blocked / Needs Attention
+
+{For each blocker:}
+- **{blocker type}**: {description}
+  {Where: file or context}
+
+{If no blockers:}
+- No blockers. Clear to proceed.
+
+## 📈 Progress
+
+{From merlin_get_project_status:}
+- Milestone: {current milestone}
+- Phase: {current phase} of {total phases}
+- Tasks: {done}/{total} ({percentage}%)
+
+───────────────────────────────────────
+Next: {recommended action}
+═══════════════════════════════════════
+```
+</standup_format>
+
+<grouping_rules>
+**Group commits by feature/area, not individually.**
+
+- Group by commit prefix: `feat(auth)`, `fix(billing)`, `docs(phase-3)` → group by scope
+- If no conventional commits, group by directory: all `src/routes/auth/*` → "Auth routes"
+- Collapse "docs(phase-X): complete..." into "Phase X planning complete"
+- Skip merge commits and trivial formatting
+
+**Summarize, don't list:**
+- Bad: "feat(auth): add login", "feat(auth): add logout", "feat(auth): add refresh"
+- Good: "**Auth**: Login, logout, and refresh token endpoints (3 commits, 5 files)"
+</grouping_rules>
+
+<success_criteria>
+- [ ] Git activity from last 24h summarized
+- [ ] Current phase/plan status shown
+- [ ] Blockers identified (if any)
+- [ ] Progress percentage shown
+- [ ] Next recommended action shown
+- [ ] Output is scannable in under 30 seconds
+</success_criteria>

package/files/merlin/workflows/execute-phase.md

@@ -143,6 +143,128 @@ Report wave structure with context:
 The "What it builds" column comes from skimming plan names and objectives. Keep it brief (3 to 8 words).
 </step>
 
+<step name="worktree_management">
+**Git worktree isolation for parallel wave execution.**
+
+When multiple plans in a wave run simultaneously, they can conflict on file changes. Git worktrees give each agent its own working directory on a separate branch, then merge results back.
+
+**When to use worktrees:**
+- Wave has 2+ plans (parallel execution)
+- Git is available and repo has at least one commit
+- No `--no-worktrees` flag passed
+
+**When to skip worktrees (fallback to sequential):**
+- Wave has only 1 plan (no parallelism needed)
+- Git is not available or not a git repo
+- Worktree creation fails for any reason
+- User explicitly disabled worktrees
+
+**Create worktrees before spawning wave agents:**
+
+```bash
+# Get current branch name
+CURRENT_BRANCH=$(git branch --show-current)
+
+# For each plan in the wave, create a worktree
+# Use a sibling directory to avoid nesting inside the repo
+REPO_ROOT=$(git rev-parse --show-toplevel)
+REPO_NAME=$(basename "$REPO_ROOT")
+
+for PLAN_ID in {plan_ids_in_wave}; do
+  WORKTREE_DIR="${REPO_ROOT}/../${REPO_NAME}-worktree-${PLAN_ID}"
+  WORKTREE_BRANCH="merlin/worktree-${PLAN_ID}"
+
+  # Create branch from current HEAD and worktree
+  git worktree add "$WORKTREE_DIR" -b "$WORKTREE_BRANCH" 2>/dev/null
+
+  if [ $? -ne 0 ]; then
+    echo "WORKTREE_FAILED: Could not create worktree for ${PLAN_ID}"
+    # Fallback: run this wave sequentially in main tree
+  fi
+done
+```
+
+**Pass worktree path to each agent:**
+
+Each spawned agent receives its worktree directory as working directory context. The agent runs ALL file operations (Read, Write, Edit, Bash) relative to that worktree, not the main repo.
+
+Add to each agent's prompt:
+```
+<worktree_context>
+IMPORTANT: You are working in a git worktree, NOT the main repo.
+Working directory: {worktree_dir}
+Branch: merlin/worktree-{plan_id}
+Main branch: {current_branch}
+
+All file paths are relative to your worktree directory.
+Commit your work normally — commits go to your worktree branch.
+Do NOT switch branches or modify the main branch.
+</worktree_context>
+```
+
+**Merge worktrees back after wave completes:**
+
+After all agents in a wave finish:
+
+```bash
+# Switch to main branch
+cd "$REPO_ROOT"
+
+for PLAN_ID in {completed_plan_ids}; do
+  WORKTREE_BRANCH="merlin/worktree-${PLAN_ID}"
+  WORKTREE_DIR="${REPO_ROOT}/../${REPO_NAME}-worktree-${PLAN_ID}"
+
+  # Merge the worktree branch into main
+  git merge "$WORKTREE_BRANCH" --no-edit 2>&1
+  MERGE_EXIT=$?
+
+  if [ $MERGE_EXIT -ne 0 ]; then
+    echo "MERGE_CONFLICT: ${PLAN_ID} has conflicts with other plans"
+    # Abort the merge, report to user
+    git merge --abort
+    # See conflict_handling below
+  else
+    echo "MERGED: ${PLAN_ID} merged successfully"
+  fi
+
+  # Clean up worktree and branch
+  git worktree remove "$WORKTREE_DIR" --force 2>/dev/null
+  git branch -d "$WORKTREE_BRANCH" 2>/dev/null
+done
+```
+
+**Handle merge conflicts:**
+
+If a merge conflict occurs:
+1. Abort the failed merge: `git merge --abort`
+2. Report to user which plans conflicted and which files
+3. Present options:
+   ```
+   ⚠️ Merge conflict: Plan {A} and Plan {B} both modified {files}
+
+   [1] Resolve manually (show conflicting files)
+   [2] Re-run Plan {B} sequentially on top of Plan {A}
+   [3] Skip Plan {B} for now
+   ```
+4. If re-running: spawn a fresh agent for Plan B on the already-merged main branch
+
+**Cleanup on failure or abort:**
+
+Always clean up worktrees, even if execution fails:
+
+```bash
+# List and remove all merlin worktrees
+git worktree list | grep "worktree-" | awk '{print $1}' | while read dir; do
+  git worktree remove "$dir" --force 2>/dev/null
+done
+
+# Remove leftover worktree branches
+git branch --list "merlin/worktree-*" | while read branch; do
+  git branch -D "$branch" 2>/dev/null
+done
+```
+</step>
+
 <step name="execute_waves">
 Execute each wave in sequence. Autonomous plans within a wave run in parallel.
 
@@ -174,7 +296,29 @@ Examples:
 - Bad: "Executing terrain generation plan"
 - Good: "Procedural terrain generator using Perlin noise, creates height maps, biome zones, and collision meshes. Required before vehicle physics can interact with ground."
 
-2. **Spawn all autonomous agents in wave simultaneously:**
+2. **Set up worktrees for parallel waves:**
+
+If this wave has 2+ plans:
+
+```bash
+# Check git availability and worktree support
+git rev-parse --is-inside-work-tree 2>/dev/null
+```
+
+If git is available, follow the `worktree_management` step to create a worktree per plan. Store the mapping:
+```
+worktree_map = {
+  "plan-01": "/path/to/repo-worktree-plan-01",
+  "plan-02": "/path/to/repo-worktree-plan-02"
+}
+```
+
+If worktree creation fails for any plan, fall back to sequential execution for the entire wave:
+```
+⚠️ Worktree creation failed. Falling back to sequential execution for Wave {N}.
+```
+
+3. **Spawn all autonomous agents in wave simultaneously:**
 
 Use Task tool with multiple parallel calls. Each agent gets prompt from subagent-task-prompt template:
 
@@ -185,6 +329,22 @@ Execute plan {plan_number} of phase {phase_number}-{phase_name}.
 Commit each task atomically. Create SUMMARY.md. Update STATE.md.
 </objective>
 
+<worktree_context>
+{IF using worktrees:}
+IMPORTANT: You are working in a git worktree, NOT the main repo.
+Working directory: {worktree_dir}
+Branch: merlin/worktree-{plan_id}
+Main branch: {current_branch}
+
+All file paths are relative to your worktree directory.
+Commit your work normally — commits go to your worktree branch.
+Do NOT switch branches or modify the main branch.
+
+{IF not using worktrees (single plan or fallback):}
+Working in main repository directory.
+No worktree isolation — you have direct access to the main branch.
+</worktree_context>
+
 <merlin_requirement>
 **CRITICAL: Call Merlin before each task.**
 
@@ -218,11 +378,26 @@ Config: @.planning/config.json (if exists)
 </success_criteria>
 ```
 
-3. **Wait for all agents in wave to complete:**
+4. **Wait for all agents in wave to complete:**
 
 Task tool blocks until each agent finishes. All parallel agents return together.
 
-4. **Report completion and what was built:**
+5. **Merge worktrees back (if using worktrees):**
+
+After all agents complete, follow the `worktree_management` merge procedure:
+- Merge each worktree branch back to the main branch in plan order
+- If merge conflicts occur, follow the conflict resolution flow
+- Clean up all worktrees and branches
+
+Report merge results:
+```
+Worktree merge results:
+- Plan {A}: ✓ Merged cleanly
+- Plan {B}: ✓ Merged cleanly
+- Plan {C}: ⚠️ Conflict — {resolution taken}
+```
+
+6. **Report completion and what was built:**
 
 For each completed agent:
 - Verify SUMMARY.md exists at expected path
@@ -252,7 +427,7 @@ Examples:
 - Bad: "Wave 2 complete. Proceeding to Wave 3."
 - Good: "Terrain system complete, 3 biome types, height based texturing, physics collision meshes. Vehicle physics (Wave 3) can now reference ground surfaces."
 
-**3.5 Run Oudi quality and documentation skills after the wave:**
+**6.5 Run quality and documentation skills after the wave:**
 
 After all plans in the wave complete and their SUMMARY.md files are created:
 
@@ -281,19 +456,20 @@ Keep these skill runs pragmatic:
 - Prefer small, continuous improvements over big rewrites.
 - Do not over abstract. Favor clarity and maintainability.
 
-5. **Handle failures:**
+7. **Handle failures:**
 
 If any agent in wave fails:
 - Report which plan failed and why
+- If using worktrees: clean up that plan's worktree before proceeding
 - Ask user: "Continue with remaining waves?" or "Stop execution?"
 - If continue: proceed to next wave (dependent plans may also fail)
-- If stop: exit with partial completion report
+- If stop: clean up all worktrees, exit with partial completion report
 
-6. **Execute checkpoint plans between waves:**
+8. **Execute checkpoint plans between waves:**
 
 See <checkpoint_handling> for details.
 
-7. **Proceed to next wave**
+9. **Proceed to next wave**
 </step>
 
 <step name="checkpoint_handling">
@@ -585,6 +761,7 @@ No context bleed. Orchestrator never reads workflow internals. Just paths and re
 Subagent fails mid-plan:
 - SUMMARY.md will not exist
 - Orchestrator detects missing SUMMARY
+- If using worktrees: clean up that plan's worktree and branch
 - Reports failure, asks user how to proceed
 
 Dependency chain breaks:
@@ -595,13 +772,20 @@ Dependency chain breaks:
 
 All agents in wave fail:
 - Something systemic (git issues, permissions, etc)
+- Clean up ALL worktrees before stopping
 - Stop execution
 - Report for manual investigation
 
+Worktree-specific failures:
+- Worktree creation fails: fall back to sequential execution for that wave
+- Merge conflict after wave: present conflict to user with resolution options
+- Orphaned worktrees: always run cleanup at end of execution (success or failure)
+
 Checkpoint fails to resolve:
 - User cannot approve or provides repeated issues
 - Ask: "Skip this plan?" or "Abort phase execution?"
 - Record partial progress in STATE.md
+- Clean up any active worktrees
 </failure_handling>
 
 <resumption>

package/files/merlin/workflows/plan-phase.md

@@ -575,6 +575,73 @@ Plan 05: depends_on: ["03", "04"] → wave: 3
 Store wave number with each plan in memory. Write to frontmatter in next step.
 </step>
 
+<step name="detect_file_conflicts">
+**Analyze file overlap between same-wave plans to prevent unsafe parallel execution.**
+
+After assigning waves, check every pair of plans in the same wave for file conflicts:
+
+```
+for each wave W:
+  plans_in_wave = [plans where plan.wave == W]
+
+  for each pair (plan_A, plan_B) in plans_in_wave:
+    shared_files = intersection(plan_A.files_modified, plan_B.files_modified)
+
+    if shared_files is not empty:
+      # These plans cannot safely run in parallel
+      plan_A.conflicts_with.append(plan_B.id)
+      plan_B.conflicts_with.append(plan_A.id)
+
+      # Serialize: move plan_B to next wave
+      plan_B.wave = W + 1
+      plan_B.depends_on.append(plan_A.id)
+
+      # Log the conflict for the user
+      log: "⚠️ File conflict: Plan {A} and Plan {B} both modify {shared_files}"
+      log: "  → Plan {B} moved to Wave {W+1} (serialized after Plan {A})"
+```
+
+**What counts as a file conflict:**
+- Exact same file path in both plans' `files_modified`
+- Same directory + wildcard overlap (e.g., both modify files in `src/routes/auth/`)
+- Shared config files (package.json, tsconfig.json, .env) — these ALWAYS conflict
+
+**What does NOT count as a conflict:**
+- Reading the same file (only writes conflict)
+- Different files in the same directory (unless a plan modifies an index/barrel file)
+- Test files for different features
+
+**Record conflicts in plan frontmatter:**
+
+```yaml
+---
+phase: XX-name
+plan: NN
+wave: 2                          # Bumped from 1 due to conflict
+depends_on: ["01"]               # Added due to conflict
+files_modified: ["src/routes/auth/login.ts", "src/middleware/auth.ts"]
+conflicts_with: ["01"]           # Plans that touch same files
+conflict_files: ["src/middleware/auth.ts"]  # The specific shared files
+autonomous: true
+---
+```
+
+**Report conflict analysis to user:**
+
+```
+## File Conflict Analysis
+
+| Plan A | Plan B | Shared Files | Resolution |
+|--------|--------|-------------|------------|
+| 01 | 02 | src/middleware/auth.ts | Plan 02 → Wave 2 (serialized) |
+
+Original waves: Plan 01 (W1), Plan 02 (W1)
+Adjusted waves: Plan 01 (W1), Plan 02 (W2, after 01)
+```
+
+**After conflict resolution, re-run wave assignment** to propagate any cascading changes (plans that depended on the moved plan may also shift).
+</step>
+
 <step name="group_into_plans">
 **Group tasks into plans based on dependency waves and autonomy.**
 
@@ -732,6 +799,8 @@ type: execute
 wave: N                     # Execution wave (1, 2, 3...). Computed at plan time.
 depends_on: []              # Plan IDs this plan requires.
 files_modified: []          # Files this plan touches.
+conflicts_with: []          # Plans that touch same files (detected by conflict analysis). Omit if empty.
+conflict_files: []          # Specific shared files causing conflicts. Omit if empty.
 autonomous: true            # false if plan has checkpoints requiring user interaction
 domain: [optional]
 user_setup: []              # Human-required setup (omit if empty)
@@ -889,15 +958,17 @@ Tasks are instructions for Claude, not Jira tickets.
 - [ ] Mandatory discovery completed (Level 0-3)
 - [ ] Prior decisions, issues, concerns synthesized
 - [ ] Dependency graph built (needs/creates for each task)
+- [ ] File conflict analysis run on same-wave plans
+- [ ] Conflicting plans serialized (moved to later waves) with conflicts_with metadata
 - [ ] Tasks grouped into plans by wave, not by sequence
 - [ ] PLAN file(s) exist with XML structure
-- [ ] Each plan: depends_on, files_modified, autonomous in frontmatter
+- [ ] Each plan: depends_on, files_modified, conflicts_with, autonomous in frontmatter
 - [ ] Each plan: user_setup declared if external services involved
 - [ ] Each plan: Objective, context, tasks, verification, success criteria, output
 - [ ] Each plan: 2-3 tasks (~50% context)
 - [ ] Each task: Type, Files (if auto), Action, Verify, Done
 - [ ] Checkpoints properly structured
-- [ ] Wave structure maximizes parallelism
+- [ ] Wave structure maximizes parallelism (with conflicts resolved)
 - [ ] PLAN file(s) committed to git
 - [ ] User knows next steps and wave structure
 

package/files/merlin/workflows/standup.md

@@ -0,0 +1,198 @@
+<purpose>
+Generate a daily standup summary from git history, planning state, and task status. Provides a quick "what happened, what's next, what's stuck" view.
+</purpose>
+
+<process>
+
+<step name="gather_git_activity">
+**Collect commit history from the last 24 hours.**
+
+```bash
+# Get all commits from last 24h (excluding merges)
+git log --oneline --since="24 hours ago" --no-merges 2>/dev/null
+```
+
+If no commits found, try last 48 hours as fallback:
+```bash
+git log --oneline --since="48 hours ago" --no-merges 2>/dev/null
+```
+
+For each commit, extract:
+- Commit hash (short)
+- Commit message
+- Files changed: `git diff-tree --no-commit-id --name-only -r {hash}`
+- Conventional commit prefix if present (feat, fix, docs, etc.)
+
+**Group commits by scope/area:**
+
+Parse conventional commit format `{type}({scope}): {message}`:
+- Group all commits with same scope together
+- If no conventional format, group by top-level directory of changed files
+- Collapse documentation/planning commits: "docs(phase-X): ..." → "Phase X planning"
+
+**Produce grouped summary:**
+
+```
+groups = {
+  "auth": ["add login endpoint", "add refresh token", "add logout"],
+  "billing": ["fix token balance query"],
+  "planning": ["complete phase 2 plan", "update roadmap"]
+}
+```
+
+Summarize each group in one line:
+- "**Auth**: Login, refresh, and logout endpoints (3 commits, 8 files)"
+- "**Billing**: Fixed token balance query reading from wrong table (1 commit, 3 files)"
+</step>
+
+<step name="gather_planning_state">
+**Read current project planning state.**
+
+```bash
+# Current roadmap status
+cat .planning/ROADMAP.md 2>/dev/null
+```
+
+Extract:
+- Current milestone name and status
+- Current phase number, name, and status (look for 🚧 or "In Progress" or "Building")
+- Total phases in milestone
+- How many phases complete vs remaining
+
+```bash
+# Find recently completed plans (SUMMARYs created in last 24h)
+find .planning/phases -name "*-SUMMARY.md" -newer .planning/STATE.md 2>/dev/null
+
+# Find pending plans (PLAN exists but no SUMMARY)
+find .planning/phases -name "*-PLAN.md" 2>/dev/null | while read plan; do
+  summary="${plan/-PLAN.md/-SUMMARY.md}"
+  if [ ! -f "$summary" ]; then
+    echo "$plan"
+  fi
+done
+```
+
+Read STATE.md for current position:
+```bash
+cat .planning/STATE.md 2>/dev/null
+```
+</step>
+
+<step name="gather_blockers">
+**Check for blockers and issues.**
+
+1. **Merlin Cloud blockers:**
+```
+Call: merlin_get_blockers (if MCP available)
+```
+
+2. **Code-level blockers (scan recent files):**
+```bash
+# Find TODO/FIXME/HACK in files changed in last 24h
+git log --since="24 hours ago" --no-merges --name-only --pretty=format: 2>/dev/null | sort -u | grep -v '^$' | while read f; do
+  if [ -f "$f" ]; then
+    matches=$(grep -n "TODO\|FIXME\|HACK\|XXX\|BLOCKED" "$f" 2>/dev/null)
+    if [ -n "$matches" ]; then
+      echo "=== $f ==="
+      echo "$matches" | head -5
+    fi
+  fi
+done
+```
+
+3. **Build/type errors (quick check):**
+```bash
+# Check if project has TypeScript
+if [ -f "tsconfig.json" ]; then
+  npx tsc --noEmit 2>&1 | tail -5
+fi
+```
+
+Categorize blockers:
+- **Hard blocker**: Build fails, type errors, test failures
+- **Soft blocker**: TODOs, FIXMEs that need attention
+- **External blocker**: Waiting on user input, API keys, third-party
+</step>
+
+<step name="gather_progress">
+**Get overall project progress.**
+
+```
+Call: merlin_get_project_status (if MCP available)
+```
+
+If MCP not available, calculate from files:
+```bash
+# Count completed vs total plans
+TOTAL=$(find .planning/phases -name "*-PLAN.md" 2>/dev/null | wc -l | tr -d ' ')
+DONE=$(find .planning/phases -name "*-SUMMARY.md" 2>/dev/null | wc -l | tr -d ' ')
+echo "Plans: $DONE/$TOTAL"
+```
+
+Extract:
+- Milestone name
+- Phase X of Y
+- Tasks done / total
+- Percentage complete
+</step>
+
+<step name="format_standup">
+**Assemble the standup report.**
+
+```
+═══════════════════════════════════════
+📊 STANDUP — {YYYY-MM-DD}
+═══════════════════════════════════════
+
+## ✅ Done (last 24h)
+
+{grouped commit summaries, one line per group}
+{If nothing: "No commits in the last 24 hours."}
+
+## 🚧 In Progress
+
+- **Phase {N}: {Name}** — {status}
+  {Plan being executed / next plan to execute}
+  {X of Y plans complete in this phase}
+
+## 🔴 Blocked / Needs Attention
+
+{hard blockers first, then soft blockers}
+{If nothing: "No blockers. Clear to proceed."}
+
+## 📈 Progress
+
+- Milestone: {name} ({version})
+- Phase: {current} of {total}
+- Plans: {done}/{total} ({pct}%)
+
+───────────────────────────────────────
+Next: {recommended action from project status or STATE.md}
+═══════════════════════════════════════
+```
+
+**Formatting rules:**
+- Keep each "Done" item to ONE line
+- Blockers should be actionable (say what needs to happen)
+- "Next" should be a specific command or action, not vague
+- Entire standup should be readable in under 30 seconds
+</step>
+
+</process>
+
+<customization>
+**Time range override:**
+
+If user passes an argument like "week" or "3d":
+- "week" → `--since="7 days ago"`
+- "3d" → `--since="3 days ago"`
+- Default → `--since="24 hours ago"`
+
+**Quiet mode:**
+
+If user passes "--quiet" or "-q":
+- Skip blockers scan
+- Skip build check
+- Only show Done + In Progress + Next
+- Fastest possible standup
+</customization>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-merlin-brain",
-  "version": "2.5.1",
+  "version": "2.6.0",
   "description": "Merlin - The Ultimate AI Brain for Claude Code. Installs workflows, agents, and Sights MCP server.",
   "type": "module",
   "main": "./dist/server/index.js",