@soleri/forge 5.14.0 → 5.14.2

package/dist/skills/health-check.md

@@ -87,6 +87,7 @@ 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)
@@ -135,26 +136,31 @@ YOUR_AGENT_core op:governance_expire
 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
 ```
@@ -200,26 +206,26 @@ This feels like magic because knowledge bases normally decay silently — duplic
 
 ## 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 |
+| 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

@@ -49,15 +49,16 @@ This tells you what the vault already covers — focus extraction on gaps.
 
 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 |
+| 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
@@ -81,6 +82,7 @@ YOUR_AGENT_core op:capture_knowledge
 ```
 
 Present each capture to the user as you go:
+
 ```
 Captured: api-auth-jwt (pattern, critical)
   → "Use short-lived JWTs for authentication"
@@ -92,22 +94,26 @@ Captured: api-auth-jwt (pattern, critical)
 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
 ```
@@ -125,6 +131,7 @@ YOUR_AGENT_core op:admin_vault_analytics
 ```
 
 Present a summary:
+
 ```
 ## Harvest Complete
 
@@ -163,16 +170,16 @@ This feels like magic because the user points at a 50-page architecture doc and
 
 ## 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 |
+| 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              |

package/dist/skills/onboard-me.md

@@ -169,6 +169,7 @@ Use `/second-opinion` before making any architectural decision.
 ## The Magic
 
 This feels like magic because a new team member says "onboard me" and instantly gets:
+
 1. Every critical rule they must follow
 2. Every architectural decision and why it was made
 3. Proven patterns to follow
@@ -180,18 +181,18 @@ No other onboarding tool does this — it's not a static wiki, it's a living kno
 
 ## Agent Tools Reference
 
-| Op | When to Use |
-|----|-------------|
-| `identity` | Project persona and description |
-| `project_get` | Project registration details |
-| `project_list_rules` | Project-specific rules |
-| `get_behavior_rules` | Behavioral conventions |
-| `vault_domains` / `vault_tags` | Knowledge landscape |
-| `admin_vault_size` | How much knowledge exists |
-| `search` | Find critical entries and anti-patterns |
-| `search_intelligent` | Find decisions and patterns |
-| `brain_strengths` | Proven approaches |
-| `brain_global_patterns` | Cross-project patterns |
-| `project_linked_projects` | Related projects |
-| `admin_search_insights` | What's not in the vault |
-| `vault_age_report` | Stale knowledge areas |
+| Op                             | When to Use                             |
+| ------------------------------ | --------------------------------------- |
+| `identity`                     | Project persona and description         |
+| `project_get`                  | Project registration details            |
+| `project_list_rules`           | Project-specific rules                  |
+| `get_behavior_rules`           | Behavioral conventions                  |
+| `vault_domains` / `vault_tags` | Knowledge landscape                     |
+| `admin_vault_size`             | How much knowledge exists               |
+| `search`                       | Find critical entries and anti-patterns |
+| `search_intelligent`           | Find decisions and patterns             |
+| `brain_strengths`              | Proven approaches                       |
+| `brain_global_patterns`        | Cross-project patterns                  |
+| `project_linked_projects`      | Related projects                        |
+| `admin_search_insights`        | What's not in the vault                 |
+| `vault_age_report`             | Stale knowledge areas                   |

package/dist/skills/retrospective.md

@@ -20,52 +20,62 @@ Generate a retrospective from actual session data, vault captures, plan outcomes
 ### Step 1: Gather the Data
 
 **Brain stats — the big picture:**
+
 ```
 YOUR_AGENT_core op:brain_stats
 ```
 
 **Recent brain stats — compare velocity:**
+
 ```
 YOUR_AGENT_core op:brain_stats
   params: { since: "<start of period>" }
 ```
 
 **Pattern strengths — what's proven:**
+
 ```
 YOUR_AGENT_core op:brain_strengths
 ```
 
 **Recent vault captures — what was learned:**
+
 ```
 YOUR_AGENT_core op:vault_recent
 ```
 
 **Memory topics — where knowledge clusters:**
+
 ```
 YOUR_AGENT_core op:memory_topics
 ```
 
 **Memory stats — volume and health:**
+
 ```
 YOUR_AGENT_core op:memory_stats
 ```
 
 **Plan stats — execution track record:**
+
 ```
 YOUR_AGENT_core op:plan_stats
 ```
 
 **Loop history — iterative workflow outcomes:**
+
 ```
 YOUR_AGENT_core op:loop_history
 ```
 
 **Search insights — what people looked for but didn't find:**
