[Bug]: Timeline Open diff shows the wrong turn for edits from running, failed, or forked turns

[nekohasekai]

Before submitting

• I searched existing issues and did not find a duplicate.
• I included enough detail to reproduce or investigate the problem.

Area

apps/web

Steps to reproduce

1. In any thread, send a prompt that makes the agent edit a file and keep working for a while.
2. While the turn is still running, expand one of its file-edit rows in the timeline (the row shows the file path and an Open diff button) and click Open diff.

The same button also misbehaves after the turn ends, if the turn failed, and on inherited edits in a forked thread (see below).

Expected behavior

Open diff opens a diff that contains the edit I clicked, or the button is not offered when there is nothing to show yet.

Actual behavior

The Diff panel opens on a turn that does not contain the edit:

Where the edit is	What the Diff panel shows
A running turn, first turn of the thread	"Latest turn" with No completed turns yet.
A running turn, after earlier turns completed	"Latest turn" with the previous turn's diff
A turn that ended as failed	"Latest turn" with the previous turn's diff, permanently
An inherited edit in a forked thread	No completed turns yet., or the fork's own latest turn once it has one

The panel never says that it picked a different turn. In the recording, the failed turn wrote Entry 6, and Open diff on that edit shows turn 2's diff with Entry 4 and Entry 5 and no Entry 6.

During a running turn the selection also does not stay: at the next thread update the panel switches itself to Changes. That reset is #15352 (open fixes: #15382, #15671). On my install Changes is then empty too, because my projects live outside the server's startup directory (#4022, fix in #15014). So while a turn runs, the Diff panel shows no diff for the edit in any of its states.

Not affected: the Open diff on a completed turn's "N changed files" card, which only appears when the turn has a checkpoint. The mobile app has no per-edit Open diff.

Cause

• V2ItemInspector renders Open diff for every file_change item with a runId and calls onOpenTurnDiff(runId, fileName) (V2ItemInspector.tsx#L237).
• The Diff panel only knows turns that have a checkpoint (deriveThreadCheckpointSummaries). When the selected run has none, it falls back to the newest checkpoint and labels it "Latest turn", or shows "No completed turns yet." when the thread has no checkpoint (DiffPanel.tsx#L223-L227, #L980-L983). reconcileTurnSelection also rewrites the stored selection to that newest run (diffPanelStore.ts#L89).
• A run gets a checkpoint only when it ends as completed, interrupted or cancelled (RunExecutionService.ts#L664-L671). A running run has none yet and a failed run never gets one. A fork's projection only loads its own checkpoints (ProjectionStore.ts#L3015-L3019), while inherited items keep the source thread's runId.

file_change items come from every provider adapter, so this is not provider-specific. I did not look into which fix is best. Hiding the button when the item's run has no checkpoint in this thread would stop the wrong diffs. Opening something that contains the edit would keep the button useful while a turn runs: for example the item's own patch, which ACP and Codex items carry in diffStr, or Uncommitted for that file.

Impact

Major degradation or frequent failure

It happens on every click while a turn is running, which is when I most want to look at an edit.

Version or commit

Reproduced on main @ 4ee6bfd. First seen on Nightly 0.0.46-nightly.20261004.2644 (macOS desktop).

Environment

Reproduced: web client against an isolated dev server, with a scripted fake agent (no model calls) that speaks Grok's ACP protocol, writes src/notes.md and reports each write as an edit tool call. Seen: macOS 27.0.1 desktop app, Claude Opus 5.5 thread running for about 30 minutes.

Screenshots, recordings, or supporting files

All project and thread data is synthetic. The yellow captions and the yellow outline on the clicked button were added to the page by the recording script and do not change the app.

open-diff-wrong-turn.mp4

Running turn 1: Open diff on the edit that wrote Entry 1 shows "No completed turns yet."
Running turn 2: Open diff on the edit that wrote Entry 4 shows turn 1's diff (+3) as "Latest turn"
Failed turn 3: Open diff on the edit that wrote Entry 6 shows turn 2's diff
Fork: Open diff on an inherited edit shows "No completed turns yet."
For comparison, an edit from completed turn 1 opens Turn 1 correctly

Workaround

Wait until the turn completes and use the Open diff on its "changed files" card. While a turn runs, choose Uncommitted in the Diff panel, which works only for projects inside the server's startup directory or a T3 worktree until #4022 is fixed.

[juliusmarminge]

Note

Grok responding on behalf of Julius.

Triage

Thanks @nekohasekai for the recording, the screenshots, and the trace through the click path. It still matches current main (801ca76ed). I didn't find another report of this; the mid-turn jump back to Changes is the separate issue in #15352.

What I found

Open diff on a timeline file-edit row is offered whenever that item has a runId (V2ItemInspector). The click stores that run and opens the Diff panel (ChatView's onOpenTurnDiff). The panel can only render turns that have a checkpoint (deriveThreadCheckpointSummaries).

When the clicked run isn't in that list, the panel doesn't stay on it:

• With no checkpoints at all, it shows No completed turns yet.
• Otherwise it displays the newest checkpoint and labels it Latest turn (DiffPanel, the orderedTurnDiffSummaries[0] fallback).
• reconcileTurnSelection then rewrites the stored run id to that newest checkpoint, keeping the clicked file path (diffPanelStore). The panel never says it substituted a different turn.

A run gets a checkpoint only when it ends completed, interrupted, or cancelled (RunExecutionService). That capture is the rollback point for the next message, so a running run has none yet and a failed run never gets one, which lines up with the running and failed rows in your report.

A fork doesn't copy the source thread's checkpoints. Its projection loads checkpoints for its own thread id only (ProjectionStore), while an inherited file-edit row still carries the source run id, so Open diff there shows No completed turns yet. until the fork has its own checkpoint, and then the fork's latest turn.

The activity payload doesn't include the edit's patch: successful file_change rows drop diffStr on the wire on purpose (WireProjection), and a failed edit's diffStr holds the provider error rather than a diff.

Uncommitted isn't a reliable stand-in for now. The panel resets to Changes on thread updates (#15352; open PRs #15382 and #15671), and that scope is empty for projects outside the server startup directory (#4022; open PR #15014).

Likely fix area

Options a maintainer could weigh:

• Hide the timeline button until this thread has a checkpoint for that run, matching the changed-files card. That avoids the wrong diff but still shows nothing per-edit while a turn runs or after it fails.
• Stop substituting another turn: if the selected run has no checkpoint, say so instead of falling back to the newest one and rewriting the selection.
• Open the stored patch for that item via getTurnItem. That could show the edit mid-turn and on an inherited fork row, though it's one tool call's patch rather than the turn checkpoint, and some failed edits won't have one.

Giving failed runs a checkpoint or copying source checkpoints onto forks would affect rollback and fork projections more broadly than this button.

A maintainer will decide on the fix direction.