TypeScript
// @effect-diagnostics nodeBuiltinImport:off - the suite seeds and grows real
// transcript trees on disk, outside the service's Effect FileSystem.
import * as NodeChildProcess from "node:child_process";
import * as NodeFSP from "node:fs/promises";
import * as NodeOS from "node:os";
import * as NodePath from "node:path";
import * as NodeSqlite from "node:sqlite";
import * as NodeZlib from "node:zlib";
import { assert, describe, it } from "@effect/vitest";
import { vi } from "vite-plus/test";
import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
import * as NodeServices from "@effect/platform-node/NodeServices";
import * as HostProcess from "@t3tools/shared/HostProcess";
import { mergeUsage } from "@t3tools/shared/usageMerge";
import {
EnvironmentId,
ProviderDriverKind,
ProviderInstanceId,
UsageDay,
type UsageSource,
type UsageSummary,
type UsageSummaryInput,
} from "@t3tools/contracts";
import * as Duration from "effect/Duration";
import * as Clock from "effect/Clock";
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Fiber from "effect/Fiber";
import * as FileSystem from "effect/FileSystem";
import * as Context from "effect/Context";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as Scheduler from "effect/Scheduler";
import * as Schema from "effect/Schema";
import * as TestClock from "effect/testing/TestClock";
import * as SqlClient from "effect/sql/SqlClient";
import { HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse } from "effect/http";
import * as ServerConfig from "../config.ts";
import * as ServerSettings from "../serverSettings.ts";
import * as Sqlite from "../persistence/Sqlite.ts";
import * as CodexUsageHistory from "./CodexUsageHistory.ts";
import * as CursorAccountReader from "@t3tools/provider-cursor/server/CursorAccountReader";
import * as CursorKeychain from "@t3tools/provider-cursor/server/CursorKeychain";
import * as CursorUsageAccounts from "@t3tools/provider-cursor/server/CursorUsageAccounts";
import * as ServerSecretStore from "../auth/ServerSecretStore.ts";
import * as BackgroundPolicy from "../background/BackgroundPolicy.ts";
import * as AntigravityUsage from "../provider/Drivers/AntigravityUsage.ts";
import * as ProviderHostLive from "../provider/ProviderHostLive.ts";
import { totalTokens, type UsageRecord } from "@t3tools/provider-core/server/usage";
import * as UsageService from "./UsageService.ts";
import * as MuseSdk from "../../../../packages/provider-muse/src/server/sdk.ts";
import { MuseUsageHome } from "@t3tools/provider-muse/server";
import { makeScanCacheWriter, SCAN_CACHE_FILE_NAME } from "./usageScanCache.ts";
vi.mock("node:fs/promises", { spy: true });
vi.mock("../../../../packages/provider-muse/src/server/sdk.ts", async (importOriginal) => {
const original = await importOriginal<typeof MuseSdk>();
return {
...original,
createMuseSdkHostEffect: vi.fn(() =>
Effect.fail(
new original.MuseSdkError({
operation: "start",
cause: new Error("Muse is not installed in this test"),
}),
),
),
};
});
const encodeUnknownJson = Schema.encodeEffect(Schema.fromJsonString(Schema.Unknown));
const encodeUnknownJsonString = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown));
const decodeUnknownJsonString = Schema.decodeSync(Schema.fromJsonString(Schema.Unknown));
function claudeLine(
id: number,
outputTokens: number,
model = "claude-fable-5",
sessionId = "session-1",
): string {
return `${JSON.stringify({
type: "assistant",
timestamp: "2026-08-01T10:00:00Z",
requestId: `req_${id}`,
sessionId,
message: {
id: `msg_${id}`,
model,
usage: { input_tokens: 10, output_tokens: outputTokens },
},
})}\n`;
}
const WINDOW: UsageSummaryInput = {
timeZone: "UTC",
sinceDay: UsageDay.make("2026-07-31"),
untilDay: UsageDay.make("2026-08-02"),
};
const setup = Effect.gen(function* () {
const home = yield* Effect.promise(() =>
NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "usage-service-test-")),
);
yield* Effect.addFinalizer(() =>
Effect.promise(() => NodeFSP.rm(home, { recursive: true, force: true })),
);
const transcriptDir = NodePath.join(home, "claude", "projects", "proj");
yield* Effect.promise(() => NodeFSP.mkdir(transcriptDir, { recursive: true }));
return {
home,
transcript: NodePath.join(transcriptDir, "session.jsonl"),
settings: {
providerInstances: {
[ProviderInstanceId.make("claudeAgent")]: {
driver: ProviderDriverKind.make("claudeAgent"),
config: { homePath: NodePath.join(home, "claude") },
},
[ProviderInstanceId.make("codex")]: {
driver: ProviderDriverKind.make("codex"),
config: { homePath: NodePath.join(home, "codex") },
},
},
},
};
});
const layerCursorUsageAccounts = <E, R>(
reader: Layer.Layer<CursorAccountReader.CursorAccountReader, E, R>,
) => Layer.fresh(CursorUsageAccounts.layer).pipe(Layer.provide(reader));
const makeWithCursor = (read: CursorAccountReader.CursorAccountReader["Service"]["read"]) =>
Effect.gen(function* () {
const context = yield* Layer.build(
layerCursorUsageAccounts(Layer.succeed(CursorAccountReader.CursorAccountReader, { read })),
);
const accounts = Context.get(context, CursorUsageAccounts.CursorUsageAccounts);
const service = yield* UsageService.make.pipe(Effect.provideContext(context));
return {
...service,
awaitPersisted: Effect.andThen(service.awaitPersisted, accounts.awaitPersisted),
};
});
const layerService = (input: {
readonly prefix: string;
readonly home: string;
readonly settings: Parameters<typeof ServerSettings.layerTest>[0];
readonly onRatesFetch?: (request: HttpClientRequest.HttpClientRequest) => void;
readonly ratesDocument?: unknown;
readonly ratesStatus?: () => number;
readonly ratesResponse?: (
request: HttpClientRequest.HttpClientRequest,
) => Effect.Effect<Response, HttpClientError.HttpClientError>;
readonly environment?: NodeJS.ProcessEnv;
readonly platform?: NodeJS.Platform;
readonly hostname?: string;
readonly secretStore?: Partial<ServerSecretStore.ServerSecretStore["Service"]>;
}) =>
layerCursorUsageAccounts(
CursorAccountReader.layer.pipe(Layer.provide(CursorKeychain.layer)),
).pipe(
Layer.provideMerge(AntigravityUsage.layer),
Layer.provideMerge(MuseUsageHome.layer),
Layer.provideMerge(ProviderHostLive.layer),
Layer.provideMerge(CodexUsageHistory.layer.pipe(Layer.provideMerge(Sqlite.layerMemory))),
Layer.provideMerge(Layer.mock(BackgroundPolicy.BackgroundPolicy)({})),
Layer.provideMerge(
Layer.mock(ServerSecretStore.ServerSecretStore)({
get: () => Effect.succeedNone,
...input.secretStore,
}),
),
Layer.provideMerge(
ServerConfig.layerTest(process.cwd(), NodePath.join(input.home, input.prefix)),
),
Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
Layer.provideMerge(Layer.succeed(HostProcess.Platform, input.platform ?? "linux")),
Layer.provideMerge(Layer.succeed(HostProcess.Hostname, input.hostname ?? "usage-test-host")),
Layer.provideMerge(ServerSettings.layerTest(input.settings)),
Layer.provideMerge(
Layer.succeed(
HttpClient.HttpClient,
HttpClient.make((request) =>
Effect.suspend(() => {
input.onRatesFetch?.(request);
const response = input.ratesResponse
? input.ratesResponse(request)
: Effect.succeed(
Response.json(input.ratesDocument ?? {}, {
status: input.ratesStatus?.() ?? 200,
}),
);
return response.pipe(
Effect.map((response) => HttpClientResponse.fromWeb(request, response)),
);
}),
),
),
),
Layer.provideMerge(
Layer.succeed(HostProcess.Environment, {
HOME: input.home,
GROK_HOME: NodePath.join(input.home, "grok"),
PI_CODING_AGENT_DIR: NodePath.join(input.home, "pi"),
OPENCODE_DATA_DIR: NodePath.join(input.home, "opencode"),
ANTIGRAVITY_DATA_DIR: NodePath.join(input.home, "antigravity"),
XDG_CONFIG_HOME: NodePath.join(input.home, "config"),
APPDATA: NodePath.join(input.home, "config"),
...input.environment,
}),
),
);
const BEFORE_NARROW_WINDOW = Date.parse("2026-08-01T10:00:00Z") / 1000;
const NARROW_WINDOW: UsageSummaryInput = {
timeZone: "UTC",
sinceDay: UsageDay.make("2026-09-01"),
untilDay: UsageDay.make("2026-09-02"),
};
// Each waiting gate holds a libuv thread; allow at most three.
const makeGate = (path: string, lastWriteSeconds?: number) =>
Effect.promise(async () => {
NodeChildProcess.execFileSync("mkfifo", [path]);
if (lastWriteSeconds !== undefined) {
await NodeFSP.utimes(path, lastWriteSeconds, lastWriteSeconds);
}
});
const openGate = (path: string) =>
Effect.promise(async () => (await NodeFSP.open(path, "w")).close());
const replaceFile = (path: string, content: string) =>
Effect.promise(async () => {
await NodeFSP.writeFile(path + ".next", content);
await NodeFSP.rename(path + ".next", path);
});
function totalOutputTokens(summary: { buckets: readonly { totals: { outputTokens: number } }[] }) {
return summary.buckets.reduce((sum, bucket) => sum + bucket.totals.outputTokens, 0);
}
const CURSOR_NOW = Date.parse("2026-08-02T12:00:00Z");
const HOUR_MS = 60 * 60 * 1000;
function makeFakeCursor() {
const state = {
accountKey: "account-a",
events: [] as { readonly timestampMs: number; readonly outputTokens: number }[],
error: null as string | null,
gate: undefined as Deferred.Deferred<void> | undefined,
calls: [] as { readonly sinceMs: number; readonly untilMs: number }[],
credentials: [] as unknown[],
};
const read = (credential: unknown, sinceMs: number, untilMs: number) =>
Effect.gen(function* () {
state.calls.push({ sinceMs, untilMs });
state.credentials.push(credential);
if (state.gate !== undefined) yield* Deferred.await(state.gate);
const { accountKey, error } = state;
if (error !== null) return { accountKey, records: [], missing: false, error };
const occurrences = new Map<string, number>();
const records = state.events
.filter(({ timestampMs }) => timestampMs >= sinceMs && timestampMs <= untilMs)
.map(({ timestampMs, outputTokens }): UsageRecord => {
const key = `${timestampMs}:${outputTokens}`;
const occurrence = occurrences.get(key) ?? 0;
occurrences.set(key, occurrence + 1);
return {
provider: "cursor",
timestampMs,
model: "claude-fable-5",
sessionId: "conversation-1",
totals: {
uncachedInputTokens: 0,
cachedInputTokens: 0,
cacheCreationTokens: 0,
outputTokens,
reasoningTokens: 0,
},
reportedCostUsd: null,
speed: "standard",
dedupeKey: `cursor-account:${accountKey}:${key}:${occurrence}`,
};
});
return { accountKey, records, missing: false, error: null };
});
return { state, read };
}
const writeCursorLogin = (home: string) =>
Effect.promise(async () => {
const authPath = NodePath.join(home, "config", "cursor", "auth.json");
await NodeFSP.mkdir(NodePath.dirname(authPath), { recursive: true });
await NodeFSP.writeFile(authPath, "{}");
});
function cursorSource(summary: { readonly sources: readonly UsageSource[] }) {
return summary.sources.find((source) => source.fingerprint.provider === "cursor");
}
function cursorSources(summary: { readonly sources: readonly UsageSource[] }) {
return summary.sources.filter((source) => source.fingerprint.provider === "cursor");
}
const seedCodexHistory = (input: {
id: string;
nativeTurnId?: string;
sessionId?: string;
model?: string;
options?: readonly { id: string; value: string | boolean }[];
}) =>
Effect.gen(function* () {
const sql = yield* SqlClient.SqlClient;
const { id } = input;
const selection = {
instanceId: "codex",
model: input.model ?? "gpt-6-astra",
options: input.options ?? [{ id: "serviceTier", value: "priority" }],
};
const run = {
id: `run-${id}`,
activeAttemptId: `attempt-${id}`,
status: "running",
modelSelection: selection,
};
yield* sql`INSERT INTO orchestration_v2_projection_run_attempts ${sql.insert({
attempt_id: run.activeAttemptId,
thread_id: `thread-${id}`,
run_id: run.id,
attempt_ordinal: 1,
root_node_id: `node-${id}`,
provider: "codex",
provider_thread_id: `provider-thread-${id}`,
provider_turn_id: `turn-${id}`,
status: "completed",
payload_json: encodeUnknownJsonString({ nativeThreadId: input.sessionId ?? "session" }),
})}`;
yield* sql`INSERT INTO orchestration_v2_projection_provider_turns ${sql.insert({
provider_turn_id: `turn-${id}`,
thread_id: `thread-${id}`,
provider_thread_id: `provider-thread-${id}`,
node_id: `node-${id}`,
run_attempt_id: run.activeAttemptId,
ordinal: 1,
status: "completed",
payload_json: encodeUnknownJsonString({
nativeTurnRef: { driver: "codex", nativeId: input.nativeTurnId ?? id, strength: "strong" },
}),
})}`;
const changedSelection = {
...selection,
options: [{ id: "serviceTier", value: "ultrafast" }],
};
// These selections disagree so reading the current projection or the wrong event is visible.
yield* sql`INSERT INTO orchestration_v2_projection_runs ${sql.insert({
run_id: run.id,
thread_id: `thread-${id}`,
ordinal: 1,
provider: "codex",
provider_thread_id: `provider-thread-${id}`,
status: "completed",
requested_at: "2026-08-01T10:00:00Z",
payload_json: encodeUnknownJsonString({
...run,
status: "completed",
modelSelection: { ...selection, options: [] },
}),
})}`;
for (const [index, payload] of [
{ ...run, activeAttemptId: "earlier-attempt", modelSelection: changedSelection },
{ ...run, status: "queued", modelSelection: changedSelection },
run,
{ ...run, modelSelection: changedSelection },
].entries()) {
yield* sql`INSERT INTO orchestration_events ${sql.insert({
event_id: `event-${id}-${index}`,
aggregate_kind: "thread",
stream_id: `thread-${id}`,
stream_version: index + 1,
event_type: "run.updated",
occurred_at: "2026-08-01T10:00:00Z",
actor_kind: "system",
metadata_json: "{}",
application_event_version: 2,
payload_json: encodeUnknownJsonString(payload),
})}`;
}
});
describe("Codex usage history", () => {
const historyLayer = CodexUsageHistory.layer.pipe(Layer.provideMerge(Sqlite.layerMemory));
const request = (nativeTurnId: string) => ({
sessionId: "session",
nativeTurnId,
model: "gpt-6-astra",
});
it.effect("resolves a batch from each attempt's first running selection", () =>
Effect.gen(function* () {
yield* seedCodexHistory({ id: "fast" });
yield* seedCodexHistory({
id: "ultrafast",
options: [{ id: "serviceTier", value: "ultrafast" }],
});
yield* seedCodexHistory({ id: "legacy-option", options: [{ id: "fastMode", value: true }] });
yield* seedCodexHistory({ id: "standard", options: [] });
const requests = ["fast", "ultrafast", "legacy-option", "standard", "fast"].map(request);
const history = yield* CodexUsageHistory.CodexUsageHistory;
const resolved = yield* history.resolve(requests);
assert.strictEqual(resolved.size, requests.length);
assert.deepStrictEqual(
requests.map((item) => resolved.get(item)),
["fast", "ultrafast", "fast", "standard", "fast"],
);
}).pipe(Effect.provide(historyLayer)),
);
it.effect("leaves ambiguous, mismatched, and missing V2 evidence unresolved", () =>
Effect.gen(function* () {
for (const id of [
"valid",
"duplicate-model",
"duplicate-session",
"imported",
"v1-event",
"queued",
"missing-selection",
]) {
yield* seedCodexHistory({ id });
}
yield* seedCodexHistory({
id: "second-model",
nativeTurnId: "duplicate-model",
model: "other-model",
});
yield* seedCodexHistory({
id: "second-session",
nativeTurnId: "duplicate-session",
sessionId: "other-session",
});
yield* seedCodexHistory({ id: "wrong-model", model: "other-model" });
yield* seedCodexHistory({ id: "wrong-session", sessionId: "other-session" });
const sql = yield* SqlClient.SqlClient;
yield* sql`UPDATE orchestration_v2_projection_provider_turns
SET run_attempt_id = NULL WHERE provider_turn_id = 'turn-imported'`;
yield* sql`DELETE FROM orchestration_v2_projection_run_attempts WHERE attempt_id = 'attempt-imported'`;
yield* sql`UPDATE orchestration_events SET application_event_version = 1
WHERE stream_id = 'thread-v1-event'`;
yield* sql`UPDATE orchestration_events
SET payload_json = json_set(payload_json, '$.status', 'queued')
WHERE stream_id = 'thread-queued'`;
yield* sql`UPDATE orchestration_events
SET payload_json = json_remove(payload_json, '$.modelSelection')
WHERE event_id = 'event-missing-selection-2'`;
const requests = [
"valid",
"duplicate-model",
"duplicate-session",
"wrong-model",
"wrong-session",
"missing-turn",
"imported",
"v1-event",
"queued",
"missing-selection",
].map(request);
const history = yield* CodexUsageHistory.CodexUsageHistory;
const resolved = yield* history.resolve(requests);
assert.deepStrictEqual([...resolved], [[requests[0], "fast"]]);
}).pipe(Effect.provide(historyLayer)),
);
it.effect(
"reports SQL failures through the typed channel and can resolve again after repair",
() =>
Effect.gen(function* () {
yield* seedCodexHistory({ id: "retry" });
const history = yield* CodexUsageHistory.CodexUsageHistory;
const sql = yield* SqlClient.SqlClient;
const input = request("retry");
yield* sql`ALTER TABLE orchestration_events RENAME TO unavailable_events`;
const error = yield* Effect.flip(history.resolve([input]));
assert.instanceOf(error, CodexUsageHistory.CodexUsageHistoryReadError);
assert.strictEqual(error.requestedTurnCount, 1);
yield* sql`ALTER TABLE unavailable_events RENAME TO orchestration_events`;
assert.strictEqual((yield* history.resolve([input])).get(input), "fast");
}).pipe(Effect.provide(historyLayer)),
);
});
describe("UsageService", () => {
it.live("counts compressed Codex rollouts across refresh, rewrites, and cache restarts", () =>
Effect.gen(function* () {
const { home, settings } = yield* setup;
const sessions = NodePath.join(home, "codex", "sessions");
const compressedPath = NodePath.join(sessions, "compressed.jsonl.zst");
const usage = (output_tokens: number, timestamp = "2026-08-01T10:00:00Z") =>
encodeUnknownJsonString({
type: "event_msg",
timestamp,
payload: {
type: "token_count",
info: { last_token_usage: { input_tokens: 10, output_tokens } },
},
}) + "\n";
const rollout = (id: string, output: number) =>
[
{ type: "session_meta", payload: { id } },
{ type: "turn_context", payload: { model: "gpt-6-astra" } },
]
.map((line) => encodeUnknownJsonString(line))
.join("\n") +
"\n" +
usage(output);
const compressed = rollout("compressed-session", 23);
yield* Effect.promise(async () => {
await NodeFSP.mkdir(sessions, { recursive: true });
await NodeFSP.writeFile(
NodePath.join(sessions, "plain.jsonl"),
rollout("plain-session", 17),
);
await NodeFSP.writeFile(compressedPath, NodeZlib.zstdCompressSync(compressed));
});
yield* Effect.gen(function* () {
const service = yield* UsageService.make;
const first = yield* service.readSummary(WINDOW);
assert.strictEqual(totalOutputTokens(first), 40);
assert.strictEqual(
first.sources.find((source) => source.fingerprint.provider === "codex")?.distinctSessions,
2,
);
assert.deepStrictEqual((yield* service.readSummary(WINDOW)).buckets, first.buckets);
yield* service.awaitPersisted;
// The same rollout may remain in a plain file while compression finishes.
yield* Effect.promise(() =>
NodeFSP.writeFile(NodePath.join(sessions, "copy.jsonl"), compressed),
);
assert.strictEqual(totalOutputTokens(yield* service.readSummary(WINDOW)), 40);
yield* Effect.promise(() =>
NodeFSP.writeFile(
compressedPath,
NodeZlib.zstdCompressSync(compressed + usage(31, "2026-08-01T10:00:05Z")),
),
);
const rewritten = yield* service.readSummary(WINDOW);
assert.strictEqual(totalOutputTokens(rewritten), 71);
assert.deepStrictEqual((yield* service.readSummary(WINDOW)).buckets, rewritten.buckets);
yield* service.awaitPersisted;
const restarted = yield* UsageService.make;
assert.deepStrictEqual((yield* restarted.readSummary(WINDOW)).buckets, rewritten.buckets);
yield* restarted.awaitPersisted;
}).pipe(
Effect.scoped,
Effect.provide(layerService({ prefix: "usage-compressed-codex", home, settings })),
);
}).pipe(Effect.scoped),
);
it.live("keeps the first host identity across recreation and explicit override removal", () =>
Effect.gen(function* () {
const { transcript, settings, home } = yield* setup;
yield* Effect.promise(() => NodeFSP.writeFile(transcript, claudeLine(1, 5)));
for (const [hostname, override, expected] of [
["container-a", undefined, "container-a"],
["container-b", undefined, "container-a"],
["container-c", "physical-host", "physical-host"],
["container-d", undefined, "container-a"],
] as const) {
const summary = yield* Effect.gen(function* () {
const service = yield* UsageService.make;
return yield* service.readSummary(WINDOW);
}).pipe(
Effect.scoped,
Effect.provide(
layerService({
prefix: "usage-host-id",
home,
settings,
hostname,
environment: override === undefined ? {} : { T3CODE_HOST_ID: override },
}),
),
);
const source = summary.sources.find((source) => source.fingerprint.provider === "claude");
assert.strictEqual(source?.fingerprint.hostId, expected);
}
}).pipe(Effect.scoped),
);
it.live("concurrent initialization keeps one host identity across service recreation", () =>
Effect.gen(function* () {
const { transcript, settings, home } = yield* setup;
yield* Effect.promise(() => NodeFSP.writeFile(transcript, claudeLine(1, 5)));
const prefix = "usage-host-id-race";
const hostIdPath = NodePath.join(home, prefix, "usage-host-id");
const bothRead = yield* Deferred.make<void>();
let reads = 0;
const summaries = yield* Effect.forEach(
["container-a", "container-b"],
(hostname) =>
Effect.gen(function* () {
const fileSystem = yield* FileSystem.FileSystem;
let firstRead = true;
const service = yield* UsageService.make.pipe(
Effect.provideService(FileSystem.FileSystem, {
...fileSystem,
readFileString: (path, encoding) =>
Effect.gen(function* () {
if (path !== hostIdPath || !firstRead) {
return yield* fileSystem.readFileString(path, encoding);
}
firstRead = false;
// Both instances observe the missing file before either can create it.
const result = yield* Effect.exit(fileSystem.readFileString(path, encoding));
reads += 1;
if (reads === 2) yield* Deferred.succeed(bothRead, undefined);
yield* Deferred.await(bothRead);
return yield* result;
}),
}),
);
return yield* service.readSummary(WINDOW);
}).pipe(
Effect.scoped,
Effect.provide(layerService({ prefix, home, settings, hostname })),
),
{ concurrency: "unbounded" },
);
const persisted = yield* Effect.promise(() => NodeFSP.readFile(hostIdPath, "utf8"));
const hostId = persisted.trim();
assert.include(["container-a", "container-b"], hostId);
const restarted = yield* Effect.gen(function* () {
const service = yield* UsageService.make;
return yield* service.readSummary(WINDOW);
}).pipe(
Effect.scoped,
Effect.provide(layerService({ prefix, home, settings, hostname: "container-c" })),
);
for (const summary of [...summaries, restarted]) {
const source = summary.sources.find((source) => source.fingerprint.provider === "claude");
assert.strictEqual(source?.fingerprint.hostId, hostId);
}
}).pipe(Effect.scoped),
);
it.live(
"repairs initial Codex prices after unchanged-file retries, persists evidence and corrections, and honors later native tiers",
() =>
Effect.gen(function* () {
const { home, settings } = yield* setup;
const sessions = NodePath.join(home, "codex", "sessions");
const fastPath = NodePath.join(sessions, "fast.jsonl");
const ultraPath = NodePath.join(sessions, "ultra.jsonl");
const meta = (id: string) => ({
type: "session_meta",
payload: { id, model_provider: "openai" },
});
const context = (turn_id?: string) => ({
type: "turn_context",
payload: { model: "gpt-6-astra", turn_id },
});
const usage = (output_tokens: number) => ({
type: "event_msg",
timestamp: "2026-08-01T10:00:00Z",
payload: {
type: "token_count",
info: { last_token_usage: { input_tokens: 0, output_tokens } },
},
});
const tier = (service_tier?: string) => ({
type: "event_msg",
payload: { type: "thread_settings_applied", thread_settings: { service_tier } },
});
const lines = (records: readonly unknown[]) =>
records.map((record) => encodeUnknownJsonString(record)).join("\n") + "\n";
const verify = (summary: UsageSummary, output: number, cost: number) => {
assert.strictEqual(totalOutputTokens(summary), output);
assert.strictEqual(
summary.buckets.reduce((sum, bucket) => sum + bucket.costUsd, 0),
cost,
);
};
yield* Effect.promise(async () => {
await NodeFSP.mkdir(sessions, { recursive: true });
await NodeFSP.writeFile(
fastPath,
lines([meta("fast-session"), context("fast-turn"), usage(1)]) +
encodeUnknownJsonString(usage(2)),
);
await NodeFSP.writeFile(
ultraPath,
lines([meta("ultra-session"), context("ultra-turn"), usage(4)]),
);
});
yield* Effect.gen(function* () {
const first = yield* UsageService.make;
verify(yield* first.readSummary(WINDOW), 7, 7);
yield* first.awaitPersisted;
const pending = yield* UsageService.make;
verify(yield* pending.readSummary(WINDOW), 7, 7);
yield* seedCodexHistory({ id: "fast-turn", sessionId: "fast-session" });
yield* seedCodexHistory({
id: "ultra-turn",
sessionId: "ultra-session",
options: [{ id: "serviceTier", value: "ultrafast" }],
});
const sql = yield* SqlClient.SqlClient;
yield* sql`ALTER TABLE orchestration_events RENAME TO unavailable_events`;
verify(yield* pending.readSummary(WINDOW), 7, 7);
yield* pending.awaitPersisted;
const retry = yield* UsageService.make;
verify(yield* retry.readSummary(WINDOW), 7, 7);
yield* sql`ALTER TABLE unavailable_events RENAME TO orchestration_events`;
// History repair must touch both the committed record and tentative tail.
verify(yield* retry.readSummary(WINDOW), 7, 30);
yield* retry.awaitPersisted;
yield* sql`ALTER TABLE orchestration_events RENAME TO resolved_events`;
verify(yield* retry.readSummary(WINDOW), 7, 30);
const resolved = yield* UsageService.make;
verify(yield* resolved.readSummary(WINDOW), 7, 30);
yield* sql`ALTER TABLE resolved_events RENAME TO orchestration_events`;
// Completing the tail reparses it; neither an absent turn ID nor a new
// turn with no retained attempt may inherit the inferred Fast speed.
yield* Effect.promise(() =>
NodeFSP.appendFile(
fastPath,
"\n" + lines([context(), usage(3), context("unretained-turn"), usage(4)]),
),
);
verify(yield* resolved.readSummary(WINDOW), 14, 37);
yield* seedCodexHistory({
id: "native-turn",
sessionId: "fast-session",
options: [{ id: "serviceTier", value: "ultrafast" }],
});
yield* seedCodexHistory({ id: "later-native-turn", sessionId: "fast-session" });
yield* Effect.promise(() =>
NodeFSP.appendFile(
fastPath,
lines([
context("native-turn"),
tier(),
usage(5),
context("later-native-turn"),
usage(6),
tier("priority"),
]) + encodeUnknownJsonString(usage(7)),
),
);
verify(yield* resolved.readSummary(WINDOW), 32, 62);
yield* resolved.awaitPersisted;
const native = yield* UsageService.make;
verify(yield* native.readSummary(WINDOW), 32, 62);
yield* seedCodexHistory({
id: "after-restart-native",
sessionId: "fast-session",
options: [{ id: "serviceTier", value: "ultrafast" }],
});
yield* Effect.promise(() =>
NodeFSP.appendFile(
fastPath,
"\n" +
lines([context("after-restart-native"), usage(8), tier("ultrafast"), usage(9)]),
),
);
verify(yield* native.readSummary(WINDOW), 49, 132);
yield* native.awaitPersisted;
yield* Effect.promise(async () => {
await NodeFSP.rm(fastPath);
await NodeFSP.rm(ultraPath);
});
yield* sql`DELETE FROM orchestration_events`;
const deleted = yield* UsageService.make;
verify(yield* deleted.readSummary(WINDOW), 49, 132);
}).pipe(
Effect.provide(
layerService({
prefix: "usage-initial-tier",
home,
settings,
ratesDocument: {
"gpt-6-astra": {
input_cost_per_token: 0,
output_cost_per_token: 1,
input_cost_per_token_priority: 0,
output_cost_per_token_priority: 2,
input_cost_per_token_ultrafast: 0,
output_cost_per_token_ultrafast: 6,
},
},
}),
),
);
}).pipe(Effect.scoped),
);
it.live(
"reads Pi per-model usage and auxiliary costs once across forks and repeated entries",
() =>
Effect.gen(function* () {
const { home, settings } = yield* setup;
const dir = NodePath.join(home, "pi", "sessions", "project");
const usage = {
input: 10,
output: 5,
cacheRead: 20,
cacheWrite: 3,
reasoning: 2,
totalTokens: 38,
cost: { input: 0.1, output: 0.2, cacheRead: 0.3, cacheWrite: 0.4, total: 1 },
};
const parent = {
type: "message",
id: "a123abcd",
parentId: null,
timestamp: "2026-08-01T10:00:00Z",
message: {
role: "assistant",
provider: "anthropic",
model: "requested-model",
responseModel: "actual-model",
usage,
},
};
const auxiliary = [
{
type: "message",
id: "tool",
message: { role: "toolResult", toolName: "classify", usage },
},
{
type: "message",
id: "image",
message: {
role: "toolResult",
toolName: "image",
usage: { ...usage, input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
},
},
{ type: "compaction", id: "compact", usage },
{ type: "branch_summary", id: "summary", usage },
].map((entry) => ({ ...entry, timestamp: "2026-08-01T11:00:00Z" }));
yield* Effect.promise(async () => {
await NodeFSP.mkdir(dir, { recursive: true });
await NodeFSP.writeFile(
NodePath.join(dir, "parent.jsonl"),
[
{ type: "session", id: "parent" },
parent,
...auxiliary,
{
type: "usage",
id: "warm",
timestamp: "2026-08-01T12:00:00Z",
kind: "cache_warm",
provider: "openai",
model: "actual-model",
usage: { ...usage, cost: { ...usage.cost, total: 0 } },
},
]
.map((line) => encodeUnknownJsonString(line))
.join("\n") + "\n",
);
await NodeFSP.writeFile(
NodePath.join(dir, "fork.jsonl"),
[
{ type: "session", id: "fork", parentSession: NodePath.join(dir, "parent.jsonl") },
{ ...parent, parentId: "relinked" },
parent,
...auxiliary,
{
...parent,
timestamp: "2026-08-01T13:00:00Z",
message: { ...parent.message, provider: "openai", responseModel: "another-model" },
},
{ type: "get_session_stats", usage: { ...usage, cost: { total: 1000 } } },
]
.map((line) => encodeUnknownJsonString(line))
.join("\n") + "\n",
);
});
yield* Effect.gen(function* () {
const service = yield* UsageService.make;
const first = yield* service.readSummary(WINDOW);
const pi = first.buckets.filter((bucket) => bucket.provider === "pi");
assert.strictEqual(
pi.reduce((total, bucket) => total + bucket.costUsd, 0),
44,
);
assert.strictEqual(
pi.reduce((total, bucket) => total + totalTokens(bucket.totals), 0),
228,
);
assert.deepStrictEqual(pi.map((bucket) => bucket.model).sort(), [
"Tools/summaries",
"anthropic/actual-model",
"openai/actual-model",
"openai/another-model",
]);
const assistant = pi.find((bucket) => bucket.model === "anthropic/actual-model");
assert.deepStrictEqual(assistant?.totals, {
uncachedInputTokens: 10,
outputTokens: 5,
cachedInputTokens: 20,
cacheCreationTokens: 3,
reasoningTokens: 2,
});
assert.strictEqual(assistant?.costSource, "providerReported");
assert.approximately(assistant?.categoryCostUsd?.input ?? NaN, 10 / 38, 1e-6);
assert.approximately(assistant?.categoryCostUsd?.cacheRead ?? NaN, 2 / 38, 1e-6);
assert.approximately(assistant?.categoryCostUsd?.cacheWrite ?? NaN, 6 / 38, 1e-6);
assert.approximately(assistant?.categoryCostUsd?.output ?? NaN, 20 / 38, 1e-6);
assert.strictEqual(assistant?.cacheSavingsUsd, 18);
const warm = pi.find((bucket) => bucket.model === "openai/actual-model");
assert.strictEqual(warm?.costSource, "modelPriced");
assert.strictEqual(warm?.costUsd, 38);
assert.deepStrictEqual(warm?.categoryCostUsd, {
input: 10,
cacheRead: 2,
cacheWrite: 6,
output: 20,
});
assert.strictEqual(warm?.cacheSavingsUsd, 18);
assert.strictEqual(
first.sources.filter((source) => source.fingerprint.provider === "pi").length,
1,
);
yield* Effect.promise(() =>
NodeFSP.appendFile(
NodePath.join(dir, "fork.jsonl"),
encodeUnknownJsonString({
...parent,
id: "new",
timestamp: "2026-08-01T14:00:00Z",
message: { ...parent.message, responseModel: "latest-model" },
}) + "\n",
),
);
const grown = yield* service.readSummary(WINDOW);
assert.strictEqual(
grown.buckets
.filter((bucket) => bucket.provider === "pi")
.reduce((total, bucket) => total + bucket.costUsd, 0),
45,
);
yield* service.awaitPersisted;
const restarted = yield* UsageService.make;
assert.deepStrictEqual((yield* restarted.readSummary(WINDOW)).buckets, grown.buckets);
}).pipe(
Effect.scoped,
Effect.provide(
layerService({
prefix: "usage-pi-fork",
home,
ratesDocument: {
"actual-model": {
input_cost_per_token: 1,
output_cost_per_token: 4,
cache_read_input_token_cost: 0.1,
cache_creation_input_token_cost: 2,
},
},
settings: {
...settings,
providerInstances: {
...settings.providerInstances,
[ProviderInstanceId.make("pi-extra")]: {
driver: ProviderDriverKind.make("pi"),
enabled: false,
environment: [
{
name: "PI_CODING_AGENT_DIR",
value: NodePath.join(home, "pi"),
sensitive: false,
},
],
},
},
},
}),
),
);
}).pipe(Effect.scoped),
);
it.live(
"reads Muse inference history once, persists appended usage, and reprices unknown models",
() =>
Effect.gen(function* () {
const { home, settings } = yield* setup;
const museHome = NodePath.join(home, "configured-data", "muse");
const dir = NodePath.join(museHome, "sessions", "2026", "08", "01", "parent");
const child = NodePath.join(dir, "subagent", "child");
const entry = (
id: string,
sessionId = "parent",
timestamp = "2026-08-01T00:00:00Z",
model = "muse-unknown",
) => ({
schema_version: 1,
record_type: "event",
payload_type: "runtime.session",
payload_schema_version: 1,
id,
recorded_at: Date.parse(timestamp) * 1000 + 999,
stream: { kind: "session", id: sessionId },
payload: {
source_run_record_id: id,
event: {
kind: "model_completed",
model,
usage: {
input_tokens: 100,
cached_tokens: 60,
cache_read_tokens: 60,
cache_write_tokens: 10,
output_tokens: 20,
reasoning_tokens: 8,
},
},
},
});
const parent = entry("inference-1");
const review = {
...entry("review", "child"),
payload_schema_version: 3,
payload: {
event: {
...parent.payload.event,
kind: "automated_review_completed",
model: { model_id: "priced-model" },
usage: {
input_tokens: 100,
cached_input_tokens: 60,
output_tokens: 20,
reasoning_tokens: 8,
},
},
},
};
yield* Effect.promise(async () => {
await NodeFSP.mkdir(child, { recursive: true });
await NodeFSP.writeFile(
NodePath.join(dir, "session.jsonl"),
[
parent,
parent,
{
...parent,
payload: { event: { ...parent.payload.event, kind: "workflow_completed" } },
},
{ ...parent, payload_type: "goal_usage_attribution" },
entry("before", "parent", "2026-07-31T23:59:59.999Z"),
entry("after", "parent", "2026-08-02T00:00:00Z"),
]
.map((line) => encodeUnknownJsonString(line))
.join("\n") + "\n{broken}\n",
);
await NodeFSP.writeFile(
NodePath.join(child, "session.jsonl"),
[
{ ...parent, id: "copied-envelope", stream: { kind: "session", id: "child" } },
entry("child-inference", "child"),
review,
]
.map((line) => encodeUnknownJsonString(line))
.join("\n") + "\n",
);
await NodeFSP.writeFile(
NodePath.join(child, "telemetry.jsonl"),
encodeUnknownJsonString(entry("not-a-session")) + "\n",
);
});
using _create = vi.spyOn(MuseSdk, "createMuseSdkHostEffect").mockImplementation((options) =>
Effect.succeed({
initializeResult: {
grantedCapabilities: [],
museHome: NodePath.join(options.environment?.XDG_DATA_HOME ?? home, "muse"),
},
close: async () => {},
} as unknown as MuseSdk.MuseSdkHost),
);
yield* Effect.gen(function* () {
const service = yield* UsageService.make;
const window = {
timeZone: "UTC",
sinceDay: UsageDay.make("2026-08-01"),
untilDay: UsageDay.make("2026-08-01"),
};
const muse = (summary: UsageSummary) =>
summary.buckets.filter((bucket) => bucket.provider === "muse");
const first = yield* service.readSummary(window);
const buckets = muse(first);
assert.strictEqual(
buckets.reduce((sum, b) => sum + b.records, 0),
3,
);
assert.strictEqual(
buckets.reduce((sum, b) => sum + totalTokens(b.totals), 0),
360,
);
const unknown = buckets.find((b) => b.model === "muse-unknown");
assert.strictEqual(unknown?.costSource, "unpriced");
assert.strictEqual(unknown?.unpricedRecords, 2);
assert.deepStrictEqual(unknown?.totals, {
uncachedInputTokens: 60,
cachedInputTokens: 120,
cacheCreationTokens: 20,
outputTokens: 40,
reasoningTokens: 16,
});
const priced = buckets.find((b) => b.model === "priced-model");
assert.strictEqual(priced?.costSource, "modelPriced");
assert.closeTo(priced?.costUsd ?? NaN, 0.000172, 1e-12);
assert.closeTo(priced?.cacheSavingsUsd ?? NaN, 0.000108, 1e-12);
const sources = first.sources.filter((source) => source.fingerprint.provider === "muse");
assert.strictEqual(sources.length, 1);
assert.strictEqual(sources[0]?.scannedFiles, 2);
assert.strictEqual(sources[0]?.distinctSessions, 2);
const local = muse(
yield* service.readSummary({ ...window, timeZone: "America/Los_Angeles" }),
);
assert.strictEqual(
local.reduce((sum, b) => sum + b.records, 0),
1,
);
assert.strictEqual(local[0]?.day, "2026-08-01");
const hourly = muse(
yield* service.readSummary({
...window,
resolution: "hour",
sinceTime: "2026-08-01T00:00:00.000Z",
untilTime: "2026-08-02T00:00:00.000Z",
}),
);
assert.strictEqual(
hourly.reduce((sum, b) => sum + b.records, 0),
3,
);
const appended = encodeUnknownJsonString(entry("appended", "child"));
const file = NodePath.join(child, "session.jsonl");
yield* Effect.promise(() => NodeFSP.appendFile(file, appended.slice(0, -10)));
assert.deepStrictEqual(muse(yield* service.readSummary(window)), buckets);
yield* service.awaitPersisted;
const restarted = yield* UsageService.make;
yield* Effect.promise(() => NodeFSP.appendFile(file, appended.slice(-10) + "\n"));
const grown = muse(yield* restarted.readSummary(window));
assert.strictEqual(
grown.reduce((sum, b) => sum + b.records, 0),
4,
);
assert.strictEqual(
grown.reduce((sum, b) => sum + totalTokens(b.totals), 0),
480,
);
const settingsService = yield* ServerSettings.ServerSettingsService;
yield* settingsService.updateSettings({
usagePriceOverrides: {
"muse-unknown": {
inputCostPerMillionTokens: 2,
outputCostPerMillionTokens: 4,
cacheReadCostPerMillionTokens: 0.2,
cacheWriteCostPerMillionTokens: 1,
},
},
});
const repriced = muse(yield* restarted.readSummary(window)).find(
(b) => b.model === "muse-unknown",
);
assert.strictEqual(repriced?.unpricedRecords, 0);
assert.closeTo(repriced?.costUsd ?? NaN, 0.000486, 1e-12);
}).pipe(
Effect.scoped,
Effect.provide(
layerService({
prefix: "usage-muse",
home,
environment: { XDG_DATA_HOME: NodePath.dirname(museHome) },
settings: {
...settings,
providerInstances: {
...settings.providerInstances,
[ProviderInstanceId.make("muse")]: {
driver: ProviderDriverKind.make("muse"),
enabled: false,
},
[ProviderInstanceId.make("muse-alias")]: {
driver: ProviderDriverKind.make("muse"),
enabled: false,
},
},
},
ratesDocument: {
"priced-model": {
input_cost_per_token: 0.000002,
output_cost_per_token: 0.000004,
cache_read_input_token_cost: 0.0000002,
cache_creation_input_token_cost: 0.0000002,
},
},
}),
),
);
}).pipe(Effect.scoped),
);
it.live("reports missing Pi history and skips malformed records without losing valid usage", () =>
Effect.gen(function* () {
const { home, settings } = yield* setup;
yield* Effect.gen(function* () {
const service = yield* UsageService.make;
const missing = yield* service.readSummary(WINDOW);
assert.strictEqual(
missing.sources.find((source) => source.fingerprint.provider === "pi")?.status,
"missing",
);
const dir = NodePath.join(home, "pi", "sessions");
yield* Effect.promise(async () => {
await NodeFSP.mkdir(dir, { recursive: true });
await NodeFSP.writeFile(
NodePath.join(dir, "session.jsonl"),
[
"{broken",
"null",
encodeUnknownJsonString({ type: "session", id: "valid" }),
encodeUnknownJsonString({
type: "message",
id: "bad",
timestamp: "invalid",
message: {
role: "assistant",
provider: "openai",
model: "model",
usage: { input: 100 },
},
}),
encodeUnknownJsonString({
type: "message",
id: "valid",
timestamp: "2026-08-01T10:00:00Z",
message: {
role: "assistant",
provider: "openai",
model: "model",
usage: {
input: -1,
cacheRead: "100",
output: 7,
reasoning: 50,
cost: { total: -1 },
},
},
}),
].join("\n") + "\n",
);
});
const summary = yield* service.readSummary(WINDOW);
const pi = summary.buckets.filter((bucket) => bucket.provider === "pi");
assert.strictEqual(pi.length, 1);
assert.strictEqual(pi[0] && totalTokens(pi[0].totals), 7);
assert.strictEqual(pi[0]?.totals.reasoningTokens, 7);
assert.strictEqual(pi[0]?.costSource, "unpriced");
}).pipe(
Effect.scoped,
Effect.provide(layerService({ prefix: "usage-pi-malformed", home, settings })),
);
}).pipe(Effect.scoped),
);
it.live("discovers Pi history in its default home and directory overrides", () =>
Effect.gen(function* () {
const { home, settings } = yield* setup;
for (const [agentDir, sessionDir, relativeDir, launchArgs, instanceHome, platform] of [
[undefined, undefined, ".pi/agent/sessions", undefined],
["~/custom-pi", undefined, "custom-pi/sessions", undefined],
["~/ignored-pi", "~/custom-sessions", "custom-sessions", undefined],
["~/ignored-pi", NodePath.join(home, "absolute-sessions"), "absolute-sessions", undefined],
["~/ignored-pi", undefined, "launch-sessions", "--session-dir ~/launch-sessions"],
[
"~/ignored-pi",
undefined,
"instance-home /launch-sessions",
"--session-dir ~/launch-sessions",
"instance-home ",
],
[
"~/ignored-pi",
undefined,
"windows-profile/launch-sessions",
"--session-dir ~/launch-sessions",
"windows-profile",
"win32",
],
] as const) {
const dir = NodePath.join(home, relativeDir);
yield* Effect.promise(async () => {
await NodeFSP.mkdir(dir, { recursive: true });
await NodeFSP.writeFile(
NodePath.join(dir, "session.jsonl"),
[
{ type: "session", id: relativeDir },
{
type: "usage",
id: "warm",
timestamp: "2026-08-01T10:00:00Z",
provider: "openai",
model: "model",
usage: { input: 7 },
},
]
.map((line) => encodeUnknownJsonString(line))
.join("\n") + "\n",
);
});
yield* Effect.gen(function* () {
const service = yield* UsageService.make;
const summary = yield* service.readSummary(WINDOW);
const pi = summary.buckets.filter((bucket) => bucket.provider === "pi");
assert.strictEqual(pi.length, 1);
assert.strictEqual(pi[0]?.totals.uncachedInputTokens, 7);
assert.strictEqual(
summary.sources.find((source) => source.fingerprint.provider === "pi")?.fingerprint
.resolvedHomePath,
dir,
);
}).pipe(
Effect.scoped,
Effect.provide(
layerService({
prefix: "usage-pi-" + relativeDir.replaceAll("/", "-"),
home,
settings:
launchArgs === undefined
? settings
: {
...settings,
providerInstances: {
...settings.providerInstances,
[ProviderInstanceId.make("pi")]: {
driver: ProviderDriverKind.make("pi"),
config: { launchArgs },
environment:
instanceHome === undefined
? []
: [
{
name: platform === "win32" ? "USERPROFILE" : "HOME",
value: NodePath.join(home, instanceHome),
sensitive: false,
},
],
},
},
},
environment: {
PI_CODING_AGENT_DIR: agentDir,
PI_CODING_AGENT_SESSION_DIR: sessionDir,
},
platform: platform ?? "linux",
}),
),
Effect.provideService(HostProcess.HomeDirectory, home),
);
}
}).pipe(Effect.scoped),
);
it.live("reads shared managed default and disabled extra account history once", () =>
Effect.gen(function* () {
const { home, settings } = yield* setup;
const summary = yield* Effect.gen(function* () {
for (const [id, output] of [
["codex", 17],
["codex-personal", 23],
] as const) {
const sessions = NodePath.join(home, "shared-codex", "sessions");
yield* Effect.promise(async () => {
await NodeFSP.mkdir(sessions, { recursive: true });
await NodeFSP.writeFile(
NodePath.join(sessions, `${id}-rollout.jsonl`),
[
{ type: "session_meta", payload: { id } },
{ type: "turn_context", payload: { model: "gpt-5.6-sol" } },
{
type: "event_msg",
timestamp: "2026-08-01T10:00:00Z",
payload: {
type: "token_count",
info: { last_token_usage: { input_tokens: 10, output_tokens: output } },
},
},
]
.map((line) => encodeUnknownJsonString(line))
.join("\n") + "\n",
);
});
}
const service = yield* UsageService.make;
return yield* service.readSummary(WINDOW);
}).pipe(
Effect.scoped,
Effect.provide(
layerService({
prefix: "usage-managed-accounts",
home,
settings: {
...settings,
providerInstances: {
...settings.providerInstances,
[ProviderInstanceId.make("codex")]: {
driver: ProviderDriverKind.make("codex"),
config: {
setupMode: "managed",
homePath: NodePath.join(home, "shared-codex"),
},
},
[ProviderInstanceId.make("codex-personal")]: {
driver: ProviderDriverKind.make("codex"),
enabled: false,
config: {
setupMode: "managed",
homePath: NodePath.join(home, "shared-codex"),
shadowHomePath: NodePath.join(home, "personal-shadow"),
},
environment: [
{
name: "CODEX_HOME",
value: NodePath.join(home, "ignored-environment"),
sensitive: false,
},
],
},
},
},
}),
),
);
assert.strictEqual(totalOutputTokens(summary), 40);
assert.strictEqual(
summary.sources.filter(
(source) => source.fingerprint.provider === "codex" && source.status === "ok",
).length,
1,
);
}).pipe(Effect.scoped),
);
it.live("keeps Cursor credential errors visible when a saved login cannot be read", () =>
Effect.gen(function* () {
const { settings, home } = yield* setup;
const authPath = NodePath.join(home, "config", "cursor", "auth.json");
yield* Effect.promise(async () => {
await NodeFSP.mkdir(NodePath.dirname(authPath), { recursive: true });
await NodeFSP.writeFile(authPath, "invalid json");
});
const service = yield* UsageService.make.pipe(
Effect.provide(
layerService({ prefix: "usage-service-cursor-invalid-login", home, settings }),
),
);
const summary = yield* service.readSummary({ ...WINDOW, awaitRefresh: true });
const cursor = summary.sources.find((source) => source.fingerprint.provider === "cursor");
assert.strictEqual(cursor?.message, "Cursor credentials could not be read.");
}).pipe(Effect.scoped),
);
it.live("restores the Cursor account cache after a restart", () =>
Effect.gen(function* () {
const { settings, home } = yield* setup;
yield* writeCursorLogin(home);
yield* TestClock.setTime(CURSOR_NOW);
const before = makeFakeCursor();
before.state.events = [
{ timestampMs: CURSOR_NOW - 30 * HOUR_MS, outputTokens: 5 },
{ timestampMs: CURSOR_NOW - 3 * HOUR_MS, outputTokens: 7 },
];
yield* Effect.gen(function* () {
const first = yield* makeWithCursor(before.read);
const original = yield* first.readSummary({ ...WINDOW, awaitRefresh: true });
yield* first.awaitPersisted;
const after = makeFakeCursor();
after.state.events = before.state.events;
const restarted = yield* makeWithCursor(after.read);
const restored = yield* restarted.readSummary(WINDOW);
assert.isUndefined(cursorSource(restored)?.refreshing);
assert.deepStrictEqual(restored.buckets, original.buckets);
assert.deepStrictEqual(cursorSource(restored), cursorSource(original));
assert.strictEqual(after.state.calls.length, 0);
yield* TestClock.adjust(Duration.minutes(2));
const refreshed = yield* restarted.readSummary({ ...WINDOW, awaitRefresh: true });
assert.deepStrictEqual(refreshed.buckets, original.buckets);
assert.deepStrictEqual(after.state.calls, [
{ sinceMs: CURSOR_NOW - HOUR_MS, untilMs: CURSOR_NOW + 2 * 60 * 1000 },
]);
}).pipe(
Effect.provide(layerService({ prefix: "usage-service-cursor-restart", home, settings })),
);
}).pipe(Effect.scoped, Effect.provide(TestClock.layer())),
);
it.live("does not read the macOS Cursor Keychain before account usage is enabled", () =>
Effect.gen(function* () {
const { settings, home } = yield* setup;
const service = yield* UsageService.make.pipe(
Effect.provide(
layerService({
prefix: "usage-service-cursor-keychain-disabled",
home,
settings,
platform: "darwin",
environment: {},
}),
),
);
const summary = yield* service.readSummary(WINDOW);
const cursor = summary.sources.find((source) => source.fingerprint.provider === "cursor");
assert.strictEqual(cursor?.status, "missing");
assert.strictEqual(cursor?.action, "enableCursorKeychain");
}).pipe(Effect.scoped),
);
it.effect("ignores a stale macOS Keychain login when Cursor is not installed", () =>
Effect.gen(function* () {
const { settings, home } = yield* setup;
const cursor = makeFakeCursor();
cursor.state.error = "Sign in to Cursor again to read account usage.";
const readCursorSource = Effect.gen(function* () {
const service = yield* makeWithCursor(cursor.read);
const summary = yield* service.readSummary({ ...WINDOW, awaitRefresh: true });
return cursorSource(summary);
}).pipe(
Effect.provide(
layerService({
prefix: "usage-service-cursor-keychain-uninstalled",
home,
settings: { ...settings, cursorKeychainUsageEnabled: true },
platform: "darwin",
environment: {},
}),
),
);
assert.isUndefined(yield* readCursorSource);
assert.lengthOf(cursor.state.calls, 0);
yield* Effect.promise(() => NodeFSP.mkdir(NodePath.join(home, ".cursor")));
const installed = yield* readCursorSource;
assert.strictEqual(installed?.message, "Sign in to Cursor again to read account usage.");
assert.lengthOf(cursor.state.calls, 1);
}).pipe(Effect.scoped),
);
it.live("ignores stale Cursor file logins when the active credential store differs", () =>
Effect.gen(function* () {
const { settings, home } = yield* setup;
for (const [index, testCase] of [
{
platform: "darwin" as const,
environment: { AGENT_CLI_CREDENTIAL_STORE: "memory" },
authPath: [".cursor", "auth.json"],
},
{
platform: "linux" as const,
environment: { AGENT_CLI_CREDENTIAL_STORE: "memory" },
authPath: ["config", "cursor", "auth.json"],
},
].entries()) {
const authPath = NodePath.join(home, ...testCase.authPath);
yield* Effect.promise(async () => {
await NodeFSP.mkdir(NodePath.dirname(authPath), { recursive: true });
await NodeFSP.writeFile(
authPath,
encodeUnknownJsonString({ accessToken: "stale-token" }),
);
});
const service = yield* UsageService.make.pipe(
Effect.provide(
layerService({
prefix: `usage-service-cursor-store-${index}`,
home,
settings,
platform: testCase.platform,
environment: testCase.environment,
}),
),
);
const summary = yield* service.readSummary(WINDOW);
const cursor = summary.sources.find((source) => source.fingerprint.provider === "cursor");
assert.strictEqual(cursor?.status, "missing");
assert.include(cursor?.message ?? "", "Cursor CLI login");
assert.isFalse(summary.buckets.some((bucket) => bucket.provider === "cursor"));
}
}).pipe(Effect.scoped),
);
it.live("reads the Cursor account of an API key or T3 sign-in instead of a CLI login", () =>
Effect.gen(function* () {
const { settings, home } = yield* setup;
const signIn = new TextEncoder().encode(
encodeUnknownJsonString({
version: 1,
backendUrl: "https://api2.cursor.sh",
apiKey: "signed-in-key",
createdAtMs: 0,
}),
);
for (const [index, testCase] of [
{ environment: { CURSOR_API_KEY: "environment-key" }, stored: Option.none() },
{ environment: {}, stored: Option.some(signIn) },
].entries()) {
const cursor = makeFakeCursor();
const summary = yield* Effect.gen(function* () {
const service = yield* makeWithCursor(cursor.read);
return yield* service.readSummary({ ...WINDOW, awaitRefresh: true });
}).pipe(
Effect.provide(
layerService({
prefix: `usage-service-cursor-api-key-${index}`,
home,
settings,
platform: "darwin",
environment: testCase.environment,
secretStore: { get: () => Effect.succeed(testCase.stored) },
}),
),
);
assert.deepStrictEqual(cursor.state.credentials, [
{ kind: "apiKey", apiKey: index === 0 ? "environment-key" : "signed-in-key" },
]);
assert.strictEqual(cursorSource(summary)?.status, "ok");
}
}).pipe(Effect.scoped),
);
it.live("does not show a previous Cursor account's history after the API key changes", () =>
Effect.gen(function* () {
const { settings, home } = yield* setup;
yield* TestClock.setTime(CURSOR_NOW);
let apiKey = "first-account-key";
const signIn = () =>
Option.some(
new TextEncoder().encode(
encodeUnknownJsonString({
version: 1,
backendUrl: "https://api2.cursor.sh",
apiKey,
createdAtMs: 0,
}),
),
);
const cursor = makeFakeCursor();
cursor.state.events = [{ timestampMs: CURSOR_NOW - 3 * HOUR_MS, outputTokens: 7 }];
yield* Effect.gen(function* () {
const service = yield* makeWithCursor(cursor.read);
const first = yield* service.readSummary({ ...WINDOW, awaitRefresh: true });
assert.isTrue(first.buckets.some((bucket) => bucket.provider === "cursor"));
apiKey = "second-account-key";
cursor.state.error = "Cursor account usage could not be read.";
const second = yield* service.readSummary({ ...WINDOW, awaitRefresh: true });
assert.isFalse(second.buckets.some((bucket) => bucket.provider === "cursor"));
}).pipe(
Effect.provide(
layerService({
prefix: "usage-service-cursor-key-change",
home,
settings,
platform: "darwin",
environment: {},
secretStore: { get: () => Effect.sync(signIn) },
}),
),
);
}).pipe(Effect.scoped, Effect.provide(TestClock.layer())),
);
it.live("keeps a new Cursor key's refresh visible beside a failing key", () =>
Effect.gen(function* () {
const { settings, home } = yield* setup;
const cursor = makeFakeCursor();
const started = yield* Deferred.make<void>();
const gate = yield* Deferred.make<void>();
yield* Effect.gen(function* () {
const context = yield* Layer.build(
layerCursorUsageAccounts(
Layer.succeed(CursorAccountReader.CursorAccountReader, {
read: (credential, sinceMs, untilMs) =>
(credential as { apiKey?: string }).apiKey === "failing-key"
? Effect.succeed({
accountKey: null,
records: [],
missing: false,
error: "Cursor account usage could not be read.",
})
: Deferred.succeed(started, undefined).pipe(
Effect.andThen(Deferred.await(gate)),
Effect.andThen(cursor.read(credential, sinceMs, untilMs)),
),
}),
),
);
const accounts = Context.get(context, CursorUsageAccounts.CursorUsageAccounts);
const scan = (awaitRefresh: boolean) =>
accounts.scan({
instances: [
{
instanceId: ProviderInstanceId.make("cursor"),
environment: { CURSOR_API_KEY: "failing-key" },
},
{
instanceId: ProviderInstanceId.make("cursor-work"),
environment: { CURSOR_API_KEY: "new-key" },
},
],
keychainUsageEnabled: false,
windowStartMs: 0,
retentionCutoffMs: 0,
awaitRefresh,
});
const first = yield* Effect.forkChild(scan(true));
yield* Deferred.await(started);
const sources = yield* scan(false);
assert.isTrue(sources.some((source) => source.refreshing === true));
yield* Deferred.succeed(gate, undefined);
yield* Fiber.join(first);
}).pipe(
Effect.provide(
layerService({
prefix: "usage-service-cursor-new-key",
home,
settings,
platform: "linux",
environment: {},
}),
),
);
}).pipe(Effect.scoped),
);
it.live("reports one Cursor source when two API keys belong to the same account", () =>
Effect.gen(function* () {
const { settings, home } = yield* setup;
yield* TestClock.setTime(CURSOR_NOW);
const cursor = makeFakeCursor();
cursor.state.events = [{ timestampMs: CURSOR_NOW - 3 * HOUR_MS, outputTokens: 7 }];
let revoked = false;
yield* Effect.gen(function* () {
const service = yield* makeWithCursor((credential, sinceMs, untilMs) =>
revoked && (credential as { apiKey?: string }).apiKey === "second-key"
? Effect.succeed({
accountKey: null,
records: [],
missing: false,
error: "Cursor account usage could not be read.",
})
: cursor.read(credential, sinceMs, untilMs),
);
const first = yield* service.readSummary({ ...WINDOW, awaitRefresh: true });
assert.strictEqual(cursor.state.credentials.length, 2);
assert.deepStrictEqual(
cursorSources(first).map((source) => source.distinctSessions),
[1],
);
// The revoked key keeps its stale cache, which must not replace the working key's history.
revoked = true;
cursor.state.events.push({ timestampMs: CURSOR_NOW + 60 * 1000, outputTokens: 5 });
yield* TestClock.adjust(Duration.minutes(2));
const second = yield* service.readSummary({ ...WINDOW, awaitRefresh: true });
assert.deepStrictEqual(
cursorSources(second).map((source) => source.status),
["ok"],
);
assert.strictEqual(totalOutputTokens(second), 12);
}).pipe(
Effect.provide(
layerService({
prefix: "usage-service-cursor-shared-account",
home,
settings: {
...settings,
providerInstances: {
...settings.providerInstances,
[ProviderInstanceId.make("cursor")]: {
driver: ProviderDriverKind.make("cursor"),
environment: [{ name: "CURSOR_API_KEY", value: "first-key", sensitive: true }],
},
[ProviderInstanceId.make("cursor-work")]: {
driver: ProviderDriverKind.make("cursor"),
environment: [{ name: "CURSOR_API_KEY", value: "second-key", sensitive: true }],
},
},
},
platform: "darwin",
environment: {},
}),
),
);
}).pipe(Effect.scoped, Effect.provide(TestClock.layer())),
);
it.live(
"includes OpenCode history but does not substitute desktop usage for an unavailable Cursor account",
() =>
Effect.gen(function* () {
const { settings, home } = yield* setup;
const root = NodePath.join(home, "opencode");
const message = yield* encodeUnknownJson({
id: "msg_1",
sessionID: "session-1",
role: "assistant",
modelID: "example-model",
time: { created: Date.parse("2026-08-01T10:00:00Z") },
tokens: { input: 10, output: 5, reasoning: 2, cache: { read: 20, write: 3 } },
});
const bubble = yield* encodeUnknownJson({
type: 2,
createdAt: "2026-08-01T10:00:00Z",
modelInfo: { modelName: "example-model" },
tokenCount: { inputTokens: 100, outputTokens: 20 },
});
yield* Effect.promise(async () => {
const directory = NodePath.join(root, "storage", "message", "session-1");
await NodeFSP.mkdir(directory, { recursive: true });
await NodeFSP.writeFile(NodePath.join(directory, "msg_1.json"), message);
const desktop = NodePath.join(home, "config", "Cursor", "User", "globalStorage");
await NodeFSP.mkdir(desktop, { recursive: true });
const db = new NodeSqlite.DatabaseSync(NodePath.join(desktop, "state.vscdb"));
try {
db.exec("CREATE TABLE cursorDiskKV (key TEXT, value TEXT)");
db.prepare("INSERT INTO cursorDiskKV VALUES (?, ?)").run(
"bubbleId:session:assistant",
bubble,
);
} finally {
db.close();
}
});
const service = yield* UsageService.make.pipe(
Effect.provide(layerService({ prefix: "usage-service-opencode", home, settings })),
);
const summary = yield* service.readSummary(WINDOW);
assert.strictEqual(summary.buckets[0]?.provider, "opencode");
assert.isFalse(summary.buckets.some((bucket) => bucket.provider === "cursor"));
assert.isFalse(summary.sources.some((source) => source.fingerprint.provider === "cursor"));
assert.strictEqual(
summary.buckets[0]?.sourcePath,
yield* Effect.promise(() => NodeFSP.realpath(root)),
);
assert.strictEqual(summary.buckets[0]?.totals.outputTokens, 7);
assert.strictEqual(
summary.sources.find((source) => source.fingerprint.provider === "opencode")
?.distinctSessions,
1,
);
}).pipe(Effect.scoped),
);
it.live("includes host and merged OpenCode instance histories once across list aliases", () =>
Effect.gen(function* () {
const { settings, home } = yield* setup;
const hostRoot = NodePath.join(home, "opencode");
const instanceRoot = NodePath.join(home, "opencode-work");
const alias = NodePath.join(home, "opencode-alias");
const dataHome = NodePath.join(home, "data");
const xdgRoot = NodePath.join(dataHome, "opencode");
const histories = [
{ root: hostRoot, id: "host", output: 5 },
{ root: instanceRoot, id: "work", output: 7 },
{ root: xdgRoot, id: "xdg", output: 11 },
];
yield* Effect.promise(async () => {
for (const { root, id, output } of histories) {
const directory = NodePath.join(root, "storage", "message", "session-1");
await NodeFSP.mkdir(directory, { recursive: true });
await NodeFSP.writeFile(
NodePath.join(directory, `${id}.json`),
encodeUnknownJsonString({
role: "assistant",
modelID: "example-model",
time: { created: Date.parse("2026-08-01T10:00:00Z") },
tokens: { input: 10, output },
}),
);
}
await NodeFSP.symlink(instanceRoot, alias, "junction");
});
const service = yield* UsageService.make.pipe(
Effect.provide(
layerService({
prefix: "usage-service-opencode-instances",
home,
environment: { XDG_DATA_HOME: dataHome },
settings: {
...settings,
providerInstances: {
...settings.providerInstances,
[ProviderInstanceId.make("opencode-work")]: {
driver: ProviderDriverKind.make("opencode"),
environment: [
{
name: "OPENCODE_DATA_DIR",
value: ` ${instanceRoot}, ${alias} `,
sensitive: false,
},
],
},
[ProviderInstanceId.make("opencode-xdg")]: {
driver: ProviderDriverKind.make("opencode"),
environment: [{ name: "OPENCODE_DATA_DIR", value: "", sensitive: false }],
},
},
},
}),
),
);
const summary = yield* service.readSummary(WINDOW);
const sources = summary.sources.filter(
(source) => source.fingerprint.provider === "opencode",
);
const expectedRoots = yield* Effect.promise(() =>
Promise.all(histories.map(({ root }) => NodeFSP.realpath(root))),
);
assert.deepStrictEqual(
sources.map((source) => source.fingerprint.resolvedHomePath).sort(),
expectedRoots.sort(),
);
assert.deepStrictEqual(
summary.buckets
.filter((bucket) => bucket.provider === "opencode")
.map((bucket) => bucket.totals.outputTokens)
.sort((a, b) => a - b),
[5, 7, 11],
);
}).pipe(Effect.scoped),
);
it.live("counts aliased OpenCode and Antigravity directories once", () =>
Effect.gen(function* () {
const { settings, home } = yield* setup;
const opencode = NodePath.join(home, "opencode-store");
const opencodeAlias = NodePath.join(home, "opencode-alias");
const conversations = NodePath.join(home, "antigravity-conversations");
const antigravityA = NodePath.join(home, "antigravity-a");
const antigravityB = NodePath.join(home, "antigravity-b");
yield* Effect.promise(async () => {
await NodeFSP.mkdir(opencode);
await NodeFSP.symlink(opencode, opencodeAlias, "junction");
await NodeFSP.mkdir(conversations);
await NodeFSP.mkdir(antigravityA);
await NodeFSP.mkdir(antigravityB);
await NodeFSP.symlink(
conversations,
NodePath.join(antigravityA, "conversations"),
"junction",
);
await NodeFSP.symlink(
conversations,
NodePath.join(antigravityB, "conversations"),
"junction",
);
});
const service = yield* UsageService.make.pipe(
Effect.provide(
layerService({
prefix: "usage-service-aliased-roots-test",
home,
settings,
environment: {
OPENCODE_DATA_DIR: `${opencode},${opencodeAlias}`,
ANTIGRAVITY_DATA_DIR: `${antigravityA},${antigravityB}`,
},
}),
),
);
const summary = yield* service.readSummary(WINDOW);
const sourcesFor = (provider: "opencode" | "antigravity") =>
summary.sources.filter((source) => source.fingerprint.provider === provider);
assert.strictEqual(sourcesFor("opencode").length, 1);
assert.strictEqual(sourcesFor("antigravity").length, 1);
assert.strictEqual(
sourcesFor("opencode")[0]?.fingerprint.resolvedHomePath,
yield* Effect.promise(() => NodeFSP.realpath(opencode)),
);
assert.strictEqual(
sourcesFor("antigravity")[0]?.fingerprint.resolvedHomePath,
yield* Effect.promise(() => NodeFSP.realpath(conversations)),
);
}).pipe(Effect.scoped),
);
it.live("reads Antigravity history from each instance's data directory", () =>
Effect.gen(function* () {
const { settings, home } = yield* setup;
const first = NodePath.join(home, "antigravity-first");
const second = NodePath.join(home, "antigravity-second");
yield* Effect.promise(async () => {
for (const [dir, outputTokens] of [
[first, 7],
[second, 11],
] as const) {
await NodeFSP.mkdir(dir);
const db = new NodeSqlite.DatabaseSync(
NodePath.join(dir, `${NodePath.basename(dir)}.db`),
);
try {
db.exec("CREATE TABLE steps (idx INTEGER, metadata BLOB)");
// Step protobuf: 100 input tokens, distinct output tokens, and 2026-08-01T10:00Z.
const metadata = new Uint8Array([
0x4a,
4,
0x10,
100,
0x18,
outputTokens,
...Buffer.from("420608a087b7d306", "hex"),
]);
db.prepare("INSERT INTO steps VALUES (?, ?)").run(0, metadata);
} finally {
db.close();
}
}
});
const instance = (dataDir: string) => ({
driver: ProviderDriverKind.make("antigravity"),
environment: [{ name: "ANTIGRAVITY_DATA_DIR", value: dataDir, sensitive: false }],
});
const service = yield* UsageService.make.pipe(
Effect.provide(
layerService({
prefix: "usage-service-antigravity-instances-test",
home,
settings: {
providerInstances: {
...settings.providerInstances,
[ProviderInstanceId.make("antigravity-first")]: instance(first),
[ProviderInstanceId.make("antigravity-second")]: instance(` ${second}, `),
},
},
}),
),
);
const summary = yield* service.readSummary(WINDOW);
const roots = summary.sources
.filter((source) => source.fingerprint.provider === "antigravity")
.map((source) => source.fingerprint.resolvedHomePath);
for (const [dir, outputTokens] of [
[first, 7],
[second, 11],
] as const) {
const root = yield* Effect.promise(() => NodeFSP.realpath(dir));
assert.include(roots, root);
assert.strictEqual(
summary.buckets
.filter((bucket) => bucket.provider === "antigravity" && bucket.sourcePath === root)
.reduce((sum, bucket) => sum + bucket.totals.outputTokens, 0),
outputTokens,
);
}
}).pipe(Effect.scoped),
);
it.live("reads configured and disabled accounts once across shared and aliased homes", () =>
Effect.gen(function* () {
const { transcript, settings, home } = yield* setup;
const codexHome = NodePath.join(home, "codex-account");
const alias = NodePath.join(home, "codex-alias");
const claudeHome = NodePath.join(home, "claude-account");
const grokHome = NodePath.join(home, "grok-account");
yield* Effect.promise(async () => {
await NodeFSP.writeFile(transcript, claudeLine(1, 5));
await NodeFSP.mkdir(NodePath.join(claudeHome, "projects"), { recursive: true });
await NodeFSP.writeFile(
NodePath.join(claudeHome, "projects", "session.jsonl"),
claudeLine(2, 7),
);
await NodeFSP.mkdir(NodePath.join(codexHome, "sessions"), { recursive: true });
await NodeFSP.symlink(codexHome, alias, "junction");
await NodeFSP.writeFile(
NodePath.join(codexHome, "sessions", "rollout.jsonl"),
[
{ type: "session_meta", payload: { id: "codex-account-session" } },
{ type: "turn_context", payload: { model: "gpt-5.6-sol" } },
...[11, 12, 11].map((outputTokens) => ({
type: "event_msg",
timestamp: "2026-08-01T10:00:00Z",
payload: {
type: "token_count",
info: { last_token_usage: { input_tokens: 10, output_tokens: outputTokens } },
},
})),
]
.map((line) => encodeUnknownJsonString(line))
.join("\n") + "\n",
);
await NodeFSP.mkdir(NodePath.join(grokHome, "sessions", "session"), { recursive: true });
await NodeFSP.writeFile(
NodePath.join(grokHome, "sessions", "session", "updates.jsonl"),
encodeUnknownJsonString({
timestamp: Date.parse("2026-08-01T10:00:00Z") / 1000,
method: "_x.ai/session/update",
params: {
sessionId: "grok-account-session",
update: {
sessionUpdate: "turn_completed",
prompt_id: "prompt-1",
usage: { inputTokens: 10, outputTokens: 13 },
},
},
}) + "\n",
);
});
const service = yield* UsageService.make.pipe(
Effect.provide(
layerService({
prefix: "usage-service-accounts-test",
home,
settings: {
...settings,
providerInstances: {
...settings.providerInstances,
[ProviderInstanceId.make("claude-work")]: {
driver: ProviderDriverKind.make("claudeAgent"),
enabled: false,
environment: [{ name: "CLAUDE_CONFIG_DIR", value: claudeHome, sensitive: false }],
},
[ProviderInstanceId.make("codex-work")]: {
driver: ProviderDriverKind.make("codex"),
environment: [{ name: "CODEX_HOME", value: codexHome, sensitive: false }],
},
[ProviderInstanceId.make("codex-alias")]: {
driver: ProviderDriverKind.make("codex"),
config: { homePath: alias },
},
[ProviderInstanceId.make("codex-shadow")]: {
driver: ProviderDriverKind.make("codex"),
config: { homePath: codexHome, shadowHomePath: NodePath.join(home, "shadow") },
environment: [
{ name: "CODEX_HOME", value: NodePath.join(home, "ignored"), sensitive: false },
],
},
[ProviderInstanceId.make("grok-work")]: {
driver: ProviderDriverKind.make("grok"),
config: { customModels: "not-a-list" },
environment: [{ name: "GROK_HOME", value: grokHome, sensitive: false }],
},
},
},
}),
),
);
const summary = yield* service.readSummary(WINDOW);
assert.strictEqual(totalOutputTokens(summary), 59);
yield* Effect.promise(() =>
NodeFSP.rename(
NodePath.join(codexHome, "sessions", "rollout.jsonl"),
NodePath.join(codexHome, "sessions", "moved.jsonl"),
),
);
const moved = yield* service.readSummary(WINDOW);
assert.deepStrictEqual(moved.buckets, summary.buckets);
yield* Effect.promise(() =>
NodeFSP.rm(NodePath.join(codexHome, "sessions"), { recursive: true }),
);
const removed = yield* service.readSummary(WINDOW);
assert.deepStrictEqual(removed.buckets, summary.buckets);
const sources = summary.sources.filter((source) => source.status === "ok");
assert.strictEqual(sources.length, 4);
assert.strictEqual(
sources.reduce((sum, source) => sum + source.scannedFiles, 0),
4,
);
assert.strictEqual(
sources.filter((source) => source.fingerprint.provider === "codex").length,
1,
);
}).pipe(Effect.scoped),
);
it.live(
"uses explicit account settings before environment and default homes, then refreshes them",
() =>
Effect.gen(function* () {
const { transcript, settings, home } = yield* setup;
const configured = NodePath.join(home, "configured");
const environmentHome = NodePath.join(home, "environment");
yield* Effect.promise(async () => {
await NodeFSP.writeFile(transcript, claudeLine(1, 100));
for (const [index, root] of [configured, environmentHome].entries()) {
await NodeFSP.mkdir(NodePath.join(root, "projects"), { recursive: true });
await NodeFSP.writeFile(
NodePath.join(root, "projects", "session.jsonl"),
claudeLine(index + 2, index + 7),
);
}
await NodeFSP.mkdir(NodePath.join(configured, ".claude", "projects"), {
recursive: true,
});
await NodeFSP.writeFile(
NodePath.join(configured, ".claude", "projects", "wrong.jsonl"),
claudeLine(4, 1000),
);
});
yield* Effect.gen(function* () {
const settingsService = yield* ServerSettings.ServerSettingsService;
const service = yield* UsageService.make;
const first = yield* service.readSummary(WINDOW);
assert.strictEqual(totalOutputTokens(first), 7);
const configuredProjects = yield* Effect.promise(() =>
NodeFSP.realpath(NodePath.join(configured, "projects")),
);
assert.include(
first.sources.map((source) => source.fingerprint.resolvedHomePath),
configuredProjects,
);
yield* settingsService.updateSettings({
providerInstances: {
...settings.providerInstances,
[ProviderInstanceId.make("claudeAgent")]: {
driver: ProviderDriverKind.make("claudeAgent"),
config: { homePath: "" },
environment: [
{ name: "CLAUDE_CONFIG_DIR", value: environmentHome, sensitive: false },
],
},
},
});
const second = yield* service.readSummary(WINDOW);
assert.strictEqual(totalOutputTokens(second), 8);
const environmentProjects = yield* Effect.promise(() =>
NodeFSP.realpath(NodePath.join(environmentHome, "projects")),
);
assert.include(
second.sources.map((source) => source.fingerprint.resolvedHomePath),
environmentProjects,
);
}).pipe(
Effect.scoped,
Effect.provide(
layerService({
prefix: "usage-service-home-refresh-test",
home,
environment: { CLAUDE_CONFIG_DIR: NodePath.join(home, "host-ignored") },
settings: {
...settings,
providerInstances: {
...settings.providerInstances,
[ProviderInstanceId.make("claudeAgent")]: {
driver: ProviderDriverKind.make("claudeAgent"),
config: { homePath: configured },
environment: [
{ name: "CLAUDE_CONFIG_DIR", value: environmentHome, sensitive: false },
],
},
},
},
}),
),
);
}).pipe(Effect.scoped),
);
it.live(
"uses inherited home variables when explicit default accounts have no home settings",
() =>
Effect.gen(function* () {
const { transcript, settings, home } = yield* setup;
yield* Effect.promise(() => NodeFSP.writeFile(transcript, claudeLine(1, 5)));
const service = yield* UsageService.make.pipe(
Effect.provide(
layerService({
prefix: "usage-service-inherited-homes-test",
home,
environment: {
CODEX_HOME: NodePath.join(home, "inherited-codex"),
CLAUDE_CONFIG_DIR: NodePath.join(home, "claude"),
},
settings: {
...settings,
providerInstances: {
[ProviderInstanceId.make("codex")]: {
driver: ProviderDriverKind.make("codex"),
config: {},
},
[ProviderInstanceId.make("claudeAgent")]: {
driver: ProviderDriverKind.make("claudeAgent"),
config: {},
},
},
},
}),
),
);
const summary = yield* service.readSummary(WINDOW);
assert.strictEqual(totalOutputTokens(summary), 5);
assert.strictEqual(
summary.sources.find((source) => source.fingerprint.provider === "codex")?.fingerprint
.resolvedHomePath,
NodePath.join(home, "inherited-codex", "sessions"),
);
assert.strictEqual(
summary.sources.find((source) => source.fingerprint.provider === "grok")?.fingerprint
.resolvedHomePath,
NodePath.join(home, "grok", "sessions"),
);
}).pipe(Effect.scoped),
);
it.live.skipIf(HostProcess.Platform.defaultValue() === "win32" || process.getuid?.() === 0)(
"reports unreadable transcripts as partial and recovers once they can be read",
() =>
Effect.gen(function* () {
const { transcript, settings, home } = yield* setup;
const unreadable = NodePath.join(NodePath.dirname(transcript), "other.jsonl");
yield* Effect.promise(async () => {
await NodeFSP.writeFile(transcript, claudeLine(1, 5));
await NodeFSP.writeFile(unreadable, claudeLine(2, 7));
await NodeFSP.chmod(unreadable, 0);
});
yield* Effect.gen(function* () {
const service = yield* UsageService.make;
const partial = yield* service.readSummary(WINDOW);
assert.strictEqual(totalOutputTokens(partial), 5);
assert.strictEqual(partial.sources[0]?.status, "partial");
yield* Effect.promise(() => NodeFSP.chmod(unreadable, 0o600));
const healthy = yield* service.readSummary(WINDOW);
assert.strictEqual(totalOutputTokens(healthy), 12);
assert.strictEqual(healthy.sources[0]?.status, "ok");
assert.isNull(healthy.sources[0]?.message);
}).pipe(
Effect.provide(layerService({ prefix: "usage-service-unreadable", home, settings })),
);
}).pipe(Effect.scoped),
);
it.live("filters original model IDs before aliases, pricing, buckets and session counts", () =>
Effect.gen(function* () {
const { transcript, settings, home } = yield* setup;
yield* Effect.promise(() =>
NodeFSP.writeFile(
transcript,
claudeLine(1, 3, "orbit-1", "mixed") +
claudeLine(2, 5, "orbit-2", "mixed") +
claudeLine(3, 7, "drift-9", "mixed") +
claudeLine(4, 11, "drift-9", "excluded-only"),
),
);
const rates = {
"orbit-1": { input_cost_per_token: 0.000001, output_cost_per_token: 0.00001 },
"orbit-2": { input_cost_per_token: 0.000002, output_cost_per_token: 0.00002 },
};
const include = {
// The codex selector must not match the Claude drift-9 records.
include: [
{ provider: "claude", model: "orbit-1" },
{ model: "orbit-2" },
{ provider: "codex", model: "drift-9" },
],
};
const exclude = { exclude: [{ model: "drift-9" }] };
const HOURLY: UsageSummaryInput = {
...WINDOW,
resolution: "hour",
sinceTime: "2026-08-01T09:00:00Z",
untilTime: "2026-08-01T11:00:00Z",
};
const cells = (summary: UsageSummary) =>
summary.buckets.map(({ model, totals, costUsd, records, sessions }) => ({
model,
outputTokens: totals.outputTokens,
costUsd: Math.round(costUsd * 1e6),
records,
sessions,
}));
yield* Effect.gen(function* () {
const service = yield* UsageService.make;
// Same service, concurrent reads: the in-flight key must keep these scans apart.
const [unfiltered, noOp, keepNothing, included, reordered, excluded, hourly] =
yield* Effect.all(
[
service.readSummary(WINDOW),
service.readSummary({ ...WINDOW, modelFilter: { exclude: [] } }),
service.readSummary({ ...WINDOW, modelFilter: { include: [] } }),
service.readSummary({ ...WINDOW, modelFilter: include }),
service.readSummary({
...WINDOW,
modelFilter: { include: [...include.include].reverse() },
}),
service.readSummary({ ...WINDOW, modelFilter: exclude }),
service.readSummary({ ...HOURLY, modelFilter: include }),
],
{ concurrency: "unbounded" },
);
// Unfiltered keeps today's behavior: the alias folds drift-9 into orbit-1.
assert.deepStrictEqual(cells(unfiltered), [
{ model: "orbit-1", outputTokens: 21, costUsd: 240, records: 3, sessions: 2 },
{ model: "orbit-2", outputTokens: 5, costUsd: 120, records: 1, sessions: 1 },
]);
assert.strictEqual(unfiltered.sources[0]?.distinctSessions, 2);
assert.strictEqual(unfiltered.modelFilter, undefined);
assert.strictEqual(noOp, unfiltered);
assert.deepStrictEqual(keepNothing.buckets, []);
assert.strictEqual(keepNothing.sources[0]?.distinctSessions, 0);
const kept = [
{ model: "orbit-1", outputTokens: 3, costUsd: 40, records: 1, sessions: 1 },
{ model: "orbit-2", outputTokens: 5, costUsd: 120, records: 1, sessions: 1 },
];
assert.deepStrictEqual(cells(included), kept);
assert.deepStrictEqual(cells(excluded), kept);
assert.deepStrictEqual(cells(hourly), kept);
assert.strictEqual(hourly.buckets[0]?.hourStart, "2026-08-01T10:00:00.000Z");
for (const summary of [included, excluded, hourly]) {
assert.strictEqual(summary.sources[0]?.distinctSessions, 1);
}
// Equal filters share one scan and echo one canonical form.
assert.strictEqual(reordered, included);
assert.deepStrictEqual(included.modelFilter, {
include: [
{ provider: "claude", model: "orbit-1" },
{ provider: "codex", model: "drift-9" },
{ model: "orbit-2" },
],
});
}).pipe(
Effect.scoped,
Effect.provide(
layerService({
prefix: "usage-service-model-filter-test",
home,
settings: { ...settings, usageModelAliases: { "drift-9": "orbit-1" } },
ratesDocument: rates,
}),
),
);
}).pipe(Effect.scoped),
);
it.live("reprices unchanged transcripts when custom prices are added, edited, or removed", () =>
Effect.gen(function* () {
const { transcript, settings, home } = yield* setup;
yield* Effect.promise(() => NodeFSP.writeFile(transcript, claudeLine(1, 5, "example-model")));
yield* Effect.gen(function* () {
const settingsService = yield* ServerSettings.ServerSettingsService;
const service = yield* UsageService.make;
const original = yield* service.readSummary(WINDOW);
assert.strictEqual(original.buckets[0]?.costUsd, 0);
assert.strictEqual(original.buckets[0]?.unpricedRecords, 1);
yield* settingsService.updateSettings({
usagePriceOverrides: {
"example-model": { inputCostPerMillionTokens: 2, outputCostPerMillionTokens: 8 },
},
});
const overridden = yield* service.readSummary(WINDOW);
assert.closeTo(overridden.buckets[0]?.costUsd ?? -1, 0.00006, 1e-12);
assert.strictEqual(overridden.buckets[0]?.costSource, "modelPriced");
assert.strictEqual(overridden.buckets[0]?.unpricedRecords, 0);
assert.deepStrictEqual(overridden.buckets[0]?.totals, original.buckets[0]?.totals);
yield* settingsService.updateSettings({
usagePriceOverrides: {
"example-model": { inputCostPerMillionTokens: 4, outputCostPerMillionTokens: 16 },
},
});
const edited = yield* service.readSummary(WINDOW);
assert.closeTo(edited.buckets[0]?.costUsd ?? -1, 0.00012, 1e-12);
yield* settingsService.updateSettings({ usagePriceOverrides: { "example-model": null } });
const restored = yield* service.readSummary(WINDOW);
assert.deepStrictEqual(restored.buckets, original.buckets);
}).pipe(
Effect.scoped,
Effect.provide(
layerService({ prefix: "usage-service-price-overrides-test", home, settings }),
),
);
}).pipe(Effect.scoped),
);
it.live(
"retains Codex reconciliation and partial coverage through persisted restart, append and repair",
() =>
Effect.gen(function* () {
const { home, settings } = yield* setup;
const dir = NodePath.join(home, "codex", "sessions");
const transcript = NodePath.join(dir, "rollout.jsonl");
const usage = (input: number, output: number) => ({
input_tokens: input,
output_tokens: output,
total_tokens: input + output,
});
const counted = (input: number, output: number, totalInput: number, totalOutput: number) =>
encodeUnknownJsonString({
type: "event_msg",
timestamp: "2026-08-01T10:00:00Z",
payload: {
type: "token_count",
info: {
last_token_usage: usage(input, output),
total_token_usage: usage(totalInput, totalOutput),
},
},
});
const tier = (service_tier: string) =>
encodeUnknownJsonString({
type: "event_msg",
payload: { type: "thread_settings_applied", thread_settings: { service_tier } },
});
const bad = counted(10, 2, 130, 28);
// Cross the reader's projection threshold so cumulative fields must survive selection.
const stale = counted(20, 5, 100, 20).replace(
'"payload":',
'"padding":' + encodeUnknownJsonString("x".repeat(9 * 1024 * 1024)) + ',"payload":',
);
let content = [
encodeUnknownJsonString({ type: "turn_context", payload: { model: "gpt-6-astra" } }),
counted(100, 20, 100, 20),
stale,
tier("priority"),
bad,
].join("\n");
yield* Effect.promise(async () => {
await NodeFSP.mkdir(dir, { recursive: true });
await NodeFSP.writeFile(transcript, content);
});
yield* Effect.gen(function* () {
const verify = (
summary: UsageSummary,
output: number,
cost: number,
malformed: number,
) => {
assert.strictEqual(totalOutputTokens(summary), output);
assert.strictEqual(
summary.buckets.reduce((sum, bucket) => sum + bucket.costUsd, 0),
cost,
);
const source = summary.sources.find(
(source) => source.fingerprint.provider === "codex",
);
assert.strictEqual(source?.status, malformed === 0 ? "ok" : "partial");
assert.strictEqual(source?.malformedRecords, malformed);
if (malformed > 0) assert.match(source?.message ?? "", /1 malformed or inconsistent/);
else assert.notMatch(source?.message ?? "", /malformed|inconsistent/);
};
const open = vi.spyOn(NodeFSP, "open");
open.mockClear();
yield* Effect.addFinalizer(() => Effect.sync(() => open.mockRestore()));
const first = yield* UsageService.make;
const cold = yield* first.readSummary(WINDOW);
assert.isTrue(open.mock.calls.some(([path]) => path === transcript));
verify(cold, 20, 20, 1);
yield* first.awaitPersisted;
const restarted = yield* UsageService.make;
open.mockClear();
verify(yield* first.readSummary(WINDOW), 20, 20, 1);
verify(yield* restarted.readSummary(WINDOW), 20, 20, 1);
assert.isFalse(open.mock.calls.some(([path]) => path === transcript));
open.mockRestore();
const append = "\n" + counted(10, 2, 140, 30) + "\n";
content += append;
yield* Effect.promise(() => NodeFSP.appendFile(transcript, append));
verify(yield* restarted.readSummary(WINDOW), 22, 24, 1);
yield* restarted.awaitPersisted;
const resumed = yield* UsageService.make;
verify(yield* resumed.readSummary(WINDOW), 22, 24, 1);
const next = tier("ultrafast") + "\n" + counted(10, 2, 150, 32) + "\n";
content += next;
yield* Effect.promise(() => NodeFSP.appendFile(transcript, next));
verify(yield* resumed.readSummary(WINDOW), 24, 36, 1);
const repaired = content.replace(bad, counted(30, 8, 130, 28));
assert.strictEqual(Buffer.byteLength(repaired), Buffer.byteLength(content));
yield* Effect.promise(async () => {
const stat = await NodeFSP.stat(transcript);
await NodeFSP.writeFile(transcript, repaired);
await NodeFSP.utimes(transcript, stat.atime, stat.mtimeMs / 1000 + 1);
});
verify(yield* resumed.readSummary(WINDOW), 32, 52, 0);
}).pipe(
Effect.provide(
layerService({
prefix: "usage-codex-reconciliation",
home,
settings,
ratesDocument: {
"gpt-6-astra": {
input_cost_per_token: 0,
output_cost_per_token: 1,
input_cost_per_token_priority: 0,
output_cost_per_token_priority: 2,
input_cost_per_token_ultrafast: 0,
output_cost_per_token_ultrafast: 6,
},
},
}),
),
);
}).pipe(Effect.scoped),
);
it.live(
"keeps large-record totals and costs exact through append, dedupe, restart and cleanup",
() =>
Effect.gen(function* () {
const { transcript, settings, home } = yield* setup;
const large = claudeLine(1, 9900).replace(
'"message":',
'"padding":' + encodeUnknownJsonString("x".repeat(9 * 1024 * 1024)) + ',"message":',
);
yield* Effect.promise(() => NodeFSP.writeFile(transcript, large));
yield* Effect.gen(function* () {
const service = yield* UsageService.make;
const first = yield* service.readSummary(WINDOW);
assert.strictEqual(totalOutputTokens(first), 9900);
assert.closeTo(
first.buckets.reduce((sum, bucket) => sum + bucket.costUsd, 0),
0.4951,
1e-12,
);
const warm = yield* service.readSummary(WINDOW);
assert.deepStrictEqual(warm.buckets, first.buckets);
yield* Effect.promise(() => NodeFSP.appendFile(transcript, large + claudeLine(2, 100)));
const appended = yield* service.readSummary(WINDOW);
assert.strictEqual(totalOutputTokens(appended), 10000);
assert.strictEqual(
appended.buckets.reduce((sum, bucket) => sum + bucket.totals.uncachedInputTokens, 0),
20,
);
yield* service.awaitPersisted;
const restarted = yield* UsageService.make;
const restored = yield* restarted.readSummary(WINDOW);
assert.deepStrictEqual(restored.buckets, appended.buckets);
yield* restarted.awaitPersisted;
yield* Effect.promise(() => NodeFSP.rm(transcript));
const afterCleanup = yield* UsageService.make;
assert.deepStrictEqual(
(yield* afterCleanup.readSummary(WINDOW)).buckets,
appended.buckets,
);
}).pipe(
Effect.scoped,
Effect.provide(
layerService({
prefix: "usage-service-large-record-test",
home,
settings,
ratesDocument: {
"claude-fable-5": { input_cost_per_token: 1e-5, output_cost_per_token: 5e-5 },
},
}),
),
);
}).pipe(Effect.scoped),
);
it.live.each([4, 5, 6, 7, 8, 10])(
"upgrades a v%s cache: reparses live Codex usage, keeps deleted rollouts and the old file",
(version) =>
Effect.gen(function* () {
const { home, settings } = yield* setup;
const sessions = NodePath.join(home, "codex", "sessions");
const rollout = (sessionId: string, outputTokens: number) =>
[
{ type: "session_meta", payload: { id: sessionId } },
{ type: "turn_context", payload: { model: "gpt-6-astra" } },
{
type: "event_msg",
payload: {
type: "thread_settings_applied",
thread_settings: { service_tier: "ultrafast" },
},
},
{
type: "event_msg",
timestamp: "2026-08-01T10:00:00Z",
payload: {
type: "token_count",
info: {
last_token_usage: { input_tokens: 0, output_tokens: outputTokens },
total_token_usage: { input_tokens: 100, output_tokens: outputTokens + 30 },
},
},
},
]
.map((line) => encodeUnknownJsonString(line))
.join("\n") + "\n";
const live = NodePath.join(sessions, "live.jsonl");
const deleted = NodePath.join(sessions, "deleted.jsonl");
yield* Effect.promise(async () => {
await NodeFSP.mkdir(sessions, { recursive: true });
await NodeFSP.writeFile(live, rollout("live", 10));
await NodeFSP.writeFile(deleted, rollout("deleted", 20));
});
yield* Effect.gen(function* () {
const { stateDir } = yield* ServerConfig.ServerConfig;
const cachePath = NodePath.join(stateDir, SCAN_CACHE_FILE_NAME);
const legacyPath = NodePath.join(
stateDir,
version === 4 ? "usage-scan-cache.json" : `usage-scan-cache-v${version}.json`,
);
const first = yield* UsageService.make;
yield* first.readSummary(WINDOW);
yield* first.awaitPersisted;
const legacy = yield* Effect.promise(async () => {
const livePath = await NodeFSP.realpath(live);
const document = decodeUnknownJsonString(await NodeFSP.readFile(cachePath, "utf8")) as {
files: Record<string, { r: unknown[][]; mr: number; cs: Record<string, unknown> }>;
};
for (const [path, file] of Object.entries(document.files)) {
file.r = file.r.map((row) => [
...row.slice(0, 6),
path === livePath ? 99 : row[6],
...row.slice(7, 10),
version === 4 ? 0 : 1,
]);
if (version === 4) delete file.cs.speed;
if (version < 6) {
delete file.cs.lastCumulativeUsage;
delete file.cs.malformedRecords;
}
if (version >= 8 && path === livePath) {
file.r = [];
file.mr = 1;
file.cs.malformedRecords = 1;
}
}
const text = encodeUnknownJsonString({ ...document, version });
await NodeFSP.rm(cachePath);
await NodeFSP.writeFile(legacyPath, text);
if (version === 6) {
for (const [name, olderVersion] of [
["usage-scan-cache-v5.json", 5],
["usage-scan-cache.json", 4],
] as const) {
await NodeFSP.writeFile(
NodePath.join(stateDir, name),
encodeUnknownJsonString({ ...document, version: olderVersion, files: {} }),
);
}
}
await NodeFSP.rm(deleted);
return text;
});
const upgraded = yield* UsageService.make;
const summary = yield* upgraded.readSummary(WINDOW);
assert.strictEqual(totalOutputTokens(summary), 30);
assert.strictEqual(
summary.buckets.reduce((sum, bucket) => sum + bucket.costUsd, 0),
60 + 20 * (version === 4 ? 1 : 2),
);
yield* upgraded.awaitPersisted;
assert.strictEqual(SCAN_CACHE_FILE_NAME, "usage-scan-cache-v11.json");
assert.strictEqual(
yield* Effect.promise(() => NodeFSP.readFile(legacyPath, "utf8")),
legacy,
);
}).pipe(
Effect.provide(
layerService({
prefix: "usage-service-cache-upgrade-test",
home,
settings,
ratesDocument: {
"gpt-6-astra": {
input_cost_per_token: 0,
output_cost_per_token: 1,
input_cost_per_token_priority: 0,
output_cost_per_token_priority: 2,
input_cost_per_token_ultrafast: 0,
output_cost_per_token_ultrafast: 6,
},
},
}),
),
);
}).pipe(Effect.scoped),
);
it.live("re-parses a clean v10 Codex rollout that grew after an interrupted request", () =>
Effect.gen(function* () {
const { home, settings } = yield* setup;
const sessions = NodePath.join(home, "codex", "sessions");
const live = NodePath.join(sessions, "live.jsonl");
const usage = (input: number, output: number) => ({
input_tokens: input,
output_tokens: output,
total_tokens: input + output,
});
const lines = (values: readonly unknown[]) =>
values.map((value) => `${encodeUnknownJsonString(value)}\n`).join("");
const request = (second: number, last: unknown) => ({
type: "token_usage_record",
timestamp: `2026-08-01T10:00:0${second}Z`,
payload: { usage: last },
});
const tokenCount = (second: number, last: unknown, total: unknown) => ({
type: "event_msg",
timestamp: `2026-08-01T10:00:0${second}Z`,
payload: {
type: "token_count",
info: { last_token_usage: last, total_token_usage: total },
},
});
yield* Effect.promise(async () => {
await NodeFSP.mkdir(sessions, { recursive: true });
await NodeFSP.writeFile(
live,
lines([
{ type: "session_meta", payload: { id: "live" } },
{ type: "turn_context", payload: { turn_id: "turn-1", model: "gpt-6-astra" } },
request(1, usage(100, 20)),
tokenCount(1, usage(100, 20), usage(100, 20)),
// Interrupted after this request finished: no token_count reports it.
request(2, usage(150, 10)),
]),
);
});
yield* Effect.gen(function* () {
const { stateDir } = yield* ServerConfig.ServerConfig;
const tokens = (summary: UsageSummary) =>
summary.buckets.reduce((sum, bucket) => sum + totalTokens(bucket.totals), 0);
const first = yield* UsageService.make;
assert.strictEqual(tokens(yield* first.readSummary(WINDOW)), 120);
yield* first.awaitPersisted;
yield* Effect.promise(async () => {
const cachePath = NodePath.join(stateDir, SCAN_CACHE_FILE_NAME);
const document = decodeUnknownJsonString(await NodeFSP.readFile(cachePath, "utf8")) as {
files: Record<string, { cs: Record<string, unknown> }>;
};
// The v10 parser ignored `token_usage_record`, so its clean state held nothing pending.
for (const file of Object.values(document.files)) {
file.cs = Object.fromEntries(
Object.entries(file.cs).filter(([key]) => !key.startsWith("unreported")),
);
}
await NodeFSP.rm(cachePath);
await NodeFSP.writeFile(
NodePath.join(stateDir, "usage-scan-cache-v10.json"),
encodeUnknownJsonString({ ...document, version: 10 }),
);
await NodeFSP.appendFile(
live,
lines([
{ type: "turn_context", payload: { turn_id: "turn-2", model: "gpt-6-astra" } },
request(5, usage(200, 30)),
tokenCount(5, usage(200, 30), usage(450, 60)),
]),
);
});
const upgraded = yield* UsageService.make;
const summary = yield* upgraded.readSummary(WINDOW);
assert.deepStrictEqual(
{
tokens: tokens(summary),
malformedRecords: summary.sources.find(
(source) => source.fingerprint.provider === "codex",
)?.malformedRecords,
},
{ tokens: 510, malformedRecords: 0 },
);
}).pipe(
Effect.provide(
layerService({
prefix: "usage-service-cache-v10-interrupted-test",
home,
settings,
ratesDocument: {
"gpt-6-astra": { input_cost_per_token: 0, output_cost_per_token: 1 },
},
}),
),
);
}).pipe(Effect.scoped),
);
it.live("preserves saved tokens, costs and sessions after transcript cleanup and restart", () =>
Effect.gen(function* () {
const { transcript, settings, home } = yield* setup;
const alias = NodePath.join(home, "claude-alias");
yield* Effect.promise(() =>
NodeFSP.symlink(NodePath.join(home, "claude"), alias, "junction"),
);
const content = claudeLine(1, 5);
yield* Effect.promise(() => NodeFSP.writeFile(transcript, content));
yield* Effect.gen(function* () {
const service = yield* UsageService.make;
const first = yield* service.readSummary(WINDOW);
assert.strictEqual(totalOutputTokens(first), 5);
assert.isAbove(first.buckets[0]?.costUsd ?? 0, 0);
yield* Effect.promise(() => NodeFSP.rm(transcript));
const deleted = yield* service.readSummary(WINDOW);
assert.deepStrictEqual(deleted.buckets, first.buckets);
assert.deepStrictEqual(deleted.sources, first.sources);
yield* service.awaitPersisted;
const restarted = yield* UsageService.make;
const restored = yield* restarted.readSummary(WINDOW);
assert.deepStrictEqual(restored.buckets, first.buckets);
assert.deepStrictEqual(restored.sources, first.sources);
yield* Effect.promise(() => NodeFSP.writeFile(transcript + ".jsonl", content));
const moved = yield* restarted.readSummary(WINDOW);
assert.deepStrictEqual(moved.buckets, first.buckets);
assert.strictEqual(moved.sources[0]?.distinctSessions, 1);
yield* restarted.awaitPersisted;
const replacementProjects = NodePath.join(home, "replacement-projects");
yield* Effect.promise(() => NodeFSP.mkdir(replacementProjects));
yield* Effect.promise(() =>
NodeFSP.rm(NodePath.join(home, "claude", "projects"), { recursive: true }),
);
const afterRootCleanup = yield* UsageService.make;
const missingRoot = yield* afterRootCleanup.readSummary(WINDOW);
assert.deepStrictEqual(missingRoot.buckets, first.buckets);
assert.strictEqual(missingRoot.sources[0]?.distinctSessions, 1);
assert.strictEqual(missingRoot.sources[0]?.status, "ok");
assert.deepStrictEqual(missingRoot.sources[0]?.fingerprint, first.sources[0]?.fingerprint);
yield* Effect.promise(async () => {
const projects = NodePath.join(home, "claude", "projects");
await NodeFSP.rename(replacementProjects, projects);
await NodeFSP.writeFile(NodePath.join(projects, "new.jsonl"), claudeLine(2, 7));
});
const recreated = yield* afterRootCleanup.readSummary(WINDOW);
assert.strictEqual(totalOutputTokens(recreated), 12);
assert.deepStrictEqual(recreated.sources[0]?.fingerprint, first.sources[0]?.fingerprint);
const merged = mergeUsage(
[
{
environmentId: EnvironmentId.make("cleanup-test"),
label: "test",
summary: recreated,
},
{
environmentId: EnvironmentId.make("other-environment"),
label: "before cleanup",
summary: first,
},
],
missingRoot.contractVersion,
);
assert.strictEqual(merged.outputTokens, 12);
assert.strictEqual(merged.sessions, 1);
assert.strictEqual(merged.costUsd, recreated.buckets[0]?.costUsd);
const outsideWindow = yield* restarted.readSummary({
...WINDOW,
sinceDay: UsageDay.make("2026-08-02"),
});
assert.deepStrictEqual(outsideWindow.buckets, []);
assert.strictEqual(outsideWindow.sources[0]?.distinctSessions, 0);
}).pipe(
Effect.scoped,
Effect.provide(
layerService({
prefix: "usage-service-cleanup-test",
home,
settings: {
providerInstances: {
...settings.providerInstances,
[ProviderInstanceId.make("claudeAgent")]: {
driver: ProviderDriverKind.make("claudeAgent"),
config: { homePath: alias },
},
},
},
ratesDocument: {
"claude-fable-5": { input_cost_per_token: 1e-5, output_cost_per_token: 5e-5 },
},
}),
),
);
}).pipe(Effect.scoped),
);
it.live("credits the same copy of a duplicate after its transcripts are deleted", () =>
Effect.gen(function* () {
const { transcript, settings, home } = yield* setup;
const dir = NodePath.dirname(transcript);
const [first = "", second = ""] = yield* Effect.promise(async () => {
await NodeFSP.writeFile(NodePath.join(dir, "a.jsonl"), "");
await NodeFSP.writeFile(NodePath.join(dir, "b.jsonl"), "");
return (await NodeFSP.readdir(dir)).map((name) => NodePath.join(dir, name));
});
const forked = (line: string) => line.replace('"session-1"', '"session-2"');
yield* Effect.promise(async () => {
await NodeFSP.writeFile(
first,
claudeLine(1, 5).replace(
'"message":',
'"padding":' + encodeUnknownJsonString("x".repeat(9 * 1024 * 1024)) + ',"message":',
),
);
await NodeFSP.writeFile(second, forked(claudeLine(1, 5)) + forked(claudeLine(2, 7)));
});
yield* Effect.gen(function* () {
const service = yield* UsageService.make;
const live = yield* service.readSummary(WINDOW);
assert.strictEqual(live.buckets[0]?.sessions, 2);
yield* Effect.promise(() => Promise.all([NodeFSP.rm(first), NodeFSP.rm(second)]));
const saved = yield* service.readSummary(WINDOW);
assert.deepStrictEqual(saved.buckets, live.buckets);
assert.deepStrictEqual(saved.sources, live.sources);
yield* service.awaitPersisted;
const restored = yield* (yield* UsageService.make).readSummary(WINDOW);
assert.deepStrictEqual(restored.buckets, live.buckets);
}).pipe(
Effect.provide(layerService({ prefix: "usage-service-copy-order-test", home, settings })),
);
}).pipe(Effect.scoped),
);
it.live.skipIf(HostProcess.Platform.defaultValue() === "win32")(
"keeps a newer cached read when a slower scan of another window finishes later",
() =>
Effect.gen(function* () {
const { transcript, settings, home } = yield* setup;
const dir = NodePath.dirname(transcript);
const probe = NodePath.join(dir, "probe.jsonl");
const hold = NodePath.join(dir, "hold.jsonl");
yield* Effect.promise(() => NodeFSP.writeFile(transcript, claudeLine(1, 5)));
yield* makeGate(probe, BEFORE_NARROW_WINDOW);
yield* makeGate(hold, BEFORE_NARROW_WINDOW);
yield* Effect.gen(function* () {
const service = yield* UsageService.make;
const wide = yield* service.readSummary(WINDOW).pipe(Effect.forkChild);
yield* openGate(probe);
yield* replaceFile(transcript, claudeLine(1, 5) + claudeLine(2, 7));
yield* service.readSummary(NARROW_WINDOW);
yield* openGate(hold);
yield* Fiber.join(wide);
yield* Effect.promise(() =>
Promise.all([transcript, probe, hold].map((path) => NodeFSP.rm(path))),
);
assert.strictEqual(totalOutputTokens(yield* service.readSummary(WINDOW)), 12);
}).pipe(
Effect.provide(layerService({ prefix: "usage-service-stale-read-test", home, settings })),
);
}).pipe(Effect.scoped),
);
it.live("keeps an absent directory missing when its cached files only contain diagnostics", () =>
Effect.gen(function* () {
const { transcript, settings, home } = yield* setup;
yield* Effect.promise(() =>
NodeFSP.rm(NodePath.join(home, "claude", "projects"), { recursive: true }),
);
yield* Effect.gen(function* () {
const { stateDir } = yield* ServerConfig.ServerConfig;
const mtimeMs = yield* Clock.currentTimeMillis;
const cache = makeScanCacheWriter()(
new Map([
[
transcript,
{
size: 0,
mtimeMs,
provider: "claude" as const,
records: [],
tailRecords: [],
malformedRecords: 2,
position: { resumeOffset: 0, guardLength: 0, guardHash: 0, state: null },
},
],
]),
{},
);
yield* Effect.promise(async () => {
await NodeFSP.mkdir(stateDir, { recursive: true });
await NodeFSP.writeFile(NodePath.join(stateDir, SCAN_CACHE_FILE_NAME), cache);
});
const summary = yield* (yield* UsageService.make).readSummary(WINDOW);
const source = summary.sources.find((source) => source.fingerprint.provider === "claude");
assert.strictEqual(source?.status, "missing");
assert.strictEqual(source?.scannedFiles, 0);
assert.strictEqual(source?.malformedRecords, 2);
}).pipe(
Effect.provide(
layerService({ prefix: "usage-service-missing-diagnostics", home, settings }),
),
);
}).pipe(Effect.scoped),
);
it.live("reports saved usage of a removed directory only for windows it reaches", () =>
Effect.gen(function* () {
yield* TestClock.setTime(Date.parse("2026-08-12T00:00:00Z"));
const { transcript, settings, home } = yield* setup;
// Saved usage is pruned after the retention window, so pin "now" near the write.
yield* TestClock.setTime(Date.parse("2026-08-15T00:00:00Z"));
yield* Effect.promise(async () => {
await NodeFSP.writeFile(transcript, claudeLine(1, 5));
const lastWrite = Date.parse("2026-08-01T10:00:00Z") / 1000;
await NodeFSP.utimes(transcript, lastWrite, lastWrite);
});
const service = yield* UsageService.make.pipe(
Effect.provide(layerService({ prefix: "usage-service-saved-window-test", home, settings })),
);
const first = yield* service.readSummary(WINDOW);
yield* Effect.promise(() =>
NodeFSP.rm(NodePath.join(home, "claude", "projects"), { recursive: true }),
);
const reached = yield* service.readSummary(WINDOW);
assert.deepStrictEqual(reached.buckets, first.buckets);
assert.strictEqual(reached.sources[0]?.status, "ok");
const later = yield* service.readSummary({
timeZone: "UTC",
sinceDay: UsageDay.make("2026-08-10"),
untilDay: UsageDay.make("2026-08-12"),
});
assert.deepStrictEqual(later.buckets, []);
assert.strictEqual(later.sources[0]?.status, "missing");
assert.strictEqual(later.sources[0]?.scannedFiles, 0);
}).pipe(Effect.scoped, Effect.provide(TestClock.layer())),
);
it.live("does not share an in-flight scan after custom prices change", () =>
Effect.gen(function* () {
const { transcript, settings, home } = yield* setup;
yield* Effect.promise(() => NodeFSP.writeFile(transcript, claudeLine(1, 5, "example-model")));
const transcriptDir = yield* Effect.promise(() =>
NodeFSP.realpath(NodePath.join(home, "claude", "projects")),
);
yield* Effect.gen(function* () {
const settingsService = yield* ServerSettings.ServerSettingsService;
const fileSystem = yield* FileSystem.FileSystem;
const firstScanStarted = yield* Deferred.make<void>();
const secondScanStarted = yield* Deferred.make<void>();
const releaseRates = yield* Deferred.make<void>();
let homeProbes = 0;
const service = yield* UsageService.make.pipe(
Effect.provideService(FileSystem.FileSystem, {
...fileSystem,
exists: (path) =>
fileSystem.exists(path).pipe(
Effect.tap(() => {
if (path !== transcriptDir) return Effect.void;
homeProbes += 1;
return Deferred.succeed(
homeProbes === 1 ? firstScanStarted : secondScanStarted,
undefined,
);
}),
),
}),
Effect.provideService(
HttpClient.HttpClient,
HttpClient.make((request) =>
Deferred.await(releaseRates).pipe(
Effect.as(HttpClientResponse.fromWeb(request, Response.json({}))),
),
),
),
);
const first = yield* service.readSummary(WINDOW).pipe(Effect.forkChild);
yield* Deferred.await(firstScanStarted);
yield* settingsService.updateSettings({
usagePriceOverrides: {
"example-model": { inputCostPerMillionTokens: 2, outputCostPerMillionTokens: 8 },
},
});
const second = yield* service.readSummary(WINDOW).pipe(Effect.forkChild);
yield* Deferred.await(secondScanStarted);
yield* Deferred.succeed(releaseRates, undefined);
const original = yield* Fiber.join(first);
const updated = yield* Fiber.join(second);
assert.strictEqual(original.buckets[0]?.costUsd, 0);
assert.closeTo(updated.buckets[0]?.costUsd ?? -1, 0.00006, 1e-12);
}).pipe(
Effect.provide(layerService({ prefix: "usage-service-price-race-test", home, settings })),
);
}).pipe(Effect.scoped),
);
it.live.each(["network", "http", "invalidJson", "empty"] as const)(
"recovers pricing through the GitHub API after a %s failure",
(failure) =>
Effect.gen(function* () {
const { transcript, settings, home } = yield* setup;
yield* Effect.promise(() => NodeFSP.writeFile(transcript, claudeLine(1, 5)));
const requests: HttpClientRequest.HttpClientRequest[] = [];
const ratesDocument = {
"claude-fable-5": { input_cost_per_token: 1e-5, output_cost_per_token: 5e-5 },
};
const serviceLayer = layerService({
prefix: `usage-service-rates-fallback-${failure}-test`,
home,
settings,
onRatesFetch: (request) => requests.push(request),
ratesResponse: (request) => {
if (request.url.startsWith("https://api.github.com/")) {
return Effect.succeed(Response.json(ratesDocument));
}
if (failure === "network") {
return Effect.fail(
new HttpClientError.HttpClientError({
reason: new HttpClientError.TransportError({
request,
cause: new Error("getaddrinfo ENOTFOUND raw.githubusercontent.com"),
}),
}),
);
}
return Effect.succeed(
failure === "invalidJson"
? new Response("not JSON")
: Response.json({}, { status: failure === "http" ? 503 : 200 }),
);
},
});
const service = yield* UsageService.make.pipe(Effect.provide(serviceLayer));
const summary = yield* service.readSummary(WINDOW);
assert.strictEqual(summary.pricing.status, "fresh");
assert.strictEqual(summary.pricing.knownModels, 1);
assert.closeTo(summary.buckets[0]?.costUsd ?? -1, 0.00035, 1e-12);
assert.deepStrictEqual(
requests.map((request) => request.url),
[
"https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json",
"https://api.github.com/repos/BerriAI/litellm/contents/model_prices_and_context_window.json?ref=main",
],
);
assert.strictEqual(requests[1]?.headers.accept, "application/vnd.github.raw+json");
const restarted = yield* UsageService.make.pipe(Effect.provide(serviceLayer));
const cached = yield* restarted.readSummary(WINDOW);
assert.strictEqual(cached.pricing.status, "cached");
assert.deepStrictEqual(cached.buckets, summary.buckets);
assert.strictEqual(requests.length, 2);
}).pipe(Effect.scoped),
);
it.live("does not orphan an in-flight scan when its first caller is interrupted", () =>
Effect.gen(function* () {
const { settings, home } = yield* setup;
const service = yield* UsageService.make.pipe(
Effect.provide(layerService({ prefix: "usage-service-interruption-test", home, settings })),
);
let orphanedAt: number | undefined;
// oxlint-disable-next-line t3code/no-polling-loop-in-tests -- Fixed-count scheduler interruption matrix; each iteration exercises a different interruption point.
for (let interruptAt = 1; interruptAt <= 31; interruptAt += 1) {
const tasks: Array<() => void> = [];
const dispatcher: Scheduler.SchedulerDispatcher = {
scheduleTask: (task) => tasks.push(task),
flush: () => {
let task: (() => void) | undefined;
while ((task = tasks.shift()) !== undefined) task();
},
};
let requestFiber: Fiber.Fiber<unknown, unknown> | undefined;
let requestChecks = 0;
const scheduler: Scheduler.Scheduler = {
executionMode: "async",
makeDispatcher: () => dispatcher,
shouldYield: (fiber) => {
if (fiber !== requestFiber) return false;
requestChecks += 1;
if (requestChecks !== interruptAt) return false;
fiber.interruptUnsafe();
return true;
},
};
const input: UsageSummaryInput = {
...WINDOW,
sinceDay: UsageDay.make("2026-09-01"),
untilDay: UsageDay.make(`2026-08-${String(interruptAt).padStart(2, "0")}`),
};
const first = yield* service
.readSummary(input)
.pipe(
Effect.exit,
Effect.provideService(Scheduler.Scheduler, scheduler),
Effect.forkChild,
);
requestFiber = first;
yield* Effect.yieldNow;
dispatcher.flush();
const second = yield* service.readSummary(input).pipe(
Effect.match({
onFailure: (error) => error.reason,
onSuccess: () => "success" as const,
}),
Effect.provideService(Scheduler.Scheduler, scheduler),
Effect.forkChild,
);
yield* Effect.yieldNow;
dispatcher.flush();
const secondExit = second.pollUnsafe();
if (secondExit === undefined) {
second.interruptUnsafe();
orphanedAt = interruptAt;
break;
}
if (Exit.isFailure(secondExit)) {
assert.fail("the matching request fiber was interrupted");
}
assert.strictEqual(secondExit.value, "invalidWindow");
}
assert.isUndefined(
orphanedAt,
`interruption left the next matching request pending at scheduler check ${orphanedAt}`,
);
}).pipe(Effect.scoped),
);
});