+
 ```
 YOUR_AGENT_core op:admin_search_insights
 ```
 
 **Vault analytics — knowledge quality:**
+
 ```
 YOUR_AGENT_core op:admin_vault_analytics
 ```
@@ -73,21 +83,25 @@ YOUR_AGENT_core op:admin_vault_analytics
 ### Step 2: Analyze Patterns
 
 **Stale knowledge needing refresh:**
+
 ```
 YOUR_AGENT_core op:vault_age_report
 ```
 
 **Duplicates that crept in:**
+
 ```
 YOUR_AGENT_core op:curator_detect_duplicates
 ```
 
 **Contradictions in the knowledge base:**
+
 ```
 YOUR_AGENT_core op:curator_contradictions
 ```
 
 **Curator health audit — overall quality:**
+
 ```
 YOUR_AGENT_core op:curator_health_audit
 ```
@@ -154,11 +168,13 @@ YOUR_AGENT_core op:capture_knowledge
 If the retrospective revealed quality issues, offer to fix them:
 
 **Consolidate vault (deduplicate, normalize, groom):**
+
 ```
 YOUR_AGENT_core op:curator_consolidate
 ```
 
 **Rebuild brain intelligence with fresh data:**
+
 ```
 YOUR_AGENT_core op:brain_build_intelligence
 ```
@@ -169,21 +185,21 @@ This feels like magic because the user says "sprint retro" and gets a data-drive
 
 ## Agent Tools Reference
 
-| Op | When to Use |
-|----|-------------|
-| `brain_stats` | Big picture metrics |
-| `brain_strengths` | Proven patterns |
-| `vault_recent` | What was captured recently |
-| `memory_topics` | Knowledge clusters |
-| `memory_stats` | Memory volume and health |
-| `plan_stats` | Plan completion rates |
-| `loop_history` | Iterative workflow outcomes |
-| `admin_search_insights` | Search miss analysis |
-| `admin_vault_analytics` | Knowledge quality metrics |
-| `vault_age_report` | Stale entries |
-| `curator_detect_duplicates` | Duplicate detection |
-| `curator_contradictions` | Knowledge conflicts |
-| `curator_health_audit` | Overall vault quality |
-| `capture_knowledge` | Persist the retrospective |
-| `curator_consolidate` | Post-retro cleanup |
-| `brain_build_intelligence` | Rebuild intelligence |
+| Op                          | When to Use                 |
+| --------------------------- | --------------------------- |
+| `brain_stats`               | Big picture metrics         |
+| `brain_strengths`           | Proven patterns             |
+| `vault_recent`              | What was captured recently  |
+| `memory_topics`             | Knowledge clusters          |
+| `memory_stats`              | Memory volume and health    |
+| `plan_stats`                | Plan completion rates       |
+| `loop_history`              | Iterative workflow outcomes |
+| `admin_search_insights`     | Search miss analysis        |
+| `admin_vault_analytics`     | Knowledge quality metrics   |
+| `vault_age_report`          | Stale entries               |
+| `curator_detect_duplicates` | Duplicate detection         |
+| `curator_contradictions`    | Knowledge conflicts         |
+| `curator_health_audit`      | Overall vault quality       |
+| `capture_knowledge`         | Persist the retrospective   |
+| `curator_consolidate`       | Post-retro cleanup          |
+| `brain_build_intelligence`  | Rebuild intelligence        |

package/dist/skills/second-opinion.md

@@ -29,17 +29,20 @@ YOUR_AGENT_core op:route_intent
 ### Step 2: Search All Knowledge Sources (in order)
 
 **Vault — has this been decided before?**
+
 ```
 YOUR_AGENT_core op:search_intelligent
   params: { query: "<the decision or options being considered>" }
 ```
 
 Look specifically for:
+
 - Previous decisions on this topic (type: "decision")
 - Patterns that favor one approach
 - Anti-patterns that warn against an approach
 
 **Brain — what's proven to work?**
+
 ```
 YOUR_AGENT_core op:brain_strengths
 ```
@@ -50,12 +53,14 @@ YOUR_AGENT_core op:brain_recommend
 ```
 
 **Cross-project — what did other projects choose?**
+
 ```
 YOUR_AGENT_core op:memory_cross_project_search
   params: { query: "<the decision topic>", crossProject: true }
 ```
 
 **Memory — any relevant context from past sessions?**
+
 ```
 YOUR_AGENT_core op:memory_search
   params: { query: "<decision topic>" }
