@soleri/forge 9.11.0 → 9.13.0

package/src/skills/{retrospective → soleri-retrospective}/SKILL.md

@@ -1,9 +1,10 @@
 ---
-name: retrospective
+name: soleri-retrospective
 description: >
-  Use for time-bound reflection on recent WORK — "sprint retro", "weekly summary", "what went
-  well this week", "end of sprint", "monthly report". Reviews sessions and extracts actionable
-  improvements. For brain pattern intelligence and strength scores, use brain-debrief instead.
+  Use when the user says "sprint retro", "weekly summary", "what went well",
+  "end of sprint", or "monthly report". Time-bound reflection on recent work
+  that reviews sessions and extracts actionable improvements. For brain
+  pattern intelligence and strength scores, use brain-debrief instead.
 ---
 
 # Retrospective — Learning Report From Real Data

package/{dist/skills/second-opinion → src/skills/soleri-second-opinion}/SKILL.md

@@ -1,6 +1,9 @@
 ---
-name: second-opinion
-description: Use when facing a technical decision, comparing approaches, or needing an informed recommendation backed by vault knowledge, brain patterns, and web research.
+name: soleri-second-opinion
+description: >
+  Use when the user says "second opinion", "technical decision",
+  "comparing approaches", or "which approach". Provides informed recommendations
+  backed by vault knowledge, brain patterns, and web research.
 ---
 
 # Second Opinion — Decision Support From All Sources

package/src/skills/{subagent-driven-development → soleri-subagent-driven-development}/SKILL.md

@@ -1,9 +1,9 @@
 ---
-name: subagent-driven-development
+name: soleri-subagent-driven-development
 description: >
-  Use when the user says "use subagents", "parallel agents", "fan out", "dispatch agents",
-  "subagent driven", or when a task decomposes into 2+ independent units that benefit from
-  isolated execution. Covers when to dispatch, worktree isolation, and merge strategy.
+  Use when the user says "use subagents", "parallel agents",
+  "subagent driven", or "isolated execution". Decomposes work into isolated
+  units and dispatches subagents for independent execution.
 ---
 
 # Subagent-Driven Development
@@ -56,6 +56,14 @@ Not all subagents are equal. Route by complexity:
 
 Read all relevant files. Consult the vault for patterns. Make every design decision. Define the exact spec for each subagent task: files to touch, approach to use, acceptance criteria.
 
+```
+YOUR_AGENT_core op:memory_search
+  params: { query: "subagent decomposition" }
+
+YOUR_AGENT_core op:brain_recommend
+  params: { query: "<task domain>" }
+```
+
 ### Step 2: Decompose & Route
 
 Break work into discrete units. For each, determine: files involved, dependencies on other units, conflict risk, complexity. Assign agent type per the routing table.
@@ -82,14 +90,21 @@ Each subagent prompt must include:
 Launch all independent subagents in a **single message** so they run in parallel.
 Use `isolation: "worktree"` for file-modifying tasks.
 
-### Step 4: Review and Merge
+### Step 4: Review, Merge, and Clean Up
 
 For each returning subagent:
 
 1. **Review** — read actual file changes (do not trust self-reports alone), verify tests pass, check scope compliance
 2. **Merge** — `git merge` or `git cherry-pick` from the worktree branch, one at a time
 3. **Test** — run the full suite after each merge; only proceed if green
-4. **Conflicts** — resolve manually, re-run tests, capture as anti-pattern
+4. **Clean up the branch** — after merge is confirmed and tests pass:
+   ```bash
+   git branch -D <subagent/taskId>              # delete local branch
+   ```
+   Worktree branches are local-only — never push them to remote.
+5. **Conflicts** — resolve manually, re-run tests, capture as anti-pattern
+
+**Branch cleanup is mandatory.** Every merged branch must be deleted immediately. Do not leave branches for later cleanup — they accumulate fast during parallel execution.
 
 ### Step 5: Reconcile & Report
 
