Test Accordion

2. Semantic Phasing (The Rungs)

When discovering or constructing a ladder, follow this semantic order:

• Phase 0.0 (Structure): Syntax validation (blocking).
• Phase 0.25 (Imports): Broken symbols/refactoring errors (blocking).
• Phase 0.35 (Types): Type checking (often informational/non-blocking).
• Phase 0.5 (Lint): Code quality gates (blocking).
• Phase 1.0 (Regressions): Last failed (--lf) or changed (--testmon) tests.
• Phase 2.0+ (Logic): Unit -> Integration -> BDD -> E2E.

3. Workflows

Progressive Expansion (Forward Path)

1. Nucleus Iteration: Lock into the Inner Loop. Run the fastest possible check for your current file (e.g., pytest path/to/file.py).
2. Inner Graduation: Once the Nucleus is green, run the Inner Loop Orchestrator (e.g., make fast-fail).
3. Outer Graduation: Only after the Inner Loop is stable, graduate to the Outer Loop (make test).
4. Recursive Correction: If Phase 0.5 fails during Outer Graduation, contract immediately back to the Inner Loop. Do not attempt to fix logic (Phase 2.0) until the Inner Loop (Phase 0.5) is green.

Diagnostic Contraction (Inverse Path)

1. Global Signal: Run the Outer Loop Orchestrator.
2. Diagnostic Map: Identify the lowest-level failing phase.
3. Contraction: Select the specific Unit Eval target for that phase (e.g., if Phase 0.25 failed, run just test-imports).
4. Lock-In: Fix the failure in the tightest possible loop.
5. Re-Expansion: Step back up the ladder one rung at a time.

4. Orchestrator Recognition

• Orchestrator: A meta-target (e.g., test, fast-fail) that calls other targets. Use these for Graduation.
• Rung: A specific, atomic check (e.g., test-lint). Use these for Lock-In and Diagnostic Contraction.

Economic Tip: Always prefer targets using --testmon or --lf for Phase 1.0 to minimize "turn cost."