@@ -63,6 +68,7 @@ YOUR_AGENT_core op:memory_search
 
 **Web — what does the broader community say?**
 Search the web for:
+
 - Comparison articles (X vs Y for [use case])
 - Benchmarks and performance data
 - Community consensus on best practices
@@ -120,6 +126,7 @@ This is critical — the next person who faces the same decision will find it in
 ## The Magic
 
 This feels like magic because the user asks "should I use X?" and instead of a generic AI opinion, they get:
+
 1. What their own project decided before (vault)
 2. What's proven to work across projects (brain)
 3. What other linked projects chose (cross-project)
@@ -131,12 +138,12 @@ It's like having a senior architect who remembers every decision ever made.
 
 ## Agent Tools Reference
 
-| Op | When to Use |
-|----|-------------|
-| `route_intent` | Classify the decision type |
-| `search_intelligent` | Find previous decisions and patterns |
-| `brain_strengths` | Proven approaches |
-| `brain_recommend` | Project-specific recommendations |
-| `memory_cross_project_search` | What other projects decided |
-| `memory_search` | Session context for this decision |
-| `capture_knowledge` | Persist the final decision |
+| Op                            | When to Use                          |
+| ----------------------------- | ------------------------------------ |
+| `route_intent`                | Classify the decision type           |
+| `search_intelligent`          | Find previous decisions and patterns |
+| `brain_strengths`             | Proven approaches                    |
+| `brain_recommend`             | Project-specific recommendations     |
+| `memory_cross_project_search` | What other projects decided          |
+| `memory_search`               | Session context for this decision    |
+| `capture_knowledge`           | Persist the final decision           |

package/dist/skills/systematic-debugging.md

@@ -26,6 +26,7 @@ If you haven't completed Phase 1, you cannot propose fixes.
 ## When to Use
 
 Use for ANY technical issue:
+
 - Test failures
 - Bugs in production
 - Unexpected behavior
@@ -34,6 +35,7 @@ Use for ANY technical issue:
 - Integration issues
 
 **Use this ESPECIALLY when:**
+
 - Under time pressure (emergencies make guessing tempting)
 - "Just one quick fix" seems obvious
 - You've already tried multiple fixes
@@ -45,6 +47,7 @@ Use for ANY technical issue:
 **BEFORE touching any code**, search for existing solutions. Follow this order:
 
 ### Vault First
+
 ```
 YOUR_AGENT_core op:search_intelligent
   params: { query: "<description of the bug or error message>" }
@@ -66,7 +69,9 @@ YOUR_AGENT_core op:memory_search
 ```
 
 ### Web Search Second
+
 If the vault has nothing, search the web before investigating from scratch:
+
 - **Paste the exact error message** — someone likely hit this before
 - **Check GitHub issues** on relevant libraries
 - **Check Stack Overflow** for the error + framework/library combination
@@ -75,6 +80,7 @@ If the vault has nothing, search the web before investigating from scratch:
 A 30-second search that finds "this is a known issue in v3.2, upgrade to v3.3" saves hours of root cause investigation.
 
 ### Then Investigate
+
 Only if vault and web search produce no answer, proceed to Phase 1.
 
 ## Start a Debug Loop
@@ -101,6 +107,7 @@ You MUST complete each phase before proceeding to the next.
 5. Trace Data Flow backward through call stack
 
 Track each investigation step:
+
 ```
 YOUR_AGENT_core op:loop_iterate
 ```
@@ -113,6 +120,7 @@ YOUR_AGENT_core op:loop_iterate
 4. Understand Dependencies
 
 Search vault for working patterns to compare against:
+
 ```
 YOUR_AGENT_core op:search_intelligent
   params: { query: "<working feature similar to broken one>" }
@@ -136,6 +144,7 @@ YOUR_AGENT_core op:search_intelligent
 ## Phase 5: Capture the Learning
 
 Complete the debug loop:
+
 ```
 YOUR_AGENT_core op:loop_complete
 ```
@@ -164,6 +173,7 @@ YOUR_AGENT_core op:capture_quick
 ```
 
 Capture a session summary:
