dh

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.

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.

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.

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.

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

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.

Creates dependency-based task plans for parallel AI agent execution. Transforms architecture docs and PRDs into priority-ordered tasks with acceptance criteria, sync checkpoints, and quality gates. Uses 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, and writes results to ~/.dh/projects/{slug}/plan/T0-baseline-{slug}.yaml. Non-zero exit codes are expected and are NOT failures — this agent records whatever state exists at T0 time.

Universal SAM task executor — receives a task reference (P{N}/T{M}), loads the task via sam_read, 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 writes ~/.dh/projects/{slug}/plan/TN-verification-{slug}.yaml 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.

Single interface for backlog items and GitHub Issues. GitHub Issues are the source of truth; ~/.dh/projects/{slug}/backlog/ per-item files are the local cache. All backlog CRUD goes through MCP tools (mcp__plugin_dh_backlog__*) in orchestrator sessions — 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.

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 capturing a new backlog item — creates a per-item file in ~/.dh/projects/{slug}/backlog/. 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.

Language-agnostic development process orchestrator implementing SAM 7-stage pipeline with Voltron composition. Detects project language, resolves specialist roles from language plugin manifests, and orchestrates discovery through verification. Use when starting feature development, planning implementations, or running the full development workflow.

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.

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).

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 @backlog-item-groomer agents. Writes groomed content into per-item files in ~/.dh/projects/{slug}/backlog/. 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.

Execute a SAM task plan by looping ready tasks, delegating each to its specified agent, and relying on hooks to update task timestamps/status. Task plans are stored under ~/.dh/projects/{slug}/plan/ (resolved via dh_paths.plan_dir()). Use when a task file exists and you need to run the implementation loop that picks up ready tasks and delegates them to agents.

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 Claude Code CLI sessions with bidirectional communication via tmux and stream-json. Provides spawn, send, read, status, list, and kill subcommands for orchestrating parallel peer sessions. Uses built-in --worktree and --tmux flags. 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.

Start or complete a specific task inside a SAM task file. Updates task status to IN PROGRESS with Started timestamp, writes active-task context for hooks, and supports --complete to mark tasks complete. Use when an agent needs to pick up a SAM task, set it in progress, implement acceptance criteria, and signal completion.

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.

This skill should be used when the user asks to "analyze failing tests", "debug test failures", "investigate test errors", or provides specific failing test cases to examine. Analyzes failing test cases with a balanced, investigative approach to determine whether failures indicate test issues or genuine bugs.

This skill should be used when the user asks to "review test coverage", "audit test quality", "check tests for completeness", or mentions reviewing test suites. Performs thorough test review following standard checklist for test isolation, mock usage, naming, and coverage.

This skill should be used when encountering failing tests or when the user asks about "test failure analysis", "debugging tests", "why tests fail", or needs to set a balanced investigative approach for test failures. Establishes mindset that treats test failures as valuable signals requiring investigation, not automatic 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}.

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.

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.

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.

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.

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.