@gravirei/reis 2.4.1 → 2.6.0

package/CHANGELOG.md

@@ -1,5 +1,104 @@
 # Changelog
 
+## [2.6.0] - 2026-01-26
+
+### 🎯 Major Features
+
+#### Plan Reviewer Subagent (`reis_plan_reviewer`)
+A new subagent that validates REIS plans against your codebase BEFORE execution, preventing wasted effort from:
+- Tasks for things already implemented
+- Wrong file paths
+- Missing dependencies
+- Function signature mismatches
+
+**New REIS Cycle:**
+```
+PLAN → REVIEW → EXECUTE → VERIFY → GATE → DEBUG
+```
+
+#### Quality Gates Integration
+Quality gates now run automatically in the REIS cycle after verification.
+
+**Gate Categories:**
+- 🔒 Security: Vulnerabilities, secrets detection, license compliance
+- 📊 Quality: Code coverage, lint errors, complexity analysis
+- ⚡ Performance: Bundle size, dependencies (optional)
+- ♿ Accessibility: WCAG compliance (optional)
+
+#### Parallel Wave Execution
+Execute independent waves concurrently for faster phase completion.
+
+### ✨ New Commands
+
+```bash
+# Plan Review
+reis review                     # Review all plans in .planning/
+reis review <plan-path>         # Review specific plan
+reis review --auto-fix          # Auto-fix simple issues
+reis review --strict            # Fail on warnings
+
+# Quality Gates
+reis gate                       # Run all configured gates
+reis gate security              # Run security gates only
+reis gate quality               # Run quality gates only
+reis gate status                # Show gate configuration
+
+# Parallel Execution
+reis execute <phase> --parallel            # Enable parallel waves
+reis execute <phase> --max-concurrent 4    # Limit concurrent waves
+reis visualize --dependencies              # Show wave dependency graph
+```
+
+### 🔧 Cycle Command Updates
+
+```bash
+reis cycle <phase>              # Full cycle with review + gates
+reis cycle --skip-review        # Skip plan review phase
+reis cycle --skip-gates         # Skip quality gates phase
+reis cycle --auto-fix           # Auto-fix plan issues during review
+```
+
+### 📁 New Files
+
+**Plan Reviewer:**
+- `lib/utils/code-analyzer.js` - Codebase analysis utilities
+- `lib/utils/plan-reviewer.js` - Plan validation engine
+- `lib/commands/review.js` - Review CLI command
+- `subagents/reis_plan_reviewer.md` - Subagent definition
+- `docs/PLAN_REVIEW.md` - Documentation
+
+**Quality Gates:**
+- `lib/utils/gate-runner.js` - Gate execution engine
+- `lib/utils/gate-reporter.js` - Gate result reporting
+- `lib/utils/gates/security-gate.js` - Security checks
+- `lib/utils/gates/quality-gate.js` - Quality checks
+- `lib/utils/gates/performance-gate.js` - Performance checks
+- `lib/utils/gates/accessibility-gate.js` - Accessibility checks
+- `lib/commands/gate.js` - Gate CLI command
+- `docs/QUALITY_GATES.md` - Documentation
+
+**Parallel Execution:**
+- `lib/utils/wave-dependency-graph.js` - DAG for wave dependencies
+- `lib/utils/dependency-parser.js` - Parse @dependencies from PLAN.md
+- `lib/utils/parallel-wave-scheduler.js` - Batch scheduling
+- `lib/utils/execution-coordinator.js` - Async orchestration
+- `lib/utils/wave-conflict-detector.js` - File conflict detection
+- `lib/utils/conflict-resolver.js` - Resolution strategies
+- `docs/PARALLEL_EXECUTION.md` - Documentation
+
+### 🔄 Updated Subagents
+
+- **reis_verifier** - Now includes gate readiness assessment
+- **reis_debugger** - Handles `[GATE:category]` prefixed issues
+- **reis_executor** - Knows gate fix patterns
+
+### 📊 Test Coverage
+
+- 663 tests passing
+- New test files for all features
+
+---
+
 All notable changes to REIS will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),

