Get the FREE Ultimate OpenClaw Setup Guide →

worktree-cleanup

npx machina-cli add skill michael-harris/devteam/worktree-cleanup --openclaw
Files (1)
SKILL.md
5.0 KB

Worktree Cleanup Command

Debug/Expert Command - Manually clean up development track worktrees.

Note: This command is rarely needed. Worktrees are cleaned up automatically after /devteam:implement merges all tracks. Use this only if automatic cleanup failed or you need manual control.

Command Usage

/devteam:worktree cleanup            # Clean up all worktrees
/devteam:worktree cleanup 01         # Clean up specific track
/devteam:worktree cleanup --all      # Clean up worktrees AND delete branches

Warning

This command is destructive. Use with caution.

Your Process

Step 1: Load State and Validate

  1. Load state from SQLite database (.devteam/devteam.db) via source "${CLAUDE_PLUGIN_ROOT}/scripts/state.sh"
  2. Verify worktree mode enabled
  3. If specific track, verify track exists
  4. Check if tracks are complete (warning if not)

Step 2: Safety Checks

For each worktree to be removed:

cd "$worktree_path"

# Check for uncommitted changes
if [ -n "$(git status --porcelain)" ]; then
    echo "ERROR: Uncommitted changes in $worktree_path"
    echo "  Please commit or stash changes first"
    exit 1
fi

# Check if pushed to remote
if git status | grep "Your branch is ahead"; then
    echo "WARNING: Unpushed commits in $worktree_path"
    echo "  Recommend pushing before cleanup"
    read -p "Continue anyway? (y/N): " confirm
    if [ "$confirm" != "y" ]; then
        exit 1
    fi
fi

Step 3: Remove Worktrees

For each worktree:

cd "$MAIN_REPO"

echo "Removing worktree: $worktree_path"
git worktree remove "$worktree_path"

if [ $? -eq 0 ]; then
    echo "Removed: $worktree_path"
else
    echo "Failed to remove: $worktree_path"
    echo "  Try: git worktree remove --force $worktree_path"
fi

Step 4: Remove Empty Directory

if [ -d ".multi-agent" ] && [ -z "$(ls -A .multi-agent)" ]; then
    rmdir .multi-agent
    echo "Removed empty .multi-agent/ directory"
fi

Step 5: Optionally Delete Branches

If --all flag:

for track in tracks:
    branch = "dev-track-${track:02d}"

    # Safety: verify branch is merged
    if git branch --merged | grep -q "$branch"; then
        git branch -d "$branch"
        echo "Deleted branch: $branch"
    else
        echo "Branch $branch not fully merged - keeping for safety"
        echo "  To force delete: git branch -D $branch"
    fi
done

Step 6: Update State in SQLite

# Update state in SQLite database (.devteam/devteam.db)
source "${CLAUDE_PLUGIN_ROOT}/scripts/state.sh"

set_kv_state "cleanup_info.cleaned_at" "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
set_kv_state "cleanup_info.worktrees_removed" "1,2,3"
set_kv_state "cleanup_info.branches_deleted" "true"  # or "false"

Output Format

Success:

Worktree Cleanup

Cleaning up worktrees for all tracks...

Track 1:
  Verified no uncommitted changes
  Warning: 3 unpushed commits
  Worktree removed: .multi-agent/track-01/

Track 2:
  Verified no uncommitted changes
  Verified pushed to remote
  Worktree removed: .multi-agent/track-02/

Track 3:
  Verified no uncommitted changes
  Verified pushed to remote
  Worktree removed: .multi-agent/track-03/

Removed .multi-agent/ directory

Branches kept (to remove: use --all flag):
  - dev-track-01
  - dev-track-02
  - dev-track-03

Cleanup complete!

With --all flag:

Worktree Cleanup (Including Branches)

Cleaning up worktrees and branches...

Worktrees:
  Removed: .multi-agent/track-01/
  Removed: .multi-agent/track-02/
  Removed: .multi-agent/track-03/
  Removed: .multi-agent/ directory

Branches:
  Deleted: dev-track-01 (was merged)
  Deleted: dev-track-02 (was merged)
  Deleted: dev-track-03 (was merged)

All worktrees and branches removed!

Note: Development history is still in main branch commits.

Error Handling

Uncommitted changes:

Cannot clean up worktree: .multi-agent/track-02/

Uncommitted changes detected:
  M  src/components/Header.tsx
  M  src/pages/Dashboard.tsx
  ?? src/components/NewFeature.tsx

Please commit or stash these changes:
  cd .multi-agent/track-02/
  git add .
  git commit -m "Final changes"

Or force removal (WILL LOSE CHANGES):
  git worktree remove --force .multi-agent/track-02/

Track not complete:

WARNING: Cleaning up incomplete tracks

Track 2 progress: 1/2 sprints complete (4/6 tasks)
Track 3 progress: 0/2 sprints complete (0/5 tasks)

Are you sure you want to remove these worktrees?
Work will be lost unless already committed.

To continue: /devteam:worktree cleanup --force

Safety Notes

  • Always checks for uncommitted changes
  • Warns about unpushed commits
  • Won't delete unmerged branches (without -D flag)
  • Can be undone if branches kept (recreate worktree)
  • Updates SQLite state database for audit trail

Source

git clone https://github.com/michael-harris/devteam/blob/main/skills/worktree-cleanup/SKILL.mdView on GitHub

Overview

This Debug/Expert command lets you manually remove development track worktrees when automatic cleanup fails. It should be used sparingly, as worktrees can be removed only after safety checks and state validation. It also supports optional branch deletion with the --all flag.

How This Skill Works

The command loads state from the local SQLite database, verifies that worktree cleanup is enabled, and checks the specified track (if any). It then iterates through eligible worktrees, ensuring there are no uncommitted changes and that pushes are up-to-date before removing the worktrees with git worktree remove, optionally deleting merged branches, and finally updates the SQLite state to reflect the cleanup.

When to Use It

  • Automatic cleanup failed after a /devteam:implement merge and manual intervention is required
  • You need to remove a specific track without touching others
  • You want to clean all worktrees and optionally delete merged branches with --all
  • You are tidying up after finishing development tracks and want to reclaim space
  • You’re debugging or auditing worktree cleanup and need explicit control

Quick Start

  1. Step 1: Load state and validate access to worktree cleanup
  2. Step 2: Run safety checks (uncommitted changes, pushed commits)
  3. Step 3: Remove worktrees and optionally delete branches, then update SQLite state

Best Practices

  • Verify the target track exists before removal when cleaning a specific track
  • Check for uncommitted changes and halt if present
  • Ensure you have pushed or are prepared to push relevant commits before deletion
  • Run from the repository root to avoid path mistakes
  • Update the SQLite state after cleanup to reflect the new status

Example Use Cases

  • Clean up all worktrees for every track: /devteam:worktree cleanup
  • Remove a single track (01) after a failed automatic cleanup: /devteam:worktree cleanup 01
  • Clean worktrees and delete merged branches with --all: /devteam:worktree cleanup --all
  • Run safety checks, then remove worktrees and report results
  • Post-cleanup, confirm the .multi-agent directory is removed if empty

Frequently Asked Questions

Add this skill to your agents
Sponsor this space

Reach thousands of developers