@soleri/forge 5.14.0 → 5.14.2

package/dist/skills/test-driven-development.md

@@ -18,12 +18,14 @@ Write the test first. Watch it fail. Write minimal code to pass.
 ## When to Use
 
 **Always:**
+
 - New features
 - Bug fixes
 - Refactoring
 - Behavior changes
 
 **Exceptions (ask your human partner):**
+
 - Throwaway prototypes
 - Generated code
 - Configuration files
@@ -35,6 +37,7 @@ Thinking "skip TDD just this once"? Stop. That's rationalization.
 **Never start writing tests blind.** Follow this lookup order:
 
 ### 1. Vault First
+
 Check for existing testing patterns in the knowledge base:
 
 ```
@@ -43,6 +46,7 @@ YOUR_AGENT_core op:search_intelligent
 ```
 
 Look for:
+
 - **Testing patterns** for similar features (how were they tested before?)
 - **Anti-patterns** — common testing mistakes in this domain
 - **Proven approaches** from brain strengths:
@@ -54,12 +58,15 @@ YOUR_AGENT_core op:brain_strengths
 If the vault has testing guidance for this domain, follow it. Don't reinvent test strategies that have already been validated.
 
 ### 2. Web Search
+
 If the vault has no relevant patterns, search the web for established testing approaches:
+
 - Library-specific testing patterns (e.g., how to test React hooks, Express middleware)
 - Best practices for the specific type of test (integration, e2e, unit)
 - Known gotchas in the testing framework being used
 
 ### 3. Then Write the Test
+
 Only after consulting vault and web, proceed to write the failing test. You'll write better tests when informed by existing knowledge.
 
 ## Start a TDD Loop
@@ -80,6 +87,7 @@ NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST
 Write code before the test? Delete it. Start over.
 
 **No exceptions:**
+
 - Don't keep it as "reference"
 - Don't "adapt" it while writing tests
 - Don't look at it
@@ -97,6 +105,7 @@ Good: clear name, tests real behavior, one thing
 Bad: vague name, tests mock not code
 
 **Requirements:**
+
 - One behavior
 - Clear name
 - Real code (no mocks unless unavoidable)
@@ -108,6 +117,7 @@ Bad: vague name, tests mock not code
 Run: `npm test path/to/test.test.ts`
 
 Confirm:
+
 - Test fails (not errors)
 - Failure message is expected
 - Fails because feature missing (not typos)
@@ -116,6 +126,7 @@ Confirm:
 **Test errors?** Fix error, re-run until it fails correctly.
 
 Track the iteration:
+
 ```
 YOUR_AGENT_core op:loop_iterate
 ```
@@ -131,6 +142,7 @@ Write simplest code to pass the test. Don't add features, refactor other code, o
 Run: `npm test path/to/test.test.ts`
 
 Confirm:
+
 - Test passes
 - Other tests still pass
 - Output pristine (no errors, warnings)
@@ -139,6 +151,7 @@ Confirm:
 **Other tests fail?** Fix now.
 
 Track the iteration:
+
 ```
 YOUR_AGENT_core op:loop_iterate
 ```
@@ -146,6 +159,7 @@ YOUR_AGENT_core op:loop_iterate
 ### REFACTOR - Clean Up
 
 After green only:
+
 - Remove duplication
 - Improve names
 - Extract helpers
@@ -158,11 +172,11 @@ Next failing test for next feature.
 
 ## Good Tests
 
-| Quality | Good | Bad |
-|---------|------|-----|
-| **Minimal** | One thing. "and" in name? Split it. | `test('validates email and domain and whitespace')` |
-| **Clear** | Name describes behavior | `test('test1')` |
-| **Shows intent** | Demonstrates desired API | Obscures what code should do |
+| Quality          | Good                                | Bad                                                 |
+| ---------------- | ----------------------------------- | --------------------------------------------------- |
+| **Minimal**      | One thing. "and" in name? Split it. | `test('validates email and domain and whitespace')` |
+| **Clear**        | Name describes behavior             | `test('test1')`                                     |
+| **Shows intent** | Demonstrates desired API            | Obscures what code should do                        |
 
 ## Why Order Matters
 