package/README.md

@@ -23,9 +23,16 @@ Systematic development with parallel subagent execution for Atlassian Rovo Dev
 
 **REIS (Roadmap Execution & Implementation System)** is a systematic development framework for building better software with AI. Designed for Atlassian Rovo Dev, REIS provides structured workflows, specialized subagents, and comprehensive documentation to take projects from idea to deployment.
 
-### ✨ What's New in v2.0
+### ✨ What's New in v2.5
 
-REIS v2.0 introduces powerful wave-based execution with smart checkpoints, making development more predictable and resilient:
+REIS v2.5 introduces **parallel wave execution** for significantly faster phase completion:
+
+- 🚀 **Parallel Waves** - Execute independent waves concurrently (up to 4x speedup)
+- 🔗 **Dependency Graphs** - Define and visualize wave dependencies
+- 🔍 **Conflict Detection** - Automatic file conflict detection and resolution
+- 📊 **Enhanced Kanban** - Real-time parallel execution progress tracking
+
+### Previous in v2.0
 
 - 🌊 **Wave Execution** - Sequential waves with automatic checkpoints between phases
 - 💾 **Smart Resume** - Resume from any checkpoint with deviation detection
@@ -139,11 +146,47 @@ reis assumptions        # Document assumptions
 reis plan               # Create phase plan
 reis discuss            # Discuss phase approach
 reis research           # Research requirements
+reis review             # Review plan before execution
 reis execute            # Execute current phase
 reis execute-plan [f]   # Execute with wave-based flow (v2.0)
 reis verify             # Verify completion
 ```
 
+### Plan Review
+
+Review plans against your codebase before execution to catch issues early:
+
+```bash
+# Review all plans
+reis review
+
+# Review specific plan
+reis review .planning/phases/feature/PLAN.md
+
+# Review with auto-fix
+reis review --auto-fix
+
+# Review with strict mode
+reis review --strict
+```
+
+**What Gets Checked:**
+- File existence in codebase
+- Functions already implemented
+- Exports already in place
+- Dependencies available
+- Path correctness
+
+**Status Codes:**
+| Status | Icon | Meaning |
+|--------|------|---------|
+| `ok` | ✅ | Ready for execution |
+| `already_complete` | ✅ | Already implemented |
+| `path_error` | ⚠️ | Path incorrect |
+| `missing_dependency` | ❌ | Dependency missing |
+
+**Learn more:** [Plan Review Guide](docs/PLAN_REVIEW.md)
+
 ### Verification
 
 Verify that executed plans meet all success criteria and feature completeness requirements.
@@ -322,9 +365,24 @@ Next: reis cycle 2
 --auto-fix            # Apply fixes without confirmation
 --resume              # Resume interrupted cycle
 --continue-on-fail    # Continue even if verification fails
+--skip-gates          # Skip quality gate checks
+--gate-only <cat>     # Run only specific gate category
 -v, --verbose         # Detailed output
 ```
 
+### Quality Gates in Cycle
+
+Gates automatically run after verification to ensure code quality:
+
+```bash
+reis cycle 3              # Includes gates
+reis cycle 3 --skip-gates # Without gates
+```
+
+The gate phase checks security, quality, and optionally performance/accessibility before marking a phase complete. Gate failures trigger the debug phase with `[GATE:category]` prefixed issues.
+
+See [Quality Gates](docs/QUALITY_GATES.md) for configuration.
+
 **Learn more:** [Complete Cycle Guide](docs/CYCLE_COMMAND.md)
 
 ### Checkpoints & Resume (v2.0)
