projecta-rrr 1.18.8 → 1.19.0

package/CHANGELOG.md

@@ -4,6 +4,81 @@ All notable changes to RRR will be documented in this file.
 
 Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
+## [1.19.0] - 2026-02-05
+
+### Added
+
+- **Auto-Capture Observation Logger** - PostToolUse hook that automatically captures file creates/deletes, test results, git commits, and decision signals to `.planning/observations-YYYY-MM-DD.jsonl` with daily rotation and 1MB limit
+- **Progressive STATE.md Disclosure** - Compact ~30 token state index loaded on session start; full STATE.md only on explicit resume (saves context budget)
+- **SessionStart Auto-Resume Hook** - Handles Claude Code's `source` field (startup/resume/compact/clear) for automatic context restoration
+- **Native Context Window Metrics** - 4-level fallback (HUD state > env var > cached file > estimation) with pressure levels integrated into drift detection
+- **Timeline-Aware Session Queries** - `since`/`until` filters for session search with ISO dates, relative words ("yesterday"), and durations ("3d", "2w")
+- **Complexity-Adaptive Routing** - `/rrr:mvp` auto-detects task complexity (SMALL/MEDIUM/LARGE) and routes to appropriate workflow depth
+- **Configurable Git Branching** - `git_branching` strategy (none/phase/milestone) in config.json with squash-on-complete option
+- **`/rrr:think` Command** - 4 structured thinking models: first-principles, inversion (pre-mortem), pareto (80/20), five-whys (root cause)
+- **TeammateTool / Hidden Swarm Embedding** - File-based team coordination mirroring Claude Code's hidden TeammateTool API with spawnTeam/write/broadcast/cleanup primitives, team-aware executor for wave parallelization, and GA migration path with transport swap
+- **Session Forking Guidance** - Documented session forking as preferred overnight method with fallback to traditional Jarvis
+
+### Changed
+
+- `/rrr:mvp` now includes complexity detection preamble before routing
+- `/rrr:execute-phase` supports team coordination for multi-plan waves
+- `/rrr:execute-plan` creates git branches when `git_branching` is configured
+- `/rrr:complete-milestone` handles branch merge and optional squash cleanup
+- `/rrr:discuss-phase` offers optional thinking model integration
+- `/rrr:overnight` uses session forking with 10-min hook timeout
+- Resume workflow uses compact-first progressive disclosure approach
+- Memory store includes context pressure signals in drift detection
+
+## [1.18.10] - 2026-02-03
+
+### Added
+
+- **Ferrari-Fast Performance Patch** - Comprehensive optimization implementing all Top 5 research recommendations
+  - GrepAI hybrid search configuration (27.5% cost savings, 97% token reduction)
+  - MCP process management with V8 heap limits (512MB max) and graceful shutdown
+  - LanceDB scalar quantization (4x memory reduction, <1% accuracy loss)
+  - Enhanced query caching (1000 queries, 15-minute TTL)
+  - Auto-optimization already integrated in v1.18.9 (runs on install for v1.18.9-v1.19.4)
+
+### Changed
+
+- Query cache size increased: 500 → 1000 embeddings for higher hit rate
+- Query cache TTL optimized: 30min → 15min for faster refresh cycles
+- MCP server now enforces memory limits to prevent zombie processes
+
+### Performance
+
+- Memory usage: ~800MB → ~200MB (4x reduction with quantization)
+- Query cache capacity: 2x increase for better hit rates
+- Token usage: -27.5% through GrepAI compact output
+- MCP process leaks: Prevented via V8 limits and graceful shutdown
+
+### Documentation
+
+- Created `.planning/milestones/v1.18/PATCHES.md` with full implementation details
+- Research basis: `docs/SEMANTIC_SEARCH_OPTIMIZATION.md` and `docs/OPTIMIZATION_SUMMARY.md`
+
+## [1.18.9] - 2026-02-03
+
+### Added
+
+- **`/rrr:optimize-cpu`** - Keep RRR blazing fast with one command
+  - Clean search indexes and caches (regenerable)
+  - Kill zombie VS Code processes
+  - Kill runaway MCP servers
+  - Optimize git repository
+  - Show before/after performance metrics
+  - Modes: default (safe), --aggressive (deep clean), --check-only (stats only)
+  - Run weekly to maintain peak performance
+
+- **Auto-optimization on install** - New users automatically get "Ferrari-fast" performance
+  - Runs automatically during `npx projecta-rrr` for next 5-6 updates (v1.18.9 - v1.19.4)
+  - Cleans search indexes, GrepAI cache, and optimizes git on first install
+  - Ensures new users see speed improvements immediately
+  - Add `--skip-optimization` flag to skip if needed
+  - Part of our commitment to deliver speed improvements to all users
+
 ## [1.18.8] - 2026-02-03
 
 ### Fixed

