feat(implementer): add cross-file duplication detection for parallel agent workflows

[rjmurillo]

Problem

The implementer agent prompt contains anti-duplication guidance (Code Simplification rule #1: "If 3+ lines appear twice, extract or loop. Check within the file and across files touched in this PR."), but this rule is structurally unenforceable when multiple implementer agents run in parallel.

Evidence: PR rjmurillo/moq.analyzers#898

Five parallel agents were spawned to write tests for untested Common extension methods. Each agent independently created identical boilerplate in its test file:

• CorlibReference (MetadataReference field)
• SystemRuntimeReference (MetadataReference field)
• CoreReferences (MetadataReference array)
• CreateCompilation() (full method, ~15 lines)
• CreateMoqCompilationAsync() (full method, ~20 lines)
• GetMoqReferencesAsync() (full method, ~10 lines)

Result: 489 lines of identical code across 12 files. A reviewer (Gemini) caught it, but the initial response dismissed the feedback. After investigation, a shared CompilationHelper class was extracted, reducing net lines by 287.

Root Cause Analysis

Three structural gaps allow cross-file duplication to survive:

Gap 1: Parallel agent isolation

When multiple implementer agents run concurrently via Task tool, each agent only sees its own files. The "check across files touched in this PR" guidance is impossible to follow because Agent A has no visibility into what Agent B is writing.

The prompt assumes a single-agent workflow but the orchestrator regularly spawns parallel agents for throughput.

Gap 2: No post-consolidation step in the orchestration workflow

The orchestrator's workflow is: implementer → critic → qa → security. After parallel implementer agents complete, there is no consolidation step that reviews all outputs together for cross-cutting concerns like duplication.

The critic agent (line 59: "No code review or completed work assessment") explicitly excludes itself from reviewing implementation output. The QA agent verifies tests pass but doesn't check for code redundancy.

Gap 3: PR review agents lack cross-file duplication detection

The review-pr skill uses six agents: code-reviewer, pr-test-analyzer, silent-failure-hunter, type-design-analyzer, comment-analyzer, code-simplifier. None have explicit instructions to detect duplication across files in a PR diff.

The code-simplifier focuses on simplifying individual files. The code-reviewer checks project guidelines but doesn't scan for identical blocks across changed files.

Proposed Solutions

Option A: Add a consolidation phase to the orchestrator (Recommended)

After parallel implementer agents complete, the orchestrator should:

1. Collect all files created/modified by parallel agents
2. Spawn a single implementer (or a new consolidator agent) with ALL those files as context
3. The agent scans for identical blocks (3+ lines appearing in 2+ files) and extracts shared helpers
4. Run build + tests to verify the extraction

Add to orchestrator workflow:

parallel implementers → consolidation → critic → qa

Option B: Add cross-file duplication check to code-reviewer agent

Add an explicit step to the code-reviewer prompt:

### Cross-File Duplication Detection (REQUIRED for multi-file PRs)

For PRs touching 3+ files:
1. Identify all new methods, fields, and type definitions across changed files
2. Flag any method body or field definition that appears identically in 2+ files
3. Recommend extraction to a shared helper class
4. Severity: CRITICAL (blocks merge)

Option C: Add duplication awareness to the implementer prompt

When the implementer is spawned for a task involving parallel work, the caller should provide context about other parallel agents' scopes. Add to the implementer prompt:

### Parallel Work Awareness

When working alongside other agents on the same PR:
1. Before defining helper methods, check if a shared helper already exists (Glob for *Helper*.cs, *Utilities*.cs)
2. If you need compilation setup, test fixtures, or reference assembly configuration, check tests/*/Helpers/ first
3. Prefer importing existing helpers over defining new ones

Option D: Combination approach

• Option A for orchestrator-level enforcement
• Option C for agent-level awareness
• Option B as a safety net in PR review

Impact

Without this fix, every parallel agent workflow risks introducing O(N) duplication where N is the number of parallel agents. This violates DRY at scale and creates maintenance burden.

Related

• test: add unit tests for 16 untested Common extension methods moq.analyzers#898 (PR where this was caught)
• Add unit tests for 16 untested Common extension methods moq.analyzers#897 (issue that triggered the parallel agent work)

[traycerai]

Plan

Observations

The codebase has a sophisticated multi-agent orchestration system with parallel execution support (file:docs/orchestrator-routing-algorithm.md lines 213-236). The implementer agent contains anti-duplication guidance requiring extraction when "3+ lines appear twice...across files touched in this PR" (file:templates/agents/implementer.shared.md lines 789-790), but this rule is structurally unenforceable when multiple implementer agents run concurrently. The orchestrator workflow (file:templates/agents/orchestrator.shared.md lines 547-577) shows sequential agent chains (implementer → qa) with no post-consolidation step. PR review agents (file:.github/agents/code-reviewer.agent.md, file:.github/agents/code-simplifier.agent.md) focus on individual file quality, not cross-file duplication detection. The critic agent explicitly excludes code review (file:.github/agents/critic.agent.md line 85).

Approach

Implement a combination approach (Option D from the issue) with three defensive layers: (1) orchestrator-level consolidation phase after parallel implementer completion, (2) enhanced code-reviewer agent with explicit cross-file duplication detection, and (3) parallel work awareness in the implementer prompt. This defense-in-depth strategy addresses the root cause (parallel agent isolation) while adding safety nets at review time. The orchestrator consolidation phase is the primary enforcement mechanism, triggered automatically when multiple implementer agents complete. The code-reviewer enhancement serves as a backup detection layer during PR review. The implementer prompt update provides proactive awareness to reduce duplication at creation time.

Implementation Steps

1. Add Consolidation Phase to Orchestrator Workflow

Objective: Detect and extract duplicate code blocks after parallel implementer agents complete.

1.1 Update Orchestrator Agent Sequence Logic

Files to modify:

• file:templates/agents/orchestrator.shared.md
• file:src/vs-code-agents/orchestrator.agent.md
• file:src/copilot-cli/orchestrator.agent.md
• file:src/claude/orchestrator.md

Changes:

Add new workflow path after line 577 in the "Agent Sequences by Task Type" table:

| Task Type | Agent Sequence | Path |
|-----------|----------------|------|
| Feature (parallel implementers) | [parallel: implementer-1, implementer-2, ...] → consolidation → critic → qa | Standard (extended) |

Insert new section after line 646 (after "Impact Analysis Orchestration"):

## Consolidation Phase (Post-Parallel Implementation)

**Trigger Conditions** - Invoke consolidation when:

- 2+ implementer agents executed in parallel
- All parallel implementers completed successfully
- Combined file changes >= 3 files

**Orchestration Flow**:

1. Orchestrator collects all files created/modified by parallel implementers
2. Orchestrator spawns single implementer with consolidation flag and ALL changed files as context
3. Consolidation implementer scans for duplicate blocks (3+ identical lines in 2+ files)
4. If duplicates found: Extract to shared helper class, update all references
5. Run build + tests to verify extraction
6. If build/tests fail: Rollback extraction, document gap, proceed with warning
7. Continue to critic → qa workflow

**Consolidation Prompt Template**:

```text
CONSOLIDATION MODE: Review all files modified by parallel agents for cross-file duplication.

Files to scan: [list all files from parallel agents]

Task:
1. Identify any code block (3+ lines) appearing identically in 2+ files
2. For each duplicate:
   - Extract to shared helper class (e.g., *Helper.cs, *Utilities.cs)
   - Update all references to use the shared helper
   - Preserve all functionality
3. Run build and tests to verify
4. Report: Lines saved, files consolidated, helper classes created

Severity: CRITICAL - This is a DRY violation at scale.

Failure Handling:

Condition	Action
No duplicates found	Log "No consolidation needed", proceed to critic
Duplicates found and extracted	Log "Consolidated [N] lines across [M] files", proceed to critic
Extraction breaks build	Rollback, log gap, proceed with warning to critic
Consolidation agent times out	Log gap, proceed with partial analysis to critic

#### 1.2 Update Workflow Diagrams

**Files to modify**:
- `file:docs/diagrams/routing-flowchart.md`
- `file:docs/ideation-workflow.md`

**Changes**:

Add consolidation step to the flowchart after parallel execution groups. Update the ideation workflow Phase 4 diagram (around line 80-87) to show:

Orchestrator routes (parallel):
→ implementer-1 → returns
→ implementer-2 → returns
→ implementer-N → returns
↓
Orchestrator consolidation:
→ implementer (consolidation mode) → returns
↓
Continue to critic → qa

### 2. Enhance Code-Reviewer Agent for Cross-File Duplication Detection

**Objective**: Add explicit cross-file duplication detection as a safety net during PR review.

#### 2.1 Update Code-Reviewer Agent Prompt

**Files to modify**:
- `file:.github/agents/code-reviewer.agent.md`

**Changes**:

Insert new section after line 18 (after "Code Quality" responsibility):

```markdown
**Cross-File Duplication Detection**: For PRs touching 3+ files, scan for identical code blocks (3+ lines) appearing in multiple files. This is a CRITICAL severity issue that blocks merge.

## Cross-File Duplication Detection (REQUIRED for multi-file PRs)

**Trigger**: PR modifies or creates 3+ files

**Detection Process**:

1. Extract all new methods, fields, and type definitions from changed files
2. Compare method bodies and field definitions across all changed files
3. Flag any code block (3+ consecutive lines) appearing identically in 2+ files
4. Exclude: Comments, whitespace, import statements, trivial getters/setters

**Reporting Format**:

```markdown
### CRITICAL: Cross-File Duplication Detected

**Duplicate Block**: [Method/Field name or description]
**Appears in**:
- file:[path1]:[line-range]
- file:[path2]:[line-range]
- file:[pathN]:[line-range]

**Lines duplicated**: [N]
**Recommendation**: Extract to shared helper class at [suggested-path]

**Severity**: CRITICAL (blocks merge)
**Confidence**: 95

Pass Criteria:

• No code blocks (3+ lines) appear identically in 2+ files
• OR: Duplication is intentional and documented with justification comment

Failure Action:

Report as CRITICAL issue with confidence 95+. Recommend extraction to shared helper class with specific file path suggestion (e.g., tests/Helpers/CompilationHelper.cs for test utilities).

### 3. Add Parallel Work Awareness to Implementer Prompt

**Objective**: Proactively reduce duplication by making implementers aware of potential parallel work.

#### 3.1 Update Implementer Agent Prompt

**Files to modify**:
- `file:templates/agents/implementer.shared.md`
- `file:src/vs-code-agents/implementer.agent.md`
- `file:src/copilot-cli/implementer.agent.md`
- `file:src/claude/implementer.md`
- `file:.claude/agents/implementer.md`
- `file:.github/agents/implementer.agent.md`

**Changes**:

Insert new section after line 804 (after "Code Simplification" rules, before "Qwiq-Specific Patterns"):

```markdown
### Parallel Work Awareness

When working alongside other agents on the same PR or feature:

**Before defining helper methods, check for existing shared utilities:**

1. Search for existing helper classes:
   - Glob pattern: `*Helper*.cs`, `*Utilities*.cs`, `*Common*.cs`
   - Check directories: `tests/*/Helpers/`, `src/*/Utilities/`, `Common/`
2. If you need compilation setup, test fixtures, or reference assembly configuration:
   - Check `tests/Helpers/` or `tests/Common/` first
   - Review existing test files for established patterns
3. Prefer importing existing helpers over defining new ones
4. If creating new helper methods, consider: "Would other parallel agents need this too?"
   - If yes: Create in shared location immediately (e.g., `tests/Helpers/[Domain]Helper.cs`)
   - If no: Keep local to your file

**Consolidation awareness:**

Your work may be consolidated with other parallel agents' outputs. To minimize rework:

- Use descriptive helper class names that indicate domain (e.g., `CompilationHelper`, `ReferenceHelper`)
- Document helper methods with XML comments explaining purpose
- Keep helper methods focused and single-purpose for easier extraction

**Red flags indicating duplication risk:**

- You're creating methods like `CreateCompilation()`, `GetReferences()`, `SetupFixture()`
- You're defining `MetadataReference` fields or arrays
- You're writing boilerplate that "every test file needs"

**Action when red flag detected:**

1. Search codebase for similar method names
2. If found: Reuse existing implementation
3. If not found: Create in shared helper location, not in your test file

4. Update Review-PR Skill to Include Consolidation Check

Objective: Ensure the review-pr skill explicitly checks for cross-file duplication.

4.1 Update Review-PR Prompt

Files to modify:

• file:.github/prompts/review-pr.prompt.md

Changes:

Update the "Determine Applicable Reviews" section (around line 56-64) to add:

Based on changes:
- **Always applicable**: code-reviewer (general quality + cross-file duplication check)
- **If 3+ files changed**: code-reviewer MUST check for cross-file duplication
- **If test files changed**: pr-test-analyzer
- **If comments/docs added**: comment-analyzer
- **If error handling changed**: silent-failure-hunter
- **If types added/modified**: type-design-analyzer
- **After passing review**: code-simplifier (polish and refine)

Update the "Agent Descriptions" section for code-reviewer (around line 166-170):

**code-reviewer**:

- Checks copilot-instructions.md and AGENTS.md compliance
- Detects bugs and issues
- Reviews general code quality
- **CRITICAL**: Scans for cross-file duplication in multi-file PRs (3+ files)
- Blocks merge on duplicate code blocks (3+ lines in 2+ files)

5. Create Consolidation Detection Script (Optional Enhancement)

Objective: Provide automated tooling to detect cross-file duplication.

5.1 Create PowerShell Script

New file: file:scripts/Detect-CrossFileDuplication.ps1

Content outline:

5.2 Integrate into CI Workflow

Files to modify:

• file:.github/workflows/pr-validation.yml (if exists)

Changes:

Add step to PR validation workflow:

- name: Detect Cross-File Duplication
  run: |
    $files = git diff --name-only origin/main...HEAD
    if ($files.Count -ge 3) {
      pwsh scripts/Detect-CrossFileDuplication.ps1 -Files $files
    }
  shell: pwsh

6. Update Documentation

Objective: Document the new consolidation workflow and duplication detection process.

6.1 Update Orchestrator Documentation

Files to modify:

• file:docs/orchestrator-routing-algorithm.md

Changes:

Add new section after line 271 (after "Execution Rules"):

### Consolidation Rules

| Pattern | Execution | Reason |
|---------|-----------|--------|
| parallel implementers → consolidation | Serial | Consolidation needs all outputs |
| consolidation → critic | Serial | Critic validates consolidated result |
| consolidation (no duplicates) → critic | Serial | Skip extraction, proceed to validation |

6.2 Create Consolidation Workflow Guide

New file: file:docs/consolidation-workflow.md

Content outline:

# Consolidation Workflow for Parallel Agent Execution

## Purpose

When multiple implementer agents run in parallel, each agent works in isolation and cannot see what others are creating. This can lead to duplicate code blocks across files. The consolidation phase detects and extracts these duplicates after parallel execution completes.

## When Consolidation Triggers

- 2+ implementer agents executed in parallel
- All parallel implementers completed successfully
- Combined file changes >= 3 files

## Consolidation Process

[Detailed workflow with examples]

## Example: Test Helper Consolidation

[Real example from moq.analyzers PR #898]

## Troubleshooting

[Common issues and solutions]

6.3 Update Agent Catalog

Files to modify:

• file:src/claude/AGENTS.md
• file:templates/AGENTS.md

Changes:

Update the orchestrator agent description to mention consolidation phase:

**orchestrator**: Coordinates multi-agent workflows. Routes tasks to specialized agents, synthesizes outputs, resolves conflicts. **NEW**: Automatically triggers consolidation phase after parallel implementer execution to detect and extract cross-file duplication.

7. Add Memory Patterns for Consolidation

Objective: Store consolidation patterns for future reference.

7.1 Create Memory Template

New file: file:.serena/memories/agent-workflow/consolidation-patterns.md

Content outline:

# Consolidation Patterns

## Common Duplication Scenarios

### Test Boilerplate Duplication

**Pattern**: Multiple test files create identical compilation helpers
**Solution**: Extract to `tests/Helpers/CompilationHelper.cs`
**Example**: moq.analyzers PR #898

### Reference Assembly Duplication

**Pattern**: Multiple files define same MetadataReference fields
**Solution**: Centralize in `tests/Helpers/ReferenceHelper.cs`

## Consolidation Heuristics

- Method names containing "Create", "Setup", "Initialize" are high-risk for duplication
- Fields of type `MetadataReference`, `Compilation`, `Fixture` often duplicated
- Helper methods >10 lines appearing in 2+ files should be extracted

## Extraction Naming Conventions

- Test helpers: `tests/Helpers/[Domain]Helper.cs`
- Utilities: `src/[Project]/Utilities/[Domain]Utilities.cs`
- Common: `src/Common/[Domain]Common.cs`

8. Testing and Validation

Objective: Verify the consolidation workflow works correctly.

8.1 Create Test Scenario

Approach:

1. Manually create a test PR with intentional duplication across 3+ files
2. Trigger orchestrator with parallel implementer agents
3. Verify consolidation phase detects duplicates
4. Verify extraction creates shared helper class
5. Verify build and tests pass after consolidation
6. Verify code-reviewer agent catches any remaining duplicates

8.2 Update Orchestrator Tests

Files to modify:

• file:tests/test_orchestrate_sh.py (if exists)
• file:tests/eval_orchestrator_step35.py (if exists)

Changes:

Add test cases for consolidation workflow:

def test_consolidation_triggered_after_parallel_implementers():
    # Verify consolidation phase invoked when 2+ implementers complete
    pass

def test_consolidation_detects_duplicate_blocks():
    # Verify duplicate detection logic works
    pass

def test_consolidation_extracts_to_helper_class():
    # Verify extraction creates correct helper class
    pass

Sequence Diagram

sequenceDiagram
    participant O as Orchestrator
    participant I1 as Implementer-1
    participant I2 as Implementer-2
    participant C as Consolidation<br/>Implementer
    participant CR as Critic
    participant QA as QA Agent
    participant REV as Code-Reviewer

    Note over O: Parallel work detected<br/>(e.g., write tests for<br/>5 extension methods)
    
    O->>I1: Implement tests for methods 1-2
    O->>I2: Implement tests for methods 3-5
    
    par Parallel Execution
        I1->>I1: Create test file 1<br/>+ CompilationHelper boilerplate
        I2->>I2: Create test files 2-3<br/>+ CompilationHelper boilerplate
    end
    
    I1-->>O: Complete (2 files)
    I2-->>O: Complete (3 files)
    
    Note over O: Consolidation trigger:<br/>2+ implementers, 5 files total
    
    O->>C: Consolidate files:<br/>[file1, file2, file3, file4, file5]
    
    C->>C: Scan for duplicates<br/>(3+ identical lines)
    
    Note over C: Found: CompilationHelper<br/>methods duplicated<br/>across 5 files
    
    C->>C: Extract to<br/>tests/Helpers/CompilationHelper.cs
    C->>C: Update all 5 files<br/>to use shared helper
    C->>C: Run build + tests
    
    alt Build/Tests Pass
        C-->>O: Consolidated: 287 lines saved
        O->>CR: Review (standard workflow)
        CR->>CR: Check cross-file duplication
        CR-->>O: PASS (no duplicates found)
        O->>QA: Verify tests
        QA-->>O: QA COMPLETE
    else Build/Tests Fail
        C-->>O: Consolidation failed, rollback
        O->>CR: Review with warning
        CR->>CR: Check cross-file duplication
        CR-->>O: CRITICAL: Duplicates detected
        Note over O: Manual intervention required
    end

Loading

Success Criteria

1. Orchestrator consolidation phase:

   • Automatically triggers when 2+ implementer agents complete with 3+ total files
   • Successfully detects duplicate blocks (3+ identical lines in 2+ files)
   • Extracts duplicates to shared helper classes
   • Verifies extraction with build + tests

2. Code-reviewer enhancement:

   • Explicitly checks for cross-file duplication in PRs with 3+ files
   • Reports duplicates as CRITICAL severity with confidence 95+
   • Provides specific extraction recommendations

3. Implementer awareness:

   • Prompts implementers to check for existing helpers before creating new ones
   • Encourages creation of shared helpers when duplication risk is high
   • Documents red flags for duplication scenarios

4. Documentation:

   • Consolidation workflow documented in file:docs/consolidation-workflow.md
   • Orchestrator routing algorithm updated with consolidation rules
   • Memory patterns captured for future reference

5. Validation:

   • Test scenario demonstrates consolidation workflow end-to-end
   • No regression in existing orchestrator workflows
   • Code-reviewer successfully catches duplicates in test PRs

Import In IDE

🤖 Prompt for AI Agents

## Observations

The codebase has a sophisticated multi-agent orchestration system with parallel execution support (`file:docs/orchestrator-routing-algorithm.md` lines 213-236). The implementer agent contains anti-duplication guidance requiring extraction when "3+ lines appear twice...across files touched in this PR" (`file:templates/agents/implementer.shared.md` lines 789-790), but this rule is structurally unenforceable when multiple implementer agents run concurrently. The orchestrator workflow (`file:templates/agents/orchestrator.shared.md` lines 547-577) shows sequential agent chains (implementer → qa) with no post-consolidation step. PR review agents (`file:.github/agents/code-reviewer.agent.md`, `file:.github/agents/code-simplifier.agent.md`) focus on individual file quality, not cross-file duplication detection. The critic agent explicitly excludes code review (`file:.github/agents/critic.agent.md` line 85).

## Approach

Implement a **combination approach** (Option D from the issue) with three defensive layers: (1) orchestrator-level consolidation phase after parallel implementer completion, (2) enhanced code-reviewer agent with explicit cross-file duplication detection, and (3) parallel work awareness in the implementer prompt. This defense-in-depth strategy addresses the root cause (parallel agent isolation) while adding safety nets at review time. The orchestrator consolidation phase is the primary enforcement mechanism, triggered automatically when multiple implementer agents complete. The code-reviewer enhancement serves as a backup detection layer during PR review. The implementer prompt update provides proactive awareness to reduce duplication at creation time.

## Implementation Steps

### 1. Add Consolidation Phase to Orchestrator Workflow

**Objective**: Detect and extract duplicate code blocks after parallel implementer agents complete.

#### 1.1 Update Orchestrator Agent Sequence Logic

**Files to modify**:
- `file:templates/agents/orchestrator.shared.md`
- `file:src/vs-code-agents/orchestrator.agent.md`
- `file:src/copilot-cli/orchestrator.agent.md`
- `file:src/claude/orchestrator.md`

**Changes**:

Add new workflow path after line 577 in the "Agent Sequences by Task Type" table:

```markdown
| Task Type | Agent Sequence | Path |
|-----------|----------------|------|
| Feature (parallel implementers) | [parallel: implementer-1, implementer-2, ...] → consolidation → critic → qa | Standard (extended) |
```

Insert new section after line 646 (after "Impact Analysis Orchestration"):

```markdown
## Consolidation Phase (Post-Parallel Implementation)

**Trigger Conditions** - Invoke consolidation when:

- 2+ implementer agents executed in parallel
- All parallel implementers completed successfully
- Combined file changes >= 3 files

**Orchestration Flow**:

1. Orchestrator collects all files created/modified by parallel implementers
2. Orchestrator spawns single implementer with consolidation flag and ALL changed files as context
3. Consolidation implementer scans for duplicate blocks (3+ identical lines in 2+ files)
4. If duplicates found: Extract to shared helper class, update all references
5. Run build + tests to verify extraction
6. If build/tests fail: Rollback extraction, document gap, proceed with warning
7. Continue to critic → qa workflow

**Consolidation Prompt Template**:

```text
CONSOLIDATION MODE: Review all files modified by parallel agents for cross-file duplication.

Files to scan: [list all files from parallel agents]

Task:
1. Identify any code block (3+ lines) appearing identically in 2+ files
2. For each duplicate:
   - Extract to shared helper class (e.g., *Helper.cs, *Utilities.cs)
   - Update all references to use the shared helper
   - Preserve all functionality
3. Run build and tests to verify
4. Report: Lines saved, files consolidated, helper classes created

Severity: CRITICAL - This is a DRY violation at scale.
```

**Failure Handling**:

| Condition | Action |
|-----------|--------|
| No duplicates found | Log "No consolidation needed", proceed to critic |
| Duplicates found and extracted | Log "Consolidated [N] lines across [M] files", proceed to critic |
| Extraction breaks build | Rollback, log gap, proceed with warning to critic |
| Consolidation agent times out | Log gap, proceed with partial analysis to critic |
```

#### 1.2 Update Workflow Diagrams

**Files to modify**:
- `file:docs/diagrams/routing-flowchart.md`
- `file:docs/ideation-workflow.md`

**Changes**:

Add consolidation step to the flowchart after parallel execution groups. Update the ideation workflow Phase 4 diagram (around line 80-87) to show:

```
Orchestrator routes (parallel):
  → implementer-1 → returns
  → implementer-2 → returns
  → implementer-N → returns
  ↓
Orchestrator consolidation:
  → implementer (consolidation mode) → returns
  ↓
Continue to critic → qa
```

### 2. Enhance Code-Reviewer Agent for Cross-File Duplication Detection

**Objective**: Add explicit cross-file duplication detection as a safety net during PR review.

#### 2.1 Update Code-Reviewer Agent Prompt

**Files to modify**:
- `file:.github/agents/code-reviewer.agent.md`

**Changes**:

Insert new section after line 18 (after "Code Quality" responsibility):

```markdown
**Cross-File Duplication Detection**: For PRs touching 3+ files, scan for identical code blocks (3+ lines) appearing in multiple files. This is a CRITICAL severity issue that blocks merge.

## Cross-File Duplication Detection (REQUIRED for multi-file PRs)

**Trigger**: PR modifies or creates 3+ files

**Detection Process**:

1. Extract all new methods, fields, and type definitions from changed files
2. Compare method bodies and field definitions across all changed files
3. Flag any code block (3+ consecutive lines) appearing identically in 2+ files
4. Exclude: Comments, whitespace, import statements, trivial getters/setters

**Reporting Format**:

```markdown
### CRITICAL: Cross-File Duplication Detected

**Duplicate Block**: [Method/Field name or description]
**Appears in**:
- file:[path1]:[line-range]
- file:[path2]:[line-range]
- file:[pathN]:[line-range]

**Lines duplicated**: [N]
**Recommendation**: Extract to shared helper class at [suggested-path]

**Severity**: CRITICAL (blocks merge)
**Confidence**: 95
```

**Pass Criteria**:

- No code blocks (3+ lines) appear identically in 2+ files
- OR: Duplication is intentional and documented with justification comment

**Failure Action**:

Report as CRITICAL issue with confidence 95+. Recommend extraction to shared helper class with specific file path suggestion (e.g., `tests/Helpers/CompilationHelper.cs` for test utilities).
```

### 3. Add Parallel Work Awareness to Implementer Prompt

**Objective**: Proactively reduce duplication by making implementers aware of potential parallel work.

#### 3.1 Update Implementer Agent Prompt

**Files to modify**:
- `file:templates/agents/implementer.shared.md`
- `file:src/vs-code-agents/implementer.agent.md`
- `file:src/copilot-cli/implementer.agent.md`
- `file:src/claude/implementer.md`
- `file:.claude/agents/implementer.md`
- `file:.github/agents/implementer.agent.md`

**Changes**:

Insert new section after line 804 (after "Code Simplification" rules, before "Qwiq-Specific Patterns"):

```markdown
### Parallel Work Awareness

When working alongside other agents on the same PR or feature:

**Before defining helper methods, check for existing shared utilities:**

1. Search for existing helper classes:
   - Glob pattern: `*Helper*.cs`, `*Utilities*.cs`, `*Common*.cs`
   - Check directories: `tests/*/Helpers/`, `src/*/Utilities/`, `Common/`
2. If you need compilation setup, test fixtures, or reference assembly configuration:
   - Check `tests/Helpers/` or `tests/Common/` first
   - Review existing test files for established patterns
3. Prefer importing existing helpers over defining new ones
4. If creating new helper methods, consider: "Would other parallel agents need this too?"
   - If yes: Create in shared location immediately (e.g., `tests/Helpers/[Domain]Helper.cs`)
   - If no: Keep local to your file

**Consolidation awareness:**

Your work may be consolidated with other parallel agents' outputs. To minimize rework:

- Use descriptive helper class names that indicate domain (e.g., `CompilationHelper`, `ReferenceHelper`)
- Document helper methods with XML comments explaining purpose
- Keep helper methods focused and single-purpose for easier extraction

**Red flags indicating duplication risk:**

- You're creating methods like `CreateCompilation()`, `GetReferences()`, `SetupFixture()`
- You're defining `MetadataReference` fields or arrays
- You're writing boilerplate that "every test file needs"

**Action when red flag detected:**

1. Search codebase for similar method names
2. If found: Reuse existing implementation
3. If not found: Create in shared helper location, not in your test file
```

### 4. Update Review-PR Skill to Include Consolidation Check

**Objective**: Ensure the review-pr skill explicitly checks for cross-file duplication.

#### 4.1 Update Review-PR Prompt

**Files to modify**:
- `file:.github/prompts/review-pr.prompt.md`

**Changes**:

Update the "Determine Applicable Reviews" section (around line 56-64) to add:

```markdown
Based on changes:
- **Always applicable**: code-reviewer (general quality + cross-file duplication check)
- **If 3+ files changed**: code-reviewer MUST check for cross-file duplication
- **If test files changed**: pr-test-analyzer
- **If comments/docs added**: comment-analyzer
- **If error handling changed**: silent-failure-hunter
- **If types added/modified**: type-design-analyzer
- **After passing review**: code-simplifier (polish and refine)
```

Update the "Agent Descriptions" section for code-reviewer (around line 166-170):

```markdown
**code-reviewer**:

- Checks copilot-instructions.md and AGENTS.md compliance
- Detects bugs and issues
- Reviews general code quality
- **CRITICAL**: Scans for cross-file duplication in multi-file PRs (3+ files)
- Blocks merge on duplicate code blocks (3+ lines in 2+ files)
```

### 5. Create Consolidation Detection Script (Optional Enhancement)

**Objective**: Provide automated tooling to detect cross-file duplication.

#### 5.1 Create PowerShell Script

**New file**: `file:scripts/Detect-CrossFileDuplication.ps1`

**Content outline**:

```powershell
```

#### 5.2 Integrate into CI Workflow

**Files to modify**:
- `file:.github/workflows/pr-validation.yml` (if exists)

**Changes**:

Add step to PR validation workflow:

```yaml
- name: Detect Cross-File Duplication
  run: |
    $files = git diff --name-only origin/main...HEAD
    if ($files.Count -ge 3) {
      pwsh scripts/Detect-CrossFileDuplication.ps1 -Files $files
    }
  shell: pwsh
```

### 6. Update Documentation

**Objective**: Document the new consolidation workflow and duplication detection process.

#### 6.1 Update Orchestrator Documentation

**Files to modify**:
- `file:docs/orchestrator-routing-algorithm.md`

**Changes**:

Add new section after line 271 (after "Execution Rules"):

```markdown
### Consolidation Rules

| Pattern | Execution | Reason |
|---------|-----------|--------|
| parallel implementers → consolidation | Serial | Consolidation needs all outputs |
| consolidation → critic | Serial | Critic validates consolidated result |
| consolidation (no duplicates) → critic | Serial | Skip extraction, proceed to validation |
```

#### 6.2 Create Consolidation Workflow Guide

**New file**: `file:docs/consolidation-workflow.md`

**Content outline**:

```markdown
# Consolidation Workflow for Parallel Agent Execution

## Purpose

When multiple implementer agents run in parallel, each agent works in isolation and cannot see what others are creating. This can lead to duplicate code blocks across files. The consolidation phase detects and extracts these duplicates after parallel execution completes.

## When Consolidation Triggers

- 2+ implementer agents executed in parallel
- All parallel implementers completed successfully
- Combined file changes >= 3 files

## Consolidation Process

[Detailed workflow with examples]

## Example: Test Helper Consolidation

[Real example from moq.analyzers PR #898]

## Troubleshooting

[Common issues and solutions]
```

#### 6.3 Update Agent Catalog

**Files to modify**:
- `file:src/claude/AGENTS.md`
- `file:templates/AGENTS.md`

**Changes**:

Update the orchestrator agent description to mention consolidation phase:

```markdown
**orchestrator**: Coordinates multi-agent workflows. Routes tasks to specialized agents, synthesizes outputs, resolves conflicts. **NEW**: Automatically triggers consolidation phase after parallel implementer execution to detect and extract cross-file duplication.
```

### 7. Add Memory Patterns for Consolidation

**Objective**: Store consolidation patterns for future reference.

#### 7.1 Create Memory Template

**New file**: `file:.serena/memories/agent-workflow/consolidation-patterns.md`

**Content outline**:

```markdown
# Consolidation Patterns

## Common Duplication Scenarios

### Test Boilerplate Duplication

**Pattern**: Multiple test files create identical compilation helpers
**Solution**: Extract to `tests/Helpers/CompilationHelper.cs`
**Example**: moq.analyzers PR #898

### Reference Assembly Duplication

**Pattern**: Multiple files define same MetadataReference fields
**Solution**: Centralize in `tests/Helpers/ReferenceHelper.cs`

## Consolidation Heuristics

- Method names containing "Create", "Setup", "Initialize" are high-risk for duplication
- Fields of type `MetadataReference`, `Compilation`, `Fixture` often duplicated
- Helper methods >10 lines appearing in 2+ files should be extracted

## Extraction Naming Conventions

- Test helpers: `tests/Helpers/[Domain]Helper.cs`
- Utilities: `src/[Project]/Utilities/[Domain]Utilities.cs`
- Common: `src/Common/[Domain]Common.cs`
```

### 8. Testing and Validation

**Objective**: Verify the consolidation workflow works correctly.

#### 8.1 Create Test Scenario

**Approach**:

1. Manually create a test PR with intentional duplication across 3+ files
2. Trigger orchestrator with parallel implementer agents
3. Verify consolidation phase detects duplicates
4. Verify extraction creates shared helper class
5. Verify build and tests pass after consolidation
6. Verify code-reviewer agent catches any remaining duplicates

#### 8.2 Update Orchestrator Tests

**Files to modify**:
- `file:tests/test_orchestrate_sh.py` (if exists)
- `file:tests/eval_orchestrator_step35.py` (if exists)

**Changes**:

Add test cases for consolidation workflow:

```python
def test_consolidation_triggered_after_parallel_implementers():
    # Verify consolidation phase invoked when 2+ implementers complete
    pass

def test_consolidation_detects_duplicate_blocks():
    # Verify duplicate detection logic works
    pass

def test_consolidation_extracts_to_helper_class():
    # Verify extraction creates correct helper class
    pass
```

## Sequence Diagram

```mermaid
sequenceDiagram
    participant O as Orchestrator
    participant I1 as Implementer-1
    participant I2 as Implementer-2
    participant C as Consolidation<br/>Implementer
    participant CR as Critic
    participant QA as QA Agent
    participant REV as Code-Reviewer

    Note over O: Parallel work detected<br/>(e.g., write tests for<br/>5 extension methods)
    
    O->>I1: Implement tests for methods 1-2
    O->>I2: Implement tests for methods 3-5
    
    par Parallel Execution
        I1->>I1: Create test file 1<br/>+ CompilationHelper boilerplate
        I2->>I2: Create test files 2-3<br/>+ CompilationHelper boilerplate
    end
    
    I1-->>O: Complete (2 files)
    I2-->>O: Complete (3 files)
    
    Note over O: Consolidation trigger:<br/>2+ implementers, 5 files total
    
    O->>C: Consolidate files:<br/>[file1, file2, file3, file4, file5]
    
    C->>C: Scan for duplicates<br/>(3+ identical lines)
    
    Note over C: Found: CompilationHelper<br/>methods duplicated<br/>across 5 files
    
    C->>C: Extract to<br/>tests/Helpers/CompilationHelper.cs
    C->>C: Update all 5 files<br/>to use shared helper
    C->>C: Run build + tests
    
    alt Build/Tests Pass
        C-->>O: Consolidated: 287 lines saved
        O->>CR: Review (standard workflow)
        CR->>CR: Check cross-file duplication
        CR-->>O: PASS (no duplicates found)
        O->>QA: Verify tests
        QA-->>O: QA COMPLETE
    else Build/Tests Fail
        C-->>O: Consolidation failed, rollback
        O->>CR: Review with warning
        CR->>CR: Check cross-file duplication
        CR-->>O: CRITICAL: Duplicates detected
        Note over O: Manual intervention required
    end
```

## Success Criteria

1. **Orchestrator consolidation phase**:
   - Automatically triggers when 2+ implementer agents complete with 3+ total files
   - Successfully detects duplicate blocks (3+ identical lines in 2+ files)
   - Extracts duplicates to shared helper classes
   - Verifies extraction with build + tests

2. **Code-reviewer enhancement**:
   - Explicitly checks for cross-file duplication in PRs with 3+ files
   - Reports duplicates as CRITICAL severity with confidence 95+
   - Provides specific extraction recommendations

3. **Implementer awareness**:
   - Prompts implementers to check for existing helpers before creating new ones
   - Encourages creation of shared helpers when duplication risk is high
   - Documents red flags for duplication scenarios

4. **Documentation**:
   - Consolidation workflow documented in `file:docs/consolidation-workflow.md`
   - Orchestrator routing algorithm updated with consolidation rules
   - Memory patterns captured for future reference

5. **Validation**:
   - Test scenario demonstrates consolidation workflow end-to-end
   - No regression in existing orchestrator workflows
   - Code-reviewer successfully catches duplicates in test PRs

---

Execution Information

Branch: main
Commit: 08e50ad

---

💡 Tips

Supported Commands (Inside Comments)

• Use @traycerai generate to iterate on the previous version of the implementation plan.

Supported Commands (Inside Description)

• Add @traycerai ignore anywhere in the ticket description to prevent this ticket from being processed.
• Add @traycerai branch:<branch-name> anywhere in the ticket description to specify the target branch for the implementation plan.

Community

• Join our Discord Community to get help, request features, and share feedback.
• Follow us on X/Twitter for updates and announcements.

[rjmurillo]

Velocity Accelerator: 2 Opportunities Detected

Triage issue #1187: feat(implementer): add cross-file duplication detection for

• Type: complexity_triage
• Priority: high
• Suggested Agent: agent-security
• Issue labeled with high complexity.
  Suggested agents: agent-security, agent-architect, agent-devops, agent-implementer, agent-qa

Route issue #1187 to agent-security, agent-architect, agent-devops, agent-implementer, agent-qa

• Type: agent_routing
• Priority: low
• Suggested Agent: agent-security
• Issue content suggests routing to: agent-security, agent-architect, agent-devops, agent-implementer, agent-qa
  Complexity: high

[coderabbitai]

🔗 Related PRs

#301 - docs: autonomous PR monitoring prompt and retrospective [merged]
#466 - feat(prompts): add context-aware evaluation to AI Quality Gate prompts [merged]
#467 - feat(agents): add BLOCKING gate for automatic ADR review [merged]
#534 - docs(agent-system): formalize parallel execution pattern [merged]
#562 - feat(qa): add mandatory pre-PR quality gate enforcement [merged]

---

📝 Issue Planner

_{Check the box below or use the @coderabbitai plan command to generate an implementation plan and prompts that you can use with your favorite coding assistant.}

• Create Plan

---

🧪 Issue enrichment is currently in open beta.

You can configure auto-planning by selecting labels in the issue_enrichment configuration.

To disable automatic issue enrichment, add the following to your .coderabbit.yaml:

issue_enrichment:
  auto_enrich:
    enabled: false

💬 Have feedback or questions? Drop into our discord!