@@ -393,6 +451,67 @@ reis visualize --type metrics   # Metrics dashboard
 reis visualize --watch          # Auto-refresh mode
 ```
 
+### Parallel Wave Execution (New in v2.5)
+
+Execute independent waves concurrently for faster phase completion:
+
+```bash
+# Enable parallel execution
+reis execute 3 --parallel
+
+# Limit concurrent waves
+reis execute 3 --parallel --max-concurrent 2
+
+# Preview execution plan
+reis execute 3 --parallel --dry-run --show-graph
+
+# Visualize dependencies
+reis visualize --dependencies
+```
+
+Define wave dependencies in PLAN.md:
+
+```markdown
+## Wave 1: Setup
+<!-- @dependencies: none -->
+- Initialize project
+
+## Wave 2: Backend
+<!-- @dependencies: Wave 1 -->
+- Create API endpoints
+
+## Wave 3: Frontend
+<!-- @dependencies: none -->
+- Build UI components
+
+## Wave 4: Integration
+<!-- @dependencies: Wave 2, Wave 3 -->
+- Connect frontend to backend
+```
+
+**Features:**
+- 🚀 **Dependency-based scheduling** - Waves run as soon as dependencies complete
+- ⚡ **Configurable concurrency** - Control max parallel waves (1-10)
+- 🔍 **Conflict detection** - Detect file conflicts before execution
+- 🛡️ **Resolution strategies** - fail, queue, branch, or merge conflicts
+- 📊 **Visual progress** - Kanban board shows parallel execution
+- 💾 **State persistence** - Resume interrupted parallel execution
+
+**Configuration (reis.config.js):**
+```javascript
+module.exports = {
+  waves: {
+    parallel: {
+      enabled: true,
+      maxConcurrent: 4,
+      conflictStrategy: 'fail'  // 'fail' | 'queue' | 'branch' | 'merge'
+    }
+  }
+};
+```
+
+**Learn more:** [Parallel Execution Guide](docs/PARALLEL_EXECUTION.md)
+
 ### Progress Management
 ```bash
 reis progress           # Show progress
@@ -426,7 +545,7 @@ reis uninstall          # Uninstall
 
 ## Subagents
 
-REIS includes 4 specialized subagents for Rovo Dev:
+REIS includes 5 specialized subagents for Rovo Dev:
 
 ### 🎯 reis_planner
 Creates executable phase plans with task breakdown, dependency analysis, resource requirements, and success criteria.
@@ -434,6 +553,9 @@ Creates executable phase plans with task breakdown, dependency analysis, resourc
 ### ⚡ reis_executor
 Executes plans with atomic commits, deviation handling, checkpoints, state management, and auto-fix capabilities.
 
+### 🔍 reis_plan_reviewer
+Reviews plans against your codebase before execution, detecting already-implemented features, path errors, missing dependencies, and potential conflicts.
+
 ### ✅ reis_verifier
 Verifies execution results against success criteria, runs test suites, validates code quality, detects missing features (FR4.1), and generates comprehensive verification reports.
 
@@ -458,6 +580,7 @@ Maps codebases with architecture analysis, dependency mapping, tech stack identi
 - [WAVE_EXECUTION.md](docs/WAVE_EXECUTION.md) - Wave-based execution guide
 - [CHECKPOINTS.md](docs/CHECKPOINTS.md) - Checkpoint system documentation
 - [CONFIG_GUIDE.md](docs/CONFIG_GUIDE.md) - Configuration reference
+- [PLAN_REVIEW.md](docs/PLAN_REVIEW.md) - Plan review before execution
 
 ### After Installation
 

package/bin/reis.js

@@ -79,6 +79,7 @@ const cycleCmd = require('../lib/commands/cycle.js');
 const decisionsCmd = require('../lib/commands/decisions.js');
 const treeCmd = require('../lib/commands/tree.js');
 const kanbanCmd = require('../lib/commands/kanban.js');
