devflow-kit 1.5.0 → 1.6.1

package/plugins/devflow-code-review/agents/reviewer.md

@@ -42,15 +42,16 @@ The orchestrator provides:
 ## Responsibilities
 
 1. **Load focus skill** - Read the pattern skill file for your focus area from the table above. This gives you detection rules and patterns specific to your review type.
-2. **Identify changed lines** - Get diff against base branch (main/master/develop)
-3. **Apply 3-category classification** - Sort issues by where they occur
-4. **Apply focus-specific analysis** - Use pattern skill detection rules from the loaded skill file
-5. **Assign severity** - CRITICAL, HIGH, MEDIUM, LOW based on impact
-6. **Assess confidence** - Assign 0-100% confidence to each finding (see Confidence Scale below)
-7. **Filter by confidence** - Only report findings ≥80% in main sections; lower-confidence items go to Suggestions
-8. **Consolidate similar issues** - Group related findings to reduce noise (see Consolidation Rules)
-9. **Generate report** - File:line references with suggested fixes
-10. **Determine merge recommendation** - Based on blocking issues
+2. **Check known pitfalls** - If `.memory/knowledge/pitfalls.md` exists, read it. Check if any pitfall Areas overlap with files in the current diff. Verify the Resolution was applied. Flag if a known pitfall pattern is being reintroduced.
+3. **Identify changed lines** - Get diff against base branch (main/master/develop)
+4. **Apply 3-category classification** - Sort issues by where they occur
+5. **Apply focus-specific analysis** - Use pattern skill detection rules from the loaded skill file
+6. **Assign severity** - CRITICAL, HIGH, MEDIUM, LOW based on impact
+7. **Assess confidence** - Assign 0-100% confidence to each finding (see Confidence Scale below)
+8. **Filter by confidence** - Only report findings ≥80% in main sections; lower-confidence items go to Suggestions
+9. **Consolidate similar issues** - Group related findings to reduce noise (see Consolidation Rules)
+10. **Generate report** - File:line references with suggested fixes
+11. **Determine merge recommendation** - Based on blocking issues
 
 ## Confidence Scale
 

package/plugins/devflow-code-review/commands/code-review-teams.md

@@ -85,39 +85,42 @@ Spawn review teammates with self-contained prompts:
     You are reviewing PR #{pr_number} on branch {branch} (base: {base_branch}).
     1. Read your skill: `Read ~/.claude/skills/security-patterns/SKILL.md`
     2. Read review methodology: `Read ~/.claude/skills/review-methodology/SKILL.md`
-    3. Get the diff: `git diff {base_branch}...HEAD`
-    4. Apply the 6-step review process from review-methodology
-    5. Focus: injection, auth bypass, crypto misuse, OWASP vulnerabilities
-    6. Classify each finding: 🔴 BLOCKING / ⚠️ SHOULD-FIX / ℹ️ PRE-EXISTING
-    7. Include file:line references for every finding
-    8. Write your report: `Write to .docs/reviews/{branch_slug}/security.md`
-    9. Report completion: SendMessage(type: "message", recipient: "team-lead", summary: "Security review done")
+    3. Read `.memory/knowledge/pitfalls.md` if it exists. Check for known pitfall patterns in the diff.
+    4. Get the diff: `git diff {base_branch}...HEAD`
+    5. Apply the 6-step review process from review-methodology
+    6. Focus: injection, auth bypass, crypto misuse, OWASP vulnerabilities
+    7. Classify each finding: 🔴 BLOCKING / ⚠️ SHOULD-FIX / ℹ️ PRE-EXISTING
+    8. Include file:line references for every finding
+    9. Write your report: `Write to .docs/reviews/{branch_slug}/security.md`
+    10. Report completion: SendMessage(type: "message", recipient: "team-lead", summary: "Security review done")
 
 - Name: "architecture-reviewer"
   Prompt: |
     You are reviewing PR #{pr_number} on branch {branch} (base: {base_branch}).
     1. Read your skill: `Read ~/.claude/skills/architecture-patterns/SKILL.md`
     2. Read review methodology: `Read ~/.claude/skills/review-methodology/SKILL.md`
