maestro:revert

Revert Git commits and roll back plan state for Maestro tracks, phases, or tasks.

Updated Mar 13, 2026
One-click install
npx skills add https://github.com/ReinaMacCredy/Maestro-CLI --skill maestro-revert
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: maestro:revert
Source: https://github.com/ReinaMacCredy/Maestro-CLI/tree/main/.codex/skills/maestro%3Arevert
Command: npx skills add https://github.com/ReinaMacCredy/Maestro-CLI --skill maestro-revert

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill provides a safe and guided way to undo implementation work in your Git repository, ensuring that your plan state is rolled back accordingly and preventing data loss.

Core Features & Use Cases

  • Granular Reversion: Revert changes at the track, phase, or individual task level.
  • Git-Aware Undo: Uses git revert to create new commits that undo previous ones, preserving history.
  • Plan State Rollback: Resets task completion status in plan.md to reflect the reverted work.
  • Safety First: Includes mandatory pre-checks, backup tags, and clear decision trees to avoid destructive operations.
  • Use Case: You implemented a feature, but it produced incorrect results or the approach was flawed. Use this Skill to safely undo the commits associated with that feature and reset the plan so you can re-implement it correctly.

Quick Start

Use the maestro revert skill to undo the last task in the 'authentication' track.

Frequently Asked Questions about maestro:revert

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I revert a Git commit and reset the plan state for a specific task?

To revert a Git commit and reset plan state, this Skill utilizes `git revert` to create undo commits while updating `plan.md` to roll back task completion status. It targets specified tracks, phases, or tasks to ensure your project plan accurately reflects the reverted work.

What is the safest way to undo implementation work in a Git repository without losing history?

The safest way to undo Git implementation work without losing history is using `git revert` to generate new commits that undo previous ones. This approach preserves your commit history while rolling back the unwanted changes and resetting the project plan state.

Can I revert code changes at the track or phase level instead of individual commits?

Yes, you can revert code changes at the track, phase, or individual task level. This granular reversion capability allows you to target specific sections of your development workflow, undoing only the relevant Git commits and resetting the corresponding plan.md status.

Does reverting commits with this method perform any pre-flight safety checks?

Yes, reverting commits includes mandatory pre-flight safety checks and creates backup tags before executing the undo operations. These precautions prevent destructive actions and data loss, while a clear decision tree guides the safe rollback of both Git state and plan.md updates.

Why do I need to roll back plan state when undoing Git commits?

Rolling back plan state is necessary when undoing Git commits because it resets task completion status in `plan.md` to match the reverted code. Without this synchronization, your development orchestrator would incorrectly mark undone work as complete, causing workflow tracking errors.

When should I avoid using git revert to undo changes in my development workflow?

You should avoid using git revert if you need to completely erase a commit from history rather than appending an undo commit. This Skill focuses on safe, non-destructive reversion; if pre-flight safety checks fail or backup tags cannot be created, the rollback operation is aborted to prevent data loss.