@soleri/forge 8.1.0 → 9.0.1

package/dist/skills/fix-and-learn.md

@@ -1,167 +0,0 @@
----
-name: fix-and-learn
-description: Use AFTER systematic-debugging completes to execute the fix and capture the learning in the vault. Invoke this skill when moving from diagnosis to repair for bugs, broken behavior, errors, regressions, or unexpected results. Chains with systematic-debugging — debugging finds root cause, this skill fixes and captures the anti-pattern.
----
-
-# Fix & Learn — Debug, Repair, Capture
-
-Fix bugs through a structured recovery workflow, then capture the root cause as a reusable anti-pattern. The learning step is what makes fixes compound across sessions.
-
-## When to Use
-
-Any time something is broken, behaving unexpectedly, or producing errors. This includes runtime bugs, visual regressions, type errors, and "it used to work" situations.
-
-## The Search Order — MANDATORY
-
-**Never jump to writing code.** Always follow this lookup order:
-
-1. **Vault first** — has this been solved before?
-2. **Web search** — is there a known solution or pattern?
-3. **Plan the fix** — design the approach before touching code
-4. **Implement** — only after steps 1-3
-
-Skipping to implementation is the #1 cause of wasted time and recurring bugs.
-
-## Orchestration Sequence
-
-### Step 1: Classify and Route
-
-Classify the intent to confirm this is a FIX and get routing context:
-
-```
-YOUR_AGENT_core op:route_intent
-  params: { prompt: "<user's bug description>" }
-```
-
-### Step 2: Check Vault First
-
-Search for this bug or similar issues:
-
-```
-YOUR_AGENT_core op:search_intelligent
-  params: { query: "<error message or bug description>" }
-```
-
-Check memory for patterns across sessions:
-
-```
-YOUR_AGENT_core op:memory_search
-  params: { query: "<bug description>" }
-```
-
-Check memory topics — are bugs clustering in a specific area?
-
-```
-YOUR_AGENT_core op:memory_topics
-```
-
-Check memory stats to understand the debugging landscape:
-
-```
-YOUR_AGENT_core op:memory_stats
-```
-
-If vault returns a match with high confidence — **use it**. Don't re-investigate what's already been solved.
-
-### Step 3: Search the Web
-
-If the vault has no answer, search for existing solutions before investigating from scratch:
-
-- Known issues in the library/framework
-- Stack Overflow answers for the exact error
-- GitHub issues on relevant repos
-- Official documentation for the API or feature involved
-
-A 30-second web search can save hours of investigation.
-
-### Step 4: Start Fix Loop
-
-For complex bugs requiring multiple iterations, start a validation loop:
-
-```
-YOUR_AGENT_core op:loop_start
-  params: { prompt: "Fix: <bug description>", mode: "custom" }
-```
-
-### Step 5: Diagnose and Fix
-
-Only if Steps 2-3 didn't produce a solution, apply the systematic debugging approach (use systematic-debugging skill):
-
-1. Reproduce the issue
-2. Isolate the root cause
-3. **Plan the fix before writing code** — even a one-line mental plan
-4. Implement the fix
-5. Verify the fix resolves the issue without regressions
-
-Track each iteration:
-
-```
-YOUR_AGENT_core op:loop_iterate
-```
-
-### Step 6: Validate the Fix
-
-Run the project's test suite to ensure the fix didn't introduce regressions. Use the verification-before-completion skill to confirm all checks pass.
-
-Complete the loop when validated:
-
-```
-YOUR_AGENT_core op:loop_complete
-```
-
-### Step 7: Capture the Learning
-
-This step is critical — it's what makes the agent smarter over time.
-
-```
-YOUR_AGENT_core op:capture_knowledge
-  params: {
-    title: "<bug title>",
-    description: "<root cause, solution, what made it hard to find>",
-    type: "anti-pattern",
-    category: "<domain>",
-    tags: ["<error-type>", "<component>"]
-  }
-```
-
-For quick captures:
-
-```
-YOUR_AGENT_core op:capture_quick
-  params: { title: "<bug>", description: "<root cause and fix>" }
-```
-
-### Step 8: Post-Capture Quality
-
-Run duplicate detection to ensure we didn't create redundant entries:
-
-```
-YOUR_AGENT_core op:curator_detect_duplicates
-```
-
-### Step 9: Verify Health
-
-```
-YOUR_AGENT_core op:admin_health
-```
-
-## Exit Criteria
-
-Fix is complete when: the bug is resolved, tests pass (Step 6), and the root cause is captured in vault (Step 7). A fix without a capture is an incomplete fix.
-
-## Agent Tools Reference
-
-| Op                          | When to Use                    |
-| --------------------------- | ------------------------------ |
-| `route_intent`              | Classify as FIX intent         |
-| `search_intelligent`        | Check vault for known bugs     |
-| `memory_search`             | Search across session memories |
-| `memory_topics`             | See if bugs cluster in an area |
-| `memory_stats`              | Understand debugging landscape |
-| `loop_start`                | Begin iterative fix cycle      |
-| `loop_iterate`              | Track each fix attempt         |
-| `loop_complete`             | Finish fix cycle               |
-| `capture_knowledge`         | Full anti-pattern capture      |
-| `capture_quick`             | Fast capture                   |
-| `curator_detect_duplicates` | Prevent redundant entries      |
-| `admin_health`              | Verify system health           |