@@ -98,8 +113,8 @@ After all merges, report to the user:
 **Minimal (default):**
 
 ```
-✓ N/N complete. M patterns captured to vault.
-  → Decisions: [any design decisions the orchestrator made]
+N/N complete. M patterns captured to vault.
+  -> Decisions: [any design decisions the orchestrator made]
 ```
 
 **Detailed (on request):**
@@ -107,19 +122,25 @@ After all merges, report to the user:
 ```
 | # | Task | Agent | Status | Knowledge |
 |---|------|-------|--------|-----------|
-| 1 | Desc | Worker | Done ✓ | — |
-| 2 | Desc | Instance | Done ✓ | 2 patterns |
+| 1 | Desc | Worker | Done | -- |
+| 2 | Desc | Instance | Done | 2 patterns |
 ```
 
 Capture learnings to vault. Run `orchestrate_complete` for the parent plan.
 
-## Worktree Cleanup Guarantee
+```
+YOUR_AGENT_core op:capture_knowledge
+  params: { title: "<learned pattern>", description: "<merge strategy or decomposition insight>", type: "pattern", tags: ["subagent", "parallel-execution"] }
+```
+
+## Worktree & Branch Cleanup Guarantee
 
-Three layers — nothing accumulates:
+Worktree branches are **local-only** — never push them to remote. Four layers ensure nothing accumulates:
 
-1. **Per-task:** `finally` block in dispatcher removes worktree after each task
-2. **Per-batch:** `cleanupAll()` runs after all subagents complete
-3. **Per-session:** `SessionStart` hook prunes orphaned worktrees
+1. **Per-task:** `finally` block in dispatcher removes worktree and local branch after each task
+2. **Per-merge:** Orchestrator deletes local branch immediately after confirmed merge (Step 4)
+3. **Per-batch:** `cleanupAll()` runs after all subagents complete
+4. **Per-session:** `SessionStart` hook prunes orphaned worktrees and deletes merged `subagent/*` and `worktree-agent-*` local branches
 
 ## Anti-Patterns
 

package/{dist/skills/systematic-debugging → src/skills/soleri-systematic-debugging}/SKILL.md

@@ -1,10 +1,10 @@
 ---
-name: systematic-debugging
+name: soleri-systematic-debugging
 description: >
-  Use as the FIRST response when something is broken — "bug", "failing test", "not working",
-  "debug this", "error", "crash", "unexpected behavior", "weird issue". Diagnoses root cause
-  before proposing fixes. After root cause is found, hand off to fix-and-learn for repair and
-  knowledge capture.
+  Use as the FIRST response when something is broken — "bug", "failing test",
+  "not working", "debug this", "error", "crash", or "weird issue". Diagnoses
+  root cause before proposing fixes. After root cause is found, hand off to
+  fix-and-learn for repair and knowledge capture.
 ---
 
 # Systematic Debugging

package/{dist/skills/test-driven-development → src/skills/soleri-test-driven-development}/SKILL.md

@@ -1,6 +1,9 @@
 ---
-name: test-driven-development
-description: Use when implementing any feature or bugfix — write failing tests before implementation code.
+name: soleri-test-driven-development
+description: >
+  Use when the user says "TDD", "write tests first", "red green refactor",
+  or "test driven". Write failing tests before implementation code for any
+  feature or bugfix.
 ---
 
 # Test-Driven Development (TDD)
@@ -9,6 +12,13 @@ description: Use when implementing any feature or bugfix — write failing tests
 
 ## Before You Start — Search First
 
