@devries-cameron20 / t3code-1 / commits / 0a86e157a0
Fork 0

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;