@ai-devkit/agent-manager 0.36.0 → 0.38.0

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

@@ -1,534 +0,0 @@
-/**
- * Tests for KiroAdapter
- */
-
-import type { MockedFunction } from "vitest";
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-
-import { KiroAdapter } from "../../adapters/KiroAdapter.js";
-import type { ProcessInfo } from "../../adapters/AgentAdapter.js";
-import { AgentStatus } from "../../adapters/AgentAdapter.js";
-import {
-  listAgentProcesses,
-  enrichProcesses,
-  captureProcessSnapshot,
-} from "../../utils/process.js";
-import { generateAgentName } from "../../utils/matching.js";
-
-vi.mock("../../utils/process.js", async (importOriginal) => {
-  const actual = (await importOriginal()) as typeof import("../../utils/process.js");
-  return {
-    ...actual,
-    listAgentProcesses: vi.fn(),
-    enrichProcesses: vi.fn(),
-    captureProcessSnapshot: vi.fn(),
-  };
-});
-
-vi.mock("../../utils/matching.js", async (importOriginal) => {
-  const actual = (await importOriginal()) as typeof import("../../utils/matching.js");
-  return {
-    ...actual,
-    generateAgentName: vi.fn(),
-  };
-});
-
-const mockedListAgentProcesses = listAgentProcesses as MockedFunction<typeof listAgentProcesses>;
-const mockedEnrichProcesses = enrichProcesses as MockedFunction<typeof enrichProcesses>;
-const mockedCaptureProcessSnapshot = captureProcessSnapshot as MockedFunction<
-  typeof captureProcessSnapshot
->;
-const mockedGenerateAgentName = generateAgentName as MockedFunction<typeof generateAgentName>;
-
-describe("KiroAdapter", () => {
-  let adapter: KiroAdapter;
-  let tmpHome: string;
-  let sessionsDir: string;
-
-  beforeEach(() => {
-    tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "kiro-adapter-test-"));
-    process.env.HOME = tmpHome;
-    sessionsDir = path.join(tmpHome, ".kiro", "sessions", "cli");
-    fs.mkdirSync(sessionsDir, { recursive: true });
-
-    adapter = new KiroAdapter();
-
-    mockedListAgentProcesses.mockReset();
-    mockedEnrichProcesses.mockReset();
-    mockedCaptureProcessSnapshot.mockReset();
-    mockedGenerateAgentName.mockReset();
-
-    mockedEnrichProcesses.mockImplementation((procs) => procs);
-    // Compatibility shim for standalone adapter discovery; the manager captures once and slices by name.
-    mockedCaptureProcessSnapshot.mockImplementation(async (names) =>
-      enrichProcesses(names.flatMap((name) => listAgentProcesses(name))),
-    );
-    mockedGenerateAgentName.mockImplementation((cwd: string, pid: number) => {
-      const folder = path.basename(cwd) || "unknown";
-      return `${folder} (${pid})`;
-    });
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpHome, { recursive: true, force: true });
-  });
-
-  describe("initialization", () => {
-    it("exposes the kiro type and process names", () => {
-      expect(adapter.type).toBe("kiro");
-      expect(adapter.processNames).toEqual(["kiro-cli", "kiro", "kiro-cli-chat", "node"]);
-    });
-  });
-
-  describe("canHandle", () => {
-    it("identifies Kiro commands without matching unrelated paths", () => {
-      expect(adapter.canHandle({ pid: 1, command: "kiro-cli", cwd: "/repo", tty: "ttys001" })).toBe(
-        true,
-      );
-      expect(
-        adapter.canHandle({
-          pid: 2,
-          command: "/usr/local/bin/kiro --model x",
-          cwd: "/repo",
-          tty: "ttys002",
-        }),
-      ).toBe(true);
-      expect(
-        adapter.canHandle({
-          pid: 3,
-          command: "node /opt/kiro/bin/kiro-cli.js",
-          cwd: "/repo",
-          tty: "ttys003",
-        }),
-      ).toBe(true);
-      expect(
-        adapter.canHandle({
-          pid: 4,
-          command: "node /repo/feature-kiro-adapter/script.js",
-          cwd: "/repo",
-          tty: "ttys004",
-        }),
-      ).toBe(false);
-      expect(
-        adapter.canHandle({
-          pid: 5,
-          command: "kiro-cli chat",
-          cwd: "/repo",
-          tty: "ttys005",
-        }),
-      ).toBe(true);
-      expect(
-        adapter.canHandle({
-          pid: 6,
-          command: "bun /opt/kiro/bin/kiro-cli.js",
-          cwd: "/repo",
-          tty: "ttys006",
-        }),
-      ).toBe(true);
-      expect(
-        adapter.canHandle({
-          pid: 7,
-          command: "node /usr/local/bin/ai-devkit agent start --type kiro",
-          cwd: "/repo",
-          tty: "ttys007",
-        }),
-      ).toBe(false);
-      expect(
-        adapter.canHandle({
-          pid: 8,
-          command: "node server.js --name kiro",
-          cwd: "/repo",
-          tty: "ttys008",
-        }),
-      ).toBe(false);
-      expect(
-        adapter.canHandle({
-          pid: 9,
-          command: "kiro-cli-chat acp",
-          cwd: "/repo",
-          tty: "ttys009",
-        }),
-      ).toBe(false);
-    });
-  });
-
-  describe("detectAgents", () => {
-    it("returns [] when there are no Kiro processes", async () => {
-      mockedListAgentProcesses.mockReturnValue([]);
-      expect(await adapter.detectAgents()).toEqual([]);
-    });
-
-    it("maps a running Kiro process through its session lock and metadata", async () => {
-      const cwd = "/repo/project-a";
-      const proc = makeProcess({ pid: 101, cwd: "/process/cwd" });
-      const updatedAt = new Date().toISOString();
-      const sessionFile = writeKiroSession(
-        "sess-101",
-        cwd,
-        [prompt("implement Kiro adapter", 1781098057), assistantText("working on it")],
-        101,
-        updatedAt,
-      );
-      mockedCaptureProcessSnapshot.mockResolvedValue([proc]);
-
-      const agents = await adapter.detectAgents();
-
-      expect(agents).toHaveLength(1);
-      expect(agents[0]).toMatchObject({
-        type: "kiro",
-        pid: 101,
-        projectPath: cwd,
-        sessionId: "sess-101",
-        summary: "implement Kiro adapter",
-        status: AgentStatus.WAITING,
-        sessionFilePath: sessionFile,
-        lastActive: new Date(updatedAt),
-      });
-    });
-
-    it("matches a lock held by a kiro-cli-chat acp descendant when bun is not collected", async () => {
-      const cwd = "/repo/project-a";
-      const sessionFile = writeKiroSession(
-        "sess-acp",
-        cwd,
-        [prompt("implement Kiro adapter", 1781098057), assistantText("working on it")],
-        55236,
-      );
-      const kiro = makeProcess({ pid: 55111, command: "kiro-cli", cwd: "/process/cwd", ppid: 1 });
-      const chat = makeProcess({
-        pid: 55168,
-        command: "kiro-cli-chat chat",
-        ppid: 55111,
-        tty: "ttys001",
-      });
-      const acp = makeProcess({
-        pid: 55236,
-        command: "kiro-cli-chat acp",
-        ppid: 55198,
-        tty: "ttys001",
-      });
-      mockedCaptureProcessSnapshot.mockResolvedValue([kiro, chat, acp]);
-
-      const agents = await adapter.detectAgents();
-
-      expect(agents).toEqual([
-        expect.objectContaining({
-          type: "kiro",
-          pid: 55111,
-          projectPath: cwd,
-          sessionId: "sess-acp",
-          summary: "implement Kiro adapter",
-          sessionFilePath: sessionFile,
-        }),
-      ]);
-    });
-
-    it("walks a collected kiro-cli-chat parent chain to the owning kiro-cli", async () => {
-      const sessionFile = writeKiroSession(
-        "sess-owner",
-        "/repo/owner",
-        [prompt("owned session", 1781098057)],
-        55236,
-      );
-      const owner = makeProcess({ pid: 55111, command: "kiro-cli", cwd: "/repo/owner", ppid: 1 });
-      const other = makeProcess({ pid: 66111, command: "kiro-cli", cwd: "/repo/other", ppid: 1 });
-      const chat = makeProcess({ pid: 55168, command: "kiro-cli-chat chat", ppid: 55111 });
-      const acp = makeProcess({ pid: 55236, command: "kiro-cli-chat acp", ppid: 55168 });
-      mockedCaptureProcessSnapshot.mockResolvedValue([owner, other, chat, acp]);
-
-      const agents = await adapter.detectAgents();
-
-      expect(agents).toEqual([
-        expect.objectContaining({
-          pid: 55111,
-          projectPath: "/repo/owner",
-          sessionId: "sess-owner",
-          sessionFilePath: sessionFile,
-        }),
-        expect.objectContaining({ pid: 66111, sessionId: "pid-66111" }),
-      ]);
-    });
-
-    it("does not attach a session through tty ?? or an ambiguous tty", async () => {
-      writeKiroSession("sess-unknown-tty", "/repo/unknown", [prompt("hello", 1781098057)], 55236);
-      const unknownTty = makeProcess({ pid: 55111, command: "kiro-cli", tty: "??", ppid: 1 });
-      const unknownAcp = makeProcess({
-        pid: 55236,
-        command: "kiro-cli-chat acp",
-        tty: "??",
-        ppid: 55198,
-      });
-      mockedCaptureProcessSnapshot.mockResolvedValue([unknownTty, unknownAcp]);
-
-      expect(await adapter.detectAgents()).toEqual([
-        expect.objectContaining({ pid: 55111, sessionId: "pid-55111" }),
-      ]);
-
-      writeKiroSession("sess-shared-tty", "/repo/shared", [prompt("hello", 1781098057)], 66236);
-      const first = makeProcess({ pid: 55111, command: "kiro-cli", tty: "ttys001", ppid: 1 });
-      const second = makeProcess({ pid: 66111, command: "kiro-cli", tty: "ttys001", ppid: 1 });
-      const sharedAcp = makeProcess({
-        pid: 66236,
-        command: "kiro-cli-chat acp",
-        tty: "ttys001",
-        ppid: 55198,
-      });
-      mockedCaptureProcessSnapshot.mockResolvedValue([first, second, sharedAcp]);
-
-      expect(await adapter.detectAgents()).toEqual([
-        expect.objectContaining({ pid: 55111, sessionId: "pid-55111" }),
-        expect.objectContaining({ pid: 66111, sessionId: "pid-66111" }),
-      ]);
-    });
-
-    it("uses a supplied process snapshot instead of scanning again", async () => {
-      const proc = makeProcess({ pid: 606, cwd: "/repo/context" });
-      mockedCaptureProcessSnapshot.mockResolvedValue([makeProcess({ pid: 999 })]);
-
-      const agents = await adapter.detectAgents({ processes: [proc] });
-
-      expect(mockedCaptureProcessSnapshot).not.toHaveBeenCalled();
-      expect(agents).toEqual([
-        expect.objectContaining({
-          pid: 606,
-          projectPath: "/repo/context",
-          sessionId: "pid-606",
-        }),
-      ]);
-    });
-
-    it("uses only a lock whose PID belongs to a running Kiro process", async () => {
-      writeKiroSession("ended-session", "/repo/ended", [prompt("old conversation", 1781098057)]);
-      writeKiroSession(
-        "other-process",
-        "/repo/other",
-        [prompt("other conversation", 1781098057)],
-        999,
-      );
-      const proc = makeProcess({ pid: 202, cwd: "/repo/current" });
-      mockedCaptureProcessSnapshot.mockResolvedValue([proc]);
-
-      const agents = await adapter.detectAgents();
-
-      expect(agents).toEqual([
-        expect.objectContaining({
-          pid: 202,
-          projectPath: "/repo/current",
-          sessionId: "pid-202",
-          summary: "Kiro process running",
-        }),
-      ]);
-    });
-
-    it("ignores malformed lock files", async () => {
-      writeKiroSession("bad-lock", "/repo/project", [prompt("hello", 1781098057)]);
-      fs.writeFileSync(path.join(sessionsDir, "bad-lock.lock"), "{bad json");
-      const proc = makeProcess({ pid: 303, cwd: "/repo/project" });
-      mockedCaptureProcessSnapshot.mockResolvedValue([proc]);
-
-      const agents = await adapter.detectAgents();
-
-      expect(agents[0]).toMatchObject({ sessionId: "pid-303" });
-    });
-
-    it("reports running while the latest assistant event invokes a tool", async () => {
-      writeKiroSession(
-        "tool-session",
-        "/repo/project",
-        [
-          prompt("inspect the file", Math.floor(Date.now() / 1000)),
-          assistantTool("fs_read", { path: "/repo/project/file.ts" }),
-        ],
-        404,
-        new Date().toISOString(),
-      );
-      const proc = makeProcess({ pid: 404, cwd: "/repo/project" });
-      mockedCaptureProcessSnapshot.mockResolvedValue([proc]);
-
-      const agents = await adapter.detectAgents();
-
-      expect(agents[0].status).toBe(AgentStatus.RUNNING);
-    });
-
-    it("returns a process-only agent when the locked transcript is missing", async () => {
-      fs.writeFileSync(path.join(sessionsDir, "missing.lock"), JSON.stringify({ pid: 505 }));
-      const proc = makeProcess({ pid: 505, cwd: "/repo/project-e" });
-      mockedCaptureProcessSnapshot.mockResolvedValue([proc]);
-
-      const agents = await adapter.detectAgents();
-
-      expect(agents).toEqual([
-        expect.objectContaining({
-          type: "kiro",
-          status: AgentStatus.RUNNING,
-          pid: 505,
-          projectPath: "/repo/project-e",
-          sessionId: "pid-505",
-          summary: "Kiro process running",
-        }),
-      ]);
-    });
-  });
-
-  describe("getConversation", () => {
-    it("reads real Kiro prompt and assistant message envelopes", () => {
-      const sessionFile = writeKiroSession("conversation", "/repo/project-f", [
-        prompt("hello kiro", 1781098057),
-        assistantText("Hello! How can I help?"),
-        "{not json",
-      ]);
-
-      expect(adapter.getConversation(sessionFile)).toEqual([
-        { role: "user", content: "hello kiro", timestamp: "2026-06-10T13:27:37.000Z" },
-        { role: "assistant", content: "Hello! How can I help?", timestamp: undefined },
-      ]);
-    });
-
-    it("includes Kiro tool use and results only in verbose conversation mode", () => {
-      const sessionFile = writeKiroSession("tools", "/repo/project-tools", [
-        prompt("read package.json", 1781098057),
-        assistantTool("fs_read", { path: "package.json" }),
-        toolResult("contents", "success"),
-        assistantText("Done."),
-      ]);
-
-      expect(adapter.getConversation(sessionFile)).toEqual([
-        { role: "user", content: "read package.json", timestamp: "2026-06-10T13:27:37.000Z" },
-        { role: "assistant", content: "Done.", timestamp: undefined },
-      ]);
-      expect(adapter.getConversation(sessionFile, { verbose: true })).toEqual([
-        { role: "user", content: "read package.json", timestamp: "2026-06-10T13:27:37.000Z" },
-        {
-          role: "assistant",
-          content: '[Tool: fs_read] {"path":"package.json"}',
-          timestamp: undefined,
-        },
-        { role: "system", content: "[Tool Result] contents", timestamp: undefined },
-        { role: "assistant", content: "Done.", timestamp: undefined },
-      ]);
-    });
-  });
-
-  describe("listSessions", () => {
-    it("lists historical sessions using metadata and applies cwd filtering", async () => {
-      const matchingCwd = "/repo/project-g";
-      const matchingSession = writeKiroSession("sess-g", matchingCwd, [
-        prompt("first matching message", 1781098057),
-        assistantText("response"),
-      ]);
-      writeKiroSession("sess-h", "/repo/project-h", [prompt("other message", 1781098057)]);
-
-      const sessions = await adapter.listSessions({ cwd: matchingCwd });
-
-      expect(sessions).toEqual([
-        expect.objectContaining({
-          type: "kiro",
-          sessionId: "sess-g",
-          cwd: matchingCwd,
-          firstUserMessage: "first matching message",
-          startedAt: new Date("2026-06-10T13:27:17.000Z"),
-          lastActive: new Date("2026-06-10T13:27:40.000Z"),
-          sessionFilePath: matchingSession,
-        }),
-      ]);
-    });
-  });
-
-  function makeProcess(overrides: Partial<ProcessInfo>): ProcessInfo {
-    return {
-      pid: 1,
-      command: "kiro-cli chat",
-      cwd: "/repo",
-      tty: "ttys001",
-      startTime: new Date("2026-06-10T13:27:17.000Z"),
-      ...overrides,
-    };
-  }
-
-  function writeKiroSession(
-    sessionId: string,
-    cwd: string,
-    entries: Array<Record<string, unknown> | string>,
-    pid?: number,
-    updatedAt = "2026-06-10T13:27:40.000Z",
-  ): string {
-    fs.writeFileSync(
-      path.join(sessionsDir, `${sessionId}.json`),
-      JSON.stringify({
-        session_id: sessionId,
-        cwd,
-        created_at: "2026-06-10T13:27:17.000Z",
-        updated_at: updatedAt,
-        title: "Session title",
-      }),
-    );
-    const filePath = path.join(sessionsDir, `${sessionId}.jsonl`);
-    fs.writeFileSync(
-      filePath,
-      entries
-        .map((entry) => (typeof entry === "string" ? entry : JSON.stringify(entry)))
-        .join("\n"),
-    );
-    if (pid !== undefined) {
-      fs.writeFileSync(
-        path.join(sessionsDir, `${sessionId}.lock`),
-        JSON.stringify({
-          pid,
-          started_at: "2026-06-10T13:27:17.000Z",
-        }),
-      );
-    }
-    return filePath;
-  }
-
-  function prompt(text: string, timestamp: number): Record<string, unknown> {
-    return {
-      version: "v1",
-      kind: "Prompt",
-      data: {
-        content: [{ kind: "text", data: text }],
-        meta: { timestamp },
-      },
-    };
-  }
-
-  function assistantText(text: string): Record<string, unknown> {
-    return {
-      version: "v1",
-      kind: "AssistantMessage",
-      data: { content: [{ kind: "text", data: text }] },
-    };
-  }
-
-  function assistantTool(name: string, input: Record<string, unknown>): Record<string, unknown> {
-    return {
-      version: "v1",
-      kind: "AssistantMessage",
-      data: {
-        content: [
-          {
-            kind: "toolUse",
-            data: { toolUseId: "tool-1", name, input },
-          },
-        ],
-      },
-    };
-  }
-
-  function toolResult(result: string, status: string): Record<string, unknown> {
-    return {
-      version: "v1",
-      kind: "ToolResults",
-      data: {
-        content: [
-          {
-            kind: "toolResult",
-            data: { toolUseId: "tool-1", status, result },
-          },
-        ],
-      },
-    };
-  }
-});

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

