@ai-devkit/agent-manager 0.36.0 → 0.38.0

package/src/__tests__/adapters/adapterSnapshotCandidates.test.ts

@@ -0,0 +1,243 @@
+/**
+ * Standalone snapshot enrichment tests (#281).
+ *
+ * When an adapter runs without a shared AgentDetectionContext it captures its
+ * own process snapshot. `lsof` (cwd) and `ps lstart` (start time) must then
+ * receive only the PIDs the adapter can handle — not every name-matched
+ * process, which for `node`-based adapters means every Node.js process on the
+ * machine. `child_process` is mocked so the real snapshot code runs on top.
+ */
+
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import * as childProcess from "child_process";
+import type { MockedFunction } from "vitest";
+
+import type { AgentAdapter, ProcessInfo } from "../../adapters/AgentAdapter.js";
+import { AntigravityCliAdapter } from "../../harnesses/antigravity/AntigravityCliAdapter.js";
+import { KiroAdapter } from "../../harnesses/kiro/KiroAdapter.js";
+import { ClaudeCodeAdapter } from "../../harnesses/claude/ClaudeCodeAdapter.js";
+import { CodexAdapter } from "../../harnesses/codex/CodexAdapter.js";
+import { CopilotAdapter } from "../../harnesses/copilot/CopilotAdapter.js";
+import { GeminiCliAdapter } from "../../harnesses/gemini/GeminiCliAdapter.js";
+import { GrokCliAdapter } from "../../harnesses/grok/GrokCliAdapter.js";
+import { OpenCodeAdapter } from "../../harnesses/opencode/OpenCodeAdapter.js";
+import { PiAdapter } from "../../harnesses/pi/PiAdapter.js";
+import { AgentRegistry } from "../../utils/AgentRegistry.js";
+import { captureProcessSnapshot } from "../../utils/process.js";
+
+vi.mock("child_process", async (importOriginal) => {
+  const actual = (await importOriginal()) as typeof import("child_process");
+  return { ...actual, execFile: vi.fn() };
+});
+
+vi.mock("../../utils/process.js", async (importOriginal) => {
+  const actual = (await importOriginal()) as typeof import("../../utils/process.js");
+  return { ...actual, captureProcessSnapshot: vi.fn(actual.captureProcessSnapshot) };
+});
+
+type ExecFileCallback = (error: Error | null, stdout: string, stderr: string) => void;
+
+const mockedExecFile = childProcess.execFile as unknown as ReturnType<typeof vi.fn>;
+const mockedCaptureProcessSnapshot = captureProcessSnapshot as MockedFunction<
+  typeof captureProcessSnapshot
+>;
+
+/** Node processes that no adapter handles. */
+const UNRELATED_NODE_LINES = [
+  "901 1 ttys020 node server.js",
+  "902 1 ttys021 node /usr/local/lib/node_modules/npm/bin/npm-cli.js install",
+  "903 1 ?? node --inspect /srv/app/index.js",
+];
+
+function pidList(args: readonly string[]): number[] {
+  return args[args.length - 1].split(",").map(Number);
+}
+
+function pidsSentTo(file: "lsof" | "ps"): number[][] {
+  return mockedExecFile.mock.calls
+    .filter(([name, args]) => name === file && (file === "lsof" || (args as string[])[0] === "-o"))
+    .map(([, args]) => pidList(args as string[]));
+}
+
+function installExec(psLines: readonly string[]): void {
+  mockedExecFile.mockImplementation(
+    (file: string, args: readonly string[], _opts: unknown, cb: ExecFileCallback) => {
+      if (file === "ps" && args[0] === "-axo") {
+        cb(null, psLines.join("\n"), "");
+      } else if (file === "lsof") {
+        cb(
+          null,
+          pidList(args)
+            .map((pid) => `p${pid}\nn/work/${pid}\n`)
+            .join(""),
+          "",
+        );
+      } else if (file === "ps" && args[0] === "-o") {
+        cb(
+          null,
+          pidList(args)
+            .map((pid) => `${pid} Wed Mar 18 23:18:01 2026\n`)
+            .join(""),
+          "",
+        );
+      } else {
+        cb(new Error(`unexpected execFile ${file} ${args.join(" ")}`), "", "");
+      }
+    },
+  );
+}
+
+interface AdapterCase {
+  name: string;
+  create: (home: string) => AgentAdapter;
+  /** `ps -axo` lines for processes the adapter can handle. */
+  candidates: string[];
+  /** Name-matched processes the adapter keeps for parent chains but does not handle. */
+  nonCandidates?: string[];
+}
+
+const registryIn = (home: string) => new AgentRegistry(path.join(home, "agents.json"));
+
+const CASES: AdapterCase[] = [
+  {
+    name: "gemini (node)",
+    create: (home) => new GeminiCliAdapter(registryIn(home), { geminiTmpDir: home }),
+    candidates: ["1101 1 ttys001 node /usr/local/bin/gemini"],
+  },
+  {
+    name: "pi (node)",
+    create: (home) => new PiAdapter(registryIn(home)),
+    candidates: ["1201 1 ttys002 node /usr/local/bin/pi"],
+  },
+  {
+    name: "kiro (node)",
+    create: () => new KiroAdapter(),
+    candidates: ["1301 1 ttys003 kiro-cli"],
+    nonCandidates: [
+      "1302 1301 ttys003 kiro-cli-chat chat",
+      "1303 1302 ttys003 bun --no-env-file /opt/kiro-cli/tui.js chat",
+    ],
+  },
+  {
+    name: "claude",
+    create: () => new ClaudeCodeAdapter(),
+    candidates: ["1401 1 ttys004 /usr/local/bin/claude"],
+  },
+  {
+    name: "codex",
+    create: (home) => new CodexAdapter(registryIn(home)),
+    candidates: ["1501 1 ttys005 /opt/homebrew/bin/codex"],
+  },
+  {
+    name: "copilot",
+    create: (home) => new CopilotAdapter(registryIn(home)),
+    candidates: ["1601 1 ttys006 copilot"],
+  },
+  {
+    name: "grok",
+    create: () => new GrokCliAdapter(),
+    candidates: ["1701 1 ttys007 grok"],
+  },
+  {
+    name: "opencode",
+    create: (home) => new OpenCodeAdapter(path.join(home, "opencode.db")),
+    candidates: ["1801 1 ttys008 opencode"],
+  },
+  {
+    name: "antigravity",
+    create: () => new AntigravityCliAdapter(),
+    candidates: ["1901 1 ttys009 agy"],
+  },
+];
+
+const leadingPid = (line: string) => Number(line.trim().split(/\s+/)[0]);
+
+describe("adapter standalone snapshot candidate filtering", () => {
+  let home: string;
+  let savedEnv: Record<string, string | undefined>;
+
+  beforeEach(() => {
+    home = fs.mkdtempSync(path.join(os.tmpdir(), "adapter-candidates-test-"));
+    savedEnv = { HOME: process.env.HOME, ANTIGRAVITY_CLI_HOME: process.env.ANTIGRAVITY_CLI_HOME };
+    process.env.HOME = home;
+    process.env.ANTIGRAVITY_CLI_HOME = path.join(home, "antigravity");
+    mockedExecFile.mockReset();
+    mockedCaptureProcessSnapshot.mockClear();
+  });
+
+  afterEach(() => {
+    for (const [key, value] of Object.entries(savedEnv)) {
+      if (value === undefined) delete process.env[key];
+      else process.env[key] = value;
+    }
+    fs.rmSync(home, { recursive: true, force: true });
+  });
+
+  it.each(CASES)(
+    "$name: lsof and ps lstart receive only candidate PIDs",
+    async ({ create, candidates, nonCandidates = [] }) => {
+      installExec([...candidates, ...nonCandidates, ...UNRELATED_NODE_LINES]);
+      const adapter = create(home);
+      const candidatePids = candidates.map(leadingPid);
+
+      const agents = await adapter.detectAgents();
+
+      expect(agents.map((agent) => agent.pid).sort()).toEqual(candidatePids);
+      expect(pidsSentTo("lsof")).toEqual([candidatePids]);
+      expect(pidsSentTo("ps")).toEqual([candidatePids]);
+    },
+  );
+
+  it.each(CASES)(
+    "$name: passes a canHandle-based isCandidate predicate",
+    async ({ create, candidates }) => {
+      installExec(candidates);
+      const adapter = create(home);
+
+      await adapter.detectAgents();
+
+      expect(mockedCaptureProcessSnapshot).toHaveBeenCalledTimes(1);
+      const isCandidate = mockedCaptureProcessSnapshot.mock.calls[0][1]?.isCandidate;
+      expect(isCandidate).toBeTypeOf("function");
+      const candidate: ProcessInfo = {
+        pid: leadingPid(candidates[0]),
+        command: candidates[0].trim().split(/\s+/).slice(3).join(" "),
+        cwd: "",
+        tty: "",
+      };
+      const unrelated: ProcessInfo = { pid: 901, command: "node server.js", cwd: "", tty: "" };
+      expect(isCandidate?.(candidate)).toBe(true);
+      expect(isCandidate?.(unrelated)).toBe(false);
+    },
+  );
+
+  it("kiro: still walks an un-enriched kiro-cli-chat parent chain to the owning kiro-cli", async () => {
+    const sessionsDir = path.join(home, ".kiro", "sessions", "cli");
+    fs.mkdirSync(sessionsDir, { recursive: true });
+    fs.writeFileSync(path.join(sessionsDir, "sess-owner.lock"), JSON.stringify({ pid: 2303 }));
+    fs.writeFileSync(
+      path.join(sessionsDir, "sess-owner.jsonl"),
+      `${JSON.stringify({
+        kind: "Prompt",
+        timestamp: new Date().toISOString(),
+        data: { content: [{ kind: "text", data: "owned session" }] },
+      })}\n`,
+    );
+    installExec([
+      "2301 1 ttys010 kiro-cli",
+      "2302 2301 ttys010 kiro-cli-chat chat",
+      "2303 2302 ttys010 kiro-cli-chat acp",
+      ...UNRELATED_NODE_LINES,
+    ]);
+
+    const agents = await new KiroAdapter().detectAgents();
+
+    expect(agents).toEqual([
+      expect.objectContaining({ pid: 2301, sessionId: "sess-owner", projectPath: "/work/2301" }),
+    ]);
+    expect(pidsSentTo("lsof")).toEqual([[2301]]);
+    expect(pidsSentTo("ps")).toEqual([[2301]]);
+  });
+});

