@ai-devkit/agent-manager 0.32.0 → 0.33.1

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

@@ -1,21 +1,24 @@
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it } from "vitest";
 
-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>;
+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');
+    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");
 
-        expect(error).toMatchObject({
-            name: 'DurableAgentBusyError',
-            code: 'DURABLE_AGENT_BUSY',
-            agentId: 'agent-id',
-            message: 'Durable agent "reviewer" is busy.',
-        });
+    expect(error).toMatchObject({
+      name: "DurableAgentBusyError",
+      code: "DURABLE_AGENT_BUSY",
+      agentId: "agent-id",
+      message: 'Durable agent "reviewer" is busy.',
     });
+  });
 });

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

@@ -1,105 +1,128 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import Database from 'better-sqlite3';
-import { afterEach, describe, expect, it } from 'vitest';
-import { DurableAgentRepository } from '../../durable/DurableAgentRepository.js';
+import fs from "fs";
+import os from "os";
+import path from "path";
+import Database from "better-sqlite3";
+import { afterEach, describe, expect, it } from "vitest";
+import { DurableAgentRepository } from "../../durable/DurableAgentRepository.js";
 
 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(), 'durable-agent-sqlite-'));
-    roots.push(root);
-    const cwd = path.join(root, 'project');
-    fs.mkdirSync(cwd);
-    return { root, cwd, dbPath: path.join(root, 'state', 'agents.db') };
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "durable-agent-sqlite-"));
+  roots.push(root);
+  const cwd = path.join(root, "project");
+  fs.mkdirSync(cwd);
+  return { root, cwd, dbPath: path.join(root, "state", "agents.db") };
 }
 