@@ -170,19 +184,19 @@ Tests written after code pass immediately — proving nothing. Test-first forces
 
 ## Common Rationalizations
 
-| Excuse | Reality |
-|--------|---------|
-| "Too simple to test" | Simple code breaks. Test takes 30 seconds. |
-| "I'll test after" | Tests passing immediately prove nothing. |
-| "Tests after achieve same goals" | Tests-after = "what does this do?" Tests-first = "what should this do?" |
-| "Already manually tested" | Ad-hoc ≠ systematic. No record, can't re-run. |
-| "Deleting X hours is wasteful" | Sunk cost fallacy. Keeping unverified code is technical debt. |
-| "Keep as reference, write tests first" | You'll adapt it. That's testing after. Delete means delete. |
-| "Need to explore first" | Fine. Throw away exploration, start with TDD. |
-| "Test hard = design unclear" | Listen to test. Hard to test = hard to use. |
-| "TDD will slow me down" | TDD faster than debugging. Pragmatic = test-first. |
-| "Manual test faster" | Manual doesn't prove edge cases. You'll re-test every change. |
-| "Existing code has no tests" | You're improving it. Add tests for existing code. |
+| Excuse                                 | Reality                                                                 |
+| -------------------------------------- | ----------------------------------------------------------------------- |
+| "Too simple to test"                   | Simple code breaks. Test takes 30 seconds.                              |
+| "I'll test after"                      | Tests passing immediately prove nothing.                                |
+| "Tests after achieve same goals"       | Tests-after = "what does this do?" Tests-first = "what should this do?" |
+| "Already manually tested"              | Ad-hoc ≠ systematic. No record, can't re-run.                           |
+| "Deleting X hours is wasteful"         | Sunk cost fallacy. Keeping unverified code is technical debt.           |
+| "Keep as reference, write tests first" | You'll adapt it. That's testing after. Delete means delete.             |
+| "Need to explore first"                | Fine. Throw away exploration, start with TDD.                           |
+| "Test hard = design unclear"           | Listen to test. Hard to test = hard to use.                             |
+| "TDD will slow me down"                | TDD faster than debugging. Pragmatic = test-first.                      |
+| "Manual test faster"                   | Manual doesn't prove edge cases. You'll re-test every change.           |
+| "Existing code has no tests"           | You're improving it. Add tests for existing code.                       |
 
 ## Red Flags - STOP and Start Over
 
@@ -220,6 +234,7 @@ Can't check all boxes? You skipped TDD. Start over.
 ## After TDD — Capture and Complete
 
 Complete the loop:
+
 ```
 YOUR_AGENT_core op:loop_complete
 ```
@@ -238,12 +253,12 @@ This compounds across sessions — next time someone works on similar code, the
 
 ## When Stuck
 
-| Problem | Solution |
-|---------|----------|
+| Problem                | Solution                                                             |
+| ---------------------- | -------------------------------------------------------------------- |
 | Don't know how to test | Write wished-for API. Write assertion first. Ask your human partner. |
-| Test too complicated | Design too complicated. Simplify interface. |
-| Must mock everything | Code too coupled. Use dependency injection. |
-| Test setup huge | Extract helpers. Still complex? Simplify design. |
+| Test too complicated   | Design too complicated. Simplify interface.                          |
+| Must mock everything   | Code too coupled. Use dependency injection.                          |
+| Test setup huge        | Extract helpers. Still complex? Simplify design.                     |
 
 ## Final Rule
 
@@ -256,11 +271,11 @@ No exceptions without your human partner's permission.
 
 ## Agent Tools Reference
 
-| Op | When to Use |
-|----|-------------|
+| Op                   | When to Use                           |
+| -------------------- | ------------------------------------- |
 | `search_intelligent` | Find testing patterns before starting |
