create-merlin-brain 1.1.3 → 1.1.5

package/bin/install.js

@@ -185,14 +185,43 @@ _merlin_check_update() {
   fi
 }
 
-# Main claude wrapper with Merlin branding
+# Main claude wrapper with Merlin branding and Sights pre-check
 claude() {
-  # Show Merlin branding
-  echo -e "\\033[35m✦ Merlin\\033[0m"
-
   # Check for updates in background (silent, non-blocking)
   (_merlin_check_update &) 2>/dev/null
 
+  # Pre-flight: Check Sights connection (enforced at terminal level)
+  local status_output=$(merlin status 2>/dev/null)
+  local status_code=$(echo "$status_output" | head -1)
+
+  case "$status_code" in
+    CONNECTED)
+      local repo_name=$(echo "$status_output" | sed -n '2p')
+      echo -e "\\033[35m🔮 Merlin Sights:\\033[0m \\033[32mCONNECTED\\033[0m ✓"
+      echo -e "   Repository: $repo_name"
+      ;;
+    NOT_CONNECTED)
+      local repo_url=$(echo "$status_output" | sed -n '2p')
+      echo -e "\\033[35m🔮 Merlin Sights:\\033[0m \\033[33mNOT CONNECTED\\033[0m"
+      echo ""
+      echo "   This repo isn't in Sights yet: $repo_url"
+      echo ""
+      echo -e "   \\033[36m[1]\\033[0m Connect now (analysis takes 2-5 min)"
+      echo -e "   \\033[36m[2]\\033[0m Skip - work without Sights"
+      echo ""
+      echo -n "   Choice [1/2]: "
+      read -r choice
+      if [ "$choice" = "1" ]; then
+        merlin connect
+        echo ""
+      fi
+      ;;
+    *)
+      # Not in git repo or CLI not available - just show branding
+      echo -e "\\033[35m✦ Merlin\\033[0m"
+      ;;
+  esac
+
   # Run claude with Merlin agent
   command claude --agent merlin "$@"
 }
@@ -254,20 +283,84 @@ function cleanupLegacy() {
     }
   }
 
-  // Clean settings.local.json - remove old tool permissions
+  // Clean settings.local.json - remove old tool permissions AND broken hooks
   const settingsPath = path.join(CLAUDE_DIR, 'settings.local.json');
   if (fs.existsSync(settingsPath)) {
     try {
       let content = fs.readFileSync(settingsPath, 'utf8');
+      let modified = false;
+
+      // Remove old tool permissions
       if (content.includes('mcp__briefed__') || content.includes('ccwiki')) {
-        // Remove old tool permissions, keep everything else
         content = content.replace(/"mcp__briefed__[^"]+",?\s*/g, '');
-        fs.writeFileSync(settingsPath, content);
-        cleaned.push('~/.claude/settings.local.json (removed old tools)');
+        modified = true;
+      }
+
+      // Parse as JSON to clean up hooks properly
+      try {
+        let settings = JSON.parse(content);
+
+        // Remove broken hooks (contain $HOME, gsd-, or old paths)
+        if (settings.hooks) {
+          const hookTypes = ['PreToolUse', 'PostToolUse', 'Stop', 'Start'];
+          for (const hookType of hookTypes) {
+            if (Array.isArray(settings.hooks[hookType])) {
+              const originalLength = settings.hooks[hookType].length;
+              settings.hooks[hookType] = settings.hooks[hookType].filter(hook => {
+                // Remove hooks with $HOME (doesn't work on Windows)
+                // Remove hooks with gsd- (old Get Shit Done)
+                // Remove hooks referencing non-existent files
+                const hookPath = typeof hook === 'string' ? hook : hook?.command || hook?.path || '';
+                if (hookPath.includes('$HOME') ||
+                    hookPath.includes('gsd-') ||
+                    hookPath.includes('ccwiki') ||
+                    hookPath.includes('briefed')) {
+                  return false;
+                }
+                return true;
+              });
+              if (settings.hooks[hookType].length !== originalLength) {
+                modified = true;
+              }
+              // Remove empty hook arrays
+              if (settings.hooks[hookType].length === 0) {
+                delete settings.hooks[hookType];
+              }
+            }
+          }
+          // Remove hooks object if empty
+          if (Object.keys(settings.hooks).length === 0) {
+            delete settings.hooks;
+          }
+        }
+
+        if (modified) {
+          fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+          cleaned.push('~/.claude/settings.local.json (removed old tools and broken hooks)');
+        }
+      } catch (jsonErr) {
+        // If JSON parsing fails, just do string replacement
+        if (modified) {
+          fs.writeFileSync(settingsPath, content);
+          cleaned.push('~/.claude/settings.local.json (removed old tools)');
+        }
       }
     } catch (e) { /* ignore */ }
   }
 