package/bin/install.js

@@ -207,6 +207,7 @@ const forceStatusline = args.includes('--force-statusline');
 const forceNotify = args.includes('--force-notify');
 const noNotify = args.includes('--no-notify');
 const hudOnly = args.includes('--hud-only');
+const skipOptimization = args.includes('--skip-optimization');
 
 console.log(banner);
 
@@ -222,6 +223,7 @@ if (hasHelp) {
     ${cyan}--force-statusline${reset}        Replace existing statusline config
     ${cyan}--force-notify${reset}            Replace existing notification hook
     ${cyan}--no-notify${reset}               Skip notification hook installation
+    ${cyan}--skip-optimization${reset}       Skip automatic performance optimization
     ${cyan}--hud-only${reset}                Install only HUD components (themes + stop hook)
 
   ${yellow}Examples:${reset}
@@ -1410,6 +1412,27 @@ function install(isGlobal) {
       });
       console.log(`  ${green}✓${reset} Configured cache stats hook`);
     }
+
+    // Configure SessionStart hook for auto-resume context
+    const sessionStartCommand = isGlobal
+      ? '$HOME/.claude/hooks/rrr-session-start.sh'
+      : `${localDirName}/hooks/rrr-session-start.sh`;
+
+    const hasSessionStartHook = settings.hooks.SessionStart.some(entry =>
+      entry.hooks && entry.hooks.some(h => h.command && h.command.includes('rrr-session-start'))
+    );
+
+    if (!hasSessionStartHook && hookFileExists(claudeDir, 'rrr-session-start.sh')) {
+      settings.hooks.SessionStart.push({
+        hooks: [
+          {
+            type: 'command',
+            command: sessionStartCommand
+          }
+        ]
+      });
+      console.log(`  ${green}✓${reset} Configured auto-resume hook (SessionStart)`);
+    }
   }
 
   // PATCH-01: Configure PostToolUse hook for drift detection
@@ -1445,6 +1468,37 @@ function install(isGlobal) {
     }
   }
 
+  // Configure PostToolUse hook for observation logger (auto-capture key events)
+  const observationLoggerCommand = isGlobal
+    ? '$HOME/.claude/hooks/rrr-observation-logger.sh'
+    : `${localDirName}/hooks/rrr-observation-logger.sh`;
+
+  if (bashStatus.available && hookFileExists(claudeDir, 'rrr-observation-logger.sh')) {
+    if (!settings.hooks) {
+      settings.hooks = {};
+    }
+    if (!settings.hooks.PostToolUse) {
+      settings.hooks.PostToolUse = [];
+    }
+
+    const hasObservationHook = settings.hooks.PostToolUse.some(entry =>
+      entry.hooks && entry.hooks.some(h => h.command && h.command.includes('rrr-observation-logger'))
+    );
+
+    if (!hasObservationHook) {
+      settings.hooks.PostToolUse.push({
+        matcher: '*',
+        hooks: [
+          {
+            type: 'command',
+            command: observationLoggerCommand
+          }
+        ]
+      });
+      console.log(`  ${green}✓${reset} Configured observation logger hook (PostToolUse)`);
+    }
+  }
+
   // Configure UserPromptSubmit hook for intent classification (smart drift detection)
   const classifyIntentCommand = isGlobal
     ? '$HOME/.claude/hooks/rrr-classify-intent.sh'
@@ -1654,6 +1708,13 @@ function install(isGlobal) {
         // Silent fail - context building is optional
       }
     }
+
+    // Run optimization for new users (v1.18.9 - v1.19.4)
+    // This keeps RRR "Ferrari-fast" by cleaning caches and optimizing git
+    // Only runs if: (1) version is in range, (2) --skip-optimization not passed, (3) has package.json
+    if (!skipOptimization && shouldAutoOptimize() && hasProjectPkg) {
+      runOptimization(projectDir);
+    }
   }
 
   return { settingsPath, settings, statuslineCommand, notifyCommand, claudeDir, localDirName, isGlobal, bashAvailable: bashStatus.available };
