k0ntext 3.0.0

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

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

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

@@ -0,0 +1,145 @@
+---
+name: rpi-research
+version: "2.0.0"
+description: "RPI Research Phase: Systematic codebase exploration with parallel agents and chunked output for rpi-plan consumption"
+category: "rpi-orchestration"
+rpi_phase: "research"
+context_budget_estimate: "50K tokens"
+typical_context_usage: "25%"
+parallel_agents: "3-5"
+chunk_output: true
+inter_phase_aware: true
+prerequisites: []
+outputs:
+  - "Research document in .ai-context/research/active/[name]_research.md"
+  - "Chunk manifest with 3-7 research chunks"
+  - "File inventory with line references per chunk"
+  - "Call chain diagrams per chunk"
+  - "Dependency map per chunk"
+  - "Inter-phase contract for rpi-plan"
+next_commands: ["/rpi-plan"]
+related_agents: ["context-engineer", "core-architect"]
+examples:
+  - command: "/rpi-research user-authentication"
+    description: "Research authentication flow with parallel agents creating chunked output"
+  - command: "/rpi-research payment-bug-fix"
+    description: "Investigate payment processing issue across multiple chunks"
+exit_criteria:
+  - "Research document created in .ai-context/research/active/"
+  - "Chunk manifest created with 3-7 chunks"
+  - "All chunks marked as COMPLETE"
+  - "All relevant files identified per chunk (3-20 files total)"
+  - "Call chains traced with line numbers per chunk"
+  - "Dependencies mapped per chunk"
+  - "150-word summary generated"
+  - "Inter-phase contract documented for rpi-plan"
+---
+
+# RPI Research Phase (Enhanced with Parallel Agents & Chunks)
+
+**Purpose:** Systematic, zero-code-modification exploration using parallel agents that produce chunk-structured output for rpi-plan consumption
+
+**Syntax:** `/rpi-research [feature-name]`
+
+**Example:**
+```bash
+/rpi-research user-authentication
+/rpi-research payment-bug-fix
+```
+
+---
+
+## Key Innovation: Inter-Phase Awareness
+
+RPI-Research **KNOWS** how RPI-Plan will consume its output:
+- Output is 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
+
+---
+
+## Parallel Agent Strategy
+
+Spawn 3-5 parallel Explore agents, each focused on a specific domain:
+
+```
+┌─────────────────────────────────────────────────────────┐
+│ PARALLEL AGENT DISPATCH                                 │
+├─────────────────────────────────────────────────────────┤
+│ 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      │
+└─────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Execution Steps
+
+### Step 1: Initialize Research Document
+Create `.ai-context/research/active/[feature]_research.md` from RESEARCH_TEMPLATE.md
+
+### Step 2: Spawn Parallel Agents (3-5 agents)
+
+Each agent receives:
+- Feature name and objective
+- Assigned domain (API, Logic, DB, External, Tests)
+- Required output format (chunk structure)
+- Line number requirement for all file references
+
+### Step 3: Aggregate Chunk Results
+
+Collect outputs from all agents and structure into:
+- Chunk Manifest (table of all chunks with status)
+- Individual chunk sections with full details
+- Inter-phase contract specifying rpi-plan expectations
+
+### Step 4: Generate Summary
+
+Create 150-word summary that:
+- References key files from each chunk
+- Provides overview of feature implementation
+- Recommends approach for planning phase
+
+### Step 5: Finalize Inter-Phase Contract
+
+Document explicitly what RPI-Plan should expect:
+```
+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
+```
+
+---
+
+## Output Format
+
+### Chunk Manifest (Required)
+```markdown
+| Chunk ID | Domain | Status | Files | Ready for Planning |
+|----------|--------|--------|-------|-------------------|
+| CHUNK-R1 | API/Routes | COMPLETE | 3 | ✅ |
+| CHUNK-R2 | Business Logic | COMPLETE | 4 | ✅ |
+...
+```
+
+---
+
+## Context Budget
+
+- Target: 25% of 200k (50k tokens)
+- Per-agent budget: ~10k tokens each
+- Compaction: After each agent returns
+- Final: ~20k tokens (research doc only)
+
+---
+
+## Next Step
+
+After completion: `/rpi-plan [feature-name]`
+
+RPI-Plan will read chunk manifest and create CHUNK-Pn todolist per CHUNK-Rn

package/templates/base/commands/session-resume.md

@@ -0,0 +1,144 @@
+---
+name: session-resume
+description: Resume a previous session with full context restoration
+version: 1.0.0
+category: session
+context_budget: 10000
+inputs:
+  - session/current/state.json
+  - session/history/**/*.json
+outputs:
+  - Restored session context
+---
+
+# /session-resume
+
+Resume a previous session, restoring task context, loaded files reference, and pending updates.
+
+## Syntax
+
+```
+/session-resume [sessionId | --list | --last]
+```
+
+## Options
+
+| Option | Description |
+|--------|-------------|
+| `sessionId` | Resume specific session by ID |
+| `--list` | Show available sessions |
+| `--last` | Resume most recent session (default) |
+| `--checkpoint <id>` | Resume from specific checkpoint |
+
+## Examples
+
+### Resume Last Session
+```
+/session-resume
+```
+or
+```
+/session-resume --last
+```
+
+### List Available Sessions
+```
+/session-resume --list
+```
+Shows recent sessions with IDs, dates, and task names.
+
+### Resume Specific Session
+```
+/session-resume abc123-def456
+```
+
+### Resume from Checkpoint
+```
+/session-resume --checkpoint chk-789xyz
+```
+
+## What Gets Restored
+
+| Data | Action |
+|------|--------|
+| Phase | Set to previous RPI phase |
+| Task | Display task name and description |
+| Files | List files that were loaded (for re-loading) |
+| Pending Updates | Show queued doc updates |
+| Context | Suggest files to reload |
+
+## Resume Flow
+
+1. **Load Session State**
+   - Read from history or current state
+   - Validate session data
+
+2. **Display Summary**
+   ```
+   RESUMING SESSION
+
+   Session: abc123-def456
+   Started: 2025-01-24 10:30:00
+   Phase: implement (Step 3 of 5)
+   Task: Add user authentication
+
+   Files Previously Loaded:
+   - src/auth/login.py
+   - src/models/user.py
+   - tests/test_auth.py
+
+   Pending Documentation Updates: 3
+   - workflows/authentication.md (line numbers shifted)
+   - workflows/user-management.md (new function added)
+
+   Artifacts:
+   - research/active/user-auth_research.md
+   - plans/active/user-auth_plan.md
+   ```
+
+3. **Offer Actions**
+   - [Continue] - Proceed with task
+   - [Load Files] - Reload previously loaded files
+   - [Process Updates] - Run /auto-sync for pending updates
+   - [Start Fresh] - Archive and start new session
+
+## Session List Format
+
+```
+AVAILABLE SESSIONS
+
+ID                    Date        Phase      Task
+────────────────────────────────────────────────────────
+abc123-def456        2025-01-24  implement  Add user auth
+def789-ghi012        2025-01-23  research   Fix payment bug
+jkl345-mno678        2025-01-22  plan       Refactor API
+
+Use: /session-resume <ID>
+```
+
+## Integration with RPI
+
+When resuming during an RPI workflow:
+- **Research phase**: Shows research document path
+- **Plan phase**: Shows plan document path
+- **Implement phase**: Shows current step and remaining steps
+
+## Configuration
+
+In `.ai-context/settings.json`:
+```json
+{
+  "session": {
+    "max_history_days": 30,
+    "auto_archive_completed": true
+  }
+}
+```
+
+## Related Commands
+
+- `/session-save` - Save current session
+- `/collab handoff` - Create team handoff
+- `/rpi-research` - Start research phase
+- `/rpi-plan` - Start plan phase
+- `/rpi-implement` - Start implement phase

package/templates/base/commands/session-save.md

@@ -0,0 +1,112 @@
+---
+name: session-save
+description: Save current session state for later resumption
+version: 1.0.0
+category: session
+context_budget: 5000
+outputs:
+  - session/current/state.json
+  - session/checkpoints/*.json (if checkpoint created)
+---
+
+# /session-save
+
+Save the current session state including task context, loaded files, and pending documentation updates.
+
+## Syntax
+
+```
+/session-save [--checkpoint "description"]
+```
+
+## Options
+
+| Option | Description |
+|--------|-------------|
+| `--checkpoint "desc"` | Create a named checkpoint for easy resumption |
+
+## What Gets Saved
+
+| Data | Description |
+|------|-------------|
+| Session ID | Unique identifier for this session |
+| Phase | Current RPI phase (idle/research/plan/implement) |
+| Task | Active task name and description |
+| Files Loaded | List of files loaded into context |
+| Pending Updates | Documentation updates queued |
+| Checkpoints | Named resume points |
+
+## Examples
+
+### Basic Save
+```
+/session-save
+```
+Saves current state to `.ai-context/session/current/state.json`
+
+### Save with Checkpoint
+```
+/session-save --checkpoint "After completing user auth research"
+```
+Creates a named checkpoint for easy resumption later.
+
+## Automatic Saving
+
+Sessions are automatically saved:
+- Every 5 minutes (configurable in settings.json)
+- On RPI phase transitions
+- Before context compaction
+
+## Resume Later
+
+Use `/session-resume` to restore this session.
+
+## Session Location
+
+```
+.ai-context/session/
+├── current/
+│   └── state.json       # Current session state
+├── history/
+│   └── YYYY-MM-DD/      # Archived sessions by date
+└── checkpoints/
+    └── {id}.json        # Named checkpoints
+```
+
+## Process
+
+1. **Collect State**
+   - Gather current phase, task, loaded files
+   - Collect pending documentation updates
+   - Record context usage metrics
+
+2. **Save to File**
+   - Write to session/current/state.json
+   - Optionally create checkpoint file
+
+3. **Confirm**
+   - Display summary of saved state
+   - Show pending updates count
+
+## Output Format
+
+```
+SESSION SAVED
+
+Session: abc123-def456
+Started: 2025-01-24 10:30:00
+Phase: implement
+Task: Add user authentication
+
+Files Loaded: 12
+Pending Updates: 3
+Checkpoints: 2
+
+Use '/session-resume' to restore this session.
+```
+
+## Related Commands
+
+- `/session-resume` - Resume a saved session
+- `/collab handoff` - Create team handoff document
+- `/auto-sync` - Process pending documentation updates

package/templates/base/commands/validate-all.md

@@ -0,0 +1,77 @@
+---
+name: validate-all
+version: "1.0.0"
+description: "Complete validation suite for the codebase"
+category: "validation"
+context_budget_estimate: "40K tokens"
+typical_context_usage: "20%"
+prerequisites: []
+outputs:
+  - "Validation report with PASS/FAIL per category"
+  - "Documentation accuracy metrics"
+  - "Test results summary"
+  - "Overall READY/NOT READY status"
+next_commands: []
+related_agents: ["context-engineer", "deployment-ops"]
+examples:
+  - command: "/validate-all"
+    description: "Run complete validation before deployment"
+exit_criteria:
+  - "Documentation validation complete"
+  - "Test validation complete"
+  - "Code quality checks complete"
+  - "Configuration validation complete"
+  - "Overall status determined"
+---
+
+# Complete Validation Suite
+
+**Purpose:** Run all validation checks before deployment
+
+**Syntax:** `/validate-all`
+
+---
+
+## Validation Checks
+
+### 1. Documentation Validation
+- All workflows have valid line numbers
+- All markdown links resolve
+- CODE_TO_WORKFLOW_MAP is current
+
+### 2. Test Validation
+- All unit tests pass
+- All integration tests pass
+- Coverage meets threshold
+
+### 3. Code Quality
+- No linting errors
+- Type checking passes (if applicable)
+- No security vulnerabilities
+
+### 4. Configuration Validation
+- All required environment variables defined
+- Configuration files valid
+
+---
+
+## Output Format
+
+```
+VALIDATION REPORT
+
+Documentation:  ✅ PASS / ❌ FAIL
+Tests:          ✅ PASS / ❌ FAIL
+Code Quality:   ✅ PASS / ❌ FAIL
+Configuration:  ✅ PASS / ❌ FAIL
+
+Overall: READY / NOT READY
+```
+
+---
+
+## When to Run
+
+- Before creating PR
+- Before deploying
+- After major refactoring

package/templates/base/commands/verify-docs-current.md

@@ -0,0 +1,86 @@
+---
+name: verify-docs-current
+version: "1.0.0"
+description: "Verify documentation accuracy against current code"
+category: "validation"
+context_budget_estimate: "20K tokens"
+typical_context_usage: "10%"
+prerequisites: []
+outputs:
+  - "Verification report with accuracy status"
+  - "List of outdated line references"
+  - "Link validation results"
+next_commands: []
+related_agents: ["context-engineer"]
+examples:
+  - command: "/verify-docs-current src/services/payment.py"
+    description: "Check documentation for payment service"
+  - command: "/verify-docs-current src/api/routes.py"
+    description: "Verify API routes documentation"
+exit_criteria:
+  - "All affected workflows checked"
+  - "Line number accuracy calculated"
+  - "Links validated"
+  - "Status reported (HEALTHY/NEEDS UPDATE/STALE)"
+---
+
+# Verify Documentation Currency
+
+**Purpose:** Validate that documentation matches current code
+
+**Syntax:** `/verify-docs-current [file_path]`
+
+**Example:**
+```bash
+/verify-docs-current src/services/payment.py
+```
+
+---
+
+## What This Command Does
+
+1. Look up modified file in CODE_TO_WORKFLOW_MAP.md
+2. Find all workflows that document this file
+3. For each workflow:
+   - Extract [Line XXX] references
+   - Read actual code at those lines
+   - Verify function/logic still exists (±10 lines tolerance)
+4. Check all markdown links resolve
+5. Generate accuracy report
+
+---
+
+## Output Format
+
+```
+VERIFICATION REPORT
+
+File: [path/to/file]
+Affected Workflows: X
+
+[workflow_1.md]:
+  ✅ Line XXX (function_name) - Accurate
+  ⚠️ Line YYY (other_func) - Shifted to line ZZZ
+  ❌ Line AAA (deleted_func) - NOT FOUND
+
+Links: X/Y valid (Z%)
+Overall: HEALTHY / NEEDS UPDATE / STALE
+```
+
+---
+
+## Actions Based on Result
+
+| Status | Action Required |
+|--------|-----------------|
+| HEALTHY | No action needed |
+| NEEDS UPDATE | Update line numbers |
+| STALE | Re-document workflow section |
+
+---
+
+## When to Run
+
+- After ANY code modification
+- Before deploying
+- Monthly as maintenance check