create-universal-ai-context 2.5.0 → 2.6.0-final

package/templates/base/commands/rpi-implement.md

@@ -1,115 +1,164 @@
----
-name: rpi-implement
-version: "1.0.0"
-description: "RPI Implement Phase: Execute plan with atomic changes and continuous testing"
-category: "rpi-orchestration"
-rpi_phase: "implement"
-context_budget_estimate: "60K tokens"
-typical_context_usage: "30%"
-prerequisites:
-  - "Plan document exists in .ai-context/plans/active/"
-  - "Plan has been approved by human"
-  - "Git branch is clean"
-  - "All tests currently passing"
-outputs:
-  - "Implemented feature/fix"
-  - "Updated documentation with new line numbers"
-  - "Commits with descriptive messages"
-  - "Archived plan in .ai-context/plans/completed/"
-next_commands: ["/verify-docs-current", "/validate-all"]
-related_agents: ["core-architect", "database-ops", "api-developer", "deployment-ops"]
-examples:
-  - command: "/rpi-implement user-authentication"
-    description: "Execute the approved authentication plan"
-  - command: "/rpi-implement payment-bug-fix"
-    description: "Implement the approved bug fix"
-exit_criteria:
-  - "All plan steps completed"
-  - "All tests passing"
-  - "Documentation updated"
-  - "Changes committed"
-  - "Plan archived to completed/"
----
-
-# RPI Implement Phase
-
-**Purpose:** Execute implementation plan atomically
-
-**Syntax:** `/rpi-implement [feature-name]`
-
-**Prerequisites:** Plan must be approved in `.ai-context/plans/active/`
-
----
-
-## Golden Rule
-
-```
-ONE CHANGE → ONE TEST → ONE COMMIT
-```
-
----
-
-## Execution Steps
-
-### Step 1: Load Plan
-Read `.ai-context/plans/active/[feature]_plan.md`
-
-### Step 2: Verify Preconditions
-- [ ] Plan is approved
-- [ ] Branch is clean
-- [ ] Tests pass before changes
-
-### Step 3: Execute Each Step
-For each step in plan:
-1. Make the single, atomic change
-2. Run step-specific test
-3. If pass: commit with descriptive message
-4. If fail: stop, investigate, do not proceed
-
-### Step 4: Context Reset (Every 3 Steps)
-1. Update progress in plan
-2. Re-read plan document
-3. Verify scope alignment
-4. Compact if >35% context usage
-
-### Step 5: Run Full Test Suite
-After all steps complete
-
-### Step 6: Update Documentation (MANDATORY)
-1. Check CODE_TO_WORKFLOW_MAP.md
-2. Update affected workflow files
-3. Update line numbers
-4. Run /verify-docs-current
-
-### Step 7: Final Commit
-Documentation updates
-
-### Step 8: Archive Plan
-Move to `.ai-context/plans/completed/`
-
----
-
-## Error Recovery
-
-| Error Type | Action |
-|------------|--------|
-| Syntax Error | Fix immediately |
-| Test Failure | Stop, investigate |
-| 3+ Failures | Compact, start new session |
-
----
-
-## Context Budget
-
-- Plan: 15k tokens
-- Active code: 30k tokens
-- Test results: 15k tokens
-- Total: 60k tokens (30%)
-
----
-
-## Output
-
-- Completed feature/fix
-- Updated documentation
-- Plan archived to completed/
+---
+name: rpi-implement
+version: "2.0.0"
+description: "RPI Implement Phase: Execute chunk-based todolists with atomic changes and continuous testing"
+category: "rpi-orchestration"
+rpi_phase: "implement"
+context_budget_estimate: "60K tokens"
+typical_context_usage: "30%"
+chunk_input: true
+loop_based: true
+inter_phase_aware: true
+prerequisites:
+  - "Plan document exists in .ai-context/plans/active/"
+  - "Plan has been approved by human"
+  - "Plan contains chunk manifest with chunk-todolists"
+  - "Git branch is clean"
+  - "All tests currently passing"
+outputs:
+  - "Implemented feature/fix (chunk by chunk)"
+  - "Updated documentation with new line numbers"
+  - "Commits with descriptive messages per todo"
+  - "All plan chunks marked as IMPLEMENTED"
+  - "All research chunks marked as IMPLEMENTED"
+  - "Archived plan in .ai-context/plans/completed/"
+  - "Archived research in .ai-context/research/completed/"
+next_commands: ["/verify-docs-current", "/validate-all"]
+related_agents: ["core-architect", "database-ops", "api-developer", "deployment-ops"]
+examples:
+  - command: "/rpi-implement user-authentication"
+    description: "Execute approved authentication plan chunk by chunk"
+  - command: "/rpi-implement payment-bug-fix"
+    description: "Implement approved bug fix processing each chunk's todolist"
+exit_criteria:
+  - "All chunk-todolists completed"
+  - "All plan chunks marked as IMPLEMENTED"
+  - "All research chunks marked as IMPLEMENTED"
+  - "All tests passing"
+  - "Documentation updated per chunk"
+  - "Changes committed per todo"
+  - "Plan archived to completed/"
+  - "Research archived to completed/"
+---
+
+# RPI Implement Phase (Enhanced with Chunk-Based Execution)
+
+**Purpose:** Execute implementation plan chunk by chunk, processing each chunk's todolist atomically
+
+**Syntax:** `/rpi-implement [feature-name]`
+
+**Prerequisites:** Plan must be approved in `.ai-context/plans/active/` with chunk manifest
+
+---
+
+## Key Innovation: Inter-Phase Awareness
+
+RPI-Implement **KNOWS**:
+- RPI-Plan structured chunks for atomic implementation
+- Each CHUNK-Pn contains a complete, ordered todolist
+- Chunk dependencies dictate execution order
+- Marking chunks complete updates both plan AND research documents
+- Context reset is needed after every 3 chunks or 35% utilization
+
+---
+
+## Golden Rules
+
+```
+ONE CHUNK → COMPLETE TODOLIST → MARK DONE → NEXT CHUNK
+ONE TODO → ONE CHANGE → ONE TEST → ONE COMMIT
+```
+
+---
+
+## Chunk-Based Implementation Loop
+
+```
+┌─────────────────────────────────────────────────────────┐
+│ RPI-IMPLEMENT CHUNK PROCESSING LOOP                     │
+├─────────────────────────────────────────────────────────┤
+│ FOR each CHUNK-Pn in dependency_order:                  │
+│   1. Load CHUNK-Pn todolist                             │
+│   2. FOR each TODO in CHUNK-Pn:                         │
+│      a. Make atomic change                              │
+│      b. Run specified test                              │
+│      c. If PASS: commit, mark TODO ✅                   │
+│      d. If FAIL: STOP, investigate, fix                 │
+│   3. Mark CHUNK-Pn as IMPLEMENTED                       │
+│   4. Update research CHUNK-Rn to IMPLEMENTED            │
+│   5. Context reset if needed                            │
+│   6. Proceed to next chunk                              │
+│ END LOOP                                                │
+└─────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Execution Steps
+
+### Step 1: Load Plan
+Read `.ai-context/plans/active/[feature]_plan.md` with chunk manifest
+
+### Step 2: Verify Preconditions
+- [ ] Plan is approved
+- [ ] Branch is clean
+- [ ] Tests pass before changes
+- [ ] Chunk manifest is present
+
+### Step 3: Execute Each Chunk (in dependency order)
+
+For each CHUNK-Pn:
+1. Execute each todo atomically (one change → one test → one commit)
+2. Mark CHUNK-Pn as IMPLEMENTED when all todos complete
+3. Update CHUNK-Rn status in research to IMPLEMENTED
+
+### Step 4: Context Reset (Every 3 Chunks or 35% Utilization)
+1. Update progress in plan
+2. Re-read plan document
+3. Verify scope alignment
+4. Compact if >35% context usage
+
+### Step 5: Run Full Test Suite
+After all chunks complete
+
+### Step 6: Update Documentation (MANDATORY)
+1. Check CODE_TO_WORKFLOW_MAP.md
+2. Update affected workflow files
+3. Update line numbers
+4. Run /verify-docs-current
+
+### Step 7: Final Commit
+Documentation updates
+
+### Step 8: Archive Documents
+- Move plan to `.ai-context/plans/completed/`
+- Move research to `.ai-context/research/completed/`
+
+---
+
+## Error Recovery
+
+| Error Type | Action |
+|------------|--------|
+| Syntax Error | Fix immediately in same todo |
+| Test Failure | Stop, investigate, fix before proceeding |
+| 3+ Failures in chunk | Mark chunk BLOCKED, try next independent chunk |
+| 3+ Chunks blocked | STOP. Compact context. Start new session. |
+
+---
+
+## Context Budget
+
+- Plan: 15k tokens
+- Active code (per chunk): ~10k tokens
+- Test results (per chunk): ~5k tokens
+- Max active (3 chunks): ~45k tokens (22.5%)
+
+---
+
+## Output
+
+- Completed feature/fix (implemented chunk by chunk)
+- All chunks marked IMPLEMENTED (plan + research)
+- Updated documentation per chunk
+- Documents archived to completed/

package/templates/base/commands/rpi-plan.md

@@ -1,93 +1,147 @@
----
-name: rpi-plan
-version: "1.0.0"
-description: "RPI Plan Phase: Create implementation blueprint with file:line precision"
-category: "rpi-orchestration"
-rpi_phase: "plan"
-context_budget_estimate: "35K tokens"
-typical_context_usage: "17%"
-prerequisites:
-  - "Research document exists in .ai-context/research/active/"
-  - "/rpi-research phase completed"
-outputs:
-  - "Plan document in .ai-context/plans/active/[name]_plan.md"
-  - "Modification table with file:line references"
-  - "Step-by-step implementation guide"
-  - "Test strategy"
-  - "Rollback plan"
-next_commands: ["/rpi-implement"]
-related_agents: ["core-architect", "database-ops", "api-developer"]
-examples:
-  - command: "/rpi-plan user-authentication"
-    description: "Create implementation plan for auth feature"
-  - command: "/rpi-plan payment-bug-fix"
-    description: "Plan the fix for payment issue"
-exit_criteria:
-  - "Plan document created in .ai-context/plans/active/"
-  - "All file modifications listed with line numbers"
-  - "Step-by-step implementation defined"
-  - "Test strategy documented"
-  - "Human approval obtained"
----
-
-# RPI Plan Phase
-
-**Purpose:** Create detailed implementation blueprint
-
-**Syntax:** `/rpi-plan [feature-name]`
-
-**Prerequisites:** Research document must exist in `.ai-context/research/active/`
-
----
-
-## Execution Steps
-
-### Step 1: Load Research Document
-Read `.ai-context/research/active/[feature]_research.md`
-
-### Step 2: Define Scope
-- In scope (explicit list)
-- Out of scope (what we're NOT touching)
-
-### Step 3: List File Modifications
-| File | Lines | Change | Risk |
-|------|-------|--------|------|
-Each modification with exact line numbers
-
-### Step 4: Create Step-by-Step Plan
-For each step:
-- Current code
-- Proposed change
-- Test to run after
-
-### Step 5: Define Test Strategy
-- Unit tests required
-- Integration tests required
-- E2E tests if applicable
-
-### Step 6: Document Rollback Plan
-- How to revert
-- Safe commit to return to
-
-### Step 7: Request Human Approval
-Plan requires human review before implementation
-
----
-
-## Output
-
-Plan document in `.ai-context/plans/active/[feature]_plan.md`
-
----
-
-## Context Budget
-
-- Research doc: 20k tokens
-- Plan creation: 15k tokens
-- Total: 35k tokens (17%)
-
----
-
-## Next Step
-
-After human approval: `/rpi-implement [feature-name]`
+---
+name: rpi-plan
+version: "2.0.0"
+description: "RPI Plan Phase: Create chunk-based implementation blueprint with todolists for rpi-implement consumption"
+category: "rpi-orchestration"
+rpi_phase: "plan"
+context_budget_estimate: "35K tokens"
+typical_context_usage: "17%"
+chunk_input: true
+chunk_output: true
+inter_phase_aware: true
+prerequisites:
+  - "Research document exists in .ai-context/research/active/"
+  - "/rpi-research phase completed with chunk manifest"
+outputs:
+  - "Plan document in .ai-context/plans/active/[name]_plan.md"
+  - "Chunk-based todolists (CHUNK-Pn per CHUNK-Rn)"
+  - "Modification table with file:line references per chunk"
+  - "Step-by-step implementation guide per chunk"
+  - "Test strategy per chunk"
+  - "Rollback plan per chunk"
+  - "Inter-phase contract for rpi-implement"
+next_commands: ["/rpi-implement"]
+related_agents: ["core-architect", "database-ops", "api-developer"]
+examples:
+  - command: "/rpi-plan user-authentication"
+    description: "Create chunk-based implementation plan for auth feature"
+  - command: "/rpi-plan payment-bug-fix"
+    description: "Plan the fix with chunk-todolists for payment issue"
+exit_criteria:
+  - "Plan document created in .ai-context/plans/active/"
+  - "Chunk manifest created with CHUNK-Pn per CHUNK-Rn"
+  - "All research chunks marked as PLANNED"
+  - "All file modifications listed with line numbers per chunk"
+  - "Chunk-todolists defined with atomic actions"
+  - "Test strategy documented per chunk"
+  - "Human approval obtained"
+  - "Inter-phase contract documented for rpi-implement"
+---
+
+# RPI Plan Phase (Enhanced with Chunk-Based Todolists)
+
+**Purpose:** Create detailed implementation blueprint using chunk-based todolists that RPI-Implement will process
+
+**Syntax:** `/rpi-plan [feature-name]`
+
+**Prerequisites:** Research document must exist in `.ai-context/research/active/` with chunk manifest
+
+---
+
+## Key Innovation: Inter-Phase Awareness
+
+RPI-Plan **KNOWS**:
+- RPI-Research structured chunks specifically for sequential processing
+- RPI-Implement will read each CHUNK-Pn as an atomic implementation unit
+- Each CHUNK-Pn todolist must be independently executable
+- Chunk dependencies must be explicit for proper execution ordering
+
+---
+
+## Chunk Processing Loop
+
+```
+┌─────────────────────────────────────────────────────────┐
+│ RPI-PLAN CHUNK PROCESSING LOOP                          │
+├─────────────────────────────────────────────────────────┤
+│ FOR each research_chunk (CHUNK-R1 to CHUNK-RN):         │
+│   1. Read research_chunk content                        │
+│   2. Create corresponding CHUNK-Pn todolist:            │
+│      - Define atomic action items                       │
+│      - Specify file:line for each action                │
+│      - Assign test for each action                      │
+│      - Document chunk-specific rollback                 │
+│   3. Mark research_chunk status as PLANNED              │
+│   4. Define CHUNK-Pn dependencies                       │
+│   5. Proceed to next research chunk                     │
+│ END LOOP                                                │
+└─────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Execution Steps
+
+### Step 1: Load Research Document
+Read `.ai-context/research/active/[feature]_research.md` and extract chunk manifest
+
+### Step 2: Process Each Research Chunk
+
+For each CHUNK-Rn:
+1. Analyze chunk content (files, deps, call chains)
+2. Create CHUNK-Pn todolist with atomic actions
+3. Mark CHUNK-Rn status as PLANNED
+4. Document chunk dependencies
+
+### Step 3: Define Scope
+- In scope (explicit list per chunk)
+- Out of scope (what we're NOT touching)
+
+### Step 4: Create Chunk Dependency Graph
+```
+CHUNK-P1 ───→ CHUNK-P2 ───→ CHUNK-P3
+```
+
+### Step 5: Plan Testing Strategy (Per Chunk)
+- Tests to run after each todo
+- Tests to run after chunk completion
+
+### Step 6: Document Rollback Plan (Per Chunk)
+- Per-chunk rollback commands
+- Safe commits per chunk
+
+### Step 7: Finalize Inter-Phase Contract
+```
+EXPECTED_CONSUMER: rpi-implement
+CHUNK_PROCESSING_ORDER: dependency-ordered
+MARK_AS_IMPLEMENTED_WHEN: all chunk todos complete
+UPDATE_RESEARCH_STATUS: true
+```
+
+### Step 8: Request Human Approval
+Plan requires human review before implementation
+
+---
+
+## Output
+
+Plan document in `.ai-context/plans/active/[feature]_plan.md` with:
+- Chunk manifest
+- Per-chunk todolists
+- Inter-phase contract for RPI-Implement
+
+---
+
+## Context Budget
+
+- Research doc: 20k tokens
+- Plan creation: 15k tokens
+- Total: 35k tokens (17%)
+
+---
+
+## Next Step
+
+After human approval: `/rpi-implement [feature-name]`
+
+RPI-Implement will process chunks in dependency order, executing todos atomically