dh

Produce groomed content for a backlog item — discovers related skills, agents, prior work, and dependency graph; performs RT-ICA assessment; outputs groomed item template for writing into .claude/backlog/{priority}-{slug}.md. Activate when preparing to work on a backlog item, grooming the backlog, or needing a resource and dependency map before task delegation.

SAM Stage 6 independent code reviewer. Reviews any language or stack against a SAM task file's acceptance criteria. Detects the stack from files, loads the matching dh:code-review-{stack} skill, checks universal quality dimensions (security, correctness, tests, API contracts, naming, error handling, performance), produces a structured PASS/FAIL/NEEDS-WORK verdict, and registers the report as a codebase-analysis artifact via MCP. Use when a task reaches S6 Forensic Review or when an independent review of implementation quality is required. Trigger phrases: 'review this implementation', 'run code review', 'S6 review', 'forensic review', 'check implementation against acceptance criteria'.

Explores codebase patterns and writes structured analysis documents. Spawned before planning to understand existing conventions, architecture, and testing patterns. Writes documents directly to reduce orchestrator context load.

Updates task context manifest with discoveries from current work session. Analyzes implementation code and task file to understand what was learned. Only updates if drift or new discoveries found. Provide the task file path.

Post-task verifier that compares method signatures and type contracts from the architect spec against files modified by the just-completed task. Reads the architect spec Component Design and Type System Design sections, extracts expected signatures and contracts, then greps the modified files to find actual signatures. Reports mismatches as a concerns block with CONTRACT VIOLATION (signature mismatch) and CONTRACT GAP (spec defines contract but implementation is silent) severity levels. Returns an empty response when no mismatches are found.

Use when creating a new task OR when starting/switching to a task that lacks a context manifest. ALWAYS provide the task file path so the agent can read it and update it directly with the context manifest. Skip if task file already contains "Context Manifest" section.

Audits documentation accuracy against actual implementation. Analyzes git history to identify when code and documentation diverged, extracts actual features from source code, compares against documentation claims. Generates comprehensive audit reports categorizing drift (implemented but undocumented, documented but unimplemented, outdated documentation, mismatched details). Uses git forensics, code analysis, and evidence-based reporting with specific file paths, line numbers, and commit SHAs.

Researches domain ecosystems and technology landscapes before roadmap creation. Supports three modes - Ecosystem discovery, Feasibility assessment, and Comparison analysis. Use when exploring new domains, evaluating technology choices, or comparing implementation approaches. Requires MCP research servers (Ref, exa, context7, or firecrawl) - BLOCKs if none available.

Verify a single factual claim against primary sources using web lookups. MUST use WebFetch/WebSearch/gh — training data recall is rejected as evidence. Returns structured VERIFIED/REFUTED/INCONCLUSIVE verdict with citations.

Researches feature requests and existing architecture documents to produce discovery context. Explores codebase patterns, identifies ambiguities, documents use scenarios, and surfaces questions for orchestrator resolution. Does NOT make technical implementation decisions.

Goal-backward verification AFTER feature implementation. Starts from expected outcomes, works backwards to verify each was achieved. Tests the feature as a user would, not just that code exists. Returns VERIFIED or GAPS_FOUND with specific failures.

Generic SDLC stage agent that executes workflow steps using loaded domain skills and quality gates

Use this agent when you need to assess the impact and risk of a proposed change across the entire system — code, docs, configuration, CI, tests, and agent instructions. This agent builds the affected systems inventory for backlog grooming and writes the Impact Radius section to backlog items via MCP.\n\nExamples:\n\n- Context: A backlog item is being groomed and needs impact analysis before planning.\n user: "Groom backlog item #42"\n assistant: "I'll use the impact-analyst agent to build the affected systems inventory and assess risk for this item."\n <commentary>\n Since the grooming workflow requires an Impact Radius section before planning, use the Agent tool to launch the impact-analyst agent with the backlog item context.\n </commentary>\n\n- Context: A developer wants to understand the blast radius of replacing a local capability with an external tool.\n user: "What would break if we migrate the linting from local ruff to the MCP linting server?"\n assistant: "I'll use the impact-analyst agent to map every consumer, test, doc, config, CI workflow, and agent instruction that depends on the current local ruff integration."\n <commentary>\n Since the user is asking about migration impact across multiple system boundaries, use the Agent tool to launch the impact-analyst agent to perform the full ecosystem analysis.\n </commentary>\n\n- Context: The orchestrator is running the /dh:groom-backlog-item workflow and has reached the impact analysis step.\n assistant: "Now I'll launch the impact-analyst agent to determine the full blast radius before fact-checking and planning."\n <commentary>\n The grooming workflow requires impact analysis as a prerequisite to planning. Use the Agent tool to launch the impact-analyst agent with the item selector and any known context.\n </commentary>

