ultrawork

**Used by**: `ultrawork.md`, `ultrawork-plan.md`

**Used by**: `ultrawork.md`, `ultrawork-plan.md`

**Used by**: `ultrawork-plan.md` (interactive mode only)

**Used by**: `ultrawork.md`, `ultrawork-exec.md`

**Used by**: `ultrawork.md`, `ultrawork-exec.md`

**Used by**: `ultrawork.md`, `ultrawork-exec.md`

This directory contains phase-based reference documentation following progressive disclosure patterns. Each phase file is reused by multiple commands to eliminate duplication.

**All scripts require `--session <id>` flag.**

Clean current ultrawork session or batch cleanup old sessions

Show collected evidence for ultrawork session

Execute ultrawork plan with automatic retry loop

Show ultrawork plugin help and available commands

Interactive planning phase - explore, clarify, design, then produce task breakdown

Interactive quiz on session learnings and discoveries

Check current ultrawork session status

Start ultrawork session with strict verification mode

Use this agent to create ADR from design documents and update permanent project docs after verification passes. Examples: <example> Context: Verifier returned PASS, session moving to COMPLETE. user: "Verification passed, finalize the design document" assistant: "I'll spawn the documenter agent to create an ADR and update permanent docs." <commentary>Documenter reads evidence and task results, creates ADR in docs/adr/, updates permanent docs, then deletes the plan document.</commentary> </example> <example> Context: All tasks resolved, verification complete. user: "Update the design doc with actual outcomes" assistant: "I'll spawn the documenter agent to convert the planning artifact into a permanent record." <commentary>Documenter creates ADR, enriches permanent docs (ARCHITECTURE.md, API.md, etc.), and removes the plan.</commentary> </example>

