@ai-devkit/agent-manager 0.32.0 → 0.33.1

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

@@ -1,54 +1,65 @@
-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';
+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 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 });
+  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 }) };
+  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 });
+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 });
-    });
+    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);
+  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' });
+    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" });
+  });
 });

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

@@ -1,79 +1,104 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { afterEach, describe, expect, it, vi } from 'vitest';
+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,
-    CodexPrintAgentService,
-    DurableAgentRepository,
-    type ProcessInspector,
-} from '../../index.js';
+  CodexPrintError,
+  CodexPrintAgentService,
+  DurableAgentRepository,
+  type ProcessInspector,
+} from "../../index.js";
 
-const SESSION = '22222222-2222-4222-8222-222222222222';
+const SESSION = "22222222-2222-4222-8222-222222222222";
 const roots: string[] = [];
 
 afterEach(() => {
-    for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
+  for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
 });
 
-describe('Codex print-agent fake-provider journey', () => {
-    it('creates unbound, then binds and explicitly resumes the provider-minted session', async () => {
-        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'codex-print-integration-'));
-        roots.push(root);
-        const cwd = path.join(root, 'project');
-        fs.mkdirSync(cwd);
-        const processInspector: ProcessInspector = {
-            getIdentity: (pid) => ({ pid, startedAt: `process-${pid}` }),
-        };
-        const repository = new DurableAgentRepository({ dbPath: path.join(root, 'agents.db'), processInspector });
-        const runner = {
-            run: vi.fn().mockImplementation(async (request) => {
-                await request.onSpawn({ pid: 42, startedAt: 'process-42' });
-                await request.onSession(SESSION);
-                return { sessionId: SESSION, result: `answer:${request.prompt}`, messages: [`answer:${request.prompt}`], exitCode: 0 };
-            }),
+describe("Codex print-agent fake-provider journey", () => {
+  it("creates unbound, then binds and explicitly resumes the provider-minted session", async () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "codex-print-integration-"));
+    roots.push(root);
+    const cwd = path.join(root, "project");
+    fs.mkdirSync(cwd);
+    const processInspector: ProcessInspector = {
+      getIdentity: (pid) => ({ pid, startedAt: `process-${pid}` }),
+    };
+    const repository = new DurableAgentRepository({
+      dbPath: path.join(root, "agents.db"),
+      processInspector,
+    });
+    const runner = {
+      run: vi.fn().mockImplementation(async (request) => {
+        await request.onSpawn({ pid: 42, startedAt: "process-42" });
+        await request.onSession(SESSION);
+        return {
+          sessionId: SESSION,
+          result: `answer:${request.prompt}`,
+          messages: [`answer:${request.prompt}`],
+          exitCode: 0,
         };
-        const service = new CodexPrintAgentService({
-            repository, probe: { validate: vi.fn() }, runner,
-        });
-
-        const created = await service.create({ name: 'reviewer', cwd });
-        expect(created).toMatchObject({ provider: 'codex', providerSessionId: null, sessionHealth: 'uninitialized' });
+      }),
+    };
+    const service = new CodexPrintAgentService({
+      repository,
+      probe: { validate: vi.fn() },
+      runner,
+    });
 
-        const first = await service.send(created.id, 'first secret');
-        expect(first).toMatchObject({ result: 'answer:first secret' });
-        const bound = await repository.getById(created.id);
-        expect(bound?.providerSessionId).toBe(first.sessionId);
-        await expect(service.send(created.id, 'follow up')).resolves.toMatchObject({ result: 'answer:follow up' });
+    const created = await service.create({ name: "reviewer", cwd });
+    expect(created).toMatchObject({
+      provider: "codex",
+      providerSessionId: null,
+      sessionHealth: "uninitialized",
+    });
 
-        expect(runner.run.mock.calls[0][0].agent).toMatchObject({ providerSessionId: null });
-        expect(runner.run.mock.calls[1][0].agent).toMatchObject({ providerSessionId: SESSION });
+    const first = await service.send(created.id, "first secret");
+    expect(first).toMatchObject({ result: "answer:first secret" });
+    const bound = await repository.getById(created.id);
+    expect(bound?.providerSessionId).toBe(first.sessionId);
+    await expect(service.send(created.id, "follow up")).resolves.toMatchObject({
+      result: "answer:follow up",
     });
 
-    it('retains a first-run binding when the provider fails after thread start', async () => {
-        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'codex-print-bind-failure-'));
-        roots.push(root);
-        const cwd = path.join(root, 'project');
-        fs.mkdirSync(cwd);
-        const processInspector: ProcessInspector = {
-            getIdentity: (pid) => ({ pid, startedAt: `process-${pid}` }),
-        };
-        const repository = new DurableAgentRepository({ dbPath: path.join(root, 'agents.db'), processInspector });
-        const runner = {
-            run: vi.fn().mockImplementation(async (request) => {
-                await request.onSpawn({ pid: 42, startedAt: 'process-42' });
-                await request.onSession(SESSION);
-                throw new CodexPrintError('Codex print run failed.', 'CODEX_PROCESS');
-            }),
-        };
-        const service = new CodexPrintAgentService({
-            repository, probe: { validate: vi.fn() }, runner,
-        });
-        const created = await service.create({ name: 'reviewer', cwd });
+    expect(runner.run.mock.calls[0][0].agent).toMatchObject({ providerSessionId: null });
+    expect(runner.run.mock.calls[1][0].agent).toMatchObject({ providerSessionId: SESSION });
+  });
 
-        await expect(service.send(created.id, 'secret')).rejects.toMatchObject({ code: 'CODEX_PROCESS' });
-        expect((await repository.getById(created.id))).toMatchObject({
-            providerSessionId: SESSION, state: 'degraded', sessionHealth: 'unknown',
-        });
+  it("retains a first-run binding when the provider fails after thread start", async () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "codex-print-bind-failure-"));
+    roots.push(root);
+    const cwd = path.join(root, "project");
+    fs.mkdirSync(cwd);
+    const processInspector: ProcessInspector = {
+      getIdentity: (pid) => ({ pid, startedAt: `process-${pid}` }),
+    };
+    const repository = new DurableAgentRepository({
+      dbPath: path.join(root, "agents.db"),
+      processInspector,
+    });
+    const runner = {
+      run: vi.fn().mockImplementation(async (request) => {
+        await request.onSpawn({ pid: 42, startedAt: "process-42" });
+        await request.onSession(SESSION);
+        throw new CodexPrintError("Codex print run failed.", "CODEX_PROCESS");
+      }),
+    };
+    const service = new CodexPrintAgentService({
+      repository,
+      probe: { validate: vi.fn() },
+      runner,
+    });
+    const created = await service.create({ name: "reviewer", cwd });
+
+    await expect(service.send(created.id, "secret")).rejects.toMatchObject({
+      code: "CODEX_PROCESS",
+    });
+    expect(await repository.getById(created.id)).toMatchObject({
+      providerSessionId: SESSION,
+      state: "degraded",
+      sessionHealth: "unknown",
     });
+  });
 });

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

