minions

Launch a Cursor-inspired development workflow with parallel sub-scouts, per-task commits, and a single judge

Launch a 4-phase development workflow with personality-driven agents and loop-back issue resolution

Launch a review-fix iteration workflow that reviews code, fixes all issues (LOW/MEDIUM/HIGH), and iterates up to 5 times with early termination when review finds zero issues

Superlaunch — Claude-only 15-phase thorough pipeline with minions agents and minions hooks

Analyzes existing codebase patterns and conventions, provides architecture blueprint with component designs and data flows.

Analyzes explore findings and determines implementation approach with trade-offs. Use proactively after codebase exploration to evaluate strategies before planning.

Task implementer for /minions:launch workflow. Implements a single task from scout's plan in complete isolation. One task, one agent, fresh context. No git access. Use this agent for Phase F2 of the minions workflow. One builder is spawned per task, run in parallel. <example> Context: Scout planned 4 tasks, builder gets task 2 user: "Execute task 2: Add user model with validation" assistant: "Spawning builder to implement the user model task" <commentary> Single task from the plan. Builder implements exactly what's specified, self-verifies, logs out-of-scope findings. </commentary> </example>

Reviews session for learnings and updates CLAUDE.md with concise context for future sessions.

Use proactively to review plans, implementation, tests, and final output using Claude reasoning (no Codex MCP)

Correctness reviewer for /minions:launch workflow. Reviews code for bugs, logic errors, security vulnerabilities, and missing error handling. READ-ONLY — does not modify files. Use this agent for Phase F3 of the minions workflow. Runs in parallel with pedant and witness. <example> Context: Builder completed all tasks, code needs correctness review user: "Review the implementation for bugs and security issues" assistant: "Spawning critic to review code correctness" <commentary> F3 phase. Critic finds things that break — bugs, security holes, missing error handling. </commentary> </example>

Task implementer with per-task commits for /minions:cursor workflow. Implements a single task and commits to feature branch. One task, one agent, one commit. Use this agent for Phase C2 and C2.5 of the cursor pipeline. One cursor-builder is spawned per task, run in parallel. <example> Context: Sub-scouts planned 4 tasks, cursor-builder gets task 2 user: "Execute task 2: Add user model with validation" assistant: "Spawning cursor-builder to implement the user model task" <commentary> Single task from the plan. Cursor-builder implements exactly what's specified, commits the change, self-verifies, logs out-of-scope findings. </commentary> </example>

Deep architecture tracing — execution paths, layer mapping, dependency analysis. Complements breadth-first explorer agents.

Updates documentation to reflect implemented changes. Use proactively after implementation to keep docs in sync.

Aggregates parallel explorer outputs into a single exploration report. Use after all explorer and deep-explorer agents have written their temp files.

Fast architecture explorer for /minions:launch workflow. Traces imports, dependencies, module boundaries, and architectural layers to provide pre-scout context. Uses haiku model for speed. Use this agent for pre-F1 exploration. Runs in parallel with other explorers to build context before scout plans. <example> Context: User launched minions, need to understand architecture before planning user: "Trace the architecture and dependency structure of this codebase" assistant: "Spawning explorer-architecture to map modules and dependencies" <commentary> Pre-scout phase. Explorer-architecture traces imports, module boundaries, and layers so scout understands how the system fits together. </commentary> </example>

Fast codebase structure explorer for /minions:launch workflow. Maps file structure, directory layout, naming conventions, and project organization to provide pre-scout context. Uses haiku model for speed. Use this agent for pre-F1 exploration. Runs in parallel with other explorers to build context before scout plans. <example> Context: User launched minions, need to understand project structure before planning user: "Explore the file structure and organization of this codebase" assistant: "Spawning explorer-files to map the project layout" <commentary> Pre-scout phase. Explorer-files quickly maps directories, naming conventions, config files, and entry points so scout has context. </commentary> </example>

Fast coding patterns explorer for /minions:launch workflow. Finds related implementations, coding conventions, error handling patterns, and shared utilities to provide pre-scout context. Uses haiku model for speed. Use this agent for pre-F1 exploration. Runs in parallel with other explorers to build context before scout plans. <example> Context: User launched minions, need to understand coding conventions before planning user: "Find coding patterns and conventions relevant to this task" assistant: "Spawning explorer-patterns to identify conventions and related code" <commentary> Pre-scout phase. Explorer-patterns finds related implementations and conventions so builder agents produce code that fits the codebase. </commentary> </example>