Use this agent for fast codebase exploration in ultrawork sessions. Gathers context, writes detailed findings to exploration/*.md, updates context.json summary. Examples: <example> Context: Ultrawork session started, need to understand the codebase before planning. user: "Start ultrawork for adding authentication to this project" assistant: "I'll spawn an explorer agent to analyze the codebase structure and existing patterns." <commentary>Explorer runs first to gather context about project type, tech stack, and existing patterns before planning.</commentary> </example> <example> Context: Planning phase needs specific information about a subsystem. user: "The planner needs to understand how the database layer works" assistant: "I'll spawn a targeted explorer to investigate the database implementation." <commentary>Targeted exploration for specific areas when overview is insufficient.</commentary> </example>

Use this agent for auto-mode planning in ultrawork sessions. Reads context from explorers, makes automatic decisions, creates task graph. Does NOT spawn sub-agents. Examples: <example> Context: Exploration phase complete, context.json and exploration/*.md files exist. user: "Exploration is done, now create the implementation plan" assistant: "I'll spawn the planner agent to analyze the gathered context and create a task graph." <commentary>Planner runs after explorers to design implementation based on discovered patterns.</commentary> </example> <example> Context: User wants ultrawork in auto mode without interaction. user: "Run ultrawork in auto mode for refactoring the database layer" assistant: "I'll spawn the planner agent to automatically create the task breakdown." <commentary>In auto mode, planner makes decisions without user confirmation.</commentary> </example>

**Minimize dependencies, maximize parallelism.**

Without clear criteria:

Each task does ONE thing well.

Use this agent for code review in ultrawork sessions. Reviews implementation for quality, correctness, and adherence to criteria. Examples: <example> Context: Worker completed a task implementation. user: "Review the authentication implementation before verification" assistant: "I'll spawn the reviewer agent to check code quality and correctness." <commentary>Reviewer performs deep verification: reads actual code, checks edge cases, detects security issues.</commentary> </example> <example> Context: Need quality check before marking task as complete. user: "Check if the payment processing code is production-ready" assistant: "I'll spawn the reviewer agent for thorough code review." <commentary>Reviewer uses evidence-based verification, never trusts claims without evidence.</commentary> </example>

Use this agent to analyze scope expansion during ultrawork planning. Detects cross-layer dependencies (FE↔BE↔DB↔Codegen) and suggests additional work beyond the user's explicit request. Examples: <example> Context: User requested backend API changes for a new field. user: "Add PPT options to Feed API" assistant: "I'll spawn a scope-analyzer to detect if frontend or database changes are also needed." <commentary>Scope analyzer detects that FE form and DB schema might need updates too.</commentary> </example> <example> Context: User requested frontend form update. user: "Add new settings to the user profile form" assistant: "I'll analyze if backend API changes are needed to support the new settings." <commentary>Scope analyzer detects that BE API doesn't have the fields yet.</commentary> </example>

Use this agent for verification phase in ultrawork sessions. Validates evidence, checks success criteria, scans for blocked patterns, runs final tests. Examples: <example> Context: All implementation tasks completed, ready for final verification. user: "Verify that all success criteria are met" assistant: "I'll spawn the verifier agent to audit evidence and run final tests." <commentary>Verifier is the quality gatekeeper with zero tolerance for speculation.</commentary> </example> <example> Context: Need to check if ultrawork session can be marked complete. user: "Check if we're ready to complete the ultrawork session" assistant: "I'll spawn the verifier agent to validate all criteria and scan for blocked patterns." <commentary>Verifier checks every criterion, runs verification commands, and makes PASS/FAIL determination.</commentary> </example>

Use this agent for executing implementation tasks in ultrawork sessions. Executes specific task, collects evidence, updates task file. Examples: <example> Context: Ultrawork session in EXECUTION phase with open tasks. user: "Execute the open tasks from the plan" assistant: "I'll spawn worker agents for each unblocked task to implement them." <commentary>Workers execute one task at a time, collecting concrete evidence for success criteria.</commentary> </example> <example> Context: A specific task needs to be implemented. user: "Implement task 3: Add user authentication middleware" assistant: "I'll spawn a worker agent to implement the authentication middleware." <commentary>Worker focuses on single task, makes surgical changes, and verifies with evidence.</commentary> </example>

Architecture design review skill for reviewer agents. Component boundaries, separation of concerns, modularity, and design pattern validation. Use during PLANNING phase to validate design decisions and VERIFICATION to ensure adherence.

API design, database operations, error handling, and backend architecture patterns. Use when creating APIs, database schemas, or server-side logic.

Code quality verification skill for reviewer agents. Provides checklists for logic clarity, error handling, maintainability, and performance. Use during VERIFICATION phase to assess implementation quality.

Code consistency and pattern adherence review skill. Naming conventions, style consistency, pattern usage, and project standards validation. Use during VERIFICATION to ensure codebase uniformity and maintainability.

This skill provides guidance on accessing session data efficiently in ultrawork. Covers JSON vs Markdown rules, token efficiency rationale, and common patterns. Required knowledge for all ultrawork agents (explorer, planner, worker, verifier, reviewer).

React component patterns, state management, accessibility, and frontend best practices. Use when building UI components or implementing client-side features.

This skill should be used when performing quick project overview exploration at the start of ultrawork sessions. Executes directly without agent spawn for fast codebase understanding.

This skill should be used when designing implementation plans, decomposing complex work into tasks, or making architectural decisions during ultrawork sessions. Used by orchestrator (interactive mode) and planner agent (auto mode).

This skill provides guidance for ultrawork agents on using SCRIPTS_PATH and accessing session data via scripts. Required knowledge for all ultrawork agents (explorer, planner, worker, verifier, reviewer, scope-analyzer).

Security best practices for authentication, input validation, OWASP patterns, and secure coding. Use when handling user input, auth, secrets, or sensitive data.

Security vulnerability detection skill for reviewer agents. OWASP Top 10 checklist, secrets detection, input validation, authentication patterns. CRITICAL for code handling user input, authentication, APIs, or sensitive data.

Test-Driven Development (TDD) workflow for ultrawork tasks with approach: "tdd". Enforces RED-GREEN-REFACTOR cycle with gate hooks and evidence requirements. Required knowledge for worker agents implementing TDD tasks.

Testing patterns for unit, integration, and E2E tests. Mock patterns for Supabase, Redis, OpenAI. Use when writing tests or setting up test infrastructure.

This skill should be used when the user has a large, complex task requiring: (1) multi-file or multi-step implementation, (2) major refactoring or architecture changes, (3) new feature spanning multiple components. This skill should NOT be used for simple fixes, single-file edits, or quick questions. Activates strict verification with planning, success criteria, and evidence collection.

Comprehensive guide for ultrawork agents on using session, task, and context management scripts. Covers all common script patterns with $SCRIPTS_PATH variable usage. Required for explorer, planner, worker, verifier, and reviewer agents.

11 hooks across 7 events