A desktop coding agent with free access to frontier models.
TypeScript
import { afterEach, describe, expect, jest, setSystemTime, spyOn, test } from "bun:test";
import type { SessionStatus } from "@opencode-ai/sdk/v2/client";
import type { OmniRushSessionSnapshot } from "../src/app/lib/omnirush-server";
import { markTaskRunStart, takeTaskRunStart } from "../src/app/lib/analytics";
import * as notifications from "../src/react-app/shell/desktop-notifications";
import { createClientV2, createV2EventTranslationState, translateV2Event } from "../src/app/lib/opencode-v2-adapter";
import { useSessionActivityStore } from "../src/react-app/domains/session/status/session-activity-store";
import {
__applySessionSyncEventForTest,
__createWorkspaceSessionSyncForTest,
__disposeWorkspaceSessionSyncForTest,
__resetWorkspaceSyncReconcileHealthForTest,
__revalidateWorkspaceSyncsForTest,
__setWorkspaceSessionSyncStatusFetcherForTest,
__setWorkspaceSessionSyncSubscriptionFactoryForTest,
ensureWorkspaceSessionSync,
getWorkspaceSessionSyncStreamPhase,
markSessionSnapshotFetchStart,
reconcileFailureDegradedThreshold,
revalidateWorkspaceSessionSync,
seedSessionState,
snapshotKey,
statusKey,
trackWorkspaceSessionSync,
transcriptKey,
useWorkspaceSyncStreamStore,
workspaceSyncStreamKey,
} from "../src/react-app/domains/session/sync/session-sync";
import { getReactQueryClient } from "../src/react-app/infra/query-client";
type SyncInput = {
workspaceId: string;
baseUrl: string;
omnirushToken: string;
};
type Subscription = {
signal: AbortSignal;
end: () => void;
};
const workspaceId = "workspace-run-status";
const sessionId = "session-run-status";
const syncInputs: SyncInput[] = [];
const subscriptions: Subscription[] = [];
function createSnapshot(status: SessionStatus): OmniRushSessionSnapshot {
return {
session: {
id: sessionId,
slug: sessionId,
projectID: "project-run-status",
directory: "/tmp/project-run-status",
title: "Run status test",
version: "1",
time: { created: 1, updated: 1 },
},
messages: [],
todos: [],
status,
};
}
function createSyncInput(): SyncInput {
const input = {
workspaceId,
baseUrl: "https://run-status.example/opencode",
omnirushToken: "token",
};
syncInputs.push(input);
return input;
}
function createTestSync() {
const input = createSyncInput();
const cleanup = __createWorkspaceSessionSyncForTest(input);
const releaseSession = trackWorkspaceSessionSync(input, sessionId);
return { input, cleanup, releaseSession };
}
async function createSubscription(_baseUrl: string, _token: string, signal: AbortSignal) {
let end = () => {};
const ended = new Promise<void>((resolve) => {
end = resolve;
});
signal.addEventListener("abort", end, { once: true });
async function* stream() {
await ended;
}
subscriptions.push({ signal, end });
return stream();
}
async function waitForSubscriptions(count: number) {
const deadline = Date.now() + 2_000;
while (subscriptions.length < count && Date.now() < deadline) {
await new Promise<void>((resolve) => setTimeout(resolve, 5));
}
expect(subscriptions).toHaveLength(count);
}
async function flushMicrotasks() {
for (let index = 0; index < 10; index += 1) await Promise.resolve();
}
function applyStatus(input: SyncInput, status: SessionStatus) {
__applySessionSyncEventForTest(input, {
type: "session.status",
properties: { sessionID: sessionId, status },
});
}
function applyCompletedToolAndFinalAnswer(input: SyncInput) {
__applySessionSyncEventForTest(input, {
type: "message.updated",
properties: {
info: {
id: "assistant-tool",
role: "assistant",
sessionID: sessionId,
time: { created: 1, completed: 2 },
},
},
} as any);
__applySessionSyncEventForTest(input, {
type: "message.part.updated",
properties: {
part: {
id: "part-tool",
sessionID: sessionId,
messageID: "assistant-tool",
type: "tool",
callID: "call-tool",
tool: "lookup",
state: {
status: "completed",
input: { query: "fixture" },
output: "fixture result",
title: "Lookup",
metadata: {},
time: { start: 1, end: 2 },
},
},
},
} as any);
__applySessionSyncEventForTest(input, {
type: "message.updated",
properties: {
info: {
id: "assistant-final",
role: "assistant",
sessionID: sessionId,
time: { created: 3, completed: 4 },
},
},
} as any);
__applySessionSyncEventForTest(input, {
type: "message.part.updated",
properties: {
part: {
id: "part-final",
sessionID: sessionId,
messageID: "assistant-final",
type: "text",
text: "The final answer is visible.",
},
},
} as any);
}
afterEach(() => {
jest.restoreAllMocks();
takeTaskRunStart(sessionId);
jest.useRealTimers();
for (const input of syncInputs) __disposeWorkspaceSessionSyncForTest(input);
syncInputs.length = 0;
subscriptions.length = 0;
__setWorkspaceSessionSyncSubscriptionFactoryForTest(null);
__setWorkspaceSessionSyncStatusFetcherForTest(null);
useSessionActivityStore.setState({ recordsByWorkspaceId: {}, statusesByWorkspaceId: {} });
useWorkspaceSyncStreamStore.setState({ phasesByKey: {} });
__resetWorkspaceSyncReconcileHealthForTest();
getReactQueryClient().clear();
setSystemTime();
});
describe("native v2 run lifecycle", () => {
function nativeSync() {
const input = { workspaceId, baseUrl: "https://run-status.example/opencode2", omnirushToken: "token" };
syncInputs.push(input);
__createWorkspaceSessionSyncForTest(input);
trackWorkspaceSessionSync(input, sessionId);
const state = createV2EventTranslationState();
return { input, emit(type: string, sequence: number, data: Record<string, unknown> = {}) {
for (const event of translateV2Event({ type, durable: { seq: sequence }, data: { sessionID: sessionId, ...data } }, state) ?? []) {
__applySessionSyncEventForTest(input, event);
}
} };
}
test("independent native active clients cannot erase retry detail, but progress can", async () => {
jest.useFakeTimers();
const originalFetch = globalThis.fetch;
globalThis.fetch = async () => Response.json({ data: { [sessionId]: { type: "running" } } });
__setWorkspaceSessionSyncStatusFetcherForTest(async (url, token, signal) => {
const result = await createClientV2(url, undefined, { token }).session.status(undefined, { signal });
if (!result.data) throw result.error;
return result.data;
});
try {
const { emit } = nativeSync();
emit("session.execution.started", 1);
const retry = { type: "retry", attempt: 2, message: "Rate limited", next: 1_000 };
emit("session.retry.scheduled", 2, { attempt: 2, at: 1_000, error: { message: "Rate limited" } });
for (let i = 0; i < 3; i++) {
jest.advanceTimersByTime(5_000);
await flushMicrotasks();
expect(getReactQueryClient().getQueryData(statusKey(workspaceId, sessionId))).toEqual(retry);
}
const snapshot = createSnapshot({ type: "busy" });
markSessionSnapshotFetchStart(snapshot, Date.now());
seedSessionState(workspaceId, snapshot);
expect(getReactQueryClient().getQueryData(statusKey(workspaceId, sessionId))).toEqual(retry);
emit("session.step.started", 3);
expect(getReactQueryClient().getQueryData(statusKey(workspaceId, sessionId))).toEqual({ type: "busy" });
emit("session.retry.scheduled", 2, { attempt: 2, at: 1_000, error: { message: "Rate limited" } });
expect(getReactQueryClient().getQueryData(statusKey(workspaceId, sessionId))).toEqual({ type: "busy" });
} finally { globalThis.fetch = originalFetch; }
});
test.each(["user", "shutdown", "superseded", "unknown"])("%s interruption never reports completed or stops a newer execution", async (reason) => {
jest.useFakeTimers();
const notify = spyOn(notifications, "notifyDesktopEvent").mockImplementation(() => {});
__setWorkspaceSessionSyncStatusFetcherForTest(async () => ({}));
const { emit } = nativeSync();
markTaskRunStart(sessionId);
emit("session.execution.started", 1);
emit("session.execution.interrupted", 2, { reason });
expect(useSessionActivityStore.getState().recordsByWorkspaceId[workspaceId]?.[sessionId]?.runActive).toBe(reason !== "user");
jest.advanceTimersByTime(250);
await flushMicrotasks();
expect(notify.mock.calls.some(([event]) => event.type === "task.completed")).toBe(false);
markTaskRunStart(sessionId);
emit("session.execution.started", 3);
emit("session.execution.interrupted", 2, { reason });
expect(useSessionActivityStore.getState().recordsByWorkspaceId[workspaceId]?.[sessionId]?.runActive).toBe(true);
emit("session.execution.succeeded", 4);
emit("session.execution.succeeded", 4);
expect(notify.mock.calls.filter(([event]) => event.type === "task.completed")).toHaveLength(1);
});
test("a same-clock late idle read cannot settle a successor and coarse idle is not success", async () => {
jest.useFakeTimers();
const notify = spyOn(notifications, "notifyDesktopEvent").mockImplementation(() => {});
let resolve: (value: Record<string, SessionStatus>) => void = () => {};
__setWorkspaceSessionSyncStatusFetcherForTest(() => new Promise((done) => { resolve = done; }));
const { emit } = nativeSync();
markTaskRunStart(sessionId);
emit("session.execution.started", 1);
jest.advanceTimersByTime(250);
await flushMicrotasks();
emit("session.execution.started", 3);
resolve({});
await flushMicrotasks();
expect(useSessionActivityStore.getState().recordsByWorkspaceId[workspaceId]?.[sessionId]?.runActive).toBe(true);
jest.advanceTimersByTime(250);
await flushMicrotasks();
resolve({});
await flushMicrotasks();
expect(useSessionActivityStore.getState().recordsByWorkspaceId[workspaceId]?.[sessionId]?.runActive).toBe(false);
expect(notify).not.toHaveBeenCalled();
});
test("terminal listeners cannot have a queued successor's tracking consumed", () => {
const input = { workspaceId, baseUrl: "https://run-status.example/opencode2", omnirushToken: "token",
onSessionStatus: ({ status }: { status: SessionStatus }) => { if (status.type === "idle") markTaskRunStart(sessionId); } };
syncInputs.push(input);
__createWorkspaceSessionSyncForTest(input);
markTaskRunStart(sessionId);
__applySessionSyncEventForTest(input, { type: "session.execution.interrupted", properties: { sessionID: sessionId, reason: "user", sequence: 2 } });
expect(takeTaskRunStart(sessionId)).not.toBeNull();
});
});
describe("session run status ordering", () => {
test("preserves the activity snapshot when workspace seeds are unchanged", () => {
const store = useSessionActivityStore.getState();
store.seedWorkspaceSessions(workspaceId, [{ id: sessionId, status: { type: "idle" } }]);
const before = useSessionActivityStore.getState();
let notifications = 0;
const unsubscribe = useSessionActivityStore.subscribe(() => {
notifications += 1;
});
for (let index = 0; index < 60; index += 1) {
useSessionActivityStore.getState().seedWorkspaceSessions(
workspaceId,
[{ id: sessionId, status: { type: "idle" } }],
);
}
expect(useSessionActivityStore.getState()).toBe(before);
expect(notifications).toBe(0);
useSessionActivityStore.getState().seedWorkspaceSessions(
workspaceId,
[{ id: sessionId, status: { type: "busy" } }],
);
unsubscribe();
expect(useSessionActivityStore.getState()).not.toBe(before);
expect(useSessionActivityStore.getState().getStatus(workspaceId, sessionId)).toBe("thinking");
expect(notifications).toBe(1);
});
test("does not publish duplicate activity observations", () => {
useSessionActivityStore.getState().setRunStatus(workspaceId, sessionId, { type: "busy" });
useSessionActivityStore.getState().markMessageRole(workspaceId, sessionId, "assistant-1", "assistant");
useSessionActivityStore.getState().markAssistantOutput(workspaceId, sessionId, "assistant-1");
const before = useSessionActivityStore.getState().recordsByWorkspaceId[workspaceId]?.[sessionId];
let notifications = 0;
const unsubscribe = useSessionActivityStore.subscribe(() => {
notifications += 1;
});
useSessionActivityStore.getState().markMessageRole(workspaceId, sessionId, "assistant-1", "assistant");
useSessionActivityStore.getState().markAssistantOutput(workspaceId, sessionId, "assistant-1");
useSessionActivityStore.getState().replaceWaitingRequests(workspaceId, sessionId, "permission", []);
useSessionActivityStore.getState().clearError(workspaceId, sessionId);
useSessionActivityStore.getState().setCompacting(workspaceId, sessionId, false);
unsubscribe();
expect(useSessionActivityStore.getState().recordsByWorkspaceId[workspaceId]?.[sessionId]).toBe(before);
expect(notifications).toBe(0);
});
test("invalidates the durable snapshot when a tracked run becomes idle", () => {
const { input, cleanup, releaseSession } = createTestSync();
const queryClient = getReactQueryClient();
queryClient.setQueryData(snapshotKey(workspaceId, sessionId), createSnapshot({ type: "busy" }));
__applySessionSyncEventForTest(input, {
type: "session.idle",
properties: { sessionID: sessionId },
});
expect(queryClient.getQueryState(snapshotKey(workspaceId, sessionId))?.isInvalidated).toBe(true);
releaseSession();
cleanup();
});
test("clears the busy status cache when a run errors without a following idle", () => {
const statusUpdates: SessionStatus[] = [];
const input = {
workspaceId,
baseUrl: "https://run-status.example/opencode",
omnirushToken: "token",
onSessionStatus: (update: { sessionId: string; status: SessionStatus }) => {
statusUpdates.push(update.status);
},
};
syncInputs.push(input);
const cleanup = __createWorkspaceSessionSyncForTest(input);
const releaseSession = trackWorkspaceSessionSync(input, sessionId);
applyStatus(input, { type: "busy" });
expect(getReactQueryClient().getQueryData(statusKey(workspaceId, sessionId))).toEqual({ type: "busy" });
__applySessionSyncEventForTest(input, {
type: "session.error",
properties: {
sessionID: sessionId,
error: { name: "UnknownError", data: { message: "provider exploded" } },
},
});
// The chat surface derives its thread status from this cache: an errored
// run must stop reading busy, or the "Working…" row ticks forever beside
// the error card when the engine never sends a follow-up idle event.
expect(getReactQueryClient().getQueryData(statusKey(workspaceId, sessionId))).toEqual({ type: "idle" });
expect(useSessionActivityStore.getState().recordsByWorkspaceId[workspaceId]?.[sessionId]?.status).toBe("error");
// Status listeners (like the queued-send drainer) get the same idle edge
// session.idle would have delivered, so queued sends are not wedged.
expect(statusUpdates.at(-1)).toEqual({ type: "idle" });
releaseSession();
cleanup();
});
test("does not resurrect a finished run from a stale busy snapshot", async () => {
jest.useFakeTimers();
let statusFetches = 0;
__setWorkspaceSessionSyncStatusFetcherForTest(async () => {
statusFetches += 1;
return {};
});
const { input, cleanup, releaseSession } = createTestSync();
const snapshot = createSnapshot({ type: "busy" });
markSessionSnapshotFetchStart(snapshot, 100);
setSystemTime(200);
applyStatus(input, { type: "busy" });
setSystemTime(300);
__applySessionSyncEventForTest(input, {
type: "session.idle",
properties: { sessionID: sessionId },
});
seedSessionState(workspaceId, snapshot);
expect(useSessionActivityStore.getState().recordsByWorkspaceId[workspaceId]?.[sessionId]?.status).toBe("idle");
expect(getReactQueryClient().getQueryData(statusKey(workspaceId, sessionId))).toEqual({ type: "idle" });
jest.advanceTimersByTime(1_000);
await flushMicrotasks();
expect(statusFetches).toBe(0);
releaseSession();
cleanup();
});
test("does not let an older idle snapshot stop a live run", () => {
setSystemTime(200);
useSessionActivityStore.getState().setRunStatus(workspaceId, sessionId, { type: "busy" });
useSessionActivityStore.getState().seedSessionRun(
workspaceId,
sessionId,
{ type: "idle" },
false,
{ snapshotStartedAt: 100 },
);
expect(useSessionActivityStore.getState().recordsByWorkspaceId[workspaceId]?.[sessionId]?.runActive).toBe(true);
});
test("lets a newer idle snapshot heal a stale active record", () => {
setSystemTime(100);
useSessionActivityStore.getState().setRunStatus(workspaceId, sessionId, { type: "busy" });
useSessionActivityStore.getState().seedSessionRun(
workspaceId,
sessionId,
{ type: "idle" },
false,
{ snapshotStartedAt: 200 },
);
expect(useSessionActivityStore.getState().recordsByWorkspaceId[workspaceId]?.[sessionId]?.status).toBe("idle");
});
test("ignores run state from unmarked snapshot objects", () => {
setSystemTime(100);
useSessionActivityStore.getState().setRunStatus(workspaceId, sessionId, { type: "idle" });
getReactQueryClient().setQueryData(statusKey(workspaceId, sessionId), { type: "idle" });
seedSessionState(workspaceId, createSnapshot({ type: "busy" }));
expect(useSessionActivityStore.getState().recordsByWorkspaceId[workspaceId]?.[sessionId]?.status).toBe("idle");
expect(getReactQueryClient().getQueryData(statusKey(workspaceId, sessionId))).toEqual({ type: "idle" });
});
test("preserves assistant output when an active seed omits it", () => {
setSystemTime(100);
useSessionActivityStore.getState().setRunStatus(workspaceId, sessionId, { type: "busy" });
useSessionActivityStore.getState().markAssistantOutput(workspaceId, sessionId);
useSessionActivityStore.getState().seedSessionRun(
workspaceId,
sessionId,
{ type: "busy" },
undefined,
{ snapshotStartedAt: 200 },
);
const record = useSessionActivityStore.getState().recordsByWorkspaceId[workspaceId]?.[sessionId];
expect(record?.assistantOutput).toBe(true);
expect(record?.status).toBe("responding");
});
});
describe("session run status reconnect reconciliation", () => {
test("seeds a missed busy edge into the status cache on connect", async () => {
__setWorkspaceSessionSyncSubscriptionFactoryForTest(createSubscription);
__setWorkspaceSessionSyncStatusFetcherForTest(async () => ({ [sessionId]: { type: "busy" } }));
setSystemTime(100);
const input = createSyncInput();
ensureWorkspaceSessionSync(input);
const releaseSession = trackWorkspaceSessionSync(input, sessionId);
await waitForSubscriptions(1);
await flushMicrotasks();
expect(useSessionActivityStore.getState().recordsByWorkspaceId[workspaceId]?.[sessionId]?.status).toBe("thinking");
expect(getReactQueryClient().getQueryData(statusKey(workspaceId, sessionId))).toEqual({ type: "busy" });
releaseSession();
});
test("does not clobber a newer live status with a stale reconnect fetch", async () => {
__setWorkspaceSessionSyncSubscriptionFactoryForTest(createSubscription);
let resolveStatuses: (statuses: Record<string, SessionStatus>) => void = () => {};
__setWorkspaceSessionSyncStatusFetcherForTest(() => new Promise((resolve) => {
resolveStatuses = resolve;
}));
setSystemTime(100);
const input = createSyncInput();
ensureWorkspaceSessionSync(input);
const releaseSession = trackWorkspaceSessionSync(input, sessionId);
await waitForSubscriptions(1);
await flushMicrotasks();
setSystemTime(200);
applyStatus(input, { type: "busy" });
resolveStatuses({});
await flushMicrotasks();
expect(useSessionActivityStore.getState().recordsByWorkspaceId[workspaceId]?.[sessionId]?.runActive).toBe(true);
expect(getReactQueryClient().getQueryData(statusKey(workspaceId, sessionId))).toEqual({ type: "busy" });
releaseSession();
});
test("does not resurrect an idle run from an older reconnect snapshot", async () => {
__setWorkspaceSessionSyncSubscriptionFactoryForTest(createSubscription);
let resolveStatuses: (statuses: Record<string, SessionStatus>) => void = () => {};
__setWorkspaceSessionSyncStatusFetcherForTest(() => new Promise((resolve) => {
resolveStatuses = resolve;
}));
setSystemTime(100);
const input = createSyncInput();
ensureWorkspaceSessionSync(input);
const releaseSession = trackWorkspaceSessionSync(input, sessionId);
await waitForSubscriptions(1);
await flushMicrotasks();
setSystemTime(200);
applyStatus(input, { type: "busy" });
setSystemTime(300);
applyStatus(input, { type: "idle" });
resolveStatuses({ [sessionId]: { type: "busy" } });
await flushMicrotasks();
expect(useSessionActivityStore.getState().recordsByWorkspaceId[workspaceId]?.[sessionId]?.runActive).toBe(false);
expect(getReactQueryClient().getQueryData(statusKey(workspaceId, sessionId))).toEqual({ type: "idle" });
releaseSession();
});
test("heals an active record when a reconnect reports no active run", async () => {
__setWorkspaceSessionSyncSubscriptionFactoryForTest(createSubscription);
__setWorkspaceSessionSyncStatusFetcherForTest(async () => ({}));
setSystemTime(100);
const input = createSyncInput();
ensureWorkspaceSessionSync(input);
await waitForSubscriptions(1);
await flushMicrotasks();
setSystemTime(200);
applyStatus(input, { type: "busy" });
jest.useFakeTimers();
subscriptions[0]?.end();
await flushMicrotasks();
jest.advanceTimersByTime(1_000);
await flushMicrotasks();
expect(subscriptions).toHaveLength(2);
expect(useSessionActivityStore.getState().recordsByWorkspaceId[workspaceId]?.[sessionId]?.status).toBe("idle");
});
test("keeps the stream and run state intact when reconciliation fails", async () => {
__setWorkspaceSessionSyncSubscriptionFactoryForTest(createSubscription);
__setWorkspaceSessionSyncStatusFetcherForTest(async () => {
throw new Error("status unavailable");
});
setSystemTime(100);
const input = createSyncInput();
ensureWorkspaceSessionSync(input);
await waitForSubscriptions(1);
await flushMicrotasks();
setSystemTime(200);
applyStatus(input, { type: "busy" });
jest.useFakeTimers();
subscriptions[0]?.end();
await flushMicrotasks();
jest.advanceTimersByTime(1_000);
await flushMicrotasks();
expect(subscriptions).toHaveLength(2);
expect(subscriptions[1]?.signal.aborted).toBe(false);
expect(useSessionActivityStore.getState().recordsByWorkspaceId[workspaceId]?.[sessionId]?.runActive).toBe(true);
});
});
describe("active session status reconciliation", () => {
test("converges a missed terminal edge to idle without losing the completed tool or final answer", async () => {
jest.useFakeTimers();
setSystemTime(100);
let statusFetches = 0;
__setWorkspaceSessionSyncStatusFetcherForTest(async () => {
statusFetches += 1;
return {};
});
const { input, cleanup, releaseSession } = createTestSync();
const queryClient = getReactQueryClient();
queryClient.setQueryData(snapshotKey(workspaceId, sessionId), createSnapshot({ type: "busy" }));
applyStatus(input, { type: "busy" });
applyCompletedToolAndFinalAnswer(input);
const before = queryClient.getQueryData<any[]>(transcriptKey(workspaceId, sessionId));
expect(before?.[0]?.parts[0]).toMatchObject({
type: "dynamic-tool",
state: "output-available",
output: "fixture result",
});
expect(before?.[1]?.parts[0]).toMatchObject({
type: "text",
text: "The final answer is visible.",
});
// Final assistant text is presentation, not a terminal signal. Until the
// authoritative level says otherwise, both activity and status stay busy.
expect(useSessionActivityStore.getState().getStatus(workspaceId, sessionId)).toBe("responding");
expect(queryClient.getQueryData(statusKey(workspaceId, sessionId))).toEqual({ type: "busy" });
// No session.status idle or session.idle event arrives. The long-lived
// stream remains open; only the authoritative status level reports that
// the run has ended.
setSystemTime(350);
jest.advanceTimersByTime(250);
await flushMicrotasks();
expect(statusFetches).toBe(1);
expect(useSessionActivityStore.getState().getStatus(workspaceId, sessionId)).toBe("idle");
expect(queryClient.getQueryData(statusKey(workspaceId, sessionId))).toEqual({ type: "idle" });
expect(queryClient.getQueryState(snapshotKey(workspaceId, sessionId))?.isInvalidated).toBe(true);
const after = queryClient.getQueryData<any[]>(transcriptKey(workspaceId, sessionId));
expect(after?.[1]?.parts[0]).toMatchObject({
type: "text",
text: "The final answer is visible.",
});
releaseSession();
cleanup();
});
test("validates a busy status seeded only from the durable snapshot", async () => {
jest.useFakeTimers();
setSystemTime(100);
let statusFetches = 0;
__setWorkspaceSessionSyncStatusFetcherForTest(async () => {
statusFetches += 1;
return {};
});
const { cleanup, releaseSession } = createTestSync();
const queryClient = getReactQueryClient();
// Neither a busy nor a terminal stream edge arrives for this snapshot.
const snapshot = createSnapshot({ type: "busy" });
markSessionSnapshotFetchStart(snapshot, 100);
seedSessionState(workspaceId, snapshot);
seedSessionState(workspaceId, snapshot);
expect(useSessionActivityStore.getState().getStatus(workspaceId, sessionId)).toBe("thinking");
expect(queryClient.getQueryData(statusKey(workspaceId, sessionId))).toEqual({ type: "busy" });
setSystemTime(350);
jest.advanceTimersByTime(250);
await flushMicrotasks();
expect(statusFetches).toBe(1);
expect(useSessionActivityStore.getState().getStatus(workspaceId, sessionId)).toBe("idle");
expect(queryClient.getQueryData(statusKey(workspaceId, sessionId))).toEqual({ type: "idle" });
jest.advanceTimersByTime(1_000);
await flushMicrotasks();
expect(statusFetches).toBe(1);
releaseSession();
cleanup();
});
test("does not start validation for an idle snapshot", async () => {
jest.useFakeTimers();
setSystemTime(100);
let statusFetches = 0;
__setWorkspaceSessionSyncStatusFetcherForTest(async () => {
statusFetches += 1;
return {};
});
const { cleanup, releaseSession } = createTestSync();
const snapshot = createSnapshot({ type: "idle" });
markSessionSnapshotFetchStart(snapshot, 100);
seedSessionState(workspaceId, snapshot);
jest.advanceTimersByTime(1_000);
await flushMicrotasks();
expect(statusFetches).toBe(0);
expect(useSessionActivityStore.getState().getStatus(workspaceId, sessionId)).toBe("idle");
releaseSession();
cleanup();
});
test("keeps genuine tool, retry, waiting, and compaction work active until status is authoritatively idle", async () => {
jest.useFakeTimers();
setSystemTime(100);
let status: Record<string, SessionStatus> = { [sessionId]: { type: "busy" } };
__setWorkspaceSessionSyncStatusFetcherForTest(async () => status);
const { input, cleanup, releaseSession } = createTestSync();
applyStatus(input, { type: "busy" });
useSessionActivityStore.getState().setWaitingRequest(
workspaceId,
sessionId,
"permission",
"permission-1",
true,
);
jest.advanceTimersByTime(250);
await flushMicrotasks();
expect(useSessionActivityStore.getState().getStatus(workspaceId, sessionId)).toBe("waiting");
useSessionActivityStore.getState().setWaitingRequest(
workspaceId,
sessionId,
"permission",
"permission-1",
false,
);
useSessionActivityStore.getState().setCompacting(workspaceId, sessionId, true);
status = {
[sessionId]: {
type: "retry",
attempt: 1,
message: "retrying",
next: 1_000,
},
};
jest.advanceTimersByTime(250);
await flushMicrotasks();
expect(useSessionActivityStore.getState().getStatus(workspaceId, sessionId)).toBe("compacting");
expect(useSessionActivityStore.getState().recordsByWorkspaceId[workspaceId]?.[sessionId]?.runActive).toBe(true);
status = {};
jest.advanceTimersByTime(250);
await flushMicrotasks();
expect(useSessionActivityStore.getState().getStatus(workspaceId, sessionId)).toBe("idle");
releaseSession();
cleanup();
});
test("keeps a newer busy edge when an older idle poll resolves after a queued follow-up starts", async () => {
jest.useFakeTimers();
setSystemTime(100);
let resolveStatuses: (statuses: Record<string, SessionStatus>) => void = () => {};
__setWorkspaceSessionSyncStatusFetcherForTest(() => new Promise((resolve) => {
resolveStatuses = resolve;
}));
const { input, cleanup, releaseSession } = createTestSync();
applyStatus(input, { type: "busy" });
setSystemTime(350);
jest.advanceTimersByTime(250);
await flushMicrotasks();
// A queued follow-up starts while the older status request is in flight.
// Its live edge must win over the stale empty snapshot.
setSystemTime(Date.now() + 100);
applyStatus(input, { type: "busy" });
resolveStatuses({});
await flushMicrotasks();
expect(useSessionActivityStore.getState().recordsByWorkspaceId[workspaceId]?.[sessionId]?.runActive).toBe(true);
expect(getReactQueryClient().getQueryData(statusKey(workspaceId, sessionId))).toEqual({ type: "busy" });
releaseSession();
cleanup();
});
test("accepts terminal-before-close, reordered final content, and duplicate terminal events", async () => {
__setWorkspaceSessionSyncSubscriptionFactoryForTest(createSubscription);
__setWorkspaceSessionSyncStatusFetcherForTest(async () => ({}));
setSystemTime(100);
const input = createSyncInput();
ensureWorkspaceSessionSync(input);
const releaseSession = trackWorkspaceSessionSync(input, sessionId);
await waitForSubscriptions(1);
await flushMicrotasks();
applyStatus(input, { type: "busy" });
setSystemTime(200);
__applySessionSyncEventForTest(input, {
type: "session.idle",
properties: { sessionID: sessionId },
});
// The event transport is intentionally still open when terminal status
// arrives, and final content is delivered after it.
expect(subscriptions[0]?.signal.aborted).toBe(false);
expect(useSessionActivityStore.getState().getStatus(workspaceId, sessionId)).toBe("idle");
applyCompletedToolAndFinalAnswer(input);
// Duplicate modern and deprecated terminal events remain idempotent.
applyStatus(input, { type: "idle" });
__applySessionSyncEventForTest(input, {
type: "session.idle",
properties: { sessionID: sessionId },
});
const transcript = getReactQueryClient().getQueryData<any[]>(transcriptKey(workspaceId, sessionId));
expect(transcript?.[1]?.parts[0]).toMatchObject({
type: "text",
text: "The final answer is visible.",
});
expect(useSessionActivityStore.getState().getStatus(workspaceId, sessionId)).toBe("idle");
expect(subscriptions[0]?.signal.aborted).toBe(false);
releaseSession();
});
});
describe("run status reconcile liveness health", () => {
// Distinct per-test stream keys: liveness health is keyed by
// workspace+baseUrl, and these assertions must not observe residue from
// other tests that share the default sync input.
function createHealthTestSync(label: string) {
const input = {
workspaceId,
baseUrl: `https://run-status-health-${label}.example/opencode`,
omnirushToken: "token",
};
syncInputs.push(input);
const cleanup = __createWorkspaceSessionSyncForTest(input);
const releaseSession = trackWorkspaceSessionSync(input, sessionId);
return { input, cleanup, releaseSession };
}
test("records consecutive failed revalidations without fabricating idle", async () => {
jest.useFakeTimers();
setSystemTime(100);
__setWorkspaceSessionSyncStatusFetcherForTest(async () => {
throw new Error("status unreachable");
});
const { input, cleanup, releaseSession } = createHealthTestSync("failures");
applyStatus(input, { type: "busy" });
for (let attempt = 0; attempt < reconcileFailureDegradedThreshold; attempt += 1) {
jest.advanceTimersByTime(250);
await flushMicrotasks();
}
const health = useWorkspaceSyncStreamStore.getState().reconcileHealthByKey[workspaceSyncStreamKey(input)];
expect(health?.consecutiveFailures).toBeGreaterThanOrEqual(reconcileFailureDegradedThreshold);
// A failed validation is evidence the busy state cannot be confirmed,
// never evidence that work stopped: the run state must stay busy.
expect(useSessionActivityStore.getState().recordsByWorkspaceId[workspaceId]?.[sessionId]?.runActive).toBe(true);
expect(getReactQueryClient().getQueryData(statusKey(workspaceId, sessionId))).toEqual({ type: "busy" });
releaseSession();
cleanup();
});
test("freezes the last confirmed time at the first failure and resets on recovery", () => {
const key = "workspace-run-status:https://run-status-health-store.example/opencode";
const store = useWorkspaceSyncStreamStore.getState();
// Healthy validations do not create store records (they would notify
// subscribers every 250ms for no visible change); the success time is
// remembered so the first failure can freeze it.
store.publishReconcileSuccess(key, 200);
expect(useWorkspaceSyncStreamStore.getState().reconcileHealthByKey[key]).toBeUndefined();
store.publishReconcileFailure(key);
expect(useWorkspaceSyncStreamStore.getState().reconcileHealthByKey[key]).toEqual({
consecutiveFailures: 1,
lastSuccessAt: 200,
});
store.publishReconcileFailure(key);
expect(useWorkspaceSyncStreamStore.getState().reconcileHealthByKey[key]).toEqual({
consecutiveFailures: 2,
lastSuccessAt: 200,
});
store.publishReconcileSuccess(key, 400);
expect(useWorkspaceSyncStreamStore.getState().reconcileHealthByKey[key]).toEqual({
consecutiveFailures: 0,
lastSuccessAt: 400,
});
});
test("does not count aborted revalidations as failures", async () => {
jest.useFakeTimers();
setSystemTime(100);
__setWorkspaceSessionSyncStatusFetcherForTest(
(_baseUrl, _token, signal) => new Promise((_, reject) => {
signal.addEventListener("abort", () => reject(new Error("aborted")), { once: true });
}),
);
const { input, cleanup, releaseSession } = createHealthTestSync("aborted");
applyStatus(input, { type: "busy" });
jest.advanceTimersByTime(250);
await flushMicrotasks();
// Dispose while the revalidation is in flight: the abort is lifecycle
// noise, not evidence of an unreachable engine.
releaseSession();
cleanup();
await flushMicrotasks();
expect(useWorkspaceSyncStreamStore.getState().reconcileHealthByKey[workspaceSyncStreamKey(input)]).toBeUndefined();
});
test("reconnects a parked stream as soon as validation recovers", async () => {
jest.useFakeTimers();
setSystemTime(100);
let subscribeBlocked = false;
__setWorkspaceSessionSyncSubscriptionFactoryForTest(async (baseUrl, token, signal) => {
if (subscribeBlocked) throw Object.assign(new Error("workspace not registered yet"), { status: 404 });
return createSubscription(baseUrl, token, signal);
});
let statusUnreachable = false;
__setWorkspaceSessionSyncStatusFetcherForTest(async () => {
if (statusUnreachable) throw new Error("status unreachable");
return { [sessionId]: { type: "busy" } };
});
const input = {
workspaceId,
baseUrl: "https://run-status-health-parked.example/opencode",
omnirushToken: "token",
};
syncInputs.push(input);
ensureWorkspaceSessionSync(input);
const releaseSession = trackWorkspaceSessionSync(input, sessionId);
await flushMicrotasks();
expect(subscriptions).toHaveLength(1);
expect(getWorkspaceSessionSyncStreamPhase(input)).toBe("live");
expect(useSessionActivityStore.getState().recordsByWorkspaceId[workspaceId]?.[sessionId]?.runActive).toBe(true);
// A transient 404 parks the disconnected stream in slow auth backoff.
statusUnreachable = true;
subscribeBlocked = true;
subscriptions[0]?.end();
await flushMicrotasks();
for (let tick = 0; tick < 4; tick += 1) {
jest.advanceTimersByTime(250);
await flushMicrotasks();
}
expect(subscriptions).toHaveLength(1);
expect(getWorkspaceSessionSyncStreamPhase(input)).toBe("auth-blocked");
const degraded = useWorkspaceSyncStreamStore.getState().reconcileHealthByKey[workspaceSyncStreamKey(input)];
expect(degraded?.consecutiveFailures).toBeGreaterThanOrEqual(reconcileFailureDegradedThreshold);
statusUnreachable = false;
subscribeBlocked = false;
jest.advanceTimersByTime(250);
await flushMicrotasks();
expect(subscriptions).toHaveLength(2);
expect(getWorkspaceSessionSyncStreamPhase(input)).toBe("live");
const recovered = useWorkspaceSyncStreamStore.getState().reconcileHealthByKey[workspaceSyncStreamKey(input)];
expect(recovered?.consecutiveFailures).toBe(0);
releaseSession();
});
test("explicit revalidation reads only the requested workspace and leaves a healthy stream connected", async () => {
__setWorkspaceSessionSyncSubscriptionFactoryForTest(createSubscription);
const fetchedUrls: string[] = [];
__setWorkspaceSessionSyncStatusFetcherForTest(async (baseUrl) => {
fetchedUrls.push(baseUrl);
return {};
});
const input = createSyncInput();
const other = { ...input, workspaceId: "other-workspace", baseUrl: "https://other.example/opencode" };
syncInputs.push(other);
ensureWorkspaceSessionSync(input);
ensureWorkspaceSessionSync(other);
await flushMicrotasks();
fetchedUrls.length = 0;
await revalidateWorkspaceSessionSync({ workspaceId: input.workspaceId, baseUrl: input.baseUrl });
expect(fetchedUrls).toEqual([input.baseUrl]);
expect(subscriptions).toHaveLength(2);
expect(subscriptions.every((subscription) => !subscription.signal.aborted)).toBe(true);
await revalidateWorkspaceSessionSync({ workspaceId: "missing", baseUrl: input.baseUrl });
expect(fetchedUrls).toEqual([input.baseUrl]);
});
test("disposal cancels explicit revalidation without resurrecting run state", async () => {
const { input } = createTestSync();
let observedSignal: AbortSignal | undefined;
let resolveStatuses: (statuses: Record<string, SessionStatus>) => void = () => {};
__setWorkspaceSessionSyncStatusFetcherForTest((_baseUrl, _token, signal) => {
observedSignal = signal;
return new Promise((resolve) => { resolveStatuses = resolve; });
});
const pending = revalidateWorkspaceSessionSync(input);
__disposeWorkspaceSessionSyncForTest(input);
expect(observedSignal?.aborted).toBe(true);
resolveStatuses({ [sessionId]: { type: "busy" } });
await pending;
expect(useSessionActivityStore.getState().recordsByWorkspaceId[workspaceId]?.[sessionId]).toBeUndefined();
expect(useWorkspaceSyncStreamStore.getState().reconcileHealthByKey[workspaceSyncStreamKey(input)]).toBeUndefined();
});
test("revalidates parked run state immediately when the network returns", async () => {
__setWorkspaceSessionSyncSubscriptionFactoryForTest(createSubscription);
let failing = true;
let fetches = 0;
__setWorkspaceSessionSyncStatusFetcherForTest(async () => {
fetches += 1;
if (failing) throw new Error("status unreachable");
return {};
});
setSystemTime(100);
const input = {
workspaceId,
baseUrl: "https://run-status-health-online.example/opencode",
omnirushToken: "token",
};
syncInputs.push(input);
ensureWorkspaceSessionSync(input);
const releaseSession = trackWorkspaceSessionSync(input, sessionId);
await waitForSubscriptions(1);
await flushMicrotasks();
setSystemTime(200);
applyStatus(input, { type: "busy" });
const fetchesBeforeOnline = fetches;
// The network comes back: revalidation must not wait for retry backoff
// or the next reconcile tick, and the authoritative answer (no live
// sessions) settles the run without a stream event.
failing = false;
setSystemTime(300);
__revalidateWorkspaceSyncsForTest();
await flushMicrotasks();
expect(fetches).toBeGreaterThan(fetchesBeforeOnline);
expect(useSessionActivityStore.getState().recordsByWorkspaceId[workspaceId]?.[sessionId]?.runActive).toBe(false);
expect(getReactQueryClient().getQueryData(statusKey(workspaceId, sessionId))).toEqual({ type: "idle" });
const health = useWorkspaceSyncStreamStore.getState().reconcileHealthByKey[workspaceSyncStreamKey(input)];
expect(health?.consecutiveFailures ?? 0).toBe(0);
expect(subscriptions).toHaveLength(1);
expect(subscriptions[0]?.signal.aborted).toBe(false);
releaseSession();
});
});