dso

Create a git commit with mandatory test, format, review gates.

Invoke the `/dso:end-session` skill, passing through any arguments: $ARGUMENTS

Review current code diff using a code-reviewer sub-agent.

Evaluates implementation proposals against 5 quality dimensions and returns ADR-style selection rationale or counter-proposal

Evaluates probabilistic bloat candidates from /dso:remediate, classifying each as CONFIRM (likely bloat), DISMISS (false positive), or NEEDS_HUMAN (ambiguous). Enforces asymmetric error policy — defaults to DISMISS when uncertain because false CONFIRMs are amplified downstream.

Applies confirmed bloat removals from /dso:remediate Path B (auto-resolve). Treats its output as final — performs dependency checks before each deletion and emits NO_CHANGE with categorized reasons when removal is unsafe.

Structured filter that evaluates red team adversarial findings against the original story map and removes false positives, speculative concerns, and low-signal noise.

LLM behavioral debugger agent. Diagnoses divergent, unpredictable, or failing behavior in other LLMs and agents using a 16-point failure taxonomy, 5 RCA probes, and an iterative hypothesis-experiment-analyze loop. Emits a structured RESULT schema compatible with /dso:fix-bug.

Deep-tier architectural reviewer (Opus): synthesizes specialist findings, assesses systemic risk, produces unified verdict across all dimensions.

Deep-tier correctness specialist (Sonnet A): focused exclusively on correctness — edge cases, error handling, security, efficiency.

Deep-tier hygiene/design specialist (Sonnet C): focused on hygiene, design, and maintainability.

Deep-tier verification specialist (Sonnet B): focused exclusively on verification — test presence, quality, edge case coverage, mock correctness.

Light-tier code reviewer: single-pass, highest-signal checklist for fast feedback on low-to-medium-risk changes.

Performance reviewer (Opus): calibrated performance analysis with bright-line severity rules for scaling failures and resource exhaustion.

Security blue team reviewer (Opus): context-aware triage of red team findings with dismiss/downgrade/sustain authority.

Security red team reviewer (Opus): aggressive security detection without ticket context for AI-advantaged security concerns.

Standard-tier code reviewer: comprehensive review across all five scoring dimensions for moderate-to-high-risk changes.

Test quality reviewer (Opus): detects test bloat patterns including change-detector tests, implementation-coupled assertions, tautological tests, source-file-grepping, and existence-only assertions.

Independently verifies that success criteria (SC) for epics and done definitions (DD) for stories are met by the implementation before closure is approved.

Classifies a ticket as TRIVIAL/MODERATE/COMPLEX (or SIMPLE/MODERATE/COMPLEX for epics) using an 8-dimension rubric.

Analyzes git merge conflicts, classifies each conflicted file, and proposes a resolution with confidence scoring.

Classifies interactions between a new epic and open/in-progress epics, detecting shared-resource overlaps with four-tier severity classification (benign, consideration, ambiguity, conflict).

Documentation optimization agent that enforces a 4-tier schema and decision engine to keep project docs accurate and lean after epic completion.

Verifies external tool feasibility during brainstorm by searching for evidence of real, working integrations before implementation begins.

Opus reviewer dispatched during the large-refactor confirmed-refactor branch. Receives concatenated diffs of files flagged as anomalous by the haiku conformance sweep. Reports pattern_conformance, behavioral_drift, and callsite_completeness findings using the standard 5-dimension reviewer schema.

Opus-model fallback reviewer for the light tier, used when the large-refactor review path activates and the diff exceeds the huge_diff_file_threshold. Identical behavior to code-reviewer-light but always runs on opus.

Opus-model fallback reviewer for the standard tier, used when the large-refactor review path activates and the diff exceeds the huge_diff_file_threshold. Identical behavior to code-reviewer-standard but always runs on opus.

Pre-investigation gate agent (Gate 1a) for /dso:fix-bug. Searches closed/archived tickets, git history, ADRs, design docs, and code comments to determine whether a bug aligns with or contradicts the system's documented intent.

Plan and design reviewer agent. Evaluates implementation plans and design artifacts on feasibility, completeness, YAGNI, and codebase alignment before the user sees them. Dispatched by the /dso:plan-review skill. Use subagent_type "dso:plan-review" to dispatch this agent.