@@ -1,139 +1,217 @@
-import { describe, expect, it, vi } from 'vitest';
+import { describe, expect, it, vi } from "vitest";
 
-const SESSION = '22222222-2222-4222-8222-222222222222';
+const SESSION = "22222222-2222-4222-8222-222222222222";
 const base = {
-    id: 'id', name: 'reviewer', provider: 'codex', providerSessionId: null, sessionHealth: 'uninitialized',
+  id: "id",
+  name: "reviewer",
+  provider: "codex",
+  providerSessionId: null,
+  sessionHealth: "uninitialized",
 };
 
-describe('CodexPrintAgentService', () => {
-    it('constructs default non-billable dependencies without invoking them', async () => {
-        const api = await import('../../index.js') as Record<string, unknown>;
-        const Service = api.CodexPrintAgentService as new () => any;
-        expect(new Service().repository).toBeDefined();
+describe("CodexPrintAgentService", () => {
+  it("constructs default non-billable dependencies without invoking them", async () => {
+    const api = (await import("../../index.js")) as Record<string, unknown>;
+    const Service = api.CodexPrintAgentService as new () => any;
+    expect(new Service().repository).toBeDefined();
+  });
+
+  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), list: vi.fn() };
+    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" });
+    expect(repository.create).toHaveBeenCalledWith({
+      name: "reviewer",
+      cwd: "/project",
+      provider: "codex",
     });
+    expect(runner.run).not.toHaveBeenCalled();
+  });
 
-    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), list: vi.fn() };
-        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' });
-        expect(repository.create).toHaveBeenCalledWith({ name: 'reviewer', cwd: '/project', provider: 'codex' });
-        expect(runner.run).not.toHaveBeenCalled();
+  it("binds during first send and explicitly resumes later sends", async () => {
+    const api = (await import("../../index.js")) as Record<string, unknown>;
+    const repository = {
+      list: vi.fn(),
+      resolve: vi.fn().mockResolvedValue(base),
+      acquireRun: vi
+        .fn()
+        .mockResolvedValueOnce({ agent: base, token: "one" })
+        .mockResolvedValueOnce({
+          agent: { ...base, providerSessionId: SESSION, sessionHealth: "healthy" },
+          token: "two",
+        }),
+      recordProviderProcess: vi.fn(),
+      bindProviderSession: vi.fn(),
+      completeRun: vi.fn(),
+    };
+    const runner = {
+      run: vi.fn().mockImplementation(async (request) => {
+        await request.onSpawn({ pid: 42, startedAt: "start" });
+        await request.onSession(SESSION);
+        return { sessionId: SESSION, result: "answer", messages: ["answer"], exitCode: 0 };
+      }),
+    };
+    const Service = api.CodexPrintAgentService as new (options: unknown) => any;
+    const service = new Service({
+      repository,
+      probe: { validate: vi.fn() },
+      runner,
+      executable: "fake-codex",
     });
 
-    it('binds during first send and explicitly resumes later sends', async () => {
-        const api = await import('../../index.js') as Record<string, unknown>;
-        const repository = {
-            list: vi.fn(),
-            resolve: vi.fn().mockResolvedValue(base),
-            acquireRun: vi.fn()
-                .mockResolvedValueOnce({ agent: base, token: 'one' })
-                .mockResolvedValueOnce({ agent: { ...base, providerSessionId: SESSION, sessionHealth: 'healthy' }, token: 'two' }),
-            recordProviderProcess: vi.fn(), bindProviderSession: vi.fn(), completeRun: vi.fn(),
-        };
-        const runner = { run: vi.fn().mockImplementation(async (request) => {
-            await request.onSpawn({ pid: 42, startedAt: 'start' });
-            await request.onSession(SESSION);
-            return { sessionId: SESSION, result: 'answer', messages: ['answer'], exitCode: 0 };
-        }) };
-        const Service = api.CodexPrintAgentService as new (options: unknown) => any;
-        const service = new Service({ repository, probe: { validate: vi.fn() }, runner, executable: 'fake-codex' });
+    await service.send("reviewer", "first");
+    await service.send("reviewer", "later");
 
-        await service.send('reviewer', 'first');
-        await service.send('reviewer', 'later');
+    expect(repository.bindProviderSession).toHaveBeenNthCalledWith(1, "id", "one", SESSION);
+    expect(repository.bindProviderSession).toHaveBeenNthCalledWith(2, "id", "two", SESSION);
+    expect(repository.completeRun).toHaveBeenCalledWith(
+      "id",
+      "one",
+      expect.objectContaining({
+        status: "succeeded",
+        sessionHealth: "healthy",
+      }),
+    );
+  });
 
-        expect(repository.bindProviderSession).toHaveBeenNthCalledWith(1, 'id', 'one', SESSION);
-        expect(repository.bindProviderSession).toHaveBeenNthCalledWith(2, 'id', 'two', SESSION);
-        expect(repository.completeRun).toHaveBeenCalledWith('id', 'one', expect.objectContaining({
-            status: 'succeeded', sessionHealth: 'healthy',
-        }));
+  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 = {
+      list: vi.fn(),
+      resolve: vi.fn().mockResolvedValue(base),
+      acquireRun: vi.fn().mockResolvedValue({ agent: base, token: "one" }),
+      recordProviderProcess: vi.fn(),
+      bindProviderSession: vi.fn(),
+      completeRun,
+    };
+    const Service = api.CodexPrintAgentService as new (options: unknown) => any;
+    const service = new Service({
+      repository,
+      probe: { validate: vi.fn() },
+      runner: {
+        run: vi.fn().mockRejectedValue(new ErrorType("mismatch", "CODEX_SESSION_MISMATCH")),
+      },
     });
-
-    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 = {
-            list: vi.fn(),
-            resolve: vi.fn().mockResolvedValue(base), acquireRun: vi.fn().mockResolvedValue({ agent: base, token: 'one' }),
-            recordProviderProcess: vi.fn(), bindProviderSession: vi.fn(), completeRun,
-        };
-        const Service = api.CodexPrintAgentService as new (options: unknown) => any;
-        const service = new Service({ repository, probe: { validate: vi.fn() }, runner: {
-            run: vi.fn().mockRejectedValue(new ErrorType('mismatch', 'CODEX_SESSION_MISMATCH')),
-        } });
-        await expect(service.send('reviewer', 'x')).rejects.toMatchObject({ code: 'CODEX_SESSION_MISMATCH' });
-        expect(completeRun).toHaveBeenCalledWith('id', 'one', expect.objectContaining({ sessionHealth: 'mismatch' }));
+    await expect(service.send("reviewer", "x")).rejects.toMatchObject({
+      code: "CODEX_SESSION_MISMATCH",
     });
+    expect(completeRun).toHaveBeenCalledWith(
+      "id",
+      "one",
+      expect.objectContaining({ sessionHealth: "mismatch" }),
+    );
+  });
 
