@ai-devkit/agent-manager 0.28.1 → 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__/capacity/codex.test.ts

@@ -0,0 +1,184 @@
+import { describe, expect, it, vi } from 'vitest';
+import {
+  CODEX_APP_SERVER_ARGS,
+  parseUsage,
+  probeCodexCapacity,
+  resolveCodexAuthPath,
+  toRateWindow
+} from '../../capacity/codex.js';
+
+const checkedAt = '2026-08-20T10:00:00.000Z';
+const context = { installed: true, checkedAt };
+
+function apiUsage(overrides: Record<string, unknown> = {}) {
+  return {
+    rate_limit: {
+      primary_window: { used_percent: 20, limit_window_seconds: 18_000, reset_at: 1_787_220_000 },
+      secondary_window: { used_percent: 60, limit_window_seconds: 604_800, reset_at: 1_787_824_800 },
+      ...overrides
+    },
+    credits: { balance: 12.5 },
+    additional_rate_limits: [{
+      limit_name: 'reviews',
+      rate_limit: {
+        primary_window: { used_percent: 10, limit_window_seconds: 3_600, reset_at: 1_787_220_000 }
+      }
+    }]
+  };
+}
+
+describe('Codex auth resolution', () => {
+  it('uses CODEX_HOME before HOME', () => {
+    expect(resolveCodexAuthPath({ CODEX_HOME: '/custom/codex', HOME: '/users/test' })).toBe('/custom/codex/auth.json');
+  });
+
+  it('falls back to ~/.codex/auth.json', () => {
+    expect(resolveCodexAuthPath({ HOME: '/users/test' })).toBe('/users/test/.codex/auth.json');
+  });
+});
+
+describe('Codex API usage mapping', () => {
+  it('converts an API window without treating missing data as zero', () => {
+    expect(toRateWindow({ used_percent: 25, limit_window_seconds: 18_000, reset_at: 1_787_220_000 }, 'session', 'Session')).toEqual({
+      id: 'session', label: 'Session', durationMinutes: 300, usedPercent: 25,
+      resetsAt: '2026-08-20T10:00:00.000Z'
+    });
+    expect(toRateWindow({}, 'session', 'Session')).toMatchObject({ usedPercent: null });
+  });
+
+  it('maps session, weekly, credits, and extra limits', () => {
+    const snapshot = parseUsage(apiUsage(), 'pat');
+    expect(snapshot).toMatchObject({ source: 'pat', creditsRemaining: 12.5 });
+    expect(snapshot.windows).toEqual([
+      expect.objectContaining({ id: 'session', durationMinutes: 300 }),
+      expect.objectContaining({ id: 'weekly', durationMinutes: 10080 }),
+      expect.objectContaining({ id: 'reviews:primary', durationMinutes: 60 })
+    ]);
+  });
+
+  it('represents missing limits as unavailable rather than zero', () => {
+    const snapshot = parseUsage({ credits: {} }, 'oauth');
+    expect(snapshot.windows).toEqual([]);
+    expect(snapshot.creditsRemaining).toBeNull();
+  });
+});
+
+describe('tiered Codex probing', () => {
+  it('selects PAT, calls whoami then usage, and never invokes the CLI', async () => {
+    const fetch = vi.fn()
+      .mockResolvedValueOnce(new Response(JSON.stringify({ chatgpt_account_id: 'acct-1' }), { status: 200 }))
+      .mockResolvedValueOnce(new Response(JSON.stringify(apiUsage()), { status: 200 }));
+    const rpc = vi.fn();
+    const result = await probeCodexCapacity({
+      ...context, readFile: async () => JSON.stringify({
+        personal_access_token: 'pat-secret',
+        tokens: { access_token: 'ignored-oauth', account_id: 'ignored-account' }
+      }), fetch, rpc
+    });
+    expect(fetch).toHaveBeenCalledTimes(2);
+    expect(fetch.mock.calls[0][0]).toBe('https://auth.openai.com/api/accounts/v1/user-auth-credential/whoami');
+    expect(fetch.mock.calls[1][0]).toBe('https://chatgpt.com/backend-api/wham/usage');
+    expect(fetch.mock.calls[1][1].headers).toMatchObject({ Authorization: 'Bearer pat-secret', 'ChatGPT-Account-Id': 'acct-1' });
+    expect(rpc).not.toHaveBeenCalled();
+    expect(result).toMatchObject({ provider: 'codex', available: 'yes', creditsRemaining: 12.5, authenticated: true });
+    expect(result.windows.map(window => window.id)).toEqual(['session', 'weekly', 'reviews:primary']);
+  });
+
+  it('selects a fresh OAuth token without calling whoami', async () => {
+    const fetch = vi.fn().mockResolvedValue(new Response(JSON.stringify(apiUsage()), { status: 200 }));
+    const result = await probeCodexCapacity({
+      ...context,
+      readFile: async () => JSON.stringify({ tokens: { access_token: 'oauth-secret', account_id: 'acct-2', expires_at: 1_800_000_000 } }),
+      fetch,
+      now: () => new Date('2026-08-20T10:00:00.000Z')
+    });
+    expect(fetch).toHaveBeenCalledOnce();
+    expect(fetch.mock.calls[0][1].headers).toMatchObject({ Authorization: 'Bearer oauth-secret', 'ChatGPT-Account-Id': 'acct-2' });
+    expect(result.available).toBe('yes');
+  });
+
+  it.each([
+    ['missing auth file', async () => { throw Object.assign(new Error('missing'), { code: 'ENOENT' }); }],
+    ['stale OAuth token', async () => JSON.stringify({ tokens: { access_token: 'stale-secret', account_id: 'acct', expires_at: 1 } })],
+    ['OAuth 401', async () => JSON.stringify({ tokens: { access_token: 'oauth-secret', account_id: 'acct', expires_at: 1_800_000_000 } })]
+  ])('falls back to the CLI for %s', async (name, readFile) => {
+    const fetch = vi.fn().mockResolvedValue(new Response('', { status: name === 'OAuth 401' ? 401 : 200 }));
+    const rpc = vi.fn(async () => ({
+      rateLimits: { rateLimits: { primary: { usedPercent: 5, windowDurationMins: 300, resetsAt: null } } },
+      account: { account: { type: 'chatgpt' } }
+    }));
+    const result = await probeCodexCapacity({ ...context, readFile, fetch, rpc, now: () => new Date(checkedAt) });
+    expect(rpc).toHaveBeenCalledOnce();
+    expect(result.windows).toHaveLength(1);
+  });
+
+  it('falls back to CLI if PAT requests fail', async () => {
+    const rpc = vi.fn(async () => ({ rateLimits: {}, account: { account: null } }));
+    const result = await probeCodexCapacity({
+      ...context,
+      readFile: async () => JSON.stringify({ personal_access_token: 'pat-secret' }),
+      fetch: vi.fn().mockRejectedValue(new Error('network failure pat-secret')),
+      rpc
+    });
+    expect(rpc).toHaveBeenCalledOnce();
+    expect(result.available).toBe('unknown');
+  });
+
+  it('tries fresh OAuth after a PAT request fails', async () => {
+    const fetch = vi.fn()
+      .mockRejectedValueOnce(new Error('PAT failed'))
+      .mockResolvedValueOnce(new Response(JSON.stringify(apiUsage()), { status: 200 }));
+    const rpc = vi.fn();
+    const result = await probeCodexCapacity({
+      ...context,
+      readFile: async () => JSON.stringify({
+        personal_access_token: 'pat-secret',
+        tokens: { access_token: 'oauth-secret', account_id: 'acct', expires_at: 1_800_000_000 }
+      }),
+      fetch,
+      rpc,
+      now: () => new Date(checkedAt)
+    });
+    expect(fetch).toHaveBeenCalledTimes(2);
+    expect(result.available).toBe('yes');
+    expect(rpc).not.toHaveBeenCalled();
+  });
+
+  it('uses hardened read-only app-server arguments and both account methods', async () => {
+    const rpc = vi.fn(async () => ({
+      rateLimits: { rateLimits: { primary: { usedPercent: 5, windowDurationMins: 300, resetsAt: null } } },
+      account: { account: { type: 'chatgpt' } }
+    }));
+    await probeCodexCapacity({ ...context, readFile: async () => '{}', rpc });
+    const messages = rpc.mock.calls[0][0];
+    expect(messages.map(message => message.method)).toEqual([
+      'initialize', 'initialized', 'account/rateLimits/read', 'account/read'
+    ]);
+    expect(JSON.stringify(messages)).not.toMatch(/prompt|turn\/start/);
+    expect(CODEX_APP_SERVER_ARGS).toEqual(['-s', 'read-only', '-a', 'untrusted', 'app-server']);
+  });
+
+  it('uses account/read to distinguish logged-out CLI state', async () => {
+    const result = await probeCodexCapacity({
+      ...context,
+      readFile: async () => '{}',
+      rpc: async () => ({ rateLimits: {}, account: { account: null } })
+    });
+    expect(result).toMatchObject({ authenticated: false, available: 'unknown' });
+  });
+
+  it('never exposes tokens or raw auth content through failures', async () => {
+    const secrets = ['pat-secret-value', 'oauth-secret-value', 'refresh-secret-value'];
+    const result = await probeCodexCapacity({
+      ...context,
+      readFile: async () => JSON.stringify({
+        personal_access_token: secrets[0],
+        tokens: { access_token: secrets[1], refresh_token: secrets[2] }
+      }),
+      fetch: vi.fn().mockRejectedValue(new Error(secrets.join(' '))),
+      rpc: async () => { throw new Error(secrets.join(' ')); }
+    });
+    const output = JSON.stringify(result);
+    for (const secret of secrets) expect(output).not.toContain(secret);
+  });
+});

