nexus

Analyze code patterns, data flow, and modification risks for a feature. Complements context-builder by going deep, not wide.

Validate implementation plans against architecture rules and patterns.

Store, search, and retrieve team requirements from knowledge base

AWS architecture and infrastructure guidance. Use for infrastructure decisions, CloudFormation review, cost optimization, and multi-service design.

Analyze requirements and consolidate findings from other agents. Decision maker in requirements phase.

Single-pass code review focused on real issues. No subjective nitpicks. Includes performance analysis and investigation.

Build structured context inventory for requirements gathering. First agent in the requirements pipeline.

Analyze database schema, entities, and relationships for requirements gathering.

Execute database queries and analyze data patterns. Use when the user needs to query databases, explore schemas, analyze data distributions, or understand database relationships. Returns concise summaries and key findings.

Write technical and API documentation. Use for new features, undocumented code, or API endpoints.

Resolve merge conflicts, drive complex rebases, and author PR bodies from large commit ranges. Not used for routine commit/push/branch-create — those run inline via Bash under the `git-mutation-guard.sh` hook.

Analyze external API integrations and implement API clients. Use for requirements gathering and API implementation.

Write and maintain end-to-end tests using Playwright. Expert in locator strategies, test isolation, POM patterns, and cross-browser testing.

Provide context and guidance from a project's product knowledge base. Use when working on features that have product-specific documentation.

Contrarian challenger agent that independently verifies claims, refuses unsubstantiated assumptions, and forces other agents to produce evidence-backed, high-quality output.

Safe refactoring with verification, impact analysis, and progressive sessions

Security audit for code changes including PII/sensitive data scanning. Use for payment, auth, or sensitive data code. Use before commits.

Identify security and compliance requirements early in the requirements phase.

Diagnose and fix failing tests with root cause analysis. Detects flaky tests.

Write comprehensive unit and integration tests. Coverage-aware with framework-specific patterns.

Push a release branch and open a PR to the target branch. Step 2 of the release workflow — runs after branching, before merging.

Rebuild manifest.json for any artifact storage type. Scans directories and regenerates from scratch.

Rebuild search index for requirements repository

Add a new entry to the product knowledge base. Wizard-guided — prompts for category, title, and content, then writes a structured markdown file and rebuilds the manifest.

Manually archive completed requirements to team knowledge base

Explore implementation strategies for business requirements. Interactive brainstorming that presents multiple approaches, trade-offs, and creates high-level implementation picture before committing to detailed specs.

Stage and commit changes with a conventional commit message. Runs pre-commit checks automatically. Optionally prefixes with a ticket number.

Initialize project configuration file with interactive wizard. Also supports `validate` and `migrate` modes for existing installs.

Create a formal design document for a feature or component. Guides through requirements, approach brainstorming, and iterative proposal drafts with approval gate before optional implementation. Use when you need a written design approved before committing to code.

Create a release/vX.Y.Z branch from origin/master (default), any branch, or a specific tag using tag@vX.Y.Z syntax

Run a multi-agent pipeline to produce detailed technical requirements and a ticket-ready summary. Creates a feature branch, persists session state, and supports resume. Optionally seeds from a prior brainstorm session.

Decompose large initiatives into dependency-mapped, wave-sequenced tickets with per-ticket requirements. Use when a feature is too large for a single /create-requirements run — typically 5+ tickets with complex interdependencies.

Generate a retrospective report analyzing agent pipeline execution, duplication, scope adherence, and output quality from a completed work session.

Implement a feature from saved requirements. Chunk-based commits, parallel QA (tests + review + security), and PR creation. Resumes interrupted sessions from saved state. Runs in the current working tree by default — set `worktree.enabled: true` in `.claude/configuration.yml` to isolate work in a git worktree.

Load all available context for a ticket or topic — work state, brainstorms, proposals, requirements KB, product knowledge, and git history — into a single unified summary.

Load a specific archived requirement from the requirements KB for detailed review. For in-flight tickets that have not been archived yet, use /load-context instead — it also covers work sessions, brainstorms, and proposals.

Merge an approved release PR into its target branch. Validates approval/checks/conflicts via gh, then merges. Step 3 of the release workflow.

Monitor an open pull request — watch CI, investigate and fix failing workflows, address new review comments, and loop until the PR is approved, merged, or the iteration limit is reached.

Review a pull request (or local branch with --local) with thorough analysis, severity levels, and actionable feedback

Analyze code and suggest refactoring improvements with agent-driven analysis. Runs in the current working tree by default — set `worktree.enabled: true` in `.claude/configuration.yml` to isolate work in a git worktree.

Create a GitHub release with a version tag and LLM-authored release notes. Supports pre-releases. Final step of the release workflow.

Draft and submit a bug report or feature request to the nexus plugin repository, using current conversation context to auto-populate details.

Resume any interrupted work session — brainstorm, requirements, proposal, epic, or implementation. Scans for incomplete sessions and continues from the last saved checkpoint. Re-enters the original session's worktree if one was used; otherwise runs in the current working tree.

Validate an ad-hoc implementation plan through architect and quality-guard (and optionally security-auditor), then output a revised plan with adjustments applied.

Search team requirements repository for similar past work

List pending items from TODO.md, pick one, mark it In progress, and propose a hand-off to /review-plan or /implement.

Add a new item to the project TODO.md with priority, category, and scope through an interactive wizard.

Systematically troubleshoot a failing feature or error. Discovers code, investigates root cause, applies fix, verifies with tests, and commits. Use when something isn't working as expected. Runs in the current working tree by default — set `worktree.enabled: true` in `.claude/configuration.yml` to isolate work in a git worktree.

Annotate an active work session with a note, scope change, or new finding. Appends a timestamped entry to state.json and updates the manifest. Use mid-session when you learn something that should be preserved.

Review and update project documentation using an agent team. Inventories docs, identifies gaps and drift, updates technical and API docs in parallel.

Show all active work sessions across brainstorms, requirements, proposals, and epics. Supports --update to advance lifecycle on one session and --sync to sweep them all.

7 hooks across 3 events