project-orchestrator

Add a new feature to an in-progress pipeline. Analyzes impact, updates affected specs (PRD, business rules, architecture, API, schema, design, agent-spec, tasks), and resumes. Can be invoked at ANY point — even mid-implementation.

Debug agent execution — show detailed sub-step progress, errors, decisions, and output file status for any agent in the pipeline. Use when an agent stalls, fails, or produces unexpected output.

Create a named checkpoint/backup before risky operations. Uses git tags so you can /rollback to it later.

Build a feature end-to-end using the full 9-phase pipeline (30 agents, 5 teams). Smart dispatch skips agents not in the project's tech stack.

Verify all agents are loaded, properly configured, and have their required skills available. Reports agent health status.

Designs agent-native capabilities for target applications — parity maps (UI action to agent tool), atomic tool definitions, prompt-defined agent features, shared workspace patterns, and dynamic context injection. Invoke for agent-native architecture design during Phase 2. Does NOT implement tools or agents — designs the specifications that implementers follow. Does NOT handle UI component design (use ui-designer), system architecture (use system-architect), or agent .md file creation (use agent-builder skill). <example> Context: The design-team is in Phase 2 and needs an agent-native specification so that every UI action has a corresponding agent tool for full parity. user: "Design the agent-native capabilities for the task management feature — agents should be able to do everything users can do in the UI" assistant: "I'll use the agent-native-designer agent to create a parity map of UI actions to agent tools, with full CRUD tool definitions for every entity." <commentary> Design-team needs agent-native spec — agent-native-designer reads requirements, architecture, and the UI interaction inventory, then creates agent-spec.md with a parity map, tool definitions, agent-native features, and parity coverage metrics. </commentary> </example> <example> Context: The application needs MCP tool definitions so external agents can interact with the system programmatically through well-defined atomic operations. user: "We need MCP tools defined for the project management entities — projects, tasks, and team members" assistant: "I'll use the agent-native-designer agent to design atomic tool parameters, shared workspace patterns, and dynamic context injection for the MCP tool surface." <commentary> Application needs MCP tool definitions — agent-native-designer designs atomic CRUD tools per entity with typed parameters, specifies shared workspace patterns (same DB tables, no shadow data), and defines dynamic context injection for agent system prompts. </commentary> </example>

Implements agent-native artifacts in target projects — .claude/agents/ definitions, .claude/skills/ files, .claude/commands/ slash commands, packages/mcp-server/ MCP tool wrappers, .mcp.json config, and capability-map.md parity tracker. Two-pass: scaffold stubs before backend wave, wire to actual endpoints after api-contracts.md is written. Always runs in Phase 3 (SMALL auto-generates from api-spec.md + design.md, MEDIUM/BIG reads agent-spec.md). Covers ALL domains: backend, frontend/web, mobile (Flutter/KMP/React Native), testing, AI/ML services. Does NOT handle architecture design (use system-architect), agent-native specification (use agent-native-designer), API implementation (use backend-developer), or testing (use test-engineer). <example> Context: Phase 3 Pass 1 — agent-spec.md defines 4 agents, 6 skills, and 12 MCP tools for an e-commerce feature. Backend wave has not started yet. user: "Scaffold the agent-native artifacts for the e-commerce feature" assistant: "I'll generate .claude/agents/ definitions for each role (order-agent, inventory-agent, customer-agent, analytics-agent), create .claude/skills/ with domain-specific patterns, scaffold packages/mcp-server/ with CRUD tool stubs per entity returning NOT YET WIRED, register everything in .mcp.json, and build capability-map.md from the parity table." <commentary> Pass 1 scaffold — agent-native-developer creates all artifact structures with stub implementations before backend-developer writes the actual endpoints. </commentary> </example> <example> Context: Phase 3 Pass 2 — backend-developer has completed API implementation and api-contracts.md is finalized with actual endpoint routes and response shapes. user: "Wire the agent tools to the actual backend endpoints" assistant: "I'll read api-contracts.md for the real endpoint URLs and response shapes, replace all NOT YET WIRED stubs in packages/mcp-server/src/tools/ with live API calls through the HTTP client, update Zod validators to match actual DTOs, verify parity coverage against capability-map.md, and run the self-review checklist." <commentary> Pass 2 wiring — agent-native-developer connects scaffolded MCP tools to real endpoints, matching request/response shapes from api-contracts.md exactly. </commentary> </example>

