@ai-devkit/agent-manager 0.37.0 → 0.38.0

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,14 +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,
-  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) =>
@@ -59,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",
@@ -83,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,
     });
@@ -148,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",
         },
       }),
@@ -217,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",
       },
     });
@@ -235,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",
       },
     });
@@ -255,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",
       },
     });
@@ -391,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,
@@ -427,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");
   });

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

@@ -1,7 +1,7 @@
 import { readFile } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 import { describe, expect, it } from "vitest";
-import { parseWhamUsage, toRateWindow } from "../../capacity/wham.js";
+import { parseWhamUsage, toRateWindow } from "../../capacity/providers/openai-subscription.js";
 
 const fixture = (name: string) =>
   readFile(fileURLToPath(new URL(`./fixtures/${name}`, import.meta.url)), "utf8");

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

@@ -1,18 +1,13 @@
 import { readFile } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 import { describe, expect, it, vi } from "vitest";
-import {
-  parseZaiQuota,
-  probeZaiCapacity,
-  resolveZaiApiKey,
-} from "../../capacity/zai.js";
+import { parseZaiCapacity } from "../../capacity/providers/zai.js";
+import { probeZaiCapacity } from "../../capacity/sources/pi.js";
+import { resolvePiZaiApiKey as resolveZaiApiKey } from "../../harnesses/pi/credentials.js";
 
 const checkedAt = "2026-08-20T10:00:00.000Z";
 const fixture = (name: string) =>