-describe('DurableAgentRepository SQLite concurrency', () => {
-    it('allows exactly one acquisition across two connections', async () => {
-        const { cwd, dbPath } = fixture();
-        const identity = { pid: process.pid, startedAt: 'owner-start' };
-        const processInspector = { getIdentity: (pid: number) => pid === process.pid ? identity : null };
-        const first = new DurableAgentRepository({ dbPath, processInspector });
-        const second = new DurableAgentRepository({ dbPath, processInspector });
-        const agent = await first.create({ name: 'race', cwd });
-        const results = await Promise.allSettled([first.acquireRun(agent.id), second.acquireRun(agent.id)]);
-        expect(results.filter(({ status }) => status === 'fulfilled')).toHaveLength(1);
-        const rejected = results.find(({ status }) => status === 'rejected');
-        expect(rejected).toMatchObject({ reason: { code: 'DURABLE_AGENT_BUSY' } });
-    });
+describe("DurableAgentRepository SQLite concurrency", () => {
+  it("allows exactly one acquisition across two connections", async () => {
+    const { cwd, dbPath } = fixture();
+    const identity = { pid: process.pid, startedAt: "owner-start" };
+    const processInspector = {
+      getIdentity: (pid: number) => (pid === process.pid ? identity : null),
+    };
+    const first = new DurableAgentRepository({ dbPath, processInspector });
+    const second = new DurableAgentRepository({ dbPath, processInspector });
+    const agent = await first.create({ name: "race", cwd });
+    const results = await Promise.allSettled([
+      first.acquireRun(agent.id),
+      second.acquireRun(agent.id),
+    ]);
+    expect(results.filter(({ status }) => status === "fulfilled")).toHaveLength(1);
+    const rejected = results.find(({ status }) => status === "rejected");
+    expect(rejected).toMatchObject({ reason: { code: "DURABLE_AGENT_BUSY" } });
+  });
 
-    it('accepts deprecated lock options without creating lock artifacts', async () => {
-        const { root, cwd, dbPath } = fixture();
-        const repository = new DurableAgentRepository({
-            dbPath, lockTimeoutMs: 1, incompleteLockGraceMs: 1, mutationLockStaleMs: 1,
-        });
-        await repository.create({ name: 'lockless', cwd });
-        expect(fs.existsSync(`${dbPath}.lock`)).toBe(false);
-        expect(fs.existsSync(path.join(root, 'state', 'durable-agent-locks'))).toBe(false);
+  it("accepts deprecated lock options without creating lock artifacts", async () => {
+    const { root, cwd, dbPath } = fixture();
+    const repository = new DurableAgentRepository({
+      dbPath,
+      lockTimeoutMs: 1,
+      incompleteLockGraceMs: 1,
+      mutationLockStaleMs: 1,
     });
+    await repository.create({ name: "lockless", cwd });
+    expect(fs.existsSync(`${dbPath}.lock`)).toBe(false);
+    expect(fs.existsSync(path.join(root, "state", "durable-agent-locks"))).toBe(false);
+  });
 
-    it('keeps readonly listing pure', async () => {
-        const { cwd, dbPath } = fixture();
-        const live = new Map([[process.pid, 'owner-start']]);
-        const processInspector = { getIdentity: (pid: number) => {
-            const startedAt = live.get(pid);
-            return startedAt ? { pid, startedAt } : null;
-        } };
-        const writable = new DurableAgentRepository({ dbPath, processInspector });
-        const agent = await writable.create({ name: 'readonly', cwd });
-        await writable.acquireRun(agent.id);
-        live.clear();
-        const readonly = new DurableAgentRepository({ dbPath, readonly: true, processInspector });
-        expect((await readonly.list())[0]?.state).toBe('running');
-    });
+  it("keeps readonly listing pure", async () => {
+    const { cwd, dbPath } = fixture();
+    const live = new Map([[process.pid, "owner-start"]]);
+    const processInspector = {
+      getIdentity: (pid: number) => {
+        const startedAt = live.get(pid);
+        return startedAt ? { pid, startedAt } : null;
+      },
+    };
+    const writable = new DurableAgentRepository({ dbPath, processInspector });
+    const agent = await writable.create({ name: "readonly", cwd });
+    await writable.acquireRun(agent.id);
+    live.clear();
+    const readonly = new DurableAgentRepository({ dbPath, readonly: true, processInspector });
+    expect((await readonly.list())[0]?.state).toBe("running");
+  });
 
-    it('rejects stale tokens and caps the persisted completion summary', async () => {
-        const { cwd, dbPath } = fixture();
-        const processInspector = { getIdentity: (pid: number) => ({ pid, startedAt: 'owner-start' }) };
-        const repository = new DurableAgentRepository({ dbPath, processInspector });
-        const agent = await repository.create({ name: 'token', cwd });
-        const run = await repository.acquireRun(agent.id);
-        await expect(repository.recordProviderProcess(agent.id, 'stale', { pid: 42, startedAt: 'provider' }))
-            .rejects.toMatchObject({ code: 'DURABLE_AGENT_REPOSITORY' });
-        const completed = await repository.completeRun(agent.id, run.token, {
-            status: 'succeeded', exitCode: 0, summary: 'x'.repeat(5000), sessionHealth: 'healthy',
-        });
-        expect(completed.lastResult?.summary).toHaveLength(4096);
+  it("rejects stale tokens and caps the persisted completion summary", async () => {
+    const { cwd, dbPath } = fixture();
+    const processInspector = { getIdentity: (pid: number) => ({ pid, startedAt: "owner-start" }) };
+    const repository = new DurableAgentRepository({ dbPath, processInspector });
+    const agent = await repository.create({ name: "token", cwd });
+    const run = await repository.acquireRun(agent.id);
+    await expect(
+      repository.recordProviderProcess(agent.id, "stale", { pid: 42, startedAt: "provider" }),
+    ).rejects.toMatchObject({ code: "DURABLE_AGENT_REPOSITORY" });
+    const completed = await repository.completeRun(agent.id, run.token, {
+      status: "succeeded",
+      exitCode: 0,
+      summary: "x".repeat(5000),
+      sessionHealth: "healthy",
     });
+    expect(completed.lastResult?.summary).toHaveLength(4096);
+  });
 
-    it('does not reconcile over ownership changed after process inspection', async () => {
-        const { cwd, dbPath } = fixture();
-        let inspect: (() => void) | undefined;
-        const processInspector = { getIdentity: (pid: number) => {
-            if (inspect) inspect();
-            return inspect ? null : { pid, startedAt: 'owner-start' };
-        } };
-        const repository = new DurableAgentRepository({ dbPath, processInspector });
-        const agent = await repository.create({ name: 'cas', cwd });
-        await repository.acquireRun(agent.id);
-        const other = new Database(dbPath);
-        inspect = () => {
-            inspect = undefined;
-            other.prepare(`UPDATE durable_agents SET
+  it("does not reconcile over ownership changed after process inspection", async () => {
+    const { cwd, dbPath } = fixture();
+    let inspect: (() => void) | undefined;
+    const processInspector = {
+      getIdentity: (pid: number) => {
+        if (inspect) inspect();
+        return inspect ? null : { pid, startedAt: "owner-start" };
+      },
+    };
+    const repository = new DurableAgentRepository({ dbPath, processInspector });
+    const agent = await repository.create({ name: "cas", cwd });
+    await repository.acquireRun(agent.id);
+    const other = new Database(dbPath);
+    inspect = () => {
+      inspect = undefined;
+      other
+        .prepare(`UPDATE durable_agents SET
                 active_run_token = 'replacement-token', active_owner_started_at = 'replacement-owner'
-                WHERE id = ?`).run(agent.id);
-        };
+                WHERE id = ?`)
+        .run(agent.id);
+    };
 
-        await repository.reconcile();
+    await repository.reconcile();
 
-        expect(other.prepare('SELECT state, active_run_token FROM durable_agents WHERE id = ?').get(agent.id))
-            .toEqual({ state: 'running', active_run_token: 'replacement-token' });
-        other.close();
-    });
+    expect(
+      other
+        .prepare("SELECT state, active_run_token FROM durable_agents WHERE id = ?")
+        .get(agent.id),
+    ).toEqual({ state: "running", active_run_token: "replacement-token" });
+    other.close();
+  });
 
-    it('maps a corrupt database to a store error', () => {
-        const { dbPath } = fixture();
-        fs.mkdirSync(path.dirname(dbPath), { recursive: true });
-        fs.writeFileSync(dbPath, 'not sqlite');
-        expect(() => new DurableAgentRepository({ dbPath })).toThrow(/Cannot open durable-agent database/);
-    });
+  it("maps a corrupt database to a store error", () => {
+    const { dbPath } = fixture();
+    fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+    fs.writeFileSync(dbPath, "not sqlite");
+    expect(() => new DurableAgentRepository({ dbPath })).toThrow(
+      /Cannot open durable-agent database/,
+    );
+  });
 });

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

@@ -1,163 +1,196 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, describe, expect, it } from 'vitest';
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { afterEach, describe, expect, it } from "vitest";
 
 const tempDirs: string[] = [];
 
 afterEach(() => {
-    for (const dir of tempDirs.splice(0)) fs.rmSync(dir, { recursive: true, force: true });
+  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;
+  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);
-    const cwd = path.join(root, 'project');
-    fs.mkdirSync(cwd);
-    return { root, cwd, dbPath: path.join(root, 'state', 'agents.db') };
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "durable-agent-store-"));
+  tempDirs.push(root);
+  const cwd = path.join(root, "project");
+  fs.mkdirSync(cwd);
+  return { root, cwd, dbPath: path.join(root, "state", "agents.db") };
 }
 
-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, now: () => new Date('2026-08-07T09:00:00Z') });
-
-        const agent = await repository.create({ name: 'reviewer', cwd });
-
-        expect(agent).toMatchObject({
-            name: 'reviewer',
-            provider: 'claude',
-            mode: 'durable',
-            cwd: fs.realpathSync(cwd),
-            state: 'ready',
-            sessionHealth: 'uninitialized',
-            activeRun: null,
-        });
-        expect(agent.id).toMatch(/^[0-9a-f-]{36}$/);
-        expect(agent.providerSessionId).toMatch(/^[0-9a-f-]{36}$/);
-        expect(agent.id).not.toBe(agent.providerSessionId);
-        expect(await repository.list()).toEqual([agent]);
-        expect(fs.existsSync(dbPath)).toBe(true);
+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,
+      now: () => new Date("2026-08-07T09:00:00Z"),
     });
 
