@soleri/forge 9.0.0 → 9.2.0

package/dist/skills/vault-curate.md

@@ -1,107 +0,0 @@
----
-name: vault-curate
-description: >
-  Use when the user says "clean vault", "deduplicate", "groom knowledge",
-  "consolidate vault", "vault maintenance", "find duplicates", "merge patterns",
-  "check contradictions", "vault health", or wants to maintain, clean, reorganize,
-  or improve the quality of the agent's knowledge base.
----
-
-# Vault Curate — Knowledge Maintenance
-
-Maintain vault quality through deduplication, grooming, contradiction detection, and consolidation. A well-curated vault produces better search results and brain recommendations.
-
-## When to Use
-
-Periodically (weekly or after heavy capture sessions), when search quality degrades, when vault health shows warnings, or when the user explicitly requests maintenance.
-
-## Orchestration Sequence
-
-### Step 1: Health Assessment
-
-```
-YOUR_AGENT_core op:knowledge_health
-```
-
-```
-YOUR_AGENT_core op:get_vault_analytics
-```
-
-Present the health summary to the user before proceeding: total entries, quality scores, staleness, coverage gaps.
-
-### Step 2: Detect Duplicates
-
-```
-YOUR_AGENT_core op:curator_detect_duplicates
-```
-
-This finds entries with overlapping titles, descriptions, or content. Review the duplicate pairs — some may be intentional (different contexts) while others are true duplicates.
-
-For true duplicates:
-
-```
-YOUR_AGENT_core op:merge_patterns
-  params: { patternIds: ["<id1>", "<id2>"] }
-```
-
-Preserve the best content from each.
-
-### Step 3: Find Contradictions
-
-```
-YOUR_AGENT_core op:curator_contradictions
-```
-
-Contradictions erode trust in vault search results. For each contradiction: decide which entry is correct (check dates, context, evidence), then archive or update the incorrect one.
-
-### Step 4: Groom Entries
-
-```
-YOUR_AGENT_core op:curator_groom_all
-```
-
-Runs tag enrichment and metadata cleanup across all entries. This improves searchability and categorization.
-
-For targeted grooming of specific entries:
-
-```
-YOUR_AGENT_core op:curator_groom
-  params: { entryIds: ["<id>"], tags: ["<tag>"] }
-```
-
-### Step 5: GPT Enrichment (Optional)
-
-```
-YOUR_AGENT_core op:curator_gpt_enrich
-```
-
-Adds AI-generated metadata to entries that lack descriptions, examples, or context. Fills in gaps without changing the core content.
-
-### Step 6: Full Consolidation
-
-```
-YOUR_AGENT_core op:curator_consolidate
-```
-
-Runs the complete pipeline: dedup + archive stale entries + resolve contradictions. This is the heavy-duty cleanup.
-
-### Step 7: Knowledge Reorganization
-
-```
-YOUR_AGENT_core op:knowledge_reorganize
-  params: { mode: "preview" }
-```
-
-Preview first, then run again with `mode: "apply"` if the preview looks good.
-
-### Step 8: Verify Results
-
-```
-YOUR_AGENT_core op:knowledge_health
-```
-
-Compare with Step 1 metrics. Vault health should improve: fewer duplicates, no contradictions, better coverage.
-
-## Exit Criteria
-
-Curation is complete when: duplicates merged, contradictions resolved, entries groomed, and health metrics improved compared to Step 1 baseline.

package/dist/skills/vault-navigator.md