+  // Clean up old hooks directory
+  const hooksDir = path.join(CLAUDE_DIR, 'hooks');
+  if (fs.existsSync(hooksDir)) {
+    const hookFiles = fs.readdirSync(hooksDir);
+    for (const file of hookFiles) {
+      // Remove old gsd-* hook files
+      if (file.startsWith('gsd-') || file.includes('ccwiki') || file.includes('briefed')) {
+        removeFile(path.join(hooksDir, file));
+        cleaned.push(`~/.claude/hooks/${file}`);
+      }
+    }
+  }
+
   // Clean config.json - remove briefed server, fix merlin server
   const configPath = path.join(CLAUDE_DIR, 'config.json');
   if (fs.existsSync(configPath)) {

package/bin/merlin-cli.js

@@ -17,7 +17,7 @@
 const https = require('https');
 const { execSync } = require('child_process');
 
-const API_URL = process.env.MERLIN_API_URL || 'https://claude-codeapi-production.up.railway.app';
+const API_URL = process.env.MERLIN_API_URL || 'https://auth.merlin.build';
 const API_KEY = process.env.MERLIN_API_KEY || '';
 
 // ============================================================
@@ -243,21 +243,53 @@ async function connect() {
   }
 }
 
+async function status() {
+  const repoUrl = detectGitRepo();
+  if (!repoUrl) {
+    // Not in a git repo - output for shell parsing
+    console.log('NO_GIT_REPO');
+    process.exit(1);
+  }
+
+  const repoId = await findRepoId(repoUrl);
+  if (!repoId) {
+    // Repo not connected
+    console.log('NOT_CONNECTED');
+    console.log(repoUrl);
+    process.exit(0);
+  }
+
+  // Connected - get repo name
+  try {
+    const overview = await apiRequest(`/api/agent/${repoId}/overview`);
+    const nameMatch = overview.match(/Name:\s*(.+)/);
+    const repoName = nameMatch ? nameMatch[1].trim() : repoUrl.split('/').pop();
+    console.log('CONNECTED');
+    console.log(repoName);
+    console.log(repoId);
+  } catch {
+    console.log('CONNECTED');
+    console.log(repoUrl.split('/').pop());
+    console.log(repoId);
+  }
+}
+
 function showHelp() {
   console.log(`
 Merlin CLI - Universal codebase intelligence for ALL AI agents
 
 Usage:
+  merlin status             Check if current repo is connected to Sights
+  merlin connect            Connect repo to Merlin Sights
   merlin context <task>     Get context for a task
   merlin search <query>     Search the codebase
   merlin brief              Get project overview
   merlin rules              Get coding rules
   merlin files <purpose>    Find files by purpose
-  merlin connect            Connect repo to Merlin Sights
 
 Environment:
   MERLIN_API_KEY            Your merlin.build API key
-  MERLIN_API_URL            API URL (default: https://claude-codeapi-production.up.railway.app)
+  MERLIN_API_URL            API URL (default: https://auth.merlin.build)
 
 Works with: Claude, Cursor, Windsurf, Copilot, Aider, and any AI agent!
 `);
@@ -290,6 +322,9 @@ async function main() {
     case 'connect':
       await connect();
       break;
+    case 'status':
+      await status();
+      break;
     case 'help':
     case '--help':
     case '-h':

package/files/CLAUDE.md

@@ -4,16 +4,16 @@
 
 **DO NOT read the user's message yet. DO NOT start working. FIRST:**
 
-1. **Call this tool NOW:** `merlin_get_selected_repo`
+### Step 1: Connect to Sights
 
-2. **Then show ONE of these responses:**
+```
+Call: merlin_get_selected_repo
+```
 
 **If repo IS connected:**
 ```
 🔮 Merlin Sights: CONNECTED ✓
    Repository: {repo_name}
-
-What would you like to work on?
 ```
 
 **If repo is NOT connected:**
@@ -28,13 +28,52 @@ This repository isn't in Sights yet.
 Which would you like?
 ```
 
-3. **WAIT for user response if not connected**
+Wait for user response if not connected.
+
+### Step 2: Check Project Status (THE ENFORCEMENT LOOP)
+
+```
+Call: merlin_get_project_status
+```
+
+**This returns:**
+- Vision completeness (PROJECT.md, ROADMAP.md exist?)
+- Task counts (pending, in progress, completed)
+- Checkpoint to resume from (if exists)
+- Next recommended action
 
-4. **ONLY THEN proceed with their actual request**
+**Display the status:**
+```
+📊 Project Status
+├── Vision: [✓ Complete / ❌ Missing PROJECT.md / ❌ Missing ROADMAP.md]
+├── Tasks: [X] done, [Y] pending
+├── Progress: [████████░░] 80%
+└── Next: [recommended action]
+```
+
+### Step 3: Route Based on Status
+
+| Status | What To Do |
+|--------|------------|
+| No PROJECT.md | Show: "No project defined. Run `/merlin:new-project` to start." |
+| No ROADMAP.md | Show: "No roadmap. Run `/merlin:discuss-milestone` to plan." |
+| Has checkpoint | Show: "Resume from [task]?" and offer to continue |
+| Empty backlog | Show: "⚠️ No tasks! Run `/merlin:discuss-milestone` to plan more." |
+| Has pending tasks | Show next task and "Ready to work?" |
+
+### Step 4: Only THEN Proceed
+
+After showing status and routing, THEN read the user's actual request.
 
 ---
 
-**WHY THIS MATTERS:** The user needs visual confirmation that Sights is working. Always show the 🔮 status box at session start. Never skip this step.
+**WHY THIS MATTERS:**
+- Visual confirmation that Sights is working
+- Projects always have vision documented
+- Projects always have tasks until complete
+- Any agent can pick up where work left off
+
+**THE RULE:** A project should NEVER have zero tasks unless explicitly marked complete.
 
 ---
 
@@ -257,6 +296,14 @@ After EVERY Merlin tool call, display a cue box showing what you found and wheth
 - `merlin_get_rules` - Get all coding rules for this project
 - `merlin_remove_rule` - Remove a coding rule
 
+**Project Management Tools (NEW):**
+- `merlin_get_project_status` - Get vision/task/progress status (call at session start!)
+- `merlin_ensure_tasks` - Verify backlog health, trigger planning if empty
+- `merlin_get_next_task` - Get highest priority task with pre-assembled context
+- `merlin_sync_planning` - Sync .planning/ folder to/from cloud
+- `merlin_save_checkpoint` - Save resume point for later pickup
+- `merlin_mark_complete` - Mark project done (stops task enforcement)
+
 **When to call Merlin Sights:**
 
 | Moment | Why |

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

@@ -10,6 +10,9 @@ allowed-tools:
   - Task
   - TodoWrite
   - AskUserQuestion
+  - mcp__merlin__merlin_get_context
+  - mcp__merlin__merlin_sync_task
+  - mcp__merlin__merlin_save_checkpoint
 ---
 
 <objective>
@@ -36,7 +39,34 @@ Plan path: $ARGUMENTS
    - Confirm file at $ARGUMENTS exists
    - Error if not found: "Plan not found: {path}"
 
-2. **Check if already executed**
+2. **Fetch pre-assembled context from Merlin Sights**
+
+   Before executing, get relevant context from Sights:
+
+   ```
+   Call: merlin_get_context
+   Task: "[objective from plan - what we're building]"
+   ```
+
+   This returns:
+   - Relevant code files for this task
+   - Conventions to follow
+   - Anti-patterns to avoid
+   - How-to guide
+
+   Store this context to pass to the executor subagent.
+
+   Also sync task start to cloud:
+
+   ```
+   Call: merlin_sync_task
+   Title: "[plan objective]"
+   Status: "in_progress"
+   Phase: "[phase name]"
+   Plan: "[plan name]"
+   ```
+
+3. **Check if already executed**
    - Derive SUMMARY path from plan path (replace PLAN.md with SUMMARY.md)
    - If SUMMARY exists: "Plan already executed. SUMMARY: {path}"
    - Offer: re-execute or exit

package/files/commands/merlin/new-project.md

@@ -120,19 +120,52 @@ Consult `questioning.md` for techniques:
 
 As you go, mentally check the context checklist from `questioning.md`. If gaps remain, weave questions naturally. Don't suddenly switch to checklist mode.
 
-**Decision gate:**
+</step>
+
+<step name="completeness_gate">
+
+**VISION COMPLETENESS CHECKLIST — Must pass before proceeding**
 
-When you could write a clear PROJECT.md, use AskUserQuestion:
+Before allowing "Create PROJECT.md", silently verify you have gathered ALL of these:
+
+```
+COMPLETENESS CHECKLIST:
+[ ] WHAT: Clear description of what we're building (not vague)
+[ ] WHO: Target users or audience defined
+[ ] WHY: Problem being solved or value delivered
+[ ] CORE: The ONE thing that makes this valuable (core differentiator)
+[ ] SCOPE: At least 3 concrete features or capabilities
+[ ] NON-SCOPE: At least 1 explicit exclusion (what we're NOT building)
+[ ] CONSTRAINTS: Any technical, time, or resource constraints
+[ ] SUCCESS: How we'll know it's working (success metric or signal)
+```
 
-- header: "Ready?"
-- question: "I think I understand what you're after. Ready to create PROJECT.md?"
+**If ANY item is missing:**
+
+Do NOT offer "Create PROJECT.md" yet. Instead, naturally ask a question that fills the gap:
+
+| Missing | Question to ask |
+|---------|-----------------|
+| WHO | "Who exactly will use this? Paint me a picture of that person." |
+| WHY | "What problem does this solve? What's painful about the current situation?" |
+| CORE | "If this does ONE thing really well, what is it?" |
+| SCOPE | "Give me 3 concrete things a user can do with this." |
+| NON-SCOPE | "What should this explicitly NOT do? What's out of scope?" |
+| CONSTRAINTS | "Any constraints I should know? Timeline, tech choices, budget?" |
+| SUCCESS | "How will you know this is successful? What's the signal?" |
+
+**Only when ALL 8 items are covered:**
+
+Use AskUserQuestion:
+- header: "Vision Complete ✓"
+- question: "I have a clear picture of what we're building. Ready to create PROJECT.md?"
 - options:
   - "Create PROJECT.md" — Let's move forward
-  - "Keep exploring" — I want to share more / ask me more
+  - "I want to add more" — There's more context to share
 
-If "Keep exploring" — ask what they want to add, or identify gaps and probe naturally.
+If "I want to add more" — ask what they want to add, capture it, then offer again.
 
-Loop until "Create PROJECT.md" selected.
+Loop until "Create PROJECT.md" selected AND checklist passes.
 
 </step>
 
@@ -358,6 +391,37 @@ EOF
 
 </step>
 
+<step name="cloud_sync">
+
+**Sync to Merlin Cloud for team access:**
+
+Call `merlin_sync_planning` with direction "push" to upload:
+- PROJECT.md → cloud storage
+- config.json → cloud storage
+- Vision completeness status → cloud storage
+
+Also save coding rules to cloud:
+
+Call `merlin_save_rule` for each rule in config.json:
+- max_file_lines rule
+- testing rule
+- type_strictness rule
+- each custom rule
+
+This enables:
+- Any team member to pick up the project
+- Cross-session memory of decisions
+- Rules enforced across all agents
+
+```
+Synced to Merlin Cloud ✓
+- PROJECT.md uploaded
+- Coding rules saved (X rules)
+- Team can now access this project
+```
+
+</step>
+
 <step name="done">
 
 Present completion with next steps (see ~/.claude/merlin/references/continuation-format.md):
@@ -406,6 +470,7 @@ Skip research, define requirements from what you know, then create roadmap.
 
 <success_criteria>
 
+- [ ] **Vision completeness checklist PASSED** (all 8 items covered)
 - [ ] Deep questioning completed (not rushed, threads followed)
 - [ ] PROJECT.md captures full context with evolutionary structure
 - [ ] Requirements initialized as hypotheses (greenfield) or with inferred Validated (brownfield)
@@ -413,5 +478,6 @@ Skip research, define requirements from what you know, then create roadmap.
 - [ ] Coding preferences gathered (file size, testing, type safety, custom rules)
 - [ ] config.json has workflow mode, depth, parallelization, AND rules
 - [ ] All committed to git
+- [ ] **Synced to Merlin Cloud** (PROJECT.md, rules uploaded)
 
 </success_criteria>

package/files/commands/merlin/progress.md

@@ -7,17 +7,88 @@ allowed-tools:
   - Grep
   - Glob
   - SlashCommand
+  - mcp__merlin__merlin_get_project_status
+  - mcp__merlin__merlin_ensure_tasks
+  - mcp__merlin__merlin_get_next_task
+  - mcp__merlin__merlin_sync_planning
+  - AskUserQuestion
 ---
 
 <objective>
-Check project progress, summarize recent work and what's ahead, then intelligently route to the next action - either executing an existing plan or creating the next one.
+Check project progress, ensure backlog health, and route to next action.
 
-Provides situational awareness before continuing work.
+This is the "ALWAYS HAVE TASKS" enforcer. Call at session start or when
+deciding what to do next. Ensures the project always has work until complete.
+
+Provides situational awareness and smart routing.
 </objective>
 
 
 <process>
 
+<step name="cloud_status">
+**FIRST: Get project status from Merlin Cloud.**
+
+```
+Call: merlin_get_project_status
+```
+
+This returns:
+- Vision status (PROJECT.md, ROADMAP.md, REQUIREMENTS.md)
+- Task counts (pending, in_progress, completed)
+- Progress percentage
+- Last checkpoint if exists
+- Recommended next action
+
+**If checkpoint exists:**
+
+Show resume prompt before continuing:
+```
+📍 Resume Point Found
+
+Last session stopped at: [description]
+Working on: [task]
+Phase: [phase]
+
+Resume from checkpoint? (Y/n)
+```
+
+If yes: Route to checkpoint task with context.
+If no: Continue with normal flow.
+</step>
+
+<step name="backlog_health">
+**CRITICAL: Ensure backlog is never empty until project complete.**
+
+```
+Call: merlin_ensure_tasks
+```
+
+**If backlog is EMPTY but project NOT complete:**
+
+```
+⚠️ EMPTY BACKLOG DETECTED
+
+No tasks remaining, but project is not marked complete.
+
+The project should ALWAYS have tasks until explicitly finished.
+
+What would you like to do?
+```
+
+Use AskUserQuestion:
+- header: "Empty Backlog"
+- question: "No tasks remaining. What's next?"
+- options:
+  - "Plan more work" — Run /merlin:discuss-milestone to define next milestone
+  - "Project is complete" — Run /merlin:complete-milestone to wrap up
+  - "Review first" — Run /merlin:verify-work to validate what was built
+
+Route based on selection and EXIT. Do not continue to local file checks.
+
+**If backlog is healthy:** Continue to local verification.
+</step>
+
 <step name="verify">
 **Verify planning structure exists:**
 

package/files/merlin/workflows/progress.md

@@ -0,0 +1,236 @@
+<purpose>
+Check project progress, ensure backlog health, and route to next action.
+
+This is the "always have tasks" enforcer. Call this at session start or when
+checking what to do next. It ensures the project always has work until complete.
+</purpose>
+
+<required_reading>
+**Read these files NOW:**
+
+1. .planning/STATE.md
+2. .planning/ROADMAP.md
+3. .planning/PROJECT.md
+</required_reading>
+
+<merlin_context>
+**MERLIN: Check project and task state from cloud.**
+
+```
+Call: merlin_get_project_status
+(returns vision status, task counts, next action, checkpoint)
+
+Call: merlin_ensure_tasks
+(verifies backlog health, triggers milestone discussion if empty)
+```
+</merlin_context>
+
+<process>
+
+<step name="check_status">
+**Get comprehensive project status:**
+
+Call `merlin_get_project_status` to get:
+- Vision completeness (PROJECT.md, ROADMAP.md, REQUIREMENTS.md)
+- Task counts (pending, in_progress, completed)
+- Progress percentage
+- Last checkpoint (if any)
+- Recommended next action
+
+Display the status to user:
+
+```
+# Project Progress
+
+## Vision
+- PROJECT.md: [status]
+- ROADMAP.md: [status]
+- REQUIREMENTS.md: [status]
+
+## Tasks
+Progress: [████████░░] 80%
+- Completed: X
+- In Progress: Y
+- Pending: Z
+
+## Resume Point (if exists)
+Last session stopped at: [description]
+Working on: [task]
+```
+</step>
+
+<step name="backlog_health">
+**CRITICAL: Ensure backlog is never empty until project complete.**
+
+Call `merlin_ensure_tasks` to verify:
+- If pending tasks > 0: Backlog healthy
+- If pending tasks = 0 AND project not complete: TRIGGER MILESTONE DISCUSSION
+
+**If backlog is empty:**
+
+```
+⚠️ EMPTY BACKLOG DETECTED
+
+No tasks remaining, but project is not marked complete.
+
+The project should ALWAYS have tasks until explicitly finished.
+
+What would you like to do?
+1. Plan more work → /merlin:discuss-milestone
+2. Mark project complete → /merlin:complete-milestone
+3. Review what was built → /merlin:verify-work
+```
+
+Use AskUserQuestion:
+- header: "Empty Backlog"
+- question: "No tasks remaining. What's next?"
+- options:
+  - "Plan more work" — Run /merlin:discuss-milestone to define next milestone
+  - "Project is complete" — Run /merlin:complete-milestone to wrap up
+  - "Review first" — Run /merlin:verify-work to validate what was built
+
+Route based on selection.
+
+**If backlog is healthy:** Continue to route_next.
+</step>
+
+<step name="checkpoint_resume">
+**Check for resume context:**
+
+If `merlin_get_project_status` returned a checkpoint:
+
+```
+📍 Resume Point Found
+
+Last session by: [agent]
+Stopped at: [description]
+Working on: [task]
+Phase: [phase]
+
+Next steps recorded:
+1. [step 1]
+2. [step 2]
+```
+
+Use AskUserQuestion:
+- header: "Resume"
+- question: "Found a checkpoint from a previous session. Resume from there?"
+- options:
+  - "Resume from checkpoint" — Pick up exactly where we left off
+  - "Start fresh" — Ignore checkpoint, show me the task list
+  - "Clear checkpoint" — Delete the checkpoint and choose new work
+
+If "Resume from checkpoint":
+- Load the checkpoint context
+- Display the task and next steps
+- Ready to execute
+
+If "Start fresh" or no checkpoint: Continue to route_next.
+</step>
+
+<step name="route_next">
+**Route to appropriate next action:**
+
+Based on project status, recommend the best next step:
+
+| Status | Next Action |
+|--------|-------------|
+| No PROJECT.md | `/merlin:new-project` — Define what we're building |
+| No ROADMAP.md | `/merlin:discuss-milestone` → `/merlin:create-roadmap` |
+| No active tasks | `/merlin:discuss-milestone` — Plan more work |
+| Has pending tasks | `/merlin:execute-phase` or show task list |
+| All tasks done | `/merlin:verify-work` — Validate the build |
+
+**If has pending tasks:**
+
+Call `merlin_get_next_task` to show the highest priority task with context:
+
+```
+## ▶ Next Task
+
+**[Task Title]**
+Phase: [phase] | Plan: [plan]
+
+[Task description]
+
+### Pre-Assembled Context
+[Relevant spec sections, code files, decisions]
+
+Ready to start?
+- `/merlin:execute-plan` — Execute the current plan
+- "Show all tasks" — See the full task list
+```
+
+**If no pending tasks but project incomplete:**
+
+```
+## ▶ Next Up
+
+All current tasks complete! Time to plan more work.
+
+`/merlin:discuss-milestone`
+
+This will:
+1. Review what was accomplished
+2. Discuss what's next
+3. Create new phases and tasks
+```
+</step>
+
+<step name="display_summary">
+**Show progress summary with visual indicators:**
+
+```
+================================================================================
+PROJECT: [name]
+================================================================================
+
+VISION: [✓ Complete / ⚠️ Gaps exist]
+├── What: [one-liner]
+├── Who: [target users]
+└── Core Value: [differentiator]
+
+PROGRESS: [████████░░] 80%
+├── Phase [N] of [M]: [current phase name]
+├── Tasks: [X] done, [Y] in progress, [Z] pending
+└── Runway: ~[N] tasks / ~[X] hours remaining
+
+HEALTH: [✓ Healthy / ⚠️ Empty backlog / ❌ Stalled]
+
+================================================================================
+
+▶ NEXT: [recommended action]
+
+================================================================================
+```
+</step>
+
+</process>
+
+<backlog_enforcement>
+**THE ALWAYS-HAVE-TASKS RULE:**
+
+A project should NEVER have zero pending tasks unless:
+1. Project is explicitly marked complete (`merlin_mark_complete`)
+2. User is actively in `/merlin:discuss-milestone` planning more
+
+If backlog empties during execution:
+1. Pause execution
+2. Alert user: "Backlog empty but project not complete"
+3. Route to `/merlin:discuss-milestone`
+
+This ensures:
+- Autonomous agents always have work
+- No "what should I do next?" dead ends
+- Projects progress to completion or explicit pause
+</backlog_enforcement>
+
+<success_criteria>
+- [ ] Project status retrieved from cloud
+- [ ] Vision completeness displayed
+- [ ] Task progress shown with visual indicator
+- [ ] Backlog health verified (empty → trigger milestone discussion)
+- [ ] Checkpoint offered if exists
+- [ ] Next action clearly routed
+- [ ] User knows exactly what to do next
+</success_criteria>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-merlin-brain",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "description": "The Ultimate AI Brain for Claude Code - Install Merlin workflows, agents, and sights integration",
   "main": "index.js",
   "bin": {