compound-agent 1.0.0 → 1.1.0

package/dist/cli.js

@@ -1530,11 +1530,11 @@ var SEVERITY_LABELS = {
   info: "INFO"
 };
 function loadRuleConfig(baseDir) {
-  const configPath = join(baseDir, ".claude", "rules.json");
-  if (!existsSync(configPath)) {
+  const configPath2 = join(baseDir, ".claude", "rules.json");
+  if (!existsSync(configPath2)) {
     return { rules: [] };
   }
-  const raw = readFileSync(configPath, "utf-8");
+  const raw = readFileSync(configPath2, "utf-8");
   const json = JSON.parse(raw);
   return RuleConfigSchema.parse(json);
 }
@@ -1838,68 +1838,15 @@ CLI commands are for manual/terminal use when MCP is unavailable:
 See [documentation](https://github.com/Nathandela/compound_agent) for more details.
 ${AGENTS_SECTION_END_MARKER}
 `;
-var SLASH_COMMANDS = {
-  "learn.md": `Capture a lesson from this session.
-
-Usage: /learn <insight>
-
-Examples:
-- /learn "Always use Polars for large CSV files"
-- /learn "API requires X-Request-ID header"
-
-\`\`\`bash
-npx ca learn "$ARGUMENTS"
-\`\`\`
-`,
-  "search.md": `Search lessons for relevant context.
-
-Usage: /search <query>
-
-Examples:
-- /search "API authentication"
-- /search "data processing patterns"
-
-\`\`\`bash
-npx ca search "$ARGUMENTS"
-\`\`\`
-
-Note: You can also use the \`memory_search\` MCP tool directly.
-`,
-  "list.md": `Show all stored lessons.
-
-\`\`\`bash
-npx ca list
-\`\`\`
-`,
-  "prime.md": `Load compound-agent workflow context after compaction or context loss.
-
-\`\`\`bash
-npx ca prime
-\`\`\`
-`,
-  "show.md": `Show details of a specific lesson.
-
-Usage: /show <lesson-id>
-
-\`\`\`bash
-npx ca show "$ARGUMENTS"
-\`\`\`
-`,
-  "wrong.md": `Mark a lesson as incorrect or invalid.
-
-Usage: /wrong <lesson-id>
-
-\`\`\`bash
-npx ca wrong "$ARGUMENTS"
-\`\`\`
-`,
-  "stats.md": `Show compound-agent database statistics and health.
-
-\`\`\`bash
-npx ca stats
-\`\`\`
-`
-};
+var LEGACY_ROOT_SLASH_COMMANDS = [
+  "learn.md",
+  "search.md",
+  "list.md",
+  "prime.md",
+  "show.md",
+  "wrong.md",
+  "stats.md"
+];
 var PLUGIN_MANIFEST = {
   name: "compound-agent",
   description: "Session memory for Claude Code - capture and retrieve lessons",
@@ -2165,6 +2112,128 @@ async function removeClaudeMdReference(repoRoot) {
   return true;
 }
 
+// src/setup/templates/agents-external.ts
+var EXTERNAL_AGENT_TEMPLATES = {
+  "external-reviewer-gemini.md": `---
+name: External Reviewer (Gemini)
+description: Cross-model review using Gemini CLI in headless mode
+model: sonnet
+---
+
+# External Reviewer \u2014 Gemini
+
+## Role
+Run a cross-model code review by invoking the Gemini CLI in headless mode. Provides an independent perspective from a different LLM to catch issues Claude may miss.
+
+## Prerequisites
+- Gemini CLI installed (\`npm i -g @google/gemini-cli\`)
+- Authenticated (\`gemini auth login\`)
+
+## Instructions
+1. **Check availability** \u2014 run \`command -v gemini\` via Bash. If not found, report "Gemini CLI not installed \u2014 skipping external review" and stop.
+2. **Gather context**:
+   - Get the beads issue being worked on: \`bd list --status=in_progress\` then \`bd show <id>\` to get the issue title and description.
+   - Get the diff: \`git diff HEAD~1\` (or the appropriate range for this session's changes).
+3. **Build the review prompt** combining beads context + diff:
+   \`\`\`
+   ISSUE: <title>
+   DESCRIPTION: <description>
+   DIFF:
+   <git diff output>
+
+   Review these changes for:
+   1. Correctness bugs and logic errors
+   2. Security vulnerabilities
+   3. Missed edge cases
+   4. Code quality issues
+   Output a numbered list of findings. Be concise and actionable. Skip praise.
+   \`\`\`
+4. **Call Gemini headless**:
+   \`\`\`bash
+   echo "<prompt>" | gemini -p "Review the following code changes" --output-format json
+   \`\`\`
+5. **Parse the response** \u2014 extract the \`.response\` field from the JSON output.
+6. **Present findings** to the user as a numbered list with severity tags (P1/P2/P3).
+7. **If Gemini returns an error** (auth failure, rate limit, timeout), report the error and skip gracefully. Never block the pipeline on external reviewer failure.
+
+## Output Format
+\`\`\`
+## Gemini External Review
+
+**Status**: Completed | Skipped (reason)
+**Findings**: N items
+
+1. [P2] <finding description> \u2014 <file:line>
+2. [P3] <finding description> \u2014 <file:line>
+...
+\`\`\`
+
+## Important
+- This is **advisory, not blocking**. Findings inform but do not gate the pipeline.
+- Do NOT retry more than once on failure.
+- Do NOT feed the entire codebase \u2014 only the diff and issue context.
+`,
+  "external-reviewer-codex.md": `---
+name: External Reviewer (Codex)
+description: Cross-model review using OpenAI Codex CLI in headless mode
+model: sonnet
+---
+
+# External Reviewer \u2014 Codex
+
+## Role
+Run a cross-model code review by invoking the OpenAI Codex CLI in headless exec mode. Provides an independent perspective from OpenAI's reasoning models to catch issues Claude may miss.
+
+## Prerequisites
+- Codex CLI installed (\`npm i -g @openai/codex\`)
+- Authenticated (\`codex login --api-key\`)
+
+## Instructions
+1. **Check availability** \u2014 run \`command -v codex\` via Bash. If not found, report "Codex CLI not installed \u2014 skipping external review" and stop.
+2. **Gather context**:
+   - Get the beads issue being worked on: \`bd list --status=in_progress\` then \`bd show <id>\` to get the issue title and description.
+   - Get the diff: \`git diff HEAD~1\` (or the appropriate range for this session's changes).
+3. **Build the review prompt** combining beads context + diff:
+   \`\`\`
+   ISSUE: <title>
+   DESCRIPTION: <description>
+   DIFF:
+   <git diff output>
+
+   Review these changes for:
+   1. Correctness bugs and logic errors
+   2. Security vulnerabilities
+   3. Missed edge cases
+   4. Code quality issues
+   Output a numbered list of findings. Be concise and actionable. Skip praise.
+   \`\`\`
+4. **Call Codex headless**:
+   \`\`\`bash
+   echo "<prompt>" | codex exec --quiet "Review the following code changes for bugs, security issues, and missed edge cases"
+   \`\`\`
+5. **Parse the response** \u2014 Codex exec prints the final answer to stdout.
+6. **Present findings** to the user as a numbered list with severity tags (P1/P2/P3).
+7. **If Codex returns an error** (auth failure, rate limit, timeout), report the error and skip gracefully. Never block the pipeline on external reviewer failure.
+
+## Output Format
+\`\`\`
+## Codex External Review
+
+**Status**: Completed | Skipped (reason)
+**Findings**: N items
+
+1. [P2] <finding description> \u2014 <file:line>
+2. [P3] <finding description> \u2014 <file:line>
+...
+\`\`\`
+
+## Important
+- This is **advisory, not blocking**. Findings inform but do not gate the pipeline.
+- Do NOT retry more than once on failure.
+- Do NOT feed the entire codebase \u2014 only the diff and issue context.
+`
+};
+
 // src/setup/templates/agents-phase11.ts
 var PHASE11_AGENT_TEMPLATES = {
   "compounding.md": `---
@@ -2806,7 +2875,8 @@ Call \`memory_search\` with the task description for known patterns, solutions,
 var AGENT_TEMPLATES = {
   ...REVIEW_AGENT_TEMPLATES,
   ...WORKFLOW_AGENT_TEMPLATES,
-  ...PHASE11_AGENT_TEMPLATES
+  ...PHASE11_AGENT_TEMPLATES,
+  ...EXTERNAL_AGENT_TEMPLATES
 };
 
 // src/setup/templates/commands.ts
@@ -2821,9 +2891,15 @@ Explore requirements through collaborative dialogue before committing to a plan.
 ## Workflow
 1. Parse the topic from \`$ARGUMENTS\`. If empty, ask the user what to brainstorm.
 2. Call \`memory_search\` with the topic to surface relevant past lessons. Display retrieved items and incorporate them into exploration.
-3. Spawn Explore subagents to research existing context:
-   - **docs-explorer**: scan \`docs/\` for architecture docs, specs, research, standards, anti-patterns, and existing ADRs in \`docs/decisions/\`
-   - **code-explorer**: quick codebase research on areas relevant to the brainstorm
+3. Create a research team and spawn explorers in parallel:
+   \`\`\`
+   TeamCreate: team_name="brainstorm-<topic-slug>"
+   Task: name="docs-explorer", subagent_type="Explore", team_name="brainstorm-<topic-slug>"
+     prompt: "Scan docs/ for architecture docs, specs, research, standards, anti-patterns, and existing ADRs in docs/decisions/"
+   Task: name="code-explorer", subagent_type="Explore", team_name="brainstorm-<topic-slug>"
+     prompt: "Research codebase areas relevant to: <topic>"
+   \`\`\`
+   Wait for both teammates to report findings, then synthesize.
 4. Use \`AskUserQuestion\` to clarify scope, constraints, and preferences through structured dialogue.
 5. Explore edge cases and failure modes.
 6. Propose 2-3 alternative approaches with tradeoffs.
@@ -2876,10 +2952,17 @@ Create a structured implementation plan enriched by semantic memory and existing
 1. Parse the goal from \`$ARGUMENTS\`. If empty, ask the user what to plan.
 2. Check for brainstorm output: run \`bd list\` to find a related brainstorm epic. If one exists, read its description for decisions and open questions.
 3. Call \`memory_search\` with the goal to retrieve relevant past lessons. Display retrieved memory items and incorporate them into planning context.
-4. Spawn research agent team:
-   - **Docs Analyst** (\`docs-analyst\`): scan \`docs/\` for specs, standards, anti-patterns, and ADRs in \`docs/decisions/\` that constrain the plan
-   - **Repo Analyst** (\`repo-analyst\`): explore codebase patterns, conventions, and architecture
-   - **Memory Analyst** (\`memory-analyst\`): deep dive into related memory items with multiple search queries
+4. Create a research team and spawn analysts in parallel:
+   \`\`\`
+   TeamCreate: team_name="plan-<goal-slug>"
+   Task: name="docs-analyst", subagent_type="Explore", team_name="plan-<goal-slug>"
+     prompt: "Scan docs/ for specs, standards, anti-patterns, and ADRs in docs/decisions/ that constrain the plan for: <goal>"
+   Task: name="repo-analyst", subagent_type="Explore", team_name="plan-<goal-slug>"
+     prompt: "Explore codebase patterns, conventions, and architecture relevant to: <goal>"
+   Task: name="memory-analyst", subagent_type="general-purpose", team_name="plan-<goal-slug>"
+     prompt: "Deep dive into related memory items with multiple memory_search queries for: <goal>"
+   \`\`\`
+   Wait for all teammates to report findings, then synthesize.
 5. Synthesize research findings from all agents into a coherent plan. Flag any conflicts between ADRs and proposed approach.
 6. Use \`AskUserQuestion\` to resolve ambiguities: unclear requirements, conflicting ADRs, or priority trade-offs that need user input before decomposing.
 7. Break the goal into concrete, ordered tasks with clear acceptance criteria.
@@ -2918,21 +3001,30 @@ Execute implementation by delegating to an agent team. The lead coordinates and
 2. Mark task in progress: \`bd update <id> --status=in_progress\`.
 3. Call \`memory_search\` with the task description to retrieve relevant lessons. Run \`memory_search\` per agent/subtask so each gets targeted context.
 4. Assess complexity to determine team strategy.
-5. For non-trivial tasks, spawn a **test-analyst** agent before any code is written. The test-analyst:
-   - Analyzes the task requirements and acceptance criteria
-   - Identifies happy paths, edge cases, failure modes, boundary conditions, and invariants
-   - Produces a structured **test plan** (not code) listing concrete test cases to cover
-   - The test-writer then implements this plan as actual test code
-6. Execute based on assessed complexity:
-   - If **trivial** (config changes, typos, one-line fixes): handle directly with a single agent. No TDD pair needed. Proceed to verification and close.
-   - If **simple** (well-scoped feature or bug fix): sequential TDD \u2014 **test-analyst** produces test plan, then **test-writer** implements failing tests, then **implementer** makes them pass.
-   - If **complex** (cross-cutting or ambiguous scope): iterative TDD \u2014 **test-analyst** produces test plan, then **test-writer** and **implementer** alternate in ping-pong cycles until done.
-7. When agents work on overlapping areas, they communicate directly to coordinate and avoid conflicts.
-8. Lead coordinates the cycle: review agent outputs, resolve conflicts, verify tests pass. Do not write code directly.
-9. If blocked by ambiguity or conflicting agent outputs, use \`AskUserQuestion\` to get user direction before proceeding.
-10. Commit incrementally as tests pass \u2014 do not batch all commits to the end.
-11. Run the full test suite to check for regressions.
-12. Close the task: \`bd close <id>\`.
+5. If **trivial** (config changes, typos, one-line fixes): handle directly with a single subagent. No AgentTeam needed. Proceed to step 10.
+6. If **simple** or **complex**, create an AgentTeam:
+   \`\`\`
+   TeamCreate: team_name="work-<task-id>"
+   \`\`\`
+7. Spawn **test-analyst** as the first teammate (produces a test plan, not code):
+   \`\`\`
+   Task: name="test-analyst", subagent_type="general-purpose", team_name="work-<task-id>"
+     prompt: "Analyze requirements for <task>. Identify happy paths, edge cases, failure modes, boundary conditions, invariants. Output a structured test plan."
+   \`\`\`
+   Wait for test-analyst to report the test plan via SendMessage.
+8. If **simple**: spawn test-writer, wait for tests, then spawn implementer:
+   \`\`\`
+   Task: name="test-writer", subagent_type="general-purpose", team_name="work-<task-id>"
+   Task: name="implementer", subagent_type="general-purpose", team_name="work-<task-id>"
+   \`\`\`
+   If **complex**: spawn both as teammates, coordinate via SendMessage for ping-pong cycles.
+9. When agents work on overlapping areas, they communicate directly via SendMessage to coordinate and avoid conflicts.
+10. Lead coordinates: review agent outputs, resolve conflicts, verify tests pass. Do not write code directly.
+11. If blocked by ambiguity or conflicting agent outputs, use \`AskUserQuestion\` to get user direction.
+12. Shut down the team when done: send \`shutdown_request\` to all teammates.
+13. Commit incrementally as tests pass \u2014 do not batch all commits to the end.
+14. Run the full test suite to check for regressions.
+15. Close the task: \`bd close <id>\`.
 
 ## Verification Gate
 Before marking work complete, run the 8-step TDD verification pipeline:
@@ -2956,49 +3048,48 @@ Before marking work complete, run the 8-step TDD verification pipeline:
 Multi-agent code review with severity classification and a mandatory \`/implementation-reviewer\` gate.
 
 ## Workflow
-1. Run quality gates first: \`pnpm test && pnpm lint\` to catch easy failures before the full review.
-2. Identify what to review from \`$ARGUMENTS\` or recent changes (\`git diff\`).
-3. Call \`memory_search\` with the changed areas to surface relevant past lessons.
-4. Spawn the reviewer agent team in parallel \u2014 one agent per perspective:
-   - **security-reviewer**: injection risks, auth issues, data exposure
-   - **architecture-reviewer**: module boundaries, coupling, cohesion, API design
-   - **performance-reviewer**: unnecessary allocations, N+1 queries, blocking calls
-   - **test-coverage-reviewer**: missing edge cases, cargo-cult tests, mocked business logic
-   - **simplicity-reviewer**: over-engineering, dead code, unnecessary abstractions
-   - **docs-reviewer**: documentation alignment, ADR compliance, undocumented public APIs
-   - **consistency-reviewer**: naming conventions, code patterns, style consistency with existing codebase
-   - **error-handling-reviewer**: error messages quality, resilience, logging, observability
-   - **edge-case-reviewer**: boundary conditions, off-by-one, nil/undefined, empty inputs, type coercion traps
-   - **pattern-matcher**: search \`memory_search\` for recurring issues \u2014 if a finding matches a known pattern, auto-reinforce its severity via \`memory_capture\`
-   - **cct-reviewer**: check code against CCT patterns in \`.claude/lessons/cct-patterns.jsonl\` for known Claude mistakes from past sessions
-5. Reviewers communicate findings with each other via direct messages so cross-cutting issues (e.g., a security fix that impacts performance) are identified early.
-6. Collect all findings and classify by severity:
-   - **P1** (critical): security vulnerabilities, data loss, correctness bugs \u2014 P1 findings block completion
-   - **P2** (important): architectural violations, significant performance issues
-   - **P3** (minor): style nits, small improvements, non-urgent suggestions
-7. Synthesize and prioritize findings \u2014 deduplicate overlapping reports, consolidate related items, and rank by severity before creating issues.
-8. Use \`AskUserQuestion\` when severity classification is ambiguous (e.g., a finding could be P1 or P2) or when the fix approach has multiple valid options.
-9. For P1 and P2 findings, create beads issues:
-   \`\`\`bash
-   bd create --title="P1: <finding>" --type=bug --priority=1
+1. Run quality gates first: \`pnpm test && pnpm lint\`.
+2. Identify scope from \`$ARGUMENTS\` or \`git diff\`. Count changed lines.
+3. Call \`memory_search\` with changed areas to surface past lessons.
+4. **Select reviewer tier based on diff size:**
+   - **Small** (<100 lines): 4 core reviewers \u2014 security, test-coverage, simplicity, cct-reviewer.
+   - **Medium** (100-500 lines): add architecture, performance, edge-case (7 total).
+   - **Large** (500+ lines): full team \u2014 all 11 reviewers including docs, consistency, error-handling, pattern-matcher.
+5. Create team and spawn selected reviewers in parallel:
    \`\`\`
-10. Submit to **\`/implementation-reviewer\`** as the mandatory gate \u2014 it has final authority on whether the review passes. All P1 findings must be resolved before approval.
-11. Output a review summary with pass/fail per perspective and severity breakdown.
+   TeamCreate: team_name="review-<scope-slug>"
+   Task: name="security-reviewer", prompt: "Review for injection, auth, data exposure"
+   Task: name="test-coverage-reviewer", prompt: "Review for missing edge cases, cargo-cult tests"
+   Task: name="simplicity-reviewer", prompt: "Review for over-engineering, dead code"
+   Task: name="cct-reviewer", prompt: "Check against CCT patterns in .claude/lessons/"
+   (medium+) Task: name="architecture-reviewer", prompt: "Review module boundaries, coupling"
+   (medium+) Task: name="performance-reviewer", prompt: "Review allocations, N+1, blocking calls"
+   (medium+) Task: name="edge-case-reviewer", prompt: "Check boundary conditions, off-by-one"
+   (large)   Task: name="docs-reviewer", prompt: "Check doc alignment, ADR compliance"
+   (large)   Task: name="consistency-reviewer", prompt: "Check naming, patterns, style"
+   (large)   Task: name="error-handling-reviewer", prompt: "Review error messages, resilience"
+   (large)   Task: name="pattern-matcher", prompt: "Match findings to memory, reinforce via memory_capture"
+   \`\`\`
+6. Reviewers communicate cross-cutting findings via SendMessage.
+7. Classify findings: **P1** (security, data loss, correctness \u2014 blocks completion), **P2** (architecture, performance), **P3** (style, minor).
+8. Deduplicate and prioritize. Use \`AskUserQuestion\` for ambiguous severity.
+9. For P1/P2 findings: \`bd create --title="P1: <finding>" --type=bug --priority=1\`
+10. Submit to **\`/implementation-reviewer\`** \u2014 mandatory gate, final authority. All P1s must be resolved.
+11. **External reviewers (optional)**: Check \`.claude/compound-agent.json\` for \`"externalReviewers"\`. Spawn configured reviewers. Advisory only, never blocks.
+12. Output review summary with severity breakdown and external findings (if any).
 
 ## Memory Integration
-- Call \`memory_search\` at the start for known issues in the changed areas.
-- **pattern-matcher** auto-reinforces: when a review finding matches an existing memory item, call \`memory_capture\` to increase its severity (recurring issues become higher priority).
-- **cct-reviewer** reads \`.claude/lessons/cct-patterns.jsonl\` for known Claude failure patterns.
-- After the review, call \`memory_capture\` with \`type=solution\` to store the review report for future sessions.
+- Call \`memory_search\` at the start for known issues in changed areas.
+- **pattern-matcher** auto-reinforces recurring findings via \`memory_capture\`.
+- **cct-reviewer** reads \`.claude/lessons/cct-patterns.jsonl\` for known Claude mistakes.
+- After review, call \`memory_capture\` with \`type=solution\` to store the review report.
 
 ## Docs Integration
-- **docs-reviewer** checks that code changes align with \`docs/\` content and existing ADRs.
-- Flags if a public API was added without documentation.
-- Flags if code contradicts an existing ADR in \`docs/decisions/\`.
+- **docs-reviewer** checks code changes align with \`docs/\` and existing ADRs.
+- Flags undocumented public APIs and ADR contradictions.
 
 ## Beads Integration
 - Create \`bd\` issues for P1 and P2 findings with \`bd create\`.
-- Reference the reviewed code in issue descriptions.
 - Close related issues with \`bd close\` when findings are resolved.
 `,
   "compound.md": `$ARGUMENTS
@@ -3011,14 +3102,23 @@ Multi-agent analysis to capture high-quality lessons from completed work into th
 ## Workflow
 1. Parse what was done from \`$ARGUMENTS\` or recent git history (\`git diff\`, \`git log\`).
 2. Call \`memory_search\` with the topic to check what is already known (avoid duplicates).
-3. Spawn the compound analysis team in parallel:
-   - **context-analyzer**: summarize what happened (git diff, test results, plan context)
-   - **lesson-extractor**: identify mistakes, corrections, and discoveries
-   - **docs-reviewer**: scan \`docs/\` for docs that need updating based on what changed, and check if any ADR in \`docs/decisions/\` should be deprecated or superseded
-   - **pattern-matcher**: match against existing memory, classify New/Duplicate/Reinforcement/Contradiction
-   - **solution-writer**: formulate structured items typed as lesson, solution, pattern, or preference
-   - **compounding**: synthesize accumulated lessons into CCT patterns for test reuse
-4. Agents pass results to each other via direct messages so downstream agents build on upstream findings.
+3. Create a compound team and spawn the 6 analysis agents in parallel:
+   \`\`\`
+   TeamCreate: team_name="compound-<topic-slug>"
+   Task: name="context-analyzer", subagent_type="general-purpose", team_name="compound-<topic>"
+     prompt: "Summarize what happened: git diff, test results, plan context for: <topic>"
+   Task: name="lesson-extractor", subagent_type="general-purpose", team_name="compound-<topic>"
+     prompt: "Identify mistakes, corrections, and discoveries from: <topic>"
+   Task: name="docs-reviewer", subagent_type="Explore", team_name="compound-<topic>"
+     prompt: "Scan docs/ for content that needs updating. Check if any ADR in docs/decisions/ should be deprecated."
+   Task: name="pattern-matcher", subagent_type="general-purpose", team_name="compound-<topic>"
+     prompt: "Match findings against existing memory via memory_search. Classify: New/Duplicate/Reinforcement/Contradiction."
+   Task: name="solution-writer", subagent_type="general-purpose", team_name="compound-<topic>"
+     prompt: "Formulate structured memory items typed as lesson, solution, pattern, or preference."
+   Task: name="compounding", subagent_type="general-purpose", team_name="compound-<topic>"
+     prompt: "Synthesize accumulated lessons into CCT patterns for test reuse."
+   \`\`\`
+4. Agents pass results to each other via SendMessage so downstream agents build on upstream findings. The lead coordinates the pipeline: context-analyzer and lesson-extractor feed pattern-matcher and solution-writer, which feed compounding.
 5. Apply quality filter on each candidate item:
    - **Novel**: skip if >0.85 similarity to existing memory
    - **Specific**: reject vague or generic advice
@@ -3057,38 +3157,43 @@ Chain all phases: brainstorm, plan, work, review, compound. End-to-end delivery.
 ## Workflow
 1. **Brainstorm phase**: Explore the goal from \`$ARGUMENTS\`.
    - Call \`memory_search\` with the goal.
-   - Spawn docs-explorer to scan \`docs/\` for relevant context and existing ADRs.
+   - \`TeamCreate\` team "brainstorm-<slug>", spawn docs-explorer + code-explorer as parallel teammates.
    - Ask clarifying questions via \`AskUserQuestion\`, explore alternatives.
    - Auto-create ADRs for significant decisions in \`docs/decisions/\`.
    - Create a beads epic from conclusions with \`bd create --type=feature\`.
+   - Shut down brainstorm team before next phase.
 
 2. **Plan phase**: Structure the work.
    - Check for brainstorm epic via \`bd list\`.
-   - Spawn docs-analyst to check specs, standards, and ADRs that constrain the plan.
+   - \`TeamCreate\` team "plan-<slug>", spawn docs-analyst + repo-analyst + memory-analyst as parallel teammates.
    - Break into tasks with dependencies and acceptance criteria.
    - Create beads issues with \`bd create\` and map dependencies with \`bd dep add\`.
+   - Shut down plan team before next phase.
 
 3. **Work phase**: Implement with adaptive TDD.
-   - Assess complexity (trivial/simple/complex) to choose team strategy.
-   - For non-trivial tasks: test-analyst produces test plan, then test-writer and implementer execute.
+   - Assess complexity (trivial/simple/complex) to choose strategy.
+   - Trivial: single subagent, no team. Simple/complex: \`TeamCreate\` team "work-<task-id>".
+   - Spawn test-analyst first, then test-writer + implementer as teammates.
    - Call \`memory_search\` per subtask; \`memory_capture\` after corrections.
    - Commit incrementally. Close tasks as they complete.
-   - Run verification gate before marking complete.
+   - Run verification gate before marking complete. Shut down work team.
 
 4. **Review phase**: 11-agent review with severity classification.
    - Run quality gates first: \`pnpm test && pnpm lint\`.
-   - Core (security, architecture, performance, test-coverage, simplicity), quality (docs, consistency, error-handling), intelligence (edge-case, pattern-matcher, cct-reviewer).
+   - \`TeamCreate\` team "review-<slug>", spawn all 11 reviewers as parallel teammates.
    - Classify findings as P1 (critical/blocking), P2 (important), P3 (minor).
    - P1 findings must be fixed before proceeding \u2014 they block completion.
-   - Submit to \`/implementation-reviewer\` as the mandatory gate before moving on.
-   - Create beads issues for P1/P2 findings.
+   - Submit to \`/implementation-reviewer\` as the mandatory gate. Shut down review team.
 
 5. **Compound phase**: Capture learnings.
-   - Spawn 6-agent analysis team: context-analyzer, lesson-extractor, docs-reviewer, pattern-matcher, solution-writer, compounding.
+   - \`TeamCreate\` team "compound-<slug>", spawn 6 analysis agents as parallel teammates.
    - Search first with \`memory_search\` to avoid duplicates. Apply quality filters (novelty + specificity).
    - Store novel insights via \`memory_capture\` with supersedes/related links.
    - Update outdated docs and deprecate superseded ADRs.
-   - Use \`AskUserQuestion\` to confirm high-severity items before storing.
+   - Use \`AskUserQuestion\` to confirm high-severity items. Shut down compound team.
+
+## Agent Team Pattern
+Each phase creates its own AgentTeam via \`TeamCreate\`, spawns teammates via \`Task\` tool with \`team_name\`, coordinates via \`SendMessage\`, and shuts down with \`shutdown_request\` before the next phase starts. Use subagents (Task without team_name) only for quick lookups like \`memory_search\` or \`bd\` commands.
 
 ## Phase Control
 - **Skip phases**: Parse \`$ARGUMENTS\` for "from <phase>" (e.g., "from plan"). Skip all phases before the named one.
@@ -3104,6 +3209,69 @@ Chain all phases: brainstorm, plan, work, review, compound. End-to-end delivery.
 ## Memory Integration
 - \`memory_search\` is called in brainstorm, work, and compound phases.
 - \`memory_capture\` is called in work and compound phases.
+`,
+  // =========================================================================
+  // Utility commands (CLI wrappers)
+  // =========================================================================
+  "learn.md": `Capture a lesson from this session.
+
+Usage: /compound learn <insight>
+
+Examples:
+- /compound learn "Always use Polars for large CSV files"
+- /compound learn "API requires X-Request-ID header"
+
+\`\`\`bash
+npx ca learn "$ARGUMENTS"
+\`\`\`
+`,
+  "search.md": `Search lessons for relevant context.
+
+Usage: /compound search <query>
+
+Examples:
+- /compound search "API authentication"
+- /compound search "data processing patterns"
+
+\`\`\`bash
+npx ca search "$ARGUMENTS"
+\`\`\`
+
+Note: You can also use the \`memory_search\` MCP tool directly.
+`,
+  "list.md": `Show all stored lessons.
+
+\`\`\`bash
+npx ca list
+\`\`\`
+`,
+  "prime.md": `Load compound-agent workflow context after compaction or context loss.
+
+\`\`\`bash
+npx ca prime
+\`\`\`
+`,
+  "show.md": `Show details of a specific lesson.
+
+Usage: /compound show <lesson-id>
+
+\`\`\`bash
+npx ca show "$ARGUMENTS"
+\`\`\`
+`,
+  "wrong.md": `Mark a lesson as incorrect or invalid.
+
+Usage: /compound wrong <lesson-id>
+
+\`\`\`bash
+npx ca wrong "$ARGUMENTS"
+\`\`\`
+`,
+  "stats.md": `Show compound-agent database statistics and health.
+
+\`\`\`bash
+npx ca stats
+\`\`\`
 `
 };
 
@@ -3122,7 +3290,7 @@ Explore the problem space before committing to a solution. This phase produces a
 ## Methodology
 1. Ask "why" before "how" -- understand the real problem
 2. Search memory with \`memory_search\` for similar past features and known constraints
-3. Spawn Explore subagents: docs-explorer for \`docs/\` (architecture, specs, research, standards, existing ADRs) and code-explorer for relevant codebase areas
+3. Create an AgentTeam (\`TeamCreate\`) and spawn docs-explorer + code-explorer as parallel teammates via \`Task\` tool with \`team_name\`. Use subagents only for quick single lookups.
 4. Use \`AskUserQuestion\` to clarify scope, constraints, and preferences
 5. Divergent phase: generate multiple approaches without filtering
 6. Identify constraints and non-functional requirements (performance, security, etc.)
@@ -3136,7 +3304,7 @@ Explore the problem space before committing to a solution. This phase produces a
 - If the problem domain matches past work, review those lessons first
 
 ## Docs Integration
-- Spawn docs-explorer to scan \`docs/\` for relevant architecture docs, research, and standards
+- Spawn docs-explorer as an AgentTeam teammate (not a subagent) to scan \`docs/\` for relevant architecture docs, research, and standards
 - Review existing ADRs in \`docs/decisions/\` -- prior decisions may constrain the brainstorm
 - Auto-create ADR for each significant decision made during convergence
 
@@ -3173,7 +3341,7 @@ Create a concrete implementation plan by decomposing work into small, testable t
 ## Methodology
 1. Review brainstorm output for decisions and open questions
 2. Search memory with \`memory_search\` for architectural patterns and past mistakes
-3. Spawn research agent team: docs-analyst for \`docs/\` (specs, standards, ADRs), repo-analyst for codebase, memory-analyst for deep memory search
+3. Create an AgentTeam (\`TeamCreate\`) and spawn docs-analyst, repo-analyst, and memory-analyst as parallel teammates via \`Task\` tool with \`team_name\`
 4. Synthesize research findings into a coherent approach. Flag conflicts between ADRs and proposed plan.
 5. Use \`AskUserQuestion\` to resolve ambiguities, conflicting constraints, or priority trade-offs before decomposing
 6. Decompose into tasks small enough to verify individually
@@ -3187,7 +3355,7 @@ Create a concrete implementation plan by decomposing work into small, testable t
 - Check for preferred architectural patterns in this codebase
 
 ## Docs Integration
-- Spawn docs-analyst to scan \`docs/\` for relevant specs, standards, and research
+- Spawn docs-analyst as an AgentTeam teammate to scan \`docs/\` for relevant specs, standards, and research
 - Check \`docs/decisions/\` for existing ADRs that constrain or inform the plan
 - If the plan contradicts an ADR, flag it for the user before proceeding
 
@@ -3232,24 +3400,12 @@ Execute implementation through an agent team using adaptive TDD. The lead coordi
 8. Commit incrementally as tests pass \u2014 do not batch all commits to the end
 9. Capture lessons with \`memory_capture\` after corrections or discoveries
 
-## Team Structure
-Adaptive TDD model based on task complexity:
-- **Trivial**: Single agent handles the change directly, no TDD ceremony
-- **Simple**: test-analyst \u2192 test-writer \u2192 implementer (sequential)
-- **Complex**: test-analyst \u2192 test-writer/implementer ping-pong (iterative)
-
-## Complexity Assessment
-- **Trivial**: Config changes, typos, renaming, one-line fixes. No new behavior.
-- **Simple**: Well-scoped feature or bug fix. Clear inputs/outputs. One module affected.
-- **Complex**: Cross-module changes, architectural decisions, ambiguous requirements.
-
-## Agent Delegation
-The lead coordinates but does not write code:
-- Spawn **test-analyst** first for non-trivial tasks -- it produces the test plan that test-writer implements
-- Spawn agents with task context, relevant memory items, and the test plan
-- Review agent outputs for correctness and consistency
-- Resolve conflicts between test expectations and implementation
-- Use \`AskUserQuestion\` when blocked by ambiguity or conflicting agent outputs -- get user direction before proceeding
+## Team Structure & Delegation
+The lead coordinates but does not write code. Use AgentTeam (\`TeamCreate\`) for non-trivial work, plain subagent for trivial fixes:
+- **Trivial**: Single subagent, no team. Config changes, typos, one-line fixes.
+- **Simple**: \`TeamCreate\` \u2192 test-analyst \u2192 test-writer \u2192 implementer (sequential teammates)
+- **Complex**: \`TeamCreate\` \u2192 test-analyst \u2192 test-writer/implementer ping-pong (iterative teammates)
+Spawn teammates via \`Task\` with \`team_name\`, coordinate via \`SendMessage\`, shut down with \`shutdown_request\` when done.
 
 ## Memory Integration
 - Call \`memory_search\` per delegated subtask with the subtask's specific description
@@ -3296,11 +3452,11 @@ Perform thorough code review by spawning specialized reviewers in parallel, cons
 ## Methodology
 1. Run quality gates first: \`pnpm test && pnpm lint\`
 2. Search memory with \`memory_search\` for known patterns and recurring issues
-3. Spawn 11 specialized reviewer agents in parallel:
+3. Create an AgentTeam (\`TeamCreate\`) and spawn all 11 reviewers as parallel teammates via \`Task\` tool with \`team_name\`:
    - **Core**: security, architecture, performance, test-coverage, simplicity
    - **Quality**: docs-reviewer, consistency-reviewer, error-handling-reviewer
    - **Intelligence**: edge-case-reviewer, pattern-matcher (memory-backed), cct-reviewer (CCT patterns)
-4. Reviewers communicate findings to each other via direct messages
+4. Reviewers communicate findings to each other via \`SendMessage\`
 5. Collect, consolidate, and deduplicate all findings
 6. Classify by severity: P1 (critical/blocking), P2 (important), P3 (minor)
 7. Use \`AskUserQuestion\` when severity is ambiguous or fix has multiple valid options
@@ -3350,14 +3506,14 @@ Extract and store lessons learned during the cycle, and update project documenta
 
 ## Methodology
 1. Review what happened during this cycle (git diff, test results, plan context)
-2. Spawn the compound analysis team in parallel:
+2. Create an AgentTeam (\`TeamCreate\`) and spawn the 6 analysis agents as parallel teammates via \`Task\` tool with \`team_name\`:
    - context-analyzer: gathers cycle context (diffs, test output)
    - lesson-extractor: identifies corrections, surprises, discoveries
    - docs-reviewer: scans \`docs/\` for outdated content and ADRs that need updating
    - pattern-matcher: checks \`memory_search\` for duplicates and related items
    - solution-writer: drafts final memory items
    - compounding: synthesizes accumulated lessons into CCT patterns
-3. Agents pass results through the pipeline and share findings with each other
+3. Agents pass results through the pipeline via \`SendMessage\`. The lead coordinates: context-analyzer and lesson-extractor feed pattern-matcher and solution-writer, which feed compounding.
 4. Apply quality filters: novelty check (>0.85 similarity = skip), specificity check
 5. Classify each item by type: lesson, solution, pattern, or preference
 6. Classify severity: high (data loss/security/contradictions), medium (workflow/patterns), low (style/optimizations)
@@ -3367,7 +3523,7 @@ Extract and store lessons learned during the cycle, and update project documenta
 10. Use \`AskUserQuestion\` to confirm high-severity items with the user before storing; medium/low items are auto-stored
 
 ## Docs Integration
-- Spawn docs-reviewer to check if \`docs/\` content is outdated after the cycle
+- docs-reviewer runs as an AgentTeam teammate to check if \`docs/\` content is outdated after the cycle
 - Check \`docs/decisions/\` for ADRs contradicted by the work done
 - Set ADR status to \`deprecated\` if a decision was reversed, referencing the new ADR
 
@@ -3442,19 +3598,6 @@ async function createPluginManifest(repoRoot) {
   await writeFile(pluginPath, JSON.stringify(PLUGIN_MANIFEST, null, 2) + "\n", "utf-8");
   return true;
 }
-async function createSlashCommands(repoRoot) {
-  const commandsDir = join(repoRoot, ".claude", "commands");
-  await mkdir(commandsDir, { recursive: true });
-  let created = false;
-  for (const [filename, content] of Object.entries(SLASH_COMMANDS)) {
-    const filePath = join(commandsDir, filename);
-    if (!existsSync(filePath)) {
-      await writeFile(filePath, content, "utf-8");
-      created = true;
-    }
-  }
-  return created;
-}
 async function installAgentTemplates(repoRoot) {
   const agentsDir = join(repoRoot, ".claude", "agents", "compound");
   await mkdir(agentsDir, { recursive: true });
@@ -3529,7 +3672,6 @@ async function runSetup(options) {
   const agentsMdUpdated = await updateAgentsMd(repoRoot);
   await ensureClaudeMdReference(repoRoot);
   await createPluginManifest(repoRoot);
-  await createSlashCommands(repoRoot);
   await installAgentTemplates(repoRoot);
   await installWorkflowCommands(repoRoot);
   await installPhaseSkills(repoRoot);
@@ -3569,11 +3711,14 @@ async function runUninstall(repoRoot, dryRun) {
       actions.push(`Removed ${dir}`);
     }
   }
-  for (const filename of Object.keys(SLASH_COMMANDS)) {
+  for (const filename of LEGACY_ROOT_SLASH_COMMANDS) {
     const filePath = join(repoRoot, ".claude", "commands", filename);
     if (existsSync(filePath)) {
-      if (!dryRun) await rm(filePath);
-      actions.push(`Removed ${filePath}`);
+      const content = await readFile(filePath, "utf-8");
+      if (content.startsWith(GENERATED_MARKER)) {
+        if (!dryRun) await rm(filePath);
+        actions.push(`Removed ${filePath}`);
+      }
     }
   }
   const pluginPath = join(repoRoot, ".claude", "plugin.json");
@@ -3656,6 +3801,15 @@ async function runUpdate(repoRoot, dryRun) {
   for (const [phase, content] of Object.entries(PHASE_SKILLS)) {
     await processFile(join(repoRoot, ".claude", "skills", "compound", phase, "SKILL.md"), content);
   }
+  for (const filename of LEGACY_ROOT_SLASH_COMMANDS) {
+    const filePath = join(repoRoot, ".claude", "commands", filename);
+    if (existsSync(filePath)) {
+      const content = await readFile(filePath, "utf-8");
+      if (content.startsWith(GENERATED_MARKER)) {
+        if (!dryRun) await rm(filePath);
+      }
+    }
+  }
   return { updated, added, skipped };
 }
 async function runStatus(repoRoot) {
@@ -4084,9 +4238,9 @@ async function getGitHooksDir(repoRoot) {
   if (!existsSync(gitDir)) {
     return null;
   }
-  const configPath = join(gitDir, "config");
-  if (existsSync(configPath)) {
-    const config = await readFile(configPath, "utf-8");
+  const configPath2 = join(gitDir, "config");
+  if (existsSync(configPath2)) {
+    const config = await readFile(configPath2, "utf-8");
     const match = /hooksPath\s*=\s*(.+)$/m.exec(config);
     if (match?.[1]) {
       const hooksPath = match[1].trim();
@@ -4248,10 +4402,6 @@ async function initAction(cmd, options) {
   if (!options.skipAgents) {
     await ensureClaudeMdReference(repoRoot);
   }
-  let slashCommandsCreated = false;
-  if (!options.skipAgents) {
-    slashCommandsCreated = await createSlashCommands(repoRoot);
-  }
   if (!options.skipAgents) {
     await createPluginManifest(repoRoot);
     await installAgentTemplates(repoRoot);
@@ -4273,7 +4423,6 @@ async function initAction(cmd, options) {
       initialized: true,
       lessonsDir,
       agentsMd: agentsMdUpdated,
-      slashCommands: slashCommandsCreated || !options.skipAgents,
       hooks: hooksChanged,
       hookStatus: hookResult?.status ?? "skipped",
       claudeHooks: claudeHooksInstalled
@@ -4284,7 +4433,6 @@ async function initAction(cmd, options) {
   out.success("Compound agent initialized");
   console.log(`  Lessons directory: ${lessonsDir}`);
   printAgentsMdStatus(agentsMdUpdated, options.skipAgents);
-  printSlashCommandsStatus(slashCommandsCreated, options.skipAgents);
   printHookStatus(hookResult, options.skipHooks);
   printClaudeHooksStatus(claudeHooksResult, options.skipClaude);
 }
@@ -4297,15 +4445,6 @@ function printAgentsMdStatus(updated, skipped) {
     console.log("  AGENTS.md: Already has Compound Agent section");
   }
 }
-function printSlashCommandsStatus(created, skipped) {
-  if (created) {
-    console.log("  Slash commands: Created (/learn, /show, /wrong, /stats)");
-  } else if (skipped) {
-    console.log("  Slash commands: Skipped (--skip-agents)");
-  } else {
-    console.log("  Slash commands: Already exist");
-  }
-}
 function printHookStatus(hookResult, skipped) {
   if (skipped) {
     console.log("  Git hooks: Skipped (--skip-hooks)");
@@ -4547,6 +4686,63 @@ function registerCrudCommands(program2) {
     await deleteAction(ids, options);
   });
 }
+async function runDoctor(repoRoot) {
+  const checks = [];
+  const claudeDir = join(repoRoot, ".claude");
+  checks.push(existsSync(claudeDir) ? { name: ".claude directory", status: "pass" } : { name: ".claude directory", status: "fail", fix: "Run: npx ca setup" });
+  const lessonsPath = join(repoRoot, LESSONS_PATH);
+  checks.push(existsSync(lessonsPath) ? { name: "Lessons index", status: "pass" } : { name: "Lessons index", status: "warn", fix: "Run: npx ca setup" });
+  const agentsDir = join(repoRoot, ".claude", "agents", "compound");
+  checks.push(existsSync(agentsDir) ? { name: "Agent templates", status: "pass" } : { name: "Agent templates", status: "fail", fix: "Run: npx ca setup" });
+  const commandsDir = join(repoRoot, ".claude", "commands", "compound");
+  checks.push(existsSync(commandsDir) ? { name: "Workflow commands", status: "pass" } : { name: "Workflow commands", status: "fail", fix: "Run: npx ca setup" });
+  const settingsPath = getClaudeSettingsPath(false);
+  let hooksOk = false;
+  try {
+    const settings = await readClaudeSettings(settingsPath);
+    hooksOk = hasClaudeHook(settings);
+  } catch {
+  }
+  checks.push(hooksOk ? { name: "Claude hooks", status: "pass" } : { name: "Claude hooks", status: "fail", fix: "Run: npx ca setup" });
+  const mcpOk = await hasMcpServerInMcpJson(repoRoot);
+  checks.push(mcpOk ? { name: "MCP server", status: "pass" } : { name: "MCP server", status: "fail", fix: "Run: npx ca setup" });
+  let modelOk = false;
+  try {
+    modelOk = isModelAvailable();
+  } catch {
+  }
+  checks.push(modelOk ? { name: "Embedding model", status: "pass" } : { name: "Embedding model", status: "warn", fix: "Run: npx ca download-model" });
+  return checks;
+}
+var STATUS_ICONS = {
+  pass: "OK",
+  fail: "FAIL",
+  warn: "WARN"
+};
+function registerDoctorCommand(program2) {
+  program2.command("doctor").description("Verify external dependencies and project health").action(async () => {
+    const repoRoot = getRepoRoot();
+    const checks = await runDoctor(repoRoot);
+    console.log("Compound Agent Health Check:\n");
+    for (const check of checks) {
+      const icon = STATUS_ICONS[check.status];
+      const line = `  [${icon}] ${check.name}`;
+      console.log(line);
+      if (check.fix) {
+        console.log(`        Fix: ${check.fix}`);
+      }
+    }
+    const failures = checks.filter((c) => c.status === "fail");
+    const warnings = checks.filter((c) => c.status === "warn");
+    console.log("");
+    if (failures.length === 0 && warnings.length === 0) {
+      console.log("All checks passed.");
+    } else {
+      if (failures.length > 0) console.log(`${failures.length} check(s) failed.`);
+      if (warnings.length > 0) console.log(`${warnings.length} warning(s).`);
+    }
+  });
+}
 
 // src/commands/management-invalidation.ts
 function registerInvalidationCommands(program2) {
@@ -4853,6 +5049,10 @@ function formatLessonForPrime(lesson) {
 }
 async function getPrimeContext(repoRoot) {
   const root = getRepoRoot();
+  try {
+    await syncIfNeeded(root);
+  } catch {
+  }
   const lessons = await loadSessionLessons(root, 5);
   let output = TRUST_LANGUAGE_TEMPLATE;
   if (lessons.length > 0) {
@@ -4927,6 +5127,106 @@ function registerAuditCommands(program2) {
     }
   });
 }
+var CONFIG_FILENAME = "compound-agent.json";
+var VALID_REVIEWERS = ["gemini", "codex"];
+function configPath(repoRoot) {
+  return join(repoRoot, ".claude", CONFIG_FILENAME);
+}
+async function readConfig(repoRoot) {
+  const path = configPath(repoRoot);
+  if (!existsSync(path)) return {};
+  try {
+    const parsed = JSON.parse(await readFile(path, "utf-8"));
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return {};
+    return parsed;
+  } catch {
+    return {};
+  }
+}
+async function writeConfig(repoRoot, config) {
+  await mkdir(join(repoRoot, ".claude"), { recursive: true });
+  await writeFile(configPath(repoRoot), JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+function safeReviewerArray(config) {
+  const raw = config.externalReviewers;
+  if (!Array.isArray(raw)) return [];
+  return raw;
+}
+async function getExternalReviewers(repoRoot) {
+  const config = await readConfig(repoRoot);
+  return safeReviewerArray(config).filter((r) => VALID_REVIEWERS.includes(r));
+}
+async function enableReviewer(repoRoot, name) {
+  if (!VALID_REVIEWERS.includes(name)) {
+    throw new Error(`Invalid reviewer: ${name}. Valid options: ${VALID_REVIEWERS.join(", ")}`);
+  }
+  const config = await readConfig(repoRoot);
+  const reviewers = safeReviewerArray(config);
+  if (reviewers.includes(name)) return false;
+  config.externalReviewers = [...reviewers, name];
+  await writeConfig(repoRoot, config);
+  return true;
+}
+async function disableReviewer(repoRoot, name) {
+  const config = await readConfig(repoRoot);
+  const reviewers = safeReviewerArray(config);
+  if (!reviewers.includes(name)) return false;
+  config.externalReviewers = reviewers.filter((r) => r !== name);
+  await writeConfig(repoRoot, config);
+  return true;
+}
+
+// src/commands/reviewer.ts
+function registerReviewerCommand(program2) {
+  const reviewer = program2.command("reviewer").description("Manage external code reviewers (gemini, codex)");
+  reviewer.command("enable <name>").description(`Enable an external reviewer (${VALID_REVIEWERS.join(", ")})`).action(async (name) => {
+    const repoRoot = getRepoRoot();
+    try {
+      const added = await enableReviewer(repoRoot, name);
+      if (added) {
+        console.log(`Enabled external reviewer: ${name}`);
+      } else {
+        console.log(`${name} is already enabled`);
+      }
+    } catch (err) {
+      console.error(err.message);
+      process.exitCode = 1;
+    }
+  });
+  reviewer.command("disable <name>").description("Disable an external reviewer").action(async (name) => {
+    try {
+      const repoRoot = getRepoRoot();
+      const removed = await disableReviewer(repoRoot, name);
+      if (removed) {
+        console.log(`Disabled external reviewer: ${name}`);
+      } else {
+        console.log(`${name} is not enabled`);
+      }
+    } catch (err) {
+      console.error(err.message);
+      process.exitCode = 1;
+    }
+  });
+  reviewer.command("list").description("List enabled external reviewers").action(async () => {
+    try {
+      const repoRoot = getRepoRoot();
+      const reviewers = await getExternalReviewers(repoRoot);
+      if (reviewers.length === 0) {
+        console.log("No external reviewers enabled");
+        console.log(`Available: ${VALID_REVIEWERS.join(", ")}`);
+        console.log("Enable with: ca reviewer enable <name>");
+      } else {
+        console.log("Enabled external reviewers:");
+        for (const r of reviewers) {
+          console.log(`  - ${r}`);
+        }
+      }
+    } catch (err) {
+      console.error(err.message);
+      process.exitCode = 1;
+    }
+  });
+}
 function registerRulesCommands(program2) {
   const rulesCmd = program2.command("rules").description("Run repository-defined rule checks");
   rulesCmd.command("check").description("Check codebase against rules in .claude/rules.json").action(function() {
@@ -5568,6 +5868,8 @@ function registerManagementCommands(program2) {
   registerPrimeCommand(program2);
   registerCrudCommands(program2);
   registerAuditCommands(program2);
+  registerDoctorCommand(program2);
+  registerReviewerCommand(program2);
   registerRulesCommands(program2);
   registerTestSummaryCommand(program2);
 }