-    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(), recordProviderProcess: vi.fn(), bindProviderSession: vi.fn(), completeRun: vi.fn(),
-        };
+  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(),
+      recordProviderProcess: vi.fn(),
+      bindProviderSession: vi.fn(),
+      completeRun: vi.fn(),
+    };
 
-        await expect(new Service({ 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();
-    });
+    await expect(
+      new Service({ 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),
-            acquireRun: vi.fn().mockResolvedValue({ agent: base, token: 'one' }),
-            recordProviderProcess: vi.fn(), bindProviderSession: vi.fn(),
-            completeRun: vi.fn().mockRejectedValue(completionFailure),
-        };
-        const runner = { run: vi.fn().mockResolvedValue({
-            sessionId: SESSION, result: 'answer', messages: ['answer'], exitCode: 0,
-        }) };
+  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),
+      acquireRun: vi.fn().mockResolvedValue({ agent: base, token: "one" }),
+      recordProviderProcess: vi.fn(),
+      bindProviderSession: vi.fn(),
+      completeRun: vi.fn().mockRejectedValue(completionFailure),
+    };
+    const runner = {
+      run: vi.fn().mockResolvedValue({
+        sessionId: SESSION,
+        result: "answer",
+        messages: ["answer"],
+        exitCode: 0,
+      }),
+    };
 
