feat(diff): add a Session / Last turn scope toggle to the changes panel (#1635)

[fiorelorenzo]

Description

Adds a scope toggle to the Changes panel so you can flip the "Changed" section between the whole task diff (Session, the current behavior) and only what the most recent agent turn changed (Last turn). The two scopes stay cleanly separated, which is what people asked for in the issue.

How it works

Turn baseline (main). On each turn start (the provider-agnostic conversation:input-submitted event, which fires for both ACP and PTY agents) LastTurnBaselineService snapshots the task's worktree as a git tree and remembers it per workspace. "Last turn" is then the diff between that snapshot and the current worktree.

• The snapshot captures the whole worktree, tracked and untracked, respecting .gitignore, via git write-tree against a throwaway index file. It never touches the real index, working tree, or commit history (validated in the unit test).
• The baseline is kept in memory on purpose: it is a dangling tree that git gc could prune between sessions, and it is only meaningful for the current turn. It resets on restart and is re-captured on the next prompt.

Rendering (renderer). In last-turn scope the file list comes from a new gitWorktree.getLastTurnChanges RPC, and opening a file renders the immutable baseTree to headTree snapshot diff through the existing ref-to-ref git diff group. So there is no new live-working-tree diff mode and no changes to the diff-tab machinery or its staleness reconcile. The diff is a stable view of the turn, and it refreshes when the next turn is captured.

Last-turn is a read-only review view: stage, discard, and commit actions and selection are hidden, and the empty state explains when a turn made no changes.

Commits (one layer each)

1. GitWorktree.snapshotWorktreeTree() and getChangedFilesBetweenTrees() in packages/core (plus the IGitWorktree interface): the snapshot and tree-diff primitives.
2. LastTurnBaselineService, the getLastTurnChanges RPC, the git:last-turn-baseline event, and init wiring.
3. The last-turn data source in the renderer worktree store.
4. The Session / Last turn toggle and section wiring.
5. The two new IGitWorktree methods implemented on the legacy SSH runtime, so remote worktrees compile and behave the same.

Related issues

Closes #1635.

Testing

• packages/core git tests, including a new case: snapshot plus tree-diff with tracked, untracked, and gitignored files, non-destructive (the real index still sees the change as unstaged).
• LastTurnBaselineService unit test: capture on turn start, overwrite per turn, ignore workspaceless tasks, clear on teardown.
• Touched-area suites green: core git (54), main-process git (45), diff-view stores and manager (54, no regressions).
• pnpm run format, pnpm run lint, and pnpm run typecheck clean on all changed files.

Screenshot/Recording

I develop on a headless box and cannot render the Electron UI here, so I have not visually verified the renderer wiring or captured a screenshot. The backend is fully unit-tested. If someone can run it and confirm the toggle and the read-only last-turn view render correctly, I will follow up on anything that needs adjusting.

Follow-ups (intentionally out of scope)

• Persist the scope choice globally (it is per-task right now and resets on remount).
• A browser test for the section's scope-aware rendering.
• Optionally a live-working-tree "after" side, so an open last-turn diff updates as the turn continues instead of refreshing on the next turn.

Checklist

• I kept this PR small and focused
• I ran a self-review before opening this PR
• I ran the relevant local checks or explained why not
• I updated docs when behavior or setup changed
• I added or updated tests when behavior changed, or explained why not
• I only added comments where the logic is not obvious
• I used Conventional Commits for commit messages and the PR title

[greptile-apps]

Greptile Summary

This PR adds a Session / Last turn scope toggle to the Changes panel, letting users flip the "Changed" section between the entire task diff and only what the most recent agent turn modified. The three issues flagged in the previous review (prefetch group mismatch, empty-state wording, and SSH stub parameter names) are all correctly addressed in this iteration.

• Core git primitives (snapshotWorktreeTree, getChangedFilesBetweenTrees) are added to GitWorktree with a serialization chain (snapshotChain) that keeps the shared throwaway index file race-free; the SSH runtime stubs throw/return-empty so the feature degrades gracefully on the deprecated runtime.
• LastTurnBaselineService captures a worktree tree OID at each turn start via the provider-agnostic conversation:input-submitted event, stores it in-memory per workspace, and emits a git:last-turn-baseline event that the renderer store subscribes to.
• Renderer-side, GitWorktreeStore exposes lastTurnChanges / refreshLastTurn, and UnstagedSection now selects the correct diff group ('git' for last-turn, 'disk' for session), uses scope-aware prefetch warm-up, hides mutation actions in last-turn mode, and shows distinct empty-state labels for "no turn yet" vs. "turn made no changes".

Confidence Score: 5/5

Safe to merge. The three issues from the prior review are correctly resolved, all new code paths are covered by unit and integration tests, and the legacy SSH runtime degrades cleanly without blocking the rest of the feature.

The baseline-capture service, the new git primitives, and the renderer wiring are all implemented correctly. The snapshot chain serializes concurrent calls to the shared throwaway index file, so the race-free guarantee holds. Empty-state messages now properly distinguish no baseline yet from this turn changed nothing. The prefetch hooks mirror the correct diff group per scope. No correctness bugs were found in this iteration.

controller.ts (getLastTurnChanges) is worth revisiting if snapshot-related git object accumulation becomes observable in practice — a future optimization could cache the headTree between status-revision changes to reduce redundant git operations.

Important Files Changed

Filename	Overview
packages/core/src/git/git-worktree.ts	Adds snapshotWorktreeTree (serialized via snapshotChain to protect the shared throwaway index) and getChangedFilesBetweenTrees (reuses parseNumstat/name-status pattern consistent with existing getChangedFiles); both are well-tested.
apps/emdash-desktop/src/main/core/git/last-turn-baseline-service.ts	Captures per-workspace baseline OID on every conversation:input-submitted, clears it on task:torn-down, and emits the git:last-turn-baseline channel event; lifecycle (initialize/dispose) and tests are thorough.
apps/emdash-desktop/src/main/core/git/worktree/controller.ts	Adds getLastTurnChanges RPC; calls snapshotWorktreeTree() on every invocation to get a fresh headTree — accumulation of dangling objects is a known trade-off documented in a prior review comment.
apps/emdash-desktop/src/renderer/features/tasks/stores/git-worktree-store.ts	Adds _lastTurn observable, lastTurnChanges computed getter, refreshLastTurn async method, and event subscription in start(); dispose() correctly cleans up the subscription and the MobX observable is properly registered.
apps/emdash-desktop/src/renderer/features/tasks/diff-view/changes-panel/unstaged-section.tsx	Scope-aware rendering is correct: separate diskPrefetch/gitPrefetch hooks properly warm the right model group per scope; mutation actions are correctly gated behind !isLastTurn; empty-state messages now distinguish no-baseline from zero-changes-this-turn.
apps/emdash-desktop/src/main/core/runtime/legacy/ssh-git.ts	snapshotWorktreeTree throws to degrade cleanly on the legacy SSH runtime; getChangedFilesBetweenTrees returns [] and now carries the interface parameter names as requested in the previous review.
apps/emdash-desktop/src/renderer/features/tasks/diff-view/changes-panel/components/changes-scope-toggle.tsx	New toggle component with controlled tooltip that stays open after click; aria-pressed and aria-label are set correctly for accessibility.
apps/emdash-desktop/src/main/core/git/last-turn-baseline-service.test.ts	Unit tests cover: no baseline before first turn, capture+emit on input-submitted, overwrite per turn, workspace-less task skip, and baseline cleanup on task teardown.
packages/core/src/git/git-worktree.test.ts	Integration test validates snapshot + diff with tracked, untracked, and gitignored files, confirms non-destructive behavior (real index unchanged), and baseline content preservation for the before-side of the diff.

_{Reviews (2): Last reviewed commit: "fix(diff): prefetch the correct models i..." | Re-trigger Greptile}

[fiorelorenzo]

@greptileai please re-review. I pushed the three fixes from your review in 3d4e70e:

1. Prefetch group mismatch: the Changed panel now selects a 'git'-group prefetch keyed by commitRef(baseTree) / commitRef(headTree) when the scope is last-turn, so it warms the same models openChange opens instead of the 'disk'/HEAD ones.
2. Empty state: it now tells apart "no turn recorded yet" (no baseline before the first prompt) from "the most recent turn made no file changes".
3. Legacy SSH stub: getChangedFilesBetweenTrees(_baseTree, _headTree) now carries the interface parameter names.

CI is green on the new commit.

[rabanspiegel]

Thank you for your contribution @fiorelorenzo !