+const { reviewCommand } = require('../lib/commands/review.js');
 
 // Check for --help or -h flag before Commander parses
 if (process.argv.includes('--help') || process.argv.includes('-h')) {
@@ -157,7 +158,11 @@ program
 program
   .command('execute [phase]')
   .description('Execute a phase')
-  .option('--dry-run', 'Show prompt without executing')
+  .option('--parallel', 'Enable parallel wave execution')
+  .option('--max-concurrent <n>', 'Maximum concurrent waves (default: 4)', '4')
+  .option('--conflict-strategy <strategy>', 'Conflict resolution: fail|queue|branch|merge (default: fail)', 'fail')
+  .option('--show-graph', 'Display dependency graph before execution')
+  .option('--dry-run', 'Show execution plan without running')
   .option('-v, --verbose', 'Show detailed output')
   .option('--no-commit', 'Skip auto-commit')
   .option('--timeout <ms>', 'Execution timeout in milliseconds')
@@ -190,12 +195,26 @@ program
   .option('--dry-run', 'Show prompt without executing')
   .option('-v, --verbose', 'Show detailed verification output')
   .option('-s, --strict', 'Fail on warnings')
+  .option('--with-gates', 'Run quality gates after verification')
+  .option('--skip-gates', 'Skip gates even if configured')
   .option('--timeout <ms>', 'Verification timeout in milliseconds')
   .action(async (target, options, command) => {
     const globalOpts = command.parent?.opts() || {};
     await verifyCmd(target, { ...options, noKanban: globalOpts.kanban === false });
   });
 
+// Review command
+program
+  .command('review [target]')
+  .description('Review plans against codebase before execution')
+  .option('--auto-fix', 'Automatically fix simple issues')
+  .option('--strict', 'Fail on warnings')
+  .option('--report [file]', 'Save review report to file')
+  .option('-v, --verbose', 'Show detailed output')
+  .action(async (target, options) => {
+    await reviewCommand(target, options);
+  });
+
 // Progress Commands
 program
   .command('progress')
@@ -205,6 +224,41 @@ program
     progressCmd({}, { noKanban: globalOpts.kanban === false });
   });
 
+program
+  .command('visualize')
+  .description('Visualize project data (progress, waves, roadmap, metrics, dependencies, timeline)')
+  .option('--type <type>', 'Visualization type: progress|waves|roadmap|metrics|dependencies|timeline', 'progress')
+  .option('--dependencies', 'Show wave dependency graph')
+  .option('--timeline', 'Show estimated execution timeline')
+  .option('--format <fmt>', 'Output format: ascii|mermaid (for dependencies)', 'ascii')
+  .option('--watch', 'Auto-refresh display')
+  .option('--compact', 'Compact output')
+  .option('--no-color', 'Disable colors')
+  .action(async (options) => {
+    const visualizeCmd = require('../lib/commands/visualize.js');
+    const args = [];
+    if (options.type) { args.push('--type', options.type); }
+    if (options.dependencies) { args.push('--dependencies'); }
+    if (options.timeline) { args.push('--timeline'); }
+    if (options.format) { args.push('--format', options.format); }
+    if (options.watch) { args.push('--watch'); }
+    if (options.compact) { args.push('--compact'); }
+    if (options.color === false) { args.push('--no-color'); }
+    await visualizeCmd(args);
+  });
+
+// Quality Gates Commands
+program
+  .command('gate [subcommand]')
+  .description('Run quality gates (security, quality, performance, accessibility)')
+  .option('-v, --verbose', 'Show detailed output')
+  .option('--format <format>', 'Output format: ascii|json|markdown', 'ascii')
+  .option('--output <file>', 'Output file for report command')
+  .action(async (subcommand, options) => {
+    const { gateCommand } = require('../lib/commands/gate.js');
+    await gateCommand(subcommand, options);
+  });
+
 program
   .command('pause')
   .description('Pause current work and save state')
@@ -280,11 +334,14 @@ program
 
 program
   .command('cycle [phase-or-plan]')
-  .description('Complete PLAN → EXECUTE → VERIFY → DEBUG cycle')
+  .description('Complete PLAN → EXECUTE → VERIFY → GATE → DEBUG cycle')
   .option('--max-attempts <n>', 'Maximum debug/fix attempts', '3')
   .option('--auto-fix', 'Apply fixes without confirmation')
   .option('--resume', 'Resume interrupted cycle')
   .option('--continue-on-fail', 'Continue even if verification fails')
