The best way to control Claude Code, Codex and more from any computer or phone

main
ts 4,259 lines 171 KB
Raw
1 // @effect-diagnostics nodeBuiltinImport:off - the suite seeds and grows real
2 // transcript trees on disk, outside the service's Effect FileSystem.
3 import * as NodeChildProcess from "node:child_process";
4 import * as NodeFSP from "node:fs/promises";
5 import * as NodeOS from "node:os";
6 import * as NodePath from "node:path";
7 import * as NodeSqlite from "node:sqlite";
8 import * as NodeZlib from "node:zlib";
9
10 import { assert, describe, it } from "@effect/vitest";
11 import { vi } from "vite-plus/test";
12 import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
13 import * as NodeServices from "@effect/platform-node/NodeServices";
14 import * as HostProcess from "@t3tools/shared/HostProcess";
15 import { SpawnExecutableResolution } from "@t3tools/shared/shell";
16 import { mergeUsage } from "@t3tools/shared/usageMerge";
17 import {
18 EnvironmentId,
19 ProviderDriverKind,
20 ProviderInstanceId,
21 UsageDay,
22 type UsageSource,
23 type UsageSummary,
24 type UsageSummaryInput,
25 } from "@t3tools/contracts";
26 import * as Duration from "effect/Duration";
27 import * as Clock from "effect/Clock";
28 import * as DateTime from "effect/DateTime";
29 import * as Deferred from "effect/Deferred";
30 import * as Effect from "effect/Effect";
31 import * as Exit from "effect/Exit";
32 import * as Fiber from "effect/Fiber";
33 import * as FileSystem from "effect/FileSystem";
34 import * as Context from "effect/Context";
35 import * as Layer from "effect/Layer";
36 import * as Option from "effect/Option";
37 import * as Scheduler from "effect/Scheduler";
38 import * as Schema from "effect/Schema";
39 import * as TestClock from "effect/testing/TestClock";
40 import * as SqlClient from "effect/sql/SqlClient";
41 import { HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse } from "effect/http";
42
43 import * as ServerConfig from "../config.ts";
44 import * as ServerSettings from "../serverSettings.ts";
45 import * as Sqlite from "../persistence/Sqlite.ts";
46 import * as CodexUsageHistory from "./CodexUsageHistory.ts";
47 import * as CursorAccountReader from "@t3tools/provider-cursor/server/CursorAccountReader";
48 import * as CursorUsageAccounts from "@t3tools/provider-cursor/server/CursorUsageAccounts";
49 import * as ServerSecretStore from "../auth/ServerSecretStore.ts";
50 import * as BackgroundPolicy from "../background/BackgroundPolicy.ts";
51 import * as AntigravityUsage from "../provider/Drivers/AntigravityUsage.ts";
52 import * as ProviderHostLive from "../provider/ProviderHostLive.ts";
53 import { totalTokens, type UsageRecord } from "@t3tools/provider-core/server/usage";
54 import * as UsageService from "./UsageService.ts";
55 import { DESKTOP_HOST_SCOPE_ENV, physicalSourceIdOf } from "./usageTranscriptReader.ts";
56 import * as MuseSdk from "../../../../packages/provider-muse/src/server/sdk.ts";
57 import { MuseUsageHome } from "@t3tools/provider-muse/server";
58 import { makeScanCacheWriter, SCAN_CACHE_FILE_NAME } from "./usageScanCache.ts";
59
60 vi.mock("node:fs/promises", { spy: true });
61 vi.mock("../../../../packages/provider-muse/src/server/sdk.ts", async (importOriginal) => {
62 const original = await importOriginal<typeof MuseSdk>();
63 return {
64 ...original,
65 createMuseSdkHostEffect: vi.fn(() =>
66 Effect.fail(
67 new original.MuseSdkError({
68 operation: "start",
69 cause: new Error("Muse is not installed in this test"),
70 }),
71 ),
72 ),
73 };
74 });
75
76 const encodeUnknownJson = Schema.encodeEffect(Schema.fromJsonString(Schema.Unknown));
77 const encodeUnknownJsonString = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown));
78 const decodeUnknownJsonString = Schema.decodeSync(Schema.fromJsonString(Schema.Unknown));
79
80 function claudeLine(
81 id: number,
82 outputTokens: number,
83 model = "claude-fable-5",
84 sessionId = "session-1",
85 ): string {
86 return `${JSON.stringify({
87 type: "assistant",
88 timestamp: "2026-08-01T10:00:00Z",
89 requestId: `req_${id}`,
90 sessionId,
91 message: {
92 id: `msg_${id}`,
93 model,
94 usage: { input_tokens: 10, output_tokens: outputTokens },
95 },
96 })}\n`;
97 }
98
99 /** One content-block line of message `msg_1`; Claude Code writes several per message. */
100 function claudeCopy(usage: Readonly<Record<string, number>>): string {
101 return `${JSON.stringify({
102 type: "assistant",
103 timestamp: "2026-08-01T10:00:00Z",
104 requestId: "req_1",
105 sessionId: "session-1",
106 message: { id: "msg_1", model: "claude-fable-5", usage },
107 })}\n`;
108 }
109
110 // A subagent message: its stream-start copy, then its final copy.
111 const PARTIAL_USAGE = {
112 input_tokens: 2,
113 cache_creation_input_tokens: 1097,
114 cache_read_input_tokens: 67934,
115 output_tokens: 3,
116 };
117 const COMPLETE_USAGE = { ...PARTIAL_USAGE, output_tokens: 264 };
118 const COPY_RATES = {
119 "claude-fable-5": {
120 input_cost_per_token: 1e-5,
121 output_cost_per_token: 5e-5,
122 cache_read_input_token_cost: 1e-6,
123 cache_creation_input_token_cost: 1.25e-5,
124 },
125 };
126 const COMPLETE_COST_USD = 2 * 1e-5 + 67934 * 1e-6 + 1097 * 1.25e-5 + 264 * 5e-5;
127 const COMPLETE_TOTALS = {
128 uncachedInputTokens: 2,
129 cachedInputTokens: 67934,
130 cacheCreationTokens: 1097,
131 outputTokens: 264,
132 reasoningTokens: 0,
133 };
134
135 const WINDOW: UsageSummaryInput = {
136 timeZone: "UTC",
137 sinceDay: UsageDay.make("2026-07-31"),
138 untilDay: UsageDay.make("2026-08-02"),
139 };
140
141 const setup = Effect.gen(function* () {
142 const home = yield* Effect.promise(() =>
143 NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "usage-service-test-")),
144 );
145 yield* Effect.addFinalizer(() =>
146 Effect.promise(() => NodeFSP.rm(home, { recursive: true, force: true })),
147 );
148 const transcriptDir = NodePath.join(home, "claude", "projects", "proj");
149 yield* Effect.promise(() => NodeFSP.mkdir(transcriptDir, { recursive: true }));
150 return {
151 home,
152 transcript: NodePath.join(transcriptDir, "session.jsonl"),
153 settings: {
154 providerInstances: {
155 [ProviderInstanceId.make("claudeAgent")]: {
156 driver: ProviderDriverKind.make("claudeAgent"),
157 config: { homePath: NodePath.join(home, "claude") },
158 },
159 [ProviderInstanceId.make("codex")]: {
160 driver: ProviderDriverKind.make("codex"),
161 config: { homePath: NodePath.join(home, "codex") },
162 },
163 },
164 },
165 };
166 });
167
168 const layerCursorUsageAccounts = <E, R>(
169 reader: Layer.Layer<CursorAccountReader.CursorAccountReader, E, R>,
170 ) => Layer.fresh(CursorUsageAccounts.layer).pipe(Layer.provide(reader));
171
172 const makeWithCursor = (read: CursorAccountReader.CursorAccountReader["Service"]["read"]) =>
173 Effect.gen(function* () {
174 const context = yield* Layer.build(
175 layerCursorUsageAccounts(Layer.succeed(CursorAccountReader.CursorAccountReader, { read })),
176 );
177 const accounts = Context.get(context, CursorUsageAccounts.CursorUsageAccounts);
178 const service = yield* UsageService.make.pipe(Effect.provideContext(context));
179 return {
180 ...service,
181 awaitPersisted: Effect.andThen(service.awaitPersisted, accounts.awaitPersisted),
182 };
183 });
184
185 const layerService = (input: {
186 readonly prefix: string;
187 readonly home: string;
188 readonly settings: Parameters<typeof ServerSettings.layerTest>[0];
189 readonly onRatesFetch?: (request: HttpClientRequest.HttpClientRequest) => void;
190 readonly ratesDocument?: unknown;
191 readonly ratesStatus?: () => number;
192 readonly ratesResponse?: (
193 request: HttpClientRequest.HttpClientRequest,
194 ) => Effect.Effect<Response, HttpClientError.HttpClientError>;
195 readonly environment?: NodeJS.ProcessEnv;
196 readonly platform?: NodeJS.Platform;
197 readonly hostname?: string;
198 readonly secretStore?: Partial<ServerSecretStore.ServerSecretStore["Service"]>;
199 }) =>
200 layerCursorUsageAccounts(CursorAccountReader.layer).pipe(
201 Layer.provideMerge(AntigravityUsage.layer),
202 Layer.provideMerge(MuseUsageHome.layer),
203 Layer.provideMerge(ProviderHostLive.layer),
204 Layer.provideMerge(CodexUsageHistory.layer.pipe(Layer.provideMerge(Sqlite.layerMemory))),
205 Layer.provideMerge(Layer.mock(BackgroundPolicy.BackgroundPolicy)({})),
206 Layer.provideMerge(
207 Layer.mock(ServerSecretStore.ServerSecretStore)({
208 get: () => Effect.succeedNone,
209 ...input.secretStore,
210 }),
211 ),
212 Layer.provideMerge(
213 ServerConfig.layerTest(process.cwd(), NodePath.join(input.home, input.prefix)),
214 ),
215 Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
216 Layer.provideMerge(Layer.succeed(HostProcess.Platform, input.platform ?? "linux")),
217 Layer.provideMerge(Layer.succeed(HostProcess.Hostname, input.hostname ?? "usage-test-host")),
218 Layer.provideMerge(Layer.succeed(HostProcess.HomeDirectory, input.home)),
219 Layer.provideMerge(ServerSettings.layerTest(input.settings)),
220 Layer.provideMerge(
221 Layer.succeed(
222 HttpClient.HttpClient,
223 HttpClient.make((request) =>
224 Effect.suspend(() => {
225 input.onRatesFetch?.(request);
226 const response = input.ratesResponse
227 ? input.ratesResponse(request)
228 : Effect.succeed(
229 Response.json(input.ratesDocument ?? {}, {
230 status: input.ratesStatus?.() ?? 200,
231 }),
232 );
233 return response.pipe(
234 Effect.map((response) => HttpClientResponse.fromWeb(request, response)),
235 );
236 }),
237 ),
238 ),
239 ),
240 Layer.provideMerge(
241 Layer.succeed(HostProcess.Environment, {
242 HOME: input.home,
243 GROK_HOME: NodePath.join(input.home, "grok"),
244 PI_CODING_AGENT_DIR: NodePath.join(input.home, "pi"),
245 OPENCODE_DATA_DIR: NodePath.join(input.home, "opencode"),
246 ANTIGRAVITY_DATA_DIR: NodePath.join(input.home, "antigravity"),
247 XDG_CONFIG_HOME: NodePath.join(input.home, "config"),
248 APPDATA: NodePath.join(input.home, "config"),
249 ...input.environment,
250 }),
251 ),
252 );
253
254 const BEFORE_NARROW_WINDOW = Date.parse("2026-08-01T10:00:00Z") / 1000;
255 const NARROW_WINDOW_MTIME = Date.parse("2026-09-01T10:00:00Z") / 1000;
256 const NARROW_WINDOW: UsageSummaryInput = {
257 timeZone: "UTC",
258 sinceDay: UsageDay.make("2026-09-01"),
259 untilDay: UsageDay.make("2026-09-02"),
260 };
261
262 // Each waiting gate holds a libuv thread; allow at most three.
263 const makeGate = (path: string, lastWriteSeconds?: number) =>
264 Effect.promise(async () => {
265 NodeChildProcess.execFileSync("mkfifo", [path]);
266 if (lastWriteSeconds !== undefined) {
267 await NodeFSP.utimes(path, lastWriteSeconds, lastWriteSeconds);
268 }
269 });
270
271 const openGate = (path: string) =>
272 Effect.promise(async () => (await NodeFSP.open(path, "w")).close());
273
274 const replaceFile = (path: string, content: string) =>
275 Effect.promise(async () => {
276 await NodeFSP.writeFile(path + ".next", content);
277 await NodeFSP.rename(path + ".next", path);
278 });
279
280 function totalOutputTokens(summary: { buckets: readonly { totals: { outputTokens: number } }[] }) {
281 return summary.buckets.reduce((sum, bucket) => sum + bucket.totals.outputTokens, 0);
282 }
283
284 const CURSOR_NOW = Date.parse("2026-08-02T12:00:00Z");
285 const HOUR_MS = 60 * 60 * 1000;
286
287 function makeFakeCursor() {
288 const state = {
289 accountKey: "account-a",
290 events: [] as { readonly timestampMs: number; readonly outputTokens: number }[],
291 error: null as string | null,
292 gate: undefined as Deferred.Deferred<void> | undefined,
293 started: undefined as Deferred.Deferred<void> | undefined,
294 calls: [] as { readonly sinceMs: number; readonly untilMs: number }[],
295 credentials: [] as unknown[],
296 };
297 const read = (credential: unknown, sinceMs: number, untilMs: number) =>
298 Effect.gen(function* () {
299 state.calls.push({ sinceMs, untilMs });
300 if (state.started !== undefined) yield* Deferred.succeed(state.started, undefined);
301 state.credentials.push(credential);
302 if (state.gate !== undefined) yield* Deferred.await(state.gate);
303 const { accountKey, error } = state;
304 if (error !== null) return { accountKey, records: [], missing: false, error };
305 const occurrences = new Map<string, number>();
306 const records = state.events
307 .filter(({ timestampMs }) => timestampMs >= sinceMs && timestampMs <= untilMs)
308 .map(({ timestampMs, outputTokens }): UsageRecord => {
309 const key = `${timestampMs}:${outputTokens}`;
310 const occurrence = occurrences.get(key) ?? 0;
311 occurrences.set(key, occurrence + 1);
312 return {
313 provider: "cursor",
314 timestampMs,
315 model: "claude-fable-5",
316 sessionId: "conversation-1",
317 totals: {
318 uncachedInputTokens: 0,
319 cachedInputTokens: 0,
320 cacheCreationTokens: 0,
321 outputTokens,
322 reasoningTokens: 0,
323 },
324 reportedCostUsd: null,
325 speed: "standard",
326 dedupeKey: `cursor-account:${accountKey}:${key}:${occurrence}`,
327 };
328 });
329 return { accountKey, records, missing: false, error: null };
330 });
331 return { state, read };
332 }
333
334 function cursorSource(summary: { readonly sources: readonly UsageSource[] }) {
335 return summary.sources.find((source) => source.fingerprint.provider === "cursor");
336 }
337
338 function cursorSources(summary: { readonly sources: readonly UsageSource[] }) {
339 return summary.sources.filter((source) => source.fingerprint.provider === "cursor");
340 }
341
342 const seedCodexHistory = (input: {
343 id: string;
344 nativeTurnId?: string;
345 sessionId?: string;
346 model?: string;
347 options?: readonly { id: string; value: string | boolean }[];
348 }) =>
349 Effect.gen(function* () {
350 const sql = yield* SqlClient.SqlClient;
351 const { id } = input;
352 const selection = {
353 instanceId: "codex",
354 model: input.model ?? "gpt-6-astra",
355 options: input.options ?? [{ id: "serviceTier", value: "priority" }],
356 };
357 const run = {
358 id: `run-${id}`,
359 activeAttemptId: `attempt-${id}`,
360 status: "running",
361 modelSelection: selection,
362 };
363 yield* sql`INSERT INTO orchestration_v2_projection_run_attempts ${sql.insert({
364 attempt_id: run.activeAttemptId,
365 thread_id: `thread-${id}`,
366 run_id: run.id,
367 attempt_ordinal: 1,
368 root_node_id: `node-${id}`,
369 provider: "codex",
370 provider_thread_id: `provider-thread-${id}`,
371 provider_turn_id: `turn-${id}`,
372 status: "completed",
373 payload_json: encodeUnknownJsonString({ nativeThreadId: input.sessionId ?? "session" }),
374 })}`;
375 yield* sql`INSERT INTO orchestration_v2_projection_provider_turns ${sql.insert({
376 provider_turn_id: `turn-${id}`,
377 thread_id: `thread-${id}`,
378 provider_thread_id: `provider-thread-${id}`,
379 node_id: `node-${id}`,
380 run_attempt_id: run.activeAttemptId,
381 ordinal: 1,
382 status: "completed",
383 payload_json: encodeUnknownJsonString({
384 nativeTurnRef: { driver: "codex", nativeId: input.nativeTurnId ?? id, strength: "strong" },
385 }),
386 })}`;
387 const changedSelection = {
388 ...selection,
389 options: [{ id: "serviceTier", value: "ultrafast" }],
390 };
391 // These selections disagree so reading the current projection or the wrong event is visible.
392 yield* sql`INSERT INTO orchestration_v2_projection_runs ${sql.insert({
393 run_id: run.id,
394 thread_id: `thread-${id}`,
395 ordinal: 1,
396 provider: "codex",
397 provider_thread_id: `provider-thread-${id}`,
398 status: "completed",
399 requested_at: "2026-08-01T10:00:00Z",
400 payload_json: encodeUnknownJsonString({
401 ...run,
402 status: "completed",
403 modelSelection: { ...selection, options: [] },
404 }),
405 })}`;
406 for (const [index, payload] of [
407 { ...run, activeAttemptId: "earlier-attempt", modelSelection: changedSelection },
408 { ...run, status: "queued", modelSelection: changedSelection },
409 run,
410 { ...run, modelSelection: changedSelection },
411 ].entries()) {
412 yield* sql`INSERT INTO orchestration_events ${sql.insert({
413 event_id: `event-${id}-${index}`,
414 aggregate_kind: "thread",
415 stream_id: `thread-${id}`,
416 stream_version: index + 1,
417 event_type: "run.updated",
418 occurred_at: "2026-08-01T10:00:00Z",
419 actor_kind: "system",
420 metadata_json: "{}",
421 application_event_version: 2,
422 payload_json: encodeUnknownJsonString(payload),
423 })}`;
424 }
425 });
426
427 describe("Codex usage history", () => {
428 const historyLayer = CodexUsageHistory.layer.pipe(Layer.provideMerge(Sqlite.layerMemory));
429 const request = (nativeTurnId: string) => ({
430 sessionId: "session",
431 nativeTurnId,
432 model: "gpt-6-astra",
433 });
434
435 it.effect("resolves a batch from each attempt's first running selection", () =>
436 Effect.gen(function* () {
437 yield* seedCodexHistory({ id: "fast" });
438 yield* seedCodexHistory({
439 id: "ultrafast",
440 options: [{ id: "serviceTier", value: "ultrafast" }],
441 });
442 yield* seedCodexHistory({ id: "legacy-option", options: [{ id: "fastMode", value: true }] });
443 yield* seedCodexHistory({ id: "standard", options: [] });
444 const requests = ["fast", "ultrafast", "legacy-option", "standard", "fast"].map(request);
445 const history = yield* CodexUsageHistory.CodexUsageHistory;
446 const resolved = yield* history.resolve(requests);
447 assert.strictEqual(resolved.size, requests.length);
448 assert.deepStrictEqual(
449 requests.map((item) => resolved.get(item)),
450 ["fast", "ultrafast", "fast", "standard", "fast"],
451 );
452 }).pipe(Effect.provide(historyLayer)),
453 );
454
455 it.effect("leaves ambiguous, mismatched, and missing V2 evidence unresolved", () =>
456 Effect.gen(function* () {
457 for (const id of [
458 "valid",
459 "duplicate-model",
460 "duplicate-session",
461 "imported",
462 "v1-event",
463 "queued",
464 "missing-selection",
465 ]) {
466 yield* seedCodexHistory({ id });
467 }
468 yield* seedCodexHistory({
469 id: "second-model",
470 nativeTurnId: "duplicate-model",
471 model: "other-model",
472 });
473 yield* seedCodexHistory({
474 id: "second-session",
475 nativeTurnId: "duplicate-session",
476 sessionId: "other-session",
477 });
478 yield* seedCodexHistory({ id: "wrong-model", model: "other-model" });
479 yield* seedCodexHistory({ id: "wrong-session", sessionId: "other-session" });
480 const sql = yield* SqlClient.SqlClient;
481 yield* sql`UPDATE orchestration_v2_projection_provider_turns
482 SET run_attempt_id = NULL WHERE provider_turn_id = 'turn-imported'`;
483 yield* sql`DELETE FROM orchestration_v2_projection_run_attempts WHERE attempt_id = 'attempt-imported'`;
484 yield* sql`UPDATE orchestration_events SET application_event_version = 1
485 WHERE stream_id = 'thread-v1-event'`;
486 yield* sql`UPDATE orchestration_events
487 SET payload_json = json_set(payload_json, '$.status', 'queued')
488 WHERE stream_id = 'thread-queued'`;
489 yield* sql`UPDATE orchestration_events
490 SET payload_json = json_remove(payload_json, '$.modelSelection')
491 WHERE event_id = 'event-missing-selection-2'`;
492 const requests = [
493 "valid",
494 "duplicate-model",
495 "duplicate-session",
496 "wrong-model",
497 "wrong-session",
498 "missing-turn",
499 "imported",
500 "v1-event",
501 "queued",
502 "missing-selection",
503 ].map(request);
504 const history = yield* CodexUsageHistory.CodexUsageHistory;
505 const resolved = yield* history.resolve(requests);
506 assert.deepStrictEqual([...resolved], [[requests[0], "fast"]]);
507 }).pipe(Effect.provide(historyLayer)),
508 );
509
510 it.effect(
511 "reports SQL failures through the typed channel and can resolve again after repair",
512 () =>
513 Effect.gen(function* () {
514 yield* seedCodexHistory({ id: "retry" });
515 const history = yield* CodexUsageHistory.CodexUsageHistory;
516 const sql = yield* SqlClient.SqlClient;
517 const input = request("retry");
518 yield* sql`ALTER TABLE orchestration_events RENAME TO unavailable_events`;
519 const error = yield* Effect.flip(history.resolve([input]));
520 assert.instanceOf(error, CodexUsageHistory.CodexUsageHistoryReadError);
521 assert.strictEqual(error.requestedTurnCount, 1);
522 yield* sql`ALTER TABLE unavailable_events RENAME TO orchestration_events`;
523 assert.strictEqual((yield* history.resolve([input])).get(input), "fast");
524 }).pipe(Effect.provide(historyLayer)),
525 );
526 });
527
528 describe("UsageService", () => {
529 it.effect("keeps pricing metadata paired with the rates used during a concurrent refresh", () =>
530 Effect.gen(function* () {
531 const { home, settings } = yield* setup;
532 const sessions = NodePath.join(home, "codex", "sessions");
533 yield* Effect.promise(async () => {
534 await NodeFSP.mkdir(sessions, { recursive: true });
535 await NodeFSP.writeFile(
536 NodePath.join(sessions, "session.jsonl"),
537 [
538 { type: "session_meta", payload: { id: "session", model_provider: "openai" } },
539 { type: "turn_context", payload: { model: "gpt-6-astra", turn_id: "turn" } },
540 {
541 type: "event_msg",
542 timestamp: "2026-08-01T10:00:00Z",
543 payload: {
544 type: "token_count",
545 info: { last_token_usage: { input_tokens: 0, output_tokens: 1 } },
546 },
547 },
548 ]
549 .map((record) => encodeUnknownJsonString(record))
550 .join("\n") + "\n",
551 );
552 });
553 let rate = 0;
554 yield* Effect.gen(function* () {
555 const resolving = yield* Deferred.make<void>();
556 const release = yield* Deferred.make<void>();
557 const service = yield* UsageService.make.pipe(
558 Effect.provideService(CodexUsageHistory.CodexUsageHistory, {
559 resolve: () =>
560 Deferred.succeed(resolving, undefined).pipe(
561 Effect.andThen(Deferred.await(release)),
562 Effect.as(new Map()),
563 ),
564 }),
565 );
566 const initialPricing = yield* service.refreshRates;
567 yield* TestClock.adjust(61_000);
568 const pending = yield* service.readSummary(WINDOW).pipe(Effect.forkChild);
569 yield* Deferred.await(resolving);
570 yield* service.refreshRates;
571 yield* Deferred.succeed(release, undefined);
572 const original = yield* Fiber.join(pending);
573 assert.strictEqual(original.buckets[0]?.costUsd, 1);
574 assert.strictEqual(original.pricing.fetchedAt, initialPricing.fetchedAt);
575 const updated = yield* service.readSummary(WINDOW);
576 assert.strictEqual(updated.buckets[0]?.costUsd, 2);
577 assert.notStrictEqual(updated.pricing.fetchedAt, initialPricing.fetchedAt);
578 }).pipe(
579 Effect.provide(
580 layerService({
581 prefix: "concurrent-rates",
582 home,
583 settings,
584 ratesResponse: () =>
585 Effect.succeed(
586 Response.json({
587 "gpt-6-astra": { input_cost_per_token: 0, output_cost_per_token: ++rate },
588 }),
589 ),
590 }),
591 ),
592 );
593 }).pipe(Effect.scoped),
594 );
595
596 it.effect("counts compressed Codex rollouts across refresh, rewrites, and cache restarts", () =>
597 Effect.gen(function* () {
598 const { home, settings } = yield* setup;
599 const sessions = NodePath.join(home, "codex", "sessions");
600 const compressedPath = NodePath.join(sessions, "compressed.jsonl.zst");
601 const usage = (output_tokens: number, timestamp = "2026-08-01T10:00:00Z") =>
602 encodeUnknownJsonString({
603 type: "event_msg",
604 timestamp,
605 payload: {
606 type: "token_count",
607 info: { last_token_usage: { input_tokens: 10, output_tokens } },
608 },
609 }) + "\n";
610 const rollout = (id: string, output: number) =>
611 [
612 { type: "session_meta", payload: { id } },
613 { type: "turn_context", payload: { model: "gpt-6-astra" } },
614 ]
615 .map((line) => encodeUnknownJsonString(line))
616 .join("\n") +
617 "\n" +
618 usage(output);
619 const compressed = rollout("compressed-session", 23);
620 yield* Effect.promise(async () => {
621 await NodeFSP.mkdir(sessions, { recursive: true });
622 await NodeFSP.writeFile(
623 NodePath.join(sessions, "plain.jsonl"),
624 rollout("plain-session", 17),
625 );
626 await NodeFSP.writeFile(compressedPath, NodeZlib.zstdCompressSync(compressed));
627 });
628 yield* Effect.gen(function* () {
629 const service = yield* UsageService.make;
630 const first = yield* service.readSummary(WINDOW);
631 assert.strictEqual(totalOutputTokens(first), 40);
632 assert.strictEqual(
633 first.sources.find((source) => source.fingerprint.provider === "codex")?.distinctSessions,
634 2,
635 );
636 assert.deepStrictEqual((yield* service.readSummary(WINDOW)).buckets, first.buckets);
637 yield* service.awaitPersisted;
638 // The same rollout may remain in a plain file while compression finishes.
639 yield* Effect.promise(() =>
640 NodeFSP.writeFile(NodePath.join(sessions, "copy.jsonl"), compressed),
641 );
642 assert.strictEqual(totalOutputTokens(yield* service.readSummary(WINDOW)), 40);
643 yield* Effect.promise(() =>
644 NodeFSP.writeFile(
645 compressedPath,
646 NodeZlib.zstdCompressSync(compressed + usage(31, "2026-08-01T10:00:05Z")),
647 ),
648 );
649 const rewritten = yield* service.readSummary(WINDOW);
650 assert.strictEqual(totalOutputTokens(rewritten), 71);
651 assert.deepStrictEqual((yield* service.readSummary(WINDOW)).buckets, rewritten.buckets);
652 yield* service.awaitPersisted;
653 const { stateDir } = yield* ServerConfig.ServerConfig;
654 const cachePath = NodePath.join(stateDir, SCAN_CACHE_FILE_NAME);
655 const originalPath = (yield* Effect.promise(() => NodeFSP.realpath(compressedPath))).slice(
656 0,
657 -4,
658 );
659 yield* Effect.promise(async () => {
660 const document = decodeUnknownJsonString(await NodeFSP.readFile(cachePath, "utf8")) as {
661 files: Record<
662 string,
663 { cs: Record<string, unknown>; r: unknown[]; t: unknown[]; mr: number }
664 >;
665 };
666 const archived = document.files[await NodeFSP.realpath(compressedPath)];
667 assert.ok(archived);
668 document.files[originalPath] = {
669 ...archived,
670 r: [],
671 t: [],
672 mr: 1,
673 cs: { ...archived.cs, malformedRecords: 1 },
674 };
675 await NodeFSP.writeFile(cachePath, encodeUnknownJsonString(document));
676 });
677 const restarted = yield* UsageService.make;
678 const restored = yield* restarted.readSummary(WINDOW);
679 assert.deepStrictEqual(restored.buckets, rewritten.buckets);
680 assert.strictEqual(
681 restored.sources.find((source) => source.fingerprint.provider === "codex")
682 ?.malformedRecords,
683 0,
684 );
685 yield* restarted.awaitPersisted;
686 yield* Effect.promise(async () => {
687 const document = decodeUnknownJsonString(await NodeFSP.readFile(cachePath, "utf8")) as {
688 files: Record<string, unknown>;
689 };
690 assert.strictEqual(document.files[originalPath], undefined);
691 await NodeFSP.rm(compressedPath);
692 });
693 const removed = yield* UsageService.make;
694 const retained = yield* removed.readSummary(WINDOW);
695 assert.deepStrictEqual(retained.buckets, rewritten.buckets);
696 assert.strictEqual(
697 retained.sources.find((source) => source.fingerprint.provider === "codex")
698 ?.malformedRecords,
699 0,
700 );
701 yield* removed.awaitPersisted;
702 }).pipe(
703 Effect.scoped,
704 Effect.provide(layerService({ prefix: "usage-compressed-codex", home, settings })),
705 );
706 }),
707 );
708
709 it.effect("keeps the first host identity across recreation and explicit override removal", () =>
710 Effect.gen(function* () {
711 const { transcript, settings, home } = yield* setup;
712 yield* Effect.promise(() => NodeFSP.writeFile(transcript, claudeLine(1, 5)));
713 for (const [hostname, override, expected] of [
714 ["container-a", undefined, "container-a"],
715 ["container-b", undefined, "container-a"],
716 ["container-c", "physical-host", "physical-host"],
717 ["container-d", undefined, "container-a"],
718 ] as const) {
719 const summary = yield* Effect.gen(function* () {
720 const service = yield* UsageService.make;
721 return yield* service.readSummary(WINDOW);
722 }).pipe(
723 Effect.scoped,
724 Effect.provide(
725 layerService({
726 prefix: "usage-host-id",
727 home,
728 settings,
729 hostname,
730 environment: override === undefined ? {} : { T3CODE_HOST_ID: override },
731 }),
732 ),
733 );
734 const source = summary.sources.find((source) => source.fingerprint.provider === "claude");
735 assert.strictEqual(source?.fingerprint.hostId, expected);
736 }
737 }),
738 );
739
740 it.effect("concurrent initialization keeps one host identity across service recreation", () =>
741 Effect.gen(function* () {
742 const { transcript, settings, home } = yield* setup;
743 yield* Effect.promise(() => NodeFSP.writeFile(transcript, claudeLine(1, 5)));
744 const prefix = "usage-host-id-race";
745 const hostIdPath = NodePath.join(home, prefix, "usage-host-id");
746 const bothRead = yield* Deferred.make<void>();
747 let reads = 0;
748 const summaries = yield* Effect.forEach(
749 ["container-a", "container-b"],
750 (hostname) =>
751 Effect.gen(function* () {
752 const fileSystem = yield* FileSystem.FileSystem;
753 let firstRead = true;
754 const service = yield* UsageService.make.pipe(
755 Effect.provideService(FileSystem.FileSystem, {
756 ...fileSystem,
757 readFileString: (path, encoding) =>
758 Effect.gen(function* () {
759 if (path !== hostIdPath || !firstRead) {
760 return yield* fileSystem.readFileString(path, encoding);
761 }
762 firstRead = false;
763 // Both instances observe the missing file before either can create it.
764 const result = yield* Effect.exit(fileSystem.readFileString(path, encoding));
765 reads += 1;
766 if (reads === 2) yield* Deferred.succeed(bothRead, undefined);
767 yield* Deferred.await(bothRead);
768 return yield* result;
769 }),
770 }),
771 );
772 return yield* service.readSummary(WINDOW);
773 }).pipe(
774 Effect.scoped,
775 Effect.provide(layerService({ prefix, home, settings, hostname })),
776 ),
777 { concurrency: "unbounded" },
778 );
779 const persisted = yield* Effect.promise(() => NodeFSP.readFile(hostIdPath, "utf8"));
780 const hostId = persisted.trim();
781 assert.include(["container-a", "container-b"], hostId);
782 const restarted = yield* Effect.gen(function* () {
783 const service = yield* UsageService.make;
784 return yield* service.readSummary(WINDOW);
785 }).pipe(
786 Effect.scoped,
787 Effect.provide(layerService({ prefix, home, settings, hostname: "container-c" })),
788 );
789 for (const summary of [...summaries, restarted]) {
790 const source = summary.sources.find((source) => source.fingerprint.provider === "claude");
791 assert.strictEqual(source?.fingerprint.hostId, hostId);
792 }
793 }),
794 );
795
796 it.effect(
797 "repairs initial Codex prices after unchanged-file retries, persists evidence and corrections, and honors later native tiers",
798 () =>
799 Effect.gen(function* () {
800 const { home, settings } = yield* setup;
801 const sessions = NodePath.join(home, "codex", "sessions");
802 const fastPath = NodePath.join(sessions, "fast.jsonl");
803 const ultraPath = NodePath.join(sessions, "ultra.jsonl");
804 const meta = (id: string) => ({
805 type: "session_meta",
806 payload: { id, model_provider: "openai" },
807 });
808 const context = (turn_id?: string) => ({
809 type: "turn_context",
810 payload: { model: "gpt-6-astra", turn_id },
811 });
812 const usage = (output_tokens: number) => ({
813 type: "event_msg",
814 timestamp: "2026-08-01T10:00:00Z",
815 payload: {
816 type: "token_count",
817 info: { last_token_usage: { input_tokens: 0, output_tokens } },
818 },
819 });
820 const tier = (service_tier?: string) => ({
821 type: "event_msg",
822 payload: { type: "thread_settings_applied", thread_settings: { service_tier } },
823 });
824 const lines = (records: readonly unknown[]) =>
825 records.map((record) => encodeUnknownJsonString(record)).join("\n") + "\n";
826 const verify = (summary: UsageSummary, output: number, cost: number) => {
827 assert.strictEqual(totalOutputTokens(summary), output);
828 assert.strictEqual(
829 summary.buckets.reduce((sum, bucket) => sum + bucket.costUsd, 0),
830 cost,
831 );
832 };
833 yield* Effect.promise(async () => {
834 await NodeFSP.mkdir(sessions, { recursive: true });
835 await NodeFSP.writeFile(
836 fastPath,
837 lines([meta("fast-session"), context("fast-turn"), usage(1)]) +
838 encodeUnknownJsonString(usage(2)),
839 );
840 await NodeFSP.writeFile(
841 ultraPath,
842 lines([meta("ultra-session"), context("ultra-turn"), usage(4)]),
843 );
844 });
845 yield* Effect.gen(function* () {
846 const first = yield* UsageService.make;
847 verify(yield* first.readSummary(WINDOW), 7, 7);
848 yield* first.awaitPersisted;
849 const pending = yield* UsageService.make;
850 verify(yield* pending.readSummary(WINDOW), 7, 7);
851 yield* seedCodexHistory({ id: "fast-turn", sessionId: "fast-session" });
852 yield* seedCodexHistory({
853 id: "ultra-turn",
854 sessionId: "ultra-session",
855 options: [{ id: "serviceTier", value: "ultrafast" }],
856 });
857 const sql = yield* SqlClient.SqlClient;
858 yield* sql`ALTER TABLE orchestration_events RENAME TO unavailable_events`;
859 verify(yield* pending.readSummary(WINDOW), 7, 7);
860 yield* pending.awaitPersisted;
861 const retry = yield* UsageService.make;
862 verify(yield* retry.readSummary(WINDOW), 7, 7);
863 yield* sql`ALTER TABLE unavailable_events RENAME TO orchestration_events`;
864 // History repair must touch both the committed record and tentative tail.
865 verify(yield* retry.readSummary(WINDOW), 7, 30);
866 yield* retry.awaitPersisted;
867 yield* sql`ALTER TABLE orchestration_events RENAME TO resolved_events`;
868 verify(yield* retry.readSummary(WINDOW), 7, 30);
869 const resolved = yield* UsageService.make;
870 verify(yield* resolved.readSummary(WINDOW), 7, 30);
871 yield* sql`ALTER TABLE resolved_events RENAME TO orchestration_events`;
872
873 // Completing the tail reparses it; neither an absent turn ID nor a new
874 // turn with no retained attempt may inherit the inferred Fast speed.
875 yield* Effect.promise(() =>
876 NodeFSP.appendFile(
877 fastPath,
878 "\n" + lines([context(), usage(3), context("unretained-turn"), usage(4)]),
879 ),
880 );
881 verify(yield* resolved.readSummary(WINDOW), 14, 37);
882 yield* seedCodexHistory({
883 id: "native-turn",
884 sessionId: "fast-session",
885 options: [{ id: "serviceTier", value: "ultrafast" }],
886 });
887 yield* seedCodexHistory({ id: "later-native-turn", sessionId: "fast-session" });
888 yield* Effect.promise(() =>
889 NodeFSP.appendFile(
890 fastPath,
891 lines([
892 context("native-turn"),
893 tier(),
894 usage(5),
895 context("later-native-turn"),
896 usage(6),
897 tier("priority"),
898 ]) + encodeUnknownJsonString(usage(7)),
899 ),
900 );
901 verify(yield* resolved.readSummary(WINDOW), 32, 62);
902 yield* resolved.awaitPersisted;
903 const native = yield* UsageService.make;
904 verify(yield* native.readSummary(WINDOW), 32, 62);
905 yield* seedCodexHistory({
906 id: "after-restart-native",
907 sessionId: "fast-session",
908 options: [{ id: "serviceTier", value: "ultrafast" }],
909 });
910 yield* Effect.promise(() =>
911 NodeFSP.appendFile(
912 fastPath,
913 "\n" +
914 lines([context("after-restart-native"), usage(8), tier("ultrafast"), usage(9)]),
915 ),
916 );
917 verify(yield* native.readSummary(WINDOW), 49, 132);
918 yield* native.awaitPersisted;
919 yield* Effect.promise(async () => {
920 await NodeFSP.rm(fastPath);
921 await NodeFSP.rm(ultraPath);
922 });
923 yield* sql`DELETE FROM orchestration_events`;
924 const deleted = yield* UsageService.make;
925 verify(yield* deleted.readSummary(WINDOW), 49, 132);
926 }).pipe(
927 Effect.provide(
928 layerService({
929 prefix: "usage-initial-tier",
930 home,
931 settings,
932 ratesDocument: {
933 "gpt-6-astra": {
934 input_cost_per_token: 0,
935 output_cost_per_token: 1,
936 input_cost_per_token_priority: 0,
937 output_cost_per_token_priority: 2,
938 input_cost_per_token_ultrafast: 0,
939 output_cost_per_token_ultrafast: 6,
940 },
941 },
942 }),
943 ),
944 );
945 }),
946 );
947
948 it.effect(
949 "keeps resolved Codex tiers when a grown pre-v15 cache entry re-parses without history",
950 () =>
951 Effect.gen(function* () {
952 const { home, settings } = yield* setup;
953 const sessions = NodePath.join(home, "codex", "sessions");
954 const rolloutPath = NodePath.join(sessions, "tier.jsonl");
955 const context = (turn_id: string) => ({
956 type: "turn_context",
957 payload: { model: "gpt-6-astra", turn_id },
958 });
959 const usage = (output_tokens: number, total_output_tokens: number) => ({
960 type: "event_msg",
961 timestamp: "2026-08-01T10:00:00Z",
962 payload: {
963 type: "token_count",
964 info: {
965 last_token_usage: { input_tokens: 0, output_tokens },
966 total_token_usage: { input_tokens: 0, output_tokens: total_output_tokens },
967 },
968 },
969 });
970 const lines = (records: readonly unknown[]) =>
971 records.map((record) => encodeUnknownJsonString(record)).join("\n") + "\n";
972 const verify = (summary: UsageSummary, output: number, cost: number) => {
973 assert.strictEqual(totalOutputTokens(summary), output);
974 assert.strictEqual(
975 summary.buckets.reduce((sum, bucket) => sum + bucket.costUsd, 0),
976 cost,
977 );
978 };
979 yield* Effect.promise(async () => {
980 await NodeFSP.mkdir(sessions, { recursive: true });
981 await NodeFSP.writeFile(
982 rolloutPath,
983 lines([
984 { type: "session_meta", payload: { id: "tier-session", model_provider: "openai" } },
985 context("ultra-turn"),
986 usage(1, 1),
987 // An equal request at the same time, from a turn priced at the standard tier.
988 context("standard-turn"),
989 usage(1, 2),
990 ]),
991 );
992 });
993 yield* Effect.gen(function* () {
994 const { stateDir } = yield* ServerConfig.ServerConfig;
995 yield* seedCodexHistory({
996 id: "ultra-turn",
997 sessionId: "tier-session",
998 options: [{ id: "serviceTier", value: "ultrafast" }],
999 });
1000 yield* seedCodexHistory({ id: "standard-turn", sessionId: "tier-session", options: [] });
1001 const first = yield* UsageService.make;
1002 verify(yield* first.readSummary(WINDOW), 2, 7);
1003 yield* first.awaitPersisted;
1004
1005 // Downgrade the saved cache to v14, whose clean Codex entries cannot resume.
1006 yield* Effect.promise(async () => {
1007 const cachePath = NodePath.join(stateDir, SCAN_CACHE_FILE_NAME);
1008 const document = JSON.parse(await NodeFSP.readFile(cachePath, "utf8"));
1009 await NodeFSP.rm(cachePath);
1010 await NodeFSP.writeFile(
1011 NodePath.join(stateDir, "usage-scan-cache-v14.json"),
1012 encodeUnknownJsonString({ ...document, version: 14 }),
1013 );
1014 await NodeFSP.appendFile(rolloutPath, lines([context("later-turn"), usage(2, 4)]));
1015 });
1016 const sql = yield* SqlClient.SqlClient;
1017 yield* sql`ALTER TABLE orchestration_events RENAME TO unavailable_events`;
1018 const upgraded = yield* UsageService.make;
1019 verify(yield* upgraded.readSummary(WINDOW), 4, 9);
1020 yield* upgraded.awaitPersisted;
1021 const restarted = yield* UsageService.make;
1022 verify(yield* restarted.readSummary(WINDOW), 4, 9);
1023 yield* sql`ALTER TABLE unavailable_events RENAME TO orchestration_events`;
1024 }).pipe(
1025 Effect.provide(
1026 layerService({
1027 prefix: "usage-reparse-tier",
1028 home,
1029 settings,
1030 ratesDocument: {
1031 "gpt-6-astra": {
1032 input_cost_per_token: 0,
1033 output_cost_per_token: 1,
1034 input_cost_per_token_ultrafast: 0,
1035 output_cost_per_token_ultrafast: 6,
1036 },
1037 },
1038 }),
1039 ),
1040 );
1041 }),
1042 );
1043
1044 it.effect(
1045 "reads Pi per-model usage and auxiliary costs once across forks and repeated entries",
1046 () =>
1047 Effect.gen(function* () {
1048 const { home, settings } = yield* setup;
1049 const dir = NodePath.join(home, "pi", "sessions", "project");
1050 const usage = {
1051 input: 10,
1052 output: 5,
1053 cacheRead: 20,
1054 cacheWrite: 3,
1055 reasoning: 2,
1056 totalTokens: 38,
1057 cost: { input: 0.1, output: 0.2, cacheRead: 0.3, cacheWrite: 0.4, total: 1 },
1058 };
1059 const parent = {
1060 type: "message",
1061 id: "a123abcd",
1062 parentId: null,
1063 timestamp: "2026-08-01T10:00:00Z",
1064 message: {
1065 role: "assistant",
1066 provider: "anthropic",
1067 model: "requested-model",
1068 responseModel: "actual-model",
1069 usage,
1070 },
1071 };
1072 const auxiliary = [
1073 {
1074 type: "message",
1075 id: "tool",
1076 message: { role: "toolResult", toolName: "classify", usage },
1077 },
1078 {
1079 type: "message",
1080 id: "image",
1081 message: {
1082 role: "toolResult",
1083 toolName: "image",
1084 usage: { ...usage, input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
1085 },
1086 },
1087 { type: "compaction", id: "compact", usage },
1088 { type: "branch_summary", id: "summary", usage },
1089 ].map((entry) => ({ ...entry, timestamp: "2026-08-01T11:00:00Z" }));
1090 yield* Effect.promise(async () => {
1091 await NodeFSP.mkdir(dir, { recursive: true });
1092 await NodeFSP.writeFile(
1093 NodePath.join(dir, "parent.jsonl"),
1094 [
1095 { type: "session", id: "parent" },
1096 parent,
1097 ...auxiliary,
1098 {
1099 type: "usage",
1100 id: "warm",
1101 timestamp: "2026-08-01T12:00:00Z",
1102 kind: "cache_warm",
1103 provider: "openai",
1104 model: "actual-model",
1105 usage: { ...usage, cost: { ...usage.cost, total: 0 } },
1106 },
1107 ]
1108 .map((line) => encodeUnknownJsonString(line))
1109 .join("\n") + "\n",
1110 );
1111 await NodeFSP.writeFile(
1112 NodePath.join(dir, "fork.jsonl"),
1113 [
1114 { type: "session", id: "fork", parentSession: NodePath.join(dir, "parent.jsonl") },
1115 { ...parent, parentId: "relinked" },
1116 parent,
1117 ...auxiliary,
1118 {
1119 ...parent,
1120 timestamp: "2026-08-01T13:00:00Z",
1121 message: { ...parent.message, provider: "openai", responseModel: "another-model" },
1122 },
1123 { type: "get_session_stats", usage: { ...usage, cost: { total: 1000 } } },
1124 ]
1125 .map((line) => encodeUnknownJsonString(line))
1126 .join("\n") + "\n",
1127 );
1128 });
1129 yield* Effect.gen(function* () {
1130 const service = yield* UsageService.make;
1131 const first = yield* service.readSummary(WINDOW);
1132 const pi = first.buckets.filter((bucket) => bucket.provider === "pi");
1133 assert.strictEqual(
1134 pi.reduce((total, bucket) => total + bucket.costUsd, 0),
1135 44,
1136 );
1137 assert.strictEqual(
1138 pi.reduce((total, bucket) => total + totalTokens(bucket.totals), 0),
1139 228,
1140 );
1141 assert.deepStrictEqual(pi.map((bucket) => bucket.model).sort(), [
1142 "Tools/summaries",
1143 "anthropic/actual-model",
1144 "openai/actual-model",
1145 "openai/another-model",
1146 ]);
1147 const assistant = pi.find((bucket) => bucket.model === "anthropic/actual-model");
1148 assert.deepStrictEqual(assistant?.totals, {
1149 uncachedInputTokens: 10,
1150 outputTokens: 5,
1151 cachedInputTokens: 20,
1152 cacheCreationTokens: 3,
1153 reasoningTokens: 2,
1154 });
1155 assert.strictEqual(assistant?.costSource, "providerReported");
1156 assert.approximately(assistant?.categoryCostUsd?.input ?? NaN, 10 / 38, 1e-6);
1157 assert.approximately(assistant?.categoryCostUsd?.cacheRead ?? NaN, 2 / 38, 1e-6);
1158 assert.approximately(assistant?.categoryCostUsd?.cacheWrite ?? NaN, 6 / 38, 1e-6);
1159 assert.approximately(assistant?.categoryCostUsd?.output ?? NaN, 20 / 38, 1e-6);
1160 assert.strictEqual(assistant?.cacheSavingsUsd, 18);
1161 const warm = pi.find((bucket) => bucket.model === "openai/actual-model");
1162 assert.strictEqual(warm?.costSource, "modelPriced");
1163 assert.strictEqual(warm?.costUsd, 38);
1164 assert.deepStrictEqual(warm?.categoryCostUsd, {
1165 input: 10,
1166 cacheRead: 2,
1167 cacheWrite: 6,
1168 output: 20,
1169 });
1170 assert.strictEqual(warm?.cacheSavingsUsd, 18);
1171 assert.strictEqual(
1172 first.sources.filter((source) => source.fingerprint.provider === "pi").length,
1173 1,
1174 );
1175 yield* Effect.promise(() =>
1176 NodeFSP.appendFile(
1177 NodePath.join(dir, "fork.jsonl"),
1178 encodeUnknownJsonString({
1179 ...parent,
1180 id: "new",
1181 timestamp: "2026-08-01T14:00:00Z",
1182 message: { ...parent.message, responseModel: "latest-model" },
1183 }) + "\n",
1184 ),
1185 );
1186 const grown = yield* service.readSummary(WINDOW);
1187 assert.strictEqual(
1188 grown.buckets
1189 .filter((bucket) => bucket.provider === "pi")
1190 .reduce((total, bucket) => total + bucket.costUsd, 0),
1191 45,
1192 );
1193 yield* service.awaitPersisted;
1194 const restarted = yield* UsageService.make;
1195 assert.deepStrictEqual((yield* restarted.readSummary(WINDOW)).buckets, grown.buckets);
1196 }).pipe(
1197 Effect.scoped,
1198 Effect.provide(
1199 layerService({
1200 prefix: "usage-pi-fork",
1201 home,
1202 ratesDocument: {
1203 "actual-model": {
1204 input_cost_per_token: 1,
1205 output_cost_per_token: 4,
1206 cache_read_input_token_cost: 0.1,
1207 cache_creation_input_token_cost: 2,
1208 },
1209 },
1210 settings: {
1211 ...settings,
1212 providerInstances: {
1213 ...settings.providerInstances,
1214 [ProviderInstanceId.make("pi-extra")]: {
1215 driver: ProviderDriverKind.make("pi"),
1216 enabled: false,
1217 environment: [
1218 {
1219 name: "PI_CODING_AGENT_DIR",
1220 value: NodePath.join(home, "pi"),
1221 sensitive: false,
1222 },
1223 ],
1224 },
1225 },
1226 },
1227 }),
1228 ),
1229 );
1230 }),
1231 );
1232
1233 it.effect("prices Pi usage mapped onto a Pi model at that model's rate", () =>
1234 Effect.gen(function* () {
1235 const { home, settings } = yield* setup;
1236 const dir = NodePath.join(home, "pi", "sessions", "project");
1237 const message = (id: string, model: string) => ({
1238 type: "message",
1239 id,
1240 timestamp: "2026-08-01T10:00:00Z",
1241 message: {
1242 role: "assistant",
1243 provider: "anthropic",
1244 model,
1245 usage: { input: 10, output: 5 },
1246 },
1247 });
1248 yield* Effect.promise(async () => {
1249 await NodeFSP.mkdir(dir, { recursive: true });
1250 await NodeFSP.writeFile(
1251 NodePath.join(dir, "session.jsonl"),
1252 [
1253 { type: "session", id: "session" },
1254 message("released", "actual-model"),
1255 message("preview", "actual-model-preview"),
1256 ]
1257 .map((line) => encodeUnknownJsonString(line))
1258 .join("\n") + "\n",
1259 );
1260 });
1261 const summary = yield* Effect.gen(function* () {
1262 const service = yield* UsageService.make;
1263 return yield* service.readSummary(WINDOW);
1264 }).pipe(
1265 Effect.scoped,
1266 Effect.provide(
1267 layerService({
1268 prefix: "usage-pi-model-alias",
1269 home,
1270 ratesDocument: {
1271 "actual-model": { input_cost_per_token: 1, output_cost_per_token: 4 },
1272 },
1273 settings: {
1274 ...settings,
1275 usageModelAliases: { "anthropic/actual-model-preview": "anthropic/actual-model" },
1276 },
1277 }),
1278 ),
1279 );
1280 assert.deepStrictEqual(
1281 summary.buckets
1282 .filter((bucket) => bucket.provider === "pi")
1283 .map(({ model, records, unpricedRecords, costUsd, costSource }) => ({
1284 model,
1285 records,
1286 unpricedRecords,
1287 costUsd,
1288 costSource,
1289 })),
1290 [
1291 {
1292 model: "anthropic/actual-model",
1293 records: 2,
1294 unpricedRecords: 0,
1295 costUsd: 60,
1296 costSource: "modelPriced",
1297 },
1298 ],
1299 );
1300 }),
1301 );
1302
1303 it.effect(
1304 "reads Muse inference history once, persists appended usage, and reprices unknown models",
1305 () =>
1306 Effect.gen(function* () {
1307 const { home, settings } = yield* setup;
1308 const museHome = NodePath.join(home, "configured-data", "muse");
1309 const dir = NodePath.join(museHome, "sessions", "2026", "08", "01", "parent");
1310 const child = NodePath.join(dir, "subagent", "child");
1311 const entry = (
1312 id: string,
1313 sessionId = "parent",
1314 timestamp = "2026-08-01T00:00:00Z",
1315 model = "muse-unknown",
1316 ) => ({
1317 schema_version: 1,
1318 record_type: "event",
1319 payload_type: "runtime.session",
1320 payload_schema_version: 1,
1321 id,
1322 recorded_at: Date.parse(timestamp) * 1000 + 999,
1323 stream: { kind: "session", id: sessionId },
1324 payload: {
1325 source_run_record_id: id,
1326 event: {
1327 kind: "model_completed",
1328 model,
1329 usage: {
1330 input_tokens: 100,
1331 cached_tokens: 60,
1332 cache_read_tokens: 60,
1333 cache_write_tokens: 10,
1334 output_tokens: 20,
1335 reasoning_tokens: 8,
1336 },
1337 },
1338 },
1339 });
1340 const parent = entry("inference-1");
1341 const review = {
1342 ...entry("review", "child"),
1343 payload_schema_version: 3,
1344 payload: {
1345 event: {
1346 ...parent.payload.event,
1347 kind: "automated_review_completed",
1348 model: { model_id: "priced-model" },
1349 usage: {
1350 input_tokens: 100,
1351 cached_input_tokens: 60,
1352 output_tokens: 20,
1353 reasoning_tokens: 8,
1354 },
1355 },
1356 },
1357 };
1358 yield* Effect.promise(async () => {
1359 await NodeFSP.mkdir(child, { recursive: true });
1360 await NodeFSP.writeFile(
1361 NodePath.join(dir, "session.jsonl"),
1362 [
1363 parent,
1364 parent,
1365 {
1366 ...parent,
1367 payload: { event: { ...parent.payload.event, kind: "workflow_completed" } },
1368 },
1369 { ...parent, payload_type: "goal_usage_attribution" },
1370 entry("before", "parent", "2026-07-31T23:59:59.999Z"),
1371 entry("after", "parent", "2026-08-02T00:00:00Z"),
1372 ]
1373 .map((line) => encodeUnknownJsonString(line))
1374 .join("\n") + "\n{broken}\n",
1375 );
1376 await NodeFSP.writeFile(
1377 NodePath.join(child, "session.jsonl"),
1378 [
1379 { ...parent, id: "copied-envelope", stream: { kind: "session", id: "child" } },
1380 entry("child-inference", "child"),
1381 review,
1382 ]
1383 .map((line) => encodeUnknownJsonString(line))
1384 .join("\n") + "\n",
1385 );
1386 await NodeFSP.writeFile(
1387 NodePath.join(child, "telemetry.jsonl"),
1388 encodeUnknownJsonString(entry("not-a-session")) + "\n",
1389 );
1390 });
1391 using _create = vi.spyOn(MuseSdk, "createMuseSdkHostEffect").mockImplementation((options) =>
1392 Effect.succeed({
1393 initializeResult: {
1394 grantedCapabilities: [],
1395 museHome: NodePath.join(options.environment?.XDG_DATA_HOME ?? home, "muse"),
1396 },
1397 close: async () => {},
1398 } as unknown as MuseSdk.MuseSdkHost),
1399 );
1400 yield* Effect.gen(function* () {
1401 const service = yield* UsageService.make;
1402 const window = {
1403 timeZone: "UTC",
1404 sinceDay: UsageDay.make("2026-08-01"),
1405 untilDay: UsageDay.make("2026-08-01"),
1406 };
1407 const muse = (summary: UsageSummary) =>
1408 summary.buckets.filter((bucket) => bucket.provider === "muse");
1409 const first = yield* service.readSummary({ ...window, awaitRefresh: true });
1410 const buckets = muse(first);
1411 assert.strictEqual(
1412 buckets.reduce((sum, b) => sum + b.records, 0),
1413 3,
1414 );
1415 assert.strictEqual(
1416 buckets.reduce((sum, b) => sum + totalTokens(b.totals), 0),
1417 360,
1418 );
1419 const unknown = buckets.find((b) => b.model === "muse-unknown");
1420 assert.strictEqual(unknown?.costSource, "unpriced");
1421 assert.strictEqual(unknown?.unpricedRecords, 2);
1422 assert.deepStrictEqual(unknown?.totals, {
1423 uncachedInputTokens: 60,
1424 cachedInputTokens: 120,
1425 cacheCreationTokens: 20,
1426 outputTokens: 40,
1427 reasoningTokens: 16,
1428 });
1429 const priced = buckets.find((b) => b.model === "priced-model");
1430 assert.strictEqual(priced?.costSource, "modelPriced");
1431 assert.closeTo(priced?.costUsd ?? NaN, 0.000172, 1e-12);
1432 assert.closeTo(priced?.cacheSavingsUsd ?? NaN, 0.000108, 1e-12);
1433 const sources = first.sources.filter((source) => source.fingerprint.provider === "muse");
1434 assert.strictEqual(sources.length, 1);
1435 assert.strictEqual(sources[0]?.scannedFiles, 2);
1436 assert.strictEqual(sources[0]?.distinctSessions, 2);
1437 const local = muse(
1438 yield* service.readSummary({ ...window, timeZone: "America/Los_Angeles" }),
1439 );
1440 assert.strictEqual(
1441 local.reduce((sum, b) => sum + b.records, 0),
1442 1,
1443 );
1444 assert.strictEqual(local[0]?.day, "2026-08-01");
1445 const hourly = muse(
1446 yield* service.readSummary({
1447 ...window,
1448 resolution: "hour",
1449 sinceTime: "2026-08-01T00:00:00.000Z",
1450 untilTime: "2026-08-02T00:00:00.000Z",
1451 }),
1452 );
1453 assert.strictEqual(
1454 hourly.reduce((sum, b) => sum + b.records, 0),
1455 3,
1456 );
1457 const appended = encodeUnknownJsonString(entry("appended", "child"));
1458 const file = NodePath.join(child, "session.jsonl");
1459 yield* Effect.promise(() => NodeFSP.appendFile(file, appended.slice(0, -10)));
1460 assert.deepStrictEqual(muse(yield* service.readSummary(window)), buckets);
1461 yield* service.awaitPersisted;
1462 const restarted = yield* UsageService.make;
1463 yield* Effect.promise(() => NodeFSP.appendFile(file, appended.slice(-10) + "\n"));
1464 const grown = muse(yield* restarted.readSummary(window));
1465 assert.strictEqual(
1466 grown.reduce((sum, b) => sum + b.records, 0),
1467 4,
1468 );
1469 assert.strictEqual(
1470 grown.reduce((sum, b) => sum + totalTokens(b.totals), 0),
1471 480,
1472 );
1473 const settingsService = yield* ServerSettings.ServerSettingsService;
1474 yield* settingsService.updateSettings({
1475 usagePriceOverrides: {
1476 "muse-unknown": {
1477 inputCostPerMillionTokens: 2,
1478 outputCostPerMillionTokens: 4,
1479 cacheReadCostPerMillionTokens: 0.2,
1480 cacheWriteCostPerMillionTokens: 1,
1481 },
1482 },
1483 });
1484 const repriced = muse(yield* restarted.readSummary(window)).find(
1485 (b) => b.model === "muse-unknown",
1486 );
1487 assert.strictEqual(repriced?.unpricedRecords, 0);
1488 assert.closeTo(repriced?.costUsd ?? NaN, 0.000486, 1e-12);
1489 }).pipe(
1490 Effect.scoped,
1491 Effect.provideService(SpawnExecutableResolution, (command: string) => command),
1492 Effect.provide(
1493 layerService({
1494 prefix: "usage-muse",
1495 home,
1496 environment: { XDG_DATA_HOME: NodePath.dirname(museHome) },
1497 settings: {
1498 ...settings,
1499 providerInstances: {
1500 ...settings.providerInstances,
1501 [ProviderInstanceId.make("muse")]: {
1502 driver: ProviderDriverKind.make("muse"),
1503 enabled: false,
1504 },
1505 [ProviderInstanceId.make("muse-alias")]: {
1506 driver: ProviderDriverKind.make("muse"),
1507 enabled: false,
1508 },
1509 },
1510 },
1511 ratesDocument: {
1512 "priced-model": {
1513 input_cost_per_token: 0.000002,
1514 output_cost_per_token: 0.000004,
1515 cache_read_input_token_cost: 0.0000002,
1516 cache_creation_input_token_cost: 0.0000002,
1517 },
1518 },
1519 }),
1520 ),
1521 );
1522 }),
1523 );
1524
1525 it.effect("returns other providers' usage while Muse home discovery is still pending", () =>
1526 Effect.gen(function* () {
1527 const { transcript, settings, home } = yield* setup;
1528 yield* Effect.promise(() => NodeFSP.writeFile(transcript, claudeLine(1, 5)));
1529 const museStarted = yield* Deferred.make<void>();
1530 const museReady = yield* Deferred.make<MuseSdk.MuseSdkHost>();
1531 const museHome = NodePath.join(home, "muse");
1532 yield* Effect.promise(() =>
1533 NodeFSP.mkdir(NodePath.join(museHome, "sessions"), { recursive: true }),
1534 );
1535 using _create = vi
1536 .spyOn(MuseSdk, "createMuseSdkHostEffect")
1537 .mockImplementation(() =>
1538 Deferred.succeed(museStarted, undefined).pipe(Effect.andThen(Deferred.await(museReady))),
1539 );
1540 const museSources = (summary: UsageSummary) =>
1541 summary.sources
1542 .filter((source) => source.fingerprint.provider === "muse")
1543 .map((source) => [source.fingerprint.resolvedHomePath, source.status, source.refreshing]);
1544 const [pending, refreshed] = yield* Effect.gen(function* () {
1545 const service = yield* UsageService.make;
1546 const read = yield* Effect.forkChild(service.readSummary(WINDOW));
1547 yield* Deferred.await(museStarted);
1548 const pending = yield* Fiber.join(read);
1549 const refresh = yield* Effect.forkChild(
1550 service.readSummary({ ...WINDOW, awaitRefresh: true }),
1551 );
1552 yield* Deferred.succeed(museReady, {
1553 initializeResult: { grantedCapabilities: [], museHome },
1554 close: async () => {},
1555 } as unknown as MuseSdk.MuseSdkHost);
1556 return [pending, yield* Fiber.join(refresh)] as const;
1557 }).pipe(
1558 Effect.scoped,
1559 Effect.provideService(SpawnExecutableResolution, (command: string) => command),
1560 Effect.provide(
1561 layerService({
1562 prefix: "usage-muse-pending",
1563 home,
1564 settings: {
1565 ...settings,
1566 providerInstances: {
1567 ...settings.providerInstances,
1568 [ProviderInstanceId.make("muse")]: {
1569 driver: ProviderDriverKind.make("muse"),
1570 enabled: false,
1571 },
1572 },
1573 },
1574 }),
1575 ),
1576 );
1577 assert.strictEqual(totalOutputTokens(pending), 5);
1578 assert.deepStrictEqual(museSources(pending), [["muse", "ok", true]]);
1579 assert.deepStrictEqual(museSources(refreshed), [
1580 [NodePath.join(museHome, "sessions"), "ok", undefined],
1581 ]);
1582 }),
1583 );
1584
1585 it.effect("identifies a transcript directory created after the server first read usage", () =>
1586 Effect.gen(function* () {
1587 const { home, settings } = yield* setup;
1588 const scope = "0123456789abcdef0123456789abcdef";
1589 const dir = NodePath.join(home, "pi", "sessions");
1590 yield* Effect.gen(function* () {
1591 const service = yield* UsageService.make;
1592 const piFingerprint = (summary: UsageSummary) =>
1593 summary.sources.find((source) => source.fingerprint.provider === "pi")?.fingerprint;
1594 const missing = piFingerprint(yield* service.readSummary(WINDOW));
1595 assert.strictEqual(missing?.resolvedHomePath, dir);
1596 assert.isUndefined(missing?.physicalSourceId);
1597 yield* Effect.promise(() => NodeFSP.mkdir(dir, { recursive: true }));
1598 assert.strictEqual(
1599 piFingerprint(yield* service.readSummary(WINDOW))?.physicalSourceId,
1600 physicalSourceIdOf(scope, yield* Effect.promise(() => NodeFSP.realpath(dir))),
1601 );
1602 }).pipe(
1603 Effect.scoped,
1604 Effect.provide(
1605 layerService({
1606 prefix: "usage-physical-source-created",
1607 home,
1608 settings,
1609 // The native Windows server reads identity from realpath alone.
1610 platform: "win32",
1611 environment: { [DESKTOP_HOST_SCOPE_ENV]: scope },
1612 }),
1613 ),
1614 );
1615 }),
1616 );
1617
1618 it.effect(
1619 "reports missing Pi history and skips malformed records without losing valid usage",
1620 () =>
1621 Effect.gen(function* () {
1622 const { home, settings } = yield* setup;
1623 yield* Effect.gen(function* () {
1624 const service = yield* UsageService.make;
1625 const missing = yield* service.readSummary(WINDOW);
1626 assert.strictEqual(
1627 missing.sources.find((source) => source.fingerprint.provider === "pi")?.status,
1628 "missing",
1629 );
1630 const dir = NodePath.join(home, "pi", "sessions");
1631 yield* Effect.promise(async () => {
1632 await NodeFSP.mkdir(dir, { recursive: true });
1633 await NodeFSP.writeFile(
1634 NodePath.join(dir, "session.jsonl"),
1635 [
1636 "{broken",
1637 "null",
1638 encodeUnknownJsonString({ type: "session", id: "valid" }),
1639 encodeUnknownJsonString({
1640 type: "message",
1641 id: "bad",
1642 timestamp: "invalid",
1643 message: {
1644 role: "assistant",
1645 provider: "openai",
1646 model: "model",
1647 usage: { input: 100 },
1648 },
1649 }),
1650 encodeUnknownJsonString({
1651 type: "message",
1652 id: "valid",
1653 timestamp: "2026-08-01T10:00:00Z",
1654 message: {
1655 role: "assistant",
1656 provider: "openai",
1657 model: "model",
1658 usage: {
1659 input: -1,
1660 cacheRead: "100",
1661 output: 7,
1662 reasoning: 50,
1663 cost: { total: -1 },
1664 },
1665 },
1666 }),
1667 ].join("\n") + "\n",
1668 );
1669 });
1670 const summary = yield* service.readSummary(WINDOW);
1671 const pi = summary.buckets.filter((bucket) => bucket.provider === "pi");
1672 assert.strictEqual(pi.length, 1);
1673 assert.strictEqual(pi[0] && totalTokens(pi[0].totals), 7);
1674 assert.strictEqual(pi[0]?.totals.reasoningTokens, 7);
1675 assert.strictEqual(pi[0]?.costSource, "unpriced");
1676 }).pipe(
1677 Effect.scoped,
1678 Effect.provide(layerService({ prefix: "usage-pi-malformed", home, settings })),
1679 );
1680 }),
1681 );
1682
1683 it.effect("discovers Pi history in its default home and directory overrides", () =>
1684 Effect.gen(function* () {
1685 const { home, settings } = yield* setup;
1686 for (const [agentDir, sessionDir, relativeDir, launchArgs, instanceHome, platform] of [
1687 [undefined, undefined, ".pi/agent/sessions", undefined],
1688 ["~/custom-pi", undefined, "custom-pi/sessions", undefined],
1689 ["~/ignored-pi", "~/custom-sessions", "custom-sessions", undefined],
1690 ["~/ignored-pi", NodePath.join(home, "absolute-sessions"), "absolute-sessions", undefined],
1691 ["~/ignored-pi", undefined, "launch-sessions", "--session-dir ~/launch-sessions"],
1692 [
1693 "~/ignored-pi",
1694 undefined,
1695 "instance-home /launch-sessions",
1696 "--session-dir ~/launch-sessions",
1697 "instance-home ",
1698 ],
1699 [
1700 "~/ignored-pi",
1701 undefined,
1702 "windows-profile/launch-sessions",
1703 "--session-dir ~/launch-sessions",
1704 "windows-profile",
1705 "win32",
1706 ],
1707 [undefined, undefined, "pi-home/.pi/agent/sessions", undefined, "pi-home"],
1708 ["~/custom-pi", undefined, "pi-agent-home/custom-pi/sessions", undefined, "pi-agent-home"],
1709 [
1710 "~/ignored-pi",
1711 "~/custom-sessions",
1712 "pi-session-home/custom-sessions",
1713 undefined,
1714 "pi-session-home",
1715 ],
1716 ] as const) {
1717 const dir = NodePath.join(home, relativeDir);
1718 yield* Effect.promise(async () => {
1719 await NodeFSP.mkdir(dir, { recursive: true });
1720 await NodeFSP.writeFile(
1721 NodePath.join(dir, "session.jsonl"),
1722 [
1723 { type: "session", id: relativeDir },
1724 {
1725 type: "usage",
1726 id: "warm",
1727 timestamp: "2026-08-01T10:00:00Z",
1728 provider: "openai",
1729 model: "model",
1730 usage: { input: 7 },
1731 },
1732 ]
1733 .map((line) => encodeUnknownJsonString(line))
1734 .join("\n") + "\n",
1735 );
1736 });
1737 yield* Effect.gen(function* () {
1738 const service = yield* UsageService.make;
1739 const summary = yield* service.readSummary(WINDOW);
1740 const pi = summary.buckets.filter((bucket) => bucket.provider === "pi");
1741 assert.strictEqual(pi.length, 1);
1742 assert.strictEqual(pi[0]?.totals.uncachedInputTokens, 7);
1743 assert.strictEqual(
1744 summary.sources.find((source) => source.fingerprint.provider === "pi")?.fingerprint
1745 .resolvedHomePath,
1746 dir,
1747 );
1748 }).pipe(
1749 Effect.scoped,
1750 Effect.provide(
1751 layerService({
1752 prefix: "usage-pi-" + relativeDir.replaceAll("/", "-"),
1753 home,
1754 settings:
1755 launchArgs === undefined && instanceHome === undefined
1756 ? settings
1757 : {
1758 ...settings,
1759 providerInstances: {
1760 ...settings.providerInstances,
1761 [ProviderInstanceId.make("pi")]: {
1762 driver: ProviderDriverKind.make("pi"),
1763 config: launchArgs === undefined ? {} : { launchArgs },
1764 environment:
1765 instanceHome === undefined
1766 ? []
1767 : [
1768 {
1769 name: platform === "win32" ? "USERPROFILE" : "HOME",
1770 value: NodePath.join(home, instanceHome),
1771 sensitive: false,
1772 },
1773 ],
1774 },
1775 },
1776 },
1777 environment: {
1778 PI_CODING_AGENT_DIR: agentDir,
1779 PI_CODING_AGENT_SESSION_DIR: sessionDir,
1780 },
1781 platform: platform ?? "linux",
1782 }),
1783 ),
1784 Effect.provideService(HostProcess.HomeDirectory, home),
1785 );
1786 }
1787 }),
1788 );
1789
1790 it.effect("reads shared managed default and disabled extra account history once", () =>
1791 Effect.gen(function* () {
1792 const { home, settings } = yield* setup;
1793 const summary = yield* Effect.gen(function* () {
1794 for (const [id, output] of [
1795 ["codex", 17],
1796 ["codex-personal", 23],
1797 ] as const) {
1798 const sessions = NodePath.join(home, "shared-codex", "sessions");
1799 yield* Effect.promise(async () => {
1800 await NodeFSP.mkdir(sessions, { recursive: true });
1801 await NodeFSP.writeFile(
1802 NodePath.join(sessions, `${id}-rollout.jsonl`),
1803 [
1804 { type: "session_meta", payload: { id } },
1805 { type: "turn_context", payload: { model: "gpt-5.6-sol" } },
1806 {
1807 type: "event_msg",
1808 timestamp: "2026-08-01T10:00:00Z",
1809 payload: {
1810 type: "token_count",
1811 info: { last_token_usage: { input_tokens: 10, output_tokens: output } },
1812 },
1813 },
1814 ]
1815 .map((line) => encodeUnknownJsonString(line))
1816 .join("\n") + "\n",
1817 );
1818 });
1819 }
1820 const service = yield* UsageService.make;
1821 return yield* service.readSummary(WINDOW);
1822 }).pipe(
1823 Effect.scoped,
1824 Effect.provide(
1825 layerService({
1826 prefix: "usage-managed-accounts",
1827 home,
1828 settings: {
1829 ...settings,
1830 providerInstances: {
1831 ...settings.providerInstances,
1832 [ProviderInstanceId.make("codex")]: {
1833 driver: ProviderDriverKind.make("codex"),
1834 config: {
1835 setupMode: "managed",
1836 homePath: NodePath.join(home, "shared-codex"),
1837 },
1838 },
1839 [ProviderInstanceId.make("codex-personal")]: {
1840 driver: ProviderDriverKind.make("codex"),
1841 enabled: false,
1842 config: {
1843 setupMode: "managed",
1844 homePath: NodePath.join(home, "shared-codex"),
1845 shadowHomePath: NodePath.join(home, "personal-shadow"),
1846 },
1847 environment: [
1848 {
1849 name: "CODEX_HOME",
1850 value: NodePath.join(home, "ignored-environment"),
1851 sensitive: false,
1852 },
1853 ],
1854 },
1855 },
1856 },
1857 }),
1858 ),
1859 );
1860 assert.strictEqual(totalOutputTokens(summary), 40);
1861 assert.strictEqual(
1862 summary.sources.filter(
1863 (source) => source.fingerprint.provider === "codex" && source.status === "ok",
1864 ).length,
1865 1,
1866 );
1867 }),
1868 );
1869
1870 it.effect.each([
1871 { label: "default", retention: undefined, cutoff: CURSOR_NOW - 92 * 24 * HOUR_MS },
1872 { label: "unlimited", retention: "unlimited" as const, cutoff: 0 },
1873 { label: "36500 days", retention: 36500, cutoff: 0 },
1874 ])(
1875 "propagates the $label cutoff and restores the Cursor account cache after a restart",
1876 ({ retention, cutoff }) =>
1877 Effect.gen(function* () {
1878 const { settings, home } = yield* setup;
1879 yield* TestClock.setTime(CURSOR_NOW);
1880 const before = makeFakeCursor();
1881 before.state.events = [
1882 { timestampMs: CURSOR_NOW - 30 * HOUR_MS, outputTokens: 5 },
1883 { timestampMs: CURSOR_NOW - 3 * HOUR_MS, outputTokens: 7 },
1884 ];
1885 yield* Effect.gen(function* () {
1886 const first = yield* makeWithCursor(before.read);
1887 const original = yield* first.readSummary({ ...WINDOW, awaitRefresh: true });
1888 assert.deepStrictEqual(before.state.calls, [{ sinceMs: cutoff, untilMs: CURSOR_NOW }]);
1889 yield* first.awaitPersisted;
1890
1891 const after = makeFakeCursor();
1892 after.state.events = before.state.events;
1893 const restarted = yield* makeWithCursor(after.read);
1894 const restored = yield* restarted.readSummary(WINDOW);
1895 assert.isUndefined(cursorSource(restored)?.refreshing);
1896 assert.deepStrictEqual(restored.buckets, original.buckets);
1897 assert.deepStrictEqual(cursorSource(restored), cursorSource(original));
1898 assert.strictEqual(after.state.calls.length, 0);
1899
1900 yield* TestClock.adjust(Duration.minutes(2));
1901 const refreshed = yield* restarted.readSummary({ ...WINDOW, awaitRefresh: true });
1902 assert.deepStrictEqual(refreshed.buckets, original.buckets);
1903 assert.deepStrictEqual(after.state.calls, [
1904 { sinceMs: CURSOR_NOW - HOUR_MS, untilMs: CURSOR_NOW + 2 * 60 * 1000 },
1905 ]);
1906 }).pipe(
1907 Effect.provide(
1908 layerService({
1909 prefix: "usage-service-cursor-restart",
1910 environment: { CURSOR_API_KEY: "test-key" },
1911 home,
1912 settings: {
1913 ...settings,
1914 ...(retention === undefined ? {} : { usageHistoryRetentionDays: retention }),
1915 },
1916 }),
1917 ),
1918 );
1919 }),
1920 );
1921
1922 it.effect("widens Cursor history after awaiting a shared narrower refresh", () =>
1923 Effect.gen(function* () {
1924 const { settings, home } = yield* setup;
1925 yield* TestClock.setTime(CURSOR_NOW);
1926 const cursor = makeFakeCursor();
1927 cursor.state.gate = yield* Deferred.make<void>();
1928 cursor.state.started = yield* Deferred.make<void>();
1929 cursor.state.events = [
1930 { timestampMs: CURSOR_NOW - 120 * 24 * HOUR_MS, outputTokens: 5 },
1931 { timestampMs: CURSOR_NOW - 3 * HOUR_MS, outputTokens: 7 },
1932 ];
1933 const context = yield* Layer.build(
1934 layerCursorUsageAccounts(
1935 Layer.succeed(CursorAccountReader.CursorAccountReader, { read: cursor.read }),
1936 ).pipe(
1937 Layer.provide(
1938 layerService({
1939 prefix: "usage-service-cursor-shared-refresh",
1940 home,
1941 settings,
1942 platform: "darwin",
1943 }),
1944 ),
1945 ),
1946 );
1947 const accounts = Context.get(context, CursorUsageAccounts.CursorUsageAccounts);
1948 const input = {
1949 instances: [
1950 {
1951 instanceId: ProviderInstanceId.make("cursor"),
1952 environment: { CURSOR_API_KEY: "test-key" },
1953 },
1954 ],
1955 windowStartMs: 0,
1956 retentionCutoffMs: CURSOR_NOW - 92 * 24 * HOUR_MS,
1957 awaitRefresh: false,
1958 };
1959 const narrow = yield* accounts.scan(input);
1960 assert.isTrue(narrow[0]?.refreshing);
1961 yield* Deferred.await(cursor.state.started);
1962 const wider = yield* accounts
1963 .scan({ ...input, retentionCutoffMs: 0, awaitRefresh: true })
1964 .pipe(Effect.forkChild({ startImmediately: true }));
1965 assert.strictEqual(cursor.state.calls.length, 1);
1966 yield* Deferred.succeed(cursor.state.gate, undefined);
1967 const sources = yield* Fiber.join(wider);
1968 assert.deepStrictEqual(cursor.state.calls, [
1969 { sinceMs: input.retentionCutoffMs, untilMs: CURSOR_NOW },
1970 { sinceMs: 0, untilMs: input.retentionCutoffMs },
1971 ]);
1972 assert.strictEqual(sources[0]?.status, "ok");
1973 assert.deepStrictEqual(
1974 sources[0]?.files?.flatMap((file) =>
1975 file.records.map(({ timestampMs, totals }) => ({
1976 timestampMs,
1977 outputTokens: totals.outputTokens,
1978 })),
1979 ),
1980 cursor.state.events,
1981 );
1982 yield* accounts.awaitPersisted;
1983 }),
1984 );
1985
1986 it.effect("reads the Cursor account of an API key or T3 sign-in instead of a CLI login", () =>
1987 Effect.gen(function* () {
1988 const { settings, home } = yield* setup;
1989 const signIn = new TextEncoder().encode(
1990 encodeUnknownJsonString({
1991 version: 1,
1992 backendUrl: "https://api2.cursor.sh",
1993 apiKey: "signed-in-key",
1994 createdAtMs: 0,
1995 }),
1996 );
1997 yield* Effect.promise(async () => {
1998 await NodeFSP.mkdir(NodePath.join(home, ".cursor"), { recursive: true });
1999 await NodeFSP.writeFile(
2000 NodePath.join(home, ".cursor", "auth.json"),
2001 '{"accessToken":"stale-cli-token"}',
2002 );
2003 });
2004 for (const [index, testCase] of [
2005 { environment: { CURSOR_API_KEY: "environment-key" }, stored: Option.none() },
2006 { environment: {}, stored: Option.some(signIn) },
2007 { environment: {}, stored: Option.none() },
2008 ].entries()) {
2009 const cursor = makeFakeCursor();
2010 const summary = yield* Effect.gen(function* () {
2011 const service = yield* makeWithCursor(cursor.read);
2012 return yield* service.readSummary({ ...WINDOW, awaitRefresh: true });
2013 }).pipe(
2014 Effect.provide(
2015 layerService({
2016 prefix: `usage-service-cursor-api-key-${index}`,
2017 home,
2018 settings,
2019 platform: "darwin",
2020 environment: testCase.environment,
2021 secretStore: { get: () => Effect.succeed(testCase.stored) },
2022 }),
2023 ),
2024 );
2025 if (index === 2) {
2026 assert.deepStrictEqual(cursor.state.credentials, []);
2027 assert.isUndefined(cursorSource(summary));
2028 continue;
2029 }
2030 assert.deepStrictEqual(cursor.state.credentials, [
2031 { kind: "apiKey", apiKey: index === 0 ? "environment-key" : "signed-in-key" },
2032 ]);
2033 assert.strictEqual(cursorSource(summary)?.status, "ok");
2034 }
2035 }),
2036 );
2037
2038 it.effect("does not show a previous Cursor account's history after the API key changes", () =>
2039 Effect.gen(function* () {
2040 const { settings, home } = yield* setup;
2041 yield* TestClock.setTime(CURSOR_NOW);
2042 let apiKey = "first-account-key";
2043 const signIn = () =>
2044 Option.some(
2045 new TextEncoder().encode(
2046 encodeUnknownJsonString({
2047 version: 1,
2048 backendUrl: "https://api2.cursor.sh",
2049 apiKey,
2050 createdAtMs: 0,
2051 }),
2052 ),
2053 );
2054 const cursor = makeFakeCursor();
2055 cursor.state.events = [{ timestampMs: CURSOR_NOW - 3 * HOUR_MS, outputTokens: 7 }];
2056 yield* Effect.gen(function* () {
2057 const service = yield* makeWithCursor(cursor.read);
2058 const first = yield* service.readSummary({ ...WINDOW, awaitRefresh: true });
2059 assert.isTrue(first.buckets.some((bucket) => bucket.provider === "cursor"));
2060
2061 apiKey = "second-account-key";
2062 cursor.state.error = "Cursor account usage could not be read.";
2063 const second = yield* service.readSummary({ ...WINDOW, awaitRefresh: true });
2064 assert.isFalse(second.buckets.some((bucket) => bucket.provider === "cursor"));
2065 }).pipe(
2066 Effect.provide(
2067 layerService({
2068 prefix: "usage-service-cursor-key-change",
2069 home,
2070 settings,
2071 platform: "darwin",
2072 environment: {},
2073 secretStore: { get: () => Effect.sync(signIn) },
2074 }),
2075 ),
2076 );
2077 }),
2078 );
2079
2080 it.effect("loads Cursor history that cannot be read in one request within the deadline", () =>
2081 Effect.gen(function* () {
2082 const { settings, home } = yield* setup;
2083 yield* TestClock.setTime(CURSOR_NOW);
2084 const cursor = makeFakeCursor();
2085 cursor.state.events = [
2086 { timestampMs: CURSOR_NOW - 40 * HOUR_MS, outputTokens: 7 },
2087 { timestampMs: CURSOR_NOW - 3 * HOUR_MS, outputTokens: 5 },
2088 ];
2089 // A large account: a window wider than half a day has too many pages for the read deadlines.
2090 const read: CursorAccountReader.CursorAccountReader["Service"]["read"] = (
2091 credential,
2092 sinceMs,
2093 untilMs,
2094 ) =>
2095 untilMs - sinceMs > 12 * HOUR_MS
2096 ? Effect.succeed({
2097 accountKey: cursor.state.accountKey,
2098 records: [],
2099 missing: false,
2100 error: "Cursor account usage could not be read.",
2101 })
2102 : cursor.read(credential, sinceMs, untilMs);
2103 yield* Effect.gen(function* () {
2104 const service = yield* makeWithCursor(read);
2105 let summary = yield* service.readSummary({ ...WINDOW, awaitRefresh: true });
2106 for (let attempt = 1; attempt < 10 && totalOutputTokens(summary) < 12; attempt++) {
2107 yield* TestClock.adjust("2 minutes");
2108 summary = yield* service.readSummary({ ...WINDOW, awaitRefresh: true });
2109 }
2110 assert.strictEqual(totalOutputTokens(summary), 12);
2111
2112 // Failed reads during an outage narrow the span; it widens back once reads work again.
2113 cursor.state.error = "Cursor account usage could not be read.";
2114 for (let attempt = 0; attempt < 20; attempt++) {
2115 yield* TestClock.adjust("2 minutes");
2116 yield* service.readSummary({ ...WINDOW, awaitRefresh: true });
2117 }
2118 cursor.state.error = null;
2119 yield* TestClock.adjust("10 hours");
2120 cursor.state.events.push({ timestampMs: CURSOR_NOW + 10 * HOUR_MS, outputTokens: 3 });
2121 const callsBeforeRecovery = cursor.state.calls.length;
2122 summary = yield* service.readSummary({ ...WINDOW, awaitRefresh: true });
2123 assert.strictEqual(totalOutputTokens(summary), 15);
2124 assert.isBelow(cursor.state.calls.length - callsBeforeRecovery, 20);
2125 }).pipe(
2126 Effect.provide(
2127 layerService({
2128 prefix: "usage-service-cursor-large-account",
2129 home,
2130 settings,
2131 platform: "darwin",
2132 environment: {},
2133 secretStore: {
2134 get: () =>
2135 Effect.succeedSome(
2136 new TextEncoder().encode(
2137 encodeUnknownJsonString({
2138 version: 1,
2139 backendUrl: "https://api2.cursor.sh",
2140 apiKey: "large-account-key",
2141 createdAtMs: 0,
2142 }),
2143 ),
2144 ),
2145 },
2146 }),
2147 ),
2148 );
2149 }),
2150 );
2151
2152 it.effect("keeps a new Cursor key's refresh visible beside a failing key", () =>
2153 Effect.gen(function* () {
2154 const { settings, home } = yield* setup;
2155 const cursor = makeFakeCursor();
2156 let inFlight = 0;
2157 let mostInFlight = 0;
2158 const started = yield* Deferred.make<void>();
2159 const gate = yield* Deferred.make<void>();
2160 yield* Effect.gen(function* () {
2161 const context = yield* Layer.build(
2162 layerCursorUsageAccounts(
2163 Layer.succeed(CursorAccountReader.CursorAccountReader, {
2164 read: (credential, sinceMs, untilMs) =>
2165 Effect.gen(function* () {
2166 inFlight++;
2167 mostInFlight = Math.max(mostInFlight, inFlight);
2168 if (credential.apiKey === "failing-key") {
2169 yield* Deferred.await(started);
2170 return {
2171 accountKey: null,
2172 records: [],
2173 missing: false,
2174 error: "Cursor account usage could not be read.",
2175 };
2176 }
2177 yield* Deferred.succeed(started, undefined);
2178 yield* Deferred.await(gate);
2179 return yield* cursor.read(credential, sinceMs, untilMs);
2180 }).pipe(
2181 Effect.ensuring(
2182 Effect.sync(() => {
2183 inFlight--;
2184 }),
2185 ),
2186 ),
2187 }),
2188 ),
2189 );
2190 const accounts = Context.get(context, CursorUsageAccounts.CursorUsageAccounts);
2191 const scan = (awaitRefresh: boolean) =>
2192 accounts.scan({
2193 instances: [
2194 {
2195 instanceId: ProviderInstanceId.make("cursor"),
2196 environment: { CURSOR_API_KEY: "failing-key" },
2197 },
2198 {
2199 instanceId: ProviderInstanceId.make("cursor-work"),
2200 environment: { CURSOR_API_KEY: "new-key" },
2201 },
2202 {
2203 instanceId: ProviderInstanceId.make("cursor-third"),
2204 environment: { CURSOR_API_KEY: "third-key" },
2205 },
2206 {
2207 instanceId: ProviderInstanceId.make("cursor-fourth"),
2208 environment: { CURSOR_API_KEY: "fourth-key" },
2209 },
2210 ],
2211 windowStartMs: 0,
2212 retentionCutoffMs: 0,
2213 awaitRefresh,
2214 });
2215 const first = yield* Effect.forkChild(scan(true));
2216 yield* Deferred.await(started);
2217 const sources = yield* scan(false);
2218 assert.isTrue(sources.some((source) => source.refreshing === true));
2219 yield* Deferred.succeed(gate, undefined);
2220 yield* Fiber.join(first);
2221 assert.strictEqual(mostInFlight, 2);
2222 assert.strictEqual(inFlight, 0);
2223 }).pipe(
2224 Effect.provide(
2225 layerService({
2226 prefix: "usage-service-cursor-new-key",
2227 home,
2228 settings,
2229 platform: "linux",
2230 environment: {},
2231 }),
2232 ),
2233 );
2234 }),
2235 );
2236
2237 it.effect("reports one Cursor source when two API keys belong to the same account", () =>
2238 Effect.gen(function* () {
2239 const { settings, home } = yield* setup;
2240 yield* TestClock.setTime(CURSOR_NOW);
2241 const cursor = makeFakeCursor();
2242 cursor.state.events = [{ timestampMs: CURSOR_NOW - 3 * HOUR_MS, outputTokens: 7 }];
2243 let revoked = false;
2244 yield* Effect.gen(function* () {
2245 const service = yield* makeWithCursor((credential, sinceMs, untilMs) =>
2246 revoked && (credential as { apiKey?: string }).apiKey === "second-key"
2247 ? Effect.succeed({
2248 accountKey: null,
2249 records: [],
2250 missing: false,
2251 error: "Cursor account usage could not be read.",
2252 })
2253 : cursor.read(credential, sinceMs, untilMs),
2254 );
2255 const first = yield* service.readSummary({ ...WINDOW, awaitRefresh: true });
2256 assert.strictEqual(cursor.state.credentials.length, 2);
2257 assert.deepStrictEqual(
2258 cursorSources(first).map((source) => source.distinctSessions),
2259 [1],
2260 );
2261
2262 // The revoked key keeps its stale cache, which must not replace the working key's history.
2263 revoked = true;
2264 cursor.state.events.push({ timestampMs: CURSOR_NOW + 60 * 1000, outputTokens: 5 });
2265 yield* TestClock.adjust(Duration.minutes(2));
2266 const second = yield* service.readSummary({ ...WINDOW, awaitRefresh: true });
2267 assert.deepStrictEqual(
2268 cursorSources(second).map((source) => source.status),
2269 ["ok"],
2270 );
2271 assert.strictEqual(totalOutputTokens(second), 12);
2272 }).pipe(
2273 Effect.provide(
2274 layerService({
2275 prefix: "usage-service-cursor-shared-account",
2276 home,
2277 settings: {
2278 ...settings,
2279 providerInstances: {
2280 ...settings.providerInstances,
2281 [ProviderInstanceId.make("cursor")]: {
2282 driver: ProviderDriverKind.make("cursor"),
2283 environment: [{ name: "CURSOR_API_KEY", value: "first-key", sensitive: true }],
2284 },
2285 [ProviderInstanceId.make("cursor-work")]: {
2286 driver: ProviderDriverKind.make("cursor"),
2287 environment: [{ name: "CURSOR_API_KEY", value: "second-key", sensitive: true }],
2288 },
2289 },
2290 },
2291 platform: "darwin",
2292 environment: {},
2293 }),
2294 ),
2295 );
2296 }),
2297 );
2298
2299 it.effect(
2300 "includes OpenCode history but does not substitute desktop usage for an unavailable Cursor account",
2301 () =>
2302 Effect.gen(function* () {
2303 const { settings, home } = yield* setup;
2304 const root = NodePath.join(home, "opencode");
2305 const message = yield* encodeUnknownJson({
2306 id: "msg_1",
2307 sessionID: "session-1",
2308 role: "assistant",
2309 modelID: "example-model",
2310 time: { created: Date.parse("2026-08-01T10:00:00Z") },
2311 tokens: { input: 10, output: 5, reasoning: 2, cache: { read: 20, write: 3 } },
2312 });
2313 const bubble = yield* encodeUnknownJson({
2314 type: 2,
2315 createdAt: "2026-08-01T10:00:00Z",
2316 modelInfo: { modelName: "example-model" },
2317 tokenCount: { inputTokens: 100, outputTokens: 20 },
2318 });
2319 yield* Effect.promise(async () => {
2320 const directory = NodePath.join(root, "storage", "message", "session-1");
2321 await NodeFSP.mkdir(directory, { recursive: true });
2322 await NodeFSP.writeFile(NodePath.join(directory, "msg_1.json"), message);
2323 const desktop = NodePath.join(home, "config", "Cursor", "User", "globalStorage");
2324 await NodeFSP.mkdir(desktop, { recursive: true });
2325 const db = new NodeSqlite.DatabaseSync(NodePath.join(desktop, "state.vscdb"));
2326 try {
2327 db.exec("CREATE TABLE cursorDiskKV (key TEXT, value TEXT)");
2328 db.prepare("INSERT INTO cursorDiskKV VALUES (?, ?)").run(
2329 "bubbleId:session:assistant",
2330 bubble,
2331 );
2332 } finally {
2333 db.close();
2334 }
2335 });
2336 const service = yield* UsageService.make.pipe(
2337 Effect.provide(layerService({ prefix: "usage-service-opencode", home, settings })),
2338 );
2339 const summary = yield* service.readSummary(WINDOW);
2340 assert.strictEqual(summary.buckets[0]?.provider, "opencode");
2341 assert.isFalse(summary.buckets.some((bucket) => bucket.provider === "cursor"));
2342 assert.isFalse(summary.sources.some((source) => source.fingerprint.provider === "cursor"));
2343 assert.strictEqual(
2344 summary.buckets[0]?.sourcePath,
2345 yield* Effect.promise(() => NodeFSP.realpath(root)),
2346 );
2347 assert.strictEqual(summary.buckets[0]?.totals.outputTokens, 7);
2348 assert.strictEqual(
2349 summary.sources.find((source) => source.fingerprint.provider === "opencode")
2350 ?.distinctSessions,
2351 1,
2352 );
2353 }),
2354 );
2355
2356 it.effect("counts unpriced tokens from the unpriced records of a mixed model", () =>
2357 Effect.gen(function* () {
2358 const { settings, home } = yield* setup;
2359 const message = (id: string, cost: number, input: number, output: number, minute: number) =>
2360 encodeUnknownJson({
2361 id,
2362 sessionID: "session-1",
2363 role: "assistant",
2364 modelID: "acme-coder-1",
2365 providerID: "acme",
2366 time: { created: Date.parse(`2026-08-01T10:0${minute}:00Z`) },
2367 cost,
2368 tokens: { input, output, reasoning: 0, cache: { read: 0, write: 0 } },
2369 });
2370 const priced = yield* message("msg_priced", 1, 60, 40, 0);
2371 const unpriced = yield* message("msg_unpriced", 0, 9_000, 900, 1);
2372 yield* Effect.promise(async () => {
2373 const directory = NodePath.join(home, "opencode", "storage", "message", "session-1");
2374 await NodeFSP.mkdir(directory, { recursive: true });
2375 await NodeFSP.writeFile(NodePath.join(directory, "msg_priced.json"), priced);
2376 await NodeFSP.writeFile(NodePath.join(directory, "msg_unpriced.json"), unpriced);
2377 });
2378 const service = yield* UsageService.make.pipe(
2379 Effect.provide(layerService({ prefix: "usage-service-unpriced-tokens", home, settings })),
2380 );
2381 const summary = yield* service.readSummary(WINDOW);
2382 const model = mergeUsage(
2383 [{ environmentId: EnvironmentId.make("local"), label: "local", summary }],
2384 summary.contractVersion,
2385 ).models.find((entry) => entry.model === "acme-coder-1");
2386
2387 assert.strictEqual(model?.costUsd, 1);
2388 assert.strictEqual(model?.totalTokens, 10_000);
2389 assert.strictEqual(model?.unpricedTokens, 9_900);
2390 }),
2391 );
2392
2393 it.effect("includes host and merged OpenCode instance histories once across list aliases", () =>
2394 Effect.gen(function* () {
2395 const { settings, home } = yield* setup;
2396 const hostRoot = NodePath.join(home, "opencode");
2397 const instanceRoot = NodePath.join(home, "opencode-work");
2398 const alias = NodePath.join(home, "opencode-alias");
2399 const dataHome = NodePath.join(home, "data");
2400 const xdgRoot = NodePath.join(dataHome, "opencode");
2401 const histories = [
2402 { root: hostRoot, id: "host", output: 5 },
2403 { root: instanceRoot, id: "work", output: 7 },
2404 { root: xdgRoot, id: "xdg", output: 11 },
2405 ];
2406 yield* Effect.promise(async () => {
2407 for (const { root, id, output } of histories) {
2408 const directory = NodePath.join(root, "storage", "message", "session-1");
2409 await NodeFSP.mkdir(directory, { recursive: true });
2410 await NodeFSP.writeFile(
2411 NodePath.join(directory, `${id}.json`),
2412 encodeUnknownJsonString({
2413 role: "assistant",
2414 modelID: "example-model",
2415 time: { created: Date.parse("2026-08-01T10:00:00Z") },
2416 tokens: { input: 10, output },
2417 }),
2418 );
2419 }
2420 await NodeFSP.symlink(instanceRoot, alias, "junction");
2421 });
2422 const service = yield* UsageService.make.pipe(
2423 Effect.provide(
2424 layerService({
2425 prefix: "usage-service-opencode-instances",
2426 home,
2427 environment: { XDG_DATA_HOME: dataHome },
2428 settings: {
2429 ...settings,
2430 providerInstances: {
2431 ...settings.providerInstances,
2432 [ProviderInstanceId.make("opencode-work")]: {
2433 driver: ProviderDriverKind.make("opencode"),
2434 environment: [
2435 {
2436 name: "OPENCODE_DATA_DIR",
2437 value: ` ${instanceRoot}, ${alias} `,
2438 sensitive: false,
2439 },
2440 ],
2441 },
2442 [ProviderInstanceId.make("opencode-xdg")]: {
2443 driver: ProviderDriverKind.make("opencode"),
2444 environment: [{ name: "OPENCODE_DATA_DIR", value: "", sensitive: false }],
2445 },
2446 },
2447 },
2448 }),
2449 ),
2450 );
2451 const summary = yield* service.readSummary(WINDOW);
2452 const sources = summary.sources.filter(
2453 (source) => source.fingerprint.provider === "opencode",
2454 );
2455 const expectedRoots = yield* Effect.promise(() =>
2456 Promise.all(histories.map(({ root }) => NodeFSP.realpath(root))),
2457 );
2458 assert.deepStrictEqual(
2459 sources.map((source) => source.fingerprint.resolvedHomePath).sort(),
2460 expectedRoots.sort(),
2461 );
2462 assert.deepStrictEqual(
2463 summary.buckets
2464 .filter((bucket) => bucket.provider === "opencode")
2465 .map((bucket) => bucket.totals.outputTokens)
2466 .sort((a, b) => a - b),
2467 [5, 7, 11],
2468 );
2469 }),
2470 );
2471
2472 it.effect("counts aliased OpenCode and Antigravity directories once", () =>
2473 Effect.gen(function* () {
2474 const { settings, home } = yield* setup;
2475 const opencode = NodePath.join(home, "opencode-store");
2476 const opencodeAlias = NodePath.join(home, "opencode-alias");
2477 const conversations = NodePath.join(home, "antigravity-conversations");
2478 const antigravityA = NodePath.join(home, "antigravity-a");
2479 const antigravityB = NodePath.join(home, "antigravity-b");
2480 yield* Effect.promise(async () => {
2481 await NodeFSP.mkdir(opencode);
2482 await NodeFSP.symlink(opencode, opencodeAlias, "junction");
2483 await NodeFSP.mkdir(conversations);
2484 await NodeFSP.mkdir(antigravityA);
2485 await NodeFSP.mkdir(antigravityB);
2486 await NodeFSP.symlink(
2487 conversations,
2488 NodePath.join(antigravityA, "conversations"),
2489 "junction",
2490 );
2491 await NodeFSP.symlink(
2492 conversations,
2493 NodePath.join(antigravityB, "conversations"),
2494 "junction",
2495 );
2496 });
2497 const service = yield* UsageService.make.pipe(
2498 Effect.provide(
2499 layerService({
2500 prefix: "usage-service-aliased-roots-test",
2501 home,
2502 settings,
2503 environment: {
2504 OPENCODE_DATA_DIR: `${opencode},${opencodeAlias}`,
2505 ANTIGRAVITY_DATA_DIR: `${antigravityA},${antigravityB}`,
2506 },
2507 }),
2508 ),
2509 );
2510 const summary = yield* service.readSummary(WINDOW);
2511 const sourcesFor = (provider: "opencode" | "antigravity") =>
2512 summary.sources.filter((source) => source.fingerprint.provider === provider);
2513 assert.strictEqual(sourcesFor("opencode").length, 1);
2514 assert.strictEqual(sourcesFor("antigravity").length, 1);
2515 assert.strictEqual(
2516 sourcesFor("opencode")[0]?.fingerprint.resolvedHomePath,
2517 yield* Effect.promise(() => NodeFSP.realpath(opencode)),
2518 );
2519 assert.strictEqual(
2520 sourcesFor("antigravity")[0]?.fingerprint.resolvedHomePath,
2521 yield* Effect.promise(() => NodeFSP.realpath(conversations)),
2522 );
2523 }),
2524 );
2525
2526 it.effect("reads Antigravity history from each instance's data directory", () =>
2527 Effect.gen(function* () {
2528 const { settings, home } = yield* setup;
2529 const first = NodePath.join(home, "antigravity-first");
2530 const second = NodePath.join(home, "antigravity-second");
2531 yield* Effect.promise(async () => {
2532 for (const [dir, outputTokens] of [
2533 [first, 7],
2534 [second, 11],
2535 ] as const) {
2536 await NodeFSP.mkdir(dir);
2537 const db = new NodeSqlite.DatabaseSync(
2538 NodePath.join(dir, `${NodePath.basename(dir)}.db`),
2539 );
2540 try {
2541 db.exec("CREATE TABLE steps (idx INTEGER, metadata BLOB)");
2542 // Step protobuf: 100 input tokens, distinct output tokens, and 2026-08-01T10:00Z.
2543 const metadata = new Uint8Array([
2544 0x4a,
2545 4,
2546 0x10,
2547 100,
2548 0x18,
2549 outputTokens,
2550 ...Buffer.from("420608a087b7d306", "hex"),
2551 ]);
2552 db.prepare("INSERT INTO steps VALUES (?, ?)").run(0, metadata);
2553 } finally {
2554 db.close();
2555 }
2556 }
2557 });
2558 const instance = (dataDir: string) => ({
2559 driver: ProviderDriverKind.make("antigravity"),
2560 environment: [{ name: "ANTIGRAVITY_DATA_DIR", value: dataDir, sensitive: false }],
2561 });
2562 const service = yield* UsageService.make.pipe(
2563 Effect.provide(
2564 layerService({
2565 prefix: "usage-service-antigravity-instances-test",
2566 home,
2567 settings: {
2568 providerInstances: {
2569 ...settings.providerInstances,
2570 [ProviderInstanceId.make("antigravity-first")]: instance(first),
2571 [ProviderInstanceId.make("antigravity-second")]: instance(` ${second}, `),
2572 },
2573 },
2574 }),
2575 ),
2576 );
2577 const summary = yield* service.readSummary(WINDOW);
2578 const roots = summary.sources
2579 .filter((source) => source.fingerprint.provider === "antigravity")
2580 .map((source) => source.fingerprint.resolvedHomePath);
2581 for (const [dir, outputTokens] of [
2582 [first, 7],
2583 [second, 11],
2584 ] as const) {
2585 const root = yield* Effect.promise(() => NodeFSP.realpath(dir));
2586 assert.include(roots, root);
2587 assert.strictEqual(
2588 summary.buckets
2589 .filter((bucket) => bucket.provider === "antigravity" && bucket.sourcePath === root)
2590 .reduce((sum, bucket) => sum + bucket.totals.outputTokens, 0),
2591 outputTokens,
2592 );
2593 }
2594 }),
2595 );
2596
2597 it.effect("reads configured and disabled accounts once across shared and aliased homes", () =>
2598 Effect.gen(function* () {
2599 const { transcript, settings, home } = yield* setup;
2600 const codexHome = NodePath.join(home, "codex-account");
2601 const alias = NodePath.join(home, "codex-alias");
2602 const claudeHome = NodePath.join(home, "claude-account");
2603 const grokHome = NodePath.join(home, "grok-account");
2604 yield* Effect.promise(async () => {
2605 await NodeFSP.writeFile(transcript, claudeLine(1, 5));
2606 await NodeFSP.mkdir(NodePath.join(claudeHome, "projects"), { recursive: true });
2607 await NodeFSP.writeFile(
2608 NodePath.join(claudeHome, "projects", "session.jsonl"),
2609 claudeLine(2, 7),
2610 );
2611 await NodeFSP.mkdir(NodePath.join(codexHome, "sessions"), { recursive: true });
2612 await NodeFSP.symlink(codexHome, alias, "junction");
2613 await NodeFSP.writeFile(
2614 NodePath.join(codexHome, "sessions", "rollout.jsonl"),
2615 [
2616 { type: "session_meta", payload: { id: "codex-account-session" } },
2617 { type: "turn_context", payload: { model: "gpt-5.6-sol" } },
2618 ...[11, 12, 11].map((outputTokens) => ({
2619 type: "event_msg",
2620 timestamp: "2026-08-01T10:00:00Z",
2621 payload: {
2622 type: "token_count",
2623 info: { last_token_usage: { input_tokens: 10, output_tokens: outputTokens } },
2624 },
2625 })),
2626 ]
2627 .map((line) => encodeUnknownJsonString(line))
2628 .join("\n") + "\n",
2629 );
2630 await NodeFSP.mkdir(NodePath.join(grokHome, "sessions", "session"), { recursive: true });
2631 await NodeFSP.writeFile(
2632 NodePath.join(grokHome, "sessions", "session", "updates.jsonl"),
2633 encodeUnknownJsonString({
2634 timestamp: Date.parse("2026-08-01T10:00:00Z") / 1000,
2635 method: "_x.ai/session/update",
2636 params: {
2637 sessionId: "grok-account-session",
2638 update: {
2639 sessionUpdate: "turn_completed",
2640 prompt_id: "prompt-1",
2641 usage: { inputTokens: 10, outputTokens: 13 },
2642 },
2643 },
2644 }) + "\n",
2645 );
2646 });
2647 const service = yield* UsageService.make.pipe(
2648 Effect.provide(
2649 layerService({
2650 prefix: "usage-service-accounts-test",
2651 home,
2652 settings: {
2653 ...settings,
2654 providerInstances: {
2655 ...settings.providerInstances,
2656 [ProviderInstanceId.make("claude-work")]: {
2657 driver: ProviderDriverKind.make("claudeAgent"),
2658 enabled: false,
2659 environment: [{ name: "CLAUDE_CONFIG_DIR", value: claudeHome, sensitive: false }],
2660 },
2661 [ProviderInstanceId.make("codex-work")]: {
2662 driver: ProviderDriverKind.make("codex"),
2663 config: { shadowHomePath: NodePath.join(home, "work-shadow") },
2664 environment: [{ name: "CODEX_HOME", value: codexHome, sensitive: false }],
2665 },
2666 [ProviderInstanceId.make("codex-alias")]: {
2667 driver: ProviderDriverKind.make("codex"),
2668 config: { homePath: alias },
2669 },
2670 [ProviderInstanceId.make("codex-shadow")]: {
2671 driver: ProviderDriverKind.make("codex"),
2672 config: { homePath: codexHome, shadowHomePath: NodePath.join(home, "shadow") },
2673 environment: [
2674 { name: "CODEX_HOME", value: NodePath.join(home, "ignored"), sensitive: false },
2675 ],
2676 },
2677 [ProviderInstanceId.make("grok-work")]: {
2678 driver: ProviderDriverKind.make("grok"),
2679 config: { customModels: "not-a-list" },
2680 environment: [{ name: "GROK_HOME", value: grokHome, sensitive: false }],
2681 },
2682 },
2683 },
2684 }),
2685 ),
2686 );
2687 const summary = yield* service.readSummary(WINDOW);
2688 assert.strictEqual(totalOutputTokens(summary), 59);
2689 yield* Effect.promise(() =>
2690 NodeFSP.rename(
2691 NodePath.join(codexHome, "sessions", "rollout.jsonl"),
2692 NodePath.join(codexHome, "sessions", "moved.jsonl"),
2693 ),
2694 );
2695 const moved = yield* service.readSummary(WINDOW);
2696 assert.deepStrictEqual(moved.buckets, summary.buckets);
2697 yield* Effect.promise(() =>
2698 NodeFSP.rm(NodePath.join(codexHome, "sessions"), { recursive: true }),
2699 );
2700 const removed = yield* service.readSummary(WINDOW);
2701 assert.deepStrictEqual(removed.buckets, summary.buckets);
2702
2703 const sources = summary.sources.filter((source) => source.status === "ok");
2704 assert.strictEqual(sources.length, 4);
2705 assert.strictEqual(
2706 sources.reduce((sum, source) => sum + source.scannedFiles, 0),
2707 4,
2708 );
2709 assert.strictEqual(
2710 sources.filter((source) => source.fingerprint.provider === "codex").length,
2711 1,
2712 );
2713 }),
2714 );
2715
2716 it.effect("keeps default-home history after the default account moves to a custom home", () =>
2717 Effect.gen(function* () {
2718 const { transcript, settings, home } = yield* setup;
2719 const defaultHome = NodePath.join(home, "default-claude");
2720 const defaultProjects = NodePath.join(defaultHome, "projects", "proj");
2721 yield* Effect.promise(async () => {
2722 await NodeFSP.writeFile(transcript, claudeLine(1, 5));
2723 await NodeFSP.mkdir(defaultProjects, { recursive: true });
2724 await NodeFSP.writeFile(
2725 NodePath.join(defaultProjects, "earlier.jsonl"),
2726 claudeLine(2, 7, "claude-fable-5", "earlier-session"),
2727 );
2728 });
2729 const summary = yield* UsageService.make.pipe(
2730 Effect.flatMap((service) => service.readSummary(WINDOW)),
2731 Effect.provide(
2732 layerService({
2733 prefix: "usage-service-default-home-test",
2734 home,
2735 environment: { CLAUDE_CONFIG_DIR: defaultHome },
2736 settings,
2737 }),
2738 ),
2739 );
2740 assert.strictEqual(totalOutputTokens(summary), 12);
2741 }),
2742 );
2743
2744 it.effect(
2745 "uses explicit account settings before environment and default homes, then refreshes them",
2746 () =>
2747 Effect.gen(function* () {
2748 const { transcript, settings, home } = yield* setup;
2749 const configured = NodePath.join(home, "configured");
2750 const environmentHome = NodePath.join(home, "environment");
2751 yield* Effect.promise(async () => {
2752 await NodeFSP.writeFile(transcript, claudeLine(1, 100));
2753 for (const [index, root] of [configured, environmentHome].entries()) {
2754 await NodeFSP.mkdir(NodePath.join(root, "projects"), { recursive: true });
2755 await NodeFSP.writeFile(
2756 NodePath.join(root, "projects", "session.jsonl"),
2757 claudeLine(index + 2, index + 7),
2758 );
2759 }
2760 await NodeFSP.mkdir(NodePath.join(configured, ".claude", "projects"), {
2761 recursive: true,
2762 });
2763 await NodeFSP.writeFile(
2764 NodePath.join(configured, ".claude", "projects", "wrong.jsonl"),
2765 claudeLine(4, 1000),
2766 );
2767 });
2768 yield* Effect.gen(function* () {
2769 const settingsService = yield* ServerSettings.ServerSettingsService;
2770 const service = yield* UsageService.make;
2771 const first = yield* service.readSummary(WINDOW);
2772 assert.strictEqual(totalOutputTokens(first), 7);
2773 const configuredProjects = yield* Effect.promise(() =>
2774 NodeFSP.realpath(NodePath.join(configured, "projects")),
2775 );
2776 assert.include(
2777 first.sources.map((source) => source.fingerprint.resolvedHomePath),
2778 configuredProjects,
2779 );
2780 yield* settingsService.updateSettings({
2781 providerInstances: {
2782 ...settings.providerInstances,
2783 [ProviderInstanceId.make("claudeAgent")]: {
2784 driver: ProviderDriverKind.make("claudeAgent"),
2785 config: { homePath: "" },
2786 environment: [
2787 { name: "CLAUDE_CONFIG_DIR", value: environmentHome, sensitive: false },
2788 ],
2789 },
2790 },
2791 });
2792 const second = yield* service.readSummary(WINDOW);
2793 assert.strictEqual(totalOutputTokens(second), 8);
2794 const environmentProjects = yield* Effect.promise(() =>
2795 NodeFSP.realpath(NodePath.join(environmentHome, "projects")),
2796 );
2797 assert.include(
2798 second.sources.map((source) => source.fingerprint.resolvedHomePath),
2799 environmentProjects,
2800 );
2801 }).pipe(
2802 Effect.scoped,
2803 Effect.provide(
2804 layerService({
2805 prefix: "usage-service-home-refresh-test",
2806 home,
2807 environment: { CLAUDE_CONFIG_DIR: NodePath.join(home, "host-ignored") },
2808 settings: {
2809 ...settings,
2810 providerInstances: {
2811 ...settings.providerInstances,
2812 [ProviderInstanceId.make("claudeAgent")]: {
2813 driver: ProviderDriverKind.make("claudeAgent"),
2814 config: { homePath: configured },
2815 environment: [
2816 { name: "CLAUDE_CONFIG_DIR", value: environmentHome, sensitive: false },
2817 ],
2818 },
2819 },
2820 },
2821 }),
2822 ),
2823 );
2824 }),
2825 );
2826
2827 it.effect(
2828 "uses inherited home variables when explicit default accounts have no home settings",
2829 () =>
2830 Effect.gen(function* () {
2831 const { transcript, settings, home } = yield* setup;
2832 yield* Effect.promise(() => NodeFSP.writeFile(transcript, claudeLine(1, 5)));
2833 const service = yield* UsageService.make.pipe(
2834 Effect.provide(
2835 layerService({
2836 prefix: "usage-service-inherited-homes-test",
2837 home,
2838 environment: {
2839 CODEX_HOME: NodePath.join(home, "inherited-codex"),
2840 CLAUDE_CONFIG_DIR: NodePath.join(home, "claude"),
2841 },
2842 settings: {
2843 ...settings,
2844 providerInstances: {
2845 [ProviderInstanceId.make("codex")]: {
2846 driver: ProviderDriverKind.make("codex"),
2847 config: {},
2848 },
2849 [ProviderInstanceId.make("claudeAgent")]: {
2850 driver: ProviderDriverKind.make("claudeAgent"),
2851 config: {},
2852 },
2853 },
2854 },
2855 }),
2856 ),
2857 );
2858 const summary = yield* service.readSummary(WINDOW);
2859 assert.strictEqual(totalOutputTokens(summary), 5);
2860 assert.strictEqual(
2861 summary.sources.find((source) => source.fingerprint.provider === "codex")?.fingerprint
2862 .resolvedHomePath,
2863 NodePath.join(home, "inherited-codex", "sessions"),
2864 );
2865 assert.strictEqual(
2866 summary.sources.find((source) => source.fingerprint.provider === "grok")?.fingerprint
2867 .resolvedHomePath,
2868 NodePath.join(home, "grok", "sessions"),
2869 );
2870 }),
2871 );
2872
2873 it.effect.skipIf(HostProcess.Platform.defaultValue() === "win32" || process.getuid?.() === 0)(
2874 "reports unreadable transcripts as partial and recovers once they can be read",
2875 () =>
2876 Effect.gen(function* () {
2877 const { transcript, settings, home } = yield* setup;
2878 const unreadable = NodePath.join(NodePath.dirname(transcript), "other.jsonl");
2879 yield* Effect.promise(async () => {
2880 await NodeFSP.writeFile(transcript, claudeLine(1, 5));
2881 await NodeFSP.writeFile(unreadable, claudeLine(2, 7));
2882 await NodeFSP.chmod(unreadable, 0);
2883 });
2884 yield* Effect.gen(function* () {
2885 const service = yield* UsageService.make;
2886 const partial = yield* service.readSummary(WINDOW);
2887 assert.strictEqual(totalOutputTokens(partial), 5);
2888 assert.strictEqual(partial.sources[0]?.status, "partial");
2889
2890 yield* Effect.promise(() => NodeFSP.chmod(unreadable, 0o600));
2891 const healthy = yield* service.readSummary(WINDOW);
2892 assert.strictEqual(totalOutputTokens(healthy), 12);
2893 assert.strictEqual(healthy.sources[0]?.status, "ok");
2894 assert.isNull(healthy.sources[0]?.message);
2895 }).pipe(
2896 Effect.provide(layerService({ prefix: "usage-service-unreadable", home, settings })),
2897 );
2898 }),
2899 );
2900
2901 it.effect(
2902 "answers a provisional read from the last scan, then the exact read adds what changed",
2903 () =>
2904 Effect.gen(function* () {
2905 const { transcript, settings, home } = yield* setup;
2906 yield* Effect.promise(() => NodeFSP.writeFile(transcript, claudeLine(1, 5)));
2907 const provisional = { ...WINDOW, provisional: true };
2908 const claude = (summary: UsageSummary) =>
2909 summary.sources.find((source) => source.fingerprint.provider === "claude");
2910 yield* Effect.gen(function* () {
2911 // With nothing persisted, the first answer is a full scan.
2912 const service = yield* UsageService.make;
2913 const loop = NodePath.join(NodePath.dirname(transcript), "loop.jsonl");
2914 yield* Effect.promise(() => NodeFSP.symlink(loop, loop, "junction"));
2915 assert.strictEqual(claude(yield* service.readSummary(provisional))?.status, "partial");
2916 yield* Effect.promise(() => NodeFSP.rm(loop));
2917 // A scan that missed a path covers nothing, so this is a full scan too.
2918 assert.isUndefined(claude(yield* service.readSummary(provisional))?.refreshing);
2919 yield* service.awaitPersisted;
2920
2921 yield* Effect.promise(() => NodeFSP.appendFile(transcript, claudeLine(2, 7)));
2922 const restarted = yield* UsageService.make;
2923 const saved = yield* restarted.readSummary(provisional);
2924 assert.strictEqual(totalOutputTokens(saved), 5);
2925 assert.isTrue(claude(saved)?.refreshing);
2926 // A window that starts before the saved scan could only show part of its usage.
2927 const wider = yield* restarted.readSummary({
2928 ...provisional,
2929 sinceDay: UsageDay.make("2026-07-01"),
2930 });
2931 assert.strictEqual(totalOutputTokens(wider), 12);
2932 assert.isUndefined(claude(wider)?.refreshing);
2933 const refreshed = yield* restarted.readSummary({ ...WINDOW, awaitRefresh: true });
2934 assert.strictEqual(totalOutputTokens(refreshed), 12);
2935 assert.isUndefined(claude(refreshed)?.refreshing);
2936 // Saved usage with nothing to show marks nothing refreshing, so it must not be the answer.
2937 yield* Effect.promise(() =>
2938 NodeFSP.appendFile(transcript, claudeLine(3, 11, "claude-other")),
2939 );
2940 const unseen = yield* restarted.readSummary({
2941 ...provisional,
2942 modelFilter: { include: [{ model: "claude-other" }] },
2943 });
2944 assert.strictEqual(totalOutputTokens(unseen), 11);
2945 yield* restarted.awaitPersisted;
2946
2947 // A saved scan with an entry this server cannot read covers nothing.
2948 const { stateDir } = yield* ServerConfig.ServerConfig;
2949 const cachePath = NodePath.join(stateDir, SCAN_CACHE_FILE_NAME);
2950 yield* Effect.promise(async () => {
2951 const document = decodeUnknownJsonString(await NodeFSP.readFile(cachePath, "utf8")) as {
2952 files: Record<string, Record<string, unknown>>;
2953 };
2954 const [entry] = Object.values(document.files);
2955 document.files[NodePath.join(NodePath.dirname(transcript), "broken.jsonl")] = {
2956 ...entry,
2957 r: "broken",
2958 };
2959 await NodeFSP.writeFile(cachePath, JSON.stringify(document));
2960 });
2961 const reloaded = yield* UsageService.make;
2962 assert.isUndefined(claude(yield* reloaded.readSummary(provisional))?.refreshing);
2963 }).pipe(
2964 Effect.scoped,
2965 Effect.provide(layerService({ prefix: "usage-service-provisional", home, settings })),
2966 );
2967 }),
2968 );
2969
2970 it.effect("filters original model IDs before aliases, pricing, buckets and session counts", () =>
2971 Effect.gen(function* () {
2972 const { transcript, settings, home } = yield* setup;
2973 yield* Effect.promise(() =>
2974 NodeFSP.writeFile(
2975 transcript,
2976 claudeLine(1, 3, "orbit-1", "mixed") +
2977 claudeLine(2, 5, "orbit-2", "mixed") +
2978 claudeLine(3, 7, "drift-9", "mixed") +
2979 claudeLine(4, 11, "drift-9", "excluded-only"),
2980 ),
2981 );
2982 const rates = {
2983 "orbit-1": { input_cost_per_token: 0.000001, output_cost_per_token: 0.00001 },
2984 "orbit-2": { input_cost_per_token: 0.000002, output_cost_per_token: 0.00002 },
2985 };
2986 const include = {
2987 // The codex selector must not match the Claude drift-9 records.
2988 include: [
2989 { provider: "claude", model: "orbit-1" },
2990 { model: "orbit-2" },
2991 { provider: "codex", model: "drift-9" },
2992 ],
2993 };
2994 const exclude = { exclude: [{ model: "drift-9" }] };
2995 const HOURLY: UsageSummaryInput = {
2996 ...WINDOW,
2997 resolution: "hour",
2998 sinceTime: "2026-08-01T09:00:00Z",
2999 untilTime: "2026-08-01T11:00:00Z",
3000 };
3001 const cells = (summary: UsageSummary) =>
3002 summary.buckets.map(({ model, totals, costUsd, records, sessions }) => ({
3003 model,
3004 outputTokens: totals.outputTokens,
3005 costUsd: Math.round(costUsd * 1e6),
3006 records,
3007 sessions,
3008 }));
3009
3010 yield* Effect.gen(function* () {
3011 const service = yield* UsageService.make;
3012 // Same service, concurrent reads: the in-flight key must keep these scans apart.
3013 const [unfiltered, noOp, keepNothing, included, reordered, excluded, hourly] =
3014 yield* Effect.all(
3015 [
3016 service.readSummary(WINDOW),
3017 service.readSummary({ ...WINDOW, modelFilter: { exclude: [] } }),
3018 service.readSummary({ ...WINDOW, modelFilter: { include: [] } }),
3019 service.readSummary({ ...WINDOW, modelFilter: include }),
3020 service.readSummary({
3021 ...WINDOW,
3022 modelFilter: { include: [...include.include].reverse() },
3023 }),
3024 service.readSummary({ ...WINDOW, modelFilter: exclude }),
3025 service.readSummary({ ...HOURLY, modelFilter: include }),
3026 ],
3027 { concurrency: "unbounded" },
3028 );
3029
3030 // Unfiltered keeps today's behavior: the alias folds drift-9 into orbit-1.
3031 assert.deepStrictEqual(cells(unfiltered), [
3032 { model: "orbit-1", outputTokens: 21, costUsd: 240, records: 3, sessions: 2 },
3033 { model: "orbit-2", outputTokens: 5, costUsd: 120, records: 1, sessions: 1 },
3034 ]);
3035 assert.strictEqual(unfiltered.sources[0]?.distinctSessions, 2);
3036 assert.strictEqual(unfiltered.modelFilter, undefined);
3037 assert.strictEqual(noOp, unfiltered);
3038 assert.deepStrictEqual(keepNothing.buckets, []);
3039 assert.strictEqual(keepNothing.sources[0]?.distinctSessions, 0);
3040
3041 const kept = [
3042 { model: "orbit-1", outputTokens: 3, costUsd: 40, records: 1, sessions: 1 },
3043 { model: "orbit-2", outputTokens: 5, costUsd: 120, records: 1, sessions: 1 },
3044 ];
3045 assert.deepStrictEqual(cells(included), kept);
3046 assert.deepStrictEqual(cells(excluded), kept);
3047 assert.deepStrictEqual(cells(hourly), kept);
3048 assert.strictEqual(hourly.buckets[0]?.hourStart, "2026-08-01T10:00:00.000Z");
3049 for (const summary of [included, excluded, hourly]) {
3050 assert.strictEqual(summary.sources[0]?.distinctSessions, 1);
3051 }
3052 // Equal filters share one scan and echo one canonical form.
3053 assert.strictEqual(reordered, included);
3054 assert.deepStrictEqual(included.modelFilter, {
3055 include: [
3056 { provider: "claude", model: "orbit-1" },
3057 { provider: "codex", model: "drift-9" },
3058 { model: "orbit-2" },
3059 ],
3060 });
3061 }).pipe(
3062 Effect.scoped,
3063 Effect.provide(
3064 layerService({
3065 prefix: "usage-service-model-filter-test",
3066 home,
3067 settings: { ...settings, usageModelAliases: { "drift-9": "orbit-1" } },
3068 ratesDocument: rates,
3069 }),
3070 ),
3071 );
3072 }),
3073 );
3074
3075 it.effect("reprices unchanged transcripts when custom prices are added, edited, or removed", () =>
3076 Effect.gen(function* () {
3077 const { transcript, settings, home } = yield* setup;
3078 yield* Effect.promise(() => NodeFSP.writeFile(transcript, claudeLine(1, 5, "example-model")));
3079
3080 yield* Effect.gen(function* () {
3081 const settingsService = yield* ServerSettings.ServerSettingsService;
3082 const service = yield* UsageService.make;
3083
3084 const original = yield* service.readSummary(WINDOW);
3085 assert.strictEqual(original.buckets[0]?.costUsd, 0);
3086 assert.strictEqual(original.buckets[0]?.unpricedRecords, 1);
3087
3088 yield* settingsService.updateSettings({
3089 usagePriceOverrides: {
3090 "example-model": { inputCostPerMillionTokens: 2, outputCostPerMillionTokens: 8 },
3091 },
3092 });
3093 const overridden = yield* service.readSummary(WINDOW);
3094 assert.closeTo(overridden.buckets[0]?.costUsd ?? -1, 0.00006, 1e-12);
3095 assert.strictEqual(overridden.buckets[0]?.costSource, "modelPriced");
3096 assert.strictEqual(overridden.buckets[0]?.unpricedRecords, 0);
3097 assert.deepStrictEqual(overridden.buckets[0]?.totals, original.buckets[0]?.totals);
3098
3099 yield* settingsService.updateSettings({
3100 usagePriceOverrides: {
3101 "example-model": { inputCostPerMillionTokens: 4, outputCostPerMillionTokens: 16 },
3102 },
3103 });
3104 const edited = yield* service.readSummary(WINDOW);
3105 assert.closeTo(edited.buckets[0]?.costUsd ?? -1, 0.00012, 1e-12);
3106
3107 yield* settingsService.updateSettings({ usagePriceOverrides: { "example-model": null } });
3108 const restored = yield* service.readSummary(WINDOW);
3109 assert.deepStrictEqual(restored.buckets, original.buckets);
3110 }).pipe(
3111 Effect.scoped,
3112 Effect.provide(
3113 layerService({ prefix: "usage-service-price-overrides-test", home, settings }),
3114 ),
3115 );
3116 }),
3117 );
3118
3119 it.effect(
3120 "retains Codex reconciliation and partial coverage through persisted restart, append and repair",
3121 () =>
3122 Effect.gen(function* () {
3123 const { home, settings } = yield* setup;
3124 const dir = NodePath.join(home, "codex", "sessions");
3125 const transcript = NodePath.join(dir, "rollout.jsonl");
3126 const usage = (input: number, output: number) => ({
3127 input_tokens: input,
3128 output_tokens: output,
3129 total_tokens: input + output,
3130 });
3131 const counted = (input: number, output: number, totalInput: number, totalOutput: number) =>
3132 encodeUnknownJsonString({
3133 type: "event_msg",
3134 timestamp: "2026-08-01T10:00:00Z",
3135 payload: {
3136 type: "token_count",
3137 info: {
3138 last_token_usage: usage(input, output),
3139 total_token_usage: usage(totalInput, totalOutput),
3140 },
3141 },
3142 });
3143 const tier = (service_tier: string) =>
3144 encodeUnknownJsonString({
3145 type: "event_msg",
3146 payload: { type: "thread_settings_applied", thread_settings: { service_tier } },
3147 });
3148 const bad = counted(10, 2, 130, 28);
3149 // Cross the reader's projection threshold so cumulative fields must survive selection.
3150 const stale = counted(20, 5, 100, 20).replace(
3151 '"payload":',
3152 '"padding":' + encodeUnknownJsonString("x".repeat(9 * 1024 * 1024)) + ',"payload":',
3153 );
3154 let content = [
3155 encodeUnknownJsonString({ type: "turn_context", payload: { model: "gpt-6-astra" } }),
3156 counted(100, 20, 100, 20),
3157 stale,
3158 tier("priority"),
3159 bad,
3160 ].join("\n");
3161 yield* Effect.promise(async () => {
3162 await NodeFSP.mkdir(dir, { recursive: true });
3163 await NodeFSP.writeFile(transcript, content);
3164 });
3165 yield* Effect.gen(function* () {
3166 const verify = (
3167 summary: UsageSummary,
3168 output: number,
3169 cost: number,
3170 malformed: number,
3171 ) => {
3172 assert.strictEqual(totalOutputTokens(summary), output);
3173 assert.strictEqual(
3174 summary.buckets.reduce((sum, bucket) => sum + bucket.costUsd, 0),
3175 cost,
3176 );
3177 const source = summary.sources.find(
3178 (source) => source.fingerprint.provider === "codex",
3179 );
3180 assert.strictEqual(source?.status, malformed === 0 ? "ok" : "partial");
3181 assert.strictEqual(source?.malformedRecords, malformed);
3182 if (malformed > 0) assert.match(source?.message ?? "", /1 malformed or inconsistent/);
3183 else assert.notMatch(source?.message ?? "", /malformed|inconsistent/);
3184 };
3185 const open = vi.spyOn(NodeFSP, "open");
3186 open.mockClear();
3187 yield* Effect.addFinalizer(() => Effect.sync(() => open.mockRestore()));
3188 const first = yield* UsageService.make;
3189 const cold = yield* first.readSummary(WINDOW);
3190 assert.isTrue(open.mock.calls.some(([path]) => path === transcript));
3191 verify(cold, 20, 20, 1);
3192 yield* first.awaitPersisted;
3193 const restarted = yield* UsageService.make;
3194 open.mockClear();
3195 verify(yield* first.readSummary(WINDOW), 20, 20, 1);
3196 verify(yield* restarted.readSummary(WINDOW), 20, 20, 1);
3197 assert.isFalse(open.mock.calls.some(([path]) => path === transcript));
3198 open.mockRestore();
3199
3200 const append = "\n" + counted(10, 2, 140, 30) + "\n";
3201 content += append;
3202 yield* Effect.promise(() => NodeFSP.appendFile(transcript, append));
3203 verify(yield* restarted.readSummary(WINDOW), 22, 24, 1);
3204 yield* restarted.awaitPersisted;
3205 const resumed = yield* UsageService.make;
3206 verify(yield* resumed.readSummary(WINDOW), 22, 24, 1);
3207 const next = tier("ultrafast") + "\n" + counted(10, 2, 150, 32) + "\n";
3208 content += next;
3209 yield* Effect.promise(() => NodeFSP.appendFile(transcript, next));
3210 verify(yield* resumed.readSummary(WINDOW), 24, 36, 1);
3211
3212 const repaired = content.replace(bad, counted(30, 8, 130, 28));
3213 assert.strictEqual(Buffer.byteLength(repaired), Buffer.byteLength(content));
3214 yield* Effect.promise(async () => {
3215 const stat = await NodeFSP.stat(transcript);
3216 await NodeFSP.writeFile(transcript, repaired);
3217 await NodeFSP.utimes(transcript, stat.atime, stat.mtimeMs / 1000 + 1);
3218 });
3219 verify(yield* resumed.readSummary(WINDOW), 32, 52, 0);
3220 }).pipe(
3221 Effect.provide(
3222 layerService({
3223 prefix: "usage-codex-reconciliation",
3224 home,
3225 settings,
3226 ratesDocument: {
3227 "gpt-6-astra": {
3228 input_cost_per_token: 0,
3229 output_cost_per_token: 1,
3230 input_cost_per_token_priority: 0,
3231 output_cost_per_token_priority: 2,
3232 input_cost_per_token_ultrafast: 0,
3233 output_cost_per_token_ultrafast: 6,
3234 },
3235 },
3236 }),
3237 ),
3238 );
3239 }),
3240 );
3241
3242 it.effect(
3243 "merges partial Claude copies through tail replacement, newline completion and restart",
3244 () =>
3245 Effect.gen(function* () {
3246 const { transcript, settings, home } = yield* setup;
3247 const partial = claudeCopy(PARTIAL_USAGE);
3248 const complete = claudeCopy(COMPLETE_USAGE);
3249 yield* Effect.promise(() => NodeFSP.writeFile(transcript, partial));
3250 yield* Effect.gen(function* () {
3251 const first = yield* UsageService.make;
3252 assert.strictEqual(totalOutputTokens(yield* first.readSummary(WINDOW)), 3);
3253 yield* first.awaitPersisted;
3254
3255 yield* Effect.promise(() => NodeFSP.appendFile(transcript, complete.trimEnd()));
3256 const resumed = yield* UsageService.make;
3257 const tail = yield* resumed.readSummary(WINDOW);
3258 assert.deepStrictEqual(tail.buckets[0]?.totals, COMPLETE_TOTALS);
3259 assert.strictEqual(tail.buckets[0]?.records, 1);
3260 assert.closeTo(tail.buckets[0]?.costUsd ?? 0, COMPLETE_COST_USD, 1e-12);
3261 yield* resumed.awaitPersisted;
3262 const restarted = yield* UsageService.make;
3263 assert.deepStrictEqual((yield* restarted.readSummary(WINDOW)).buckets, tail.buckets);
3264
3265 // Grow the file without changing its settled prefix: the old tail must be discarded.
3266 yield* Effect.promise(() =>
3267 NodeFSP.writeFile(transcript, partial + claudeLine(2, 7) + claudeLine(3, 5)),
3268 );
3269 const replaced = yield* restarted.readSummary(WINDOW);
3270 assert.strictEqual(totalOutputTokens(replaced), 3 + 7 + 5);
3271 assert.strictEqual(replaced.buckets[0]?.records, 3);
3272
3273 yield* Effect.promise(() => NodeFSP.appendFile(transcript, complete.trimEnd()));
3274 const grown = yield* restarted.readSummary(WINDOW);
3275 assert.deepStrictEqual(grown.buckets[0]?.totals, {
3276 ...COMPLETE_TOTALS,
3277 uncachedInputTokens: 22,
3278 outputTokens: 264 + 7 + 5,
3279 });
3280 assert.strictEqual(grown.buckets[0]?.records, 3);
3281 yield* Effect.promise(() => NodeFSP.appendFile(transcript, "\n"));
3282 assert.deepStrictEqual((yield* restarted.readSummary(WINDOW)).buckets, grown.buckets);
3283 yield* restarted.awaitPersisted;
3284 assert.deepStrictEqual(
3285 (yield* (yield* UsageService.make).readSummary(WINDOW)).buckets,
3286 grown.buckets,
3287 );
3288 }).pipe(
3289 Effect.provide(
3290 layerService({
3291 prefix: "usage-service-copy-lifecycle-test",
3292 home,
3293 settings,
3294 ratesDocument: COPY_RATES,
3295 }),
3296 ),
3297 );
3298 }),
3299 );
3300
3301 it.effect(
3302 "keeps large-record totals and costs exact through append, dedupe, restart and cleanup",
3303 () =>
3304 Effect.gen(function* () {
3305 const { transcript, settings, home } = yield* setup;
3306 const large = claudeLine(1, 9900).replace(
3307 '"message":',
3308 '"padding":' + encodeUnknownJsonString("x".repeat(9 * 1024 * 1024)) + ',"message":',
3309 );
3310 yield* Effect.promise(() => NodeFSP.writeFile(transcript, large));
3311 yield* Effect.gen(function* () {
3312 const service = yield* UsageService.make;
3313 const first = yield* service.readSummary(WINDOW);
3314 assert.strictEqual(totalOutputTokens(first), 9900);
3315 assert.closeTo(
3316 first.buckets.reduce((sum, bucket) => sum + bucket.costUsd, 0),
3317 0.4951,
3318 1e-12,
3319 );
3320 const warm = yield* service.readSummary(WINDOW);
3321 assert.deepStrictEqual(warm.buckets, first.buckets);
3322 yield* Effect.promise(() => NodeFSP.appendFile(transcript, large + claudeLine(2, 100)));
3323 const appended = yield* service.readSummary(WINDOW);
3324 assert.strictEqual(totalOutputTokens(appended), 10000);
3325 assert.strictEqual(
3326 appended.buckets.reduce((sum, bucket) => sum + bucket.totals.uncachedInputTokens, 0),
3327 20,
3328 );
3329 yield* service.awaitPersisted;
3330 const restarted = yield* UsageService.make;
3331 const restored = yield* restarted.readSummary(WINDOW);
3332 assert.deepStrictEqual(restored.buckets, appended.buckets);
3333 yield* restarted.awaitPersisted;
3334 yield* Effect.promise(() => NodeFSP.rm(transcript));
3335 const afterCleanup = yield* UsageService.make;
3336 assert.deepStrictEqual(
3337 (yield* afterCleanup.readSummary(WINDOW)).buckets,
3338 appended.buckets,
3339 );
3340 }).pipe(
3341 Effect.scoped,
3342 Effect.provide(
3343 layerService({
3344 prefix: "usage-service-large-record-test",
3345 home,
3346 settings,
3347 ratesDocument: {
3348 "claude-fable-5": { input_cost_per_token: 1e-5, output_cost_per_token: 5e-5 },
3349 },
3350 }),
3351 ),
3352 );
3353 }),
3354 );
3355
3356 it.effect.each([4, 5, 6, 7, 8, 10, 11, 12, 13, 14])(
3357 "upgrades a v%s cache: reparses live Codex usage, keeps deleted rollouts, removes the old file",
3358 (version) =>
3359 Effect.gen(function* () {
3360 yield* TestClock.setTime(Date.parse("2026-08-02T12:00:00Z"));
3361 const { home, settings } = yield* setup;
3362 const sessions = NodePath.join(home, "codex", "sessions");
3363 const rollout = (sessionId: string, outputTokens: number) =>
3364 [
3365 { type: "session_meta", payload: { id: sessionId } },
3366 { type: "turn_context", payload: { model: "gpt-6-astra" } },
3367 {
3368 type: "event_msg",
3369 payload: {
3370 type: "thread_settings_applied",
3371 thread_settings: { service_tier: "ultrafast" },
3372 },
3373 },
3374 {
3375 type: "event_msg",
3376 timestamp: "2026-08-01T10:00:00Z",
3377 payload: {
3378 type: "token_count",
3379 info: {
3380 last_token_usage: { input_tokens: 0, output_tokens: outputTokens },
3381 total_token_usage: { input_tokens: 100, output_tokens: outputTokens + 30 },
3382 },
3383 },
3384 },
3385 ]
3386 .map((line) => encodeUnknownJsonString(line))
3387 .join("\n") + "\n";
3388 const live = NodePath.join(sessions, "live.jsonl");
3389 const deleted = NodePath.join(sessions, "deleted.jsonl");
3390 yield* Effect.promise(async () => {
3391 await NodeFSP.mkdir(sessions, { recursive: true });
3392 await NodeFSP.writeFile(live, rollout("live", 10));
3393 await NodeFSP.writeFile(deleted, rollout("deleted", 20));
3394 });
3395
3396 yield* Effect.gen(function* () {
3397 const { stateDir } = yield* ServerConfig.ServerConfig;
3398 const cachePath = NodePath.join(stateDir, SCAN_CACHE_FILE_NAME);
3399 const legacyPath = NodePath.join(
3400 stateDir,
3401 version === 4 ? "usage-scan-cache.json" : `usage-scan-cache-v${version}.json`,
3402 );
3403 const first = yield* UsageService.make;
3404 yield* first.readSummary(WINDOW);
3405 yield* first.awaitPersisted;
3406
3407 yield* Effect.promise(async () => {
3408 const livePath = await NodeFSP.realpath(live);
3409 const document = decodeUnknownJsonString(await NodeFSP.readFile(cachePath, "utf8")) as {
3410 files: Record<string, { r: unknown[][]; mr: number; cs: Record<string, unknown> }>;
3411 };
3412 for (const [path, file] of Object.entries(document.files)) {
3413 file.r = file.r.map((row) => [
3414 ...row.slice(0, 6),
3415 path === livePath ? 99 : row[6],
3416 ...row.slice(7, 10),
3417 version === 4 ? 0 : 1,
3418 ]);
3419 if (version === 4) delete file.cs.speed;
3420 if (version < 6) {
3421 delete file.cs.lastCumulativeUsage;
3422 delete file.cs.malformedRecords;
3423 }
3424 if (version >= 8 && path === livePath) {
3425 file.r = [];
3426 file.mr = 1;
3427 file.cs.malformedRecords = 1;
3428 }
3429 }
3430 const text = encodeUnknownJsonString({ ...document, version });
3431 await NodeFSP.rm(cachePath);
3432 await NodeFSP.writeFile(legacyPath, text);
3433 if (version === 6) {
3434 for (const [name, olderVersion] of [
3435 ["usage-scan-cache-v5.json", 5],
3436 ["usage-scan-cache.json", 4],
3437 ] as const) {
3438 await NodeFSP.writeFile(
3439 NodePath.join(stateDir, name),
3440 encodeUnknownJsonString({ ...document, version: olderVersion, files: {} }),
3441 );
3442 }
3443 }
3444 await NodeFSP.rm(deleted);
3445 await NodeFSP.mkdir(`${cachePath}.stale`);
3446 await NodeFSP.utimes(`${cachePath}.stale`, 0, 0);
3447 await NodeFSP.mkdir(`${cachePath}.active`);
3448 });
3449
3450 const upgraded = yield* UsageService.make;
3451 const summary = yield* upgraded.readSummary(WINDOW);
3452 assert.strictEqual(totalOutputTokens(summary), 30);
3453 assert.strictEqual(
3454 summary.buckets.reduce((sum, bucket) => sum + bucket.costUsd, 0),
3455 60 + 20 * (version === 4 ? 1 : 2),
3456 );
3457 yield* upgraded.awaitPersisted;
3458 assert.strictEqual(SCAN_CACHE_FILE_NAME, "usage-scan-cache-v17.json");
3459 assert.deepStrictEqual(
3460 (yield* Effect.promise(() => NodeFSP.readdir(stateDir)))
3461 .filter((name) => name.startsWith("usage-scan-cache"))
3462 .toSorted(),
3463 [SCAN_CACHE_FILE_NAME, `${SCAN_CACHE_FILE_NAME}.active`],
3464 );
3465 }).pipe(
3466 Effect.provide(
3467 layerService({
3468 prefix: "usage-service-cache-upgrade-test",
3469 home,
3470 settings,
3471 ratesDocument: {
3472 "gpt-6-astra": {
3473 input_cost_per_token: 0,
3474 output_cost_per_token: 1,
3475 input_cost_per_token_priority: 0,
3476 output_cost_per_token_priority: 2,
3477 input_cost_per_token_ultrafast: 0,
3478 output_cost_per_token_ultrafast: 6,
3479 },
3480 },
3481 }),
3482 ),
3483 );
3484 }),
3485 );
3486
3487 it.effect("re-parses a clean v10 Codex rollout that grew after an interrupted request", () =>
3488 Effect.gen(function* () {
3489 const { home, settings } = yield* setup;
3490 const sessions = NodePath.join(home, "codex", "sessions");
3491 const live = NodePath.join(sessions, "live.jsonl");
3492 const usage = (input: number, output: number) => ({
3493 input_tokens: input,
3494 output_tokens: output,
3495 total_tokens: input + output,
3496 });
3497 const lines = (values: readonly unknown[]) =>
3498 values.map((value) => `${encodeUnknownJsonString(value)}\n`).join("");
3499 const request = (second: number, last: unknown) => ({
3500 type: "token_usage_record",
3501 timestamp: `2026-08-01T10:00:0${second}Z`,
3502 payload: { usage: last },
3503 });
3504 const tokenCount = (second: number, last: unknown, total: unknown) => ({
3505 type: "event_msg",
3506 timestamp: `2026-08-01T10:00:0${second}Z`,
3507 payload: {
3508 type: "token_count",
3509 info: { last_token_usage: last, total_token_usage: total },
3510 },
3511 });
3512 yield* Effect.promise(async () => {
3513 await NodeFSP.mkdir(sessions, { recursive: true });
3514 await NodeFSP.writeFile(
3515 live,
3516 lines([
3517 { type: "session_meta", payload: { id: "live" } },
3518 { type: "turn_context", payload: { turn_id: "turn-1", model: "gpt-6-astra" } },
3519 request(1, usage(100, 20)),
3520 tokenCount(1, usage(100, 20), usage(100, 20)),
3521 // Interrupted after this request finished: no token_count reports it.
3522 request(2, usage(150, 10)),
3523 ]),
3524 );
3525 });
3526
3527 yield* Effect.gen(function* () {
3528 const { stateDir } = yield* ServerConfig.ServerConfig;
3529 const tokens = (summary: UsageSummary) =>
3530 summary.buckets.reduce((sum, bucket) => sum + totalTokens(bucket.totals), 0);
3531 const first = yield* UsageService.make;
3532 assert.strictEqual(tokens(yield* first.readSummary(WINDOW)), 120);
3533 yield* first.awaitPersisted;
3534
3535 yield* Effect.promise(async () => {
3536 const cachePath = NodePath.join(stateDir, SCAN_CACHE_FILE_NAME);
3537 const document = decodeUnknownJsonString(await NodeFSP.readFile(cachePath, "utf8")) as {
3538 files: Record<string, { cs: Record<string, unknown> }>;
3539 };
3540 // The v10 parser ignored `token_usage_record`, so its clean state held nothing pending.
3541 for (const file of Object.values(document.files)) {
3542 file.cs = Object.fromEntries(
3543 Object.entries(file.cs).filter(([key]) => !key.startsWith("unreported")),
3544 );
3545 }
3546 await NodeFSP.rm(cachePath);
3547 await NodeFSP.writeFile(
3548 NodePath.join(stateDir, "usage-scan-cache-v10.json"),
3549 encodeUnknownJsonString({ ...document, version: 10 }),
3550 );
3551 await NodeFSP.appendFile(
3552 live,
3553 lines([
3554 { type: "turn_context", payload: { turn_id: "turn-2", model: "gpt-6-astra" } },
3555 request(5, usage(200, 30)),
3556 tokenCount(5, usage(200, 30), usage(450, 60)),
3557 ]),
3558 );
3559 });
3560
3561 const upgraded = yield* UsageService.make;
3562 const summary = yield* upgraded.readSummary(WINDOW);
3563 assert.deepStrictEqual(
3564 {
3565 tokens: tokens(summary),
3566 malformedRecords: summary.sources.find(
3567 (source) => source.fingerprint.provider === "codex",
3568 )?.malformedRecords,
3569 },
3570 { tokens: 510, malformedRecords: 0 },
3571 );
3572 }).pipe(
3573 Effect.provide(
3574 layerService({
3575 prefix: "usage-service-cache-v10-interrupted-test",
3576 home,
3577 settings,
3578 ratesDocument: {
3579 "gpt-6-astra": { input_cost_per_token: 0, output_cost_per_token: 1 },
3580 },
3581 }),
3582 ),
3583 );
3584 }),
3585 );
3586
3587 it.effect("preserves saved tokens, costs and sessions after transcript cleanup and restart", () =>
3588 Effect.gen(function* () {
3589 const { transcript, settings, home } = yield* setup;
3590 const alias = NodePath.join(home, "claude-alias");
3591 yield* Effect.promise(() =>
3592 NodeFSP.symlink(NodePath.join(home, "claude"), alias, "junction"),
3593 );
3594 const content = claudeLine(1, 5);
3595 yield* Effect.promise(() => NodeFSP.writeFile(transcript, content));
3596 yield* Effect.gen(function* () {
3597 const service = yield* UsageService.make;
3598 const first = yield* service.readSummary(WINDOW);
3599 assert.strictEqual(totalOutputTokens(first), 5);
3600 assert.isAbove(first.buckets[0]?.costUsd ?? 0, 0);
3601
3602 yield* Effect.promise(() => NodeFSP.rm(transcript));
3603 const deleted = yield* service.readSummary(WINDOW);
3604 assert.deepStrictEqual(deleted.buckets, first.buckets);
3605 assert.deepStrictEqual(deleted.sources, first.sources);
3606
3607 yield* service.awaitPersisted;
3608 const restarted = yield* UsageService.make;
3609 const restored = yield* restarted.readSummary(WINDOW);
3610 assert.deepStrictEqual(restored.buckets, first.buckets);
3611 assert.deepStrictEqual(restored.sources, first.sources);
3612
3613 yield* Effect.promise(() => NodeFSP.writeFile(transcript + ".jsonl", content));
3614 const moved = yield* restarted.readSummary(WINDOW);
3615 assert.deepStrictEqual(moved.buckets, first.buckets);
3616 assert.strictEqual(moved.sources[0]?.distinctSessions, 1);
3617 yield* restarted.awaitPersisted;
3618
3619 const replacementProjects = NodePath.join(home, "replacement-projects");
3620 yield* Effect.promise(() => NodeFSP.mkdir(replacementProjects));
3621 yield* Effect.promise(() =>
3622 NodeFSP.rm(NodePath.join(home, "claude", "projects"), { recursive: true }),
3623 );
3624 const afterRootCleanup = yield* UsageService.make;
3625 const missingRoot = yield* afterRootCleanup.readSummary(WINDOW);
3626 assert.deepStrictEqual(missingRoot.buckets, first.buckets);
3627 assert.strictEqual(missingRoot.sources[0]?.distinctSessions, 1);
3628 assert.strictEqual(missingRoot.sources[0]?.status, "ok");
3629 assert.deepStrictEqual(missingRoot.sources[0]?.fingerprint, first.sources[0]?.fingerprint);
3630 yield* Effect.promise(async () => {
3631 const projects = NodePath.join(home, "claude", "projects");
3632 await NodeFSP.rename(replacementProjects, projects);
3633 await NodeFSP.writeFile(NodePath.join(projects, "new.jsonl"), claudeLine(2, 7));
3634 });
3635 const recreated = yield* afterRootCleanup.readSummary(WINDOW);
3636 assert.strictEqual(totalOutputTokens(recreated), 12);
3637 assert.deepStrictEqual(recreated.sources[0]?.fingerprint, first.sources[0]?.fingerprint);
3638
3639 const merged = mergeUsage(
3640 [
3641 {
3642 environmentId: EnvironmentId.make("cleanup-test"),
3643 label: "test",
3644 summary: recreated,
3645 },
3646 {
3647 environmentId: EnvironmentId.make("other-environment"),
3648 label: "before cleanup",
3649 summary: first,
3650 },
3651 ],
3652 missingRoot.contractVersion,
3653 );
3654 assert.strictEqual(merged.outputTokens, 12);
3655 assert.strictEqual(merged.sessions, 1);
3656 assert.strictEqual(merged.costUsd, recreated.buckets[0]?.costUsd);
3657
3658 const outsideWindow = yield* restarted.readSummary({
3659 ...WINDOW,
3660 sinceDay: UsageDay.make("2026-08-02"),
3661 });
3662 assert.deepStrictEqual(outsideWindow.buckets, []);
3663 assert.strictEqual(outsideWindow.sources[0]?.distinctSessions, 0);
3664 }).pipe(
3665 Effect.scoped,
3666 Effect.provide(
3667 layerService({
3668 prefix: "usage-service-cleanup-test",
3669 home,
3670 settings: {
3671 providerInstances: {
3672 ...settings.providerInstances,
3673 [ProviderInstanceId.make("claudeAgent")]: {
3674 driver: ProviderDriverKind.make("claudeAgent"),
3675 config: { homePath: alias },
3676 },
3677 },
3678 },
3679 ratesDocument: {
3680 "claude-fable-5": { input_cost_per_token: 1e-5, output_cost_per_token: 5e-5 },
3681 },
3682 }),
3683 ),
3684 );
3685 }),
3686 );
3687
3688 it.effect.each([
3689 { label: "the default 92 days", retention: undefined, expected: 1 },
3690 { label: "unlimited", retention: "unlimited" as const, expected: 15 },
3691 ])(
3692 "retains deleted transcripts according to $label across restart and settings changes",
3693 ({ retention, expected }) =>
3694 Effect.gen(function* () {
3695 const { transcript, settings, home } = yield* setup;
3696 const now = Date.parse("2026-08-02T12:00:00Z");
3697 yield* TestClock.setTime(now);
3698 const window = { ...WINDOW, sinceDay: UsageDay.make("2024-01-01") };
3699 const files = [92, 93, 180, 730].map((days, index) => ({
3700 path: `${transcript}-${index}.jsonl`,
3701 timestamp: now - days * 86400000,
3702 content: claudeLine(index, 2 ** index).replace(
3703 "2026-08-01T10:00:00Z",
3704 DateTime.formatIso(DateTime.makeUnsafe(now - days * 86400000)),
3705 ),
3706 }));
3707 yield* Effect.promise(async () => {
3708 for (const file of files) {
3709 await NodeFSP.writeFile(file.path, file.content);
3710 await NodeFSP.utimes(file.path, file.timestamp / 1000, file.timestamp / 1000);
3711 }
3712 });
3713 yield* Effect.gen(function* () {
3714 const service = yield* UsageService.make;
3715 const first = yield* service.readSummary(window);
3716 assert.strictEqual(totalOutputTokens(first), 15);
3717 yield* service.awaitPersisted;
3718 yield* Effect.promise(() => Promise.all(files.map((file) => NodeFSP.rm(file.path))));
3719 const restarted = yield* UsageService.make;
3720 const saved = yield* restarted.readSummary(window);
3721 assert.strictEqual(totalOutputTokens(saved), expected);
3722 assert.deepStrictEqual(saved.sources[0]?.fingerprint, first.sources[0]?.fingerprint);
3723 const narrow = yield* restarted.readSummary(WINDOW);
3724 assert.strictEqual(totalOutputTokens(narrow), 0);
3725 assert.strictEqual(narrow.sources[0]?.distinctSessions, 0);
3726
3727 const config = yield* ServerSettings.ServerSettingsService;
3728 yield* config.updateSettings({ usageHistoryRetentionDays: 1 });
3729 assert.strictEqual(totalOutputTokens(yield* restarted.readSummary(window)), 0);
3730 yield* restarted.awaitPersisted;
3731 yield* config.updateSettings({ usageHistoryRetentionDays: "unlimited" });
3732 const afterPruning = yield* UsageService.make;
3733 assert.strictEqual(totalOutputTokens(yield* afterPruning.readSummary(window)), 0);
3734 }).pipe(
3735 Effect.provide(
3736 layerService({
3737 prefix: "usage-service-retention",
3738 home,
3739 settings: {
3740 ...settings,
3741 ...(retention === undefined ? {} : { usageHistoryRetentionDays: retention }),
3742 },
3743 }),
3744 ),
3745 );
3746 }),
3747 );
3748
3749 it.effect("keeps retained history when an obsolete scan finishes after retention widens", () =>
3750 Effect.gen(function* () {
3751 const { transcript, settings, home } = yield* setup;
3752 yield* TestClock.setTime(CURSOR_NOW);
3753 const timestamp = CURSOR_NOW - 180 * 24 * HOUR_MS;
3754 yield* Effect.promise(async () => {
3755 await NodeFSP.writeFile(
3756 transcript,
3757 claudeLine(1, 11).replace(
3758 "2026-08-01T10:00:00Z",
3759 DateTime.formatIso(DateTime.makeUnsafe(timestamp)),
3760 ),
3761 );
3762 await NodeFSP.utimes(transcript, timestamp / 1000, timestamp / 1000);
3763 });
3764 const started = yield* Deferred.make<void>();
3765 const release = yield* Deferred.make<void>();
3766 let scans = 0;
3767 yield* Effect.gen(function* () {
3768 const config = yield* ServerSettings.ServerSettingsService;
3769 const service = yield* UsageService.make.pipe(
3770 Effect.provideService(CursorUsageAccounts.CursorUsageAccounts, {
3771 scan: () =>
3772 Effect.gen(function* () {
3773 if (++scans === 1) {
3774 yield* Deferred.succeed(started, undefined);
3775 yield* Deferred.await(release);
3776 }
3777 return [];
3778 }),
3779 awaitPersisted: Effect.void,
3780 }),
3781 );
3782 const window = { ...WINDOW, sinceDay: UsageDay.make("2024-01-01") };
3783 const oldScan = yield* service.readSummary(window).pipe(Effect.forkChild);
3784 yield* Deferred.await(started);
3785 yield* config.updateSettings({ usageHistoryRetentionDays: "unlimited" });
3786 assert.strictEqual(totalOutputTokens(yield* service.readSummary(window)), 11);
3787 yield* service.awaitPersisted;
3788 yield* Effect.promise(() => NodeFSP.rm(transcript));
3789 yield* Deferred.succeed(release, undefined);
3790 yield* Fiber.join(oldScan);
3791 yield* service.awaitPersisted;
3792 const restarted = yield* UsageService.make;
3793 assert.strictEqual(totalOutputTokens(yield* restarted.readSummary(window)), 11);
3794 }).pipe(Effect.provide(layerService({ prefix: "usage-retention-race", home, settings })));
3795 }),
3796 );
3797
3798 it.effect("credits the same copy of a duplicate after its transcripts are deleted", () =>
3799 Effect.gen(function* () {
3800 const { transcript, settings, home } = yield* setup;
3801 const dir = NodePath.dirname(transcript);
3802 const [first = "", second = ""] = yield* Effect.promise(async () => {
3803 await NodeFSP.writeFile(NodePath.join(dir, "a.jsonl"), "");
3804 await NodeFSP.writeFile(NodePath.join(dir, "b.jsonl"), "");
3805 return (await NodeFSP.readdir(dir)).map((name) => NodePath.join(dir, name));
3806 });
3807 const forked = (line: string) => line.replace('"session-1"', '"session-2"');
3808 yield* Effect.promise(async () => {
3809 await NodeFSP.writeFile(
3810 first,
3811 claudeLine(1, 5).replace(
3812 '"message":',
3813 '"padding":' + encodeUnknownJsonString("x".repeat(9 * 1024 * 1024)) + ',"message":',
3814 ),
3815 );
3816 await NodeFSP.writeFile(second, forked(claudeLine(1, 5)) + forked(claudeLine(2, 7)));
3817 });
3818 yield* Effect.gen(function* () {
3819 const service = yield* UsageService.make;
3820 const live = yield* service.readSummary(WINDOW);
3821 assert.strictEqual(live.buckets[0]?.sessions, 2);
3822
3823 yield* Effect.promise(() => Promise.all([NodeFSP.rm(first), NodeFSP.rm(second)]));
3824 const saved = yield* service.readSummary(WINDOW);
3825 assert.deepStrictEqual(saved.buckets, live.buckets);
3826 assert.deepStrictEqual(saved.sources, live.sources);
3827 yield* service.awaitPersisted;
3828 const restored = yield* (yield* UsageService.make).readSummary(WINDOW);
3829 assert.deepStrictEqual(restored.buckets, live.buckets);
3830 }).pipe(
3831 Effect.provide(layerService({ prefix: "usage-service-copy-order-test", home, settings })),
3832 );
3833 }),
3834 );
3835
3836 it.effect("credits the same copy of a duplicate from the last scan as an exact read does", () =>
3837 Effect.gen(function* () {
3838 yield* TestClock.setTime(Date.parse("2026-08-15T00:00:00Z"));
3839 const { transcript, settings, home } = yield* setup;
3840 const dir = NodePath.dirname(transcript);
3841 const [first = "", second = ""] = yield* Effect.promise(async () => {
3842 await NodeFSP.writeFile(NodePath.join(dir, "a.jsonl"), "");
3843 await NodeFSP.writeFile(NodePath.join(dir, "b.jsonl"), "");
3844 return (await NodeFSP.readdir(dir)).map((name) => NodePath.join(dir, name));
3845 });
3846 const forked = (line: string) => line.replace('"session-1"', '"session-2"');
3847 yield* Effect.promise(async () => {
3848 await NodeFSP.writeFile(first, claudeLine(1, 5));
3849 await NodeFSP.utimes(first, BEFORE_NARROW_WINDOW, BEFORE_NARROW_WINDOW);
3850 await NodeFSP.writeFile(second, forked(claudeLine(1, 5)) + forked(claudeLine(2, 7)));
3851 });
3852 yield* Effect.gen(function* () {
3853 const service = yield* UsageService.make;
3854 // The narrow window saves the second copy before the wide one reads the first.
3855 yield* service.readSummary(NARROW_WINDOW);
3856 const exact = yield* service.readSummary(WINDOW);
3857 yield* service.awaitPersisted;
3858 const restarted = yield* UsageService.make;
3859 const saved = yield* restarted.readSummary({ ...WINDOW, provisional: true });
3860 assert.isTrue(saved.sources.some((source) => source.refreshing === true));
3861 assert.deepStrictEqual(saved.buckets, exact.buckets);
3862 }).pipe(
3863 Effect.provide(layerService({ prefix: "usage-service-saved-order-test", home, settings })),
3864 );
3865
3866 // A narrow scan that first saves the earlier copy still puts it before a later file it skipped.
3867 yield* Effect.promise(async () => {
3868 await NodeFSP.writeFile(first, forked(claudeLine(1, 5)) + forked(claudeLine(2, 7)));
3869 await NodeFSP.utimes(
3870 first,
3871 Date.parse("2026-07-01T00:00:00Z") / 1000,
3872 Date.parse("2026-07-01T00:00:00Z") / 1000,
3873 );
3874 await NodeFSP.writeFile(second, claudeLine(1, 5));
3875 await NodeFSP.utimes(second, BEFORE_NARROW_WINDOW, BEFORE_NARROW_WINDOW);
3876 });
3877 yield* Effect.gen(function* () {
3878 const service = yield* UsageService.make;
3879 yield* service.readSummary(WINDOW);
3880 yield* Effect.promise(() =>
3881 NodeFSP.utimes(first, NARROW_WINDOW_MTIME, NARROW_WINDOW_MTIME),
3882 );
3883 yield* service.readSummary(NARROW_WINDOW);
3884 const saved = yield* service.readSummary({ ...WINDOW, provisional: true });
3885 assert.isTrue(saved.sources.some((source) => source.refreshing === true));
3886 const exact = yield* service.readSummary(WINDOW);
3887 assert.deepStrictEqual(saved.buckets, exact.buckets);
3888 }).pipe(
3889 Effect.provide(layerService({ prefix: "usage-service-narrow-order-test", home, settings })),
3890 );
3891 }),
3892 );
3893
3894 it.effect.skipIf(HostProcess.Platform.defaultValue() === "win32")(
3895 "keeps a newer cached read when a slower scan of another window finishes later",
3896 () =>
3897 Effect.gen(function* () {
3898 const { transcript, settings, home } = yield* setup;
3899 const dir = NodePath.dirname(transcript);
3900 const probe = NodePath.join(dir, "probe.jsonl");
3901 const hold = NodePath.join(dir, "hold.jsonl");
3902 yield* Effect.promise(() => NodeFSP.writeFile(transcript, claudeLine(1, 5)));
3903 yield* makeGate(probe, BEFORE_NARROW_WINDOW);
3904 yield* makeGate(hold, BEFORE_NARROW_WINDOW);
3905 yield* Effect.gen(function* () {
3906 const service = yield* UsageService.make;
3907 const wide = yield* service.readSummary(WINDOW).pipe(Effect.forkChild);
3908 yield* openGate(probe);
3909 yield* replaceFile(transcript, claudeLine(1, 5) + claudeLine(2, 7));
3910 yield* service.readSummary(NARROW_WINDOW);
3911 yield* openGate(hold);
3912 yield* Fiber.join(wide);
3913
3914 yield* Effect.promise(() =>
3915 Promise.all([transcript, probe, hold].map((path) => NodeFSP.rm(path))),
3916 );
3917 assert.strictEqual(totalOutputTokens(yield* service.readSummary(WINDOW)), 12);
3918 }).pipe(
3919 Effect.provide(layerService({ prefix: "usage-service-stale-read-test", home, settings })),
3920 );
3921 }),
3922 );
3923
3924 it.effect(
3925 "keeps an absent directory missing when its cached files only contain diagnostics",
3926 () =>
3927 Effect.gen(function* () {
3928 yield* TestClock.setTime(Date.parse("2026-08-02T12:00:00Z"));
3929 const { transcript, settings, home } = yield* setup;
3930 yield* Effect.promise(() =>
3931 NodeFSP.rm(NodePath.join(home, "claude", "projects"), { recursive: true }),
3932 );
3933 yield* Effect.gen(function* () {
3934 const { stateDir } = yield* ServerConfig.ServerConfig;
3935 const mtimeMs = yield* Clock.currentTimeMillis;
3936 const cache = makeScanCacheWriter()(
3937 new Map([
3938 [
3939 transcript,
3940 {
3941 size: 0,
3942 mtimeMs,
3943 provider: "claude" as const,
3944 records: [],
3945 tailRecords: [],
3946 malformedRecords: 2,
3947 position: { resumeOffset: 0, guardLength: 0, guardHash: 0, state: null },
3948 },
3949 ],
3950 ]),
3951 {},
3952 );
3953 yield* Effect.promise(async () => {
3954 await NodeFSP.mkdir(stateDir, { recursive: true });
3955 await NodeFSP.writeFile(NodePath.join(stateDir, SCAN_CACHE_FILE_NAME), cache);
3956 });
3957 const summary = yield* (yield* UsageService.make).readSummary(WINDOW);
3958 const source = summary.sources.find((source) => source.fingerprint.provider === "claude");
3959 assert.strictEqual(source?.status, "missing");
3960 assert.strictEqual(source?.scannedFiles, 0);
3961 assert.strictEqual(source?.malformedRecords, 2);
3962 }).pipe(
3963 Effect.provide(
3964 layerService({ prefix: "usage-service-missing-diagnostics", home, settings }),
3965 ),
3966 );
3967 }),
3968 );
3969
3970 it.effect("reports saved usage of a removed directory only for windows it reaches", () =>
3971 Effect.gen(function* () {
3972 yield* TestClock.setTime(Date.parse("2026-08-12T00:00:00Z"));
3973 const { transcript, settings, home } = yield* setup;
3974 // Saved usage is pruned after the retention window, so pin "now" near the write.
3975 yield* TestClock.setTime(Date.parse("2026-08-15T00:00:00Z"));
3976 yield* Effect.promise(async () => {
3977 await NodeFSP.writeFile(transcript, claudeLine(1, 5));
3978 const lastWrite = Date.parse("2026-08-01T10:00:00Z") / 1000;
3979 await NodeFSP.utimes(transcript, lastWrite, lastWrite);
3980 });
3981 const service = yield* UsageService.make.pipe(
3982 Effect.provide(layerService({ prefix: "usage-service-saved-window-test", home, settings })),
3983 );
3984 const first = yield* service.readSummary(WINDOW);
3985 yield* Effect.promise(() =>
3986 NodeFSP.rm(NodePath.join(home, "claude", "projects"), { recursive: true }),
3987 );
3988
3989 const reached = yield* service.readSummary(WINDOW);
3990 assert.deepStrictEqual(reached.buckets, first.buckets);
3991 assert.strictEqual(reached.sources[0]?.status, "ok");
3992
3993 const later = yield* service.readSummary({
3994 timeZone: "UTC",
3995 sinceDay: UsageDay.make("2026-08-10"),
3996 untilDay: UsageDay.make("2026-08-12"),
3997 });
3998 assert.deepStrictEqual(later.buckets, []);
3999 assert.strictEqual(later.sources[0]?.status, "missing");
4000 assert.strictEqual(later.sources[0]?.scannedFiles, 0);
4001 }),
4002 );
4003
4004 it.effect("does not share an in-flight scan after custom prices change", () =>
4005 Effect.gen(function* () {
4006 const { transcript, settings, home } = yield* setup;
4007 yield* Effect.promise(() => NodeFSP.writeFile(transcript, claudeLine(1, 5, "example-model")));
4008 const transcriptDir = yield* Effect.promise(() =>
4009 NodeFSP.realpath(NodePath.join(home, "claude", "projects")),
4010 );
4011
4012 yield* Effect.gen(function* () {
4013 const settingsService = yield* ServerSettings.ServerSettingsService;
4014 const fileSystem = yield* FileSystem.FileSystem;
4015 const firstScanStarted = yield* Deferred.make<void>();
4016 const secondScanStarted = yield* Deferred.make<void>();
4017 const releaseRates = yield* Deferred.make<void>();
4018 let homeProbes = 0;
4019 const service = yield* UsageService.make.pipe(
4020 Effect.provideService(FileSystem.FileSystem, {
4021 ...fileSystem,
4022 exists: (path) =>
4023 fileSystem.exists(path).pipe(
4024 Effect.tap(() => {
4025 if (path !== transcriptDir) return Effect.void;
4026 homeProbes += 1;
4027 return Deferred.succeed(
4028 homeProbes === 1 ? firstScanStarted : secondScanStarted,
4029 undefined,
4030 );
4031 }),
4032 ),
4033 }),
4034 Effect.provideService(
4035 HttpClient.HttpClient,
4036 HttpClient.make((request) =>
4037 Deferred.await(releaseRates).pipe(
4038 Effect.as(
4039 HttpClientResponse.fromWeb(
4040 request,
4041 Response.json({
4042 "example-model": { input_cost_per_token: 1e-6, output_cost_per_token: 1e-5 },
4043 }),
4044 ),
4045 ),
4046 ),
4047 ),
4048 ),
4049 );
4050
4051 const first = yield* service.readSummary(WINDOW).pipe(Effect.forkChild);
4052 yield* Deferred.await(firstScanStarted);
4053 yield* settingsService.updateSettings({
4054 usagePriceOverrides: {
4055 "example-model": { inputCostPerMillionTokens: 2, outputCostPerMillionTokens: 8 },
4056 },
4057 });
4058 const second = yield* service.readSummary(WINDOW).pipe(Effect.forkChild);
4059 yield* Deferred.await(secondScanStarted);
4060 yield* Deferred.succeed(releaseRates, undefined);
4061
4062 const original = yield* Fiber.join(first);
4063 const updated = yield* Fiber.join(second);
4064 // Fetched rates price the first read, so scans must start while the fetch is pending.
4065 assert.isAbove(original.buckets[0]?.costUsd ?? 0, 0);
4066 assert.closeTo(updated.buckets[0]?.costUsd ?? -1, 0.00006, 1e-12);
4067 }).pipe(
4068 Effect.provide(layerService({ prefix: "usage-service-price-race-test", home, settings })),
4069 );
4070 }),
4071 );
4072
4073 it.effect.each(["network", "http", "invalidJson", "empty"] as const)(
4074 "recovers pricing through the GitHub API after a %s failure",
4075 (failure) =>
4076 Effect.gen(function* () {
4077 const { transcript, settings, home } = yield* setup;
4078 yield* Effect.promise(() => NodeFSP.writeFile(transcript, claudeLine(1, 5)));
4079 const requests: HttpClientRequest.HttpClientRequest[] = [];
4080 const ratesDocument = {
4081 "claude-fable-5": { input_cost_per_token: 1e-5, output_cost_per_token: 5e-5 },
4082 };
4083 const serviceLayer = layerService({
4084 prefix: `usage-service-rates-fallback-${failure}-test`,
4085 home,
4086 settings,
4087 onRatesFetch: (request) => requests.push(request),
4088 ratesResponse: (request) => {
4089 if (request.url.startsWith("https://api.github.com/")) {
4090 return Effect.succeed(Response.json(ratesDocument));
4091 }
4092 if (failure === "network") {
4093 return Effect.fail(
4094 new HttpClientError.HttpClientError({
4095 reason: new HttpClientError.TransportError({
4096 request,
4097 cause: new Error("getaddrinfo ENOTFOUND raw.githubusercontent.com"),
4098 }),
4099 }),
4100 );
4101 }
4102 return Effect.succeed(
4103 failure === "invalidJson"
4104 ? new Response("not JSON")
4105 : Response.json({}, { status: failure === "http" ? 503 : 200 }),
4106 );
4107 },
4108 });
4109 const service = yield* UsageService.make.pipe(Effect.provide(serviceLayer));
4110
4111 const summary = yield* service.readSummary(WINDOW);
4112 assert.strictEqual(summary.pricing.status, "fresh");
4113 assert.strictEqual(summary.pricing.knownModels, 1);
4114 assert.closeTo(summary.buckets[0]?.costUsd ?? -1, 0.00035, 1e-12);
4115 assert.deepStrictEqual(
4116 requests.map((request) => request.url),
4117 [
4118 "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json",
4119 "https://api.github.com/repos/BerriAI/litellm/contents/model_prices_and_context_window.json?ref=main",
4120 ],
4121 );
4122 assert.strictEqual(requests[1]?.headers.accept, "application/vnd.github.raw+json");
4123
4124 const restarted = yield* UsageService.make.pipe(Effect.provide(serviceLayer));
4125 const cached = yield* restarted.readSummary(WINDOW);
4126 assert.strictEqual(cached.pricing.status, "cached");
4127 assert.deepStrictEqual(cached.buckets, summary.buckets);
4128 assert.strictEqual(requests.length, 2);
4129 }),
4130 );
4131
4132 it.effect("refetches cached rates early for a model they do not list", () =>
4133 Effect.gen(function* () {
4134 yield* TestClock.setTime(Date.parse("2026-08-02T00:00:00Z"));
4135 const { transcript, settings, home } = yield* setup;
4136 yield* Effect.promise(() =>
4137 NodeFSP.writeFile(
4138 transcript,
4139 claudeLine(1, 5, "claude-new-model") + claudeLine(2, 5, "claude-unknown-model"),
4140 ),
4141 );
4142 const requests: string[] = [];
4143 let ratesDocument: Record<string, unknown> = {
4144 "claude-fable-5": { input_cost_per_token: 1e-5, output_cost_per_token: 5e-5 },
4145 };
4146 const serviceLayer = layerService({
4147 prefix: "usage-service-unlisted-model-test",
4148 home,
4149 settings,
4150 onRatesFetch: (request) => requests.push(request.url),
4151 ratesResponse: () => Effect.succeed(Response.json(ratesDocument)),
4152 });
4153 const newModelCost = (summary: UsageSummary) =>
4154 summary.buckets.find((bucket) => bucket.model === "claude-new-model")?.costUsd;
4155
4156 // Rates fetched for this scan are fresh: no second request for the models they lack.
4157 const first = yield* (yield* UsageService.make.pipe(
4158 Effect.provide(serviceLayer),
4159 )).readSummary(WINDOW);
4160 assert.strictEqual(newModelCost(first), 0);
4161 assert.strictEqual(requests.length, 1);
4162
4163 // An hour later LiteLLM lists the new model; a restarted server starts from the cached table.
4164 ratesDocument = {
4165 ...ratesDocument,
4166 "claude-new-model": { input_cost_per_token: 2e-5, output_cost_per_token: 1e-4 },
4167 };
4168 yield* TestClock.adjust(Duration.hours(1));
4169 const service = yield* UsageService.make.pipe(Effect.provide(serviceLayer));
4170 const refreshed = yield* service.readSummary(WINDOW);
4171 assert.strictEqual(refreshed.pricing.status, "fresh");
4172 assert.closeTo(newModelCost(refreshed) ?? -1, 10 * 2e-5 + 5 * 1e-4, 1e-12);
4173 assert.strictEqual(requests.length, 2);
4174
4175 // A model the fresh table still lacks does not refetch again before the TTL.
4176 yield* TestClock.adjust(Duration.hours(1));
4177 yield* service.readSummary(WINDOW);
4178 assert.strictEqual(requests.length, 2);
4179 }),
4180 );
4181
4182 it.effect("does not orphan an in-flight scan when its first caller is interrupted", () =>
4183 Effect.gen(function* () {
4184 const { settings, home } = yield* setup;
4185 const service = yield* UsageService.make.pipe(
4186 Effect.provide(layerService({ prefix: "usage-service-interruption-test", home, settings })),
4187 );
4188
4189 let orphanedAt: number | undefined;
4190 // oxlint-disable-next-line t3code/no-polling-loop-in-tests -- Fixed-count scheduler interruption matrix; each iteration exercises a different interruption point.
4191 for (let interruptAt = 1; interruptAt <= 31; interruptAt += 1) {
4192 const tasks: Array<() => void> = [];
4193 const dispatcher: Scheduler.SchedulerDispatcher = {
4194 scheduleTask: (task) => tasks.push(task),
4195 flush: () => {
4196 let task: (() => void) | undefined;
4197 while ((task = tasks.shift()) !== undefined) task();
4198 },
4199 };
4200
4201 let requestFiber: Fiber.Fiber<unknown, unknown> | undefined;
4202 let requestChecks = 0;
4203 const scheduler: Scheduler.Scheduler = {
4204 executionMode: "async",
4205 makeDispatcher: () => dispatcher,
4206 shouldYield: (fiber) => {
4207 if (fiber !== requestFiber) return false;
4208 requestChecks += 1;
4209 if (requestChecks !== interruptAt) return false;
4210 fiber.interruptUnsafe();
4211 return true;
4212 },
4213 };
4214
4215 const input: UsageSummaryInput = {
4216 ...WINDOW,
4217 sinceDay: UsageDay.make("2026-09-01"),
4218 untilDay: UsageDay.make(`2026-08-${String(interruptAt).padStart(2, "0")}`),
4219 };
4220 const first = yield* service
4221 .readSummary(input)
4222 .pipe(
4223 Effect.exit,
4224 Effect.provideService(Scheduler.Scheduler, scheduler),
4225 Effect.forkChild,
4226 );
4227 requestFiber = first;
4228 yield* Effect.yieldNow;
4229 dispatcher.flush();
4230
4231 const second = yield* service.readSummary(input).pipe(
4232 Effect.match({
4233 onFailure: (error) => error.reason,
4234 onSuccess: () => "success" as const,
4235 }),
4236 Effect.provideService(Scheduler.Scheduler, scheduler),
4237 Effect.forkChild,
4238 );
4239 yield* Effect.yieldNow;
4240 dispatcher.flush();
4241 const secondExit = second.pollUnsafe();
4242 if (secondExit === undefined) {
4243 second.interruptUnsafe();
4244 orphanedAt = interruptAt;
4245 break;
4246 }
4247 if (Exit.isFailure(secondExit)) {
4248 assert.fail("the matching request fiber was interrupted");
4249 }
4250 assert.strictEqual(secondExit.value, "invalidWindow");
4251 }
4252
4253 assert.isUndefined(
4254 orphanedAt,
4255 `interruption left the next matching request pending at scheduler check ${orphanedAt}`,
4256 );
4257 }),
4258 );
4259 });