From 35e556f3dfad48f4747dd41513f0179bd6f4bd37 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Mon, 16 Nov 2026 10:19:17 -0800 Subject: [PATCH 1/5] refactor(mobile): deliver queued messages with one fiber per thread Outbox delivery ran every queued message through one global slot, with a drain loop rerun on every input change, reentrancy flags, and a map of setTimeout retries. Each thread with queued messages now has its own Effect fiber that sends its head message, backs off after a failure, and otherwise waits on a latch that input changes open. A slow send in one thread no longer holds another. The outbox no longer skips a message whose attachment is uploading; the send joins that upload. Co-Authored-By: Claude Opus 5.5 --- .../src/lib/composerAttachmentUploadQueue.ts | 24 - .../composer-attachment-upload-states.ts | 8 - .../state/composer-attachment-uploads.test.ts | 2 +- .../src/state/composer-attachment-uploads.ts | 6 +- .../state/edit-pending-thread-message.test.ts | 8 +- .../src/state/edit-pending-thread-message.ts | 4 +- .../src/state/thread-task-permissions.test.ts | 2 +- .../threadOutboxDelivery.permissions.test.ts | 101 +-- .../src/state/threadOutboxDelivery.test.ts | 2 +- apps/mobile/src/state/threadOutboxDelivery.ts | 589 +++++++++--------- .../src/state/use-thread-composer-state.ts | 8 +- apps/mobile/src/state/use-thread-outbox.ts | 8 +- 12 files changed, 385 insertions(+), 377 deletions(-) delete mode 100644 apps/mobile/src/state/composer-attachment-upload-states.ts diff --git a/apps/mobile/src/lib/composerAttachmentUploadQueue.ts b/apps/mobile/src/lib/composerAttachmentUploadQueue.ts index f52b6fcdbe36b..92434c56b391d 100644 --- a/apps/mobile/src/lib/composerAttachmentUploadQueue.ts +++ b/apps/mobile/src/lib/composerAttachmentUploadQueue.ts @@ -114,30 +114,6 @@ export function composerAttachmentsStillUploading(input: { }); } -/** Changes when an upload starts or settles, not on its progress ticks. */ -export function uploadingComposerAttachmentKeys( - states: Readonly>, -): string { - return Object.keys(states) - .filter((key) => states[key]?.status === "uploading") - .sort() - .join("\n"); -} - -/** A queued message waits for the worker's upload instead of starting a second one. */ -export function queuedAttachmentsStillUploading(input: { - readonly environmentId: EnvironmentId; - readonly attachments: ReadonlyArray; - readonly states: Readonly>; -}): boolean { - return input.attachments.some( - (attachment) => - attachment.uploadedAttachmentId === undefined && - input.states[composerAttachmentUploadKey(input.environmentId, attachment.id)]?.status === - "uploading", - ); -} - /** Equal by environment and attachment id; the request rides along for the upload. */ class UploadKey implements Equal.Equal { constructor( diff --git a/apps/mobile/src/state/composer-attachment-upload-states.ts b/apps/mobile/src/state/composer-attachment-upload-states.ts deleted file mode 100644 index 2dafe12ef678a..0000000000000 --- a/apps/mobile/src/state/composer-attachment-upload-states.ts +++ /dev/null @@ -1,8 +0,0 @@ -import { Atom } from "effect/reactivity"; - -import type { ComposerAttachmentUploadState } from "../lib/composerAttachmentUploadQueue"; - -/** The upload worker's per-attachment states, apart from the worker so the outbox can read them. */ -export const composerAttachmentUploadsAtom = Atom.make< - Readonly> ->({}).pipe(Atom.keepAlive); diff --git a/apps/mobile/src/state/composer-attachment-uploads.test.ts b/apps/mobile/src/state/composer-attachment-uploads.test.ts index ac8bed2a42a75..16261ab662f20 100644 --- a/apps/mobile/src/state/composer-attachment-uploads.test.ts +++ b/apps/mobile/src/state/composer-attachment-uploads.test.ts @@ -167,7 +167,7 @@ vi.mock("./use-thread-outbox", async () => { const { Atom } = await import("effect/reactivity"); return { editingQueuedMessageIdsAtom: Atom.make>({}).pipe(Atom.keepAlive), - dispatchingQueuedMessageIdAtom: Atom.make>({}).pipe(Atom.keepAlive), + dispatchingQueuedMessageIdsAtom: Atom.make>({}).pipe(Atom.keepAlive), useThreadOutboxMessages: () => appAtomRegistry.get(threadOutboxManager.queuedMessagesByThreadKeyAtom), retryingQueuedMessageIdsAtom: Atom.make({}).pipe(Atom.keepAlive), diff --git a/apps/mobile/src/state/composer-attachment-uploads.ts b/apps/mobile/src/state/composer-attachment-uploads.ts index 71812bb70aa72..acc7576a8d1d8 100644 --- a/apps/mobile/src/state/composer-attachment-uploads.ts +++ b/apps/mobile/src/state/composer-attachment-uploads.ts @@ -16,9 +16,9 @@ import { composerDraftEnvironmentId, canUploadComposerAttachment, createComposerAttachmentUploadQueue, + type ComposerAttachmentUploadState, } from "../lib/composerAttachmentUploadQueue"; import { appAtomRegistry } from "./atom-registry"; -import { composerAttachmentUploadsAtom } from "./composer-attachment-upload-states"; import { environmentServerConfigsAtom } from "./server"; import { flattenQueuedThreadMessages, @@ -46,7 +46,9 @@ export { composerAttachmentsStillUploading, } from "../lib/composerAttachmentUploadQueue"; -export { composerAttachmentUploadsAtom }; +export const composerAttachmentUploadsAtom = Atom.make< + Readonly> +>({}).pipe(Atom.keepAlive); const uploadStateAtom = Atom.family((key: string) => Atom.map(composerAttachmentUploadsAtom, (states) => states[key]), ); diff --git a/apps/mobile/src/state/edit-pending-thread-message.test.ts b/apps/mobile/src/state/edit-pending-thread-message.test.ts index c9c8b4f6a47f8..c9efb7c934e5c 100644 --- a/apps/mobile/src/state/edit-pending-thread-message.test.ts +++ b/apps/mobile/src/state/edit-pending-thread-message.test.ts @@ -3,7 +3,7 @@ import { CommandId, EnvironmentId, MessageId, ThreadId } from "@t3tools/contract import type { QueuedThreadMessage } from "./thread-outbox-model"; const state = vi.hoisted(() => ({ - dispatching: null as string | null, + dispatching: {} as Record, held: {} as Record, draft: { text: "Existing draft", attachments: [] as { id: string }[] }, confirm: vi.fn(async () => true), @@ -16,7 +16,7 @@ vi.mock("./atom-registry", () => ({ }, })); vi.mock("./use-thread-outbox", () => ({ - dispatchingQueuedMessageIdAtom: "dispatching", + dispatchingQueuedMessageIdsAtom: "dispatching", editingQueuedMessageIdsAtom: "editing", holdEditingQueuedMessage: (id: string) => { state.held[id] = true; @@ -67,7 +67,7 @@ const message: QueuedThreadMessage = { }; beforeEach(() => { vi.clearAllMocks(); - state.dispatching = null; + state.dispatching = {}; state.held = {}; state.draft = { text: "Existing draft", attachments: [] }; state.confirm.mockResolvedValue(true); @@ -90,7 +90,7 @@ describe("editing a pending message", () => { expect(state.held).toEqual({}); }); it("does not reclaim a message already being dispatched", async () => { - state.dispatching = message.messageId; + state.dispatching = { [message.messageId]: true }; expect(await editPendingThreadMessage(message)).toBe(false); expect(state.confirm).not.toHaveBeenCalled(); expect(state.draft.text).toBe("Existing draft"); diff --git a/apps/mobile/src/state/edit-pending-thread-message.ts b/apps/mobile/src/state/edit-pending-thread-message.ts index e2f3a2bfcb5d5..6e599abf6823d 100644 --- a/apps/mobile/src/state/edit-pending-thread-message.ts +++ b/apps/mobile/src/state/edit-pending-thread-message.ts @@ -16,7 +16,7 @@ import { waitForComposerDraftsLoaded, } from "./use-composer-drafts"; import { - dispatchingQueuedMessageIdAtom, + dispatchingQueuedMessageIdsAtom, editingQueuedMessageIdsAtom, holdEditingQueuedMessage, releaseEditingQueuedMessage, @@ -26,7 +26,7 @@ import { export async function editPendingThreadMessage(message: QueuedThreadMessage): Promise { if ( message.creation || - appAtomRegistry.get(dispatchingQueuedMessageIdAtom) === message.messageId || + appAtomRegistry.get(dispatchingQueuedMessageIdsAtom)[message.messageId] || appAtomRegistry.get(editingQueuedMessageIdsAtom)[message.messageId] ) { return false; diff --git a/apps/mobile/src/state/thread-task-permissions.test.ts b/apps/mobile/src/state/thread-task-permissions.test.ts index d037ac106a025..7051193be1175 100644 --- a/apps/mobile/src/state/thread-task-permissions.test.ts +++ b/apps/mobile/src/state/thread-task-permissions.test.ts @@ -141,7 +141,7 @@ vi.mock("./threads", async () => { }); vi.mock("./use-thread-outbox", async () => { const { Atom } = await import("effect/reactivity"); - return { dispatchingQueuedMessageIdAtom: Atom.make(null), useThreadOutboxMessages: () => ({}) }; + return { dispatchingQueuedMessageIdsAtom: Atom.make({}), useThreadOutboxMessages: () => ({}) }; }); vi.mock("./thread-outbox", () => ({ enqueueThreadOutboxMessage: state.enqueue })); vi.mock("./composer-attachment-uploads", async () => { diff --git a/apps/mobile/src/state/threadOutboxDelivery.permissions.test.ts b/apps/mobile/src/state/threadOutboxDelivery.permissions.test.ts index b9ad37a6d7d0d..314b02ca762cc 100644 --- a/apps/mobile/src/state/threadOutboxDelivery.permissions.test.ts +++ b/apps/mobile/src/state/threadOutboxDelivery.permissions.test.ts @@ -138,7 +138,9 @@ vi.mock("./use-thread-outbox", async () => { const { Atom } = await import("effect/reactivity"); return { editingQueuedMessageIdsAtom: Atom.make({}).pipe(Atom.keepAlive), - dispatchingQueuedMessageIdAtom: Atom.make(null).pipe(Atom.keepAlive), + dispatchingQueuedMessageIdsAtom: Atom.make>>({}).pipe( + Atom.keepAlive, + ), retryingQueuedMessageIdsAtom: Atom.make({}).pipe(Atom.keepAlive), threadOutboxShellStatusesAtom: Atom.make(new Map([["secondary", "live"]])), }; @@ -164,9 +166,10 @@ vi.mock("./use-composer-drafts", async () => { import { appAtomRegistry } from "./atom-registry"; import { environmentSession } from "./session"; -import { dispatchingQueuedMessageIdAtom, editingQueuedMessageIdsAtom } from "./use-thread-outbox"; +import { dispatchingQueuedMessageIdsAtom, editingQueuedMessageIdsAtom } from "./use-thread-outbox"; + +const sendingMessageIds = () => Object.keys(appAtomRegistry.get(dispatchingQueuedMessageIdsAtom)); import { createThreadOutboxDelivery } from "./threadOutboxDelivery"; -import { composerAttachmentUploadsAtom } from "./composer-attachment-upload-states"; import { workspaceConnections } from "./workspace"; const message = (overrides: Partial = {}): QueuedThreadMessage => ({ @@ -190,8 +193,8 @@ function setOperateGrant(environmentId: string, granted: boolean): void { function runDrain() { const settled = Promise.withResolvers(); - const release = appAtomRegistry.subscribe(dispatchingQueuedMessageIdAtom, (id) => { - if (id === null) settled.resolve(); + const release = appAtomRegistry.subscribe(dispatchingQueuedMessageIdsAtom, (ids) => { + if (Object.keys(ids).length === 0) settled.resolve(); }); startDelivery(); return settled.promise.finally(release); @@ -220,7 +223,7 @@ beforeEach(() => { state.familyMount.mockReset().mockReturnValue(() => {}); appAtomRegistry.set(state.threadShells, [state.thread]); appAtomRegistry.set(state.manager.queuedMessagesByThreadKeyAtom, {}); - appAtomRegistry.set(dispatchingQueuedMessageIdAtom, null); + appAtomRegistry.set(dispatchingQueuedMessageIdsAtom, {}); appAtomRegistry.set(editingQueuedMessageIdsAtom, {}); for (const command of [ state.start, @@ -361,7 +364,7 @@ describe("queued task operation access", () => { expect(state.modelUnavailable).toHaveBeenCalledOnce(); expect(state.prepare).not.toHaveBeenCalled(); expect(state.start).not.toHaveBeenCalled(); - expect(appAtomRegistry.get(dispatchingQueuedMessageIdAtom)).toBeNull(); + expect(sendingMessageIds()).toEqual([]); expect(remaining()).toEqual([queued]); }); @@ -378,17 +381,15 @@ describe("queued task operation access", () => { startDelivery(); appAtomRegistry.set(editingQueuedMessageIdsAtom, { [queued.messageId]: true }); await state.manager.enqueue(queued); - using confirm = vi.spyOn(state.manager, "confirmQueued"); const delivered = Promise.withResolvers(); - const release = appAtomRegistry.subscribe(dispatchingQueuedMessageIdAtom, (id) => { - if (id === null) delivered.resolve(); + const release = appAtomRegistry.subscribe(dispatchingQueuedMessageIdsAtom, (ids) => { + if (Object.keys(ids).length === 0) delivered.resolve(); }); - // Ending the edit wakes the drain through a registry notification, the path on which the - // mount's synchronous row change notifies the drain again mid-pass. + // Ending the edit wakes the thread through a registry notification, the path on which the + // mount's synchronous row change wakes it again while it is deciding. appAtomRegistry.set(editingQueuedMessageIdsAtom, {}); - expect(state.familyMount).toHaveBeenCalledOnce(); - expect(confirm).toHaveBeenCalledOnce(); await delivered.promise.finally(release); + expect(state.familyMount).toHaveBeenCalledOnce(); expect(state.start).toHaveBeenCalledOnce(); expect(remaining()).toEqual([]); }); @@ -544,8 +545,8 @@ describe("queued task whose launch reply is lost", () => { async function fireRetry(): Promise { const settled = Promise.withResolvers(); - const release = appAtomRegistry.subscribe(dispatchingQueuedMessageIdAtom, (id) => { - if (id === null) settled.resolve(); + const release = appAtomRegistry.subscribe(dispatchingQueuedMessageIdsAtom, (ids) => { + if (Object.keys(ids).length === 0) settled.resolve(); }); vi.advanceTimersByTime(threadOutboxRetryDelayMs(1)); await settled.promise.finally(release); @@ -577,7 +578,7 @@ describe("queued task whose launch reply is lost", () => { await loseLaunchReply(queuedTask()); setOperateGrant("secondary", false); vi.advanceTimersByTime(threadOutboxRetryDelayMs(1)); - expect(appAtomRegistry.get(dispatchingQueuedMessageIdAtom)).toBeNull(); + expect(sendingMessageIds()).toEqual([]); expect(state.start).toHaveBeenCalledOnce(); expect(remaining()).toHaveLength(1); @@ -665,42 +666,58 @@ describe("compaction before a queued send", () => { describe("queued delivery timing", () => { /** Runs `change`, then resolves once the delivery it starts has settled. */ async function deliveryAfter(change: () => void): Promise { + const started = Promise.withResolvers(); const settled = Promise.withResolvers(); - const release = appAtomRegistry.subscribe(dispatchingQueuedMessageIdAtom, (id) => { - if (id === null) settled.resolve(); + const release = appAtomRegistry.subscribe(dispatchingQueuedMessageIdsAtom, (ids) => { + if (Object.keys(ids).length > 0) started.resolve(); + else settled.resolve(); }); change(); - expect(appAtomRegistry.get(dispatchingQueuedMessageIdAtom)).not.toBeNull(); + await started.promise; await settled.promise.finally(release); } - it("waits for the composer's upload of a sent attachment instead of uploading it again", async () => { + it("sends another thread's message while one thread's send is still running", async () => { setOperateGrant("secondary", true); - const photo = { - id: "photo-1", - type: "image" as const, - name: "photo.png", - mimeType: "image/png", - sizeBytes: 3, - previewUri: "file:///photo.png", - fileUri: "file:///photo.png", - }; - appAtomRegistry.set(composerAttachmentUploadsAtom, { - "secondary:photo-1": { status: "uploading", progress: 0.5 }, + const other = { ...state.thread, id: "other" }; + appAtomRegistry.set(state.threadShells, [state.thread, other]); + const slowStarted = Promise.withResolvers(); + const finishSlow = Promise.withResolvers>(); + state.start.mockImplementation(async ({ input }: { input: { threadId: string } }) => { + if (input.threadId !== "thread") return AsyncResult.success({}); + slowStarted.resolve(); + return finishSlow.promise; }); - state.cleanups.push(() => appAtomRegistry.set(composerAttachmentUploadsAtom, {})); - await state.manager.enqueue(message({ attachments: [photo] })); + /** Resolves once only these message ids are still queued. */ + const queuedBecomes = (ids: ReadonlyArray) => { + const reached = Promise.withResolvers(); + const release = appAtomRegistry.subscribe(state.manager.queuedMessagesByThreadKeyAtom, () => { + if ( + remaining() + .map((queued) => queued.messageId) + .join() === ids.join() + ) { + reached.resolve(); + } + }); + return reached.promise.finally(release); + }; + await state.manager.enqueue(message()); startDelivery(); - expect(appAtomRegistry.get(dispatchingQueuedMessageIdAtom)).toBeNull(); - - await deliveryAfter(() => - appAtomRegistry.set(composerAttachmentUploadsAtom, { - "secondary:photo-1": { status: "ready" }, + await slowStarted.promise; + const otherDelivered = queuedBecomes(["message"]); + await state.manager.enqueue( + message({ + threadId: ThreadId.make("other"), + messageId: MessageId.make("other-message"), + commandId: CommandId.make("other-command"), }), ); - expect(state.prepare).toHaveBeenCalledOnce(); - expect(state.start).toHaveBeenCalledOnce(); - expect(remaining()).toEqual([]); + await otherDelivered; + const allDelivered = queuedBecomes([]); + finishSlow.resolve(AsyncResult.success({})); + await allDelivered; + expect(state.start).toHaveBeenCalledTimes(2); }); it("sends at once when its environment reconnects instead of waiting out the backoff", async () => { diff --git a/apps/mobile/src/state/threadOutboxDelivery.test.ts b/apps/mobile/src/state/threadOutboxDelivery.test.ts index b85ed8e4bf4cd..997226f0dcb2e 100644 --- a/apps/mobile/src/state/threadOutboxDelivery.test.ts +++ b/apps/mobile/src/state/threadOutboxDelivery.test.ts @@ -121,7 +121,7 @@ vi.mock("./use-thread-outbox", async () => { const { Atom } = await import("effect/reactivity"); return { editingQueuedMessageIdsAtom: Atom.make>({}).pipe(Atom.keepAlive), - dispatchingQueuedMessageIdAtom: Atom.make(null).pipe(Atom.keepAlive), + dispatchingQueuedMessageIdsAtom: Atom.make({}).pipe(Atom.keepAlive), retryingQueuedMessageIdsAtom: Atom.make({}).pipe(Atom.keepAlive), threadOutboxShellStatusesAtom: Atom.make(new Map()), }; diff --git a/apps/mobile/src/state/threadOutboxDelivery.ts b/apps/mobile/src/state/threadOutboxDelivery.ts index 3a3802d425897..f9f4726c9c947 100644 --- a/apps/mobile/src/state/threadOutboxDelivery.ts +++ b/apps/mobile/src/state/threadOutboxDelivery.ts @@ -23,7 +23,10 @@ import { } from "@t3tools/contracts"; import { buildTemporaryWorktreeBranchName } from "@t3tools/shared/git"; import * as Cause from "effect/Cause"; +import * as Clock from "effect/Clock"; import * as Effect from "effect/Effect"; +import * as Fiber from "effect/Fiber"; +import * as Latch from "effect/Latch"; import { AsyncResult, Atom } from "effect/reactivity"; import { createDebugLogger } from "../lib/debugLog"; @@ -49,12 +52,7 @@ import { } from "./pending-thread-creation"; import { environmentProjects } from "./projects"; import { environmentServerConfigsAtom, serverEnvironment } from "./server"; -import { composerAttachmentUploadsAtom } from "./composer-attachment-upload-states"; import { uploadComposerAttachmentShared } from "./composer-attachment-uploads"; -import { - queuedAttachmentsStillUploading, - uploadingComposerAttachmentKeys, -} from "../lib/composerAttachmentUploadQueue"; import { gitEnvironment } from "./git"; import { environmentSession, readEnvironmentScope, sessionHasScope } from "./session"; import { @@ -92,7 +90,7 @@ import { waitForComposerDraftsLoaded, } from "./use-composer-drafts"; import { - dispatchingQueuedMessageIdAtom, + dispatchingQueuedMessageIdsAtom, editingQueuedMessageIdsAtom, retryingQueuedMessageIdsAtom, threadOutboxShellStatusesAtom, @@ -177,12 +175,17 @@ function setQueuedMessageRetrying(queuedMessageId: MessageId, retrying: boolean) function beginDispatchingQueuedMessage(queuedMessageId: MessageId): void { // An attempt in flight is sending, even while its retry count is kept. setQueuedMessageRetrying(queuedMessageId, false); - appAtomRegistry.set(dispatchingQueuedMessageIdAtom, queuedMessageId); + appAtomRegistry.set(dispatchingQueuedMessageIdsAtom, { + ...appAtomRegistry.get(dispatchingQueuedMessageIdsAtom), + [queuedMessageId]: true, + }); } function finishDispatchingQueuedMessage(queuedMessageId: MessageId): void { - const current = appAtomRegistry.get(dispatchingQueuedMessageIdAtom); - appAtomRegistry.set(dispatchingQueuedMessageIdAtom, current === queuedMessageId ? null : current); + const { [queuedMessageId]: _finished, ...others } = appAtomRegistry.get( + dispatchingQueuedMessageIdsAtom, + ); + appAtomRegistry.set(dispatchingQueuedMessageIdsAtom, others); } function findThread( @@ -599,12 +602,8 @@ async function preserveUploadedAttachmentsForEditor( } } -// Everything a drain pass decides from. Each queued environment's session is -// read here so a granted or revoked operate scope re-runs the drain. -const uploadingComposerAttachmentKeysAtom = Atom.map( - composerAttachmentUploadsAtom, - uploadingComposerAttachmentKeys, -); +// Everything delivery decides from. Each queued environment's session is read +// here so a granted or revoked operate scope wakes delivery. const deliveryInputsAtom = Atom.make((get) => { const connectedEnvironments = get(workspaceConnections.environmentsAtom); @@ -620,7 +619,6 @@ const deliveryInputsAtom = Atom.make((get) => { } } return { - dispatchingQueuedMessageId: get(dispatchingQueuedMessageIdAtom), editingQueuedMessageIds: get(editingQueuedMessageIdsAtom), queuedMessagesByThreadKey: get(threadOutboxManager.queuedMessagesByThreadKeyAtom), shellStatuses: get(threadOutboxShellStatusesAtom), @@ -629,8 +627,6 @@ const deliveryInputsAtom = Atom.make((get) => { serverConfigs: get(environmentServerConfigsAtom), connectedEnvironments, operableEnvironments, - // Wakes a message waiting on the upload worker when that upload settles. - uploadingAttachmentKeys: get(uploadingComposerAttachmentKeysAtom), }; }).pipe(Atom.withLabel("mobile:thread-outbox:delivery-inputs")); @@ -695,14 +691,26 @@ function reportCommandFailure( interface ThreadOutboxRetry { readonly attempt: number; readonly notBefore: number; - readonly timer: ReturnType; } +/** What a thread's delivery fiber does next with the head of its queue. */ +type ThreadDeliveryStep = + /** Nothing to send until an input changes, or until `until` when a backoff is running. */ + | { readonly kind: "wait"; readonly until?: number } + /** The head failed without a send; back off before trying it again. */ + | { readonly kind: "backoff"; readonly messageId: MessageId } + | { + readonly kind: "dispatch"; + readonly messageId: MessageId; + /** Resolves true when the message is done with (sent, removed or handed back). */ + readonly run: () => Promise; + }; + /** - * Delivers queued thread messages one at a time. A drain pass runs whenever its inputs - * change (outbox, locks, shells, projects, configs, connections, scopes) and when a retry - * backoff expires. `dispatchingQueuedMessageIdAtom` is the single in-flight slot; clearing - * it re-runs the drain for the next message. + * Delivers queued thread messages, one fiber per thread so a slow send in one thread never + * holds another. Each fiber sends its thread's head message in order, backs off after a + * failure, and otherwise waits until an input changes (outbox, locks, shells, projects, + * configs, connections, scopes). */ export function createThreadOutboxDelivery(): { readonly drain: () => void; @@ -732,40 +740,19 @@ export function createThreadOutboxDelivery(): { const scheduleRetry = (messageId: MessageId): void => { if (disposed) return; - const previous = retries.get(messageId); - if (previous !== undefined) clearTimeout(previous.timer); - const attempt = (previous?.attempt ?? 0) + 1; - const delayMs = threadOutboxRetryDelayMs(attempt); + const attempt = (retries.get(messageId)?.attempt ?? 0) + 1; retries.set(messageId, { attempt, - notBefore: Date.now() + delayMs, - timer: setTimeout(drain, delayMs), + notBefore: Date.now() + threadOutboxRetryDelayMs(attempt), }); setQueuedMessageRetrying(messageId, true); }; const clearRetry = (messageId: MessageId): void => { - const retry = retries.get(messageId); - if (retry === undefined) return; - clearTimeout(retry.timer); - retries.delete(messageId); + if (!retries.delete(messageId)) return; setQueuedMessageRetrying(messageId, false); }; - // A delivery that throws backs off like any failure. Releasing the slot - // without a retry would re-run the drain straight into the same message. - const settle = (messageId: MessageId, delivery: Promise): void => { - void delivery - .then( - (sent) => (sent ? clearRetry(messageId) : scheduleRetry(messageId)), - (error: unknown) => { - console.warn("[thread-outbox] queued message delivery threw", { messageId, error }); - scheduleRetry(messageId); - }, - ) - .finally(() => finishDispatchingQueuedMessage(messageId)); - }; - // An over-cap draft blocks recovery until the user changes its attachments; // parking on the draft avoids hammering the restore with backoff retries. const restoreQueuedMessage = async ( @@ -800,7 +787,7 @@ export function createThreadOutboxDelivery(): { } blockedRecoveries.delete(queuedMessage.messageId); active.unsubscribe(); - drain(); + wakeThreads(); }); blockedRecoveries.set(queuedMessage.messageId, { message: queuedMessage, unsubscribe }); return true; @@ -1176,268 +1163,191 @@ export function createThreadOutboxDelivery(): { return outcome === "removed"; }; - // A pass writes atoms the pass reads (family mounts, the dispatch slot), and the registry - // notifies subscribers synchronously, so drain() can be called from inside a pass. That call - // only asks for another pass; a nested pass would decide from inputs the outer one is still - // acting on and could start a second delivery. - let draining = false; - let drainRequested = false; - function drain(): void { - if (disposed) return; - if (draining) { - drainRequested = true; - return; - } - draining = true; - try { - do { - if (disposed) return; - drainRequested = false; - drainPass(); - } while (drainRequested); - } finally { - draining = false; - } - } - - function drainPass(): void { + /** The head of one thread's queue, as the inputs stand now. */ + function nextStep( + threadKey: string, + queuedMessages: ReadonlyArray, + inputs: Atom.Type, + ): ThreadDeliveryStep { const { - dispatchingQueuedMessageId, editingQueuedMessageIds, - queuedMessagesByThreadKey, shellStatuses, threads, projects, serverConfigs, connectedEnvironments, operableEnvironments, - } = appAtomRegistry.get(deliveryInputsAtom); - // Failures while an environment was unreachable say nothing about it now; a backoff - // started then would hold a message for up to its full delay after reconnecting. - const ready = new Set( - connectedEnvironments - .filter( - (environment) => - environment.connectionState === "connected" && - serverConfigs.has(environment.environmentId), - ) - .map((environment) => environment.environmentId), - ); - for (const message of Object.values(queuedMessagesByThreadKey).flat()) { - if (ready.has(message.environmentId) && !readyEnvironmentIds.has(message.environmentId)) { - clearRetry(message.messageId); - } - } - readyEnvironmentIds = ready; - if (dispatchingQueuedMessageId !== null) { - return; - } - - const queuedMessageIds = new Set( - Object.values(queuedMessagesByThreadKey) - .flat() - .map((message) => message.messageId), - ); - for (const messageId of acknowledgedExistingThreadMessageIds) { - if (!queuedMessageIds.has(messageId)) { - acknowledgedExistingThreadMessageIds.delete(messageId); - } - } - for (const messageId of launchedCreations.keys()) { - if (!queuedMessageIds.has(messageId)) { - launchedCreations.delete(messageId); - } - } - for (const [messageId, release] of familyMounts) { - if (!queuedMessageIds.has(messageId)) { - release(); - familyMounts.delete(messageId); - } + } = inputs; + const nextQueuedMessage = queuedMessages[0]; + if (!nextQueuedMessage) { + return { kind: "wait" }; } - - for (const [threadKey, queuedMessages] of Object.entries(queuedMessagesByThreadKey)) { - const nextQueuedMessage = queuedMessages[0]; - if (!nextQueuedMessage) { - continue; + const messageId = nextQueuedMessage.messageId; + if ( + nextQueuedMessage.creation === undefined && + acknowledgedExistingThreadMessageIds.has(messageId) + ) { + if (retryNotBefore(messageId) > Date.now()) { + return { kind: "wait", until: retryNotBefore(messageId) }; } - const messageId = nextQueuedMessage.messageId; - if ( - nextQueuedMessage.creation === undefined && - acknowledgedExistingThreadMessageIds.has(messageId) - ) { - if (retryNotBefore(messageId) > Date.now()) { - continue; - } - beginDispatchingQueuedMessage(messageId); - settle( - messageId, + return { + kind: "dispatch", + messageId, + run: () => removeAcknowledgedExistingThreadMessage( nextQueuedMessage, acknowledgedExistingThreadMessageIds, ), - ); - return; - } - if (editingQueuedMessageIds[messageId]) { - continue; - } - const blockedRecovery = blockedRecoveries.get(messageId); - if (blockedRecovery) { - if (blockedRecovery.message === nextQueuedMessage) { - continue; - } - blockedRecoveries.delete(messageId); - blockedRecovery.unsubscribe(); - } - if (retryNotBefore(messageId) > Date.now()) { - continue; - } - if ( - queuedAttachmentsStillUploading({ - environmentId: nextQueuedMessage.environmentId, - attachments: nextQueuedMessage.attachments, - states: appAtomRegistry.get(composerAttachmentUploadsAtom), - }) - ) { - continue; - } - - let thread = findThread(threads, nextQueuedMessage); - if (thread && scopedThreadKey(thread.environmentId, thread.id) !== threadKey) { - continue; + }; + } + if (editingQueuedMessageIds[messageId]) { + return { kind: "wait" }; + } + const blockedRecovery = blockedRecoveries.get(messageId); + if (blockedRecovery) { + if (blockedRecovery.message === nextQueuedMessage) { + return { kind: "wait" }; } + blockedRecoveries.delete(messageId); + blockedRecovery.unsubscribe(); + } + if (retryNotBefore(messageId) > Date.now()) { + return { kind: "wait", until: retryNotBefore(messageId) }; + } + let thread = findThread(threads, nextQueuedMessage); + if (thread && scopedThreadKey(thread.environmentId, thread.id) !== threadKey) { + return { kind: "wait" }; + } - const creation = nextQueuedMessage.creation; - const environment = connectedEnvironments.find( - (candidate) => candidate.environmentId === nextQueuedMessage.environmentId, - ); - const shellStatus = shellStatuses.get(nextQueuedMessage.environmentId) ?? "empty"; - const serverConfig = serverConfigs.get(nextQueuedMessage.environmentId); - let familyRead: ThreadFamilyRead | undefined; - if ( - thread === undefined && - creation === undefined && - serverConfig?.shellThreadFamilies === true - ) { - // The family keeps the row readable through dispatch once it loads; the current shell - // generation's read decides whether the thread is gone. - if (!familyMounts.has(nextQueuedMessage.messageId)) { - familyMounts.set( - nextQueuedMessage.messageId, - threadFamilies.mount( - appAtomRegistry, - nextQueuedMessage.environmentId, - nextQueuedMessage.threadId, - ), - ); - } - familyRead = threadFamilyRead( - appAtomRegistry.get( - threadFamilies.familyAtom(nextQueuedMessage.environmentId, nextQueuedMessage.threadId), - ), - ); - if (familyRead === "settled") { - // The rows read at the start of this pass can lag the family that just settled; - // decide from the merged rows as they are now. - thread = findThread( - appAtomRegistry.get(environmentThreadShells.threadShellsAtom), - nextQueuedMessage, - ); - } else if (familyRead === "failed") { - threadFamilies.refresh( + const creation = nextQueuedMessage.creation; + const environment = connectedEnvironments.find( + (candidate) => candidate.environmentId === nextQueuedMessage.environmentId, + ); + const shellStatus = shellStatuses.get(nextQueuedMessage.environmentId) ?? "empty"; + const serverConfig = serverConfigs.get(nextQueuedMessage.environmentId); + let familyRead: ThreadFamilyRead | undefined; + if ( + thread === undefined && + creation === undefined && + serverConfig?.shellThreadFamilies === true + ) { + // The family keeps the row readable through dispatch once it loads; the current shell + // generation's read decides whether the thread is gone. + if (!familyMounts.has(nextQueuedMessage.messageId)) { + familyMounts.set( + nextQueuedMessage.messageId, + threadFamilies.mount( appAtomRegistry, nextQueuedMessage.environmentId, nextQueuedMessage.threadId, - ); - } - } - const resendLaunch = - creation !== undefined && - launchedCreations.get(messageId)?.revision === threadOutboxRevision(messageId); - const deliveryAction = resolveThreadOutboxDeliveryAction({ - isCreation: creation !== undefined, - // A resend goes through the same gates as the first launch. - threadExists: thread !== undefined && !resendLaunch, - shellStatus, - environmentConnected: environment?.connectionState === "connected", - ...(familyRead === undefined ? {} : { familyRead }), - }); - if ( - deliveryAction === "wait" && - shellStatus === "live" && - familyRead !== undefined && - familyRead !== "settled" - ) { - // An empty family read changes no merged row, so nothing else would wake the drain. - scheduleRetry(messageId); - continue; - } - if (deliveryAction === "send" && !operableEnvironments.has(nextQueuedMessage.environmentId)) { - continue; + ), + ); } - const dispatchStep = resolveThreadOutboxDispatchStep({ - deliveryAction, - fileAttachments: nextQueuedMessage.attachments.filter( - (attachment) => attachment.type === "file", + familyRead = threadFamilyRead( + appAtomRegistry.get( + threadFamilies.familyAtom(nextQueuedMessage.environmentId, nextQueuedMessage.threadId), ), - serverConfig: serverConfig - ? { - maxFileUploadBytes: - serverConfig.environment.capabilities.fileAttachments?.maxUploadBytes, - } - : null, - }); - if (dispatchStep.step === "wait") { - continue; - } - if (dispatchStep.step === "retry") { - scheduleRetry(messageId); - continue; + ); + if (familyRead === "settled") { + // The rows read at the start of this pass can lag the family that just settled; + // decide from the merged rows as they are now. + thread = findThread( + appAtomRegistry.get(environmentThreadShells.threadShellsAtom), + nextQueuedMessage, + ); + } else if (familyRead === "failed") { + threadFamilies.refresh( + appAtomRegistry, + nextQueuedMessage.environmentId, + nextQueuedMessage.threadId, + ); } - if (dispatchStep.step === "restore") { - const attachmentError = dispatchStep.reason; - beginDispatchingQueuedMessage(messageId); - settle( - messageId, + } + const resendLaunch = + creation !== undefined && + launchedCreations.get(messageId)?.revision === threadOutboxRevision(messageId); + const deliveryAction = resolveThreadOutboxDeliveryAction({ + isCreation: creation !== undefined, + // A resend goes through the same gates as the first launch. + threadExists: thread !== undefined && !resendLaunch, + shellStatus, + environmentConnected: environment?.connectionState === "connected", + ...(familyRead === undefined ? {} : { familyRead }), + }); + if ( + deliveryAction === "wait" && + shellStatus === "live" && + familyRead !== undefined && + familyRead !== "settled" + ) { + // An empty family read changes no merged row, so nothing else would wake the thread. + return { kind: "backoff", messageId }; + } + if (deliveryAction === "send" && !operableEnvironments.has(nextQueuedMessage.environmentId)) { + return { kind: "wait" }; + } + const dispatchStep = resolveThreadOutboxDispatchStep({ + deliveryAction, + fileAttachments: nextQueuedMessage.attachments.filter( + (attachment) => attachment.type === "file", + ), + serverConfig: serverConfig + ? { + maxFileUploadBytes: + serverConfig.environment.capabilities.fileAttachments?.maxUploadBytes, + } + : null, + }); + if (dispatchStep.step === "wait") { + return { kind: "wait" }; + } + if (dispatchStep.step === "retry") { + return { kind: "backoff", messageId }; + } + if (dispatchStep.step === "restore") { + const attachmentError = dispatchStep.reason; + return { + kind: "dispatch", + messageId, + run: () => confirmThreadOutboxMessageQueued(nextQueuedMessage).then((queued) => !queued || appAtomRegistry.get(editingQueuedMessageIdsAtom)[messageId] ? true : restoreQueuedMessage(nextQueuedMessage, attachmentError), ), - ); - return; + }; + } + const creationProjectCwd = + creation !== undefined + ? (findCreationProject(projects, nextQueuedMessage)?.workspaceRoot ?? + creation.projectCwd ?? + null) + : null; + if (deliveryAction === "send" && creation !== undefined) { + if (!isQueuedThreadCreationSendable(nextQueuedMessage)) { + return { kind: "wait" }; } - const creationProjectCwd = - creation !== undefined - ? (findCreationProject(projects, nextQueuedMessage)?.workspaceRoot ?? - creation.projectCwd ?? - null) - : null; - if (deliveryAction === "send" && creation !== undefined) { - if (!isQueuedThreadCreationSendable(nextQueuedMessage)) { - continue; - } - if (creationProjectCwd === null && shellStatus !== "live") { - continue; - } + if (creationProjectCwd === null && shellStatus !== "live") { + return { kind: "wait" }; } + } - beginDispatchingQueuedMessage(messageId); - const removeQueuedMessage = (warning: string) => - removeThreadOutboxMessage(nextQueuedMessage).then( - () => true, - (error) => { - console.warn(warning, { - environmentId: nextQueuedMessage.environmentId, - threadId: nextQueuedMessage.threadId, - messageId, - error, - }); - return false; - }, - ); - // Confirm durability before sending; optimistic enqueue can still roll back on write failure. - const delivery = confirmThreadOutboxMessageQueued(nextQueuedMessage).then((queued) => { + const removeQueuedMessage = (warning: string) => + removeThreadOutboxMessage(nextQueuedMessage).then( + () => true, + (error) => { + console.warn(warning, { + environmentId: nextQueuedMessage.environmentId, + threadId: nextQueuedMessage.threadId, + messageId, + error, + }); + return false; + }, + ); + // Confirm durability before sending; optimistic enqueue can still roll back on write failure. + const run = () => + confirmThreadOutboxMessageQueued(nextQueuedMessage).then((queued) => { if (!queued) { return true; } @@ -1473,12 +1383,118 @@ export function createThreadOutboxDelivery(): { ? sendQueuedMessage(nextQueuedMessage, thread) : Promise.resolve(false); }); - settle(messageId, delivery); - return; + return { kind: "dispatch", messageId, run }; + } + + // One fiber per thread with queued messages. Opening a thread's latch wakes its fiber to + // reconsider its head; the fiber closes it before reading the inputs, so no wake is lost. + const threadFibers = new Map< + string, + { readonly wake: Latch.Latch; readonly fiber: Fiber.Fiber } + >(); + + const deliverThread = (threadKey: string, wake: Latch.Latch) => + Effect.forever( + Effect.gen(function* () { + yield* wake.close; + const inputs = appAtomRegistry.get(deliveryInputsAtom); + const step = nextStep(threadKey, inputs.queuedMessagesByThreadKey[threadKey] ?? [], inputs); + if (step.kind === "backoff") { + scheduleRetry(step.messageId); + return; + } + if (step.kind === "wait") { + if (step.until === undefined) { + yield* wake.await; + return; + } + const now = yield* Clock.currentTimeMillis; + yield* wake.await.pipe( + Effect.timeoutOrElse({ + duration: Math.max(0, step.until - now), + orElse: () => Effect.void, + }), + ); + return; + } + // A send that started finishes, even when its thread leaves the queue meanwhile. + beginDispatchingQueuedMessage(step.messageId); + const sent = yield* Effect.promise(() => + step.run().catch((error: unknown) => { + // A delivery that throws backs off like any failure, not straight back into the send. + console.warn("[thread-outbox] queued message delivery threw", { + messageId: step.messageId, + error, + }); + return false; + }), + ).pipe( + Effect.ensuring(Effect.sync(() => finishDispatchingQueuedMessage(step.messageId))), + Effect.uninterruptible, + ); + if (sent) clearRetry(step.messageId); + else scheduleRetry(step.messageId); + }), + ); + + function wakeThreads(): void { + for (const { wake } of threadFibers.values()) wake.openUnsafe(); + } + + /** Starts a fiber for each thread with queued messages, stops the rest, and wakes them all. */ + function onInputs(): void { + if (disposed) return; + const { queuedMessagesByThreadKey, serverConfigs, connectedEnvironments } = + appAtomRegistry.get(deliveryInputsAtom); + const queued = Object.values(queuedMessagesByThreadKey).flat(); + // Failures while an environment was unreachable say nothing about it now; a backoff + // started then would hold a message for up to its full delay after reconnecting. + const ready = new Set( + connectedEnvironments + .filter( + (environment) => + environment.connectionState === "connected" && + serverConfigs.has(environment.environmentId), + ) + .map((environment) => environment.environmentId), + ); + for (const message of queued) { + if (ready.has(message.environmentId) && !readyEnvironmentIds.has(message.environmentId)) { + clearRetry(message.messageId); + } + } + readyEnvironmentIds = ready; + + const queuedMessageIds = new Set(queued.map((message) => message.messageId)); + for (const messageId of acknowledgedExistingThreadMessageIds) { + if (!queuedMessageIds.has(messageId)) acknowledgedExistingThreadMessageIds.delete(messageId); + } + for (const messageId of launchedCreations.keys()) { + if (!queuedMessageIds.has(messageId)) launchedCreations.delete(messageId); } + for (const [messageId, release] of familyMounts) { + if (!queuedMessageIds.has(messageId)) { + release(); + familyMounts.delete(messageId); + } + } + + for (const [threadKey, entry] of threadFibers) { + if ((queuedMessagesByThreadKey[threadKey]?.length ?? 0) > 0) continue; + threadFibers.delete(threadKey); + Effect.runFork(Fiber.interrupt(entry.fiber)); + } + for (const [threadKey, messages] of Object.entries(queuedMessagesByThreadKey)) { + if (messages.length === 0 || threadFibers.has(threadKey)) continue; + const wake = Latch.makeUnsafe(true); + threadFibers.set(threadKey, { wake, fiber: Effect.runFork(deliverThread(threadKey, wake)) }); + } + wakeThreads(); } - const stopDraining = appAtomRegistry.subscribe(deliveryInputsAtom, drain, { immediate: true }); + const stopDelivering = appAtomRegistry.subscribe(deliveryInputsAtom, onInputs, { + immediate: true, + }); const stopCollectingOutcomes = appAtomRegistry.subscribe( settledCreationOutcomeKeysAtom, (threadKeys) => { @@ -1488,12 +1504,13 @@ export function createThreadOutboxDelivery(): { ); return { - drain, + drain: wakeThreads, dispose: () => { disposed = true; - stopDraining(); + stopDelivering(); stopCollectingOutcomes(); - for (const retry of retries.values()) clearTimeout(retry.timer); + for (const { fiber } of threadFibers.values()) Effect.runFork(Fiber.interrupt(fiber)); + threadFibers.clear(); retries.clear(); appAtomRegistry.set(retryingQueuedMessageIdsAtom, {}); for (const blocked of blockedRecoveries.values()) blocked.unsubscribe(); diff --git a/apps/mobile/src/state/use-thread-composer-state.ts b/apps/mobile/src/state/use-thread-composer-state.ts index f8f836dd77e9b..58f2da087ea41 100644 --- a/apps/mobile/src/state/use-thread-composer-state.ts +++ b/apps/mobile/src/state/use-thread-composer-state.ts @@ -122,7 +122,7 @@ import { } from "./use-thread-detail"; import { useThreadSelection } from "./use-thread-selection"; import { enqueueThreadOutboxMessage } from "./thread-outbox"; -import { dispatchingQueuedMessageIdAtom, useThreadOutboxMessages } from "./use-thread-outbox"; +import { dispatchingQueuedMessageIdsAtom, useThreadOutboxMessages } from "./use-thread-outbox"; import { threadEnvironment } from "./threads"; import { useAtomCommand } from "./use-atom-command"; @@ -217,7 +217,7 @@ export function useThreadComposerState(input: { const selectedThreadVisibleTurnItems = useSelectedThreadVisibleTurnItems(); const acknowledgedMessages = useAtomValue(acknowledgedThreadMessagesAtom); const queuedMessagesByThreadKey = useThreadOutboxMessages(); - const dispatchingQueuedMessageId = useAtomValue(dispatchingQueuedMessageIdAtom); + const dispatchingQueuedMessageIds = useAtomValue(dispatchingQueuedMessageIdsAtom); const [feedbackSubmissionsByThreadKey, setFeedbackSubmissionsByThreadKey] = useState< Record> >({}); @@ -240,6 +240,10 @@ export function useThreadComposerState(input: { (message) => message.creation === undefined, ) : []; + // The thread sends one message at a time, the head of its queue. + const dispatchingQueuedMessageId = + selectedThreadQueuedMessages.find((message) => dispatchingQueuedMessageIds[message.messageId]) + ?.messageId ?? null; const feedbackSubmissions = selectedThreadKey ? (feedbackSubmissionsByThreadKey[selectedThreadKey] ?? []) : []; diff --git a/apps/mobile/src/state/use-thread-outbox.ts b/apps/mobile/src/state/use-thread-outbox.ts index bc1f3ea149e1b..8edb8e033b361 100644 --- a/apps/mobile/src/state/use-thread-outbox.ts +++ b/apps/mobile/src/state/use-thread-outbox.ts @@ -26,10 +26,10 @@ export const editingQueuedMessageIdsAtom = Atom.make(null).pipe( - Atom.keepAlive, - Atom.withLabel("mobile:thread-outbox:dispatching-message-id"), -); +/** Messages being sent now: at most one per thread, the head of its queue. */ +export const dispatchingQueuedMessageIdsAtom = Atom.make< + Readonly>> +>({}).pipe(Atom.keepAlive, Atom.withLabel("mobile:thread-outbox:dispatching-message-ids")); /** Messages waiting out a retry backoff, which can repeat for as long as the failure lasts. */ export const retryingQueuedMessageIdsAtom = Atom.make>>>( From 04759e69f1de575fea43a0bccc8dc3a21d75cdcf Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Mon, 16 Nov 2026 10:24:52 -0800 Subject: [PATCH 2/5] refactor(mobile): tag thread delivery steps with _tag Co-Authored-By: Claude Opus 5.5 --- apps/mobile/src/state/threadOutboxDelivery.ts | 40 +++++++++---------- 1 file changed, 20 insertions(+), 20 deletions(-) diff --git a/apps/mobile/src/state/threadOutboxDelivery.ts b/apps/mobile/src/state/threadOutboxDelivery.ts index f9f4726c9c947..59617bccc84c8 100644 --- a/apps/mobile/src/state/threadOutboxDelivery.ts +++ b/apps/mobile/src/state/threadOutboxDelivery.ts @@ -696,11 +696,11 @@ interface ThreadOutboxRetry { /** What a thread's delivery fiber does next with the head of its queue. */ type ThreadDeliveryStep = /** Nothing to send until an input changes, or until `until` when a backoff is running. */ - | { readonly kind: "wait"; readonly until?: number } + | { readonly _tag: "Wait"; readonly until?: number } /** The head failed without a send; back off before trying it again. */ - | { readonly kind: "backoff"; readonly messageId: MessageId } + | { readonly _tag: "Backoff"; readonly messageId: MessageId } | { - readonly kind: "dispatch"; + readonly _tag: "Dispatch"; readonly messageId: MessageId; /** Resolves true when the message is done with (sent, removed or handed back). */ readonly run: () => Promise; @@ -1180,7 +1180,7 @@ export function createThreadOutboxDelivery(): { } = inputs; const nextQueuedMessage = queuedMessages[0]; if (!nextQueuedMessage) { - return { kind: "wait" }; + return { _tag: "Wait" }; } const messageId = nextQueuedMessage.messageId; if ( @@ -1188,10 +1188,10 @@ export function createThreadOutboxDelivery(): { acknowledgedExistingThreadMessageIds.has(messageId) ) { if (retryNotBefore(messageId) > Date.now()) { - return { kind: "wait", until: retryNotBefore(messageId) }; + return { _tag: "Wait", until: retryNotBefore(messageId) }; } return { - kind: "dispatch", + _tag: "Dispatch", messageId, run: () => removeAcknowledgedExistingThreadMessage( @@ -1201,22 +1201,22 @@ export function createThreadOutboxDelivery(): { }; } if (editingQueuedMessageIds[messageId]) { - return { kind: "wait" }; + return { _tag: "Wait" }; } const blockedRecovery = blockedRecoveries.get(messageId); if (blockedRecovery) { if (blockedRecovery.message === nextQueuedMessage) { - return { kind: "wait" }; + return { _tag: "Wait" }; } blockedRecoveries.delete(messageId); blockedRecovery.unsubscribe(); } if (retryNotBefore(messageId) > Date.now()) { - return { kind: "wait", until: retryNotBefore(messageId) }; + return { _tag: "Wait", until: retryNotBefore(messageId) }; } let thread = findThread(threads, nextQueuedMessage); if (thread && scopedThreadKey(thread.environmentId, thread.id) !== threadKey) { - return { kind: "wait" }; + return { _tag: "Wait" }; } const creation = nextQueuedMessage.creation; @@ -1281,10 +1281,10 @@ export function createThreadOutboxDelivery(): { familyRead !== "settled" ) { // An empty family read changes no merged row, so nothing else would wake the thread. - return { kind: "backoff", messageId }; + return { _tag: "Backoff", messageId }; } if (deliveryAction === "send" && !operableEnvironments.has(nextQueuedMessage.environmentId)) { - return { kind: "wait" }; + return { _tag: "Wait" }; } const dispatchStep = resolveThreadOutboxDispatchStep({ deliveryAction, @@ -1299,15 +1299,15 @@ export function createThreadOutboxDelivery(): { : null, }); if (dispatchStep.step === "wait") { - return { kind: "wait" }; + return { _tag: "Wait" }; } if (dispatchStep.step === "retry") { - return { kind: "backoff", messageId }; + return { _tag: "Backoff", messageId }; } if (dispatchStep.step === "restore") { const attachmentError = dispatchStep.reason; return { - kind: "dispatch", + _tag: "Dispatch", messageId, run: () => confirmThreadOutboxMessageQueued(nextQueuedMessage).then((queued) => @@ -1325,10 +1325,10 @@ export function createThreadOutboxDelivery(): { : null; if (deliveryAction === "send" && creation !== undefined) { if (!isQueuedThreadCreationSendable(nextQueuedMessage)) { - return { kind: "wait" }; + return { _tag: "Wait" }; } if (creationProjectCwd === null && shellStatus !== "live") { - return { kind: "wait" }; + return { _tag: "Wait" }; } } @@ -1383,7 +1383,7 @@ export function createThreadOutboxDelivery(): { ? sendQueuedMessage(nextQueuedMessage, thread) : Promise.resolve(false); }); - return { kind: "dispatch", messageId, run }; + return { _tag: "Dispatch", messageId, run }; } // One fiber per thread with queued messages. Opening a thread's latch wakes its fiber to @@ -1399,11 +1399,11 @@ export function createThreadOutboxDelivery(): { yield* wake.close; const inputs = appAtomRegistry.get(deliveryInputsAtom); const step = nextStep(threadKey, inputs.queuedMessagesByThreadKey[threadKey] ?? [], inputs); - if (step.kind === "backoff") { + if (step._tag === "Backoff") { scheduleRetry(step.messageId); return; } - if (step.kind === "wait") { + if (step._tag === "Wait") { if (step.until === undefined) { yield* wake.await; return; From 453e7a827fc20cde0684c3ba8cca82213c99fbfa Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Mon, 16 Nov 2026 11:02:41 -0800 Subject: [PATCH 3/5] refactor(mobile): run outbox delivery steps as Effects Sending, preparing attachments, completing, removing, recovering and restoring a queued message are Effect.fn steps that succeed once the message is handled and fail with DeliveryRetry to back off, replacing the boolean protocol and the promise chains under the thread fibers. Promises remain only at the storage and command adapters. A send stays uninterruptible except while it waits on a shared upload, so a thread that leaves the queue stops waiting instead of holding the upload. Co-Authored-By: Claude Opus 5.5 --- .../state/composer-attachment-uploads.test.ts | 47 +- .../threadOutboxDelivery.permissions.test.ts | 2 +- .../src/state/threadOutboxDelivery.test.ts | 1056 +++++++++-------- apps/mobile/src/state/threadOutboxDelivery.ts | 961 ++++++++------- 4 files changed, 1072 insertions(+), 994 deletions(-) diff --git a/apps/mobile/src/state/composer-attachment-uploads.test.ts b/apps/mobile/src/state/composer-attachment-uploads.test.ts index 16261ab662f20..c931dd1a87aaa 100644 --- a/apps/mobile/src/state/composer-attachment-uploads.test.ts +++ b/apps/mobile/src/state/composer-attachment-uploads.test.ts @@ -1,5 +1,7 @@ import { CommandId, EnvironmentId, MessageId, ThreadId } from "@t3tools/contracts"; -import { afterEach, beforeEach, expect, it, vi } from "vite-plus/test"; +import { expect, it } from "@effect/vitest"; +import * as Effect from "effect/Effect"; +import { afterEach, beforeEach, vi } from "vite-plus/test"; type UploadOptions = { signal: AbortSignal; @@ -296,29 +298,30 @@ function uploadState() { ]; } -it.each(["decode", "write"] as const)( +it.effect.each(["decode", "write"] as const)( "keeps an accepted upload ready when the draft %s fails", - async (fault) => { - native.fault = fault; - if (fault === "decode") - native.files.set(draftsUri, Buffer.from('{"schemaVersion":1,"drafts":')); - drafts.resetComposerDraftsLoadState(); - const queue = worker(); - await queue.settled(); - expect(uploadState()).toEqual({ status: "ready" }); - expect(native.deleted).toEqual([]); - expect(composerAttachmentUploadBlockReason(sendInput())).toBeNull(); - expect(composerAttachmentsStillUploading(sendInput())).toBe(false); + (fault) => + Effect.gen(function* () { + native.fault = fault; + if (fault === "decode") + native.files.set(draftsUri, Buffer.from('{"schemaVersion":1,"drafts":')); + drafts.resetComposerDraftsLoadState(); + const queue = worker(); + yield* Effect.promise(() => queue.settled()); + expect(uploadState()).toEqual({ status: "ready" }); + expect(native.deleted).toEqual([]); + expect(composerAttachmentUploadBlockReason(sendInput())).toBeNull(); + expect(composerAttachmentsStillUploading(sendInput())).toBe(false); - const message = queuedMessage(); - expect(message.attachments[0]?.uploadedAttachmentId).toBe("pending-1"); - await enqueueThreadOutboxMessage(message); - const prepared = await prepareQueuedMessageAttachments(message); - expect(prepared.status).toBe("ready"); - if (prepared.status !== "ready") throw new Error("Outbox preparation abandoned"); - expect(prepared.prepared.pendingAttachmentIds).toEqual(["pending-1"]); - expect(native.transfer).toHaveBeenCalledTimes(1); - }, + const message = queuedMessage(); + expect(message.attachments[0]?.uploadedAttachmentId).toBe("pending-1"); + yield* Effect.promise(() => enqueueThreadOutboxMessage(message)); + const prepared = yield* prepareQueuedMessageAttachments(message); + expect(prepared.status).toBe("ready"); + if (prepared.status !== "ready") throw new Error("Outbox preparation abandoned"); + expect(prepared.prepared.pendingAttachmentIds).toEqual(["pending-1"]); + expect(native.transfer).toHaveBeenCalledTimes(1); + }), ); it("keeps an upload running when its message is sent mid-upload and records it on the message", async () => { diff --git a/apps/mobile/src/state/threadOutboxDelivery.permissions.test.ts b/apps/mobile/src/state/threadOutboxDelivery.permissions.test.ts index 314b02ca762cc..e23324ba94528 100644 --- a/apps/mobile/src/state/threadOutboxDelivery.permissions.test.ts +++ b/apps/mobile/src/state/threadOutboxDelivery.permissions.test.ts @@ -151,7 +151,7 @@ vi.mock("./use-composer-drafts", async () => { composerDraftsAtom: Atom.make({}), removeDeliveredCloudQueuedMessage: async () => {}, appendComposerDraftAttachments: vi.fn(), - flushComposerDrafts: vi.fn(), + flushComposerDrafts: vi.fn(async () => {}), getComposerDraftSnapshot: vi.fn(() => ({ text: state.draftText, attachments: [] })), mergeComposerDraftContent: vi.fn(async (_key: string, input: { text: string }) => { state.draftText += `\n${input.text}`; diff --git a/apps/mobile/src/state/threadOutboxDelivery.test.ts b/apps/mobile/src/state/threadOutboxDelivery.test.ts index 997226f0dcb2e..aa6e04c1867c8 100644 --- a/apps/mobile/src/state/threadOutboxDelivery.test.ts +++ b/apps/mobile/src/state/threadOutboxDelivery.test.ts @@ -3,6 +3,7 @@ import { pruneCaughtUpAcknowledgedThreadMessages, } from "./acknowledged-thread-messages"; import * as Effect from "effect/Effect"; +import * as Fiber from "effect/Fiber"; import { CommandId, EnvironmentId, @@ -11,7 +12,8 @@ import { ProviderInstanceId, ThreadId, } from "@t3tools/contracts"; -import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test"; +import { describe, expect, it } from "@effect/vitest"; +import { afterEach, beforeEach, vi } from "vite-plus/test"; import type { PreparedTurnAttachments } from "../lib/attachmentUpload"; @@ -160,6 +162,7 @@ import { recoverFailedThreadDraft } from "./recover-failed-thread-draft"; import { editingQueuedMessageIdsAtom } from "./use-thread-outbox"; import { completeQueuedMessageDelivery, + type DeliveryRetry, prepareQueuedMessageAttachments, recoverEditedCreationAfterDelivery, removeAcknowledgedExistingThreadMessage, @@ -235,447 +238,522 @@ afterEach(() => { harness.prepareTurnAttachments.mockReset(); }); +/** True once a delivery step handled its message, false when it asks to retry. */ +const handled = (step: Effect.Effect) => + step.pipe(Effect.as(true), Effect.catchTags({ DeliveryRetry: () => Effect.succeed(false) })); + describe("thread outbox attachment preparation", () => { - it("keeps a denied message queued without starting its attachment upload", async () => { - const message = queuedMessage({ - messageId: "denied-queued-message", - text: "Keep this queued", - fileUri: "file:///documents/keep.pdf", - }); - await harness.manager.enqueue(message); - harness.prepareTurnAttachments.mockReturnValueOnce( - Effect.succeed({ + it.effect("keeps a denied message queued without starting its attachment upload", () => + Effect.gen(function* () { + const message = queuedMessage({ + messageId: "denied-queued-message", + text: "Keep this queued", + fileUri: "file:///documents/keep.pdf", + }); + yield* Effect.promise(() => harness.manager.enqueue(message)); + harness.prepareTurnAttachments.mockReturnValueOnce( + Effect.succeed({ + status: "ready", + attachments: [], + draftAttachments: message.attachments, + pendingAttachmentIds: [], + }), + ); + harness.canOperate = false; + expect(yield* prepareQueuedMessageAttachments(message)).toEqual({ + status: "abandoned", + }); + expect(harness.prepareTurnAttachments).not.toHaveBeenCalled(); + expect(remainingMessages()).toEqual([message]); + }), + ); + + it.effect("abandons reused uploads when an editor saves changed text during verification", () => + Effect.gen(function* () { + const message = withReusedFileUpload( + queuedMessage({ + messageId: "message-reused-upload-race", + text: "original text", + fileUri: "file:///documents/t3-composer-attachments/reused.pdf", + }), + "pending-reused-upload", + ); + const preparationStarted = Promise.withResolvers(); + const preparationBarrier = Promise.withResolvers(); + harness.prepareTurnAttachments.mockImplementationOnce(() => + Effect.promise(() => { + preparationStarted.resolve(); + return preparationBarrier.promise; + }), + ); + yield* Effect.promise(() => harness.manager.enqueue(message)); + appAtomRegistry.set(editingQueuedMessageIdsAtom, { [message.messageId]: true }); + + const preparation = yield* Effect.forkChild(prepareQueuedMessageAttachments(message), { + startImmediately: true, + }); + yield* Effect.promise(() => preparationStarted.promise); + const edited = { ...message, text: "saved editor text" }; + yield* Effect.promise(() => harness.manager.update(edited)); + appAtomRegistry.set(editingQueuedMessageIdsAtom, {}); + preparationBarrier.resolve({ status: "ready", attachments: [], draftAttachments: message.attachments, - pendingAttachmentIds: [], - }), - ); - harness.canOperate = false; - await expect(prepareQueuedMessageAttachments(message)).resolves.toEqual({ - status: "abandoned", - }); - expect(harness.prepareTurnAttachments).not.toHaveBeenCalled(); - expect(remainingMessages()).toEqual([message]); - }); - - it("abandons reused uploads when an editor saves changed text during verification", async () => { - const message = withReusedFileUpload( - queuedMessage({ - messageId: "message-reused-upload-race", - text: "original text", - fileUri: "file:///documents/t3-composer-attachments/reused.pdf", - }), - "pending-reused-upload", - ); - const preparationStarted = Promise.withResolvers(); - const preparationBarrier = Promise.withResolvers(); - harness.prepareTurnAttachments.mockImplementationOnce(() => - Effect.promise(() => { - preparationStarted.resolve(); - return preparationBarrier.promise; - }), - ); - await harness.manager.enqueue(message); - appAtomRegistry.set(editingQueuedMessageIdsAtom, { [message.messageId]: true }); - - const preparation = prepareQueuedMessageAttachments(message); - await preparationStarted.promise; - const edited = { ...message, text: "saved editor text" }; - await harness.manager.update(edited); - appAtomRegistry.set(editingQueuedMessageIdsAtom, {}); - preparationBarrier.resolve({ - status: "ready", - attachments: [], - draftAttachments: message.attachments, - pendingAttachmentIds: ["pending-reused-upload"], - }); + pendingAttachmentIds: ["pending-reused-upload"], + }); - await expect(preparation).resolves.toEqual({ status: "abandoned" }); - expect(remainingMessages()).toEqual([edited]); - }); + expect(yield* Fiber.join(preparation)).toEqual({ status: "abandoned" }); + expect(remainingMessages()).toEqual([edited]); + }), + ); - it("uses the known next revision after persisting uploaded references", async () => { - const message = queuedMessage({ - messageId: "message-new-upload-revision", - text: "upload this file", - fileUri: "file:///documents/t3-composer-attachments/new.pdf", - }); - const uploadedAttachments = message.attachments.map((attachment) => - attachment.type === "file" - ? { - ...attachment, - uploadedAttachmentId: "pending-new-upload", - uploadEnvironmentId: message.environmentId, - } - : attachment, - ); - harness.prepareTurnAttachments.mockImplementationOnce((input) => - Effect.gen(function* () { - expect(yield* input.persistUploadedReferences!(uploadedAttachments)).toBe("persisted"); - return { - status: "ready", - attachments: [], - draftAttachments: uploadedAttachments, - pendingAttachmentIds: ["pending-new-upload"], - } as const; - }), - ); - await harness.manager.enqueue(message); - const revision = harness.manager.revisionOf(message.messageId); + it.effect("uses the known next revision after persisting uploaded references", () => + Effect.gen(function* () { + const message = queuedMessage({ + messageId: "message-new-upload-revision", + text: "upload this file", + fileUri: "file:///documents/t3-composer-attachments/new.pdf", + }); + const uploadedAttachments = message.attachments.map((attachment) => + attachment.type === "file" + ? { + ...attachment, + uploadedAttachmentId: "pending-new-upload", + uploadEnvironmentId: message.environmentId, + } + : attachment, + ); + harness.prepareTurnAttachments.mockImplementationOnce((input) => + Effect.gen(function* () { + expect(yield* input.persistUploadedReferences!(uploadedAttachments)).toBe("persisted"); + return { + status: "ready", + attachments: [], + draftAttachments: uploadedAttachments, + pendingAttachmentIds: ["pending-new-upload"], + } as const; + }), + ); + yield* Effect.promise(() => harness.manager.enqueue(message)); + const revision = harness.manager.revisionOf(message.messageId); - const result = await prepareQueuedMessageAttachments(message); + const result = yield* prepareQueuedMessageAttachments(message); - expect(result).toMatchObject({ - status: "ready", - persistedMessage: { attachments: uploadedAttachments }, - deliveryRevision: revision + 1, - }); - expect(harness.manager.revisionOf(message.messageId)).toBe(revision + 1); - }); + expect(result).toMatchObject({ + status: "ready", + persistedMessage: { attachments: uploadedAttachments }, + deliveryRevision: revision + 1, + }); + expect(harness.manager.revisionOf(message.messageId)).toBe(revision + 1); + }), + ); - it("does not prepare a payload that was already replaced", async () => { - const message = queuedMessage({ messageId: "message-stale-before-upload", text: "old" }); - await harness.manager.enqueue(message); - const edited = { ...message, text: "new" }; - await harness.manager.update(edited); + it.effect("does not prepare a payload that was already replaced", () => + Effect.gen(function* () { + const message = queuedMessage({ messageId: "message-stale-before-upload", text: "old" }); + yield* Effect.promise(() => harness.manager.enqueue(message)); + const edited = { ...message, text: "new" }; + yield* Effect.promise(() => harness.manager.update(edited)); - await expect(prepareQueuedMessageAttachments(message)).resolves.toEqual({ - status: "abandoned", - }); - expect(harness.prepareTurnAttachments).not.toHaveBeenCalled(); - expect(remainingMessages()).toEqual([edited]); - }); + expect(yield* prepareQueuedMessageAttachments(message)).toEqual({ + status: "abandoned", + }); + expect(harness.prepareTurnAttachments).not.toHaveBeenCalled(); + expect(remainingMessages()).toEqual([edited]); + }), + ); }); describe("thread outbox drain delivery cleanup", () => { - it("drops caught-up acknowledged rows at the next delivery without subscribing to the thread", async () => { - const first = queuedMessage({ messageId: "awaiting-echo", text: "Delivered" }); - const second = queuedMessage({ messageId: "next-delivery", text: "Also delivered" }); - await harness.manager.enqueue(first); - await harness.manager.enqueue(second); - - await expect( - completeQueuedMessageDelivery(first, harness.manager.revisionOf(first.messageId), 7), - ).resolves.toBe("removed"); - expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([ - { ...first, sequence: 7 }, - ]); - - // The thread applied the message, but its bounded window does not hold it. - appAtomRegistry.set(harness.threadState, { - data: Option.some({ messages: [{ id: "unrelated" }] }), - sequence: 7, - }); - expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toHaveLength(1); - - await expect( - completeQueuedMessageDelivery(second, harness.manager.revisionOf(second.messageId), 9), - ).resolves.toBe("removed"); - expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([ - { ...second, sequence: 9 }, - ]); - }); - - it("drops an acknowledged row once the open thread catches up, so a reload cannot resurrect it", async () => { - const message = queuedMessage({ messageId: "paged-out-later", text: "Delivered" }); - await harness.manager.enqueue(message); - await completeQueuedMessageDelivery(message, harness.manager.revisionOf(message.messageId), 7); - - pruneCaughtUpAcknowledgedThreadMessages( - scopedThreadKey(message.environmentId, message.threadId), - { - sequence: 6, - messages: [], - }, - ); - expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([ - { ...message, sequence: 7 }, - ]); - - pruneCaughtUpAcknowledgedThreadMessages( - scopedThreadKey(message.environmentId, message.threadId), - { - sequence: 7, - messages: [], - }, - ); - expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([]); - }); + it.effect( + "drops caught-up acknowledged rows at the next delivery without subscribing to the thread", + () => + Effect.gen(function* () { + const first = queuedMessage({ messageId: "awaiting-echo", text: "Delivered" }); + const second = queuedMessage({ messageId: "next-delivery", text: "Also delivered" }); + yield* Effect.promise(() => harness.manager.enqueue(first)); + yield* Effect.promise(() => harness.manager.enqueue(second)); + + expect( + yield* completeQueuedMessageDelivery( + first, + harness.manager.revisionOf(first.messageId), + 7, + ), + ).toBe("removed"); + expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([ + { ...first, sequence: 7 }, + ]); + + // The thread applied the message, but its bounded window does not hold it. + appAtomRegistry.set(harness.threadState, { + data: Option.some({ messages: [{ id: "unrelated" }] }), + sequence: 7, + }); + expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toHaveLength(1); + + expect( + yield* completeQueuedMessageDelivery( + second, + harness.manager.revisionOf(second.messageId), + 9, + ), + ).toBe("removed"); + expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([ + { ...second, sequence: 9 }, + ]); + }), + ); - it("removes an acknowledged outbox item even when the sign-out archive write fails", async () => { - const message = queuedMessage({ messageId: "archive-write-failure", text: "Delivered" }); - await harness.manager.enqueue(message); - await composerDrafts.archiveCloudComposerDrafts("account-a", new Set([message.environmentId]), [ - message.environmentId, - ]); - harness.draftFile.setWriteError(new Error("Draft storage unavailable")); - - await expect( - completeQueuedMessageDelivery( - message, - harness.manager.revisionOf(message.messageId), - undefined, - ), - ).resolves.toBe("removed"); - expect(remainingMessages()).toEqual([]); + it.effect( + "drops an acknowledged row once the open thread catches up, so a reload cannot resurrect it", + () => + Effect.gen(function* () { + const message = queuedMessage({ messageId: "paged-out-later", text: "Delivered" }); + yield* Effect.promise(() => harness.manager.enqueue(message)); + yield* completeQueuedMessageDelivery( + message, + harness.manager.revisionOf(message.messageId), + 7, + ); + + pruneCaughtUpAcknowledgedThreadMessages( + scopedThreadKey(message.environmentId, message.threadId), + { + sequence: 6, + messages: [], + }, + ); + expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([ + { ...message, sequence: 7 }, + ]); - harness.draftFile.setWriteError(null); - await composerDrafts.flushComposerDrafts(); - appAtomRegistry.set(composerDrafts.composerCloudDraftsAtom, { accountId: null, signedOut: {} }); - composerDrafts.resetComposerDraftsLoadState(); - await composerDrafts.restoreCloudComposerDrafts("account-a"); - expect(remainingMessages()).toEqual([]); - }); + pruneCaughtUpAcknowledgedThreadMessages( + scopedThreadKey(message.environmentId, message.threadId), + { + sequence: 7, + messages: [], + }, + ); + expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([]); + }), + ); - it.each([false, true])( - "does not restore a message delivered after the sign-out snapshot (outbox already cleared: %s)", - async (cleared) => { - const message = queuedMessage({ - messageId: "delivered-during-sign-out", - text: "Already delivered", - }); - await harness.manager.enqueue(message); - const deliveryRevision = harness.manager.revisionOf(message.messageId); - await composerDrafts.archiveCloudComposerDrafts( - "account-a", - new Set([message.environmentId]), - [message.environmentId], + it.effect("removes an acknowledged outbox item even when the sign-out archive write fails", () => + Effect.gen(function* () { + const message = queuedMessage({ messageId: "archive-write-failure", text: "Delivered" }); + yield* Effect.promise(() => harness.manager.enqueue(message)); + yield* Effect.promise(() => + composerDrafts.archiveCloudComposerDrafts("account-a", new Set([message.environmentId]), [ + message.environmentId, + ]), ); - expect( - appAtomRegistry.get(composerDrafts.composerCloudDraftsAtom).signedOut["account-a"] - ?.queuedMessages, - ).toEqual([message]); + harness.draftFile.setWriteError(new Error("Draft storage unavailable")); - if (cleared) await harness.manager.clearEnvironment(message.environmentId); - await expect( - completeQueuedMessageDelivery(message, deliveryRevision, undefined), - ).resolves.toBe(cleared ? "edited" : "removed"); + expect( + yield* completeQueuedMessageDelivery( + message, + harness.manager.revisionOf(message.messageId), + undefined, + ), + ).toBe("removed"); + expect(remainingMessages()).toEqual([]); + harness.draftFile.setWriteError(null); + yield* Effect.promise(() => composerDrafts.flushComposerDrafts()); appAtomRegistry.set(composerDrafts.composerCloudDraftsAtom, { accountId: null, signedOut: {}, }); composerDrafts.resetComposerDraftsLoadState(); - await composerDrafts.restoreCloudComposerDrafts("account-a"); + yield* Effect.promise(() => composerDrafts.restoreCloudComposerDrafts("account-a")); expect(remainingMessages()).toEqual([]); - }, + }), ); - it("preserves an archived edit when an older payload finishes delivery", async () => { - const message = queuedMessage({ messageId: "edited-during-sign-out", text: "Original" }); - await harness.manager.enqueue(message); - const deliveryRevision = harness.manager.revisionOf(message.messageId); - const edited = { ...message, text: "Keep this edit" }; - await harness.manager.update(edited); - await composerDrafts.archiveCloudComposerDrafts("account-a", new Set([message.environmentId]), [ - message.environmentId, - ]); - await harness.manager.clearEnvironment(message.environmentId); - await expect(completeQueuedMessageDelivery(message, deliveryRevision, undefined)).resolves.toBe( - "edited", - ); - await composerDrafts.restoreCloudComposerDrafts("account-a"); - expect(remainingMessages()).toEqual([edited]); - }); - - it("retries only cleanup after an acknowledged send removal fails", async () => { - const message = queuedMessage({ messageId: "message-acknowledged", text: "delivered" }); - const acknowledged = new Set([message.messageId]); - harness.removeOutboxMessage.mockRejectedValueOnce(new Error("storage unavailable")); - await harness.manager.enqueue(message); - - await expect(removeAcknowledgedExistingThreadMessage(message, acknowledged)).resolves.toBe( - false, - ); - expect(remainingMessages()).toEqual([message]); - expect(acknowledged).toEqual(new Set([message.messageId])); - - await expect(removeAcknowledgedExistingThreadMessage(message, acknowledged)).resolves.toBe( - true, - ); - expect(remainingMessages()).toEqual([]); - expect(acknowledged).toEqual(new Set()); - }); + it.effect.each([false, true])( + "does not restore a message delivered after the sign-out snapshot (outbox already cleared: %s)", + (cleared) => + Effect.gen(function* () { + const message = queuedMessage({ + messageId: "delivered-during-sign-out", + text: "Already delivered", + }); + yield* Effect.promise(() => harness.manager.enqueue(message)); + const deliveryRevision = harness.manager.revisionOf(message.messageId); + yield* Effect.promise(() => + composerDrafts.archiveCloudComposerDrafts("account-a", new Set([message.environmentId]), [ + message.environmentId, + ]), + ); + expect( + appAtomRegistry.get(composerDrafts.composerCloudDraftsAtom).signedOut["account-a"] + ?.queuedMessages, + ).toEqual([message]); + + if (cleared) { + yield* Effect.promise(() => harness.manager.clearEnvironment(message.environmentId)); + } + expect(yield* completeQueuedMessageDelivery(message, deliveryRevision, undefined)).toBe( + cleared ? "edited" : "removed", + ); + + appAtomRegistry.set(composerDrafts.composerCloudDraftsAtom, { + accountId: null, + signedOut: {}, + }); + composerDrafts.resetComposerDraftsLoadState(); + yield* Effect.promise(() => composerDrafts.restoreCloudComposerDrafts("account-a")); + expect(remainingMessages()).toEqual([]); + }), + ); - it("keeps an edited message and its files when delivery cleanup loses the revision race", async () => { - const message = queuedMessage({ - messageId: "message-edited", - text: "original", - fileUri: "file:///documents/t3-composer-attachments/report.pdf", - }); - await harness.manager.enqueue(message); - const deliveryRevision = harness.manager.revisionOf(message.messageId); - const edited = { ...message, text: "edited while the turn delivered" }; - await harness.manager.update(edited); + it.effect("preserves an archived edit when an older payload finishes delivery", () => + Effect.gen(function* () { + const message = queuedMessage({ messageId: "edited-during-sign-out", text: "Original" }); + yield* Effect.promise(() => harness.manager.enqueue(message)); + const deliveryRevision = harness.manager.revisionOf(message.messageId); + const edited = { ...message, text: "Keep this edit" }; + yield* Effect.promise(() => harness.manager.update(edited)); + yield* Effect.promise(() => + composerDrafts.archiveCloudComposerDrafts("account-a", new Set([message.environmentId]), [ + message.environmentId, + ]), + ); + yield* Effect.promise(() => harness.manager.clearEnvironment(message.environmentId)); + expect(yield* completeQueuedMessageDelivery(message, deliveryRevision, undefined)).toBe( + "edited", + ); + yield* Effect.promise(() => composerDrafts.restoreCloudComposerDrafts("account-a")); + expect(remainingMessages()).toEqual([edited]); + }), + ); - await expect(completeQueuedMessageDelivery(message, deliveryRevision, undefined)).resolves.toBe( - "edited", - ); + it.effect("retries only cleanup after an acknowledged send removal fails", () => + Effect.gen(function* () { + const message = queuedMessage({ messageId: "message-acknowledged", text: "delivered" }); + const acknowledged = new Set([message.messageId]); + harness.removeOutboxMessage.mockRejectedValueOnce(new Error("storage unavailable")); + yield* Effect.promise(() => harness.manager.enqueue(message)); - expect(remainingMessages()).toEqual([edited]); - expect(harness.removePersistedFile).not.toHaveBeenCalled(); - }); - - it("removes the delivered message when no edit was accepted", async () => { - const message = queuedMessage({ messageId: "message-clean", text: "hello" }); - await harness.manager.enqueue(message); - const deliveryRevision = harness.manager.revisionOf(message.messageId); + expect(yield* handled(removeAcknowledgedExistingThreadMessage(message, acknowledged))).toBe( + false, + ); + expect(remainingMessages()).toEqual([message]); + expect(acknowledged).toEqual(new Set([message.messageId])); - await expect(completeQueuedMessageDelivery(message, deliveryRevision, undefined)).resolves.toBe( - "removed", - ); + expect(yield* handled(removeAcknowledgedExistingThreadMessage(message, acknowledged))).toBe( + true, + ); + expect(remainingMessages()).toEqual([]); + expect(acknowledged).toEqual(new Set()); + }), + ); - expect(remainingMessages()).toEqual([]); - expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([message]); - }); + it.effect( + "keeps an edited message and its files when delivery cleanup loses the revision race", + () => + Effect.gen(function* () { + const message = queuedMessage({ + messageId: "message-edited", + text: "original", + fileUri: "file:///documents/t3-composer-attachments/report.pdf", + }); + yield* Effect.promise(() => harness.manager.enqueue(message)); + const deliveryRevision = harness.manager.revisionOf(message.messageId); + const edited = { ...message, text: "edited while the turn delivered" }; + yield* Effect.promise(() => harness.manager.update(edited)); + + expect(yield* completeQueuedMessageDelivery(message, deliveryRevision, undefined)).toBe( + "edited", + ); + + expect(remainingMessages()).toEqual([edited]); + expect(harness.removePersistedFile).not.toHaveBeenCalled(); + }), + ); - it("keeps a delivered message when its editor opens during storage removal", async () => { - const message = queuedMessage({ - messageId: "message-editor-removal-race", - text: "keep editor changes", - fileUri: "file:///documents/t3-composer-attachments/editor-race.pdf", - }); - const removeStarted = Promise.withResolvers(); - const removeBarrier = Promise.withResolvers(); - harness.removeOutboxMessage.mockImplementationOnce(async () => { - removeStarted.resolve(); - await removeBarrier.promise; - }); - await harness.manager.enqueue(message); - const deliveryRevision = harness.manager.revisionOf(message.messageId); + it.effect("removes the delivered message when no edit was accepted", () => + Effect.gen(function* () { + const message = queuedMessage({ messageId: "message-clean", text: "hello" }); + yield* Effect.promise(() => harness.manager.enqueue(message)); + const deliveryRevision = harness.manager.revisionOf(message.messageId); - const cleanup = completeQueuedMessageDelivery(message, deliveryRevision, undefined); - await removeStarted.promise; - appAtomRegistry.set(editingQueuedMessageIdsAtom, { [message.messageId]: true }); - removeBarrier.resolve(); + expect(yield* completeQueuedMessageDelivery(message, deliveryRevision, undefined)).toBe( + "removed", + ); - await expect(cleanup).resolves.toBe("edited"); - expect(remainingMessages()).toEqual([message]); - expect(harness.removePersistedFile).not.toHaveBeenCalled(); - }); -}); + expect(remainingMessages()).toEqual([]); + expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([message]); + }), + ); -describe("thread outbox delivered creation recovery", () => { - it("keeps an edit accepted while the older payload is persisted to the draft", async () => { - const message = queuedMessage({ - messageId: "message-recovery-race", - text: "original queued text", - fileUri: "file:///documents/t3-composer-attachments/report.pdf", - }); - const originalMergeComposerDraftContent = composerDrafts.mergeComposerDraftContent; - const mergeCompleted = Promise.withResolvers(); - const releaseRecovery = Promise.withResolvers(); - const mergeSpy = vi - .spyOn(composerDrafts, "mergeComposerDraftContent") - .mockImplementation(async (draftKey, content) => { - const result = await originalMergeComposerDraftContent(draftKey, content); - mergeCompleted.resolve(); - await releaseRecovery.promise; - return result; + it.effect("keeps a delivered message when its editor opens during storage removal", () => + Effect.gen(function* () { + const message = queuedMessage({ + messageId: "message-editor-removal-race", + text: "keep editor changes", + fileUri: "file:///documents/t3-composer-attachments/editor-race.pdf", }); - - try { - await harness.manager.enqueue(message); - const recovery = recoverEditedCreationAfterDelivery(message); - await mergeCompleted.promise; - - const newer = { ...message, text: "edited while recovery persisted the draft" }; - await harness.manager.update(newer); - - releaseRecovery.resolve(); - await expect(recovery).resolves.toBe(false); - - expect(remainingMessages()).toEqual([newer]); - expect( - composerDrafts.getComposerDraftSnapshot(`${message.environmentId}:${message.threadId}`), - ).toMatchObject({ text: message.text, attachments: [] }); - expect(harness.removePersistedFile).not.toHaveBeenCalled(); - } finally { - releaseRecovery.resolve(); - mergeSpy.mockRestore(); - } - }); - - it("leaves recovery to an editor that opens while the draft persists", async () => { - const message = queuedMessage({ - messageId: "message-recovery-editor", - text: "recover this text", - fileUri: "file:///documents/t3-composer-attachments/editor.pdf", - }); - const originalMergeComposerDraftContent = composerDrafts.mergeComposerDraftContent; - const mergeCompleted = Promise.withResolvers(); - const releaseRecovery = Promise.withResolvers(); - const mergeSpy = vi - .spyOn(composerDrafts, "mergeComposerDraftContent") - .mockImplementation(async (draftKey, content) => { - const result = await originalMergeComposerDraftContent(draftKey, content); - mergeCompleted.resolve(); - await releaseRecovery.promise; - return result; + const removeStarted = Promise.withResolvers(); + const removeBarrier = Promise.withResolvers(); + harness.removeOutboxMessage.mockImplementationOnce(async () => { + removeStarted.resolve(); + await removeBarrier.promise; }); + yield* Effect.promise(() => harness.manager.enqueue(message)); + const deliveryRevision = harness.manager.revisionOf(message.messageId); - try { - await harness.manager.enqueue(message); - const recovery = recoverEditedCreationAfterDelivery(message); - await mergeCompleted.promise; + const cleanup = yield* Effect.forkChild( + completeQueuedMessageDelivery(message, deliveryRevision, undefined), + { startImmediately: true }, + ); + yield* Effect.promise(() => removeStarted.promise); appAtomRegistry.set(editingQueuedMessageIdsAtom, { [message.messageId]: true }); + removeBarrier.resolve(); - releaseRecovery.resolve(); - await expect(recovery).resolves.toBe(true); - + expect(yield* Fiber.join(cleanup)).toBe("edited"); expect(remainingMessages()).toEqual([message]); - expect( - composerDrafts.getComposerDraftSnapshot(`${message.environmentId}:${message.threadId}`), - ).toMatchObject({ text: message.text, attachments: [] }); expect(harness.removePersistedFile).not.toHaveBeenCalled(); - } finally { - releaseRecovery.resolve(); - mergeSpy.mockRestore(); - } - }); - - it("retries a failed removal without duplicating recovered draft content", async () => { - const message = queuedMessage({ - messageId: "message-recovery-removal", - text: "recover once", - fileUri: "file:///documents/t3-composer-attachments/retry.pdf", - }); - const draftKey = `${message.environmentId}:${message.threadId}`; - const removeSpy = vi - .spyOn(harness.manager, "remove") - .mockRejectedValueOnce(new Error("storage unavailable")); + }), + ); +}); - try { - await harness.manager.enqueue(message); +describe("thread outbox delivered creation recovery", () => { + it.effect("keeps an edit accepted while the older payload is persisted to the draft", () => + Effect.gen(function* () { + const message = queuedMessage({ + messageId: "message-recovery-race", + text: "original queued text", + fileUri: "file:///documents/t3-composer-attachments/report.pdf", + }); + const originalMergeComposerDraftContent = composerDrafts.mergeComposerDraftContent; + const mergeCompleted = Promise.withResolvers(); + const releaseRecovery = Promise.withResolvers(); + const mergeSpy = vi + .spyOn(composerDrafts, "mergeComposerDraftContent") + .mockImplementation(async (draftKey, content) => { + const result = await originalMergeComposerDraftContent(draftKey, content); + mergeCompleted.resolve(); + await releaseRecovery.promise; + return result; + }); + + try { + yield* Effect.promise(() => harness.manager.enqueue(message)); + const recovery = yield* Effect.forkChild( + handled(recoverEditedCreationAfterDelivery(message)), + { startImmediately: true }, + ); + yield* Effect.promise(() => mergeCompleted.promise); + + const newer = { ...message, text: "edited while recovery persisted the draft" }; + yield* Effect.promise(() => harness.manager.update(newer)); + + releaseRecovery.resolve(); + expect(yield* Fiber.join(recovery)).toBe(false); + + expect(remainingMessages()).toEqual([newer]); + expect( + composerDrafts.getComposerDraftSnapshot(`${message.environmentId}:${message.threadId}`), + ).toMatchObject({ text: message.text, attachments: [] }); + expect(harness.removePersistedFile).not.toHaveBeenCalled(); + } finally { + releaseRecovery.resolve(); + mergeSpy.mockRestore(); + } + }), + ); - await expect(recoverEditedCreationAfterDelivery(message)).resolves.toBe(false); - expect(remainingMessages()).toEqual([message]); + it.effect("leaves recovery to an editor that opens while the draft persists", () => + Effect.gen(function* () { + const message = queuedMessage({ + messageId: "message-recovery-editor", + text: "recover this text", + fileUri: "file:///documents/t3-composer-attachments/editor.pdf", + }); + const originalMergeComposerDraftContent = composerDrafts.mergeComposerDraftContent; + const mergeCompleted = Promise.withResolvers(); + const releaseRecovery = Promise.withResolvers(); + const mergeSpy = vi + .spyOn(composerDrafts, "mergeComposerDraftContent") + .mockImplementation(async (draftKey, content) => { + const result = await originalMergeComposerDraftContent(draftKey, content); + mergeCompleted.resolve(); + await releaseRecovery.promise; + return result; + }); + + try { + yield* Effect.promise(() => harness.manager.enqueue(message)); + const recovery = yield* Effect.forkChild( + handled(recoverEditedCreationAfterDelivery(message)), + { startImmediately: true }, + ); + yield* Effect.promise(() => mergeCompleted.promise); + appAtomRegistry.set(editingQueuedMessageIdsAtom, { [message.messageId]: true }); - await expect(recoverEditedCreationAfterDelivery(message)).resolves.toBe(true); + releaseRecovery.resolve(); + expect(yield* Fiber.join(recovery)).toBe(true); + + expect(remainingMessages()).toEqual([message]); + expect( + composerDrafts.getComposerDraftSnapshot(`${message.environmentId}:${message.threadId}`), + ).toMatchObject({ text: message.text, attachments: [] }); + expect(harness.removePersistedFile).not.toHaveBeenCalled(); + } finally { + releaseRecovery.resolve(); + mergeSpy.mockRestore(); + } + }), + ); - const draft = composerDrafts.getComposerDraftSnapshot(draftKey); - expect(draft.text).toBe(message.text); - expect(draft.attachments).toEqual(message.attachments); - expect(remainingMessages()).toEqual([]); - expect(harness.removePersistedFile).not.toHaveBeenCalled(); - } finally { - removeSpy.mockRestore(); - } - }); + it.effect("retries a failed removal without duplicating recovered draft content", () => + Effect.gen(function* () { + const message = queuedMessage({ + messageId: "message-recovery-removal", + text: "recover once", + fileUri: "file:///documents/t3-composer-attachments/retry.pdf", + }); + const draftKey = `${message.environmentId}:${message.threadId}`; + const removeSpy = vi + .spyOn(harness.manager, "remove") + .mockRejectedValueOnce(new Error("storage unavailable")); + + try { + yield* Effect.promise(() => harness.manager.enqueue(message)); + + expect(yield* handled(recoverEditedCreationAfterDelivery(message))).toBe(false); + expect(remainingMessages()).toEqual([message]); + + expect(yield* handled(recoverEditedCreationAfterDelivery(message))).toBe(true); + + const draft = composerDrafts.getComposerDraftSnapshot(draftKey); + expect(draft.text).toBe(message.text); + expect(draft.attachments).toEqual(message.attachments); + expect(remainingMessages()).toEqual([]); + expect(harness.removePersistedFile).not.toHaveBeenCalled(); + } finally { + removeSpy.mockRestore(); + } + }), + ); - it("keeps the queue entry when the recovered draft cannot persist", async () => { - const message = queuedMessage({ - messageId: "message-recovery-persistence", - text: "recover after persistence returns", - }); - await harness.manager.enqueue(message); - harness.draftFile.setWriteError(new Error("disk full")); + it.effect("keeps the queue entry when the recovered draft cannot persist", () => + Effect.gen(function* () { + const message = queuedMessage({ + messageId: "message-recovery-persistence", + text: "recover after persistence returns", + }); + yield* Effect.promise(() => harness.manager.enqueue(message)); + harness.draftFile.setWriteError(new Error("disk full")); - await expect(recoverEditedCreationAfterDelivery(message)).resolves.toBe(false); + expect(yield* handled(recoverEditedCreationAfterDelivery(message))).toBe(false); - expect(remainingMessages()).toEqual([message]); - }); + expect(remainingMessages()).toEqual([message]); + }), + ); }); describe("thread outbox recovery rollback", () => { @@ -728,111 +806,121 @@ describe("thread outbox recovery rollback", () => { ); }); - it("restores a rejected new task as its own draft for the project", async () => { - const message: QueuedThreadMessage = { - ...queuedMessage({ messageId: "message-creation-restore", text: "new task text" }), - modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.6-sol" }, - creation: { - projectId: ProjectId.make("project-1"), - workspaceMode: "local", - branch: null, - worktreePath: null, - }, - }; - await harness.manager.enqueue(message); - - await expect(restoreRejectedQueuedMessage(message, "rejected by server")).resolves.toBe( - "restored", - ); + it.effect("restores a rejected new task as its own draft for the project", () => + Effect.gen(function* () { + const message: QueuedThreadMessage = { + ...queuedMessage({ messageId: "message-creation-restore", text: "new task text" }), + modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.6-sol" }, + creation: { + projectId: ProjectId.make("project-1"), + workspaceMode: "local", + branch: null, + worktreePath: null, + }, + }; + yield* Effect.promise(() => harness.manager.enqueue(message)); + + expect(yield* restoreRejectedQueuedMessage(message, "rejected by server")).toBe("restored"); - expect( - composerDrafts.getComposerDraftSnapshot(`new-task:restored-${message.messageId}`), - ).toMatchObject({ - text: message.text, - attachments: message.attachments, - modelSelection: message.modelSelection, - project: { - environmentId: message.environmentId, - projectId: message.creation!.projectId, - createdAt: message.createdAt, - }, - }); - expect(remainingMessages()).toEqual([]); - expect(appAtomRegistry.get(threadComposerErrorsAtom)).toEqual({}); - expect( - appAtomRegistry.get(pendingThreadCreationOutcomesAtom)[ - `${message.environmentId}:${message.threadId}` - ], - ).toEqual({ kind: "failed", message, reason: "rejected by server" }); - }); + expect( + composerDrafts.getComposerDraftSnapshot(`new-task:restored-${message.messageId}`), + ).toMatchObject({ + text: message.text, + attachments: message.attachments, + modelSelection: message.modelSelection, + project: { + environmentId: message.environmentId, + projectId: message.creation!.projectId, + createdAt: message.createdAt, + }, + }); + expect(remainingMessages()).toEqual([]); + expect(appAtomRegistry.get(threadComposerErrorsAtom)).toEqual({}); + expect( + appAtomRegistry.get(pendingThreadCreationOutcomesAtom)[ + `${message.environmentId}:${message.threadId}` + ], + ).toEqual({ kind: "failed", message, reason: "rejected by server" }); + }), + ); - it("does not record a creation outcome for a rejected follow-up message", async () => { - const message = queuedMessage({ messageId: "message-followup-restore", text: "follow up" }); - await harness.manager.enqueue(message); + it.effect("does not record a creation outcome for a rejected follow-up message", () => + Effect.gen(function* () { + const message = queuedMessage({ messageId: "message-followup-restore", text: "follow up" }); + yield* Effect.promise(() => harness.manager.enqueue(message)); - await expect(restoreRejectedQueuedMessage(message, "rejected")).resolves.toBe("restored"); + expect(yield* restoreRejectedQueuedMessage(message, "rejected")).toBe("restored"); - expect(appAtomRegistry.get(pendingThreadCreationOutcomesAtom)).toEqual({}); - expect( - appAtomRegistry.get(threadComposerErrorsAtom)[`${message.environmentId}:${message.threadId}`], - ).toEqual({ message: "rejected", messageId: message.messageId }); - }); + expect(appAtomRegistry.get(pendingThreadCreationOutcomesAtom)).toEqual({}); + expect( + appAtomRegistry.get(threadComposerErrorsAtom)[ + `${message.environmentId}:${message.threadId}` + ], + ).toEqual({ message: "rejected", messageId: message.messageId }); + }), + ); - it("leaves no error when the restored text is resent before recovery finishes", async () => { - const message = queuedMessage({ messageId: "message-resent", text: "resend me" }); - const threadKey = `${message.environmentId}:${message.threadId}`; - await harness.manager.enqueue(message); - const unsubscribe = appAtomRegistry.subscribe(composerDrafts.composerDraftsAtom, (drafts) => { - if (drafts[threadKey]?.text === "resend me") { - unsubscribe(); - clearThreadComposerError(threadKey); - void composerDrafts.clearComposerDraftContent(threadKey); - } - }); + it.effect("leaves no error when the restored text is resent before recovery finishes", () => + Effect.gen(function* () { + const message = queuedMessage({ messageId: "message-resent", text: "resend me" }); + const threadKey = `${message.environmentId}:${message.threadId}`; + yield* Effect.promise(() => harness.manager.enqueue(message)); + const unsubscribe = appAtomRegistry.subscribe(composerDrafts.composerDraftsAtom, (drafts) => { + if (drafts[threadKey]?.text === "resend me") { + unsubscribe(); + clearThreadComposerError(threadKey); + void composerDrafts.clearComposerDraftContent(threadKey); + } + }); - await expect(restoreRejectedQueuedMessage(message, "rejected")).resolves.toBe("restored"); + expect(yield* restoreRejectedQueuedMessage(message, "rejected")).toBe("restored"); - expect(appAtomRegistry.get(threadComposerErrorsAtom)).toEqual({}); - }); + expect(appAtomRegistry.get(threadComposerErrorsAtom)).toEqual({}); + }), + ); - it("withdraws the error when an edit makes the recovery back out", async () => { - const message = queuedMessage({ messageId: "message-edited-mid-recovery", text: "edit me" }); - const threadKey = `${message.environmentId}:${message.threadId}`; - await harness.manager.enqueue(message); - const unsubscribe = appAtomRegistry.subscribe(composerDrafts.composerDraftsAtom, (drafts) => { - if (drafts[threadKey]?.text === "edit me") { - unsubscribe(); - appAtomRegistry.set(editingQueuedMessageIdsAtom, { [message.messageId]: true }); - } - }); + it.effect("withdraws the error when an edit makes the recovery back out", () => + Effect.gen(function* () { + const message = queuedMessage({ messageId: "message-edited-mid-recovery", text: "edit me" }); + const threadKey = `${message.environmentId}:${message.threadId}`; + yield* Effect.promise(() => harness.manager.enqueue(message)); + const unsubscribe = appAtomRegistry.subscribe(composerDrafts.composerDraftsAtom, (drafts) => { + if (drafts[threadKey]?.text === "edit me") { + unsubscribe(); + appAtomRegistry.set(editingQueuedMessageIdsAtom, { [message.messageId]: true }); + } + }); - await expect(restoreRejectedQueuedMessage(message, "rejected")).resolves.toBe("deferred"); + expect(yield* restoreRejectedQueuedMessage(message, "rejected")).toBe("deferred"); - expect(appAtomRegistry.get(threadComposerErrorsAtom)).toEqual({}); - expect(remainingMessages()).toEqual([message]); - }); + expect(appAtomRegistry.get(threadComposerErrorsAtom)).toEqual({}); + expect(remainingMessages()).toEqual([message]); + }), + ); - it("rolls a failed recovery merge back so the retry cannot duplicate the text", async () => { - const message = queuedMessage({ messageId: "message-restore", text: "queued text" }); - const draftKey = `${message.environmentId}:${message.threadId}`; - appAtomRegistry.set(composerDrafts.composerDraftsAtom, { - [draftKey]: { text: "typed offline", attachments: [] }, - }); - await harness.manager.enqueue(message); + it.effect("rolls a failed recovery merge back so the retry cannot duplicate the text", () => + Effect.gen(function* () { + const message = queuedMessage({ messageId: "message-restore", text: "queued text" }); + const draftKey = `${message.environmentId}:${message.threadId}`; + appAtomRegistry.set(composerDrafts.composerDraftsAtom, { + [draftKey]: { text: "typed offline", attachments: [] }, + }); + yield* Effect.promise(() => harness.manager.enqueue(message)); - harness.draftFile.setWriteError(new Error("disk full")); - await expect(restoreRejectedQueuedMessage(message, "too large")).resolves.toBe("retry"); + harness.draftFile.setWriteError(new Error("disk full")); + expect(yield* restoreRejectedQueuedMessage(message, "too large")).toBe("retry"); - expect(composerDrafts.getComposerDraftSnapshot(draftKey).text).toBe("typed offline"); - expect(remainingMessages()).toEqual([message]); + expect(composerDrafts.getComposerDraftSnapshot(draftKey).text).toBe("typed offline"); + expect(remainingMessages()).toEqual([message]); - harness.draftFile.setWriteError(null); - await expect(restoreRejectedQueuedMessage(message, "too large")).resolves.toBe("restored"); + harness.draftFile.setWriteError(null); + expect(yield* restoreRejectedQueuedMessage(message, "too large")).toBe("restored"); - expect(composerDrafts.getComposerDraftSnapshot(draftKey).text).toBe( - "typed offline\n\nqueued text", - ); - expect(remainingMessages()).toEqual([]); - expect(appAtomRegistry.get(threadComposerErrorsAtom)[draftKey]?.message).toBe("too large"); - }); + expect(composerDrafts.getComposerDraftSnapshot(draftKey).text).toBe( + "typed offline\n\nqueued text", + ); + expect(remainingMessages()).toEqual([]); + expect(appAtomRegistry.get(threadComposerErrorsAtom)[draftKey]?.message).toBe("too large"); + }), + ); }); diff --git a/apps/mobile/src/state/threadOutboxDelivery.ts b/apps/mobile/src/state/threadOutboxDelivery.ts index 59617bccc84c8..52eb689394feb 100644 --- a/apps/mobile/src/state/threadOutboxDelivery.ts +++ b/apps/mobile/src/state/threadOutboxDelivery.ts @@ -25,15 +25,18 @@ import { buildTemporaryWorktreeBranchName } from "@t3tools/shared/git"; import * as Cause from "effect/Cause"; import * as Clock from "effect/Clock"; import * as Effect from "effect/Effect"; +import * as Exit from "effect/Exit"; import * as Fiber from "effect/Fiber"; import * as Latch from "effect/Latch"; +import * as Schema from "effect/Schema"; import { AsyncResult, Atom } from "effect/reactivity"; import { createDebugLogger } from "../lib/debugLog"; +import type { DraftComposerAttachment } from "../lib/composerImages"; import { scopedThreadKey } from "../lib/scopedEntities"; import { buildProjectThreadStartTurnInput } from "../lib/projectThreadStartTurn"; import { serializeComposerMessageForServer, uploadedComposerContext } from "../lib/composerContext"; -import { prepareTurnAttachments, type PreparedTurnAttachments } from "../lib/attachmentUpload"; +import { prepareTurnAttachments } from "../lib/attachmentUpload"; import { randomHex } from "../lib/uuid"; import { describeUnavailableModelSelection, @@ -213,57 +216,66 @@ function settingsCommandId(message: QueuedThreadMessage, setting: string): Comma return CommandId.make(`${message.commandId}:${setting}`); } -export async function prepareQueuedMessageAttachments(queuedMessage: QueuedThreadMessage): Promise< - | { - readonly status: "ready"; - readonly prepared: PreparedTurnAttachments; - readonly persistedMessage: QueuedThreadMessage; - readonly deliveryRevision: number; +/** Outbox or draft storage refused a step; the step decides what that means for the message. */ +class ThreadOutboxStorageError extends Schema.TaggedError()( + "ThreadOutboxStorageError", + { cause: Schema.Defect() }, +) {} + +const storage = (write: () => Promise) => + Effect.tryPromise({ try: write, catch: (cause) => new ThreadOutboxStorageError({ cause }) }); + +/** The head was not handled; back off and try it again. */ +export class DeliveryRetry extends Schema.TaggedError()("DeliveryRetry", {}) {} + +const retryDelivery = Effect.fail(new DeliveryRetry()); + +const isEditingQueuedMessage = (messageId: MessageId): boolean => + appAtomRegistry.get(editingQueuedMessageIdsAtom)[messageId] === true; + +const confirmQueued = (message: QueuedThreadMessage) => + Effect.promise(() => confirmThreadOutboxMessageQueued(message)); + +const abandoned = { status: "abandoned" } as const; + +export const prepareQueuedMessageAttachments = Effect.fn("ThreadOutbox.prepareAttachments")( + function* (queuedMessage: QueuedThreadMessage) { + if (!(yield* confirmQueued(queuedMessage))) return abandoned; + if (!readEnvironmentScope(queuedMessage.environmentId, AuthOrchestrationOperateScope)) { + return abandoned; } - | { readonly status: "abandoned" } -> { - if (!(await confirmThreadOutboxMessageQueued(queuedMessage))) { - return { status: "abandoned" }; - } - if (!readEnvironmentScope(queuedMessage.environmentId, AuthOrchestrationOperateScope)) { - return { status: "abandoned" }; - } - const revision = threadOutboxRevision(queuedMessage.messageId); - if (!isQueuedMessagePayloadCurrent(queuedMessage, revision)) { - return { status: "abandoned" }; - } - let persistedMessage = queuedMessage; - let deliveryRevision = revision; - const result = await Effect.runPromise( - prepareTurnAttachments({ + const revision = threadOutboxRevision(queuedMessage.messageId); + if (!isQueuedMessagePayloadCurrent(queuedMessage, revision)) return abandoned; + let persistedMessage = queuedMessage; + let deliveryRevision = revision; + const result = yield* prepareTurnAttachments({ environmentId: queuedMessage.environmentId, attachments: queuedMessage.attachments, supportsImageUploads: true, uploadAttachment: (attachment) => uploadComposerAttachmentShared(queuedMessage.environmentId, attachment), - persistUploadedReferences: (draftAttachments) => - Effect.promise(async () => { - if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]) { - return "abandon" as const; - } - const updatedMessage = { ...queuedMessage, attachments: draftAttachments }; - if (!(await updateThreadOutboxMessage(updatedMessage, revision))) { - return "abandon" as const; - } - persistedMessage = updatedMessage; - deliveryRevision = revision + 1; - return "persisted" as const; - }), - }), - ); - if ( - result.status === "abandoned" || - !isQueuedMessagePayloadCurrent(persistedMessage, deliveryRevision) - ) { - return { status: "abandoned" }; - } - return { status: "ready", prepared: result, persistedMessage, deliveryRevision }; -} + persistUploadedReferences: Effect.fn("ThreadOutbox.persistUploadedReferences")(function* ( + draftAttachments: ReadonlyArray, + ) { + if (isEditingQueuedMessage(queuedMessage.messageId)) return "abandon" as const; + const updatedMessage = { ...queuedMessage, attachments: draftAttachments }; + if (!(yield* Effect.promise(() => updateThreadOutboxMessage(updatedMessage, revision)))) { + return "abandon" as const; + } + persistedMessage = updatedMessage; + deliveryRevision = revision + 1; + return "persisted" as const; + }), + }); + if ( + result.status === "abandoned" || + !isQueuedMessagePayloadCurrent(persistedMessage, deliveryRevision) + ) { + return abandoned; + } + return { status: "ready", prepared: result, persistedMessage, deliveryRevision } as const; + }, +); function isQueuedMessagePayloadCurrent( message: QueuedThreadMessage, @@ -277,273 +289,273 @@ function isQueuedMessagePayloadCurrent( ); } -export async function completeQueuedMessageDelivery( +const forgetCloudQueuedMessage = (queuedMessage: QueuedThreadMessage) => + storage(() => removeDeliveredCloudQueuedMessage(queuedMessage)).pipe( + Effect.catch((error) => + Effect.logWarning("[thread-outbox] could not update sign-out snapshot after delivery", { + messageId: queuedMessage.messageId, + error: error.cause, + }), + ), + ); + +export const completeQueuedMessageDelivery = Effect.fn("ThreadOutbox.completeDelivery")(function* ( queuedMessage: QueuedThreadMessage, deliveryRevision: number, - sequence: number | undefined, -): Promise<"removed" | "edited" | "failed"> { + sequence?: number, +) { clearThreadComposerError( scopedThreadKey(queuedMessage.environmentId, queuedMessage.threadId), queuedMessage.messageId, ); - try { - await removeDeliveredCloudQueuedMessage(queuedMessage).catch((error) => { - console.warn("[thread-outbox] could not update sign-out snapshot after delivery", { - messageId: queuedMessage.messageId, - error, - }); - }); - // Editors can acquire entries during startTurn without bumping revisions; CAS alone would lose unsaved edits. - if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]) { - return "edited"; - } - retainAcknowledgedThreadMessage( - sequence === undefined ? queuedMessage : { ...queuedMessage, sequence }, - ); - const removed = await removeThreadOutboxMessage( + yield* forgetCloudQueuedMessage(queuedMessage); + // Editors can acquire entries during startTurn without bumping revisions; CAS alone would lose unsaved edits. + if (isEditingQueuedMessage(queuedMessage.messageId)) return "edited" as const; + retainAcknowledgedThreadMessage( + sequence === undefined ? queuedMessage : { ...queuedMessage, sequence }, + ); + const removed = yield* storage(() => + removeThreadOutboxMessage( queuedMessage, deliveryRevision, - () => !appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId], - ); - if (!removed) { - forgetAcknowledgedThreadMessage(queuedMessage); - threadOutboxDebug.log("delivered message was edited before cleanup", { + () => !isEditingQueuedMessage(queuedMessage.messageId), + ), + ).pipe( + Effect.catch((error) => + Effect.logWarning("[thread-outbox] failed to remove delivered queued message", { environmentId: queuedMessage.environmentId, threadId: queuedMessage.threadId, messageId: queuedMessage.messageId, - }); - return "edited"; - } - return "removed"; - } catch (error) { - forgetAcknowledgedThreadMessage(queuedMessage); - console.warn("[thread-outbox] failed to remove delivered queued message", { - environmentId: queuedMessage.environmentId, - threadId: queuedMessage.threadId, - messageId: queuedMessage.messageId, - error, - }); - return "failed"; - } -} + error: error.cause, + }).pipe(Effect.as(null)), + ), + ); + if (removed === true) return "removed" as const; + forgetAcknowledgedThreadMessage(queuedMessage); + if (removed === null) return "failed" as const; + threadOutboxDebug.log("delivered message was edited before cleanup", { + environmentId: queuedMessage.environmentId, + threadId: queuedMessage.threadId, + messageId: queuedMessage.messageId, + }); + return "edited" as const; +}); -export async function removeAcknowledgedExistingThreadMessage( - queuedMessage: QueuedThreadMessage, - acknowledgedMessageIds: Set, -): Promise { - try { - await removeDeliveredCloudQueuedMessage(queuedMessage).catch((error) => { - console.warn("[thread-outbox] could not update sign-out snapshot after delivery", { +export const removeAcknowledgedExistingThreadMessage = Effect.fn( + "ThreadOutbox.removeAcknowledgedMessage", +)(function* (queuedMessage: QueuedThreadMessage, acknowledgedMessageIds: Set) { + yield* forgetCloudQueuedMessage(queuedMessage); + const removed = yield* storage(() => removeThreadOutboxMessage(queuedMessage)).pipe( + Effect.catch((error) => + Effect.logWarning("[thread-outbox] failed to remove acknowledged queued message", { + environmentId: queuedMessage.environmentId, + threadId: queuedMessage.threadId, messageId: queuedMessage.messageId, - error, - }); - }); - const removed = await removeThreadOutboxMessage(queuedMessage); - if (removed) { - acknowledgedMessageIds.delete(queuedMessage.messageId); - } - return removed; - } catch (error) { - console.warn("[thread-outbox] failed to remove acknowledged queued message", { - environmentId: queuedMessage.environmentId, - threadId: queuedMessage.threadId, - messageId: queuedMessage.messageId, - error, - }); - return false; - } -} + error: error.cause, + }).pipe(Effect.as(false)), + ), + ); + if (!removed) return yield* retryDelivery; + acknowledgedMessageIds.delete(queuedMessage.messageId); +}); -export async function recoverEditedCreationAfterDelivery( - queuedMessage: QueuedThreadMessage, -): Promise { - const kept = Object.values(appAtomRegistry.get(threadOutboxManager.queuedMessagesByThreadKeyAtom)) - .flat() - .find((candidate) => candidate.messageId === queuedMessage.messageId); - if (!kept) { - return true; - } - const keptRevision = threadOutboxRevision(kept.messageId); - if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[kept.messageId]) { - return true; - } - const draftKey = scopedThreadKey(kept.environmentId, kept.threadId); - try { - // Merge before removal to retain file ownership; allow overflow and let send guards require trimming. - await mergeComposerDraftContent(draftKey, { - text: kept.text, - context: kept.context, - attachments: [], - }); - if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[kept.messageId]) { - return true; - } - if (threadOutboxRevision(kept.messageId) !== keptRevision) { - return false; - } - const existingAttachmentIds = new Set( - getComposerDraftSnapshot(draftKey).attachments.map((attachment) => attachment.id), - ); - appendComposerDraftAttachments( - draftKey, - kept.attachments.filter((attachment) => !existingAttachmentIds.has(attachment.id)), - { restore: true }, +/** Hands a new task edited after its launch back to the composer, then drops it from the queue. */ +export const recoverEditedCreationAfterDelivery = Effect.fn("ThreadOutbox.recoverEditedCreation")( + function* (queuedMessage: QueuedThreadMessage) { + const kept = Object.values( + appAtomRegistry.get(threadOutboxManager.queuedMessagesByThreadKeyAtom), + ) + .flat() + .find((candidate) => candidate.messageId === queuedMessage.messageId); + if (!kept || isEditingQueuedMessage(kept.messageId)) return; + const keptRevision = threadOutboxRevision(kept.messageId); + const draftKey = scopedThreadKey(kept.environmentId, kept.threadId); + const handedBack = yield* Effect.gen(function* () { + // Merge before removal to retain file ownership; allow overflow and let send guards require trimming. + yield* storage(() => + mergeComposerDraftContent(draftKey, { + text: kept.text, + context: kept.context, + attachments: [], + }), + ); + if (isEditingQueuedMessage(kept.messageId)) return "edited" as const; + if (threadOutboxRevision(kept.messageId) !== keptRevision) return "changed" as const; + const existingAttachmentIds = new Set( + getComposerDraftSnapshot(draftKey).attachments.map((attachment) => attachment.id), + ); + appendComposerDraftAttachments( + draftKey, + kept.attachments.filter((attachment) => !existingAttachmentIds.has(attachment.id)), + { restore: true }, + ); + updateComposerDraftSettings(draftKey, { + ...(kept.modelSelection !== undefined ? { modelSelection: kept.modelSelection } : {}), + ...(kept.runtimeMode !== undefined ? { runtimeMode: kept.runtimeMode } : {}), + ...(kept.interactionMode !== undefined ? { interactionMode: kept.interactionMode } : {}), + }); + // Flush before removal: append only schedules persistence, leaving the queue as the sole durable copy. + yield* storage(() => flushComposerDrafts()); + return "handed-back" as const; + }).pipe( + Effect.catch((error) => + Effect.logWarning( + "[thread-outbox] could not hand an edited pending task to the composer", + error.cause, + ).pipe(Effect.as("failed" as const)), + ), ); - updateComposerDraftSettings(draftKey, { - ...(kept.modelSelection !== undefined ? { modelSelection: kept.modelSelection } : {}), - ...(kept.runtimeMode !== undefined ? { runtimeMode: kept.runtimeMode } : {}), - ...(kept.interactionMode !== undefined ? { interactionMode: kept.interactionMode } : {}), - }); - // Flush before removal: append only schedules persistence, leaving the queue as the sole durable copy. - await flushComposerDrafts(); - } catch (error) { - console.warn("[thread-outbox] could not hand an edited pending task to the composer", error); - return false; - } - if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[kept.messageId]) { - return true; - } - try { - return await removeThreadOutboxMessage( - kept, - keptRevision, - () => !appAtomRegistry.get(editingQueuedMessageIdsAtom)[kept.messageId], + if (handedBack === "edited") return; + if (handedBack !== "handed-back") return yield* retryDelivery; + if (isEditingQueuedMessage(kept.messageId)) return; + const removed = yield* storage(() => + removeThreadOutboxMessage(kept, keptRevision, () => !isEditingQueuedMessage(kept.messageId)), + ).pipe( + Effect.catch((error) => + Effect.logWarning( + "[thread-outbox] could not remove recovered pending task", + error.cause, + ).pipe(Effect.as(false)), + ), ); - } catch (error) { - console.warn("[thread-outbox] could not remove recovered pending task", error); - return false; - } -} - -export async function restoreRejectedQueuedMessage( - queuedMessage: QueuedThreadMessage, - message: string, -): Promise<"restored" | "deferred" | "blocked" | "retry"> { - const draftKey = recoveryDraftKey(queuedMessage); - const threadKey = scopedThreadKey(queuedMessage.environmentId, queuedMessage.threadId); - let rollback: { readonly snapshot: ComposerDraft; readonly merged: ComposerDraft } | null = null; - try { - if ( - appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId] || - !(await confirmThreadOutboxMessageQueued(queuedMessage)) || - appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId] - ) { - return "deferred"; - } - const revision = threadOutboxRevision(queuedMessage.messageId); + if (!removed) return yield* retryDelivery; + }, +); - await waitForComposerDraftsLoaded(); - if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]) { - return "deferred"; - } - const originalDraft = getComposerDraftSnapshot(draftKey); - const existingAttachmentIds = new Set( - originalDraft.attachments.map((attachment) => attachment.id), - ); - const addedAttachmentCount = queuedMessage.attachments.filter( - (attachment) => !existingAttachmentIds.has(attachment.id), - ).length; - if (existingAttachmentIds.size + addedAttachmentCount > PROVIDER_SEND_TURN_MAX_ATTACHMENTS) { - setThreadComposerError( - threadKey, - `Remove attachments from the draft before restoring this message. Messages can contain at most ${PROVIDER_SEND_TURN_MAX_ATTACHMENTS} attachments.`, - queuedMessage.messageId, +/** + * Hands an undeliverable message back to its draft with the reason. "blocked" means the draft + * cannot take it yet (attachment cap); "deferred" means an editor or newer write owns it. + */ +export const restoreRejectedQueuedMessage = Effect.fn("ThreadOutbox.restoreRejectedMessage")( + function* (queuedMessage: QueuedThreadMessage, message: string) { + const draftKey = recoveryDraftKey(queuedMessage); + const threadKey = scopedThreadKey(queuedMessage.environmentId, queuedMessage.threadId); + const editing = () => isEditingQueuedMessage(queuedMessage.messageId); + // Until the queue drops the message, a failure undoes the merge, keeping concurrent edits. + let rollback: { readonly snapshot: ComposerDraft; readonly merged: ComposerDraft } | null = + null; + const undo = (snapshot: ComposerDraft, merged: ComposerDraft) => + storage(() => undoComposerDraftMerge(draftKey, snapshot, merged)); + return yield* Effect.gen(function* () { + if (editing() || !(yield* confirmQueued(queuedMessage)) || editing()) { + return "deferred" as const; + } + const revision = threadOutboxRevision(queuedMessage.messageId); + yield* storage(() => waitForComposerDraftsLoaded()); + if (editing()) return "deferred" as const; + const originalDraft = getComposerDraftSnapshot(draftKey); + const existingAttachmentIds = new Set( + originalDraft.attachments.map((attachment) => attachment.id), ); - return "blocked"; - } + const addedAttachmentCount = queuedMessage.attachments.filter( + (attachment) => !existingAttachmentIds.has(attachment.id), + ).length; + if (existingAttachmentIds.size + addedAttachmentCount > PROVIDER_SEND_TURN_MAX_ATTACHMENTS) { + setThreadComposerError( + threadKey, + `Remove attachments from the draft before restoring this message. Messages can contain at most ${PROVIDER_SEND_TURN_MAX_ATTACHMENTS} attachments.`, + queuedMessage.messageId, + ); + return "blocked" as const; + } - const withdrawError = () => clearThreadComposerError(threadKey, queuedMessage.messageId); - if (!queuedMessage.creation) { - setThreadComposerError(threadKey, message, queuedMessage.messageId); - } - let mergedDraft: ComposerDraft; - try { + const withdraw = (merged: ComposerDraft) => + Effect.sync(() => clearThreadComposerError(threadKey, queuedMessage.messageId)).pipe( + Effect.andThen(undo(originalDraft, merged)), + Effect.as("deferred" as const), + ); + if (!queuedMessage.creation) { + setThreadComposerError(threadKey, message, queuedMessage.messageId); + } stampRecoveryDraftProject(queuedMessage, draftKey); - await mergeComposerDraftContent(draftKey, { - text: queuedMessage.text, - context: queuedMessage.context, - attachments: queuedMessage.attachments, - }); - } finally { - // Capture rollback in finally because merge publishes even on persistence failure; undo must preserve concurrent edits. - mergedDraft = getComposerDraftSnapshot(draftKey); - rollback = { snapshot: originalDraft, merged: mergedDraft }; - } - if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]) { - withdrawError(); - await undoComposerDraftMerge(draftKey, originalDraft, mergedDraft); - return "deferred"; - } - updateComposerDraftSettings(draftKey, { - ...(queuedMessage.modelSelection ? { modelSelection: queuedMessage.modelSelection } : {}), - ...(queuedMessage.runtimeMode ? { runtimeMode: queuedMessage.runtimeMode } : {}), - ...(queuedMessage.interactionMode ? { interactionMode: queuedMessage.interactionMode } : {}), - ...(queuedMessage.freshContext ? { freshContext: true } : {}), - ...(queuedMessage.creation - ? { - workspaceSelection: { - mode: queuedMessage.creation.workspaceMode, - branch: queuedMessage.creation.branch, - worktreePath: queuedMessage.creation.worktreePath, - pullRequestReference: queuedMessage.creation.pullRequestReference, - ...(queuedMessage.creation.startFromOrigin !== undefined - ? { startFromOrigin: queuedMessage.creation.startFromOrigin } - : {}), - }, - } - : {}), - }); - const restoredDraft = getComposerDraftSnapshot(draftKey); - rollback = { snapshot: originalDraft, merged: restoredDraft }; - await flushComposerDrafts(); - if ( - appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId] || - !(await confirmThreadOutboxMessageQueued(queuedMessage)) || - appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId] - ) { - withdrawError(); - await undoComposerDraftMerge(draftKey, originalDraft, restoredDraft); - return "deferred"; - } - if ( - !(await removeThreadOutboxMessage( - queuedMessage, - revision, - () => !appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId], - )) - ) { - withdrawError(); - await undoComposerDraftMerge(draftKey, originalDraft, restoredDraft); - return "deferred"; - } - // After queue removal, the draft owns content and must never roll back. - rollback = null; - if (queuedMessage.creation) { - withdrawError(); - recordPendingThreadCreationOutcome({ - kind: "failed", - message: queuedMessage, - reason: message, + // The merge publishes even when persisting it fails, so the rollback is captured either way. + yield* storage(() => + mergeComposerDraftContent(draftKey, { + text: queuedMessage.text, + context: queuedMessage.context, + attachments: queuedMessage.attachments, + }), + ).pipe( + Effect.ensuring( + Effect.sync(() => { + rollback = { snapshot: originalDraft, merged: getComposerDraftSnapshot(draftKey) }; + }), + ), + ); + if (editing()) return yield* withdraw(getComposerDraftSnapshot(draftKey)); + updateComposerDraftSettings(draftKey, { + ...(queuedMessage.modelSelection ? { modelSelection: queuedMessage.modelSelection } : {}), + ...(queuedMessage.runtimeMode ? { runtimeMode: queuedMessage.runtimeMode } : {}), + ...(queuedMessage.interactionMode + ? { interactionMode: queuedMessage.interactionMode } + : {}), + ...(queuedMessage.freshContext ? { freshContext: true } : {}), + ...(queuedMessage.creation + ? { + workspaceSelection: { + mode: queuedMessage.creation.workspaceMode, + branch: queuedMessage.creation.branch, + worktreePath: queuedMessage.creation.worktreePath, + pullRequestReference: queuedMessage.creation.pullRequestReference, + ...(queuedMessage.creation.startFromOrigin !== undefined + ? { startFromOrigin: queuedMessage.creation.startFromOrigin } + : {}), + }, + } + : {}), }); - } - return "restored"; - } catch (error) { - if (rollback !== null) { - await undoComposerDraftMerge(draftKey, rollback.snapshot, rollback.merged).catch( - (undoError) => { - console.warn("[thread-outbox] failed to persist a recovery rollback", undoError); - }, + const restoredDraft = getComposerDraftSnapshot(draftKey); + rollback = { snapshot: originalDraft, merged: restoredDraft }; + yield* storage(() => flushComposerDrafts()); + if (editing() || !(yield* confirmQueued(queuedMessage)) || editing()) { + return yield* withdraw(restoredDraft); + } + const removed = yield* storage(() => + removeThreadOutboxMessage(queuedMessage, revision, () => !editing()), ); - } - console.warn("[thread-outbox] failed to restore an undeliverable message", error); - setThreadComposerError( - threadKey, - error instanceof Error ? error.message : "The unsent message could not be restored.", - queuedMessage.messageId, + if (!removed) return yield* withdraw(restoredDraft); + // After queue removal, the draft owns content and must never roll back. + rollback = null; + if (queuedMessage.creation) { + clearThreadComposerError(threadKey, queuedMessage.messageId); + recordPendingThreadCreationOutcome({ + kind: "failed", + message: queuedMessage, + reason: message, + }); + } + return "restored" as const; + }).pipe( + Effect.catch((error) => + Effect.gen(function* () { + const pending: typeof rollback = rollback; + if (pending !== null) { + yield* undo(pending.snapshot, pending.merged).pipe( + Effect.catch((undoError) => + Effect.logWarning( + "[thread-outbox] failed to persist a recovery rollback", + undoError.cause, + ), + ), + ); + } + yield* Effect.logWarning( + "[thread-outbox] failed to restore an undeliverable message", + error.cause, + ); + setThreadComposerError( + threadKey, + error.cause instanceof Error + ? error.cause.message + : "The unsent message could not be restored.", + queuedMessage.messageId, + ); + return "retry" as const; + }), + ), ); - return "retry"; - } -} + }, +); /** Derive keys from message ids so failed recovery retries reuse the same draft. */ function recoveryDraftKey(queuedMessage: QueuedThreadMessage): string { @@ -565,14 +577,10 @@ function stampRecoveryDraftProject(queuedMessage: QueuedThreadMessage, draftKey: }); } -async function preserveUploadedAttachmentsForEditor( - originalMessage: QueuedThreadMessage, - uploadedMessage: QueuedThreadMessage, -): Promise { - if (!originalMessage.creation) { - return; - } - +const preserveUploadedAttachmentsForEditor = Effect.fn( + "ThreadOutbox.preserveUploadedAttachmentsForEditor", +)(function* (originalMessage: QueuedThreadMessage, uploadedMessage: QueuedThreadMessage) { + if (!originalMessage.creation) return; const draftKey = `pending-task:${originalMessage.messageId}`; const draft = getComposerDraftSnapshot(draftKey); const uploadedById = new Map( @@ -596,11 +604,10 @@ async function preserveUploadedAttachmentsForEditor( uploadEnvironmentId: uploaded.uploadEnvironmentId, }; }); - if (changed) { - replaceComposerDraftAttachments(draftKey, nextAttachments); - await flushComposerDrafts(); - } -} + if (!changed) return; + replaceComposerDraftAttachments(draftKey, nextAttachments); + yield* Effect.promise(() => flushComposerDrafts()); +}); // Everything delivery decides from. Each queued environment's session is read // here so a granted or revoked operate scope wakes delivery. @@ -656,11 +663,11 @@ function deliveredSequence( return AsyncResult.isSuccess(result) ? result.value.sequence : undefined; } -const runDeliveryCommand = ( +const deliveryCommand = ( command: AtomCommand, input: W, -): Promise> => - runAtomCommand(appAtomRegistry, command, input, { reportFailure: false }); +): Effect.Effect> => + Effect.promise(() => runAtomCommand(appAtomRegistry, command, input, { reportFailure: false })); function reportCommandFailure( queuedMessage: QueuedThreadMessage, @@ -702,8 +709,8 @@ type ThreadDeliveryStep = | { readonly _tag: "Dispatch"; readonly messageId: MessageId; - /** Resolves true when the message is done with (sent, removed or handed back). */ - readonly run: () => Promise; + /** Succeeds once the message is handled (sent, removed or handed back). */ + readonly run: Effect.Effect; }; /** @@ -755,16 +762,14 @@ export function createThreadOutboxDelivery(): { // An over-cap draft blocks recovery until the user changes its attachments; // parking on the draft avoids hammering the restore with backoff retries. - const restoreQueuedMessage = async ( + const restoreQueuedMessage = Effect.fn("ThreadOutbox.restoreQueuedMessage")(function* ( queuedMessage: QueuedThreadMessage, message: string, - ): Promise => { - const result = await restoreRejectedQueuedMessage(queuedMessage, message); - if (result !== "blocked") { - return result !== "retry"; - } - if (disposed || blockedRecoveries.has(queuedMessage.messageId)) { - return true; + ) { + const result = yield* restoreRejectedQueuedMessage(queuedMessage, message); + if (result === "retry") return yield* retryDelivery; + if (result !== "blocked" || disposed || blockedRecoveries.has(queuedMessage.messageId)) { + return; } const draftKey = recoveryDraftKey(queuedMessage); const editorDraftKey = queuedMessage.creation @@ -790,20 +795,19 @@ export function createThreadOutboxDelivery(): { wakeThreads(); }); blockedRecoveries.set(queuedMessage.messageId, { message: queuedMessage, unsubscribe }); - return true; - }; + }); - const sendQueuedMessage = async ( + const sendQueuedMessage = Effect.fn("ThreadOutbox.sendQueuedMessage")(function* ( queuedMessage: QueuedThreadMessage, thread: EnvironmentThreadShell, - ): Promise => { + ) { const hasAccess = () => readEnvironmentScope(queuedMessage.environmentId, AuthOrchestrationOperateScope); - if (!hasAccess()) return true; + if (!hasAccess()) return; const serverConfig = appAtomRegistry.get( serverEnvironment.configValueAtom(queuedMessage.environmentId), ); - if (!serverConfig) return false; + if (!serverConfig) return yield* retryDelivery; const settings = resolveQueuedThreadSettings(queuedMessage, thread, serverConfig.providers); if (isModelSelectionUnavailable(serverConfig, settings.modelSelection, thread.projectId)) { const { title, detail } = describeUnavailableModelSelection( @@ -811,7 +815,7 @@ export function createThreadOutboxDelivery(): { settings.modelSelection, thread.projectId, ); - return restoreQueuedMessage(queuedMessage, `${title}. ${detail}`); + return yield* restoreQueuedMessage(queuedMessage, `${title}. ${detail}`); } // The server would refuse this mode in settings sync, which retries forever; stop first. const runtimeModeDenial = managedRuntimeModeDenial( @@ -819,12 +823,12 @@ export function createThreadOutboxDelivery(): { settings.runtimeMode, ); if (runtimeModeDenial !== undefined) { - return restoreQueuedMessage(queuedMessage, runtimeModeDenial); + return yield* restoreQueuedMessage(queuedMessage, runtimeModeDenial); } if (settings.runtimeMode !== thread.runtimeMode) { - if (!hasAccess()) return true; - const runtimeResult = await runDeliveryCommand(threadEnvironment.setRuntimeMode, { + if (!hasAccess()) return; + const runtimeResult = yield* deliveryCommand(threadEnvironment.setRuntimeMode, { environmentId: queuedMessage.environmentId, input: { commandId: settingsCommandId(queuedMessage, "runtime-mode"), @@ -835,13 +839,13 @@ export function createThreadOutboxDelivery(): { }); if (AsyncResult.isFailure(runtimeResult)) { reportCommandFailure(queuedMessage, runtimeResult, "settings-sync"); - return false; + return yield* retryDelivery; } } if (settings.interactionMode !== thread.interactionMode) { - if (!hasAccess()) return true; - const interactionResult = await runDeliveryCommand(threadEnvironment.setInteractionMode, { + if (!hasAccess()) return; + const interactionResult = yield* deliveryCommand(threadEnvironment.setInteractionMode, { environmentId: queuedMessage.environmentId, input: { commandId: settingsCommandId(queuedMessage, "interaction-mode"), @@ -852,51 +856,48 @@ export function createThreadOutboxDelivery(): { }); if (AsyncResult.isFailure(interactionResult)) { reportCommandFailure(queuedMessage, interactionResult, "settings-sync"); - return false; + return yield* retryDelivery; } } - let prepared: PreparedTurnAttachments; - let persistedMessage: QueuedThreadMessage; - let deliveryRevision: number; - if (!hasAccess()) return true; - try { - const preparedResult = await prepareQueuedMessageAttachments(queuedMessage); - if (preparedResult.status === "abandoned") { - return true; - } - prepared = preparedResult.prepared; - persistedMessage = preparedResult.persistedMessage; - deliveryRevision = preparedResult.deliveryRevision; - if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]) { - await preserveUploadedAttachmentsForEditor(queuedMessage, preparedResult.persistedMessage); - return true; - } - } catch (error) { - if (!hasAccess()) return true; + if (!hasAccess()) return; + // Waiting on the shared upload is the one part of a send that may be cut short. + const preparedExit = yield* Effect.exit( + Effect.interruptible(prepareQueuedMessageAttachments(queuedMessage)), + ); + if (Exit.isFailure(preparedExit)) { + if (Cause.hasInterruptsOnly(preparedExit.cause)) return yield* Effect.interrupt; + const error = Cause.squash(preparedExit.cause); + if (!hasAccess()) return; logThreadOutboxUploadFailure(queuedMessage, error); if (!shouldRetryThreadOutboxDelivery(error)) { - return restoreQueuedMessage( + return yield* restoreQueuedMessage( queuedMessage, error instanceof Error ? error.message : "An attachment could not upload.", ); } - return false; + return yield* retryDelivery; + } + if (preparedExit.value.status === "abandoned") return; + const { prepared, persistedMessage, deliveryRevision } = preparedExit.value; + if (isEditingQueuedMessage(queuedMessage.messageId)) { + yield* preserveUploadedAttachmentsForEditor(queuedMessage, persistedMessage); + return; } if (!isQueuedMessagePayloadCurrent(persistedMessage, deliveryRevision)) { - return true; + return; } const currentConfig = appAtomRegistry.get( serverEnvironment.configValueAtom(queuedMessage.environmentId), ); - if (!currentConfig) return false; + if (!currentConfig) return yield* retryDelivery; if (isModelSelectionUnavailable(currentConfig, settings.modelSelection, thread.projectId)) { const { title, detail } = describeUnavailableModelSelection( currentConfig, settings.modelSelection, thread.projectId, ); - return restoreQueuedMessage(persistedMessage, `${title}. ${detail}`); + return yield* restoreQueuedMessage(persistedMessage, `${title}. ${detail}`); } const sendSettings = resolveQueuedThreadSettings( queuedMessage, @@ -904,9 +905,9 @@ export function createThreadOutboxDelivery(): { currentConfig.providers, ); if (queuedMessage.compactBeforeSend === true) { - if (!hasAccess()) return true; + if (!hasAccess()) return; // Queued, since steering a running turn with a compaction is rejected. - const compactionResult = await runDeliveryCommand(threadEnvironment.startTurn, { + const compactionResult = yield* deliveryCommand(threadEnvironment.startTurn, { environmentId: queuedMessage.environmentId, input: { commandId: settingsCommandId(queuedMessage, "compact"), @@ -927,16 +928,16 @@ export function createThreadOutboxDelivery(): { resendAfterSocketLoss: false, }, }); - if (AsyncResult.isFailure(compactionResult) && !hasAccess()) return true; + if (AsyncResult.isFailure(compactionResult) && !hasAccess()) return; const compactionFailure = reportCommandFailure(queuedMessage, compactionResult, "start-turn"); - if (compactionFailure?.action === "retry") return false; + if (compactionFailure?.action === "retry") return yield* retryDelivery; if (compactionFailure?.action === "restore") { - return restoreQueuedMessage(persistedMessage, compactionFailure.message); + return yield* restoreQueuedMessage(persistedMessage, compactionFailure.message); } - if (!isQueuedMessagePayloadCurrent(persistedMessage, deliveryRevision)) return true; + if (!isQueuedMessagePayloadCurrent(persistedMessage, deliveryRevision)) return; } - if (!hasAccess()) return true; - const deliveryResult = await runDeliveryCommand(threadEnvironment.startTurn, { + if (!hasAccess()) return; + const deliveryResult = yield* deliveryCommand(threadEnvironment.startTurn, { environmentId: queuedMessage.environmentId, input: { commandId: queuedMessage.commandId, @@ -968,43 +969,40 @@ export function createThreadOutboxDelivery(): { resendAfterSocketLoss: false, }, }); - if (AsyncResult.isFailure(deliveryResult) && !hasAccess()) return true; + if (AsyncResult.isFailure(deliveryResult) && !hasAccess()) return; const failure = reportCommandFailure(queuedMessage, deliveryResult, "start-turn"); if (failure?.action === "retry") { - return false; + return yield* retryDelivery; } if (failure?.action === "restore") { - return restoreQueuedMessage(persistedMessage, failure.message); + return yield* restoreQueuedMessage(persistedMessage, failure.message); } acknowledgedExistingThreadMessageIds.add(persistedMessage.messageId); - const delivered = - (await completeQueuedMessageDelivery( - persistedMessage, - deliveryRevision, - deliveredSequence(deliveryResult), - )) === "removed"; - if (delivered) { - acknowledgedExistingThreadMessageIds.delete(persistedMessage.messageId); - } - return delivered; - }; + const outcome = yield* completeQueuedMessageDelivery( + persistedMessage, + deliveryRevision, + deliveredSequence(deliveryResult), + ); + if (outcome !== "removed") return yield* retryDelivery; + acknowledgedExistingThreadMessageIds.delete(persistedMessage.messageId); + }); - const sendQueuedCreation = async ( + const sendQueuedCreation = Effect.fn("ThreadOutbox.sendQueuedCreation")(function* ( queuedMessage: QueuedThreadMessage, creation: QueuedThreadCreation, projectCwd: string, - ): Promise => { + ) { const hasAccess = () => readEnvironmentScope(queuedMessage.environmentId, AuthOrchestrationOperateScope); - if (!hasAccess()) return true; + if (!hasAccess()) return; const modelSelection = queuedMessage.modelSelection; if (modelSelection === undefined) { - return false; + return yield* retryDelivery; } const serverConfig = appAtomRegistry.get( serverEnvironment.configValueAtom(queuedMessage.environmentId), ); - if (!serverConfig) return false; + if (!serverConfig) return yield* retryDelivery; const settings = resolveQueuedThreadSettings( queuedMessage, { @@ -1020,84 +1018,81 @@ export function createThreadOutboxDelivery(): { settings.modelSelection, creation.projectId, ); - return restoreQueuedMessage(queuedMessage, `${title}. ${detail}`); + return yield* restoreQueuedMessage(queuedMessage, `${title}. ${detail}`); } const runtimeModeDenial = managedRuntimeModeDenial( serverConfig.managedPolicy, settings.runtimeMode, ); if (runtimeModeDenial !== undefined) { - return restoreQueuedMessage(queuedMessage, runtimeModeDenial); + return yield* restoreQueuedMessage(queuedMessage, runtimeModeDenial); } - let prepared: PreparedTurnAttachments; - let persistedMessage: QueuedThreadMessage; - let deliveryRevision: number; - try { - const preparedResult = await prepareQueuedMessageAttachments(queuedMessage); - if (preparedResult.status === "abandoned") { - return true; - } - prepared = preparedResult.prepared; - persistedMessage = preparedResult.persistedMessage; - deliveryRevision = preparedResult.deliveryRevision; - if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]) { - await preserveUploadedAttachmentsForEditor(queuedMessage, preparedResult.persistedMessage); - return true; - } - } catch (error) { - if (!hasAccess()) return true; + // Waiting on the shared upload is the one part of a send that may be cut short. + const preparedExit = yield* Effect.exit( + Effect.interruptible(prepareQueuedMessageAttachments(queuedMessage)), + ); + if (Exit.isFailure(preparedExit)) { + if (Cause.hasInterruptsOnly(preparedExit.cause)) return yield* Effect.interrupt; + const error = Cause.squash(preparedExit.cause); + if (!hasAccess()) return; logThreadOutboxUploadFailure(queuedMessage, error); if (!shouldRetryThreadOutboxDelivery(error)) { - return restoreQueuedMessage( + return yield* restoreQueuedMessage( queuedMessage, error instanceof Error ? error.message : "An attachment could not upload.", ); } - return false; + return yield* retryDelivery; + } + if (preparedExit.value.status === "abandoned") return; + const { prepared, persistedMessage, deliveryRevision } = preparedExit.value; + if (isEditingQueuedMessage(queuedMessage.messageId)) { + yield* preserveUploadedAttachmentsForEditor(queuedMessage, persistedMessage); + return; } if (!isQueuedMessagePayloadCurrent(persistedMessage, deliveryRevision)) { - return true; + return; } const currentConfig = appAtomRegistry.get( serverEnvironment.configValueAtom(queuedMessage.environmentId), ); - if (!currentConfig) return false; + if (!currentConfig) return yield* retryDelivery; if (isModelSelectionUnavailable(currentConfig, settings.modelSelection, creation.projectId)) { const { title, detail } = describeUnavailableModelSelection( currentConfig, settings.modelSelection, creation.projectId, ); - return restoreQueuedMessage(persistedMessage, `${title}. ${detail}`); + return yield* restoreQueuedMessage(persistedMessage, `${title}. ${detail}`); } const sendSettings = resolveQueuedThreadSettings( queuedMessage, settings, currentConfig.providers, ); - if (!hasAccess()) return true; + if (!hasAccess()) return; let workspace = creation; const launched = launchedCreations.get(persistedMessage.messageId); if (launched?.revision === deliveryRevision) { workspace = launched.workspace; } else if (creation.pullRequestReference) { - const checkout = await runDeliveryCommand(gitEnvironment.preparePullRequestThread, { + const checkout = yield* deliveryCommand(gitEnvironment.preparePullRequestThread, { environmentId: queuedMessage.environmentId, input: { cwd: projectCwd, reference: creation.pullRequestReference, mode: "worktree" }, }); if (!isQueuedMessagePayloadCurrent(persistedMessage, deliveryRevision) || !hasAccess()) - return true; + return; const failure = reportCommandFailure(queuedMessage, checkout, "start-turn"); - if (failure?.action === "retry") return false; + if (failure?.action === "retry") return yield* retryDelivery; if (failure?.action === "restore") - return restoreQueuedMessage(persistedMessage, failure.message); - if (!AsyncResult.isSuccess(checkout)) return false; + return yield* restoreQueuedMessage(persistedMessage, failure.message); + if (!AsyncResult.isSuccess(checkout)) return yield* retryDelivery; if (!checkout.value.worktreePath || !checkout.value.isOnPullRequestHead) { const { shortLabel } = ( sourceControlClients.findByChangeRequestUrl(creation.pullRequestReference) ?? sourceControlClients.get(undefined) ).changeRequest; - return restoreQueuedMessage( + return yield* restoreQueuedMessage( persistedMessage, `The ${shortLabel} worktree has local changes and could not update to the ${shortLabel} head. Resolve them before trying again.`, ); @@ -1111,7 +1106,7 @@ export function createThreadOutboxDelivery(): { }; } launchedCreations.set(persistedMessage.messageId, { revision: deliveryRevision, workspace }); - const deliveryResult = await runDeliveryCommand(threadEnvironment.startTurn, { + const deliveryResult = yield* deliveryCommand(threadEnvironment.startTurn, { environmentId: queuedMessage.environmentId, input: buildProjectThreadStartTurnInput({ projectId: creation.projectId, @@ -1140,28 +1135,26 @@ export function createThreadOutboxDelivery(): { worktreeBranchName: buildTemporaryWorktreeBranchName(randomHex), }), }); - if (AsyncResult.isFailure(deliveryResult) && !hasAccess()) return true; + if (AsyncResult.isFailure(deliveryResult) && !hasAccess()) return; const failure = reportCommandFailure(queuedMessage, deliveryResult, "start-turn"); if (failure?.action === "retry") { - return false; + return yield* retryDelivery; } if (failure?.action === "restore") { - return restoreQueuedMessage(persistedMessage, failure.message); + return yield* restoreQueuedMessage(persistedMessage, failure.message); } recordPendingThreadCreationOutcome({ kind: "delivered", message: persistedMessage }); - const outcome = await completeQueuedMessageDelivery( + const outcome = yield* completeQueuedMessageDelivery( persistedMessage, deliveryRevision, deliveredSequence(deliveryResult), ); if (outcome === "edited") { - if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]) { - return true; - } - return recoverEditedCreationAfterDelivery(persistedMessage); + if (isEditingQueuedMessage(queuedMessage.messageId)) return; + return yield* recoverEditedCreationAfterDelivery(persistedMessage); } - return outcome === "removed"; - }; + if (outcome !== "removed") return yield* retryDelivery; + }); /** The head of one thread's queue, as the inputs stand now. */ function nextStep( @@ -1193,11 +1186,10 @@ export function createThreadOutboxDelivery(): { return { _tag: "Dispatch", messageId, - run: () => - removeAcknowledgedExistingThreadMessage( - nextQueuedMessage, - acknowledgedExistingThreadMessageIds, - ), + run: removeAcknowledgedExistingThreadMessage( + nextQueuedMessage, + acknowledgedExistingThreadMessageIds, + ), }; } if (editingQueuedMessageIds[messageId]) { @@ -1309,12 +1301,12 @@ export function createThreadOutboxDelivery(): { return { _tag: "Dispatch", messageId, - run: () => - confirmThreadOutboxMessageQueued(nextQueuedMessage).then((queued) => - !queued || appAtomRegistry.get(editingQueuedMessageIdsAtom)[messageId] - ? true - : restoreQueuedMessage(nextQueuedMessage, attachmentError), - ), + run: Effect.gen(function* () { + if (!(yield* confirmQueued(nextQueuedMessage)) || isEditingQueuedMessage(messageId)) { + return; + } + yield* restoreQueuedMessage(nextQueuedMessage, attachmentError); + }), }; } const creationProjectCwd = @@ -1333,56 +1325,50 @@ export function createThreadOutboxDelivery(): { } const removeQueuedMessage = (warning: string) => - removeThreadOutboxMessage(nextQueuedMessage).then( - () => true, - (error) => { - console.warn(warning, { + storage(() => removeThreadOutboxMessage(nextQueuedMessage)).pipe( + Effect.catch((error) => + Effect.logWarning(warning, { environmentId: nextQueuedMessage.environmentId, threadId: nextQueuedMessage.threadId, messageId, - error, - }); - return false; - }, + error: error.cause, + }).pipe(Effect.andThen(retryDelivery)), + ), + Effect.asVoid, ); // Confirm durability before sending; optimistic enqueue can still roll back on write failure. - const run = () => - confirmThreadOutboxMessageQueued(nextQueuedMessage).then((queued) => { - if (!queued) { - return true; - } - // Re-check editor ownership after confirmation; return true to defer without failure backoff. - if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[messageId]) { - return true; - } - if (deliveryAction === "send") { - const liveThread = findThread( - appAtomRegistry.get(environmentThreadShells.threadShellsAtom), - nextQueuedMessage, - ); - const liveDeliveryAction = resolveThreadOutboxDeliveryAction({ - isCreation: creation !== undefined, - threadExists: liveThread !== undefined && !resendLaunch, - shellStatus, - environmentConnected: environment?.connectionState === "connected", - }); - if (liveDeliveryAction !== "send") { - return true; - } - } - return deliveryAction === "remove" - ? creation !== undefined - ? // Edited since launch, or launched before a restart that lost the revision: hand it back. - recoverEditedCreationAfterDelivery(nextQueuedMessage) - : removeQueuedMessage("[thread-outbox] failed to remove message for a missing thread") - : creation !== undefined - ? creationProjectCwd !== null - ? sendQueuedCreation(nextQueuedMessage, creation, creationProjectCwd) - : removeQueuedMessage("[thread-outbox] dropped pending task for a missing project") - : thread !== undefined - ? sendQueuedMessage(nextQueuedMessage, thread) - : Promise.resolve(false); - }); + const run = Effect.gen(function* () { + if (!(yield* confirmQueued(nextQueuedMessage))) return; + // An editor that took the message after confirmation owns it; that is not a failure. + if (isEditingQueuedMessage(messageId)) return; + if (deliveryAction === "send") { + const liveThread = findThread( + appAtomRegistry.get(environmentThreadShells.threadShellsAtom), + nextQueuedMessage, + ); + const liveDeliveryAction = resolveThreadOutboxDeliveryAction({ + isCreation: creation !== undefined, + threadExists: liveThread !== undefined && !resendLaunch, + shellStatus, + environmentConnected: environment?.connectionState === "connected", + }); + if (liveDeliveryAction !== "send") return; + } + if (deliveryAction === "remove") { + // Edited since launch, or launched before a restart that lost the revision: hand it back. + return yield* creation !== undefined + ? recoverEditedCreationAfterDelivery(nextQueuedMessage) + : removeQueuedMessage("[thread-outbox] failed to remove message for a missing thread"); + } + if (creation !== undefined) { + return yield* creationProjectCwd !== null + ? sendQueuedCreation(nextQueuedMessage, creation, creationProjectCwd) + : removeQueuedMessage("[thread-outbox] dropped pending task for a missing project"); + } + return yield* thread !== undefined + ? sendQueuedMessage(nextQueuedMessage, thread) + : retryDelivery; + }); return { _tag: "Dispatch", messageId, run }; } @@ -1417,18 +1403,19 @@ export function createThreadOutboxDelivery(): { ); return; } - // A send that started finishes, even when its thread leaves the queue meanwhile. + // A send that started finishes, even when its thread leaves the queue meanwhile; only + // its wait on a shared upload stops early. beginDispatchingQueuedMessage(step.messageId); - const sent = yield* Effect.promise(() => - step.run().catch((error: unknown) => { - // A delivery that throws backs off like any failure, not straight back into the send. - console.warn("[thread-outbox] queued message delivery threw", { + const sent = yield* step.run.pipe( + Effect.as(true), + Effect.catchTags({ DeliveryRetry: () => Effect.succeed(false) }), + // A send that throws backs off like any failure, not straight back into the send. + Effect.catchDefect((error) => + Effect.logWarning("[thread-outbox] queued message delivery threw", { messageId: step.messageId, error, - }); - return false; - }), - ).pipe( + }).pipe(Effect.as(false)), + ), Effect.ensuring(Effect.sync(() => finishDispatchingQueuedMessage(step.messageId))), Effect.uninterruptible, ); From 8556fd2f106c3a6b89a118e00c60edaad199faf8 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Mon, 16 Nov 2026 11:47:03 -0800 Subject: [PATCH 4/5] fix(mobile): keep one delivery fiber per thread across re-entry and retirement A thread's entry is registered before its fiber starts, since the fiber's first step runs synchronously and a thread-family mount can re-enter onInputs, which used to start a second untracked fiber. An interrupted fiber keeps its entry until it exits, so a message queued while its send finishes waits for it instead of sending alongside. Co-Authored-By: Claude Opus 5.5 --- .../threadOutboxDelivery.permissions.test.ts | 31 ++++++++++++++ apps/mobile/src/state/threadOutboxDelivery.ts | 41 ++++++++++++++----- 2 files changed, 62 insertions(+), 10 deletions(-) diff --git a/apps/mobile/src/state/threadOutboxDelivery.permissions.test.ts b/apps/mobile/src/state/threadOutboxDelivery.permissions.test.ts index e23324ba94528..700b58499d691 100644 --- a/apps/mobile/src/state/threadOutboxDelivery.permissions.test.ts +++ b/apps/mobile/src/state/threadOutboxDelivery.permissions.test.ts @@ -390,6 +390,8 @@ describe("queued task operation access", () => { appAtomRegistry.set(editingQueuedMessageIdsAtom, {}); await delivered.promise.finally(release); expect(state.familyMount).toHaveBeenCalledOnce(); + // One fiber took the message: a second would have prepared it again. + expect(state.prepare).toHaveBeenCalledOnce(); expect(state.start).toHaveBeenCalledOnce(); expect(remaining()).toEqual([]); }); @@ -677,6 +679,35 @@ describe("queued delivery timing", () => { await settled.promise.finally(release); } + it("starts a thread's next message only after its interrupted send has finished", async () => { + setOperateGrant("secondary", true); + const firstStarted = Promise.withResolvers(); + const finishFirst = Promise.withResolvers>(); + state.start.mockImplementationOnce(async () => { + firstStarted.resolve(); + return finishFirst.promise; + }); + const first = message(); + await state.manager.enqueue(first); + startDelivery(); + await firstStarted.promise; + // The queue empties under the running send, then the thread gets its next message. + await state.manager.remove(first); + const allDelivered = Promise.withResolvers(); + const release = appAtomRegistry.subscribe(state.manager.queuedMessagesByThreadKeyAtom, () => { + if (remaining().length === 0) allDelivered.resolve(); + }); + await state.manager.enqueue( + message({ messageId: MessageId.make("next"), commandId: CommandId.make("next-command") }), + ); + // The next message waits; only the interrupted send is still marked as sending. + expect(sendingMessageIds()).toEqual(["message"]); + expect(state.start).toHaveBeenCalledOnce(); + finishFirst.resolve(AsyncResult.success({})); + await allDelivered.promise.finally(release); + expect(state.start).toHaveBeenCalledTimes(2); + }); + it("sends another thread's message while one thread's send is still running", async () => { setOperateGrant("secondary", true); const other = { ...state.thread, id: "other" }; diff --git a/apps/mobile/src/state/threadOutboxDelivery.ts b/apps/mobile/src/state/threadOutboxDelivery.ts index 52eb689394feb..7376ac276b6b3 100644 --- a/apps/mobile/src/state/threadOutboxDelivery.ts +++ b/apps/mobile/src/state/threadOutboxDelivery.ts @@ -700,6 +700,13 @@ interface ThreadOutboxRetry { readonly notBefore: number; } +/** A thread's delivery fiber; `retiring` once interrupted, until the fiber has exited. */ +interface ThreadFiber { + readonly wake: Latch.Latch; + fiber: Fiber.Fiber | undefined; + retiring: boolean; +} + /** What a thread's delivery fiber does next with the head of its queue. */ type ThreadDeliveryStep = /** Nothing to send until an input changes, or until `until` when a backoff is running. */ @@ -1374,10 +1381,8 @@ export function createThreadOutboxDelivery(): { // One fiber per thread with queued messages. Opening a thread's latch wakes its fiber to // reconsider its head; the fiber closes it before reading the inputs, so no wake is lost. - const threadFibers = new Map< - string, - { readonly wake: Latch.Latch; readonly fiber: Fiber.Fiber } - >(); + // An entry outlives its interrupted fiber until that fiber exits, so a thread never has two. + const threadFibers = new Map(); const deliverThread = (threadKey: string, wake: Latch.Latch) => Effect.forever( @@ -1467,14 +1472,28 @@ export function createThreadOutboxDelivery(): { } for (const [threadKey, entry] of threadFibers) { - if ((queuedMessagesByThreadKey[threadKey]?.length ?? 0) > 0) continue; - threadFibers.delete(threadKey); - Effect.runFork(Fiber.interrupt(entry.fiber)); + if ((queuedMessagesByThreadKey[threadKey]?.length ?? 0) > 0 || entry.retiring) continue; + entry.retiring = true; + if (entry.fiber !== undefined) Effect.runFork(Fiber.interrupt(entry.fiber)); } for (const [threadKey, messages] of Object.entries(queuedMessagesByThreadKey)) { if (messages.length === 0 || threadFibers.has(threadKey)) continue; - const wake = Latch.makeUnsafe(true); - threadFibers.set(threadKey, { wake, fiber: Effect.runFork(deliverThread(threadKey, wake)) }); + // Registered before the fiber starts: its first step runs synchronously and can re-enter here. + const entry: ThreadFiber = { + wake: Latch.makeUnsafe(true), + fiber: undefined, + retiring: false, + }; + threadFibers.set(threadKey, entry); + const fiber = Effect.runFork(deliverThread(threadKey, entry.wake)); + entry.fiber = fiber; + fiber.addObserver(() => { + if (threadFibers.get(threadKey) !== entry) return; + threadFibers.delete(threadKey); + // A message queued while this fiber finished its send starts the next fiber now. + if (!disposed) onInputs(); + }); + if (entry.retiring) Effect.runFork(Fiber.interrupt(fiber)); } wakeThreads(); } @@ -1496,7 +1515,9 @@ export function createThreadOutboxDelivery(): { disposed = true; stopDelivering(); stopCollectingOutcomes(); - for (const { fiber } of threadFibers.values()) Effect.runFork(Fiber.interrupt(fiber)); + for (const { fiber } of threadFibers.values()) { + if (fiber !== undefined) Effect.runFork(Fiber.interrupt(fiber)); + } threadFibers.clear(); retries.clear(); appAtomRegistry.set(retryingQueuedMessageIdsAtom, {}); From 695238f9bb0da3c534992629f0073210cbafa2a3 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Mon, 16 Nov 2026 11:57:46 -0800 Subject: [PATCH 5/5] refactor(mobile): name the operation and message on outbox storage errors Co-Authored-By: Claude Opus 5.5 --- apps/mobile/src/state/threadOutboxDelivery.ts | 67 ++++++++++++++----- 1 file changed, 51 insertions(+), 16 deletions(-) diff --git a/apps/mobile/src/state/threadOutboxDelivery.ts b/apps/mobile/src/state/threadOutboxDelivery.ts index 7376ac276b6b3..5eb87964571db 100644 --- a/apps/mobile/src/state/threadOutboxDelivery.ts +++ b/apps/mobile/src/state/threadOutboxDelivery.ts @@ -219,11 +219,38 @@ function settingsCommandId(message: QueuedThreadMessage, setting: string): Comma /** Outbox or draft storage refused a step; the step decides what that means for the message. */ class ThreadOutboxStorageError extends Schema.TaggedError()( "ThreadOutboxStorageError", - { cause: Schema.Defect() }, -) {} + { + operation: Schema.Literals([ + "forget-sign-out-snapshot", + "remove-delivered", + "remove-acknowledged", + "remove-unsendable", + "hand-back-to-draft", + "restore-to-draft", + "undo-draft-merge", + "load-drafts", + "flush-drafts", + "remove-recovered", + "remove-restored", + ]), + messageId: Schema.String, + cause: Schema.Defect(), + }, +) { + override get message(): string { + return `Queued message ${this.messageId} could not ${this.operation.replaceAll("-", " ")}.`; + } +} -const storage = (write: () => Promise) => - Effect.tryPromise({ try: write, catch: (cause) => new ThreadOutboxStorageError({ cause }) }); +const storage = ( + operation: ThreadOutboxStorageError["operation"], + messageId: MessageId, + write: () => Promise, +) => + Effect.tryPromise({ + try: write, + catch: (cause) => new ThreadOutboxStorageError({ operation, messageId, cause }), + }); /** The head was not handled; back off and try it again. */ export class DeliveryRetry extends Schema.TaggedError()("DeliveryRetry", {}) {} @@ -290,7 +317,9 @@ function isQueuedMessagePayloadCurrent( } const forgetCloudQueuedMessage = (queuedMessage: QueuedThreadMessage) => - storage(() => removeDeliveredCloudQueuedMessage(queuedMessage)).pipe( + storage("forget-sign-out-snapshot", queuedMessage.messageId, () => + removeDeliveredCloudQueuedMessage(queuedMessage), + ).pipe( Effect.catch((error) => Effect.logWarning("[thread-outbox] could not update sign-out snapshot after delivery", { messageId: queuedMessage.messageId, @@ -314,7 +343,7 @@ export const completeQueuedMessageDelivery = Effect.fn("ThreadOutbox.completeDel retainAcknowledgedThreadMessage( sequence === undefined ? queuedMessage : { ...queuedMessage, sequence }, ); - const removed = yield* storage(() => + const removed = yield* storage("remove-delivered", queuedMessage.messageId, () => removeThreadOutboxMessage( queuedMessage, deliveryRevision, @@ -345,7 +374,9 @@ export const removeAcknowledgedExistingThreadMessage = Effect.fn( "ThreadOutbox.removeAcknowledgedMessage", )(function* (queuedMessage: QueuedThreadMessage, acknowledgedMessageIds: Set) { yield* forgetCloudQueuedMessage(queuedMessage); - const removed = yield* storage(() => removeThreadOutboxMessage(queuedMessage)).pipe( + const removed = yield* storage("remove-acknowledged", queuedMessage.messageId, () => + removeThreadOutboxMessage(queuedMessage), + ).pipe( Effect.catch((error) => Effect.logWarning("[thread-outbox] failed to remove acknowledged queued message", { environmentId: queuedMessage.environmentId, @@ -372,7 +403,7 @@ export const recoverEditedCreationAfterDelivery = Effect.fn("ThreadOutbox.recove const draftKey = scopedThreadKey(kept.environmentId, kept.threadId); const handedBack = yield* Effect.gen(function* () { // Merge before removal to retain file ownership; allow overflow and let send guards require trimming. - yield* storage(() => + yield* storage("hand-back-to-draft", kept.messageId, () => mergeComposerDraftContent(draftKey, { text: kept.text, context: kept.context, @@ -395,7 +426,7 @@ export const recoverEditedCreationAfterDelivery = Effect.fn("ThreadOutbox.recove ...(kept.interactionMode !== undefined ? { interactionMode: kept.interactionMode } : {}), }); // Flush before removal: append only schedules persistence, leaving the queue as the sole durable copy. - yield* storage(() => flushComposerDrafts()); + yield* storage("flush-drafts", kept.messageId, () => flushComposerDrafts()); return "handed-back" as const; }).pipe( Effect.catch((error) => @@ -408,7 +439,7 @@ export const recoverEditedCreationAfterDelivery = Effect.fn("ThreadOutbox.recove if (handedBack === "edited") return; if (handedBack !== "handed-back") return yield* retryDelivery; if (isEditingQueuedMessage(kept.messageId)) return; - const removed = yield* storage(() => + const removed = yield* storage("remove-recovered", kept.messageId, () => removeThreadOutboxMessage(kept, keptRevision, () => !isEditingQueuedMessage(kept.messageId)), ).pipe( Effect.catch((error) => @@ -435,13 +466,15 @@ export const restoreRejectedQueuedMessage = Effect.fn("ThreadOutbox.restoreRejec let rollback: { readonly snapshot: ComposerDraft; readonly merged: ComposerDraft } | null = null; const undo = (snapshot: ComposerDraft, merged: ComposerDraft) => - storage(() => undoComposerDraftMerge(draftKey, snapshot, merged)); + storage("undo-draft-merge", queuedMessage.messageId, () => + undoComposerDraftMerge(draftKey, snapshot, merged), + ); return yield* Effect.gen(function* () { if (editing() || !(yield* confirmQueued(queuedMessage)) || editing()) { return "deferred" as const; } const revision = threadOutboxRevision(queuedMessage.messageId); - yield* storage(() => waitForComposerDraftsLoaded()); + yield* storage("load-drafts", queuedMessage.messageId, () => waitForComposerDraftsLoaded()); if (editing()) return "deferred" as const; const originalDraft = getComposerDraftSnapshot(draftKey); const existingAttachmentIds = new Set( @@ -469,7 +502,7 @@ export const restoreRejectedQueuedMessage = Effect.fn("ThreadOutbox.restoreRejec } stampRecoveryDraftProject(queuedMessage, draftKey); // The merge publishes even when persisting it fails, so the rollback is captured either way. - yield* storage(() => + yield* storage("restore-to-draft", queuedMessage.messageId, () => mergeComposerDraftContent(draftKey, { text: queuedMessage.text, context: queuedMessage.context, @@ -506,11 +539,11 @@ export const restoreRejectedQueuedMessage = Effect.fn("ThreadOutbox.restoreRejec }); const restoredDraft = getComposerDraftSnapshot(draftKey); rollback = { snapshot: originalDraft, merged: restoredDraft }; - yield* storage(() => flushComposerDrafts()); + yield* storage("flush-drafts", queuedMessage.messageId, () => flushComposerDrafts()); if (editing() || !(yield* confirmQueued(queuedMessage)) || editing()) { return yield* withdraw(restoredDraft); } - const removed = yield* storage(() => + const removed = yield* storage("remove-restored", queuedMessage.messageId, () => removeThreadOutboxMessage(queuedMessage, revision, () => !editing()), ); if (!removed) return yield* withdraw(restoredDraft); @@ -1332,7 +1365,9 @@ export function createThreadOutboxDelivery(): { } const removeQueuedMessage = (warning: string) => - storage(() => removeThreadOutboxMessage(nextQueuedMessage)).pipe( + storage("remove-unsendable", messageId, () => + removeThreadOutboxMessage(nextQueuedMessage), + ).pipe( Effect.catch((error) => Effect.logWarning(warning, { environmentId: nextQueuedMessage.environmentId,