Verifies cross-module integration and end-to-end flows. Checks that new code connects properly with existing modules - exports used, imports work, data flows complete. Existence is not integration.

Validates implementation plans BEFORE execution begins. Checks for completeness, contradictions, missing dependencies, and executability. Returns READY or BLOCKED with specific gaps. Prevents wasted effort from flawed plans.

Synchronizes documentation with code changes — use after implementing features, refactoring code, deleting files, changing APIs, or modifying configurations. Launch this agent whenever code changes could render existing documentation inaccurate or incomplete. Triggers include new endpoints added, modules refactored, files deleted, configuration formats changed, or at session end to sweep all affected documentation.

Use when transforming architecture docs, PRDs, or feature specs into dependency-ordered task plans for parallel AI agent execution. Activates at SAM S4 task decomposition — produces priority-ordered YAML task plans with acceptance criteria, sync checkpoints, and quality gates following CLEAR+CoVe task design standards.

Captures baseline state of structured acceptance criteria before implementation begins. Reads acceptance-criteria-structured from a SAM plan file, runs each check_command via Bash, assembles T0 results as YAML in memory, and registers the artifact via artifact_register with content= for MCP-native storage. Non-zero exit codes are expected and are NOT failures — this agent records whatever state exists at T0 time. Requires issue_number as a mandatory input.

Universal SAM task executor — receives a task reference (P{N}/T{M}), loads the task via sam_task, loads skills from task metadata, claims the task, executes against acceptance criteria, and reports structured completion. Use when dispatching parallel work via TeamCreate, or when any agent needs to execute a SAM task. The task file contains the full work specification — this agent adapts to any domain by loading the skills the task requires.

Verification gate that runs after all implementation tasks complete. Re-runs acceptance-criteria-structured check commands, compares results against T0 baseline, computes CriterionStatus per criterion, and registers a TN-verification artifact via MCP with a verdict of PASS or FAIL. FAIL blocks /complete-implementation if any criterion regressed.

SAM-style feature initiation workflow: discovery -> codebase analysis -> architecture spec -> task decomposition -> validation -> context manifest. Use when a user asks to add a feature, plan a feature, or convert an idea into executable task files.

Use when analyzing failing test cases to determine whether failures indicate genuine bugs or test implementation issues. Activates on "analyze failing tests", "debug test failures", "investigate test errors", or when provided with specific failing test names or output. Applies balanced investigative reasoning — does not auto-fix tests without establishing root cause.

Single interface for backlog items and GitHub Issues. GitHub Issues are the source of truth. All backlog CRUD goes through MCP tools (mcp__plugin_dh_backlog__*) — no direct file edits. Use when creating, listing, viewing, updating, closing, resolving, grooming, or syncing backlog items and GitHub issues.

Combine CLEAR (Concise, Logical, Explicit, Adaptive, Reflective) and CoVe (Chain of Verification) to write and lint agent task files that will be executed by worker agents. Use when orchestration or planning agents are producing task plans, task prompts, or TASK.md style instructions that must be unambiguous, verifiable, and resistant to hallucination.

Claude Code skill and agent review patterns. Covers SKILL.md structure, frontmatter validity, token budget, description quality, and agent contract compliance. Loaded automatically when reviewing Claude skills or agent definitions.

CLI application code review patterns. Covers UX, argument parsing, exit codes, terminal output, and non-interactive operation. Loaded automatically when reviewing CLI tools.

LLM integration and machine learning code review patterns. Covers prompt engineering, model selection, context management, token economics, evaluation, and safety. Loaded automatically when reviewing AI/ML code.

Node.js-specific code review patterns. Covers async patterns, streams, security, process management, and dependency hygiene. Loaded automatically when reviewing Node.js server code.

