import {
AuthOrchestrationOperateScope,
CommandId,
EnvironmentId,
MessageId,
ProjectId,
ProviderInstanceId,
ThreadId,
} from "@t3tools/contracts";
import * as Cause from "effect/Cause";
import { AsyncResult, type Atom } from "effect/reactivity";
import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";
import type { QueuedThreadMessage } from "./thread-outbox-model";
const state = vi.hoisted(() => ({
draftText: "Keep this draft separate",
cleanups: [] as Array<() => void>,
delivery: null as {
readonly drain: () => void;
readonly dispose: () => void;
} | null,
start: vi.fn(),
metadata: vi.fn(),
runtime: vi.fn(),
interaction: vi.fn(),
prepare: vi.fn(),
checkout: vi.fn(),
modelUnavailable: vi.fn(() => false),
familyMount: vi.fn(() => () => {}),
threadShells: null as unknown as Atom.Writable<ReadonlyArray<unknown>>,
manager: null as unknown as ReturnType<
typeof import("./thread-outbox-manager").createThreadOutboxManager
>,
thread: {
environmentId: "secondary",
id: "thread",
modelSelection: { instanceId: "codex", model: "gpt-5.4" },
runtimeMode: "full-access",
interactionMode: "default",
session: null,
},
config: {
shellThreadFamilies: false,
providers: [{ instanceId: "codex", driver: "codex" }],
environment: { capabilities: {} },
},
}));
vi.mock("react-native", () => ({ Alert: { alert: vi.fn() } }));
vi.mock("@t3tools/client-runtime/state/runtime", async (importOriginal) => ({
...(await importOriginal<typeof import("@t3tools/client-runtime/state/runtime")>()),
runAtomCommand: (_registry: unknown, command: (input: unknown) => unknown, input: unknown) =>
command(input),
}));
vi.mock("./session", async () => {
const { Atom } = await import("effect/reactivity");
const { appAtomRegistry } = await import("./atom-registry");
// A session's state is reduced to whether it grants the operate scope.
const sessionStateAtom = Atom.family((_id: string) => Atom.make(false).pipe(Atom.keepAlive));
const sessionHasScope = (granted: boolean, scope: string) =>
granted && scope === AuthOrchestrationOperateScope;
return {
environmentSession: { sessionStateAtom },
sessionHasScope,
readEnvironmentScope: (environmentId: string, scope: string) =>
sessionHasScope(appAtomRegistry.get(sessionStateAtom(environmentId)), scope),
};
});
vi.mock("./projects", async () => {
const { Atom } = await import("effect/reactivity");
return { environmentProjects: { projectsAtom: Atom.make([]) } };
});
vi.mock("./workspace", async () => {
const { Atom } = await import("effect/reactivity");
return {
workspaceConnections: {
environmentsAtom: Atom.make([{ environmentId: "secondary", connectionState: "connected" }]),
},
};
});
vi.mock("./server", async () => {
const { Atom } = await import("effect/reactivity");
return {
serverEnvironment: { configValueAtom: Atom.family((_id: string) => Atom.make(state.config)) },
environmentServerConfigsAtom: Atom.make(new Map([["secondary", state.config]])),
};
});
vi.mock("./threads", async () => {
const { Atom, AsyncResult } = await import("effect/reactivity");
state.threadShells = Atom.make<ReadonlyArray<unknown>>([state.thread]).pipe(Atom.keepAlive);
return {
threadEnvironment: {
startTurn: state.start,
updateMetadata: state.metadata,
setRuntimeMode: state.runtime,
setInteractionMode: state.interaction,
},
environmentThreadShells: { threadShellsAtom: state.threadShells },
threadFamilies: {
mount: state.familyMount,
familyAtom: () => Atom.make(AsyncResult.success({})),
refresh: vi.fn(),
},
environmentThreadDetails: { stateAtom: () => Atom.make(null) },
};
});
vi.mock("./git", () => ({ gitEnvironment: { preparePullRequestThread: state.checkout } }));
vi.mock("../lib/modelOptions", () => ({ isModelSelectionUnavailable: state.modelUnavailable }));
vi.mock("../lib/uuid", () => ({ uuidv4: () => "uuid", randomHex: () => "abcd" }));
vi.mock("../lib/attachmentUpload", () => ({ prepareTurnAttachments: state.prepare }));
vi.mock("./thread-outbox", async () => {
const { createThreadOutboxManager } = await import("./thread-outbox-manager");
const { appAtomRegistry } = await import("./atom-registry");
state.manager = createThreadOutboxManager({
registry: appAtomRegistry,
storage: {
load: async () => ({ messages: [], errors: [] }),
write: async () => {},
remove: async () => {},
},
});
return {
threadOutboxManager: state.manager,
threadOutboxRevision: (id: MessageId) => state.manager.revisionOf(id),
confirmThreadOutboxMessageQueued: (message: QueuedThreadMessage) =>
state.manager.confirmQueued(message),
updateThreadOutboxMessage: (message: QueuedThreadMessage, revision?: number) =>
state.manager.update(message, revision),
};
});
vi.mock("./thread-outbox-removal", () => ({
removeThreadOutboxMessage: (message: QueuedThreadMessage, revision?: number) =>
state.manager.remove(message, revision),
}));
vi.mock("./use-thread-outbox", async () => {
const { Atom } = await import("effect/reactivity");
return {
editingQueuedMessageIdsAtom: Atom.make({}).pipe(Atom.keepAlive),
dispatchingQueuedMessageIdAtom: Atom.make<MessageId | null>(null).pipe(Atom.keepAlive),
threadOutboxShellStatusesAtom: Atom.make(new Map([["secondary", "live"]])),
};
});
vi.mock("./use-composer-drafts", async () => {
const { Atom } = await import("effect/reactivity");
return {
composerDraftsAtom: Atom.make({}),
removeDeliveredCloudQueuedMessage: async () => {},
appendComposerDraftAttachments: vi.fn(),
flushComposerDrafts: vi.fn(),
getComposerDraftSnapshot: vi.fn(() => ({ text: state.draftText, attachments: [] })),
mergeComposerDraftContent: vi.fn(async (_key: string, input: { text: string }) => {
state.draftText += `\n${input.text}`;
}),
replaceComposerDraftAttachments: vi.fn(),
setFreshSessionPending: vi.fn(),
undoComposerDraftMerge: vi.fn(),
updateComposerDraftSettings: vi.fn(),
waitForComposerDraftsLoaded: vi.fn(),
};
});
import { appAtomRegistry } from "./atom-registry";
import { environmentSession } from "./session";
import { dispatchingQueuedMessageIdAtom, editingQueuedMessageIdsAtom } from "./use-thread-outbox";
import { createThreadOutboxDelivery } from "./threadOutboxDelivery";
const message = (overrides: Partial<QueuedThreadMessage> = {}): QueuedThreadMessage => ({
environmentId: EnvironmentId.make("secondary"),
threadId: ThreadId.make("thread"),
commandId: CommandId.make("command"),
messageId: MessageId.make("message"),
text: "Keep this queued",
attachments: [],
createdAt: "2026-09-05T00:00:00.000Z",
...overrides,
});
const remaining = () =>
Object.values(appAtomRegistry.get(state.manager.queuedMessagesByThreadKeyAtom)).flat();
function setOperateGrant(environmentId: string, granted: boolean): void {
// The mocked session atom holds the grant itself (see the ./session mock).
const sessionAtom = environmentSession.sessionStateAtom(EnvironmentId.make(environmentId));
appAtomRegistry.set(sessionAtom as unknown as Atom.Writable<boolean>, granted);
}
function runDrain() {
const settled = Promise.withResolvers<void>();
const release = appAtomRegistry.subscribe(dispatchingQueuedMessageIdAtom, (id) => {
if (id === null) settled.resolve();
});
startDelivery();
return settled.promise.finally(release);
}
/** Starts the service once per test; later calls run another drain pass. */
function startDelivery(): void {
if (state.delivery !== null) {
state.delivery.drain();
return;
}
const delivery = createThreadOutboxDelivery();
state.delivery = delivery;
state.cleanups.push(() => {
delivery.dispose();
state.delivery = null;
});
}
beforeEach(() => {
setOperateGrant("primary", true);
setOperateGrant("secondary", false);
state.draftText = "Keep this draft separate";
state.config.shellThreadFamilies = false;
state.modelUnavailable.mockReset().mockReturnValue(false);
state.familyMount.mockReset().mockReturnValue(() => {});
appAtomRegistry.set(state.threadShells, [state.thread]);
appAtomRegistry.set(state.manager.queuedMessagesByThreadKeyAtom, {});
appAtomRegistry.set(dispatchingQueuedMessageIdAtom, null);
appAtomRegistry.set(editingQueuedMessageIdsAtom, {});
for (const command of [
state.start,
state.metadata,
state.runtime,
state.interaction,
state.checkout,
]) {
command.mockReset().mockResolvedValue(AsyncResult.success(undefined));
}
state.start.mockResolvedValue(AsyncResult.success({}));
state.prepare.mockReset().mockImplementation(async ({ attachments }) => ({
status: "ready",
attachments: [],
draftAttachments: attachments,
pendingAttachmentIds: [],
}));
});
describe("queued PR checkout", () => {
const queuedPullRequest = () =>
message({
threadId: ThreadId.make("new-pr-thread"),
modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" },
creation: {
projectId: ProjectId.make("project"),
projectCwd: "/repo",
workspaceMode: "worktree",
branch: "fork/feature",
worktreePath: null,
pullRequestReference: "https://github.com/acme/repo/pull/123",
},
});
const preparedCheckout = {
branch: "pr-123",
worktreePath: "/repo/.t3/worktrees/pr-123",
isOnPullRequestHead: true,
};
it("waits for the provider's PR checkout and launches in that worktree", async () => {
setOperateGrant("secondary", true);
await state.manager.enqueue(queuedPullRequest());
const started = Promise.withResolvers<void>();
const checkout =
Promise.withResolvers<AsyncResult.AsyncResult<typeof preparedCheckout, Error>>();
state.checkout.mockImplementationOnce(() => {
started.resolve();
return checkout.promise;
});
const drained = runDrain();
await started.promise;
expect(state.start).not.toHaveBeenCalled();
expect(state.checkout).toHaveBeenCalledWith({
environmentId: "secondary",
input: { cwd: "/repo", reference: "https://github.com/acme/repo/pull/123", mode: "worktree" },
});
checkout.resolve(AsyncResult.success(preparedCheckout));
await drained;
expect(state.start).toHaveBeenCalledOnce();
const bootstrap = state.start.mock.calls[0]?.[0].input.bootstrap;
expect(bootstrap.createThread).toMatchObject({
branch: "pr-123",
worktreePath: preparedCheckout.worktreePath,
});
expect(bootstrap.prepareWorktree).toBeUndefined();
expect(remaining()).toEqual([]);
});
it("keeps the PR source queued on a transport failure without starting the agent", async () => {
setOperateGrant("secondary", true);
const queued = queuedPullRequest();
await state.manager.enqueue(queued);
state.checkout.mockResolvedValueOnce(
AsyncResult.failure(Cause.fail(new Error("Socket is not connected"))),
);
await runDrain();
expect(state.start).not.toHaveBeenCalled();
expect(remaining()).toEqual([queued]);
});
it("stops launch if operation access is revoked while checking out the PR", async () => {
setOperateGrant("secondary", true);
const queued = queuedPullRequest();
await state.manager.enqueue(queued);
state.checkout.mockImplementationOnce(async () => {
setOperateGrant("secondary", false);
return AsyncResult.success(preparedCheckout);
});
await runDrain();
expect(state.start).not.toHaveBeenCalled();
expect(remaining()).toEqual([queued]);
});
it("does not launch a stale task edited while the PR checkout was running", async () => {
setOperateGrant("secondary", true);
const queued = queuedPullRequest();
await state.manager.enqueue(queued);
const edited = { ...queued, text: "Updated instructions" };
state.checkout.mockImplementationOnce(async () => {
await state.manager.update(edited);
return AsyncResult.success(preparedCheckout);
});
await runDrain();
expect(state.start).not.toHaveBeenCalled();
expect(remaining()).toEqual([edited]);
});
});
afterEach(() => {
state.cleanups.splice(0).forEach((cleanup) => cleanup());
});
describe("queued task operation access", () => {
it("parks a connected read-only target, then delivers its unchanged queue after a grant", async () => {
const queued = message();
await state.manager.enqueue(queued);
startDelivery();
expect(state.start).not.toHaveBeenCalled();
expect(state.prepare).not.toHaveBeenCalled();
expect(remaining()).toEqual([queued]);
setOperateGrant("secondary", true);
await runDrain();
expect(state.start).toHaveBeenCalledOnce();
expect(remaining()).toEqual([]);
});
it("backs off instead of redelivering at once when a delivery hits a defect", async () => {
setOperateGrant("secondary", true);
const queued = message();
await state.manager.enqueue(queued);
// Awaited steps catch their own failures, so a defect in the delivery's own code is what
// rejects a delivery.
state.modelUnavailable.mockImplementationOnce(() => {
throw new TypeError("Cannot read properties of undefined");
});
await runDrain();
expect(state.modelUnavailable).toHaveBeenCalledOnce();
expect(state.prepare).not.toHaveBeenCalled();
expect(state.start).not.toHaveBeenCalled();
expect(appAtomRegistry.get(dispatchingQueuedMessageIdAtom)).toBeNull();
expect(remaining()).toEqual([queued]);
});
it("starts one delivery when mounting a thread family changes the rows mid-pass", async () => {
setOperateGrant("secondary", true);
state.config.shellThreadFamilies = true;
const subAgentThread = { ...state.thread, id: "sub-agent" };
// A cached family merges its rows into the shell list as soon as it is mounted.
state.familyMount.mockImplementationOnce(() => {
appAtomRegistry.set(state.threadShells, [state.thread, subAgentThread]);
return () => {};
});
const queued = message({ threadId: ThreadId.make("sub-agent") });
startDelivery();
appAtomRegistry.set(editingQueuedMessageIdsAtom, { [queued.messageId]: true });
await state.manager.enqueue(queued);
using confirm = vi.spyOn(state.manager, "confirmQueued");
const delivered = Promise.withResolvers<void>();
const release = appAtomRegistry.subscribe(dispatchingQueuedMessageIdAtom, (id) => {
if (id === null) 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.
appAtomRegistry.set(editingQueuedMessageIdsAtom, {});
expect(state.familyMount).toHaveBeenCalledOnce();
expect(confirm).toHaveBeenCalledOnce();
await delivered.promise.finally(release);
expect(state.start).toHaveBeenCalledOnce();
expect(remaining()).toEqual([]);
});
it("stops the remaining settings and turn commands when an earlier update loses access", async () => {
setOperateGrant("secondary", true);
const queued = message({
modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "different-model" },
runtimeMode: "approval-required",
interactionMode: "plan",
});
await state.manager.enqueue(queued);
state.runtime.mockImplementationOnce(async () => {
setOperateGrant("secondary", false);
return AsyncResult.success(undefined);
});
await runDrain();
expect(state.runtime).toHaveBeenCalledOnce();
expect(state.interaction).not.toHaveBeenCalled();
expect(state.prepare).not.toHaveBeenCalled();
expect(state.start).not.toHaveBeenCalled();
expect(remaining()).toEqual([queued]);
});
it.each([
{ isCreation: false, accepted: false },
{ isCreation: true, accepted: true },
])(
"preserves a rejected queue but removes an accepted turn after access loss (new task: $isCreation, accepted: $accepted)",
async ({ isCreation, accepted }) => {
setOperateGrant("secondary", true);
const queued = message(
isCreation
? {
threadId: ThreadId.make("new-thread"),
modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" },
creation: {
projectId: ProjectId.make("project"),
projectCwd: "/repo",
workspaceMode: "local",
branch: null,
worktreePath: null,
},
}
: {},
);
await state.manager.enqueue(queued);
const started = Promise.withResolvers<void>();
const delivery =
Promise.withResolvers<AsyncResult.AsyncResult<{ readonly sequence?: number }, Error>>();
state.start.mockImplementationOnce(() => {
started.resolve();
return delivery.promise;
});
const drained = runDrain();
await started.promise;
setOperateGrant("secondary", false);
delivery.resolve(
accepted
? AsyncResult.success({})
: AsyncResult.failure(Cause.fail(new Error("This connection cannot control this task."))),
);
await drained;
expect(remaining()).toEqual(accepted ? [] : [queued]);
expect(state.draftText).toBe("Keep this draft separate");
if (!accepted) {
setOperateGrant("secondary", true);
await runDrain();
expect(state.start).toHaveBeenCalledTimes(2);
expect(remaining()).toEqual([]);
expect(state.draftText).toBe("Keep this draft separate");
}
},
);
it.each([
{ isCreation: false, uploadFails: false },
{ isCreation: true, uploadFails: false },
{ isCreation: false, uploadFails: true },
{ isCreation: true, uploadFails: true },
])(
"keeps the message queued after upload revocation (new task: $isCreation, upload fails: $uploadFails)",
async ({ isCreation, uploadFails }) => {
setOperateGrant("secondary", true);
const queued = message(
isCreation
? {
threadId: ThreadId.make("new-thread"),
modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" },
creation: {
projectId: ProjectId.make("project"),
projectCwd: "/repo",
workspaceMode: "local",
branch: null,
worktreePath: null,
},
}
: {},
);
await state.manager.enqueue(queued);
state.prepare.mockImplementationOnce(async ({ attachments }) => {
setOperateGrant("secondary", false);
if (uploadFails) throw new Error("This connection cannot upload attachments.");
return {
status: "ready",
attachments: [],
draftAttachments: attachments,
pendingAttachmentIds: [],
};
});
await runDrain();
expect(state.prepare).toHaveBeenCalledOnce();
expect(state.start).not.toHaveBeenCalled();
expect(remaining()).toEqual([queued]);
},
);
});
describe("compaction before a queued send", () => {
const compactTurn = {
commandId: "command:compact",
message: {
messageId: "message:compact",
role: "user",
text: "/compact",
attachments: [],
idleCompaction: "onReturn",
},
dispatchMode: "queue",
};
it("queues /compact ahead of the message and resends the same /compact on a retry", async () => {
setOperateGrant("secondary", true);
const queued = message({ compactBeforeSend: true, dispatchMode: "queue" });
await state.manager.enqueue(queued);
state.start
.mockResolvedValueOnce(AsyncResult.success({}))
.mockResolvedValueOnce(AsyncResult.failure(Cause.fail(new Error("Socket is not connected"))));
await runDrain();
expect(remaining()).toEqual([queued]);
// A restarted app delivers the persisted message again.
state.cleanups.splice(0).forEach((cleanup) => cleanup());
await runDrain();
expect(state.start.mock.calls.map(([call]) => call.input)).toEqual([
expect.objectContaining(compactTurn),
expect.objectContaining({ commandId: "command", dispatchMode: "queue" }),
expect.objectContaining(compactTurn),
expect.objectContaining({ commandId: "command", dispatchMode: "queue" }),
]);
expect(remaining()).toEqual([]);
});
it("holds the message when its /compact cannot be sent", async () => {
setOperateGrant("secondary", true);
const queued = message({ compactBeforeSend: true, dispatchMode: "queue" });
await state.manager.enqueue(queued);
state.start.mockResolvedValueOnce(
AsyncResult.failure(Cause.fail(new Error("Socket is not connected"))),
);
await runDrain();
expect(state.start).toHaveBeenCalledOnce();
expect(state.start.mock.calls[0]?.[0].input).toMatchObject(compactTurn);
expect(remaining()).toEqual([queued]);
});
});