@soleri/forge 5.14.1 → 5.14.3

package/dist/skills/skills/onboard-me.md

@@ -0,0 +1,198 @@
+---
+name: onboard-me
+description: Use when the user says "onboard me", "I'm new here", "what should I know", "project overview", "show me the ropes", "knowledge tour", "what are the rules", "how does this project work", or is new to the project and needs a structured introduction to its knowledge, patterns, decisions, and conventions.
+---
+
+# Onboard Me — Instant Project Intelligence
+
+Give any newcomer a structured tour of everything the vault knows about this project. Decisions, patterns, anti-patterns, principles, conventions — all in one guided walkthrough. Turns months of tribal knowledge into a 5-minute briefing.
+
+## When to Use
+
+- New team member joining the project
+- Switching context to a project you haven't touched in a while
+- "What should I know before I start?"
+- "What are the rules here?"
+
+## The Magic: Structured Knowledge Tour
+
+### Step 1: Project Overview
+
+Get the project identity and registration:
+
+```
+YOUR_AGENT_core op:identity
+```
+
+```
+YOUR_AGENT_core op:project_get
+```
+
+Get project-specific rules and conventions:
+
+```
+YOUR_AGENT_core op:project_list_rules
+```
+
+Get behavior rules:
+
+```
+YOUR_AGENT_core op:get_behavior_rules
+```
+
+### Step 2: Knowledge Landscape
+
+Show what the vault knows, organized by domain:
+
+```
+YOUR_AGENT_core op:vault_domains
+```
+
+```
+YOUR_AGENT_core op:vault_tags
+```
+
+```
+YOUR_AGENT_core op:admin_vault_size
+```
+
+Present: "This project has X entries across Y domains, covering Z tags."
+
+### Step 3: Critical Knowledge
+
+Search for the most important entries — critical severity first:
+
+```
+YOUR_AGENT_core op:search
+  params: { severity: "critical" }
+```
+
+These are the "must know" items — rules that cannot be violated.
+
+### Step 4: Key Decisions
+
+Search for architectural and design decisions:
+
+```
+YOUR_AGENT_core op:search_intelligent
+  params: { query: "architectural decision design choice" }
+```
+
+Present the top decisions with their rationale — this is the "why" behind the codebase.
+
+### Step 5: Strongest Patterns
+
+Show what the brain has validated as proven approaches:
+
+```
+YOUR_AGENT_core op:brain_strengths
+```
+
+These are the "how" — patterns that have been used successfully and should be followed.
+
+### Step 6: Anti-Patterns to Avoid
+
+Search for anti-patterns — things that went wrong and shouldn't be repeated:
+
+```
+YOUR_AGENT_core op:search
+  params: { type: "anti-pattern" }
+```
+
+Present as a "don't do this" list with the reasoning.
+
+### Step 7: Cross-Project Context
+
+Check if this project is linked to others:
+
+```
+YOUR_AGENT_core op:project_linked_projects
+```
+
+If linked, show what patterns are shared:
+
+```
+YOUR_AGENT_core op:brain_global_patterns
+```
+
+### Step 8: Knowledge Gaps
+
+Show what's NOT in the vault — areas where the newcomer should ask questions:
+
+```
+YOUR_AGENT_core op:admin_search_insights
+```
+
+```
+YOUR_AGENT_core op:vault_age_report
+```
+
+## Presenting the Onboarding
+
+```
+## Welcome to [Project Name]
+
+**Role:** [project description]
+**Domains:** [list of knowledge domains]
+**Vault:** X entries across Y domains
+
+---
+
+### Critical Rules (Must Follow)
+[Critical severity entries — non-negotiable conventions]
+
+### Key Decisions
+[Top architectural decisions with rationale]
+"We chose X over Y because Z"
+
+### Proven Patterns (Do This)
+[Top brain-strength patterns — the project's best practices]
+
+### Anti-Patterns (Don't Do This)
+[Known mistakes — save yourself the debugging]
+
+### Project Conventions
+[Project rules, behavior rules, naming conventions]
+
+### Related Projects
+[Linked projects and shared patterns]
+
+### Knowledge Gaps
+[Areas not well-documented — ask the team about these]
+
+---
+
+**Tip:** Use `/vault-navigator` to search for specific topics as you work.
+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
+4. Anti-patterns to avoid
+5. What's shared with other projects
+6. Where the knowledge gaps are
+
+No other onboarding tool does this — it's not a static wiki, it's a living knowledge base that grows with the project.
+
+## 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                   |

package/dist/skills/skills/retrospective.md

@@ -0,0 +1,205 @@
+---
+name: retrospective
+description: Use when the user asks "what did I learn this week", "sprint retro", "retrospective", "learning report", "what went well", "what could improve", "weekly summary", "monthly report", or wants to reflect on recent work and extract actionable insights from accumulated data.
+---
+
+# Retrospective — Learning Report From Real Data
+
+Generate a retrospective from actual session data, vault captures, plan outcomes, and brain intelligence. Not opinions — data-driven reflection on what happened, what worked, what didn't, and what to do differently.
+
+## When to Use
+
+- End of sprint / week / month
+- "What did I learn this week?"
+- "Sprint retrospective"
+- "What went well? What didn't?"
+- After completing a major feature or milestone
+
+## The Magic: Data-Driven Reflection
+
+### 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
+```
+
+### 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
+```
+
+### Step 3: Present the Retrospective
+
+```
+## Retrospective: [Period]
+
+### By the Numbers
+| Metric | This Period | Previous | Trend |
+|--------|-----------|----------|-------|
+| Patterns captured | X | Y | ↑/↓ |
+| Anti-patterns logged | X | Y | ↑/↓ |
+| Plans completed | X | Y | ↑/↓ |
+| Brain strength (avg) | X | Y | ↑/↓ |
+| Vault entries total | X | — | — |
+| Search misses | X | Y | ↑/↓ |
+
+### What Went Well
+[Patterns with high brain strength, completed plans, growing domains]
+
+### What Didn't Go Well
+[Recurring anti-patterns, failed plans, search misses = knowledge gaps]
+
+### Strongest Patterns
+[Top 5 patterns by brain strength — these are your superpowers]
+
+### Recurring Anti-Patterns
+[Top 3 anti-patterns that keep appearing — these need systemic fixes]
+
+### Knowledge Gaps
+[Domains with low coverage, frequent search misses, stale entries]
+
+### Vault Health
+- Quality score: X/100
+- Duplicates found: N
+- Contradictions found: N
+- Stale entries (>30 days): N
+
+### Recommendations
+1. [Action item based on data]
+2. [Action item based on data]
+3. [Action item based on data]
+```
+
+### Step 4: Capture the Retrospective
+
+Save the retrospective itself as knowledge:
+
+```
+YOUR_AGENT_core op:capture_knowledge
+  params: {
+    title: "Retrospective — [period]",
+    description: "<key findings and action items>",
+    type: "workflow",
+    category: "meta",
+    tags: ["retrospective", "<period>"]
+  }
+```
+
+### Step 5: Clean Up (Optional)
+
+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
+```
+
+## The Magic
+
+This feels like magic because the user says "sprint retro" and gets a data-driven report they didn't have to compile. It's not AI making up observations — it's actual metrics from their vault, brain, plans, and memory. The recommendations come from real gaps, not generic advice.
+
+## 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        |

