skimpyclaw 0.3.15 → 0.4.0

package/dist/__tests__/code-agents-notifications.test.js

@@ -0,0 +1,137 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const { sendActiveChannelProactiveMessageMock, sendToDiscordThreadMock, sendToDiscordThreadWithAttachmentsMock, sendDiscordProactiveMessageMock, sendDiscordProactiveMessageWithAttachmentsMock, } = vi.hoisted(() => ({
+    sendActiveChannelProactiveMessageMock: vi.fn(async () => true),
+    sendToDiscordThreadMock: vi.fn(async () => false),
+    sendToDiscordThreadWithAttachmentsMock: vi.fn(async () => false),
+    sendDiscordProactiveMessageMock: vi.fn(async () => undefined),
+    sendDiscordProactiveMessageWithAttachmentsMock: vi.fn(async () => undefined),
+}));
+vi.mock('../channels.js', () => ({
+    sendActiveChannelProactiveMessage: sendActiveChannelProactiveMessageMock,
+}));
+vi.mock('../channels/discord/index.js', () => ({
+    sendToDiscordThread: sendToDiscordThreadMock,
+    sendToDiscordThreadWithAttachments: sendToDiscordThreadWithAttachmentsMock,
+    sendDiscordProactiveMessage: sendDiscordProactiveMessageMock,
+    sendDiscordProactiveMessageWithAttachments: sendDiscordProactiveMessageWithAttachmentsMock,
+}));
+import { buildCodeAgentDiscordNotification, notifyCodeAgentResult, setCodeAgentConfig } from '../code-agents/utils.js';
+describe('notifyCodeAgentResult Discord routing', () => {
+    const config = { channels: { active: 'discord' } };
+    const completedTask = {
+        id: 'ca-1',
+        agent: 'codex',
+        task: 'Fix Discord routing',
+        status: 'completed',
+        startedAt: '2026-04-12T00:00:00.000Z',
+        durationSeconds: 12,
+        workdir: '/tmp',
+        outputPreview: 'Patched notifier routing.',
+    };
+    beforeEach(() => {
+        vi.clearAllMocks();
+        setCodeAgentConfig(config);
+        sendToDiscordThreadMock.mockResolvedValue(false);
+        sendToDiscordThreadWithAttachmentsMock.mockResolvedValue(false);
+        sendDiscordProactiveMessageMock.mockResolvedValue(undefined);
+        sendDiscordProactiveMessageWithAttachmentsMock.mockResolvedValue(undefined);
+        sendActiveChannelProactiveMessageMock.mockResolvedValue(true);
+    });
+    it('falls back from Discord thread to the originating Discord channel', async () => {
+        await notifyCodeAgentResult({
+            ...completedTask,
+            discordThreadId: 'thread-1',
+            discordChannelId: 'channel-1',
+        });
+        expect(sendToDiscordThreadMock).toHaveBeenCalledWith('thread-1', expect.stringContaining('`ca-1` completed'));
+        expect(sendDiscordProactiveMessageMock).toHaveBeenCalledWith('channel-1', expect.stringContaining('`ca-1` completed'));
+        expect(sendActiveChannelProactiveMessageMock).not.toHaveBeenCalled();
+    });
+    it('does not fall back to the global active channel when Discord-scoped delivery fails', async () => {
+        sendDiscordProactiveMessageMock.mockRejectedValue(new Error('channel missing'));
+        await notifyCodeAgentResult({
+            ...completedTask,
+            discordThreadId: 'thread-1',
+            discordChannelId: 'channel-1',
+        });
+        expect(sendToDiscordThreadMock).toHaveBeenCalled();
+        expect(sendDiscordProactiveMessageMock).toHaveBeenCalled();
+        expect(sendActiveChannelProactiveMessageMock).not.toHaveBeenCalled();
+    });
+    it('uses the active channel only when the task has no Discord-specific route', async () => {
+        await notifyCodeAgentResult(completedTask);
+        expect(sendToDiscordThreadMock).not.toHaveBeenCalled();
+        expect(sendDiscordProactiveMessageMock).not.toHaveBeenCalled();
+        expect(sendActiveChannelProactiveMessageMock).toHaveBeenCalledWith(config, expect.stringContaining('Coding agent ca-1 completed'));
+    });
+    it('sends compact Discord summary with full report attachment for long output', async () => {
+        const longOutput = [
+            'Findings',
+            '',
+            '- High: important issue was resolved on current branch.',
+            '- Low: coverage gaps remain.',
+            '',
+            'Risk Checks',
+            '',
+            'No reproducible leak found in current code.',
+            '',
+            'Recommendation',
+            '',
+            'Merge only if the PR head is current.',
+            '',
+            'Details '.repeat(500),
+        ].join('\n');
+        await notifyCodeAgentResult({
+            ...completedTask,
+            agent: 'claude',
+            model: 'claude-opus-4-6',
+            effort: 'xhigh',
+            discordThreadId: 'thread-1',
+            outputPreview: longOutput,
+        });
+        expect(sendToDiscordThreadWithAttachmentsMock).toHaveBeenCalledWith('thread-1', expect.stringContaining('`ca-1` completed · CLAUDE · claude-opus-4-6 · effort xhigh'), [expect.objectContaining({
+                name: 'ca-1-report.md',
+                content: expect.stringContaining('## Result'),
+            })]);
+        const message = sendToDiscordThreadWithAttachmentsMock.mock.calls[0][1];
+        expect(message.length).toBeLessThan(1900);
+        expect(message).toContain('Full report attached.');
+    });
+    it('strips raw Codex stream-json from Discord summary', () => {
+        const rawCodexOutput = [
+            JSON.stringify({ type: 'thread.started', thread_id: 't1' }),
+            JSON.stringify({ type: 'turn.started' }),
+            JSON.stringify({
+                type: 'item.completed',
+                item: {
+                    id: 'item_1',
+                    type: 'agent_message',
+                    text: 'Findings\n\n- High: state contract can regress.\n\nRecommendation\n\nDo not merge until fixed.',
+                },
+            }),
+            JSON.stringify({
+                type: 'item.started',
+                item: {
+                    id: 'item_2',
+                    type: 'command_execution',
+                    command: 'git status --short',
+                    status: 'in_progress',
+                },
+            }),
+        ].join('\n');
+        const notification = buildCodeAgentDiscordNotification({
+            ...completedTask,
+            agent: 'codex',
+            model: 'gpt-5.5',
+            effort: 'high',
+            outputPreview: rawCodexOutput,
+            task: 'Review PR https://github.com/Automattic/wp-calypso/pull/110225',
+        });
+        expect(notification.content).toContain('**Findings**');
+        expect(notification.content).toContain('state contract can regress');
+        expect(notification.content).toContain('**Decision**');
+        expect(notification.content).not.toContain('thread.started');
+        expect(notification.content).not.toContain('command_execution');
+        expect(notification.content).not.toContain('{"type"');
+    });
+});

