enrich-phase-plan

Enrich Phase Plan

Takes an approved high-level plan document and produces a detailed, executor-ready TOML implementation plan by running a pipeline of specialized agents over it.

Pipeline

fortran-architect (elaborate)
       ↓
plan-decomposer (break down into TOML)
       ↓
impl-plan-reviewer (review)
       ↓ [loop if Needs More Detail]
plan-decomposer (revise)
       ↓
dry-run compile (validate)
       ↓ [loop if fails, max 2]
fortran-architect (final review)

Step 1 — Identify the plan file

Ask the user for the path to the existing plan file if not already provided. Read it before proceeding.

Step 1.5 — Load deferred improvements and failure patterns (optional)

Deferred improvements: Search for deferred improvement files from prior phases:

fd deferred.md notes/pr-reviews/

If any are found, read them and include their contents in the fortran-architect elaboration prompt (Step 2) as additional context. This gives the architect visibility into improvements that were explicitly deferred — some may now be relevant to include.

Cross-round failure patterns: Search for fix plans from prior phases:

fd fix-plan.toml notes/pr-reviews/ | head -3

If any are found, read them and extract recurring issue categories. Look for patterns such as:

• Missing use ModuleName statements (module wiring)
• Missing public :: declarations for symbols needed by other modules
• Incomplete consumer updates (module created but never used)
• Stale use statements after refactoring
• Cross-module integration failures (subroutine placed in wrong module)

Summarize the recurring categories as KNOWN_FAILURE_MODES. These will be passed to the plan-decomposer in Step 3 as proactive checks.

If no fix plans or deferred files exist, proceed without this context.

Step 2 — fortran-architect elaboration

Invoke the fortran-dev-pipeline:fortran-architect agent with this prompt:

You are reviewing the following implementation plan for the NEXT phase of work on a Fortran scientific codebase.

<plan>
{{PLAN_FILE_CONTENTS}}
</plan>

<deferred_improvements>
{{DEFERRED_CONTENTS — or "None" if no deferred.md files were found}}
</deferred_improvements>

Your job:
1. Identify what the next phase is trying to achieve.
2. Elaborate on implementation details that are underspecified — concrete subroutine signatures, INTENT declarations, MODULE locations, KIND parameters, error handling strategy (IOSTAT/STAT patterns).
3. Call out architectural cautions: numerical stability pitfalls, interface mismatches, module boundary violations, API surface decisions that are hard to reverse, places where the plan may conflict with Fortran idioms or the project's established patterns.
4. **Use LSP tools** to understand the current codebase state:
   - Use `LSP documentSymbol` to locate existing modules/subroutines mentioned in the plan
   - Use `LSP hover` to verify current subroutine signatures before proposing changes
   - Use `LSP references` to understand how existing subroutines are called
   - Use `LSP definition` to navigate to type/interface definitions
   - Check `LSP diagnostics` to identify any existing issues that might affect the plan
5. Do NOT decompose into tasks. Output a single enriched narrative that a plan-decomposer agent can use as input.