Adversarial reviewer that attacks preplanning story maps for cross-story blind spots, implicit assumptions, and interaction gaps across 7 taxonomy categories.

Triages RED test writer failures with REVISE/REJECT/CONFIRM verdicts. Aligned with shared behavioral testing standard.

Writes behavioral RED tests for TDD workflows, rejecting change-detector patterns.

Post-fix scope-drift classifier for /dso:fix-bug. Reviews a completed fix against the original ticket scope to detect whether the diff introduces behavioral changes outside the ticket boundary. Emits a GATE_SIGNAL conforming to gate-signal-schema.md.

Creates design artifacts for a story ID. Produces a Design Brief (Lite track) or full Design Manifest (spatial layout tree, SVG blueprint, token overlay, manifest). Returns structured payload conforming to docs/contracts/ui-designer-payload.md.

Deep-dive architectural scaffolding for an existing project — reads .claude/project-understanding.md (written by /dso:onboarding), uses Socratic dialogue to uncover enforcement preferences and anti-pattern risks, and generates targeted scaffolding without re-running project detection.

Use when starting a new feature or epic — turns an idea into a defined, ticket-ready epic through Socratic dialogue, approach design, and milestone spec creation.

Guidance for creating well-formatted, evidence-based bug reports using the shared bug report template and ticket CLI.

Use when reviewing proposed designs (code, wireframes, screenshots) against an established .claude/design-notes.md, or when enforcing design system compliance before merging UI changes

DEPRECATED — design wireframe functionality has moved to the dso:ui-designer agent, dispatched by /dso:preplanning Step 6. Run /dso:preplanning on the parent epic to orchestrate UI story design via the Agent tool.

Use when the user wants to preview what a skill would do without making changes to tickets, the file system, or git

End Session - Worktree Cleanup and Task Summary

Emergency brake for runaway cascades. Stops edits, assesses damage, decides revert, then hands off to /dso:fix-bug for investigation.

Generate a project-specific CLAUDE.md file from workflow-config.yaml and the Digital Service Orchestra template

Initialize project with Digital Service Orchestra config

Interface contract design for parallel agent development

Detect feedback oscillation in iterative review loops using structural diff comparison. Invoke before implementing review feedback.

Orchestrator-level skill that reviews plans and designs before user approval by dispatching a dso:plan-review sub-agent. Invoke before presenting any plan or design to the user, or before calling ExitPlanMode. Do NOT dispatch this skill itself as a sub-agent — it requires the Agent tool and will refuse sub-agent invocation.

Use when debugging a UI or browser-visible bug. Enforces a 3-tier hypothesis-first process that minimizes @playwright/cli token usage by exhausting static code analysis and targeted JS evidence before escalating to full browser interaction.

Use when decomposing a ticket epic into prioritized user stories with measurable done definitions, or when auditing and reconciling existing epic children before implementation

Auto-discover and display all plugin scripts and skills available in this workflow plugin.

Agent-assisted git merge/rebase conflict resolution with confidence-gated automation

Use when performing periodic project health reviews, optimizing development workflow, cleaning up worktrees, auditing test quality, or identifying technical debt and maintenance needs

Use when a skill needs structured multi-perspective review with conflict detection, revision cycles, and standardized JSON output — replaces ad-hoc mental reviews and custom sub-agent review logic

Display review event statistics — shows reviewer tier distribution, resolution rates, and trends over time.

Use when the user wants to transform a high-level product vision, PRD, or project idea into a prioritized roadmap of epics, or when they want to brainstorm and architect project milestones

Issue health validation and remediation

Generates or refreshes the UI Discovery Cache for a project. Inventories components via Glob/Grep, crawls routes via Playwright, and writes structured results to .ui-discovery-cache/. Produces a deterministic validation script for git-based cache invalidation. Run once before starting an epic's wireframe designs.

Invoke the doc-writer agent to update project documentation based on recent changes. Scoped to a commit range (default main...HEAD). Use after an epic completes or when documentation is out of sync.

Use when starting any conversation - establishes how to find and use skills, requiring Skill tool invocation before ANY response including clarifying questions

Use when verifying project health after completing work, before closing tasks, or when you need confidence that code, CI, staging deployment, and live environment are all passing. Does not fix issues — only detects and reports them.

Use when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions always

14 hooks across 6 events