package/src/__tests__/capacity/anthropic.test.ts

@@ -0,0 +1,105 @@
+import { describe, expect, it, vi } from "vitest";
+import * as capacity from "../../capacity/index.js";
+import * as agentManager from "../../index.js";
+
+const checkedAt = "2026-09-30T12:00:00.000Z";
+const freshAuth = JSON.stringify({
+  anthropic: {
+    type: "oauth",
+    access: "fake-pi-anthropic-token",
+    refresh: "fake-pi-anthropic-refresh",
+    expires: Date.parse("2026-10-01T12:00:00.000Z"),
+  },
+});
+
+describe("Pi Anthropic capacity", () => {
+  it("exports a Pi Anthropic capacity report reader", () => {
+    expect(capacity).toHaveProperty("getAnthropicCapacityReport");
+    expect(agentManager).toHaveProperty("getAnthropicCapacityReport");
+  });
+
+  it("reads Pi's Anthropic OAuth credential and reports the Pi harness", async () => {
+    const readFile = vi.fn(async () => freshAuth);
+    const fetch = vi.fn(
+      async () =>
+        new Response(JSON.stringify({ five_hour: { utilization: 20 } }), {
+          status: 200,
+        }),
+    );
+
+    const report = await capacity.getAnthropicCapacityReport({
+      now: () => new Date(checkedAt),
+      env: { HOME: "/users/test" },
+      readFile,
+      fetch,
+    });
+
+    expect(readFile).toHaveBeenCalledWith("/users/test/.pi/agent/auth.json", "utf8");
+    expect(fetch).toHaveBeenCalledWith(
+      "https://api.anthropic.com/api/oauth/usage",
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          Authorization: "Bearer fake-pi-anthropic-token",
+        }),
+      }),
+    );
+    expect(report).toMatchObject({
+      harness: "pi",
+      provider: "anthropic",
+      generatedAt: checkedAt,
+      authenticated: true,
+      available: "yes",
+    });
+    expect(JSON.stringify(report)).not.toContain("fake-pi-anthropic-token");
+    expect(JSON.stringify(report)).not.toContain("fake-pi-anthropic-refresh");
+  });
+
+  it("does not fetch for an expired Pi login and returns a stale report", async () => {
+    const fetch = vi.fn();
+    const report = await capacity.getAnthropicCapacityReport({
+      now: () => new Date(checkedAt),
+      env: { HOME: "/users/test" },
+      readFile: async () =>
+        JSON.stringify({
+          anthropic: {
+            type: "oauth",
+            access: "fake-expired-token",
+            expires: 1,
+          },
+        }),
+      fetch,
+    });
+
+    expect(fetch).not.toHaveBeenCalled();
+    expect(report).toEqual({
+      harness: "pi",
+      provider: "anthropic",
+      generatedAt: checkedAt,
+      authenticated: true,
+      available: "unknown",
+      windows: [],
+      creditsRemaining: null,
+    });
+  });
+
+  it.each([
+    [
+      "missing file",
+      async () => Promise.reject(Object.assign(new Error("missing"), { code: "ENOENT" })),
+    ],
+    ["malformed file", async () => "{"],
+    ["missing credential", async () => "{}"],
+    ["malformed credential", async () => JSON.stringify({ anthropic: { type: "oauth" } })],
+  ])("rejects a %s without fetching", async (_name, readFile) => {
+    const fetch = vi.fn();
+    await expect(
+      capacity.getAnthropicCapacityReport({
+        now: () => new Date(checkedAt),
+        env: { HOME: "/users/test" },
+        readFile,
+        fetch,
+      }),
+    ).rejects.toThrow(/Pi Anthropic/);
+    expect(fetch).not.toHaveBeenCalled();
+  });
+});