+### Check Vault for Testing Patterns
+
+```
+YOUR_AGENT_core op:search_intelligent
+  params: { query: "<domain> testing patterns" }
+```
+
 ```
 YOUR_AGENT_core op:search_intelligent
   params: { query: "<what you're about to test>" }

package/src/skills/{using-git-worktrees → soleri-using-git-worktrees}/SKILL.md

@@ -1,9 +1,9 @@
 ---
-name: using-git-worktrees
+name: soleri-using-git-worktrees
 description: >
-  Use when the user says "worktree", "isolate", "parallel branch", "safe branch", or when a plan
-  has independent tasks that benefit from parallel execution in isolated branches. Provides the
-  protocol for creating, working in, and cleaning up git worktrees safely.
+  Use when the user says "worktree", "parallel branch", "safe branch",
+  or "isolated branch". Provides the protocol for creating, working in,
+  and cleaning up git worktrees safely.
 ---
 
 # Using Git Worktrees
@@ -12,6 +12,13 @@ Isolate work into parallel branches without stashing or switching. Use for multi
 
 **Announce at start:** "I'm using the using-git-worktrees skill to isolate this work."
 
+## Check Vault for Worktree Patterns
+
+```
+YOUR_AGENT_core op:search_intelligent
+  params: { query: "worktree parallel execution patterns" }
+```
+
 ## When to Use
 
 - Plan has 2+ independent tasks that can run in parallel
@@ -79,3 +86,17 @@ git worktree list                      # confirm removal
 | Claude Code    | Sub-agent with `isolation: "worktree"` parameter |
 
 **Related skills:** executing-plans, parallel-execute
+
+## Capture Worktree Learnings
+
+```
+YOUR_AGENT_core op:capture_quick
+  params: { title: "<what was learned>", tags: ["worktree", "parallel-execution"] }
+```
+
+## Agent Tools Reference
+
+| Op                   | When to Use                       |
+| -------------------- | --------------------------------- |
+| `search_intelligent` | Check vault before starting       |
+| `capture_quick`      | Fast capture for simple learnings |

package/src/skills/soleri-vault-capture/SKILL.md

@@ -0,0 +1,205 @@
+---
+name: soleri-vault-capture
+description: >
+  Use when the user says "save this", "capture this", "remember this pattern",
+  "add to vault", "vault capture", or when persisting learnings from a work
+  session. Validated capture with tier scoping, duplicate detection, and
+  abstraction review. For bulk extraction from documents, code, or PRs, use
+  knowledge-harvest instead.
+---
+
+# Vault Capture — Validated Knowledge Persistence
+
+Capture knowledge to the vault with mandatory validation before persistence. Every item goes through tier classification, duplicate detection, and abstraction review. Nothing lands in the vault without conscious scoping.
+
+## When to Use
+
+- End of a work session — collecting learnings
+- After a significant decision, pattern discovery, or anti-pattern identification
+- When multiple items need capturing from a conversation
+- User says "capture this", "save to vault", "remember this"
+
+## Steps
+
+### 1. Extract Candidate Items
+
+Review the conversation or user request. For each piece of knowledge, extract:
+
+- **Title** — clear, searchable name
+- **Description** — what it is, when it applies, why it matters
+- **Why** — reasoning behind the pattern (makes entries actionable)
+- **Type** — pattern | anti-pattern | workflow | principle | decision | rule | reference
+- **Domain** — architecture, design, components, process, testing, etc.
+- **Tags** — 3-5 searchable keywords
+
+### 2. Tier Classification (MANDATORY)
+
+For EACH item, apply the three-question test:
+
+| Question                                           | If YES           |
+| -------------------------------------------------- | ---------------- |
+| Would any developer on ANY project benefit?        | **agent** tier   |
+| Would this apply to OTHER projects this team owns? | **team** tier    |
+| Is this specific to THIS codebase only?            | **project** tier |
+
+Decision tree:
+
+```
+Universal? (WCAG, UX laws, language patterns)
+  → YES → agent
+  → NO → Shared across team projects? (design system, workflow conventions)
+    → YES → team
+    → NO → project (component rules, token policies, architectural decisions)
+```
+
+**When in doubt: prefer project over agent.** Too specific is safer than too general.
+
+### 3. Duplicate Detection
+
+For each item, search the vault:
+
+```
+YOUR_AGENT_core op:search_intelligent
+  params: { query: "<item title and key terms>" }
+```
+
+Check results:
+
+- **Score > 0.5** — likely duplicate. Update the existing entry instead of creating new.
+- **Score 0.3-0.5** — possible overlap. Review existing entry: update or capture as new.
+- **Score < 0.3** — no duplicate. Proceed with capture.
+
+For batch scans: `YOUR_AGENT_core op:curator_detect_duplicates`
+
+### 4. Abstraction Level Check
+
+Validate each item is at the right level:
+
+| Too Specific (skip)                        | Just Right (capture)                                           | Too General (skip)             |
+| ------------------------------------------ | -------------------------------------------------------------- | ------------------------------ |
+| "Line 42 of FileUpload.tsx needs a Button" | "Components must use Button atom for all interactive elements" | "Use design system components" |
+| "Changed bg-red-500 to error token"        | "No raw Tailwind colors — use semantic tokens"                 | "Use semantic colors"          |
+| "Fixed timeout in GuidedCodeBlock"         | "setTimeout in useEffect must return clearTimeout cleanup"     | "Clean up side effects"        |
+
+Ask: "Would this help someone who hasn't read today's conversation?" If NO — too specific, skip it.
+
+### 5. Present Review Table
+
+Before capturing, present ALL items to the user:
+
+```
+## Capture Review
+
+| # | Title | Type | Tier | Duplicate? | Abstraction | Action |
+|---|-------|------|------|------------|-------------|--------|
+| 1 | [title] | pattern | project | No match | Good | Capture |
+| 2 | [title] | anti-pattern | agent | Similar: [id] (0.45) | Good | Update existing |
+| 3 | [title] | workflow | project | No match | Too specific | Skip |
+```
+
+**Wait for user approval.** Do NOT proceed without explicit confirmation.
+
+### 6. Execute Approved Captures
+
+For each approved item:
+
+```
+YOUR_AGENT_core op:capture_knowledge
+  params: {
+    entries: [{
+      title: "<title>",
+      description: "<description>",
+      type: "<type>",
+      domain: "<domain>",
+      severity: "<critical|warning|suggestion>",
+      tags: ["<tag1>", "<tag2>"],
+      why: "<reasoning>"
+    }]
+  }
+```
+
+For quick single captures: `YOUR_AGENT_core op:capture_quick params: { title: "<name>", description: "<details>" }`
+
+### 7. Post-Capture Quality
+
+For each captured entry:
+
+- `YOUR_AGENT_core op:curator_groom params: { entryId: "<id>" }` — normalize tags
+- `YOUR_AGENT_core op:curator_enrich params: { entryId: "<id>" }` — LLM enrichment
+- `YOUR_AGENT_core op:curator_contradictions` — check for conflicts with existing entries
+
+### 8. Verify and Fix Tiers (MANDATORY)
+
+After capture, check EVERY response. Auto-detection frequently assigns "agent" tier with LOW confidence to project-specific knowledge.
+
+```
+YOUR_AGENT_core op:vault_set_scope
+  params: { id: "<entry-id>", tier: "<correct-tier>" }
+```
+
+### 9. Governance (if enabled)
+
+If capture returns a `proposalId`, entry is queued for review:
+
+```
+YOUR_AGENT_core op:governance_proposals
+  params: { action: "list" }
+```
+
+### 10. Promote to Global (optional)
+
+For cross-project knowledge worth sharing:
+
+```
+YOUR_AGENT_core op:memory_promote_to_global
+  params: { entryId: "<id>" }
+```
+
+### 11. Report
+
+After all captures:
+
+```
+## Captured
+
+| # | Title | ID | Tier | Type | Links |
+|---|-------|----|------|------|-------|
+| 1 | [title] | [id] | project | pattern | 3 auto-linked |
+
+Skipped: [count] (too specific / duplicate)
+Updated: [count] (merged into existing)
+```
+
+Verify with `YOUR_AGENT_core op:admin_health` and `YOUR_AGENT_core op:admin_vault_analytics`.
+
+## Anti-patterns
+
+- Capturing code fixes as knowledge (that's what git is for)
+- Capturing temporary state (active plan, current task)
+- Capturing things already in CLAUDE.md (duplication)
+- Using "agent" tier for anything mentioning project-specific names
+- Batch-capturing without showing the review table first
+- Skipping tier verification after capture
+
+## Common Mistakes
+
+- Not checking for duplicates before capturing
+- Missing the `why` field (makes entries not actionable)
+- Skipping post-capture grooming (tags stay unnormalized)
+- Letting auto-detection assign wrong tier without correction
+- Capturing implementation details that belong in git, not vault
+
+## Agent Tools Reference
+
+| Op                                       | When to Use                          |
+| ---------------------------------------- | ------------------------------------ |
+| `search_intelligent`                     | Duplicate detection before capture   |
+| `curator_detect_duplicates`              | Batch duplicate scan                 |
+| `capture_knowledge`                      | Persist after approval               |
+| `capture_quick`                          | Fast capture for simple items        |
+| `curator_groom` / `curator_enrich`       | Post-capture quality                 |
+| `curator_contradictions`                 | Find conflicts with existing entries |
+| `vault_set_scope`                        | Fix tier after capture               |
+| `governance_proposals`                   | Check governance queue               |
+| `memory_promote_to_global`               | Share cross-project                  |
+| `admin_health` / `admin_vault_analytics` | Verify health after capture          |

package/{dist/skills/vault-curate → src/skills/soleri-vault-curate}/SKILL.md

@@ -1,10 +1,9 @@
 ---
-name: vault-curate
+name: soleri-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.
+  Use when the user says "clean vault", "deduplicate vault", "groom knowledge",
+  "merge patterns", or "vault maintenance". Maintains vault quality through
+  deduplication, grooming, and contradiction detection.
 ---
 
 # Vault Curate — Knowledge Maintenance
@@ -86,7 +85,15 @@ YOUR_AGENT_core op:knowledge_reorganize
 
 Preview first, then run again with `mode: "apply"` if the preview looks good.
 
-### Step 7: Verify Results
+### Step 7: Rebuild Brain Intelligence
+
+```
+YOUR_AGENT_core op:brain_build_intelligence
+```
+
+Rebuild brain intelligence after vault has been cleaned/reorganized.
+
+### Step 8: Verify Results
 
 ```
 YOUR_AGENT_core op:knowledge_health