@@ -1800,6 +1861,136 @@ function printDoctorSummary(claudeDir, settings, localDirName, isGlobal) {
   }
 }
 
+/**
+ * Check if current version should run auto-optimization
+ * Runs for v1.18.9 through v1.19.4 (next 5-6 updates)
+ */
+function shouldAutoOptimize() {
+  const currentVersion = pkg.version;
+
+  // Parse version parts
+  const match = currentVersion.match(/^(\d+)\.(\d+)\.(\d+)$/);
+  if (!match) return false;
+
+  const [_, major, minor, patch] = match.map(Number);
+
+  // Enable for v1.18.9 through v1.19.4
+  if (major !== 1) return false;
+  if (minor === 18 && patch >= 9) return true;
+  if (minor === 19 && patch <= 4) return true;
+
+  return false;
+}
+
+/**
+ * Run performance optimization on the installed RRR directory
+ * Cleans search indexes, GrepAI cache, and optimizes git
+ */
+function runOptimization(projectDir) {
+  console.log(`\n  ${cyan}Optimizing RRR Performance${reset}\n`);
+
+  try {
+    // Get initial metrics
+    const initialStats = {
+      repoSize: execSync('du -sh . 2>/dev/null || echo "unknown"', {
+        cwd: projectDir,
+        encoding: 'utf8',
+        timeout: 10000
+      }).split('\t')[0].trim()
+    };
+
+    console.log(`  ${dim}Current repo size: ${initialStats.repoSize}${reset}`);
+
+    let freedSpace = 0;
+
+    // Clean search indexes (regenerable)
+    const searchIndexDir = path.join(projectDir, '.rrr', 'search');
+    if (fs.existsSync(searchIndexDir)) {
+      try {
+        const beforeSize = execSync(`du -sk "${searchIndexDir}" 2>/dev/null || echo "0"`, {
+          encoding: 'utf8',
+          timeout: 5000
+        }).split('\t')[0];
+
+        fs.rmSync(searchIndexDir, { recursive: true, force: true });
+        console.log(`  ${green}✓${reset} Removed search indexes (~${Math.round(parseInt(beforeSize) / 1024)}MB)`);
+        freedSpace += parseInt(beforeSize);
+      } catch (e) {
+        // Silent fail - not critical
+      }
+    }
+
+    // Clean GrepAI cache (regenerable)
+    const grepaiDir = path.join(projectDir, '.grepai');
+    if (fs.existsSync(grepaiDir)) {
+      try {
+        const beforeSize = execSync(`du -sk "${grepaiDir}" 2>/dev/null || echo "0"`, {
+          encoding: 'utf8',
+          timeout: 5000
+        }).split('\t')[0];
+
+        fs.rmSync(grepaiDir, { recursive: true, force: true });
+        console.log(`  ${green}✓${reset} Removed GrepAI cache (~${Math.round(parseInt(beforeSize) / 1024)}MB)`);
+        freedSpace += parseInt(beforeSize);
+      } catch (e) {
+        // Silent fail - not critical
+      }
+    }
+
+    // Clean .claude-local duplicates (if not in source repo)
+    const claudeLocalDir = path.join(projectDir, '.claude-local');
+    if (fs.existsSync(claudeLocalDir) && !isRrrSourceRepo()) {
+      try {
+        const beforeSize = execSync(`du -sk "${claudeLocalDir}" 2>/dev/null || echo "0"`, {
+          encoding: 'utf8',
+          timeout: 5000
+        }).split('\t')[0];
+
+        fs.rmSync(claudeLocalDir, { recursive: true, force: true });
+        console.log(`  ${green}✓${reset} Removed .claude-local duplicates (~${Math.round(parseInt(beforeSize) / 1024)}MB)`);
+        freedSpace += parseInt(beforeSize);
+      } catch (e) {
+        // Silent fail - not critical
+      }
+    }
+
+    // Optimize git repository
+    try {
+      console.log(`  ${dim}Optimizing git repository...${reset}`);
+      execSync('git gc --auto 2>&1', {
+        cwd: projectDir,
+        encoding: 'utf8',
+        stdio: 'pipe',
+        timeout: 30000
+      });
+      console.log(`  ${green}✓${reset} Git optimized`);
+    } catch (e) {
+      // Silent fail - git gc is optional
+    }
+
+    // Get final metrics
+    const finalStats = {
+      repoSize: execSync('du -sh . 2>/dev/null || echo "unknown"', {
+        cwd: projectDir,
+        encoding: 'utf8',
+        timeout: 10000
+      }).split('\t')[0].trim()
+    };
+
+    const freedMB = Math.round(freedSpace / 1024);
+    console.log(`\n  ${green}Optimization complete!${reset}`);
+    console.log(`  ${dim}Final repo size: ${finalStats.repoSize}${reset}`);
+    if (freedMB > 0) {
+      console.log(`  ${dim}Freed ~${freedMB}MB of disk space${reset}`);
+    }
+    console.log(`  ${dim}Search indexes will rebuild as needed${reset}\n`);
+
+  } catch (e) {
+    // Don't fail install if optimization fails
+    console.log(`  ${yellow}⚠${reset} Optimization skipped: ${e.message}\n`);
+  }
+}
+
 /**
  * Apply statusline and notification config, then print completion message
  */
