sailfork / t3code-github / apps/ server/ src/ usage/ UsageService.test.ts

// @effect-diagnostics nodeBuiltinImport:off - the suite seeds and grows real
// transcript trees on disk, outside the service's Effect FileSystem.
import * as NodeChildProcess from "node:child_process";
import * as NodeFSP from "node:fs/promises";
import * as NodeOS from "node:os";
import * as NodePath from "node:path";
import * as NodeSqlite from "node:sqlite";
import * as NodeZlib from "node:zlib";

import { assert, describe, it } from "@effect/vitest";
import { vi } from "vite-plus/test";
import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
import * as NodeServices from "@effect/platform-node/NodeServices";
import * as HostProcess from "@t3tools/shared/HostProcess";
import { mergeUsage } from "@t3tools/shared/usageMerge";
import {
  EnvironmentId,
  ProviderDriverKind,
  ProviderInstanceId,
  UsageDay,
  type UsageSource,
  type UsageSummary,
  type UsageSummaryInput,
} from "@t3tools/contracts";
import * as Duration from "effect/Duration";
import * as Clock from "effect/Clock";
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Fiber from "effect/Fiber";
import * as FileSystem from "effect/FileSystem";
import * as Context from "effect/Context";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as Scheduler from "effect/Scheduler";
import * as Schema from "effect/Schema";
import * as TestClock from "effect/testing/TestClock";
import * as SqlClient from "effect/sql/SqlClient";
import { HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse } from "effect/http";

import * as ServerConfig from "../config.ts";
import * as ServerSettings from "../serverSettings.ts";
import * as Sqlite from "../persistence/Sqlite.ts";
import * as CodexUsageHistory from "./CodexUsageHistory.ts";
import * as CursorAccountReader from "@t3tools/provider-cursor/server/CursorAccountReader";
import * as CursorKeychain from "@t3tools/provider-cursor/server/CursorKeychain";
import * as CursorUsageAccounts from "@t3tools/provider-cursor/server/CursorUsageAccounts";
import * as ServerSecretStore from "../auth/ServerSecretStore.ts";
import * as BackgroundPolicy from "../background/BackgroundPolicy.ts";
import * as AntigravityUsage from "../provider/Drivers/AntigravityUsage.ts";
import * as ProviderHostLive from "../provider/ProviderHostLive.ts";
import { totalTokens, type UsageRecord } from "@t3tools/provider-core/server/usage";
import * as UsageService from "./UsageService.ts";
import * as MuseSdk from "../../../../packages/provider-muse/src/server/sdk.ts";
import { MuseUsageHome } from "@t3tools/provider-muse/server";
import { makeScanCacheWriter, SCAN_CACHE_FILE_NAME } from "./usageScanCache.ts";

vi.mock("node:fs/promises", { spy: true });
vi.mock("../../../../packages/provider-muse/src/server/sdk.ts", async (importOriginal) => {
  const original = await importOriginal<typeof MuseSdk>();
  return {
    ...original,
    createMuseSdkHostEffect: vi.fn(() =>
      Effect.fail(
        new original.MuseSdkError({
          operation: "start",
          cause: new Error("Muse is not installed in this test"),
        }),
      ),
    ),
  };
});

const encodeUnknownJson = Schema.encodeEffect(Schema.fromJsonString(Schema.Unknown));
const encodeUnknownJsonString = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown));
const decodeUnknownJsonString = Schema.decodeSync(Schema.fromJsonString(Schema.Unknown));

function claudeLine(
  id: number,
  outputTokens: number,
  model = "claude-fable-5",
  sessionId = "session-1",
): string {
  return `${JSON.stringify({
    type: "assistant",
    timestamp: "2026-08-01T10:00:00Z",
    requestId: `req_${id}`,
    sessionId,
    message: {
      id: `msg_${id}`,
      model,
      usage: { input_tokens: 10, output_tokens: outputTokens },
    },
  })}\n`;
}

const WINDOW: UsageSummaryInput = {
  timeZone: "UTC",
  sinceDay: UsageDay.make("2026-07-31"),
  untilDay: UsageDay.make("2026-08-02"),
};

const setup = Effect.gen(function* () {
  const home = yield* Effect.promise(() =>
    NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "usage-service-test-")),
  );
  yield* Effect.addFinalizer(() =>
    Effect.promise(() => NodeFSP.rm(home, { recursive: true, force: true })),
  );
  const transcriptDir = NodePath.join(home, "claude", "projects", "proj");
  yield* Effect.promise(() => NodeFSP.mkdir(transcriptDir, { recursive: true }));
  return {
    home,
    transcript: NodePath.join(transcriptDir, "session.jsonl"),
    settings: {
      providerInstances: {
        [ProviderInstanceId.make("claudeAgent")]: {
          driver: ProviderDriverKind.make("claudeAgent"),
          config: { homePath: NodePath.join(home, "claude") },
        },
        [ProviderInstanceId.make("codex")]: {
          driver: ProviderDriverKind.make("codex"),
          config: { homePath: NodePath.join(home, "codex") },
        },
      },
    },
  };
});

const layerCursorUsageAccounts = <E, R>(
  reader: Layer.Layer<CursorAccountReader.CursorAccountReader, E, R>,
) => Layer.fresh(CursorUsageAccounts.layer).pipe(Layer.provide(reader));

const makeWithCursor = (read: CursorAccountReader.CursorAccountReader["Service"]["read"]) =>
  Effect.gen(function* () {
    const context = yield* Layer.build(
      layerCursorUsageAccounts(Layer.succeed(CursorAccountReader.CursorAccountReader, { read })),
    );
    const accounts = Context.get(context, CursorUsageAccounts.CursorUsageAccounts);
    const service = yield* UsageService.make.pipe(Effect.provideContext(context));
    return {
      ...service,
      awaitPersisted: Effect.andThen(service.awaitPersisted, accounts.awaitPersisted),
    };
  });

const layerService = (input: {
  readonly prefix: string;
  readonly home: string;
  readonly settings: Parameters<typeof ServerSettings.layerTest>[0];
  readonly onRatesFetch?: (request: HttpClientRequest.HttpClientRequest) => void;
  readonly ratesDocument?: unknown;
  readonly ratesStatus?: () => number;
  readonly ratesResponse?: (
    request: HttpClientRequest.HttpClientRequest,
  ) => Effect.Effect<Response, HttpClientError.HttpClientError>;
  readonly environment?: NodeJS.ProcessEnv;
  readonly platform?: NodeJS.Platform;
  readonly hostname?: string;
  readonly secretStore?: Partial<ServerSecretStore.ServerSecretStore["Service"]>;
}) =>
  layerCursorUsageAccounts(
    CursorAccountReader.layer.pipe(Layer.provide(CursorKeychain.layer)),
  ).pipe(
    Layer.provideMerge(AntigravityUsage.layer),
    Layer.provideMerge(MuseUsageHome.layer),
    Layer.provideMerge(ProviderHostLive.layer),
    Layer.provideMerge(CodexUsageHistory.layer.pipe(Layer.provideMerge(Sqlite.layerMemory))),
    Layer.provideMerge(Layer.mock(BackgroundPolicy.BackgroundPolicy)({})),
    Layer.provideMerge(
      Layer.mock(ServerSecretStore.ServerSecretStore)({
        get: () => Effect.succeedNone,
        ...input.secretStore,
      }),
    ),
    Layer.provideMerge(
      ServerConfig.layerTest(process.cwd(), NodePath.join(input.home, input.prefix)),
    ),
    Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
    Layer.provideMerge(Layer.succeed(HostProcess.Platform, input.platform ?? "linux")),
    Layer.provideMerge(Layer.succeed(HostProcess.Hostname, input.hostname ?? "usage-test-host")),
    Layer.provideMerge(ServerSettings.layerTest(input.settings)),
    Layer.provideMerge(
      Layer.succeed(
        HttpClient.HttpClient,
        HttpClient.make((request) =>
          Effect.suspend(() => {
            input.onRatesFetch?.(request);
            const response = input.ratesResponse
              ? input.ratesResponse(request)
              : Effect.succeed(
                  Response.json(input.ratesDocument ?? {}, {
                    status: input.ratesStatus?.() ?? 200,
                  }),
                );
            return response.pipe(
              Effect.map((response) => HttpClientResponse.fromWeb(request, response)),
            );
          }),
        ),
      ),
    ),
    Layer.provideMerge(
      Layer.succeed(HostProcess.Environment, {
        HOME: input.home,
        GROK_HOME: NodePath.join(input.home, "grok"),
        PI_CODING_AGENT_DIR: NodePath.join(input.home, "pi"),
        OPENCODE_DATA_DIR: NodePath.join(input.home, "opencode"),
        ANTIGRAVITY_DATA_DIR: NodePath.join(input.home, "antigravity"),
        XDG_CONFIG_HOME: NodePath.join(input.home, "config"),
        APPDATA: NodePath.join(input.home, "config"),
        ...input.environment,
      }),
    ),
  );

