refactor(core): significantly speed up slow revert functionality

[natewill]

Issue for this PR

Closes #20550

Type of change

• Bug fix
• New feature
• Refactor / code improvement
• Documentation

What does this PR do?

This PR speeds up Snapshot.revert for large revert operations.

Currently, revert handles files one at a time. In the worst case, that means up to 2n git subprocesses for n files: one git checkout per file, and one git ls-tree per file when checkout fails. Because each subprocess has overhead (10-20ms per file), revert gets very slow as file count grows.

This change batches files by snapshot hash and processes them in chunks. In the common case, that reduces the work from 2n git subprocesses to two batched git ls-tree and git checkout calls per 100 file chunks, while preserving the existing single-file path as a fallback if a batched operation fails.

In local testing on my machine, Snapshot.revert for a 300-file revert dropped from 8.72s to 96ms, which is about a 90x speedup.

This improves the file rollback portion of revert specifically. The remaining time in full session revert is still dominated by diff generation after rollback, which can be lengthy.

How did you verify your code works?

• Verified locally with mixed revert scenarios covering modified existing files, deleted existing files, newly created files, and overlapping files across patches.
• Verified the real session revert flow restores the worktree correctly for mixed file changes.
• Ran bun typecheck in packages/opencode.

Screenshots / recordings

Not UI change

Checklist

• I have tested my changes locally
• I have not included unrelated changes in this PR

[github-actions]

Hey! Your PR title perf(core): significantly speed up slow revert functionality doesn't follow conventional commit format.

Please update it to start with one of:

• feat: or feat(scope): new feature
• fix: or fix(scope): bug fix
• docs: or docs(scope): documentation changes
• chore: or chore(scope): maintenance tasks
• refactor: or refactor(scope): code refactoring
• test: or test(scope): adding or updating tests

Where scope is the package name (e.g., app, desktop, opencode).

See CONTRIBUTING.md for details.

[github-actions]

The following comment was made by an LLM, it may be inaccurate:

Based on my search, the current PR (#20551) appears to be the primary result in most searches. The other related PRs found are:

• refactor(opencode): parallelize git snapshot operations on finish-step #16103 - "refactor(opencode): parallelize git snapshot operations on finish-step" - Related to batching git operations for snapshot performance
• feat: add conversation-only revert capability #16447 - "feat: add conversation-only revert capability" - Related to revert functionality
• fix(opencode): improve message filtering for summary update during revert and unrevert #13489 - "fix(opencode): improve message filtering for summary update during revert and unrevert" - Related to revert operations
• fix(snapshot): make /redo targeted to only restore files from reverted turn #15611 - "fix(snapshot): make /redo targeted to only restore files from reverted turn" - Related to snapshot restoration

However, none of these appear to be duplicates addressing the same optimization (batching by snapshot hash to speed up Snapshot.revert). PR #16103 touches on parallelizing git operations, but that's a different scope.

No duplicate PRs found

[natewill]

revertSingle is the same functionality as the revert function that is in the current code. We use this as a fallback if the batching doesn't work for some reason or the snapshot hash only has one reverted file in it

[natewill]

Here, we only checkout files that exist in this snapshot; files missing from the tree should be removed. The old code did the same thing but individually.