How should I group these N commits?
  ○ Single commit - All N → 1
  ○ By time clustering - Based on when committed
  ○ By commit prefix - Group feat/fix/test (Recommended)
  ○ By logical change - Split shared files (advanced)

What timestamp for each squashed commit?
  ○ Last commit time (Recommended) - When work finished
  ○ First commit time - When work started
  ○ Middle (average) time

Preview: N commits → M groups

1. feat: Add auth (9:00-9:30, 4 commits) → 9:30
2. fix: Fix login (14:00-14:15, 2 commits) → 14:15
3. test: Add tests (10:00-10:20, 2 commits) → 10:20

  ○ Proceed
  ○ Adjust grouping
  ○ Cancel

What would you like to change?
  ○ Grouping strategy (currently: [current])
  ○ Clustering granularity (currently: [current])
  ○ Timestamp selection (currently: [current])
  ○ Start over from beginning

GIT_AUTHOR_DATE="<timestamp>" \
GIT_COMMITTER_DATE="<timestamp>" \
git commit -m "<message>"

📅 Preserving commit times (using last commit of each group):
  • Group 1: 2026-01-23 09:30:00
  • Group 2: 2026-01-23 14:15:00
  • Group 3: 2026-01-24 10:20:00

# ALWAYS run this and show output
git diff <backup-tag> HEAD

✅ Verification passed

git diff <backup-tag> HEAD
(no output - codebase identical)

The squash preserved all code changes exactly. Only the commit history changed.

❌ Verification FAILED: [uncommitted changes | codebase differs]

git diff output:
<show the actual diff>

What should I do?
  ○ Rollback and retry with different strategy
  ○ Rollback and stop (investigate manually)

if [ -n "$(git status --porcelain)" ]; then
  echo "Error: Working directory not clean."
  echo "Please commit or stash changes first."
  exit 1
fi

BRANCH=$(git branch --show-current)
SANITIZED_BRANCH=$(echo "$BRANCH" | tr '/' '-')

if echo "$BRANCH" | grep -qE "^(main|master)$"; then
  echo "Error: Cannot squash on main/master branch."
  exit 1
fi

MERGE_BASE=$(git merge-base master HEAD 2>/dev/null)
if [ -z "$MERGE_BASE" ]; then
  echo "Error: Cannot find merge base with master."
  exit 1
fi

COMMIT_COUNT=$(git log "$MERGE_BASE"..HEAD --oneline | wc -l | tr -d " ")
echo "Found $COMMIT_COUNT commits since branching from master."

UPSTREAM=$(git rev-parse --abbrev-ref @{u} 2>/dev/null)
if [ -n "$UPSTREAM" ]; then
  REMOTE_HEAD=$(git rev-parse "origin/$BRANCH" 2>/dev/null)
  if [ -n "$REMOTE_HEAD" ] && [ "$REMOTE_HEAD" != "$(git rev-parse HEAD)" ]; then
    # Use wizard to ask
    echo "Warning: Some commits may have been pushed."
    echo "Squashing will require force push."
  fi
fi

MERGES=$(git log "$MERGE_BASE"..HEAD --merges --oneline | wc -l | tr -d " ")
if [ "$MERGES" -gt 0 ]; then
  echo "Warning: Branch has $MERGES merge commit(s)."
  echo "Squashing may produce unexpected results."
fi

SESSION_DIR=".claude/sessions/${SANITIZED_BRANCH}"
if [ -f "$SESSION_DIR/last-squash.json" ]; then
  LAST_SHA=$(jq -r .newHead "$SESSION_DIR/last-squash.json" 2>/dev/null)
  if [ "$LAST_SHA" = "$(git rev-parse HEAD)" ]; then
    echo "Already squashed at current HEAD."
    echo "Make more commits first, or use /undo-squash to restore."
    exit 0
  fi
fi

SESSION_DIR=".claude/sessions/${SANITIZED_BRANCH}"
mkdir -p "$SESSION_DIR"