-| `brain_strengths` | Check proven testing approaches |
-| `loop_start` | Begin TDD validation loop |
-| `loop_iterate` | Track each red-green cycle |
-| `loop_complete` | Finish TDD loop |
-| `capture_quick` | Capture new testing patterns |
+| `brain_strengths`    | Check proven testing approaches       |
+| `loop_start`         | Begin TDD validation loop             |
+| `loop_iterate`       | Track each red-green cycle            |
+| `loop_complete`      | Finish TDD loop                       |
+| `capture_quick`      | Capture new testing patterns          |

package/dist/skills/vault-capture.md

@@ -14,6 +14,7 @@ After discovering something worth remembering: a solution that worked, a mistake
 ## Orchestration Sequence
 
 ### Step 1: Check for Duplicates
+
 Call `YOUR_AGENT_core op:search_intelligent` with the knowledge title or description. If a similar entry exists, consider updating it instead of creating a duplicate.
 
 ```
@@ -30,7 +31,9 @@ YOUR_AGENT_core op:curator_detect_duplicates
 If duplicates are found, decide: update the existing entry or merge them.
 
 ### Step 2: Classify the Knowledge
+
 Determine the entry type:
+
 - **pattern** — Something that works and should be repeated
 - **anti-pattern** — Something that fails and should be avoided
 - **workflow** — A sequence of steps for a specific task
@@ -45,8 +48,10 @@ YOUR_AGENT_core op:route_intent
 ```
 
 ### Step 3: Capture
+
 For quick, single-entry captures:
 Call `YOUR_AGENT_core op:capture_knowledge` with:
+
 - **title**: Clear, searchable name
 - **description**: What it is and when it applies
 - **type**: From Step 2 classification
@@ -69,6 +74,7 @@ YOUR_AGENT_core op:capture_knowledge
 ```
 
 For quick captures:
+
 ```
 YOUR_AGENT_core op:capture_quick
   params: { title: "<name>", description: "<details>" }
@@ -79,29 +85,34 @@ YOUR_AGENT_core op:capture_quick
 After capturing, run the curator to ensure quality:
 
 **Groom the entry** — normalize tags, fix metadata:
+
 ```
 YOUR_AGENT_core op:curator_groom
   params: { entryId: "<captured entry id>" }
 ```
 
 **Enrich the entry** — use LLM to add context, improve description:
+
 ```
 YOUR_AGENT_core op:curator_enrich
   params: { entryId: "<captured entry id>" }
 ```
 
 **Check for contradictions** — does this conflict with existing knowledge?
+
 ```
 YOUR_AGENT_core op:curator_contradictions
 ```
 
 If contradictions found, resolve them:
+
 ```
 YOUR_AGENT_core op:curator_resolve_contradiction
   params: { contradictionId: "<id>" }
 ```
 
 ### Step 5: Handle Governance (if enabled)
+
 If governance policy requires review, the capture returns a `proposalId`. The entry is queued for approval.
 
 ```
@@ -112,7 +123,9 @@ YOUR_AGENT_core op:governance_proposals
 Present pending proposals to the user for approval.
 
 ### Step 6: Promote to Global (Optional)
+
 If the knowledge applies across projects (not project-specific):
+
 ```
 YOUR_AGENT_core op:memory_promote_to_global
   params: { entryId: "<entry id>" }
@@ -121,12 +134,15 @@ YOUR_AGENT_core op:memory_promote_to_global
 This makes it available in cross-project searches and brain recommendations.
 
 ### Step 7: Verify Health
+
 Confirm the capture was stored and vault health is maintained:
+
 ```
 YOUR_AGENT_core op:admin_health
 ```
 
 Check vault analytics for overall knowledge quality:
+
 ```
 YOUR_AGENT_core op:admin_vault_analytics
 ```
@@ -137,18 +153,18 @@ Capture is complete when: the entry is stored (or queued for review), categorize
 
 ## Agent Tools Reference
 