const BEFORE_NARROW_WINDOW = Date.parse("2026-08-01T10:00:00Z") / 1000;
const NARROW_WINDOW: UsageSummaryInput = {
  timeZone: "UTC",
  sinceDay: UsageDay.make("2026-09-01"),
  untilDay: UsageDay.make("2026-09-02"),
};

// Each waiting gate holds a libuv thread; allow at most three.
const makeGate = (path: string, lastWriteSeconds?: number) =>
  Effect.promise(async () => {
    NodeChildProcess.execFileSync("mkfifo", [path]);
    if (lastWriteSeconds !== undefined) {
      await NodeFSP.utimes(path, lastWriteSeconds, lastWriteSeconds);
    }
  });

const openGate = (path: string) =>
  Effect.promise(async () => (await NodeFSP.open(path, "w")).close());

const replaceFile = (path: string, content: string) =>
  Effect.promise(async () => {
    await NodeFSP.writeFile(path + ".next", content);
    await NodeFSP.rename(path + ".next", path);
  });

function totalOutputTokens(summary: { buckets: readonly { totals: { outputTokens: number } }[] }) {
  return summary.buckets.reduce((sum, bucket) => sum + bucket.totals.outputTokens, 0);
}

const CURSOR_NOW = Date.parse("2026-08-02T12:00:00Z");
const HOUR_MS = 60 * 60 * 1000;

function makeFakeCursor() {
  const state = {
    accountKey: "account-a",
    events: [] as { readonly timestampMs: number; readonly outputTokens: number }[],
    error: null as string | null,
    gate: undefined as Deferred.Deferred<void> | undefined,
    calls: [] as { readonly sinceMs: number; readonly untilMs: number }[],
    credentials: [] as unknown[],
  };
  const read = (credential: unknown, sinceMs: number, untilMs: number) =>
    Effect.gen(function* () {
      state.calls.push({ sinceMs, untilMs });
      state.credentials.push(credential);
      if (state.gate !== undefined) yield* Deferred.await(state.gate);
      const { accountKey, error } = state;
      if (error !== null) return { accountKey, records: [], missing: false, error };
      const occurrences = new Map<string, number>();
      const records = state.events
        .filter(({ timestampMs }) => timestampMs >= sinceMs && timestampMs <= untilMs)
        .map(({ timestampMs, outputTokens }): UsageRecord => {
          const key = `${timestampMs}:${outputTokens}`;
          const occurrence = occurrences.get(key) ?? 0;
          occurrences.set(key, occurrence + 1);
          return {
            provider: "cursor",
            timestampMs,
            model: "claude-fable-5",
            sessionId: "conversation-1",
            totals: {
              uncachedInputTokens: 0,
              cachedInputTokens: 0,
              cacheCreationTokens: 0,
              outputTokens,
              reasoningTokens: 0,
            },
            reportedCostUsd: null,
            speed: "standard",
            dedupeKey: `cursor-account:${accountKey}:${key}:${occurrence}`,
          };
        });
      return { accountKey, records, missing: false, error: null };
    });
  return { state, read };
}

const writeCursorLogin = (home: string) =>
  Effect.promise(async () => {
    const authPath = NodePath.join(home, "config", "cursor", "auth.json");
    await NodeFSP.mkdir(NodePath.dirname(authPath), { recursive: true });
    await NodeFSP.writeFile(authPath, "{}");
  });

function cursorSource(summary: { readonly sources: readonly UsageSource[] }) {
  return summary.sources.find((source) => source.fingerprint.provider === "cursor");
}

function cursorSources(summary: { readonly sources: readonly UsageSource[] }) {
  return summary.sources.filter((source) => source.fingerprint.provider === "cursor");
}

const seedCodexHistory = (input: {
  id: string;
  nativeTurnId?: string;
  sessionId?: string;
  model?: string;
  options?: readonly { id: string; value: string | boolean }[];
}) =>
  Effect.gen(function* () {
    const sql = yield* SqlClient.SqlClient;
    const { id } = input;
    const selection = {
      instanceId: "codex",
      model: input.model ?? "gpt-6-astra",
      options: input.options ?? [{ id: "serviceTier", value: "priority" }],
    };
    const run = {
      id: `run-${id}`,
      activeAttemptId: `attempt-${id}`,
      status: "running",
      modelSelection: selection,
    };
    yield* sql`INSERT INTO orchestration_v2_projection_run_attempts ${sql.insert({
      attempt_id: run.activeAttemptId,
      thread_id: `thread-${id}`,
      run_id: run.id,
      attempt_ordinal: 1,
      root_node_id: `node-${id}`,
      provider: "codex",
      provider_thread_id: `provider-thread-${id}`,
      provider_turn_id: `turn-${id}`,
      status: "completed",
      payload_json: encodeUnknownJsonString({ nativeThreadId: input.sessionId ?? "session" }),
    })}`;
    yield* sql`INSERT INTO orchestration_v2_projection_provider_turns ${sql.insert({
      provider_turn_id: `turn-${id}`,
      thread_id: `thread-${id}`,
      provider_thread_id: `provider-thread-${id}`,
      node_id: `node-${id}`,
      run_attempt_id: run.activeAttemptId,
      ordinal: 1,
      status: "completed",
      payload_json: encodeUnknownJsonString({
        nativeTurnRef: { driver: "codex", nativeId: input.nativeTurnId ?? id, strength: "strong" },
      }),
    })}`;
    const changedSelection = {
      ...selection,
      options: [{ id: "serviceTier", value: "ultrafast" }],
    };
    // These selections disagree so reading the current projection or the wrong event is visible.
    yield* sql`INSERT INTO orchestration_v2_projection_runs ${sql.insert({
      run_id: run.id,
      thread_id: `thread-${id}`,
      ordinal: 1,
      provider: "codex",
      provider_thread_id: `provider-thread-${id}`,
      status: "completed",
      requested_at: "2026-08-01T10:00:00Z",
      payload_json: encodeUnknownJsonString({
        ...run,
        status: "completed",
        modelSelection: { ...selection, options: [] },
      }),
    })}`;
    for (const [index, payload] of [
      { ...run, activeAttemptId: "earlier-attempt", modelSelection: changedSelection },
      { ...run, status: "queued", modelSelection: changedSelection },
      run,
      { ...run, modelSelection: changedSelection },
    ].entries()) {
      yield* sql`INSERT INTO orchestration_events ${sql.insert({
        event_id: `event-${id}-${index}`,
        aggregate_kind: "thread",
        stream_id: `thread-${id}`,
        stream_version: index + 1,
        event_type: "run.updated",
        occurred_at: "2026-08-01T10:00:00Z",
        actor_kind: "system",
        metadata_json: "{}",
        application_event_version: 2,
        payload_json: encodeUnknownJsonString(payload),
      })}`;
    }
  });