# Create backup tag
BACKUP_TAG="_squash-backup-$(date +%s)"
git tag "$BACKUP_TAG"

# ANNOUNCE
echo "📦 Backup created: $BACKUP_TAG"

# Create bundle for undo
git bundle create "$SESSION_DIR/pre-squash.bundle" "$MERGE_BASE"..HEAD

# Record in-progress state
cat > "$SESSION_DIR/squash-in-progress.json" << EOF
{
  "status": "started",
  "backupTag": "$BACKUP_TAG",
  "originalHead": "$(git rev-parse HEAD)",
  "mergeBase": "$MERGE_BASE",
  "startTime": "$(date -Iseconds)"
}
EOF

# ANNOUNCE strategy
echo "📋 Strategy: soft reset. Reason: default, all changes preserved in staging"

# 1. Soft reset to merge base
git reset --soft "$MERGE_BASE"
echo "🔄 Reset to merge base, all changes staged"

# 2. Create consolidated commits with preserved timestamps
# For each group:
#   ANNOUNCE: "✅ Creating commit N of M: <message>"
#   GIT_AUTHOR_DATE="<timestamp>" GIT_COMMITTER_DATE="<timestamp>" \
#   git commit -m "<prefix>: <message>"

# 3. Verify and SHOW diff to user
git status --porcelain  # Must be empty
git diff "$BACKUP_TAG" HEAD  # Run and SHOW output (should be empty)
# If diff is empty: "No output - the codebase is identical. ✅"
echo "✅ Verification passed"

# 4. Update squash state
rm "$SESSION_DIR/squash-in-progress.json"

# 5. Record successful squash
cat > "$SESSION_DIR/last-squash.json" << EOF
{
  "squashedAt": "$(date -Iseconds)",
  "newHead": "$(git rev-parse HEAD)",
  "backupTag": "$BACKUP_TAG",
  "originalHead": "$ORIGINAL_HEAD",
  "bundlePath": "$SESSION_DIR/pre-squash.bundle"
}
EOF

# ANNOUNCE completion
echo "🎉 Squash complete! X commits → Y commits"
echo "Backups preserved. To undo: /undo-squash"

feat: Add authorization error handling for external files (ref SG-1234)

Design went through 3 rounds of plan hardening (17 issues found: 8 fixed,
1 won't do, 10 deferred to future work).

## Error scenarios handled

- Auth revoked mid-session: Dialog prompts user to re-authorize via OAuth
- File access lost: Pre-run validation detects inaccessible external files
- Token expiration: Retry-once pattern with fresh OAuth token on 401

## Backend changes

- Add drive-error-helpers with standardized error throwing and validation
- Add withApiResilience for exponential backoff on 429 rate limits
- New error codes: AUTH_REVOKED, TOKEN_EXPIRED, SOURCE_ACCESS_LOST

## Frontend changes

- Add AuthRequiredDialog with 3 states: required → waiting → failed
- Add useFileValidation hook for pre-run external file validation
- Wire auth error detection into useAutomationRun with retry callback

Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

feat: Add authorization error handling (ref SG-1234)

- Add authorization error handling design
- Revise authorization error handling design
- Finalize authorization error handling design
- Add drive error helpers
- Add authorization status APIs
- Add file validation API
- Add auth service
- Add AuthRequiredDialog component
- Add useFileValidation hook
...

if [ -f "$SESSION_DIR/squash-in-progress.json" ]; then
  STATUS=$(jq -r .status "$SESSION_DIR/squash-in-progress.json")
  BACKUP=$(jq -r .backupTag "$SESSION_DIR/squash-in-progress.json")

  echo "Previous squash interrupted at: $STATUS"
  # Use wizard:
  #   ○ Recover original (git reset --hard $BACKUP)
  #   ○ Continue from current state
  #   ○ Abort and clean up
fi

🎉 Squash complete! Backups preserved for undo.

To undo this squash:  /undo-squash
To clean up backups:  /cleanup-squash