package/{dist/skills/vault-navigator → src/skills/soleri-vault-navigator}/SKILL.md

@@ -1,10 +1,9 @@
 ---
-name: vault-navigator
+name: soleri-vault-navigator
 description: >
-  Use when the user asks "search the vault", "find patterns for", "have we seen this before",
-  "what does the vault say about", "best practice for", "check vault", "vault search", or wants
-  to query the knowledge base for existing solutions and prior art. For saving a new entry, use
-  vault-capture instead.
+  Use when the user says "search the vault", "find patterns for",
+  "have we seen this before", "vault search", or "best practice for".
+  Queries the knowledge base for existing solutions and prior art.
 ---
 
 # Vault Navigator — Knowledge Oracle
@@ -52,6 +51,15 @@ YOUR_AGENT_core op:brain_global_patterns
   params: { domain: "<domain>" }
 ```
 
+### Session Memory Search
+
+For queries about recent work or session-specific knowledge:
+
+```
+YOUR_AGENT_core op:memory_search
+  params: { query: "<session-specific query>" }
+```
+
 ### Broad exploration ("What do I know about X?")
 
 Chain: `search_intelligent` -> `vault_tags` / `vault_domains` -> `memory_cross_project_search` -> `brain_strengths`. Label each finding with its source.
@@ -80,5 +88,6 @@ If all vault strategies return nothing, search the web. If web finds something u
 | `vault_recent`                              | Recently modified entries      |
 | `vault_age_report`                          | Stale entries                  |
 | `memory_cross_project_search`               | Cross-project search           |
+| `memory_search`                             | Session and recent work search |
 | `brain_strengths` / `brain_global_patterns` | Proven patterns                |
 | `capture_quick`                             | Capture web findings           |

package/src/skills/{vault-smells → soleri-vault-smells}/SKILL.md

@@ -1,11 +1,10 @@
 ---
-name: vault-smells
+name: soleri-vault-smells
 description: >
-  Use for deep knowledge quality analysis — finding contradictions, stale patterns, orphaned entries,
-  weak links, knowledge decay, and structural issues in the vault. Triggers on "vault smells",
-  "knowledge quality", "vault analysis", "find contradictions", "stale patterns", "knowledge debt",
-  "vault deep check", "is my vault healthy". Goes deeper than health-check (which is operational).
-  For code review, use deep-review instead.
+  Use when the user says "vault quality", "vault analysis", "knowledge quality",
+  "knowledge debt", "stale patterns", or "find contradictions". Deep knowledge
+  quality analysis beyond operational health checks. For basic operational
+  health scoring and diagnostics, use health-check instead.
 ---
 
 # Vault Smells — Knowledge Quality Deep Analysis
@@ -116,7 +115,7 @@ YOUR_AGENT_core op:vault_tags
 - Near-duplicate categories (e.g., "error-handling" and "errors" and "exception-handling")
 - Categories with only 1-2 entries (too granular)
 - Tags used inconsistently (same concept, different tag names)
-- Entries miscategorized (architecture pattern filed under "testing")
+- Entries mis-categorized (architecture pattern filed under "testing")
 
 **Action:** Normalize with `op:curator_groom_all`. Merge overlapping categories.
 
@@ -198,7 +197,7 @@ For each smell category, assess severity:
 |----------|----------|-------|--------|
 | Contradictions | 🔴/🟠/🟡/🟢 | X | Inconsistent decisions |
 | Staleness | 🔴/🟠/🟡/🟢 | X | Outdated guidance |
-| Orphans | 🔴/🟠/🟡/🟢 | X | Unfindable knowledge |
+| Orphans | 🔴/🟠/🟡/🟢 | X | Un-findable knowledge |
 | Duplicates | 🔴/🟠/🟡/🟢 | X | Noise, conflicting versions |
 | Shallow entries | 🔴/🟠/🟡/🟢 | X | Low-value knowledge |
 | Category drift | 🔴/🟠/🟡/🟢 | X | Poor discoverability |

package/{dist/skills/verification-before-completion → src/skills/soleri-verification-before-completion}/SKILL.md

@@ -1,9 +1,9 @@
 ---
-name: verification-before-completion
+name: soleri-verification-before-completion
 description: >
-  Use as an internal quality gate before claiming any task is done — run tests, check output,
-  verify behavior. This is a mid-workflow checkpoint, not a shipping gate. For actual deployment
-  and release workflows, use deliver-and-ship instead.
+  Use when the user says "verify this works", "check output", "quality gate",
+  or "run tests before done". Internal quality gate before claiming any task
+  is done. For shipping, use deliver-and-ship instead.
 ---
 
 # Verification Before Completion
@@ -31,6 +31,16 @@ If you haven't run the verification command in this message, you cannot claim it
 6. ONLY THEN: Make the claim
 ```
 