@@ -1,140 +0,0 @@
----
-name: vault-navigator
-description: Use when the user asks "what does vault say", "search knowledge", "find pattern", "have we seen this before", "best practice for", "check vault", "vault search", "any patterns for", or wants to query the knowledge base for existing solutions or guidance.
----
-
-# Vault Navigator — Knowledge Oracle
-
-Navigate the vault intelligently. The vault has multiple search strategies — this skill picks the right one based on what the user needs.
-
-## When to Use
-
-Any time the user wants to find existing knowledge before building something new. Also when asking about best practices, previous solutions, or patterns.
-
-## Search Strategy Decision Tree
-
-### For "Have we seen this before?" / "Best practice for X"
-
-Start with `YOUR_AGENT_core op:search_intelligent` — this is semantic search, the broadest and smartest query. Pass the user's question as the query.
-
-```
-YOUR_AGENT_core op:search_intelligent
-  params: { query: "<user's question>" }
-```
-
-If results are weak (low scores or few matches), fall back to `YOUR_AGENT_core op:search` with explicit filters (type, category, tags, severity). This is structured search — narrower but more precise.
-
-### For "Show me everything about X" (Exploration)
-
-Use tag-based and domain-based browsing for broader exploration:
-
-```
-YOUR_AGENT_core op:vault_tags
-```
-
-Lists all tags in the vault — helps discover what topics are covered.
-
-```
-YOUR_AGENT_core op:vault_domains
-```
-
-Lists all domains — shows the knowledge landscape at a glance.
-
-```
-YOUR_AGENT_core op:vault_recent
-```
-
-Shows recently added or modified entries — what's fresh in the vault.
-
-### For "What's stale?" / "What needs updating?"
-
-Run an age report to find outdated knowledge:
-
-```
-YOUR_AGENT_core op:vault_age_report
-```
-
-Present entries that haven't been updated recently — these are candidates for review, refresh, or removal.
-
-### For "What do other projects do?"
-
-Call `YOUR_AGENT_core op:memory_cross_project_search` with `crossProject: true`. This searches across all linked projects, not just the current one.
-
-```
-YOUR_AGENT_core op:memory_cross_project_search
-  params: { query: "<topic>", crossProject: true }
-```
-
-Check what projects are linked:
-
-```
-YOUR_AGENT_core op:project_linked_projects
-```
-
-### For "Has brain learned anything about X?"
-
-Call `YOUR_AGENT_core op:brain_strengths` to see which patterns have proven strength. Then call `YOUR_AGENT_core op:brain_global_patterns` with a domain or tag filter to find cross-project patterns.
-
-```
-YOUR_AGENT_core op:brain_strengths
-YOUR_AGENT_core op:brain_global_patterns
-  params: { domain: "<domain>" }
-```
-
-### For "What do I know about X?" (broad exploration)
-
-Chain multiple strategies for comprehensive results:
-
-1. `search_intelligent` → semantic vault search
-2. `vault_tags` / `vault_domains` → browse knowledge landscape
-3. `memory_cross_project_search` → cross-project patterns
-4. `brain_strengths` → proven patterns
-
-Present all findings with source labels so the user knows where each insight came from.
-
-## Presenting Results
-
-Always include:
-
-- **Source**: Which search found it (vault, memory, brain, tags, domains)
-- **Confidence**: Score or strength rating
-- **Relevance**: Why this result matches the query
-- **Actionable next step**: How to apply this knowledge
-
-## Fallback: Web Search
-
-If all vault strategies return no results, search the web for the user's question before saying "nothing found." The web may have:
-
-- Documentation, articles, or guides on the topic
-- Community patterns and best practices
-- Library-specific solutions
-
-If web search finds something useful, offer to capture it to the vault:
-
-```
-YOUR_AGENT_core op:capture_quick
-  params: {
-    title: "<what was found>",
-    description: "<summary from web search, source URL>"
-  }
-```
-
-## Exit Criteria
-
-Search is complete when at least one search strategy has been tried and results presented. If no results found across all strategies (vault + web), say so explicitly — that's valuable information too (it means this is genuinely new territory worth exploring and capturing).
-
-## Agent Tools Reference
-
-| Op                            | When to Use                                           |
-| ----------------------------- | ----------------------------------------------------- |
-| `search_intelligent`          | Default semantic search — broadest and smartest       |
-| `search`                      | Structured search with filters (type, tags, category) |
-| `vault_tags`                  | Browse all tags — discover knowledge landscape        |
-| `vault_domains`               | Browse all domains — see what areas are covered       |
-| `vault_recent`                | Recently modified entries — what's fresh              |
-| `vault_age_report`            | Find stale entries needing refresh                    |
-| `memory_cross_project_search` | Search across linked projects                         |
-| `project_linked_projects`     | See what projects are connected                       |
-| `brain_strengths`             | Proven patterns ranked by success                     |
-| `brain_global_patterns`       | Cross-project patterns from global pool               |
-| `capture_quick`               | Capture web findings to vault for next time           |