Fast test conventions explorer for /minions:launch workflow. Maps test frameworks, patterns, coverage configuration, and existing test files to provide pre-scout context. Uses haiku model for speed. Use this agent for pre-F1 exploration. Runs in parallel with other explorers to build context before scout plans. <example> Context: User launched minions, need to understand test setup before planning user: "Explore the test conventions and framework in this codebase" assistant: "Spawning explorer-tests to map test patterns and configuration" <commentary> Pre-scout phase. Explorer-tests finds test frameworks, patterns, and conventions so builder agents write tests that fit the project. </commentary> </example>

Use proactively to explore codebase structure, find patterns, and gather context before planning - dispatched as parallel batch (1-10 agents)

Analyzes test/lint failures, identifies root causes, and applies fixes. Use proactively when test results contain failures.

Comprehensive final review of the entire implementation before completion — used in superlaunch Phase S13

Deep code review of implementation for correctness, security, and architecture — used in superlaunch Phase S6

Continuation judge for /minions:cursor workflow. Evaluates implementation, decides: approve, fix, or replan. Single agent replaces multi-reviewer panel. Use this agent for Phase C3 of the cursor pipeline. Dispatched once per loop. <example> Context: Cursor-builders completed all tasks, code needs comprehensive review user: "Evaluate the implementation and decide: approve, fix, or replan" assistant: "Spawning judge to evaluate the implementation" <commentary> C3 phase. Judge combines correctness, quality, runtime, security, and error handling review into a single verdict. </commentary> </example>

Holistic judgment reviewer for /minions:launch and /minions:superlaunch workflows. Evaluates correctness, quality, runtime behavior, security, and error handling in one pass, then returns launch-compatible review JSON. Use this agent in launch Phase F3 and as a supplementary reviewer in superlaunch review phases. <example> Context: implementation is complete and needs one consolidated judgment pass user: "Run a holistic judgment review" assistant: "Spawning judgement-agent for consolidated review" <commentary> Reviews across dimensions, flags issues with evidence, and returns clean/issues_found verdict. </commentary> </example>

Quality reviewer for /minions:launch workflow. Reviews code for naming, style, unnecessary complexity, test coverage gaps, and comment accuracy. READ-ONLY — does not modify files. Use this agent for Phase F3 of the minions workflow. Runs in parallel with critic and witness. <example> Context: Builder completed all tasks, code needs quality review user: "Review the implementation for code quality" assistant: "Spawning pedant to review code quality and style" <commentary> F3 phase. Pedant finds things that rot — bad naming, unnecessary complexity, missing tests. </commentary> </example>

Aggregates parallel planner outputs and architecture blueprint into a unified implementation plan. Use after all planner and architecture-analyst agents have written their temp files.

Reviews implementation plans for completeness, feasibility, and risk — used in superlaunch Phase S3

Creates detailed implementation plans with task decomposition. Use proactively to break down brainstorm results into executable tasks - dispatched as parallel batch (1-10 agents).

Analyzes workflow metrics after completion — restart history, fix attempts, coverage loops — and writes project-specific learnings to CLAUDE.md

Fix agent for /minions:review workflow. Reads review issues from the current iteration's R1 output files and applies targeted fixes using Edit/Write. Dispatched during Phase R2. Fixes ALL severities (critical, warning, info). Use this agent for Phase R2 of the minions review pipeline. One review-fixer runs per iteration. <example> Context: 5 review agents found issues in iteration 1, fixes needed user: "Fix all review issues from iteration 1" assistant: "Spawning review-fixer to apply targeted fixes" <commentary> R2 phase. Review-fixer reads all r1-*.json files, extracts issues, and applies fixes directly. </commentary> </example>

