The best way to control Claude Code, Codex and more from any computer or phone
refactor(mobile): deliver queued messages with one Effect fiber per thread (#37725)
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Julius Marminge committed
Nov 16, 2026 at 12:15 UTC
07e8bfa70d6e237baa769842d2b406c0eb4b65c7
12 files changed
+1504
-1331
apps/mobile/src/lib/composerAttachmentUploadQueue.ts
-24
@@ -114,30 +114,6 @@ export function composerAttachmentsStillUploading(input: {
114
});
115
}
116
117
-/** Changes when an upload starts or settles, not on its progress ticks. */
118
-export function uploadingComposerAttachmentKeys(
119
- states: Readonly<Record<string, ComposerAttachmentUploadState>>,
120
-): string {
121
- return Object.keys(states)
122
- .filter((key) => states[key]?.status === "uploading")
123
- .sort()
124
- .join("\n");
125
-}
126
-
127
-/** A queued message waits for the worker's upload instead of starting a second one. */
128
-export function queuedAttachmentsStillUploading(input: {
129
- readonly environmentId: EnvironmentId;
130
- readonly attachments: ReadonlyArray<DraftComposerAttachment>;
131
- readonly states: Readonly<Record<string, ComposerAttachmentUploadState>>;
132
-}): boolean {
133
- return input.attachments.some(
134
- (attachment) =>
135
- attachment.uploadedAttachmentId === undefined &&
136
- input.states[composerAttachmentUploadKey(input.environmentId, attachment.id)]?.status ===
137
- "uploading",
138
- );
139
-}
140
-
117
/** Equal by environment and attachment id; the request rides along for the upload. */
118
class UploadKey implements Equal.Equal {
119
constructor(
apps/mobile/src/state/composer-attachment-upload-states.ts
deleted
-8
@@ -1,8 +0,0 @@
1
-import { Atom } from "effect/reactivity";
2
-
3
-import type { ComposerAttachmentUploadState } from "../lib/composerAttachmentUploadQueue";
4
-
5
-/** The upload worker's per-attachment states, apart from the worker so the outbox can read them. */
6
-export const composerAttachmentUploadsAtom = Atom.make<
7
- Readonly<Record<string, ComposerAttachmentUploadState>>
8
->({}).pipe(Atom.keepAlive);
apps/mobile/src/state/composer-attachment-uploads.test.ts
+26
-23
@@ -1,5 +1,7 @@
1
import { CommandId, EnvironmentId, MessageId, ThreadId } from "@t3tools/contracts";
2
-import { afterEach, beforeEach, expect, it, vi } from "vite-plus/test";
2
+import { expect, it } from "@effect/vitest";
3
+import * as Effect from "effect/Effect";
4
+import { afterEach, beforeEach, vi } from "vite-plus/test";
5
6
type UploadOptions = {
7
signal: AbortSignal;
@@ -167,7 +169,7 @@ vi.mock("./use-thread-outbox", async () => {
169
const { Atom } = await import("effect/reactivity");
170
return {
171
editingQueuedMessageIdsAtom: Atom.make<Record<string, boolean>>({}).pipe(Atom.keepAlive),
170
- dispatchingQueuedMessageIdAtom: Atom.make<Record<string, string>>({}).pipe(Atom.keepAlive),
172
+ dispatchingQueuedMessageIdsAtom: Atom.make<Record<string, true>>({}).pipe(Atom.keepAlive),
173
useThreadOutboxMessages: () =>
174
appAtomRegistry.get(threadOutboxManager.queuedMessagesByThreadKeyAtom),
175
retryingQueuedMessageIdsAtom: Atom.make({}).pipe(Atom.keepAlive),
@@ -296,29 +298,30 @@ function uploadState() {
298
];
299
}
300
299
-it.each(["decode", "write"] as const)(
301
+it.effect.each(["decode", "write"] as const)(
302
"keeps an accepted upload ready when the draft %s fails",
301
- async (fault) => {
302
- native.fault = fault;
303
- if (fault === "decode")
304
- native.files.set(draftsUri, Buffer.from('{"schemaVersion":1,"drafts":'));
305
- drafts.resetComposerDraftsLoadState();
306
- const queue = worker();
307
- await queue.settled();
308
- expect(uploadState()).toEqual({ status: "ready" });
309
- expect(native.deleted).toEqual([]);
310
- expect(composerAttachmentUploadBlockReason(sendInput())).toBeNull();
311
- expect(composerAttachmentsStillUploading(sendInput())).toBe(false);
303
+ (fault) =>
304
+ Effect.gen(function* () {
305
+ native.fault = fault;
306
+ if (fault === "decode")
307
+ native.files.set(draftsUri, Buffer.from('{"schemaVersion":1,"drafts":'));
308
+ drafts.resetComposerDraftsLoadState();
309
+ const queue = worker();
310
+ yield* Effect.promise(() => queue.settled());
311
+ expect(uploadState()).toEqual({ status: "ready" });
312
+ expect(native.deleted).toEqual([]);
313
+ expect(composerAttachmentUploadBlockReason(sendInput())).toBeNull();
314
+ expect(composerAttachmentsStillUploading(sendInput())).toBe(false);
315
313
- const message = queuedMessage();
314
- expect(message.attachments[0]?.uploadedAttachmentId).toBe("pending-1");
315
- await enqueueThreadOutboxMessage(message);
316
- const prepared = await prepareQueuedMessageAttachments(message);
317
- expect(prepared.status).toBe("ready");
318
- if (prepared.status !== "ready") throw new Error("Outbox preparation abandoned");
319
- expect(prepared.prepared.pendingAttachmentIds).toEqual(["pending-1"]);
320
- expect(native.transfer).toHaveBeenCalledTimes(1);
321
- },
316
+ const message = queuedMessage();
317
+ expect(message.attachments[0]?.uploadedAttachmentId).toBe("pending-1");
318
+ yield* Effect.promise(() => enqueueThreadOutboxMessage(message));
319
+ const prepared = yield* prepareQueuedMessageAttachments(message);
320
+ expect(prepared.status).toBe("ready");
321
+ if (prepared.status !== "ready") throw new Error("Outbox preparation abandoned");
322
+ expect(prepared.prepared.pendingAttachmentIds).toEqual(["pending-1"]);
323
+ expect(native.transfer).toHaveBeenCalledTimes(1);
324
+ }),
325
);
326
327
it("keeps an upload running when its message is sent mid-upload and records it on the message", async () => {
apps/mobile/src/state/composer-attachment-uploads.ts
+4
-2
@@ -16,9 +16,9 @@ import {
16
composerDraftEnvironmentId,
17
canUploadComposerAttachment,
18
createComposerAttachmentUploadQueue,
19
+ type ComposerAttachmentUploadState,
20
} from "../lib/composerAttachmentUploadQueue";
21
import { appAtomRegistry } from "./atom-registry";
21
-import { composerAttachmentUploadsAtom } from "./composer-attachment-upload-states";
22
import { environmentServerConfigsAtom } from "./server";
23
import {
24
flattenQueuedThreadMessages,
@@ -46,7 +46,9 @@ export {
46
composerAttachmentsStillUploading,
47
} from "../lib/composerAttachmentUploadQueue";
48
49
-export { composerAttachmentUploadsAtom };
49
+export const composerAttachmentUploadsAtom = Atom.make<
50
+ Readonly<Record<string, ComposerAttachmentUploadState>>
51
+>({}).pipe(Atom.keepAlive);
52
const uploadStateAtom = Atom.family((key: string) =>
53
Atom.map(composerAttachmentUploadsAtom, (states) => states[key]),
54
);
apps/mobile/src/state/edit-pending-thread-message.test.ts
+4
-4
@@ -3,7 +3,7 @@ import { CommandId, EnvironmentId, MessageId, ThreadId } from "@t3tools/contract
3
import type { QueuedThreadMessage } from "./thread-outbox-model";
4
5
const state = vi.hoisted(() => ({
6
- dispatching: null as string | null,
6
+ dispatching: {} as Record<string, true>,
7
held: {} as Record<string, true>,
8
draft: { text: "Existing draft", attachments: [] as { id: string }[] },
9
confirm: vi.fn(async () => true),
@@ -16,7 +16,7 @@ vi.mock("./atom-registry", () => ({
16
},
17
}));
18
vi.mock("./use-thread-outbox", () => ({
19
- dispatchingQueuedMessageIdAtom: "dispatching",
19
+ dispatchingQueuedMessageIdsAtom: "dispatching",
20
editingQueuedMessageIdsAtom: "editing",
21
holdEditingQueuedMessage: (id: string) => {
22
state.held[id] = true;
@@ -67,7 +67,7 @@ const message: QueuedThreadMessage = {
67
};
68
beforeEach(() => {
69
vi.clearAllMocks();
70
- state.dispatching = null;
70
+ state.dispatching = {};
71
state.held = {};
72
state.draft = { text: "Existing draft", attachments: [] };
73
state.confirm.mockResolvedValue(true);
@@ -90,7 +90,7 @@ describe("editing a pending message", () => {
90
expect(state.held).toEqual({});
91
});
92
it("does not reclaim a message already being dispatched", async () => {
93
- state.dispatching = message.messageId;
93
+ state.dispatching = { [message.messageId]: true };
94
expect(await editPendingThreadMessage(message)).toBe(false);
95
expect(state.confirm).not.toHaveBeenCalled();
96
expect(state.draft.text).toBe("Existing draft");
apps/mobile/src/state/edit-pending-thread-message.ts
+2
-2
@@ -16,7 +16,7 @@ import {
16
waitForComposerDraftsLoaded,
17
} from "./use-composer-drafts";
18
import {
19
- dispatchingQueuedMessageIdAtom,
19
+ dispatchingQueuedMessageIdsAtom,
20
editingQueuedMessageIdsAtom,
21
holdEditingQueuedMessage,
22
releaseEditingQueuedMessage,
@@ -26,7 +26,7 @@ import {
26
export async function editPendingThreadMessage(message: QueuedThreadMessage): Promise<boolean> {
27
if (
28
message.creation ||
29
- appAtomRegistry.get(dispatchingQueuedMessageIdAtom) === message.messageId ||
29
+ appAtomRegistry.get(dispatchingQueuedMessageIdsAtom)[message.messageId] ||
30
appAtomRegistry.get(editingQueuedMessageIdsAtom)[message.messageId]
31
) {
32
return false;
apps/mobile/src/state/thread-task-permissions.test.ts
+1
-1
@@ -141,7 +141,7 @@ vi.mock("./threads", async () => {
141
});
142
vi.mock("./use-thread-outbox", async () => {
143
const { Atom } = await import("effect/reactivity");
144
- return { dispatchingQueuedMessageIdAtom: Atom.make(null), useThreadOutboxMessages: () => ({}) };
144
+ return { dispatchingQueuedMessageIdsAtom: Atom.make({}), useThreadOutboxMessages: () => ({}) };
145
});
146
vi.mock("./thread-outbox", () => ({ enqueueThreadOutboxMessage: state.enqueue }));
147
vi.mock("./composer-attachment-uploads", async () => {
apps/mobile/src/state/threadOutboxDelivery.permissions.test.ts
+90
-42
@@ -138,7 +138,9 @@ vi.mock("./use-thread-outbox", async () => {
138
const { Atom } = await import("effect/reactivity");
139
return {
140
editingQueuedMessageIdsAtom: Atom.make({}).pipe(Atom.keepAlive),
141
- dispatchingQueuedMessageIdAtom: Atom.make<MessageId | null>(null).pipe(Atom.keepAlive),
141
+ dispatchingQueuedMessageIdsAtom: Atom.make<Readonly<Record<MessageId, true>>>({}).pipe(
142
+ Atom.keepAlive,
143
+ ),
144
retryingQueuedMessageIdsAtom: Atom.make({}).pipe(Atom.keepAlive),
145
threadOutboxShellStatusesAtom: Atom.make(new Map([["secondary", "live"]])),
146
};
@@ -149,7 +151,7 @@ vi.mock("./use-composer-drafts", async () => {
151
composerDraftsAtom: Atom.make({}),
152
removeDeliveredCloudQueuedMessage: async () => {},
153
appendComposerDraftAttachments: vi.fn(),
152
- flushComposerDrafts: vi.fn(),
154
+ flushComposerDrafts: vi.fn(async () => {}),
155
getComposerDraftSnapshot: vi.fn(() => ({ text: state.draftText, attachments: [] })),
156
mergeComposerDraftContent: vi.fn(async (_key: string, input: { text: string }) => {
157
state.draftText += `\n${input.text}`;
@@ -164,9 +166,10 @@ vi.mock("./use-composer-drafts", async () => {
166
167
import { appAtomRegistry } from "./atom-registry";
168
import { environmentSession } from "./session";
167
-import { dispatchingQueuedMessageIdAtom, editingQueuedMessageIdsAtom } from "./use-thread-outbox";
169
+import { dispatchingQueuedMessageIdsAtom, editingQueuedMessageIdsAtom } from "./use-thread-outbox";
170
+
171
+const sendingMessageIds = () => Object.keys(appAtomRegistry.get(dispatchingQueuedMessageIdsAtom));
172
import { createThreadOutboxDelivery } from "./threadOutboxDelivery";
169
-import { composerAttachmentUploadsAtom } from "./composer-attachment-upload-states";
173
import { workspaceConnections } from "./workspace";
174
175
const message = (overrides: Partial<QueuedThreadMessage> = {}): QueuedThreadMessage => ({
@@ -190,8 +193,8 @@ function setOperateGrant(environmentId: string, granted: boolean): void {
193
194
function runDrain() {
195
const settled = Promise.withResolvers<void>();
193
- const release = appAtomRegistry.subscribe(dispatchingQueuedMessageIdAtom, (id) => {
194
- if (id === null) settled.resolve();
196
+ const release = appAtomRegistry.subscribe(dispatchingQueuedMessageIdsAtom, (ids) => {
197
+ if (Object.keys(ids).length === 0) settled.resolve();
198
});
199
startDelivery();
200
return settled.promise.finally(release);
@@ -220,7 +223,7 @@ beforeEach(() => {
223
state.familyMount.mockReset().mockReturnValue(() => {});
224
appAtomRegistry.set(state.threadShells, [state.thread]);
225
appAtomRegistry.set(state.manager.queuedMessagesByThreadKeyAtom, {});
223
- appAtomRegistry.set(dispatchingQueuedMessageIdAtom, null);
226
+ appAtomRegistry.set(dispatchingQueuedMessageIdsAtom, {});
227
appAtomRegistry.set(editingQueuedMessageIdsAtom, {});
228
for (const command of [
229
state.start,
@@ -361,7 +364,7 @@ describe("queued task operation access", () => {
364
expect(state.modelUnavailable).toHaveBeenCalledOnce();
365
expect(state.prepare).not.toHaveBeenCalled();
366
expect(state.start).not.toHaveBeenCalled();
364
- expect(appAtomRegistry.get(dispatchingQueuedMessageIdAtom)).toBeNull();
367
+ expect(sendingMessageIds()).toEqual([]);
368
expect(remaining()).toEqual([queued]);
369
});
370
@@ -378,17 +381,17 @@ describe("queued task operation access", () => {
381
startDelivery();
382
appAtomRegistry.set(editingQueuedMessageIdsAtom, { [queued.messageId]: true });
383
await state.manager.enqueue(queued);
381
- using confirm = vi.spyOn(state.manager, "confirmQueued");
384
const delivered = Promise.withResolvers<void>();
383
- const release = appAtomRegistry.subscribe(dispatchingQueuedMessageIdAtom, (id) => {
384
- if (id === null) delivered.resolve();
385
+ const release = appAtomRegistry.subscribe(dispatchingQueuedMessageIdsAtom, (ids) => {
386
+ if (Object.keys(ids).length === 0) delivered.resolve();
387
});
386
- // Ending the edit wakes the drain through a registry notification, the path on which the
387
- // mount's synchronous row change notifies the drain again mid-pass.
388
+ // Ending the edit wakes the thread through a registry notification, the path on which the
389
+ // mount's synchronous row change wakes it again while it is deciding.
390
appAtomRegistry.set(editingQueuedMessageIdsAtom, {});
389
- expect(state.familyMount).toHaveBeenCalledOnce();
390
- expect(confirm).toHaveBeenCalledOnce();
391
await delivered.promise.finally(release);
392
+ expect(state.familyMount).toHaveBeenCalledOnce();
393
+ // One fiber took the message: a second would have prepared it again.
394
+ expect(state.prepare).toHaveBeenCalledOnce();
395
expect(state.start).toHaveBeenCalledOnce();
396
expect(remaining()).toEqual([]);
397
});
@@ -544,8 +547,8 @@ describe("queued task whose launch reply is lost", () => {
547
548
async function fireRetry(): Promise<void> {
549
const settled = Promise.withResolvers<void>();
547
- const release = appAtomRegistry.subscribe(dispatchingQueuedMessageIdAtom, (id) => {
548
- if (id === null) settled.resolve();
550
+ const release = appAtomRegistry.subscribe(dispatchingQueuedMessageIdsAtom, (ids) => {
551
+ if (Object.keys(ids).length === 0) settled.resolve();
552
});
553
vi.advanceTimersByTime(threadOutboxRetryDelayMs(1));
554
await settled.promise.finally(release);
@@ -577,7 +580,7 @@ describe("queued task whose launch reply is lost", () => {
580
await loseLaunchReply(queuedTask());
581
setOperateGrant("secondary", false);
582
vi.advanceTimersByTime(threadOutboxRetryDelayMs(1));
580
- expect(appAtomRegistry.get(dispatchingQueuedMessageIdAtom)).toBeNull();
583
+ expect(sendingMessageIds()).toEqual([]);
584
expect(state.start).toHaveBeenCalledOnce();
585
expect(remaining()).toHaveLength(1);
586
@@ -665,42 +668,87 @@ describe("compaction before a queued send", () => {
668
describe("queued delivery timing", () => {
669
/** Runs `change`, then resolves once the delivery it starts has settled. */
670
async function deliveryAfter(change: () => void): Promise<void> {
671
+ const started = Promise.withResolvers<void>();
672
const settled = Promise.withResolvers<void>();
669
- const release = appAtomRegistry.subscribe(dispatchingQueuedMessageIdAtom, (id) => {
670
- if (id === null) settled.resolve();
673
+ const release = appAtomRegistry.subscribe(dispatchingQueuedMessageIdsAtom, (ids) => {
674
+ if (Object.keys(ids).length > 0) started.resolve();
675
+ else settled.resolve();
676
});
677
change();
673
- expect(appAtomRegistry.get(dispatchingQueuedMessageIdAtom)).not.toBeNull();
678
+ await started.promise;
679
await settled.promise.finally(release);
680
}
681
677
- it("waits for the composer's upload of a sent attachment instead of uploading it again", async () => {
682
+ it("starts a thread's next message only after its interrupted send has finished", async () => {
683
setOperateGrant("secondary", true);
679
- const photo = {
680
- id: "photo-1",
681
- type: "image" as const,
682
- name: "photo.png",
683
- mimeType: "image/png",
684
- sizeBytes: 3,
685
- previewUri: "file:///photo.png",
686
- fileUri: "file:///photo.png",
687
- };
688
- appAtomRegistry.set(composerAttachmentUploadsAtom, {
689
- "secondary:photo-1": { status: "uploading", progress: 0.5 },
684
+ const firstStarted = Promise.withResolvers<void>();
685
+ const finishFirst = Promise.withResolvers<AsyncResult.AsyncResult<object, never>>();
686
+ state.start.mockImplementationOnce(async () => {
687
+ firstStarted.resolve();
688
+ return finishFirst.promise;
689
});
691
- state.cleanups.push(() => appAtomRegistry.set(composerAttachmentUploadsAtom, {}));
692
- await state.manager.enqueue(message({ attachments: [photo] }));
690
+ const first = message();
691
+ await state.manager.enqueue(first);
692
startDelivery();
694
- expect(appAtomRegistry.get(dispatchingQueuedMessageIdAtom)).toBeNull();
693
+ await firstStarted.promise;
694
+ // The queue empties under the running send, then the thread gets its next message.
695
+ await state.manager.remove(first);
696
+ const allDelivered = Promise.withResolvers<void>();
697
+ const release = appAtomRegistry.subscribe(state.manager.queuedMessagesByThreadKeyAtom, () => {
698
+ if (remaining().length === 0) allDelivered.resolve();
699
+ });
700
+ await state.manager.enqueue(
701
+ message({ messageId: MessageId.make("next"), commandId: CommandId.make("next-command") }),
702
+ );
703
+ // The next message waits; only the interrupted send is still marked as sending.
704
+ expect(sendingMessageIds()).toEqual(["message"]);
705
+ expect(state.start).toHaveBeenCalledOnce();
706
+ finishFirst.resolve(AsyncResult.success({}));
707
+ await allDelivered.promise.finally(release);
708
+ expect(state.start).toHaveBeenCalledTimes(2);
709
+ });
710
696
- await deliveryAfter(() =>
697
- appAtomRegistry.set(composerAttachmentUploadsAtom, {
698
- "secondary:photo-1": { status: "ready" },
711
+ it("sends another thread's message while one thread's send is still running", async () => {
712
+ setOperateGrant("secondary", true);
713
+ const other = { ...state.thread, id: "other" };
714
+ appAtomRegistry.set(state.threadShells, [state.thread, other]);
715
+ const slowStarted = Promise.withResolvers<void>();
716
+ const finishSlow = Promise.withResolvers<AsyncResult.AsyncResult<object, never>>();
717
+ state.start.mockImplementation(async ({ input }: { input: { threadId: string } }) => {
718
+ if (input.threadId !== "thread") return AsyncResult.success({});
719
+ slowStarted.resolve();
720
+ return finishSlow.promise;
721
+ });
722
+ /** Resolves once only these message ids are still queued. */
723
+ const queuedBecomes = (ids: ReadonlyArray<string>) => {
724
+ const reached = Promise.withResolvers<void>();
725
+ const release = appAtomRegistry.subscribe(state.manager.queuedMessagesByThreadKeyAtom, () => {
726
+ if (
727
+ remaining()
728
+ .map((queued) => queued.messageId)
729
+ .join() === ids.join()
730
+ ) {
731
+ reached.resolve();
732
+ }
733
+ });
734
+ return reached.promise.finally(release);
735
+ };
736
+ await state.manager.enqueue(message());
737
+ startDelivery();
738
+ await slowStarted.promise;
739
+ const otherDelivered = queuedBecomes(["message"]);
740
+ await state.manager.enqueue(
741
+ message({
742
+ threadId: ThreadId.make("other"),
743
+ messageId: MessageId.make("other-message"),
744
+ commandId: CommandId.make("other-command"),
745
}),
746
);
701
- expect(state.prepare).toHaveBeenCalledOnce();
702
- expect(state.start).toHaveBeenCalledOnce();
703
- expect(remaining()).toEqual([]);
747
+ await otherDelivered;
748
+ const allDelivered = queuedBecomes([]);
749
+ finishSlow.resolve(AsyncResult.success({}));
750
+ await allDelivered;
751
+ expect(state.start).toHaveBeenCalledTimes(2);
752
});
753
754
it("sends at once when its environment reconnects instead of waiting out the backoff", async () => {
apps/mobile/src/state/threadOutboxDelivery.test.ts
+573
-485
@@ -3,6 +3,7 @@ import {
3
pruneCaughtUpAcknowledgedThreadMessages,
4
} from "./acknowledged-thread-messages";
5
import * as Effect from "effect/Effect";
6
+import * as Fiber from "effect/Fiber";
7
import {
8
CommandId,
9
EnvironmentId,
@@ -11,7 +12,8 @@ import {
12
ProviderInstanceId,
13
ThreadId,
14
} from "@t3tools/contracts";
14
-import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";
15
+import { describe, expect, it } from "@effect/vitest";
16
+import { afterEach, beforeEach, vi } from "vite-plus/test";
17
18
import type { PreparedTurnAttachments } from "../lib/attachmentUpload";
19
@@ -121,7 +123,7 @@ vi.mock("./use-thread-outbox", async () => {
123
const { Atom } = await import("effect/reactivity");
124
return {
125
editingQueuedMessageIdsAtom: Atom.make<Record<string, boolean>>({}).pipe(Atom.keepAlive),
124
- dispatchingQueuedMessageIdAtom: Atom.make(null).pipe(Atom.keepAlive),
126
+ dispatchingQueuedMessageIdsAtom: Atom.make({}).pipe(Atom.keepAlive),
127
retryingQueuedMessageIdsAtom: Atom.make({}).pipe(Atom.keepAlive),
128
threadOutboxShellStatusesAtom: Atom.make(new Map()),
129
};
@@ -160,6 +162,7 @@ import { recoverFailedThreadDraft } from "./recover-failed-thread-draft";
162
import { editingQueuedMessageIdsAtom } from "./use-thread-outbox";
163
import {
164
completeQueuedMessageDelivery,
165
+ type DeliveryRetry,
166
prepareQueuedMessageAttachments,
167
recoverEditedCreationAfterDelivery,
168
removeAcknowledgedExistingThreadMessage,
@@ -235,447 +238,522 @@ afterEach(() => {
238
harness.prepareTurnAttachments.mockReset();
239
});
240
241
+/** True once a delivery step handled its message, false when it asks to retry. */
242
+const handled = (step: Effect.Effect<void, DeliveryRetry>) =>
243
+ step.pipe(Effect.as(true), Effect.catchTags({ DeliveryRetry: () => Effect.succeed(false) }));
244
+
245
describe("thread outbox attachment preparation", () => {
239
- it("keeps a denied message queued without starting its attachment upload", async () => {
240
- const message = queuedMessage({
241
- messageId: "denied-queued-message",
242
- text: "Keep this queued",
243
- fileUri: "file:///documents/keep.pdf",
244
- });
245
- await harness.manager.enqueue(message);
246
- harness.prepareTurnAttachments.mockReturnValueOnce(
247
- Effect.succeed({
246
+ it.effect("keeps a denied message queued without starting its attachment upload", () =>
247
+ Effect.gen(function* () {
248
+ const message = queuedMessage({
249
+ messageId: "denied-queued-message",
250
+ text: "Keep this queued",
251
+ fileUri: "file:///documents/keep.pdf",
252
+ });
253
+ yield* Effect.promise(() => harness.manager.enqueue(message));
254
+ harness.prepareTurnAttachments.mockReturnValueOnce(
255
+ Effect.succeed({
256
+ status: "ready",
257
+ attachments: [],
258
+ draftAttachments: message.attachments,
259
+ pendingAttachmentIds: [],
260
+ }),
261
+ );
262
+ harness.canOperate = false;
263
+ expect(yield* prepareQueuedMessageAttachments(message)).toEqual({
264
+ status: "abandoned",
265
+ });
266
+ expect(harness.prepareTurnAttachments).not.toHaveBeenCalled();
267
+ expect(remainingMessages()).toEqual([message]);
268
+ }),
269
+ );
270
+
271
+ it.effect("abandons reused uploads when an editor saves changed text during verification", () =>
272
+ Effect.gen(function* () {
273
+ const message = withReusedFileUpload(
274
+ queuedMessage({
275
+ messageId: "message-reused-upload-race",
276
+ text: "original text",
277
+ fileUri: "file:///documents/t3-composer-attachments/reused.pdf",
278
+ }),
279
+ "pending-reused-upload",
280
+ );
281
+ const preparationStarted = Promise.withResolvers<void>();
282
+ const preparationBarrier = Promise.withResolvers<PreparedTurnAttachments>();
283
+ harness.prepareTurnAttachments.mockImplementationOnce(() =>
284
+ Effect.promise(() => {
285
+ preparationStarted.resolve();
286
+ return preparationBarrier.promise;
287
+ }),
288
+ );
289
+ yield* Effect.promise(() => harness.manager.enqueue(message));
290
+ appAtomRegistry.set(editingQueuedMessageIdsAtom, { [message.messageId]: true });
291
+
292
+ const preparation = yield* Effect.forkChild(prepareQueuedMessageAttachments(message), {
293
+ startImmediately: true,
294
+ });
295
+ yield* Effect.promise(() => preparationStarted.promise);
296
+ const edited = { ...message, text: "saved editor text" };
297
+ yield* Effect.promise(() => harness.manager.update(edited));
298
+ appAtomRegistry.set(editingQueuedMessageIdsAtom, {});
299
+ preparationBarrier.resolve({
300
status: "ready",
301
attachments: [],
302
draftAttachments: message.attachments,
251
- pendingAttachmentIds: [],
252
- }),
253
- );
254
- harness.canOperate = false;
255
- await expect(prepareQueuedMessageAttachments(message)).resolves.toEqual({
256
- status: "abandoned",
257
- });
258
- expect(harness.prepareTurnAttachments).not.toHaveBeenCalled();
259
- expect(remainingMessages()).toEqual([message]);
260
- });
261
-
262
- it("abandons reused uploads when an editor saves changed text during verification", async () => {
263
- const message = withReusedFileUpload(
264
- queuedMessage({
265
- messageId: "message-reused-upload-race",
266
- text: "original text",
267
- fileUri: "file:///documents/t3-composer-attachments/reused.pdf",
268
- }),
269
- "pending-reused-upload",
270
- );
271
- const preparationStarted = Promise.withResolvers<void>();
272
- const preparationBarrier = Promise.withResolvers<PreparedTurnAttachments>();
273
- harness.prepareTurnAttachments.mockImplementationOnce(() =>
274
- Effect.promise(() => {
275
- preparationStarted.resolve();
276
- return preparationBarrier.promise;
277
- }),
278
- );
279
- await harness.manager.enqueue(message);
280
- appAtomRegistry.set(editingQueuedMessageIdsAtom, { [message.messageId]: true });
281
-
282
- const preparation = prepareQueuedMessageAttachments(message);
283
- await preparationStarted.promise;
284
- const edited = { ...message, text: "saved editor text" };
285
- await harness.manager.update(edited);
286
- appAtomRegistry.set(editingQueuedMessageIdsAtom, {});
287
- preparationBarrier.resolve({
288
- status: "ready",
289
- attachments: [],
290
- draftAttachments: message.attachments,
291
- pendingAttachmentIds: ["pending-reused-upload"],
292
- });
303
+ pendingAttachmentIds: ["pending-reused-upload"],
304
+ });
305
294
- await expect(preparation).resolves.toEqual({ status: "abandoned" });
295
- expect(remainingMessages()).toEqual([edited]);
296
- });
306
+ expect(yield* Fiber.join(preparation)).toEqual({ status: "abandoned" });
307
+ expect(remainingMessages()).toEqual([edited]);
308
+ }),
309
+ );
310
298
- it("uses the known next revision after persisting uploaded references", async () => {
299
- const message = queuedMessage({
300
- messageId: "message-new-upload-revision",
301
- text: "upload this file",
302
- fileUri: "file:///documents/t3-composer-attachments/new.pdf",
303
- });
304
- const uploadedAttachments = message.attachments.map((attachment) =>
305
- attachment.type === "file"
306
- ? {
307
- ...attachment,
308
- uploadedAttachmentId: "pending-new-upload",
309
- uploadEnvironmentId: message.environmentId,
310
- }
311
- : attachment,
312
- );
313
- harness.prepareTurnAttachments.mockImplementationOnce((input) =>
314
- Effect.gen(function* () {
315
- expect(yield* input.persistUploadedReferences!(uploadedAttachments)).toBe("persisted");
316
- return {
317
- status: "ready",
318
- attachments: [],
319
- draftAttachments: uploadedAttachments,
320
- pendingAttachmentIds: ["pending-new-upload"],
321
- } as const;
322
- }),
323
- );
324
- await harness.manager.enqueue(message);
325
- const revision = harness.manager.revisionOf(message.messageId);
311
+ it.effect("uses the known next revision after persisting uploaded references", () =>
312
+ Effect.gen(function* () {
313
+ const message = queuedMessage({
314
+ messageId: "message-new-upload-revision",
315
+ text: "upload this file",
316
+ fileUri: "file:///documents/t3-composer-attachments/new.pdf",
317
+ });
318
+ const uploadedAttachments = message.attachments.map((attachment) =>
319
+ attachment.type === "file"
320
+ ? {
321
+ ...attachment,
322
+ uploadedAttachmentId: "pending-new-upload",
323
+ uploadEnvironmentId: message.environmentId,
324
+ }
325
+ : attachment,
326
+ );
327
+ harness.prepareTurnAttachments.mockImplementationOnce((input) =>
328
+ Effect.gen(function* () {
329
+ expect(yield* input.persistUploadedReferences!(uploadedAttachments)).toBe("persisted");
330
+ return {
331
+ status: "ready",
332
+ attachments: [],
333
+ draftAttachments: uploadedAttachments,
334
+ pendingAttachmentIds: ["pending-new-upload"],
335
+ } as const;
336
+ }),
337
+ );
338
+ yield* Effect.promise(() => harness.manager.enqueue(message));
339
+ const revision = harness.manager.revisionOf(message.messageId);
340
327
- const result = await prepareQueuedMessageAttachments(message);
341
+ const result = yield* prepareQueuedMessageAttachments(message);
342
329
- expect(result).toMatchObject({
330
- status: "ready",
331
- persistedMessage: { attachments: uploadedAttachments },
332
- deliveryRevision: revision + 1,
333
- });
334
- expect(harness.manager.revisionOf(message.messageId)).toBe(revision + 1);
335
- });
343
+ expect(result).toMatchObject({
344
+ status: "ready",
345
+ persistedMessage: { attachments: uploadedAttachments },
346
+ deliveryRevision: revision + 1,
347
+ });
348
+ expect(harness.manager.revisionOf(message.messageId)).toBe(revision + 1);
349
+ }),
350
+ );
351
337
- it("does not prepare a payload that was already replaced", async () => {
338
- const message = queuedMessage({ messageId: "message-stale-before-upload", text: "old" });
339
- await harness.manager.enqueue(message);
340
- const edited = { ...message, text: "new" };
341
- await harness.manager.update(edited);
352
+ it.effect("does not prepare a payload that was already replaced", () =>
353
+ Effect.gen(function* () {
354
+ const message = queuedMessage({ messageId: "message-stale-before-upload", text: "old" });
355
+ yield* Effect.promise(() => harness.manager.enqueue(message));
356
+ const edited = { ...message, text: "new" };
357
+ yield* Effect.promise(() => harness.manager.update(edited));
358
343
- await expect(prepareQueuedMessageAttachments(message)).resolves.toEqual({
344
- status: "abandoned",
345
- });
346
- expect(harness.prepareTurnAttachments).not.toHaveBeenCalled();
347
- expect(remainingMessages()).toEqual([edited]);
348
- });
359
+ expect(yield* prepareQueuedMessageAttachments(message)).toEqual({
360
+ status: "abandoned",
361
+ });
362
+ expect(harness.prepareTurnAttachments).not.toHaveBeenCalled();
363
+ expect(remainingMessages()).toEqual([edited]);
364
+ }),
365
+ );
366
});
367
368
describe("thread outbox drain delivery cleanup", () => {
352
- it("drops caught-up acknowledged rows at the next delivery without subscribing to the thread", async () => {
353
- const first = queuedMessage({ messageId: "awaiting-echo", text: "Delivered" });
354
- const second = queuedMessage({ messageId: "next-delivery", text: "Also delivered" });
355
- await harness.manager.enqueue(first);
356
- await harness.manager.enqueue(second);
357
-
358
- await expect(
359
- completeQueuedMessageDelivery(first, harness.manager.revisionOf(first.messageId), 7),
360
- ).resolves.toBe("removed");
361
- expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([
362
- { ...first, sequence: 7 },
363
- ]);
364
-
365
- // The thread applied the message, but its bounded window does not hold it.
366
- appAtomRegistry.set(harness.threadState, {
367
- data: Option.some({ messages: [{ id: "unrelated" }] }),
368
- sequence: 7,
369
- });
370
- expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toHaveLength(1);
371
-
372
- await expect(
373
- completeQueuedMessageDelivery(second, harness.manager.revisionOf(second.messageId), 9),
374
- ).resolves.toBe("removed");
375
- expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([
376
- { ...second, sequence: 9 },
377
- ]);
378
- });
379
-
380
- it("drops an acknowledged row once the open thread catches up, so a reload cannot resurrect it", async () => {
381
- const message = queuedMessage({ messageId: "paged-out-later", text: "Delivered" });
382
- await harness.manager.enqueue(message);
383
- await completeQueuedMessageDelivery(message, harness.manager.revisionOf(message.messageId), 7);
384
-
385
- pruneCaughtUpAcknowledgedThreadMessages(
386
- scopedThreadKey(message.environmentId, message.threadId),
387
- {
388
- sequence: 6,
389
- messages: [],
390
- },
391
- );
392
- expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([
393
- { ...message, sequence: 7 },
394
- ]);
395
-
396
- pruneCaughtUpAcknowledgedThreadMessages(
397
- scopedThreadKey(message.environmentId, message.threadId),
398
- {
399
- sequence: 7,
400
- messages: [],
401
- },
402
- );
403
- expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([]);
404
- });
369
+ it.effect(
370
+ "drops caught-up acknowledged rows at the next delivery without subscribing to the thread",
371
+ () =>
372
+ Effect.gen(function* () {
373
+ const first = queuedMessage({ messageId: "awaiting-echo", text: "Delivered" });
374
+ const second = queuedMessage({ messageId: "next-delivery", text: "Also delivered" });
375
+ yield* Effect.promise(() => harness.manager.enqueue(first));
376
+ yield* Effect.promise(() => harness.manager.enqueue(second));
377
+
378
+ expect(
379
+ yield* completeQueuedMessageDelivery(
380
+ first,
381
+ harness.manager.revisionOf(first.messageId),
382
+ 7,
383
+ ),
384
+ ).toBe("removed");
385
+ expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([
386
+ { ...first, sequence: 7 },
387
+ ]);
388
+
389
+ // The thread applied the message, but its bounded window does not hold it.
390
+ appAtomRegistry.set(harness.threadState, {
391
+ data: Option.some({ messages: [{ id: "unrelated" }] }),
392
+ sequence: 7,
393
+ });
394
+ expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toHaveLength(1);
395
+
396
+ expect(
397
+ yield* completeQueuedMessageDelivery(
398
+ second,
399
+ harness.manager.revisionOf(second.messageId),
400
+ 9,
401
+ ),
402
+ ).toBe("removed");
403
+ expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([
404
+ { ...second, sequence: 9 },
405
+ ]);
406
+ }),
407
+ );
408
406
- it("removes an acknowledged outbox item even when the sign-out archive write fails", async () => {
407
- const message = queuedMessage({ messageId: "archive-write-failure", text: "Delivered" });
408
- await harness.manager.enqueue(message);
409
- await composerDrafts.archiveCloudComposerDrafts("account-a", new Set([message.environmentId]), [
410
- message.environmentId,
411
- ]);
412
- harness.draftFile.setWriteError(new Error("Draft storage unavailable"));
413
-
414
- await expect(
415
- completeQueuedMessageDelivery(
416
- message,
417
- harness.manager.revisionOf(message.messageId),
418
- undefined,
419
- ),
420
- ).resolves.toBe("removed");
421
- expect(remainingMessages()).toEqual([]);
409
+ it.effect(
410
+ "drops an acknowledged row once the open thread catches up, so a reload cannot resurrect it",
411
+ () =>
412
+ Effect.gen(function* () {
413
+ const message = queuedMessage({ messageId: "paged-out-later", text: "Delivered" });
414
+ yield* Effect.promise(() => harness.manager.enqueue(message));
415
+ yield* completeQueuedMessageDelivery(
416
+ message,
417
+ harness.manager.revisionOf(message.messageId),
418
+ 7,
419
+ );
420
+
421
+ pruneCaughtUpAcknowledgedThreadMessages(
422
+ scopedThreadKey(message.environmentId, message.threadId),
423
+ {
424
+ sequence: 6,
425
+ messages: [],
426
+ },
427
+ );
428
+ expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([
429
+ { ...message, sequence: 7 },
430
+ ]);
431
423
- harness.draftFile.setWriteError(null);
424
- await composerDrafts.flushComposerDrafts();
425
- appAtomRegistry.set(composerDrafts.composerCloudDraftsAtom, { accountId: null, signedOut: {} });
426
- composerDrafts.resetComposerDraftsLoadState();
427
- await composerDrafts.restoreCloudComposerDrafts("account-a");
428
- expect(remainingMessages()).toEqual([]);
429
- });
432
+ pruneCaughtUpAcknowledgedThreadMessages(
433
+ scopedThreadKey(message.environmentId, message.threadId),
434
+ {
435
+ sequence: 7,
436
+ messages: [],
437
+ },
438
+ );
439
+ expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([]);
440
+ }),
441
+ );
442
431
- it.each([false, true])(
432
- "does not restore a message delivered after the sign-out snapshot (outbox already cleared: %s)",
433
- async (cleared) => {
434
- const message = queuedMessage({
435
- messageId: "delivered-during-sign-out",
436
- text: "Already delivered",
437
- });
438
- await harness.manager.enqueue(message);
439
- const deliveryRevision = harness.manager.revisionOf(message.messageId);
440
- await composerDrafts.archiveCloudComposerDrafts(
441
- "account-a",
442
- new Set([message.environmentId]),
443
- [message.environmentId],
443
+ it.effect("removes an acknowledged outbox item even when the sign-out archive write fails", () =>
444
+ Effect.gen(function* () {
445
+ const message = queuedMessage({ messageId: "archive-write-failure", text: "Delivered" });
446
+ yield* Effect.promise(() => harness.manager.enqueue(message));
447
+ yield* Effect.promise(() =>
448
+ composerDrafts.archiveCloudComposerDrafts("account-a", new Set([message.environmentId]), [
449
+ message.environmentId,
450
+ ]),
451
);
445
- expect(
446
- appAtomRegistry.get(composerDrafts.composerCloudDraftsAtom).signedOut["account-a"]
447
- ?.queuedMessages,
448
- ).toEqual([message]);
452
+ harness.draftFile.setWriteError(new Error("Draft storage unavailable"));
453
450
- if (cleared) await harness.manager.clearEnvironment(message.environmentId);
451
- await expect(
452
- completeQueuedMessageDelivery(message, deliveryRevision, undefined),
453
- ).resolves.toBe(cleared ? "edited" : "removed");
454
+ expect(
455
+ yield* completeQueuedMessageDelivery(
456
+ message,
457
+ harness.manager.revisionOf(message.messageId),
458
+ undefined,
459
+ ),
460
+ ).toBe("removed");
461
+ expect(remainingMessages()).toEqual([]);
462
463
+ harness.draftFile.setWriteError(null);
464
+ yield* Effect.promise(() => composerDrafts.flushComposerDrafts());
465
appAtomRegistry.set(composerDrafts.composerCloudDraftsAtom, {
466
accountId: null,
467
signedOut: {},
468
});
469
composerDrafts.resetComposerDraftsLoadState();
460
- await composerDrafts.restoreCloudComposerDrafts("account-a");
470
+ yield* Effect.promise(() => composerDrafts.restoreCloudComposerDrafts("account-a"));
471
expect(remainingMessages()).toEqual([]);
462
- },
472
+ }),
473
);
474
465
- it("preserves an archived edit when an older payload finishes delivery", async () => {
466
- const message = queuedMessage({ messageId: "edited-during-sign-out", text: "Original" });
467
- await harness.manager.enqueue(message);
468
- const deliveryRevision = harness.manager.revisionOf(message.messageId);
469
- const edited = { ...message, text: "Keep this edit" };
470
- await harness.manager.update(edited);
471
- await composerDrafts.archiveCloudComposerDrafts("account-a", new Set([message.environmentId]), [
472
- message.environmentId,
473
- ]);
474
- await harness.manager.clearEnvironment(message.environmentId);
475
- await expect(completeQueuedMessageDelivery(message, deliveryRevision, undefined)).resolves.toBe(
476
- "edited",
477
- );
478
- await composerDrafts.restoreCloudComposerDrafts("account-a");
479
- expect(remainingMessages()).toEqual([edited]);
480
- });
481
-
482
- it("retries only cleanup after an acknowledged send removal fails", async () => {
483
- const message = queuedMessage({ messageId: "message-acknowledged", text: "delivered" });
484
- const acknowledged = new Set([message.messageId]);
485
- harness.removeOutboxMessage.mockRejectedValueOnce(new Error("storage unavailable"));
486
- await harness.manager.enqueue(message);
487
-
488
- await expect(removeAcknowledgedExistingThreadMessage(message, acknowledged)).resolves.toBe(
489
- false,
490
- );
491
- expect(remainingMessages()).toEqual([message]);
492
- expect(acknowledged).toEqual(new Set([message.messageId]));
493
-
494
- await expect(removeAcknowledgedExistingThreadMessage(message, acknowledged)).resolves.toBe(
495
- true,
496
- );
497
- expect(remainingMessages()).toEqual([]);
498
- expect(acknowledged).toEqual(new Set());
499
- });
475
+ it.effect.each([false, true])(
476
+ "does not restore a message delivered after the sign-out snapshot (outbox already cleared: %s)",
477
+ (cleared) =>
478
+ Effect.gen(function* () {
479
+ const message = queuedMessage({
480
+ messageId: "delivered-during-sign-out",
481
+ text: "Already delivered",
482
+ });
483
+ yield* Effect.promise(() => harness.manager.enqueue(message));
484
+ const deliveryRevision = harness.manager.revisionOf(message.messageId);
485
+ yield* Effect.promise(() =>
486
+ composerDrafts.archiveCloudComposerDrafts("account-a", new Set([message.environmentId]), [
487
+ message.environmentId,
488
+ ]),
489
+ );
490
+ expect(
491
+ appAtomRegistry.get(composerDrafts.composerCloudDraftsAtom).signedOut["account-a"]
492
+ ?.queuedMessages,
493
+ ).toEqual([message]);
494
+
495
+ if (cleared) {
496
+ yield* Effect.promise(() => harness.manager.clearEnvironment(message.environmentId));
497
+ }
498
+ expect(yield* completeQueuedMessageDelivery(message, deliveryRevision, undefined)).toBe(
499
+ cleared ? "edited" : "removed",
500
+ );
501
+
502
+ appAtomRegistry.set(composerDrafts.composerCloudDraftsAtom, {
503
+ accountId: null,
504
+ signedOut: {},
505
+ });
506
+ composerDrafts.resetComposerDraftsLoadState();
507
+ yield* Effect.promise(() => composerDrafts.restoreCloudComposerDrafts("account-a"));
508
+ expect(remainingMessages()).toEqual([]);
509
+ }),
510
+ );
511
501
- it("keeps an edited message and its files when delivery cleanup loses the revision race", async () => {
502
- const message = queuedMessage({
503
- messageId: "message-edited",
504
- text: "original",
505
- fileUri: "file:///documents/t3-composer-attachments/report.pdf",
506
- });
507
- await harness.manager.enqueue(message);
508
- const deliveryRevision = harness.manager.revisionOf(message.messageId);
509
- const edited = { ...message, text: "edited while the turn delivered" };
510
- await harness.manager.update(edited);
512
+ it.effect("preserves an archived edit when an older payload finishes delivery", () =>
513
+ Effect.gen(function* () {
514
+ const message = queuedMessage({ messageId: "edited-during-sign-out", text: "Original" });
515
+ yield* Effect.promise(() => harness.manager.enqueue(message));
516
+ const deliveryRevision = harness.manager.revisionOf(message.messageId);
517
+ const edited = { ...message, text: "Keep this edit" };
518
+ yield* Effect.promise(() => harness.manager.update(edited));
519
+ yield* Effect.promise(() =>
520
+ composerDrafts.archiveCloudComposerDrafts("account-a", new Set([message.environmentId]), [
521
+ message.environmentId,
522
+ ]),
523
+ );
524
+ yield* Effect.promise(() => harness.manager.clearEnvironment(message.environmentId));
525
+ expect(yield* completeQueuedMessageDelivery(message, deliveryRevision, undefined)).toBe(
526
+ "edited",
527
+ );
528
+ yield* Effect.promise(() => composerDrafts.restoreCloudComposerDrafts("account-a"));
529
+ expect(remainingMessages()).toEqual([edited]);
530
+ }),
531
+ );
532
512
- await expect(completeQueuedMessageDelivery(message, deliveryRevision, undefined)).resolves.toBe(
513
- "edited",
514
- );
533
+ it.effect("retries only cleanup after an acknowledged send removal fails", () =>
534
+ Effect.gen(function* () {
535
+ const message = queuedMessage({ messageId: "message-acknowledged", text: "delivered" });
536
+ const acknowledged = new Set([message.messageId]);
537
+ harness.removeOutboxMessage.mockRejectedValueOnce(new Error("storage unavailable"));
538
+ yield* Effect.promise(() => harness.manager.enqueue(message));
539
516
- expect(remainingMessages()).toEqual([edited]);
517
- expect(harness.removePersistedFile).not.toHaveBeenCalled();
518
- });
519
-
520
- it("removes the delivered message when no edit was accepted", async () => {
521
- const message = queuedMessage({ messageId: "message-clean", text: "hello" });
522
- await harness.manager.enqueue(message);
523
- const deliveryRevision = harness.manager.revisionOf(message.messageId);
540
+ expect(yield* handled(removeAcknowledgedExistingThreadMessage(message, acknowledged))).toBe(
541
+ false,
542
+ );
543
+ expect(remainingMessages()).toEqual([message]);
544
+ expect(acknowledged).toEqual(new Set([message.messageId]));
545
525
- await expect(completeQueuedMessageDelivery(message, deliveryRevision, undefined)).resolves.toBe(
526
- "removed",
527
- );
546
+ expect(yield* handled(removeAcknowledgedExistingThreadMessage(message, acknowledged))).toBe(
547
+ true,
548
+ );
549
+ expect(remainingMessages()).toEqual([]);
550
+ expect(acknowledged).toEqual(new Set());
551
+ }),
552
+ );
553
529
- expect(remainingMessages()).toEqual([]);
530
- expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([message]);
531
- });
554
+ it.effect(
555
+ "keeps an edited message and its files when delivery cleanup loses the revision race",
556
+ () =>
557
+ Effect.gen(function* () {
558
+ const message = queuedMessage({
559
+ messageId: "message-edited",
560
+ text: "original",
561
+ fileUri: "file:///documents/t3-composer-attachments/report.pdf",
562
+ });
563
+ yield* Effect.promise(() => harness.manager.enqueue(message));
564
+ const deliveryRevision = harness.manager.revisionOf(message.messageId);
565
+ const edited = { ...message, text: "edited while the turn delivered" };
566
+ yield* Effect.promise(() => harness.manager.update(edited));
567
+
568
+ expect(yield* completeQueuedMessageDelivery(message, deliveryRevision, undefined)).toBe(
569
+ "edited",
570
+ );
571
+
572
+ expect(remainingMessages()).toEqual([edited]);
573
+ expect(harness.removePersistedFile).not.toHaveBeenCalled();
574
+ }),
575
+ );
576
533
- it("keeps a delivered message when its editor opens during storage removal", async () => {
534
- const message = queuedMessage({
535
- messageId: "message-editor-removal-race",
536
- text: "keep editor changes",
537
- fileUri: "file:///documents/t3-composer-attachments/editor-race.pdf",
538
- });
539
- const removeStarted = Promise.withResolvers<void>();
540
- const removeBarrier = Promise.withResolvers<void>();
541
- harness.removeOutboxMessage.mockImplementationOnce(async () => {
542
- removeStarted.resolve();
543
- await removeBarrier.promise;
544
- });
545
- await harness.manager.enqueue(message);
546
- const deliveryRevision = harness.manager.revisionOf(message.messageId);
577
+ it.effect("removes the delivered message when no edit was accepted", () =>
578
+ Effect.gen(function* () {
579
+ const message = queuedMessage({ messageId: "message-clean", text: "hello" });
580
+ yield* Effect.promise(() => harness.manager.enqueue(message));
581
+ const deliveryRevision = harness.manager.revisionOf(message.messageId);
582
548
- const cleanup = completeQueuedMessageDelivery(message, deliveryRevision, undefined);
549
- await removeStarted.promise;
550
- appAtomRegistry.set(editingQueuedMessageIdsAtom, { [message.messageId]: true });
551
- removeBarrier.resolve();
583
+ expect(yield* completeQueuedMessageDelivery(message, deliveryRevision, undefined)).toBe(
584
+ "removed",
585
+ );
586
553
- await expect(cleanup).resolves.toBe("edited");
554
- expect(remainingMessages()).toEqual([message]);
555
- expect(harness.removePersistedFile).not.toHaveBeenCalled();
556
- });
557
-});
587
+ expect(remainingMessages()).toEqual([]);
588
+ expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([message]);
589
+ }),
590
+ );
591
559
-describe("thread outbox delivered creation recovery", () => {
560
- it("keeps an edit accepted while the older payload is persisted to the draft", async () => {
561
- const message = queuedMessage({
562
- messageId: "message-recovery-race",
563
- text: "original queued text",
564
- fileUri: "file:///documents/t3-composer-attachments/report.pdf",
565
- });
566
- const originalMergeComposerDraftContent = composerDrafts.mergeComposerDraftContent;
567
- const mergeCompleted = Promise.withResolvers<void>();
568
- const releaseRecovery = Promise.withResolvers<void>();
569
- const mergeSpy = vi
570
- .spyOn(composerDrafts, "mergeComposerDraftContent")
571
- .mockImplementation(async (draftKey, content) => {
572
- const result = await originalMergeComposerDraftContent(draftKey, content);
573
- mergeCompleted.resolve();
574
- await releaseRecovery.promise;
575
- return result;
592
+ it.effect("keeps a delivered message when its editor opens during storage removal", () =>
593
+ Effect.gen(function* () {
594
+ const message = queuedMessage({
595
+ messageId: "message-editor-removal-race",
596
+ text: "keep editor changes",
597
+ fileUri: "file:///documents/t3-composer-attachments/editor-race.pdf",
598
});
577
-
578
- try {
579
- await harness.manager.enqueue(message);
580
- const recovery = recoverEditedCreationAfterDelivery(message);
581
- await mergeCompleted.promise;
582
-
583
- const newer = { ...message, text: "edited while recovery persisted the draft" };
584
- await harness.manager.update(newer);
585
-
586
- releaseRecovery.resolve();
587
- await expect(recovery).resolves.toBe(false);
588
-
589
- expect(remainingMessages()).toEqual([newer]);
590
- expect(
591
- composerDrafts.getComposerDraftSnapshot(`${message.environmentId}:${message.threadId}`),
592
- ).toMatchObject({ text: message.text, attachments: [] });
593
- expect(harness.removePersistedFile).not.toHaveBeenCalled();
594
- } finally {
595
- releaseRecovery.resolve();
596
- mergeSpy.mockRestore();
597
- }
598
- });
599
-
600
- it("leaves recovery to an editor that opens while the draft persists", async () => {
601
- const message = queuedMessage({
602
- messageId: "message-recovery-editor",
603
- text: "recover this text",
604
- fileUri: "file:///documents/t3-composer-attachments/editor.pdf",
605
- });
606
- const originalMergeComposerDraftContent = composerDrafts.mergeComposerDraftContent;
607
- const mergeCompleted = Promise.withResolvers<void>();
608
- const releaseRecovery = Promise.withResolvers<void>();
609
- const mergeSpy = vi
610
- .spyOn(composerDrafts, "mergeComposerDraftContent")
611
- .mockImplementation(async (draftKey, content) => {
612
- const result = await originalMergeComposerDraftContent(draftKey, content);
613
- mergeCompleted.resolve();
614
- await releaseRecovery.promise;
615
- return result;
599
+ const removeStarted = Promise.withResolvers<void>();
600
+ const removeBarrier = Promise.withResolvers<void>();
601
+ harness.removeOutboxMessage.mockImplementationOnce(async () => {
602
+ removeStarted.resolve();
603
+ await removeBarrier.promise;
604
});
605
+ yield* Effect.promise(() => harness.manager.enqueue(message));
606
+ const deliveryRevision = harness.manager.revisionOf(message.messageId);
607
618
- try {
619
- await harness.manager.enqueue(message);
620
- const recovery = recoverEditedCreationAfterDelivery(message);
621
- await mergeCompleted.promise;
608
+ const cleanup = yield* Effect.forkChild(
609
+ completeQueuedMessageDelivery(message, deliveryRevision, undefined),
610
+ { startImmediately: true },
611
+ );
612
+ yield* Effect.promise(() => removeStarted.promise);
613
appAtomRegistry.set(editingQueuedMessageIdsAtom, { [message.messageId]: true });
614
+ removeBarrier.resolve();
615
624
- releaseRecovery.resolve();
625
- await expect(recovery).resolves.toBe(true);
626
-
616
+ expect(yield* Fiber.join(cleanup)).toBe("edited");
617
expect(remainingMessages()).toEqual([message]);
628
- expect(
629
- composerDrafts.getComposerDraftSnapshot(`${message.environmentId}:${message.threadId}`),
630
- ).toMatchObject({ text: message.text, attachments: [] });
618
expect(harness.removePersistedFile).not.toHaveBeenCalled();
632
- } finally {
633
- releaseRecovery.resolve();
634
- mergeSpy.mockRestore();
635
- }
636
- });
637
-
638
- it("retries a failed removal without duplicating recovered draft content", async () => {
639
- const message = queuedMessage({
640
- messageId: "message-recovery-removal",
641
- text: "recover once",
642
- fileUri: "file:///documents/t3-composer-attachments/retry.pdf",
643
- });
644
- const draftKey = `${message.environmentId}:${message.threadId}`;
645
- const removeSpy = vi
646
- .spyOn(harness.manager, "remove")
647
- .mockRejectedValueOnce(new Error("storage unavailable"));
619
+ }),
620
+ );
621
+});
622
649
- try {
650
- await harness.manager.enqueue(message);
623
+describe("thread outbox delivered creation recovery", () => {
624
+ it.effect("keeps an edit accepted while the older payload is persisted to the draft", () =>
625
+ Effect.gen(function* () {
626
+ const message = queuedMessage({
627
+ messageId: "message-recovery-race",
628
+ text: "original queued text",
629
+ fileUri: "file:///documents/t3-composer-attachments/report.pdf",
630
+ });
631
+ const originalMergeComposerDraftContent = composerDrafts.mergeComposerDraftContent;
632
+ const mergeCompleted = Promise.withResolvers<void>();
633
+ const releaseRecovery = Promise.withResolvers<void>();
634
+ const mergeSpy = vi
635
+ .spyOn(composerDrafts, "mergeComposerDraftContent")
636
+ .mockImplementation(async (draftKey, content) => {
637
+ const result = await originalMergeComposerDraftContent(draftKey, content);
638
+ mergeCompleted.resolve();
639
+ await releaseRecovery.promise;
640
+ return result;
641
+ });
642
+
643
+ try {
644
+ yield* Effect.promise(() => harness.manager.enqueue(message));
645
+ const recovery = yield* Effect.forkChild(
646
+ handled(recoverEditedCreationAfterDelivery(message)),
647
+ { startImmediately: true },
648
+ );
649
+ yield* Effect.promise(() => mergeCompleted.promise);
650
+
651
+ const newer = { ...message, text: "edited while recovery persisted the draft" };
652
+ yield* Effect.promise(() => harness.manager.update(newer));
653
+
654
+ releaseRecovery.resolve();
655
+ expect(yield* Fiber.join(recovery)).toBe(false);
656
+
657
+ expect(remainingMessages()).toEqual([newer]);
658
+ expect(
659
+ composerDrafts.getComposerDraftSnapshot(`${message.environmentId}:${message.threadId}`),
660
+ ).toMatchObject({ text: message.text, attachments: [] });
661
+ expect(harness.removePersistedFile).not.toHaveBeenCalled();
662
+ } finally {
663
+ releaseRecovery.resolve();
664
+ mergeSpy.mockRestore();
665
+ }
666
+ }),
667
+ );
668
652
- await expect(recoverEditedCreationAfterDelivery(message)).resolves.toBe(false);
653
- expect(remainingMessages()).toEqual([message]);
669
+ it.effect("leaves recovery to an editor that opens while the draft persists", () =>
670
+ Effect.gen(function* () {
671
+ const message = queuedMessage({
672
+ messageId: "message-recovery-editor",
673
+ text: "recover this text",
674
+ fileUri: "file:///documents/t3-composer-attachments/editor.pdf",
675
+ });
676
+ const originalMergeComposerDraftContent = composerDrafts.mergeComposerDraftContent;
677
+ const mergeCompleted = Promise.withResolvers<void>();
678
+ const releaseRecovery = Promise.withResolvers<void>();
679
+ const mergeSpy = vi
680
+ .spyOn(composerDrafts, "mergeComposerDraftContent")
681
+ .mockImplementation(async (draftKey, content) => {
682
+ const result = await originalMergeComposerDraftContent(draftKey, content);
683
+ mergeCompleted.resolve();
684
+ await releaseRecovery.promise;
685
+ return result;
686
+ });
687
+
688
+ try {
689
+ yield* Effect.promise(() => harness.manager.enqueue(message));
690
+ const recovery = yield* Effect.forkChild(
691
+ handled(recoverEditedCreationAfterDelivery(message)),
692
+ { startImmediately: true },
693
+ );
694
+ yield* Effect.promise(() => mergeCompleted.promise);
695
+ appAtomRegistry.set(editingQueuedMessageIdsAtom, { [message.messageId]: true });
696
655
- await expect(recoverEditedCreationAfterDelivery(message)).resolves.toBe(true);
697
+ releaseRecovery.resolve();
698
+ expect(yield* Fiber.join(recovery)).toBe(true);
699
+
700
+ expect(remainingMessages()).toEqual([message]);
701
+ expect(
702
+ composerDrafts.getComposerDraftSnapshot(`${message.environmentId}:${message.threadId}`),
703
+ ).toMatchObject({ text: message.text, attachments: [] });
704
+ expect(harness.removePersistedFile).not.toHaveBeenCalled();
705
+ } finally {
706
+ releaseRecovery.resolve();
707
+ mergeSpy.mockRestore();
708
+ }
709
+ }),
710
+ );
711
657
- const draft = composerDrafts.getComposerDraftSnapshot(draftKey);
658
- expect(draft.text).toBe(message.text);
659
- expect(draft.attachments).toEqual(message.attachments);
660
- expect(remainingMessages()).toEqual([]);
661
- expect(harness.removePersistedFile).not.toHaveBeenCalled();
662
- } finally {
663
- removeSpy.mockRestore();
664
- }
665
- });
712
+ it.effect("retries a failed removal without duplicating recovered draft content", () =>
713
+ Effect.gen(function* () {
714
+ const message = queuedMessage({
715
+ messageId: "message-recovery-removal",
716
+ text: "recover once",
717
+ fileUri: "file:///documents/t3-composer-attachments/retry.pdf",
718
+ });
719
+ const draftKey = `${message.environmentId}:${message.threadId}`;
720
+ const removeSpy = vi
721
+ .spyOn(harness.manager, "remove")
722
+ .mockRejectedValueOnce(new Error("storage unavailable"));
723
+
724
+ try {
725
+ yield* Effect.promise(() => harness.manager.enqueue(message));
726
+
727
+ expect(yield* handled(recoverEditedCreationAfterDelivery(message))).toBe(false);
728
+ expect(remainingMessages()).toEqual([message]);
729
+
730
+ expect(yield* handled(recoverEditedCreationAfterDelivery(message))).toBe(true);
731
+
732
+ const draft = composerDrafts.getComposerDraftSnapshot(draftKey);
733
+ expect(draft.text).toBe(message.text);
734
+ expect(draft.attachments).toEqual(message.attachments);
735
+ expect(remainingMessages()).toEqual([]);
736
+ expect(harness.removePersistedFile).not.toHaveBeenCalled();
737
+ } finally {
738
+ removeSpy.mockRestore();
739
+ }
740
+ }),
741
+ );
742
667
- it("keeps the queue entry when the recovered draft cannot persist", async () => {
668
- const message = queuedMessage({
669
- messageId: "message-recovery-persistence",
670
- text: "recover after persistence returns",
671
- });
672
- await harness.manager.enqueue(message);
673
- harness.draftFile.setWriteError(new Error("disk full"));
743
+ it.effect("keeps the queue entry when the recovered draft cannot persist", () =>
744
+ Effect.gen(function* () {
745
+ const message = queuedMessage({
746
+ messageId: "message-recovery-persistence",
747
+ text: "recover after persistence returns",
748
+ });
749
+ yield* Effect.promise(() => harness.manager.enqueue(message));
750
+ harness.draftFile.setWriteError(new Error("disk full"));
751
675
- await expect(recoverEditedCreationAfterDelivery(message)).resolves.toBe(false);
752
+ expect(yield* handled(recoverEditedCreationAfterDelivery(message))).toBe(false);
753
677
- expect(remainingMessages()).toEqual([message]);
678
- });
754
+ expect(remainingMessages()).toEqual([message]);
755
+ }),
756
+ );
757
});
758
759
describe("thread outbox recovery rollback", () => {
@@ -728,111 +806,121 @@ describe("thread outbox recovery rollback", () => {
806
);
807
});
808
731
- it("restores a rejected new task as its own draft for the project", async () => {
732
- const message: QueuedThreadMessage = {
733
- ...queuedMessage({ messageId: "message-creation-restore", text: "new task text" }),
734
- modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.6-sol" },
735
- creation: {
736
- projectId: ProjectId.make("project-1"),
737
- workspaceMode: "local",
738
- branch: null,
739
- worktreePath: null,
740
- },
741
- };
742
- await harness.manager.enqueue(message);
743
-
744
- await expect(restoreRejectedQueuedMessage(message, "rejected by server")).resolves.toBe(
745
- "restored",
746
- );
809
+ it.effect("restores a rejected new task as its own draft for the project", () =>
810
+ Effect.gen(function* () {
811
+ const message: QueuedThreadMessage = {
812
+ ...queuedMessage({ messageId: "message-creation-restore", text: "new task text" }),
813
+ modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.6-sol" },
814
+ creation: {
815
+ projectId: ProjectId.make("project-1"),
816
+ workspaceMode: "local",
817
+ branch: null,
818
+ worktreePath: null,
819
+ },
820
+ };
821
+ yield* Effect.promise(() => harness.manager.enqueue(message));
822
+
823
+ expect(yield* restoreRejectedQueuedMessage(message, "rejected by server")).toBe("restored");
824
748
- expect(
749
- composerDrafts.getComposerDraftSnapshot(`new-task:restored-${message.messageId}`),
750
- ).toMatchObject({
751
- text: message.text,
752
- attachments: message.attachments,
753
- modelSelection: message.modelSelection,
754
- project: {
755
- environmentId: message.environmentId,
756
- projectId: message.creation!.projectId,
757
- createdAt: message.createdAt,
758
- },
759
- });
760
- expect(remainingMessages()).toEqual([]);
761
- expect(appAtomRegistry.get(threadComposerErrorsAtom)).toEqual({});
762
- expect(
763
- appAtomRegistry.get(pendingThreadCreationOutcomesAtom)[
764
- `${message.environmentId}:${message.threadId}`
765
- ],
766
- ).toEqual({ kind: "failed", message, reason: "rejected by server" });
767
- });
825
+ expect(
826
+ composerDrafts.getComposerDraftSnapshot(`new-task:restored-${message.messageId}`),
827
+ ).toMatchObject({
828
+ text: message.text,
829
+ attachments: message.attachments,
830
+ modelSelection: message.modelSelection,
831
+ project: {
832
+ environmentId: message.environmentId,
833
+ projectId: message.creation!.projectId,
834
+ createdAt: message.createdAt,
835
+ },
836
+ });
837
+ expect(remainingMessages()).toEqual([]);
838
+ expect(appAtomRegistry.get(threadComposerErrorsAtom)).toEqual({});
839
+ expect(
840
+ appAtomRegistry.get(pendingThreadCreationOutcomesAtom)[
841
+ `${message.environmentId}:${message.threadId}`
842
+ ],
843
+ ).toEqual({ kind: "failed", message, reason: "rejected by server" });
844
+ }),
845
+ );
846
769
- it("does not record a creation outcome for a rejected follow-up message", async () => {
770
- const message = queuedMessage({ messageId: "message-followup-restore", text: "follow up" });
771
- await harness.manager.enqueue(message);
847
+ it.effect("does not record a creation outcome for a rejected follow-up message", () =>
848
+ Effect.gen(function* () {
849
+ const message = queuedMessage({ messageId: "message-followup-restore", text: "follow up" });
850
+ yield* Effect.promise(() => harness.manager.enqueue(message));
851
773
- await expect(restoreRejectedQueuedMessage(message, "rejected")).resolves.toBe("restored");
852
+ expect(yield* restoreRejectedQueuedMessage(message, "rejected")).toBe("restored");
853
775
- expect(appAtomRegistry.get(pendingThreadCreationOutcomesAtom)).toEqual({});
776
- expect(
777
- appAtomRegistry.get(threadComposerErrorsAtom)[`${message.environmentId}:${message.threadId}`],
778
- ).toEqual({ message: "rejected", messageId: message.messageId });
779
- });
854
+ expect(appAtomRegistry.get(pendingThreadCreationOutcomesAtom)).toEqual({});
855
+ expect(
856
+ appAtomRegistry.get(threadComposerErrorsAtom)[
857
+ `${message.environmentId}:${message.threadId}`
858
+ ],
859
+ ).toEqual({ message: "rejected", messageId: message.messageId });
860
+ }),
861
+ );
862
781
- it("leaves no error when the restored text is resent before recovery finishes", async () => {
782
- const message = queuedMessage({ messageId: "message-resent", text: "resend me" });
783
- const threadKey = `${message.environmentId}:${message.threadId}`;
784
- await harness.manager.enqueue(message);
785
- const unsubscribe = appAtomRegistry.subscribe(composerDrafts.composerDraftsAtom, (drafts) => {
786
- if (drafts[threadKey]?.text === "resend me") {
787
- unsubscribe();
788
- clearThreadComposerError(threadKey);
789
- void composerDrafts.clearComposerDraftContent(threadKey);
790
- }
791
- });
863
+ it.effect("leaves no error when the restored text is resent before recovery finishes", () =>
864
+ Effect.gen(function* () {
865
+ const message = queuedMessage({ messageId: "message-resent", text: "resend me" });
866
+ const threadKey = `${message.environmentId}:${message.threadId}`;
867
+ yield* Effect.promise(() => harness.manager.enqueue(message));
868
+ const unsubscribe = appAtomRegistry.subscribe(composerDrafts.composerDraftsAtom, (drafts) => {
869
+ if (drafts[threadKey]?.text === "resend me") {
870
+ unsubscribe();
871
+ clearThreadComposerError(threadKey);
872
+ void composerDrafts.clearComposerDraftContent(threadKey);
873
+ }
874
+ });
875
793
- await expect(restoreRejectedQueuedMessage(message, "rejected")).resolves.toBe("restored");
876
+ expect(yield* restoreRejectedQueuedMessage(message, "rejected")).toBe("restored");
877
795
- expect(appAtomRegistry.get(threadComposerErrorsAtom)).toEqual({});
796
- });
878
+ expect(appAtomRegistry.get(threadComposerErrorsAtom)).toEqual({});
879
+ }),
880
+ );
881
798
- it("withdraws the error when an edit makes the recovery back out", async () => {
799
- const message = queuedMessage({ messageId: "message-edited-mid-recovery", text: "edit me" });
800
- const threadKey = `${message.environmentId}:${message.threadId}`;
801
- await harness.manager.enqueue(message);
802
- const unsubscribe = appAtomRegistry.subscribe(composerDrafts.composerDraftsAtom, (drafts) => {
803
- if (drafts[threadKey]?.text === "edit me") {
804
- unsubscribe();
805
- appAtomRegistry.set(editingQueuedMessageIdsAtom, { [message.messageId]: true });
806
- }
807
- });
882
+ it.effect("withdraws the error when an edit makes the recovery back out", () =>
883
+ Effect.gen(function* () {
884
+ const message = queuedMessage({ messageId: "message-edited-mid-recovery", text: "edit me" });
885
+ const threadKey = `${message.environmentId}:${message.threadId}`;
886
+ yield* Effect.promise(() => harness.manager.enqueue(message));
887
+ const unsubscribe = appAtomRegistry.subscribe(composerDrafts.composerDraftsAtom, (drafts) => {
888
+ if (drafts[threadKey]?.text === "edit me") {
889
+ unsubscribe();
890
+ appAtomRegistry.set(editingQueuedMessageIdsAtom, { [message.messageId]: true });
891
+ }
892
+ });
893
809
- await expect(restoreRejectedQueuedMessage(message, "rejected")).resolves.toBe("deferred");
894
+ expect(yield* restoreRejectedQueuedMessage(message, "rejected")).toBe("deferred");
895
811
- expect(appAtomRegistry.get(threadComposerErrorsAtom)).toEqual({});
812
- expect(remainingMessages()).toEqual([message]);
813
- });
896
+ expect(appAtomRegistry.get(threadComposerErrorsAtom)).toEqual({});
897
+ expect(remainingMessages()).toEqual([message]);
898
+ }),
899
+ );
900
815
- it("rolls a failed recovery merge back so the retry cannot duplicate the text", async () => {
816
- const message = queuedMessage({ messageId: "message-restore", text: "queued text" });
817
- const draftKey = `${message.environmentId}:${message.threadId}`;
818
- appAtomRegistry.set(composerDrafts.composerDraftsAtom, {
819
- [draftKey]: { text: "typed offline", attachments: [] },
820
- });
821
- await harness.manager.enqueue(message);
901
+ it.effect("rolls a failed recovery merge back so the retry cannot duplicate the text", () =>
902
+ Effect.gen(function* () {
903
+ const message = queuedMessage({ messageId: "message-restore", text: "queued text" });
904
+ const draftKey = `${message.environmentId}:${message.threadId}`;
905
+ appAtomRegistry.set(composerDrafts.composerDraftsAtom, {
906
+ [draftKey]: { text: "typed offline", attachments: [] },
907
+ });
908
+ yield* Effect.promise(() => harness.manager.enqueue(message));
909
823
- harness.draftFile.setWriteError(new Error("disk full"));
824
- await expect(restoreRejectedQueuedMessage(message, "too large")).resolves.toBe("retry");
910
+ harness.draftFile.setWriteError(new Error("disk full"));
911
+ expect(yield* restoreRejectedQueuedMessage(message, "too large")).toBe("retry");
912
826
- expect(composerDrafts.getComposerDraftSnapshot(draftKey).text).toBe("typed offline");
827
- expect(remainingMessages()).toEqual([message]);
913
+ expect(composerDrafts.getComposerDraftSnapshot(draftKey).text).toBe("typed offline");
914
+ expect(remainingMessages()).toEqual([message]);
915
829
- harness.draftFile.setWriteError(null);
830
- await expect(restoreRejectedQueuedMessage(message, "too large")).resolves.toBe("restored");
916
+ harness.draftFile.setWriteError(null);
917
+ expect(yield* restoreRejectedQueuedMessage(message, "too large")).toBe("restored");
918
832
- expect(composerDrafts.getComposerDraftSnapshot(draftKey).text).toBe(
833
- "typed offline\n\nqueued text",
834
- );
835
- expect(remainingMessages()).toEqual([]);
836
- expect(appAtomRegistry.get(threadComposerErrorsAtom)[draftKey]?.message).toBe("too large");
837
- });
919
+ expect(composerDrafts.getComposerDraftSnapshot(draftKey).text).toBe(
920
+ "typed offline\n\nqueued text",
921
+ );
922
+ expect(remainingMessages()).toEqual([]);
923
+ expect(appAtomRegistry.get(threadComposerErrorsAtom)[draftKey]?.message).toBe("too large");
924
+ }),
925
+ );
926
});
apps/mobile/src/state/threadOutboxDelivery.ts
+794
-734
@@ -23,14 +23,20 @@ import {
23
} from "@t3tools/contracts";
24
import { buildTemporaryWorktreeBranchName } from "@t3tools/shared/git";
25
import * as Cause from "effect/Cause";
26
+import * as Clock from "effect/Clock";
27
import * as Effect from "effect/Effect";
28
+import * as Exit from "effect/Exit";
29
+import * as Fiber from "effect/Fiber";
30
+import * as Latch from "effect/Latch";
31
+import * as Schema from "effect/Schema";
32
import { AsyncResult, Atom } from "effect/reactivity";
33
34
import { createDebugLogger } from "../lib/debugLog";
35
+import type { DraftComposerAttachment } from "../lib/composerImages";
36
import { scopedThreadKey } from "../lib/scopedEntities";
37
import { buildProjectThreadStartTurnInput } from "../lib/projectThreadStartTurn";
38
import { serializeComposerMessageForServer, uploadedComposerContext } from "../lib/composerContext";
33
-import { prepareTurnAttachments, type PreparedTurnAttachments } from "../lib/attachmentUpload";
39
+import { prepareTurnAttachments } from "../lib/attachmentUpload";
40
import { randomHex } from "../lib/uuid";
41
import {
42
describeUnavailableModelSelection,
@@ -49,12 +55,7 @@ import {
55
} from "./pending-thread-creation";
56
import { environmentProjects } from "./projects";
57
import { environmentServerConfigsAtom, serverEnvironment } from "./server";
52
-import { composerAttachmentUploadsAtom } from "./composer-attachment-upload-states";
58
import { uploadComposerAttachmentShared } from "./composer-attachment-uploads";
54
-import {
55
- queuedAttachmentsStillUploading,
56
- uploadingComposerAttachmentKeys,
57
-} from "../lib/composerAttachmentUploadQueue";
59
import { gitEnvironment } from "./git";
60
import { environmentSession, readEnvironmentScope, sessionHasScope } from "./session";
61
import {
@@ -92,7 +93,7 @@ import {
93
waitForComposerDraftsLoaded,
94
} from "./use-composer-drafts";
95
import {
95
- dispatchingQueuedMessageIdAtom,
96
+ dispatchingQueuedMessageIdsAtom,
97
editingQueuedMessageIdsAtom,
98
retryingQueuedMessageIdsAtom,
99
threadOutboxShellStatusesAtom,
@@ -177,12 +178,17 @@ function setQueuedMessageRetrying(queuedMessageId: MessageId, retrying: boolean)
178
function beginDispatchingQueuedMessage(queuedMessageId: MessageId): void {
179
// An attempt in flight is sending, even while its retry count is kept.
180
setQueuedMessageRetrying(queuedMessageId, false);
180
- appAtomRegistry.set(dispatchingQueuedMessageIdAtom, queuedMessageId);
181
+ appAtomRegistry.set(dispatchingQueuedMessageIdsAtom, {
182
+ ...appAtomRegistry.get(dispatchingQueuedMessageIdsAtom),
183
+ [queuedMessageId]: true,
184
+ });
185
}
186
187
function finishDispatchingQueuedMessage(queuedMessageId: MessageId): void {
184
- const current = appAtomRegistry.get(dispatchingQueuedMessageIdAtom);
185
- appAtomRegistry.set(dispatchingQueuedMessageIdAtom, current === queuedMessageId ? null : current);
188
+ const { [queuedMessageId]: _finished, ...others } = appAtomRegistry.get(
189
+ dispatchingQueuedMessageIdsAtom,
190
+ );
191
+ appAtomRegistry.set(dispatchingQueuedMessageIdsAtom, others);
192
}
193
194
function findThread(
@@ -210,57 +216,93 @@ function settingsCommandId(message: QueuedThreadMessage, setting: string): Comma
216
return CommandId.make(`${message.commandId}:${setting}`);
217
}
218
213
-export async function prepareQueuedMessageAttachments(queuedMessage: QueuedThreadMessage): Promise<
214
- | {
215
- readonly status: "ready";
216
- readonly prepared: PreparedTurnAttachments;
217
- readonly persistedMessage: QueuedThreadMessage;
218
- readonly deliveryRevision: number;
219
- }
220
- | { readonly status: "abandoned" }
221
-> {
222
- if (!(await confirmThreadOutboxMessageQueued(queuedMessage))) {
223
- return { status: "abandoned" };
224
- }
225
- if (!readEnvironmentScope(queuedMessage.environmentId, AuthOrchestrationOperateScope)) {
226
- return { status: "abandoned" };
219
+/** Outbox or draft storage refused a step; the step decides what that means for the message. */
220
+class ThreadOutboxStorageError extends Schema.TaggedError<ThreadOutboxStorageError>()(
221
+ "ThreadOutboxStorageError",
222
+ {
223
+ operation: Schema.Literals([
224
+ "forget-sign-out-snapshot",
225
+ "remove-delivered",
226
+ "remove-acknowledged",
227
+ "remove-unsendable",
228
+ "hand-back-to-draft",
229
+ "restore-to-draft",
230
+ "undo-draft-merge",
231
+ "load-drafts",
232
+ "flush-drafts",
233
+ "remove-recovered",
234
+ "remove-restored",
235
+ ]),
236
+ messageId: Schema.String,
237
+ cause: Schema.Defect(),
238
+ },
239
+) {
240
+ override get message(): string {
241
+ return `Queued message ${this.messageId} could not ${this.operation.replaceAll("-", " ")}.`;
242
}
228
- const revision = threadOutboxRevision(queuedMessage.messageId);
229
- if (!isQueuedMessagePayloadCurrent(queuedMessage, revision)) {
230
- return { status: "abandoned" };
231
- }
232
- let persistedMessage = queuedMessage;
233
- let deliveryRevision = revision;
234
- const result = await Effect.runPromise(
235
- prepareTurnAttachments({
243
+}
244
+
245
+const storage = <A>(
246
+ operation: ThreadOutboxStorageError["operation"],
247
+ messageId: MessageId,
248
+ write: () => Promise<A>,
249
+) =>
250
+ Effect.tryPromise({
251
+ try: write,
252
+ catch: (cause) => new ThreadOutboxStorageError({ operation, messageId, cause }),
253
+ });
254
+
255
+/** The head was not handled; back off and try it again. */
256
+export class DeliveryRetry extends Schema.TaggedError<DeliveryRetry>()("DeliveryRetry", {}) {}
257
+
258
+const retryDelivery = Effect.fail(new DeliveryRetry());
259
+
260
+const isEditingQueuedMessage = (messageId: MessageId): boolean =>
261
+ appAtomRegistry.get(editingQueuedMessageIdsAtom)[messageId] === true;
262
+
263
+const confirmQueued = (message: QueuedThreadMessage) =>
264
+ Effect.promise(() => confirmThreadOutboxMessageQueued(message));
265
+
266
+const abandoned = { status: "abandoned" } as const;
267
+
268
+export const prepareQueuedMessageAttachments = Effect.fn("ThreadOutbox.prepareAttachments")(
269
+ function* (queuedMessage: QueuedThreadMessage) {
270
+ if (!(yield* confirmQueued(queuedMessage))) return abandoned;
271
+ if (!readEnvironmentScope(queuedMessage.environmentId, AuthOrchestrationOperateScope)) {
272
+ return abandoned;
273
+ }
274
+ const revision = threadOutboxRevision(queuedMessage.messageId);
275
+ if (!isQueuedMessagePayloadCurrent(queuedMessage, revision)) return abandoned;
276
+ let persistedMessage = queuedMessage;
277
+ let deliveryRevision = revision;
278
+ const result = yield* prepareTurnAttachments({
279
environmentId: queuedMessage.environmentId,
280
attachments: queuedMessage.attachments,
281
supportsImageUploads: true,
282
uploadAttachment: (attachment) =>
283
uploadComposerAttachmentShared(queuedMessage.environmentId, attachment),
241
- persistUploadedReferences: (draftAttachments) =>
242
- Effect.promise(async () => {
243
- if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]) {
244
- return "abandon" as const;
245
- }
246
- const updatedMessage = { ...queuedMessage, attachments: draftAttachments };
247
- if (!(await updateThreadOutboxMessage(updatedMessage, revision))) {
248
- return "abandon" as const;
249
- }
250
- persistedMessage = updatedMessage;
251
- deliveryRevision = revision + 1;
252
- return "persisted" as const;
253
- }),
254
- }),
255
- );
256
- if (
257
- result.status === "abandoned" ||
258
- !isQueuedMessagePayloadCurrent(persistedMessage, deliveryRevision)
259
- ) {
260
- return { status: "abandoned" };
261
- }
262
- return { status: "ready", prepared: result, persistedMessage, deliveryRevision };
263
-}
284
+ persistUploadedReferences: Effect.fn("ThreadOutbox.persistUploadedReferences")(function* (
285
+ draftAttachments: ReadonlyArray<DraftComposerAttachment>,
286
+ ) {
287
+ if (isEditingQueuedMessage(queuedMessage.messageId)) return "abandon" as const;
288
+ const updatedMessage = { ...queuedMessage, attachments: draftAttachments };
289
+ if (!(yield* Effect.promise(() => updateThreadOutboxMessage(updatedMessage, revision)))) {
290
+ return "abandon" as const;
291
+ }
292
+ persistedMessage = updatedMessage;
293
+ deliveryRevision = revision + 1;
294
+ return "persisted" as const;
295
+ }),
296
+ });
297
+ if (
298
+ result.status === "abandoned" ||
299
+ !isQueuedMessagePayloadCurrent(persistedMessage, deliveryRevision)
300
+ ) {
301
+ return abandoned;
302
+ }
303
+ return { status: "ready", prepared: result, persistedMessage, deliveryRevision } as const;
304
+ },
305
+);
306
307
function isQueuedMessagePayloadCurrent(
308
message: QueuedThreadMessage,
@@ -274,273 +316,279 @@ function isQueuedMessagePayloadCurrent(
316
);
317
}
318
277
-export async function completeQueuedMessageDelivery(
319
+const forgetCloudQueuedMessage = (queuedMessage: QueuedThreadMessage) =>
320
+ storage("forget-sign-out-snapshot", queuedMessage.messageId, () =>
321
+ removeDeliveredCloudQueuedMessage(queuedMessage),
322
+ ).pipe(
323
+ Effect.catch((error) =>
324
+ Effect.logWarning("[thread-outbox] could not update sign-out snapshot after delivery", {
325
+ messageId: queuedMessage.messageId,
326
+ error: error.cause,
327
+ }),
328
+ ),
329
+ );
330
+
331
+export const completeQueuedMessageDelivery = Effect.fn("ThreadOutbox.completeDelivery")(function* (
332
queuedMessage: QueuedThreadMessage,
333
deliveryRevision: number,
280
- sequence: number | undefined,
281
-): Promise<"removed" | "edited" | "failed"> {
334
+ sequence?: number,
335
+) {
336
clearThreadComposerError(
337
scopedThreadKey(queuedMessage.environmentId, queuedMessage.threadId),
338
queuedMessage.messageId,
339
);
286
- try {
287
- await removeDeliveredCloudQueuedMessage(queuedMessage).catch((error) => {
288
- console.warn("[thread-outbox] could not update sign-out snapshot after delivery", {
289
- messageId: queuedMessage.messageId,
290
- error,
291
- });
292
- });
293
- // Editors can acquire entries during startTurn without bumping revisions; CAS alone would lose unsaved edits.
294
- if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]) {
295
- return "edited";
296
- }
297
- retainAcknowledgedThreadMessage(
298
- sequence === undefined ? queuedMessage : { ...queuedMessage, sequence },
299
- );
300
- const removed = await removeThreadOutboxMessage(
340
+ yield* forgetCloudQueuedMessage(queuedMessage);
341
+ // Editors can acquire entries during startTurn without bumping revisions; CAS alone would lose unsaved edits.
342
+ if (isEditingQueuedMessage(queuedMessage.messageId)) return "edited" as const;
343
+ retainAcknowledgedThreadMessage(
344
+ sequence === undefined ? queuedMessage : { ...queuedMessage, sequence },
345
+ );
346
+ const removed = yield* storage("remove-delivered", queuedMessage.messageId, () =>
347
+ removeThreadOutboxMessage(
348
queuedMessage,
349
deliveryRevision,
303
- () => !appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId],
304
- );
305
- if (!removed) {
306
- forgetAcknowledgedThreadMessage(queuedMessage);
307
- threadOutboxDebug.log("delivered message was edited before cleanup", {
350
+ () => !isEditingQueuedMessage(queuedMessage.messageId),
351
+ ),
352
+ ).pipe(
353
+ Effect.catch((error) =>
354
+ Effect.logWarning("[thread-outbox] failed to remove delivered queued message", {
355
environmentId: queuedMessage.environmentId,
356
threadId: queuedMessage.threadId,
357
messageId: queuedMessage.messageId,
311
- });
312
- return "edited";
313
- }
314
- return "removed";
315
- } catch (error) {
316
- forgetAcknowledgedThreadMessage(queuedMessage);
317
- console.warn("[thread-outbox] failed to remove delivered queued message", {
318
- environmentId: queuedMessage.environmentId,
319
- threadId: queuedMessage.threadId,
320
- messageId: queuedMessage.messageId,
321
- error,
322
- });
323
- return "failed";
324
- }
325
-}
358
+ error: error.cause,
359
+ }).pipe(Effect.as(null)),
360
+ ),
361
+ );
362
+ if (removed === true) return "removed" as const;
363
+ forgetAcknowledgedThreadMessage(queuedMessage);
364
+ if (removed === null) return "failed" as const;
365
+ threadOutboxDebug.log("delivered message was edited before cleanup", {
366
+ environmentId: queuedMessage.environmentId,
367
+ threadId: queuedMessage.threadId,
368
+ messageId: queuedMessage.messageId,
369
+ });
370
+ return "edited" as const;
371
+});
372
327
-export async function removeAcknowledgedExistingThreadMessage(
328
- queuedMessage: QueuedThreadMessage,
329
- acknowledgedMessageIds: Set<MessageId>,
330
-): Promise<boolean> {
331
- try {
332
- await removeDeliveredCloudQueuedMessage(queuedMessage).catch((error) => {
333
- console.warn("[thread-outbox] could not update sign-out snapshot after delivery", {
373
+export const removeAcknowledgedExistingThreadMessage = Effect.fn(
374
+ "ThreadOutbox.removeAcknowledgedMessage",
375
+)(function* (queuedMessage: QueuedThreadMessage, acknowledgedMessageIds: Set<MessageId>) {
376
+ yield* forgetCloudQueuedMessage(queuedMessage);
377
+ const removed = yield* storage("remove-acknowledged", queuedMessage.messageId, () =>
378
+ removeThreadOutboxMessage(queuedMessage),
379
+ ).pipe(
380
+ Effect.catch((error) =>
381
+ Effect.logWarning("[thread-outbox] failed to remove acknowledged queued message", {
382
+ environmentId: queuedMessage.environmentId,
383
+ threadId: queuedMessage.threadId,
384
messageId: queuedMessage.messageId,
335
- error,
336
- });
337
- });
338
- const removed = await removeThreadOutboxMessage(queuedMessage);
339
- if (removed) {
340
- acknowledgedMessageIds.delete(queuedMessage.messageId);
341
- }
342
- return removed;
343
- } catch (error) {
344
- console.warn("[thread-outbox] failed to remove acknowledged queued message", {
345
- environmentId: queuedMessage.environmentId,
346
- threadId: queuedMessage.threadId,
347
- messageId: queuedMessage.messageId,
348
- error,
349
- });
350
- return false;
351
- }
352
-}
385
+ error: error.cause,
386
+ }).pipe(Effect.as(false)),
387
+ ),
388
+ );
389
+ if (!removed) return yield* retryDelivery;
390
+ acknowledgedMessageIds.delete(queuedMessage.messageId);
391
+});
392
354
-export async function recoverEditedCreationAfterDelivery(
355
- queuedMessage: QueuedThreadMessage,
356
-): Promise<boolean> {
357
- const kept = Object.values(appAtomRegistry.get(threadOutboxManager.queuedMessagesByThreadKeyAtom))
358
- .flat()
359
- .find((candidate) => candidate.messageId === queuedMessage.messageId);
360
- if (!kept) {
361
- return true;
362
- }
363
- const keptRevision = threadOutboxRevision(kept.messageId);
364
- if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[kept.messageId]) {
365
- return true;
366
- }
367
- const draftKey = scopedThreadKey(kept.environmentId, kept.threadId);
368
- try {
369
- // Merge before removal to retain file ownership; allow overflow and let send guards require trimming.
370
- await mergeComposerDraftContent(draftKey, {
371
- text: kept.text,
372
- context: kept.context,
373
- attachments: [],
374
- });
375
- if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[kept.messageId]) {
376
- return true;
377
- }
378
- if (threadOutboxRevision(kept.messageId) !== keptRevision) {
379
- return false;
380
- }
381
- const existingAttachmentIds = new Set(
382
- getComposerDraftSnapshot(draftKey).attachments.map((attachment) => attachment.id),
383
- );
384
- appendComposerDraftAttachments(
385
- draftKey,
386
- kept.attachments.filter((attachment) => !existingAttachmentIds.has(attachment.id)),
387
- { restore: true },
393
+/** Hands a new task edited after its launch back to the composer, then drops it from the queue. */
394
+export const recoverEditedCreationAfterDelivery = Effect.fn("ThreadOutbox.recoverEditedCreation")(
395
+ function* (queuedMessage: QueuedThreadMessage) {
396
+ const kept = Object.values(
397
+ appAtomRegistry.get(threadOutboxManager.queuedMessagesByThreadKeyAtom),
398
+ )
399
+ .flat()
400
+ .find((candidate) => candidate.messageId === queuedMessage.messageId);
401
+ if (!kept || isEditingQueuedMessage(kept.messageId)) return;
402
+ const keptRevision = threadOutboxRevision(kept.messageId);
403
+ const draftKey = scopedThreadKey(kept.environmentId, kept.threadId);
404
+ const handedBack = yield* Effect.gen(function* () {
405
+ // Merge before removal to retain file ownership; allow overflow and let send guards require trimming.
406
+ yield* storage("hand-back-to-draft", kept.messageId, () =>
407
+ mergeComposerDraftContent(draftKey, {
408
+ text: kept.text,
409
+ context: kept.context,
410
+ attachments: [],
411
+ }),
412
+ );
413
+ if (isEditingQueuedMessage(kept.messageId)) return "edited" as const;
414
+ if (threadOutboxRevision(kept.messageId) !== keptRevision) return "changed" as const;
415
+ const existingAttachmentIds = new Set(
416
+ getComposerDraftSnapshot(draftKey).attachments.map((attachment) => attachment.id),
417
+ );
418
+ appendComposerDraftAttachments(
419
+ draftKey,
420
+ kept.attachments.filter((attachment) => !existingAttachmentIds.has(attachment.id)),
421
+ { restore: true },
422
+ );
423
+ updateComposerDraftSettings(draftKey, {
424
+ ...(kept.modelSelection !== undefined ? { modelSelection: kept.modelSelection } : {}),
425
+ ...(kept.runtimeMode !== undefined ? { runtimeMode: kept.runtimeMode } : {}),
426
+ ...(kept.interactionMode !== undefined ? { interactionMode: kept.interactionMode } : {}),
427
+ });
428
+ // Flush before removal: append only schedules persistence, leaving the queue as the sole durable copy.
429
+ yield* storage("flush-drafts", kept.messageId, () => flushComposerDrafts());
430
+ return "handed-back" as const;
431
+ }).pipe(
432
+ Effect.catch((error) =>
433
+ Effect.logWarning(
434
+ "[thread-outbox] could not hand an edited pending task to the composer",
435
+ error.cause,
436
+ ).pipe(Effect.as("failed" as const)),
437
+ ),
438
);
389
- updateComposerDraftSettings(draftKey, {
390
- ...(kept.modelSelection !== undefined ? { modelSelection: kept.modelSelection } : {}),
391
- ...(kept.runtimeMode !== undefined ? { runtimeMode: kept.runtimeMode } : {}),
392
- ...(kept.interactionMode !== undefined ? { interactionMode: kept.interactionMode } : {}),
393
- });
394
- // Flush before removal: append only schedules persistence, leaving the queue as the sole durable copy.
395
- await flushComposerDrafts();
396
- } catch (error) {
397
- console.warn("[thread-outbox] could not hand an edited pending task to the composer", error);
398
- return false;
399
- }
400
- if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[kept.messageId]) {
401
- return true;
402
- }
403
- try {
404
- return await removeThreadOutboxMessage(
405
- kept,
406
- keptRevision,
407
- () => !appAtomRegistry.get(editingQueuedMessageIdsAtom)[kept.messageId],
439
+ if (handedBack === "edited") return;
440
+ if (handedBack !== "handed-back") return yield* retryDelivery;
441
+ if (isEditingQueuedMessage(kept.messageId)) return;
442
+ const removed = yield* storage("remove-recovered", kept.messageId, () =>
443
+ removeThreadOutboxMessage(kept, keptRevision, () => !isEditingQueuedMessage(kept.messageId)),
444
+ ).pipe(
445
+ Effect.catch((error) =>
446
+ Effect.logWarning(
447
+ "[thread-outbox] could not remove recovered pending task",
448
+ error.cause,
449
+ ).pipe(Effect.as(false)),
450
+ ),
451
);
409
- } catch (error) {
410
- console.warn("[thread-outbox] could not remove recovered pending task", error);
411
- return false;
412
- }
413
-}
414
-
415
-export async function restoreRejectedQueuedMessage(
416
- queuedMessage: QueuedThreadMessage,
417
- message: string,
418
-): Promise<"restored" | "deferred" | "blocked" | "retry"> {
419
- const draftKey = recoveryDraftKey(queuedMessage);
420
- const threadKey = scopedThreadKey(queuedMessage.environmentId, queuedMessage.threadId);
421
- let rollback: { readonly snapshot: ComposerDraft; readonly merged: ComposerDraft } | null = null;
422
- try {
423
- if (
424
- appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId] ||
425
- !(await confirmThreadOutboxMessageQueued(queuedMessage)) ||
426
- appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]
427
- ) {
428
- return "deferred";
429
- }
430
- const revision = threadOutboxRevision(queuedMessage.messageId);
452
+ if (!removed) return yield* retryDelivery;
453
+ },
454
+);
455
432
- await waitForComposerDraftsLoaded();
433
- if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]) {
434
- return "deferred";
435
- }
436
- const originalDraft = getComposerDraftSnapshot(draftKey);
437
- const existingAttachmentIds = new Set(
438
- originalDraft.attachments.map((attachment) => attachment.id),
439
- );
440
- const addedAttachmentCount = queuedMessage.attachments.filter(
441
- (attachment) => !existingAttachmentIds.has(attachment.id),
442
- ).length;
443
- if (existingAttachmentIds.size + addedAttachmentCount > PROVIDER_SEND_TURN_MAX_ATTACHMENTS) {
444
- setThreadComposerError(
445
- threadKey,
446
- `Remove attachments from the draft before restoring this message. Messages can contain at most ${PROVIDER_SEND_TURN_MAX_ATTACHMENTS} attachments.`,
447
- queuedMessage.messageId,
456
+/**
457
+ * Hands an undeliverable message back to its draft with the reason. "blocked" means the draft
458
+ * cannot take it yet (attachment cap); "deferred" means an editor or newer write owns it.
459
+ */
460
+export const restoreRejectedQueuedMessage = Effect.fn("ThreadOutbox.restoreRejectedMessage")(
461
+ function* (queuedMessage: QueuedThreadMessage, message: string) {
462
+ const draftKey = recoveryDraftKey(queuedMessage);
463
+ const threadKey = scopedThreadKey(queuedMessage.environmentId, queuedMessage.threadId);
464
+ const editing = () => isEditingQueuedMessage(queuedMessage.messageId);
465
+ // Until the queue drops the message, a failure undoes the merge, keeping concurrent edits.
466
+ let rollback: { readonly snapshot: ComposerDraft; readonly merged: ComposerDraft } | null =
467
+ null;
468
+ const undo = (snapshot: ComposerDraft, merged: ComposerDraft) =>
469
+ storage("undo-draft-merge", queuedMessage.messageId, () =>
470
+ undoComposerDraftMerge(draftKey, snapshot, merged),
471
);
449
- return "blocked";
450
- }
472
+ return yield* Effect.gen(function* () {
473
+ if (editing() || !(yield* confirmQueued(queuedMessage)) || editing()) {
474
+ return "deferred" as const;
475
+ }
476
+ const revision = threadOutboxRevision(queuedMessage.messageId);
477
+ yield* storage("load-drafts", queuedMessage.messageId, () => waitForComposerDraftsLoaded());
478
+ if (editing()) return "deferred" as const;
479
+ const originalDraft = getComposerDraftSnapshot(draftKey);
480
+ const existingAttachmentIds = new Set(
481
+ originalDraft.attachments.map((attachment) => attachment.id),
482
+ );
483
+ const addedAttachmentCount = queuedMessage.attachments.filter(
484
+ (attachment) => !existingAttachmentIds.has(attachment.id),
485
+ ).length;
486
+ if (existingAttachmentIds.size + addedAttachmentCount > PROVIDER_SEND_TURN_MAX_ATTACHMENTS) {
487
+ setThreadComposerError(
488
+ threadKey,
489
+ `Remove attachments from the draft before restoring this message. Messages can contain at most ${PROVIDER_SEND_TURN_MAX_ATTACHMENTS} attachments.`,
490
+ queuedMessage.messageId,
491
+ );
492
+ return "blocked" as const;
493
+ }
494
452
- const withdrawError = () => clearThreadComposerError(threadKey, queuedMessage.messageId);
453
- if (!queuedMessage.creation) {
454
- setThreadComposerError(threadKey, message, queuedMessage.messageId);
455
- }
456
- let mergedDraft: ComposerDraft;
457
- try {
495
+ const withdraw = (merged: ComposerDraft) =>
496
+ Effect.sync(() => clearThreadComposerError(threadKey, queuedMessage.messageId)).pipe(
497
+ Effect.andThen(undo(originalDraft, merged)),
498
+ Effect.as("deferred" as const),
499
+ );
500
+ if (!queuedMessage.creation) {
501
+ setThreadComposerError(threadKey, message, queuedMessage.messageId);
502
+ }
503
stampRecoveryDraftProject(queuedMessage, draftKey);
459
- await mergeComposerDraftContent(draftKey, {
460
- text: queuedMessage.text,
461
- context: queuedMessage.context,
462
- attachments: queuedMessage.attachments,
463
- });
464
- } finally {
465
- // Capture rollback in finally because merge publishes even on persistence failure; undo must preserve concurrent edits.
466
- mergedDraft = getComposerDraftSnapshot(draftKey);
467
- rollback = { snapshot: originalDraft, merged: mergedDraft };
468
- }
469
- if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]) {
470
- withdrawError();
471
- await undoComposerDraftMerge(draftKey, originalDraft, mergedDraft);
472
- return "deferred";
473
- }
474
- updateComposerDraftSettings(draftKey, {
475
- ...(queuedMessage.modelSelection ? { modelSelection: queuedMessage.modelSelection } : {}),
476
- ...(queuedMessage.runtimeMode ? { runtimeMode: queuedMessage.runtimeMode } : {}),
477
- ...(queuedMessage.interactionMode ? { interactionMode: queuedMessage.interactionMode } : {}),
478
- ...(queuedMessage.freshContext ? { freshContext: true } : {}),
479
- ...(queuedMessage.creation
480
- ? {
481
- workspaceSelection: {
482
- mode: queuedMessage.creation.workspaceMode,
483
- branch: queuedMessage.creation.branch,
484
- worktreePath: queuedMessage.creation.worktreePath,
485
- pullRequestReference: queuedMessage.creation.pullRequestReference,
486
- ...(queuedMessage.creation.startFromOrigin !== undefined
487
- ? { startFromOrigin: queuedMessage.creation.startFromOrigin }
488
- : {}),
489
- },
490
- }
491
- : {}),
492
- });
493
- const restoredDraft = getComposerDraftSnapshot(draftKey);
494
- rollback = { snapshot: originalDraft, merged: restoredDraft };
495
- await flushComposerDrafts();
496
- if (
497
- appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId] ||
498
- !(await confirmThreadOutboxMessageQueued(queuedMessage)) ||
499
- appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]
500
- ) {
501
- withdrawError();
502
- await undoComposerDraftMerge(draftKey, originalDraft, restoredDraft);
503
- return "deferred";
504
- }
505
- if (
506
- !(await removeThreadOutboxMessage(
507
- queuedMessage,
508
- revision,
509
- () => !appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId],
510
- ))
511
- ) {
512
- withdrawError();
513
- await undoComposerDraftMerge(draftKey, originalDraft, restoredDraft);
514
- return "deferred";
515
- }
516
- // After queue removal, the draft owns content and must never roll back.
517
- rollback = null;
518
- if (queuedMessage.creation) {
519
- withdrawError();
520
- recordPendingThreadCreationOutcome({
521
- kind: "failed",
522
- message: queuedMessage,
523
- reason: message,
504
+ // The merge publishes even when persisting it fails, so the rollback is captured either way.
505
+ yield* storage("restore-to-draft", queuedMessage.messageId, () =>
506
+ mergeComposerDraftContent(draftKey, {
507
+ text: queuedMessage.text,
508
+ context: queuedMessage.context,
509
+ attachments: queuedMessage.attachments,
510
+ }),
511
+ ).pipe(
512
+ Effect.ensuring(
513
+ Effect.sync(() => {
514
+ rollback = { snapshot: originalDraft, merged: getComposerDraftSnapshot(draftKey) };
515
+ }),
516
+ ),
517
+ );
518
+ if (editing()) return yield* withdraw(getComposerDraftSnapshot(draftKey));
519
+ updateComposerDraftSettings(draftKey, {
520
+ ...(queuedMessage.modelSelection ? { modelSelection: queuedMessage.modelSelection } : {}),
521
+ ...(queuedMessage.runtimeMode ? { runtimeMode: queuedMessage.runtimeMode } : {}),
522
+ ...(queuedMessage.interactionMode
523
+ ? { interactionMode: queuedMessage.interactionMode }
524
+ : {}),
525
+ ...(queuedMessage.freshContext ? { freshContext: true } : {}),
526
+ ...(queuedMessage.creation
527
+ ? {
528
+ workspaceSelection: {
529
+ mode: queuedMessage.creation.workspaceMode,
530
+ branch: queuedMessage.creation.branch,
531
+ worktreePath: queuedMessage.creation.worktreePath,
532
+ pullRequestReference: queuedMessage.creation.pullRequestReference,
533
+ ...(queuedMessage.creation.startFromOrigin !== undefined
534
+ ? { startFromOrigin: queuedMessage.creation.startFromOrigin }
535
+ : {}),
536
+ },
537
+ }
538
+ : {}),
539
});
525
- }
526
- return "restored";
527
- } catch (error) {
528
- if (rollback !== null) {
529
- await undoComposerDraftMerge(draftKey, rollback.snapshot, rollback.merged).catch(
530
- (undoError) => {
531
- console.warn("[thread-outbox] failed to persist a recovery rollback", undoError);
532
- },
540
+ const restoredDraft = getComposerDraftSnapshot(draftKey);
541
+ rollback = { snapshot: originalDraft, merged: restoredDraft };
542
+ yield* storage("flush-drafts", queuedMessage.messageId, () => flushComposerDrafts());
543
+ if (editing() || !(yield* confirmQueued(queuedMessage)) || editing()) {
544
+ return yield* withdraw(restoredDraft);
545
+ }
546
+ const removed = yield* storage("remove-restored", queuedMessage.messageId, () =>
547
+ removeThreadOutboxMessage(queuedMessage, revision, () => !editing()),
548
);
534
- }
535
- console.warn("[thread-outbox] failed to restore an undeliverable message", error);
536
- setThreadComposerError(
537
- threadKey,
538
- error instanceof Error ? error.message : "The unsent message could not be restored.",
539
- queuedMessage.messageId,
549
+ if (!removed) return yield* withdraw(restoredDraft);
550
+ // After queue removal, the draft owns content and must never roll back.
551
+ rollback = null;
552
+ if (queuedMessage.creation) {
553
+ clearThreadComposerError(threadKey, queuedMessage.messageId);
554
+ recordPendingThreadCreationOutcome({
555
+ kind: "failed",
556
+ message: queuedMessage,
557
+ reason: message,
558
+ });
559
+ }
560
+ return "restored" as const;
561
+ }).pipe(
562
+ Effect.catch((error) =>
563
+ Effect.gen(function* () {
564
+ const pending: typeof rollback = rollback;
565
+ if (pending !== null) {
566
+ yield* undo(pending.snapshot, pending.merged).pipe(
567
+ Effect.catch((undoError) =>
568
+ Effect.logWarning(
569
+ "[thread-outbox] failed to persist a recovery rollback",
570
+ undoError.cause,
571
+ ),
572
+ ),
573
+ );
574
+ }
575
+ yield* Effect.logWarning(
576
+ "[thread-outbox] failed to restore an undeliverable message",
577
+ error.cause,
578
+ );
579
+ setThreadComposerError(
580
+ threadKey,
581
+ error.cause instanceof Error
582
+ ? error.cause.message
583
+ : "The unsent message could not be restored.",
584
+ queuedMessage.messageId,
585
+ );
586
+ return "retry" as const;
587
+ }),
588
+ ),
589
);
541
- return "retry";
542
- }
543
-}
590
+ },
591
+);
592
593
/** Derive keys from message ids so failed recovery retries reuse the same draft. */
594
function recoveryDraftKey(queuedMessage: QueuedThreadMessage): string {
@@ -562,14 +610,10 @@ function stampRecoveryDraftProject(queuedMessage: QueuedThreadMessage, draftKey:
610
});
611
}
612
565
-async function preserveUploadedAttachmentsForEditor(
566
- originalMessage: QueuedThreadMessage,
567
- uploadedMessage: QueuedThreadMessage,
568
-): Promise<void> {
569
- if (!originalMessage.creation) {
570
- return;
571
- }
572
-
613
+const preserveUploadedAttachmentsForEditor = Effect.fn(
614
+ "ThreadOutbox.preserveUploadedAttachmentsForEditor",
615
+)(function* (originalMessage: QueuedThreadMessage, uploadedMessage: QueuedThreadMessage) {
616
+ if (!originalMessage.creation) return;
617
const draftKey = `pending-task:${originalMessage.messageId}`;
618
const draft = getComposerDraftSnapshot(draftKey);
619
const uploadedById = new Map(
@@ -593,18 +637,13 @@ async function preserveUploadedAttachmentsForEditor(
637
uploadEnvironmentId: uploaded.uploadEnvironmentId,
638
};
639
});
596
- if (changed) {
597
- replaceComposerDraftAttachments(draftKey, nextAttachments);
598
- await flushComposerDrafts();
599
- }
600
-}
640
+ if (!changed) return;
641
+ replaceComposerDraftAttachments(draftKey, nextAttachments);
642
+ yield* Effect.promise(() => flushComposerDrafts());
643
+});
644
602
-// Everything a drain pass decides from. Each queued environment's session is
603
-// read here so a granted or revoked operate scope re-runs the drain.
604
-const uploadingComposerAttachmentKeysAtom = Atom.map(
605
- composerAttachmentUploadsAtom,
606
- uploadingComposerAttachmentKeys,
607
-);
645
+// Everything delivery decides from. Each queued environment's session is read
646
+// here so a granted or revoked operate scope wakes delivery.
647
648
const deliveryInputsAtom = Atom.make((get) => {
649
const connectedEnvironments = get(workspaceConnections.environmentsAtom);
@@ -620,7 +659,6 @@ const deliveryInputsAtom = Atom.make((get) => {
659
}
660
}
661
return {
623
- dispatchingQueuedMessageId: get(dispatchingQueuedMessageIdAtom),
662
editingQueuedMessageIds: get(editingQueuedMessageIdsAtom),
663
queuedMessagesByThreadKey: get(threadOutboxManager.queuedMessagesByThreadKeyAtom),
664
shellStatuses: get(threadOutboxShellStatusesAtom),
@@ -629,8 +667,6 @@ const deliveryInputsAtom = Atom.make((get) => {
667
serverConfigs: get(environmentServerConfigsAtom),
668
connectedEnvironments,
669
operableEnvironments,
632
- // Wakes a message waiting on the upload worker when that upload settles.
633
- uploadingAttachmentKeys: get(uploadingComposerAttachmentKeysAtom),
670
};
671
}).pipe(Atom.withLabel("mobile:thread-outbox:delivery-inputs"));
672
@@ -660,11 +696,11 @@ function deliveredSequence(
696
return AsyncResult.isSuccess(result) ? result.value.sequence : undefined;
697
}
698
663
-const runDeliveryCommand = <W, A, E>(
699
+const deliveryCommand = <W, A, E>(
700
command: AtomCommand<W, A, E>,
701
input: W,
666
-): Promise<AtomCommandResult<A, E>> =>
667
- runAtomCommand(appAtomRegistry, command, input, { reportFailure: false });
702
+): Effect.Effect<AtomCommandResult<A, E>> =>
703
+ Effect.promise(() => runAtomCommand(appAtomRegistry, command, input, { reportFailure: false }));
704
705
function reportCommandFailure(
706
queuedMessage: QueuedThreadMessage,
@@ -695,14 +731,33 @@ function reportCommandFailure(
731
interface ThreadOutboxRetry {
732
readonly attempt: number;
733
readonly notBefore: number;
698
- readonly timer: ReturnType<typeof setTimeout>;
734
}
735
736
+/** A thread's delivery fiber; `retiring` once interrupted, until the fiber has exited. */
737
+interface ThreadFiber {
738
+ readonly wake: Latch.Latch;
739
+ fiber: Fiber.Fiber<never> | undefined;
740
+ retiring: boolean;
741
+}
742
+
743
+/** What a thread's delivery fiber does next with the head of its queue. */
744
+type ThreadDeliveryStep =
745
+ /** Nothing to send until an input changes, or until `until` when a backoff is running. */
746
+ | { readonly _tag: "Wait"; readonly until?: number }
747
+ /** The head failed without a send; back off before trying it again. */
748
+ | { readonly _tag: "Backoff"; readonly messageId: MessageId }
749
+ | {
750
+ readonly _tag: "Dispatch";
751
+ readonly messageId: MessageId;
752
+ /** Succeeds once the message is handled (sent, removed or handed back). */
753
+ readonly run: Effect.Effect<void, DeliveryRetry>;
754
+ };
755
+
756
/**
702
- * Delivers queued thread messages one at a time. A drain pass runs whenever its inputs
703
- * change (outbox, locks, shells, projects, configs, connections, scopes) and when a retry
704
- * backoff expires. `dispatchingQueuedMessageIdAtom` is the single in-flight slot; clearing
705
- * it re-runs the drain for the next message.
757
+ * Delivers queued thread messages, one fiber per thread so a slow send in one thread never
758
+ * holds another. Each fiber sends its thread's head message in order, backs off after a
759
+ * failure, and otherwise waits until an input changes (outbox, locks, shells, projects,
760
+ * configs, connections, scopes).
761
*/
762
export function createThreadOutboxDelivery(): {
763
readonly drain: () => void;
@@ -732,52 +787,29 @@ export function createThreadOutboxDelivery(): {
787
788
const scheduleRetry = (messageId: MessageId): void => {
789
if (disposed) return;
735
- const previous = retries.get(messageId);
736
- if (previous !== undefined) clearTimeout(previous.timer);
737
- const attempt = (previous?.attempt ?? 0) + 1;
738
- const delayMs = threadOutboxRetryDelayMs(attempt);
790
+ const attempt = (retries.get(messageId)?.attempt ?? 0) + 1;
791
retries.set(messageId, {
792
attempt,
741
- notBefore: Date.now() + delayMs,
742
- timer: setTimeout(drain, delayMs),
793
+ notBefore: Date.now() + threadOutboxRetryDelayMs(attempt),
794
});
795
setQueuedMessageRetrying(messageId, true);
796
};
797
798
const clearRetry = (messageId: MessageId): void => {
748
- const retry = retries.get(messageId);
749
- if (retry === undefined) return;
750
- clearTimeout(retry.timer);
751
- retries.delete(messageId);
799
+ if (!retries.delete(messageId)) return;
800
setQueuedMessageRetrying(messageId, false);
801
};
802
755
- // A delivery that throws backs off like any failure. Releasing the slot
756
- // without a retry would re-run the drain straight into the same message.
757
- const settle = (messageId: MessageId, delivery: Promise<boolean>): void => {
758
- void delivery
759
- .then(
760
- (sent) => (sent ? clearRetry(messageId) : scheduleRetry(messageId)),
761
- (error: unknown) => {
762
- console.warn("[thread-outbox] queued message delivery threw", { messageId, error });
763
- scheduleRetry(messageId);
764
- },
765
- )
766
- .finally(() => finishDispatchingQueuedMessage(messageId));
767
- };
768
-
803
// An over-cap draft blocks recovery until the user changes its attachments;
804
// parking on the draft avoids hammering the restore with backoff retries.
771
- const restoreQueuedMessage = async (
805
+ const restoreQueuedMessage = Effect.fn("ThreadOutbox.restoreQueuedMessage")(function* (
806
queuedMessage: QueuedThreadMessage,
807
message: string,
774
- ): Promise<boolean> => {
775
- const result = await restoreRejectedQueuedMessage(queuedMessage, message);
776
- if (result !== "blocked") {
777
- return result !== "retry";
778
- }
779
- if (disposed || blockedRecoveries.has(queuedMessage.messageId)) {
780
- return true;
808
+ ) {
809
+ const result = yield* restoreRejectedQueuedMessage(queuedMessage, message);
810
+ if (result === "retry") return yield* retryDelivery;
811
+ if (result !== "blocked" || disposed || blockedRecoveries.has(queuedMessage.messageId)) {
812
+ return;
813
}
814
const draftKey = recoveryDraftKey(queuedMessage);
815
const editorDraftKey = queuedMessage.creation
@@ -800,23 +832,22 @@ export function createThreadOutboxDelivery(): {
832
}
833
blockedRecoveries.delete(queuedMessage.messageId);
834
active.unsubscribe();
803
- drain();
835
+ wakeThreads();
836
});
837
blockedRecoveries.set(queuedMessage.messageId, { message: queuedMessage, unsubscribe });
806
- return true;
807
- };
838
+ });
839
809
- const sendQueuedMessage = async (
840
+ const sendQueuedMessage = Effect.fn("ThreadOutbox.sendQueuedMessage")(function* (
841
queuedMessage: QueuedThreadMessage,
842
thread: EnvironmentThreadShell,
812
- ): Promise<boolean> => {
843
+ ) {
844
const hasAccess = () =>
845
readEnvironmentScope(queuedMessage.environmentId, AuthOrchestrationOperateScope);
815
- if (!hasAccess()) return true;
846
+ if (!hasAccess()) return;
847
const serverConfig = appAtomRegistry.get(
848
serverEnvironment.configValueAtom(queuedMessage.environmentId),
849
);
819
- if (!serverConfig) return false;
850
+ if (!serverConfig) return yield* retryDelivery;
851
const settings = resolveQueuedThreadSettings(queuedMessage, thread, serverConfig.providers);
852
if (isModelSelectionUnavailable(serverConfig, settings.modelSelection, thread.projectId)) {
853
const { title, detail } = describeUnavailableModelSelection(
@@ -824,7 +855,7 @@ export function createThreadOutboxDelivery(): {
855
settings.modelSelection,
856
thread.projectId,
857
);
827
- return restoreQueuedMessage(queuedMessage, `${title}. ${detail}`);
858
+ return yield* restoreQueuedMessage(queuedMessage, `${title}. ${detail}`);
859
}
860
// The server would refuse this mode in settings sync, which retries forever; stop first.
861
const runtimeModeDenial = managedRuntimeModeDenial(
@@ -832,12 +863,12 @@ export function createThreadOutboxDelivery(): {
863
settings.runtimeMode,
864
);
865
if (runtimeModeDenial !== undefined) {
835
- return restoreQueuedMessage(queuedMessage, runtimeModeDenial);
866
+ return yield* restoreQueuedMessage(queuedMessage, runtimeModeDenial);
867
}
868
869
if (settings.runtimeMode !== thread.runtimeMode) {
839
- if (!hasAccess()) return true;
840
- const runtimeResult = await runDeliveryCommand(threadEnvironment.setRuntimeMode, {
870
+ if (!hasAccess()) return;
871
+ const runtimeResult = yield* deliveryCommand(threadEnvironment.setRuntimeMode, {
872
environmentId: queuedMessage.environmentId,
873
input: {
874
commandId: settingsCommandId(queuedMessage, "runtime-mode"),
@@ -848,13 +879,13 @@ export function createThreadOutboxDelivery(): {
879
});
880
if (AsyncResult.isFailure(runtimeResult)) {
881
reportCommandFailure(queuedMessage, runtimeResult, "settings-sync");
851
- return false;
882
+ return yield* retryDelivery;
883
}
884
}
885
886
if (settings.interactionMode !== thread.interactionMode) {
856
- if (!hasAccess()) return true;
857
- const interactionResult = await runDeliveryCommand(threadEnvironment.setInteractionMode, {
887
+ if (!hasAccess()) return;
888
+ const interactionResult = yield* deliveryCommand(threadEnvironment.setInteractionMode, {
889
environmentId: queuedMessage.environmentId,
890
input: {
891
commandId: settingsCommandId(queuedMessage, "interaction-mode"),
@@ -865,51 +896,48 @@ export function createThreadOutboxDelivery(): {
896
});
897
if (AsyncResult.isFailure(interactionResult)) {
898
reportCommandFailure(queuedMessage, interactionResult, "settings-sync");
868
- return false;
899
+ return yield* retryDelivery;
900
}
901
}
902
872
- let prepared: PreparedTurnAttachments;
873
- let persistedMessage: QueuedThreadMessage;
874
- let deliveryRevision: number;
875
- if (!hasAccess()) return true;
876
- try {
877
- const preparedResult = await prepareQueuedMessageAttachments(queuedMessage);
878
- if (preparedResult.status === "abandoned") {
879
- return true;
880
- }
881
- prepared = preparedResult.prepared;
882
- persistedMessage = preparedResult.persistedMessage;
883
- deliveryRevision = preparedResult.deliveryRevision;
884
- if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]) {
885
- await preserveUploadedAttachmentsForEditor(queuedMessage, preparedResult.persistedMessage);
886
- return true;
887
- }
888
- } catch (error) {
889
- if (!hasAccess()) return true;
903
+ if (!hasAccess()) return;
904
+ // Waiting on the shared upload is the one part of a send that may be cut short.
905
+ const preparedExit = yield* Effect.exit(
906
+ Effect.interruptible(prepareQueuedMessageAttachments(queuedMessage)),
907
+ );
908
+ if (Exit.isFailure(preparedExit)) {
909
+ if (Cause.hasInterruptsOnly(preparedExit.cause)) return yield* Effect.interrupt;
910
+ const error = Cause.squash(preparedExit.cause);
911
+ if (!hasAccess()) return;
912
logThreadOutboxUploadFailure(queuedMessage, error);
913
if (!shouldRetryThreadOutboxDelivery(error)) {
892
- return restoreQueuedMessage(
914
+ return yield* restoreQueuedMessage(
915
queuedMessage,
916
error instanceof Error ? error.message : "An attachment could not upload.",
917
);
918
}
897
- return false;
919
+ return yield* retryDelivery;
920
+ }
921
+ if (preparedExit.value.status === "abandoned") return;
922
+ const { prepared, persistedMessage, deliveryRevision } = preparedExit.value;
923
+ if (isEditingQueuedMessage(queuedMessage.messageId)) {
924
+ yield* preserveUploadedAttachmentsForEditor(queuedMessage, persistedMessage);
925
+ return;
926
}
927
if (!isQueuedMessagePayloadCurrent(persistedMessage, deliveryRevision)) {
900
- return true;
928
+ return;
929
}
930
const currentConfig = appAtomRegistry.get(
931
serverEnvironment.configValueAtom(queuedMessage.environmentId),
932
);
905
- if (!currentConfig) return false;
933
+ if (!currentConfig) return yield* retryDelivery;
934
if (isModelSelectionUnavailable(currentConfig, settings.modelSelection, thread.projectId)) {
935
const { title, detail } = describeUnavailableModelSelection(
936
currentConfig,
937
settings.modelSelection,
938
thread.projectId,
939
);
912
- return restoreQueuedMessage(persistedMessage, `${title}. ${detail}`);
940
+ return yield* restoreQueuedMessage(persistedMessage, `${title}. ${detail}`);
941
}
942
const sendSettings = resolveQueuedThreadSettings(
943
queuedMessage,
@@ -917,9 +945,9 @@ export function createThreadOutboxDelivery(): {
945
currentConfig.providers,
946
);
947
if (queuedMessage.compactBeforeSend === true) {
920
- if (!hasAccess()) return true;
948
+ if (!hasAccess()) return;
949
// Queued, since steering a running turn with a compaction is rejected.
922
- const compactionResult = await runDeliveryCommand(threadEnvironment.startTurn, {
950
+ const compactionResult = yield* deliveryCommand(threadEnvironment.startTurn, {
951
environmentId: queuedMessage.environmentId,
952
input: {
953
commandId: settingsCommandId(queuedMessage, "compact"),
@@ -940,16 +968,16 @@ export function createThreadOutboxDelivery(): {
968
resendAfterSocketLoss: false,
969
},
970
});
943
- if (AsyncResult.isFailure(compactionResult) && !hasAccess()) return true;
971
+ if (AsyncResult.isFailure(compactionResult) && !hasAccess()) return;
972
const compactionFailure = reportCommandFailure(queuedMessage, compactionResult, "start-turn");
945
- if (compactionFailure?.action === "retry") return false;
973
+ if (compactionFailure?.action === "retry") return yield* retryDelivery;
974
if (compactionFailure?.action === "restore") {
947
- return restoreQueuedMessage(persistedMessage, compactionFailure.message);
975
+ return yield* restoreQueuedMessage(persistedMessage, compactionFailure.message);
976
}
949
- if (!isQueuedMessagePayloadCurrent(persistedMessage, deliveryRevision)) return true;
977
+ if (!isQueuedMessagePayloadCurrent(persistedMessage, deliveryRevision)) return;
978
}
951
- if (!hasAccess()) return true;
952
- const deliveryResult = await runDeliveryCommand(threadEnvironment.startTurn, {
979
+ if (!hasAccess()) return;
980
+ const deliveryResult = yield* deliveryCommand(threadEnvironment.startTurn, {
981
environmentId: queuedMessage.environmentId,
982
input: {
983
commandId: queuedMessage.commandId,
@@ -981,43 +1009,40 @@ export function createThreadOutboxDelivery(): {
1009
resendAfterSocketLoss: false,
1010
},
1011
});
984
- if (AsyncResult.isFailure(deliveryResult) && !hasAccess()) return true;
1012
+ if (AsyncResult.isFailure(deliveryResult) && !hasAccess()) return;
1013
const failure = reportCommandFailure(queuedMessage, deliveryResult, "start-turn");
1014
if (failure?.action === "retry") {
987
- return false;
1015
+ return yield* retryDelivery;
1016
}
1017
if (failure?.action === "restore") {
990
- return restoreQueuedMessage(persistedMessage, failure.message);
1018
+ return yield* restoreQueuedMessage(persistedMessage, failure.message);
1019
}
1020
acknowledgedExistingThreadMessageIds.add(persistedMessage.messageId);
993
- const delivered =
994
- (await completeQueuedMessageDelivery(
995
- persistedMessage,
996
- deliveryRevision,
997
- deliveredSequence(deliveryResult),
998
- )) === "removed";
999
- if (delivered) {
1000
- acknowledgedExistingThreadMessageIds.delete(persistedMessage.messageId);
1001
- }
1002
- return delivered;
1003
- };
1021
+ const outcome = yield* completeQueuedMessageDelivery(
1022
+ persistedMessage,
1023
+ deliveryRevision,
1024
+ deliveredSequence(deliveryResult),
1025
+ );
1026
+ if (outcome !== "removed") return yield* retryDelivery;
1027
+ acknowledgedExistingThreadMessageIds.delete(persistedMessage.messageId);
1028
+ });
1029
1005
- const sendQueuedCreation = async (
1030
+ const sendQueuedCreation = Effect.fn("ThreadOutbox.sendQueuedCreation")(function* (
1031
queuedMessage: QueuedThreadMessage,
1032
creation: QueuedThreadCreation,
1033
projectCwd: string,
1009
- ): Promise<boolean> => {
1034
+ ) {
1035
const hasAccess = () =>
1036
readEnvironmentScope(queuedMessage.environmentId, AuthOrchestrationOperateScope);
1012
- if (!hasAccess()) return true;
1037
+ if (!hasAccess()) return;
1038
const modelSelection = queuedMessage.modelSelection;
1039
if (modelSelection === undefined) {
1015
- return false;
1040
+ return yield* retryDelivery;
1041
}
1042
const serverConfig = appAtomRegistry.get(
1043
serverEnvironment.configValueAtom(queuedMessage.environmentId),
1044
);
1020
- if (!serverConfig) return false;
1045
+ if (!serverConfig) return yield* retryDelivery;
1046
const settings = resolveQueuedThreadSettings(
1047
queuedMessage,
1048
{
@@ -1033,84 +1058,81 @@ export function createThreadOutboxDelivery(): {
1058
settings.modelSelection,
1059
creation.projectId,
1060
);
1036
- return restoreQueuedMessage(queuedMessage, `${title}. ${detail}`);
1061
+ return yield* restoreQueuedMessage(queuedMessage, `${title}. ${detail}`);
1062
}
1063
const runtimeModeDenial = managedRuntimeModeDenial(
1064
serverConfig.managedPolicy,
1065
settings.runtimeMode,
1066
);
1067
if (runtimeModeDenial !== undefined) {
1043
- return restoreQueuedMessage(queuedMessage, runtimeModeDenial);
1068
+ return yield* restoreQueuedMessage(queuedMessage, runtimeModeDenial);
1069
}
1045
- let prepared: PreparedTurnAttachments;
1046
- let persistedMessage: QueuedThreadMessage;
1047
- let deliveryRevision: number;
1048
- try {
1049
- const preparedResult = await prepareQueuedMessageAttachments(queuedMessage);
1050
- if (preparedResult.status === "abandoned") {
1051
- return true;
1052
- }
1053
- prepared = preparedResult.prepared;
1054
- persistedMessage = preparedResult.persistedMessage;
1055
- deliveryRevision = preparedResult.deliveryRevision;
1056
- if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]) {
1057
- await preserveUploadedAttachmentsForEditor(queuedMessage, preparedResult.persistedMessage);
1058
- return true;
1059
- }
1060
- } catch (error) {
1061
- if (!hasAccess()) return true;
1070
+ // Waiting on the shared upload is the one part of a send that may be cut short.
1071
+ const preparedExit = yield* Effect.exit(
1072
+ Effect.interruptible(prepareQueuedMessageAttachments(queuedMessage)),
1073
+ );
1074
+ if (Exit.isFailure(preparedExit)) {
1075
+ if (Cause.hasInterruptsOnly(preparedExit.cause)) return yield* Effect.interrupt;
1076
+ const error = Cause.squash(preparedExit.cause);
1077
+ if (!hasAccess()) return;
1078
logThreadOutboxUploadFailure(queuedMessage, error);
1079
if (!shouldRetryThreadOutboxDelivery(error)) {
1064
- return restoreQueuedMessage(
1080
+ return yield* restoreQueuedMessage(
1081
queuedMessage,
1082
error instanceof Error ? error.message : "An attachment could not upload.",
1083
);
1084
}
1069
- return false;
1085
+ return yield* retryDelivery;
1086
+ }
1087
+ if (preparedExit.value.status === "abandoned") return;
1088
+ const { prepared, persistedMessage, deliveryRevision } = preparedExit.value;
1089
+ if (isEditingQueuedMessage(queuedMessage.messageId)) {
1090
+ yield* preserveUploadedAttachmentsForEditor(queuedMessage, persistedMessage);
1091
+ return;
1092
}
1093
if (!isQueuedMessagePayloadCurrent(persistedMessage, deliveryRevision)) {
1072
- return true;
1094
+ return;
1095
}
1096
const currentConfig = appAtomRegistry.get(
1097
serverEnvironment.configValueAtom(queuedMessage.environmentId),
1098
);
1077
- if (!currentConfig) return false;
1099
+ if (!currentConfig) return yield* retryDelivery;
1100
if (isModelSelectionUnavailable(currentConfig, settings.modelSelection, creation.projectId)) {
1101
const { title, detail } = describeUnavailableModelSelection(
1102
currentConfig,
1103
settings.modelSelection,
1104
creation.projectId,
1105
);
1084
- return restoreQueuedMessage(persistedMessage, `${title}. ${detail}`);
1106
+ return yield* restoreQueuedMessage(persistedMessage, `${title}. ${detail}`);
1107
}
1108
const sendSettings = resolveQueuedThreadSettings(
1109
queuedMessage,
1110
settings,
1111
currentConfig.providers,
1112
);
1091
- if (!hasAccess()) return true;
1113
+ if (!hasAccess()) return;
1114
let workspace = creation;
1115
const launched = launchedCreations.get(persistedMessage.messageId);
1116
if (launched?.revision === deliveryRevision) {
1117
workspace = launched.workspace;
1118
} else if (creation.pullRequestReference) {
1097
- const checkout = await runDeliveryCommand(gitEnvironment.preparePullRequestThread, {
1119
+ const checkout = yield* deliveryCommand(gitEnvironment.preparePullRequestThread, {
1120
environmentId: queuedMessage.environmentId,
1121
input: { cwd: projectCwd, reference: creation.pullRequestReference, mode: "worktree" },
1122
});
1123
if (!isQueuedMessagePayloadCurrent(persistedMessage, deliveryRevision) || !hasAccess())
1102
- return true;
1124
+ return;
1125
const failure = reportCommandFailure(queuedMessage, checkout, "start-turn");
1104
- if (failure?.action === "retry") return false;
1126
+ if (failure?.action === "retry") return yield* retryDelivery;
1127
if (failure?.action === "restore")
1106
- return restoreQueuedMessage(persistedMessage, failure.message);
1107
- if (!AsyncResult.isSuccess(checkout)) return false;
1128
+ return yield* restoreQueuedMessage(persistedMessage, failure.message);
1129
+ if (!AsyncResult.isSuccess(checkout)) return yield* retryDelivery;
1130
if (!checkout.value.worktreePath || !checkout.value.isOnPullRequestHead) {
1131
const { shortLabel } = (
1132
sourceControlClients.findByChangeRequestUrl(creation.pullRequestReference) ??
1133
sourceControlClients.get(undefined)
1134
).changeRequest;
1113
- return restoreQueuedMessage(
1135
+ return yield* restoreQueuedMessage(
1136
persistedMessage,
1137
`The ${shortLabel} worktree has local changes and could not update to the ${shortLabel} head. Resolve them before trying again.`,
1138
);
@@ -1124,7 +1146,7 @@ export function createThreadOutboxDelivery(): {
1146
};
1147
}
1148
launchedCreations.set(persistedMessage.messageId, { revision: deliveryRevision, workspace });
1127
- const deliveryResult = await runDeliveryCommand(threadEnvironment.startTurn, {
1149
+ const deliveryResult = yield* deliveryCommand(threadEnvironment.startTurn, {
1150
environmentId: queuedMessage.environmentId,
1151
input: buildProjectThreadStartTurnInput({
1152
projectId: creation.projectId,
@@ -1153,65 +1175,305 @@ export function createThreadOutboxDelivery(): {
1175
worktreeBranchName: buildTemporaryWorktreeBranchName(randomHex),
1176
}),
1177
});
1156
- if (AsyncResult.isFailure(deliveryResult) && !hasAccess()) return true;
1178
+ if (AsyncResult.isFailure(deliveryResult) && !hasAccess()) return;
1179
const failure = reportCommandFailure(queuedMessage, deliveryResult, "start-turn");
1180
if (failure?.action === "retry") {
1159
- return false;
1181
+ return yield* retryDelivery;
1182
}
1183
if (failure?.action === "restore") {
1162
- return restoreQueuedMessage(persistedMessage, failure.message);
1184
+ return yield* restoreQueuedMessage(persistedMessage, failure.message);
1185
}
1186
recordPendingThreadCreationOutcome({ kind: "delivered", message: persistedMessage });
1165
- const outcome = await completeQueuedMessageDelivery(
1187
+ const outcome = yield* completeQueuedMessageDelivery(
1188
persistedMessage,
1189
deliveryRevision,
1190
deliveredSequence(deliveryResult),
1191
);
1192
if (outcome === "edited") {
1171
- if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]) {
1172
- return true;
1173
- }
1174
- return recoverEditedCreationAfterDelivery(persistedMessage);
1193
+ if (isEditingQueuedMessage(queuedMessage.messageId)) return;
1194
+ return yield* recoverEditedCreationAfterDelivery(persistedMessage);
1195
}
1176
- return outcome === "removed";
1177
- };
1178
-
1179
- // A pass writes atoms the pass reads (family mounts, the dispatch slot), and the registry
1180
- // notifies subscribers synchronously, so drain() can be called from inside a pass. That call
1181
- // only asks for another pass; a nested pass would decide from inputs the outer one is still
1182
- // acting on and could start a second delivery.
1183
- let draining = false;
1184
- let drainRequested = false;
1185
- function drain(): void {
1186
- if (disposed) return;
1187
- if (draining) {
1188
- drainRequested = true;
1189
- return;
1190
- }
1191
- draining = true;
1192
- try {
1193
- do {
1194
- if (disposed) return;
1195
- drainRequested = false;
1196
- drainPass();
1197
- } while (drainRequested);
1198
- } finally {
1199
- draining = false;
1200
- }
1201
- }
1196
+ if (outcome !== "removed") return yield* retryDelivery;
1197
+ });
1198
1203
- function drainPass(): void {
1199
+ /** The head of one thread's queue, as the inputs stand now. */
1200
+ function nextStep(
1201
+ threadKey: string,
1202
+ queuedMessages: ReadonlyArray<QueuedThreadMessage>,
1203
+ inputs: Atom.Type<typeof deliveryInputsAtom>,
1204
+ ): ThreadDeliveryStep {
1205
const {
1205
- dispatchingQueuedMessageId,
1206
editingQueuedMessageIds,
1207
- queuedMessagesByThreadKey,
1207
shellStatuses,
1208
threads,
1209
projects,
1210
serverConfigs,
1211
connectedEnvironments,
1212
operableEnvironments,
1214
- } = appAtomRegistry.get(deliveryInputsAtom);
1213
+ } = inputs;
1214
+ const nextQueuedMessage = queuedMessages[0];
1215
+ if (!nextQueuedMessage) {
1216
+ return { _tag: "Wait" };
1217
+ }
1218
+ const messageId = nextQueuedMessage.messageId;
1219
+ if (
1220
+ nextQueuedMessage.creation === undefined &&
1221
+ acknowledgedExistingThreadMessageIds.has(messageId)
1222
+ ) {
1223
+ if (retryNotBefore(messageId) > Date.now()) {
1224
+ return { _tag: "Wait", until: retryNotBefore(messageId) };
1225
+ }
1226
+ return {
1227
+ _tag: "Dispatch",
1228
+ messageId,
1229
+ run: removeAcknowledgedExistingThreadMessage(
1230
+ nextQueuedMessage,
1231
+ acknowledgedExistingThreadMessageIds,
1232
+ ),
1233
+ };
1234
+ }
1235
+ if (editingQueuedMessageIds[messageId]) {
1236
+ return { _tag: "Wait" };
1237
+ }
1238
+ const blockedRecovery = blockedRecoveries.get(messageId);
1239
+ if (blockedRecovery) {
1240
+ if (blockedRecovery.message === nextQueuedMessage) {
1241
+ return { _tag: "Wait" };
1242
+ }
1243
+ blockedRecoveries.delete(messageId);
1244
+ blockedRecovery.unsubscribe();
1245
+ }
1246
+ if (retryNotBefore(messageId) > Date.now()) {
1247
+ return { _tag: "Wait", until: retryNotBefore(messageId) };
1248
+ }
1249
+ let thread = findThread(threads, nextQueuedMessage);
1250
+ if (thread && scopedThreadKey(thread.environmentId, thread.id) !== threadKey) {
1251
+ return { _tag: "Wait" };
1252
+ }
1253
+
1254
+ const creation = nextQueuedMessage.creation;
1255
+ const environment = connectedEnvironments.find(
1256
+ (candidate) => candidate.environmentId === nextQueuedMessage.environmentId,
1257
+ );
1258
+ const shellStatus = shellStatuses.get(nextQueuedMessage.environmentId) ?? "empty";
1259
+ const serverConfig = serverConfigs.get(nextQueuedMessage.environmentId);
1260
+ let familyRead: ThreadFamilyRead | undefined;
1261
+ if (
1262
+ thread === undefined &&
1263
+ creation === undefined &&
1264
+ serverConfig?.shellThreadFamilies === true
1265
+ ) {
1266
+ // The family keeps the row readable through dispatch once it loads; the current shell
1267
+ // generation's read decides whether the thread is gone.
1268
+ if (!familyMounts.has(nextQueuedMessage.messageId)) {
1269
+ familyMounts.set(
1270
+ nextQueuedMessage.messageId,
1271
+ threadFamilies.mount(
1272
+ appAtomRegistry,
1273
+ nextQueuedMessage.environmentId,
1274
+ nextQueuedMessage.threadId,
1275
+ ),
1276
+ );
1277
+ }
1278
+ familyRead = threadFamilyRead(
1279
+ appAtomRegistry.get(
1280
+ threadFamilies.familyAtom(nextQueuedMessage.environmentId, nextQueuedMessage.threadId),
1281
+ ),
1282
+ );
1283
+ if (familyRead === "settled") {
1284
+ // The rows read at the start of this pass can lag the family that just settled;
1285
+ // decide from the merged rows as they are now.
1286
+ thread = findThread(
1287
+ appAtomRegistry.get(environmentThreadShells.threadShellsAtom),
1288
+ nextQueuedMessage,
1289
+ );
1290
+ } else if (familyRead === "failed") {
1291
+ threadFamilies.refresh(
1292
+ appAtomRegistry,
1293
+ nextQueuedMessage.environmentId,
1294
+ nextQueuedMessage.threadId,
1295
+ );
1296
+ }
1297
+ }
1298
+ const resendLaunch =
1299
+ creation !== undefined &&
1300
+ launchedCreations.get(messageId)?.revision === threadOutboxRevision(messageId);
1301
+ const deliveryAction = resolveThreadOutboxDeliveryAction({
1302
+ isCreation: creation !== undefined,
1303
+ // A resend goes through the same gates as the first launch.
1304
+ threadExists: thread !== undefined && !resendLaunch,
1305
+ shellStatus,
1306
+ environmentConnected: environment?.connectionState === "connected",
1307
+ ...(familyRead === undefined ? {} : { familyRead }),
1308
+ });
1309
+ if (
1310
+ deliveryAction === "wait" &&
1311
+ shellStatus === "live" &&
1312
+ familyRead !== undefined &&
1313
+ familyRead !== "settled"
1314
+ ) {
1315
+ // An empty family read changes no merged row, so nothing else would wake the thread.
1316
+ return { _tag: "Backoff", messageId };
1317
+ }
1318
+ if (deliveryAction === "send" && !operableEnvironments.has(nextQueuedMessage.environmentId)) {
1319
+ return { _tag: "Wait" };
1320
+ }
1321
+ const dispatchStep = resolveThreadOutboxDispatchStep({
1322
+ deliveryAction,
1323
+ fileAttachments: nextQueuedMessage.attachments.filter(
1324
+ (attachment) => attachment.type === "file",
1325
+ ),
1326
+ serverConfig: serverConfig
1327
+ ? {
1328
+ maxFileUploadBytes:
1329
+ serverConfig.environment.capabilities.fileAttachments?.maxUploadBytes,
1330
+ }
1331
+ : null,
1332
+ });
1333
+ if (dispatchStep.step === "wait") {
1334
+ return { _tag: "Wait" };
1335
+ }
1336
+ if (dispatchStep.step === "retry") {
1337
+ return { _tag: "Backoff", messageId };
1338
+ }
1339
+ if (dispatchStep.step === "restore") {
1340
+ const attachmentError = dispatchStep.reason;
1341
+ return {
1342
+ _tag: "Dispatch",
1343
+ messageId,
1344
+ run: Effect.gen(function* () {
1345
+ if (!(yield* confirmQueued(nextQueuedMessage)) || isEditingQueuedMessage(messageId)) {
1346
+ return;
1347
+ }
1348
+ yield* restoreQueuedMessage(nextQueuedMessage, attachmentError);
1349
+ }),
1350
+ };
1351
+ }
1352
+ const creationProjectCwd =
1353
+ creation !== undefined
1354
+ ? (findCreationProject(projects, nextQueuedMessage)?.workspaceRoot ??
1355
+ creation.projectCwd ??
1356
+ null)
1357
+ : null;
1358
+ if (deliveryAction === "send" && creation !== undefined) {
1359
+ if (!isQueuedThreadCreationSendable(nextQueuedMessage)) {
1360
+ return { _tag: "Wait" };
1361
+ }
1362
+ if (creationProjectCwd === null && shellStatus !== "live") {
1363
+ return { _tag: "Wait" };
1364
+ }
1365
+ }
1366
+
1367
+ const removeQueuedMessage = (warning: string) =>
1368
+ storage("remove-unsendable", messageId, () =>
1369
+ removeThreadOutboxMessage(nextQueuedMessage),
1370
+ ).pipe(
1371
+ Effect.catch((error) =>
1372
+ Effect.logWarning(warning, {
1373
+ environmentId: nextQueuedMessage.environmentId,
1374
+ threadId: nextQueuedMessage.threadId,
1375
+ messageId,
1376
+ error: error.cause,
1377
+ }).pipe(Effect.andThen(retryDelivery)),
1378
+ ),
1379
+ Effect.asVoid,
1380
+ );
1381
+ // Confirm durability before sending; optimistic enqueue can still roll back on write failure.
1382
+ const run = Effect.gen(function* () {
1383
+ if (!(yield* confirmQueued(nextQueuedMessage))) return;
1384
+ // An editor that took the message after confirmation owns it; that is not a failure.
1385
+ if (isEditingQueuedMessage(messageId)) return;
1386
+ if (deliveryAction === "send") {
1387
+ const liveThread = findThread(
1388
+ appAtomRegistry.get(environmentThreadShells.threadShellsAtom),
1389
+ nextQueuedMessage,
1390
+ );
1391
+ const liveDeliveryAction = resolveThreadOutboxDeliveryAction({
1392
+ isCreation: creation !== undefined,
1393
+ threadExists: liveThread !== undefined && !resendLaunch,
1394
+ shellStatus,
1395
+ environmentConnected: environment?.connectionState === "connected",
1396
+ });
1397
+ if (liveDeliveryAction !== "send") return;
1398
+ }
1399
+ if (deliveryAction === "remove") {
1400
+ // Edited since launch, or launched before a restart that lost the revision: hand it back.
1401
+ return yield* creation !== undefined
1402
+ ? recoverEditedCreationAfterDelivery(nextQueuedMessage)
1403
+ : removeQueuedMessage("[thread-outbox] failed to remove message for a missing thread");
1404
+ }
1405
+ if (creation !== undefined) {
1406
+ return yield* creationProjectCwd !== null
1407
+ ? sendQueuedCreation(nextQueuedMessage, creation, creationProjectCwd)
1408
+ : removeQueuedMessage("[thread-outbox] dropped pending task for a missing project");
1409
+ }
1410
+ return yield* thread !== undefined
1411
+ ? sendQueuedMessage(nextQueuedMessage, thread)
1412
+ : retryDelivery;
1413
+ });
1414
+ return { _tag: "Dispatch", messageId, run };
1415
+ }
1416
+
1417
+ // One fiber per thread with queued messages. Opening a thread's latch wakes its fiber to
1418
+ // reconsider its head; the fiber closes it before reading the inputs, so no wake is lost.
1419
+ // An entry outlives its interrupted fiber until that fiber exits, so a thread never has two.
1420
+ const threadFibers = new Map<string, ThreadFiber>();
1421
+
1422
+ const deliverThread = (threadKey: string, wake: Latch.Latch) =>
1423
+ Effect.forever(
1424
+ Effect.gen(function* () {
1425
+ yield* wake.close;
1426
+ const inputs = appAtomRegistry.get(deliveryInputsAtom);
1427
+ const step = nextStep(threadKey, inputs.queuedMessagesByThreadKey[threadKey] ?? [], inputs);
1428
+ if (step._tag === "Backoff") {
1429
+ scheduleRetry(step.messageId);
1430
+ return;
1431
+ }
1432
+ if (step._tag === "Wait") {
1433
+ if (step.until === undefined) {
1434
+ yield* wake.await;
1435
+ return;
1436
+ }
1437
+ const now = yield* Clock.currentTimeMillis;
1438
+ yield* wake.await.pipe(
1439
+ Effect.timeoutOrElse({
1440
+ duration: Math.max(0, step.until - now),
1441
+ orElse: () => Effect.void,
1442
+ }),
1443
+ );
1444
+ return;
1445
+ }
1446
+ // A send that started finishes, even when its thread leaves the queue meanwhile; only
1447
+ // its wait on a shared upload stops early.
1448
+ beginDispatchingQueuedMessage(step.messageId);
1449
+ const sent = yield* step.run.pipe(
1450
+ Effect.as(true),
1451
+ Effect.catchTags({ DeliveryRetry: () => Effect.succeed(false) }),
1452
+ // A send that throws backs off like any failure, not straight back into the send.
1453
+ Effect.catchDefect((error) =>
1454
+ Effect.logWarning("[thread-outbox] queued message delivery threw", {
1455
+ messageId: step.messageId,
1456
+ error,
1457
+ }).pipe(Effect.as(false)),
1458
+ ),
1459
+ Effect.ensuring(Effect.sync(() => finishDispatchingQueuedMessage(step.messageId))),
1460
+ Effect.uninterruptible,
1461
+ );
1462
+ if (sent) clearRetry(step.messageId);
1463
+ else scheduleRetry(step.messageId);
1464
+ }),
1465
+ );
1466
+
1467
+ function wakeThreads(): void {
1468
+ for (const { wake } of threadFibers.values()) wake.openUnsafe();
1469
+ }
1470
+
1471
+ /** Starts a fiber for each thread with queued messages, stops the rest, and wakes them all. */
1472
+ function onInputs(): void {
1473
+ if (disposed) return;
1474
+ const { queuedMessagesByThreadKey, serverConfigs, connectedEnvironments } =
1475
+ appAtomRegistry.get(deliveryInputsAtom);
1476
+ const queued = Object.values(queuedMessagesByThreadKey).flat();
1477
// Failures while an environment was unreachable say nothing about it now; a backoff
1478
// started then would hold a message for up to its full delay after reconnecting.
1479
const ready = new Set(
@@ -1223,30 +1485,19 @@ export function createThreadOutboxDelivery(): {
1485
)
1486
.map((environment) => environment.environmentId),
1487
);
1226
- for (const message of Object.values(queuedMessagesByThreadKey).flat()) {
1488
+ for (const message of queued) {
1489
if (ready.has(message.environmentId) && !readyEnvironmentIds.has(message.environmentId)) {
1490
clearRetry(message.messageId);
1491
}
1492
}
1493
readyEnvironmentIds = ready;
1232
- if (dispatchingQueuedMessageId !== null) {
1233
- return;
1234
- }
1494
1236
- const queuedMessageIds = new Set(
1237
- Object.values(queuedMessagesByThreadKey)
1238
- .flat()
1239
- .map((message) => message.messageId),
1240
- );
1495
+ const queuedMessageIds = new Set(queued.map((message) => message.messageId));
1496
for (const messageId of acknowledgedExistingThreadMessageIds) {
1242
- if (!queuedMessageIds.has(messageId)) {
1243
- acknowledgedExistingThreadMessageIds.delete(messageId);
1244
- }
1497
+ if (!queuedMessageIds.has(messageId)) acknowledgedExistingThreadMessageIds.delete(messageId);
1498
}
1499
for (const messageId of launchedCreations.keys()) {
1247
- if (!queuedMessageIds.has(messageId)) {
1248
- launchedCreations.delete(messageId);
1249
- }
1500
+ if (!queuedMessageIds.has(messageId)) launchedCreations.delete(messageId);
1501
}
1502
for (const [messageId, release] of familyMounts) {
1503
if (!queuedMessageIds.has(messageId)) {
@@ -1255,230 +1506,36 @@ export function createThreadOutboxDelivery(): {
1506
}
1507
}
1508
1258
- for (const [threadKey, queuedMessages] of Object.entries(queuedMessagesByThreadKey)) {
1259
- const nextQueuedMessage = queuedMessages[0];
1260
- if (!nextQueuedMessage) {
1261
- continue;
1262
- }
1263
- const messageId = nextQueuedMessage.messageId;
1264
- if (
1265
- nextQueuedMessage.creation === undefined &&
1266
- acknowledgedExistingThreadMessageIds.has(messageId)
1267
- ) {
1268
- if (retryNotBefore(messageId) > Date.now()) {
1269
- continue;
1270
- }
1271
- beginDispatchingQueuedMessage(messageId);
1272
- settle(
1273
- messageId,
1274
- removeAcknowledgedExistingThreadMessage(
1275
- nextQueuedMessage,
1276
- acknowledgedExistingThreadMessageIds,
1277
- ),
1278
- );
1279
- return;
1280
- }
1281
- if (editingQueuedMessageIds[messageId]) {
1282
- continue;
1283
- }
1284
- const blockedRecovery = blockedRecoveries.get(messageId);
1285
- if (blockedRecovery) {
1286
- if (blockedRecovery.message === nextQueuedMessage) {
1287
- continue;
1288
- }
1289
- blockedRecoveries.delete(messageId);
1290
- blockedRecovery.unsubscribe();
1291
- }
1292
- if (retryNotBefore(messageId) > Date.now()) {
1293
- continue;
1294
- }
1295
- if (
1296
- queuedAttachmentsStillUploading({
1297
- environmentId: nextQueuedMessage.environmentId,
1298
- attachments: nextQueuedMessage.attachments,
1299
- states: appAtomRegistry.get(composerAttachmentUploadsAtom),
1300
- })
1301
- ) {
1302
- continue;
1303
- }
1304
-
1305
- let thread = findThread(threads, nextQueuedMessage);
1306
- if (thread && scopedThreadKey(thread.environmentId, thread.id) !== threadKey) {
1307
- continue;
1308
- }
1309
-
1310
- const creation = nextQueuedMessage.creation;
1311
- const environment = connectedEnvironments.find(
1312
- (candidate) => candidate.environmentId === nextQueuedMessage.environmentId,
1313
- );
1314
- const shellStatus = shellStatuses.get(nextQueuedMessage.environmentId) ?? "empty";
1315
- const serverConfig = serverConfigs.get(nextQueuedMessage.environmentId);
1316
- let familyRead: ThreadFamilyRead | undefined;
1317
- if (
1318
- thread === undefined &&
1319
- creation === undefined &&
1320
- serverConfig?.shellThreadFamilies === true
1321
- ) {
1322
- // The family keeps the row readable through dispatch once it loads; the current shell
1323
- // generation's read decides whether the thread is gone.
1324
- if (!familyMounts.has(nextQueuedMessage.messageId)) {
1325
- familyMounts.set(
1326
- nextQueuedMessage.messageId,
1327
- threadFamilies.mount(
1328
- appAtomRegistry,
1329
- nextQueuedMessage.environmentId,
1330
- nextQueuedMessage.threadId,
1331
- ),
1332
- );
1333
- }
1334
- familyRead = threadFamilyRead(
1335
- appAtomRegistry.get(
1336
- threadFamilies.familyAtom(nextQueuedMessage.environmentId, nextQueuedMessage.threadId),
1337
- ),
1338
- );
1339
- if (familyRead === "settled") {
1340
- // The rows read at the start of this pass can lag the family that just settled;
1341
- // decide from the merged rows as they are now.
1342
- thread = findThread(
1343
- appAtomRegistry.get(environmentThreadShells.threadShellsAtom),
1344
- nextQueuedMessage,
1345
- );
1346
- } else if (familyRead === "failed") {
1347
- threadFamilies.refresh(
1348
- appAtomRegistry,
1349
- nextQueuedMessage.environmentId,
1350
- nextQueuedMessage.threadId,
1351
- );
1352
- }
1353
- }
1354
- const resendLaunch =
1355
- creation !== undefined &&
1356
- launchedCreations.get(messageId)?.revision === threadOutboxRevision(messageId);
1357
- const deliveryAction = resolveThreadOutboxDeliveryAction({
1358
- isCreation: creation !== undefined,
1359
- // A resend goes through the same gates as the first launch.
1360
- threadExists: thread !== undefined && !resendLaunch,
1361
- shellStatus,
1362
- environmentConnected: environment?.connectionState === "connected",
1363
- ...(familyRead === undefined ? {} : { familyRead }),
1364
- });
1365
- if (
1366
- deliveryAction === "wait" &&
1367
- shellStatus === "live" &&
1368
- familyRead !== undefined &&
1369
- familyRead !== "settled"
1370
- ) {
1371
- // An empty family read changes no merged row, so nothing else would wake the drain.
1372
- scheduleRetry(messageId);
1373
- continue;
1374
- }
1375
- if (deliveryAction === "send" && !operableEnvironments.has(nextQueuedMessage.environmentId)) {
1376
- continue;
1377
- }
1378
- const dispatchStep = resolveThreadOutboxDispatchStep({
1379
- deliveryAction,
1380
- fileAttachments: nextQueuedMessage.attachments.filter(
1381
- (attachment) => attachment.type === "file",
1382
- ),
1383
- serverConfig: serverConfig
1384
- ? {
1385
- maxFileUploadBytes:
1386
- serverConfig.environment.capabilities.fileAttachments?.maxUploadBytes,
1387
- }
1388
- : null,
1389
- });
1390
- if (dispatchStep.step === "wait") {
1391
- continue;
1392
- }
1393
- if (dispatchStep.step === "retry") {
1394
- scheduleRetry(messageId);
1395
- continue;
1396
- }
1397
- if (dispatchStep.step === "restore") {
1398
- const attachmentError = dispatchStep.reason;
1399
- beginDispatchingQueuedMessage(messageId);
1400
- settle(
1401
- messageId,
1402
- confirmThreadOutboxMessageQueued(nextQueuedMessage).then((queued) =>
1403
- !queued || appAtomRegistry.get(editingQueuedMessageIdsAtom)[messageId]
1404
- ? true
1405
- : restoreQueuedMessage(nextQueuedMessage, attachmentError),
1406
- ),
1407
- );
1408
- return;
1409
- }
1410
- const creationProjectCwd =
1411
- creation !== undefined
1412
- ? (findCreationProject(projects, nextQueuedMessage)?.workspaceRoot ??
1413
- creation.projectCwd ??
1414
- null)
1415
- : null;
1416
- if (deliveryAction === "send" && creation !== undefined) {
1417
- if (!isQueuedThreadCreationSendable(nextQueuedMessage)) {
1418
- continue;
1419
- }
1420
- if (creationProjectCwd === null && shellStatus !== "live") {
1421
- continue;
1422
- }
1423
- }
1424
-
1425
- beginDispatchingQueuedMessage(messageId);
1426
- const removeQueuedMessage = (warning: string) =>
1427
- removeThreadOutboxMessage(nextQueuedMessage).then(
1428
- () => true,
1429
- (error) => {
1430
- console.warn(warning, {
1431
- environmentId: nextQueuedMessage.environmentId,
1432
- threadId: nextQueuedMessage.threadId,
1433
- messageId,
1434
- error,
1435
- });
1436
- return false;
1437
- },
1438
- );
1439
- // Confirm durability before sending; optimistic enqueue can still roll back on write failure.
1440
- const delivery = confirmThreadOutboxMessageQueued(nextQueuedMessage).then((queued) => {
1441
- if (!queued) {
1442
- return true;
1443
- }
1444
- // Re-check editor ownership after confirmation; return true to defer without failure backoff.
1445
- if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[messageId]) {
1446
- return true;
1447
- }
1448
- if (deliveryAction === "send") {
1449
- const liveThread = findThread(
1450
- appAtomRegistry.get(environmentThreadShells.threadShellsAtom),
1451
- nextQueuedMessage,
1452
- );
1453
- const liveDeliveryAction = resolveThreadOutboxDeliveryAction({
1454
- isCreation: creation !== undefined,
1455
- threadExists: liveThread !== undefined && !resendLaunch,
1456
- shellStatus,
1457
- environmentConnected: environment?.connectionState === "connected",
1458
- });
1459
- if (liveDeliveryAction !== "send") {
1460
- return true;
1461
- }
1462
- }
1463
- return deliveryAction === "remove"
1464
- ? creation !== undefined
1465
- ? // Edited since launch, or launched before a restart that lost the revision: hand it back.
1466
- recoverEditedCreationAfterDelivery(nextQueuedMessage)
1467
- : removeQueuedMessage("[thread-outbox] failed to remove message for a missing thread")
1468
- : creation !== undefined
1469
- ? creationProjectCwd !== null
1470
- ? sendQueuedCreation(nextQueuedMessage, creation, creationProjectCwd)
1471
- : removeQueuedMessage("[thread-outbox] dropped pending task for a missing project")
1472
- : thread !== undefined
1473
- ? sendQueuedMessage(nextQueuedMessage, thread)
1474
- : Promise.resolve(false);
1509
+ for (const [threadKey, entry] of threadFibers) {
1510
+ if ((queuedMessagesByThreadKey[threadKey]?.length ?? 0) > 0 || entry.retiring) continue;
1511
+ entry.retiring = true;
1512
+ if (entry.fiber !== undefined) Effect.runFork(Fiber.interrupt(entry.fiber));
1513
+ }
1514
+ for (const [threadKey, messages] of Object.entries(queuedMessagesByThreadKey)) {
1515
+ if (messages.length === 0 || threadFibers.has(threadKey)) continue;
1516
+ // Registered before the fiber starts: its first step runs synchronously and can re-enter here.
1517
+ const entry: ThreadFiber = {
1518
+ wake: Latch.makeUnsafe(true),
1519
+ fiber: undefined,
1520
+ retiring: false,
1521
+ };
1522
+ threadFibers.set(threadKey, entry);
1523
+ const fiber = Effect.runFork(deliverThread(threadKey, entry.wake));
1524
+ entry.fiber = fiber;
1525
+ fiber.addObserver(() => {
1526
+ if (threadFibers.get(threadKey) !== entry) return;
1527
+ threadFibers.delete(threadKey);
1528
+ // A message queued while this fiber finished its send starts the next fiber now.
1529
+ if (!disposed) onInputs();
1530
});
1476
- settle(messageId, delivery);
1477
- return;
1531
+ if (entry.retiring) Effect.runFork(Fiber.interrupt(fiber));
1532
}
1533
+ wakeThreads();
1534
}
1535
1481
- const stopDraining = appAtomRegistry.subscribe(deliveryInputsAtom, drain, { immediate: true });
1536
+ const stopDelivering = appAtomRegistry.subscribe(deliveryInputsAtom, onInputs, {
1537
+ immediate: true,
1538
+ });
1539
const stopCollectingOutcomes = appAtomRegistry.subscribe(
1540
settledCreationOutcomeKeysAtom,
1541
(threadKeys) => {
@@ -1488,12 +1545,15 @@ export function createThreadOutboxDelivery(): {
1545
);
1546
1547
return {
1491
- drain,
1548
+ drain: wakeThreads,
1549
dispose: () => {
1550
disposed = true;
1494
- stopDraining();
1551
+ stopDelivering();
1552
stopCollectingOutcomes();
1496
- for (const retry of retries.values()) clearTimeout(retry.timer);
1553
+ for (const { fiber } of threadFibers.values()) {
1554
+ if (fiber !== undefined) Effect.runFork(Fiber.interrupt(fiber));
1555
+ }
1556
+ threadFibers.clear();
1557
retries.clear();
1558
appAtomRegistry.set(retryingQueuedMessageIdsAtom, {});
1559
for (const blocked of blockedRecoveries.values()) blocked.unsubscribe();
apps/mobile/src/state/use-thread-composer-state.ts
+6
-2
@@ -122,7 +122,7 @@ import {
122
} from "./use-thread-detail";
123
import { useThreadSelection } from "./use-thread-selection";
124
import { enqueueThreadOutboxMessage } from "./thread-outbox";
125
-import { dispatchingQueuedMessageIdAtom, useThreadOutboxMessages } from "./use-thread-outbox";
125
+import { dispatchingQueuedMessageIdsAtom, useThreadOutboxMessages } from "./use-thread-outbox";
126
import { threadEnvironment } from "./threads";
127
import { useAtomCommand } from "./use-atom-command";
128
@@ -217,7 +217,7 @@ export function useThreadComposerState(input: {
217
const selectedThreadVisibleTurnItems = useSelectedThreadVisibleTurnItems();
218
const acknowledgedMessages = useAtomValue(acknowledgedThreadMessagesAtom);
219
const queuedMessagesByThreadKey = useThreadOutboxMessages();
220
- const dispatchingQueuedMessageId = useAtomValue(dispatchingQueuedMessageIdAtom);
220
+ const dispatchingQueuedMessageIds = useAtomValue(dispatchingQueuedMessageIdsAtom);
221
const [feedbackSubmissionsByThreadKey, setFeedbackSubmissionsByThreadKey] = useState<
222
Record<string, ReadonlyArray<CodexFeedbackSubmission>>
223
>({});
@@ -240,6 +240,10 @@ export function useThreadComposerState(input: {
240
(message) => message.creation === undefined,
241
)
242
: [];
243
+ // The thread sends one message at a time, the head of its queue.
244
+ const dispatchingQueuedMessageId =
245
+ selectedThreadQueuedMessages.find((message) => dispatchingQueuedMessageIds[message.messageId])
246
+ ?.messageId ?? null;
247
const feedbackSubmissions = selectedThreadKey
248
? (feedbackSubmissionsByThreadKey[selectedThreadKey] ?? [])
249
: [];
apps/mobile/src/state/use-thread-outbox.ts
+4
-4
@@ -26,10 +26,10 @@ export const editingQueuedMessageIdsAtom = Atom.make<Readonly<Record<MessageId,
26
Atom.withLabel("mobile:thread-outbox:editing-message-ids"),
27
);
28
29
-export const dispatchingQueuedMessageIdAtom = Atom.make<MessageId | null>(null).pipe(
30
- Atom.keepAlive,
31
- Atom.withLabel("mobile:thread-outbox:dispatching-message-id"),
32
-);
29
+/** Messages being sent now: at most one per thread, the head of its queue. */
30
+export const dispatchingQueuedMessageIdsAtom = Atom.make<
31
+ Readonly<Partial<Record<MessageId, true>>>
32
+>({}).pipe(Atom.keepAlive, Atom.withLabel("mobile:thread-outbox:dispatching-message-ids"));
33
34
/** Messages waiting out a retry backoff, which can repeat for as long as the failure lasts. */
35
export const retryingQueuedMessageIdsAtom = Atom.make<Readonly<Partial<Record<MessageId, true>>>>(