package/dist/skills/health-check.md

@@ -1,231 +0,0 @@
----
-name: health-check
-description: Use when the user asks "check health", "vault health", "knowledge quality", "clean up vault", "groom knowledge", "maintenance", "housekeeping", "deduplicate", "find contradictions", or wants to run a maintenance cycle on the knowledge base to keep it healthy and accurate.
----
-
-# Health Check — Knowledge Base Maintenance
-
-Run a comprehensive maintenance cycle on the knowledge base. Finds stale entries, duplicates, contradictions, quality issues, and fixes them. Like a doctor's checkup for your knowledge.
-
-## When to Use
-
-- Weekly/monthly maintenance ritual
-- "Is my vault healthy?"
-- "Clean up my knowledge base"
-- Before a retrospective (clean data = better insights)
-- After a knowledge harvest (post-ingest quality check)
-
-## The Magic: Comprehensive Quality Audit
-
-### Step 1: System Health
-
-```
-YOUR_AGENT_core op:admin_health
-```
-
-```
-YOUR_AGENT_core op:admin_diagnostic
-```
-
-Catches infrastructure issues — database corruption, stale caches, configuration problems.
-
-### Step 2: Vault Metrics
-
-```
-YOUR_AGENT_core op:admin_vault_size
-```
-
-```
-YOUR_AGENT_core op:admin_vault_analytics
-```
-
-```
-YOUR_AGENT_core op:vault_domains
-```
-
-```
-YOUR_AGENT_core op:vault_tags
-```
-
-Shows the big picture: how many entries, which domains, tag distribution.
-
-### Step 3: Quality Audit
-
-Run the curator's health audit — the most comprehensive quality check:
-
-```
-YOUR_AGENT_core op:curator_health_audit
-```
-
-This checks: tag normalization, description quality, severity distribution, domain coverage balance, and overall vault quality score.
-
-### Step 4: Find Duplicates
-
-```
-YOUR_AGENT_core op:curator_detect_duplicates
-```
-
-Present duplicates for review. Offer to merge or remove them.
-
-### Step 5: Find Contradictions
-
-```
-YOUR_AGENT_core op:curator_contradictions
-```
-
-Contradictions are entries that give conflicting advice. Present each pair for the user to resolve:
-
-```
-YOUR_AGENT_core op:curator_resolve_contradiction
-  params: { contradictionId: "<id>" }
-```
-
-### Step 6: Find Stale Entries
-
-```
-YOUR_AGENT_core op:vault_age_report
-```
-
-Entries older than 30 days without updates are candidates for:
-
-- Refresh (still relevant, needs updating)
-- Archive (no longer relevant)
-- Delete (incorrect or superseded)
-
-### Step 7: Check Search Quality
-
-```
-YOUR_AGENT_core op:admin_search_insights
-```
-
-Shows what people search for but don't find — these are knowledge gaps that should be filled.
-
-### Step 8: Memory Health
-
-```
-YOUR_AGENT_core op:memory_stats
-```
-
-```
-YOUR_AGENT_core op:memory_deduplicate
-```
-
-Clean up duplicate memories.
-
-### Step 9: Governance Queue
-
-Check if any proposals are pending review:
-
-```
-YOUR_AGENT_core op:governance_proposals
-  params: { action: "list" }
-```
-
-```
-YOUR_AGENT_core op:governance_stats
-```
-
-Expire stale proposals:
-
-```
-YOUR_AGENT_core op:governance_expire
-```
-
-### Step 10: Fix Everything (Optional)
-
-If the user approves, run the full cleanup:
-
-**Groom all entries — normalize tags, fix metadata:**
-
-```
-YOUR_AGENT_core op:curator_groom_all
-```
-
-**Full consolidation — deduplicate, normalize, quality-score:**
-
-```
-YOUR_AGENT_core op:curator_consolidate
-```
-
-**Prune stale memory:**
-
-```
-YOUR_AGENT_core op:memory_prune
-```
-
-**Rebuild brain intelligence with clean data:**
-
-```
-YOUR_AGENT_core op:brain_build_intelligence
-```
-
-**Reset caches to pick up changes:**
-
-```
-YOUR_AGENT_core op:admin_reset_cache
-```
-
-## Presenting the Health Report
-
-```
-## Knowledge Health Report
-
-### System
-| Check | Status |
-|-------|--------|
-| Infrastructure | OK / Issues |
-| Database | OK / Issues |
-| Cache | OK / Issues |
-
-### Vault Quality
-| Metric | Value | Status |
-|--------|-------|--------|
-| Total entries | X | — |
-| Quality score | X/100 | Good/Warning/Critical |
-| Domains | X | — |
-| Tags | X | — |
-
-### Issues Found
-| Issue | Count | Action |
-|-------|-------|--------|
-| Duplicates | X | Merge |
-| Contradictions | X | Resolve |
-| Stale entries (>30d) | X | Review |
-| Search misses | X | Fill gaps |
-| Pending proposals | X | Review |
-
-### Recommended Actions
-1. [Most impactful fix]
-2. [Second most impactful]
-3. [Third most impactful]
-```
-
-## The Magic
-
-This feels like magic because knowledge bases normally decay silently — duplicates accumulate, entries go stale, contradictions creep in, gaps grow. This skill makes decay visible and fixable in one command. It's like having a librarian who does a weekly audit of every book on every shelf.
-
-## Agent Tools Reference
-
-| Op                              | When to Use                     |
-| ------------------------------- | ------------------------------- |
-| `admin_health`                  | System health check             |
-| `admin_diagnostic`              | Comprehensive system diagnostic |
-| `admin_vault_size`              | Vault storage metrics           |
-| `admin_vault_analytics`         | Knowledge quality metrics       |
-| `admin_search_insights`         | Search miss analysis            |
-| `admin_reset_cache`             | Clear caches after cleanup      |
-| `vault_domains` / `vault_tags`  | Knowledge landscape             |
-| `vault_age_report`              | Stale entry detection           |
-| `curator_health_audit`          | Quality score and audit         |
-| `curator_detect_duplicates`     | Find duplicates                 |
-| `curator_contradictions`        | Find conflicting entries        |
-| `curator_resolve_contradiction` | Resolve conflicts               |
-| `curator_groom_all`             | Batch tag normalization         |
-| `curator_consolidate`           | Full cleanup pipeline           |
-| `memory_stats`                  | Memory health                   |
-| `memory_deduplicate`            | Remove duplicate memories       |
-| `memory_prune`                  | Remove stale memories           |
-| `governance_proposals`          | Pending review queue            |
-| `governance_stats`              | Governance metrics              |
-| `governance_expire`             | Expire stale proposals          |
-| `brain_build_intelligence`      | Rebuild after cleanup           |