-    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 });
-
-        expect(await repository.resolve(agent.id)).toMatchObject({ id: agent.id });
-        expect(await repository.resolve('reviewer')).toMatchObject({ id: agent.id });
-        expect(await repository.resolve('view')).toBeNull();
-        await expect(repository.create({ name: 'reviewer', cwd })).rejects.toMatchObject({
-            code: 'DURABLE_AGENT_NAME_CONFLICT',
-        });
+    const agent = await repository.create({ name: "reviewer", cwd });
+
+    expect(agent).toMatchObject({
+      name: "reviewer",
+      provider: "claude",
+      mode: "durable",
+      cwd: fs.realpathSync(cwd),
+      state: "ready",
+      sessionHealth: "uninitialized",
+      activeRun: null,
+    });
+    expect(agent.id).toMatch(/^[0-9a-f-]{36}$/);
+    expect(agent.providerSessionId).toMatch(/^[0-9a-f-]{36}$/);
+    expect(agent.id).not.toBe(agent.providerSessionId);
+    expect(await repository.list()).toEqual([agent]);
+    expect(fs.existsSync(dbPath)).toBe(true);
+  });
+
+  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 });
+
+    expect(await repository.resolve(agent.id)).toMatchObject({ id: agent.id });
+    expect(await repository.resolve("reviewer")).toMatchObject({ id: agent.id });
+    expect(await repository.resolve("view")).toBeNull();
+    await expect(repository.create({ name: "reviewer", cwd })).rejects.toMatchObject({
+      code: "DURABLE_AGENT_NAME_CONFLICT",
     });