describe("Codex usage history", () => {
  const historyLayer = CodexUsageHistory.layer.pipe(Layer.provideMerge(Sqlite.layerMemory));
  const request = (nativeTurnId: string) => ({
    sessionId: "session",
    nativeTurnId,
    model: "gpt-6-astra",
  });

  it.effect("resolves a batch from each attempt's first running selection", () =>
    Effect.gen(function* () {
      yield* seedCodexHistory({ id: "fast" });
      yield* seedCodexHistory({
        id: "ultrafast",
        options: [{ id: "serviceTier", value: "ultrafast" }],
      });
      yield* seedCodexHistory({ id: "legacy-option", options: [{ id: "fastMode", value: true }] });
      yield* seedCodexHistory({ id: "standard", options: [] });
      const requests = ["fast", "ultrafast", "legacy-option", "standard", "fast"].map(request);
      const history = yield* CodexUsageHistory.CodexUsageHistory;
      const resolved = yield* history.resolve(requests);
      assert.strictEqual(resolved.size, requests.length);
      assert.deepStrictEqual(
        requests.map((item) => resolved.get(item)),
        ["fast", "ultrafast", "fast", "standard", "fast"],
      );
    }).pipe(Effect.provide(historyLayer)),
  );

  it.effect("leaves ambiguous, mismatched, and missing V2 evidence unresolved", () =>
    Effect.gen(function* () {
      for (const id of [
        "valid",
        "duplicate-model",
        "duplicate-session",
        "imported",
        "v1-event",
        "queued",
        "missing-selection",
      ]) {
        yield* seedCodexHistory({ id });
      }
      yield* seedCodexHistory({
        id: "second-model",
        nativeTurnId: "duplicate-model",
        model: "other-model",
      });
      yield* seedCodexHistory({
        id: "second-session",
        nativeTurnId: "duplicate-session",
        sessionId: "other-session",
      });
      yield* seedCodexHistory({ id: "wrong-model", model: "other-model" });
      yield* seedCodexHistory({ id: "wrong-session", sessionId: "other-session" });
      const sql = yield* SqlClient.SqlClient;
      yield* sql`UPDATE orchestration_v2_projection_provider_turns
        SET run_attempt_id = NULL WHERE provider_turn_id = 'turn-imported'`;
      yield* sql`DELETE FROM orchestration_v2_projection_run_attempts WHERE attempt_id = 'attempt-imported'`;
      yield* sql`UPDATE orchestration_events SET application_event_version = 1
        WHERE stream_id = 'thread-v1-event'`;
      yield* sql`UPDATE orchestration_events
        SET payload_json = json_set(payload_json, '$.status', 'queued')
        WHERE stream_id = 'thread-queued'`;
      yield* sql`UPDATE orchestration_events
        SET payload_json = json_remove(payload_json, '$.modelSelection')
        WHERE event_id = 'event-missing-selection-2'`;
      const requests = [
        "valid",
        "duplicate-model",
        "duplicate-session",
        "wrong-model",
        "wrong-session",
        "missing-turn",
        "imported",
        "v1-event",
        "queued",
        "missing-selection",
      ].map(request);
      const history = yield* CodexUsageHistory.CodexUsageHistory;
      const resolved = yield* history.resolve(requests);
      assert.deepStrictEqual([...resolved], [[requests[0], "fast"]]);
    }).pipe(Effect.provide(historyLayer)),
  );

  it.effect(
    "reports SQL failures through the typed channel and can resolve again after repair",
    () =>
      Effect.gen(function* () {
        yield* seedCodexHistory({ id: "retry" });
        const history = yield* CodexUsageHistory.CodexUsageHistory;
        const sql = yield* SqlClient.SqlClient;
        const input = request("retry");
        yield* sql`ALTER TABLE orchestration_events RENAME TO unavailable_events`;
        const error = yield* Effect.flip(history.resolve([input]));
        assert.instanceOf(error, CodexUsageHistory.CodexUsageHistoryReadError);
        assert.strictEqual(error.requestedTurnCount, 1);
        yield* sql`ALTER TABLE unavailable_events RENAME TO orchestration_events`;
        assert.strictEqual((yield* history.resolve([input])).get(input), "fast");
      }).pipe(Effect.provide(historyLayer)),
  );
});