@@ -1,85 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-
-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: "" })
-      .mockResolvedValueOnce({
-        stdout: "Usage: codex exec [PROMPT]\n--json\n- read from stdin\nresume",
-        stderr: "",
-      })
-      .mockResolvedValueOnce({
-        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",
-    });
-    expect(exec.mock.calls).toEqual([
-      ["fake-codex", ["--version"]],
-      ["fake-codex", ["exec", "--help"]],
-      ["fake-codex", ["exec", "resume", "--help"]],
-    ]);
-  });
-
-  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({
-      exec: vi
-        .fn()
-        .mockResolvedValueOnce({ stdout: "version", stderr: "" })
-        .mockResolvedValueOnce({ stdout: "exec", stderr: "" })
-        .mockResolvedValueOnce({ stdout: "resume", stderr: "" }),
-    });
-    await expect(unsupported.validate()).rejects.toMatchObject({ code: "CODEX_CLI_UNSUPPORTED" });
-    const missingCommands = new Probe({
-      exec: vi
-        .fn()
-        .mockResolvedValueOnce({ stdout: "version", stderr: "" })
-        .mockResolvedValueOnce({ stdout: "", stderr: "" })
-        .mockResolvedValueOnce({ stdout: "", stderr: "" }),
-    });
-    await expect(missingCommands.validate()).rejects.toMatchObject({
-      code: "CODEX_CLI_UNSUPPORTED",
-    });
-
-    const unavailable = new Probe({
-      exec: vi.fn().mockRejectedValue(new Error(`bad\0${"x".repeat(1000)}`)),
-    });
-    const error = await unavailable.validate().catch((value: Error & { code: string }) => value);
-    expect(error.code).toBe("CODEX_CLI_UNAVAILABLE");
-    expect(error.message).not.toContain("\0");
-    expect(error.message.length).toBeLessThan(600);
-  });
-
-  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" });
-  });
-
-  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({
-      code: "CODEX_CLI_UNSUPPORTED",
-    });
-  });
-});