Python-specific code review patterns for the dh code-reviewer agent. Covers uv, ruff, ty, pytest, typing, and Python 3.11+ idioms. Loaded automatically when reviewing Python code.

TypeScript-specific code review patterns. Covers strict mode, ESM, type safety, branded types, and common anti-patterns. Loaded automatically when reviewing TypeScript code.

Web frontend code review patterns. Covers accessibility, DOM safety, performance, CSS, and framework-agnostic quality indicators. Loaded automatically when reviewing frontend code.

Holistic completion workflow after a feature's tasks are marked COMPLETE: code review, feature verification, integration check, documentation drift audit/update, and context refinement. Creates follow-up task files when issues are found.

Use when reviewing test suites for coverage, isolation, mock usage, naming conventions, or completeness. Activates on "review test coverage", "audit test quality", or "check tests for completeness" requests. Performs thorough checklist-driven review covering test isolation, mock correctness, AAA pattern adherence, and naming standards.

SAM Stage 3 — Ground the design plan in actual codebase reality. Performs scope analysis, conflict detection, and resource mapping. Used when the PLAN artifact needs contextualization with concrete file references, integration points, and resolved conflicts.

Use when capturing a new backlog item via the backlog MCP server. Three modes — guided intake (no args), quick entry (quick {title}), or fully autonomous (--auto {title}). Validates required fields, detects duplicates, and offers GitHub Issue creation for P0/P1 items.

Development Harness plugin overview and skill router — use when unsure which dh skill to invoke. Routes by intent — capture, groom, plan, execute, single task, quality gates, or milestone. Activates on 'which skill', 'where do I start', 'development workflow', or direct /dh invocation.

Development harness plugin documentation index. Load when needing to read about SAM pipeline, backlog lifecycle, SDLC layers, task file format, plan artifacts, quality gates, or dispatch schema.

SAM Stage 1 — Structured requirements gathering through discussion with user. Produces the DISCOVERY artifact containing feature requirements, NFRs, goals, anti-goals, references, and resolved questions. Use when starting a new feature or gathering requirements.

Orchestrate parallel agent teams as a manager — not a micromanager. Use when coordinating 2+ independent workers, running SAM task waves, relaying discoveries between worker waves, handling blockers, or synthesizing team results. Covers both SAM structured dispatch (task file does the work) and ad-hoc dispatch (reference agent-orchestration for prompt template).

SAM Stage 5 — Stateless execution of a single task in a fresh agent session. The task file IS the complete prompt containing all context needed. Used when dispatching a task to an agent; produces the EXECUTION artifact with implementation results and verification output.

SAM Stage 7 — Goal-backward certification that the feature achieves its original objectives. Used when all tasks pass forensic review; starts from expected outcomes, works backwards to verify each was achieved. Returns CERTIFIED or NOT_CERTIFIED with specific gaps.

SAM Stage 6 — Independent verification of execution results by a separate reviewer agent. Used when validating task completion against plan; performs fact-checking and returns COMPLETE or NEEDS_WORK with specific findings.

Generate a single worker task prompt using the existing CLEAR + selective CoVe task design standard and the task structure requirements used by swarm-task-planner. Use when you need to create or rewrite one TASK/ file or one task block for a plan.

Groom backlog items — trigger /groom-backlog-item <title|section|all> — fact-checks item claims against primary sources, runs RT-ICA per item, then spawns @dh:backlog-item-groomer agents. Writes groomed content via backlog MCP tools (backlog_groom, backlog_update). Use when preparing backlog items for planning or execution.

Groom a GitHub milestone for parallel execution. Batch-grooms ungroomed items, assesses scope gaps, analyzes cross-item dependencies (Impact Radius overlap), builds conflict groups, assigns items to execution waves, and persists the dispatch plan via dispatch_create_plan MCP tool. Calls dispatch_wave_start MCP tool per wave to register state. Use when preparing a milestone for /work-milestone execution. Args: {milestone-number}. Requires milestone to have items assigned via /group-items-to-milestone.

Use when a SAM task plan exists and you need to execute the implementation loop — picks up ready tasks, delegates each to its specified agent, and relies on hooks to update task timestamps and status. Activates when a plan address (P{NNN}) or feature slug is provided after planning is complete. Task plans are managed by the SAM MCP server (sam_status, sam_read).

