nx

Analyze codebase using codebase-deep-analyzer agent

Design architecture and create phased execution plans using architect-planner agent

Create implementation plan using strategic-planner agent

Debug test failures using debugger agent

Thorough analysis of complex problems using deep-analyst agent

Enrich beads with execution context using plan-enricher agent

Implement feature using developer agent

Persist and organize knowledge into nx store using knowledge-tidier agent

Check that all nx plugin dependencies are correctly installed and configured

Index PDF files into nx store for semantic search using pdf-chromadb-processor agent

Audit a plan using plan-auditor agent

Accept a gated RDR — verifies gate PASSED in T2, updates status to accepted

Close an RDR with optional post-mortem, bead status gate, and T3 archival

Create a new RDR — scaffold from template, assign sequential ID, register in T2

Run finalization gate on an RDR — structural, assumption audit, and AI critique

List all RDRs with status, type, and priority

Add, track, or verify structured research findings for an active RDR

Show detailed information about a specific RDR including content, research findings, and linked beads

Research topic using deep-research-synthesizer agent

Review code changes using code-review-expert agent

Constructive critique of code, plans, designs, or documentation using substantive-critic agent

Validate tests using test-validator agent

This file documents the standard context exchange protocol used by all agents for consistent relays, context recovery, and knowledge management.

This file documents common error handling patterns for agents.

- **Context Protocol**: All agents reference `_shared/CONTEXT_PROTOCOL.md`

Conducts comprehensive research across nx knowledge store, memory, web resources, and code repositories. Use when needing multi-source research synthesis or building comprehensive understanding of new technologies.

Executes development tasks using test-first methodology including feature implementation and refactoring. Use proactively for implementing features from specifications or executing architectural plans.

Reviews and consolidates nx T3 knowledge and T2 memory for accuracy and consistency. Use after major research tasks or when contradicting information is discovered across documents.

Routes requests to appropriate specialized agents and manages multi-agent pipelines. Use when the task is ambiguous, when coordinating work across multiple agents, or when unsure which agent to invoke.

Indexes PDF files into nx T3 store for semantic search by delegating to nx index pdf. Use for any PDF that needs to be extracted and made semantically searchable.

Reviews and validates technical plans for accuracy, completeness, and codebase alignment. Use before implementing any plan — catches gaps and technical errors before they become bugs.

Enriches beads with execution context — file paths, code patterns, constraints, test commands, and (when available) audit findings. Use after plan-audit in RDR planning chain, or standalone for bead enrichment within the same session.

Decomposes analytical questions into step-by-step execution plans with operator references. Use when complex research questions need multi-step retrieval and analysis.

Creates phased TDD-driven implementation plans and decomposes complex work into tracked beads. Use for multi-phase feature planning, dependency management, breaking vague requirements into executable tasks, or iterating on existing plans.

Provides deep constructive critique of code, documentation, plans, and designs. Identifies structural flaws, logical inconsistencies, and unvalidated assumptions. Use when reviewing architectural decisions, validating implementations against specifications, or auditing plans before committing.

Verifies test coverage, runs test suites, and validates test quality for code changes. Use after implementation, before marking work complete, or when test failures need systematic root-cause analysis.

This directory contains shared resources used across multiple agents.

All agent dispatches follow this standardized structure. **Relays are constructed by the caller** (main conversation, skill, or orchestrator) — not by agents themselves. Subagents cannot spawn other subagents; they output "Recommended Next Step" blocks that the caller uses to build the next relay.

Executes analytical operations (extract, summarize, rank, compare, generate) on retrieved content. Use when multi-step queries need structured data processing over search results.

Designs comprehensive software architecture and creates phased execution plans for complex projects. Use when starting new features requiring architectural design or planning multi-phase implementations.

Reviews code for quality, security, and best practices. Use proactively after completing features or immediately after writing significant code changes.

Performs comprehensive codebase analysis including architecture patterns, dependencies, and technical debt. Use when onboarding to projects, before major refactoring, or for system-wide understanding.

Systematically investigates bugs, test failures, and performance issues using hypothesis-driven debugging. Use when encountering bugs after 2-3 failed fix attempts or facing non-deterministic failures.

Provides thorough analysis of complex problems and intricate system relationships. Use when investigating performance mysteries, debugging multi-component interactions, or understanding system behavior.

Use when complex features need architectural design before implementation, or when system design decisions span multiple modules

Use when about to implement any feature, build any component, or make any behavioral change — requires design exploration and user approval before implementation

Use when controlling interactive CLI applications, debugging with pdb/gdb/jshell, spawning Claude Code instances, or working with REPLs and long-running processes

Use when code changes are ready for quality, security, or best practices review, before committing or creating a pull request

Use when exploring an unfamiliar codebase, onboarding to a project, or needing to understand module structure before making changes

Use when tests fail, exceptions occur, or behavior is non-deterministic, especially after 2+ failed manual fix attempts

Use when surface-level analysis is insufficient and problems require hypothesis-driven investigation across multiple system components

Use when a plan has been approved and implementation work is ready to begin, before writing production code

Use when beads need enrichment with execution context, file paths, code patterns, constraints, and test commands. Audit findings incorporated when available.

Use when implementation is complete, all tests pass, and you need to decide how to integrate the work - guides completion of development work by presenting structured options for merge, PR, or cleanup

Use when starting feature work that needs isolation from current workspace or before executing implementation plans - creates isolated git worktrees with smart directory selection and safety verification

Use when validated findings, decisions, or patterns need to be persisted to nx T3 knowledge store for cross-session reuse

Use when running nx commands for search, memory, knowledge storage, or indexing — or when unsure which nx subcommand to use

Use when unsure which agent to use for a task, or when coordinating work across multiple agents in a pipeline

Use when PDF documents need to be indexed into nx store for semantic search

Use when a plan has been created and needs validation before implementation begins, or when reviewing an existing plan for gaps

Use when questions require multi-step retrieval and analysis (extract, summarize, rank, compare, generate) over nx knowledge collections with plan decomposition and reuse.

Use when a gated RDR returned PASSED and you want to officially accept it for implementation

Use when an RDR is done — close it with optional post-mortem, bead status gate, and T3 archival

Use when starting a new research-design-review document to think through a technical decision

Use when an RDR appears complete and needs finalization validation — structural, assumption, and AI critique checks

Use when needing to see all RDRs in the project with their status, type, and priority

Use when adding, tracking, or verifying structured research findings for an active RDR

Use when needing detailed information about a specific RDR including content, research findings, and linked beads

Use when receiving any code review feedback, before implementing any suggestion - requires technical rigor and verification, not performative agreement or blind implementation

Use when researching unfamiliar topics, comparing technology approaches, or building comprehensive understanding from multiple sources

Use when navigating code by symbol — finding definitions, all callers, type hierarchies, renaming safely, or editing a method body without reading the whole file. Use instead of Grep for any symbol-level task.

Use when facing multi-step development work that needs decomposition into tasks, before writing any implementation code

Use when architectural decisions, implementations, or documentation need deep constructive critique against specs or evidence

Use when implementation is complete and test coverage needs verification, before merge or pull request

Use when starting any conversation or task — establishes that nx skills must be checked before every response, including clarifying questions

Use when creating new nx plugin skills, editing existing skills, or verifying skill quality before committing

10 hooks across 7 events