k0ntext 3.0.0

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

@@ -0,0 +1,150 @@
+---
+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

@@ -0,0 +1,143 @@
+---
+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

@@ -0,0 +1,103 @@
+---
+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

@@ -0,0 +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% |

package/skills/verify-docs/SKILL.md

@@ -0,0 +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