+  .option('--skip-review', 'Skip plan review phase')
+  .option('--skip-gates', 'Skip quality gates phase')
+  .option('--gate-only <category>', 'Run only specific gate category (security|quality|performance|accessibility)')
   .option('-v, --verbose', 'Detailed output')
   .action(async (phaseOrPlan, options, command) => {
     const globalOpts = command.parent?.opts() || {};

package/docs/CYCLE_WORKFLOW.md

@@ -2,7 +2,91 @@
 
 ## Overview
 
-The REIS Cycle Command automates the complete development workflow: PLAN → EXECUTE → VERIFY → DEBUG → FIX. This document defines the state machine that orchestrates this workflow.
+The REIS Cycle Command automates the complete development workflow:
+
+```
+PLAN → EXECUTE → VERIFY → GATE → DEBUG (if needed)
+```
+
+This document defines the state machine that orchestrates this workflow.
+
+## Cycle Phases
+
+### 1. PLAN
+Create or update the execution plan using `reis_planner` subagent.
+
+### 2. EXECUTE
+Implement the plan using `reis_executor` subagent.
+
+### 3. VERIFY
+Verify implementation completeness using `reis_verifier` subagent.
+
+### 4. GATE (New in v2.5)
+Run quality gates to check:
+- **Security**: Vulnerabilities, secrets, license compliance
+- **Quality**: Test coverage, linting, code complexity
+- **Performance**: Bundle size, dependencies (optional)
+- **Accessibility**: WCAG compliance (optional)
+
+### 5. DEBUG
+If verification or gates fail, analyze issues using `reis_debugger` subagent.
+
+## Gate Phase Details
+
+### When Gates Run
+- Automatically after successful verification in `reis cycle`
+- Manually with `reis verify --with-gates`
+- Controlled by `gates.runOn` in config
+
+### Gate Behavior
+- **blockOnFail: true** (default) - Gate failure triggers debug phase
+- **blockOnFail: false** - Gate failure shows warning, cycle continues
+- **blockOnWarning: true** - Treat warnings as failures
+
+### Skipping Gates
+```bash
+reis cycle --skip-gates           # Skip all gates
+reis cycle --gate-only security   # Run only security gates
+```
+
+## Configuration
+
+```javascript
+// reis.config.js
+module.exports = {
+  gates: {
+    enabled: true,
+    runOn: ['cycle'],        // 'cycle', 'verify', or both
+    blockOnFail: true,       // Block cycle on gate failure
+    blockOnWarning: false,   // Block on warnings
+    timeout: 30000,          // Gate timeout (ms)
+    
+    security: { enabled: true },
+    quality: { enabled: true },
+    performance: { enabled: false },
+    accessibility: { enabled: false }
+  }
+};
+```
+
+## CLI Commands
+
+```bash
+# Full cycle with gates
+reis cycle 3
+
+# Cycle without gates
+reis cycle 3 --skip-gates
+
+# Cycle with specific gate category
+reis cycle 3 --gate-only security
+
+# Verification with gates
+reis verify --with-gates
+
+# Resume interrupted cycle
+reis cycle --resume
+```
 
 ## State Machine
 
@@ -13,7 +97,8 @@ The REIS Cycle Command automates the complete development workflow: PLAN → EXE
 | **IDLE** | No cycle running | PLANNING |
 | **PLANNING** | Generating or validating plan | EXECUTING, FAILED |
 | **EXECUTING** | Running plan tasks | VERIFYING, FAILED |
-| **VERIFYING** | Checking completion criteria | COMPLETE, DEBUGGING, FAILED |
+| **VERIFYING** | Checking completion criteria | GATING, DEBUGGING, FAILED |
+| **GATING** | Running quality gates | COMPLETE, DEBUGGING, FAILED |
 | **DEBUGGING** | Analyzing failures | FIXING, FAILED |
 | **FIXING** | Applying fix plan | VERIFYING, FAILED |
 | **COMPLETE** | All tasks successful | IDLE |
@@ -56,10 +141,19 @@ The REIS Cycle Command automates the complete development workflow: PLAN → EXE
     │                  │
     │ Pass (100%)      │ Fail (<100%)
     ▼                  ▼
+┌─────────────────────────────────────────┐  ┌────────────────┐
+│              GATING (v2.5)              │  │   DEBUGGING    │
+│    - Run security gates                 │  │ (verification  │
+│    - Run quality gates                  │  │  failures)     │
+│    - Optional: performance, a11y        │  └───────┬────────┘
+└───┬──────────────────┬──────────────────┘          │
+    │                  │                             │
+    │ Gates pass       │ Gates fail                  │
+    ▼                  ▼                             │
 ┌──────────┐    ┌─────────────────────────────────────────────┐
 │ COMPLETE │    │             DEBUGGING                        │
-│          │    │    - Analyze verification failures           │
-│          │    │    - Classify issues                         │
+│          │    │    - Analyze verification/gate failures      │
+│          │    │    - Classify issues [GATE:category]         │
 └──────────┘    │    - Generate fix plan                       │
                 └───┬──────────────────────┬───────────────────┘
                     │                      │
@@ -83,13 +177,16 @@ The REIS Cycle Command automates the complete development workflow: PLAN → EXE
                  │ Pass       │ Fail (< max attempts)
                  ▼            │
          ┌──────────┐         │
-         │ COMPLETE │         └─→ Back to DEBUGGING
-         └──────────┘
-                               │ Fail (≥ max attempts)
-                               ▼
-                          ┌──────────┐
-                          │  FAILED  │
-                          └──────────┘
+         │  GATING  │         └─→ Back to DEBUGGING
+         └────┬─────┘
+              │
+              │ Gates pass
+              ▼
+         ┌──────────┐         │ Fail (≥ max attempts)
+         │ COMPLETE │         ▼
+         └──────────┘    ┌──────────┐
+                         │  FAILED  │
+                         └──────────┘
 ```
 
 ## State Persistence
@@ -195,10 +292,41 @@ The REIS Cycle Command automates the complete development workflow: PLAN → EXE
 4. Collect missing items
 
 **Next State:**
-- 100% complete → COMPLETE
+- 100% complete → GATING
 - <100% complete → DEBUGGING
 - Error → FAILED
 
+### VERIFYING → GATING
+
+**Trigger:** Verification passes (completeness = 100%)
+
+**Actions:**
+1. Check if gates enabled (`gates.enabled` and `gates.runOn` includes 'cycle')
+2. Skip if `--skip-gates` flag provided
+3. Run only specified category if `--gate-only <category>` provided
+4. Run all enabled gate categories
+5. Collect gate results
+
+**Next State:**
+- All gates pass → COMPLETE
+- Gates fail and `blockOnFail: true` → DEBUGGING
+- Gates fail and `blockOnFail: false` → COMPLETE (with warnings)
+- Error → FAILED
+
+### GATING → DEBUGGING
+
+**Trigger:** Gate failure with `blockOnFail: true`
+
+**Actions:**
+1. Collect failed gate results
+2. Prefix issues with `[GATE:category]` (e.g., `[GATE:security]`)
+3. Pass to debugger for analysis
+4. Generate gate-specific fix recommendations
+
+**Next State:**
+- Fix plan generated → FIXING
+- Cannot generate fix → FAILED
+
 ### VERIFYING → DEBUGGING
 
 **Trigger:** Verification fails (completeness < 100%)
@@ -394,6 +522,6 @@ reis cycle <phase>
 
 ---
 
-**Version:** 1.0.0  
-**Last Updated:** 2026-01-18  
-**Status:** Design Complete
+**Version:** 2.0.0  
+**Last Updated:** 2026-01-26  
+**Status:** Design Complete (Updated for Gate Integration)