@ai-devkit/agent-manager 0.29.0 → 0.30.0

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

@@ -6,7 +6,7 @@ import type { MockedFunction } from 'vitest';
 import * as fs from 'fs';
 import * as path from 'path';
 
-import { ClaudeCodeAdapter } from '../../adapters/ClaudeCodeAdapter.js';
+import { ClaudeCodeAdapter } from '../../providers/claude/ClaudeCodeAdapter.js';
 import type { ProcessInfo } from '../../adapters/AgentAdapter.js';
 import { AgentStatus } from '../../adapters/AgentAdapter.js';
 import { listAgentProcesses, enrichProcesses, captureProcessSnapshot } from '../../utils/process.js';
@@ -764,115 +764,6 @@ describe('ClaudeCodeAdapter', () => {
         });
     });
 
-    describe('discoverSessions', () => {
-        let tmpDir: string;
-
-        beforeEach(() => {
-            tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-test-'));
-            (adapter as any).projectsDir = path.join(tmpDir, 'projects');
-        });
-
-        afterEach(() => {
-            fs.rmSync(tmpDir, { recursive: true, force: true });
-        });
-
-        it('should return empty when projects dir does not exist', () => {
-            (adapter as any).projectsDir = path.join(tmpDir, 'nonexistent');
-            const discoverSessions = (adapter as any).discoverSessions.bind(adapter);
-
-            const result = discoverSessions([
-                { pid: 1, command: 'claude', cwd: '/test', tty: '' },
-            ]);
-            expect(result).toEqual([]);
-        });
-
-        it('should scan only directories matching process CWDs', () => {
-            const projectsDir = path.join(tmpDir, 'projects');
-            (adapter as any).projectsDir = projectsDir;
-            const discoverSessions = (adapter as any).discoverSessions.bind(adapter);
-
-            // /my/project → -my-project (encoded dir)
-            const encodedDir = path.join(projectsDir, '-my-project');
-            fs.mkdirSync(encodedDir, { recursive: true });
-
-            // Also create another dir that should NOT be scanned
-            const otherDir = path.join(projectsDir, '-other-project');
-            fs.mkdirSync(otherDir, { recursive: true });
-
-            const mockFiles: SessionFile[] = [
-                {
-                    sessionId: 's1',
-                    filePath: path.join(encodedDir, 's1.jsonl'),
-                    projectDir: encodedDir,
-                    birthtimeMs: 1710800324000,
-                    resolvedCwd: '',
-                },
-            ];
-            mockedBatchGetSessionFileBirthtimes.mockReturnValue(mockFiles);
-
-            const processes = [
-                { pid: 1, command: 'claude', cwd: '/my/project', tty: '' },
-            ];
-
-            const result = discoverSessions(processes);
-            expect(result).toHaveLength(1);
-            expect(result[0].resolvedCwd).toBe('/my/project');
-            // batchGetSessionFileBirthtimes called once with all dirs
-            expect(mockedBatchGetSessionFileBirthtimes).toHaveBeenCalledTimes(1);
-            expect(mockedBatchGetSessionFileBirthtimes).toHaveBeenCalledWith([encodedDir]);
-        });
-
-        it('should return empty when encoded dir does not exist', () => {
-            const projectsDir = path.join(tmpDir, 'projects');
-            fs.mkdirSync(projectsDir, { recursive: true });
-            (adapter as any).projectsDir = projectsDir;
-            const discoverSessions = (adapter as any).discoverSessions.bind(adapter);
-
-            // Process CWD /test encodes to -test, but that dir doesn't exist
-            const result = discoverSessions([
-                { pid: 1, command: 'claude', cwd: '/test', tty: '' },
-            ]);
-            expect(result).toEqual([]);
-            expect(mockedBatchGetSessionFileBirthtimes).not.toHaveBeenCalled();
-        });
-
-        it('should deduplicate when multiple processes share same CWD', () => {
-            const projectsDir = path.join(tmpDir, 'projects');
-            (adapter as any).projectsDir = projectsDir;
-            const discoverSessions = (adapter as any).discoverSessions.bind(adapter);
-
-            const encodedDir = path.join(projectsDir, '-my-project');
-            fs.mkdirSync(encodedDir, { recursive: true });
-
-            mockedBatchGetSessionFileBirthtimes.mockReturnValue([
-                { sessionId: 's1', filePath: path.join(encodedDir, 's1.jsonl'), projectDir: encodedDir, birthtimeMs: 1710800324000, resolvedCwd: '' },
-            ]);
-
-            const processes = [
-                { pid: 1, command: 'claude', cwd: '/my/project', tty: '' },
-                { pid: 2, command: 'claude', cwd: '/my/project', tty: '' },
-            ];
-
-            const result = discoverSessions(processes);
-            // Should only call batch once with deduplicated dir
-            expect(mockedBatchGetSessionFileBirthtimes).toHaveBeenCalledTimes(1);
-            expect(mockedBatchGetSessionFileBirthtimes).toHaveBeenCalledWith([encodedDir]);
-            expect(result).toHaveLength(1);
-        });
-
-        it('should skip processes with empty cwd', () => {
-            const projectsDir = path.join(tmpDir, 'projects');
-            fs.mkdirSync(projectsDir, { recursive: true });
-            (adapter as any).projectsDir = projectsDir;
-            const discoverSessions = (adapter as any).discoverSessions.bind(adapter);
-
-            const result = discoverSessions([
-                { pid: 1, command: 'claude', cwd: '', tty: '' },
-            ]);
-            expect(result).toEqual([]);
-        });
-    });
-
     describe('helper methods', () => {
         describe('determineStatus', () => {
             it('should return "unknown" for sessions with no last entry type', () => {
@@ -1092,203 +983,6 @@ describe('ClaudeCodeAdapter', () => {
             fs.rmSync(tmpDir, { recursive: true, force: true });
         });
 
-        describe('tryPidFileMatching', () => {
-            let sessionsDir: string;
-            let projectsDir: string;
-
-            beforeEach(() => {
-                sessionsDir = path.join(tmpDir, 'sessions');
-                projectsDir = path.join(tmpDir, 'projects');
-                fs.mkdirSync(sessionsDir, { recursive: true });
-                (adapter as any).sessionsDir = sessionsDir;
-                (adapter as any).projectsDir = projectsDir;
-            });
-
-            const makeProc = (pid: number, cwd = '/project/test', startTime?: Date): ProcessInfo => ({
-                pid, command: 'claude', cwd, tty: 'ttys001', startTime,
-            });
-
-            const writePidFile = (pid: number, sessionId: string, cwd: string, startedAt: number) => {
-                fs.writeFileSync(
-                    path.join(sessionsDir, `${pid}.json`),
-                    JSON.stringify({ pid, sessionId, cwd, startedAt, kind: 'interactive', entrypoint: 'cli' }),
-                );
-            };
-
-            const writeJsonl = (cwd: string, sessionId: string) => {
-                const encoded = cwd.replace(/[^a-zA-Z0-9]/g, '-');
-                const projDir = path.join(projectsDir, encoded);
-                fs.mkdirSync(projDir, { recursive: true });
-                const filePath = path.join(projDir, `${sessionId}.jsonl`);
-                fs.writeFileSync(filePath, JSON.stringify({ type: 'assistant', timestamp: new Date().toISOString() }));
-                return filePath;
-            };
-
-            it('should return direct match when PID file and JSONL both exist within time tolerance', () => {
-                const startTime = new Date();
-                const proc = makeProc(1001, '/project/test', startTime);
-                writePidFile(1001, 'session-abc', '/project/test', startTime.getTime());
-                writeJsonl('/project/test', 'session-abc');
-
-                const tryMatch = (adapter as any).tryPidFileMatching.bind(adapter);
-                const { direct, fallback } = tryMatch([proc]);
-
-                expect(direct).toHaveLength(1);
-                expect(fallback).toHaveLength(0);
-                expect(direct[0].sessionFile.sessionId).toBe('session-abc');
-                expect(direct[0].sessionFile.resolvedCwd).toBe('/project/test');
-                expect(direct[0].process.pid).toBe(1001);
-            });
-
-            it('should fall back when PID file exists but JSONL is missing', () => {
-                const startTime = new Date();
-                const proc = makeProc(1002, '/project/test', startTime);
-                writePidFile(1002, 'nonexistent-session', '/project/test', startTime.getTime());
-                // No JSONL file written
-
-                const tryMatch = (adapter as any).tryPidFileMatching.bind(adapter);
-                const { direct, fallback } = tryMatch([proc]);
-
-                expect(direct).toHaveLength(0);
-                expect(fallback).toHaveLength(1);
-                expect(fallback[0].pid).toBe(1002);
-            });
-
-            it('should fall back when startedAt is stale (>60s from proc.startTime)', () => {
-                const startTime = new Date();
-                const staleTime = startTime.getTime() - 90_000; // 90 seconds earlier
-                const proc = makeProc(1003, '/project/test', startTime);
-                writePidFile(1003, 'stale-session', '/project/test', staleTime);
-                writeJsonl('/project/test', 'stale-session');
-
-                const tryMatch = (adapter as any).tryPidFileMatching.bind(adapter);
-                const { direct, fallback } = tryMatch([proc]);
-
-                expect(direct).toHaveLength(0);
-                expect(fallback).toHaveLength(1);
-            });
-
-            it('should accept PID file when startedAt is within 60s tolerance', () => {
-                const startTime = new Date();
-                const closeTime = startTime.getTime() - 30_000; // 30 seconds earlier — within tolerance
-                const proc = makeProc(1004, '/project/test', startTime);
-                writePidFile(1004, 'close-session', '/project/test', closeTime);
-                writeJsonl('/project/test', 'close-session');
-
-                const tryMatch = (adapter as any).tryPidFileMatching.bind(adapter);
-                const { direct, fallback } = tryMatch([proc]);
-
-                expect(direct).toHaveLength(1);
-                expect(fallback).toHaveLength(0);
-            });
-
-            it('should fall back when PID file is absent', () => {
-                const proc = makeProc(1005, '/project/test', new Date());
-                // No PID file written
-
-                const tryMatch = (adapter as any).tryPidFileMatching.bind(adapter);
-                const { direct, fallback } = tryMatch([proc]);
-
-                expect(direct).toHaveLength(0);
-                expect(fallback).toHaveLength(1);
-            });
-
-            it('should fall back when PID file contains malformed JSON', () => {
-                const proc = makeProc(1006, '/project/test', new Date());
-                fs.writeFileSync(path.join(sessionsDir, '1006.json'), 'not valid json {{{');
-
-                const tryMatch = (adapter as any).tryPidFileMatching.bind(adapter);
-                expect(() => {
-                    const { direct, fallback } = tryMatch([proc]);
-                    expect(direct).toHaveLength(0);
-                    expect(fallback).toHaveLength(1);
-                }).not.toThrow();
-            });
-
-            it('should fall back for all processes when sessions dir does not exist', () => {
-                (adapter as any).sessionsDir = path.join(tmpDir, 'nonexistent-sessions');
-                const processes = [makeProc(2001, '/a', new Date()), makeProc(2002, '/b', new Date())];
-
-                const tryMatch = (adapter as any).tryPidFileMatching.bind(adapter);
-                const { direct, fallback } = tryMatch(processes);
-
-                expect(direct).toHaveLength(0);
-                expect(fallback).toHaveLength(2);
-            });
-
-            it('should correctly split mixed processes (some with PID files, some without)', () => {
-                const startTime = new Date();
-                const proc1 = makeProc(3001, '/project/one', startTime);
-                const proc2 = makeProc(3002, '/project/two', startTime);
-                const proc3 = makeProc(3003, '/project/three', startTime);
-
-                writePidFile(3001, 'session-one', '/project/one', startTime.getTime());
-                writeJsonl('/project/one', 'session-one');
-                writePidFile(3003, 'session-three', '/project/three', startTime.getTime());
-                writeJsonl('/project/three', 'session-three');
-                // proc2 has no PID file
-
-                const tryMatch = (adapter as any).tryPidFileMatching.bind(adapter);
-                const { direct, fallback } = tryMatch([proc1, proc2, proc3]);
-
-                expect(direct).toHaveLength(2);
-                expect(fallback).toHaveLength(1);
-                expect(direct.map((d: any) => d.process.pid).sort()).toEqual([3001, 3003]);
-                expect(fallback[0].pid).toBe(3002);
-            });
-
-            it('should skip stale-file check when proc.startTime is undefined', () => {
-                const proc = makeProc(4001, '/project/test', undefined); // no startTime
-                writePidFile(4001, 'no-time-session', '/project/test', Date.now() - 999_999);
-                writeJsonl('/project/test', 'no-time-session');
-
-                const tryMatch = (adapter as any).tryPidFileMatching.bind(adapter);
-                const { direct, fallback } = tryMatch([proc]);
-
-                // startTime undefined → stale check skipped → direct match
-                expect(direct).toHaveLength(1);
-                expect(fallback).toHaveLength(0);
-            });
-        });
-
-        describe('getProjectDir', () => {
-            const encode = (cwd: string) => (adapter as any).getProjectDir(cwd) as string;
-
-            it('should replace path separators with hyphens', () => {
-                const expected = path.join((adapter as any).projectsDir, '-Users-foo-bar');
-                expect(encode('/Users/foo/bar')).toBe(expected);
-            });
-
-            it('should encode underscores as hyphens (matches Claude Code CLI)', () => {
-                const expected = path.join((adapter as any).projectsDir, '-Users-foo-my-project');
-                expect(encode('/Users/foo/my_project')).toBe(expected);
-            });
-
-            it('should encode dots as hyphens', () => {
-                const expected = path.join((adapter as any).projectsDir, '-Users-foo--worktrees-x');
-                expect(encode('/Users/foo/.worktrees/x')).toBe(expected);
-            });
-
-            it('should collide paths that differ only in non-alphanumeric chars', () => {
-                // The encoding is intentionally lossy — callers must
-                // disambiguate via session JSONL contents, not dir name.
-                expect(encode('/a/b_c')).toBe(encode('/a/b-c'));
-                expect(encode('/a/b_c')).toBe(encode('/a/b.c'));
-            });
-
-            it('should resolve to a real session dir when cwd contains underscores', () => {
-                const cwd = '/Users/foo/my_project';
-                const projectsDir = (adapter as any).projectsDir as string;
-                const expectedDir = path.join(projectsDir, '-Users-foo-my-project');
-                fs.mkdirSync(expectedDir, { recursive: true });
-                const sessionFile = path.join(expectedDir, 'session-underscore.jsonl');
-                fs.writeFileSync(sessionFile, '');
-
-                expect(encode(cwd)).toBe(expectedDir);
-                expect(fs.existsSync(path.join(encode(cwd), 'session-underscore.jsonl'))).toBe(true);
-            });
-        });
-
         describe('readSession', () => {
             it('should parse session file with timestamps, cwd, and entry type', () => {
                 const readSession = (adapter as any).parser.readSession.bind((adapter as any).parser);

package/src/__tests__/database/DurableAgentsDatabase.test.ts

@@ -19,9 +19,9 @@ function dbPath(): string {
 }
 
 describe('durable agents schema', () => {
-    it('migrates to version 3 with durable constraints and indexes', () => {
+    it('migrates to version 4 with durable constraints and indexes', () => {
         const connection = new DatabaseConnection({ dbPath: dbPath() });
-        expect(getSchemaVersion(connection)).toBe(3);
+        expect(getSchemaVersion(connection)).toBe(4);
         const table = connection.queryOne<{ sql: string }>(
             "SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'durable_agents'",
         );
@@ -35,6 +35,31 @@ describe('durable agents schema', () => {
         connection.close();
     });
 
+    it('upgrades a version 3 database to nullable, unique provider sessions', () => {
+        const file = dbPath();
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        const raw = new Database(file);
+        raw.exec(`
+            CREATE TABLE durable_agents (
+                id TEXT PRIMARY KEY,
+                provider_session_id TEXT NOT NULL UNIQUE
+            );
+            INSERT INTO durable_agents (id, provider_session_id) VALUES ('existing', 'existing-session');
+            PRAGMA user_version = 3;
+        `);
+        raw.close();
+
+        const connection = new DatabaseConnection({ dbPath: file });
+        expect(getSchemaVersion(connection)).toBe(4);
+        expect(() => connection.execute(
+            'INSERT INTO durable_agents (id, provider_session_id) VALUES (?, NULL)', ['codex'],
+        )).not.toThrow();
+        expect(() => connection.execute(
+            'INSERT INTO durable_agents (id, provider_session_id) VALUES (?, ?)', ['duplicate', 'existing-session'],
+        )).toThrow(/UNIQUE/i);
+        connection.close();
+    });
+
     it('enforces case-insensitive names and active-run consistency but permits new providers', () => {
         const connection = new DatabaseConnection({ dbPath: dbPath() });
         const insert = (name: string, provider: string, state = 'ready') => connection.execute(`
@@ -57,7 +82,7 @@ describe('readonly DatabaseConnection', () => {
         writable.close();
         const before = fs.statSync(file).mtimeMs;
         const readonly = new DatabaseConnection({ dbPath: file, readonly: true });
-        expect(readonly.queryOne<{ user_version: number }>('PRAGMA user_version')?.user_version).toBe(3);
+        expect(readonly.queryOne<{ user_version: number }>('PRAGMA user_version')?.user_version).toBe(4);
         readonly.close();
         expect(fs.statSync(file).mtimeMs).toBe(before);
     });

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

@@ -0,0 +1,63 @@
+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

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

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

@@ -0,0 +1,79 @@
+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';
+
+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 });
+});
+
+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 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' });
+
+        expect(runner.run.mock.calls[0][0].agent).toMatchObject({ providerSessionId: null });
+        expect(runner.run.mock.calls[1][0].agent).toMatchObject({ providerSessionId: SESSION });
+    });
+
+    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',
+        });
+    });
+});