Git Squash

Pre-flight Checks

Before merging, validate the environment:

Determine source branch — use the argument if provided (/git-squash feature/my-branch), otherwise use the current branch.
Verify not on main — if the source branch is main, abort with an error.
Check for uncommitted changes — run git status --porcelain. If there are uncommitted changes, abort and suggest committing or stashing first.
Verify branch exists — confirm the source branch exists locally (git rev-parse --verify <branch>).
Verify divergence from main — run git log main..<branch> --oneline. If empty, abort — nothing to merge.

Switch to Main

git checkout main

If a remote origin exists, pull latest:

git pull --ff-only

If --ff-only fails, abort — main has diverged and needs manual resolution.

Squash Merge

git merge --squash <branch>

If the merge produces conflicts:

Abort immediately:
```
git merge --abort
```
Switch back to the source branch:
```
git checkout <branch>
```

Suggest the user rebase first:

Merge conflicts detected. Run `git rebase main` on your branch to resolve conflicts, then retry.

Stop — do not proceed.

Delegate to git-commit

After a successful squash merge, invoke /git-commit to handle the commit. This delegates the full 7-step workflow:

Sensitive File Guard
Auto-stage tracked changes
Multi-concern analysis
Commit message generation (Conventional Commits with inferred type/scope)
Heredoc commit with Co-Authored-By trailer
Hook failure handling

Do not write commit messages directly — always delegate.

Post-merge Verification

After the commit succeeds:

git log --oneline -5
git status
git diff

Confirm: clean working tree, squash commit visible at HEAD, no leftover staged changes.

Cleanup

Delete local branch

First, try safe delete:

git branch -d <branch>

If -d fails because git doesn't recognise the squash merge (expected — squash merges don't preserve commit ancestry), verify there is zero diff between main and the branch:

git diff main <branch>

If the diff is empty (content fully merged), force-delete is safe:

git branch -D <branch>

If there IS a diff, do not delete — something was lost in the squash. Investigate before proceeding.

Delete remote branch (if exists)

Check if a remote tracking branch exists:

git ls-remote --heads origin <branch>

If it exists:

git push origin --delete <branch>

Rules

Proceed without confirmation — pre-flight checks are the safety gate. Do not ask the user to approve before merging.
Only merge into main — never squash-merge into other branches.
Always use --squash — never fast-forward or regular merge.
Always delegate the commit to /git-commit — never write commit messages directly.
Abort on merge conflicts — never auto-resolve.
Never force-push (--force, --force-with-lease).
Prefer git branch -d — use -D only after verifying zero diff between main and the branch (squash merges don't preserve ancestry, so -d will fail even when content is fully merged).
If any step fails, stop and report the error — do not continue the workflow.

Quick Reference

Pre-flight: verify branch, check uncommitted changes, confirm divergence from main.
Switch to main, pull latest with --ff-only.
git merge --squash <branch> — abort on conflicts, suggest rebase.
Delegate commit to /git-commit (Sensitive File Guard, Conventional Commits, heredoc).
Verify: git log, git status, git diff.
Cleanup: git branch -d (fall back to -D after verifying zero diff), git push origin --delete (if remote exists).

git-squash