+  });
 
-    it('rejects a missing cwd', async () => {
-        const DurableAgentRepository = await loadStore();
-        const { root, dbPath } = fixture();
-        const repository = new DurableAgentRepository({ dbPath });
+  it("rejects a missing cwd", async () => {
+    const DurableAgentRepository = await loadStore();
+    const { root, dbPath } = fixture();
+    const repository = new DurableAgentRepository({ dbPath });
 
-        await expect(repository.create({ name: 'missing', cwd: path.join(root, 'missing') }))
-            .rejects.toMatchObject({ code: 'DURABLE_AGENT_REPOSITORY' });
-    });
+    await expect(
+      repository.create({ name: "missing", cwd: path.join(root, "missing") }),
+    ).rejects.toMatchObject({ code: "DURABLE_AGENT_REPOSITORY" });
+  });
 });
 
-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 = { getIdentity: (pid: number) => {
-            const startedAt = live.get(pid);
-            return startedAt ? { pid, startedAt } : null;
-        } };
-        const repository = new DurableAgentRepository({ dbPath, processInspector });
-        const agent = await repository.create({ name: 'runner', cwd });
-
-        const acquired = await repository.acquireRun(agent.id);
-        await expect(repository.acquireRun(agent.id)).rejects.toMatchObject({ code: 'DURABLE_AGENT_BUSY' });
-        await expect(repository.completeRun(agent.id, 'wrong-token', {
-            status: 'succeeded', exitCode: 0, summary: 'done', sessionHealth: 'healthy',
-        })).rejects.toMatchObject({ code: 'DURABLE_AGENT_REPOSITORY' });
-
-        const completed = await repository.completeRun(agent.id, acquired.token, {
-            status: 'succeeded', exitCode: 0, summary: 'done', sessionHealth: 'healthy',
-        });
-        expect(completed).toMatchObject({ state: 'ready', sessionHealth: 'healthy', activeRun: null });
+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 = {
+      getIdentity: (pid: number) => {
+        const startedAt = live.get(pid);
+        return startedAt ? { pid, startedAt } : null;
+      },
+    };
+    const repository = new DurableAgentRepository({ dbPath, processInspector });
+    const agent = await repository.create({ name: "runner", cwd });
+
+    const acquired = await repository.acquireRun(agent.id);
+    await expect(repository.acquireRun(agent.id)).rejects.toMatchObject({
+      code: "DURABLE_AGENT_BUSY",
     });