Query and manage feature implementation task status. Provides CLI tools to list features, check task status, find ready tasks, and validate task files. Used by /execution orchestrator to track progress. Automatically updates task timestamps via hooks on /start-task.

Use this skill when routing a Superpowers plan file through the /work-backlog-item pipeline — creates a SAM task file and writes back-references into the original plan

Spawn and manage persistent interactive Claude Code CLI sessions with bidirectional communication via tmux. Provides spawn, send, read, status, list, and kill subcommands for orchestrating parallel peer sessions. Uses built-in --worktree and --tmux flags. Sessions stay alive for multi-turn steering. Triggers on "spawn claude session", "launch separate claude", "peer session", "inter-session communication", "shadow clone", "kage bunshin".

Identify required inputs, dependencies, and uncertainty during planning. Use when generating plans or task graphs under incomplete information. Does not block plan generation; instead localizes gaps and creates unblock dependencies.

SAM Stage 2 — Transform discovery into actionable design with RT-ICA prerequisite verification. Produces the PLAN artifact with approach, components, success criteria, acceptance tests, and risks. Use when discovery is complete and design must begin. Blocks on missing prerequisites.

Reverse Thinking - Information Completeness Assessment. Mandatory pre-planning checkpoint that blocks planning until prerequisites are verified. Use when receiving specs, PRDs, tickets, RFCs, architecture designs, or any multi-step engineering task. Integrates with CoVe-style planning pipelines. Invoke BEFORE creating plans, delegating to agents, or defining acceptance criteria.

Creates or regenerates .dh/skill_discovery.yaml. Scans repo to infer tech stack, inventories installed skills via npx skills list, loads candidate skill content before suggesting, and writes a config-driven skill injection file. Run /dh:setup-skill-discovery to create or update the project skill discovery config.

Use when an agent needs to pick up a specific SAM task, set it in progress, implement its acceptance criteria, and signal completion. Activates when executing tasks from a SAM task file — updates status to IN PROGRESS with a Started timestamp, writes active-task context for hooks, and supports --complete to mark tasks done. Triggers on task execution within the implement-feature loop.

Global contract for all specialist subagents — enforces role boundaries, scope discipline, and DONE/BLOCKED status signaling. Use when loading any agent that should operate as a bounded specialist following supervisor delegation patterns.

SAM Stage 4 — Decompose contextualized plan into atomic, independently executable tasks with complete embedded context. Used when the contextualized plan is ready for TASK file generation with CLEAR ordering, CoVe checks, and dependency graphs for parallel execution.

Use when encountering failing tests, diagnosing test errors, or establishing a systematic approach to test failure investigation. Activates on "test failure analysis", "debugging tests", or "why tests fail" requests. Establishes the mindset that treats test failures as valuable diagnostic signals requiring root-cause investigation — not automatic code fixes or test dismissal.

Scientific validation protocol for verifying fixes work through observation, not assumption. Use when claiming a bug fix, code change, or implementation is complete. Enforces create-broken-state — define-success-criteria — apply-fix — verify-outcome workflow. Success equals observing intended behavior, not absence of errors.

Use when working, planning, or closing a backlog item. Bridges backlog items to SAM planning with GitHub Issue/Project/Milestone tracking. No args: interactive browser. '#N': load from GitHub Issue #N. Title substring: auto-grooming, RT-ICA gate, GitHub sync, SAM planning. '--auto {title}': autonomous mode — no AskUserQuestion, derives data from research files, logs decisions. 'close {title}': dismiss without completion — reason required (duplicate, out_of_scope, superseded, wontfix, blocked). ADR-9. 'resolve {title}': mark DONE with evidence trail — summary required. ADR-9. 'setup-github': init labels, project, milestone. '--language' and '--stack' select Layer 1/2 profile. STOPS if item has Plan field or RT-ICA returns BLOCKED.

Execute a groomed milestone with parallel kage-bunshin sessions in isolated worktrees. Use when running a milestone after /groom-milestone has produced a dispatch plan. Reads dispatch plan, creates integration branch, spawns one kage-bunshin (independent claude -p process) per wave item in its own worktree — each session is a full orchestrator with Agent tool and TeamCreate. Sequentially merges worktree branches, relays wave discoveries to subsequent waves, then lands integration branch to main. Args: {milestone-number}.

9 hooks across 7 events