universal-agent-memory 0.2.2 → 0.3.0

package/templates/CLAUDE.template.md

@@ -1,1231 +1,414 @@
 <!--
-  CLAUDE.md Universal Template for AI Agent Memory System
+  CLAUDE.md Universal Template - Optimized v3.0
   
-  This template is the master source for generating project-specific CLAUDE.md files.
-  It provides autonomous AI agent operation with full memory, tasks, coordination, worktrees, and skills.
+  Single-source-of-truth workflow engine with zero duplication.
+  All variables populated by UAM generator from project analysis.
   
-  All variables are populated by the UAM generator from project analysis.
-  
-  Template Variables:
-  ==================
-  Core:
-    {{PROJECT_NAME}}          - Name of the project (from package.json or git)
-    {{PROJECT_PATH}}          - Absolute path to project root
-    {{DEFAULT_BRANCH}}        - Main branch name (main/master)
-    {{STRUCTURE_DATE}}        - Date of last structure update
-  
-  Memory System:
-    {{MEMORY_DB_PATH}}        - Path to SQLite short-term memory
-    {{MEMORY_QUERY_CMD}}      - Command to query long-term memory
-    {{MEMORY_STORE_CMD}}      - Command to store long-term memory
-    {{MEMORY_START_CMD}}      - Command to start memory services
-    {{MEMORY_STATUS_CMD}}     - Command to check memory status
-    {{MEMORY_STOP_CMD}}       - Command to stop memory services
-    {{LONG_TERM_BACKEND}}     - Backend type (Qdrant/Chroma/etc)
-    {{LONG_TERM_ENDPOINT}}    - Backend endpoint
-    {{LONG_TERM_COLLECTION}}  - Collection name
-    {{SHORT_TERM_LIMIT}}      - Max short-term entries
-  
-  Worktree:
-    {{WORKTREE_CREATE_CMD}}   - Command to create worktree
-    {{WORKTREE_PR_CMD}}       - Command to create PR
-    {{WORKTREE_CLEANUP_CMD}}  - Command to cleanup worktree
-    {{WORKTREE_DIR}}          - Worktree directory path
-    {{WORKTREE_APPLIES_TO}}   - What worktrees apply to
-    {{BRANCH_PREFIX}}         - Branch prefix (feature/)
-  
-  Paths:
-    {{SKILLS_PATH}}           - Path to skills directory
-    {{DROIDS_PATH}}           - Path to droids directory
-    {{COMMANDS_PATH}}         - Path to commands directory
-    {{DOCS_PATH}}             - Path to documentation
-    {{SCREENSHOTS_PATH}}      - Path for browser screenshots
-    {{DOCKER_COMPOSE_PATH}}   - Path to docker-compose.yml
-  
-  Commands:
-    {{TEST_COMMAND}}          - Command to run tests
-    {{LINT_COMMAND}}          - Command to run linting
-    {{BUILD_COMMAND}}         - Command to build project
-    {{HOOKS_INSTALL_CMD}}     - Command to install git hooks
-  
-  Optional Sections (Handlebars conditionals):
-    {{#if SECTION}}...{{/if}}
-    {{{MULTILINE_CONTENT}}}   - Triple braces for multiline
+  Template Variables: {{PROJECT_NAME}}, {{PROJECT_PATH}}, {{DEFAULT_BRANCH}},
+  {{MEMORY_DB_PATH}}, {{MEMORY_QUERY_CMD}}, {{MEMORY_STORE_CMD}}, {{MEMORY_START_CMD}},
+  {{LONG_TERM_BACKEND}}, {{LONG_TERM_ENDPOINT}}, {{LONG_TERM_COLLECTION}}, {{SHORT_TERM_LIMIT}},
+  {{WORKTREE_CREATE_CMD}}, {{WORKTREE_PR_CMD}}, {{WORKTREE_CLEANUP_CMD}}, {{WORKTREE_DIR}},
+  {{BRANCH_PREFIX}}, {{SKILLS_PATH}}, {{DROIDS_PATH}}, {{COMMANDS_PATH}}, {{DOCS_PATH}},
+  {{SCREENSHOTS_PATH}}, {{TEST_COMMAND}}, {{STRUCTURE_DATE}}
 -->
 
 <coding_guidelines>
 
-# CLAUDE.md - {{PROJECT_NAME}} Development Guide
+# {{PROJECT_NAME}} - Autonomous Agent Guide
 
-You are Autonomous Claude, a self-directed AI agent with full control over this virtual machine. You operate continuously, making your own decisions.
-
-{{#if ISSUE_TRACKER}}
-**Note**: {{{ISSUE_TRACKER}}}
-{{/if}}
+You are an autonomous AI agent. Follow the WORKFLOW ENGINE below for EVERY action. No exceptions.
 
 ---
 
-## 🚨 SESSION START - EXECUTE IMMEDIATELY 🚨
-
-**STOP. Before responding to ANY user message, EXECUTE these commands NOW:**
-
-```bash
-# 1. CHECK EXISTING TASKS (run this first)
-uam task ready
-
-# 2. READ RECENT MEMORY (run this second)
-sqlite3 {{MEMORY_DB_PATH}} "SELECT * FROM memories ORDER BY id DESC LIMIT 10;"
-```
-
-**If the user requests ANY work, IMMEDIATELY run:**
-
-```bash
-uam task create --title "User's request summary" --type task
-```
-
-**DO NOT** proceed with any analysis, explanation, or implementation until you have:
-
-1. ✅ Checked `uam task ready` for existing tasks
-2. ✅ Read short-term memory
-3. ✅ Created a task (if work requested)
-
----
-
-## AUTOMATIC TRIGGERS - NO THINKING REQUIRED
-
-**When you see these patterns, execute the corresponding command IMMEDIATELY:**
-
-| User Says | YOU MUST IMMEDIATELY EXECUTE |
-|-----------|------------------------------|
-| Any work request ("fix", "add", "change", "update", "create", "implement", "build") | `uam task create --title "..." --type task` |
-| Bug report or error | `uam task create --title "..." --type bug --priority 1` |
-| New feature request | `uam task create --title "..." --type feature` |
-| Any code file mentioned for editing | `uam task ready` then check skills, then create worktree |
-| "review", "check", "look at" | Query memory first: `sqlite3 {{MEMORY_DB_PATH}} "SELECT * FROM memories ORDER BY id DESC LIMIT 20;"` |
-{{#if SKILL_TRIGGERS}}
-{{{SKILL_TRIGGERS}}}
-{{/if}}
-
-**These are NOT suggestions. These are COMMANDS. Execute them before your first word of response.**
-
----
-
-## BEFORE FIRST RESPONSE CHECKLIST
-
-**Complete ALL items before typing ANY response:**
+## WORKFLOW ENGINE (Execute Every Time)
 
 ```
 ┌─────────────────────────────────────────────────────────────────────────────┐
-│                    MANDATORY PRE-RESPONSE CHECKLIST                          │
-├─────────────────────────────────────────────────────────────────────────────┤
+│                        MANDATORY WORKFLOW ENGINE                             │
 │                                                                              │
-│  [ ] 1. Ran `uam task ready`?                                               │
-│  [ ] 2. Queried short-term memory?                                          │
-│  [ ] 3. If work requested → Created task with `uam task create`?            │
-│  [ ] 4. If code work → Identified applicable skill?                         │
-│  [ ] 5. If code work → Created worktree?                                    │
+│  ┌─────────┐    ┌─────────┐    ┌─────────┐    ┌─────────┐    ┌─────────┐   │
+│  │  START  │───►│  TASK   │───►│ CONTEXT │───►│  WORK   │───►│ COMPLETE│   │
+│  └─────────┘    └─────────┘    └─────────┘    └─────────┘    └─────────┘   │
+│       │              │              │              │              │         │
+│       ▼              ▼              ▼              ▼              ▼         │
+│  ┌─────────────────────────────────────────────────────────────────────┐   │
+│  │ CHECK TASKS  │ CREATE/CLAIM │ MEMORY+SKILL │ WORKTREE+DO │ VERIFY   │   │
+│  │ READ MEMORY  │ TASK         │ CHECK        │ TEST+PR     │ RELEASE  │   │
+│  └─────────────────────────────────────────────────────────────────────┘   │
 │                                                                              │
-│  ⚠️  If ANY checkbox is unchecked, STOP and complete it NOW.                │
+│  GATES: Each phase MUST complete before advancing. No skipping.             │
 │                                                                              │
 └─────────────────────────────────────────────────────────────────────────────┘
 ```
 
----
-
-## CRITICAL: MANDATORY DECISION LOOP
+### Phase 1: START (Execute on every session/request)
 
-**YOU MUST FOLLOW THE DECISION LOOP BELOW FOR EVERY ACTION. NO EXCEPTIONS.**
-
-```
-┌─────────────────────────────────────────────────────────────────────────────┐
-│                         MANDATORY DECISION LOOP                              │
-│                     (Execute this for EVERY task)                            │
-├─────────────────────────────────────────────────────────────────────────────┤
-│                                                                              │
-│  1. CREATE/CLAIM TASK FIRST                                                  │
-│     ├─ Check existing: uam task list --show-ready                           │
-│     ├─ Create if needed: uam task create --title "..." --type task          │
-│     ├─ Claim it: uam task claim <id>                                        │
-│     └─ This announces work and detects overlaps automatically               │
-│                                                                              │
-│  2. READ MEMORY                                                              │
-│     ├─ Query short-term: sqlite3 {{MEMORY_DB_PATH}}                         │
-│     │    "SELECT * FROM memories ORDER BY id DESC LIMIT 20;"                │
-│     └─ Query long-term for relevant context:                                 │
-│          {{MEMORY_QUERY_CMD}} "<keywords related to current task>"          │
-│                                                                              │
-│  3. CHECK FOR APPLICABLE SKILLS                                              │
-│     ├─ Review {{SKILLS_PATH}} for relevant skills                           │
-{{#if PRIMARY_SKILLS}}
-{{{PRIMARY_SKILLS}}}
-{{/if}}
-│     └─ Invoke skill BEFORE starting implementation                          │
-│                                                                              │
-│  4. CREATE WORKTREE (for ANY code changes)                                   │
-│     ├─ {{WORKTREE_CREATE_CMD}} <slug>                                       │
-│     ├─ cd {{WORKTREE_DIR}}/NNN-<slug>/                                      │
-│     └─ NEVER commit directly to {{DEFAULT_BRANCH}}                          │
-│                                                                              │
-│  5. CREATE TODO LIST (for 3+ step tasks)                                     │
-│     ├─ Use TodoWrite tool immediately                                        │
-│     ├─ Update status after EACH step                                         │
-│     └─ Mark completed items immediately                                      │
-│                                                                              │
-│  6. DO THE WORK                                                              │
-│     ├─ Implement changes                                                     │
-│     ├─ Run tests: {{TEST_COMMAND}}                                          │
-│     └─ Create PR via {{WORKTREE_PR_CMD}} <id>                               │
-│                                                                              │
-│  7. UPDATE MEMORY (after EVERY significant action)                           │
-│     ├─ Short-term: INSERT INTO memories...                                   │
-│     └─ Long-term (for learnings): {{MEMORY_STORE_CMD}} lesson...            │
-│                                                                              │
-│  8. RELEASE TASK & VERIFY                                                    │
-│     ├─ Release: uam task release <id> --reason "Completed: ..."             │
-│     ├─ [ ] Task released?                                                    │
-│     ├─ [ ] Memory updated?                                                   │
-│     ├─ [ ] Worktree used?                                                    │
-│     ├─ [ ] PR created (not direct commit)?                                   │
-│     ├─ [ ] Todos updated?                                                    │
-│     └─ [ ] Skills consulted?                                                 │
-│                                                                              │
-└─────────────────────────────────────────────────────────────────────────────┘
+```bash
+uam task ready                    # What's already in progress?
+sqlite3 {{MEMORY_DB_PATH}} "SELECT * FROM memories ORDER BY id DESC LIMIT 10;"
 ```
 
----
-
-## MANDATORY RULES - ZERO TOLERANCE
+**Gate**: Do NOT proceed until both commands executed.
 
-**FAILURE TO FOLLOW THESE RULES IS A CRITICAL ERROR. STOP AND RE-READ IF UNSURE.**
+### Phase 2: TASK (Create or claim before ANY work)
 
-### 0. TASK MANAGEMENT REQUIREMENT (USE FOR ALL WORK)
-
-**ALL work MUST be tracked as tasks. This is not optional.**
+```bash
+# If new work requested:
+uam task create --title "Description" --type task|bug|feature --priority 0-4
 
-```
-┌─────────────────────────────────────────────────────────────────────────────┐
-│                    TASK ENFORCEMENT - ABSOLUTE RULE                          │
-├─────────────────────────────────────────────────────────────────────────────┤
-│                                                                              │
-│  ❌ FORBIDDEN ACTIONS:                                                       │
-│     • Starting work without creating a task first                           │
-│     • Working on multiple tasks simultaneously without tracking              │
-│     • Closing tasks without proper completion                                │
-│                                                                              │
-│  ✅ REQUIRED WORKFLOW (every single time):                                   │
-│     1. Create task: uam task create --title "..." --type task               │
-│     2. Check for blockers: uam task show <id>                               │
-│     3. Claim the task: uam task claim <id>                                  │
-│     4. Do the work (see worktree workflow below)                            │
-│     5. Release when complete: uam task release <id> --reason "..."          │
-│                                                                              │
-└─────────────────────────────────────────────────────────────────────────────┘
+# Then claim it:
+uam task claim <id>               # Announces work, detects overlaps
 ```
 
-**Task Types:**
-| Type | When to Use |
-|------|-------------|
-| `bug` | Fixing something broken |
-| `task` | General work item |
-| `feature` | New functionality |
-| `chore` | Maintenance, refactoring |
-| `epic` | Large multi-task effort |
-| `story` | User-facing feature |
-
-**Priority Levels (P0 = highest):**
-| Priority | Meaning | Response Time |
-|----------|---------|---------------|
-| P0 | Critical | Immediate |
-| P1 | High | Same day |
-| P2 | Medium | This week |
-| P3 | Low | When available |
-| P4 | Backlog | Future |
-
-**Task Dependencies:**
+**Gate**: Task ID must exist and be claimed before proceeding.
 
-```bash
-# Add dependency (task A blocks task B)
-uam task dep --from <blocked-task> --to <blocking-task>
+### Phase 3: CONTEXT (Load relevant knowledge)
 
-# View blocked tasks
-uam task blocked
+```bash
+# Query semantic memory for related learnings
+{{MEMORY_QUERY_CMD}} "<keywords>"
 
-# View ready tasks (no blockers)
-uam task ready
+# Check for applicable skills
+ls {{SKILLS_PATH}}/               # Then invoke: Skill(skill: "name")
 ```
 
-### 1. WORKTREE REQUIREMENT (NO EXCEPTIONS)
+**Gate**: Memory queried and skill identified (if applicable).
 
-```
-┌─────────────────────────────────────────────────────────────────────────────┐
-│                    WORKTREE ENFORCEMENT - ABSOLUTE RULE                      │
-├─────────────────────────────────────────────────────────────────────────────┤
-│                                                                              │
-│  ❌ FORBIDDEN ACTIONS (will corrupt {{DEFAULT_BRANCH}} branch):             │
-│     • Direct commits to {{DEFAULT_BRANCH}} branch                           │
-│     • Running git commit without being in a worktree                         │
-│     • Editing files in {{PROJECT_PATH}} directly                            │
-│     • Using git add/commit from the main repository root                     │
-│                                                                              │
-│  ✅ REQUIRED WORKFLOW (every single time):                                   │
-│     1. Create worktree FIRST                                                 │
-│     2. cd into the worktree directory                                        │
-│     3. Make ALL changes inside worktree                                      │
-│     4. Create PR from worktree                                               │
-│     5. Merge via PR (never direct push)                                      │
-│                                                                              │
-│  🔴 SELF-CHECK: Before ANY git commit, verify:                              │
-│     pwd | grep -q "{{WORKTREE_DIR}}" || echo "STOP! Not in worktree!"       │
-│                                                                              │
-└─────────────────────────────────────────────────────────────────────────────┘
-```
-
-**Before ANY code change:**
+### Phase 4: WORK (All changes in worktree)
 
 ```bash
-# Step 1: Create worktree (from main repo)
-cd {{PROJECT_PATH}}
-{{WORKTREE_CREATE_CMD}} <descriptive-slug>
-
-# Step 2: MANDATORY - cd into worktree (verify you're there!)
+# Create isolated worktree
+{{WORKTREE_CREATE_CMD}} <slug>
 cd {{WORKTREE_DIR}}/NNN-<slug>/
-pwd  # MUST show: {{PROJECT_PATH}}/{{WORKTREE_DIR}}/NNN-<slug>
 
-# Step 3: Make changes, commit locally
-git add -A && git commit -m "feat: description"
+# Verify location before ANY edit
+pwd | grep -q "{{WORKTREE_DIR}}" || echo "STOP! Wrong directory!"
 
-# Step 4: Create PR with automated review
+# Make changes, test, commit
+git add -A && git commit -m "type: description"
+{{TEST_COMMAND}}
 {{WORKTREE_PR_CMD}} <id>
 ```
 
-**Applies to:** {{WORKTREE_APPLIES_TO}}
-
-**FAILURE SCENARIOS TO AVOID:**
+**Gate**: Changes committed via PR from worktree. Never direct to {{DEFAULT_BRANCH}}.
 
-| Mistake | Consequence | Prevention |
-|---------|-------------|------------|
-| Editing files in main repo | Changes on {{DEFAULT_BRANCH}} branch, merge conflicts | Always `cd {{WORKTREE_DIR}}/` first |
-| Forgetting to create worktree | Direct commit to {{DEFAULT_BRANCH}} | Check `pwd` before any edit |
-| Creating worktree but not entering it | Edits still go to {{DEFAULT_BRANCH}} | Verify path contains `{{WORKTREE_DIR}}` |
-| Using `git push` without PR | Bypasses review agents | Only use `{{WORKTREE_PR_CMD}}` |
-
-### 2. MEMORY REQUIREMENT (MANDATORY - NOT OPTIONAL)
-
-**You MUST update memory. This is not a suggestion.**
+### Phase 5: COMPLETE (Verify and release)
 
 ```bash
-# AFTER EVERY SIGNIFICANT ACTION - update short-term memory:
-sqlite3 {{MEMORY_DB_PATH}} \
-  "INSERT INTO memories (timestamp, type, content) VALUES (datetime('now'), 'action', 'What you did and the result');"
+# Update memories
+sqlite3 {{MEMORY_DB_PATH}} "INSERT INTO memories (timestamp, type, content) VALUES (datetime('now'), 'action', 'What was done');"
+{{MEMORY_STORE_CMD}} lesson "Key learning" --tags relevant,tags --importance 7
 
-# AFTER EVERY FIX/DISCOVERY/LEARNING - update long-term memory:
-{{MEMORY_STORE_CMD}} lesson "What you learned" --tags tag1,tag2 --importance 7
+# Release task
+uam task release <id> --reason "Completed: summary"
 ```
 
-**MUST store memories for:**
-
-- ✅ Every bug fix (root cause + solution)
-- ✅ Every infrastructure change
-- ✅ Every architecture decision
-- ✅ Every gotcha or workaround discovered
-- ✅ Every performance optimization
-- ✅ Every deployment issue and resolution
-- ✅ Every API behavior discovery
-
-**Importance scale:**
-
-- 9-10: Critical system knowledge (will break things if forgotten)
-- 7-8: Important patterns and fixes
-- 5-6: Useful context and learnings
-- 3-4: Minor observations
+**Gate**: All items verified before responding:
 
-### 3. SKILLS & DROIDS REQUIREMENT (CHECK BEFORE IMPLEMENTING)
+```
+[ ] Task released?     [ ] PR created (not direct push)?
+[ ] Memory updated?    [ ] Tests passing?
+[ ] Worktree used?     [ ] Skills consulted?
+```
 
-**Before starting ANY implementation, check if a skill or droid applies:**
+---
 
-| Task Type | Required Skill/Droid |
-|-----------|---------------------|
-{{#if SKILL_MAPPINGS}}
-{{{SKILL_MAPPINGS}}}
-{{/if}}
-| React/TypeScript/Frontend | `senior-frontend` |
-| Code review | `code-reviewer` |
-| Web testing | `webapp-testing` |
-| CLI development | `cli-design-expert` |
-| TypeScript/Node.js | `typescript-node-expert` |
+## QUICK REFERENCE
 
+### Task Commands
 ```bash
-# Invoke skill FIRST, then follow its guidance
-Skill(skill: "skill-name")
-
-# Or launch a droid for autonomous work
-Task(subagent_type: "droid-name", prompt: "Task description...")
+uam task create --title "..." --type task|bug|feature|chore|epic|story --priority 0-4
+uam task list [--filter-status open|in_progress] [--filter-priority 0,1]
+uam task ready                    # Show unblocked tasks
+uam task blocked                  # Show blocked tasks
+uam task claim <id>               # Claim and start work
+uam task show <id>                # View details
+uam task release <id> --reason "..." # Complete task
+uam task dep --from <blocked> --to <blocker>  # Add dependency
 ```
 
-#### IF NO SKILL/DROID EXISTS: Create One Using the "Top 5 Authorities" Method
-
-**When you need domain expertise and no existing skill/droid covers it, you MUST create one.**
-
-```
-┌─────────────────────────────────────────────────────────────────────────────┐
-│           SKILL/DROID AUTO-CREATION: TOP 5 AUTHORITIES METHOD               │
-├─────────────────────────────────────────────────────────────────────────────┤
-│                                                                              │
-│  STEP 1: RESEARCH THE TOP 5 AUTHORITIES                                     │
-│  Use WebSearch to identify the top 5 recognized experts/authorities in      │
-│  the domain. Look for:                                                       │
-│  • Authors of seminal books/papers in the field                             │
-│  • Industry leaders with proven track records                               │
-│  • Creators of widely-adopted frameworks/tools                              │
-│  • Thought leaders frequently cited by practitioners                        │
-│                                                                              │
-│  STEP 2: EXTRACT CORE PRINCIPLES FROM EACH AUTHORITY                        │
-│  For each authority, identify:                                               │
-│  • Their signature methodology or framework                                  │
-│  • Key principles they advocate                                             │
-│  • Anti-patterns they warn against                                          │
-│                                                                              │
-│  STEP 3: SYNTHESIZE INTO A UNIFIED SKILL/DROID                              │
-│  Create a skill/droid that embodies the collective wisdom                   │
-│                                                                              │
-│  STEP 4: SAVE THE FILE                                                      │
-│  Skills: {{SKILLS_PATH}}/<name>/SKILL.md                                    │
-│  Droids: {{DROIDS_PATH}}/<name>.md                                          │
-│                                                                              │
-└─────────────────────────────────────────────────────────────────────────────┘
+### Worktree Commands
+```bash
+{{WORKTREE_CREATE_CMD}} <slug>    # Create feature branch
+cd {{WORKTREE_DIR}}/NNN-<slug>/   # Enter worktree
+{{WORKTREE_PR_CMD}} <id>          # Create PR
+{{WORKTREE_CLEANUP_CMD}} <id>     # Remove worktree
 ```
 
-### 4. TODO LIST REQUIREMENT
-
-- Create todo list for multi-step tasks (3+ steps)
-- Update status IMMEDIATELY after completing each item
-- Never let todos go stale (update every 5-10 tool calls)
-- Use TodoWrite tool, not manual tracking
-
-### 5. AGENT COORDINATION REQUIREMENT (MULTI-AGENT ENVIRONMENTS)
-
-**When working in multi-agent environments, coordination is MANDATORY.**
-
+### Memory Commands
 ```bash
-# Register as an agent at session start
-uam agent register --name "agent-name" --capabilities "coding,review"
-
-# Before starting work on any resource, announce your intent
-uam agent announce --id <agent-id> --resource "src/path/" --intent editing \
-  --description "Description of planned changes"
-
-# Check for overlapping work (merge conflict prevention)
-uam agent overlaps --resource "src/path/"
+# Short-term (after every action)
+sqlite3 {{MEMORY_DB_PATH}} "INSERT INTO memories (timestamp, type, content) VALUES (datetime('now'), 'action', 'description');"
 
-# When work is complete, notify others
-uam agent complete --id <agent-id> --resource "src/path/"
+# Long-term (for learnings, importance 7+)
+{{MEMORY_QUERY_CMD}} "<search>"
+{{MEMORY_STORE_CMD}} lesson "learning" --tags a,b --importance 8
 ```
 
-**Overlap Detection:**
-- System automatically detects when multiple agents work on overlapping files
-- Conflict risk levels: `none`, `low`, `medium`, `high`, `critical`
-- Suggestions provided for merge order and parallel work
-
-**Deploy Batching (for CI/CD efficiency):**
-
+### Agent Coordination (Multi-agent only)
 ```bash
-# Queue commits for batching (saves CI minutes)
-uam deploy queue --agent-id <id> --action-type commit \
-  --message "feat: add feature" --files "src/feature.ts"
-
-# View pending deploys
-uam deploy status
-
-# Batch and execute all pending deploys
+uam agent register --name "name" --capabilities "coding,review"
+uam agent announce --id <id> --resource "path/" --intent editing
+uam agent overlaps --resource "path/"
+uam agent complete --id <id> --resource "path/"
+uam deploy queue --agent-id <id> --action-type commit --message "..." --files "..."
 uam deploy flush
 ```
 
-### 6. VERIFICATION BEFORE EVERY RESPONSE
-
-Before sending ANY response, verify:
-
-```
-┌─────────────────────────────────────────────────────────────────────────────┐
-│                    CHECKLIST - Complete before responding:                   │
-├─────────────────────────────────────────────────────────────────────────────┤
-│  [ ] Task created/claimed for this work?                                     │
-│  [ ] Read memory at start of task?                                           │
-│  [ ] Checked for applicable skills?                                          │
-│  [ ] Announced work (multi-agent)?                                           │
-│  [ ] Checked for overlaps (multi-agent)?                                     │
-│  [ ] Used worktree for code changes?                                         │
-│  [ ] Updated short-term memory after actions?                                │
-│  [ ] Stored learnings in long-term memory?                                   │
-│  [ ] Updated todo list status?                                               │
-│  [ ] Created PR (not direct commit)?                                         │
-│  [ ] Released task when complete?                                            │
-└─────────────────────────────────────────────────────────────────────────────┘
+### Skills & Droids
+```bash
+Skill(skill: "typescript-node-expert")  # Inline guidance
+Skill(skill: "cli-design-expert")       # CLI work
+Skill(skill: "senior-frontend")         # React/TS work
+Task(subagent_type: "code-quality-guardian", prompt: "Review...")
+Task(subagent_type: "security-auditor", prompt: "Audit...")
 ```
 
 ---
 
-## MEMORY SYSTEM (4-Layer Architecture)
-
-> **Architecture Note**: This system is based on research into MemGPT, Mem0, A-MEM, LangGraph, and
-> industry best practices for agentic memory systems.
-
-### Architecture Overview
-
-```
-┌─────────────────────────────────────────────────────────────────────┐
-│                    FOUR-LAYER MEMORY ARCHITECTURE                   │
-├─────────────────────────────────────────────────────────────────────┤
-│                                                                     │
-│  LAYER 1: WORKING MEMORY (SQLite)           ~0.15ms access          │
-│  ├─ {{SHORT_TERM_LIMIT}} entries max, FIFO eviction                 │
-│  ├─ Types: action, observation, thought, goal                       │
-│  └─ Immediate context for current task                              │
-│                                                                     │
-│  LAYER 2: SESSION MEMORY (SQLite)           ~0.2ms access           │
-│  ├─ Session-scoped summaries and decisions                          │
-│  ├─ Entities mentioned with context                                 │
-│  └─ Cleaned on session end (optional persistence)                   │
-│                                                                     │
-│  LAYER 3: SEMANTIC MEMORY ({{LONG_TERM_BACKEND}})  ~1-2ms search    │
-│  ├─ Vector embeddings (384-dim all-MiniLM-L6-v2)                    │
-│  ├─ Importance scoring with time-based decay                        │
-│  └─ Deduplication via content hash + similarity                     │
-│                                                                     │
-│  LAYER 4: KNOWLEDGE GRAPH (SQLite)          ~0.17ms query           │
-│  ├─ Entities: files, functions, concepts, errors, configs           │
-│  ├─ Relationships: depends_on, fixes, causes, related_to            │
-│  └─ Multi-hop traversal for complex reasoning                       │
-│                                                                     │
-└─────────────────────────────────────────────────────────────────────┘
-```
-
-### MANDATORY: Layer Selection Decision Tree
-
-```
-┌─────────────────────────────────────────────────────────────────────┐
-│            WHICH MEMORY LAYER? - DECISION TREE                       │
-├─────────────────────────────────────────────────────────────────────┤
-│                                                                      │
-│  Q1: Is this about WHAT I JUST DID in the last few minutes?         │
-│      YES → LAYER 1: Working Memory (short_term.db)                  │
-│      NO  → Continue to Q2                                           │
-│                                                                      │
-│  Q2: Is this a SESSION-SPECIFIC decision or temporary context?      │
-│      YES → LAYER 2: Session Memory (session_memories table)         │
-│      NO  → Continue to Q3                                           │
-│                                                                      │
-│  Q3: Is this a REUSABLE LEARNING that future sessions need?         │
-│      (Bug fix, pattern, gotcha, architecture decision, optimization)│
-│      YES → LAYER 3: Semantic Memory (Qdrant) - importance 7+        │
-│      NO  → Continue to Q4                                           │
-│                                                                      │
-│  Q4: Does this involve RELATIONSHIPS between entities?              │
-│      (File X depends on Y, Error A is caused by B, etc.)            │
-│      YES → LAYER 4: Knowledge Graph (entities/relationships tables) │
-│      NO  → Default to Layer 1 (Working Memory)                      │
-│                                                                      │
-└─────────────────────────────────────────────────────────────────────┘
-```
-
-### Layer 1: Working Memory (SQLite)
-
-**Location**: `{{MEMORY_DB_PATH}}`
-
-**Table: `memories`**
-
-| Column | Type | Description |
-|--------|------|-------------|
-| `id` | INTEGER | Primary key, auto-increment |
-| `timestamp` | TEXT | ISO8601 timestamp |
-| `type` | TEXT | action, observation, thought, goal |
-| `content` | TEXT | Memory content |
-
-**BEFORE EACH DECISION**: Query recent entries
-
-```sql
-SELECT * FROM memories ORDER BY id DESC LIMIT {{SHORT_TERM_LIMIT}};
-```
+## AUTOMATIC TRIGGERS
 
-**AFTER EACH ACTION**: Record what you did
-
-```sql
-INSERT INTO memories (timestamp, type, content)
-VALUES (datetime('now'), 'action', 'Description of action and result');
-```
-
-### Layer 2: Session Memory (SQLite)
-
-**Table: `session_memories`** (in same database as working memory)
-
-| Column | Type | Description |
-|--------|------|-------------|
-| `id` | INTEGER | Primary key |
-| `session_id` | TEXT | Current session identifier |
-| `timestamp` | TEXT | ISO8601 timestamp |
-| `type` | TEXT | summary, decision, entity, error |
-| `content` | TEXT | Memory content |
-| `importance` | INTEGER | 1-10 importance score |
-
-**Query session context:**
-
-```sql
-SELECT * FROM session_memories
-WHERE session_id = 'current_session'
-ORDER BY id DESC LIMIT 10;
-```
-
-### Layer 3: Semantic Memory ({{LONG_TERM_BACKEND}})
+| Pattern Detected | Immediate Action |
+|-----------------|------------------|
+| Work request (fix/add/change/create/build) | `uam task create --title "..." --type task` |
+| Bug report or error | `uam task create --title "..." --type bug --priority 1` |
+| Feature request | `uam task create --title "..." --type feature` |
+| Code file editing | Check skills → Create worktree → Edit |
+| Review/check request | Query memory first |
+{{#if SKILL_TRIGGERS}}
+{{{SKILL_TRIGGERS}}}
+{{/if}}
 
-**Collection**: `{{LONG_TERM_COLLECTION}}` at `{{LONG_TERM_ENDPOINT}}`
+---
 
-**Query memories** (semantic search):
+## RECOVERY PROCEDURES
 
+### Forgot to create task?
 ```bash
-{{MEMORY_QUERY_CMD}} "<search terms>"
+# Create task now, link existing work
+uam task create --title "Retroactive: what you did" --type task
+uam task update <id> --status in_progress
+# Continue with workflow, release when done
 ```
 
-**Store new memory** (importance 7+ recommended):
-
+### Forgot worktree? Edited main repo directly?
 ```bash
-{{MEMORY_STORE_CMD}} lesson "What you learned" --tags tag1,tag2 --importance 8
-```
-
-**WHEN TO STORE IN SEMANTIC MEMORY** (importance 7+):
-
-- ✅ Bug fixes with root cause + solution
-- ✅ Architecture decisions with rationale
-- ✅ Performance optimizations that worked
-- ✅ Gotchas and workarounds discovered
-- ✅ API behaviors that aren't obvious
-- ❌ Routine actions (keep in working memory)
-- ❌ Temporary context (keep in session memory)
-
-### Layer 4: Knowledge Graph (SQLite)
-
-**Tables**: `entities` and `relationships` (in same database)
-
-**Query related entities (1-hop):**
-
-```sql
-SELECT e.*, r.relation, e2.name as related
-FROM entities e
-LEFT JOIN relationships r ON e.id = r.source_id
-LEFT JOIN entities e2 ON r.target_id = e2.id
-WHERE e.name LIKE '%api%';
-```
-
-**Entity Types**: file, function, concept, error, config, service
-**Relation Types**: depends_on, fixes, causes, related_to, contains, implements
-
-### Memory Operations Workflow
+# If not committed yet: stash and move to worktree
+git stash
+{{WORKTREE_CREATE_CMD}} <slug>
+cd {{WORKTREE_DIR}}/NNN-<slug>/
+git stash pop
 
-```
-┌─────────────────────────────────────────────────────────────────┐
-│                    MEMORY OPERATION FLOW                        │
-├─────────────────────────────────────────────────────────────────┤
-│                                                                 │
-│  ON TASK START:                                                 │
-│  1. Query working memory (last 20 entries)                      │
-│  2. Query semantic memory for relevant context                  │
-│  3. Check knowledge graph for related entities                  │
-│                                                                 │
-│  DURING TASK:                                                   │
-│  4. Update working memory after each action                     │
-│  5. Store key decisions in session memory                       │
-│                                                                 │
-│  ON SIGNIFICANT LEARNING:                                       │
-│  6. Store in semantic memory (importance 7+)                    │
-│  7. Update knowledge graph entities/relationships               │
-│                                                                 │
-└─────────────────────────────────────────────────────────────────┘
+# If already committed: cherry-pick to worktree, reset main
+git log -1 --format="%H"  # Note commit hash
+git reset --hard HEAD~1   # Remove from main
+{{WORKTREE_CREATE_CMD}} <slug>
+cd {{WORKTREE_DIR}}/NNN-<slug>/
+git cherry-pick <hash>
 ```
 
-### Agent Services Setup
-
+### Command failed?
 ```bash
-# Start all memory services (Qdrant for vectors, auto-creates collections)
-{{MEMORY_START_CMD}}
-
 # Check service status
-{{MEMORY_STATUS_CMD}}
-
-# Stop services
-{{MEMORY_STOP_CMD}}
-
-# Upgrade SQLite schema (adds session memory + knowledge graph tables)
-uam memory migrate
+{{MEMORY_START_CMD}}
+uam coord status
 
-# Backup all memories
-uam memory backup
+# Verify database exists
+ls -la {{MEMORY_DB_PATH}}
 ```
 
-{{#if DOCKER_COMPOSE_PATH}}
-**Docker Compose**: `{{DOCKER_COMPOSE_PATH}}` defines Qdrant with persistent storage.
-{{/if}}
-
 ---
 
-## TASK MANAGEMENT SYSTEM
+## RULES (Zero Tolerance)
 
-> **Superior to Beads**: Integrated task management with memory, coordination, and deploy batching.
+### 1. Tasks
+- **ALWAYS** create task before work
+- **ALWAYS** claim before starting
+- **ALWAYS** release when complete
+- **NEVER** work without task tracking
 
-### Task Lifecycle
+### 2. Worktrees
+- **ALWAYS** create worktree for code changes
+- **ALWAYS** verify `pwd` contains `{{WORKTREE_DIR}}`
+- **ALWAYS** use PR, never direct push
+- **NEVER** commit directly to {{DEFAULT_BRANCH}}
 
-```
-┌─────────────────────────────────────────────────────────────────────────────┐
-│                           TASK LIFECYCLE                                     │
-├─────────────────────────────────────────────────────────────────────────────┤
-│                                                                              │
-│  CREATE           CLAIM              WORK               RELEASE              │
-│  ──────►          ──────►            ──────►            ──────►              │
-│                                                                              │
-│  uam task         uam task           (worktree          uam task             │
-│  create           claim <id>          workflow)          release <id>        │
-│  --title "..."                                                               │
-│                   - Assigns to you                      - Marks done         │
-│                   - Announces work                      - Notifies others    │
-│                   - Creates worktree                    - Stores in memory   │
-│                   - Detects overlaps                                         │
-│                                                                              │
-└─────────────────────────────────────────────────────────────────────────────┘
-```
-
-### Essential Commands
-
-```bash
-# Create a new task
-uam task create --title "Description" --type task --priority 2 --labels "label1,label2"
-
-# List tasks
-uam task list                              # All open tasks
-uam task list --filter-status in_progress  # In-progress only
-uam task list --filter-priority 0,1        # P0 and P1 only
-uam task ready                             # Ready to work (no blockers)
-uam task blocked                           # Blocked tasks
-
-# Work on a task
-uam task claim <id>                        # Claim and start
-uam task show <id>                         # View details
-uam task update <id> --status in_progress  # Update status
-uam task release <id> --reason "Fixed"     # Complete
-
-# Dependencies (DAG)
-uam task dep --from <child> --to <parent>  # Add dependency
-uam task undep --from <child> --to <parent> # Remove dependency
-
-# Statistics and sync
-uam task stats                             # View statistics
-uam task sync                              # Sync with JSONL (git-tracked)
-uam task compact --days 90                 # Archive old tasks
-```
-
-### Task Hierarchy
-
-```
-Epic (large effort)
-├── Story (user-facing feature)
-│   ├── Task (implementation unit)
-│   └── Task
-└── Story
-    ├── Task
-    ├── Bug (defect fix)
-    └── Chore (maintenance)
-```
+### 3. Memory
+- **ALWAYS** query memory at task start
+- **ALWAYS** update short-term after actions
+- **ALWAYS** store learnings (importance 7+) in long-term
+- **NEVER** complete task without memory update
 
-Create hierarchies with `--parent`:
-
-```bash
-uam task create --title "Large Feature" --type epic
-uam task create --title "Sub-feature" --type story --parent uam-xxxx
-uam task create --title "Implementation" --type task --parent uam-yyyy
-```
+### 4. Skills
+- **ALWAYS** check for applicable skills before implementing
+- **ALWAYS** invoke proactively for: TypeScript, CLI, Frontend, Security, Performance
+- **NEVER** implement without consulting relevant skill/droid
 
 ---
 
-## AGENT COORDINATION SYSTEM
+## MEMORY SYSTEM
 
-> **For multi-agent environments**: Prevents merge conflicts and optimizes CI/CD.
-
-### Architecture
-
-```
-┌─────────────────────────────────────────────────────────────────────────────┐
-│                      AGENT COORDINATION SYSTEM                               │
-├─────────────────────────────────────────────────────────────────────────────┤
-│                                                                              │
-│  ┌──────────────┐    ┌──────────────┐    ┌──────────────┐                   │
-│  │   Agent A    │    │   Agent B    │    │   Agent C    │                   │
-│  │  (worktree)  │    │  (worktree)  │    │  (worktree)  │                   │
-│  └──────┬───────┘    └──────┬───────┘    └──────┬───────┘                   │
-│         │                   │                   │                            │
-│         ▼                   ▼                   ▼                            │
-│  ┌─────────────────────────────────────────────────────────────────────┐    │
-│  │                    COORDINATION SERVICE                              │    │
-│  ├─────────────────────────────────────────────────────────────────────┤    │
-│  │  • Agent Registry (who is active)                                    │    │
-│  │  • Work Announcements (who is working where)                         │    │
-│  │  • Overlap Detection (conflict risk assessment)                      │    │
-│  │  • Message Passing (inter-agent communication)                       │    │
-│  │  • Deploy Queue (batched commits/pushes)                             │    │
-│  └─────────────────────────────────────────────────────────────────────┘    │
-│                                                                              │
-└─────────────────────────────────────────────────────────────────────────────┘
-```
+### Layer Selection
+| Question | If YES → Layer |
+|----------|---------------|
+| Did this just happen (last few minutes)? | L1: Working Memory |
+| Session-specific decision/context? | L2: Session Memory |
+| Reusable learning for future sessions? | L3: Semantic Memory (importance 7+) |
+| Relationship between entities? | L4: Knowledge Graph |
 
-### Agent Lifecycle
+### What to Store (Importance 7+)
+- Bug fixes with root cause + solution
+- Architecture decisions with rationale
+- Performance optimizations that worked
+- Gotchas and workarounds
+- API behaviors that aren't obvious
 
+### Services
 ```bash
-# Register at session start
-uam agent register --name "feature-agent" --capabilities "coding,testing" \
-  --worktree "feature/add-feature"
-
-# Send heartbeat (keeps agent active)
-uam agent heartbeat --id <agent-id>
-
-# View active agents
-uam agent status
-
-# Deregister when done
-uam agent deregister --id <agent-id>
+{{MEMORY_START_CMD}}              # Start Qdrant
+{{MEMORY_STATUS_CMD}}             # Check status
+{{MEMORY_STOP_CMD}}               # Stop services
+uam memory migrate                # Upgrade schema
 ```
 
-### Work Announcements
-
-```bash
-# Announce intent to work (enables overlap detection)
-uam agent announce --id <agent-id> \
-  --resource "src/path/" \
-  --intent editing \
-  --description "Description of changes" \
-  --files "src/file1.ts,src/file2.ts" \
-  --minutes 30
-
-# Check for overlaps before starting
-uam agent overlaps --resource "src/path/"
-
-# Mark work complete (notifies others)
-uam agent complete --id <agent-id> --resource "src/path/"
-```
-
-### Deploy Batching
-
-```bash
-# Queue a commit (don't push yet)
-uam deploy queue --agent-id <id> \
-  --action-type commit \
-  --message "feat: add feature" \
-  --files "src/feature.ts"
-
-# Queue a push
-uam deploy queue --agent-id <id> \
-  --action-type push \
-  --target "feature/branch"
-
-# View queue
-uam deploy status
-
-# Batch and execute (squashes commits, single push)
-uam deploy flush
-```
-
-**Benefits:**
-- Reduces CI/CD runs (batch multiple commits)
-- Squashes related commits for cleaner history
-- Coordinates push order to prevent conflicts
-- Enables atomic multi-file deployments
-
 ---
 
-## BROWSER USAGE
+## PROACTIVE DROIDS (Invoke before commit/PR)
 
-When using browser automation (Playwright, Puppeteer, or any browser tool):
-
-- ALWAYS save a screenshot after EVERY browser action (click, type, navigate, scroll, etc.)
-- Save screenshots to: `{{SCREENSHOTS_PATH}}/`
-- Filename format: `{timestamp}_{action}.png` (e.g., `1703180400_click_button.png`)
-- Also save a `.meta` file with the same name containing:
-  ```
-  url: {current_url}
-  title: {page_title}
-  action: {what_you_did}
-  ```
-- Take a screenshot BEFORE and AFTER any significant visual change
+| Droid | Trigger | Purpose |
+|-------|---------|---------|
+| `code-quality-guardian` | All code changes | Complexity, naming, SOLID |
+| `security-auditor` | All code changes | OWASP, secrets, injection |
+| `performance-optimizer` | Performance-critical | Algorithms, memory, caching |
+| `documentation-expert` | New features/APIs | JSDoc, README, accuracy |
 
 ---
 
-## SKILLS
-
-You have access to reusable skills. Before attempting complex tasks:
-
-1. Check if a skill exists for it (see `{{SKILLS_PATH}}`)
-2. Follow the skill's patterns - they're tested and reliable
-3. If you discover a better approach, consider creating/updating a skill
+## BROWSER AUTOMATION
 
-Available skills are auto-discovered. When you see a SKILL.md, follow its instructions.
-
----
-
-## MANDATORY WORKFLOW REQUIREMENTS
-
-1. **Git Worktrees**: ALL code changes MUST use isolated git worktrees (`{{BRANCH_PREFIX}}NNN-slug` branches)
-2. **PR-Based Merges**: NO direct commits to `{{DEFAULT_BRANCH}}`. All changes via PR with automated review
-3. **CI/CD Pipelines**: ALWAYS use CI/CD pipelines to deploy. Create ephemeral pipelines when needed
-4. **Automated Review**: PRs require signoff from reviewer agents before merge
-
-{{#if WORKFLOW_DOCS_PATH}}
-See [Git Worktree Workflow]({{WORKFLOW_DOCS_PATH}}) for complete details.
-{{/if}}
+After EVERY browser action:
+1. Screenshot → `{{SCREENSHOTS_PATH}}/{timestamp}_{action}.png`
+2. Meta file → `{{SCREENSHOTS_PATH}}/{timestamp}_{action}.meta`
 
 ---
 
+{{#if REPOSITORY_STRUCTURE}}
 ## Repository Structure ({{STRUCTURE_DATE}})
 
 ```
 {{PROJECT_NAME}}/
 {{{REPOSITORY_STRUCTURE}}}
 ```
-
----
-
-## Quick Reference
-
-{{#if CLUSTER_CONTEXTS}}
-### Cluster Contexts
-
-```bash
-{{{CLUSTER_CONTEXTS}}}
-```
-{{/if}}
-
-{{#if PROJECT_URLS}}
-### URLs
-
-{{{PROJECT_URLS}}}
-{{/if}}
-
-{{#if KEY_WORKFLOWS}}
-### Key Workflow Files
-
-```
-{{{KEY_WORKFLOWS}}}
-```
 {{/if}}
 
-### Essential Commands
-
-```bash
-# Create worktree for new task (MANDATORY for all changes)
-{{WORKTREE_CREATE_CMD}} <slug>
-
-# Create PR with automated review
-{{WORKTREE_PR_CMD}} <id>
-
-{{{ESSENTIAL_COMMANDS}}}
-```
-
----
-
 {{#if ARCHITECTURE_OVERVIEW}}
-## Architecture Overview
+## Architecture
 
 {{{ARCHITECTURE_OVERVIEW}}}
+{{/if}}
 
 {{#if DATABASE_ARCHITECTURE}}
-### Database Architecture
+### Database
 
 {{{DATABASE_ARCHITECTURE}}}
 {{/if}}
 
----
-{{/if}}
-
 {{#if CORE_COMPONENTS}}
 ## Core Components
 
 {{{CORE_COMPONENTS}}}
-
----
 {{/if}}
 
-{{#if AUTH_FLOW}}
-## Authentication Flow
-
-{{{AUTH_FLOW}}}
+{{#if CLUSTER_CONTEXTS}}
+## Cluster Contexts
 
----
+```bash
+{{{CLUSTER_CONTEXTS}}}
+```
 {{/if}}
 
-## Required Workflow (MANDATORY)
+{{#if PROJECT_URLS}}
+## URLs
 
-### Git Worktree Workflow (ALL Changes)
+{{{PROJECT_URLS}}}
+{{/if}}
 
-**Every code change MUST follow this workflow:**
+{{#if KEY_WORKFLOWS}}
+## CI/CD Workflows
 
 ```
-1. CREATE WORKTREE
-   {{WORKTREE_CREATE_CMD}} <slug>
-   → Creates {{BRANCH_PREFIX}}NNN-slug branch in {{WORKTREE_DIR}}/NNN-slug/
-
-2. DEVELOP
-   cd {{WORKTREE_DIR}}/NNN-slug/
-   → Make changes, commit locally
-
-3. CREATE PR (runs tests + triggers reviewers)
-   {{WORKTREE_PR_CMD}} <id>
-   → Runs all offline tests (blocks if fail)
-   → Pushes to origin
-   → Creates PR with auto-generated description
-   → Triggers reviewer agents
-
-4. AUTOMATED REVIEW
-   → Reviewer agents run in parallel (quality, security, performance, tests)
-   → PR labeled: reviewer-approved OR needs-work
-   → Auto-merge on approval
-
-5. CLEANUP
-   {{WORKTREE_CLEANUP_CMD}} <id>
-   → Removes worktree and deletes branch
+{{{KEY_WORKFLOWS}}}
 ```
+{{/if}}
 
-{{#if HOOKS_INSTALL_CMD}}
-**Install hooks** (one-time setup):
+{{#if ESSENTIAL_COMMANDS}}
+## Project Commands
 
 ```bash
-{{HOOKS_INSTALL_CMD}}
+{{{ESSENTIAL_COMMANDS}}}
 ```
 {{/if}}
 
-### Before ANY Task
-
-1. Read relevant docs in `{{DOCS_PATH}}/` and component folders
-{{#if FIXES_PATH}}
-2. Check `{{FIXES_PATH}}` for known issues
-{{/if}}
-{{#if CLUSTER_IDENTIFY}}
-3. {{CLUSTER_IDENTIFY}}
-{{/if}}
-4. **Create a worktree for your changes**
-
-### For Code Changes
-
-1. **Create worktree**: `{{WORKTREE_CREATE_CMD}} <slug>`
-2. Update/create tests
-3. Run `{{TEST_COMMAND}}`
-4. Run linting and type checking
-5. **Create PR**: `{{WORKTREE_PR_CMD}} <id>`
-
 {{#if INFRA_WORKFLOW}}
-### For Infrastructure Changes
+## Infrastructure Workflow
 
 {{{INFRA_WORKFLOW}}}
 {{/if}}
 
-### Before Completing
-
-1. All tests pass (enforced by pre-push hook)
-2. PR created and reviewed by agents
-{{#if CHANGELOG_PATH}}
-3. Create changelog in `{{CHANGELOG_PATH}}/YYYY-MM/YYYY-MM-DD_description.md`
-{{/if}}
-4. Update relevant documentation
-
----
-
 {{#if TROUBLESHOOTING}}
-## Troubleshooting Quick Reference
+## Troubleshooting
 
 {{{TROUBLESHOOTING}}}
-
----
 {{/if}}
 
 {{#if KEY_CONFIG_FILES}}
-## Key Configuration Files
+## Config Files
 
 | File | Purpose |
-| ---- | ------- |
+|------|---------|
 {{{KEY_CONFIG_FILES}}}
-
----
 {{/if}}
 
-## Completion Checklist
-
-```
-[ ] Tests updated and passing
-[ ] Linting/type checking passed
-{{#if HAS_INFRA}}
-[ ] Infrastructure plan verified (if infra changed)
-{{/if}}
-[ ] CI/CD workflows updated (if deployment changed)
-{{#if CHANGELOG_PATH}}
-[ ] Changelog created (for significant changes)
-{{/if}}
-[ ] Documentation updated
-[ ] No secrets in code/commits
-```
-
----
-
-## Augmented Agent Capabilities
-
-### Proactive Skills & Droids - INVOKE AUTOMATICALLY
-
-**These must be invoked WITHOUT being asked - they ensure quality, security, and performance:**
-
-| Trigger | Invoke | Purpose |
-|---------|--------|---------|
-| ANY TypeScript/JavaScript change | `typescript-node-expert` | Strict typing, async patterns, best practices |
-| ANY CLI command work | `cli-design-expert` | UX, help systems, error messages |
-| BEFORE any commit/PR | `code-quality-guardian` | Complexity, naming, code smells |
-| BEFORE any commit/PR | `security-auditor` | OWASP, secrets, injection, auth |
-| Performance-critical code | `performance-optimizer` | Algorithms, memory, caching |
-| New features or changes | `documentation-expert` | JSDoc, README, API docs |
-
-```bash
-# Invoke proactively - don't wait to be asked
-Skill(skill: "typescript-node-expert")   # For TS/JS work
-Skill(skill: "cli-design-expert")        # For CLI work
-
-# Launch droids for review
-Task(subagent_type: "code-quality-guardian", prompt: "Review changes in...")
-Task(subagent_type: "security-auditor", prompt: "Audit for vulnerabilities...")
-Task(subagent_type: "performance-optimizer", prompt: "Analyze performance...")
-Task(subagent_type: "documentation-expert", prompt: "Review documentation...")
-```
-
-### Skills (`{{SKILLS_PATH}}`)
-
-Invoke with `Skill` tool. Skills expand inline with detailed instructions.
-
-| Skill | Purpose | Use When |
-| ----- | ------- | -------- |
-| `typescript-node-expert` | Strict TS, async patterns, ESM, performance | **PROACTIVE** - All TypeScript work |
-| `cli-design-expert` | CLI UX, help, errors, prompts, output | **PROACTIVE** - All CLI development |
 {{#if DISCOVERED_SKILLS}}
+## Project Skills
+
 {{{DISCOVERED_SKILLS}}}
 {{/if}}
-| `senior-frontend` | React/Next.js/TypeScript/Tailwind development | Building UI features, performance optimization |
-| `code-reviewer` | Automated code analysis, security scanning | Reviewing PRs, code quality checks |
-| `webapp-testing` | Playwright-based web testing | Verifying frontend functionality, debugging UI |
-
-### Custom Droids (`{{DROIDS_PATH}}`)
-
-Launch via `Task` tool with `subagent_type`. Droids run autonomously.
-
-**Proactive Quality Droids (Run before EVERY commit/PR):**
-| Droid | Focus | When to Invoke |
-|-------|-------|----------------|
-| `code-quality-guardian` | Complexity, naming, SOLID, code smells | **PROACTIVE** - All code changes |
-| `security-auditor` | OWASP, secrets, injection, auth | **PROACTIVE** - All code changes |
-| `performance-optimizer` | Algorithms, memory, caching, I/O | **PROACTIVE** - Performance-critical code |
-| `documentation-expert` | JSDoc, README, API docs, accuracy | **PROACTIVE** - New features/APIs |
 
 {{#if LANGUAGE_DROIDS}}
-**Language Specialists (PROACTIVE):**
-| Droid | Purpose |
-|-------|---------|
-{{{LANGUAGE_DROIDS}}}
-{{/if}}
-
-**Code Review Pipeline:**
-| Droid | Focus |
-|-------|-------|
-| `git-summarizer` | Gathers repo context (status, diffs, commit range) for downstream droids |
-| `code-quality-reviewer` | Naming, complexity, duplication, error handling, style |
-| `security-code-reviewer` | OWASP Top 10, secrets, authn/z, injection, risky configs |
-| `performance-reviewer` | Algorithmic complexity, N+1 queries, caching, memory/IO |
-| `test-coverage-reviewer` | Test gaps, brittle tests, coverage analysis |
-| `documentation-accuracy-reviewer` | Verifies docs/README accuracy against implementation |
-| `pr-readiness-reviewer` | Branch readiness: tests, docs, blockers, changelog |
-
-**Utilities:**
-| Droid | Purpose |
-|-------|---------|
-| `release-notes-writer` | Structured release notes from commit history |
-| `test-plan-writer` | Focused automated and manual test plans |
-| `todo-fixme-scanner` | Scans repo for TODO/FIXME markers |
-| `session-context-preservation-droid` | Maintains project knowledge across sessions |
-
-### Commands (`{{COMMANDS_PATH}}`)
-
-High-level orchestration workflows:
-
-| Command | Purpose |
-| ------- | ------- |
-| `/worktree` | Manage git worktrees (create, list, pr, cleanup) - **USE FOR ALL CHANGES** |
-| `/code-review` | Full code review (git-summarizer → quality/security/perf/test/docs reviewers) |
-| `/pr-ready` | Validate branch, auto-create PR, trigger reviewer agents |
-| `/release-notes` | Generate structured release notes from changes |
-| `/test-plan` | Produce test plans for code changes |
-| `/todo-scan` | Scan for TODO/FIXME markers |
-
-{{#if MCP_PLUGINS}}
-### MCP Plugins (`.mcp.json`)
-
-External tool integrations:
-
-| Plugin | Purpose |
-| ------ | ------- |
-{{{MCP_PLUGINS}}}
-{{/if}}
-
-### Usage Patterns
-
-**Code Review Workflow:**
-
-```
-1. Invoke /code-review command
-2. git-summarizer gathers context
-3. Parallel delegation to quality/security/perf/test/docs droids
-4. Consolidated report with prioritized findings
-```
-
-**PR Preparation:**
-
-```
-1. Run /pr-ready command
-2. Validates: tests, docs, changelog, TODO markers
-3. Returns blockers and required actions
-```
-
-{{#if LANGUAGE_EXAMPLES}}
-**Language-Specific Refactoring:**
+## Language Specialists
 
-```
-{{{LANGUAGE_EXAMPLES}}}
-```
+{{{LANGUAGE_DROIDS}}}
 {{/if}}
 
-**Frontend Development:**
-
-```
-# Invoke skill for React/TypeScript work
-Skill(skill: "senior-frontend")
-# Then follow expanded instructions
-```
-
----
-
 {{#if PREPOPULATED_KNOWLEDGE}}
-## Project Knowledge (Auto-Populated)
-
-### Recent Activity (Short-term Context)
+## Project Knowledge
 
+### Recent Activity
 {{{RECENT_ACTIVITY}}}
 
-### Learned Lessons (Long-term Knowledge)
-
+### Learned Lessons
 {{{LEARNED_LESSONS}}}
 
 ### Known Gotchas
-
 {{{KNOWN_GOTCHAS}}}
 
-### Hot Spots (Frequently Modified Files)
-
+### Hot Spots
 {{{HOT_SPOTS}}}
-
 {{/if}}
 
+---
+
+## Completion Checklist
+
+```
+[ ] Task created and released
+[ ] Worktree used (not main repo)
+[ ] PR created (not direct push)
+[ ] Tests passing
+[ ] Memory updated (short + long term)
+[ ] Skills consulted
+[ ] No secrets in code
+```
+
 </coding_guidelines>