-    3. Get the diff: `git diff {base_branch}...HEAD`
-    4. Apply the 6-step review process from review-methodology
-    5. Focus: SOLID violations, coupling, layering issues, modularity problems
-    6. Classify each finding: 🔴 BLOCKING / ⚠️ SHOULD-FIX / ℹ️ PRE-EXISTING
-    7. Include file:line references for every finding
-    8. Write your report: `Write to .docs/reviews/{branch_slug}/architecture.md`
-    9. Report completion: SendMessage(type: "message", recipient: "team-lead", summary: "Architecture review done")
+    3. Read `.memory/knowledge/pitfalls.md` if it exists. Check for known pitfall patterns in the diff.
+    4. Get the diff: `git diff {base_branch}...HEAD`
+    5. Apply the 6-step review process from review-methodology
+    6. Focus: SOLID violations, coupling, layering issues, modularity problems
+    7. Classify each finding: 🔴 BLOCKING / ⚠️ SHOULD-FIX / ℹ️ PRE-EXISTING
+    8. Include file:line references for every finding
+    9. Write your report: `Write to .docs/reviews/{branch_slug}/architecture.md`
+    10. Report completion: SendMessage(type: "message", recipient: "team-lead", summary: "Architecture review done")
 
 - Name: "performance-reviewer"
   Prompt: |
     You are reviewing PR #{pr_number} on branch {branch} (base: {base_branch}).
     1. Read your skill: `Read ~/.claude/skills/performance-patterns/SKILL.md`
     2. Read review methodology: `Read ~/.claude/skills/review-methodology/SKILL.md`
-    3. Get the diff: `git diff {base_branch}...HEAD`
-    4. Apply the 6-step review process from review-methodology
-    5. Focus: N+1 queries, memory leaks, algorithm issues, I/O bottlenecks
-    6. Classify each finding: 🔴 BLOCKING / ⚠️ SHOULD-FIX / ℹ️ PRE-EXISTING
-    7. Include file:line references for every finding
-    8. Write your report: `Write to .docs/reviews/{branch_slug}/performance.md`
-    9. Report completion: SendMessage(type: "message", recipient: "team-lead", summary: "Performance review done")
+    3. Read `.memory/knowledge/pitfalls.md` if it exists. Check for known pitfall patterns in the diff.
+    4. Get the diff: `git diff {base_branch}...HEAD`
+    5. Apply the 6-step review process from review-methodology
+    6. Focus: N+1 queries, memory leaks, algorithm issues, I/O bottlenecks
+    7. Classify each finding: 🔴 BLOCKING / ⚠️ SHOULD-FIX / ℹ️ PRE-EXISTING
+    8. Include file:line references for every finding
+    9. Write your report: `Write to .docs/reviews/{branch_slug}/performance.md`
+    10. Report completion: SendMessage(type: "message", recipient: "team-lead", summary: "Performance review done")
 
 - Name: "quality-reviewer"
   Prompt: |
@@ -128,13 +131,14 @@ Spawn review teammates with self-contained prompts:
        - `Read ~/.claude/skills/test-patterns/SKILL.md`
        - `Read ~/.claude/skills/regression-patterns/SKILL.md`
     2. Read review methodology: `Read ~/.claude/skills/review-methodology/SKILL.md`
-    3. Get the diff: `git diff {base_branch}...HEAD`
-    4. Apply the 6-step review process from review-methodology
-    5. Focus: complexity, test gaps, pattern violations, regressions, naming
-    6. Classify each finding: 🔴 BLOCKING / ⚠️ SHOULD-FIX / ℹ️ PRE-EXISTING
-    7. Include file:line references for every finding
-    8. Write your report: `Write to .docs/reviews/{branch_slug}/quality.md`
-    9. Report completion: SendMessage(type: "message", recipient: "team-lead", summary: "Quality review done")
+    3. Read `.memory/knowledge/pitfalls.md` if it exists. Check for known pitfall patterns in the diff.
+    4. Get the diff: `git diff {base_branch}...HEAD`
+    5. Apply the 6-step review process from review-methodology
+    6. Focus: complexity, test gaps, pattern violations, regressions, naming
+    7. Classify each finding: 🔴 BLOCKING / ⚠️ SHOULD-FIX / ℹ️ PRE-EXISTING
+    8. Include file:line references for every finding
+    9. Write your report: `Write to .docs/reviews/{branch_slug}/quality.md`
+    10. Report completion: SendMessage(type: "message", recipient: "team-lead", summary: "Quality review done")
 
 [Add conditional perspectives based on Phase 1 — follow same pattern:
  explicit skill path, diff command, output path, SendMessage for completion]