package/src/__tests__/durable/CodexDurableAgentRepository.test.ts

@@ -1,65 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { DurableAgentRepository } from "../../durable/DurableAgentRepository.js";
-
-const SESSION = "22222222-2222-4222-8222-222222222222";
-const OTHER_SESSION = "33333333-3333-4333-8333-333333333333";
-const roots: string[] = [];
-
-afterEach(() => {
-  for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
-});
-
-function fixture() {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), "codex-durable-repository-"));
-  roots.push(root);
-  const cwd = path.join(root, "project");
-  fs.mkdirSync(cwd);
-  const processInspector = { getIdentity: (pid: number) => ({ pid, startedAt: "owner-start" }) };
-  return {
-    cwd,
-    repository: new DurableAgentRepository({
-      dbPath: path.join(root, "agents.db"),
-      processInspector,
-    }),
-  };
-}
-
-describe("Codex durable-agent repository binding", () => {
-  it("creates Codex agents unbound and binds during the owned run", async () => {
-    const { cwd, repository } = fixture();
-    const agent = await repository.create({ name: "reviewer", cwd, provider: "codex" });
-    expect(agent).toMatchObject({ provider: "codex", mode: "durable", providerSessionId: null });
-
-    const run = await repository.acquireRun(agent.id);
-    const bound = await repository.bindProviderSession(agent.id, run.token, SESSION);
-    expect(bound.providerSessionId).toBe(SESSION);
-    await expect(
-      repository.bindProviderSession(agent.id, run.token, SESSION),
-    ).resolves.toMatchObject({ providerSessionId: SESSION });
-  });
-
-  it("rejects invalid, stale, replacement, and duplicate bindings", async () => {
-    const { cwd, repository } = fixture();
-    const first = await repository.create({ name: "first", cwd, provider: "codex" });
-    const second = await repository.create({ name: "second", cwd, provider: "codex" });
-    const firstRun = await repository.acquireRun(first.id);
-    const secondRun = await repository.acquireRun(second.id);
-
-    await expect(repository.bindProviderSession(first.id, "stale", SESSION)).rejects.toMatchObject({
-      code: "DURABLE_AGENT_REPOSITORY",
-    });
-    await expect(
-      repository.bindProviderSession(first.id, firstRun.token, "invalid"),
-    ).rejects.toMatchObject({ code: "DURABLE_AGENT_REPOSITORY" });
-    await repository.bindProviderSession(first.id, firstRun.token, SESSION);
-    await expect(
-      repository.bindProviderSession(first.id, firstRun.token, OTHER_SESSION),
-    ).rejects.toMatchObject({ code: "CODEX_SESSION_MISMATCH" });
-    await expect(
-      repository.bindProviderSession(second.id, secondRun.token, SESSION),
-    ).rejects.toMatchObject({ code: "CODEX_SESSION_MISMATCH" });
-  });
-});