package/dist/skills/skills/second-opinion.md

@@ -0,0 +1,149 @@
+---
+name: second-opinion
+description: Use when the user asks "should I", "what do you think about", "which approach", "compare options", "what would you recommend", "pros and cons", "trade-offs", or faces any technical decision and wants an informed recommendation backed by vault knowledge, brain patterns, and web research.
+---
+
+# Second Opinion — Decision Support From All Sources
+
+Before making any technical decision, get an informed recommendation that synthesizes vault knowledge, brain patterns, cross-project experience, and web research. Never decide in a vacuum.
+
+## When to Use
+
+- "Should I use Redis or Memcached?"
+- "What's the best way to handle auth?"
+- "Which testing framework?"
+- "Microservices or monolith?"
+- Any fork-in-the-road technical decision
+
+## The Magic: Multi-Source Decision Intelligence
+
+### Step 1: Understand the Decision
+
+Classify the intent to understand what kind of decision this is:
+
+```
+YOUR_AGENT_core op:route_intent
+  params: { prompt: "<user's question>" }
+```
+
+### 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
+```
+
+```
+YOUR_AGENT_core op:brain_recommend
+  params: { projectName: "<current project>" }
+```
+
+**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>" }
+```
+
+**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
+- Known limitations and gotchas
+
+### Step 3: Synthesize and Present
+
+Format the recommendation as a decision brief:
+
+```
+## Decision: [Question]
+
+### What the Vault Says
+[Existing decisions, patterns, and anti-patterns from vault]
+
+### What the Brain Recommends
+[Proven patterns, cross-project insights]
+
+### What the Web Says
+[Community consensus, benchmarks, comparison data]
+
+### Options Analysis
+
+| Criteria | Option A | Option B | Option C |
+|----------|----------|----------|----------|
+| [criteria 1] | ... | ... | ... |
+| [criteria 2] | ... | ... | ... |
+| Vault support | [existing patterns?] | [existing patterns?] | — |
+| Brain confidence | [strength score] | [strength score] | — |
+
+### Recommendation
+[Clear recommendation with reasoning]
+
+### Risks
+[What could go wrong with the recommended approach]
+```
+
+### Step 4: Capture the Decision
+
+Once the user decides, capture it to the vault for future reference:
+
+```
+YOUR_AGENT_core op:capture_knowledge
+  params: {
+    title: "<decision title>",
+    description: "<chosen option, rationale, rejected alternatives and why>",
+    type: "decision",
+    category: "<relevant domain>",
+    tags: ["<option-a>", "<option-b>", "decision", "<domain>"]
+  }
+```
+
+This is critical — the next person who faces the same decision will find it in the vault.
+
+## 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)
+4. What the broader community recommends (web)
+5. A synthesized recommendation with trade-offs
+6. The decision captured for the next person who asks
+
+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           |