-| Op | When to Use |
-|----|-------------|
-| `search_intelligent` | Check for duplicates before capture |
-| `curator_detect_duplicates` | Explicit duplicate detection |
-| `route_intent` | Help classify knowledge type |
-| `capture_knowledge` | Full-metadata capture |
-| `capture_quick` | Fast capture for simple entries |
-| `curator_groom` | Normalize tags and metadata |
-| `curator_enrich` | LLM-powered metadata enrichment |
-| `curator_contradictions` | Find conflicting entries |
-| `curator_resolve_contradiction` | Resolve conflicts |
-| `governance_proposals` | Check/manage approval queue |
-| `memory_promote_to_global` | Share across projects |
-| `admin_health` | Verify system health |
-| `admin_vault_analytics` | Overall knowledge quality metrics |
+| Op                              | When to Use                         |
+| ------------------------------- | ----------------------------------- |
+| `search_intelligent`            | Check for duplicates before capture |
+| `curator_detect_duplicates`     | Explicit duplicate detection        |
+| `route_intent`                  | Help classify knowledge type        |
+| `capture_knowledge`             | Full-metadata capture               |
+| `capture_quick`                 | Fast capture for simple entries     |
+| `curator_groom`                 | Normalize tags and metadata         |
+| `curator_enrich`                | LLM-powered metadata enrichment     |
+| `curator_contradictions`        | Find conflicting entries            |
+| `curator_resolve_contradiction` | Resolve conflicts                   |
+| `governance_proposals`          | Check/manage approval queue         |
+| `memory_promote_to_global`      | Share across projects               |
+| `admin_health`                  | Verify system health                |
+| `admin_vault_analytics`         | Overall knowledge quality metrics   |

package/dist/skills/vault-navigator.md

@@ -14,6 +14,7 @@ Any time the user wants to find existing knowledge before building something new
 ## 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.
 
 ```
@@ -24,24 +25,29 @@ YOUR_AGENT_core op:search_intelligent
 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:
 
 ```
@@ -51,6 +57,7 @@ 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.
 
 ```
@@ -65,6 +72,7 @@ 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.
 
 ```
@@ -74,6 +82,7 @@ YOUR_AGENT_core op:brain_global_patterns
 ```
 
 ### For "What do I know about X?" (broad exploration)
+
 Chain multiple strategies for comprehensive results:
 
 1. `search_intelligent` → semantic vault search
@@ -86,6 +95,7 @@ Present all findings with source labels so the user knows where each insight cam
 ## 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
@@ -94,6 +104,7 @@ Always include:
 ## 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
@@ -114,16 +125,16 @@ Search is complete when at least one search strategy has been tried and results
 
 ## 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 |
+| 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

@@ -45,37 +45,43 @@ Skip any step = lying, not verifying
 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" |
+| 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
 
@@ -90,44 +96,49 @@ If any check reports problems, address them before claiming completion.
 
 ## 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 |
+| 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
@@ -149,6 +160,7 @@ 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
@@ -162,9 +174,9 @@ 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 |
+| 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

@@ -22,6 +22,7 @@ Assume they are a skilled developer, but know almost nothing about our toolset o
 **Never write a plan from scratch.** Always search for existing knowledge first.
 
 ### 1. Vault First
+
 Check the vault for relevant implementation patterns:
 
 ```
@@ -30,6 +31,7 @@ YOUR_AGENT_core op:search_intelligent
 ```
 
 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
@@ -48,13 +50,16 @@ 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
@@ -123,6 +128,7 @@ This generates individual tasks from the plan steps, ready for execution trackin
 ## 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
@@ -150,6 +156,7 @@ This generates individual tasks from the plan steps, ready for execution trackin
 ## 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)
@@ -158,6 +165,7 @@ Each task uses this format:
 - Step 5: Commit (with exact git commands)
 
 ## Remember
+
 - Exact file paths always
 - Complete code in plan (not "add validation")
 - Exact commands with expected output
@@ -192,16 +200,16 @@ 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 |
+| 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               |