@@ -212,7 +216,14 @@ Include confidence levels from debate consensus."
 {Key exchanges that changed findings}
 ```
 
-### Phase 5: Cleanup and Report
+### Phase 5: Record Pitfalls (if blocking issues found)
+
+If the review summary contains CRITICAL or HIGH blocking issues:
+1. Read `~/.claude/skills/knowledge-persistence/SKILL.md` and follow its extraction procedure to record pitfalls to `.memory/knowledge/pitfalls.md`
+2. Source field: `/code-review {branch}`
+3. Skip entirely if no CRITICAL/HIGH blocking issues
+
+### Phase 6: Cleanup and Report
 
 Shut down all review teammates explicitly:
 
@@ -257,7 +268,9 @@ Display results:
 │  ├─ Git agent (comment-pr with consensus findings)
 │  └─ Lead writes review-summary with confidence levels
 │
-└─ Phase 5: Cleanup and display results
+├─ Phase 5: Record Pitfalls (inline, if blocking issues)
+│
+└─ Phase 6: Cleanup and display results
 ```
 
 ## Principles

package/plugins/devflow-code-review/commands/code-review.md

@@ -117,6 +117,13 @@ Display results from all agents:
 - PR comments created/skipped (from Git)
 - Artifact paths
 
+### Phase 5: Record Pitfalls (if blocking issues found)
+
+If the review summary contains CRITICAL or HIGH blocking issues:
+1. Read `~/.claude/skills/knowledge-persistence/SKILL.md` and follow its extraction procedure to record pitfalls to `.memory/knowledge/pitfalls.md`
+2. Source field: `/code-review {branch}`
+3. Skip entirely if no CRITICAL/HIGH blocking issues
+
 ## Architecture
 
 ```
@@ -142,7 +149,9 @@ Display results from all agents:
 │  ├─ Git agent (comment-pr)
 │  └─ Synthesizer agent (mode: review)
 │
-└─ Phase 4: Display results
+├─ Phase 4: Display results
+│
+└─ Phase 5: Record Pitfalls (inline, if blocking issues)
 ```
 
 ## Principles

package/plugins/devflow-code-review/skills/knowledge-persistence/SKILL.md

