@every-env/compound-plugin 0.2.0 → 0.3.0

package/.claude-plugin/marketplace.json

@@ -11,8 +11,8 @@
   "plugins": [
     {
       "name": "compound-engineering",
-      "description": "AI-powered development tools that get smarter with every use. Make each unit of engineering work easier than the last. Includes 29 specialized agents, 25 commands, and 16 skills.",
-      "version": "2.30.0",
+      "description": "AI-powered development tools that get smarter with every use. Make each unit of engineering work easier than the last. Includes 29 specialized agents, 24 commands, and 18 skills.",
+      "version": "2.31.0",
       "author": {
         "name": "Kieran Klaassen",
         "url": "https://github.com/kieranklaassen",

package/docs/plans/2026-02-08-refactor-reduce-plugin-context-token-usage-plan.md

@@ -0,0 +1,212 @@
+---
+title: Reduce compound-engineering plugin context token usage
+type: refactor
+date: 2026-02-08
+---
+
+# Reduce compound-engineering Plugin Context Token Usage
+
+## Overview
+
+The compound-engineering plugin is **overflowing the default context budget by ~3x**, causing Claude Code to silently drop components. The plugin consumes ~50,500 characters in always-loaded descriptions against a default budget of 16,000 characters (2% of context window). This means Claude literally doesn't know some agents/skills exist during sessions.
+
+## Problem Statement
+
+### How Context Loading Works
+
+Claude Code uses progressive disclosure for plugin content:
+
+| Level | What Loads | When |
+|-------|-----------|------|
+| **Always in context** | `description` frontmatter from skills, commands, and agents | Session startup (unless `disable-model-invocation: true`) |
+| **On invocation** | Full SKILL.md / command body / agent body | When triggered |
+| **On demand** | Reference files in skill directories | When Claude reads them |
+
+The total budget for ALL descriptions combined is **2% of context window** (~16,000 chars fallback). When exceeded, components are **silently excluded**.
+
+### Current State: 316% of Budget
+
+| Component | Count | Always-Loaded Chars | % of 16K Budget |
+|-----------|------:|--------------------:|----------------:|
+| Agent descriptions | 29 | ~41,400 | 259% |
+| Skill descriptions | 16 | ~5,450 | 34% |
+| Command descriptions | 24 | ~3,700 | 23% |
+| **Total** | **69** | **~50,500** | **316%** |
+
+### Root Cause: Bloated Agent Descriptions
+
+Agent `description` fields contain full `<example>` blocks with user/assistant dialog. These examples belong in the agent body (system prompt), not the description. The description's only job is **discovery** — helping Claude decide whether to delegate.
+
+Examples of the problem:
+
+- `design-iterator.md`: 2,488 chars in description (should be ~200)
+- `spec-flow-analyzer.md`: 2,289 chars in description
+- `security-sentinel.md`: 1,986 chars in description
+- `kieran-rails-reviewer.md`: 1,822 chars in description
+- Average agent description: ~1,400 chars (should be 100-250)
+
+Compare to Anthropic's official examples at 100-200 chars:
+
+```yaml
+# Official (140 chars)
+description: Expert code review specialist. Proactively reviews code for quality, security, and maintainability. Use immediately after writing or modifying code.
+
+# Current plugin (1,822 chars)
+description: "Use this agent when you need to review Rails code changes with an extremely high quality bar...\n\nExamples:\n- <example>\n  Context: The user has just implemented..."
+```
+
+### Secondary Cause: No `disable-model-invocation` on Manual Commands
+
+Zero commands set `disable-model-invocation: true`. Commands like `/deploy-docs`, `/lfg`, `/slfg`, `/triage`, `/feature-video`, `/test-browser`, `/xcode-test` are manual workflows with side effects. Their descriptions consume budget unnecessarily.
+
+The official docs explicitly state:
+> Use `disable-model-invocation: true` for workflows with side effects: `/deploy`, `/commit`, `/triage-prs`. You don't want Claude deciding to deploy because your code looks ready.
+
+---
+
+## Proposed Solution
+
+Three changes, ordered by impact:
+
+### Phase 1: Trim Agent Descriptions (saves ~35,600 chars)
+
+For all 29 agents: move `<example>` blocks from the `description` field into the agent body markdown. Keep descriptions to 1-2 sentences (100-250 chars).
+
+**Before** (agent frontmatter):
+```yaml
+---
+name: kieran-rails-reviewer
+description: "Use this agent when you need to review Rails code changes with an extremely high quality bar. This agent should be invoked after implementing features, modifying existing code, or creating new Rails components. The agent applies Kieran's strict Rails conventions and taste preferences to ensure code meets exceptional standards.\n\nExamples:\n- <example>\n  Context: The user has just implemented a new controller action with turbo streams.\n  user: \"I've added a new update action to the posts controller\"\n  ..."
+---
+
+Detailed system prompt...
+```
+
+**After** (agent frontmatter):
+```yaml
+---
+name: kieran-rails-reviewer
+description: Review Rails code with Kieran's strict conventions. Use after implementing features, modifying code, or creating new Rails components.
+---
+
+<examples>
+<example>
+Context: The user has just implemented a new controller action with turbo streams.
+user: "I've added a new update action to the posts controller"
+...
+</example>
+</examples>
+
+Detailed system prompt...
+```
+
+The examples move into the body (which only loads when the agent is actually invoked).
+
+**Impact:** ~41,400 chars → ~5,800 chars (86% reduction)
+
+### Phase 2: Add `disable-model-invocation: true` to Manual Commands (saves ~3,100 chars)
+
+Commands that should only run when explicitly invoked by the user:
+
+| Command | Reason |
+|---------|--------|
+| `/deploy-docs` | Side effect: deploys |
+| `/release-docs` | Side effect: regenerates docs |
+| `/changelog` | Side effect: generates changelog |
+| `/lfg` | Side effect: autonomous workflow |
+| `/slfg` | Side effect: swarm workflow |
+| `/triage` | Side effect: categorizes findings |
+| `/resolve_parallel` | Side effect: resolves TODOs |
+| `/resolve_todo_parallel` | Side effect: resolves todos |
+| `/resolve_pr_parallel` | Side effect: resolves PR comments |
+| `/feature-video` | Side effect: records video |
+| `/test-browser` | Side effect: runs browser tests |
+| `/xcode-test` | Side effect: builds/tests iOS |
+| `/reproduce-bug` | Side effect: runs reproduction |
+| `/report-bug` | Side effect: creates bug report |
+| `/agent-native-audit` | Side effect: runs audit |
+| `/heal-skill` | Side effect: modifies skill files |
+| `/generate_command` | Side effect: creates files |
+| `/create-agent-skill` | Side effect: creates files |
+
+Keep these **without** the flag (Claude should know about them):
+- `/workflows:plan` — Claude might suggest planning
+- `/workflows:work` — Claude might suggest starting work
+- `/workflows:review` — Claude might suggest review
+- `/workflows:brainstorm` — Claude might suggest brainstorming
+- `/workflows:compound` — Claude might suggest documenting
+- `/deepen-plan` — Claude might suggest deepening a plan
+
+**Impact:** ~3,700 chars → ~600 chars for commands in context
+
+### Phase 3: Add `disable-model-invocation: true` to Manual Skills (saves ~1,000 chars)
+
+Skills that are manual workflows:
+
+| Skill | Reason |
+|-------|--------|
+| `skill-creator` | Only invoked manually |
+| `orchestrating-swarms` | Only invoked manually |
+| `git-worktree` | Only invoked manually |
+| `resolve-pr-parallel` | Side effect |
+| `compound-docs` | Only invoked manually |
+| `file-todos` | Only invoked manually |
+
+Keep without the flag (Claude should auto-invoke):
+- `dhh-rails-style` — Claude should use when writing Rails code
+- `frontend-design` — Claude should use when building UI
+- `brainstorming` — Claude should suggest before implementation
+- `agent-browser` — Claude should use for browser tasks
+- `gemini-imagegen` — Claude should use for image generation
+- `create-agent-skills` — Claude should use when creating skills
+- `every-style-editor` — Claude should use for editing
+- `dspy-ruby` — Claude should use for DSPy.rb
+- `agent-native-architecture` — Claude should use for agent-native design
+- `andrew-kane-gem-writer` — Claude should use for gem writing
+- `rclone` — Claude should use for cloud uploads
+- `document-review` — Claude should use for doc review
+
+**Impact:** ~5,450 chars → ~4,000 chars for skills in context
+
+---
+
+## Projected Result
+
+| Component | Before (chars) | After (chars) | Reduction |
+|-----------|---------------:|-------------:|-----------:|
+| Agent descriptions | ~41,400 | ~5,800 | -86% |
+| Command descriptions | ~3,700 | ~600 | -84% |
+| Skill descriptions | ~5,450 | ~4,000 | -27% |
+| **Total** | **~50,500** | **~10,400** | **-79%** |
+| **% of 16K budget** | **316%** | **65%** | -- |
+
+From 316% of budget (components silently dropped) to 65% of budget (room for growth).
+
+---
+
+## Acceptance Criteria
+
+- [x] All 29 agent description fields are under 250 characters
+- [x] All `<example>` blocks moved from description to agent body
+- [x] 18 manual commands have `disable-model-invocation: true`
+- [x] 6 manual skills have `disable-model-invocation: true`
+- [x] Total always-loaded description content is under 16,000 characters
+- [ ] Run `/context` to verify no "excluded skills" warnings
+- [x] All agents still function correctly (examples are in body, not lost)
+- [x] All commands still invocable via `/command-name`
+- [x] Update plugin version in plugin.json and marketplace.json
+- [x] Update CHANGELOG.md
+
+## Implementation Notes
+
+- Agent examples should use `<examples><example>...</example></examples>` tags in the body — Claude understands these natively
+- Description format: "[What it does]. Use [when/trigger condition]." — two sentences max
+- The `lint` agent at 115 words shows compact agents work great
+- Test with `claude --plugin-dir ./plugins/compound-engineering` after changes
+- The `SLASH_COMMAND_TOOL_CHAR_BUDGET` env var can override the default budget for testing
+
+## References
+
+- [Skills docs](https://code.claude.com/docs/en/skills) — "Skill descriptions are loaded into context... If you have many skills, they may exceed the character budget"
+- [Subagents docs](https://code.claude.com/docs/en/sub-agents) — description field used for automatic delegation
+- [Skills troubleshooting](https://code.claude.com/docs/en/skills#claude-doesnt-see-all-my-skills) — "The budget scales dynamically at 2% of the context window, with a fallback of 16,000 characters"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@every-env/compound-plugin",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "type": "module",
   "private": false,
   "bin": {

package/plugins/compound-engineering/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "compound-engineering",
-  "version": "2.30.0",
-  "description": "AI-powered development tools. 29 agents, 25 commands, 16 skills, 1 MCP server for code review, research, design, and workflow automation.",
+  "version": "2.31.0",
+  "description": "AI-powered development tools. 29 agents, 24 commands, 18 skills, 1 MCP server for code review, research, design, and workflow automation.",
   "author": {
     "name": "Kieran Klaassen",
     "email": "kieran@every.to",

package/plugins/compound-engineering/CHANGELOG.md

@@ -5,6 +5,32 @@ All notable changes to the compound-engineering plugin will be documented in thi
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.31.0] - 2026-02-08
+
+### Added
+
+- **`document-review` skill** — Brainstorm and plan refinement through structured review ([@Trevin Chow](https://github.com/trevin))
+- **`/sync` command** — Sync Claude Code personal config across machines ([@Terry Li](https://github.com/terryli))
+
+### Changed
+
+- **Context token optimization (79% reduction)** — Plugin was consuming 316% of the context description budget, causing Claude Code to silently exclude components. Now at 65% with room to grow:
+  - All 29 agent descriptions trimmed from ~1,400 to ~180 chars avg (examples moved to agent body)
+  - 18 manual commands marked `disable-model-invocation: true` (side-effect commands like `/lfg`, `/deploy-docs`, `/triage`, etc.)
+  - 6 manual skills marked `disable-model-invocation: true` (`orchestrating-swarms`, `git-worktree`, `skill-creator`, `compound-docs`, `file-todos`, `resolve-pr-parallel`)
+- **git-worktree**: Remove confirmation prompt for worktree creation ([@Sam Xie](https://github.com/samxie))
+- **Prevent subagents from writing intermediary files** in compound workflow ([@Trevin Chow](https://github.com/trevin))
+
+### Fixed
+
+- Fix crash when hook entries have no matcher ([@Roberto Mello](https://github.com/robertomello))
+- Fix git-worktree detection where `.git` is a file, not a directory ([@David Alley](https://github.com/davidalley))
+- Backup existing config files before overwriting in sync ([@Zac Williams](https://github.com/zacwilliams))
+- Note new repository URL ([@Aarni Koskela](https://github.com/aarnikoskela))
+- Plugin component counts corrected: 29 agents, 24 commands, 18 skills
+
+---
+
 ## [2.30.0] - 2026-02-05
 
 ### Added

package/plugins/compound-engineering/agents/design/design-implementation-reviewer.md

@@ -1,9 +1,24 @@
 ---
 name: design-implementation-reviewer
-description: "Use this agent when you need to verify that a UI implementation matches its Figma design specifications. This agent should be called after code has been written to implement a design, particularly after HTML/CSS/React components have been created or modified. The agent will visually compare the live implementation against the Figma design and provide detailed feedback on discrepancies.\\n\\nExamples:\\n- <example>\\n  Context: The user has just implemented a new component based on a Figma design.\\n  user: \"I've finished implementing the hero section based on the Figma design\"\\n  assistant: \"I'll review how well your implementation matches the Figma design.\"\\n  <commentary>\\n  Since UI implementation has been completed, use the design-implementation-reviewer agent to compare the live version with Figma.\\n  </commentary>\\n  </example>\\n- <example>\\n  Context: After the general code agent has implemented design changes.\\n  user: \"Update the button styles to match the new design system\"\\n  assistant: \"I've updated the button styles. Now let me verify the implementation matches the Figma specifications.\"\\n  <commentary>\\n  After implementing design changes, proactively use the design-implementation-reviewer to ensure accuracy.\\n  </commentary>\\n  </example>"
+description: "Visually compares live UI implementation against Figma designs and provides detailed feedback on discrepancies. Use after writing or modifying HTML/CSS/React components to verify design fidelity."
 model: inherit
 ---
 
+<examples>
+<example>
+Context: The user has just implemented a new component based on a Figma design.
+user: "I've finished implementing the hero section based on the Figma design"
+assistant: "I'll review how well your implementation matches the Figma design."
+<commentary>Since UI implementation has been completed, use the design-implementation-reviewer agent to compare the live version with Figma.</commentary>
+</example>
+<example>
+Context: After the general code agent has implemented design changes.
+user: "Update the button styles to match the new design system"
+assistant: "I've updated the button styles. Now let me verify the implementation matches the Figma specifications."
+<commentary>After implementing design changes, proactively use the design-implementation-reviewer to ensure accuracy.</commentary>
+</example>
+</examples>
+
 You are an expert UI/UX implementation reviewer specializing in ensuring pixel-perfect fidelity between Figma designs and live implementations. You have deep expertise in visual design principles, CSS, responsive design, and cross-browser compatibility.
 
 Your primary responsibility is to conduct thorough visual comparisons between implemented UI and Figma designs, providing actionable feedback on discrepancies.

package/plugins/compound-engineering/agents/design/design-iterator.md

@@ -1,10 +1,37 @@
 ---
 name: design-iterator
-description: "Use this agent PROACTIVELY when design work isn't coming together on the first attempt. If you've made 1-2 design changes and the result still feels off, suggest using this agent with 5x or 10x iterations for deeper refinement. This agent takes screenshots, analyzes what's not working, implements improvements, and repeats N times to systematically fix design issues. Perfect when colors feel wrong, layouts aren't balanced, or the overall aesthetic needs work that single changes can't achieve. <example>Context: User asks to change button color but result still looks off. user: \"Change the button to blue\" assistant: [makes change, takes screenshot] \"The button is now blue, but I notice the overall color balance still feels off. Would you like me to use the design-iterator agent with 5 iterations to systematically improve the color harmony and visual balance?\" <commentary>PROACTIVE USE: After a simple change doesn't fully resolve the design issue, suggest the design-iterator to do deeper work.</commentary></example> <example>Context: User's design request leads to something that doesn't look right. user: \"Make the hero section more modern\" assistant: [makes initial changes] \"I've added some modern elements, but the result isn't quite coming together. This looks like it needs iterative refinement. Let me use the design-iterator agent with 10 iterations to systematically improve typography, spacing, colors, and visual hierarchy until it feels polished.\" <commentary>PROACTIVE USE: When initial design work produces mediocre results, automatically suggest or use the design-iterator for comprehensive improvement.</commentary></example> <example>Context: User wants explicit iterative refinement. user: \"The features section looks boring, iterate on it 10 times\" assistant: \"I'll use the design-iterator agent to systematically refine your features section through 10 iterations of visual improvements\" <commentary>User explicitly requests iteration, use design-iterator directly.</commentary></example> <example>Context: Design task requires research and multiple passes. user: \"Look at how Stripe does their pricing page and make mine better\" assistant: \"I'll launch the design-iterator agent with 8 iterations to research Stripe's design patterns and progressively apply those insights to your pricing page\" <commentary>Competitor research combined with iterative refinement benefits from the systematic approach.</commentary></example>"
+description: "Iteratively refines UI design through N screenshot-analyze-improve cycles. Use PROACTIVELY when design changes aren't coming together after 1-2 attempts, or when user requests iterative refinement."
 color: violet
 model: inherit
 ---
 
+<examples>
+<example>
+Context: User asks to change button color but result still looks off.
+user: "Change the button to blue"
+assistant: [makes change, takes screenshot] "The button is now blue, but I notice the overall color balance still feels off. Would you like me to use the design-iterator agent with 5 iterations to systematically improve the color harmony and visual balance?"
+<commentary>PROACTIVE USE: After a simple change doesn't fully resolve the design issue, suggest the design-iterator to do deeper work.</commentary>
+</example>
+<example>
+Context: User's design request leads to something that doesn't look right.
+user: "Make the hero section more modern"
+assistant: [makes initial changes] "I've added some modern elements, but the result isn't quite coming together. This looks like it needs iterative refinement. Let me use the design-iterator agent with 10 iterations to systematically improve typography, spacing, colors, and visual hierarchy until it feels polished."
+<commentary>PROACTIVE USE: When initial design work produces mediocre results, automatically suggest or use the design-iterator for comprehensive improvement.</commentary>
+</example>
+<example>
+Context: User wants explicit iterative refinement.
+user: "The features section looks boring, iterate on it 10 times"
+assistant: "I'll use the design-iterator agent to systematically refine your features section through 10 iterations of visual improvements"
+<commentary>User explicitly requests iteration, use design-iterator directly.</commentary>
+</example>
+<example>
+Context: Design task requires research and multiple passes.
+user: "Look at how Stripe does their pricing page and make mine better"
+assistant: "I'll launch the design-iterator agent with 8 iterations to research Stripe's design patterns and progressively apply those insights to your pricing page"
+<commentary>Competitor research combined with iterative refinement benefits from the systematic approach.</commentary>
+</example>
+</examples>
+
 You are an expert UI/UX design iterator specializing in systematic, progressive refinement of web components. Your methodology combines visual analysis, competitor research, and incremental improvements to transform ordinary interfaces into polished, professional designs.
 
 ## Core Methodology

package/plugins/compound-engineering/agents/design/figma-design-sync.md

@@ -1,10 +1,28 @@
 ---
 name: figma-design-sync
-description: "Use this agent when you need to synchronize a web implementation with its Figma design by automatically detecting and fixing visual differences. This agent should be used iteratively until the implementation matches the design.\\n\\n<example>\\nContext: User has just implemented a new component and wants to ensure it matches the Figma design.\\nuser: \\\"I've just finished implementing the hero section component. Can you check if it matches the Figma design at https://figma.com/file/abc123/design?node-id=45:678\\\"\\nassistant: \\\"I'll use the figma-design-sync agent to compare your implementation with the Figma design and fix any differences.\\\"\\n<uses Task tool to launch figma-design-sync agent with the Figma URL and local URL>\\n</example>\\n\\n<example>\\nContext: User is working on responsive design and wants to verify mobile breakpoint matches design.\\nuser: \\\"The mobile view doesn't look quite right. Here's the Figma: https://figma.com/file/xyz789/mobile?node-id=12:34\\\"\\nassistant: \\\"Let me use the figma-design-sync agent to identify the differences and fix them.\\\"\\n<uses Task tool to launch figma-design-sync agent>\\n</example>\\n\\n<example>\\nContext: After initial fixes, user wants to verify the implementation now matches.\\nuser: \\\"Can you check if the button component matches the design now?\\\"\\nassistant: \\\"I'll run the figma-design-sync agent again to verify the implementation matches the Figma design.\\\"\\n<uses Task tool to launch figma-design-sync agent for verification>\\n</example>\\n\\n<example>\\nContext: User mentions design inconsistencies proactively during development.\\nuser: \\\"I'm working on the navigation bar but I'm not sure if the spacing is right.\\\"\\nassistant: \\\"Let me use the figma-design-sync agent to compare your implementation with the Figma design and identify any spacing or other visual differences.\\\"\\n<uses Task tool to launch figma-design-sync agent>\\n</example>"
+description: "Detects and fixes visual differences between a web implementation and its Figma design. Use iteratively when syncing implementation to match Figma specs."
 model: inherit
 color: purple
 ---
 
+<examples>
+<example>
+Context: User has just implemented a new component and wants to ensure it matches the Figma design.
+user: "I've just finished implementing the hero section component. Can you check if it matches the Figma design at https://figma.com/file/abc123/design?node-id=45:678"
+assistant: "I'll use the figma-design-sync agent to compare your implementation with the Figma design and fix any differences."
+</example>
+<example>
+Context: User is working on responsive design and wants to verify mobile breakpoint matches design.
+user: "The mobile view doesn't look quite right. Here's the Figma: https://figma.com/file/xyz789/mobile?node-id=12:34"
+assistant: "Let me use the figma-design-sync agent to identify the differences and fix them."
+</example>
+<example>
+Context: After initial fixes, user wants to verify the implementation now matches.
+user: "Can you check if the button component matches the design now?"
+assistant: "I'll run the figma-design-sync agent again to verify the implementation matches the Figma design."
+</example>
+</examples>
+
 You are an expert design-to-code synchronization specialist with deep expertise in visual design systems, web development, CSS/Tailwind styling, and automated quality assurance. Your mission is to ensure pixel-perfect alignment between Figma designs and their web implementations through systematic comparison, detailed analysis, and precise code adjustments.
 
 ## Your Core Responsibilities

package/plugins/compound-engineering/agents/docs/ankane-readme-writer.md

@@ -1,10 +1,25 @@
 ---
 name: ankane-readme-writer
-description: "Use this agent when you need to create or update README files following the Ankane-style template for Ruby gems. This includes writing concise documentation with imperative voice, keeping sentences under 15 words, organizing sections in the standard order (Installation, Quick Start, Usage, etc.), and ensuring proper formatting with single-purpose code fences and minimal prose. Examples: <example>Context: User is creating documentation for a new Ruby gem. user: \"I need to write a README for my new search gem called 'turbo-search'\" assistant: \"I'll use the ankane-readme-writer agent to create a properly formatted README following the Ankane style guide\" <commentary>Since the user needs a README for a Ruby gem and wants to follow best practices, use the ankane-readme-writer agent to ensure it follows the Ankane template structure.</commentary></example> <example>Context: User has an existing README that needs to be reformatted. user: \"Can you update my gem's README to follow the Ankane style?\" assistant: \"Let me use the ankane-readme-writer agent to reformat your README according to the Ankane template\" <commentary>The user explicitly wants to follow Ankane style, so use the specialized agent for this formatting standard.</commentary></example>"
+description: "Creates or updates README files following Ankane-style template for Ruby gems. Use when writing gem documentation with imperative voice, concise prose, and standard section ordering."
 color: cyan
 model: inherit
 ---
 
+<examples>
+<example>
+Context: User is creating documentation for a new Ruby gem.
+user: "I need to write a README for my new search gem called 'turbo-search'"
+assistant: "I'll use the ankane-readme-writer agent to create a properly formatted README following the Ankane style guide"
+<commentary>Since the user needs a README for a Ruby gem and wants to follow best practices, use the ankane-readme-writer agent to ensure it follows the Ankane template structure.</commentary>
+</example>
+<example>
+Context: User has an existing README that needs to be reformatted.
+user: "Can you update my gem's README to follow the Ankane style?"
+assistant: "Let me use the ankane-readme-writer agent to reformat your README according to the Ankane template"
+<commentary>The user explicitly wants to follow Ankane style, so use the specialized agent for this formatting standard.</commentary>
+</example>
+</examples>
+
 You are an expert Ruby gem documentation writer specializing in the Ankane-style README format. You have deep knowledge of Ruby ecosystem conventions and excel at creating clear, concise documentation that follows Andrew Kane's proven template structure.
 
 Your core responsibilities:

package/plugins/compound-engineering/agents/research/best-practices-researcher.md

@@ -1,9 +1,24 @@
 ---
 name: best-practices-researcher
-description: "Use this agent when you need to research and gather external best practices, documentation, and examples for any technology, framework, or development practice. This includes finding official documentation, community standards, well-regarded examples from open source projects, and domain-specific conventions. The agent excels at synthesizing information from multiple sources to provide comprehensive guidance on how to implement features or solve problems according to industry standards. <example>Context: User wants to know the best way to structure GitHub issues for their Rails project. user: \"I need to create some GitHub issues for our project. Can you research best practices for writing good issues?\" assistant: \"I'll use the best-practices-researcher agent to gather comprehensive information about GitHub issue best practices, including examples from successful projects and Rails-specific conventions.\" <commentary>Since the user is asking for research on best practices, use the best-practices-researcher agent to gather external documentation and examples.</commentary></example> <example>Context: User is implementing a new authentication system and wants to follow security best practices. user: \"We're adding JWT authentication to our Rails API. What are the current best practices?\" assistant: \"Let me use the best-practices-researcher agent to research current JWT authentication best practices, security considerations, and Rails-specific implementation patterns.\" <commentary>The user needs research on best practices for a specific technology implementation, so the best-practices-researcher agent is appropriate.</commentary></example>"
+description: "Researches and synthesizes external best practices, documentation, and examples for any technology or framework. Use when you need industry standards, community conventions, or implementation guidance."
 model: inherit
 ---
 
+<examples>
+<example>
+Context: User wants to know the best way to structure GitHub issues for their Rails project.
+user: "I need to create some GitHub issues for our project. Can you research best practices for writing good issues?"
+assistant: "I'll use the best-practices-researcher agent to gather comprehensive information about GitHub issue best practices, including examples from successful projects and Rails-specific conventions."
+<commentary>Since the user is asking for research on best practices, use the best-practices-researcher agent to gather external documentation and examples.</commentary>
+</example>
+<example>
+Context: User is implementing a new authentication system and wants to follow security best practices.
+user: "We're adding JWT authentication to our Rails API. What are the current best practices?"
+assistant: "Let me use the best-practices-researcher agent to research current JWT authentication best practices, security considerations, and Rails-specific implementation patterns."
+<commentary>The user needs research on best practices for a specific technology implementation, so the best-practices-researcher agent is appropriate.</commentary>
+</example>
+</examples>
+
 **Note: The current year is 2026.** Use this when searching for recent documentation and best practices.
 
 You are an expert technology researcher specializing in discovering, analyzing, and synthesizing best practices from authoritative sources. Your mission is to provide comprehensive, actionable guidance based on current industry standards and successful real-world implementations.

package/plugins/compound-engineering/agents/research/framework-docs-researcher.md

@@ -1,9 +1,24 @@
 ---
 name: framework-docs-researcher
-description: "Use this agent when you need to gather comprehensive documentation and best practices for frameworks, libraries, or dependencies in your project. This includes fetching official documentation, exploring source code, identifying version-specific constraints, and understanding implementation patterns. <example>Context: The user needs to understand how to properly implement a new feature using a specific library. user: \"I need to implement file uploads using Active Storage\" assistant: \"I'll use the framework-docs-researcher agent to gather comprehensive documentation about Active Storage\" <commentary>Since the user needs to understand a framework/library feature, use the framework-docs-researcher agent to collect all relevant documentation and best practices.</commentary></example> <example>Context: The user is troubleshooting an issue with a gem. user: \"Why is the turbo-rails gem not working as expected?\" assistant: \"Let me use the framework-docs-researcher agent to investigate the turbo-rails documentation and source code\" <commentary>The user needs to understand library behavior, so the framework-docs-researcher agent should be used to gather documentation and explore the gem's source.</commentary></example>"
+description: "Gathers comprehensive documentation and best practices for frameworks, libraries, or dependencies. Use when you need official docs, version-specific constraints, or implementation patterns."
 model: inherit
 ---
 
+<examples>
+<example>
+Context: The user needs to understand how to properly implement a new feature using a specific library.
+user: "I need to implement file uploads using Active Storage"
+assistant: "I'll use the framework-docs-researcher agent to gather comprehensive documentation about Active Storage"
+<commentary>Since the user needs to understand a framework/library feature, use the framework-docs-researcher agent to collect all relevant documentation and best practices.</commentary>
+</example>
+<example>
+Context: The user is troubleshooting an issue with a gem.
+user: "Why is the turbo-rails gem not working as expected?"
+assistant: "Let me use the framework-docs-researcher agent to investigate the turbo-rails documentation and source code"
+<commentary>The user needs to understand library behavior, so the framework-docs-researcher agent should be used to gather documentation and explore the gem's source.</commentary>
+</example>
+</examples>
+
 **Note: The current year is 2026.** Use this when searching for recent documentation and version information.
 
 You are a meticulous Framework Documentation Researcher specializing in gathering comprehensive technical documentation and best practices for software libraries and frameworks. Your expertise lies in efficiently collecting, analyzing, and synthesizing documentation from multiple sources to provide developers with the exact information they need.

package/plugins/compound-engineering/agents/research/git-history-analyzer.md

@@ -1,9 +1,24 @@
 ---
 name: git-history-analyzer
-description: "Use this agent when you need to understand the historical context and evolution of code changes, trace the origins of specific code patterns, identify key contributors and their expertise areas, or analyze patterns in commit history. This agent excels at archaeological analysis of git repositories to provide insights about code evolution and development patterns. <example>Context: The user wants to understand the history and evolution of recently modified files.\\nuser: \"I've just refactored the authentication module. Can you analyze the historical context?\"\\nassistant: \"I'll use the git-history-analyzer agent to examine the evolution of the authentication module files.\"\\n<commentary>Since the user wants historical context about code changes, use the git-history-analyzer agent to trace file evolution, identify contributors, and extract patterns from the git history.</commentary></example> <example>Context: The user needs to understand why certain code patterns exist.\\nuser: \"Why does this payment processing code have so many try-catch blocks?\"\\nassistant: \"Let me use the git-history-analyzer agent to investigate the historical context of these error handling patterns.\"\\n<commentary>The user is asking about the reasoning behind code patterns, which requires historical analysis to understand past issues and fixes.</commentary></example>"
+description: "Performs archaeological analysis of git history to trace code evolution, identify contributors, and understand why code patterns exist. Use when you need historical context for code changes."
 model: inherit
 ---
 
+<examples>
+<example>
+Context: The user wants to understand the history and evolution of recently modified files.
+user: "I've just refactored the authentication module. Can you analyze the historical context?"
+assistant: "I'll use the git-history-analyzer agent to examine the evolution of the authentication module files."
+<commentary>Since the user wants historical context about code changes, use the git-history-analyzer agent to trace file evolution, identify contributors, and extract patterns from the git history.</commentary>
+</example>
+<example>
+Context: The user needs to understand why certain code patterns exist.
+user: "Why does this payment processing code have so many try-catch blocks?"
+assistant: "Let me use the git-history-analyzer agent to investigate the historical context of these error handling patterns."
+<commentary>The user is asking about the reasoning behind code patterns, which requires historical analysis to understand past issues and fixes.</commentary>
+</example>
+</examples>
+
 **Note: The current year is 2026.** Use this when interpreting commit dates and recent changes.
 
 You are a Git History Analyzer, an expert in archaeological analysis of code repositories. Your specialty is uncovering the hidden stories within git history, tracing code evolution, and identifying patterns that inform current development decisions.

package/plugins/compound-engineering/agents/research/learnings-researcher.md

@@ -1,9 +1,30 @@
 ---
 name: learnings-researcher
-description: "Use this agent when you need to search institutional learnings in docs/solutions/ for relevant past solutions before implementing a new feature or fixing a problem. This agent efficiently filters documented solutions by frontmatter metadata (tags, category, module, symptoms) to find applicable patterns, gotchas, and lessons learned. The agent excels at preventing repeated mistakes by surfacing relevant institutional knowledge before work begins.\\n\\n<example>Context: User is about to implement a feature involving email processing.\\nuser: \"I need to add email threading to the brief system\"\\nassistant: \"I'll use the learnings-researcher agent to check docs/solutions/ for any relevant learnings about email processing or brief system implementations.\"\\n<commentary>Since the user is implementing a feature in a documented domain, use the learnings-researcher agent to surface relevant past solutions before starting work.</commentary></example>\\n\\n<example>Context: User is debugging a performance issue.\\nuser: \"Brief generation is slow, taking over 5 seconds\"\\nassistant: \"Let me use the learnings-researcher agent to search for documented performance issues, especially any involving briefs or N+1 queries.\"\\n<commentary>The user has symptoms matching potential documented solutions, so use the learnings-researcher agent to find relevant learnings before debugging.</commentary></example>\\n\\n<example>Context: Planning a new feature that touches multiple modules.\\nuser: \"I need to add Stripe subscription handling to the payments module\"\\nassistant: \"I'll use the learnings-researcher agent to search for any documented learnings about payments, integrations, or Stripe specifically.\"\\n<commentary>Before implementing, check institutional knowledge for gotchas, patterns, and lessons learned in similar domains.</commentary></example>"
+description: "Searches docs/solutions/ for relevant past solutions by frontmatter metadata. Use before implementing features or fixing problems to surface institutional knowledge and prevent repeated mistakes."
 model: haiku
 ---
 
+<examples>
+<example>
+Context: User is about to implement a feature involving email processing.
+user: "I need to add email threading to the brief system"
+assistant: "I'll use the learnings-researcher agent to check docs/solutions/ for any relevant learnings about email processing or brief system implementations."
+<commentary>Since the user is implementing a feature in a documented domain, use the learnings-researcher agent to surface relevant past solutions before starting work.</commentary>
+</example>
+<example>
+Context: User is debugging a performance issue.
+user: "Brief generation is slow, taking over 5 seconds"
+assistant: "Let me use the learnings-researcher agent to search for documented performance issues, especially any involving briefs or N+1 queries."
+<commentary>The user has symptoms matching potential documented solutions, so use the learnings-researcher agent to find relevant learnings before debugging.</commentary>
+</example>
+<example>
+Context: Planning a new feature that touches multiple modules.
+user: "I need to add Stripe subscription handling to the payments module"
+assistant: "I'll use the learnings-researcher agent to search for any documented learnings about payments, integrations, or Stripe specifically."
+<commentary>Before implementing, check institutional knowledge for gotchas, patterns, and lessons learned in similar domains.</commentary>
+</example>
+</examples>
+
 You are an expert institutional knowledge researcher specializing in efficiently surfacing relevant documented solutions from the team's knowledge base. Your mission is to find and distill applicable learnings before new work begins, preventing repeated mistakes and leveraging proven patterns.
 
 ## Search Strategy (Grep-First Filtering)

package/plugins/compound-engineering/agents/research/repo-research-analyst.md

@@ -1,9 +1,30 @@
 ---
 name: repo-research-analyst
-description: "Use this agent when you need to conduct thorough research on a repository's structure, documentation, and patterns. This includes analyzing architecture files, examining GitHub issues for patterns, reviewing contribution guidelines, checking for templates, and searching codebases for implementation patterns. The agent excels at gathering comprehensive information about a project's conventions and best practices.\\n\\nExamples:\\n- <example>\\n  Context: User wants to understand a new repository's structure and conventions before contributing.\\n  user: \"I need to understand how this project is organized and what patterns they use\"\\n  assistant: \"I'll use the repo-research-analyst agent to conduct a thorough analysis of the repository structure and patterns.\"\\n  <commentary>\\n  Since the user needs comprehensive repository research, use the repo-research-analyst agent to examine all aspects of the project.\\n  </commentary>\\n</example>\\n- <example>\\n  Context: User is preparing to create a GitHub issue and wants to follow project conventions.\\n  user: \"Before I create this issue, can you check what format and labels this project uses?\"\\n  assistant: \"Let me use the repo-research-analyst agent to examine the repository's issue patterns and guidelines.\"\\n  <commentary>\\n  The user needs to understand issue formatting conventions, so use the repo-research-analyst agent to analyze existing issues and templates.\\n  </commentary>\\n</example>\\n- <example>\\n  Context: User is implementing a new feature and wants to follow existing patterns.\\n  user: \"I want to add a new service object - what patterns does this codebase use?\"\\n  assistant: \"I'll use the repo-research-analyst agent to search for existing implementation patterns in the codebase.\"\\n  <commentary>\\n  Since the user needs to understand implementation patterns, use the repo-research-analyst agent to search and analyze the codebase.\\n  </commentary>\\n</example>"
+description: "Conducts thorough research on repository structure, documentation, conventions, and implementation patterns. Use when onboarding to a new codebase or understanding project conventions."
 model: inherit
 ---
 
+<examples>
+<example>
+Context: User wants to understand a new repository's structure and conventions before contributing.
+user: "I need to understand how this project is organized and what patterns they use"
+assistant: "I'll use the repo-research-analyst agent to conduct a thorough analysis of the repository structure and patterns."
+<commentary>Since the user needs comprehensive repository research, use the repo-research-analyst agent to examine all aspects of the project.</commentary>
+</example>
+<example>
+Context: User is preparing to create a GitHub issue and wants to follow project conventions.
+user: "Before I create this issue, can you check what format and labels this project uses?"
+assistant: "Let me use the repo-research-analyst agent to examine the repository's issue patterns and guidelines."
+<commentary>The user needs to understand issue formatting conventions, so use the repo-research-analyst agent to analyze existing issues and templates.</commentary>
+</example>
+<example>
+Context: User is implementing a new feature and wants to follow existing patterns.
+user: "I want to add a new service object - what patterns does this codebase use?"
+assistant: "I'll use the repo-research-analyst agent to search for existing implementation patterns in the codebase."
+<commentary>Since the user needs to understand implementation patterns, use the repo-research-analyst agent to search and analyze the codebase.</commentary>
+</example>
+</examples>
+
 **Note: The current year is 2026.** Use this when searching for recent documentation and patterns.
 
 You are an expert repository research analyst specializing in understanding codebases, documentation structures, and project conventions. Your mission is to conduct thorough, systematic research to uncover patterns, guidelines, and best practices within repositories.

package/plugins/compound-engineering/agents/review/agent-native-reviewer.md

@@ -1,9 +1,24 @@
 ---
 name: agent-native-reviewer
-description: "Use this agent when reviewing code to ensure features are agent-native - that any action a user can take, an agent can also take, and anything a user can see, an agent can see. This enforces the principle that agents should have parity with users in capability and context. <example>Context: The user added a new feature to their application.\\nuser: \"I just implemented a new email filtering feature\"\\nassistant: \"I'll use the agent-native-reviewer to verify this feature is accessible to agents\"\\n<commentary>New features need agent-native review to ensure agents can also filter emails, not just humans through UI.</commentary></example><example>Context: The user created a new UI workflow.\\nuser: \"I added a multi-step wizard for creating reports\"\\nassistant: \"Let me check if this workflow is agent-native using the agent-native-reviewer\"\\n<commentary>UI workflows often miss agent accessibility - the reviewer checks for API/tool equivalents.</commentary></example>"
+description: "Reviews code to ensure agent-native parity — any action a user can take, an agent can also take. Use after adding UI features, agent tools, or system prompts."
 model: inherit
 ---
 
+<examples>
+<example>
+Context: The user added a new feature to their application.
+user: "I just implemented a new email filtering feature"
+assistant: "I'll use the agent-native-reviewer to verify this feature is accessible to agents"
+<commentary>New features need agent-native review to ensure agents can also filter emails, not just humans through UI.</commentary>
+</example>
+<example>
+Context: The user created a new UI workflow.
+user: "I added a multi-step wizard for creating reports"
+assistant: "Let me check if this workflow is agent-native using the agent-native-reviewer"
+<commentary>UI workflows often miss agent accessibility - the reviewer checks for API/tool equivalents.</commentary>
+</example>
+</examples>
+
 # Agent-Native Architecture Reviewer
 
 You are an expert reviewer specializing in agent-native application architecture. Your role is to review code, PRs, and application designs to ensure they follow agent-native principles—where agents are first-class citizens with the same capabilities as users, not bolt-on features.