package/dist/skills/verification-before-completion.md

@@ -1,182 +0,0 @@
----
-name: verification-before-completion
-description: Use when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions always
----
-
-<!-- Adapted from superpowers (MIT License) -->
-
-# Verification Before Completion
-
-## Overview
-
-Claiming work is complete without verification is dishonesty, not efficiency.
-
-**Core principle:** Evidence before claims, always.
-
-**Violating the letter of this rule is violating the spirit of this rule.**
-
-## The Iron Law
-
-```
-NO COMPLETION CLAIMS WITHOUT FRESH VERIFICATION EVIDENCE
-```
-
-If you haven't run the verification command in this message, you cannot claim it passes.
-
-## The Gate Function
-
-```
-BEFORE claiming any status or expressing satisfaction:
-
-1. IDENTIFY: What command proves this claim?
-2. RUN: Execute the FULL command (fresh, complete)
-3. READ: Full output, check exit code, count failures
-4. VERIFY: Does output confirm the claim?
-   - If NO: State actual status with evidence
-   - If YES: State claim WITH evidence
-5. AGENT CHECK: Run system diagnostics
-6. ONLY THEN: Make the claim
-
-Skip any step = lying, not verifying
-```
-
-## Agent System Checks
-
-After passing all verification commands, run system diagnostics:
-
-### Health Check
-
-```
-YOUR_AGENT_core op:admin_health
-```
-
-Catches issues tests might miss — vault corruption, stale caches, configuration drift.
-
-### Full Diagnostic
-
-```
-YOUR_AGENT_core op:admin_diagnostic
-```
-
-Comprehensive system check — module status, database integrity, cache health, configuration validity.
-
-### Vault Analytics
-
-```
-YOUR_AGENT_core op:admin_vault_analytics
-```
-
-Verify knowledge quality metrics — are capture rates healthy? Any degradation?
-
-If any check reports problems, address them before claiming completion.
-
-## Common Failures
-
-| Claim                 | Requires                        | Not Sufficient                 |
-| --------------------- | ------------------------------- | ------------------------------ |
-| Tests pass            | Test command output: 0 failures | Previous run, "should pass"    |
-| Linter clean          | Linter output: 0 errors         | Partial check, extrapolation   |
-| Build succeeds        | Build command: exit 0           | Linter passing, logs look good |
-| Bug fixed             | Test original symptom: passes   | Code changed, assumed fixed    |
-| Regression test works | Red-green cycle verified        | Test passes once               |
-| Agent completed       | VCS diff shows changes          | Agent reports "success"        |
-| Requirements met      | Line-by-line checklist          | Tests passing                  |
-| Agent healthy         | `admin_diagnostic` clean        | "No errors in logs"            |
-
-## Red Flags - STOP
-
-- Using "should", "probably", "seems to"
-- Expressing satisfaction before verification ("Great!", "Perfect!", "Done!", etc.)
-- About to commit/push/PR without verification
-- Trusting agent success reports
-- Relying on partial verification
-- Thinking "just this once"
-- Tired and wanting work over
-- ANY wording implying success without having run verification
-
-## Rationalization Prevention
-
-| Excuse                                  | Reality                |
-| --------------------------------------- | ---------------------- |
-| "Should work now"                       | RUN the verification   |
-| "I'm confident"                         | Confidence ≠ evidence  |
-| "Just this once"                        | No exceptions          |
-| "Linter passed"                         | Linter ≠ compiler      |
-| "Agent said success"                    | Verify independently   |
-| "I'm tired"                             | Exhaustion ≠ excuse    |
-| "Partial check is enough"               | Partial proves nothing |
-| "Different words so rule doesn't apply" | Spirit over letter     |
-
-## Key Patterns
-
-**Tests:**
-
-```
-[Run test command] [See: 34/34 pass] "All tests pass"
-NOT: "Should pass now" / "Looks correct"
-```
-
-**Regression tests (TDD Red-Green):**
-
-```
-Write -> Run (pass) -> Revert fix -> Run (MUST FAIL) -> Restore -> Run (pass)
-NOT: "I've written a regression test" (without red-green verification)
-```
-
-**Build:**
-
-```
-[Run build] [See: exit 0] "Build passes"
-NOT: "Linter passed" (linter doesn't check compilation)
-```
-
-**Requirements:**
-
-```
-Re-read plan -> Create checklist -> Verify each -> Report gaps or completion
-NOT: "Tests pass, phase complete"
-```
-
-**Agent delegation:**
-
-```
-Agent reports success -> Check VCS diff -> Verify changes -> Report actual state
-NOT: Trust agent report
-```
-
-## After Verification — Capture Session
-
-Once work is verified complete, capture a session summary so context persists:
-
-```
-YOUR_AGENT_core op:session_capture
-  params: {
-    summary: "<what was accomplished, files modified, key decisions>"
-  }
-```
-
-This ensures the next session has context about what was verified and completed.
-
-## When To Apply
-
-**ALWAYS before:**
-
-- ANY variation of success/completion claims
-- ANY expression of satisfaction
-- ANY positive statement about work state
-- Committing, PR creation, task completion
-- Moving to next task
-- Delegating to agents
-
-## The Bottom Line
-
-Run the command. Read the output. THEN claim the result. This is non-negotiable.
-
-## Agent Tools Reference
-
-| Op                      | When to Use                         |
-| ----------------------- | ----------------------------------- |
-| `admin_health`          | Quick system health check           |
-| `admin_diagnostic`      | Comprehensive system diagnostic     |
-| `admin_vault_analytics` | Knowledge quality metrics           |
-| `session_capture`       | Persist verified completion context |