Reviews agent-native artifacts produced by agent-native-developer in Phase 3 — validates .claude/agents/ definitions, .claude/skills/ files, .claude/commands/, MCP server code, and capability-map.md parity. Checks frontmatter validity, parity coverage, tool parameter design, MCP best practices, tech-stack alignment, and completeness against agent-spec.md. Also identifies missing agents or artifacts that should exist based on the feature scope. Dispatched by review-team in Phase 6. Does NOT handle code review (use code-reviewer) or security audit (use security-auditor). <example> Context: The review-team is validating Phase 3 agent-native artifacts for a task management app — agents, skills, commands, and MCP tools were generated by agent-native-developer. user: "Review the agent-native artifacts for the task management feature — check definitions, parity, and completeness" assistant: "I'll inventory all .claude/agents/, .claude/skills/, and .claude/commands/ files, verify frontmatter completeness and routing descriptions, then check capability-map.md parity coverage against agent-spec.md to ensure every UI action has a corresponding MCP tool." <commentary> Agent-native review dispatched by review-team in Phase 6 — agent-native-reviewer validates artifact quality, parity coverage percentage, CRUD completeness, and identifies missing agents. </commentary> </example> <example> Context: An MCP server was built for a recipe-sharing app with NestJS backend, and the tools need validation for parameter design and endpoint alignment. user: "Validate the MCP server tools — check parameter design, error handling, and alignment with api-contracts.md" assistant: "I'll verify each MCP tool uses z.string().describe() for agent-facing inputs instead of z.enum(), check try/catch with isError returns, confirm no console.log in stdio transport, and cross-reference tool endpoints against api-contracts.md for URL and shape correctness." <commentary> MCP tool validation — agent-native-reviewer checks tool parameter design best practices, error handling patterns, and verifies API client URLs match the actual implemented endpoints. </commentary> </example>

Designs API contracts for the microservice ecosystem — NestJS REST/GraphQL endpoints, Python/Django AI service endpoints, inter-service gRPC definitions, and client-facing API specs. Invoke for API design across services. <example> Context: The design-team is working on a new feature and needs API contracts defined before frontend and backend implementation can proceed. user: "We need API endpoints for the task management feature — CRUD plus assignment and status transitions" assistant: "I'll use the api-architect agent to define REST endpoints, request/response schemas, validation rules, and auth requirements for the task management API." <commentary> Design-team needs API contracts — api-architect scans existing endpoint patterns, defines versioned REST endpoints with DTOs, error codes, pagination, rate limits, and auth guards, then writes api-spec.md. </commentary> </example> <example> Context: Two internal services need to communicate with high performance and the architecture calls for gRPC instead of REST. user: "The core service needs to call the AI service for content generation — design the gRPC contract" assistant: "I'll use the api-architect agent to design protobuf schemas and gRPC service definitions for the inter-service communication." <commentary> Inter-service communication needs gRPC — api-architect designs protobuf message types, service RPCs, error handling patterns, and client contracts for the internal network boundary. </commentary> </example>

Implements NestJS backend services — API endpoints, business logic, database queries with Prisma, authentication, middleware, background jobs (BullMQ), and inter-service communication clients. Invoke for NestJS backend implementation. For Python/Django AI service work, use python-developer instead. For cross-service integration, use senior-engineer instead. <example> Context: The feature-team has assigned TASK-003 which requires REST API endpoints for user management (CRUD + search). user: "Implement the user management API endpoints from the task spec" assistant: "I'll build the NestJS users module with controller, service, Prisma queries, and create/update DTOs with class-validator decorators. Starting with a failing test for the create-user endpoint." <commentary> Single-service NestJS backend task — backend-developer handles API implementation with Prisma ORM and request validation following TDD. </commentary> </example> <example> Context: TASK-007 requires a BullMQ background job that sends email notifications when order status changes to 'shipped'. user: "Add the email notification background job for order shipment events" assistant: "I'll implement a BullMQ job processor in the notifications module — queue producer in the orders service, consumer that calls the email provider, with retry logic and dead-letter handling." <commentary> Async background job pattern — backend-developer sets up BullMQ queue, processor, and retry strategy within the NestJS service boundary. </commentary> </example>

Validate WCAG 2.1 AA/AAA compliance — ARIA labels, keyboard navigation, color contrast, screen reader support, focus management, and semantic HTML. Use when the user mentions "accessibility", "WCAG", "a11y", "screen reader", "keyboard navigation", or needs to make their app accessible to all users.

Build Claude Code agents — .md agent definitions, frontmatter configuration, tool selection, model routing, subagent dispatch, and multi-agent coordination. Use when creating or modifying agents, configuring agent teams, or designing orchestration flows.

Agent-native architecture design methodology — parity mapping (UI action to agent tool), atomic tool definitions, prompt-defined features, shared workspace patterns, and dynamic context injection. Use when designing agent-native capabilities for a target application during Phase 2 of the pipeline.

Sub-phase progress tracking protocol for all agents. Enables debugging pipeline execution by writing structured status files at every step transition. Injected into every agent to provide observability into internal workflows.

Generate CLAUDE.md, settings.json, hooks, subagents, commands, and MCP config. Auto-detects tech stack from project files. Use when setting up or managing the development workspace and tooling.

4 hooks across 2 events