-  readFile(
-    fileURLToPath(new URL(`./fixtures/${name}`, import.meta.url)),
-    "utf8",
-  );
+  readFile(fileURLToPath(new URL(`./fixtures/${name}`, import.meta.url)), "utf8");
 
 describe("z.ai credential resolution", () => {
   it("prefers Z_AI_API_KEY without reading Pi auth", async () => {
@@ -31,44 +26,28 @@ describe("z.ai credential resolution", () => {
     await expect(
       resolveZaiApiKey({ env: { HOME: "/users/test" }, readFile: readAuth }),
     ).resolves.toBe("pi-zai-test-key");
-    expect(readAuth).toHaveBeenCalledWith(
-      "/users/test/.pi/agent/auth.json",
-      "utf8",
-    );
+    expect(readAuth).toHaveBeenCalledWith("/users/test/.pi/agent/auth.json", "utf8");
   });
 
   it.each([
     [
       "missing",
-      async () =>
-        Promise.reject(Object.assign(new Error("missing"), { code: "ENOENT" })),
+      async () => Promise.reject(Object.assign(new Error("missing"), { code: "ENOENT" })),
     ],
     ["invalid JSON", async () => "{"],
-    [
-      "wrong credential type",
-      async () => JSON.stringify({ zai: { type: "oauth", key: "x" } }),
-    ],
+    ["wrong credential type", async () => JSON.stringify({ zai: { type: "oauth", key: "x" } })],
     ["missing key", async () => JSON.stringify({ zai: { type: "api_key" } })],
-  ])(
-    "fails clearly for %s credentials without exposing file content",
-    async (_name, readAuth) => {
-      await expect(
-        resolveZaiApiKey({ env: { HOME: "/users/test" }, readFile: readAuth }),
-      ).rejects.toThrow(/z\.ai API key|z\.ai Pi auth file/);
-    },
-  );
+  ])("fails clearly for %s credentials without exposing file content", async (_name, readAuth) => {
+    await expect(
+      resolveZaiApiKey({ env: { HOME: "/users/test" }, readFile: readAuth }),
+    ).rejects.toThrow(/z\.ai API key|z\.ai Pi auth file/);
+  });
 });
 
 describe("z.ai quota mapping", () => {
   it("maps token, credit, and monthly MCP windows with recomputed usage", async () => {
-    const report = parseZaiQuota(
-      JSON.parse(await fixture("zai-quota.json")),
-      checkedAt,
-    );
+    const report = parseZaiCapacity(JSON.parse(await fixture("zai-quota.json")));
     expect(report).toMatchObject({
-      harness: "pi",
-      provider: "zai",
-      generatedAt: checkedAt,
       authenticated: true,
       available: "yes",
       creditsRemaining: null,
@@ -111,40 +90,26 @@ describe("z.ai quota mapping", () => {
   });
 
   it("uses and clamps the server percentage when quota amounts are unavailable", () => {
-    const report = parseZaiQuota(
-      {
-        success: true,
-        code: 200,
-        data: {
-          limits: [
-            { type: "TOKENS_LIMIT", unit: 1, number: 1, percentage: 120 },
-            { type: "CREDIT_LIMIT", unit: 5, number: 30, percentage: -5 },
-          ],
-        },
+    const report = parseZaiCapacity({
+      success: true,
+      code: 200,
+      data: {
+        limits: [
+          { type: "TOKENS_LIMIT", unit: 1, number: 1, percentage: 120 },
+          { type: "CREDIT_LIMIT", unit: 5, number: 30, percentage: -5 },
+        ],
       },
-      checkedAt,
-    );
-    expect(report.windows.map((window) => window.usedPercent)).toEqual([
-      100, 0,
-    ]);
+    });
+    expect(report.windows.map((window) => window.usedPercent)).toEqual([100, 0]);
   });
 
   it.each([
-    [
-      "invalid fixture",
-      async () => JSON.parse(await fixture("zai-quota-invalid.json")),
-    ],
-    [
-      "unsuccessful envelope",
-      async () => ({ success: false, code: 401, data: { limits: [] } }),
-    ],
-    [
-      "invalid entry",
-      async () => ({ success: true, code: 200, data: { limits: [{}] } }),
-    ],
+    ["invalid fixture", async () => JSON.parse(await fixture("zai-quota-invalid.json"))],
+    ["unsuccessful envelope", async () => ({ success: false, code: 401, data: { limits: [] } })],
+    ["invalid entry", async () => ({ success: true, code: 200, data: { limits: [{}] } })],
   ])("rejects %s", async (_name, input) => {
     const value = await input();
-    expect(() => parseZaiQuota(value, checkedAt)).toThrow(/z\.ai quota/);
+    expect(() => parseZaiCapacity(value)).toThrow(/z\.ai quota/);
   });
 });
 

package/src/__tests__/harnesses/claude/durable/ClaudePrintAgent.integration.test.ts

@@ -3,10 +3,10 @@ import os from "node:os";
 import path from "node:path";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import {
-  ClaudePrintAgentService,
   DurableAgentRepository,
   type ProcessInspector,
-} from "../../../../index.js";
+} from "../../../../durable/DurableAgentRepository.js";
+import { ClaudePrintAgentService } from "../../../../harnesses/claude/durable/ClaudePrintAgentService.js";
 
 const roots: string[] = [];
 

package/src/__tests__/harnesses/claude/durable/ClaudePrintRunner.test.ts

@@ -1,7 +1,7 @@
 import { EventEmitter } from "node:events";
 import { PassThrough, Writable } from "node:stream";
 import { describe, expect, it, vi } from "vitest";
-import type { DurableAgent } from "../../../../index.js";
+import type { DurableAgent } from "../../../../durable/DurableAgent.js";
 import { ClaudePrintRunner } from "../../../../harnesses/claude/durable/ClaudePrintRunner.js";
 
 function agent(): DurableAgent {

package/src/__tests__/harnesses/codex/durable/CodexCliProbe.test.ts

@@ -1,9 +1,8 @@
 import { describe, expect, it, vi } from "vitest";
+import { CodexCliProbe } from "../../../../harnesses/codex/durable/CodexCliProbe.js";
 
 describe("CodexCliProbe", () => {
   it("validates version, exec JSON/stdin, and resume capabilities without a model call", async () => {
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
-    expect(api).toHaveProperty("CodexCliProbe");
     const exec = vi
       .fn()
       .mockResolvedValueOnce({ stdout: "codex-cli 0.147.0", stderr: "" })
@@ -15,12 +14,12 @@ describe("CodexCliProbe", () => {
         stdout: "Usage: codex exec resume [SESSION_ID] [PROMPT]\n--json\n- stdin",
         stderr: "",
       });
-    const Probe = api.CodexCliProbe as new (options: unknown) => any;
-
-    await expect(new Probe({ executable: "fake-codex", exec }).validate()).resolves.toEqual({
-      executable: "fake-codex",
-      version: "codex-cli 0.147.0",
-    });
+    await expect(new CodexCliProbe({ executable: "fake-codex", exec }).validate()).resolves.toEqual(
+      {
+        executable: "fake-codex",
+        version: "codex-cli 0.147.0",
+      },
+    );
     expect(exec.mock.calls).toEqual([
       ["fake-codex", ["--version"]],
       ["fake-codex", ["exec", "--help"]],
@@ -29,9 +28,7 @@ describe("CodexCliProbe", () => {
   });
 
   it("rejects unsupported and unavailable CLIs with bounded sanitized errors", async () => {
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
-    const Probe = api.CodexCliProbe as new (options: unknown) => any;
-    const unsupported = new Probe({
+    const unsupported = new CodexCliProbe({
       exec: vi
         .fn()
         .mockResolvedValueOnce({ stdout: "version", stderr: "" })
@@ -39,7 +36,7 @@ describe("CodexCliProbe", () => {
         .mockResolvedValueOnce({ stdout: "resume", stderr: "" }),
     });
     await expect(unsupported.validate()).rejects.toMatchObject({ code: "CODEX_CLI_UNSUPPORTED" });
-    const missingCommands = new Probe({
+    const missingCommands = new CodexCliProbe({
       exec: vi
         .fn()
         .mockResolvedValueOnce({ stdout: "version", stderr: "" })
@@ -50,7 +47,7 @@ describe("CodexCliProbe", () => {
       code: "CODEX_CLI_UNSUPPORTED",
     });
 
-    const unavailable = new Probe({
+    const unavailable = new CodexCliProbe({
       exec: vi.fn().mockRejectedValue(new Error(`bad\0${"x".repeat(1000)}`)),
     });
     const error = await unavailable.validate().catch((value: Error & { code: string }) => value);
@@ -60,25 +57,23 @@ describe("CodexCliProbe", () => {
   });
 
   it("reports an empty version response as unknown", async () => {
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
-    const Probe = api.CodexCliProbe as new (options: unknown) => any;
     const exec = vi
       .fn()
       .mockResolvedValueOnce({ stdout: " \n", stderr: "" })
       .mockResolvedValueOnce({ stdout: "exec --json -", stderr: "" })
       .mockResolvedValueOnce({ stdout: "resume --json -", stderr: "" });
-    await expect(new Probe({ exec }).validate()).resolves.toMatchObject({ version: "unknown" });
+    await expect(new CodexCliProbe({ exec }).validate()).resolves.toMatchObject({
+      version: "unknown",
+    });
   });
 
   it("requires a standalone stdin dash rather than accepting flag hyphens", async () => {
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
-    const Probe = api.CodexCliProbe as new (options: unknown) => any;
     const exec = vi
       .fn()
       .mockResolvedValueOnce({ stdout: "version", stderr: "" })
       .mockResolvedValueOnce({ stdout: "exec --json", stderr: "" })
       .mockResolvedValueOnce({ stdout: "resume --json", stderr: "" });
-    await expect(new Probe({ exec }).validate()).rejects.toMatchObject({
+    await expect(new CodexCliProbe({ exec }).validate()).rejects.toMatchObject({
       code: "CODEX_CLI_UNSUPPORTED",
     });
   });

package/src/__tests__/harnesses/codex/durable/CodexPrintAgent.integration.test.ts

@@ -2,12 +2,12 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { afterEach, describe, expect, it, vi } from "vitest";
+import { CodexPrintError } from "../../../../durable/DurableAgent.js";
 import {
-  CodexPrintError,
-  CodexPrintAgentService,
   DurableAgentRepository,
   type ProcessInspector,
-} from "../../../../index.js";
+} from "../../../../durable/DurableAgentRepository.js";
+import { CodexPrintAgentService } from "../../../../harnesses/codex/durable/CodexPrintAgentService.js";
 
 const SESSION = "22222222-2222-4222-8222-222222222222";
 const roots: string[] = [];

package/src/__tests__/harnesses/codex/durable/CodexPrintAgentService.test.ts

@@ -1,4 +1,6 @@
 import { describe, expect, it, vi } from "vitest";
+import { CodexPrintError } from "../../../../durable/DurableAgent.js";
+import { CodexPrintAgentService } from "../../../../harnesses/codex/durable/CodexPrintAgentService.js";
 
 const SESSION = "22222222-2222-4222-8222-222222222222";
 const base = {
@@ -11,15 +13,15 @@ const base = {
 
 describe("CodexPrintAgentService", () => {
   it("validates before provider-aware create and never runs Codex", async () => {
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
-    expect(api).toHaveProperty("CodexPrintAgentService");
     const probe = {
       validate: vi.fn().mockResolvedValue({ executable: "codex", version: "0.147.0" }),
     };
     const repository = { create: vi.fn().mockResolvedValue(base) };
     const runner = { run: vi.fn() };
-    const Service = api.CodexPrintAgentService as new (options: unknown) => any;
-    await new Service({ repository, probe, runner }).create({ name: "reviewer", cwd: "/project" });
+    await new CodexPrintAgentService({ repository, probe, runner }).create({
+      name: "reviewer",
+      cwd: "/project",
+    });
     expect(repository.create).toHaveBeenCalledWith({
       name: "reviewer",
       cwd: "/project",
@@ -29,7 +31,6 @@ describe("CodexPrintAgentService", () => {
   });
 
   it("binds during first send and explicitly resumes later sends", async () => {
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
     const repository = {
       resolve: vi.fn().mockResolvedValue(base),
       acquireRun: vi
@@ -50,8 +51,7 @@ describe("CodexPrintAgentService", () => {
         return { sessionId: SESSION, result: "answer", messages: ["answer"], exitCode: 0 };
       }),
     };
-    const Service = api.CodexPrintAgentService as new (options: unknown) => any;
-    const service = new Service({
+    const service = new CodexPrintAgentService({
       repository,
       probe: { validate: vi.fn() },
       runner,
@@ -74,8 +74,6 @@ describe("CodexPrintAgentService", () => {
   });
 
   it("records mismatch separately from unknown failures", async () => {
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
-    const ErrorType = api.CodexPrintError as new (message: string, code: string) => Error;
     const completeRun = vi.fn();
     const repository = {
       resolve: vi.fn().mockResolvedValue(base),
@@ -84,12 +82,11 @@ describe("CodexPrintAgentService", () => {
       bindProviderSession: vi.fn(),
       completeRun,
     };
-    const Service = api.CodexPrintAgentService as new (options: unknown) => any;
-    const service = new Service({
+    const service = new CodexPrintAgentService({
       repository,
       probe: { validate: vi.fn() },
       runner: {
-        run: vi.fn().mockRejectedValue(new ErrorType("mismatch", "CODEX_SESSION_MISMATCH")),
+        run: vi.fn().mockRejectedValue(new CodexPrintError("mismatch", "CODEX_SESSION_MISMATCH")),
       },
     });
     await expect(service.send("reviewer", "x")).rejects.toMatchObject({
@@ -103,8 +100,6 @@ describe("CodexPrintAgentService", () => {
   });
 
   it("rejects a non-Codex target without acquiring or mutating it", async () => {
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
-    const Service = api.CodexPrintAgentService as new (options: unknown) => any;
     const repository = {
       resolve: vi.fn().mockResolvedValue({ ...base, provider: "claude" }),
       acquireRun: vi.fn(),
@@ -114,18 +109,17 @@ describe("CodexPrintAgentService", () => {
     };
 
     await expect(
-      new Service({ repository, probe: { validate: vi.fn() }, runner: { run: vi.fn() } }).send(
-        "reviewer",
-        "x",
-      ),
+      new CodexPrintAgentService({
+        repository,
+        probe: { validate: vi.fn() },
+        runner: { run: vi.fn() },
+      }).send("reviewer", "x"),
     ).rejects.toMatchObject({ code: "CODEX_UNSUPPORTED" });
     expect(repository.acquireRun).not.toHaveBeenCalled();
     expect(repository.completeRun).not.toHaveBeenCalled();
   });
 
   it("does not turn a successful completion write failure into a second completion", async () => {
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
-    const Service = api.CodexPrintAgentService as new (options: unknown) => any;
     const completionFailure = new Error("completion failed");
     const repository = {
       resolve: vi.fn().mockResolvedValue(base),
@@ -144,14 +138,15 @@ describe("CodexPrintAgentService", () => {
     };
 
     await expect(
-      new Service({ repository, probe: { validate: vi.fn() }, runner }).send("reviewer", "x"),
+      new CodexPrintAgentService({ repository, probe: { validate: vi.fn() }, runner }).send(
+        "reviewer",
+        "x",
+      ),
     ).rejects.toBe(completionFailure);
     expect(repository.completeRun).toHaveBeenCalledOnce();
   });
 
   it("records a repository binding conflict as a session mismatch", async () => {
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
-    const BindingError = api.CodexPrintError as new (message: string, code: string) => Error;
     const completeRun = vi.fn();
     const repository = {
       resolve: vi.fn().mockResolvedValue(base),
@@ -159,7 +154,7 @@ describe("CodexPrintAgentService", () => {
       recordProviderProcess: vi.fn(),
       bindProviderSession: vi
         .fn()
-        .mockRejectedValue(new BindingError("binding mismatch", "CODEX_SESSION_MISMATCH")),
+        .mockRejectedValue(new CodexPrintError("binding mismatch", "CODEX_SESSION_MISMATCH")),
       completeRun,
     };
     const runner = {
@@ -168,10 +163,11 @@ describe("CodexPrintAgentService", () => {
         return { sessionId: SESSION, result: "x", messages: ["x"], exitCode: 0 };
       }),
     };
-    const Service = api.CodexPrintAgentService as new (options: unknown) => any;
-
     await expect(
-      new Service({ repository, probe: { validate: vi.fn() }, runner }).send("reviewer", "x"),
+      new CodexPrintAgentService({ repository, probe: { validate: vi.fn() }, runner }).send(
+        "reviewer",
+        "x",
+      ),
     ).rejects.toMatchObject({ code: "CODEX_SESSION_MISMATCH" });
     expect(completeRun).toHaveBeenCalledWith(
       "id",
@@ -181,8 +177,6 @@ describe("CodexPrintAgentService", () => {
   });
 
   it("rejects missing and ambiguous records before acquiring a run", async () => {
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
-    const Service = api.CodexPrintAgentService as new (options: unknown) => any;
     const repository = {
       create: vi.fn(),
       resolve: vi.fn().mockResolvedValueOnce(null).mockResolvedValueOnce([base, base]),
@@ -191,7 +185,7 @@ describe("CodexPrintAgentService", () => {
       bindProviderSession: vi.fn(),
       completeRun: vi.fn(),
     };
-    const service = new Service({
+    const service = new CodexPrintAgentService({
       repository,
       probe: { validate: vi.fn() },
       runner: { run: vi.fn() },