package/dist/skills/writing-plans.md

@@ -1,215 +0,0 @@
----
-name: writing-plans
-description: Use when you have a spec or requirements for a multi-step task, before touching code
----
-
-<!-- Adapted from superpowers (MIT License) -->
-
-# Writing Plans
-
-## Overview
-
-Write comprehensive implementation plans assuming the engineer has zero context for our codebase and questionable taste. Document everything they need to know: which files to touch for each task, code, testing, docs they might need to check, how to test it. Give them the whole plan as bite-sized tasks. DRY. YAGNI. TDD. Frequent commits.
-
-Assume they are a skilled developer, but know almost nothing about our toolset or problem domain. Assume they don't know good test design very well.
-
-**Announce at start:** "I'm using the writing-plans skill to create the implementation plan."
-
-**Save plans to:** `docs/plans/YYYY-MM-DD-<feature-name>.md`
-
-## Before Writing — Search First, Plan Second
-
-**Never write a plan from scratch.** Always search for existing knowledge first.
-
-### 1. Vault First
-
-Check the vault for relevant implementation patterns:
-
-```
-YOUR_AGENT_core op:search_intelligent
-  params: { query: "<feature being planned>" }
-```
-
-Look for:
-
-- **Implementation patterns** — proven approaches for similar features
-- **Anti-patterns** — approaches that failed and should be avoided
-- **Testing patterns** — how similar features were tested
-
-Also check brain strengths for what's worked:
-
-```
-YOUR_AGENT_core op:brain_strengths
-```
-
-Browse related knowledge domains for additional context:
-
-```
-YOUR_AGENT_core op:vault_domains
-YOUR_AGENT_core op:vault_tags
-```
-
-### 2. Web Search Second
-
-If the vault doesn't have implementation guidance, search the web:
-
-- **Libraries and tools** — is there a package that does this already?
-- **Reference implementations** — how did other projects solve this?
-- **API documentation** — official docs for libraries you'll use
-- **Known issues** — pitfalls others ran into
-
-### 3. Then Write the Plan
-
-Incorporate vault insights and web findings into the plan. Reference specific vault entries and documentation links when they inform a step. A plan informed by existing knowledge is dramatically better than one written from first principles.
-
-## Create a Tracked Plan
-
-Use the agent's planning system to create a tracked, resumable plan:
-
-```
-YOUR_AGENT_core op:create_plan
-  params: {
-    objective: "<one-sentence goal>",
-    scope: { included: [...], excluded: [...] },
-    steps: [
-      { title: "Step 1 title", description: "details" },
-      ...
-    ]
-  }
-```
-
-This makes the plan persistent across sessions — if context compacts or sessions change, the plan survives.
-
-## Grade the Plan
-
-After drafting, grade the plan for quality before presenting to the user:
-
-```
-YOUR_AGENT_core op:plan_grade
-  params: { planId: "<id from create_plan>" }
-```
-
-If the grade is below target, auto-improve:
-
-```
-YOUR_AGENT_core op:plan_auto_improve
-  params: { planId: "<id>" }
-```
-
-This iterates on the plan — filling gaps, adding missing test steps, clarifying ambiguous instructions. Repeat until the grade meets the target:
-
-```
-YOUR_AGENT_core op:plan_meets_grade
-  params: { planId: "<id>", targetGrade: "A" }
-```
-
-### Iterate on Drafts
-
-For complex plans, iterate before finalizing:
-
-```
-YOUR_AGENT_core op:plan_iterate
-  params: { planId: "<id>", feedback: "<what needs improvement>" }
-```
-
-This creates a new version of the plan incorporating the feedback, preserving version history.
-
-## Split into Tasks
-
-Once the plan is approved, split it into trackable tasks:
-
-```
-YOUR_AGENT_core op:plan_split
-  params: { planId: "<id>" }
-```
-
-This generates individual tasks from the plan steps, ready for execution tracking.
-
-## Bite-Sized Task Granularity
-
-**Each step is one action (2-5 minutes):**
-
-- "Write the failing test" - step
-- "Run it to make sure it fails" - step
-- "Implement the minimal code to make the test pass" - step
-- "Run the tests and make sure they pass" - step
-- "Commit" - step
-
-## Plan Document Header
-
-**Every plan MUST start with this header:**
-
-```markdown
-# [Feature Name] Implementation Plan
-
-> **For Claude:** REQUIRED SUB-SKILL: Use executing-plans to implement this plan task-by-task.
-
-**Goal:** [One sentence describing what this builds]
-
-**Architecture:** [2-3 sentences about approach]
-
-**Tech Stack:** [Key technologies/libraries]
-
----
-```
-
-## Task Structure
-
-Each task uses this format:
-
-- Files: Create / Modify / Test paths
-- Step 1: Write the failing test (with code)
-- Step 2: Run test to verify it fails (with expected output)
-- Step 3: Write minimal implementation (with code)
-- Step 4: Run test to verify it passes (with expected output)
-- Step 5: Commit (with exact git commands)
-
-## Remember
-
-- Exact file paths always
-- Complete code in plan (not "add validation")
-- Exact commands with expected output
-- DRY, YAGNI, TDD, frequent commits
-
-## After Plan Approval
-
-Once the user approves the plan, register it for tracking:
-
-```
-YOUR_AGENT_core op:approve_plan
-  params: { planId: "<id from create_plan>" }
-```
-
-Check plan stats for an overview:
-
-```
-YOUR_AGENT_core op:plan_stats
-```
-
-## Execution Handoff
-
-After saving the plan, offer execution choice:
-
-"Plan complete and saved to `docs/plans/<filename>.md`. Two execution options:
-
-**1. Subagent-Driven (this session)** - I dispatch fresh subagent per task, review between tasks, fast iteration
-
-**2. Parallel Session (separate)** - Open new session with executing-plans, batch execution with checkpoints
-
-Which approach?"
-
-## Agent Tools Reference
-
-| Op                             | When to Use                            |
-| ------------------------------ | -------------------------------------- |
-| `search_intelligent`           | Find relevant patterns before planning |
-| `brain_strengths`              | Check proven approaches                |
-| `vault_domains` / `vault_tags` | Browse knowledge landscape             |
-| `create_plan`                  | Create tracked, persistent plan        |
-| `plan_grade`                   | Grade plan quality                     |
-| `plan_auto_improve`            | Auto-fix plan weaknesses               |
-| `plan_meets_grade`             | Verify grade target reached            |
-| `plan_iterate`                 | Iterate on draft with feedback         |
-| `plan_split`                   | Split plan into trackable tasks        |
-| `approve_plan`                 | Lock in approved plan                  |
-| `plan_stats`                   | Overview of plan metrics               |