+## Check Loop Status
+
+If this task is part of a tracked loop:
+
+```
+YOUR_AGENT_core op:loop_status
+```
+
+Report loop iteration status before claiming completion.
+
 ## Agent System Checks
 
 After passing verification commands:
@@ -91,6 +101,7 @@ Do NOT rationalize away failures. If a check fails, it fails. Period.
 
 | Op                      | When to Use                         |
 | ----------------------- | ----------------------------------- |
+| `loop_status`           | Check loop iteration status         |
 | `admin_health`          | Quick system health check           |
 | `admin_diagnostic`      | Comprehensive diagnostic            |
 | `admin_vault_analytics` | Knowledge quality metrics           |

package/{dist/skills/writing-plans → src/skills/soleri-writing-plans}/SKILL.md

@@ -1,9 +1,9 @@
 ---
-name: writing-plans
+name: soleri-writing-plans
 description: >
-  Use when the user has clear requirements or a spec and needs a structured implementation plan —
-  "create a plan", "break this down", "plan the implementation". Requirements are already known.
-  For open-ended exploration when requirements are unclear, use brainstorming instead.
+  Use when the user says "create a plan", "break this down", or
+  "plan the implementation". Creates structured implementation plans when
+  requirements are already known. For exploration, use brainstorming.
 ---
 
 # Writing Plans