package/dist/__tests__/code-agents-parser.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { parseClaudeOutput, parseStreamJsonForLive } from '../code-agents/parser.js';
+import { parseClaudeOutput, parseCodexOutput, parseStreamJsonForLive } from '../code-agents/parser.js';
 describe('code-agents parser', () => {
     it('parses newer Claude stream item.completed agent_message events', () => {
         const stdout = [
@@ -36,4 +36,22 @@ describe('code-agents parser', () => {
         expect(live).toContain('New format message');
         expect(live).toContain('[Read]');
     });
+    it('parses Codex stream-json without leaking raw events', () => {
+        const stdout = [
+            JSON.stringify({ type: 'thread.started', thread_id: 't1' }),
+            JSON.stringify({ type: 'turn.started' }),
+            JSON.stringify({
+                type: 'item.completed',
+                item: { id: 'item_1', type: 'agent_message', text: 'Final review text.' },
+            }),
+            JSON.stringify({
+                type: 'item.started',
+                item: { id: 'item_2', type: 'command_execution', command: 'git status', status: 'in_progress' },
+            }),
+        ].join('\n');
+        const parsed = parseCodexOutput(stdout);
+        expect(parsed).toBe('Final review text.');
+        expect(parsed).not.toContain('thread.started');
+        expect(parsed).not.toContain('command_execution');
+    });
 });

package/dist/__tests__/code-agents-preflight.test.js

@@ -1,5 +1,5 @@
 import { afterEach, describe, expect, it, vi } from 'vitest';
-const PRECHECK_ERROR = 'Error: No supported coding CLI found on PATH. Install Codex CLI (`codex`), Claude Code CLI (`claude` or `claude-code`), or Kimi CLI (`kimi`).';
+const PRECHECK_ERROR = 'Error: No supported coding CLI found on PATH. Install Codex CLI (`codex`) or Claude Code CLI (`claude` or `claude-code`).';
 const toolConfig = {
     enabled: true,
     allowedPaths: [process.cwd()],
@@ -9,7 +9,6 @@ const toolConfig = {
 async function loadSubject(preflightError) {
     vi.resetModules();
     const runCodeAgentBackground = vi.fn().mockResolvedValue(undefined);
-    const runTeamOrchestrator = vi.fn().mockResolvedValue(undefined);
     vi.doMock('../code-agents/utils.js', async () => {
         const actual = await vi.importActual('../code-agents/utils.js');
         return {
@@ -22,13 +21,6 @@ async function loadSubject(preflightError) {
         runValidation: vi.fn(),
         buildValidationCommand: vi.fn(() => 'pnpm build && pnpm test'),
     }));
-    vi.doMock('../code-agents/orchestrator.js', () => ({
-        runTeamOrchestrator,
-        computeWaves: vi.fn(),
-        decomposeTask: vi.fn(),
-        synthesizeResults: vi.fn(),
-        gatherCodebaseContext: vi.fn(),
-    }));
     vi.doMock('../code-agents/registry.js', () => ({
         getNextCodeAgentId: vi.fn(() => 'ca_test_1'),
         storeCodeAgentTask: vi.fn(),
@@ -42,17 +34,16 @@ async function loadSubject(preflightError) {
         getCodeAgentsDir: vi.fn(() => process.cwd()),
     }));
     const subject = await import('../code-agents/index.js');
-    return { ...subject, runCodeAgentBackground, runTeamOrchestrator };
+    return { ...subject, runCodeAgentBackground };
 }
 afterEach(() => {
     vi.doUnmock('../code-agents/utils.js');
     vi.doUnmock('../code-agents/executor.js');
-    vi.doUnmock('../code-agents/orchestrator.js');
     vi.doUnmock('../code-agents/registry.js');
     vi.clearAllMocks();
     vi.resetModules();
 });
-describe('coding CLI preflight guard', () => {
+describe('coding CLI preflight guard', { timeout: 15000 }, () => {
     it('fails code_with_agent before spawning when no supported CLI is available', async () => {
         const { executeCodeWithAgent, runCodeAgentBackground } = await loadSubject(PRECHECK_ERROR);
         const result = await executeCodeWithAgent({ task: 'Fix bug', workdir: process.cwd() }, toolConfig, {
@@ -61,14 +52,6 @@ describe('coding CLI preflight guard', () => {
         expect(result).toBe(PRECHECK_ERROR);
         expect(runCodeAgentBackground).not.toHaveBeenCalled();
     });
-    it('fails code_with_team before spawning when no supported CLI is available', async () => {
-        const { executeCodeWithTeam, runTeamOrchestrator } = await loadSubject(PRECHECK_ERROR);
-        const result = await executeCodeWithTeam({ task: 'Refactor auth', workdir: process.cwd() }, toolConfig, {
-            fullConfig: { codeAgents: { maxConcurrent: 99 } },
-        });
-        expect(result).toBe(PRECHECK_ERROR);
-        expect(runTeamOrchestrator).not.toHaveBeenCalled();
-    });
     it('allows code_with_agent when at least one supported CLI exists', async () => {
         const { executeCodeWithAgent, runCodeAgentBackground } = await loadSubject(null);
         const result = await executeCodeWithAgent({ task: 'Fix bug', workdir: process.cwd() }, toolConfig, {
@@ -77,12 +60,4 @@ describe('coding CLI preflight guard', () => {
         expect(result).toContain('Started coding agent');
         expect(runCodeAgentBackground).toHaveBeenCalledTimes(1);
     });
-    it('allows code_with_team when at least one supported CLI exists', async () => {
-        const { executeCodeWithTeam, runTeamOrchestrator } = await loadSubject(null);
-        const result = await executeCodeWithTeam({ task: 'Refactor auth', workdir: process.cwd() }, toolConfig, {
-            fullConfig: { codeAgents: { maxConcurrent: 99 } },
-        });
-        expect(result).toContain('Started coding team');
-        expect(runTeamOrchestrator).toHaveBeenCalledTimes(1);
-    });
 });

package/dist/__tests__/code-agents-utils.test.js

@@ -1,15 +1,16 @@
 import { describe, expect, it } from 'vitest';
-import { normalizeCodeAgent, resolveSelectedCodeAgent, getAvailableCodingCliTools, getCodingCliPreflightError, } from '../code-agents/utils.js';
+import { mkdtempSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { homedir, tmpdir } from 'os';
+import { buildCodeAgentSpawnEnv, normalizeCodeAgent, resolveSelectedCodeAgent, getAvailableCodingCliTools, getCodingCliPreflightError, readClaudeCodeDefaultModel, resolveCodeAgentModelLabel, } from '../code-agents/utils.js';
 describe('normalizeCodeAgent', () => {
     it('accepts strict ids', () => {
         expect(normalizeCodeAgent('claude')).toBe('claude');
         expect(normalizeCodeAgent('codex')).toBe('codex');
-        expect(normalizeCodeAgent('kimi')).toBe('kimi');
     });
     it('maps legacy alias-like values', () => {
-        expect(normalizeCodeAgent('claude-think')).toBe('claude');
+        expect(normalizeCodeAgent('claude-coder')).toBe('claude');
         expect(normalizeCodeAgent('codex5.3')).toBe('codex');
-        expect(normalizeCodeAgent('kimi/coding')).toBe('kimi');
     });
     it('returns null for unknown values', () => {
         expect(normalizeCodeAgent('gpt')).toBeNull();
@@ -21,7 +22,7 @@ describe('resolveSelectedCodeAgent', () => {
         expect(resolveSelectedCodeAgent('codex5.3', 'claude')).toBe('codex');
     });
     it('falls back to configured default agent', () => {
-        expect(resolveSelectedCodeAgent(undefined, 'claude-think')).toBe('claude');
+        expect(resolveSelectedCodeAgent(undefined, 'claude-coder')).toBe('claude');
     });
     it('uses claude as hard default', () => {
         expect(resolveSelectedCodeAgent(undefined, undefined)).toBe('claude');
@@ -32,9 +33,6 @@ describe('resolveSelectedCodeAgent', () => {
         expect(resolveSelectedCodeAgent(undefined, 'claude', 'openai/gpt-4.1')).toBe('codex');
         expect(resolveSelectedCodeAgent(undefined, 'claude', 'o3-pro')).toBe('codex');
     });
-    it('auto-selects kimi when model is a kimi model and no agent specified', () => {
-        expect(resolveSelectedCodeAgent(undefined, 'claude', 'kimi-for-coding')).toBe('kimi');
-    });
     it('respects explicit agent even when model suggests different agent', () => {
         expect(resolveSelectedCodeAgent('claude', 'claude', 'gpt-4.1')).toBe('claude');
     });
@@ -42,7 +40,7 @@ describe('resolveSelectedCodeAgent', () => {
 describe('coding CLI preflight', () => {
     it('returns a clear error when no supported CLI is found on PATH', () => {
         expect(getAvailableCodingCliTools(() => false)).toEqual([]);
-        expect(getCodingCliPreflightError(() => false)).toBe('Error: No supported coding CLI found on PATH. Install Codex CLI (`codex`), Claude Code CLI (`claude` or `claude-code`), or Kimi CLI (`kimi`).');
+        expect(getCodingCliPreflightError(() => false)).toBe('Error: No supported coding CLI found on PATH. Install Codex CLI (`codex`) or Claude Code CLI (`claude` or `claude-code`).');
     });
     it('accepts claude-code binary as claude support', () => {
         const hasCommand = (name) => name === 'claude-code';
@@ -50,3 +48,30 @@ describe('coding CLI preflight', () => {
         expect(getCodingCliPreflightError(hasCommand)).toBeNull();
     });
 });
+describe('buildCodeAgentSpawnEnv', () => {
+    it('points Codex subprocesses at the standard ~/.codex state directory', () => {
+        const env = buildCodeAgentSpawnEnv({
+            HOME: '/tmp/ignored-home',
+            CODEX_HOME: '/tmp/old-codex-home',
+            GH_TOKEN: 'stale-gh',
+            GITHUB_TOKEN: 'stale-github',
+            CLAUDECODE: 'nested',
+        });
+        expect(env.CODEX_HOME).toBe(join(homedir(), '.codex'));
+        expect(env.CLAUDECODE).toBeUndefined();
+        expect(env.GH_TOKEN).toBeUndefined();
+        expect(env.GITHUB_TOKEN).toBeUndefined();
+    });
+});
+describe('code agent model labels', () => {
+    it('reads Claude Code default model from settings', () => {
+        const dir = mkdtempSync(join(tmpdir(), 'skimpyclaw-claude-settings-'));
+        const settingsPath = join(dir, 'settings.json');
+        writeFileSync(settingsPath, JSON.stringify({ model: 'opus[1m]' }));
+        expect(readClaudeCodeDefaultModel(settingsPath)).toBe('opus[1m]');
+    });
+    it('strips provider prefixes for explicit model labels', () => {
+        expect(resolveCodeAgentModelLabel('claude', 'anthropic/claude-opus-4-7')).toBe('claude-opus-4-7');
+        expect(resolveCodeAgentModelLabel('codex', 'codex/gpt-5.5')).toBe('gpt-5.5');
+    });
+});

package/dist/__tests__/code-agents-worktrees.test.js

@@ -0,0 +1,116 @@
+import { execFileSync } from 'child_process';
+import { existsSync, mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { cleanupCodeAgentWorktree, normalizeWorktreeRequest, prepareCodeAgentWorktree, shouldAutoWorktreeTask, shouldUseCodeAgentWorktree, } from '../code-agents/worktrees.js';
+const roots = [];
+function git(cwd, args) {
+    execFileSync('git', args, { cwd, stdio: 'ignore' });
+}
+function makeRepo() {
+    const root = mkdtempSync(join(tmpdir(), 'skimpyclaw-worktree-test-'));
+    roots.push(root);
+    git(root, ['init']);
+    git(root, ['config', 'user.email', 'test@example.com']);
+    git(root, ['config', 'user.name', 'Test']);
+    mkdirSync(join(root, 'packages', 'demo'), { recursive: true });
+    writeFileSync(join(root, 'README.md'), '# test\n');
+    writeFileSync(join(root, 'packages', 'demo', 'package.json'), '{"name":"demo"}\n');
+    git(root, ['add', '.']);
+    git(root, ['commit', '-m', 'init']);
+    return root;
+}
+afterEach(() => {
+    for (const root of roots.splice(0)) {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+describe('code agent worktrees', () => {
+    it('normalizes worktree requests', () => {
+        expect(normalizeWorktreeRequest(true)).toBe(true);
+        expect(normalizeWorktreeRequest('yes')).toBe(true);
+        expect(normalizeWorktreeRequest('off')).toBe(false);
+        expect(normalizeWorktreeRequest('auto')).toBe('auto');
+        expect(normalizeWorktreeRequest('wat')).toBeUndefined();
+    });
+    it('defaults auto worktrees to review and rebase tasks only', () => {
+        expect(shouldAutoWorktreeTask('Review PR https://github.com/org/repo/pull/123')).toBe(true);
+        expect(shouldAutoWorktreeTask('rebase this branch from trunk')).toBe(true);
+        expect(shouldAutoWorktreeTask('fix this css bug')).toBe(false);
+        expect(shouldUseCodeAgentWorktree('fix this css bug', undefined, { mode: 'always' })).toBe(true);
+        expect(shouldUseCodeAgentWorktree('Review PR', false, { mode: 'always' })).toBe(false);
+    });
+    it('creates a detached worktree and preserves subdirectory workdir', () => {
+        const repo = makeRepo();
+        const root = mkdtempSync(join(tmpdir(), 'skimpyclaw-worktrees-'));
+        roots.push(root);
+        const result = prepareCodeAgentWorktree({
+            id: 'ca-123',
+            sourceWorkdir: join(repo, 'packages', 'demo'),
+            config: { root },
+            required: true,
+        });
+        expect(result).toBeDefined();
+        expect(result?.sourceWorkdir).toBe(realpathSync(join(repo, 'packages', 'demo')));
+        expect(result?.runWorkdir).toBe(join(result.worktreePath, 'packages', 'demo'));
+        expect(existsSync(result.worktreePath)).toBe(true);
+        expect(existsSync(result.runWorkdir)).toBe(true);
+        expect(result?.worktreeRef).toMatch(/^[0-9a-f]{40}$/);
+    });
+    it('removes clean unchanged worktrees', () => {
+        const repo = makeRepo();
+        const root = mkdtempSync(join(tmpdir(), 'skimpyclaw-worktrees-'));
+        roots.push(root);
+        const result = prepareCodeAgentWorktree({
+            id: 'ca-clean',
+            sourceWorkdir: repo,
+            config: { root },
+            required: true,
+        });
+        const cleanup = cleanupCodeAgentWorktree(result);
+        expect(cleanup.status).toBe('removed');
+        expect(existsSync(result.worktreePath)).toBe(false);
+    });
+    it('preserves dirty worktrees', () => {
+        const repo = makeRepo();
+        const root = mkdtempSync(join(tmpdir(), 'skimpyclaw-worktrees-'));
+        roots.push(root);
+        const result = prepareCodeAgentWorktree({
+            id: 'ca-dirty',
+            sourceWorkdir: repo,
+            config: { root },
+            required: true,
+        });
+        writeFileSync(join(result.worktreePath, 'dirty.txt'), 'dirty\n');
+        const cleanup = cleanupCodeAgentWorktree(result);
+        expect(cleanup.status).toBe('preserved');
+        expect(cleanup.reason).toContain('uncommitted changes');
+        expect(existsSync(result.worktreePath)).toBe(true);
+    });
+    it('preserves worktrees whose HEAD changed', () => {
+        const repo = makeRepo();
+        const root = mkdtempSync(join(tmpdir(), 'skimpyclaw-worktrees-'));
+        roots.push(root);
+        const result = prepareCodeAgentWorktree({
+            id: 'ca-head',
+            sourceWorkdir: repo,
+            config: { root },
+            required: true,
+        });
+        writeFileSync(join(result.worktreePath, 'README.md'), '# changed\n');
+        git(result.worktreePath, ['add', 'README.md']);
+        git(result.worktreePath, ['commit', '-m', 'change']);
+        const cleanup = cleanupCodeAgentWorktree(result);
+        expect(cleanup.status).toBe('preserved');
+        expect(cleanup.reason).toContain('HEAD changed');
+        expect(existsSync(result.worktreePath)).toBe(true);
+    });
+    it('skips non-git directories in optional mode and errors in required mode', () => {
+        const dir = mkdtempSync(join(tmpdir(), 'skimpyclaw-not-git-'));
+        roots.push(dir);
+        expect(prepareCodeAgentWorktree({ id: 'ca-1', sourceWorkdir: dir })).toBeUndefined();
+        expect(() => prepareCodeAgentWorktree({ id: 'ca-1', sourceWorkdir: dir, required: true }))
+            .toThrow(/not inside a git repository/);
+    });
+});

package/dist/__tests__/codex-adapter.test.js

@@ -0,0 +1,184 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { CodexAdapter } from '../providers/adapters/codex-adapter.js';
+const { mockCodexFetch, mockParseCodexSSE, mockRecordCodexUsage } = vi.hoisted(() => ({
+    mockCodexFetch: vi.fn(),
+    mockParseCodexSSE: vi.fn(),
+    mockRecordCodexUsage: vi.fn(),
+}));
+vi.mock('../providers/codex.js', () => ({
+    codexFetch: mockCodexFetch,
+    parseCodexSSE: mockParseCodexSSE,
+    recordCodexUsage: mockRecordCodexUsage,
+}));
+describe('CodexAdapter', () => {
+    let adapter;
+    let config;
+    let options;
+    beforeEach(() => {
+        adapter = new CodexAdapter();
+        config = {
+            gateway: { port: 18790, mode: 'local' },
+            agents: { default: 'main', list: {} },
+            models: { providers: {}, aliases: {} },
+            channels: { telegram: { enabled: false, token: 't', allowFrom: [] } },
+            cron: { jobs: [] },
+            heartbeat: { intervalMs: 300000, prompt: 'HEARTBEAT' },
+        };
+        options = { model: 'codex/gpt-5.5' };
+        mockCodexFetch.mockReset();
+        mockParseCodexSSE.mockReset();
+    });
+    it('builds Codex messages and extracts system instructions', () => {
+        const messages = [
+            { role: 'system', content: 'System prompt' },
+            { role: 'user', content: 'Hello' },
+            { role: 'assistant', content: 'Hi' },
+        ];
+        const result = adapter.buildMessages(messages, options, config);
+        expect(result.systemParam).toBe('System prompt');
+        expect(result.messages).toHaveLength(2);
+        expect(result.messages[0].type).toBe('message');
+        expect(result.messages[0].role).toBe('user');
+        expect(result.messages[1].role).toBe('assistant');
+    });
+    it('normalizes function calls when arguments are missing', async () => {
+        mockCodexFetch.mockResolvedValue('sse');
+        mockParseCodexSSE.mockReturnValue({
+            outputText: '',
+            functionCalls: [{ callId: 'fc_1', name: 'Read', arguments: undefined }],
+            response: { usage: { input_tokens: 10, output_tokens: 5 }, output: [] },
+        });
+        const providerMessages = {
+            messages: [{ type: 'message', role: 'user', content: [{ type: 'input_text', text: 'x' }] }],
+            systemParam: 'sys',
+        };
+        const result = await adapter.call(providerMessages, [], options, config);
+        expect(result.hasToolCalls).toBe(true);
+        expect(result.toolCalls).toHaveLength(1);
+        expect(result.toolCalls[0].id).toBe('fc_1');
+        expect(result.toolCalls[0].rawArgs).toBe('{}');
+        expect(result.toolCalls[0].args).toEqual({});
+    });
+    it('appends assistant output items and function_call_output results', () => {
+        const providerMessages = { messages: [] };
+        adapter.appendAssistantResponse(providerMessages, {
+            output: [
+                { type: 'function_call', call_id: 'fc_1', name: 'Read', arguments: '{}' },
+            ],
+        });
+        adapter.appendToolResult(providerMessages, 'fc_1', 'ok');
+        expect(providerMessages.messages).toHaveLength(2);
+        expect(providerMessages.messages[0].type).toBe('function_call');
+        expect(providerMessages.messages[1]).toEqual({
+            type: 'function_call_output',
+            call_id: 'fc_1',
+            output: 'ok',
+        });
+    });
+    it('enables MCP tool discovery for Codex', () => {
+        expect(adapter.getToolDefinitionOptions()).toEqual({ includeMcp: true });
+    });
+    it('passes xhigh thinking through as Codex reasoning effort', async () => {
+        mockCodexFetch.mockResolvedValue('sse');
+        mockParseCodexSSE.mockReturnValue({
+            outputText: 'ok',
+            functionCalls: [],
+            response: { usage: { input_tokens: 10, output_tokens: 5 } },
+        });
+        await adapter.chat([{ role: 'user', content: 'Use deeper reasoning' }], { ...options, thinking: 'xhigh' }, config);
+        expect(mockCodexFetch).toHaveBeenCalledWith(expect.objectContaining({
+            reasoning: { effort: 'xhigh', summary: 'auto' },
+        }));
+    });
+    it('keeps Codex reasoning at medium by default', async () => {
+        mockCodexFetch.mockResolvedValue('sse');
+        mockParseCodexSSE.mockReturnValue({
+            outputText: 'ok',
+            functionCalls: [],
+            response: { usage: { input_tokens: 10, output_tokens: 5 } },
+        });
+        await adapter.call({ messages: [], systemParam: 'sys' }, [], options, config);
+        expect(mockCodexFetch).toHaveBeenCalledWith(expect.objectContaining({
+            reasoning: { effort: 'medium', summary: 'auto' },
+        }));
+    });
+    describe('onEmptyFinalResponse', () => {
+        it('makes a finalization API call and returns text', async () => {
+            mockCodexFetch.mockResolvedValue('sse-finalize');
+            mockParseCodexSSE.mockReturnValue({
+                outputText: 'Here is the final answer.',
+                functionCalls: [],
+                response: { usage: { input_tokens: 50, output_tokens: 20 } },
+            });
+            const providerMessages = {
+                messages: [
+                    { type: 'message', role: 'user', content: [{ type: 'input_text', text: 'test' }] },
+                    { type: 'function_call_output', call_id: 'fc_1', output: 'result data' },
+                ],
+                systemParam: 'System prompt',
+            };
+            const result = await adapter.onEmptyFinalResponse(providerMessages, [], options, config);
+            expect(result).toBe('Here is the final answer.');
+            expect(mockCodexFetch).toHaveBeenCalledTimes(1);
+            // Should NOT include tools in the finalization body
+            const body = mockCodexFetch.mock.calls[0][0];
+            expect(body.tools).toBeUndefined();
+            // Should include the nudge message
+            const lastInput = body.input[body.input.length - 1];
+            expect(lastInput.role).toBe('user');
+            expect(lastInput.content[0].text).toContain('final answer');
+        });
+        it('returns undefined when finalization yields empty text', async () => {
+            mockCodexFetch.mockResolvedValue('sse-empty');
+            mockParseCodexSSE.mockReturnValue({
+                outputText: '',
+                functionCalls: [],
+                response: { usage: { input_tokens: 10, output_tokens: 0 } },
+            });
+            const providerMessages = {
+                messages: [],
+                systemParam: 'sys',
+            };
+            const result = await adapter.onEmptyFinalResponse(providerMessages, [], options, config);
+            expect(result).toBeUndefined();
+        });
+    });
+    describe('call – response normalization', () => {
+        it('returns textContent from outputText when no tool calls', async () => {
+            mockCodexFetch.mockResolvedValue('sse');
+            mockParseCodexSSE.mockReturnValue({
+                outputText: 'Just text',
+                functionCalls: [],
+                response: { usage: { input_tokens: 100, output_tokens: 50 } },
+            });
+            const providerMessages = {
+                messages: [{ type: 'message', role: 'user', content: [{ type: 'input_text', text: 'hi' }] }],
+                systemParam: 'sys',
+            };
+            const result = await adapter.call(providerMessages, [], options, config);
+            expect(result.hasToolCalls).toBe(false);
+            expect(result.textContent).toBe('Just text');
+            expect(result.toolCalls).toHaveLength(0);
+            expect(result.usage?.inputTokens).toBe(100);
+            expect(result.usage?.outputTokens).toBe(50);
+        });
+        it('parses multiple function calls correctly', async () => {
+            mockCodexFetch.mockResolvedValue('sse');
+            mockParseCodexSSE.mockReturnValue({
+                outputText: '',
+                functionCalls: [
+                    { callId: 'fc_1', name: 'Read', arguments: '{"path":"/a.ts"}' },
+                    { callId: 'fc_2', name: 'Bash', arguments: '{"command":"ls"}' },
+                ],
+                response: { usage: { input_tokens: 200, output_tokens: 100 } },
+            });
+            const providerMessages = { messages: [], systemParam: 'sys' };
+            const result = await adapter.call(providerMessages, [], options, config);
+            expect(result.hasToolCalls).toBe(true);
+            expect(result.toolCalls).toHaveLength(2);
+            expect(result.toolCalls[0].name).toBe('Read');
+            expect(result.toolCalls[0].args).toEqual({ path: '/a.ts' });
+            expect(result.toolCalls[1].name).toBe('Bash');
+        });
+    });
+});