@@ -0,0 +1,128 @@
+---
+name: knowledge-persistence
+description: >-
+  This skill should be used when recording architectural decisions or pitfalls
+  to project knowledge files, or when loading prior decisions and known pitfalls
+  for context during investigation, specification, or review.
+user-invocable: false
+allowed-tools: Read, Write, Bash
+---
+
+# Knowledge Persistence
+
+Record architectural decisions and pitfalls to `.memory/knowledge/` files. This is the single source of truth for the extraction procedure — commands reference this skill instead of inlining the steps.
+
+## Iron Law
+
+> **SINGLE SOURCE OF TRUTH**
+>
+> All knowledge extraction follows this procedure exactly. Commands never inline
+> their own extraction steps — they read this skill and follow it.
+
+---
+
+## File Locations
+
+```
+.memory/knowledge/
+├── decisions.md    # ADR entries (append-only)
+└── pitfalls.md     # PF entries (area-specific gotchas)
+```
+
+## File Formats
+
+### decisions.md (ADR entries)
+
+**Template header** (create if file missing):
+```
+<!-- TL;DR: 0 decisions. Key: -->
+# Architectural Decisions
+
+Append-only. Status changes allowed; deletions prohibited.
+```
+
+**Entry format**:
+```markdown
+## ADR-{NNN}: {Title}
+
+- **Date**: {YYYY-MM-DD}
+- **Status**: Accepted
+- **Context**: {Why this decision was needed}
+- **Decision**: {What was decided}
+- **Consequences**: {Tradeoffs and implications}
+- **Source**: {command and identifier, e.g. `/implement TASK-123`}
+```
+
+### pitfalls.md (PF entries)
+
+**Template header** (create if file missing):
+```
+<!-- TL;DR: 0 pitfalls. Key: -->
+# Known Pitfalls
+
+Area-specific gotchas, fragile areas, and past bugs.
+```
+
+**Entry format**:
+```markdown
+## PF-{NNN}: {Short description}
+
+- **Area**: {file paths or module names}
+- **Issue**: {What goes wrong}
+- **Impact**: {Consequences if hit}
+- **Resolution**: {How to fix or avoid}
+- **Source**: {command and identifier, e.g. `/code-review branch-name`}
+```
+
+---
+
+## Extraction Procedure
+
+Follow these steps when recording decisions or pitfalls:
+
+1. **Read** the target file (`.memory/knowledge/decisions.md` or `.memory/knowledge/pitfalls.md`). If it doesn't exist, create it with the template header above.
+2. **Check capacity** — count `## ADR-` or `## PF-` headings. If >=50, log "Knowledge base at capacity — skipping new entry" and stop.
+3. **Find next ID** — find highest NNN via regex (`/^## ADR-(\d+)/` or `/^## PF-(\d+)/`), default to 0. Increment by 1.
+4. **Deduplicate** (pitfalls only) — skip if an entry with the same Area + Issue already exists.
+5. **Append** the new entry using the format above.
+6. **Update TL;DR** — rewrite the `<!-- TL;DR: ... -->` comment on line 1 to reflect the new count and key topics.
+
+## Lock Protocol
+
+When writing, use a mkdir-based lock:
+- Lock path: `.memory/.knowledge.lock`
+- Timeout: 30 seconds (fail if lock not acquired)
+- Stale recovery: if lock directory is >60 seconds old, remove it and retry
+- Release lock after write completes (remove lock directory)
+
+## Loading Knowledge for Context
+
+When a command needs prior knowledge as input (not recording):
+
+1. Read `.memory/knowledge/decisions.md` if it exists
+2. Read `.memory/knowledge/pitfalls.md` if it exists
+3. Pass content as context to downstream agents — prior decisions constrain scope, known pitfalls inform investigation
+
+If neither file exists, skip silently. No error, no empty-file creation.
+
+## Operation Budget
+
+Recording: do inline (no agent spawn), 2-3 Read/Write operations total.
+Loading: 1-2 Read operations, pass as context string.
+
+---
+
+## Extended References
+
+For entry examples and status lifecycle details:
+- `references/examples.md` - Full decision and pitfall entry examples
+
+---
+
+## Success Criteria
+
+- [ ] Entry appended with correct sequential ID
+- [ ] No duplicate pitfalls (same Area + Issue)
+- [ ] TL;DR comment updated with current count
+- [ ] Lock acquired before write, released after
+- [ ] Capacity limit (50) respected

package/plugins/devflow-code-review/skills/knowledge-persistence/references/examples.md

