@devries-cameron20 / t3code-1 / commits / 07e8bfa70d
Fork 0

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>>>>(