Agent skill
maestro:status
Interpret feature progress, detect problems, and recommend next actions based on maestro status output.
Install this agent skill to your Project
npx add-skill https://github.com/ReinaMacCredy/maestro/tree/main/.codex/skills/maestro:status
SKILL.md
Status -- Feature Progress & Next Actions
Overview
Read the current feature state and translate it into actionable guidance. Status is the orientation layer -- run it at session start, after completing work, or when uncertain about what to do next.
Core principle: Status is not a passive display. It is a diagnostic. Detect problems, highlight what needs attention, and tell the user exactly what command to run next.
When to Use
- Session start (always)
- After a task completes or fails
- When the user asks "what's next?" or "where are we?"
- Before starting any new work (to check for zombies, blockers, or stale state)
Step 1: Gather State
Run maestro status (or maestro status --feature <name> for a specific feature).
If no active feature is set:
- Report: "No active feature. Run
maestro feature-active <name>to set one, ormaestro feature-listto see available features." - If no features exist at all: "No features found. Run
maestro feature-create <name>to start." - Stop.
The status output contains these fields:
- feature: name and status (
planning|approved|executing|completed) - plan: exists (yes/no), approved (yes/no), comment count
- tasks: total, pending, in_progress, done counts, plus individual task list with statuses
- zombies: stale in_progress tasks where the session is missing or expired
- blocked: tasks blocked by unfinished dependencies
- context: file count and byte total for saved context
- nextAction: the system's recommended next step
Step 2: Identify the Feature Phase
Map the status output to one of four phases. This determines what to emphasize in the report.
| Feature Status | Plan | Tasks | Phase | Focus |
|---|---|---|---|---|
planning |
none | 0 | Discovery | Gathering requirements, exploring |
planning |
draft | 0 | Planning | Refining plan, addressing comments |
approved |
approved | 0 | Pre-Execution | Need to sync tasks from plan |
approved |
approved | >0 pending | Execution | Starting and running tasks |
executing |
approved | mixed | Execution | Active work in progress |
completed |
any | all done | Completion | Review and wrap-up |
Phase determines what sections to show:
- Discovery: Emphasize context files, suggest brainstorming or design skills, de-emphasize tasks (none exist).
- Planning: Emphasize plan status and comments. If comments exist, highlight them -- they may contain unresolved feedback.
- Pre-Execution: Single clear action: run
maestro task-sync. - Execution: Full task breakdown with progress, conditions, and next action. This is the most detailed phase.
- Completion: Brief summary. Show done count. Suggest
maestro feature-complete.
Step 3: Detect Conditions Requiring Attention
Scan the status output for these conditions. Each one requires a specific callout in the report.
| Condition | Detection Signal | Severity | Action |
|---|---|---|---|
| Zombie (stale task) | zombies list is non-empty |
High | maestro task-start --feature <f> --task <id> --force to recover |
| Blocked task | Task status is blocked |
High | Review blocker, then maestro task-start --task <id> --continue-from blocked --decision |
| Failed task | Task status is failed |
Medium | maestro task-update --feature <f> --task <id> --status pending to reset |
| Partial task | Task status is partial |
Medium | maestro task-start --feature <f> --task <id> --continue-from partial to resume |
| Unreviewed comments | plan.commentCount > 0 and plan is draft |
Medium | Read comments with maestro plan-read, address feedback, revise plan |
| No tasks synced | Plan approved but tasks.total == 0 |
Low | maestro task-sync --feature <name> to generate tasks |
| All pending, dep-blocked | All tasks pending, blocked map non-empty |
Low | Check dependency chain -- something upstream may need manual intervention |
Severity determines formatting:
- High: Mark with
[!]prefix. These block progress and must be resolved first. - Medium: Mark with
[~]prefix. These represent interrupted work that should be resumed. - Low: Mark with
-->prefix. These are informational next steps.
Step 4: Present the Status Report
Format the report using phase-aware rules. See reference/output-templates.md for concrete examples of every phase and condition.
General formatting rules:
- Lead with the headline: Feature name, phase, and overall health in one line.
- Show problems first: Any High or Medium conditions appear before the task list.
- Task list: Show all tasks with status markers. Use alignment for readability.
- Progress bar: For execution phase, show completion as
done/totalwith percentage. - Next action: Always end with the specific command to run next.
- Suppress empty sections: Do not show "Blockers: None" or "Zombies: None". Only show sections that have content.
Phase-specific rules:
- Discovery: Show context file count if any. Suggest
maestro:brainstormingormaestro:designskills. - Planning: Show plan status prominently. If comments exist, show count and suggest
maestro plan-read. If plan is draft, suggestmaestro plan-writeormaestro plan-approve. - Execution: Full task table. Group by status: in_progress first, then partial/blocked/failed, then pending, then done (collapsed if many).
- Completion: Brief summary. Show done count. Suggest
maestro feature-complete.
Step 5: Recommend Next Action
The nextAction field from maestro status provides the primary recommendation. Use it as the base, then layer on context-aware guidance.
Enhancement rules based on phase and conditions:
| Phase | Condition | Beyond nextAction |
|---|---|---|
| Discovery | No plan | Suggest loading maestro:brainstorming skill before writing plan |
| Planning | Comments exist | "Address the N comments before seeking approval" |
| Planning | No comments | "Plan looks clean -- run maestro plan-approve when ready" |
| Execution | Zombie detected | "Recover the stale task BEFORE starting new work" |
| Execution | Blocked task | "Read the blocker report: maestro task-report-read --task <id>" |
| Execution | Multiple runnable | "N tasks are ready. Pick based on priority or dependencies." |
| Execution | All done | "All tasks complete. Review implementation, then maestro feature-complete" |
| Execution | Failed + runnable | "Reset the failed task or skip it and continue with runnable tasks" |
| Any | Zero context files | "Consider saving key decisions: maestro context-write" |
Compound conditions: When multiple conditions coexist (e.g., zombie + blocked), prioritize by severity. Address the highest-severity condition first in the recommendation.
Relationship to Other Commands and Skills
Status is the observability layer across the maestro workflow:
| Command / Skill | Relationship to Status |
|---|---|
maestro feature-create |
Creates the feature that status reads |
maestro plan-write |
Status tracks plan existence and approval state |
maestro plan-approve |
Status detects approved plans and suggests task-sync |
maestro task-sync |
Generates tasks that status tracks |
maestro task-start |
Status detects in_progress, partial, blocked, failed tasks |
maestro task-finish |
Status updates done count and recalculates next action |
maestro:brainstorming |
Status suggests this skill during Discovery phase |
maestro:design |
Status suggests this skill for complex features |
maestro:implement |
Load during Execution phase alongside status |
Run maestro status before and after every significant action to stay oriented.
Recommended Agent Skills
Expand your agent's capabilities with these related and highly-rated skills.
maestro-skill-author
Create, update, or debug maestro built-in skills. Covers SKILL.md frontmatter, reference directory structure, step-file architecture, build-time embedding, naming conventions, alias management, and registry validation. Use when creating a new maestro built-in skill, modifying an existing SKILL.md, adding reference files, debugging skill loading failures, updating the skills registry, or working on the skills full port. Also use when frontmatter validation fails, skills don't appear in skill-list, or reference files fail to load.
maestro:brainstorming
Use before any creative work - creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements and design before implementation.
mcp-builder
Guide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK).
maestro:plan-review-loop
Deep-review any plan (maestro, Codex, Claude Code plan mode, or plain markdown) using iterative subagent review loops with BMAD-inspired adversarial edge-case discovery. Spawns reviewer subagents that find issues using pre-mortem, inversion, and red-team techniques, auto-fixes them with structured fix strategies, and re-reviews until the plan passes with zero actionable issues. Use when the user says 'review the plan', 'deep review', 'check the plan thoroughly', 'review loop', 'validate before approving', or wants rigorous plan validation before execution. Also use proactively before plan-approve when the plan is complex or high-risk.
maestro:research
Structured research workflow for maestro features. Guides tool selection across three tiers (codebase exploration, Context7 for library docs, NotebookLM for deep analysis), defines research patterns, finding organization via memory_write, and completion criteria. Use during the research pipeline stage after feature_create and before plan_write. Also use when investigating a problem space, comparing technical approaches, gathering context on unfamiliar code, or needing to understand external library APIs before making architectural decisions.
cli-for-agents
Designs or reviews CLIs so coding agents can run them reliably: non-interactive flags, layered --help with examples, stdin/pipelines, fast actionable errors, idempotency, dry-run, and predictable structure. Use when building a CLI, adding commands, writing --help, or when the user mentions agents, terminals, or automation-friendly CLIs.
Didn't find tool you were looking for?