@@ -0,0 +1,44 @@
+# Knowledge Persistence Examples
+
+## Decision Entry Example
+
+```markdown
+## ADR-001: Use mkdir-based locks for concurrent session serialization
+
+- **Date**: 2026-03-03
+- **Status**: Accepted
+- **Context**: Multiple Claude Code sessions can run on the same project simultaneously (different terminals, SSH, etc.). Memory writes must serialize to prevent corruption.
+- **Decision**: Use `mkdir` as an atomic lock primitive. Lock directory at `.memory/.knowledge.lock`. 30-second timeout with 60-second stale recovery.
+- **Consequences**: Simple, cross-platform, no external dependencies. Cannot detect holder PID if lock is stale — relies on age-based recovery. Sufficient for low-contention writes.
+- **Source**: `/implement #99`
+```
+
+## Pitfall Entry Example
+
+```markdown
+## PF-001: Orphaned teams variants silently skipped
+
+- **Area**: plugins/devflow-*/commands/*-teams.md, src/cli/installer
+- **Issue**: The installer iterates base `.md` files and looks up matching `-teams.md` variants. A `-teams.md` file without a corresponding base `.md` is silently ignored during installation.
+- **Impact**: Teams variant appears committed but never installs. Users on `--teams` mode silently get no command.
+- **Resolution**: Always create the base `.md` file first. CI should validate that every `-teams.md` has a matching base file.
+- **Source**: `/code-review feat/agent-teams`
+```
+
+## Status Lifecycle (Decisions Only)
+
+Decisions support status transitions:
+- `Accepted` — current, in effect
+- `Superseded by ADR-NNN` — replaced by a newer decision
+- `Deprecated` — no longer relevant, kept for history
+
+Pitfalls have no status field — they remain until manually removed.
+
+## Deduplication Logic (Pitfalls Only)
+
+Before appending a new pitfall, check existing entries:
+1. Extract `Area` and `Issue` from the new entry
+2. Compare against all existing `PF-*` entries
+3. If both Area AND Issue match an existing entry (case-insensitive substring), skip
+
+This prevents recording the same gotcha from multiple review cycles.

package/plugins/devflow-core-skills/.claude-plugin/plugin.json

@@ -4,7 +4,7 @@
   "author": {
     "name": "Dean0x"
   },
-  "version": "1.5.0",
+  "version": "1.6.1",
   "homepage": "https://github.com/dean0x/devflow",
   "repository": "https://github.com/dean0x/devflow",
   "license": "MIT",

package/plugins/devflow-core-skills/skills/docs-framework/SKILL.md

@@ -38,8 +38,10 @@ All generated documentation lives under `.docs/` in the project root:
 
 .memory/
 ├── WORKING-MEMORY.md                   # Auto-maintained by Stop hook (overwritten)
-├── PROJECT-PATTERNS.md                 # Accumulated patterns (merged across sessions)
-└── backup.json                         # Pre-compact git state snapshot
+├── backup.json                         # Pre-compact git state snapshot
+└── knowledge/
+    ├── decisions.md                    # Architectural decisions (ADR-NNN format)
+    └── pitfalls.md                     # Known pitfalls (PF-NNN format)
 ```
 
 ---
@@ -97,6 +99,8 @@ source .devflow/scripts/docs-helpers.sh 2>/dev/null || {
 |-------|-----------------|----------|
 | Reviewer | `.docs/reviews/{branch-slug}/{type}-report.{timestamp}.md` | Creates new |
 | Working Memory | `.memory/WORKING-MEMORY.md` | Overwrites (auto-maintained by Stop hook) |
+| Knowledge (decisions) | `.memory/knowledge/decisions.md` | Append-only (ADR-NNN sequential IDs) |
+| Knowledge (pitfalls) | `.memory/knowledge/pitfalls.md` | Append-only (PF-NNN sequential IDs) |
 
 ### Agents That Don't Persist
 
@@ -125,6 +129,7 @@ When creating or modifying persisting agents:
 This framework is used by:
 - **Review agents**: Creates review reports
 - **Working Memory hooks**: Auto-maintains `.memory/WORKING-MEMORY.md`
+- **Command flows**: `/implement` appends ADRs to `decisions.md`; `/code-review`, `/debug`, `/resolve` append PFs to `pitfalls.md`
 
 All persisting agents should load this skill to ensure consistent documentation.
 

package/plugins/devflow-core-skills/skills/test-driven-development/SKILL.md

@@ -91,7 +91,7 @@ See `references/rationalization-prevention.md` for extended examples with code.
 
 ## Process Enforcement
 
-When implementing any feature under ambient BUILD/GUIDED:
+When implementing any feature under ambient IMPLEMENT/GUIDED or IMPLEMENT/ORCHESTRATED:
 
 1. **Identify the first behavior** — What is the simplest thing this feature must do?
 2. **Write the test** — Describe that behavior as a failing test
@@ -130,7 +130,8 @@ When skipping TDD, never rationalize. State clearly: "Skipping TDD because: [spe
 
 ## Integration with Ambient Mode
 
-- **BUILD/GUIDED** → TDD enforced. Every new function/method gets test-first treatment.
-- **BUILD/QUICK** → TDD skipped (trivial single-file edit).
-- **BUILD/ELEVATE** → TDD mentioned in nudge toward `/implement`.
-- **DEBUG/GUIDED** → TDD applies to the fix: write a test that reproduces the bug first, then fix.
+- **IMPLEMENT/GUIDED** → TDD enforced in main session. Write the failing test before production code. Skill loaded directly.
+- **IMPLEMENT/ORCHESTRATED** → TDD enforced via Coder agent (skill in Coder frontmatter). Every implementation gets test-first treatment.
+- **IMPLEMENT/QUICK** → TDD skipped (trivial single-file edit).
+- **DEBUG/GUIDED** → TDD applies to the fix in main session: write a test that reproduces the bug first, then fix.
+- **DEBUG/ORCHESTRATED** → TDD applies to the fix: write a test that reproduces the bug first, then fix.

package/plugins/devflow-debug/.claude-plugin/plugin.json

@@ -4,7 +4,7 @@
   "author": {
     "name": "Dean0x"
   },
-  "version": "1.5.0",
+  "version": "1.6.1",
   "homepage": "https://github.com/dean0x/devflow",
   "repository": "https://github.com/dean0x/devflow",
   "license": "MIT",
@@ -15,10 +15,12 @@
     "agent-teams"
   ],
   "agents": [
-    "git"
+    "git",
+    "synthesizer"
   ],
   "skills": [
     "agent-teams",
-    "git-safety"
+    "git-safety",
+    "knowledge-persistence"
   ]
 }

package/plugins/devflow-debug/agents/synthesizer.md

@@ -0,0 +1,211 @@
+---
+name: Synthesizer
+description: Combines outputs from multiple agents into actionable summaries (modes: exploration, planning, review)
+model: haiku
+skills: review-methodology, docs-framework
+---
+
+# Synthesizer Agent
+
+You are a synthesis specialist. You combine outputs from multiple parallel agents into clear, actionable summaries. You operate in three modes: exploration, planning, and review.
+
+## Input
+
+The orchestrator provides:
+- **Mode**: `exploration` | `planning` | `review`
+- **Agent outputs**: Results from parallel agents to synthesize
+- **Output path**: Where to save synthesis (if applicable)
+
+---
+
+## Mode: Exploration
+
+Synthesize outputs from 4 Explore agents (architecture, integration, reusable code, edge cases).
+
+**Process:**
+1. Extract key findings from each explorer
+2. Identify patterns that appear across multiple explorations
+3. Resolve conflicts if explorers found contradictory patterns
+4. Prioritize by relevance to the task
+
+**Output:**
+```markdown
+## Exploration Synthesis
+
+### Patterns to Follow
+| Pattern | Location | Usage |
+|---------|----------|-------|
+| {pattern} | `file:line` | {when to use} |
+
+### Integration Points
+| Entry Point | File | How to Integrate |
+|-------------|------|------------------|
+| {point} | `file:line` | {description} |
+
+### Reusable Code
+| Utility | Location | Purpose |
+|---------|----------|---------|
+| {function} | `file:line` | {what it does} |
+
+### Edge Cases
+| Scenario | Pattern | Example |
+|----------|---------|---------|
+| {case} | {handling} | `file:line` |
+
+### Key Insights
+1. {insight}
+2. {insight}
+```
+
+---
+
+## Mode: Planning
+
+Synthesize outputs from 3 Plan agents (implementation, testing, execution strategy).
+
+**Process:**
+1. Merge implementation steps with testing strategy
+2. Apply execution strategy analysis to determine Coder deployment
+3. Identify dependencies between steps
+4. Assess context risk based on file count and module breadth
+
+**Execution Strategy Decision:**
+
+Analyze 3 axes to determine strategy:
+
+| Axis | Signals | Impact |
+|------|---------|--------|
+| **Artifact Independence** | Shared contracts? Integration points? Cross-file dependencies? | If coupled → SINGLE_CODER |
+| **Context Capacity** | File count, module breadth, pattern complexity | HIGH/CRITICAL → SEQUENTIAL_CODERS |
+| **Domain Specialization** | Tech stack detected (backend, frontend, tests) | Determines DOMAIN hints |
+
+**Context Risk Levels:**
+- **LOW**: <10 files, single module → SINGLE_CODER
+- **MEDIUM**: 10-20 files, 2-3 modules → Consider SEQUENTIAL_CODERS
+- **HIGH**: 20-30 files, multiple modules → SEQUENTIAL_CODERS (2-3 phases)
+- **CRITICAL**: >30 files, cross-cutting concerns → SEQUENTIAL_CODERS (more phases)
+
+**Strategy Selection:**
+- **SINGLE_CODER** (~80%): Default. Coherent A→Z implementation. Best for consistency in naming, patterns, error handling.
+- **SEQUENTIAL_CODERS** (~15%): Context overflow risk or layered dependencies. Split into phases with handoff summaries.
+- **PARALLEL_CODERS** (~5%): True artifact independence - no shared contracts, no integration points. Rare.
+
+**Output:**
+```markdown
+## Planning Synthesis
+
+### Execution Strategy
+**Type**: {SINGLE_CODER | SEQUENTIAL_CODERS | PARALLEL_CODERS}
+**Context Risk**: {LOW | MEDIUM | HIGH | CRITICAL}
+**File Estimate**: {n} files across {m} modules
+**Reason**: {why this strategy}
+
+### Subtask Breakdown (if not SINGLE_CODER)
+| Phase | Domain | Description | Files | Depends On |
+|-------|--------|-------------|-------|------------|
+| 1 | backend | {description} | `file1`, `file2` | - |
+| 2 | frontend | {description} | `file3`, `file4` | Phase 1 |
+
+### Implementation Plan
+| Step | Action | Files | Tests | Depends On |
+|------|--------|-------|-------|------------|
+| 1 | {action} | `file` | `test_file` | - |
+| 2 | {action} | `file` | `test_file` | Step 1 |
+
+### Risk Assessment
+| Risk | Mitigation |
+|------|------------|
+| {issue} | {approach} |
+
+### Complexity
+{Low | Medium | High} - {reasoning}
+```
+
+---
+
+## Mode: Review
+
+Synthesize outputs from multiple Reviewer agents. Apply strict merge rules.
+
+**Process:**
+1. Read all review reports from `${REVIEW_BASE_DIR}/*.md` (exclude your own output `review-summary.*.md`)
+2. Extract confidence percentages from each finding
+3. Apply confidence-aware aggregation: when multiple reviewers flag the same file:line, boost confidence by 10% per additional reviewer (cap at 100%)
+<!-- Confidence threshold also in: shared/agents/reviewer.md, plugins/devflow-code-review/commands/code-review.md -->
+4. Maintain ≥80% confidence threshold in final output
+5. Categorize issues into 3 buckets (from review-methodology)
+6. Count by severity (CRITICAL, HIGH, MEDIUM, LOW)
+7. Determine merge recommendation based on blocking issues
+
+**Issue Categories:**
+- **Blocking** (Category 1): Issues in YOUR changes - CRITICAL/HIGH must block
+- **Should-Fix** (Category 2): Issues in code you touched - HIGH/MEDIUM
+- **Pre-existing** (Category 3): Legacy issues - informational only
+
+**Merge Rules:**
+| Condition | Recommendation |
+|-----------|----------------|
+| Any CRITICAL in blocking | BLOCK MERGE |
+| Any HIGH in blocking | CHANGES REQUESTED |
+| Only MEDIUM in blocking | APPROVED WITH COMMENTS |
+| No blocking issues | APPROVED |
+
+**Output:**
+**CRITICAL**: Write the summary to disk using the Write tool:
+1. Create directory: `mkdir -p ${REVIEW_BASE_DIR}`
+2. Write to `${REVIEW_BASE_DIR}/review-summary.${TIMESTAMP}.md` using Write tool
+3. Confirm file written in final message
+
+Report format:
+
+```markdown
+# Code Review Summary
+
+**Branch**: {branch} -> {base}
+**Date**: {timestamp}
+
+## Merge Recommendation: {BLOCK | CHANGES_REQUESTED | APPROVED}
+
+{Brief reasoning}
+
+## Issue Summary
+| Category | CRITICAL | HIGH | MEDIUM | LOW | Total |
+|----------|----------|------|--------|-----|-------|
+| Blocking | {n} | {n} | {n} | - | {n} |
+| Should Fix | - | {n} | {n} | - | {n} |
+| Pre-existing | - | - | {n} | {n} | {n} |
+
+## Blocking Issues
+{List with file:line, confidence %, and suggested fix}
+
+## Suggestions (Lower Confidence)
+{Max 5 items across all reviewers with 60-79% confidence. Brief descriptions only.}
+
+## Action Plan
+1. {Priority fix}
+2. {Next fix}
+```
+
+---
+
+## Principles
+
+1. **No new research** - Only synthesize what agents found
+2. **Preserve references** - Keep file:line from source agents
+3. **Resolve conflicts** - If agents disagree, pick best pattern with justification
+4. **Actionable output** - Results must be executable by next phase
+5. **Accurate counts** - Issue counts must match reality (review mode)
+6. **Honest recommendation** - Never approve with blocking issues (review mode)
+7. **Be decisive** - Make confident synthesis choices
+
+## Boundaries
+
+**Handle autonomously:**
+- Combining agent outputs
+- Resolving conflicts between agents
+- Generating structured summaries
+- Determining merge recommendations
+
+**Escalate to orchestrator:**
+- Fundamental disagreements between agents that need user input
+- Missing critical agent outputs