-
-    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'], [4242, 'provider-start']]);
-        const processInspector = { getIdentity: (pid: number) => {
-            const startedAt = live.get(pid);
-            return startedAt ? { pid, startedAt } : null;
-        } };
-        const first = new DurableAgentRepository({ dbPath, processInspector });
-        const agent = await first.create({ name: 'recoverable', cwd });
-        const run = await first.acquireRun(agent.id);
-        await first.recordProviderProcess(agent.id, run.token, { pid: 4242, startedAt: 'provider-start' });
-
-        live.delete(process.pid);
-        await expect(first.acquireRun(agent.id)).rejects.toMatchObject({ code: 'DURABLE_AGENT_BUSY' });
-
-        live.delete(4242);
-        live.set(process.pid, 'replacement-owner-start');
-        const recovered = await first.acquireRun(agent.id);
-        expect(recovered.agent).toMatchObject({
-            state: 'running',
-            lastResult: { status: 'interrupted' },
-        });
-        await first.completeRun(agent.id, recovered.token, {
-            status: 'failed', exitCode: 1, summary: 'failed', sessionHealth: 'unknown',
-        });
+    await expect(
+      repository.completeRun(agent.id, "wrong-token", {
+        status: "succeeded",
+        exitCode: 0,
+        summary: "done",
+        sessionHealth: "healthy",
+      }),
+    ).rejects.toMatchObject({ code: "DURABLE_AGENT_REPOSITORY" });
+
+    const completed = await repository.completeRun(agent.id, acquired.token, {
+      status: "succeeded",
+      exitCode: 0,
+      summary: "done",
+      sessionHealth: "healthy",
+    });
+    expect(completed).toMatchObject({ state: "ready", sessionHealth: "healthy", activeRun: null });
+  });
+
+  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"],
+      [4242, "provider-start"],
+    ]);
+    const processInspector = {
+      getIdentity: (pid: number) => {
+        const startedAt = live.get(pid);
+        return startedAt ? { pid, startedAt } : null;
+      },
+    };
+    const first = new DurableAgentRepository({ dbPath, processInspector });
+    const agent = await first.create({ name: "recoverable", cwd });
+    const run = await first.acquireRun(agent.id);
+    await first.recordProviderProcess(agent.id, run.token, {
+      pid: 4242,
+      startedAt: "provider-start",
     });
 
-    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({ dbPath, incompleteLockGraceMs: 10, processInspector: {
-            getIdentity: (pid: number) => {
-                const startedAt = live.get(pid);
-                return startedAt ? { pid, startedAt } : null;
-            },
-        } });
-        const agent = await repository.create({ name: 'crashed', cwd });
-        await repository.acquireRun(agent.id);
-        live.clear();
-
-        const listed = await repository.list();
-
-        expect(listed[0]).toMatchObject({
-            state: 'degraded',
-            sessionHealth: 'unknown',
-            activeRun: null,
-            lastResult: { status: 'interrupted' },
-        });
+    live.delete(process.pid);
+    await expect(first.acquireRun(agent.id)).rejects.toMatchObject({ code: "DURABLE_AGENT_BUSY" });
+
+    live.delete(4242);
+    live.set(process.pid, "replacement-owner-start");
+    const recovered = await first.acquireRun(agent.id);
+    expect(recovered.agent).toMatchObject({
+      state: "running",
+      lastResult: { status: "interrupted" },
+    });
+    await first.completeRun(agent.id, recovered.token, {
+      status: "failed",
+      exitCode: 1,
+      summary: "failed",
+      sessionHealth: "unknown",
+    });
+  });
+
+  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({
+      dbPath,
+      incompleteLockGraceMs: 10,
+      processInspector: {
+        getIdentity: (pid: number) => {
+          const startedAt = live.get(pid);
+          return startedAt ? { pid, startedAt } : null;
+        },
+      },
     });
+    const agent = await repository.create({ name: "crashed", cwd });
+    await repository.acquireRun(agent.id);
+    live.clear();
 
-    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 });
-        const moved = path.join(root, 'moved-project');
-        const other = path.join(root, 'other-project');
-        fs.renameSync(cwd, moved);
-        fs.mkdirSync(other);
-        fs.symlinkSync(other, cwd);
-
-        await expect(repository.acquireRun(agent.id)).rejects.toMatchObject({ code: 'DURABLE_AGENT_REPOSITORY' });
+    const listed = await repository.list();
+
+    expect(listed[0]).toMatchObject({
+      state: "degraded",
+      sessionHealth: "unknown",
+      activeRun: null,
+      lastResult: { status: "interrupted" },
+    });
+  });
+
+  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 });
+    const moved = path.join(root, "moved-project");
+    const other = path.join(root, "other-project");
+    fs.renameSync(cwd, moved);
+    fs.mkdirSync(other);
+    fs.symlinkSync(other, cwd);
+
+    await expect(repository.acquireRun(agent.id)).rejects.toMatchObject({
+      code: "DURABLE_AGENT_REPOSITORY",
     });
+  });
 });