Planning agent for /minions:launch workflow. Explores the codebase, brainstorms approaches, and writes a structured implementation plan with a task table. READ-ONLY — does not modify files. Use this agent for Phase F1 of the minions workflow. Dispatched at the start of each loop. <example> Context: User launched minions to add authentication user: "Execute F1: Scout the codebase and write a plan" assistant: "Spawning scout to explore and plan the authentication implementation" <commentary> First phase. Scout maps the codebase, brainstorms approaches, writes a plan with tasks and acceptance criteria. </commentary> </example>

Deep security reviewer for /minions:launch workflow. Reviews code for OWASP top 10 vulnerabilities, access control flaws, injection attacks, cryptographic weaknesses, and secret exposure. READ-ONLY — does not modify files. Use this agent for Phase F3 of the minions workflow. Runs in parallel with critic, pedant, witness, and silent-failure-hunter. <example> Context: Builder completed all tasks, code needs deep security review user: "Review the implementation for security vulnerabilities" assistant: "Spawning security-reviewer to perform deep security analysis" <commentary> F3 phase. Security-reviewer goes deep on security — OWASP top 10, injection, access control, secrets. Goes beyond critic's superficial security checks. </commentary> </example>

Completion agent for /minions:launch workflow. Updates documentation, creates git commit, and opens a PR. Only runs when F3 produces a clean verdict. Use this agent for Phase F4 of the minions workflow. Runs once after all reviewers approve. <example> Context: All F3 reviewers gave clean verdict, time to ship user: "Ship the implementation — update docs, commit, and open PR" assistant: "Spawning shipper to finalize and deliver" <commentary> F4 phase. Shipper updates docs, creates a clean commit, and opens a PR. Finish line. </commentary> </example>

Silent failure hunter for /minions:launch workflow. Finds silently swallowed errors, empty catch blocks, catch-and-log-only patterns, overly broad catches, silent null returns, and missing async error handling. READ-ONLY — does not modify files. Use this agent for Phase F3 of the minions workflow. Runs in parallel with critic, pedant, witness, and security-reviewer. <example> Context: Builder completed all tasks, code needs error handling review user: "Review the implementation for silently swallowed errors" assistant: "Spawning silent-failure-hunter to find error handling gaps" <commentary> F3 phase. Silent-failure-hunter finds errors that are caught but not properly handled — the invisible bugs that don't crash but silently corrupt. </commentary> </example>

Reviews implemented code for simplification opportunities and applies improvements. Use proactively after implementation to reduce complexity.

Domain-specific parallel planner for /minions:cursor workflow. Plans one area of a larger task. Multiple sub-scouts run in parallel for recursive planning. Use this agent for Phase C1 of the cursor pipeline. 2-3 sub-scouts are dispatched in parallel, each assigned a domain. <example> Context: User launched cursor workflow, task spans backend and frontend user: "Plan the backend API portion of this task" assistant: "Spawning sub-scout to plan the backend domain" <commentary> C1 phase. Sub-scout plans only its assigned domain. Orchestrator aggregates all sub-scout plans into a unified c1-plan.md. </commentary> </example>

Task executor for superlaunch implementation — reads codebase, writes code, writes tests, simplifies. Dispatched per-task during Phase S4.

Reviews newly developed test code for correctness and coverage quality — used in superlaunch Phase S10

Writes tests and CI configuration iteratively until coverage threshold is met. Use proactively after initial test run reveals coverage gaps.

Reviews overall test coverage and determines if coverage is sufficient — used in superlaunch Phase S11

Analyzes type design quality — encapsulation, invariant expression, type safety.

Runtime verification agent for /minions:launch workflow. Runs code, curls endpoints, captures output, and observes behavior. Tests passing is NOT enough — witness must SEE the code work. Use this agent for Phase F3 of the minions workflow. Runs in parallel with critic and pedant. <example> Context: Builder completed a web API, need to verify it actually works user: "Verify the implementation actually runs correctly" assistant: "Spawning witness to run the code and observe its behavior" <commentary> F3 phase. Witness doesn't trust assertions — it runs the code, curls endpoints, captures output as evidence. </commentary> </example>

Review-fix iteration loop -- dispatches review agents then review-fixer, iterating up to 5 times with early termination on zero issues

Claude-only 15-phase thorough pipeline — dispatches minions agents through minions hooks

Ralph-style orchestrator loop — dispatches each phase as a subagent, hooks enforce progression

5 hooks across 4 events