package/dist/skills/knowledge-harvest.md

@@ -1,185 +0,0 @@
----
-name: knowledge-harvest
-description: Use when the user says "learn from this", "extract patterns", "harvest knowledge", "ingest this document", "read this and capture", "populate vault from", or points at code, docs, PRs, or any text and wants the agent to automatically extract and capture patterns, anti-patterns, and decisions into the vault.
----
-
-# Knowledge Harvest — Extract Patterns From Anything
-
-Point at code, docs, PRs, architecture decisions, postmortems, or any text — the agent reads it, extracts every pattern, anti-pattern, decision, and principle, then captures them all to the vault. Zero-friction knowledge population.
-
-## When to Use
-
-- "Learn from this file" / "Extract patterns from this codebase"
-- "Read our architecture doc and capture everything"
-- "Harvest knowledge from this PR"
-- "Ingest this post-mortem"
-- Populating a fresh vault with existing team knowledge
-
-## The Magic: Automated Knowledge Extraction
-
-### Step 1: Understand the Source
-
-Read the target content (code, docs, etc.) and classify what type of knowledge it contains:
-
-```
-YOUR_AGENT_core op:route_intent
-  params: { prompt: "Extract knowledge from: <source description>" }
-```
-
-### Step 2: Check What's Already Known
-
-Before extracting, search the vault to avoid duplicates:
-
-```
-YOUR_AGENT_core op:search_intelligent
-  params: { query: "<topic of the source material>" }
-```
-
-```
-YOUR_AGENT_core op:vault_tags
-```
-
-```
-YOUR_AGENT_core op:vault_domains
-```
-
-This tells you what the vault already covers — focus extraction on gaps.
-
-### Step 3: Extract and Classify
-
-Read through the source material and identify:
-
-| Type             | What to Look For                                       |
-| ---------------- | ------------------------------------------------------ |
-| **pattern**      | "We always do X because Y" — repeatable approaches     |
-| **anti-pattern** | "Don't do X because Y" — known mistakes                |
-| **decision**     | "We chose X over Y because Z" — architectural choices  |
-| **principle**    | "We believe X" — guiding rules                         |
-| **workflow**     | "The process for X is: step 1, step 2..." — procedures |
-
-For each extracted item, determine:
-
-- **Category**: Which domain it belongs to
-- **Severity**: critical / warning / suggestion
-- **Tags**: Searchable keywords
-
-### Step 4: Batch Capture
-
-For each extracted item, capture to the vault:
-
-```
-YOUR_AGENT_core op:capture_knowledge
-  params: {
-    title: "<clear, searchable name>",
-    description: "<what it is, when to apply, why it matters>",
-    type: "<pattern|anti-pattern|decision|principle|workflow>",
-    category: "<domain>",
-    tags: ["<tag1>", "<tag2>"],
-    severity: "<critical|warning|suggestion>",
-    example: "<code snippet or quote from source>",
-    why: "<reasoning>"
-  }
-```
-
-Present each capture to the user as you go:
-
-```
-Captured: api-auth-jwt (pattern, critical)
-  → "Use short-lived JWTs for authentication"
-  Auto-tags: auth, jwt, security
-```
-
-### Step 5: Post-Harvest Quality
-
-After all items captured, run quality checks:
-
-**Detect any duplicates created during harvest:**
-
-```
-YOUR_AGENT_core op:curator_detect_duplicates
-```
-
-**Groom all new entries — normalize tags, fix metadata:**
-
-```
-YOUR_AGENT_core op:curator_groom_all
-```
-
-**Enrich entries with additional context:**
-
-```
-YOUR_AGENT_core op:curator_enrich
-  params: { entryId: "<id>" }
-```
-
-**Check for contradictions with existing knowledge:**
-
-```
-YOUR_AGENT_core op:curator_contradictions
-```
-
-### Step 6: Verify Harvest Results
-
-Check vault health after the harvest:
-
-```
-YOUR_AGENT_core op:admin_health
-```
-
-```
-YOUR_AGENT_core op:admin_vault_analytics
-```
-
-Present a summary:
-
-```
-## Harvest Complete
-
-Source: [file/doc name]
-Extracted: X entries
-  - Y patterns
-  - Z anti-patterns
-  - W decisions
-  - V principles
-
-Duplicates found: N (merged/skipped)
-Contradictions found: N (flagged for review)
-Vault health: OK
-```
-
-### Step 7: Promote Universal Patterns (Optional)
-
-If any extracted patterns apply across projects:
-
-```
-YOUR_AGENT_core op:memory_promote_to_global
-  params: { entryId: "<id>" }
-```
-
-## The Magic
-
-This feels like magic because the user points at a 50-page architecture doc and says "learn from this" — and 2 minutes later, the vault has 30 classified, tagged, searchable patterns that inform every future conversation. The agent didn't just read the doc — it understood it, classified it, deduplicated it, and made it permanent.
-
-## Tips for Best Results
-
-- **Start with your team's top 10 decisions** — the ones people keep asking about
-- **Feed postmortems** — they're goldmines of anti-patterns
-- **Feed architecture decision records (ADRs)** — pure decision captures
-- **Feed code review comments** — patterns that reviewers enforce repeatedly
-- **Feed onboarding docs** — principles that new team members need to learn
-
-## Agent Tools Reference
-
-| Op                             | When to Use                            |
-| ------------------------------ | -------------------------------------- |
-| `route_intent`                 | Classify the source material           |
-| `search_intelligent`           | Check for existing knowledge           |
-| `vault_tags` / `vault_domains` | See what's already covered             |
-| `capture_knowledge`            | Capture each extracted item            |
-| `curator_detect_duplicates`    | Find duplicates post-harvest           |
-| `curator_groom_all`            | Normalize all new entries              |
-| `curator_enrich`               | LLM-enrich entries                     |
-| `curator_contradictions`       | Find conflicts with existing knowledge |
-| `memory_promote_to_global`     | Share universal patterns cross-project |
-| `admin_health`                 | Post-harvest health check              |
-| `admin_vault_analytics`        | Knowledge quality metrics              |