@ekkos/cli 1.3.1 → 1.3.5

package/templates/skills/ekkOS_Learn/Skill.md

@@ -1,265 +0,0 @@
----
-name: ekkOS_Learn
-description: Capture solutions as patterns for future use. Activate when you fix a bug, solve a non-trivial problem, get corrected by the user, discover something that works (or doesn't work), find a better approach, or complete any solution worth remembering. Failures are just as valuable as successes - forge anti-patterns too.
-allowed-tools:
-  - mcp__ekkos-memory__ekkOS_Forge
-  - mcp__ekkos-memory__ekkOS_Outcome
-  - mcp__ekkos-memory__ekkOS_Track
-  - mcp__ekkos-memory__ekkOS_Search
----
-
-# ekkOS_Learn
-
-You are augmented with **ekkOS_ memory** - and your job is to make it SMARTER over time by forging what you learn.
-
-## Why This Skill Exists
-
-The Stop hook detects `[ekkOS_LEARN]` markers in your responses and auto-forges patterns. This skill teaches you **WHEN** to add those markers and **HOW** to forge patterns directly.
-
-**The Golden Rule**: If you solved something non-trivial, FORGE IT. If something didn't work, FORGE IT AS AN ANTI-PATTERN. Every forged pattern makes future sessions smarter.
-
-## When To Activate
-
-This skill should trigger when you detect:
-
-| Trigger | What To Forge |
-|---------|---------------|
-| **Bug fixed** | Problem + root cause + solution |
-| **Non-trivial solution** | The approach that worked |
-| **User corrected you** | What you got wrong + the correct way |
-| **Unexpected success** | Why it worked (capture the insight) |
-| **Unexpected failure** | Why it didn't work (anti-pattern) |
-| **Better approach found** | The improvement over first attempt |
-| **Configuration solved** | Setup steps that worked |
-| **Architecture decision** | The decision + rationale |
-| **Gotcha discovered** | The pitfall + how to avoid it |
-
-## Pattern vs Anti-Pattern
-
-**Patterns** = Things that WORK
-```
-Title: "Fix JWT expiration errors with clock tolerance"
-Problem: "JWT tokens rejected as expired due to clock skew"
-Solution: "Add clockTolerance: 30 to jwt.verify options"
-```
-
-**Anti-Patterns** = Things that DON'T WORK
-```
-Title: "Don't use setTimeout for rate limiting"
-Problem: "Tried setTimeout to throttle API calls"
-Solution: "This doesn't work because... Use debounce instead"
-anti_patterns: ["setTimeout for throttling"]
-```
-
-**BOTH ARE VALUABLE.** Anti-patterns prevent repeating mistakes.
-
-## Instructions
-
-### Method 1: Marker-Based (Recommended)
-
-Add a marker in your response that the Stop hook will detect:
-
-```
-[ekkOS_LEARN] Forging: "Your Pattern Title"
-```
-
-The hook extracts:
-- Title from the marker
-- Problem from user's question
-- Solution from your response
-
-**Example:**
-```
-The issue was that the database connection wasn't being released.
-Here's the fix:
-
-```typescript
-finally {
-  await connection.release();
-}
-```
-
-[ekkOS_LEARN] Forging: "Always release database connections in finally block"
-```
-
-### Method 2: Direct Forge (For Complex Patterns)
-
-For patterns that need specific structure:
-
-```
-ekkOS_Forge({
-  title: "Handle race conditions in React useEffect",
-  problem: "Multiple rapid state updates cause stale closures",
-  solution: "Use cleanup function with cancelled flag: let cancelled = false; return () => { cancelled = true; }",
-  tags: ["react", "useEffect", "race-condition", "hooks"],
-  works_when: ["async operations in useEffect", "rapid re-renders"],
-  anti_patterns: ["ignoring cleanup", "not checking cancelled flag"]
-})
-```
-
-### Method 3: Report Outcome (After Applying Patterns)
-
-When you apply a pattern from search, report if it worked:
-
-```
-ekkOS_Outcome({
-  success: true,  // or false if it didn't work
-  model_used: "claude-opus-4-5"
-})
-```
-
-This helps the system learn which patterns are reliable.
-
-## What Makes a Good Pattern
-
-### Good Pattern Titles
-- "Fix CORS errors by setting correct headers"
-- "Prevent memory leaks in event listeners"
-- "Handle null values in JSON parsing"
-
-### Bad Pattern Titles
-- "Fixed the bug" (too vague)
-- "Solution" (no context)
-- "Code change" (not descriptive)
-
-### Good Problem Descriptions
-- Specific error message or symptom
-- Context where it occurred
-- What was expected vs what happened
-
-### Good Solutions
-- The specific fix or approach
-- Why it works (the insight)
-- Any caveats or edge cases
-
-## Forge Triggers Checklist
-
-Ask yourself after solving anything:
-
-- [ ] Was this non-trivial? → FORGE
-- [ ] Did the user teach me something? → FORGE (they corrected me)
-- [ ] Would I want to remember this? → FORGE
-- [ ] Did something NOT work? → FORGE AS ANTI-PATTERN
-- [ ] Is this project-specific? → FORGE with project tags
-- [ ] Is this universal? → FORGE for collective layer
-
-## Integration with Hooks
-
-```
-┌─────────────────────────────────────────────────────────────────┐
-│  YOUR RESPONSE                                                   │
-│  └── Include [ekkOS_LEARN] marker if you solved something       │
-│           ↓                                                      │
-│  STOP HOOK                                                       │
-│  └── Detects marker, extracts title                             │
-│  └── Calls ekkOS_Forge with problem/solution                    │
-│           ↓                                                      │
-│  MEMORY SUBSTRATE                                                │
-│  └── Pattern saved to Layer 4                                   │
-│  └── Indexed for future retrieval                               │
-│           ↓                                                      │
-│  NEXT SESSION                                                    │
-│  └── Pattern retrieved when similar problem arises              │
-└─────────────────────────────────────────────────────────────────┘
-```
-
-## Example Scenarios
-
-### Scenario 1: Bug Fix
-```
-User: "My API keeps timing out"
-
-You: *investigate*
-     *find the issue*
-
-     "The problem is connection pooling. Your pool was set to
-      max 5 connections but you have 20 concurrent requests.
-
-      Fix: Increase pool size to match expected concurrency:
-      ```
-      pool: { max: 25, min: 5, idle: 10000 }
-      ```
-
-      [ekkOS_LEARN] Forging: "Match connection pool size to concurrent request volume"
-```
-
-### Scenario 2: User Correction
-```
-User: "No, that's wrong. You should use useCallback, not useMemo"
-
-You: "You're right, I apologize for the confusion.
-
-      - useMemo: Memoizes a VALUE (result of computation)
-      - useCallback: Memoizes a FUNCTION (prevents recreation)
-
-      For passing callbacks to child components, useCallback is correct.
-
-      [ekkOS_LEARN] Forging: "useCallback for functions, useMemo for values"
-```
-
-### Scenario 3: Anti-Pattern Discovery
-```
-User: "I tried your suggestion but it made things worse"
-
-You: "I see what went wrong. Using synchronous file reads in the
-      request handler blocks the event loop.
-
-      This is an ANTI-PATTERN:
-      ```javascript
-      // DON'T DO THIS
-      const data = fs.readFileSync(path);
-      ```
-
-      Instead, use async:
-      ```javascript
-      const data = await fs.promises.readFile(path);
-      ```
-
-      ekkOS_Forge({
-        title: "Never use sync file operations in request handlers",
-        problem: "Synchronous file reads block Node.js event loop",
-        solution: "Always use fs.promises or callback-based async operations",
-        anti_patterns: ["fs.readFileSync in handlers", "blocking I/O in async context"]
-      })
-```
-
-### Scenario 4: Configuration Success
-```
-User: "Finally got Tailwind working with the monorepo!"
-
-You: "Great! Let me capture that configuration for future reference.
-
-      ekkOS_Forge({
-        title: "Tailwind CSS in Turborepo monorepo setup",
-        problem: "Tailwind not detecting classes across workspace packages",
-        solution: "Add all workspace paths to content array: content: ['./src/**/*.{ts,tsx}', '../../packages/ui/**/*.{ts,tsx}']",
-        tags: ["tailwind", "turborepo", "monorepo", "css"],
-        works_when: ["monorepo with shared UI package", "Turborepo setup"]
-      })
-
-      This is now saved for next time you set up a similar project.
-```
-
-## Success Metrics
-
-You're using this skill correctly when:
-- You forge after EVERY non-trivial solution
-- You capture anti-patterns when things fail
-- You acknowledge user corrections as learning moments
-- Your forge titles are specific and searchable
-- You include both WHAT worked and WHY
-
-## Remember
-
-**The memory only gets smarter if you teach it.**
-
-Every pattern you forge helps:
-- Future you (in the next session)
-- This user (across all their projects)
-- Other users (via collective layer)
-
-Don't be stingy with forging. If in doubt, FORGE.
-
----
-
-**Mantra**: Solved it? Forge it. Broke it? Forge the anti-pattern. Learned something? Forge it.

package/templates/skills/ekkOS_Memory_First/Skill.md

@@ -1,206 +0,0 @@
----
-name: ekkOS_Memory_First
-description: Search your memory before solving problems. Activate when debugging errors, discussing architecture, answering "how do I...", fixing bugs, making technical decisions, or when you realize mid-response that past solutions might help. This skill ensures you check existing patterns BEFORE reasoning from scratch.
-allowed-tools:
-  - mcp__ekkos-memory__ekkOS_Search
-  - mcp__ekkos-memory__ekkOS_Context
-  - mcp__ekkos-memory__ekkOS_Codebase
-  - mcp__ekkos-memory__ekkOS_Track
-  - Read
-  - Glob
----
-
-# ekkOS_Memory_First
-
-You are augmented with **ekkOS_ memory** - a cognitive substrate that remembers solutions from past conversations.
-
-## Why This Skill Exists
-
-The UserPromptSubmit hook already injects patterns at the START of each turn. This skill activates **MIDSTREAM** when you realize:
-- The initial patterns weren't enough
-- You need project-specific context (codebase layer)
-- A follow-up search would help
-- The problem is evolving and you need fresh patterns
-
-## When To Activate
-
-This skill should trigger when you detect:
-
-| Trigger | Example |
-|---------|---------|
-| Debugging | "Why is X failing?", "error", "not working", "bug" |
-| Architecture | "How should I structure...", "best approach", "design pattern" |
-| Implementation | "How do I...", "what's the pattern for", "implement" |
-| Configuration | "setup", "config", "environment", "deploy" |
-| Mid-response realization | "Wait, I might have solved this before..." |
-
-## Instructions
-
-### Step 1: Assess What You Already Have
-
-The hook may have already injected patterns. Check if they're sufficient:
-- Are the patterns relevant to THIS specific problem?
-- Do you need more context about the codebase?
-- Has the problem evolved since the initial query?
-
-If patterns were injected and are sufficient, acknowledge them and proceed.
-
-### Step 2: Search for Additional Context (If Needed)
-
-**For general patterns:**
-```
-ekkOS_Search({
-  query: "<specific problem description>",
-  sources: ["patterns", "collective"],
-  limit: 5
-})
-```
-
-**For project-specific patterns:**
-```
-ekkOS_Codebase({
-  query: "<what you're looking for in this project>",
-  limit: 5
-})
-```
-
-**For task context (combines patterns + episodes):**
-```
-ekkOS_Context({
-  task: "<what you're trying to accomplish>"
-})
-```
-
-### Step 3: Acknowledge What You Found
-
-**When you find relevant patterns:**
-```
-🧠 I remember solving something like this...
-
-[Reference the pattern title and key insight]
-```
-
-**When applying a pattern:**
-```
-Using your approach from "[Pattern Title]"...
-```
-
-**When patterns don't quite fit:**
-```
-I found some related patterns, but this seems like a new variation.
-Let me solve it and we can save the solution for next time.
-```
-
-### Step 4: Track Usage (For Learning)
-
-When you apply a pattern, track it:
-```
-ekkOS_Track({
-  pattern_id: "<id from search>",
-  retrieval_id: "<from search response>"
-})
-```
-
-This helps the system learn which patterns are most useful.
-
-## Fallback Behavior
-
-If the MCP server is unavailable:
-
-1. **Check local cache:**
-   - Read `.ekkos/patterns/recent.json`
-   - Read `.ekkos/patterns/project.json`
-
-2. **If no cache:**
-   - Proceed without memory
-   - Note: "🧠 Memory unavailable - solving from first principles"
-   - The solution can still be forged later
-
-## What NOT To Do
-
-- **Don't duplicate hook retrieval** - If patterns were already injected at turn start, don't re-search the same query
-- **Don't over-search** - One focused search is better than many broad ones
-- **Don't ignore results** - If patterns are retrieved, acknowledge them (SELECT or SKIP)
-- **Don't fabricate patterns** - Only reference patterns that were actually retrieved
-
-## Integration with Golden Loop
-
-This skill is the **RETRIEVE** phase of the Golden Loop:
-
-```
-┌─────────────────────────────────────────────────────────────────┐
-│  RETRIEVE (This Skill)                                          │
-│  ├── Hook injects patterns at turn start                        │
-│  └── Skill searches midstream when needed                       │
-│           ↓                                                      │
-│  REASON (Your Response)                                         │
-│  └── Apply patterns to solve the problem                        │
-│           ↓                                                      │
-│  FORGE (ekkOS_Learn Skill)                                      │
-│  └── Save novel solutions as new patterns                       │
-│           ↓                                                      │
-│  APPLY (Next Time)                                              │
-│  └── Retrieved patterns make future responses better            │
-└─────────────────────────────────────────────────────────────────┘
-```
-
-## Example Scenarios
-
-### Scenario 1: Debugging Question
-```
-User: "Why is my API returning 500 errors?"
-
-[Hook already injected 2 patterns about error handling]
-
-You: *Check if injected patterns are relevant*
-     *They're about frontend errors, not API*
-
-     "Let me search for API-specific patterns..."
-
-     ekkOS_Search({query: "API 500 error server backend", sources: ["patterns"]})
-
-     "🧠 I remember - we solved a similar issue last month.
-      It was related to connection pooling timeouts..."
-```
-
-### Scenario 2: Architecture Discussion
-```
-User: "How should I structure the authentication system?"
-
-[Hook injected 1 pattern about JWT]
-
-You: *Pattern is relevant but need more context*
-
-     ekkOS_Codebase({query: "authentication auth login session"})
-
-     "I found your existing auth patterns in this codebase.
-      You're using JWT with refresh tokens. Building on that..."
-```
-
-### Scenario 3: Mid-Response Realization
-```
-User: "Help me optimize this database query"
-
-[No patterns injected - hook found nothing]
-
-You: *Start analyzing the query*
-     *Realize: "Wait, we optimized something similar before"*
-
-     ekkOS_Search({query: "database query optimization SQL performance"})
-
-     "🧠 Actually, I remember we solved a similar optimization.
-      The key was adding an index on the foreign key..."
-```
-
-## Success Metrics
-
-You're using this skill correctly when:
-- You search BEFORE saying "I don't know" or "I'm not sure"
-- You acknowledge patterns that were retrieved
-- You credit past solutions when applying them
-- You don't repeat searches the hook already did
-- Users hear "I remember..." more often than "Let me figure this out from scratch..."
-
----
-
-**Remember**: Every pattern you find was a solution that worked before. Trust the memory. Use it first.