development-advanced-team

Consumes a Sprint Plan slice (one epic or feature) + the governing ADR Y-statement + a Spec slice, and produces ticket design — objective, hard dependencies, acceptance criteria, complexity, and US-### back-refs — for AI-ready tickets. Owns per-sprint design; writes NO design-doc file. <example> Context: /sprint-tickets assigns each epic to a separate code-architect agent in parallel user: Create tickets for the auth login sequence epic agent: Reads the Sprint Plan slice, the touched-module Spec sections, and the governing ADR Y-statement, then produces ticket-sized units with an objective, hard dependencies, acceptance criteria, and US-### back-refs </example> <example> Context: /sprint-tickets needs detailed implementation design for a complex feature user: Design the environment checking system from the Sprint Plan agent: Identifies natural ticket boundaries, maps the hard-dependency graph, and produces S/M/L complexity estimates for each unit of work — returning the design in findings, not a file </example>

Reviews PR diffs for bugs, logic errors, missing error handling, and pattern violations. Always runs on every review as part of the always-on specialist floor; findings feed a downstream arbiter that assigns the binding score. <example> Context: /sprint-review always dispatches this agent in the parallel specialist batch as the core quality gate user: Review PR #42 agent: Scans the diff for null access, race conditions, missing error handling, and pattern violations, reporting each with file:line evidence, a fix suggestion, and an honest self-assessed confidence for the arbiter </example> <example> Context: A PR adds async code with potential unhandled rejections user: Review this PR that adds the install orchestrator agent: Finds a fire-and-forget async call missing await and an overly broad catch block, reports both with impact analysis and calibrated confidence </example>

Finds opportunities to simplify code without changing behavior. Reduces nesting, eliminates redundancy, improves readability. Always runs, in parallel with other reviewers. <example> Context: /sprint-review dispatches this agent in the parallel specialist batch user: Review PR #42 agent: Finds a 4-level nested conditional that can be flattened with early returns, and a wrapper function that just passes arguments through unchanged </example> <example> Context: A PR adds verbose async handling that could be simplified user: Review this PR that adds the auth login sequence agent: Identifies callback nesting that could use async/await and three duplicate error formatting blocks that should be a shared helper </example>

Explores a specific aspect of the project's codebase — architecture, patterns, or integration points. Reports findings back to the main model for synthesis. <example> Context: /sprint-plan needs to understand how the project is structured before writing a Sprint Plan user: Plan a new notifications feature agent: Explores module boundaries, entry points, and existing UI/data patterns, then reports file paths and architectural findings </example> <example> Context: /sprint-tickets re-explores the codebase after reading the Sprint Plan to gather fresh implementation context user: Create tickets from the latest Sprint Plan agent: Explores relevant modules and patterns so code-architect agents have accurate codebase context for designing tickets </example>

Checks whether code comments match the actual code. Finds comment rot, misleading docs, and outdated explanations. Runs when changed files contain code comments. <example> Context: /sprint-review detects that changed files contain JSDoc or inline comments user: Review PR #42 agent: Compares each comment in the diff against the actual code behavior, flagging stale parameter descriptions and misleading algorithm explanations </example> <example> Context: A function was refactored but its doc comment still describes the old behavior user: Review this PR that refactors the auth flow agent: Finds that the @returns annotation says 'token string' but the function now returns a Result object, and flags the mismatch </example>

Implements the sprint's tickets wave by wave — worktree-isolated implementers write files and self-verify, the session snapshots each workspace and folds one atomic commit per ticket in jj — then partitions the integration chain into divided PR chain(s), publishes, opens draft PRs, and retires the sprint's issues. Use when the user says 'start coding', 'implement this', 'build the tickets', or 'start building' — normally after /sprint-tickets has pinned a build-order; ticket numbers may be passed directly when no pin exists.

Create a Sprint Plan, capture ADRs, and write or update the living Brief and Stories through guided discovery, codebase exploration, and architecture discussion. Use when user has an idea for what to build, says 'I want to build', 'let's plan', 'I have a project idea', wants to start a new sprint, or wants to resume an unfinished sprint plan.

Refines and lands the sprint's PR(s), per PR — fixes the published review findings via worktree-isolated fix agents, patches the system .spec through spec-writer, then lands each PR on the trunk by rebase + fast-forward (never a merge); a conflicted land parks for a paired session while everything else continues; closes the sprint once all PRs have landed. Runs on jj (colocated git) + GitHub via gh. Use when PR(s) carry needs-refine, or the user says 'fix these', 'address the review', 'refine the sprint', 'land the sprint', 'merge the PRs', 'ship it', 'close out the sprint', 'update the spec', or has reviewed PRs awaiting fixes and landing.

Reviews the sprint's open PR(s) with a specialist agent roster and publishes scored findings — one Opus arbitration assigns a binding 0–100 score and testable tag per finding, then each PR gets a ### Code Review comment and the needs-refine label. Runs on jj (colocated git) + GitHub via gh. Use when PR(s) carry needs-review, or the user says 'review my code', 'check this PR', 'review the sprint', 'code review', or 'is this ready'.

Turns an approved sprint plan into AI-ready GitHub Issues plus a pinned build-order issue — hard-dependency wave analysis, PR grouping by coupling, and real provision/verify commands. Writes to GitHub via gh, with one human gate before any forge write. Use when the user has an approved sprint plan that needs implementation planning, or says 'break this down', 'create issues', 'make tickets', or 'turn this into tasks'.

2 hooks across 2 events