The best way to control Claude Code, Codex and more from any computer or phone

main
ts 1,408 lines 47 KB
Raw
1 import { describe, expect, it } from "@effect/vitest";
2 import { EnvironmentNotRegisteredError } from "@t3tools/client-runtime/connection";
3 import { isTransportConnectionErrorMessage } from "@t3tools/client-runtime/errors";
4 import { EnvironmentRpcUnavailableError } from "@t3tools/client-runtime/rpc";
5 import {
6 CommandId,
7 ComposerContextId,
8 EnvironmentAuthorizationError,
9 EnvironmentId,
10 MessageId,
11 OrchestrationDispatchCommandError,
12 ProjectId,
13 ProviderInstanceId,
14 ThreadId,
15 } from "@t3tools/contracts";
16 import { AtomRegistry } from "effect/reactivity";
17 import * as RpcClientError from "effect/rpc/RpcClientError";
18 import * as Socket from "effect/socket/Socket";
19 import { onTestFinished, vi } from "vite-plus/test";
20
21 const outboxFiles = vi.hoisted(() => new Map<string, string | Error>());
22
23 vi.mock("expo-file-system", () => {
24 class Directory {
25 create() {}
26
27 list() {
28 return Array.from(outboxFiles.keys(), (name) => new File(name));
29 }
30 }
31
32 class File {
33 readonly name: string;
34 readonly parentDirectory = new Directory();
35
36 constructor(...parts: [string] | [Directory, string]) {
37 this.name = parts.length === 1 ? parts[0] : parts[1];
38 }
39
40 get exists() {
41 return outboxFiles.has(this.name);
42 }
43
44 create() {
45 outboxFiles.set(this.name, "");
46 }
47
48 write(contents: string) {
49 outboxFiles.set(this.name, contents);
50 }
51
52 moveSync(file: File) {
53 const contents = outboxFiles.get(this.name);
54 if (contents === undefined) throw new Error("Missing file");
55 outboxFiles.set(file.name, contents);
56 outboxFiles.delete(this.name);
57 }
58
59 delete() {
60 outboxFiles.delete(this.name);
61 }
62
63 async text(): Promise<string> {
64 const contents = outboxFiles.get(this.name);
65 if (contents instanceof Error) throw contents;
66 if (contents === undefined) throw new Error("Missing file");
67 return contents;
68 }
69 }
70
71 return {
72 File,
73 Directory,
74 Paths: { document: "/documents" },
75 };
76 });
77
78 import {
79 decodeQueuedThreadMessage,
80 encodeQueuedThreadMessage,
81 isQueuedThreadCreationSendable,
82 resolveThreadOutboxDeliveryAction,
83 resolveThreadOutboxDispatchStep,
84 resolveThreadOutboxFailureAction,
85 resolveQueuedThreadSettings,
86 shouldRetryThreadOutboxDelivery,
87 type QueuedThreadMessage,
88 } from "./thread-outbox-model";
89 import { createThreadOutboxManager, ThreadOutboxManagerError } from "./thread-outbox-manager";
90 import {
91 expoThreadOutboxStorage,
92 ThreadOutboxStorageError,
93 type ThreadOutboxLoadResult,
94 type ThreadOutboxStorage,
95 } from "./thread-outbox-storage";
96
97 function queuedMessage(input: {
98 readonly environmentId?: string;
99 readonly threadId?: string;
100 readonly messageId: string;
101 readonly createdAt: string;
102 }): QueuedThreadMessage {
103 return {
104 environmentId: EnvironmentId.make(input.environmentId ?? "environment-1"),
105 threadId: ThreadId.make(input.threadId ?? "thread-1"),
106 messageId: MessageId.make(input.messageId),
107 commandId: CommandId.make(`command-${input.messageId}`),
108 text: input.messageId,
109 attachments: [],
110 createdAt: input.createdAt,
111 };
112 }
113
114 describe("thread outbox", () => {
115 it("retains structured context through a persisted offline queue round trip", () => {
116 const message: QueuedThreadMessage = {
117 ...queuedMessage({ messageId: "context-message", createdAt: "2026-09-06T12:00:00.000Z" }),
118 text: "[Build](t3-context://v1/terminal/build-output)",
119 context: {
120 version: 1,
121 records: [
122 {
123 version: 1,
124 kind: "terminal",
125 contextId: ComposerContextId.make("build-output"),
126 label: "Build",
127 terminalId: "main",
128 terminalLabel: "Terminal",
129 lineStart: 2,
130 lineEnd: 2,
131 text: "Build failed",
132 },
133 ],
134 },
135 };
136 expect(
137 decodeQueuedThreadMessage(JSON.parse(JSON.stringify(encodeQueuedThreadMessage(message)))),
138 ).toEqual(message);
139 });
140 it.each(["read", "json", "schema"] as const)(
141 "recovers usable messages without permitting cleanup after a record %s failure",
142 async (failure) => {
143 onTestFinished(() => outboxFiles.clear());
144 const first = queuedMessage({
145 messageId: "message-1",
146 createdAt: "2026-06-08T10:00:01.000Z",
147 });
148 const second = queuedMessage({
149 environmentId: "environment-2",
150 messageId: "message-2",
151 createdAt: "2026-06-08T10:00:02.000Z",
152 });
153 outboxFiles.set(
154 "message-2.json",
155 failure === "read"
156 ? new Error("storage unavailable")
157 : failure === "json"
158 ? "{"
159 : JSON.stringify({ ...second, schemaVersion: 999 }),
160 );
161 outboxFiles.set("message-1.json", JSON.stringify(encodeQueuedThreadMessage(first)));
162 const unreadable = outboxFiles.get("message-2.json");
163
164 await expect(expoThreadOutboxStorage.load()).resolves.toMatchObject({
165 messages: [first],
166 errors: [{ operation: "read-message", fileName: "message-2.json" }],
167 });
168
169 const registry = AtomRegistry.make();
170 onTestFinished(() => registry.dispose());
171 const manager = createThreadOutboxManager({
172 registry,
173 storage: expoThreadOutboxStorage,
174 warn: () => {},
175 });
176 await expect(manager.load()).resolves.toBe(false);
177 const recovered = registry.get(manager.queuedMessagesByThreadKeyAtom)[
178 "environment-1:thread-1"
179 ]![0]!;
180 expect(recovered).toEqual(first);
181 await expect(manager.confirmQueued(recovered)).resolves.toBe(true);
182 const edited = { ...recovered, text: "Edited after recovery" };
183 await expect(manager.update(edited)).resolves.toBe(true);
184 const beforeRetry = registry.get(manager.queuedMessagesByThreadKeyAtom);
185 await expect(manager.load()).resolves.toBe(false);
186 expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toBe(beforeRetry);
187 await expect(manager.clearEnvironment(first.environmentId)).rejects.toMatchObject({
188 operation: "clear-environment-load",
189 });
190 expect(outboxFiles.get("message-2.json")).toBe(unreadable);
191 expect(outboxFiles.has("message-1.json")).toBe(true);
192
193 await expect(manager.remove(edited)).resolves.toBe(edited);
194 expect(outboxFiles.has("message-1.json")).toBe(false);
195
196 outboxFiles.set("message-2.json", JSON.stringify(encodeQueuedThreadMessage(second)));
197 await expect(manager.load()).resolves.toBe(true);
198 expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toEqual({
199 "environment-2:thread-1": [second],
200 });
201 await expect(expoThreadOutboxStorage.load()).resolves.toEqual({
202 messages: [second],
203 errors: [],
204 });
205 },
206 );
207
208 it("preserves queued messages when environment cleanup cannot read the outbox", async () => {
209 const registry = AtomRegistry.make();
210 onTestFinished(() => registry.dispose());
211 const message = queuedMessage({
212 messageId: "message-1",
213 createdAt: "2026-06-08T10:00:01.000Z",
214 });
215 const stored = new Map<MessageId, QueuedThreadMessage>();
216 const manager = createThreadOutboxManager({
217 registry,
218 warn: () => {},
219 storage: {
220 load: async () => {
221 throw new Error("storage unavailable");
222 },
223 write: async (entry) => {
224 stored.set(entry.messageId, entry);
225 },
226 remove: async (entry) => {
227 stored.delete(entry.messageId);
228 },
229 },
230 });
231 await manager.enqueue(message);
232
233 await expect(manager.clearEnvironment(message.environmentId)).rejects.toMatchObject({
234 operation: "clear-environment-load",
235 });
236 expect([...stored.values()]).toEqual([message]);
237 expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toEqual({
238 "environment-1:thread-1": [message],
239 });
240 });
241
242 it("keeps in-session edits and removals when an incomplete load is retried", async () => {
243 const registry = AtomRegistry.make();
244 onTestFinished(() => registry.dispose());
245 const message = queuedMessage({
246 messageId: "message-retried",
247 createdAt: "2026-06-08T10:00:01.000Z",
248 });
249 const started = Promise.withResolvers<void>();
250 const response = Promise.withResolvers<ThreadOutboxLoadResult>();
251 const load = vi.fn<ThreadOutboxStorage["load"]>(async () => ({
252 messages: [message],
253 errors: [],
254 }));
255 load.mockImplementationOnce(() => {
256 started.resolve();
257 return response.promise;
258 });
259 const manager = createThreadOutboxManager({
260 registry,
261 storage: { load, write: async () => {}, remove: async () => {} },
262 warn: () => {},
263 });
264 const loading = manager.load();
265 await started.promise;
266 const edited = { ...message, text: "Accepted while storage was being read" };
267 const writing = manager.enqueue(edited);
268 response.resolve({
269 messages: [message],
270 errors: [
271 new ThreadOutboxStorageError({
272 operation: "read-message",
273 environmentId: null,
274 threadId: null,
275 messageId: null,
276 fileName: "unreadable.json",
277 cause: new Error("unreadable record"),
278 }),
279 ],
280 });
281 await expect(loading).resolves.toBe(false);
282 await writing;
283 expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toEqual({
284 "environment-1:thread-1": [edited],
285 });
286 await expect(manager.confirmQueued(edited)).resolves.toBe(true);
287
288 await manager.remove(edited);
289 await expect(manager.load()).resolves.toBe(true);
290 expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toEqual({});
291 expect(load).toHaveBeenCalledTimes(2);
292 });
293
294 it("reads file-backed images from v4 queued messages", () => {
295 const message = {
296 ...queuedMessage({
297 messageId: "message-image",
298 createdAt: "2026-06-08T10:00:01.000Z",
299 }),
300 attachments: [
301 {
302 id: "image-1",
303 type: "image" as const,
304 name: "photo.png",
305 mimeType: "image/png",
306 sizeBytes: 3,
307 fileUri: "file:///documents/t3-composer-attachments/photo.png",
308 previewUri: "file:///documents/t3-composer-attachments/photo.png",
309 uploadedAttachmentId: "pending-photo-png",
310 uploadEnvironmentId: EnvironmentId.make("environment-1"),
311 },
312 ],
313 } satisfies QueuedThreadMessage;
314
315 expect(decodeQueuedThreadMessage({ ...message, schemaVersion: 4 })).toEqual(message);
316 });
317
318 it("persists the exact selector snapshot while remaining compatible with v1 messages", () => {
319 const legacyMessage = queuedMessage({
320 messageId: "message-1",
321 createdAt: "2026-06-08T10:00:01.000Z",
322 });
323 const selectedMessage = {
324 ...legacyMessage,
325 modelSelection: {
326 instanceId: ProviderInstanceId.make("codex"),
327 model: "gpt-5.4",
328 options: [{ id: "reasoningEffort", value: "xhigh" }],
329 },
330 runtimeMode: "approval-required",
331 interactionMode: "plan",
332 dispatchMode: "queue",
333 compactBeforeSend: true,
334 } satisfies QueuedThreadMessage;
335
336 expect(decodeQueuedThreadMessage(encodeQueuedThreadMessage(selectedMessage))).toEqual(
337 selectedMessage,
338 );
339 expect(
340 resolveQueuedThreadSettings(legacyMessage, {
341 modelSelection: selectedMessage.modelSelection,
342 runtimeMode: selectedMessage.runtimeMode,
343 interactionMode: selectedMessage.interactionMode,
344 }),
345 ).toEqual({
346 modelSelection: selectedMessage.modelSelection,
347 runtimeMode: selectedMessage.runtimeMode,
348 interactionMode: selectedMessage.interactionMode,
349 });
350 });
351
352 it("normalizes queued plan mode against the queued provider, not the current thread", () => {
353 const codex = { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.6-sol" };
354 const antigravity = {
355 instanceId: ProviderInstanceId.make("google-personal"),
356 model: "gemini-test-thinking",
357 options: [{ id: "native-option", value: "keep-this-choice" }],
358 };
359 const providers = [
360 { instanceId: codex.instanceId, showInteractionModeToggle: true, models: [] },
361 { instanceId: antigravity.instanceId, showInteractionModeToggle: false, models: [] },
362 ];
363 const message = {
364 ...queuedMessage({ messageId: "queued-plan", createdAt: "2026-09-02T10:00:00.000Z" }),
365 text: "/plan inspect the project",
366 modelSelection: antigravity,
367 interactionMode: "plan",
368 } satisfies QueuedThreadMessage;
369
370 expect(
371 resolveQueuedThreadSettings(
372 message,
373 { modelSelection: codex, runtimeMode: "approval-required", interactionMode: "plan" },
374 providers,
375 ),
376 ).toEqual({
377 modelSelection: antigravity,
378 runtimeMode: "approval-required",
379 interactionMode: "default",
380 });
381 expect(
382 resolveQueuedThreadSettings(
383 { ...message, modelSelection: codex },
384 {
385 modelSelection: antigravity,
386 runtimeMode: "approval-required",
387 interactionMode: "default",
388 },
389 providers,
390 ).interactionMode,
391 ).toBe("plan");
392 });
393
394 // regression: #29729 Cursor runs its own Fast default when the turn carries no fastMode
395 it("sends the Fast off the picker shows for a model without a Fast selection", () => {
396 const cursor = { instanceId: ProviderInstanceId.make("cursor"), model: "composer-2.5" };
397 const providers = [
398 {
399 instanceId: cursor.instanceId,
400 showInteractionModeToggle: true,
401 models: [
402 {
403 slug: cursor.model,
404 capabilities: {
405 optionDescriptors: [
406 { id: "fastMode", label: "Fast", type: "boolean", currentValue: true } as const,
407 ],
408 },
409 },
410 ],
411 },
412 ];
413 const thread = {
414 modelSelection: cursor,
415 runtimeMode: "full-access",
416 interactionMode: "default",
417 } as const;
418 const message = queuedMessage({ messageId: "fast", createdAt: "2026-11-03T10:00:00.000Z" });
419 const fastOn = { ...cursor, options: [{ id: "fastMode", value: true }] };
420
421 expect(resolveQueuedThreadSettings(message, thread, providers).modelSelection.options).toEqual([
422 { id: "fastMode", value: false },
423 ]);
424 expect(
425 resolveQueuedThreadSettings({ ...message, modelSelection: fastOn }, thread, providers)
426 .modelSelection,
427 ).toEqual(fastOn);
428 });
429
430 it("holds the mutation queue while persisted messages are loading", async () => {
431 const registry = AtomRegistry.make();
432 const message = queuedMessage({
433 messageId: "message-1",
434 createdAt: "2026-06-08T10:00:01.000Z",
435 });
436 const stored = new Map([[message.messageId, message]]);
437 let loadCalls = 0;
438 let removeCalls = 0;
439 let releaseInitialLoad!: () => void;
440 const initialLoadBlocked = new Promise<void>((resolve) => {
441 releaseInitialLoad = resolve;
442 });
443 const storage: ThreadOutboxStorage = {
444 load: async () => {
445 loadCalls += 1;
446 if (loadCalls === 1) {
447 await initialLoadBlocked;
448 }
449 return { messages: [...stored.values()], errors: [] };
450 },
451 write: async () => undefined,
452 remove: async (candidate) => {
453 removeCalls += 1;
454 stored.delete(candidate.messageId);
455 },
456 };
457 const manager = createThreadOutboxManager({ registry, storage });
458
459 const loading = manager.load();
460 await Promise.resolve();
461 const clearing = manager.clearEnvironment(message.environmentId);
462 await Promise.resolve();
463 await Promise.resolve();
464
465 expect(loadCalls).toBe(1);
466 expect(removeCalls).toBe(0);
467
468 releaseInitialLoad();
469 await Promise.all([loading, clearing]);
470 expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toEqual({});
471 registry.dispose();
472 });
473
474 it("reports structured load failures and permits a retry", async () => {
475 const registry = AtomRegistry.make();
476 const loadCause = new Error("storage unavailable");
477 const warnings: Array<{ message: string; error: unknown }> = [];
478 let loadCalls = 0;
479 const manager = createThreadOutboxManager({
480 registry,
481 storage: {
482 load: async () => {
483 loadCalls += 1;
484 if (loadCalls === 1) throw loadCause;
485 return { messages: [], errors: [] };
486 },
487 write: async () => undefined,
488 remove: async () => undefined,
489 },
490 warn: (message, error) => warnings.push({ message, error }),
491 });
492
493 await manager.load();
494 expect(warnings).toEqual([
495 {
496 message: "[thread-outbox] failed to load persisted messages",
497 error: new ThreadOutboxManagerError({
498 operation: "load",
499 environmentId: null,
500 threadId: null,
501 messageId: null,
502 cause: loadCause,
503 }),
504 },
505 ]);
506
507 await manager.load();
508 expect(loadCalls).toBe(2);
509 registry.dispose();
510 });
511
512 it("keeps atom state aligned with durable writes and removals", async () => {
513 const registry = AtomRegistry.make();
514 const stored = new Map<MessageId, QueuedThreadMessage>();
515 const removalCause = new Error("remove failed");
516 let failRemoval = true;
517 const storage: ThreadOutboxStorage = {
518 load: async () => ({ messages: [...stored.values()], errors: [] }),
519 write: async (message) => {
520 stored.set(message.messageId, message);
521 },
522 remove: async (message) => {
523 if (failRemoval) {
524 throw removalCause;
525 }
526 stored.delete(message.messageId);
527 },
528 };
529 const manager = createThreadOutboxManager({ registry, storage });
530 const message = queuedMessage({
531 messageId: "message-1",
532 createdAt: "2026-06-08T10:00:01.000Z",
533 });
534
535 await manager.enqueue(message);
536 expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toEqual({
537 "environment-1:thread-1": [message],
538 });
539
540 await expect(manager.remove(message)).rejects.toEqual(
541 new ThreadOutboxManagerError({
542 operation: "remove",
543 environmentId: message.environmentId,
544 threadId: message.threadId,
545 messageId: message.messageId,
546 cause: removalCause,
547 }),
548 );
549 expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toEqual({
550 "environment-1:thread-1": [message],
551 });
552
553 failRemoval = false;
554 await manager.remove(message);
555 expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toEqual({});
556 registry.dispose();
557 });
558
559 it("publishes an enqueued message before the durable write resolves", async () => {
560 const registry = AtomRegistry.make();
561 let releaseWrite!: () => void;
562 const writeBlocked = new Promise<void>((resolve) => {
563 releaseWrite = resolve;
564 });
565 const manager = createThreadOutboxManager({
566 registry,
567 storage: {
568 load: async () => ({ messages: [], errors: [] }),
569 write: async () => writeBlocked,
570 remove: async () => undefined,
571 },
572 });
573 const message = queuedMessage({
574 messageId: "message-1",
575 createdAt: "2026-06-08T10:00:01.000Z",
576 });
577
578 const enqueueing = manager.enqueue(message);
579 expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toEqual({
580 "environment-1:thread-1": [message],
581 });
582
583 releaseWrite();
584 await enqueueing;
585 expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toEqual({
586 "environment-1:thread-1": [message],
587 });
588 registry.dispose();
589 });
590
591 it("rolls an enqueued message back out when the durable write fails", async () => {
592 const registry = AtomRegistry.make();
593 const writeCause = new Error("disk full");
594 const manager = createThreadOutboxManager({
595 registry,
596 storage: {
597 load: async () => ({ messages: [], errors: [] }),
598 write: async () => {
599 throw writeCause;
600 },
601 remove: async () => undefined,
602 },
603 });
604 const message = queuedMessage({
605 messageId: "message-1",
606 createdAt: "2026-06-08T10:00:01.000Z",
607 });
608
609 await expect(manager.enqueue(message)).rejects.toEqual(
610 new ThreadOutboxManagerError({
611 operation: "enqueue",
612 environmentId: message.environmentId,
613 threadId: message.threadId,
614 messageId: message.messageId,
615 cause: writeCause,
616 }),
617 );
618 expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toEqual({});
619 registry.dispose();
620 });
621
622 it("drops the disk entry when a failed enqueue leaves no queued message behind", async () => {
623 const registry = AtomRegistry.make();
624 const removed: string[] = [];
625 const manager = createThreadOutboxManager({
626 registry,
627 storage: {
628 load: async () => ({ messages: [], errors: [] }),
629 write: async () => {
630 throw new Error("disk full");
631 },
632 remove: async (message) => {
633 removed.push(message.messageId);
634 },
635 },
636 });
637 const message = queuedMessage({
638 messageId: "message-1",
639 createdAt: "2026-06-08T10:00:01.000Z",
640 });
641
642 await expect(manager.enqueue(message)).rejects.toBeInstanceOf(ThreadOutboxManagerError);
643 expect(removed).toEqual(["message-1"]);
644 registry.dispose();
645 });
646
647 it("keeps a same-id retry queued when the first attempt's write fails", async () => {
648 const registry = AtomRegistry.make();
649 let failNextWrite = true;
650 let releaseFirstWrite!: () => void;
651 const firstWriteBlocked = new Promise<void>((resolve) => {
652 releaseFirstWrite = resolve;
653 });
654 const manager = createThreadOutboxManager({
655 registry,
656 storage: {
657 load: async () => ({ messages: [], errors: [] }),
658 write: async () => {
659 if (failNextWrite) {
660 failNextWrite = false;
661 await firstWriteBlocked;
662 throw new Error("disk full");
663 }
664 },
665 remove: async () => undefined,
666 },
667 });
668 const message = queuedMessage({
669 messageId: "message-1",
670 createdAt: "2026-06-08T10:00:01.000Z",
671 });
672 const retried = { ...message, text: "retried" };
673
674 const first = manager.enqueue(message);
675 const second = manager.enqueue(retried);
676 releaseFirstWrite();
677 await expect(first).rejects.toBeInstanceOf(ThreadOutboxManagerError);
678 await second;
679
680 expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toEqual({
681 "environment-1:thread-1": [retried],
682 });
683 await expect(manager.confirmQueued(retried)).resolves.toBe(true);
684 await expect(manager.confirmQueued(message)).resolves.toBe(false);
685 registry.dispose();
686 });
687
688 it("updates a queued message in place but never resurrects a removed one", async () => {
689 const registry = AtomRegistry.make();
690 const stored = new Map<MessageId, QueuedThreadMessage>();
691 const storage: ThreadOutboxStorage = {
692 load: async () => ({ messages: [...stored.values()], errors: [] }),
693 write: async (message) => {
694 stored.set(message.messageId, message);
695 },
696 remove: async (message) => {
697 stored.delete(message.messageId);
698 },
699 };
700 const manager = createThreadOutboxManager({ registry, storage });
701 const message = queuedMessage({
702 messageId: "message-1",
703 createdAt: "2026-06-08T10:00:01.000Z",
704 });
705
706 await manager.enqueue(message);
707 const edited = { ...message, text: "edited" };
708 await expect(manager.update(edited)).resolves.toBe(true);
709 expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toEqual({
710 "environment-1:thread-1": [edited],
711 });
712 expect(stored.get(message.messageId)).toEqual(edited);
713
714 await manager.remove(edited);
715 await expect(manager.update({ ...message, text: "stale flush" })).resolves.toBe(false);
716 expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toEqual({});
717 expect(stored.size).toBe(0);
718 registry.dispose();
719 });
720
721 it("composes concurrent modifications of one message instead of rejecting the later one", async () => {
722 const registry = AtomRegistry.make();
723 const stored = new Map<MessageId, QueuedThreadMessage>();
724 const manager = createThreadOutboxManager({
725 registry,
726 storage: {
727 load: async () => ({ messages: [], errors: [] }),
728 write: async (message) => {
729 stored.set(message.messageId, message);
730 },
731 remove: async () => undefined,
732 },
733 });
734 const message = queuedMessage({
735 messageId: "message-two-uploads",
736 createdAt: "2026-06-08T10:00:01.000Z",
737 });
738 await manager.enqueue(message);
739
740 // Two attachments finishing together each record their upload on the same message.
741 const results = await Promise.all([
742 manager.modify(message.messageId, (current) => ({ ...current, text: `${current.text} a` })),
743 manager.modify(message.messageId, (current) => ({ ...current, text: `${current.text} b` })),
744 ]);
745
746 expect(results).toEqual([true, true]);
747 const composed = { ...message, text: `${message.text} a b` };
748 expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toEqual({
749 "environment-1:thread-1": [composed],
750 });
751 expect(stored.get(message.messageId)).toEqual(composed);
752 await manager.remove(composed);
753 await expect(manager.modify(message.messageId, (current) => current)).resolves.toBe(false);
754 registry.dispose();
755 });
756
757 it("rejects a stale revision before its payload reaches durable storage", async () => {
758 const registry = AtomRegistry.make();
759 const writes: string[] = [];
760 const manager = createThreadOutboxManager({
761 registry,
762 storage: {
763 load: async () => ({ messages: [], errors: [] }),
764 write: async (message) => {
765 writes.push(message.text);
766 },
767 remove: async () => undefined,
768 },
769 });
770 const original = queuedMessage({
771 messageId: "message-edit-race",
772 createdAt: "2026-06-08T10:00:01.000Z",
773 });
774 const edited = { ...original, text: "keep my changes" };
775
776 await manager.enqueue(original);
777 const revision = manager.revisionOf(original.messageId);
778 await manager.update(edited);
779
780 await expect(manager.update({ ...original, text: "stale upload" }, revision)).resolves.toBe(
781 false,
782 );
783 expect(writes).toEqual([original.text, "keep my changes"]);
784 expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toEqual({
785 "environment-1:thread-1": [edited],
786 });
787 registry.dispose();
788 });
789
790 it("does not publish a stale attachment update after a replacement appears during its write", async () => {
791 const registry = AtomRegistry.make();
792 const writes: string[] = [];
793 let resumeWrite: () => void = () => {};
794 let signalWriteStarted: () => void = () => {};
795 const writeStarted = new Promise<void>((resolve) => {
796 signalWriteStarted = resolve;
797 });
798 const writeBarrier = new Promise<void>((resolve) => {
799 resumeWrite = resolve;
800 });
801 const manager = createThreadOutboxManager({
802 registry,
803 storage: {
804 load: async () => ({ messages: [], errors: [] }),
805 write: async (message) => {
806 writes.push(message.text);
807 if (message.text === "stale upload") {
808 signalWriteStarted();
809 await writeBarrier;
810 }
811 },
812 remove: async () => undefined,
813 },
814 });
815 const original = queuedMessage({
816 messageId: "message-write-race",
817 createdAt: "2026-06-08T10:00:01.000Z",
818 });
819 const replacement = { ...original, text: "newer edit" };
820
821 await manager.enqueue(original);
822 const update = manager.update(
823 { ...original, text: "stale upload" },
824 manager.revisionOf(original.messageId),
825 );
826 await writeStarted;
827 const enqueue = manager.enqueue(replacement);
828 resumeWrite();
829
830 await expect(update).resolves.toBe(false);
831 expect(writes).toEqual([original.text, "stale upload", "newer edit", "newer edit"]);
832 await enqueue;
833 expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toEqual({
834 "environment-1:thread-1": [replacement],
835 });
836 registry.dispose();
837 });
838
839 it("refuses to remove a message that was rewritten after the removal decision", async () => {
840 const registry = AtomRegistry.make();
841 const stored = new Map<MessageId, QueuedThreadMessage>();
842 const manager = createThreadOutboxManager({
843 registry,
844 storage: {
845 load: async () => ({ messages: [...stored.values()], errors: [] }),
846 write: async (message) => {
847 stored.set(message.messageId, message);
848 },
849 remove: async (message) => {
850 stored.delete(message.messageId);
851 },
852 },
853 });
854 const original = queuedMessage({
855 messageId: "message-remove-race",
856 createdAt: "2026-06-08T10:00:01.000Z",
857 });
858 const edited = { ...original, text: "edited while restoring" };
859
860 await manager.enqueue(original);
861 const revision = manager.revisionOf(original.messageId);
862 await manager.update(edited);
863
864 await expect(manager.remove(original, revision)).resolves.toBe(null);
865 expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toEqual({
866 "environment-1:thread-1": [edited],
867 });
868 expect(stored.get(original.messageId)).toEqual(edited);
869
870 await expect(manager.remove(edited, manager.revisionOf(edited.messageId))).resolves.toEqual(
871 edited,
872 );
873 expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toEqual({});
874 registry.dispose();
875 });
876
877 it("keeps a retry enqueued when its publish races a revision-checked removal", async () => {
878 const registry = AtomRegistry.make();
879 const stored = new Map<MessageId, QueuedThreadMessage>();
880 const removeStarted = Promise.withResolvers<void>();
881 const removeBarrier = Promise.withResolvers<void>();
882 const replacementWriteStarted = Promise.withResolvers<void>();
883 const replacementWriteBarrier = Promise.withResolvers<void>();
884 const original = queuedMessage({
885 messageId: "message-remove-enqueue-race",
886 createdAt: "2026-06-08T10:00:01.000Z",
887 });
888 const retried = { ...original, text: "retried" };
889 const manager = createThreadOutboxManager({
890 registry,
891 storage: {
892 load: async () => ({ messages: [...stored.values()], errors: [] }),
893 write: async (message) => {
894 if (message === retried) {
895 replacementWriteStarted.resolve();
896 await replacementWriteBarrier.promise;
897 }
898 stored.set(message.messageId, message);
899 },
900 remove: async (message) => {
901 removeStarted.resolve();
902 await removeBarrier.promise;
903 stored.delete(message.messageId);
904 },
905 },
906 });
907
908 await manager.enqueue(original);
909 const removal = manager.remove(original, manager.revisionOf(original.messageId));
910 let removalSettled = false;
911 void removal.then(() => {
912 removalSettled = true;
913 });
914 await removeStarted.promise;
915 const enqueue = manager.enqueue(retried);
916 removeBarrier.resolve();
917 await replacementWriteStarted.promise;
918
919 expect(removalSettled).toBe(false);
920 replacementWriteBarrier.resolve();
921 await expect(removal).resolves.toBe(null);
922 expect(stored.get(original.messageId)).toEqual(retried);
923 await enqueue;
924 expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toEqual({
925 "environment-1:thread-1": [retried],
926 });
927 expect(stored.get(original.messageId)).toEqual(retried);
928 registry.dispose();
929 });
930
931 it("restores a message when its live removal predicate changes during storage removal", async () => {
932 const registry = AtomRegistry.make();
933 const stored = new Map<MessageId, QueuedThreadMessage>();
934 const removeStarted = Promise.withResolvers<void>();
935 const removeBarrier = Promise.withResolvers<void>();
936 const manager = createThreadOutboxManager({
937 registry,
938 storage: {
939 load: async () => ({ messages: [...stored.values()], errors: [] }),
940 write: async (message) => {
941 stored.set(message.messageId, message);
942 },
943 remove: async (message) => {
944 removeStarted.resolve();
945 await removeBarrier.promise;
946 stored.delete(message.messageId);
947 },
948 },
949 });
950 const message = queuedMessage({
951 messageId: "message-remove-predicate-race",
952 createdAt: "2026-06-08T10:00:01.000Z",
953 });
954 let canRemove = true;
955
956 await manager.enqueue(message);
957 const removal = manager.remove(message, manager.revisionOf(message.messageId), () => canRemove);
958 await removeStarted.promise;
959 canRemove = false;
960 removeBarrier.resolve();
961
962 await expect(removal).resolves.toBe(null);
963 expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toEqual({
964 "environment-1:thread-1": [message],
965 });
966 expect(stored.get(message.messageId)).toEqual(message);
967 registry.dispose();
968 });
969
970 it("preserves concurrent enqueues while clearing an environment", async () => {
971 const registry = AtomRegistry.make();
972 const stored = new Map<MessageId, QueuedThreadMessage>();
973 const removeStarted = Promise.withResolvers<void>();
974 const removeBarrier = Promise.withResolvers<void>();
975 const manager = createThreadOutboxManager({
976 registry,
977 storage: {
978 load: async () => ({ messages: [...stored.values()], errors: [] }),
979 write: async (message) => {
980 stored.set(message.messageId, message);
981 },
982 remove: async (message) => {
983 if (message.environmentId === EnvironmentId.make("environment-clear")) {
984 removeStarted.resolve();
985 await removeBarrier.promise;
986 }
987 stored.delete(message.messageId);
988 },
989 },
990 });
991 const replaced = queuedMessage({
992 environmentId: "environment-clear",
993 messageId: "message-replaced-during-clear",
994 createdAt: "2026-06-08T10:00:01.000Z",
995 });
996 const removed = queuedMessage({
997 environmentId: "environment-clear",
998 messageId: "message-removed-by-clear",
999 createdAt: "2026-06-08T10:00:02.000Z",
1000 });
1001 const kept = queuedMessage({
1002 environmentId: "environment-keep",
1003 messageId: "message-other-environment",
1004 createdAt: "2026-06-08T10:00:03.000Z",
1005 });
1006 const replacement = { ...replaced, text: "replacement" };
1007 const added = queuedMessage({
1008 environmentId: "environment-clear",
1009 messageId: "message-added-during-clear",
1010 createdAt: "2026-06-08T10:00:04.000Z",
1011 });
1012
1013 await Promise.all([manager.enqueue(replaced), manager.enqueue(removed), manager.enqueue(kept)]);
1014 const clearing = manager.clearEnvironment(replaced.environmentId);
1015 await removeStarted.promise;
1016 const replacing = manager.enqueue(replacement);
1017 const adding = manager.enqueue(added);
1018 removeBarrier.resolve();
1019
1020 await expect(clearing).resolves.toEqual([removed]);
1021 expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toEqual({
1022 "environment-clear:thread-1": [replacement, added],
1023 "environment-keep:thread-1": [kept],
1024 });
1025 expect(stored.get(replacement.messageId)).toEqual(replacement);
1026 expect(stored.has(removed.messageId)).toBe(false);
1027
1028 await Promise.all([replacing, adding]);
1029 expect([...stored.values()]).toEqual(expect.arrayContaining([replacement, added, kept]));
1030 registry.dispose();
1031 });
1032
1033 it("does not restore a message removed before a queued environment clear starts", async () => {
1034 const registry = AtomRegistry.make();
1035 const stored = new Map<MessageId, QueuedThreadMessage>();
1036 const removeStarted = Promise.withResolvers<void>();
1037 const removeBarrier = Promise.withResolvers<void>();
1038 let removeCalls = 0;
1039 const manager = createThreadOutboxManager({
1040 registry,
1041 storage: {
1042 load: async () => ({ messages: [...stored.values()], errors: [] }),
1043 write: async (message) => {
1044 stored.set(message.messageId, message);
1045 },
1046 remove: async (message) => {
1047 removeCalls += 1;
1048 if (removeCalls === 1) {
1049 removeStarted.resolve();
1050 await removeBarrier.promise;
1051 }
1052 stored.delete(message.messageId);
1053 },
1054 },
1055 });
1056 const message = queuedMessage({
1057 environmentId: "environment-clear",
1058 messageId: "message-removed-before-clear",
1059 createdAt: "2026-06-08T10:00:01.000Z",
1060 });
1061
1062 await manager.enqueue(message);
1063 const removal = manager.remove(message);
1064 await removeStarted.promise;
1065 const clearing = manager.clearEnvironment(message.environmentId);
1066 removeBarrier.resolve();
1067
1068 await expect(removal).resolves.toEqual(message);
1069 await expect(clearing).resolves.toEqual([]);
1070 expect(removeCalls).toBe(1);
1071 expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toEqual({});
1072 expect(stored.has(message.messageId)).toBe(false);
1073 registry.dispose();
1074 });
1075
1076 it("keeps an enqueue published while an environment clear waits to start", async () => {
1077 const registry = AtomRegistry.make();
1078 const stored = new Map<MessageId, QueuedThreadMessage>();
1079 const mutationStarted = Promise.withResolvers<void>();
1080 const mutationBarrier = Promise.withResolvers<void>();
1081 let removeCalls = 0;
1082 const manager = createThreadOutboxManager({
1083 registry,
1084 storage: {
1085 load: async () => ({ messages: [...stored.values()], errors: [] }),
1086 write: async (message) => {
1087 stored.set(message.messageId, message);
1088 },
1089 remove: async () => {
1090 removeCalls += 1;
1091 },
1092 },
1093 });
1094 const blocker = manager.serialize(async () => {
1095 mutationStarted.resolve();
1096 await mutationBarrier.promise;
1097 });
1098 await mutationStarted.promise;
1099 const clearing = manager.clearEnvironment(EnvironmentId.make("environment-clear"));
1100 const added = queuedMessage({
1101 environmentId: "environment-clear",
1102 messageId: "message-enqueued-before-clear-start",
1103 createdAt: "2026-06-08T10:00:01.000Z",
1104 });
1105 const enqueue = manager.enqueue(added);
1106 mutationBarrier.resolve();
1107
1108 await blocker;
1109 await expect(clearing).resolves.toEqual([]);
1110 expect(removeCalls).toBe(0);
1111 expect(registry.get(manager.queuedMessagesByThreadKeyAtom)).toEqual({
1112 "environment-clear:thread-1": [added],
1113 });
1114 await enqueue;
1115 expect(stored.get(added.messageId)).toEqual(added);
1116 registry.dispose();
1117 });
1118
1119 it("removes an already-created pending task before the file-capability gate runs", () => {
1120 const fileAttachments = [{ name: "report.pdf", sizeBytes: 42 }];
1121 expect(
1122 resolveThreadOutboxDispatchStep({
1123 deliveryAction: "remove",
1124 fileAttachments,
1125 serverConfig: null,
1126 }),
1127 ).toEqual({ step: "remove" });
1128 expect(
1129 resolveThreadOutboxDispatchStep({
1130 deliveryAction: "remove",
1131 fileAttachments,
1132 serverConfig: { maxFileUploadBytes: undefined },
1133 }),
1134 ).toEqual({ step: "remove" });
1135 });
1136
1137 it("retries instead of parking a file message while the server config loads", () => {
1138 expect(
1139 resolveThreadOutboxDispatchStep({
1140 deliveryAction: "send",
1141 fileAttachments: [{ name: "report.pdf", sizeBytes: 42 }],
1142 serverConfig: null,
1143 }),
1144 ).toEqual({ step: "retry" });
1145 });
1146
1147 it("gates a sending file message on the server's file support and limit", () => {
1148 expect(
1149 resolveThreadOutboxDispatchStep({
1150 deliveryAction: "send",
1151 fileAttachments: [{ name: "report.pdf", sizeBytes: 42 }],
1152 serverConfig: { maxFileUploadBytes: undefined },
1153 }),
1154 ).toEqual({ step: "restore", reason: "This server does not support file attachments." });
1155 expect(
1156 resolveThreadOutboxDispatchStep({
1157 deliveryAction: "send",
1158 fileAttachments: [{ name: "big.zip", sizeBytes: 2 * 1024 * 1024 }],
1159 serverConfig: { maxFileUploadBytes: 1024 * 1024 },
1160 }),
1161 ).toEqual({ step: "restore", reason: "'big.zip' exceeds the 1 MB attachment limit." });
1162 expect(
1163 resolveThreadOutboxDispatchStep({
1164 deliveryAction: "send",
1165 fileAttachments: [{ name: "report.pdf", sizeBytes: 42 }],
1166 serverConfig: { maxFileUploadBytes: 1024 * 1024 },
1167 }),
1168 ).toEqual({ step: "send" });
1169 });
1170
1171 it("only removes a missing-thread message after shell synchronization is live", () => {
1172 expect(
1173 resolveThreadOutboxDeliveryAction({
1174 isCreation: false,
1175 threadExists: false,
1176 shellStatus: "synchronizing",
1177 environmentConnected: true,
1178 }),
1179 ).toBe("wait");
1180 expect(
1181 resolveThreadOutboxDeliveryAction({
1182 isCreation: false,
1183 threadExists: false,
1184 shellStatus: "live",
1185 environmentConnected: true,
1186 }),
1187 ).toBe("remove");
1188 expect(
1189 resolveThreadOutboxDeliveryAction({
1190 isCreation: false,
1191 threadExists: true,
1192 shellStatus: "live",
1193 environmentConnected: true,
1194 }),
1195 ).toBe("send");
1196 });
1197
1198 it("removes a missing-thread message only after a settled family read when idle children can be omitted", () => {
1199 const missing = {
1200 isCreation: false,
1201 threadExists: false,
1202 shellStatus: "live",
1203 environmentConnected: true,
1204 } as const;
1205 expect(resolveThreadOutboxDeliveryAction({ ...missing, familyRead: "pending" })).toBe("wait");
1206 expect(resolveThreadOutboxDeliveryAction({ ...missing, familyRead: "failed" })).toBe("wait");
1207 expect(resolveThreadOutboxDeliveryAction({ ...missing, familyRead: "settled" })).toBe("remove");
1208 });
1209
1210 it("sends existing-thread messages whenever connected so queued messages can steer", () => {
1211 expect(
1212 resolveThreadOutboxDeliveryAction({
1213 isCreation: false,
1214 threadExists: true,
1215 shellStatus: "live",
1216 environmentConnected: true,
1217 }),
1218 ).toBe("send");
1219 expect(
1220 resolveThreadOutboxDeliveryAction({
1221 isCreation: false,
1222 threadExists: true,
1223 shellStatus: "live",
1224 environmentConnected: false,
1225 }),
1226 ).toBe("wait");
1227 });
1228
1229 it("sends queued creations once connected and live, removing already-created ones", () => {
1230 expect(
1231 resolveThreadOutboxDeliveryAction({
1232 isCreation: true,
1233 threadExists: false,
1234 shellStatus: "cached",
1235 environmentConnected: false,
1236 }),
1237 ).toBe("wait");
1238 expect(
1239 resolveThreadOutboxDeliveryAction({
1240 isCreation: true,
1241 threadExists: false,
1242 shellStatus: "synchronizing",
1243 environmentConnected: true,
1244 }),
1245 ).toBe("wait");
1246 expect(
1247 resolveThreadOutboxDeliveryAction({
1248 isCreation: true,
1249 threadExists: false,
1250 shellStatus: "live",
1251 environmentConnected: true,
1252 }),
1253 ).toBe("send");
1254 expect(
1255 resolveThreadOutboxDeliveryAction({
1256 isCreation: true,
1257 threadExists: true,
1258 shellStatus: "live",
1259 environmentConnected: true,
1260 }),
1261 ).toBe("remove");
1262 });
1263
1264 it("round-trips queued PR checkout sources and gates incomplete creations from sending", () => {
1265 const base = queuedMessage({
1266 messageId: "message-1",
1267 createdAt: "2026-06-08T10:00:01.000Z",
1268 });
1269 const creationMessage = {
1270 ...base,
1271 modelSelection: {
1272 instanceId: ProviderInstanceId.make("codex"),
1273 model: "gpt-5.4",
1274 },
1275 creation: {
1276 projectId: ProjectId.make("project-1"),
1277 workspaceMode: "worktree",
1278 branch: "fork/feature",
1279 worktreePath: null,
1280 startFromOrigin: false,
1281 pullRequestReference: "https://github.com/acme/repo/pull/123",
1282 },
1283 } satisfies QueuedThreadMessage;
1284
1285 expect(decodeQueuedThreadMessage(encodeQueuedThreadMessage(creationMessage))).toEqual(
1286 creationMessage,
1287 );
1288 expect(isQueuedThreadCreationSendable(creationMessage)).toBe(true);
1289 expect(
1290 isQueuedThreadCreationSendable({
1291 ...creationMessage,
1292 creation: { ...creationMessage.creation, branch: null },
1293 }),
1294 ).toBe(false);
1295 expect(
1296 isQueuedThreadCreationSendable({
1297 ...creationMessage,
1298 creation: { ...creationMessage.creation, branch: "" },
1299 }),
1300 ).toBe(false);
1301 expect(isQueuedThreadCreationSendable({ ...creationMessage, modelSelection: undefined })).toBe(
1302 false,
1303 );
1304 expect(isQueuedThreadCreationSendable(base)).toBe(false);
1305 expect(isQueuedThreadCreationSendable({ ...creationMessage, text: " " })).toBe(false);
1306 expect(
1307 isQueuedThreadCreationSendable({
1308 ...creationMessage,
1309 text: "",
1310 attachments: [
1311 {
1312 id: "image-1",
1313 type: "image",
1314 name: "photo.png",
1315 mimeType: "image/png",
1316 sizeBytes: 3,
1317 fileUri: "file:///documents/t3-composer-attachments/photo.png",
1318 previewUri: "file:///documents/t3-composer-attachments/photo.png",
1319 uploadedAttachmentId: "pending-photo-png",
1320 uploadEnvironmentId: EnvironmentId.make("environment-1"),
1321 },
1322 ],
1323 }),
1324 ).toBe(true);
1325 });
1326
1327 it("retries transport failures but drops deterministic command failures", () => {
1328 expect(shouldRetryThreadOutboxDelivery(new Error("Socket is not connected"))).toBe(true);
1329 expect(
1330 shouldRetryThreadOutboxDelivery({
1331 _tag: "ConnectionTransientError",
1332 message: "temporarily unavailable",
1333 }),
1334 ).toBe(true);
1335 expect(shouldRetryThreadOutboxDelivery(new Error("Thread no longer exists"))).toBe(false);
1336 expect(
1337 shouldRetryThreadOutboxDelivery(
1338 new OrchestrationDispatchCommandError({ message: "Thread no longer exists" }),
1339 ),
1340 ).toBe(false);
1341 expect(
1342 shouldRetryThreadOutboxDelivery(
1343 new EnvironmentAuthorizationError({
1344 message: "Missing scope",
1345 requiredScope: "orchestration:operate",
1346 }),
1347 ),
1348 ).toBe(false);
1349 });
1350
1351 it("retries every in-flight transport failure by tag, not by message text", () => {
1352 const socketReasons = [
1353 new Socket.SocketReadError({ cause: new Error("The network connection was lost.") }),
1354 new Socket.SocketWriteError({ cause: new Error("Broken pipe") }),
1355 new Socket.SocketCloseError({ code: 1006 }),
1356 new Socket.SocketOpenError({ kind: "Timeout", cause: new Error("timeout") }),
1357 ];
1358 for (const reason of socketReasons) {
1359 const error = new RpcClientError.RpcClientError({ reason });
1360 expect(isTransportConnectionErrorMessage(error.message)).toBe(
1361 reason._tag === "SocketCloseError" || reason._tag === "SocketOpenError",
1362 );
1363 expect(shouldRetryThreadOutboxDelivery(error)).toBe(true);
1364 }
1365 expect(
1366 shouldRetryThreadOutboxDelivery(
1367 new RpcClientError.RpcClientError({
1368 reason: new RpcClientError.RpcClientDefect({
1369 message: "Error decoding message",
1370 cause: new Error("Unexpected end of JSON input"),
1371 }),
1372 }),
1373 ),
1374 ).toBe(true);
1375 expect(
1376 shouldRetryThreadOutboxDelivery(
1377 new EnvironmentRpcUnavailableError({
1378 environmentId: "environment-1",
1379 message: "Home is not connected.",
1380 }),
1381 ),
1382 ).toBe(true);
1383 expect(
1384 shouldRetryThreadOutboxDelivery(
1385 new EnvironmentNotRegisteredError({ environmentId: EnvironmentId.make("environment-1") }),
1386 ),
1387 ).toBe(true);
1388 });
1389
1390 it("retains queued messages when settings synchronization fails before startTurn", () => {
1391 const deterministicFailure = new Error("Thread no longer exists");
1392
1393 expect(
1394 resolveThreadOutboxFailureAction({
1395 stage: "settings-sync",
1396 error: deterministicFailure,
1397 interrupted: false,
1398 }),
1399 ).toBe("retry");
1400 expect(
1401 resolveThreadOutboxFailureAction({
1402 stage: "start-turn",
1403 error: deterministicFailure,
1404 interrupted: false,
1405 }),
1406 ).toBe("restore");
1407 });
1408 });