---
name: rollback
description: |
  Revert implementation to a specific batch checkpoint using git revert, reset Jira ticket statuses,
  verify rollback integrity with tests, and produce a rollback report.
  Trigger phrases:
  - "rollback", "revert", "revert batch"
  - "undo implementation", "roll back to batch"
category: build
tags: [rollback, revert, recovery, implementation]
disable-model-invocation: true
---

# Implementation Rollback

Revert the codebase to a specific batch checkpoint, reset Jira statuses for reverted tasks, and verify integrity.

## Core Principles

- **Preserve history**: always use `git revert`, never force-push
- **Verify after revert**: run the full test suite after every rollback
- **Update tracking**: reset Jira ticket statuses for all reverted tasks
- **Atomic rollback**: if rollback fails midway, stop and report — do not leave the codebase in a partial state
- **Ask, don't assume**: if the target batch is ambiguous, present options and ask

## Context Resolution

- IMPL_DIR: `_docs/03_implementation/`
- Batch reports: `IMPL_DIR/batch_*_report.md`

## Prerequisite Checks (BLOCKING)

1. IMPL_DIR exists and contains at least one `batch_*_report.md` — **STOP if missing**
2. Git working tree is clean (no uncommitted changes) — **STOP if dirty**, ask user to commit or stash

## Input

- User specifies a target batch number or commit hash
- If not specified, present the list of available batch checkpoints and ask

## Workflow

### Step 1: Identify Checkpoints

1. Read all `batch_*_report.md` files from IMPL_DIR
2. Extract: batch number, date, tasks included, commit hash, code review verdict
3. Present batch list to user

**BLOCKING**: User must confirm which batch to roll back to.

### Step 2: Revert Commits

1. Determine which commits need to be reverted (all commits after the target batch)
2. For each commit in reverse chronological order:
   - Run `git revert <commit-hash> --no-edit`
   - If merge conflicts occur: present conflicts and ask user for resolution
3. If any revert fails and cannot be resolved, abort the rollback sequence with `git revert --abort` and report

### Step 3: Verify Integrity

1. Run the full test suite
2. If tests fail: report failures to user, ask how to proceed (fix or abort)
3. If tests pass: continue

### Step 4: Update Jira

1. Identify all tasks from reverted batches
2. Reset each task's Jira ticket status to "To Do" via Jira MCP

### Step 5: Finalize

1. Commit with message: `[ROLLBACK] Reverted to batch [N]: [task list]`
2. Write rollback report to `IMPL_DIR/rollback_report.md`

## Output

Write `_docs/03_implementation/rollback_report.md`:

```markdown
# Rollback Report

**Date**: [YYYY-MM-DD]
**Target**: Batch [N] (commit [hash])
**Reverted Batches**: [list]

## Reverted Tasks

| Task | Batch | Status Before | Status After |
|------|-------|--------------|-------------|
| [JIRA-ID] | [batch #] | In Testing | To Do |

## Test Results
- [pass/fail count]

## Jira Updates
- [list of ticket transitions]

## Notes
- [any conflicts, manual steps, or issues encountered]
```

## Escalation Rules

| Situation | Action |
|-----------|--------|
| No batch reports exist | **STOP** — nothing to roll back |
| Uncommitted changes in working tree | **STOP** — ask user to commit or stash |
| Merge conflicts during revert | **ASK user** for resolution |
| Tests fail after rollback | **ASK user** — fix or abort |
| Rollback fails midway | Abort with `git revert --abort`, report to user |

## Methodology Quick Reference

```
┌────────────────────────────────────────────────────────────────┐
│              Rollback (5-Step Method)                            │
├────────────────────────────────────────────────────────────────┤
│ PREREQ: batch reports exist, clean working tree                 │
│                                                                │
│ 1. Identify Checkpoints → present batch list                    │
│    [BLOCKING: user confirms target batch]                       │
│ 2. Revert Commits       → git revert per commit                │
│ 3. Verify Integrity     → run full test suite                   │
│ 4. Update Jira          → reset statuses to "To Do"            │
│ 5. Finalize             → commit + rollback_report.md           │
├────────────────────────────────────────────────────────────────┤
│ Principles: Preserve history · Verify after revert              │
│             Atomic rollback · Ask don't assume                 │
└────────────────────────────────────────────────────────────────┘
```