@ai-devkit/agent-manager 0.37.0 → 0.38.0

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

@@ -1,7 +1,8 @@
 import { EventEmitter } from "node:events";
 import { PassThrough, Writable } from "node:stream";
 import { describe, expect, it, vi } from "vitest";
-import type { CodexDurableAgent } from "../../../../index.js";
+import type { CodexDurableAgent } from "../../../../durable/DurableAgent.js";
+import { CodexPrintRunner } from "../../../../harnesses/codex/durable/CodexPrintRunner.js";
 
 const SESSION = "22222222-2222-4222-8222-222222222222";
 
@@ -64,10 +65,7 @@ function events(session = SESSION): string[] {
 }
 
 async function runner(fixture: ReturnType<typeof fakeSpawn>, maxLineBytes?: number) {
-  const api = (await import("../../../../index.js")) as Record<string, unknown>;
-  expect(api).toHaveProperty("CodexPrintRunner");
-  const Runner = api.CodexPrintRunner as new (options: unknown) => any;
-  return new Runner({
+  return new CodexPrintRunner({
     spawn: fixture.spawn,
     maxLineBytes,
     processInspector: {
@@ -262,10 +260,8 @@ describe("CodexPrintRunner", () => {
   });
 
   it("rejects an unverifiable positive PID", async () => {
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
     const fixture = fakeSpawn([]);
-    const Runner = api.CodexPrintRunner as new (options: unknown) => any;
-    const instance = new Runner({
+    const instance = new CodexPrintRunner({
       spawn: fixture.spawn,
       processInspector: { getIdentity: () => null },
     });

package/src/__tests__/harnesses/pi/durable/PiCliProbe.test.ts

@@ -1,9 +1,8 @@
 import { describe, expect, it, vi } from "vitest";
+import { PiCliProbe } from "../../../../harnesses/pi/durable/PiCliProbe.js";
 
 describe("PiCliProbe", () => {
   it("validates documented JSON mode and session capabilities", async () => {
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
-    expect(api).toHaveProperty("PiCliProbe");
     const exec = vi
       .fn()
       .mockResolvedValueOnce({ stdout: "pi 0.52.8", stderr: "" })
@@ -11,8 +10,7 @@ describe("PiCliProbe", () => {
         stdout: "--mode json\n--session-id <uuid>\n--session <path|id>",
         stderr: "",
       });
-    const Probe = api.PiCliProbe as new (options: unknown) => any;
-    await expect(new Probe({ executable: "fake-pi", exec }).validate()).resolves.toEqual({
+    await expect(new PiCliProbe({ executable: "fake-pi", exec }).validate()).resolves.toEqual({
       executable: "fake-pi",
       version: "pi 0.52.8",
     });
@@ -23,17 +21,15 @@ describe("PiCliProbe", () => {
   });
 
   it("rejects unsupported and unavailable CLIs with sanitized errors", async () => {
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
-    const Probe = api.PiCliProbe as new (options: unknown) => any;
     await expect(
-      new Probe({
+      new PiCliProbe({
         exec: vi
           .fn()
           .mockResolvedValueOnce({ stdout: "", stderr: "" })
           .mockResolvedValueOnce({ stdout: "--print only", stderr: "" }),
       }).validate(),
     ).rejects.toMatchObject({ code: "PI_CLI_UNSUPPORTED" });
-    const unavailable = new Probe({
+    const unavailable = new PiCliProbe({
       exec: vi.fn().mockRejectedValue(new Error(`bad\0${"x".repeat(1000)}`)),
     });
     const error = await unavailable.validate().catch((value: Error & { code: string }) => value);
@@ -43,12 +39,12 @@ describe("PiCliProbe", () => {
   });
 
   it("reports an empty version as unknown", async () => {
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
-    const Probe = api.PiCliProbe as new (options: unknown) => any;
     const exec = vi
       .fn()
       .mockResolvedValueOnce({ stdout: " \n", stderr: "" })
       .mockResolvedValueOnce({ stdout: "--mode json --session-id --session", stderr: "" });
-    await expect(new Probe({ exec }).validate()).resolves.toMatchObject({ version: "unknown" });
+    await expect(new PiCliProbe({ exec }).validate()).resolves.toMatchObject({
+      version: "unknown",
+    });
   });
 });

package/src/__tests__/harnesses/pi/durable/PiPrintAgentService.test.ts

@@ -1,4 +1,6 @@
 import { describe, expect, it, vi } from "vitest";
+import { PiPrintError } from "../../../../durable/DurableAgent.js";
+import { PiPrintAgentService } from "../../../../harnesses/pi/durable/PiPrintAgentService.js";
 const SESSION = "22222222-2222-4222-8222-222222222222";
 const base = {
   id: "id",
@@ -10,13 +12,13 @@ const base = {
 
 describe("PiPrintAgentService", () => {
   it("probes before provider-aware create", async () => {
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
-    expect(api).toHaveProperty("PiPrintAgentService");
     const probe = { validate: vi.fn() };
     const repository = { create: vi.fn().mockResolvedValue(base), list: vi.fn() };
     const runner = { run: vi.fn() };
-    const Service = api.PiPrintAgentService as new (options: unknown) => any;
-    await new Service({ repository, probe, runner }).create({ name: "reviewer", cwd: "/project" });
+    await new PiPrintAgentService({ repository, probe, runner }).create({
+      name: "reviewer",
+      cwd: "/project",
+    });
     expect(probe.validate).toHaveBeenCalledOnce();
     expect(repository.create).toHaveBeenCalledWith({
       name: "reviewer",
@@ -26,7 +28,6 @@ describe("PiPrintAgentService", () => {
   });
 
   it("records successful first and resumed sends", async () => {
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
     const repository = {
       list: vi.fn(),
       resolve: vi.fn().mockResolvedValue(base),
@@ -43,8 +44,7 @@ describe("PiPrintAgentService", () => {
         return { sessionId: SESSION, result: "answer", messages: ["answer"], exitCode: 0 };
       }),
     };
-    const Service = api.PiPrintAgentService as new (options: unknown) => any;
-    const service = new Service({ repository, probe: { validate: vi.fn() }, runner });
+    const service = new PiPrintAgentService({ repository, probe: { validate: vi.fn() }, runner });
     await service.send("reviewer", "first");
     await service.send("reviewer", "later");
     expect(repository.completeRun).toHaveBeenCalledWith(
@@ -55,8 +55,6 @@ describe("PiPrintAgentService", () => {
   });
 
   it("records mismatches and rejects missing and ambiguous records", async () => {
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
-    const ErrorType = api.PiPrintError as new (message: string, code: string) => Error;
     const completeRun = vi.fn();
     const repository = {
       list: vi.fn(),
@@ -65,12 +63,11 @@ describe("PiPrintAgentService", () => {
       recordProviderProcess: vi.fn(),
       completeRun,
     };
-    const Service = api.PiPrintAgentService as new (options: unknown) => any;
     await expect(
-      new Service({
+      new PiPrintAgentService({
         repository,
         probe: { validate: vi.fn() },
-        runner: { run: vi.fn().mockRejectedValue(new ErrorType("bad", "PI_SESSION_MISMATCH")) },
+        runner: { run: vi.fn().mockRejectedValue(new PiPrintError("bad", "PI_SESSION_MISMATCH")) },
       }).send("reviewer", "x"),
     ).rejects.toMatchObject({ code: "PI_SESSION_MISMATCH" });
     expect(completeRun).toHaveBeenCalledWith(
@@ -83,7 +80,7 @@ describe("PiPrintAgentService", () => {
       resolve: vi.fn().mockResolvedValueOnce(null).mockResolvedValueOnce([base, base]),
       acquireRun: vi.fn(),
     };
-    const early = new Service({
+    const early = new PiPrintAgentService({
       repository: earlyRepository,
       probe: { validate: vi.fn() },
       runner: { run: vi.fn() },
@@ -95,8 +92,6 @@ describe("PiPrintAgentService", () => {
   });
 
   it("rejects a non-Pi target without acquiring or mutating it", async () => {
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
-    const Service = api.PiPrintAgentService as new (options: unknown) => any;
     const repository = {
       resolve: vi.fn().mockResolvedValue({ ...base, provider: "claude" }),
       acquireRun: vi.fn(),
@@ -105,18 +100,17 @@ describe("PiPrintAgentService", () => {
     };
 
     await expect(
-      new Service({ repository, probe: { validate: vi.fn() }, runner: { run: vi.fn() } }).send(
-        "reviewer",
-        "x",
-      ),
+      new PiPrintAgentService({
+        repository,
+        probe: { validate: vi.fn() },
+        runner: { run: vi.fn() },
+      }).send("reviewer", "x"),
     ).rejects.toMatchObject({ code: "PI_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.PiPrintAgentService as new (options: unknown) => any;
     const completionFailure = new Error("completion failed");
     const repository = {
       resolve: vi.fn().mockResolvedValue(base),
@@ -134,7 +128,10 @@ describe("PiPrintAgentService", () => {
     };
 
     await expect(
-      new Service({ repository, probe: { validate: vi.fn() }, runner }).send("reviewer", "x"),
+      new PiPrintAgentService({ repository, probe: { validate: vi.fn() }, runner }).send(
+        "reviewer",
+        "x",
+      ),
     ).rejects.toBe(completionFailure);
     expect(repository.completeRun).toHaveBeenCalledOnce();
   });

package/src/__tests__/harnesses/pi/durable/PiPrintRunner.test.ts

@@ -1,7 +1,8 @@
 import { EventEmitter } from "node:events";
 import { PassThrough, Writable } from "node:stream";
 import { describe, expect, it, vi } from "vitest";
-import type { PiDurableAgent } from "../../../../index.js";
+import type { PiDurableAgent } from "../../../../durable/DurableAgent.js";
+import { PiPrintRunner } from "../../../../harnesses/pi/durable/PiPrintRunner.js";
 
 const SESSION = "22222222-2222-4222-8222-222222222222";
 function agent(sessionHealth: PiDurableAgent["sessionHealth"] = "uninitialized"): PiDurableAgent {
@@ -63,10 +64,7 @@ function events(session = SESSION): string[] {
   ];
 }
 async function runner(fixture: ReturnType<typeof fakeSpawn>, maxLineBytes?: number) {
-  const api = (await import("../../../../index.js")) as Record<string, unknown>;
-  expect(api).toHaveProperty("PiPrintRunner");
-  const Runner = api.PiPrintRunner as new (options: unknown) => any;
-  return new Runner({
+  return new PiPrintRunner({
     spawn: fixture.spawn,
     maxLineBytes,
     processInspector: { getIdentity: () => ({ pid: 4242, startedAt: "start" }) },
@@ -154,10 +152,11 @@ describe("PiPrintRunner", () => {
       (await runner(fakeSpawn(events(), 1))).run({ agent: agent(), prompt: "x", onSpawn: vi.fn() }),
     ).rejects.toMatchObject({ code: "PI_PROCESS" });
     const fixture = fakeSpawn([]);
-    const api = (await import("../../../../index.js")) as Record<string, unknown>;
-    const Runner = api.PiPrintRunner as new (options: unknown) => any;
     await expect(
-      new Runner({ spawn: fixture.spawn, processInspector: { getIdentity: () => null } }).run({
+      new PiPrintRunner({
+        spawn: fixture.spawn,
+        processInspector: { getIdentity: () => null },
+      }).run({
         agent: agent(),
         prompt: "x",
         onSpawn: vi.fn(),

package/src/__tests__/{readiness → harnesses/readiness}/AgentReadiness.test.ts

@@ -1,21 +1,23 @@
 import path from "node:path";
 import { describe, expect, it, vi } from "vitest";
 import {
-  AGENTS,
   getAgentReadinessReport,
   getAgentReadinessReports,
   type AgentReadinessOptions,
   type ReadinessAgentType,
-} from "../../index.js";
+} from "../../../harnesses/readiness/AgentReadiness.js";
+import { HARNESS_RUNTIME_PROFILES } from "../../../harnesses/runtimeProfiles.js";
 
 type Files = Record<string, string>;
 
 const builtInSkillNames = ["agent-management", "memory", "verify"];
-const skillRoots: Record<ReadinessAgentType, string> = {
+const skillRoots: Record<string, string> = {
   claude: ".claude/skills",
   codex: ".codex/skills",
   copilot: ".copilot/skills",
+  gemini_cli: ".gemini/skills",
   grok_cli: ".grok/skills",
+  antigravity_cli: ".gemini/config/skills",
   opencode: ".config/opencode/skill",
   pi: ".pi/agent/skills",
 };
@@ -56,7 +58,17 @@ function fixture(overrides: Partial<AgentReadinessOptions> = {}) {
       litellm: { key: "litellm-secret", env: { LITELLM_BASE_URL: "https://litellm.example.test" } },
     }),
   };
-  for (const directory of [".claude", ".codex", ".copilot", ".grok", ".config/opencode", ".pi"]) {
+  for (const directory of [
+    ".claude",
+    ".codex",
+    ".copilot",
+    ".gemini",
+    ".grok",
+    ".kiro",
+    ".gemini/antigravity-cli",
+    ".config/opencode",
+    ".pi",
+  ]) {
     files[path.join(homeDir, directory)] = "<dir>";
   }
   for (const root of Object.values(skillRoots)) {
@@ -64,7 +76,9 @@ function fixture(overrides: Partial<AgentReadinessOptions> = {}) {
       files[path.join(homeDir, root, skill, "SKILL.md")] = "# skill";
     }
   }
-  const executablePaths = Object.values(AGENTS).map((agent) => path.join("/bin", agent.command));
+  const executablePaths = Object.values(HARNESS_RUNTIME_PROFILES).map((agent) =>
+    path.join("/bin", agent.command),
+  );
   const options: AgentReadinessOptions = {
     homeDir,
     path: "/bin",
@@ -103,20 +117,30 @@ describe("agent readiness", () => {
     expect(Object.keys(reports)).toEqual([
       "claude",
       "codex",
-      "copilot",
+      "gemini_cli",
       "grok_cli",
+      "kiro",
+      "antigravity_cli",
       "opencode",
+      "copilot",
       "pi",
     ]);
-    expect(reports).not.toHaveProperty("gemini_cli");
     for (const [agent, report] of Object.entries(reports) as Array<
       [ReadinessAgentType, (typeof reports)[ReadinessAgentType]]
     >) {
       expect(report.type).toBe(agent);
       expect(report.executable.status).toBe("pass");
       expect(report.globalConfig.status).toBe("pass");
-      expect(report.builtInSkills).toMatchObject({ status: "info", present: 3, required: 3 });
+      expect(report.builtInSkills.status).toBe("info");
     }
+    expect(reports.gemini_cli.builtInSkills).toMatchObject({ present: 3, required: 3 });
+    expect(reports.antigravity_cli.builtInSkills).toMatchObject({ present: 3, required: 3 });
+    expect(reports.kiro.builtInSkills).toMatchObject({
+      path: null,
+      present: 0,
+      required: 3,
+      missing: builtInSkillNames,
+    });
     expect(reports.codex.integration).toMatchObject({
       label: "ai-devkit hook",
       installed: true,
@@ -133,13 +157,16 @@ describe("agent readiness", () => {
       status: "pass",
     });
     expect(reports.copilot.integration).toBeUndefined();
+    expect(reports.gemini_cli.integration).toBeUndefined();
     expect(reports.grok_cli.integration).toBeUndefined();
+    expect(reports.kiro.integration).toBeUndefined();
+    expect(reports.antigravity_cli.integration).toBeUndefined();
     expect(reports.opencode.integration).toBeUndefined();
   });
 
   it("resolves agent executables from PATH directories containing spaces", async () => {
     const spacedBin = "/Applications/Some App.app/Contents/Resources";
-    const codexPath = path.join(spacedBin, AGENTS.codex.command);
+    const codexPath = path.join(spacedBin, HARNESS_RUNTIME_PROFILES.codex.command);
     const { options } = fixture({
       path: [spacedBin, "/usr/local/bin"].join(path.delimiter),
       access: async (target) => {

package/src/__tests__/harnesses/runtimeProfiles.test.ts

@@ -0,0 +1,110 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import {
+  HARNESS_RUNTIME_PROFILES,
+  runtimeAgentMatchesHarness,
+} from "../../harnesses/runtimeProfiles.js";
+
+describe("harness runtime profiles", () => {
+  it("keeps launch and runtime identity metadata together", () => {
+    expect(HARNESS_RUNTIME_PROFILES.antigravity_cli).toMatchObject({
+      command: "agy",
+      runtimeKind: "agy",
+      discoveryAliases: ["agy", "antigravity", "antigravity_cli"],
+    });
+    expect(HARNESS_RUNTIME_PROFILES.antigravity_cli.matches("/usr/local/bin/agy")).toBe(true);
+  });
+
+  it("recognizes agent commands without matching similar argument text", () => {
+    expect(HARNESS_RUNTIME_PROFILES.copilot.matches("/opt/copilot-cli/1.0/copilot")).toBe(true);
+    expect(HARNESS_RUNTIME_PROFILES.copilot.matches("node /repo/copilot-cli/script.js")).toBe(
+      false,
+    );
+    expect(HARNESS_RUNTIME_PROFILES.grok_cli.matches("/Users/dev/.grok/bin/grok --approve")).toBe(
+      true,
+    );
+    expect(HARNESS_RUNTIME_PROFILES.grok_cli.matches("node /repo/grok-cli/script.js")).toBe(false);
+    expect(
+      HARNESS_RUNTIME_PROFILES.gemini_cli.matches("node --no-warnings /usr/local/bin/gemini"),
+    ).toBe(true);
+  });
+
+  it("matches runtime discovery names through the owning harness profile", () => {
+    expect(runtimeAgentMatchesHarness("kiro-cli", "kiro")).toBe(true);
+    expect(runtimeAgentMatchesHarness("gemini", "gemini_cli")).toBe(true);
+    expect(runtimeAgentMatchesHarness("codex", "claude")).toBe(false);
+  });
+});
+
+describe("harness matchers with executables under paths containing spaces", () => {
+  let root: string;
+
+  function install(relativePath: string): string {
+    const fullPath = path.join(root, relativePath);
+    fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+    fs.writeFileSync(fullPath, "");
+    return fullPath;
+  }
+
+  beforeEach(() => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), "runtime-profiles-spaces-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  it("recognizes argv[0] under a spaced directory", () => {
+    const codex = install("Applications/Some App.app/Contents/Resources/codex");
+    const claude = install("Users/dev/My Tools/bin/claude");
+
+    expect(HARNESS_RUNTIME_PROFILES.codex.matches(`${codex} --sandbox workspace-write`)).toBe(true);
+    expect(HARNESS_RUNTIME_PROFILES.codex.matches(codex)).toBe(true);
+    expect(HARNESS_RUNTIME_PROFILES.claude.matches(`${claude} --continue`)).toBe(true);
+    expect(HARNESS_RUNTIME_PROFILES.claude.matches(`${codex} exec --cd /repo`)).toBe(false);
+  });
+
+  it("recognizes argv[0] by distribution name under a spaced directory", () => {
+    const copilot = install("opt/Home Brew/Caskroom/copilot-cli/1.0.60/copilot");
+
+    expect(HARNESS_RUNTIME_PROFILES.copilot.matches(`${copilot} --allow-all-tools`)).toBe(true);
+  });
+
+  it("does not treat arguments containing spaces as the executable", () => {
+    const vim = install("usr/bin/vim");
+    const codex = install("Applications/Some App.app/Contents/Resources/codex");
+
+    expect(HARNESS_RUNTIME_PROFILES.claude.matches(`${vim} My Notes/claude`)).toBe(false);
+    expect(
+      HARNESS_RUNTIME_PROFILES.claude.matches(`${codex} exec review the Other Dir/claude`),
+    ).toBe(false);
+    expect(HARNESS_RUNTIME_PROFILES.copilot.matches(`${vim} Some Dir/copilot-cli/notes.md`)).toBe(
+      false,
+    );
+    expect(HARNESS_RUNTIME_PROFILES.claude.matches("/usr/bin/vim My Notes/claude")).toBe(false);
+  });
+
+  it("recognizes spaced argv[0] in script-aware matchers", () => {
+    const pi = install("Users/dev/Node Tools/bin/pi");
+    const kiro = install("Applications/Kiro CLI.app/Contents/MacOS/kiro-cli");
+    const node = install("Applications/Dev Tools/node/bin/node");
+
+    expect(HARNESS_RUNTIME_PROFILES.pi.matches(`${pi} --model x`)).toBe(true);
+    expect(HARNESS_RUNTIME_PROFILES.kiro.matches(`${kiro} chat`)).toBe(true);
+    expect(
+      HARNESS_RUNTIME_PROFILES.gemini_cli.matches(`${node} /Users/dev/.npm/bin/gemini --yolo`),
+    ).toBe(true);
+    expect(HARNESS_RUNTIME_PROFILES.pi.matches(`${node} /opt/pi-tools/script.js`)).toBe(false);
+  });
+
+  it("does not match agent words inside an executable directory", () => {
+    const node = install("opt/Dev pi gemini/bin/node");
+
+    expect(HARNESS_RUNTIME_PROFILES.pi.matches(`${node} /repo/script.js`)).toBe(false);
+    expect(HARNESS_RUNTIME_PROFILES.gemini_cli.matches(`${node} /repo/script.js`)).toBe(false);
+    expect(HARNESS_RUNTIME_PROFILES.gemini_cli.matches(`${node} /repo/bin/gemini`)).toBe(true);
+    expect(HARNESS_RUNTIME_PROFILES.pi.matches(`${node} --title pi`)).toBe(true);
+  });
+});

package/src/__tests__/print/DurableAgent.test.ts

@@ -1,18 +1,9 @@
 import { describe, expect, it } from "vitest";
+import { DurableAgentBusyError } from "../../durable/DurableAgent.js";
 
-describe("durable-agent public domain", () => {
-  it("exports a classified busy error without exposing prompt data", async () => {
-    const api = (await import("../../index.js")) as Record<string, unknown>;
-
-    expect(api).toHaveProperty("DurableAgentBusyError");
-    const ErrorType = api.DurableAgentBusyError as new (
-      agentId: string,
-      name: string,
-    ) => Error & {
-      code: string;
-      agentId: string;
-    };
-    const error = new ErrorType("agent-id", "reviewer");
+describe("durable-agent errors", () => {
+  it("classifies a busy error without exposing prompt data", () => {
+    const error = new DurableAgentBusyError("agent-id", "reviewer");
 
     expect(error).toMatchObject({
       name: "DurableAgentBusyError",

package/src/__tests__/print/DurableAgentRepository.test.ts

@@ -2,6 +2,7 @@ import fs from "fs";
 import os from "os";
 import path from "path";
 import { afterEach, describe, expect, it } from "vitest";
+import { DurableAgentRepository } from "../../durable/DurableAgentRepository.js";
 
 const tempDirs: string[] = [];
 
@@ -9,12 +10,6 @@ afterEach(() => {
   for (const dir of tempDirs.splice(0)) fs.rmSync(dir, { recursive: true, force: true });
 });
 
-async function loadStore(): Promise<any> {
-  const api = (await import("../../index.js")) as Record<string, unknown>;
-  expect(api).toHaveProperty("DurableAgentRepository");
-  return api.DurableAgentRepository;
-}
-
 function fixture(): { root: string; cwd: string; dbPath: string } {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), "durable-agent-store-"));
   tempDirs.push(root);
@@ -25,7 +20,6 @@ function fixture(): { root: string; cwd: string; dbPath: string } {
 
 describe("DurableAgentRepository create/list/resolve", () => {
   it("creates distinct durable identities with a canonical cwd and lists them", async () => {
-    const DurableAgentRepository = await loadStore();
     const { cwd, dbPath } = fixture();
     const repository = new DurableAgentRepository({
       dbPath,
@@ -51,7 +45,6 @@ describe("DurableAgentRepository create/list/resolve", () => {
   });
 
   it("resolves exact ids and names and rejects duplicate names", async () => {
-    const DurableAgentRepository = await loadStore();
     const { cwd, dbPath } = fixture();
     const repository = new DurableAgentRepository({ dbPath });
     const agent = await repository.create({ name: "Reviewer", cwd });
@@ -65,7 +58,6 @@ describe("DurableAgentRepository create/list/resolve", () => {
   });
 
   it("rejects a missing cwd", async () => {
-    const DurableAgentRepository = await loadStore();
     const { root, dbPath } = fixture();
     const repository = new DurableAgentRepository({ dbPath });
 
@@ -77,7 +69,6 @@ describe("DurableAgentRepository create/list/resolve", () => {
 
 describe("DurableAgentRepository run ownership", () => {
   it("fails fast when another exact owner is live and completes only for its token", async () => {
-    const DurableAgentRepository = await loadStore();
     const { cwd, dbPath } = fixture();
     const live = new Map<number, string>([[process.pid, "owner-start"]]);
     const processInspector = {
@@ -112,7 +103,6 @@ describe("DurableAgentRepository run ownership", () => {
   });
 
   it("retains busy for a live provider then recovers a dead run without signaling it", async () => {
-    const DurableAgentRepository = await loadStore();
     const { cwd, dbPath } = fixture();
     const live = new Map<number, string>([
       [process.pid, "owner-start"],
@@ -151,7 +141,6 @@ describe("DurableAgentRepository run ownership", () => {
   });
 
   it("reconciles an interrupted run to degraded during list", async () => {
-    const DurableAgentRepository = await loadStore();
     const { cwd, dbPath } = fixture();
     const live = new Map<number, string>([[process.pid, "owner-start"]]);
     const repository = new DurableAgentRepository({
@@ -179,7 +168,6 @@ describe("DurableAgentRepository run ownership", () => {
   });
 
   it("rejects send acquisition when the bound cwd is replaced by a symlink", async () => {
-    const DurableAgentRepository = await loadStore();
     const { root, cwd, dbPath } = fixture();
     const repository = new DurableAgentRepository({ dbPath });
     const agent = await repository.create({ name: "bound", cwd });

package/src/__tests__/runtime/ManagedAgentRuntime.test.ts

@@ -15,7 +15,7 @@ import {
 } from "../../runtime/ManagedAgentRuntime.js";
 import type { AgentInfo } from "../../adapters/AgentAdapter.js";
 import type { AgentRegistry, RegistryEntry } from "../../utils/AgentRegistry.js";
-import type { TmuxManager } from "../../terminal/TmuxManager.js";
+import type { TmuxManager } from "../../runtime/tmux/TmuxManager.js";
 import type { InteractiveAgentRuntime } from "../../runtime/types.js";
 
 function makeAgent(overrides: Partial<AgentInfo> = {}): AgentInfo {

package/src/__tests__/terminal/TmuxManager.test.ts

@@ -1,6 +1,6 @@
 import { execFile } from "child_process";
 import type { MockedFunction } from "vitest";
-import { TmuxManager } from "../../terminal/TmuxManager.js";
+import { TmuxManager } from "../../runtime/tmux/TmuxManager.js";
 
 vi.mock("child_process", () => ({
   execFile: vi.fn(),

package/src/capacity/index.ts

@@ -1,14 +1,25 @@
 import { constants } from "node:fs";
 import { access as fsAccess } from "node:fs/promises";
 import path from "node:path";
-import { codexUnavailableReport, probeCodexCapacity } from "./codex.js";
-import { probeClaudeCapacity, type ClaudeCapacityOptions } from "./claude.js";
-import { probeOpenAiCapacity } from "./openai.js";
-import { probeZaiCapacity } from "./zai.js";
+import { codexUnavailableReport, probeCodexCapacity } from "./sources/codex.js";
+import { probeClaudeCapacity, type ClaudeCapacityOptions } from "./sources/claude.js";
+import {
+  probeOpenAiCapacity,
+  probePiAnthropicCapacity,
+  probeZaiCapacity,
+  type PiAnthropicCapacityOptions,
+  type PiOpenAiCapacityOptions,
+  type PiZaiCapacityOptions,
+} from "./sources/pi.js";
 import type { CapacityReport } from "./types.js";
 
 export type { CapacityReport, CapacityWindow } from "./types.js";
-export type { ClaudeCapacityOptions } from "./claude.js";
+export type { ClaudeCapacityOptions } from "./sources/claude.js";
+export type { PiAnthropicCapacityOptions as AnthropicCapacityOptions } from "./sources/pi.js";
+export type {
+  PiOpenAiCapacityOptions as OpenAiCapacityOptions,
+  PiZaiCapacityOptions as ZaiCapacityOptions,
+} from "./sources/pi.js";
 
 export type CapacityProbeOptions = {
   now?: () => Date;
@@ -17,22 +28,6 @@ export type CapacityProbeOptions = {
   probe?: typeof probeCodexCapacity;
 };
 
-export type ZaiCapacityOptions = {
-  now?: () => Date;
-  env?: NodeJS.ProcessEnv;
-  readFile?: (path: string, encoding: BufferEncoding) => Promise<string>;
-  fetch?: typeof globalThis.fetch;
-  timeoutMs?: number;
-};
-
-export type OpenAiCapacityOptions = {
-  now?: () => Date;
-  env?: NodeJS.ProcessEnv;
-  readFile?: (path: string, encoding: BufferEncoding) => Promise<string>;
-  fetch?: typeof globalThis.fetch;
-  timeoutMs?: number;
-};
-
 async function canAccess(target: string, mode: number): Promise<boolean> {
   try {
     await fsAccess(target, mode);
@@ -78,7 +73,7 @@ export async function getCodexCapacityReport(
 }
 
 export async function getZaiCapacityReport(
-  options: ZaiCapacityOptions = {},
+  options: PiZaiCapacityOptions = {},
 ): Promise<CapacityReport> {
   const { now, ...probeOptions } = options;
   return probeZaiCapacity({
@@ -88,7 +83,7 @@ export async function getZaiCapacityReport(
 }
 
 export async function getOpenAiCapacityReport(
-  options: OpenAiCapacityOptions = {},
+  options: PiOpenAiCapacityOptions = {},
 ): Promise<CapacityReport> {
   const { now, ...probeOptions } = options;
   return probeOpenAiCapacity({
@@ -107,3 +102,14 @@ export async function getClaudeCapacityReport(
     now,
   });
 }
+
+export async function getAnthropicCapacityReport(
+  options: PiAnthropicCapacityOptions = {},
+): Promise<CapacityReport> {
+  const { now, ...probeOptions } = options;
+  return probePiAnthropicCapacity({
+    ...probeOptions,
+    checkedAt: (now?.() ?? new Date()).toISOString(),
+    now,
+  });
+}