Verifies that with display limit at 2 MB and restore limit at 20 MB:
- 3 MB file is restorable but not expandable
- 20 MB+ file has restoreAvailable=false

…istants

- TurnChange.aggregateTurn collapses every assistant in a user turn (parentID match) into one Display, merging same-path edits and dropping white-busy files
- aggregateTurnUndo / aggregateTurnRedo apply per-message mutations under the session lock; default aborts on conflict, force=true skips conflicting messages and reports skipped[]
- MutationResult/Schema gain optional skipped[] for partial-success reporting

Closes the SessionTurn findLast bug surface where only the last assistant's changes were visible.

- GET /session/:id/turn/:userMessageID/changes returns the aggregated display
- POST .../undo and .../redo accept { force? } and reuse the session lock; on applied, broadcast file-changed events
- HTTP-level e2e covers happy path, conflict-blocked default, force=true skip behavior

… flow

- SessionTurn drops the findLast lookup; aggregates per user-turn via the new turn-change endpoint and waits for every child assistant to complete before showing the action
- Mark large+unrestorable files inline; show an "undone" badge and switch the action label to "Reapply" when the turn is undone
- Add a conflict confirm dialog (Skip and apply / Cancel) before retrying with force=true; on applied-with-skipped, persist a yellow notice on the changes block
- New i18n keys for unrestorable, undone, reapply, confirm dialog, and skipped notice (zh uses 爪印 voice: 不可撤回 / 已撤销 / 重新应用)

Two assistants editing the same file in one user turn (e.g. +161-126 then +31-20) used to undo as conflict because preflight checked every message's expected state against frozen real disk. Carry a per-path virtual state through the loop so each message's expected_current is matched against the prior step's target, exactly the scenario reported in #428.

- collapseRestoreFiles now keys by absolute path so two assistants
  writing different files with the same basename do not merge.
- aggregateTurnInternal switches to "any-state" availability so a
  partially-undone turn keeps both undo and redo actionable.
- mutateTurn no longer aborts when one actionable message fails;
  instead it appends to skipped[] and keeps going for the rest.
- When all surviving display rows collapse to white-busy after
  partial mutate, synthesize an applied result with empty files.
- Track the exact paths actually written and pass them to
  publishTurnChangeFiles so skipped files do not emit File events.

Adds three regression tests covering the basename collision,
mixed-state availability, and the mutatedPaths exclusion contract.

- mutateTurn now rolls back already-mutated assistants when force=false
  and a later actionable mutate fails. Previously a TOCTOU could leave
  the turn half-applied while the user saw a blocked toast.
- turnChangeFetch catches network errors and JSON parse failures, so a
  thrown HTTP error in mutateTurnChange no longer becomes an unhandled
  rejection and the user sees the standard blocked toast instead.
- Retry path for null-display fetch now stores its setTimeout in a per-
  key map cleared on cleanup, and keeps the cache key so a second event
  burst can no longer race a duplicate GET for the same turn.
- Stop mutating the response body in place when attaching skippedCount;
  spread into a fresh display object before storing.

When mutateTurn aborts non-force, the per-message reverse rollback used
to swallow blocked results via .catch(() => undefined). If a rollback
itself failed (e.g. file changed externally between forward write and
reverse), the disk was left half-rolled-back but the response carried
the original failure's reason and files, hiding the inconsistency.

mutateTurn now collects dirty paths from each blocked reverse mutate and
returns reason "rollback_failed" with the affected files when any
rollback step did not complete. UI maps the new reason to a dedicated
toast that asks the user to inspect the listed files manually.

force-partial leaves a turn with both hasApplied and hasUndone. The
single inline button continues in the original direction (undo) by
design; the redo path for a mixed state is intentionally not exposed.
Recovery UX for mixed state is tracked as follow-up.

Reverse mutate can return blocked with files: [] from the catch branch
(unexpected throw) or from internal early returns like restore_missing.
The previous loop iterated over empty files, leaving dirty[] empty, so
the outer call returned the original blocked reason and hid the
rollback failure entirely.

Now a blocked reverse without file-level detail records a message-level
dirty entry, ensuring the outer call returns rollback_failed and the UI
warns the user about the partially-rolled-back message.

- Cancel pending turn-change retry timers and clear fetched-turn cache when
  the active session changes, so a stale 500 ms retry from the previous
  session cannot land on a freshly opened one.
- Move the conflict dialog overflow label ("+N more") behind an i18n key
  (`ui.sessionTurn.turnChanges.confirmListMore`) for both en and zh.
- Add a second-pass disambiguation over aggregated restore files so two
  sibling assistants editing different opaque external paths that share a
  basename do not collide on `path: "config.json"` in the turn display.
- Treat `restore_unavailable` as fatal `unsupported_size` in
  `preflightTurn`, matching the single-message `mutate()` behavior so an
  aggregated undo/redo with one oversized/binary file blocks the whole
  turn instead of partially mutating other assistant messages with
  force=true.
- Cover the two backend cases with regression tests in
  `turn-change-aggregate.test.ts`.