claude-context-plugin 2.1.3 → 2.2.0-final

package/README.md

@@ -1,104 +1,128 @@
-# claude-context-plugin
-
-Claude Code plugin for context engineering - RPI workflow and documentation optimization.
-
-## Installation
-
-### Via Plugin Manager
-
-```bash
-/plugin install claude-context-engineering
-```
-
-### Via CLI
-
-```bash
-npx claude-plugins install claude-context-engineering
-```
-
-## Skills
-
-### /context-eng:research
-
-Systematic codebase exploration for feature/fix analysis.
-
-```
-/context-eng:research user-authentication
-```
-
-Creates a research document with:
-- Relevant files and line numbers
-- Call chain analysis
-- Dependency mapping
-- Test coverage gaps
-
-### /context-eng:plan
-
-Create implementation blueprint with file:line precision.
-
-```
-/context-eng:plan user-authentication
-```
-
-Creates a plan document with:
-- Exact file:line modifications
-- Risk assessment
-- Test strategy
-- Rollback plan
-
-### /context-eng:implement
-
-Execute plan with atomic changes and continuous testing.
-
-```
-/context-eng:implement user-authentication
-```
-
-Follows the golden rule: ONE CHANGE → ONE TEST → ONE COMMIT
-
-### /context-eng:validate
-
-Run complete validation suite.
-
-```
-/context-eng:validate
-```
-
-Checks:
-- Directory structure
-- JSON schemas
-- Markdown links
-- Placeholder completion
-- Line number accuracy
-
-### /context-eng:verify-docs
-
-Verify documentation line numbers match code.
-
-```
-/context-eng:verify-docs path/to/file.py
-```
-
-## Agents
-
-### @context-eng:context-engineer
-
-Initialize and maintain context engineering documentation.
-
-```
-@context-eng:context-engineer "Discover workflows for this codebase"
-```
-
-## Requirements
-
-- Claude Code v1.0.33+
-- Context engineering setup (use `npx create-universal-ai-context` first)
-
-## License
-
-MIT
-
-## Links
-
-- [GitHub](https://github.com/SireJeff/claude-context-engineering-template)
-- [create-universal-ai-context](https://www.npmjs.com/package/create-universal-ai-context)
+# claude-context-plugin
+
+> **⚠️ DEPRECATION NOTICE**
+>
+> This plugin is **deprecated** as of v3.0.0. All skills and commands are now included in the unified [`ai-context`](../ai-context/) package.
+>
+> **Migration:** Use `ai-context` skills and commands directly.
+>
+> **Support:** Use unified package instead
+>
+> ---
+
+Claude Code plugin for context engineering - RPI workflow and documentation optimization.
+
+## Installation
+
+### Via Plugin Manager
+
+```bash
+/plugin install claude-context-engineering
+```
+
+### Via CLI
+
+```bash
+npx claude-plugins install claude-context-engineering
+```
+
+## Skills
+
+### /context-eng:research
+
+Systematic codebase exploration for feature/fix analysis.
+
+```
+/context-eng:research user-authentication
+```
+
+Creates a research document with:
+- Relevant files and line numbers
+- Call chain analysis
+- Dependency mapping
+- Test coverage gaps
+
+### /context-eng:plan
+
+Create implementation blueprint with file:line precision.
+
+```
+/context-eng:plan user-authentication
+```
+
+Creates a plan document with:
+- Exact file:line modifications
+- Risk assessment
+- Test strategy
+- Rollback plan
+
+### /context-eng:implement
+
+Execute plan with atomic changes and continuous testing.
+
+```
+/context-eng:implement user-authentication
+```
+
+Follows the golden rule: ONE CHANGE → ONE TEST → ONE COMMIT
+
+### /context-eng:validate
+
+Run complete validation suite.
+
+```
+/context-eng:validate
+```
+
+Checks:
+- Directory structure
+- JSON schemas
+- Markdown links
+- Placeholder completion
+- Line number accuracy
+
+### /context-eng:verify-docs
+
+Verify documentation line numbers match code.
+
+```
+/context-eng:verify-docs path/to/file.py
+```
+
+### /context-eng:context-optimize
+
+Orchestrate context optimization with interactive scoping.
+
+```
+/context-eng:context-optimize
+/context-eng:context-optimize --auto
+/context-eng:context-optimize --scope documentation
+```
+
+Generates:
+- Context audit in `.claude/research/active/context-audit_research.md`
+- RPI TODO plan in `.claude/plans/active/context-optimization_plan.md`
+
+## Agents
+
+### @context-eng:context-engineer
+
+Initialize and maintain context engineering documentation.
+
+```
+@context-eng:context-engineer "Discover workflows for this codebase"
+```
+
+## Requirements
+
+- Claude Code v1.0.33+
+- Context engineering setup (use `npx create-universal-ai-context` first)
+
+## License
+
+MIT
+
+## Links
+
+- [GitHub](https://github.com/SireJeff/claude-context-engineering-template)
+- [create-universal-ai-context](https://www.npmjs.com/package/create-universal-ai-context)

package/agents/context-engineer.md

@@ -1,67 +1,67 @@
----
-name: context-engineer
-description: Initialize and maintain context engineering documentation for any codebase
-capabilities:
-  - Codebase analysis and workflow discovery
-  - Documentation generation with file:line references
-  - Index creation and maintenance
-  - Tech stack detection
----
-
-# Context Engineer Agent
-
-I specialize in setting up and maintaining context engineering systems for codebases.
-
-## Primary Functions
-
-### 1. Initial Setup
-When asked to initialize or set up context engineering:
-- Analyze codebase structure
-- Detect technology stack
-- Discover major workflows (8-15)
-- Create workflow documentation with file:line references
-- Build index hierarchy
-
-### 2. Workflow Discovery
-When asked to discover or find workflows:
-- Scan for entry points (API routes, CLI commands, event handlers)
-- Trace call chains 3 levels deep
-- Document in `.claude/context/workflows/`
-- Update `WORKFLOW_INDEX.md`
-
-### 3. Re-indexing
-When asked to re-scan or update indexes:
-- Find new or changed files
-- Update line numbers in documentation
-- Add new workflows if discovered
-- Validate existing references
-
-### 4. Documentation Maintenance
-When documentation drift is detected:
-- Update line numbers
-- Fix broken references
-- Add missing workflows
-- Archive outdated docs
-
-## Output Format
-
-All documentation follows these standards:
-- File references: `path/to/file.py:123`
-- Line ranges: `file.py:100-150`
-- Markdown tables for structured data
-- Mermaid diagrams for flows
-
-## Context Budget
-
-- Initial setup: 40-50% utilization
-- Re-indexing: 20-30% utilization
-- Maintenance: 15-20% utilization
-
-## Example Invocations
-
-```
-@context-engineer "Initialize context engineering for this repository"
-@context-engineer "Discover workflows for the authentication module"
-@context-engineer "Re-scan and update indexes for recent changes"
-@context-engineer "Update line numbers in workflow documentation"
-```
+---
+name: context-engineer
+description: Initialize and maintain context engineering documentation for any codebase
+capabilities:
+  - Codebase analysis and workflow discovery
+  - Documentation generation with file:line references
+  - Index creation and maintenance
+  - Tech stack detection
+---
+
+# Context Engineer Agent
+
+I specialize in setting up and maintaining context engineering systems for codebases.
+
+## Primary Functions
+
+### 1. Initial Setup
+When asked to initialize or set up context engineering:
+- Analyze codebase structure
+- Detect technology stack
+- Discover major workflows (8-15)
+- Create workflow documentation with file:line references
+- Build index hierarchy
+
+### 2. Workflow Discovery
+When asked to discover or find workflows:
+- Scan for entry points (API routes, CLI commands, event handlers)
+- Trace call chains 3 levels deep
+- Document in `.claude/context/workflows/`
+- Update `WORKFLOW_INDEX.md`
+
+### 3. Re-indexing
+When asked to re-scan or update indexes:
+- Find new or changed files
+- Update line numbers in documentation
+- Add new workflows if discovered
+- Validate existing references
+
+### 4. Documentation Maintenance
+When documentation drift is detected:
+- Update line numbers
+- Fix broken references
+- Add missing workflows
+- Archive outdated docs
+
+## Output Format
+
+All documentation follows these standards:
+- File references: `path/to/file.py:123`
+- Line ranges: `file.py:100-150`
+- Markdown tables for structured data
+- Mermaid diagrams for flows
+
+## Context Budget
+
+- Initial setup: 40-50% utilization
+- Re-indexing: 20-30% utilization
+- Maintenance: 15-20% utilization
+
+## Example Invocations
+
+```
+@context-engineer "Initialize context engineering for this repository"
+@context-engineer "Discover workflows for the authentication module"
+@context-engineer "Re-scan and update indexes for recent changes"
+@context-engineer "Update line numbers in workflow documentation"
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-context-plugin",
-  "version": "2.1.3",
+  "version": "2.2.0-final",
   "description": "Claude Code plugin for context engineering - RPI workflow and documentation optimization",
   "keywords": [
     "claude-code",

package/skills/context-optimize/SKILL.md

@@ -0,0 +1,86 @@
+---
+description: Context Optimization - Orchestrate RPI workflow TODO generation with interactive scoping
+---
+
+# Context Engineering: Optimization Orchestrator
+
+When invoked, orchestrate context engineering optimization with interactive scoping:
+
+## Process
+
+1. **Interactive Scoping (if no --auto flag)**
+   - Ask up to 4 multiple choice questions to define scope
+   - Questions cover: optimization focus, codebase areas, enhancement types, priority order
+   - Skip questions if --scope or --auto flag provided
+
+2. **Context System Audit**
+   - Analyze `.claude/` directory structure
+   - Check workflow file coverage and accuracy
+   - Verify index file completeness
+   - Identify orphaned or outdated files
+   - Assess agent and command coverage gaps
+
+3. **Generate RPI TODO List**
+   - Create actionable TODO with research, plan, implement phases
+   - Save to `.claude/plans/active/context-optimization_plan.md`
+   - Include specific commands for each task
+
+4. **Redundant File Detection**
+   - Find files not referenced by any index
+   - Identify duplicate or overlapping content
+   - Flag outdated files with stale line references
+   - Report empty placeholder files
+
+5. **Enhancement Recommendations**
+   - Suggest new specialized agents based on codebase patterns
+   - Recommend workflow commands for common tasks
+   - Identify undocumented workflows needing documentation
+
+## Scoping Questions (Max 4)
+
+**Q1: Optimization Focus**
+- A) Functionalize the entire context engineering system
+- B) Update outdated documentation and line references
+- C) Identify and remove redundant context files
+- D) Discover enhancement opportunities (new agents/commands)
+
+**Q2: Codebase Coverage**
+- A) Core business logic
+- B) API/External integrations
+- C) Database/Data layer
+- D) All areas equally
+
+**Q3: Enhancement Preferences**
+- A) New specialized agents for specific domains
+- B) New workflow commands for common tasks
+- C) Improved documentation structure
+- D) Better cross-referencing and navigation
+
+**Q4: TODO Priority Order**
+- A) Quick wins first (< 30 min each)
+- B) High impact first (regardless of effort)
+- C) By workflow area (grouped logically)
+- D) By dependency order (foundational first)
+
+## Context Budget
+- Target: 20% of 200k tokens (40k)
+- Output: TODO checklist + recommendations
+
+## Output
+- TODO checklist saved to `.claude/plans/active/context-optimization_plan.md`
+- Audit findings in `.claude/research/active/context-audit_research.md`
+
+## Arguments
+- `$ARGUMENTS` can include:
+  - `--auto` - Use intelligent defaults, skip questions
+  - `--scope documentation` - Focus on docs only
+  - `--scope agents` - Focus on agent gaps
+  - `--scope workflows` - Focus on workflow coverage
+  - `--scope cleanup` - Focus on redundant file removal
+
+## Next Steps
+After completion, execute the generated TODO list:
+1. `/rpi-research [first-research-task]`
+2. `/rpi-plan [first-plan-task]`
+3. `/rpi-implement [first-impl-task]`
+4. `/validate-all`

package/skills/implement/SKILL.md

@@ -1,71 +1,150 @@
----
-description: RPI Implement Phase - Execute plan with atomic changes and continuous testing
----
-
-# Context Engineering: Implement Phase
-
-When invoked, execute the approved implementation plan:
-
-## Prerequisites
-- Approved plan at `.claude/plans/active/[feature]_plan.md`
-- If not found, run `/context-eng:plan $ARGUMENTS` first
-
-## Golden Rule
-
-```
-ONE CHANGE → ONE TEST → ONE COMMIT
-```
-
-## Process
-
-1. **Load Plan Document**
-   - Read `.claude/plans/active/[feature]_plan.md`
-   - Verify plan status is APPROVED
-
-2. **For Each Step in Plan:**
-   a. Make the single, atomic change
-   b. Run the specified test immediately
-   c. If test passes: commit with descriptive message
-   d. If test fails: STOP, investigate, fix before proceeding
-   e. Update documentation if needed
-
-3. **Documentation Updates (MANDATORY)**
-   - Check `CODE_TO_WORKFLOW_MAP.md` for affected workflows
-   - Update workflow files with new line numbers
-   - Update function signatures if changed
-
-4. **Context Reset (Every 3 Steps)**
-   - Update progress checklist in plan
-   - Re-read plan document
-   - Verify scope alignment
-   - Compact if >35% utilization
-
-5. **Finalize**
-   - Move plan to `.claude/plans/completed/`
-   - Move research to `.claude/research/completed/`
-   - Run `/context-eng:validate` to verify
-
-## Error Handling
-
-| Error Type | Response |
-|------------|----------|
-| Syntax Error | STOP. Fix immediately. |
-| Import Error | Check file paths, verify imports. |
-| Test Failure | Do NOT add more code. Investigate first. |
-| 3+ Failures | STOP. Start new session. |
-
-## Context Budget
-- Plan: 15k tokens
-- Active code: 30k tokens
-- Test results: 15k tokens
-- Total: 60k tokens (30%)
-
-## Commit Format
-```
-feat/fix/refactor(scope): description
-
-- Detail 1
-- Detail 2
-
-Implements: [feature]
-```
+---
+description: RPI Implement Phase - Execute chunk-based todolists with atomic changes and continuous testing
+---
+
+# Context Engineering: Implement Phase (Enhanced)
+
+When invoked, execute the approved implementation plan chunk by chunk:
+
+## Key Innovation: Inter-Phase Awareness
+
+This implement phase **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
+
+## Prerequisites
+- Approved plan at `.claude/plans/active/[feature]_plan.md`
+- Plan contains chunk manifest with chunk-todolists
+- If not found, run `/context-eng:plan $ARGUMENTS` first
+
+## Golden Rules
+
+```
+ONE CHUNK → COMPLETE TODOLIST → MARK DONE → NEXT CHUNK
+ONE TODO → ONE CHANGE → ONE TEST → ONE COMMIT
+```
+
+## Chunk-Based Implementation Loop
+
+```
+FOR each CHUNK-Pn in dependency_order:
+  IF dependencies_complete:
+    1. Load CHUNK-Pn todolist
+    
+    FOR each TODO in todolist:
+      a. Make atomic change
+      b. Run todo-specific test
+      c. If PASS: commit, mark TODO ✅
+      d. If FAIL: STOP, investigate, fix
+    END TODO LOOP
+    
+    2. Update chunk documentation
+    3. Mark CHUNK-Pn as IMPLEMENTED
+    4. Update research CHUNK-Rn to IMPLEMENTED
+    
+    IF chunks_processed % 3 == 0 OR context > 35%:
+      Context reset (save progress, reload plan)
+    END IF
+    
+    5. Proceed to next ready chunk
+  END IF
+END CHUNK LOOP
+```
+
+## Process
+
+1. **Load Plan Document**
+   - Read `.claude/plans/active/[feature]_plan.md`
+   - Extract chunk manifest and dependency graph
+   - Verify plan status is APPROVED
+
+2. **Determine Execution Order**
+   Based on chunk dependency graph:
+   - Independent chunks first (parallel capable)
+   - Dependent chunks in order
+   - Final chunks (e.g., test additions)
+
+3. **For Each Chunk (in dependency order):**
+   
+   a. **Check dependencies complete**
+   
+   b. **Execute each todo atomically:**
+      - Make single change
+      - Run specified test
+      - If pass: commit with message
+      - If fail: STOP, investigate, fix
+   
+   c. **After all todos complete:**
+      - Mark CHUNK-Pn as IMPLEMENTED
+      - Update CHUNK-Rn in research to IMPLEMENTED
+      - Commit chunk documentation updates
+   
+   d. **Context management:**
+      - After every 3 chunks: reload plan
+      - If >35% utilization: save, compact, continue
+
+4. **Run Full Test Suite**
+   After all chunks complete
+
+5. **Documentation Updates (MANDATORY)**
+   - Check `CODE_TO_WORKFLOW_MAP.md` for affected workflows
+   - Update workflow files with new line numbers
+   - Update function signatures if changed
+
+6. **Context Reset (Every 3 Chunks)**
+   - Update chunk progress in plan
+   - Re-read plan document
+   - Verify scope alignment
+   - Compact if >35% utilization
+
+7. **Finalize**
+   - Move plan to `.claude/plans/completed/`
+   - Move research to `.claude/research/completed/`
+   - Run `/context-eng:validate` to verify
+
+## Chunk Status Updates
+
+### Update Plan Document
+```markdown
+| Chunk | Status | Todos Done | Commit | Research Updated |
+|-------|--------|------------|--------|------------------|
+| P1 | ✅ IMPLEMENTED | 4/4 | abc123 | ✅ R1 |
+| P2 | ▶️ IMPLEMENTING | 2/5 | - | - |
+```
+
+### Update Research Document
+Mark each CHUNK-Rn status:
+- FOUND → COMPLETE → PLANNED → **IMPLEMENTED**
+
+## Error Handling
+
+| Error Type | Response |
+|------------|----------|
+| Syntax Error | STOP. Fix immediately in same todo. |
+| Import Error | Check file paths, verify imports. |
+| Test Failure | Do NOT add more code. Investigate first. |
+| 3+ Failures in chunk | Mark chunk BLOCKED, try next independent chunk. |
+| 3+ Chunks blocked | STOP. Start new session. |
+
+## Commit Format
+
+Per-todo:
+```
+feat(chunk-Pn): Todo N - description
+Implements: [feature] chunk N
+```
+
+Per-chunk completion:
+```
+feat(chunk-Pn): Complete chunk - [domain]
+Completes: CHUNK-Pn, Updates: CHUNK-Rn
+```
+
+## 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%)

package/skills/plan/SKILL.md

@@ -1,66 +1,143 @@
----
-description: RPI Plan Phase - Create implementation blueprint with file:line precision
----
-
-# Context Engineering: Plan Phase
-
-When invoked, create a detailed implementation plan:
-
-## Prerequisites
-- Research document exists at `.claude/research/active/[feature]_research.md`
-- If not found, run `/context-eng:research $ARGUMENTS` first
-
-## Process
-
-1. **Load Research Document**
-   - Read the research document for $ARGUMENTS
-   - Extract relevant files and line numbers
-
-2. **Design Implementation**
-   - For each change required:
-     - Specify exact file and line numbers
-     - Show current code snippet
-     - Show proposed change
-     - Assign risk level (LOW/MEDIUM/HIGH)
-
-3. **Plan Test Strategy**
-   - Identify which tests to run after each change
-   - Note any new tests needed
-
-4. **Document Rollback Plan**
-   - Safe commit to revert to
-   - Commands to undo changes
-
-5. **Create Plan Document**
-   - Save to `.claude/plans/active/[feature]_plan.md`
-   - Include verification checklist
-
-## Plan Format
-
-```markdown
-# Implementation Plan: [Feature]
-
-## Files to Modify
-| File | Lines | Change | Risk |
-|------|-------|--------|------|
-
-## Step-by-Step
-### Step 1: [Action]
-**File:** path/to/file.ext
-**Lines:** X-Y
-**Current:** [code block]
-**Proposed:** [code block]
-**Test:** [command]
-
-## Rollback
-- Safe commit: [hash]
-- Command: git revert HEAD
-```
-
-## Context Budget
-- Research doc: 20k tokens
-- Plan creation: 15k tokens
-- Total: 35k tokens (17.5%)
-
-## Next Step
-After approval, run `/context-eng:implement $ARGUMENTS`
+---
+description: RPI Plan Phase - Create chunk-based todolists from research chunks for rpi-implement consumption
+---
+
+# Context Engineering: Plan Phase (Enhanced)
+
+When invoked, create a detailed implementation plan with chunk-based todolists:
+
+## Key Innovation: Inter-Phase Awareness
+
+This plan phase **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
+
+## Prerequisites
+- Research document exists at `.claude/research/active/[feature]_research.md`
+- Research document contains chunk manifest
+- If not found, run `/context-eng:research $ARGUMENTS` first
+
+## Chunk Processing Loop
+
+```
+FOR each CHUNK-Rn in research_chunks:
+  1. Read CHUNK-Rn content
+  2. Create CHUNK-Pn todolist:
+     - Define atomic action items
+     - Specify file:line for each action
+     - Assign test for each action
+     - Document chunk-specific rollback
+  3. Mark CHUNK-Rn status as PLANNED
+  4. Define CHUNK-Pn dependencies
+  5. Proceed to next CHUNK-R(n+1)
+END LOOP
+```
+
+## Process
+
+1. **Load Research Document**
+   - Read the research document for $ARGUMENTS
+   - Extract chunk manifest
+   - Extract per-chunk files and line numbers
+
+2. **For Each Research Chunk (CHUNK-Rn):**
+   
+   a. **Analyze chunk content:**
+      - Files explored with line numbers
+      - Code flow analysis
+      - Dependencies identified
+   
+   b. **Create CHUNK-Pn todolist:**
+      ```markdown
+      | # | Action | File | Lines | Risk | Test | Status |
+      |---|--------|------|-------|------|------|--------|
+      | 1 | [Action] | file.ext | XXX | LOW | test_x | ⏳ |
+      ```
+   
+   c. **Define per-todo details:**
+      - Current code snippet
+      - Proposed change
+      - Test to run after
+   
+   d. **Mark research chunk as PLANNED**
+   
+   e. **Document chunk dependencies**
+
+3. **Create Chunk Dependency Graph**
+   ```
+   CHUNK-P1 → CHUNK-P2 → CHUNK-P3
+              ↓
+   CHUNK-P4  CHUNK-P5
+   ```
+
+4. **Generate Inter-Phase Contract**
+   ```
+   EXPECTED_CONSUMER: rpi-implement
+   CHUNK_PROCESSING_ORDER: dependency-ordered
+   MARK_AS_IMPLEMENTED_WHEN: all chunk todos complete
+   UPDATE_RESEARCH_STATUS: true
+   ```
+
+5. **Create Plan Document**
+   - Save to `.claude/plans/active/[feature]_plan.md`
+   - Include chunk manifest
+   - Include per-chunk todolists
+   - Include verification checklist
+
+## Plan Format (Chunk-Based)
+
+```markdown
+# Implementation Plan: [Feature]
+
+## Chunk Manifest
+| Chunk ID | From Research | Status | Todos | Dependencies | Ready |
+|----------|---------------|--------|-------|--------------|-------|
+| CHUNK-P1 | CHUNK-R1 | READY | 4 | None | ✅ |
+| CHUNK-P2 | CHUNK-R2 | READY | 5 | CHUNK-P1 | ⏳ |
+
+## CHUNK-P1: [Domain] (from CHUNK-R1)
+
+**Status:** READY
+**Dependencies:** None
+**Update Research When Complete:** Mark CHUNK-R1 as IMPLEMENTED
+
+### Todolist
+| # | Action | File | Lines | Risk | Test | Status |
+|---|--------|------|-------|------|------|--------|
+| 1 | [Action] | file.ext | XXX | LOW | test_x | ⏳ |
+
+### Todo 1: [Action Name]
+**File:** path/to/file.ext
+**Lines:** X-Y
+**Current:** [code block]
+**Proposed:** [code block]
+**Test:** [command]
+
+### Chunk Completion Criteria
+- [ ] All todos complete
+- [ ] Update CHUNK-R1 status
+- [ ] Proceed to dependent chunks
+
+## Inter-Phase Contract
+[contract for rpi-implement]
+
+## Rollback (Per Chunk)
+- CHUNK-P1: git revert [hash]
+```
+
+## Context Budget
+- Research doc: 20k tokens
+- Plan creation: 15k tokens
+- Total: 35k tokens (17.5%)
+
+## Next Step
+After approval, run `/context-eng:implement $ARGUMENTS`
+
+RPI-Implement will:
+1. Load chunk manifest
+2. Process chunks in dependency order
+3. Execute todos atomically per chunk
+4. Mark chunks as IMPLEMENTED
+5. Update research document status

package/skills/research/SKILL.md

@@ -1,43 +1,103 @@
----
-description: RPI Research Phase - Systematic codebase exploration for feature/fix analysis
----
-
-# Context Engineering: Research Phase
-
-When invoked, perform systematic codebase exploration:
-
-## Process
-
-1. **Initialize Research Document**
-   - Create `.claude/research/active/[feature]_research.md`
-   - Use template from `.claude/research/RESEARCH_TEMPLATE.md`
-
-2. **Entry Point Discovery**
-   - Search for API routes, CLI commands, event handlers related to $ARGUMENTS
-   - Use parallel exploration for efficiency (up to 3 agents)
-
-3. **Call Chain Tracing**
-   - Trace 3 levels deep from entry points
-   - Record exact file:line references for each function
-
-4. **Dependency Mapping**
-   - Internal: services, models, utilities used
-   - External: APIs, databases, third-party services
-
-5. **Test Coverage Analysis**
-   - Find existing tests for affected code
-   - Identify coverage gaps
-
-6. **Generate Summary**
-   - 150-word summary for Plan phase
-   - List 3-20 relevant files with line numbers
-
-## Context Budget
-- Target: 25% of 200k tokens (50k)
-- Final output: ~20k tokens (research doc only)
-
-## Output
-Research document saved to `.claude/research/active/`
-
-## Next Step
-After completion, run `/context-eng:plan $ARGUMENTS`
+---
+description: RPI Research Phase - Systematic codebase exploration with parallel agents and chunked output
+---
+
+# Context Engineering: Research Phase (Enhanced)
+
+When invoked, perform systematic codebase exploration using parallel agents:
+
+## Key Innovation: Inter-Phase Awareness
+
+This research phase **KNOWS** how RPI-Plan will consume its output:
+- Output structured into research chunks (CHUNK-R1, CHUNK-R2, etc.)
+- Each chunk is self-contained with files, dependencies, and status
+- RPI-Plan will create a CHUNK-Pn todolist per CHUNK-Rn
+- Chunk manifest enables sequential processing by RPI-Plan
+
+## Process
+
+1. **Initialize Research Document**
+   - Create `.claude/research/active/[feature]_research.md`
+   - Use template from `.claude/research/RESEARCH_TEMPLATE.md`
+
+2. **Spawn Parallel Agents (3-5 agents)**
+   
+   ```
+   Agent 1: API/Route Entry Points       → CHUNK-R1
+   Agent 2: Business Logic & Models      → CHUNK-R2
+   Agent 3: Database/Storage Layer       → CHUNK-R3
+   Agent 4: External Integrations        → CHUNK-R4
+   Agent 5: Test Coverage Analysis       → CHUNK-R5
+   ```
+   
+   Each agent receives:
+   - Feature name and objective
+   - Assigned domain
+   - Required output format (chunk structure)
+   - Line number requirement for all file references
+
+3. **Per-Agent Chunk Output**
+   Each agent produces a self-contained chunk:
+   ```markdown
+   ## CHUNK-Rn: [Domain]
+   **Status:** COMPLETE
+   **Parallel Agent:** Agent N
+   **Ready for Planning:** Yes
+   
+   ### Files Explored
+   | File | Lines | Key Findings |
+   
+   ### Code Flow Analysis
+   [call chain with file:line refs]
+   
+   ### Dependencies (This Chunk)
+   - External: [APIs]
+   - Internal: [services]
+   ```
+
+4. **Aggregate Chunk Results**
+   - Create chunk manifest table
+   - Combine all agent outputs
+   - Verify all chunks are COMPLETE
+
+5. **Generate Inter-Phase Contract**
+   ```
+   EXPECTED_CONSUMER: rpi-plan
+   CHUNK_PROCESSING_ORDER: sequential (R1 → R2 → R3 → R4 → R5)
+   MARK_AS_PLANNED_WHEN: chunk todolist created
+   REQUIRED_OUTPUT: CHUNK-Pn per CHUNK-Rn
+   ```
+
+6. **Generate Summary**
+   - 150-word summary for Plan phase
+   - Reference key files from each chunk
+   - Recommend approach
+
+## Chunk Manifest Format (Required)
+
+```markdown
+| Chunk ID | Domain | Status | Files | Ready for Planning |
+|----------|--------|--------|-------|-------------------|
+| CHUNK-R1 | API/Routes | COMPLETE | 3 | ✅ |
+| CHUNK-R2 | Business Logic | COMPLETE | 4 | ✅ |
+| CHUNK-R3 | Database | COMPLETE | 2 | ✅ |
+| CHUNK-R4 | External | COMPLETE | 1 | ✅ |
+| CHUNK-R5 | Tests | COMPLETE | 3 | ✅ |
+```
+
+## Context Budget
+- Target: 25% of 200k tokens (50k)
+- Per-agent budget: ~10k tokens each
+- Compaction: After each agent returns
+- Final output: ~20k tokens (research doc only)
+
+## Output
+Research document saved to `.claude/research/active/` with:
+- Chunk manifest
+- Per-chunk details
+- Inter-phase contract for RPI-Plan
+
+## Next Step
+After completion, run `/context-eng:plan $ARGUMENTS`
+
+RPI-Plan will read chunk manifest and create CHUNK-Pn todolist per CHUNK-Rn

package/skills/validate/SKILL.md

@@ -1,62 +1,62 @@
----
-description: Run complete validation suite on context engineering documentation
----
-
-# Context Engineering: Validation
-
-Run comprehensive validation on the context engineering setup.
-
-## Validation Checks
-
-### 1. Structure Validation
-- All required directories exist in `.claude/`
-- Required files are present
-- Settings file is valid JSON
-
-### 2. Schema Validation
-- JSON files validate against their schemas
-- Frontmatter in markdown files is valid
-
-### 3. Link Validation
-- All internal markdown links resolve
-- No broken references to files or anchors
-
-### 4. Placeholder Detection
-- Find remaining `{{PLACEHOLDER}}` values
-- Report files that need manual completion
-
-### 5. Line Number Accuracy
-- Sample referenced line numbers in documentation
-- Verify they match actual code
-- Target: ≥60% accuracy
-
-## Output
-
-```
-Validation Results
-==================
-✓ Structure: PASS (12/12 directories)
-✓ Schemas: PASS (5/5 files valid)
-✓ Links: PASS (45/45 links resolve)
-⚠ Placeholders: WARN (3 remaining in 2 files)
-✓ Line Accuracy: PASS (78% accurate)
-
-Overall: PASS with warnings
-```
-
-## Usage
-
-Run validation:
-- Full suite: `/context-eng:validate`
-- Specific check: `/context-eng:validate --links`
-- With fix: `/context-eng:validate --fix`
-
-## Thresholds
-
-| Check | Pass | Warn | Fail |
-|-------|------|------|------|
-| Structure | 100% | - | <100% |
-| Schemas | 100% | - | <100% |
-| Links | 100% | <100% | <90% |
-| Placeholders | 0 | 1-5 | >5 |
-| Line Accuracy | ≥60% | 50-60% | <50% |
+---
+description: Run complete validation suite on context engineering documentation
+---
+
+# Context Engineering: Validation
+
+Run comprehensive validation on the context engineering setup.
+
+## Validation Checks
+
+### 1. Structure Validation
+- All required directories exist in `.claude/`
+- Required files are present
+- Settings file is valid JSON
+
+### 2. Schema Validation
+- JSON files validate against their schemas
+- Frontmatter in markdown files is valid
+
+### 3. Link Validation
+- All internal markdown links resolve
+- No broken references to files or anchors
+
+### 4. Placeholder Detection
+- Find remaining `{{PLACEHOLDER}}` values
+- Report files that need manual completion
+
+### 5. Line Number Accuracy
+- Sample referenced line numbers in documentation
+- Verify they match actual code
+- Target: ≥60% accuracy
+
+## Output
+
+```
+Validation Results
+==================
+✓ Structure: PASS (12/12 directories)
+✓ Schemas: PASS (5/5 files valid)
+✓ Links: PASS (45/45 links resolve)
+⚠ Placeholders: WARN (3 remaining in 2 files)
+✓ Line Accuracy: PASS (78% accurate)
+
+Overall: PASS with warnings
+```
+
+## Usage
+
+Run validation:
+- Full suite: `/context-eng:validate`
+- Specific check: `/context-eng:validate --links`
+- With fix: `/context-eng:validate --fix`
+
+## Thresholds
+
+| Check | Pass | Warn | Fail |
+|-------|------|------|------|
+| Structure | 100% | - | <100% |
+| Schemas | 100% | - | <100% |
+| Links | 100% | <100% | <90% |
+| Placeholders | 0 | 1-5 | >5 |
+| Line Accuracy | ≥60% | 50-60% | <50% |

package/skills/verify-docs/SKILL.md

@@ -1,77 +1,77 @@
----
-description: Verify documentation line numbers match current code state
----
-
-# Context Engineering: Verify Documentation
-
-Check if documentation line numbers still match the actual code.
-
-## Purpose
-
-After code changes, line numbers in documentation may drift. This skill:
-1. Finds all `file:line` references in `.claude/` documentation
-2. Verifies the referenced lines exist and match described content
-3. Reports accuracy and suggests fixes
-
-## Process
-
-1. **Scan Documentation**
-   - Find all patterns like `file.py:123` or `[file.py:123]`
-   - Extract file path and line number
-
-2. **Verify References**
-   - Check if file exists
-   - Check if line number is within file bounds
-   - Sample content to verify it matches description
-
-3. **Calculate Accuracy**
-   - Total references found
-   - Valid references
-   - Accuracy percentage
-
-4. **Generate Report**
-   ```
-   Documentation Accuracy Report
-   =============================
-   Total References: 156
-   Valid: 142
-   Invalid: 14
-   Accuracy: 91%
-
-   Invalid References:
-   - context/workflows/auth.md:45 → src/auth.py:230 (line moved to 245)
-   - context/workflows/api.md:12 → src/api.py:100 (file renamed)
-   ```
-
-## Usage
-
-Check specific file:
-```
-/context-eng:verify-docs path/to/changed/file.py
-```
-
-Check all documentation:
-```
-/context-eng:verify-docs
-```
-
-Auto-fix (update line numbers):
-```
-/context-eng:verify-docs --fix
-```
-
-## Target Accuracy
-
-| Level | Accuracy | Action |
-|-------|----------|--------|
-| Excellent | ≥80% | No action needed |
-| Good | 60-80% | Update when convenient |
-| Warning | 40-60% | Update soon |
-| Critical | <40% | Update immediately |
-
-## When to Run
-
-- After refactoring
-- After adding/removing significant code
-- Before creating a PR
-- Weekly maintenance
+---
+description: Verify documentation line numbers match current code state
+---
+
+# Context Engineering: Verify Documentation
+
+Check if documentation line numbers still match the actual code.
+
+## Purpose
+
+After code changes, line numbers in documentation may drift. This skill:
+1. Finds all `file:line` references in `.claude/` documentation
+2. Verifies the referenced lines exist and match described content
+3. Reports accuracy and suggests fixes
+
+## Process
+
+1. **Scan Documentation**
+   - Find all patterns like `file.py:123` or `[file.py:123]`
+   - Extract file path and line number
+
+2. **Verify References**
+   - Check if file exists
+   - Check if line number is within file bounds
+   - Sample content to verify it matches description
+
+3. **Calculate Accuracy**
+   - Total references found
+   - Valid references
+   - Accuracy percentage
+
+4. **Generate Report**
+   ```
+   Documentation Accuracy Report
+   =============================
+   Total References: 156
+   Valid: 142
+   Invalid: 14
+   Accuracy: 91%
+
+   Invalid References:
+   - context/workflows/auth.md:45 → src/auth.py:230 (line moved to 245)
+   - context/workflows/api.md:12 → src/api.py:100 (file renamed)
+   ```
+
+## Usage
+
+Check specific file:
+```
+/context-eng:verify-docs path/to/changed/file.py
+```
+
+Check all documentation:
+```
+/context-eng:verify-docs
+```
+
+Auto-fix (update line numbers):
+```
+/context-eng:verify-docs --fix
+```
+
+## Target Accuracy
+
+| Level | Accuracy | Action |
+|-------|----------|--------|
+| Excellent | ≥80% | No action needed |
+| Good | 60-80% | Update when convenient |
+| Warning | 40-60% | Update soon |
+| Critical | <40% | Update immediately |
+
+## When to Run
+
+- After refactoring
+- After adding/removing significant code
+- Before creating a PR
+- Weekly maintenance

package/.claude-plugin/plugin.json

@@ -1,23 +0,0 @@
-{
-  "name": "claude-context-engineering",
-  "version": "1.0.0",
-  "displayName": "Context Engineering",
-  "description": "RPI workflow and context optimization for Claude Code - Research, Plan, Implement with file:line precision",
-  "author": {
-    "name": "SireJeff"
-  },
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/SireJeff/claude-context-engineering-template"
-  },
-  "keywords": [
-    "context-engineering",
-    "rpi-workflow",
-    "documentation",
-    "productivity"
-  ],
-  "claudeCode": {
-    "minVersion": "1.0.33"
-  }
-}