-        await expect(new Service({ repository, probe: { validate: vi.fn() }, runner })
-            .send('reviewer', 'x')).rejects.toBe(completionFailure);
-        expect(repository.completeRun).toHaveBeenCalledOnce();
-    });
+    await expect(
+      new Service({ 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 = {
-            list: vi.fn(), resolve: vi.fn().mockResolvedValue(base),
-            acquireRun: vi.fn().mockResolvedValue({ agent: base, token: 'one' }),
-            recordProviderProcess: vi.fn(),
-            bindProviderSession: vi.fn().mockRejectedValue(new BindingError('binding mismatch', 'CODEX_SESSION_MISMATCH')),
-            completeRun,
-        };
-        const runner = { run: vi.fn().mockImplementation(async (request) => {
-            await request.onSession(SESSION);
-            return { sessionId: SESSION, result: 'x', messages: ['x'], exitCode: 0 };
-        }) };
-        const Service = api.CodexPrintAgentService as new (options: unknown) => any;
+  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 = {
+      list: vi.fn(),
+      resolve: vi.fn().mockResolvedValue(base),
+      acquireRun: vi.fn().mockResolvedValue({ agent: base, token: "one" }),
+      recordProviderProcess: vi.fn(),
+      bindProviderSession: vi
+        .fn()
+        .mockRejectedValue(new BindingError("binding mismatch", "CODEX_SESSION_MISMATCH")),
+      completeRun,
+    };
+    const runner = {
+      run: vi.fn().mockImplementation(async (request) => {
+        await request.onSession(SESSION);
+        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'))
-            .rejects.toMatchObject({ code: 'CODEX_SESSION_MISMATCH' });
-        expect(completeRun).toHaveBeenCalledWith('id', 'one', expect.objectContaining({ sessionHealth: 'mismatch' }));
-    });
+    await expect(
+      new Service({ repository, probe: { validate: vi.fn() }, runner }).send("reviewer", "x"),
+    ).rejects.toMatchObject({ code: "CODEX_SESSION_MISMATCH" });
+    expect(completeRun).toHaveBeenCalledWith(
+      "id",
+      "one",
+      expect.objectContaining({ sessionHealth: "mismatch" }),
+    );
+  });
 
-    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 = {
-            list: vi.fn(), create: vi.fn(), resolve: vi.fn().mockResolvedValueOnce(null).mockResolvedValueOnce([base, base]),
-            acquireRun: vi.fn(), recordProviderProcess: vi.fn(), bindProviderSession: vi.fn(), completeRun: vi.fn(),
-        };
-        const service = new Service({ repository, probe: { validate: vi.fn() }, runner: { run: vi.fn() } });
-        await expect(service.send('missing', 'x')).rejects.toMatchObject({ code: 'DURABLE_AGENT_NOT_FOUND' });
-        await expect(service.send('ambiguous', 'x')).rejects.toMatchObject({ code: 'CODEX_UNSUPPORTED' });
-        expect(repository.acquireRun).not.toHaveBeenCalled();
+  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 = {
+      list: vi.fn(),
+      create: vi.fn(),
+      resolve: vi.fn().mockResolvedValueOnce(null).mockResolvedValueOnce([base, base]),
+      acquireRun: vi.fn(),
+      recordProviderProcess: vi.fn(),
+      bindProviderSession: vi.fn(),
+      completeRun: vi.fn(),
+    };
+    const service = new Service({
+      repository,
+      probe: { validate: vi.fn() },
+      runner: { run: vi.fn() },
+    });
+    await expect(service.send("missing", "x")).rejects.toMatchObject({
+      code: "DURABLE_AGENT_NOT_FOUND",
+    });
+    await expect(service.send("ambiguous", "x")).rejects.toMatchObject({
+      code: "CODEX_UNSUPPORTED",
     });
+    expect(repository.acquireRun).not.toHaveBeenCalled();
+  });
 });