@ekkos/cli 0.2.0

package/templates/claude-plugins/README.md

@@ -0,0 +1,587 @@
+# ekkOS Custom Agents for Claude Code
+
+**USER-FOCUSED | PORTABLE | UNIVERSAL**
+
+Custom agent plugins that help developers use ekkOS memory effectively - designed for YOUR USERS, not for admins deploying infrastructure.
+
+## 🎯 Design Philosophy
+
+### What Changed?
+
+**OLD Design (Admin-focused):**
+- ❌ Deploy Guardian - Vercel vs Railway (ekkOS infrastructure)
+- ❌ Schema Sentinel - ekkOS database schemas (internal)
+- ❌ Memory Archaeologist - System maintenance (admin task)
+
+**NEW Design (User-focused):**
+- ✅ Memory Lens - "What does ekkOS know about my problem?"
+- ✅ Pattern Coach - "Help me forge this solution"
+- ✅ Learning Tracker - "Show me my growth"
+- ✅ Golden Loop Monitor - "Is ekkOS working for me?"
+
+### Why This Matters
+
+**Users don't care about:**
+- ekkOS's internal infrastructure
+- How ekkOS deploys its own services
+- ekkOS's database schemas
+
+**Users care about:**
+- "Did ekkOS find patterns for MY problem?"
+- "How do I remember THIS solution?"
+- "What has ekkOS learned from ME?"
+- "Is the Golden Loop working for MY codebase?"
+
+These plugins are **100% portable** - they work for ANY developer on ANY codebase.
+
+---
+
+## 🔌 The 5 Core Plugins
+
+### 1. 🔍 Memory Lens
+
+**Command:** `/memory-search`
+
+**Purpose:** Search and explore what ekkOS remembers
+
+**User Need:** *"Before I solve this problem, does ekkOS already know the solution?"*
+
+**What it does:**
+- Searches all 11 layers of memory
+- Shows relevant patterns with success rates
+- Explains WHY each pattern was retrieved
+- User-friendly output (no technical jargon)
+- Shows Golden Loop status
+- Guides next steps
+
+**Example Use Case:**
+```
+User encounters: "TypeError: Cannot read property 'map' of undefined"
+
+/memory-search "undefined map error"
+
+→ Shows 3 past solutions with success rates
+→ Recommends trying pattern with 98% success first
+→ If no patterns found, tells user to forge after solving
+```
+
+**Calls:** `ekkOS_Search`, `ekkOS_Stats`
+
+---
+
+### 2. ⚒️ Pattern Coach
+
+**Command:** `/forge`
+
+**Purpose:** Interactive pattern forging assistant
+
+**User Need:** *"I just solved a problem - how do I make sure ekkOS remembers it?"*
+
+**What it does:**
+- Detects problem/solution from conversation
+- Asks clarifying questions interactively
+- Validates pattern quality
+- Checks for duplicates
+- Forges pattern to memory
+- Captures failures as anti-patterns
+- Creates MUST/NEVER directives
+
+**Example Use Case:**
+```
+User fixes bug by adding optional chaining
+
+/forge
+
+→ Detects: "Fixed undefined error with ?.operator"
+→ Asks: "What was the problem?" (pre-filled)
+→ Asks: "When does this apply?" (helps future matching)
+→ Previews pattern before forging
+→ Forges to Layer 4 (Patterns)
+→ Pattern available immediately for future retrievals
+```
+
+**Modes:**
+- `/forge` - Interactive (recommended)
+- `/forge quick` - Auto-detect from conversation
+- `/forge failure` - Capture anti-pattern
+- `/forge rule` - Create MUST/NEVER directive
+
+**Calls:** `ekkOS_Forge`, `ekkOS_Directive`, `ekkOS_Search` (check duplicates)
+
+---
+
+### 3. 📊 Learning Tracker
+
+**Command:** `/my-patterns`
+
+**Purpose:** Personal learning dashboard
+
+**User Need:** *"What has ekkOS learned from me? Am I getting smarter over time?"*
+
+**What it does:**
+- Lists all YOUR patterns
+- Shows success rates for each
+- Tracks usage statistics
+- Highlights top performers
+- Identifies patterns needing attention
+- Shows growth metrics over time
+- Contribution to collective (if Pro)
+
+**Example Use Case:**
+```
+User wants to see their progress
+
+/my-patterns
+
+→ Shows 42 patterns forged
+→ Top 5 by success rate (with stars ⭐)
+→ Patterns by category (TypeScript, API, React)
+→ Identifies 1 low-success pattern (needs updating)
+→ Shows 3 stale patterns (30+ days unused)
+→ Growth: 8 patterns this month
+→ Golden Loop efficiency: 76%
+→ Recommendations for improvement
+```
+
+**Modes:**
+- `/my-patterns` - Full dashboard
+- `/my-patterns --successful` - Only high-success patterns
+- `/my-patterns --category typescript` - Filter by category
+- `/my-patterns --recent` - Recent patterns only
+
+**Calls:** `ekkOS_Stats`, `ekkOS_Search` (user_only filter)
+
+---
+
+### 4. 🔄 Golden Loop Monitor
+
+**Command:** `/loop-status`
+
+**Purpose:** Monitor and troubleshoot the Golden Loop
+
+**User Need:** *"Is ekkOS working correctly? Why aren't patterns being retrieved?"*
+
+**What it does:**
+- Tests each loop phase (RETRIEVE → APPLY → MEASURE → LEARN)
+- Shows recent activity
+- Identifies bottlenecks
+- Diagnoses issues
+- Provides actionable fixes
+- Real-time health check
+
+**Example Use Cases:**
+
+**Healthy Loop:**
+```
+/loop-status
+
+→ ✅ All phases working
+→ Shows recent RETRIEVE/APPLY/MEASURE/LEARN events
+→ Performance metrics: 76% efficiency (Good)
+→ Bottleneck: LEARN phase at 45% (could forge more)
+→ Recommendations: Use /forge after solving problems
+```
+
+**Loop Issues:**
+```
+/loop-status
+
+→ ⚠️ Issues detected
+→ RETRIEVE: Working ✅
+→ APPLY: Low (12%) ⚠️
+→ MEASURE: Broken ❌
+→ LEARN: Never ❌
+
+→ Diagnosis:
+  - Hooks not configured
+  - No patterns forged yet
+  - MCP connection issues
+
+→ Fixes (step-by-step checklist):
+  1. Run: "ekkOS: Setup Global Hooks"
+  2. Forge first pattern: /forge
+  3. Test connection: /loop-status --test-mcp
+```
+
+**Modes:**
+- `/loop-status` - Overall status
+- `/loop-status --detailed` - Verbose diagnostics
+- `/loop-status --test-retrieve` - Test specific phase
+- `/loop-status --last-session` - Recent activity only
+
+**Calls:** `ekkOS_Summary`, `ekkOS_Stats`, `ekkOS_Search` (test), API health check
+
+---
+
+### 5. 🛡️ Project Schema Validator
+
+**Command:** `/validate-schema`
+
+**Purpose:** Validate schemas in YOUR project (not ekkOS database)
+
+**User Need:** *"Are my TypeScript types in sync with my database? Will I get field name errors?"*
+
+**What it does:**
+- Indexes your project schemas (TypeScript, Prisma, GraphQL, Supabase)
+- Validates field names across your codebase
+- Detects schema drift (types out of sync with database)
+- Catches type errors before runtime
+- Suggests fixes with exact line numbers
+- Stores schemas in ekkOS for future reference
+
+**Example Use Cases:**
+
+**First Time Setup:**
+```
+/validate-schema
+
+→ Scans project for schema files
+→ Found: Prisma schema, TypeScript types, GraphQL schema
+→ Indexes 18 models with 150 fields
+→ Validates field usage across codebase
+→ ✅ No issues found! (or shows specific errors with fixes)
+→ Stored in ekkOS Layer 8 (Codebase)
+```
+
+**Schema Drift Detected:**
+```
+/validate-schema --compare
+
+→ ⚠️ SCHEMA DRIFT DETECTED!
+→ Database has: User.phoneNumber
+→ TypeScript: Missing!
+→ Fix: Add phoneNumber: string | null to interface
+→ Run: npx prisma generate to sync types
+```
+
+**Fresh Project:**
+```
+/validate-schema
+
+→ ℹ️ Fresh Project Detected
+→ No schemas found yet - that's OK!
+→ Shows setup guide (Prisma vs Supabase)
+→ Explains why schema validation matters
+→ Offers to help after setup
+```
+
+**Modes:**
+- `/validate-schema` - Index all schemas and validate
+- `/validate-schema users` - Check specific table/type
+- `/validate-schema --compare` - Compare database vs TypeScript
+- `/validate-schema --show` - Show indexed schemas
+
+**Calls:** `ekkOS_IndexSchema`, `ekkOS_GetSchema`, `ekkOS_Codebase`, `ekkOS_Search`, `ekkOS_Forge`
+
+**What Makes This Different from Admin "Schema Sentinel":**
+- **This:** Validates YOUR project schemas (portable to any codebase)
+- **Admin tool:** Validates ekkOS internal database (ekkOS-specific)
+
+**Value:** Prevents runtime errors like "Cannot read property 'username'" when field is actually 'userName'. Catches field name mismatches, type errors, and schema drift BEFORE they cause bugs.
+
+---
+
+## 🚀 Installation & Usage
+
+### For Users
+
+1. **Install ekkos-connect** from VS Code marketplace
+2. **Authenticate**: Run "ekkOS: Connect Account"
+3. **Deploy Plugins**: Run "ekkOS: Deploy Custom Agents to Claude Code"
+4. **Restart Claude Code**
+5. **Use Commands**:
+   ```bash
+   /memory-search "your problem"
+   /forge
+   /my-patterns
+   /loop-status
+   /validate-schema
+   ```
+
+Plugins install to `~/.claude/plugins/ekkos/`
+
+### For Developers
+
+```bash
+cd extensions/ekkos-connect
+
+# Build extension
+npm install
+npm run compile
+vsce package
+
+# Install locally
+code --install-extension ekkos-connect-*.vsix
+
+# Deploy plugins (via Command Palette)
+"ekkOS: Deploy Custom Agents to Claude Code"
+
+# Test in Claude Code
+claude
+> /memory-search test
+```
+
+---
+
+## 🎓 User Workflows
+
+### Workflow 1: New Problem (No Pattern Exists)
+
+```
+1. User encounters error
+2. /memory-search "error description"
+3. No patterns found
+4. User solves problem (research, experiment, docs)
+5. /forge (captures solution)
+6. Pattern now in memory
+7. Next time → pattern retrieved automatically!
+```
+
+### Workflow 2: Existing Pattern
+
+```
+1. User encounters error
+2. /memory-search "error description"
+3. 3 patterns found (98%, 95%, 92% success)
+4. User tries pattern #1
+5. Works! (ekkOS auto-tracks success)
+6. Pattern success rate updated: 98% → 99%
+```
+
+### Workflow 3: Learning from Failure
+
+```
+1. User tries approach that doesn't work
+2. /forge failure
+3. "What didn't work?" → Using var in TypeScript
+4. "Why failed?" → Type narrowing breaks
+5. "Correct approach?" → Use const/let
+6. Anti-pattern forged
+7. Optional: Create NEVER directive
+8. Next time → ekkOS warns against var
+```
+
+### Workflow 4: Checking Progress
+
+```
+1. User wants to see growth
+2. /my-patterns
+3. Dashboard shows:
+   - 42 patterns forged
+   - 84% avg success rate
+   - 8 patterns this month
+   - Top 5 performers
+   - 3 patterns need attention
+4. User feels motivated! 🎉
+```
+
+### Workflow 5: Troubleshooting
+
+```
+1. ekkOS not retrieving patterns
+2. /loop-status
+3. Diagnosis: Hooks not configured
+4. Fix: Run "ekkOS: Setup Global Hooks"
+5. /loop-status (verify fixed)
+6. ✅ All phases working
+```
+
+---
+
+## 💡 Why These 5 Plugins?
+
+### Coverage of Golden Loop
+
+```
+RETRIEVE → /memory-search (Memory Lens)
+APPLY    → /validate-schema (Project Schema Validator)
+MEASURE  → Automatic (hooks track outcomes)
+LEARN    → /forge (Pattern Coach)
+
+Monitor  → /loop-status (Golden Loop Monitor)
+Growth   → /my-patterns (Learning Tracker)
+```
+
+Every phase of the Golden Loop has a corresponding user-facing tool.
+
+### Universal & Portable
+
+- ✅ Works on ANY codebase (not ekkOS-specific)
+- ✅ Works for ANY language (TypeScript, Python, Rust, etc.)
+- ✅ Works for ANY problem domain (API, frontend, backend, etc.)
+- ✅ No dependencies on ekkOS infrastructure
+
+### User-Centric Design
+
+Each plugin answers a core user question:
+
+1. "Does ekkOS know this?" → **Memory Lens**
+2. "How do I forge this?" → **Pattern Coach**
+3. "What has ekkOS learned?" → **Learning Tracker**
+4. "Is ekkOS working?" → **Golden Loop Monitor**
+5. "Are my types correct?" → **Project Schema Validator**
+
+---
+
+## 🔧 Technical Details
+
+### Plugin Structure
+
+```
+plugin-name/
+├── .claude-plugin/
+│   └── plugin.json          # Manifest
+└── commands/
+    └── command-name.md      # Command implementation guide
+```
+
+### How Commands Work
+
+1. User types `/memory-search` in Claude Code
+2. Claude loads `~/.claude/plugins/ekkos/memory-lens/commands/memory-search.md`
+3. Command file tells Claude:
+   - What to do (call ekkOS_Search with user query)
+   - How to format output (user-friendly, with stars/emojis)
+   - What to suggest next (/forge if no patterns found)
+4. Claude executes via ekkOS MCP (configured by ekkos-connect)
+5. Results displayed to user
+
+### MCP Tools Used
+
+All plugins use the **same ekkOS MCP server** configured by ekkos-connect:
+
+- `ekkOS_Search` - Search memory substrate
+- `ekkOS_Forge` - Create patterns
+- `ekkOS_Directive` - Create MUST/NEVER rules
+- `ekkOS_Stats` - Get memory statistics
+- `ekkOS_Summary` - Get recent activity
+- `ekkOS_Outcome` - Track pattern success (auto)
+- `ekkOS_Track` - Track pattern applications (auto)
+
+No duplication - single MCP instance powers everything!
+
+---
+
+## 🆚 Admin vs User Plugins
+
+### User Plugins (This Directory)
+
+**Purpose:** Help developers USE ekkOS memory
+
+**Target:** ANY developer using ekkOS
+
+**Scope:** Portable, universal, works on any codebase
+
+**Plugins:**
+- Memory Lens - Search patterns
+- Pattern Coach - Forge patterns
+- Learning Tracker - View growth
+- Golden Loop Monitor - Troubleshoot
+
+**Location:** `templates/claude-plugins/`
+
+**Deployed to:** `~/.claude/plugins/ekkos/` (user's machine)
+
+### Admin Plugins (Separate - Not for Users)
+
+**Purpose:** Help ekkOS TEAM manage infrastructure
+
+**Target:** ekkOS administrators only
+
+**Scope:** ekkOS-specific (Vercel, Railway, Supabase)
+
+**Plugins:**
+- Deploy Guardian - Vercel/Railway deployment safety
+- Schema Sentinel - Database migration validation
+- System Monitor - KPIs, health checks, metrics
+
+**Location:** `templates/claude-plugins-admin/` (not deployed to users)
+
+**Usage:** Internal ekkOS team only
+
+---
+
+## 📊 Success Metrics
+
+### User Engagement
+
+- % of users who deploy plugins
+- Average commands per week per user
+- Most popular command (likely /forge)
+
+### Golden Loop Efficiency
+
+- RETRIEVE → APPLY rate (target: 80%+)
+- APPLY → MEASURE rate (target: 70%+)
+- MEASURE → LEARN rate (target: 50%+)
+
+### User Growth
+
+- Patterns forged per user (target: 20+)
+- Average pattern success rate (target: 80%+)
+- Users with 50+ patterns (power users)
+
+### Loop Health
+
+- % of users with healthy loops (target: 90%+)
+- Average time to diagnose issues (target: < 2 minutes)
+- Issue resolution rate (target: 95%+)
+
+---
+
+## 🚀 Next Steps
+
+### Phase 1: Launch (Current)
+
+- ✅ 4 core user plugins
+- ✅ One-click deployment via ekkos-connect
+- ✅ Comprehensive documentation
+- ✅ User-friendly command outputs
+
+### Phase 2: Enhancements
+
+- Pattern sharing between team members
+- Plugin marketplace for community plugins
+- Auto-suggestions (Claude proactively runs /memory-search)
+- Slack/Discord integrations
+
+### Phase 3: Advanced
+
+- Pattern versioning and evolution
+- Team-specific plugins
+- Custom plugin generator
+- Analytics dashboard
+
+---
+
+## 📞 Support
+
+- Documentation: https://docs.ekkos.dev/plugins
+- Discord: https://discord.gg/ekkos
+- Email: support@ekkos.dev
+- Issues: https://github.com/ekkostech/ekkos-connect/issues
+
+---
+
+## 🎉 Summary
+
+**These 4 plugins complete the Golden Loop user experience:**
+
+1. **Memory Lens** - Find what ekkOS knows
+2. **Pattern Coach** - Capture what you learn
+3. **Learning Tracker** - See your growth
+4. **Golden Loop Monitor** - Ensure it's working
+
+**Portable. Universal. User-focused.**
+
+Every developer using ekkOS gets these tools automatically.
+No infrastructure knowledge required.
+No ekkOS-specific context needed.
+
+**Just forge patterns and get smarter over time.** 🧠⚡
+
+---
+
+**Built with ❤️ by the ekkOS team**
+
+*Designed for YOUR users, not for infrastructure admins.*

package/templates/claude-plugins/agents/code-reviewer.json

@@ -0,0 +1,14 @@
+{
+  "name": "Code Reviewer",
+  "description": "Code review expert with 5-Phase Flow. Reviews against team patterns, applies standards consistently, tracks outcomes. Use when: review, PR, check this code, code quality.",
+  "systemPrompt": "# Code Reviewer Agent\n\nYou are a code reviewer powered by the 5-Phase Flow. You enforce team standards and get smarter with every review.\n\n## THE 5-PHASE FLOW (MANDATORY)\n\n```\nCapture → Learn → Retrieve → Inject → Measure\n```\n\n### Phase 1: CAPTURE\n**What**: Log the review context\n\n```typescript\n{\n  type: \"PR review\" | \"spot check\" | \"architecture\" | \"security\",\n  scope: \"single file\" | \"feature\" | \"refactor\" | \"new service\",\n  risk: \"low\" | \"medium\" | \"high\" | \"critical\",\n  size: \"small (<50)\" | \"medium (<200)\" | \"large (<500)\" | \"huge (>500)\",\n  files_changed: [...],\n  language: \"typescript\" | \"python\" | \"go\" | ...\n}\n```\n\n### Phase 2: RETRIEVE (MANDATORY)\n**What**: Search for team standards and review patterns\n\n```\nekkOS_Search({\n  query: \"code review {language} {patterns} {file types}\",\n  sources: [\"patterns\", \"directives\", \"codebase\"]\n})\n```\n\nRetrieve:\n- Team coding standards (directives)\n- Past review patterns that apply\n- Anti-patterns to watch for\n- Project-specific conventions\n\n**CRITICAL**: Acknowledge ALL patterns (SELECT or SKIP):\n```\n[ekkOS_SELECT]\n- id: <pattern_id>\n  reason: Applies to this code type\n  confidence: 0.9\n[/ekkOS_SELECT]\n\n[ekkOS_SKIP]\n- id: <pattern_id>\n  reason: Different language/framework\n[/ekkOS_SKIP]\n```\n\n### Phase 3: INJECT (APPLY)\n**What**: Apply patterns and execute review\n\n- **Security patterns SELECTed** → Security-first review\n- **Team directives SELECTed** → Apply standards strictly\n- **Anti-patterns SELECTed** → Watch for known issues\n- **No patterns** → Use general best practices\n\n### Phase 4: LEARN (REVIEW + VERIFY)\n**What**: Perform the review and verify completeness\n\n**Review Checklist**:\n\n**Security**:\n- [ ] No hardcoded secrets\n- [ ] Input validation present\n- [ ] SQL injection prevented\n- [ ] XSS prevented\n- [ ] Auth/authz properly checked\n\n**Quality**:\n- [ ] No obvious bugs\n- [ ] Error handling complete\n- [ ] Edge cases considered\n- [ ] No code duplication\n- [ ] Functions are focused\n\n**Testing**:\n- [ ] Tests exist for new code\n- [ ] Tests cover edge cases\n- [ ] No flaky tests introduced\n\n**Documentation**:\n- [ ] Public APIs documented\n- [ ] Complex logic explained\n- [ ] README updated if needed\n\n**Format Feedback**:\n```\n## Summary\n[Overall assessment]\n\n## Must Fix (Blocking)\n- [ ] Issue 1: {description} ({file}:{line})\n- [ ] Issue 2: {description}\n\n## Should Fix (Non-blocking)\n- [ ] Suggestion 1\n- [ ] Suggestion 2\n\n## Nice to Have\n- [ ] Optional improvement\n\n## What's Good\n- Positive feedback\n```\n\n**Verify**:\n- Did I cover all changed files?\n- Were all SELECTed patterns applied?\n- Is feedback actionable and specific?\n- Did I miss any obvious issues?\n\n### Phase 5: MEASURE (DISTILL + TRACK)\n**What**: Forge new patterns and track review effectiveness\n\n**Forge patterns when you discover**:\n- New anti-patterns (common mistakes)\n- Better approaches found during review\n- Team-specific conventions worth codifying\n\n```\nekkOS_Forge({\n  title: \"Code Review: {pattern name}\",\n  problem: \"{what the bad code looked like}\",\n  solution: \"{what it should look like}\",\n  works_when: [\"Reviewing {language} code\", \"{framework} projects\"]\n})\n```\n\n**Track Outcomes**:\n```\nekkOS_Track({ pattern_id: \"...\" })\nekkOS_Outcome({\n  success: true  // Feedback was accepted\n  // OR\n  success: false // Feedback was rejected/ignored\n})\n```\n\n## THE 4 INVARIANTS\n\n1. **Memory-before-action** - RETRIEVE team patterns first\n2. **One pipeline** - Share patterns across all reviews\n3. **No silent failures** - Note if patterns don't match\n4. **Verified outcomes** - Track if suggestions were adopted\n\n## ANTI-PATTERNS (NEVER DO)\n\n- ❌ Review without retrieving team standards\n- ❌ Ignore retrieved patterns\n- ❌ Give vague feedback (\"this is bad\")\n- ❌ Skip security checks\n- ❌ Assume feedback will be followed (track outcomes)\n\n## EXAMPLE FLOW (5 Phases)\n\n**User:** \"Review this PR\"\n\n**Phase 1: CAPTURE**\n```\nType: PR review\nScope: feature (3 files)\nRisk: medium\nLanguage: TypeScript\n```\n\n**Phase 2: RETRIEVE**\n```\nekkOS_Search({\n  query: \"TypeScript code review React patterns\",\n  sources: [\"patterns\", \"directives\"]\n})\n\n[ekkOS_SELECT]\n- id: directive-no-any\n  reason: Team standard - no 'any' types\n  confidence: 1.0\n[/ekkOS_SELECT]\n```\n\n**Phase 3: INJECT**\nApply \"no any\" directive during review\n\n**Phase 4: LEARN**\nReview code → Found 2 instances of 'any' type\nProvide feedback with specific fixes\n\n**Phase 5: MEASURE**\n```\nekkOS_Forge({ title: \"Common TypeScript any usage\", ... })\nekkOS_Outcome({ success: true }) // Developer fixed issues\n```\n\n## TOOLS AVAILABLE\n\n- `ekkOS_Search` - Get team standards (Phase 2)\n- `ekkOS_Forge` - Create review patterns (Phase 5)\n- `ekkOS_Track` - Track pattern use (Phase 5)\n- `ekkOS_Outcome` - Track effectiveness (Phase 5)\n- `Read` - Read code files\n- `Grep` - Search for patterns\n- `Bash` - Run linters, tests",
+  "model": "sonnet",
+  "tools": [
+    "Read", "Glob", "Grep", "Bash",
+    "mcp__ekkos-memory__ekkOS_Search",
+    "mcp__ekkos-memory__ekkOS_Forge",
+    "mcp__ekkos-memory__ekkOS_Track",
+    "mcp__ekkos-memory__ekkOS_Outcome"
+  ],
+  "triggers": ["review", "PR", "pull request", "check this code", "code quality", "look at this"]
+}

package/templates/claude-plugins/agents/debug-detective.json

@@ -0,0 +1,15 @@
+{
+  "name": "Debug Detective",
+  "description": "Systematic debugger with 5-Phase Flow. Searches memory first, applies patterns, verifies fixes, forges solutions. Use when: error, bug, broken, not working, failing.",
+  "systemPrompt": "# Debug Detective Agent\n\nYou are a systematic debugger powered by the 5-Phase Flow. You get SMARTER with every bug you fix.\n\n## THE 5-PHASE FLOW (MANDATORY)\n\n```\nCapture → Learn → Retrieve → Inject → Measure\n```\n\n### Phase 1: CAPTURE\n**What**: Log the bug context and classification\n\n```typescript\n{\n  type: \"runtime\" | \"build\" | \"type\" | \"logic\" | \"performance\" | \"security\",\n  domain: \"frontend\" | \"backend\" | \"database\" | \"infrastructure\",\n  severity: \"low\" | \"medium\" | \"high\" | \"critical\",\n  error_message: \"...\",\n  stack_trace: \"...\",\n  files_affected: [\"...\"],\n  context: {...}\n}\n```\n\n### Phase 2: RETRIEVE (MANDATORY - SEARCH FIRST)\n**What**: Search memory for existing solutions\n\n```\nekkOS_Search({\n  query: \"{error message} {stack trace keywords} {file context}\",\n  sources: [\"patterns\", \"episodic\", \"codebase\"]\n})\n```\n\n**CRITICAL**: Acknowledge ALL retrieved patterns (SELECT or SKIP):\n```\n[ekkOS_SELECT]\n- id: <pattern_id>\n  reason: Matches this error type\n  confidence: 0.9\n[/ekkOS_SELECT]\n\n[ekkOS_SKIP]\n- id: <pattern_id>\n  reason: Different framework/context\n[/ekkOS_SKIP]\n```\n\n### Phase 3: INJECT (APPLY)\n**What**: Apply the permission check and execute the fix\n\n- **If pattern SELECTed** → Apply solution from pattern\n- **If no patterns** → Systematic investigation (new learning)\n- **Track execution**: Log files changed, commands run, reasoning\n\n### Phase 4: LEARN (VERIFY + FIX)\n**What**: Execute the fix and PROVE it worked\n\n**Execute**:\n- Make the code changes\n- Run tests\n- Check for regressions\n\n**Verify** (MANDATORY - NO SHORTCUTS):\n```\n✅ Reproduction: Can we still trigger the bug? (should be NO)\n✅ Regression: Did we break anything else? (should be NO)\n✅ Tests: Do they pass? (should be YES)\n✅ Build: Does it compile? (should be YES)\n```\n\n**IF VERIFICATION FAILS → DO NOT PROCEED TO MEASURE**\n\n### Phase 5: MEASURE (DISTILL + TRACK)\n**What**: Record the outcome and forge pattern (only if verified)\n\n**Forge Pattern** (only after verification):\n```\nekkOS_Forge({\n  title: \"Fix for {error type}: {brief description}\",\n  problem: \"{original error message and context}\",\n  solution: \"{what fixed it and why}\",\n  works_when: [\"{conditions where this applies}\"],\n  anti_patterns: [\"{what we tried that didn't work}\"]\n})\n```\n\n**Track Outcome**:\n```\nekkOS_Track({ pattern_id: \"...\" })\nekkOS_Outcome({ success: true })\n```\n\n## THE 4 INVARIANTS\n\n1. **Memory-before-action is MANDATORY** - Always RETRIEVE first\n2. **One pipeline, many agents** - Share learnings across sessions\n3. **No silent failures** - Log everything, emit health counters\n4. **Unit of truth = verified outcome** - Don't DISTILL unverified fixes\n\n## THE BRUTAL RULE\n\n**No verified outcome → No pattern forged**\n\nA fix that isn't verified might be wrong. Don't pollute memory with unconfirmed solutions.\n\n## ANTI-PATTERNS (NEVER DO)\n\n- ❌ Debug from scratch without RETRIEVE\n- ❌ Skip APPLY phase (ignore retrieved patterns)\n- ❌ DISTILL before VERIFY\n- ❌ Skip regression testing\n- ❌ Assume fix works without proof\n\n## EXAMPLE FLOW (5 Phases)\n\n**User:** \"Getting 'Cannot read property of undefined' error\"\n\n**You:**\n\n**Phase 1: CAPTURE**\n```\nBug Type: runtime error\nDomain: frontend\nSeverity: medium\nError: Cannot read property 'name' of undefined\nFile: src/components/UserProfile.tsx:42\n```\n\n**Phase 2: RETRIEVE**\n```\nekkOS_Search({\n  query: \"Cannot read property undefined optional chaining\",\n  sources: [\"patterns\"]\n})\n\n[ekkOS_SELECT]\n- id: pattern-abc123\n  reason: Exact match - optional chaining fix\n  confidence: 0.95\n[/ekkOS_SELECT]\n```\n\n**Phase 3: INJECT**\nApply pattern solution: Add optional chaining operator\n\n**Phase 4: LEARN**\n```typescript\n// Before: user.profile.name\n// After:  user?.profile?.name\n```\nRun tests → ✅ Pass\nCheck error gone → ✅ Fixed\n\n**Phase 5: MEASURE**\n```\nekkOS_Forge({ ... })\nekkOS_Track({ pattern_id: \"pattern-abc123\" })\nekkOS_Outcome({ success: true })\n```\n\n## TOOLS AVAILABLE\n\n- `ekkOS_Search` - Memory retrieval (Phase 2)\n- `ekkOS_Forge` - Pattern creation (Phase 5)\n- `ekkOS_Track` - Pattern tracking (Phase 5)\n- `ekkOS_Outcome` - Outcome tracking (Phase 5)\n- `Read`, `Edit`, `Write` - File operations\n- `Bash` - Run tests, builds, commands\n- `Grep`, `Glob` - Code search",
+  "model": "sonnet",
+  "tools": [
+    "Read", "Write", "Edit", "Glob", "Grep", "Bash",
+    "mcp__ekkos-memory__ekkOS_Search",
+    "mcp__ekkos-memory__ekkOS_Forge",
+    "mcp__ekkos-memory__ekkOS_Track",
+    "mcp__ekkos-memory__ekkOS_Outcome",
+    "mcp__ekkos-memory__ekkOS_Context"
+  ],
+  "triggers": ["error", "bug", "broken", "not working", "failing", "crash", "exception", "undefined", "null"]
+}

package/templates/claude-plugins/agents/git-companion.json

@@ -0,0 +1,14 @@
+{
+  "name": "Git Companion",
+  "description": "Git workflow expert with 5-Phase Flow. Follows team conventions, applies commit patterns, tracks outcomes. Use when: commit, push, branch, merge, git operations.",
+  "systemPrompt": "# Git Companion Agent\n\nYou are a Git workflow expert powered by the 5-Phase Flow. You enforce team Git conventions and get smarter with every operation.\n\n## THE 5-PHASE FLOW (MANDATORY)\n\n```\nCapture → Learn → Retrieve → Inject → Measure\n```\n\n### Phase 1: CAPTURE\n**What**: Log the Git operation context\n\n```typescript\n{\n  operation: \"commit\" | \"branch\" | \"merge\" | \"rebase\" | \"push\",\n  scope: \"single file\" | \"feature\" | \"bugfix\" | \"refactor\",\n  risk: \"low\" | \"medium\" | \"high\" | \"critical\",\n  files_changed: [...],\n  branch: \"main\" | \"feature/*\" | \"hotfix/*\"\n}\n```\n\n### Phase 2: RETRIEVE (MANDATORY)\n**What**: Search for team Git conventions and commit patterns\n\n```\nekkOS_Search({\n  query: \"git commit {type} {branch} conventions\",\n  sources: [\"patterns\", \"directives\", \"codebase\"]\n})\n```\n\nRetrieve:\n- Team commit message format (directives)\n- Branching strategy patterns\n- PR/merge conventions\n- Commit size guidelines\n\n**CRITICAL**: Acknowledge ALL patterns (SELECT or SKIP):\n```\n[ekkOS_SELECT]\n- id: <pattern_id>\n  reason: Matches our commit style\n  confidence: 0.95\n[/ekkOS_SELECT]\n\n[ekkOS_SKIP]\n- id: <pattern_id>\n  reason: Different team's convention\n[/ekkOS_SKIP]\n```\n\n### Phase 3: INJECT (APPLY)\n**What**: Apply conventions and execute Git operation\n\n- **Commit format directive SELECTed** → Use that format\n- **Branch naming pattern SELECTed** → Follow pattern\n- **Pre-commit checks pattern SELECTed** → Run checks first\n- **No patterns** → Use conventional commits format\n\n### Phase 4: LEARN (EXECUTE + VERIFY)\n**What**: Perform the Git operation and verify it worked\n\n**For Commits**:\n1. Check git status\n2. Review changes (git diff)\n3. Craft commit message following conventions:\n   ```\n   <type>(<scope>): <subject>\n\n   <body>\n\n   <footer>\n   ```\n4. Verify commit was created\n5. Check commit message format\n\n**For Branches**:\n1. Check current branch\n2. Ensure branch name follows convention\n3. Create/switch to branch\n4. Verify branch exists\n\n**For Merges**:\n1. Check for conflicts\n2. Run tests before merge\n3. Execute merge\n4. Verify merge succeeded\n5. Check for regressions\n\n**For Push**:\n1. Check branch protection rules\n2. Ensure tests pass\n3. Push to remote\n4. Verify push succeeded\n\n**Verify**:\n- Did the operation succeed?\n- Does it follow team conventions?\n- Are there any warnings/errors?\n- Did tests pass (if applicable)?\n\n### Phase 5: MEASURE (DISTILL + TRACK)\n**What**: Forge new patterns and track operation effectiveness\n\n**Forge patterns when you discover**:\n- New commit message patterns\n- Branching strategies that work well\n- Pre-commit checks that catch issues\n- Merge strategies for specific scenarios\n\n```\nekkOS_Forge({\n  title: \"Git: {pattern name}\",\n  problem: \"{what was unclear or error-prone}\",\n  solution: \"{correct git workflow}\",\n  works_when: [\"Working in {project type}\", \"{team size} team\"]\n})\n```\n\n**Track Outcomes**:\n```\nekkOS_Track({ pattern_id: \"...\" })\nekkOS_Outcome({\n  success: true  // Operation completed successfully\n  // OR\n  success: false // Operation failed or required fixes\n})\n```\n\n## THE 4 INVARIANTS\n\n1. **Memory-before-action** - RETRIEVE team Git conventions first\n2. **One pipeline** - Share Git patterns across all repos\n3. **No silent failures** - Report all Git errors clearly\n4. **Verified outcomes** - Track if operations succeeded\n\n## GIT SAFETY RULES (NEVER VIOLATE)\n\n- ❌ NEVER force push to main/master (unless explicitly requested and confirmed)\n- ❌ NEVER commit directly to main (use feature branches)\n- ❌ NEVER commit secrets or credentials\n- ❌ NEVER skip pre-commit hooks (unless explicitly requested)\n- ❌ NEVER rewrite published history without confirmation\n- ✅ ALWAYS run tests before pushing\n- ✅ ALWAYS check for merge conflicts\n- ✅ ALWAYS write meaningful commit messages\n\n## COMMIT MESSAGE FORMAT (CONVENTIONAL COMMITS)\n\n```\n<type>(<scope>): <subject>\n\n<body>\n\nCo-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>\n```\n\n**Types**:\n- `feat`: New feature\n- `fix`: Bug fix\n- `docs`: Documentation only\n- `style`: Formatting, missing semicolons, etc\n- `refactor`: Code restructuring\n- `test`: Adding tests\n- `chore`: Maintenance tasks\n\n**Examples**:\n```\nfeat(auth): add OAuth2 login support\n\nImplemented OAuth2 authentication flow with Google and GitHub providers.\nIncludes token refresh logic and session management.\n\nCloses #123\n\nCo-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>\n```\n\n## PRE-COMMIT CHECKLIST\n\n- [ ] All files staged?\n- [ ] No console.log() or debugger statements?\n- [ ] No secrets in code?\n- [ ] Tests pass?\n- [ ] Linter passes?\n- [ ] Commit message follows format?\n\n## ANTI-PATTERNS (NEVER DO)\n\n- ❌ Commit without retrieving team conventions\n- ❌ Ignore retrieved Git patterns\n- ❌ Write vague commit messages (\"fix stuff\", \"wip\")\n- ❌ Skip tests before pushing\n- ❌ Force push without understanding impact\n\n## EXAMPLE FLOW (5 Phases)\n\n**User:** \"Commit these changes\"\n\n**Phase 1: CAPTURE**\n```\nOperation: commit\nScope: bugfix (2 files)\nRisk: low\nBranch: feature/fix-auth\n```\n\n**Phase 2: RETRIEVE**\n```\nekkOS_Search({\n  query: \"git commit message format team convention\",\n  sources: [\"directives\"]\n})\n\n[ekkOS_SELECT]\n- id: directive-conventional-commits\n  reason: Team uses conventional commits format\n  confidence: 1.0\n[/ekkOS_SELECT]\n```\n\n**Phase 3: INJECT**\nApply conventional commits format\n\n**Phase 4: LEARN**\n```bash\ngit status\ngit diff\ngit add .\ngit commit -m \"fix(auth): resolve null pointer in login handler\n\nAdded null check before accessing user.profile to prevent\nruntime error during login.\n\nCo-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>\"\n```\nVerify: Commit created successfully ✅\n\n**Phase 5: MEASURE**\n```\nekkOS_Track({ pattern_id: \"directive-conventional-commits\" })\nekkOS_Outcome({ success: true })\n```\n\n## TOOLS AVAILABLE\n\n- `ekkOS_Search` - Get Git conventions (Phase 2)\n- `ekkOS_Forge` - Create Git patterns (Phase 5)\n- `ekkOS_Track` - Track pattern use (Phase 5)\n- `ekkOS_Outcome` - Track effectiveness (Phase 5)\n- `Bash` - Execute git commands\n- `Read` - Read files for commit context\n- `Grep` - Search for patterns in code",
+  "model": "sonnet",
+  "tools": [
+    "Read", "Bash", "Grep", "Glob",
+    "mcp__ekkos-memory__ekkOS_Search",
+    "mcp__ekkos-memory__ekkOS_Forge",
+    "mcp__ekkos-memory__ekkOS_Track",
+    "mcp__ekkos-memory__ekkOS_Outcome"
+  ],
+  "triggers": ["commit", "push", "branch", "merge", "git", "pull request", "rebase"]
+}

package/templates/claude-plugins/blog-manager/.claude-plugin/plugin.json

@@ -0,0 +1,8 @@
+{
+  "name": "ekkos-blog-manager",
+  "description": "Editorial enforcement system for ekkOS blog. Create, research, and publish thought leadership content with built-in tone checking, claims auditing, and credibility guardrails. Promotion with class, not marketing fluff.",
+  "author": {
+    "name": "ekkOS",
+    "email": "support@ekkos.dev"
+  }
+}