@@ -1878,9 +2069,18 @@ function finishInstall(settingsPath, settings, statuslineCommand, notifyCommand,
     setupScheduledIndexing();
   }
 
+  // Show optimization note if it ran
+  let optimizationNote = '';
+  if (!skipOptimization && shouldAutoOptimize()) {
+    optimizationNote = `
+  ${green}Performance optimized!${reset} RRR is ready to run at "Ferrari speed".
+  ${dim}(Run ${cyan}/rrr:optimize-cpu${reset} anytime to clean caches and free resources)${reset}
+`;
+  }
+
   console.log(`
   ${green}Done!${reset}
-
+${optimizationNote}
   ${yellow}If you installed from inside Claude Code:${reset}
   Type ${cyan}exit${reset} and restart ${cyan}claude${reset} so it reloads commands.
 

package/commands/rrr/complete-milestone.md

@@ -100,14 +100,55 @@ Output: Milestone archived (roadmap + requirements), PROJECT.md evolved, git tag
    - Add "Next Milestone Goals" section
    - Archive previous content in `<details>` (if v1.1+)
 
-7. **Commit and tag:**
+7. **Merge branches (if git branching was used):**
+
+   Check config.json for `git_branching` setting:
+
+   ```bash
+   GIT_BRANCHING=$(node -e "try { const c = require('./.planning/config.json'); console.log(c.git_branching || 'none'); } catch(e) { console.log('none'); }" 2>/dev/null)
+   SQUASH=$(node -e "try { const c = require('./.planning/config.json'); console.log(c.squash_on_complete ? 'true' : 'false'); } catch(e) { console.log('false'); }" 2>/dev/null)
+   ```
+
+   **If `git_branching` is `phase` or `milestone`:**
+
+   a. List all RRR branches:
+   ```bash
+   git branch --list 'rrr/*'
+   ```
+
+   b. For each RRR branch:
+   - Ensure we are on the main/default branch
+   - Merge or squash-merge based on `squash_on_complete`:
+     ```bash
+     DEFAULT_BRANCH=$(git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null | sed 's@^refs/remotes/origin/@@' || echo "main")
+     git checkout "$DEFAULT_BRANCH"
+
+     if [ "$SQUASH" = "true" ]; then
+       git merge --squash "$BRANCH_NAME"
+       git commit -m "feat: merge ${BRANCH_NAME} (squashed)"
+     else
+       git merge "$BRANCH_NAME" --no-edit
+     fi
+     ```
+
+   c. Clean up merged branches:
+   ```bash
+   git branch -d "$BRANCH_NAME"
+   echo "[RRR] Merged and deleted branch: $BRANCH_NAME"
+   ```
+
+   d. Present summary of merged branches to user for confirmation.
+
+   **If `none`:** Skip this step entirely.
+
+8. **Commit and tag:**
 
    - Stage: MILESTONES.md, PROJECT.md, ROADMAP.md, STATE.md, archive files
    - Commit: `chore: archive v{{version}} milestone`
    - Tag: `git tag -a v{{version}} -m "[milestone summary]"`
    - Ask about pushing tag
 
-8. **Offer next steps:**
+9. **Offer next steps:**
    - `/rrr:discuss-milestone` — thinking partner, creates context file
    - Then `/rrr:new-milestone` — update PROJECT.md with new goals
 

package/commands/rrr/discuss-phase.md

@@ -62,6 +62,39 @@ Phase number: $ARGUMENTS (required)
 - Scope expansion (roadmap defines scope)
 </process>
 
+<thinking_models>
+**Optional: Apply thinking model during discussion**
+
+After step 5 (deep-dive areas) and before step 6 (write CONTEXT.md), offer structured analysis if the discussion revealed complex architectural decisions:
+
+```
+---
+
+Noticed some meaty decisions in this discussion. Want to apply a thinking model?
+
+| Model | Good For |
+|-------|----------|
+| `/rrr:think first-principles` | Strip assumptions, rebuild approach |
+| `/rrr:think inversion` | Pre-mortem: what could go wrong? |
+| `/rrr:think pareto` | Cut scope to the essential 20% |
+| `/rrr:think five-whys` | Dig into root cause of a design question |
+
+Or skip and proceed to CONTEXT.md.
+
+---
+```
+
+**When to offer:**
+- At least one gray area involved architecture or technology choice
+- Discussion surfaced significant trade-offs
+- User expressed uncertainty about approach
+
+**When to skip (just proceed):**
+- All gray areas were UI/UX/content (not architectural)
+- Discussion was quick and clear
+- User has strong opinions already
+</thinking_models>
+
 <success_criteria>
 - Gray areas identified through intelligent analysis
 - User chose which areas to discuss

package/commands/rrr/execute-phase.md

@@ -100,6 +100,50 @@ Phase: $ARGUMENTS
    **If script not found:**
    - Log warning, continue without preflight
 
+1.7. **Git branching (if configured)**
+
+   Check config.json for `git_branching` setting:
+
+   ```bash
+   GIT_BRANCHING=$(node -e "try { const c = require('./.planning/config.json'); console.log(c.git_branching || 'none'); } catch(e) { console.log('none'); }" 2>/dev/null)
+   ```
+
+   **If `git_branching` is `phase`:**
+   - Create and checkout branch for this phase:
+   ```bash
+   PHASE_NUM=$ARGUMENTS
+   PHASE_SLUG=$(basename "$PHASE_DIR" | sed "s/^${PHASE_NUM}-//")
+   BRANCH_NAME="rrr/phase-${PHASE_NUM}-${PHASE_SLUG}"
+
+   if ! git rev-parse --verify "$BRANCH_NAME" >/dev/null 2>&1; then
+     git checkout -b "$BRANCH_NAME"
+     echo "[RRR] Created branch: $BRANCH_NAME"
+   else
+     git checkout "$BRANCH_NAME" 2>/dev/null || echo "[RRR] Already on branch: $BRANCH_NAME"
+   fi
+   ```
+
+   **If `git_branching` is `milestone`:**
+   - Branch is created at milestone level (by execute-plan or new-milestone)
+   - Ensure we are on the milestone branch if it exists
+
+   **If `none` (default):** No branching, continue on current branch.
+
+1.8. **Team coordination (if configured)**
+
+   Check config.json for `team_coordination` setting:
+
+   ```bash
+   TEAM_COORD=$(node -e "try { const c = require('./.planning/config.json'); console.log(c.team_coordination !== false ? 'true' : 'false'); } catch(e) { console.log('true'); }" 2>/dev/null)
+   ```
+
+   **If `true` (default):** Team coordination enabled for multi-plan waves.
+   - Load team libraries: `rrr/lib/team-coord.js` and `rrr/lib/team-executor.js`
+   - Team coordination only activates for waves with 2+ plans
+   - Single-plan waves always skip team coordination (zero overhead)
+
+   **If `false`:** Team coordination disabled. Execute with original hub-and-spoke pattern.
+
 2. **Discover plans**
    - List all *-PLAN.md files in phase directory
    - Check which have *-SUMMARY.md (already complete)
@@ -133,11 +177,69 @@ Phase: $ARGUMENTS
    - If user chooses to skip: Mark plan as skipped, continue to next
    - If user chooses to continue: Proceed with execution
 
-   **5b. Execute plans:**
+   **5b. Team setup (if multi-plan wave and team_coordination enabled):**
+
+   For waves with 2+ plans when `TEAM_COORD=true`:
+
+   ```javascript
+   // Using rrr/lib/team-executor.js
+   const team = prepareWaveTeam(phaseNum, waveNum, planIds, planPaths, projectRoot);
+   // team is null for single-plan waves (zero overhead)
+   ```
+
+   This creates `.planning/teams/phase-{N}-wave-{W}/` with:
+   - `config.json` — team members, status
+   - `messages/{agent-id}/` — per-agent inbox dirs
+   - `messages/broadcast/` — group messages
+   - `state.json` — team lifecycle state
+
+   Shared file detection: parse each plan's `## Files Modified` section,
+   find files appearing in 2+ plans. These require coordination.
+
+   **5c. Execute plans:**
    - For each plan, inject `<skills>` block into executor prompt
+   - If team exists (multi-plan wave): inject `<team_context>` block with team name, agent ID, peer IDs, shared files
    - Spawn `rrr-executor` for each plan in wave (parallel Task calls)
    - Wait for completion (Task blocks)
-   - Verify SUMMARYs created
+
+   **5d. Post-wave team analysis (if team exists):**
+
+   After all executors in wave complete:
+
+   1. **Read team messages** (for logging/debugging):
+      ```javascript
+      const { messages } = collectTeamMessages(team);
+      // Log: "[RRR] Wave {W}: {N} team messages exchanged"
+      ```
+
+   2. **Detect file conflicts** (same file modified by 2+ agents):
+      ```javascript
+      const conflicts = detectFileConflicts(team, summaryPaths);
+      ```
+
+   3. **If conflicts detected:** Present conflict resolution UI:
+      ```
+      ── FILE CONFLICT DETECTED ──────────────────────────
+
+      File: {file_path}
+      Modified by: {agent-1}, {agent-2}
+
+      {agent-1} changes: {summary from team messages}
+      {agent-2} changes: {summary from team messages}
+
+      ────────────────────────────────────────────────────
+      > Select: merge-both / keep-{agent-1} / keep-{agent-2} / manual
+      ────────────────────────────────────────────────────
+      ```
+
+      Use AskUserQuestion for conflict resolution if any non-expected conflicts exist.
+
+   4. **Cleanup team:**
+      ```javascript
+      cleanupWaveTeam(team); // Archives to .planning/teams/archived/
+      ```
+
+   5. **Verify SUMMARYs created**
    - Proceed to next wave
 
 6. **Aggregate results**
@@ -374,22 +476,56 @@ After user runs `/rrr:plan-phase {Z} --gaps`:
 </offer_next>
 
 <wave_execution>
-**Parallel spawning:**
+**Parallel spawning with team coordination:**
+
+**Step 1: Prepare team (multi-plan waves only)**
+
+For waves with 2+ plans when `team_coordination` is enabled:
+
+```javascript
+// From rrr/lib/team-executor.js
+const team = prepareWaveTeam(phaseNum, waveNum, planIds, planPaths, projectRoot);
+// Returns null for single-plan waves (zero overhead)
+
+// Build team context for each executor
+const teamBlock = buildTeamPromptBlock(team, planId);
+// Returns '' for null teams
+```
+
+**Step 2: Spawn executors**
 
 Spawn all plans in a wave with a single message containing multiple Task calls.
-Include the `<skills>` block loaded in step 4 for each plan:
+Include the `<skills>` block loaded in step 4 and `<team_context>` block for each plan:
 
 ```
-Task(prompt="Execute plan at {plan_01_path}\n\n{skills_01_block}\n\nPlan: @{plan_01_path}\nProject state: @.planning/STATE.md", subagent_type="rrr-executor")
-Task(prompt="Execute plan at {plan_02_path}\n\n{skills_02_block}\n\nPlan: @{plan_02_path}\nProject state: @.planning/STATE.md", subagent_type="rrr-executor")
-Task(prompt="Execute plan at {plan_03_path}\n\n{skills_03_block}\n\nPlan: @{plan_03_path}\nProject state: @.planning/STATE.md", subagent_type="rrr-executor")
+Task(prompt="Execute plan at {plan_01_path}\n\n{skills_01_block}\n\n{team_context_01}\n\nPlan: @{plan_01_path}\nProject state: @.planning/STATE.md", subagent_type="rrr-executor")
+Task(prompt="Execute plan at {plan_02_path}\n\n{skills_02_block}\n\n{team_context_02}\n\nPlan: @{plan_02_path}\nProject state: @.planning/STATE.md", subagent_type="rrr-executor")
+Task(prompt="Execute plan at {plan_03_path}\n\n{skills_03_block}\n\n{team_context_03}\n\nPlan: @{plan_03_path}\nProject state: @.planning/STATE.md", subagent_type="rrr-executor")
 ```
 
-Where `{skills_XX_block}` is the `<skills>` content containing skill SKILL.md files specific to that plan.
+Where:
+- `{skills_XX_block}` is the `<skills>` content containing skill SKILL.md files specific to that plan
+- `{team_context_XX}` is the `<team_context>` block from `buildTeamPromptBlock()` (empty for single-plan waves)
+
+All executors run in parallel. Task tool blocks until all complete.
+
+**Step 3: Post-wave analysis (multi-plan waves only)**
 
-All three run in parallel. Task tool blocks until all complete.
+```javascript
+// Collect team messages for logging
+const { messages } = collectTeamMessages(team);
+// Log: "[RRR] Wave {W}: {N} team messages exchanged"
+
+// Check for file conflicts
+const conflicts = detectFileConflicts(team, summaryPaths);
+// If conflicts: present resolution UI via AskUserQuestion
+
+// Archive team
+cleanupWaveTeam(team);
+```
 
 **No polling.** No background agents. No TaskOutput loops.
+**Single-plan waves:** Skip all team logic. Zero overhead. Same as before.
 </wave_execution>
 
 <checkpoint_handling>

package/commands/rrr/execute-plan.md

@@ -168,6 +168,50 @@ Plan path: $ARGUMENTS
    - "Review plan first" → display plan summary, ask again
    - "Cancel" → exit without executing
 
+0.7. **Git branching (if configured)**
+
+   Check config.json for `git_branching` setting:
+
+   ```bash
+   GIT_BRANCHING=$(node -e "try { const c = require('./.planning/config.json'); console.log(c.git_branching || 'none'); } catch(e) { console.log('none'); }" 2>/dev/null)
+   ```
+
+   **If `git_branching` is `phase`:**
+   - Extract phase number and slug from plan path
+   - Check if branch `rrr/phase-{N}-{slug}` already exists
+   - If not: create and checkout the branch
+   ```bash
+   PHASE_NUM=$(basename "$(dirname "$ARGUMENTS")" | cut -d'-' -f1)
+   PHASE_SLUG=$(basename "$(dirname "$ARGUMENTS")" | sed "s/^${PHASE_NUM}-//")
+   BRANCH_NAME="rrr/phase-${PHASE_NUM}-${PHASE_SLUG}"
+
+   if ! git rev-parse --verify "$BRANCH_NAME" >/dev/null 2>&1; then
+     git checkout -b "$BRANCH_NAME"
+     echo "[RRR] Created branch: $BRANCH_NAME"
+   else
+     git checkout "$BRANCH_NAME" 2>/dev/null || echo "[RRR] Already on branch: $BRANCH_NAME"
+   fi
+   ```
+
+   **If `git_branching` is `milestone`:**
+   - Extract milestone version from ROADMAP.md
+   - Check if branch `rrr/{version}-{slug}` already exists
+   - If not: create and checkout the branch
+   ```bash
+   MILESTONE_VER=$(grep -E "^## Current Milestone:" .planning/ROADMAP.md 2>/dev/null | sed 's/.*: *\(v[0-9.]*\).*/\1/' || echo "vX.X")
+   PHASE_SLUG=$(basename "$(dirname "$ARGUMENTS")" | sed 's/^[0-9]*-//')
+   BRANCH_NAME="rrr/${MILESTONE_VER}-${PHASE_SLUG}"
+
+   if ! git rev-parse --verify "$BRANCH_NAME" >/dev/null 2>&1; then
+     git checkout -b "$BRANCH_NAME"
+     echo "[RRR] Created branch: $BRANCH_NAME"
+   else
+     git checkout "$BRANCH_NAME" 2>/dev/null || echo "[RRR] Already on branch: $BRANCH_NAME"
+   fi
+   ```
+
+   **If `none` (default):** No branching, continue on current branch.
+
 1. **Validate plan exists**
    - Confirm file at $ARGUMENTS exists
    - Error if not found: "Plan not found: {path}"