The best way to control Claude Code, Codex and more from any computer or phone
perf(shared): avoid redundant visibility work on status updates (#28965)
Hieu Le committed
Nov 4, 2026 at 00:14 UTC
0a86e157a0eaf80c34da089a29526c6201ac529a
2 files changed
+247
-17
packages/shared/src/orchestrationV2Timeline.test.ts
+234
-13
@@ -8,6 +8,20 @@ import {
8
9
const runId = RunId.make("run:timeline-visibility");
10
const nodeId = NodeId.make("node:timeline-visibility");
11
+const otherRunId = RunId.make("run:timeline-visibility:other");
12
+const otherNodeId = NodeId.make("node:timeline-visibility:other");
13
+type VisibilityInput = Parameters<typeof createOrchestrationV2TurnItemVisibility>[0];
14
+
15
+const ordinaryStatuses = [
16
+ "preparing",
17
+ "queued",
18
+ "starting",
19
+ "running",
20
+ "waiting",
21
+ "completed",
22
+ "interrupted",
23
+ "failed",
24
+] as const;
25
26
describe.each([
27
["point", isOrchestrationV2TurnItemVisible],
@@ -28,19 +42,26 @@ describe.each([
42
).toBe(false);
43
});
44
31
- it("keeps paired interruption results from superseded attempts", () => {
32
- expect(
33
- isVisible({
34
- item: { type: "run_interrupt_result", runId, nodeId },
35
- runs: [{ id: runId, status: "running" }],
36
- attempts: [{ runId, rootNodeId: nodeId, status: "superseded" }],
37
- items: [
38
- { type: "run_interrupt_request", runId, nodeId },
39
- { type: "run_interrupt_result", runId, nodeId },
40
- ],
41
- }),
42
- ).toBe(true);
43
- });
45
+ it.each([
46
+ { status: "running", visible: true },
47
+ { status: "cancelled", visible: true },
48
+ { status: "rolled_back", visible: false },
49
+ ] as const)(
50
+ "keeps paired superseded results unless the run is rolled back ($status)",
51
+ ({ status, visible }) => {
52
+ expect(
53
+ isVisible({
54
+ item: { type: "run_interrupt_result", runId, nodeId },
55
+ runs: [{ id: runId, status }],
56
+ attempts: [{ runId, rootNodeId: nodeId, status: "superseded" }],
57
+ items: [
58
+ { type: "run_interrupt_request", runId, nodeId },
59
+ { type: "run_interrupt_result", runId, nodeId },
60
+ ],
61
+ }),
62
+ ).toBe(visible);
63
+ },
64
+ );
65
66
it("keeps interruption results from terminal attempts without a request", () => {
67
expect(
@@ -92,4 +113,204 @@ describe.each([
113
}),
114
).toBe(true);
115
});
116
+
117
+ it.each([
118
+ ...ordinaryStatuses.map((status) => ({ status, hidden: [] })),
119
+ { status: "cancelled", hidden: ["queued"] },
120
+ {
121
+ status: "rolled_back",
122
+ hidden: ["queued", "start", "steer", "promoted", "legacy", "assistant", "request", "result"],
123
+ },
124
+ ] satisfies ReadonlyArray<{
125
+ status: VisibilityInput["runs"][number]["status"];
126
+ hidden: string[];
127
+ }>)("keeps the correct transcript rows for $status runs", ({ status, hidden }) => {
128
+ const rows = [
129
+ { id: "queued", type: "user_message", inputIntent: "queued_turn", runId, nodeId },
130
+ { id: "start", type: "user_message", inputIntent: "turn_start", runId, nodeId },
131
+ { id: "steer", type: "user_message", inputIntent: "steer", runId, nodeId },
132
+ {
133
+ id: "promoted",
134
+ type: "user_message",
135
+ inputIntent: "promoted_queued_to_steer",
136
+ runId,
137
+ nodeId,
138
+ },
139
+ { id: "legacy", type: "user_message", runId, nodeId },
140
+ { id: "assistant", type: "assistant_message", inputIntent: "queued_turn", runId, nodeId },
141
+ { id: "request", type: "run_interrupt_request", runId, nodeId },
142
+ { id: "result", type: "run_interrupt_result", runId, nodeId },
143
+ { id: "null", type: "user_message", inputIntent: "queued_turn", runId: null, nodeId },
144
+ {
145
+ id: "missing",
146
+ type: "user_message",
147
+ inputIntent: "queued_turn",
148
+ runId: otherRunId,
149
+ nodeId,
150
+ },
151
+ ] satisfies ReadonlyArray<VisibilityInput["items"][number] & { id: string }>;
152
+ const input = {
153
+ runs: [{ id: runId, status }],
154
+ attempts: [],
155
+ items: rows,
156
+ } satisfies VisibilityInput;
157
+ expect(rows.filter((item) => isVisible({ ...input, item })).map((item) => item.id)).toEqual(
158
+ [
159
+ "queued",
160
+ "start",
161
+ "steer",
162
+ "promoted",
163
+ "legacy",
164
+ "assistant",
165
+ "request",
166
+ "result",
167
+ "null",
168
+ "missing",
169
+ ].filter((id) => !hidden.some((hiddenId) => hiddenId === id)),
170
+ );
171
+ });
172
+
173
+ it.each([
174
+ { name: "empty history", runs: [], attempts: [] },
175
+ {
176
+ name: "ordinary attempts",
177
+ runs: [{ id: runId, status: "completed" }],
178
+ attempts: [{ runId, rootNodeId: nodeId, status: "completed" }],
179
+ },
180
+ ] satisfies ReadonlyArray<Pick<VisibilityInput, "runs" | "attempts"> & { name: string }>)(
181
+ "keeps all rows with $name",
182
+ ({ runs, attempts }) => {
183
+ const items = [
184
+ { type: "user_message", inputIntent: "queued_turn", runId, nodeId },
185
+ { type: "run_interrupt_result", runId, nodeId },
186
+ { type: "assistant_message", runId: null, nodeId: null },
187
+ ] satisfies VisibilityInput["items"];
188
+ expect(items.filter((item) => isVisible({ item, runs, attempts, items }))).toEqual(items);
189
+ },
190
+ );
191
+
192
+ it.each([
193
+ { name: "unpaired", runId, nodeId, requests: [], visible: false },
194
+ { name: "second root", runId, nodeId: otherNodeId, requests: [], visible: false },
195
+ { name: "other run", runId: otherRunId, nodeId, requests: [], visible: true },
196
+ {
197
+ name: "unknown root",
198
+ runId,
199
+ nodeId: NodeId.make("node:unknown"),
200
+ requests: [],
201
+ visible: true,
202
+ },
203
+ { name: "null run", runId: null, nodeId, requests: [], visible: true },
204
+ { name: "null node", runId, nodeId: null, requests: [], visible: true },
205
+ { name: "other request", runId, nodeId, requests: [otherRunId], visible: false },
206
+ { name: "null request", runId, nodeId, requests: [null], visible: false },
207
+ { name: "paired request", runId, nodeId, requests: [runId], visible: true },
208
+ ] satisfies ReadonlyArray<{
209
+ name: string;
210
+ runId: VisibilityInput["items"][number]["runId"];
211
+ nodeId: VisibilityInput["items"][number]["nodeId"];
212
+ requests: VisibilityInput["items"][number]["runId"][];
213
+ visible: boolean;
214
+ }>)("matches superseded roots and requests for $name results", (row) => {
215
+ const item = { type: "run_interrupt_result", runId: row.runId, nodeId: row.nodeId } as const;
216
+ const requests = row.requests.map((requestRunId) => ({
217
+ type: "run_interrupt_request" as const,
218
+ runId: requestRunId,
219
+ nodeId: otherNodeId,
220
+ }));
221
+ for (const items of [
222
+ [...requests, item],
223
+ [item, ...requests],
224
+ ]) {
225
+ expect(
226
+ isVisible({
227
+ item,
228
+ runs: [],
229
+ attempts: [
230
+ { runId, rootNodeId: nodeId, status: "superseded" },
231
+ { runId, rootNodeId: otherNodeId, status: "superseded" },
232
+ ],
233
+ items,
234
+ }),
235
+ ).toBe(row.visible);
236
+ }
237
+ });
238
+});
239
+
240
+describe("indexed timeline visibility", () => {
241
+ it.each([
242
+ ...ordinaryStatuses.flatMap(
243
+ (status) =>
244
+ [
245
+ { statuses: ["rolled_back", status], visible: true, ordinaryVisible: true },
246
+ { statuses: ["cancelled", status], visible: true, ordinaryVisible: true },
247
+ { statuses: [status, "rolled_back"], visible: false, ordinaryVisible: false },
248
+ { statuses: [status, "cancelled"], visible: false, ordinaryVisible: true },
249
+ ] as const,
250
+ ),
251
+ { statuses: ["rolled_back", "cancelled"], visible: false, ordinaryVisible: true },
252
+ { statuses: ["cancelled", "rolled_back"], visible: false, ordinaryVisible: false },
253
+ {
254
+ statuses: ["rolled_back", "running", "cancelled", "completed"],
255
+ visible: true,
256
+ ordinaryVisible: true,
257
+ },
258
+ ] satisfies ReadonlyArray<{
259
+ statuses: ReadonlyArray<VisibilityInput["runs"][number]["status"]>;
260
+ visible: boolean;
261
+ ordinaryVisible: boolean;
262
+ }>)(
263
+ "uses the last duplicate run status in $statuses",
264
+ ({ statuses, visible, ordinaryVisible }) => {
265
+ const queued = { type: "user_message", inputIntent: "queued_turn", runId, nodeId } as const;
266
+ const ordinary = { type: "assistant_message", runId, nodeId } as const;
267
+ const isVisible = createOrchestrationV2TurnItemVisibility({
268
+ runs: statuses.map((status) => ({ id: runId, status })),
269
+ attempts: [],
270
+ items: [queued, ordinary],
271
+ });
272
+ expect(isVisible(queued)).toBe(visible);
273
+ expect(isVisible(ordinary)).toBe(ordinaryVisible);
274
+ },
275
+ );
276
+
277
+ it("preserves frozen rows and reads fresh status and attempt snapshots", () => {
278
+ const item = Object.freeze({ type: "run_interrupt_result", runId, nodeId } as const);
279
+ const queued = Object.freeze({
280
+ type: "user_message",
281
+ inputIntent: "queued_turn",
282
+ runId,
283
+ nodeId,
284
+ } as const);
285
+ const items = Object.freeze([item, queued]);
286
+ const attempts = Object.freeze([
287
+ Object.freeze({ runId, rootNodeId: nodeId, status: "superseded" } as const),
288
+ ]);
289
+ const runs = Object.freeze([Object.freeze({ id: runId, status: "running" } as const)]);
290
+ const input = Object.freeze({ runs, attempts, items });
291
+ const before = structuredClone(input);
292
+ const visible = items.filter(createOrchestrationV2TurnItemVisibility(input));
293
+ expect(visible).toEqual([queued]);
294
+ expect(visible[0]).toBe(queued);
295
+ expect(input).toEqual(before);
296
+ expect(
297
+ items.filter(createOrchestrationV2TurnItemVisibility({ ...input, attempts: [] })),
298
+ ).toEqual(items);
299
+ expect(
300
+ items.filter(
301
+ createOrchestrationV2TurnItemVisibility({
302
+ ...input,
303
+ runs: [{ id: runId, status: "cancelled" }],
304
+ }),
305
+ ),
306
+ ).toEqual([]);
307
+ expect(
308
+ items.filter(
309
+ createOrchestrationV2TurnItemVisibility({
310
+ ...input,
311
+ items: [...items, { type: "run_interrupt_request", runId, nodeId: null }],
312
+ }),
313
+ ),
314
+ ).toEqual(items);
315
+ });
316
});
packages/shared/src/orchestrationV2Timeline.ts
+13
-4
@@ -74,7 +74,12 @@ export function createOrchestrationV2TurnItemVisibility(input: {
74
readonly attempts: ReadonlyArray<TimelineRunAttempt>;
75
readonly items: ReadonlyArray<TimelineTurnItem>;
76
}): (item: TimelineTurnItem) => boolean {
77
- const statuses = new Map(input.runs.map((run) => [run.id, run.status]));
77
+ const statuses = new Map<TimelineRun["id"], TimelineRun["status"]>();
78
+ for (const run of input.runs) {
79
+ if (run.status === "rolled_back" || run.status === "cancelled")
80
+ statuses.set(run.id, run.status);
81
+ else statuses.delete(run.id);
82
+ }
83
const supersededRoots = new Map<
84
TimelineRunAttempt["runId"],
85
Set<TimelineRunAttempt["rootNodeId"]>
@@ -85,9 +90,13 @@ export function createOrchestrationV2TurnItemVisibility(input: {
90
if (roots === undefined) supersededRoots.set(attempt.runId, (roots = new Set()));
91
roots.add(attempt.rootNodeId);
92
}
88
- const interruptRuns = new Set(
89
- input.items.filter((item) => item.type === "run_interrupt_request").map((item) => item.runId),
90
- );
93
+ if (statuses.size === 0 && supersededRoots.size === 0) return () => true;
94
+ const interruptRuns = new Set<TimelineTurnItem["runId"]>();
95
+ if (supersededRoots.size > 0) {
96
+ for (const item of input.items) {
97
+ if (item.type === "run_interrupt_request") interruptRuns.add(item.runId);
98
+ }
99
+ }
100
return (item) => {
101
const status = item.runId === null ? undefined : statuses.get(item.runId);
102
if (status === "rolled_back") return false;