@soleri/forge 5.2.0 → 5.5.0

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

@@ -0,0 +1,170 @@
+---
+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/src/skills/writing-plans.md

@@ -0,0 +1,207 @@
+---
+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 |

package/src/templates/claude-md-template.ts

@@ -57,6 +57,9 @@ export function generateClaudeMdTemplate(config: AgentConfig): string {
     `| Session capture | ${bt}${toolPrefix}_core${bt} | ${bt}session_capture${bt} |`,
     `| Export knowledge | ${bt}${toolPrefix}_core${bt} | ${bt}export${bt} |`,
     `| Record feedback | ${bt}${toolPrefix}_core${bt} | ${bt}record_feedback${bt} |`,
+    `| Enhanced feedback | ${bt}${toolPrefix}_core${bt} | ${bt}brain_feedback${bt} |`,
+    `| Feedback stats | ${bt}${toolPrefix}_core${bt} | ${bt}brain_feedback_stats${bt} |`,
+    `| Reset extracted | ${bt}${toolPrefix}_core${bt} | ${bt}brain_reset_extracted${bt} |`,
     `| Rebuild vocabulary | ${bt}${toolPrefix}_core${bt} | ${bt}rebuild_vocabulary${bt} |`,
     `| Brain stats | ${bt}${toolPrefix}_core${bt} | ${bt}brain_stats${bt} |`,
     `| LLM status | ${bt}${toolPrefix}_core${bt} | ${bt}llm_status${bt} |`,
@@ -73,6 +76,117 @@ export function generateClaudeMdTemplate(config: AgentConfig): string {
     `| Add guideline | ${bt}${toolPrefix}_core${bt} | ${bt}add_guideline${bt} |`,
     `| Remove guideline | ${bt}${toolPrefix}_core${bt} | ${bt}remove_guideline${bt} |`,
     `| Rollback identity | ${bt}${toolPrefix}_core${bt} | ${bt}rollback_identity${bt} |`,
+    `| Cognee status | ${bt}${toolPrefix}_core${bt} | ${bt}cognee_status${bt} |`,
+    `| Cognee search | ${bt}${toolPrefix}_core${bt} | ${bt}cognee_search${bt} |`,
+    `| Cognee add | ${bt}${toolPrefix}_core${bt} | ${bt}cognee_add${bt} |`,
+    `| Cognee cognify | ${bt}${toolPrefix}_core${bt} | ${bt}cognee_cognify${bt} |`,
+    `| Cognee config | ${bt}${toolPrefix}_core${bt} | ${bt}cognee_config${bt} |`,
+    `| LLM rotate key | ${bt}${toolPrefix}_core${bt} | ${bt}llm_rotate${bt} |`,
+    `| LLM call | ${bt}${toolPrefix}_core${bt} | ${bt}llm_call${bt} |`,
+    `| Governance policy | ${bt}${toolPrefix}_core${bt} | ${bt}governance_policy${bt} |`,
+    `| Governance proposals | ${bt}${toolPrefix}_core${bt} | ${bt}governance_proposals${bt} |`,
+    `| Governance stats | ${bt}${toolPrefix}_core${bt} | ${bt}governance_stats${bt} |`,
+    `| Expire proposals | ${bt}${toolPrefix}_core${bt} | ${bt}governance_expire${bt} |`,
+    `| Governance dashboard | ${bt}${toolPrefix}_core${bt} | ${bt}governance_dashboard${bt} |`,
+    // Planning Extra ops
+    `| Iterate plan | ${bt}${toolPrefix}_core${bt} | ${bt}plan_iterate${bt} |`,
+    `| Split plan tasks | ${bt}${toolPrefix}_core${bt} | ${bt}plan_split${bt} |`,
+    `| Reconcile plan | ${bt}${toolPrefix}_core${bt} | ${bt}plan_reconcile${bt} |`,
+    `| Complete lifecycle | ${bt}${toolPrefix}_core${bt} | ${bt}plan_complete_lifecycle${bt} |`,
+    `| Dispatch tasks | ${bt}${toolPrefix}_core${bt} | ${bt}plan_dispatch${bt} |`,
+    `| Review plan | ${bt}${toolPrefix}_core${bt} | ${bt}plan_review${bt} |`,
+    `| Archive plan | ${bt}${toolPrefix}_core${bt} | ${bt}plan_archive${bt} |`,
+    `| List plan tasks | ${bt}${toolPrefix}_core${bt} | ${bt}plan_list_tasks${bt} |`,
+    `| Plan stats | ${bt}${toolPrefix}_core${bt} | ${bt}plan_stats${bt} |`,
+    // Memory Extra ops
+    `| Delete memory | ${bt}${toolPrefix}_core${bt} | ${bt}memory_delete${bt} |`,
+    `| Memory stats | ${bt}${toolPrefix}_core${bt} | ${bt}memory_stats${bt} |`,
+    `| Export memories | ${bt}${toolPrefix}_core${bt} | ${bt}memory_export${bt} |`,
+    `| Import memories | ${bt}${toolPrefix}_core${bt} | ${bt}memory_import${bt} |`,
+    `| Prune memories | ${bt}${toolPrefix}_core${bt} | ${bt}memory_prune${bt} |`,
+    `| Deduplicate memories | ${bt}${toolPrefix}_core${bt} | ${bt}memory_deduplicate${bt} |`,
+    `| Memory topics | ${bt}${toolPrefix}_core${bt} | ${bt}memory_topics${bt} |`,
+    `| Memories by project | ${bt}${toolPrefix}_core${bt} | ${bt}memory_by_project${bt} |`,
+    // Vault Extra ops
+    `| Get vault entry | ${bt}${toolPrefix}_core${bt} | ${bt}vault_get${bt} |`,
+    `| Update entry | ${bt}${toolPrefix}_core${bt} | ${bt}vault_update${bt} |`,
+    `| Remove entry | ${bt}${toolPrefix}_core${bt} | ${bt}vault_remove${bt} |`,
+    `| Bulk add | ${bt}${toolPrefix}_core${bt} | ${bt}vault_bulk_add${bt} |`,
+    `| Bulk remove | ${bt}${toolPrefix}_core${bt} | ${bt}vault_bulk_remove${bt} |`,
+    `| Vault tags | ${bt}${toolPrefix}_core${bt} | ${bt}vault_tags${bt} |`,
+    `| Vault domains | ${bt}${toolPrefix}_core${bt} | ${bt}vault_domains${bt} |`,
+    `| Recent entries | ${bt}${toolPrefix}_core${bt} | ${bt}vault_recent${bt} |`,
+    `| Import entries | ${bt}${toolPrefix}_core${bt} | ${bt}vault_import${bt} |`,
+    `| Seed entries | ${bt}${toolPrefix}_core${bt} | ${bt}vault_seed${bt} |`,
+    `| Backup vault | ${bt}${toolPrefix}_core${bt} | ${bt}vault_backup${bt} |`,
+    `| Vault age report | ${bt}${toolPrefix}_core${bt} | ${bt}vault_age_report${bt} |`,
+    // Admin ops
+    `| Admin health | ${bt}${toolPrefix}_core${bt} | ${bt}admin_health${bt} |`,
+    `| Tool list | ${bt}${toolPrefix}_core${bt} | ${bt}admin_tool_list${bt} |`,
+    `| Config | ${bt}${toolPrefix}_core${bt} | ${bt}admin_config${bt} |`,
+    `| Vault size | ${bt}${toolPrefix}_core${bt} | ${bt}admin_vault_size${bt} |`,
+    `| Uptime | ${bt}${toolPrefix}_core${bt} | ${bt}admin_uptime${bt} |`,
+    `| Version | ${bt}${toolPrefix}_core${bt} | ${bt}admin_version${bt} |`,
+    `| Reset cache | ${bt}${toolPrefix}_core${bt} | ${bt}admin_reset_cache${bt} |`,
+    `| Diagnostic | ${bt}${toolPrefix}_core${bt} | ${bt}admin_diagnostic${bt} |`,
+    // Loop ops
+    `| Start loop | ${bt}${toolPrefix}_core${bt} | ${bt}loop_start${bt} |`,
+    `| Loop iterate | ${bt}${toolPrefix}_core${bt} | ${bt}loop_iterate${bt} |`,
+    `| Loop status | ${bt}${toolPrefix}_core${bt} | ${bt}loop_status${bt} |`,
+    `| Cancel loop | ${bt}${toolPrefix}_core${bt} | ${bt}loop_cancel${bt} |`,
+    `| Loop history | ${bt}${toolPrefix}_core${bt} | ${bt}loop_history${bt} |`,
+    `| Loop active | ${bt}${toolPrefix}_core${bt} | ${bt}loop_is_active${bt} |`,
+    `| Complete loop | ${bt}${toolPrefix}_core${bt} | ${bt}loop_complete${bt} |`,
+    // Orchestrate ops
+    `| Orchestrate plan | ${bt}${toolPrefix}_core${bt} | ${bt}orchestrate_plan${bt} |`,
+    `| Orchestrate execute | ${bt}${toolPrefix}_core${bt} | ${bt}orchestrate_execute${bt} |`,
+    `| Orchestrate complete | ${bt}${toolPrefix}_core${bt} | ${bt}orchestrate_complete${bt} |`,
+    `| Orchestrate status | ${bt}${toolPrefix}_core${bt} | ${bt}orchestrate_status${bt} |`,
+    `| Quick capture | ${bt}${toolPrefix}_core${bt} | ${bt}orchestrate_quick_capture${bt} |`,
+    // Capture ops
+    `| Capture knowledge | ${bt}${toolPrefix}_core${bt} | ${bt}capture_knowledge${bt} |`,
+    `| Quick capture entry | ${bt}${toolPrefix}_core${bt} | ${bt}capture_quick${bt} |`,
+    `| Intelligent search | ${bt}${toolPrefix}_core${bt} | ${bt}search_intelligent${bt} |`,
+    `| Search feedback | ${bt}${toolPrefix}_core${bt} | ${bt}search_feedback${bt} |`,
+    // Grading ops
+    `| Grade plan | ${bt}${toolPrefix}_core${bt} | ${bt}plan_grade${bt} |`,
+    `| Check history | ${bt}${toolPrefix}_core${bt} | ${bt}plan_check_history${bt} |`,
+    `| Latest check | ${bt}${toolPrefix}_core${bt} | ${bt}plan_latest_check${bt} |`,
+    `| Meets grade | ${bt}${toolPrefix}_core${bt} | ${bt}plan_meets_grade${bt} |`,
+    `| Auto improve plan | ${bt}${toolPrefix}_core${bt} | ${bt}plan_auto_improve${bt} |`,
+    // Admin Extra ops
+    `| Telemetry stats | ${bt}${toolPrefix}_core${bt} | ${bt}admin_telemetry${bt} |`,
+    `| Recent calls | ${bt}${toolPrefix}_core${bt} | ${bt}admin_telemetry_recent${bt} |`,
+    `| Reset telemetry | ${bt}${toolPrefix}_core${bt} | ${bt}admin_telemetry_reset${bt} |`,
+    `| Permissions | ${bt}${toolPrefix}_core${bt} | ${bt}admin_permissions${bt} |`,
+    `| Vault analytics | ${bt}${toolPrefix}_core${bt} | ${bt}admin_vault_analytics${bt} |`,
+    `| Search insights | ${bt}${toolPrefix}_core${bt} | ${bt}admin_search_insights${bt} |`,
+    `| Module status | ${bt}${toolPrefix}_core${bt} | ${bt}admin_module_status${bt} |`,
+    `| Environment | ${bt}${toolPrefix}_core${bt} | ${bt}admin_env${bt} |`,
+    `| Garbage collect | ${bt}${toolPrefix}_core${bt} | ${bt}admin_gc${bt} |`,
+    `| Export config | ${bt}${toolPrefix}_core${bt} | ${bt}admin_export_config${bt} |`,
+    // Curator Extra ops
+    `| Entry history | ${bt}${toolPrefix}_core${bt} | ${bt}curator_entry_history${bt} |`,
+    `| Record snapshot | ${bt}${toolPrefix}_core${bt} | ${bt}curator_record_snapshot${bt} |`,
+    `| Queue stats | ${bt}${toolPrefix}_core${bt} | ${bt}curator_queue_stats${bt} |`,
+    `| Enrich metadata | ${bt}${toolPrefix}_core${bt} | ${bt}curator_enrich${bt} |`,
+    // Project ops
+    `| Get project | ${bt}${toolPrefix}_core${bt} | ${bt}project_get${bt} |`,
+    `| List projects | ${bt}${toolPrefix}_core${bt} | ${bt}project_list${bt} |`,
+    `| Unregister project | ${bt}${toolPrefix}_core${bt} | ${bt}project_unregister${bt} |`,
+    `| Project rules | ${bt}${toolPrefix}_core${bt} | ${bt}project_get_rules${bt} |`,
+    `| All project rules | ${bt}${toolPrefix}_core${bt} | ${bt}project_list_rules${bt} |`,
+    `| Add rule | ${bt}${toolPrefix}_core${bt} | ${bt}project_add_rule${bt} |`,
+    `| Remove rule | ${bt}${toolPrefix}_core${bt} | ${bt}project_remove_rule${bt} |`,
+    `| Link projects | ${bt}${toolPrefix}_core${bt} | ${bt}project_link${bt} |`,
+    `| Unlink projects | ${bt}${toolPrefix}_core${bt} | ${bt}project_unlink${bt} |`,
+    `| Project links | ${bt}${toolPrefix}_core${bt} | ${bt}project_get_links${bt} |`,
+    `| Linked projects | ${bt}${toolPrefix}_core${bt} | ${bt}project_linked_projects${bt} |`,
+    `| Touch project | ${bt}${toolPrefix}_core${bt} | ${bt}project_touch${bt} |`,
+    // Cross-project memory ops
+    `| Promote to global | ${bt}${toolPrefix}_core${bt} | ${bt}memory_promote_to_global${bt} |`,
+    `| Configure memory | ${bt}${toolPrefix}_core${bt} | ${bt}memory_configure${bt} |`,
+    `| Cross-project search | ${bt}${toolPrefix}_core${bt} | ${bt}memory_cross_project_search${bt} |`,
   );
 
   mdLines.push(
@@ -130,6 +244,73 @@ export function generateClaudeMdTemplate(config: AgentConfig): string {
     `<!-- /${marker} -->`,
   );
 
+  // ─── Hook Packs section (when configured) ─────────────────────
+  if (config.hookPacks?.length) {
+    const PACK_INFO: Record<string, { description: string; hooks: Record<string, string> }> = {
+      'typescript-safety': {
+        description: 'Block unsafe TypeScript patterns',
+        hooks: {
+          'no-any-types': '`:any`, `as any`, `<any>`, `Record<string, any>`',
+          'no-console-log': '`console.log` in committed code',
+        },
+      },
+      a11y: {
+        description: 'Accessibility enforcement',
+        hooks: {
+          'semantic-html': 'Generic divs where semantic HTML should be used',
+          'focus-ring-required': 'Missing visible focus indicators',
+          'ux-touch-targets': 'Touch targets smaller than 44px',
+        },
+      },
+      'css-discipline': {
+        description: 'CSS best practices',
+        hooks: {
+          'no-important': '`!important` in CSS',
+          'no-inline-styles': 'Inline style attributes',
+        },
+      },
+      'clean-commits': {
+        description: 'Clean git history',
+        hooks: {
+          'no-ai-attribution': 'AI attribution in commits',
+        },
+      },
+    };
+
+    // Build rows — expand 'full' to constituent packs
+    const rows: Array<{ pack: string; hook: string; blocks: string }> = [];
+    for (const packName of config.hookPacks) {
+      if (packName === 'full') {
+        // Composed pack — expand all constituent packs
+        for (const [subPack, info] of Object.entries(PACK_INFO)) {
+          for (const [hook, blocks] of Object.entries(info.hooks)) {
+            rows.push({ pack: subPack, hook, blocks });
+          }
+        }
+      } else if (PACK_INFO[packName]) {
+        for (const [hook, blocks] of Object.entries(PACK_INFO[packName].hooks)) {
+          rows.push({ pack: packName, hook, blocks });
+        }
+      }
+    }
+
+    if (rows.length > 0) {
+      // Insert before the closing marker
+      const closingMarkerIndex = mdLines.length - 1;
+      const hookLines = [
+        '',
+        '## Hook Packs',
+        '',
+        'Quality gates installed in `.claude/`. Run `scripts/setup.sh` to install globally.',
+        '',
+        '| Pack | Hook | Blocks |',
+        '|------|------|--------|',
+        ...rows.map((r) => `| ${r.pack} | ${r.hook} | ${r.blocks} |`),
+      ];
+      mdLines.splice(closingMarkerIndex, 0, ...hookLines);
+    }
+  }
+
   // Escape each markdown line for use in a single-quoted TS string literal
   const quotedLines = mdLines.map((line) => {
     const escaped = line.replace(/\\/g, '\\\\').replace(/'/g, "\\'");

package/src/templates/domain-facade.ts

@@ -1,6 +1,10 @@
 /**
  * Generate a domain-specific facade for the agent.
  * Each domain gets a facade with search, get_patterns, and list ops.
+ *
+ * @deprecated v4 legacy only — v5 agents use createDomainFacade() from
+ * @soleri/core which includes governance gating. This template is only
+ * used by domain-manager.ts for pre-v5 agents.
  */
 export function generateDomainFacade(agentId: string, domain: string): string {
   const facadeName = `${agentId}_${domain.replace(/-/g, '_')}`;

package/src/templates/entry-point.ts

@@ -143,6 +143,37 @@ async function main(): Promise<void> {
         if (s.totalEntries === 0) {
           recommendations.push('Vault is empty — add intelligence data or capture knowledge via domain facades');
         }
+
+        // Check hook status
+        const { readdirSync } = await import('node:fs');
+        const agentClaudeDir = joinPath(__dirname, '..', '.claude');
+        const globalClaudeDir = joinPath(homedir(), '.claude');
+
+        const hookStatus = { agent: [] as string[], global: [] as string[], missing: [] as string[] };
+
+        if (existsSync(agentClaudeDir)) {
+          try {
+            const agentHooks = readdirSync(agentClaudeDir)
+              .filter((f: string) => f.startsWith('hookify.') && f.endsWith('.local.md'))
+              .map((f: string) => f.replace('hookify.', '').replace('.local.md', ''));
+            hookStatus.agent = agentHooks;
+
+            for (const hook of agentHooks) {
+              if (existsSync(joinPath(globalClaudeDir, \`hookify.\${hook}.local.md\`))) {
+                hookStatus.global.push(hook);
+              } else {
+                hookStatus.missing.push(hook);
+              }
+            }
+          } catch {
+            // ignore read errors
+          }
+        }
+
+        if (hookStatus.missing.length > 0) {
+          recommendations.push(\`\${hookStatus.missing.length} hook(s) not installed globally — run scripts/setup.sh\`);
+        }
+
         if (recommendations.length === 0) {
           recommendations.push('${config.name} is fully set up and ready!');
         }
@@ -154,6 +185,7 @@ async function main(): Promise<void> {
             global: { exists: globalExists, has_agent_section: globalHasAgent },
           },
           vault: { entries: s.totalEntries, domains: Object.keys(s.byDomain) },
+          hooks: hookStatus,
           recommendations,
         };
       },

package/src/templates/readme.ts

@@ -84,6 +84,44 @@ ${domainRows}
 
 ${principleLines}
 
+## Built-in Skills
+
+${config.name} ships with 17 structured workflow skills, invocable via \`/<skill-name>\` in Claude Code:
+
+**Development Workflows:**
+
+| Skill | Description |
+|-------|-------------|
+| \`/test-driven-development\` | Red-green-refactor TDD workflow with vault-informed test patterns |
+| \`/systematic-debugging\` | Root cause investigation — vault search, web search, then diagnose |
+| \`/verification-before-completion\` | Evidence-based completion claims with system diagnostics |
+| \`/brainstorming\` | Collaborative design exploration with vault + web research first |
+| \`/writing-plans\` | Implementation plans with quality grading and auto-improvement |
+| \`/executing-plans\` | Batch execution with loop tracking and plan reconciliation |
+| \`/fix-and-learn\` | Fix bugs and capture root cause — vault search before any fix |
+| \`/code-patrol\` | Review code against YOUR vault patterns, not generic lint rules |
+
+**Knowledge Management:**
+
+| Skill | Description |
+|-------|-------------|
+| \`/vault-navigator\` | Intelligent vault search — tags, domains, age reports, cross-project |
+| \`/vault-capture\` | Persist knowledge with curator grooming and governance |
+| \`/knowledge-harvest\` | Point at any doc/code — auto-extract patterns into vault |
+| \`/brain-debrief\` | Intelligence report — strengths, gaps, cross-project insights |
+
+**Magic UX:**
+
+| Skill | Description |
+|-------|-------------|
+| \`/context-resume\` | "What was I working on?" — full context reconstruction |
+| \`/second-opinion\` | Decision support from vault + brain + web combined |
+| \`/retrospective\` | Data-driven sprint/week retro from actual metrics |
+| \`/onboard-me\` | Instant project knowledge tour for newcomers |
+| \`/health-check\` | Vault maintenance — duplicates, contradictions, stale entries |
+
+Skills are installed to \`~/.claude/commands/\` during setup. Run \`./scripts/setup.sh\` to install or reinstall.
+
 ## Features
 
 ### Knowledge Vault