package/src/__tests__/capacity/boundaries.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it } from "vitest";
+import { parseAnthropicCapacity } from "../../capacity/providers/anthropic.js";
+import { resolvePiAnthropicCredential } from "../../harnesses/pi/credentials.js";
+
+describe("capacity boundaries", () => {
+  it("keeps Pi credential extraction separate from Anthropic quota parsing", async () => {
+    const credential = await resolvePiAnthropicCredential({
+      env: { HOME: "/users/test" },
+      readFile: async () =>
+        JSON.stringify({
+          anthropic: {
+            type: "oauth",
+            access: "fake-boundary-token",
+            expires: Date.parse("2026-10-01T00:00:00.000Z"),
+          },
+        }),
+    });
+
+    const snapshot = parseAnthropicCapacity({ five_hour: { utilization: 25 } });
+
+    expect(credential).toEqual({
+      kind: "oauth",
+      access: "fake-boundary-token",
+      expiresMs: Date.parse("2026-10-01T00:00:00.000Z"),
+    });
+    expect(snapshot).toMatchObject({
+      authenticated: true,
+      available: "yes",
+      windows: [{ id: "session", usedPercent: 25 }],
+      creditsRemaining: null,
+    });
+    expect(snapshot).not.toHaveProperty("harness");
+    expect(snapshot).not.toHaveProperty("provider");
+    expect(snapshot).not.toHaveProperty("generatedAt");
+  });
+});

