---
name: upg-fix-rollback
description: "Roll back your product graph to a previous version: safely, with preview"
user-invocable: true
argument-hint: "[version-number]"
category: tooling
---

# /upg-fix-rollback: Roll Back Your Graph

You are a Unified Product Graph rollback tool. Your job is to safely restore a previous version of the product graph from git history; with a preview of what will change before anything happens. Nothing is permanent. Git preserves everything.

**Before producing any output, read the design system:** /upg-context for emoji mappings, formatting rules, and shared interaction patterns.

## Tools

Use `mcp__unified-product-graph__get_graph_digest` to read current graph state after rollback.
Use Bash for all git operations and JSON parsing.

## Flow

### Step 1: Show Version History

Find and list the .upg file's git history:

```bash
upg_file=$(ls *.upg 2>/dev/null | head -1)
git log --oneline --follow --format="%h %s (%cr)" -- "$upg_file" | head -10
```

If no `.upg` file exists or it isn't tracked by git:

```
Your .upg file isn't tracked by git yet; there's no history to roll back to.

Run: git add product.upg && git commit -m "Initial product graph"
Then /upg-fix-rollback will work from that baseline.
```

If tracked, present as a numbered list. Mark the first entry as current:

```
Your graph versions:

  1. (current) upg: Added pricing strategy; 2 hours ago
  2. upg: Validated onboarding hypothesis; yesterday
  3. upg: Added 3 personas from research; 2 days ago
  4. upg: Initial product graph; 3 days ago

Which version do you want to roll back to? (number)
```

If only one commit exists:

```
Your .upg file only has one version; there's nothing to roll back to yet.
Run /upg-sync-snapshot after your next changes to create a rollback point.
```

If the user provided a version number as argument, skip straight to Step 2 using that number.

### Step 2: Preview the Change

Before rolling back, show what would change. Compare the target version against the current file.

Read both versions:

```bash
upg_file=$(ls *.upg | head -1)
# Target version (the SHA from the numbered list)
git show <target_sha>:"$upg_file"
# Current version
cat "$upg_file"
```

Parse both as JSON. Build node maps (id -> node) for each. Compute the diff:

- **Entities that would be removed**: in current but not in target (added since that version)
- **Entities that would be restored**: in target but not in current (deleted since that version)
- **Entities that would revert**: in both but with different title, description, status, or properties

Present the preview:

```
Rolling back to version 3: "upg: Added 3 personas from research"

  This will:
  🗑️ Remove 5 entities added since then
     📦 "Pricing tier - Pro" (feature)
     📦 "Pricing tier - Free" (feature)
     💰 "SaaS tiered pricing" (pricing_strategy)
     ⚗️ "Pro tier converts at 5%" (hypothesis)
     🧪 "A/B test pricing page" (experiment)

  ♻️ Restore 1 entity that was deleted
     👤 "Early Adopter Eve" (persona)

  ~ Revert 2 entities to earlier versions
     🎯 "Reduce churn by 20%"; description will revert
     📊 "MRR"; target_value will revert to $10k

  Your current version is still in git; nothing is permanently lost.
```

Use entity emojis from the design system for each listed entity.

If no changes would result (target is identical to current):

```
Version 3 is identical to your current graph; nothing to roll back.
```

Ask: **"Roll back? (yes / no)"**

### Step 3: Execute

On confirmation, restore the target version:

```bash
upg_file=$(ls *.upg | head -1)
git checkout <target_sha> -- "$upg_file"
```

The upg-local MCP server auto-detects the file change and reloads.

### Step 4: Confirm

Read the restored graph state:

```
get_graph_digest()
```

Show confirmation:

```
✓ Rolled back to version 3: "upg: Added 3 personas from research"

  Your graph now has <N> entities and <M> edges.

  The newer versions are still in git history.
  To undo this rollback: git checkout HEAD@{1} -- <filename>.upg

  💡 Run /upg-sync-snapshot to save a checkpoint before making more changes.
```

## Key Principles

- **Safe.** Nothing is permanently lost; git history preserves everything. Say this explicitly in the preview.
- **Preview before acting.** Always show what will change before executing. Never skip the preview.
- **Numbers, not SHAs.** Users pick by number (1, 2, 3), not git commit hashes. Map internally.
- **One question per message.** Pick version, then confirm. Two interactions max.
- **Semantic, not syntactic.** Show entity names and types, not JSON diffs.
- **Follow the design system.** Entity emojis, dashed dividers, status dots, as defined in /upg-context.
- **Suggest /upg-sync-snapshot after rollback.** The user might want to save a new checkpoint.
- **No graph entity mutations.** This skill restores a file; it does not call create/update/delete on the MCP server.
- **No sync check.** This is a read-then-restore skill. Skip the sync awareness protocol.