describe("UsageService", () => {
  it.live("counts compressed Codex rollouts across refresh, rewrites, and cache restarts", () =>
    Effect.gen(function* () {
      const { home, settings } = yield* setup;
      const sessions = NodePath.join(home, "codex", "sessions");
      const compressedPath = NodePath.join(sessions, "compressed.jsonl.zst");
      const usage = (output_tokens: number, timestamp = "2026-08-01T10:00:00Z") =>
        encodeUnknownJsonString({
          type: "event_msg",
          timestamp,
          payload: {
            type: "token_count",
            info: { last_token_usage: { input_tokens: 10, output_tokens } },
          },
        }) + "\n";
      const rollout = (id: string, output: number) =>
        [
          { type: "session_meta", payload: { id } },
          { type: "turn_context", payload: { model: "gpt-6-astra" } },
        ]
          .map((line) => encodeUnknownJsonString(line))
          .join("\n") +
        "\n" +
        usage(output);
      const compressed = rollout("compressed-session", 23);
      yield* Effect.promise(async () => {
        await NodeFSP.mkdir(sessions, { recursive: true });
        await NodeFSP.writeFile(
          NodePath.join(sessions, "plain.jsonl"),
          rollout("plain-session", 17),
        );
        await NodeFSP.writeFile(compressedPath, NodeZlib.zstdCompressSync(compressed));
      });
      yield* Effect.gen(function* () {
        const service = yield* UsageService.make;
        const first = yield* service.readSummary(WINDOW);
        assert.strictEqual(totalOutputTokens(first), 40);
        assert.strictEqual(
          first.sources.find((source) => source.fingerprint.provider === "codex")?.distinctSessions,
          2,
        );
        assert.deepStrictEqual((yield* service.readSummary(WINDOW)).buckets, first.buckets);
        yield* service.awaitPersisted;
        // The same rollout may remain in a plain file while compression finishes.
        yield* Effect.promise(() =>
          NodeFSP.writeFile(NodePath.join(sessions, "copy.jsonl"), compressed),
        );
        assert.strictEqual(totalOutputTokens(yield* service.readSummary(WINDOW)), 40);
        yield* Effect.promise(() =>
          NodeFSP.writeFile(
            compressedPath,
            NodeZlib.zstdCompressSync(compressed + usage(31, "2026-08-01T10:00:05Z")),
          ),
        );
        const rewritten = yield* service.readSummary(WINDOW);
        assert.strictEqual(totalOutputTokens(rewritten), 71);
        assert.deepStrictEqual((yield* service.readSummary(WINDOW)).buckets, rewritten.buckets);
        yield* service.awaitPersisted;
        const restarted = yield* UsageService.make;
        assert.deepStrictEqual((yield* restarted.readSummary(WINDOW)).buckets, rewritten.buckets);
        yield* restarted.awaitPersisted;
      }).pipe(
        Effect.scoped,
        Effect.provide(layerService({ prefix: "usage-compressed-codex", home, settings })),
      );
    }).pipe(Effect.scoped),
  );

  it.live("keeps the first host identity across recreation and explicit override removal", () =>
    Effect.gen(function* () {
      const { transcript, settings, home } = yield* setup;
      yield* Effect.promise(() => NodeFSP.writeFile(transcript, claudeLine(1, 5)));
      for (const [hostname, override, expected] of [
        ["container-a", undefined, "container-a"],
        ["container-b", undefined, "container-a"],
        ["container-c", "physical-host", "physical-host"],
        ["container-d", undefined, "container-a"],
      ] as const) {
        const summary = yield* Effect.gen(function* () {
          const service = yield* UsageService.make;
          return yield* service.readSummary(WINDOW);
        }).pipe(
          Effect.scoped,
          Effect.provide(
            layerService({
              prefix: "usage-host-id",
              home,
              settings,
              hostname,
              environment: override === undefined ? {} : { T3CODE_HOST_ID: override },
            }),
          ),
        );
        const source = summary.sources.find((source) => source.fingerprint.provider === "claude");
        assert.strictEqual(source?.fingerprint.hostId, expected);
      }
    }).pipe(Effect.scoped),
  );

  it.live("concurrent initialization keeps one host identity across service recreation", () =>
    Effect.gen(function* () {
      const { transcript, settings, home } = yield* setup;
      yield* Effect.promise(() => NodeFSP.writeFile(transcript, claudeLine(1, 5)));
      const prefix = "usage-host-id-race";
      const hostIdPath = NodePath.join(home, prefix, "usage-host-id");
      const bothRead = yield* Deferred.make<void>();
      let reads = 0;
      const summaries = yield* Effect.forEach(
        ["container-a", "container-b"],
        (hostname) =>
          Effect.gen(function* () {
            const fileSystem = yield* FileSystem.FileSystem;
            let firstRead = true;
            const service = yield* UsageService.make.pipe(
              Effect.provideService(FileSystem.FileSystem, {
                ...fileSystem,
                readFileString: (path, encoding) =>
                  Effect.gen(function* () {
                    if (path !== hostIdPath || !firstRead) {
                      return yield* fileSystem.readFileString(path, encoding);
                    }
                    firstRead = false;
                    // Both instances observe the missing file before either can create it.
                    const result = yield* Effect.exit(fileSystem.readFileString(path, encoding));
                    reads += 1;
                    if (reads === 2) yield* Deferred.succeed(bothRead, undefined);
                    yield* Deferred.await(bothRead);
                    return yield* result;
                  }),
              }),
            );
            return yield* service.readSummary(WINDOW);
          }).pipe(
            Effect.scoped,
            Effect.provide(layerService({ prefix, home, settings, hostname })),
          ),
        { concurrency: "unbounded" },
      );
      const persisted = yield* Effect.promise(() => NodeFSP.readFile(hostIdPath, "utf8"));
      const hostId = persisted.trim();
      assert.include(["container-a", "container-b"], hostId);
      const restarted = yield* Effect.gen(function* () {
        const service = yield* UsageService.make;
        return yield* service.readSummary(WINDOW);
      }).pipe(
        Effect.scoped,
        Effect.provide(layerService({ prefix, home, settings, hostname: "container-c" })),
      );
      for (const summary of [...summaries, restarted]) {
        const source = summary.sources.find((source) => source.fingerprint.provider === "claude");
        assert.strictEqual(source?.fingerprint.hostId, hostId);
      }
    }).pipe(Effect.scoped),
  );

  it.live(
    "repairs initial Codex prices after unchanged-file retries, persists evidence and corrections, and honors later native tiers",
    () =>
      Effect.gen(function* () {
        const { home, settings } = yield* setup;
        const sessions = NodePath.join(home, "codex", "sessions");
        const fastPath = NodePath.join(sessions, "fast.jsonl");
        const ultraPath = NodePath.join(sessions, "ultra.jsonl");
        const meta = (id: string) => ({
          type: "session_meta",
          payload: { id, model_provider: "openai" },
        });
        const context = (turn_id?: string) => ({
          type: "turn_context",
          payload: { model: "gpt-6-astra", turn_id },
        });
        const usage = (output_tokens: number) => ({
          type: "event_msg",
          timestamp: "2026-08-01T10:00:00Z",
          payload: {
            type: "token_count",
            info: { last_token_usage: { input_tokens: 0, output_tokens } },
          },
        });
        const tier = (service_tier?: string) => ({
          type: "event_msg",
          payload: { type: "thread_settings_applied", thread_settings: { service_tier } },
        });
        const lines = (records: readonly unknown[]) =>
          records.map((record) => encodeUnknownJsonString(record)).join("\n") + "\n";
        const verify = (summary: UsageSummary, output: number, cost: number) => {
          assert.strictEqual(totalOutputTokens(summary), output);
          assert.strictEqual(
            summary.buckets.reduce((sum, bucket) => sum + bucket.costUsd, 0),
            cost,
          );
        };
        yield* Effect.promise(async () => {
          await NodeFSP.mkdir(sessions, { recursive: true });
          await NodeFSP.writeFile(
            fastPath,
            lines([meta("fast-session"), context("fast-turn"), usage(1)]) +
              encodeUnknownJsonString(usage(2)),
          );
          await NodeFSP.writeFile(
            ultraPath,
            lines([meta("ultra-session"), context("ultra-turn"), usage(4)]),
          );
        });
        yield* Effect.gen(function* () {
          const first = yield* UsageService.make;
          verify(yield* first.readSummary(WINDOW), 7, 7);
          yield* first.awaitPersisted;
          const pending = yield* UsageService.make;
          verify(yield* pending.readSummary(WINDOW), 7, 7);
          yield* seedCodexHistory({ id: "fast-turn", sessionId: "fast-session" });
          yield* seedCodexHistory({
            id: "ultra-turn",
            sessionId: "ultra-session",
            options: [{ id: "serviceTier", value: "ultrafast" }],
          });
          const sql = yield* SqlClient.SqlClient;
          yield* sql`ALTER TABLE orchestration_events RENAME TO unavailable_events`;
          verify(yield* pending.readSummary(WINDOW), 7, 7);
          yield* pending.awaitPersisted;
          const retry = yield* UsageService.make;
          verify(yield* retry.readSummary(WINDOW), 7, 7);
          yield* sql`ALTER TABLE unavailable_events RENAME TO orchestration_events`;
          // History repair must touch both the committed record and tentative tail.
          verify(yield* retry.readSummary(WINDOW), 7, 30);
          yield* retry.awaitPersisted;
          yield* sql`ALTER TABLE orchestration_events RENAME TO resolved_events`;
          verify(yield* retry.readSummary(WINDOW), 7, 30);
          const resolved = yield* UsageService.make;
          verify(yield* resolved.readSummary(WINDOW), 7, 30);
          yield* sql`ALTER TABLE resolved_events RENAME TO orchestration_events`;

          // Completing the tail reparses it; neither an absent turn ID nor a new
          // turn with no retained attempt may inherit the inferred Fast speed.
          yield* Effect.promise(() =>
            NodeFSP.appendFile(
              fastPath,
              "\n" + lines([context(), usage(3), context("unretained-turn"), usage(4)]),
            ),
          );
          verify(yield* resolved.readSummary(WINDOW), 14, 37);
          yield* seedCodexHistory({
            id: "native-turn",
            sessionId: "fast-session",
            options: [{ id: "serviceTier", value: "ultrafast" }],
          });
          yield* seedCodexHistory({ id: "later-native-turn", sessionId: "fast-session" });
          yield* Effect.promise(() =>
            NodeFSP.appendFile(
              fastPath,
              lines([
                context("native-turn"),
                tier(),
                usage(5),
                context("later-native-turn"),
                usage(6),
                tier("priority"),
              ]) + encodeUnknownJsonString(usage(7)),
            ),
          );
          verify(yield* resolved.readSummary(WINDOW), 32, 62);
          yield* resolved.awaitPersisted;
          const native = yield* UsageService.make;
          verify(yield* native.readSummary(WINDOW), 32, 62);
          yield* seedCodexHistory({
            id: "after-restart-native",
            sessionId: "fast-session",
            options: [{ id: "serviceTier", value: "ultrafast" }],
          });
          yield* Effect.promise(() =>
            NodeFSP.appendFile(
              fastPath,
              "\n" +
                lines([context("after-restart-native"), usage(8), tier("ultrafast"), usage(9)]),
            ),
          );
          verify(yield* native.readSummary(WINDOW), 49, 132);
          yield* native.awaitPersisted;
          yield* Effect.promise(async () => {
            await NodeFSP.rm(fastPath);
            await NodeFSP.rm(ultraPath);
          });
          yield* sql`DELETE FROM orchestration_events`;
          const deleted = yield* UsageService.make;
          verify(yield* deleted.readSummary(WINDOW), 49, 132);
        }).pipe(
          Effect.provide(
            layerService({
              prefix: "usage-initial-tier",
              home,
              settings,
              ratesDocument: {
                "gpt-6-astra": {
                  input_cost_per_token: 0,
                  output_cost_per_token: 1,
                  input_cost_per_token_priority: 0,
                  output_cost_per_token_priority: 2,
                  input_cost_per_token_ultrafast: 0,
                  output_cost_per_token_ultrafast: 6,
                },
              },
            }),
          ),
        );
      }).pipe(Effect.scoped),
  );

  it.live(
    "reads Pi per-model usage and auxiliary costs once across forks and repeated entries",
    () =>
      Effect.gen(function* () {
        const { home, settings } = yield* setup;
        const dir = NodePath.join(home, "pi", "sessions", "project");
        const usage = {
          input: 10,
          output: 5,
          cacheRead: 20,
          cacheWrite: 3,
          reasoning: 2,
          totalTokens: 38,
          cost: { input: 0.1, output: 0.2, cacheRead: 0.3, cacheWrite: 0.4, total: 1 },
        };
        const parent = {
          type: "message",
          id: "a123abcd",
          parentId: null,
          timestamp: "2026-08-01T10:00:00Z",
          message: {
            role: "assistant",
            provider: "anthropic",
            model: "requested-model",
            responseModel: "actual-model",
            usage,
          },
        };
        const auxiliary = [
          {
            type: "message",
            id: "tool",
            message: { role: "toolResult", toolName: "classify", usage },
          },
          {
            type: "message",
            id: "image",
            message: {
              role: "toolResult",
              toolName: "image",
              usage: { ...usage, input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
            },
          },
          { type: "compaction", id: "compact", usage },
          { type: "branch_summary", id: "summary", usage },
        ].map((entry) => ({ ...entry, timestamp: "2026-08-01T11:00:00Z" }));
        yield* Effect.promise(async () => {
          await NodeFSP.mkdir(dir, { recursive: true });
          await NodeFSP.writeFile(
            NodePath.join(dir, "parent.jsonl"),
            [
              { type: "session", id: "parent" },
              parent,
              ...auxiliary,
              {
                type: "usage",
                id: "warm",
                timestamp: "2026-08-01T12:00:00Z",
                kind: "cache_warm",
                provider: "openai",
                model: "actual-model",
                usage: { ...usage, cost: { ...usage.cost, total: 0 } },
              },
            ]
              .map((line) => encodeUnknownJsonString(line))
              .join("\n") + "\n",
          );
          await NodeFSP.writeFile(
            NodePath.join(dir, "fork.jsonl"),
            [
              { type: "session", id: "fork", parentSession: NodePath.join(dir, "parent.jsonl") },
              { ...parent, parentId: "relinked" },
              parent,
              ...auxiliary,
              {
                ...parent,
                timestamp: "2026-08-01T13:00:00Z",
                message: { ...parent.message, provider: "openai", responseModel: "another-model" },
              },
              { type: "get_session_stats", usage: { ...usage, cost: { total: 1000 } } },
            ]
              .map((line) => encodeUnknownJsonString(line))
              .join("\n") + "\n",
          );
        });
        yield* Effect.gen(function* () {
          const service = yield* UsageService.make;
          const first = yield* service.readSummary(WINDOW);
          const pi = first.buckets.filter((bucket) => bucket.provider === "pi");
          assert.strictEqual(
            pi.reduce((total, bucket) => total + bucket.costUsd, 0),
            44,
          );
          assert.strictEqual(
            pi.reduce((total, bucket) => total + totalTokens(bucket.totals), 0),
            228,
          );
          assert.deepStrictEqual(pi.map((bucket) => bucket.model).sort(), [
            "Tools/summaries",
            "anthropic/actual-model",
            "openai/actual-model",
            "openai/another-model",
          ]);
          const assistant = pi.find((bucket) => bucket.model === "anthropic/actual-model");
          assert.deepStrictEqual(assistant?.totals, {
            uncachedInputTokens: 10,
            outputTokens: 5,
            cachedInputTokens: 20,
            cacheCreationTokens: 3,
            reasoningTokens: 2,
          });
          assert.strictEqual(assistant?.costSource, "providerReported");
          assert.approximately(assistant?.categoryCostUsd?.input ?? NaN, 10 / 38, 1e-6);
          assert.approximately(assistant?.categoryCostUsd?.cacheRead ?? NaN, 2 / 38, 1e-6);
          assert.approximately(assistant?.categoryCostUsd?.cacheWrite ?? NaN, 6 / 38, 1e-6);
          assert.approximately(assistant?.categoryCostUsd?.output ?? NaN, 20 / 38, 1e-6);
          assert.strictEqual(assistant?.cacheSavingsUsd, 18);
          const warm = pi.find((bucket) => bucket.model === "openai/actual-model");
          assert.strictEqual(warm?.costSource, "modelPriced");
          assert.strictEqual(warm?.costUsd, 38);
          assert.deepStrictEqual(warm?.categoryCostUsd, {
            input: 10,
            cacheRead: 2,
            cacheWrite: 6,
            output: 20,
          });
          assert.strictEqual(warm?.cacheSavingsUsd, 18);
          assert.strictEqual(
            first.sources.filter((source) => source.fingerprint.provider === "pi").length,
            1,
          );
          yield* Effect.promise(() =>
            NodeFSP.appendFile(
              NodePath.join(dir, "fork.jsonl"),
              encodeUnknownJsonString({
                ...parent,
                id: "new",
                timestamp: "2026-08-01T14:00:00Z",
                message: { ...parent.message, responseModel: "latest-model" },
              }) + "\n",
            ),
          );
          const grown = yield* service.readSummary(WINDOW);
          assert.strictEqual(
            grown.buckets
              .filter((bucket) => bucket.provider === "pi")
              .reduce((total, bucket) => total + bucket.costUsd, 0),
            45,
          );
          yield* service.awaitPersisted;
          const restarted = yield* UsageService.make;
          assert.deepStrictEqual((yield* restarted.readSummary(WINDOW)).buckets, grown.buckets);
        }).pipe(
          Effect.scoped,
          Effect.provide(
            layerService({
              prefix: "usage-pi-fork",
              home,
              ratesDocument: {
                "actual-model": {
                  input_cost_per_token: 1,
                  output_cost_per_token: 4,
                  cache_read_input_token_cost: 0.1,
                  cache_creation_input_token_cost: 2,
                },
              },
              settings: {
                ...settings,
                providerInstances: {
                  ...settings.providerInstances,
                  [ProviderInstanceId.make("pi-extra")]: {
                    driver: ProviderDriverKind.make("pi"),
                    enabled: false,
                    environment: [
                      {
                        name: "PI_CODING_AGENT_DIR",
                        value: NodePath.join(home, "pi"),
                        sensitive: false,
                      },
                    ],
                  },
                },
              },
            }),
          ),
        );
      }).pipe(Effect.scoped),
  );

  it.live(
    "reads Muse inference history once, persists appended usage, and reprices unknown models",
    () =>
      Effect.gen(function* () {
        const { home, settings } = yield* setup;
        const museHome = NodePath.join(home, "configured-data", "muse");
        const dir = NodePath.join(museHome, "sessions", "2026", "08", "01", "parent");
        const child = NodePath.join(dir, "subagent", "child");
        const entry = (
          id: string,
          sessionId = "parent",
          timestamp = "2026-08-01T00:00:00Z",
          model = "muse-unknown",
        ) => ({
          schema_version: 1,
          record_type: "event",
          payload_type: "runtime.session",
          payload_schema_version: 1,
          id,
          recorded_at: Date.parse(timestamp) * 1000 + 999,
          stream: { kind: "session", id: sessionId },
          payload: {
            source_run_record_id: id,
            event: {
              kind: "model_completed",
              model,
              usage: {
                input_tokens: 100,
                cached_tokens: 60,
                cache_read_tokens: 60,
                cache_write_tokens: 10,
                output_tokens: 20,
                reasoning_tokens: 8,
              },
            },
          },
        });
        const parent = entry("inference-1");
        const review = {
          ...entry("review", "child"),
          payload_schema_version: 3,
          payload: {
            event: {
              ...parent.payload.event,
              kind: "automated_review_completed",
              model: { model_id: "priced-model" },
              usage: {
                input_tokens: 100,
                cached_input_tokens: 60,
                output_tokens: 20,
                reasoning_tokens: 8,
              },
            },
          },
        };
        yield* Effect.promise(async () => {
          await NodeFSP.mkdir(child, { recursive: true });
          await NodeFSP.writeFile(
            NodePath.join(dir, "session.jsonl"),
            [
              parent,
              parent,
              {
                ...parent,
                payload: { event: { ...parent.payload.event, kind: "workflow_completed" } },
              },
              { ...parent, payload_type: "goal_usage_attribution" },
              entry("before", "parent", "2026-07-31T23:59:59.999Z"),
              entry("after", "parent", "2026-08-02T00:00:00Z"),
            ]
              .map((line) => encodeUnknownJsonString(line))
              .join("\n") + "\n{broken}\n",
          );
          await NodeFSP.writeFile(
            NodePath.join(child, "session.jsonl"),
            [
              { ...parent, id: "copied-envelope", stream: { kind: "session", id: "child" } },
              entry("child-inference", "child"),
              review,
            ]
              .map((line) => encodeUnknownJsonString(line))
              .join("\n") + "\n",
          );
          await NodeFSP.writeFile(
            NodePath.join(child, "telemetry.jsonl"),
            encodeUnknownJsonString(entry("not-a-session")) + "\n",
          );
        });
        using _create = vi.spyOn(MuseSdk, "createMuseSdkHostEffect").mockImplementation((options) =>
          Effect.succeed({
            initializeResult: {
              grantedCapabilities: [],
              museHome: NodePath.join(options.environment?.XDG_DATA_HOME ?? home, "muse"),
            },
            close: async () => {},
          } as unknown as MuseSdk.MuseSdkHost),
        );
        yield* Effect.gen(function* () {
          const service = yield* UsageService.make;
          const window = {
            timeZone: "UTC",
            sinceDay: UsageDay.make("2026-08-01"),
            untilDay: UsageDay.make("2026-08-01"),
          };
          const muse = (summary: UsageSummary) =>
            summary.buckets.filter((bucket) => bucket.provider === "muse");
          const first = yield* service.readSummary(window);
          const buckets = muse(first);
          assert.strictEqual(
            buckets.reduce((sum, b) => sum + b.records, 0),
            3,
          );
          assert.strictEqual(
            buckets.reduce((sum, b) => sum + totalTokens(b.totals), 0),
            360,
          );
          const unknown = buckets.find((b) => b.model === "muse-unknown");
          assert.strictEqual(unknown?.costSource, "unpriced");
          assert.strictEqual(unknown?.unpricedRecords, 2);
          assert.deepStrictEqual(unknown?.totals, {
            uncachedInputTokens: 60,
            cachedInputTokens: 120,
            cacheCreationTokens: 20,
            outputTokens: 40,
            reasoningTokens: 16,
          });
          const priced = buckets.find((b) => b.model === "priced-model");
          assert.strictEqual(priced?.costSource, "modelPriced");
          assert.closeTo(priced?.costUsd ?? NaN, 0.000172, 1e-12);
          assert.closeTo(priced?.cacheSavingsUsd ?? NaN, 0.000108, 1e-12);
          const sources = first.sources.filter((source) => source.fingerprint.provider === "muse");
          assert.strictEqual(sources.length, 1);
          assert.strictEqual(sources[0]?.scannedFiles, 2);
          assert.strictEqual(sources[0]?.distinctSessions, 2);
          const local = muse(
            yield* service.readSummary({ ...window, timeZone: "America/Los_Angeles" }),
          );
          assert.strictEqual(
            local.reduce((sum, b) => sum + b.records, 0),
            1,
          );
          assert.strictEqual(local[0]?.day, "2026-08-01");
          const hourly = muse(
            yield* service.readSummary({
              ...window,
              resolution: "hour",
              sinceTime: "2026-08-01T00:00:00.000Z",
              untilTime: "2026-08-02T00:00:00.000Z",
            }),
          );
          assert.strictEqual(
            hourly.reduce((sum, b) => sum + b.records, 0),
            3,
          );
          const appended = encodeUnknownJsonString(entry("appended", "child"));
          const file = NodePath.join(child, "session.jsonl");
          yield* Effect.promise(() => NodeFSP.appendFile(file, appended.slice(0, -10)));
          assert.deepStrictEqual(muse(yield* service.readSummary(window)), buckets);
          yield* service.awaitPersisted;
          const restarted = yield* UsageService.make;
          yield* Effect.promise(() => NodeFSP.appendFile(file, appended.slice(-10) + "\n"));
          const grown = muse(yield* restarted.readSummary(window));
          assert.strictEqual(
            grown.reduce((sum, b) => sum + b.records, 0),
            4,
          );
          assert.strictEqual(
            grown.reduce((sum, b) => sum + totalTokens(b.totals), 0),
            480,
          );
          const settingsService = yield* ServerSettings.ServerSettingsService;
          yield* settingsService.updateSettings({
            usagePriceOverrides: {
              "muse-unknown": {
                inputCostPerMillionTokens: 2,
                outputCostPerMillionTokens: 4,
                cacheReadCostPerMillionTokens: 0.2,
                cacheWriteCostPerMillionTokens: 1,
              },
            },
          });
          const repriced = muse(yield* restarted.readSummary(window)).find(
            (b) => b.model === "muse-unknown",
          );
          assert.strictEqual(repriced?.unpricedRecords, 0);
          assert.closeTo(repriced?.costUsd ?? NaN, 0.000486, 1e-12);
        }).pipe(
          Effect.scoped,
          Effect.provide(
            layerService({
              prefix: "usage-muse",
              home,
              environment: { XDG_DATA_HOME: NodePath.dirname(museHome) },
              settings: {
                ...settings,
                providerInstances: {
                  ...settings.providerInstances,
                  [ProviderInstanceId.make("muse")]: {
                    driver: ProviderDriverKind.make("muse"),
                    enabled: false,
                  },
                  [ProviderInstanceId.make("muse-alias")]: {
                    driver: ProviderDriverKind.make("muse"),
                    enabled: false,
                  },
                },
              },
              ratesDocument: {
                "priced-model": {
                  input_cost_per_token: 0.000002,
                  output_cost_per_token: 0.000004,
                  cache_read_input_token_cost: 0.0000002,
                  cache_creation_input_token_cost: 0.0000002,
                },
              },
            }),
          ),
        );
      }).pipe(Effect.scoped),
  );

  it.live("reports missing Pi history and skips malformed records without losing valid usage", () =>
    Effect.gen(function* () {
      const { home, settings } = yield* setup;
      yield* Effect.gen(function* () {
        const service = yield* UsageService.make;
        const missing = yield* service.readSummary(WINDOW);
        assert.strictEqual(
          missing.sources.find((source) => source.fingerprint.provider === "pi")?.status,
          "missing",
        );
        const dir = NodePath.join(home, "pi", "sessions");
        yield* Effect.promise(async () => {
          await NodeFSP.mkdir(dir, { recursive: true });
          await NodeFSP.writeFile(
            NodePath.join(dir, "session.jsonl"),
            [
              "{broken",
              "null",
              encodeUnknownJsonString({ type: "session", id: "valid" }),
              encodeUnknownJsonString({
                type: "message",
                id: "bad",
                timestamp: "invalid",
                message: {
                  role: "assistant",
                  provider: "openai",
                  model: "model",
                  usage: { input: 100 },
                },
              }),
              encodeUnknownJsonString({
                type: "message",
                id: "valid",
                timestamp: "2026-08-01T10:00:00Z",
                message: {
                  role: "assistant",
                  provider: "openai",
                  model: "model",
                  usage: {
                    input: -1,
                    cacheRead: "100",
                    output: 7,
                    reasoning: 50,
                    cost: { total: -1 },
                  },
                },
              }),
            ].join("\n") + "\n",
          );
        });
        const summary = yield* service.readSummary(WINDOW);
        const pi = summary.buckets.filter((bucket) => bucket.provider === "pi");
        assert.strictEqual(pi.length, 1);
        assert.strictEqual(pi[0] && totalTokens(pi[0].totals), 7);
        assert.strictEqual(pi[0]?.totals.reasoningTokens, 7);
        assert.strictEqual(pi[0]?.costSource, "unpriced");
      }).pipe(
        Effect.scoped,
        Effect.provide(layerService({ prefix: "usage-pi-malformed", home, settings })),
      );
    }).pipe(Effect.scoped),
  );

  it.live("discovers Pi history in its default home and directory overrides", () =>
    Effect.gen(function* () {
      const { home, settings } = yield* setup;
      for (const [agentDir, sessionDir, relativeDir, launchArgs, instanceHome, platform] of [
        [undefined, undefined, ".pi/agent/sessions", undefined],
        ["~/custom-pi", undefined, "custom-pi/sessions", undefined],
        ["~/ignored-pi", "~/custom-sessions", "custom-sessions", undefined],
        ["~/ignored-pi", NodePath.join(home, "absolute-sessions"), "absolute-sessions", undefined],
        ["~/ignored-pi", undefined, "launch-sessions", "--session-dir ~/launch-sessions"],
        [
          "~/ignored-pi",
          undefined,
          "instance-home /launch-sessions",
          "--session-dir ~/launch-sessions",
          "instance-home ",
        ],
        [
          "~/ignored-pi",
          undefined,
          "windows-profile/launch-sessions",
          "--session-dir ~/launch-sessions",
          "windows-profile",
          "win32",
        ],
      ] as const) {
        const dir = NodePath.join(home, relativeDir);
        yield* Effect.promise(async () => {
          await NodeFSP.mkdir(dir, { recursive: true });
          await NodeFSP.writeFile(
            NodePath.join(dir, "session.jsonl"),
            [
              { type: "session", id: relativeDir },
              {
                type: "usage",
                id: "warm",
                timestamp: "2026-08-01T10:00:00Z",
                provider: "openai",
                model: "model",
                usage: { input: 7 },
              },
            ]
              .map((line) => encodeUnknownJsonString(line))
              .join("\n") + "\n",
          );
        });
        yield* Effect.gen(function* () {
          const service = yield* UsageService.make;
          const summary = yield* service.readSummary(WINDOW);
          const pi = summary.buckets.filter((bucket) => bucket.provider === "pi");
          assert.strictEqual(pi.length, 1);
          assert.strictEqual(pi[0]?.totals.uncachedInputTokens, 7);
          assert.strictEqual(
            summary.sources.find((source) => source.fingerprint.provider === "pi")?.fingerprint
              .resolvedHomePath,
            dir,
          );
        }).pipe(
          Effect.scoped,
          Effect.provide(
            layerService({
              prefix: "usage-pi-" + relativeDir.replaceAll("/", "-"),
              home,
              settings:
                launchArgs === undefined
                  ? settings
                  : {
                      ...settings,
                      providerInstances: {
                        ...settings.providerInstances,
                        [ProviderInstanceId.make("pi")]: {
                          driver: ProviderDriverKind.make("pi"),
                          config: { launchArgs },
                          environment:
                            instanceHome === undefined
                              ? []
                              : [
                                  {
                                    name: platform === "win32" ? "USERPROFILE" : "HOME",
                                    value: NodePath.join(home, instanceHome),
                                    sensitive: false,
                                  },
                                ],
                        },
                      },
                    },
              environment: {
                PI_CODING_AGENT_DIR: agentDir,
                PI_CODING_AGENT_SESSION_DIR: sessionDir,
              },
              platform: platform ?? "linux",
            }),
          ),
          Effect.provideService(HostProcess.HomeDirectory, home),
        );
      }
    }).pipe(Effect.scoped),
  );

  it.live("reads shared managed default and disabled extra account history once", () =>
    Effect.gen(function* () {
      const { home, settings } = yield* setup;
      const summary = yield* Effect.gen(function* () {
        for (const [id, output] of [
          ["codex", 17],
          ["codex-personal", 23],
        ] as const) {
          const sessions = NodePath.join(home, "shared-codex", "sessions");
          yield* Effect.promise(async () => {
            await NodeFSP.mkdir(sessions, { recursive: true });
            await NodeFSP.writeFile(
              NodePath.join(sessions, `${id}-rollout.jsonl`),
              [
                { type: "session_meta", payload: { id } },
                { type: "turn_context", payload: { model: "gpt-5.6-sol" } },
                {
                  type: "event_msg",
                  timestamp: "2026-08-01T10:00:00Z",
                  payload: {
                    type: "token_count",
                    info: { last_token_usage: { input_tokens: 10, output_tokens: output } },
                  },
                },
              ]
                .map((line) => encodeUnknownJsonString(line))
                .join("\n") + "\n",
            );
          });
        }
        const service = yield* UsageService.make;
        return yield* service.readSummary(WINDOW);
      }).pipe(
        Effect.scoped,
        Effect.provide(
          layerService({
            prefix: "usage-managed-accounts",
            home,
            settings: {
              ...settings,
              providerInstances: {
                ...settings.providerInstances,
                [ProviderInstanceId.make("codex")]: {
                  driver: ProviderDriverKind.make("codex"),
                  config: {
                    setupMode: "managed",
                    homePath: NodePath.join(home, "shared-codex"),
                  },
                },
                [ProviderInstanceId.make("codex-personal")]: {
                  driver: ProviderDriverKind.make("codex"),
                  enabled: false,
                  config: {
                    setupMode: "managed",
                    homePath: NodePath.join(home, "shared-codex"),
                    shadowHomePath: NodePath.join(home, "personal-shadow"),
                  },
                  environment: [
                    {
                      name: "CODEX_HOME",
                      value: NodePath.join(home, "ignored-environment"),
                      sensitive: false,
                    },
                  ],
                },
              },
            },
          }),
        ),
      );
      assert.strictEqual(totalOutputTokens(summary), 40);
      assert.strictEqual(
        summary.sources.filter(
          (source) => source.fingerprint.provider === "codex" && source.status === "ok",
        ).length,
        1,
      );
    }).pipe(Effect.scoped),
  );

  it.live("keeps Cursor credential errors visible when a saved login cannot be read", () =>
    Effect.gen(function* () {
      const { settings, home } = yield* setup;
      const authPath = NodePath.join(home, "config", "cursor", "auth.json");
      yield* Effect.promise(async () => {
        await NodeFSP.mkdir(NodePath.dirname(authPath), { recursive: true });
        await NodeFSP.writeFile(authPath, "invalid json");
      });
      const service = yield* UsageService.make.pipe(
        Effect.provide(
          layerService({ prefix: "usage-service-cursor-invalid-login", home, settings }),
        ),
      );
      const summary = yield* service.readSummary({ ...WINDOW, awaitRefresh: true });
      const cursor = summary.sources.find((source) => source.fingerprint.provider === "cursor");
      assert.strictEqual(cursor?.message, "Cursor credentials could not be read.");
    }).pipe(Effect.scoped),
  );

  it.live("restores the Cursor account cache after a restart", () =>
    Effect.gen(function* () {
      const { settings, home } = yield* setup;
      yield* writeCursorLogin(home);
      yield* TestClock.setTime(CURSOR_NOW);
      const before = makeFakeCursor();
      before.state.events = [
        { timestampMs: CURSOR_NOW - 30 * HOUR_MS, outputTokens: 5 },
        { timestampMs: CURSOR_NOW - 3 * HOUR_MS, outputTokens: 7 },
      ];
      yield* Effect.gen(function* () {
        const first = yield* makeWithCursor(before.read);
        const original = yield* first.readSummary({ ...WINDOW, awaitRefresh: true });
        yield* first.awaitPersisted;

        const after = makeFakeCursor();
        after.state.events = before.state.events;
        const restarted = yield* makeWithCursor(after.read);
        const restored = yield* restarted.readSummary(WINDOW);
        assert.isUndefined(cursorSource(restored)?.refreshing);
        assert.deepStrictEqual(restored.buckets, original.buckets);
        assert.deepStrictEqual(cursorSource(restored), cursorSource(original));
        assert.strictEqual(after.state.calls.length, 0);

        yield* TestClock.adjust(Duration.minutes(2));
        const refreshed = yield* restarted.readSummary({ ...WINDOW, awaitRefresh: true });
        assert.deepStrictEqual(refreshed.buckets, original.buckets);
        assert.deepStrictEqual(after.state.calls, [
          { sinceMs: CURSOR_NOW - HOUR_MS, untilMs: CURSOR_NOW + 2 * 60 * 1000 },
        ]);
      }).pipe(
        Effect.provide(layerService({ prefix: "usage-service-cursor-restart", home, settings })),
      );
    }).pipe(Effect.scoped, Effect.provide(TestClock.layer())),
  );

  it.live("does not read the macOS Cursor Keychain before account usage is enabled", () =>
    Effect.gen(function* () {
      const { settings, home } = yield* setup;
      const service = yield* UsageService.make.pipe(
        Effect.provide(
          layerService({
            prefix: "usage-service-cursor-keychain-disabled",
            home,
            settings,
            platform: "darwin",
            environment: {},
          }),
        ),
      );
      const summary = yield* service.readSummary(WINDOW);
      const cursor = summary.sources.find((source) => source.fingerprint.provider === "cursor");
      assert.strictEqual(cursor?.status, "missing");
      assert.strictEqual(cursor?.action, "enableCursorKeychain");
    }).pipe(Effect.scoped),
  );

  it.effect("ignores a stale macOS Keychain login when Cursor is not installed", () =>
    Effect.gen(function* () {
      const { settings, home } = yield* setup;
      const cursor = makeFakeCursor();
      cursor.state.error = "Sign in to Cursor again to read account usage.";
      const readCursorSource = Effect.gen(function* () {
        const service = yield* makeWithCursor(cursor.read);
        const summary = yield* service.readSummary({ ...WINDOW, awaitRefresh: true });
        return cursorSource(summary);
      }).pipe(
        Effect.provide(
          layerService({
            prefix: "usage-service-cursor-keychain-uninstalled",
            home,
            settings: { ...settings, cursorKeychainUsageEnabled: true },
            platform: "darwin",
            environment: {},
          }),
        ),
      );

      assert.isUndefined(yield* readCursorSource);
      assert.lengthOf(cursor.state.calls, 0);

      yield* Effect.promise(() => NodeFSP.mkdir(NodePath.join(home, ".cursor")));
      const installed = yield* readCursorSource;
      assert.strictEqual(installed?.message, "Sign in to Cursor again to read account usage.");
      assert.lengthOf(cursor.state.calls, 1);
    }).pipe(Effect.scoped),
  );

  it.live("ignores stale Cursor file logins when the active credential store differs", () =>
    Effect.gen(function* () {
      const { settings, home } = yield* setup;
      for (const [index, testCase] of [
        {
          platform: "darwin" as const,
          environment: { AGENT_CLI_CREDENTIAL_STORE: "memory" },
          authPath: [".cursor", "auth.json"],
        },
        {
          platform: "linux" as const,
          environment: { AGENT_CLI_CREDENTIAL_STORE: "memory" },
          authPath: ["config", "cursor", "auth.json"],
        },
      ].entries()) {
        const authPath = NodePath.join(home, ...testCase.authPath);
        yield* Effect.promise(async () => {
          await NodeFSP.mkdir(NodePath.dirname(authPath), { recursive: true });
          await NodeFSP.writeFile(
            authPath,
            encodeUnknownJsonString({ accessToken: "stale-token" }),
          );
        });
        const service = yield* UsageService.make.pipe(
          Effect.provide(
            layerService({
              prefix: `usage-service-cursor-store-${index}`,
              home,
              settings,
              platform: testCase.platform,
              environment: testCase.environment,
            }),
          ),
        );
        const summary = yield* service.readSummary(WINDOW);
        const cursor = summary.sources.find((source) => source.fingerprint.provider === "cursor");
        assert.strictEqual(cursor?.status, "missing");
        assert.include(cursor?.message ?? "", "Cursor CLI login");
        assert.isFalse(summary.buckets.some((bucket) => bucket.provider === "cursor"));
      }
    }).pipe(Effect.scoped),
  );

  it.live("reads the Cursor account of an API key or T3 sign-in instead of a CLI login", () =>
    Effect.gen(function* () {
      const { settings, home } = yield* setup;
      const signIn = new TextEncoder().encode(
        encodeUnknownJsonString({
          version: 1,
          backendUrl: "https://api2.cursor.sh",
          apiKey: "signed-in-key",
          createdAtMs: 0,
        }),
      );
      for (const [index, testCase] of [
        { environment: { CURSOR_API_KEY: "environment-key" }, stored: Option.none() },
        { environment: {}, stored: Option.some(signIn) },
      ].entries()) {
        const cursor = makeFakeCursor();
        const summary = yield* Effect.gen(function* () {
          const service = yield* makeWithCursor(cursor.read);
          return yield* service.readSummary({ ...WINDOW, awaitRefresh: true });
        }).pipe(
          Effect.provide(
            layerService({
              prefix: `usage-service-cursor-api-key-${index}`,
              home,
              settings,
              platform: "darwin",
              environment: testCase.environment,
              secretStore: { get: () => Effect.succeed(testCase.stored) },
            }),
          ),
        );
        assert.deepStrictEqual(cursor.state.credentials, [
          { kind: "apiKey", apiKey: index === 0 ? "environment-key" : "signed-in-key" },
        ]);
        assert.strictEqual(cursorSource(summary)?.status, "ok");
      }
    }).pipe(Effect.scoped),
  );

  it.live("does not show a previous Cursor account's history after the API key changes", () =>
    Effect.gen(function* () {
      const { settings, home } = yield* setup;
      yield* TestClock.setTime(CURSOR_NOW);
      let apiKey = "first-account-key";
      const signIn = () =>
        Option.some(
          new TextEncoder().encode(