package/src/__tests__/capacity/claude.test.ts

@@ -2,7 +2,7 @@ import { readFile } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 import { describe, expect, it, vi } from "vitest";
 import * as capacity from "../../capacity/index.js";
-import { parseClaudeUsage } from "../../capacity/claude.js";
+import { parseAnthropicCapacity } from "../../capacity/providers/anthropic.js";
 import * as agentManager from "../../index.js";
 
 const fixture = (name: string) =>
@@ -226,10 +226,7 @@ describe("Claude capacity", () => {
   });
 
   it("preserves valid windows in a partial payload", async () => {
-    const report = parseClaudeUsage(
-      JSON.parse(await fixture("claude-usage-partial.json")),
-      "2026-09-25T18:00:00.000Z",
-    );
+    const report = parseAnthropicCapacity(JSON.parse(await fixture("claude-usage-partial.json")));
     expect(report.available).toBe("yes");
     expect(report.windows).toEqual([
       {
@@ -251,9 +248,7 @@ describe("Claude capacity", () => {
 
   it("rejects a non-object usage payload", async () => {
     const raw = JSON.parse(await fixture("claude-usage-malformed.json"));
-    expect(() => parseClaudeUsage(raw, "2026-09-25T18:00:00.000Z")).toThrow(
-      "Claude usage response is malformed",
-    );
+    expect(() => parseAnthropicCapacity(raw)).toThrow("Claude usage response is malformed");
   });
 
   it.each([

package/src/__tests__/capacity/codex.test.ts

@@ -3,9 +3,9 @@ import {
   CODEX_APP_SERVER_ARGS,
   parseUsage,
   probeCodexCapacity,
-  resolveCodexAuthPath,
-  toRateWindow,
-} from "../../capacity/codex.js";
+} from "../../capacity/sources/codex.js";
+import { resolveCodexAuthPath } from "../../harnesses/codex/credentials.js";
+import { toRateWindow } from "../../capacity/providers/openai-subscription.js";
 
 const checkedAt = "2026-08-20T10:00:00.000Z";
 const context = { installed: true, checkedAt };
@@ -52,9 +52,7 @@ describe("Codex auth resolution", () => {
   });
 
   it("falls back to ~/.codex/auth.json", () => {
-    expect(resolveCodexAuthPath({ HOME: "/users/test" })).toBe(
-      "/users/test/.codex/auth.json",
-    );
+    expect(resolveCodexAuthPath({ HOME: "/users/test" })).toBe("/users/test/.codex/auth.json");
   });
 });
 
@@ -108,9 +106,7 @@ describe("tiered Codex probing", () => {
           status: 200,
         }),
       )
-      .mockResolvedValueOnce(
-        new Response(JSON.stringify(apiUsage()), { status: 200 }),
-      );
+      .mockResolvedValueOnce(new Response(JSON.stringify(apiUsage()), { status: 200 }));
     const rpc = vi.fn();
     const result = await probeCodexCapacity({
       ...context,
@@ -129,9 +125,7 @@ describe("tiered Codex probing", () => {
     expect(fetch.mock.calls[0][0]).toBe(
       "https://auth.openai.com/api/accounts/v1/user-auth-credential/whoami",
     );
-    expect(fetch.mock.calls[1][0]).toBe(
-      "https://chatgpt.com/backend-api/wham/usage",
-    );
+    expect(fetch.mock.calls[1][0]).toBe("https://chatgpt.com/backend-api/wham/usage");
     expect(fetch.mock.calls[1][1].headers).toMatchObject({
       Authorization: "Bearer pat-secret",
       "ChatGPT-Account-Id": "acct-1",
@@ -154,9 +148,7 @@ describe("tiered Codex probing", () => {
   it("selects a fresh OAuth token without calling whoami", async () => {
     const fetch = vi
       .fn()
-      .mockResolvedValue(
-        new Response(JSON.stringify(apiUsage()), { status: 200 }),
-      );
+      .mockResolvedValue(new Response(JSON.stringify(apiUsage()), { status: 200 }));
     const result = await probeCodexCapacity({
       ...context,
       readFile: async () =>
@@ -210,9 +202,7 @@ describe("tiered Codex probing", () => {
   ])("falls back to the CLI for %s", async (name, readFile) => {
     const fetch = vi
       .fn()
-      .mockResolvedValue(
-        new Response("", { status: name === "OAuth 401" ? 401 : 200 }),
-      );
+      .mockResolvedValue(new Response("", { status: name === "OAuth 401" ? 401 : 200 }));
     const rpc = vi.fn(async () => ({
       rateLimits: {
         rateLimits: {
@@ -239,8 +229,7 @@ describe("tiered Codex probing", () => {
     }));
     const result = await probeCodexCapacity({
       ...context,
-      readFile: async () =>
-        JSON.stringify({ personal_access_token: "pat-secret" }),
+      readFile: async () => JSON.stringify({ personal_access_token: "pat-secret" }),
       fetch: vi.fn().mockRejectedValue(new Error("network failure pat-secret")),
       rpc,
     });
@@ -252,9 +241,7 @@ describe("tiered Codex probing", () => {
     const fetch = vi
       .fn()
       .mockRejectedValueOnce(new Error("PAT failed"))
-      .mockResolvedValueOnce(
-        new Response(JSON.stringify(apiUsage()), { status: 200 }),
-      );
+      .mockResolvedValueOnce(new Response(JSON.stringify(apiUsage()), { status: 200 }));
     const rpc = vi.fn();
     const result = await probeCodexCapacity({
       ...context,
@@ -294,13 +281,7 @@ describe("tiered Codex probing", () => {
       "account/read",
     ]);
     expect(JSON.stringify(messages)).not.toMatch(/prompt|turn\/start/);
-    expect(CODEX_APP_SERVER_ARGS).toEqual([
-      "-s",
-      "read-only",
-      "-a",
-      "untrusted",
-      "app-server",
-    ]);
+    expect(CODEX_APP_SERVER_ARGS).toEqual(["-s", "read-only", "-a", "untrusted", "app-server"]);
   });
 
   it("uses account/read to distinguish logged-out CLI state", async () => {
@@ -316,11 +297,7 @@ describe("tiered Codex probing", () => {
   });
 
   it("never exposes tokens or raw auth content through failures", async () => {
-    const secrets = [
-      "pat-secret-value",
-      "oauth-secret-value",
-      "refresh-secret-value",
-    ];
+    const secrets = ["pat-secret-value", "oauth-secret-value", "refresh-secret-value"];
     const result = await probeCodexCapacity({
       ...context,
       readFile: async () =>

package/src/__tests__/capacity/fixtures/openai-codex-auth.json

@@ -1,7 +1,7 @@
 {
   "openai-codex": {
     "type": "oauth",
-    "access": "fixture-header.eyJleHAiOjE3OTMwMDAwMDB9.fixture-signature",
+    "access": "sample access value for tests",
     "refresh": "fixture-refresh-token",
     "expires": 1793000000000,
     "accountId": "fixture-chatgpt-account-id"

package/src/__tests__/capacity/openai.test.ts

@@ -2,15 +2,17 @@ import { readFile } from "node:fs/promises";
 import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { describe, expect, it, vi } from "vitest";
+import { probeOpenAiCapacity } from "../../capacity/sources/pi.js";
 import {
-  buildOpenAiReport,
+  buildOpenAiPlatformCapacity,
   parseOpenAiUsage,
-  probeOpenAiCapacity,
-  resolveOpenAiApiKey,
-  resolveOpenAiCredential,
-} from "../../capacity/openai.js";
+} from "../../capacity/providers/openai-platform.js";
+import { resolvePiOpenAiCredential as resolveOpenAiCredential } from "../../harnesses/pi/credentials.js";
 
 const checkedAt = "2026-09-26T10:00:00.000Z";
+const fixtureOauthAccess = "sample access value for tests";
+const fakeJwt = (payload: string) =>
+  ["test", Buffer.from(payload).toString("base64url"), "test"].join(".");
 const fixture = (name: string) =>
   readFile(fileURLToPath(new URL(`./fixtures/${name}`, import.meta.url)), "utf8");
 const fixtureString = (name: string) =>
@@ -20,19 +22,19 @@ describe("OpenAI credential resolution", () => {
   it("prefers OPENAI_API_KEY without reading Pi auth", async () => {
     const readAuth = vi.fn(async () => fixture("openai-auth.json"));
     await expect(
-      resolveOpenAiApiKey({
+      resolveOpenAiCredential({
         env: { OPENAI_API_KEY: "env-openai-test-key" },
         readFile: readAuth,
       }),
-    ).resolves.toBe("env-openai-test-key");
+    ).resolves.toEqual({ kind: "platform", key: "env-openai-test-key" });
     expect(readAuth).not.toHaveBeenCalled();
   });
 
   it("reads the Pi openai api_key credential from ~/.pi/agent/auth.json", async () => {
     const readAuth = vi.fn(async () => fixture("openai-auth.json"));
     await expect(
-      resolveOpenAiApiKey({ env: { HOME: "/users/test" }, readFile: readAuth }),
-    ).resolves.toBe("pi-openai-test-key");
+      resolveOpenAiCredential({ env: { HOME: "/users/test" }, readFile: readAuth }),
+    ).resolves.toEqual({ kind: "platform", key: "pi-openai-test-key" });
     expect(readAuth).toHaveBeenCalledWith("/users/test/.pi/agent/auth.json", "utf8");
   });
 
@@ -46,7 +48,7 @@ describe("OpenAI credential resolution", () => {
     ["missing key", async () => JSON.stringify({ openai: { type: "api_key" } })],
   ])("fails clearly for %s credentials without exposing file content", async (_name, readAuth) => {
     await expect(
-      resolveOpenAiApiKey({
+      resolveOpenAiCredential({
         env: { HOME: "/users/test" },
         readFile: readAuth,
       }),
@@ -60,7 +62,7 @@ describe("OpenAI tiered credential resolution", () => {
     openai: { type: "api_key", key: "pi-openai-test-key" },
     "openai-codex": {
       type: "oauth",
-      access: "fixture-header.eyJleHAiOjE3OTMwMDAwMDB9.fixture-signature",
+      access: fixtureOauthAccess,
       refresh: "fixture-refresh-token",
       expires: 1793000000000,
       accountId: "fixture-chatgpt-account-id",
@@ -84,7 +86,7 @@ describe("OpenAI tiered credential resolution", () => {
       }),
     ).resolves.toEqual({
       kind: "oauth",
-      access: "fixture-header.eyJleHAiOjE3OTMwMDAwMDB9.fixture-signature",
+      access: fixtureOauthAccess,
       accountId: "fixture-chatgpt-account-id",
       expiresMs: 1793000000000,
     });
@@ -130,15 +132,6 @@ describe("OpenAI tiered credential resolution", () => {
       ).rejects.toThrow("OpenAI credentials not found");
     },
   );
-
-  it("still throws for OAuth-only machines on the legacy platform-key resolver", async () => {
-    await expect(
-      resolveOpenAiApiKey({
-        env: { HOME: "/users/test" },
-        readFile: async () => oauthFixture(),
-      }),
-    ).rejects.toThrow("OpenAI credentials not found");
-  });
 });
 
 describe("OpenAI OAuth capacity probe", () => {
@@ -158,7 +151,7 @@ describe("OpenAI OAuth capacity probe", () => {
       expect.objectContaining({
         method: "GET",
         headers: {
-          Authorization: "Bearer fixture-header.eyJleHAiOjE3OTMwMDAwMDB9.fixture-signature",
+          Authorization: `Bearer ${fixtureOauthAccess}`,
           "ChatGPT-Account-Id": "fixture-chatgpt-account-id",
         },
       }),
@@ -227,7 +220,7 @@ describe("OpenAI OAuth capacity probe", () => {
     const expiredJwtAuth = JSON.stringify({
       "openai-codex": {
         type: "oauth",
-        access: "h.eyJleHAiOjE3ODkwMDAwMDB9.s",
+        access: fakeJwt(JSON.stringify({ exp: 1789000000 })),
         accountId: "fixture-chatgpt-account-id",
       },
     });
@@ -245,7 +238,7 @@ describe("OpenAI OAuth capacity probe", () => {
     const futureJwtAuth = JSON.stringify({
       "openai-codex": {
         type: "oauth",
-        access: "h.eyJleHAiOjE3OTMwMDAwMDB9.s",
+        access: fakeJwt(JSON.stringify({ exp: 1793000000 })),
         accountId: "fixture-chatgpt-account-id",
       },
     });
@@ -265,7 +258,7 @@ describe("OpenAI OAuth capacity probe", () => {
     const auth = JSON.stringify({
       "openai-codex": {
         type: "oauth",
-        access: "fixture-header.bm90LWpzb24.fixture-signature",
+        access: fakeJwt("not-json"),
         accountId: "fixture-chatgpt-account-id",
       },
     });
@@ -401,11 +394,8 @@ describe("OpenAI usage mapping", () => {
       ...parseOpenAiUsage(JSON.parse(await fixture("openai-usage-completions.json"))),
       ...parseOpenAiUsage(JSON.parse(await fixture("openai-usage-responses.json"))),
     ];
-    const report = buildOpenAiReport(buckets, checkedAt);
+    const report = buildOpenAiPlatformCapacity(buckets, checkedAt);
     expect(report).toMatchObject({
-      harness: "pi",
-      provider: "openai",
-      generatedAt: checkedAt,
       authenticated: true,
       available: "yes",
       creditsRemaining: null,
@@ -437,7 +427,7 @@ describe("OpenAI usage mapping", () => {
   });
 
   it("reports zero usage for days without buckets", () => {
-    const report = buildOpenAiReport([], checkedAt);
+    const report = buildOpenAiPlatformCapacity([], checkedAt);
     expect(report.windows.map((window) => window.current)).toEqual([0, 0]);
     expect(report.windows[0].resetsAt).toBe("2026-09-27T00:00:00.000Z");
   });