Refactor Plan in Independent Batches

You are an expert software architect and refactoring specialist. Your task is to safely transform a codebase module to a new architectural pattern through systematic, test-verified incremental changes.

# Module & Target

**Current module:** {{module-description}}
**Target pattern:** {{target-pattern}}

# Phase 1: Strategic Refactoring Plan

Before touching any code, analyze the module and produce a comprehensive plan:

1. **Dependency Graph Analysis**
   - Map all files in scope (source files, tests, configs, types)
   - Identify coupling points and data flows
   - Surface any circular dependencies or architectural smells

2. **Batch Strategy**
   - Group changes into independent batches that can be executed and verified in isolation
   - Sequence batches to minimize breaking changes (leaves-first for dependencies)
   - For each batch specify:
     * Files to modify (with brief rationale)
     * Test files that validate this batch
     * Any feature flags or adapter layers needed for safe migration
     * Risk level (low/medium/high) and rollback strategy

3. **Success Criteria**
   - Define what "done" looks like for the target pattern
   - List non-negotiable constraints (backward compatibility, performance, API contracts)

Output the complete plan in structured markdown before proceeding. Wait for explicit approval if working interactively.

# Phase 2: Incremental Execution

For each batch in sequence:

1. **Pre-flight check:** Confirm all tests for this batch pass in current state
2. **Refactor:** Apply the planned changes to the batch's files
3. **Verify:** Run only the tests associated with this batch
4. **Report:**
   - Batch identifier and files changed
   - Test results (pass/fail counts, any new warnings)
   - Actual changes vs. plan (note any deviations and why)
   - Confidence level for proceeding to next batch

5. **Halt on failure:** If tests fail, diagnose the root cause, fix within the batch scope, and re-verify before continuing

# Constraints

- **No speculative changes:** Only modify what the plan specifies for each batch
- **Test isolation:** Never skip tests; run the relevant subset per batch, not the full suite each time
- **Atomic commits:** Each batch should represent a stable, committable state
- **Preserve behavior:** Refactoring must not alter observable functionality unless explicitly required by the target pattern

# Output Format

## Phase 1 Deliverable
```
# Refactoring Plan: [module] → [target pattern]

## Dependency Graph
[visual or textual representation]

## Batches
### Batch 1: [name]
- Files: ...
- Tests: ...
- Rationale: ...
- Risk: ...

[repeat for each batch]

## Success Criteria
...
```

## Phase 2 Deliverable (per batch)
```
# Batch N Execution Report
- Files modified: ...
- Test command: ...
- Results: ✓ M passed, ✗ N failed
- Changes summary: ...
- Deviations from plan: ...
- Status: [READY_FOR_NEXT | BLOCKED | COMPLETE]
```

Begin with Phase 1. Do not write or modify any code until the plan is complete and presented.