package/src/__tests__/capacity/index.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getCodexCapacityReport } from '../../capacity/index.js';
+
+const checkedAt = '2026-08-09T10:00:00.000Z';
+
+describe('getCodexCapacityReport', () => {
+  it('checks Codex installation before probing', async () => {
+    const probe = vi.fn(async context => ({
+      provider: 'codex', generatedAt: context.checkedAt,
+      authenticated: true, available: 'yes' as const, windows: [], creditsRemaining: null
+    }));
+
+    const report = await getCodexCapacityReport({
+      now: () => new Date(checkedAt),
+      path: '/usr/bin:/opt/bin',
+      access: async target => {
+        if (target !== '/opt/bin/codex') throw new Error('missing');
+      },
+      probe
+    });
+
+    expect(probe).toHaveBeenCalledWith({ installed: true, checkedAt });
+    expect(report).toMatchObject({ provider: 'codex', generatedAt: checkedAt, available: 'yes' });
+  });
+
+  it('redacts unexpected probe failures into a stable unknown result', async () => {
+    const report = await getCodexCapacityReport({
+      now: () => new Date(checkedAt),
+      path: '',
+      probe: async () => { throw new Error('private provider response'); }
+    });
+
+    expect(report).toMatchObject({
+      provider: 'codex', available: 'unknown', authenticated: null, windows: []
+    });
+    expect(JSON.stringify(report)).not.toContain('private provider response');
+  });
+});

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' });
+    });
+});