@@ -18,6 +18,11 @@ Write implementation plans assuming the engineer has zero codebase context. Docu
 
 ### 1. Vault First
 
+```
+YOUR_AGENT_core op:memory_search
+  params: { query: "<plan topic>", crossProject: true }
+```
+
 ```
 YOUR_AGENT_core op:search_intelligent
   params: { query: "<feature being planned>" }
@@ -99,6 +104,7 @@ Offer execution choice: subagent-driven (this session) or parallel session with
 
 | Op                                 | When to Use                   |
 | ---------------------------------- | ----------------------------- |
+| `memory_search`                    | Cross-project plan precedents |
 | `search_intelligent`               | Find patterns before planning |
 | `brain_strengths`                  | Proven approaches             |
 | `create_plan`                      | Create tracked plan           |

package/src/skills/{yolo-mode → soleri-yolo-mode}/SKILL.md

@@ -1,9 +1,9 @@
 ---
-name: yolo-mode
+name: soleri-yolo-mode
 description: >
-  Use when the user says "yolo", "autonomous", "skip approvals", "full auto", "hands off",
-  or asks to execute without approval gates. Activates autonomous execution mode where the
-  agent skips plan approval gates but preserves all safety invariants.
+  Use when the user says "yolo", "autonomous", "skip approvals",
+  "full auto", or "hands off". Activates autonomous execution mode
+  that skips approval gates but preserves safety invariants.
 ---
 
 # YOLO Mode

package/src/templates/clean-worktrees.ts

@@ -47,12 +47,32 @@ for dir in "$WORKTREE_DIR"/*/; do
     fi
   fi
 
+  # Delete the local branch if it exists (worktree branches are local-only)
+  if [ -n "$branch" ] && [ "$branch" != "HEAD" ]; then
+    git branch -D "$branch" 2>/dev/null
+  fi
+
   rm -rf "$dir" 2>/dev/null && cleaned=$((cleaned + 1))
 done
 
+# Detect default branch (main, master, etc.)
+default_branch="$(git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null | sed 's@^refs/remotes/origin/@@')"
+[ -z "$default_branch" ] && default_branch="main"
+
+# Also clean up orphaned subagent/* and worktree-agent-* local branches
+# whose changes are already merged
+for branch in $(git branch --format='%(refname:short)' 2>/dev/null | grep -E '^(subagent/|worktree-agent-)'); do
+  diff="$(git diff "$default_branch"..."$branch" --stat 2>/dev/null | tail -1)"
+  if [ -z "$diff" ]; then
+    git branch -D "$branch" 2>/dev/null
+    cleaned=$((cleaned + 1))
+  fi
+done
+
 # Silent unless something was cleaned
 if [ "$cleaned" -gt 0 ]; then
   echo "Cleaned $cleaned stale worktree(s), $skipped active/protected"
 fi
+exit 0
 `;
 }

package/src/templates/package-json.ts

@@ -27,7 +27,7 @@ export function generatePackageJson(config: AgentConfig): string {
     license: 'MIT',
     engines: { node: '>=18.0.0' },
     dependencies: {
-      '@modelcontextprotocol/sdk': '^1.12.1',
+      '@modelcontextprotocol/sdk': '^1.28.0',
       '@soleri/core': '^2.0.0',
       zod: '^3.24.2',
       ...(config.telegram ? { grammy: '^1.35.0' } : {}),