dso-dev

Plugin dso-dev from marketplace digital-service-orchestra in navapbc/digital-service-orchestra. Commands read from the repo's manifest — 1 month ago.

Skills (38)

• architect-foundation

  Use when the user wants to set up architecture rules, code standards, guardrails, fitness functions, lint configs, or enforce project conventions after onboarding has run. Reads .claude/project-understanding.md (written by /dso:onboarding) and uses Socratic dialogue to surface enforcement preference

• brainstorm

  Use when starting a new feature or epic — turns a feature idea into a defined, ticket-ready epic through Socratic dialogue with the user. Designs technical approaches, breaks features into milestones, drafts ticket descriptions and success criteria, and writes the epic to the ticket tracker. Trigger

• create-bug

  Use when an agent or user needs to file a bug, report an issue, create a defect ticket, or capture a sub-agent blocker. Creates well-formatted, evidence-based bug tickets by collecting reproduction steps, expected vs. actual behavior, environment details, and logs, then writing the ticket via the ti

• debug-everything

  Use when the user wants a comprehensive multi-issue health pass — fix all bugs, resolve broken tests, clear CI failures, fix lint and type errors, restore green builds — not for a single targeted bug fix. Diagnoses and resolves every outstanding open bug ticket plus all validation failures (test, li

• design-review

  Use when reviewing proposed designs (code, wireframes, screenshots) against an established DESIGN.md, or when enforcing design system compliance before merging UI changes. Checks color tokens, typography, spacing, component usage, layout, and accessibility against the project's design notes and prod

• dryrun

  Use when the user wants to dry-run a DSO skill, simulate its execution, or preview its planned changes without executing them. Wraps any /dso:* skill invocation with override rules that block all mutating operations (ticket writes, file edits, git commits) while still running read-only steps; emits

• end-session

  Use when wrapping up a worktree session — closing tasks, finishing work, or merging the branch back to main. Closes completed tickets, sweeps orphaned epics, extracts technical learnings, files bug tickets for unfixed failures, commits remaining changes, syncs the tickets branch, merges to main via

• fix-bug

  Use when fixing a single bug, debugging an error or crash, investigating a defect, or routing a bug report through structured investigation. Classifies the bug by type and severity, runs pre-investigation gates (intent search, feature-request check), dispatches a tiered investigation sub-agent (BASI

• fix-cascade-recovery

  Use when 5+ fix attempts have cascaded into new failures, when the cascade circuit-breaker fires (CLAUDE.md `rule:cascade-circuit`), or when repeated edits are propagating errors instead of resolving them. Stops further edits, assesses blast radius via git diff, decides whether to fully revert / sel

• fp-recovery

  Manual review escalation when CI llm-review blocks a PR on a finding that looks like a false positive. Dispatches dso:code-reviewer-standard at opus tier on the PR's diff, parses the result, and emits a force-merge clearance when zero critical/important/fragile findings remain. Use ONLY when CI llm-

• generate-claude-md

  Generate a project-specific CLAUDE.md file from .claude/dso-config.conf and the Digital Service Orchestra template

• implementation-plan

  Use when a user story or simple epic needs to be broken into atomic, TDD-driven implementation tasks with architectural review, or when planning the TDD task breakdown for a specific story or task ticket. Produces an ordered task list with explicit RED-test specs, identifies file impact and consumer

• init

  Initialize project with Digital Service Orchestra config

• interface-contracts
• onboarding
• oscillation-check
• plan-review
• playwright-debug
• preplanning
• prioritize-epics
• quick-ref
• remediate-arch-evidence
• resolve-conflicts
• respond-to-pr-comments
• retro
• review-protocol
• review-stats
• review
• roadmap
• sprint
• test-quality-report
• tickets-health
• ui-discover
• update-docs
• using-dso
• validate-work
• verification-before-completion
• visual-evaluator

Slash commands (4)

• /dso-dev:commit
• /dso-dev:debug-everything
• /dso-dev:end
• /dso-dev:review

Subagents (53)

• approach-decision-maker

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

• approach-proposer

  Generates a distinct set of implementation proposals for a user story, applying the complexity gates (YAGNI / Rule of Three / new-dependency) and the four-axis distinctness gate before returning the set to the approach-decision-maker. Read-only — does not modify files, dispatch agents, or run shell

• architectural-probe

  Produces end-to-end test scaffold or integration-harness spec for architectural epics before scrutiny.

• bloat-blue-team

  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.

• bloat-resolver

  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.

• blue-team-filter

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

• bot-psychologist

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

• bug-classifier-haiku

  Classifies a bug ticket into exactly one registry slug from the bug-classification registry, or returns 'uncategorized' if no slug fits without caveats.

• code-reviewer-arbiter

  Arbiter (Opus): cycle-end ruling — BLOCK/DEFER/DROP per finding at cycle boundary.

• code-reviewer-deep-arch

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

• code-reviewer-deep-correctness

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

• code-reviewer-deep-hygiene

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

• code-reviewer-deep-verification

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

• code-reviewer-light

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

• code-reviewer-performance

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

• code-reviewer-security-blue-team

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

• code-reviewer-security-red-team

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

• code-reviewer-standard

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

• code-reviewer-test-quality

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

• code-reviewer-verifier

  Verifier agent: inspects absence-claim findings by checking cited evidence, then emits structured rulings with fingerprints.

• completion-verifier

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

• complexity-evaluator

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

• conflict-analyzer

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

• cross-epic-interaction-classifier

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

• doc-writer

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

• feasibility-reviewer

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

• gov-copy-writer

  Generates empathetic, plain-language UI copy for government services per federal style canon. Produces YAML artifacts conforming to gov-copy-artifact.md schema with structured rationale and deterministic check fields. Loads federal-style canon entries via ref-query.sh and applies precedence ladder (

• huge-diff-refactor-anomaly

  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.

• huge-diff-reviewer-light

  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.

• huge-diff-reviewer-standard

  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.

• inference-incident-curator

  Scans ticket history for inference incidents and emits JSONL corpus records per inference-incident-schema.md

• intent-search

  Pre-investigation gate agent (Intent Gate) 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.

• investigator-advanced-code-tracer

  Bug investigator (opus, ADVANCED Code Tracer lens): execution path tracing, intermediate variable tracking, code-evidence hypothesis set.

• investigator-advanced-historical

  Bug investigator (opus, ADVANCED Historical lens): timeline reconstruction, fault tree analysis, git bisect, change-history hypothesis set.

• investigator-basic

  Bug investigator (sonnet, BASIC tier): single-pass localization, five whys, single proposed fix for low-complexity bugs.

• investigator-escalated-code-tracer

  Bug investigator (opus, ESCALATED Code Tracer): deep execution-path tracing, dependency-ordered analysis, state and concurrency inspection.

• investigator-escalated-empirical

  Bug investigator (opus, ESCALATED Empirical Agent): authorized to add temporary logging/debugging; veto authority over theoretical consensus; must confirm artifact revert.

• investigator-escalated-history

  Bug investigator (opus, ESCALATED History Analyst): deep timeline reconstruction, fault tree, commit bisection beyond ADVANCED depth.

• investigator-escalated-web

  Bug investigator (opus, ESCALATED Web Researcher): error pattern analysis, dependency changelogs, upstream issue correlation; WebSearch/WebFetch authorized.

• investigator-intermediate-fallback

  Bug investigator (opus, INTERMEDIATE fallback persona): same investigation depth as intermediate when error-detective is unavailable.

• investigator-intermediate

  Bug investigator (opus, INTERMEDIATE tier): dependency-ordered reading, intermediate variable tracking, hypothesis elimination, ≥2 ranked fixes with tradeoffs.

• plan-review

  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.

• red-team-reviewer

  Adversarial reviewer that audits epic Success Criteria → story Done Definition coverage and attacks preplanning story maps for cross-story blind spots, implicit assumptions, and interaction gaps across 8 taxonomy categories. Requires opus.

• red-test-evaluator

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

• red-test-writer

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

• schema-correction

  Schema correction specialist: repairs missing or invalid fields in review findings JSON without re-evaluating the diff.

• scope-drift-reviewer

  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.

• second-source-verifier

  Independently audits story closure artifacts in an epic to confirm typed-enum verifier (P1 field), deterministic renderer (render-closure-narrative.sh), and handoff gate (check-story-handoff.sh) were actually used for each story closure.

• story-decomposer

  Decomposes an epic into a draft set of vertical-slice user stories with measurable Done Definitions tied to epic Success Criteria. Reads the epic, reconciliation results, and any external-dependency stories already created, then returns the new-story drafts needed to cover the epic's outcomes. Read-

• task-decomposer

  Decomposes a user story plus its selected implementation approach into an atomic, TDD-driven task list. Each task carries a Story DD Coverage block, Given/When/Then test approach, full Acceptance Criteria from the AC library, retry budget, and dependency edges. Partitions story DDs so every DD is ow

• ui-designer

  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.

• verification-remediation-planner

  Classifies completion-verifier failures via a deterministic 4-branch ordered decision tree and emits a structured remediation directive. Requires opus for multi-document reasoning across verifier artifacts, ticket hierarchy, and scope boundaries.

• visual-evaluator

  Evaluates rendered UI screenshots against design manifests, emitting structured JSON findings with pixel-observable spatial quality scores and attribution class routing.

Hooks (15)

• SessionStart

  ${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.sh dispatchers/session-start.sh

• PreToolUse

  ${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.sh dispatchers/pre-bash.sh

• PreToolUse

  ${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.sh dispatchers/pre-edit.sh

• PreToolUse

  ${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.sh dispatchers/pre-write.sh

• PreToolUse

  ${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.sh dispatchers/pre-enterplanmode.sh

• PreToolUse

  ${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.sh dispatchers/pre-exitplanmode.sh

• PreToolUse

  ${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.sh dispatchers/pre-taskoutput.sh

• PostToolUse

  ${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.sh dispatchers/post-bash.sh

• PostToolUse

  ${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.sh dispatchers/post-edit.sh

• PostToolUse

  ${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.sh dispatchers/post-write.sh

• PostToolUse

  ${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.sh dispatchers/post-agent.sh

• PostToolUse

  ${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.sh dispatchers/post-skill.sh

• Stop

  ${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.sh dispatchers/stop.sh

• PostToolUseFailure

  ${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.sh dispatchers/post-failure.sh

• UserPromptSubmit

  ${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.sh fix-bug-skill-directive.sh