🔬 Evaluate rawDiff concatenation strategy for multi-turn same-file edits

[Robdel12]

Context

Discovered in #62: ReviewCanvasStatePlanner.rawDiff joins all turn diffs with \n. When multiple turns edit the same file, this produces concatenated unified diff blocks for the same path. The diff parser/renderer may handle this correctly (showing each turn's changes separately), but it hasn't been verified.

Questions

• Does the diff renderer correctly parse multiple diff blocks for the same file path?
• Should the review UI merge/squash same-file diffs across turns into a single coherent diff?
• Should the per-turn view be the default, with cumulative as an option?
• Do we properly capture/show the diff lines in the file and not make up line numbers at different indexes?

Files

• OrbitDockNative/OrbitDock/Views/Review/ReviewCanvasStatePlanner.swift
• Diff parsing/rendering code

Acceptance Criteria

• Verify the current behavior with a multi-turn same-file edit scenario
• Document the intended behavior
• Fix if the renderer produces confusing output

---

Follow-up from #62: I_kwDORFu4Vs71S6MD

[Robdel12]

Workpad — Evaluate rawDiff concatenation strategy

Analysis

After exploring the full data flow (rawDiff → DiffModel.parse → DiffHunkView/DiffLineRow), I found a real issue with multi-turn same-file edits:

The problem: DiffModel.parse deduplicates same-file diff blocks with "last entry wins" — when turns 1 and 2 both edit App.swift, only turn 2's changes are visible in the cumulative view. Turn 1's changes to that file are silently dropped.

Per-turn view is fine: When selectedTurnDiffId is set, rawDiff returns only that single turn's diff. No concatenation happens.

Direction change: server-driven cumulative diff

Initial approach was client-side hunk merging in DiffModel.parse. Reverting that — it's hacky and doesn't translate to the web client.

New approach: The server should produce a properly merged cumulative diff. Both clients receive a clean unified diff string without needing to stitch or deduplicate anything.

Plan:

1. Revert client-side DiffModel.parse merge logic — go back to simple parsing
2. Add server-side merging — Rust endpoint/logic that combines all turn diffs into a single cumulative diff with same-file hunks merged
3. Update Swift client — consume server-provided cumulative diff instead of concatenating turnDiffs in rawDiff()
4. Web client benefits automatically — same server endpoint/data
5. Keep web parseDiff hardening — skipping metadata lines is still good defensive code

[Robdel12]

🐛 Merge same-file hunks across turns instead of dropping earlier diffs: #108

[Robdel12]

Status: CI green, ready for review

PR: #108

What was found

• DiffModel.parse used "last entry wins" deduplication — when multiple turns edited the same file, only the last turn's changes were visible in the cumulative review view
• Web parseDiff didn't skip diff --git / index / rename metadata lines, which would produce garbage context lines if concatenated multi-file input was passed

What was fixed

• Swift: Changed deduplication to hunk merging — same-file entries get their hunks concatenated with sequential IDs
• Web: Added skipping for all diff metadata lines (diff --git, index, rename from/to, similarity index, file mode lines)
• Added 4 Swift tests (DiffModelTests) and 3 web tests covering multi-turn same-file scenarios

CI

• ✅ Web CI (Lint, Build & Test)
• ✅ Rust CI (Check, Lint & Test)
• ✅ macOS Unit Tests
• ✅ iOS Unit Tests

[Robdel12]

Blocked — agent reported a blocker:

PR #108 is open with all 4 CI checks passing, no conflicts, and no review feedback. Waiting for human review and merge. No remaining code work to do.

[Robdel12]

✅ Server-driven cumulative diff — implementation complete

All three layers (Rust server, Swift client, web client) are wired up and passing CI.

What shipped

• Rust diff_merge module — compute_cumulative_diff() merges same-file hunks across turns so each file appears once in the diff
• Protocol — cumulative_diff field on SessionState (bootstrap) and StateChanges (deltas)
• Swift pipeline — full decode → projection → observable → view model chain; ReviewCanvasStatePlanner.rawDiff() prefers server cumulative_diff, falls back to concatenation
• Web — parser already handles merged format; added edge case tests

CI status

• make rust-ci ✅ (fmt, clippy, 91 protocol tests)
• make test-unit ✅ (all Swift tests)
• Web tests ✅ (81/81)

Ready for review

PR: #108