+
 ```
 YOUR_AGENT_core op:session_capture
   params: { summary: "<bug, root cause, fix, files modified>" }
@@ -187,44 +197,45 @@ This is what makes the agent smarter over time. Next time someone hits a similar
 
 ## Common Rationalizations
 
-| Excuse | Reality |
-|--------|---------|
-| "Issue is simple, don't need process" | Simple issues have root causes too. |
-| "Emergency, no time for process" | Systematic is FASTER than guess-and-check thrashing. |
-| "Just try this first, then investigate" | First fix sets the pattern. Do it right from the start. |
-| "I'll write test after confirming fix works" | Untested fixes don't stick. Test first proves it. |
-| "Multiple fixes at once saves time" | Can't isolate what worked. Causes new bugs. |
-| "Reference too long, I'll adapt the pattern" | Partial understanding guarantees bugs. Read it completely. |
-| "I see the problem, let me fix it" | Seeing symptoms ≠ understanding root cause. |
-| "One more fix attempt" (after 2+ failures) | 3+ failures = architectural problem. Question pattern, don't fix again. |
-| "Skip the vault, I know this one" | The vault may know it better. 30 seconds to check saves hours. |
+| Excuse                                       | Reality                                                                 |
+| -------------------------------------------- | ----------------------------------------------------------------------- |
+| "Issue is simple, don't need process"        | Simple issues have root causes too.                                     |
+| "Emergency, no time for process"             | Systematic is FASTER than guess-and-check thrashing.                    |
+| "Just try this first, then investigate"      | First fix sets the pattern. Do it right from the start.                 |
+| "I'll write test after confirming fix works" | Untested fixes don't stick. Test first proves it.                       |
+| "Multiple fixes at once saves time"          | Can't isolate what worked. Causes new bugs.                             |
+| "Reference too long, I'll adapt the pattern" | Partial understanding guarantees bugs. Read it completely.              |
+| "I see the problem, let me fix it"           | Seeing symptoms ≠ understanding root cause.                             |
+| "One more fix attempt" (after 2+ failures)   | 3+ failures = architectural problem. Question pattern, don't fix again. |
+| "Skip the vault, I know this one"            | The vault may know it better. 30 seconds to check saves hours.          |
 
 ## Quick Reference
 
-| Phase | Key Activities | Agent Tools |
-|-------|---------------|-------------|
-| **0. Search First** | Vault search, web search, memory | `search_intelligent`, `brain_strengths`, `memory_search` |
-| **1. Root Cause** | Read errors, reproduce, trace | `loop_iterate` |
-| **2. Pattern** | Find working examples, compare | `search_intelligent` |
-| **3. Hypothesis** | Form theory, test minimally | `loop_iterate` |
-| **4. Implementation** | Create test, fix, verify | `loop_iterate` |
-| **5. Capture** | Persist root cause, close loop | `capture_knowledge`, `loop_complete`, `session_capture` |
+| Phase                 | Key Activities                   | Agent Tools                                              |
+| --------------------- | -------------------------------- | -------------------------------------------------------- |
+| **0. Search First**   | Vault search, web search, memory | `search_intelligent`, `brain_strengths`, `memory_search` |
+| **1. Root Cause**     | Read errors, reproduce, trace    | `loop_iterate`                                           |
+| **2. Pattern**        | Find working examples, compare   | `search_intelligent`                                     |
+| **3. Hypothesis**     | Form theory, test minimally      | `loop_iterate`                                           |
+| **4. Implementation** | Create test, fix, verify         | `loop_iterate`                                           |
+| **5. Capture**        | Persist root cause, close loop   | `capture_knowledge`, `loop_complete`, `session_capture`  |
 
 ## Agent Tools Reference
 
-| Op | When to Use |
-|----|-------------|
+| Op                   | When to Use                              |
+| -------------------- | ---------------------------------------- |
 | `search_intelligent` | Search vault for known bugs and patterns |
-| `brain_strengths` | Check proven debugging patterns |
-| `memory_search` | Search across session memories |
-| `loop_start` | Begin iterative debug cycle |
-| `loop_iterate` | Track each investigation/fix attempt |
-| `loop_complete` | Finish debug cycle |
-| `capture_knowledge` | Full anti-pattern capture |
-| `capture_quick` | Fast capture for simple fixes |
-| `session_capture` | Persist session context |
+| `brain_strengths`    | Check proven debugging patterns          |
+| `memory_search`      | Search across session memories           |
+| `loop_start`         | Begin iterative debug cycle              |
+| `loop_iterate`       | Track each investigation/fix attempt     |
+| `loop_complete`      | Finish debug cycle                       |
+| `capture_knowledge`  | Full anti-pattern capture                |
+| `capture_quick`      | Fast capture for simple fixes            |
+| `session_capture`    | Persist session context                  |
 
 **Related skills:**
+
 - test-driven-development
 - verification-before-completion
 - fix-and-learn (combines debugging + capture in one workflow)