ai-dev-pipeline

Show current git status summary.

Show tasks from the current implementation plan.

Revert a merged PR or commit. Creates a revert PR for review.

Show status of active orchestrators and workflows.

Use this orchestrator for architecture analysis and design workflows. It coordinates codebase exploration (spawning multiple architecture-analysts in parallel), AI consensus on decisions, and documentation. Supports both "analyze existing" and "design new" modes with interactive checkpoints.

Use this orchestrator to coordinate implementation from plan to completion. It spawns task-decomposer, task-implementer, and pr-review-manager to handle the full implementation lifecycle with interactive checkpoints for human oversight.

Use this orchestrator for the complete PR review lifecycle. It coordinates code review, documentation, implementation of fixes, and merge. Spawns code-reviewer, doc-writer, task-implementer, and git-operator as sub-agents. Provides interactive checkpoints for human oversight at key decision points.

Use this agent for deep codebase exploration and architecture analysis. This specialist analyzes structure, patterns, and integration points. Can be spawned multiple times in parallel with different focus areas. Returns structured findings for the orchestrator to synthesize.

Use this agent for deep code review of pull requests using PAL integration. This specialist fetches PR data from GitHub, runs comprehensive code analysis, and returns structured findings with severity categorization. Spawned by orchestrators - returns findings for doc-writer to create review documents.

Use this agent when you need systematic debugging of code issues, mysterious errors, race conditions, or any problem requiring rigorous root cause analysis. This agent excels at methodical investigation with full documentation. Examples: <example> Context: User encounters an unexpected error in their application. user: "I'm getting a KeyError when calling process_data() but the key should exist" assistant: "This requires systematic debugging to identify the root cause. Let me use the debug-analyst agent to investigate." <Task tool launched with debug-analyst> </example> <example> Context: User has a race condition or intermittent failure. user: "My tests fail randomly about 20% of the time with a timeout" assistant: "Intermittent failures require careful analysis. I'll launch the debug-analyst agent to systematically investigate this." <Task tool launched with debug-analyst> </example> <example> Context: User has written code that produces incorrect output. user: "This sorting function returns wrong results for some inputs" assistant: "I'll use the debug-analyst agent to trace through the logic and identify where the algorithm fails." <Task tool launched with debug-analyst> </example> <example> Context: After implementing a feature, unexpected behavior occurs. assistant: "The feature is implemented, but I notice unexpected behavior in edge cases. Let me launch the debug-analyst agent to investigate systematically before proceeding." <Task tool launched with debug-analyst> </example>

Use this agent when you need to create detailed implementation plans from feature specifications or architecture reports. This includes converting product requirements into actionable developer documentation, breaking down complex features into implementable tasks, creating step-by-step technical guides for new functionality, or translating architecture decisions into concrete implementation steps. The agent excels at producing clear, concise, and immediately actionable implementation documentation. Examples: <example> Context: The user has received a feature specification and needs implementation documentation. user: "Here's the architecture report for our new authentication system. Can you create an implementation plan?" assistant: "I'll use the implementation-planner agent to create a comprehensive implementation plan from this architecture report." <Task tool invocation to launch implementation-planner agent> </example> <example> Context: The user has completed a design phase and needs to move to implementation. user: "We've finished designing the payment processing feature. I need implementation docs for the team." assistant: "Let me invoke the implementation-planner agent to transform your payment processing design into ready-to-implement documentation." <Task tool invocation to launch implementation-planner agent> </example> <example> Context: The user shares a product feature document. user: "Here's the PRD for our new notification system with real-time updates and user preferences." assistant: "I'll use the implementation-planner agent to break this down into actionable implementation plans that your developers can follow." <Task tool invocation to launch implementation-planner agent> </example>

Use this agent when you need to structure, organize, and decompose complex analysis reports, bugfix lists, or feature implementation tasks into an actionable implementation plan. This agent excels at reading comprehensive reports containing multiple interconnected tasks, analyzing dependencies between them, determining optimal implementation order, and creating structured documentation with specific code change guidance. Examples: <example> Context: User has received a large analysis report with multiple issues to fix. user: "I have this CONTEXTMAN-ANALYSIS-REPORT.md with about 15 different issues. Can you help me organize these into a workable plan?" assistant: "I'll use the task-decomposer agent to analyze the report, identify task dependencies, and create a structured implementation plan." <commentary> Since the user has a complex analysis report with multiple tasks that need organization and structuring, use the Task tool to launch the task-decomposer agent to create an ordered implementation plan. </commentary> </example> <example> Context: User is working through a code review that identified numerous changes needed. user: "The security audit found 20 different vulnerabilities across the codebase. I need help figuring out what order to fix them in." assistant: "Let me invoke the task-decomposer agent to analyze the security audit findings, group related vulnerabilities, and create prioritized fix documentation." <commentary> The user has a complex set of interrelated fixes from a security audit. Use the task-decomposer agent to structure these into an organized implementation plan with proper dependency ordering. </commentary> </example> <example> Context: User has a feature specification with multiple components. user: "Here's our feature spec for the new authentication system. It has database changes, API endpoints, UI components, and tests all mixed together." assistant: "I'll launch the task-decomposer agent to untangle these components, identify implementation dependencies, and create a structured task breakdown with implementation guidance." <commentary> The user needs help decomposing a complex feature into implementable chunks with proper ordering. Use the task-decomposer agent to analyze and structure the work. </commentary> </example>

Use this agent for comprehensive test execution, coverage analysis, and test failure debugging. This specialist runs test suites, analyzes results, and provides actionable insights for failing tests.

Use this agent to create ALL structured documentation files. This worker standardizes document creation including review summaries, implementation plans, architecture reports, and index updates. It follows templates, checks for existing files, and maintains consistency. Spawned by orchestrators - never create documentation files directly.

Use this agent for ALL git operations. This worker centralizes git safety with mandatory gates that cannot be bypassed. It handles pre-flight checks, stash management, branch operations, commits, pushes, and merges. Spawned by orchestrators and other agents - never run git commands directly.

Use this agent when you have a well-defined single task from the task-decomposer agent that needs to be implemented. This includes creating the feature branch, writing the implementation code, creating comprehensive tests, committing the work, pushing to origin, and opening a pull request. Spawns git-operator for all git operations.

Interactive checkpoint format for orchestrator pause points

Error handling patterns and recovery protocols for agents

Git safety rules and mandatory gates for all git operations

Pre-flight verification for PAL MCP server availability

Standard templates for debugging reports, reviews, and implementation plans