factory-factory 0.3.4 → 0.3.6

package/dist/src/backend/domains/session/acp/codex-app-server-adapter/codex-app-server-acp-adapter.test.js

@@ -45,7 +45,7 @@ const DEFAULT_COLLABORATION_MODES = [
     { name: 'Default', mode: 'default' },
     { name: 'Plan', mode: 'plan' },
 ];
-async function initializeAdapterWithDefaultModel(adapter, codex) {
+async function initializeAdapterWithDefaultModel(adapter, codex, options) {
     codex.request.mockResolvedValueOnce({});
     codex.request.mockResolvedValueOnce({
         requirements: {
@@ -54,7 +54,7 @@ async function initializeAdapterWithDefaultModel(adapter, codex) {
         },
     });
     codex.request.mockResolvedValueOnce({
-        data: DEFAULT_COLLABORATION_MODES,
+        data: options?.collaborationModes ?? DEFAULT_COLLABORATION_MODES,
         nextCursor: null,
     });
     codex.request.mockResolvedValueOnce({
@@ -327,6 +327,11 @@ describe('CodexAppServerAcpAdapter', () => {
                                 id: 'item_c1',
                                 command: 'pwd',
                             },
+                            {
+                                type: 'reasoning',
+                                id: 'item_r1',
+                                summary: [{ type: 'summary_text', text: '**Thinking through replay**' }],
+                            },
                         ],
                     },
                 ],
@@ -340,9 +345,506 @@ describe('CodexAppServerAcpAdapter', () => {
         const updates = connection.sessionUpdate.mock.calls.map((call) => call[0].update);
         expect(updates.some((update) => update.sessionUpdate === 'user_message_chunk')).toBe(true);
         expect(updates.some((update) => update.sessionUpdate === 'agent_message_chunk')).toBe(true);
+        expect(updates.some((update) => update.sessionUpdate === 'agent_thought_chunk' &&
+            update.content?.type === 'text' &&
+            update.content.text === '**Thinking through replay**')).toBe(true);
         expect(updates.some((update) => update.sessionUpdate === 'tool_call' &&
             update.status === 'completed' &&
-            update.toolCallId === 'codex:thread_abc:turn_1:item_c1')).toBe(true);
+            update.toolCallId === 'item_c1')).toBe(true);
+    });
+    it('does not duplicate replayed tool and reasoning updates when matching live events arrive', async () => {
+        const { connection } = createMockConnection();
+        const { client: codexClient, mocks: codex } = createMockCodexClient();
+        const adapter = new CodexAppServerAcpAdapter(connection, codexClient);
+        await initializeAdapterWithDefaultModel(adapter, codex);
+        codex.request.mockResolvedValueOnce({
+            thread: { id: 'thread_replay_dedupe', cwd: '/tmp/workspace' },
+            approvalPolicy: DEFAULT_APPROVAL_POLICY,
+            reasoningEffort: 'medium',
+        });
+        codex.request.mockResolvedValueOnce({
+            thread: {
+                id: 'thread_replay_dedupe',
+                turns: [
+                    {
+                        id: 'turn_replay_dedupe',
+                        items: [
+                            {
+                                type: 'commandExecution',
+                                id: 'item_replayed_command',
+                                command: 'cat README.md',
+                            },
+                            {
+                                type: 'reasoning',
+                                id: 'item_replayed_reasoning',
+                                summary: [{ type: 'summary_text', text: '**From replay**' }],
+                            },
+                        ],
+                    },
+                ],
+            },
+        });
+        await adapter.loadSession({
+            sessionId: 'sess_thread_replay_dedupe',
+            cwd: '/tmp/workspace',
+            mcpServers: [],
+        });
+        connection.sessionUpdate.mockClear();
+        await adapter.handleCodexNotification('item/started', {
+            threadId: 'thread_replay_dedupe',
+            turnId: 'turn_replay_dedupe',
+            item: {
+                type: 'commandExecution',
+                id: 'item_replayed_command',
+                status: 'inProgress',
+                command: 'cat README.md',
+            },
+        });
+        await adapter.handleCodexNotification('item/completed', {
+            threadId: 'thread_replay_dedupe',
+            turnId: 'turn_replay_dedupe',
+            item: {
+                type: 'commandExecution',
+                id: 'item_replayed_command',
+                status: 'completed',
+                command: 'cat README.md',
+            },
+        });
+        await adapter.handleCodexNotification('item/reasoning/summaryTextDelta', {
+            threadId: 'thread_replay_dedupe',
+            turnId: 'turn_replay_dedupe',
+            itemId: 'item_replayed_reasoning',
+            delta: '**From live**',
+        });
+        await adapter.handleCodexNotification('item/completed', {
+            threadId: 'thread_replay_dedupe',
+            turnId: 'turn_replay_dedupe',
+            item: {
+                type: 'reasoning',
+                id: 'item_replayed_reasoning',
+                status: 'completed',
+                summary: [{ type: 'summary_text', text: '**From live**' }],
+            },
+        });
+        expect(connection.sessionUpdate).not.toHaveBeenCalled();
+    });
+    it('prefers codex callId for tool call ids and enriches command metadata', async () => {
+        const { connection } = createMockConnection();
+        const { client: codexClient, mocks: codex } = createMockCodexClient();
+        const adapter = new CodexAppServerAcpAdapter(connection, codexClient);
+        await initializeAdapterWithDefaultModel(adapter, codex);
+        codex.request.mockResolvedValueOnce({
+            thread: { id: 'thread_call_id', cwd: '/tmp/workspace' },
+            approvalPolicy: DEFAULT_APPROVAL_POLICY,
+            reasoningEffort: 'medium',
+        });
+        await adapter.newSession({
+            cwd: '/tmp/workspace',
+            mcpServers: [],
+        });
+        await adapter.handleCodexNotification('item/started', {
+            threadId: 'thread_call_id',
+            turnId: 'turn_call_id',
+            item: {
+                type: 'commandExecution',
+                id: 'item_call_id',
+                callId: 'call_123',
+                status: 'inProgress',
+                command: 'cat README.md',
+            },
+        });
+        await adapter.handleCodexNotification('item/completed', {
+            threadId: 'thread_call_id',
+            turnId: 'turn_call_id',
+            item: {
+                type: 'commandExecution',
+                id: 'item_call_id',
+                callId: 'call_123',
+                status: 'completed',
+                command: 'cat README.md',
+            },
+        });
+        expect(connection.sessionUpdate.mock.calls).toEqual(expect.arrayContaining([
+            [
+                expect.objectContaining({
+                    update: expect.objectContaining({
+                        sessionUpdate: 'tool_call',
+                        toolCallId: 'call_123',
+                        title: 'Read README.md',
+                        kind: 'read',
+                        locations: [{ path: '/tmp/workspace/README.md' }],
+                    }),
+                }),
+            ],
+            [
+                expect.objectContaining({
+                    update: expect.objectContaining({
+                        sessionUpdate: 'tool_call_update',
+                        toolCallId: 'call_123',
+                        title: 'Read README.md',
+                        kind: 'read',
+                    }),
+                }),
+            ],
+        ]));
+    });
+    it('synthesizes completion when command output hands off to a session id', async () => {
+        const { connection } = createMockConnection();
+        const { client: codexClient, mocks: codex } = createMockCodexClient();
+        const adapter = new CodexAppServerAcpAdapter(connection, codexClient);
+        await initializeAdapterWithDefaultModel(adapter, codex);
+        codex.request.mockResolvedValueOnce({
+            thread: { id: 'thread_command_handoff', cwd: '/tmp/workspace' },
+            approvalPolicy: DEFAULT_APPROVAL_POLICY,
+            reasoningEffort: 'medium',
+        });
+        await adapter.newSession({
+            cwd: '/tmp/workspace',
+            mcpServers: [],
+        });
+        await adapter.handleCodexNotification('item/started', {
+            threadId: 'thread_command_handoff',
+            turnId: 'turn_command_handoff',
+            item: {
+                type: 'commandExecution',
+                id: 'item_command_handoff',
+                callId: 'call_command_handoff',
+                status: 'inProgress',
+                command: 'git commit -m "test"',
+            },
+        });
+        await adapter.handleCodexNotification('item/commandExecution/outputDelta', {
+            threadId: 'thread_command_handoff',
+            turnId: 'turn_command_handoff',
+            itemId: 'item_command_handoff',
+            delta: 'Process running with session ID 96081',
+        });
+        await adapter.handleCodexNotification('item/commandExecution/outputDelta', {
+            threadId: 'thread_command_handoff',
+            turnId: 'turn_command_handoff',
+            itemId: 'item_command_handoff',
+            delta: 'still running',
+        });
+        const updates = connection.sessionUpdate.mock.calls.map((call) => call[0].update);
+        const inProgressUpdates = updates.filter((update) => update.sessionUpdate === 'tool_call_update' &&
+            update.toolCallId === 'call_command_handoff' &&
+            update.status === 'in_progress');
+        expect(inProgressUpdates).toHaveLength(1);
+        expect(updates).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                sessionUpdate: 'tool_call_update',
+                toolCallId: 'call_command_handoff',
+                status: 'completed',
+                rawOutput: 'Process running with session ID 96081',
+            }),
+        ]));
+    });
+    it('does not synthesize completion for normal output that mentions session handoff text', async () => {
+        const { connection } = createMockConnection();
+        const { client: codexClient, mocks: codex } = createMockCodexClient();
+        const adapter = new CodexAppServerAcpAdapter(connection, codexClient);
+        await initializeAdapterWithDefaultModel(adapter, codex);
+        codex.request.mockResolvedValueOnce({
+            thread: { id: 'thread_command_log_output', cwd: '/tmp/workspace' },
+            approvalPolicy: DEFAULT_APPROVAL_POLICY,
+            reasoningEffort: 'medium',
+        });
+        await adapter.newSession({
+            cwd: '/tmp/workspace',
+            mcpServers: [],
+        });
+        await adapter.handleCodexNotification('item/started', {
+            threadId: 'thread_command_log_output',
+            turnId: 'turn_command_log_output',
+            item: {
+                type: 'commandExecution',
+                id: 'item_command_log_output',
+                callId: 'call_command_log_output',
+                status: 'inProgress',
+                command: 'bash script.sh',
+            },
+        });
+        await adapter.handleCodexNotification('item/commandExecution/outputDelta', {
+            threadId: 'thread_command_log_output',
+            turnId: 'turn_command_log_output',
+            itemId: 'item_command_log_output',
+            delta: 'worker log: process running with session ID 96081 and waiting',
+        });
+        await adapter.handleCodexNotification('item/commandExecution/outputDelta', {
+            threadId: 'thread_command_log_output',
+            turnId: 'turn_command_log_output',
+            itemId: 'item_command_log_output',
+            delta: 'still running',
+        });
+        const updates = connection.sessionUpdate.mock.calls.map((call) => call[0].update);
+        const completedUpdates = updates.filter((update) => update.sessionUpdate === 'tool_call_update' &&
+            update.toolCallId === 'call_command_log_output' &&
+            update.status === 'completed');
+        expect(completedUpdates).toHaveLength(0);
+        expect(updates).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                sessionUpdate: 'tool_call_update',
+                toolCallId: 'call_command_log_output',
+                status: 'in_progress',
+                rawOutput: 'worker log: process running with session ID 96081 and waiting',
+            }),
+            expect.objectContaining({
+                sessionUpdate: 'tool_call_update',
+                toolCallId: 'call_command_log_output',
+                status: 'in_progress',
+                rawOutput: 'still running',
+            }),
+        ]));
+    });
+    it('parses escaped quotes in quoted command arguments for metadata', async () => {
+        const { connection } = createMockConnection();
+        const { client: codexClient, mocks: codex } = createMockCodexClient();
+        const adapter = new CodexAppServerAcpAdapter(connection, codexClient);
+        await initializeAdapterWithDefaultModel(adapter, codex);
+        codex.request.mockResolvedValueOnce({
+            thread: { id: 'thread_escaped_quotes', cwd: '/tmp/workspace' },
+            approvalPolicy: DEFAULT_APPROVAL_POLICY,
+            reasoningEffort: 'medium',
+        });
+        await adapter.newSession({
+            cwd: '/tmp/workspace',
+            mcpServers: [],
+        });
+        await adapter.handleCodexNotification('item/started', {
+            threadId: 'thread_escaped_quotes',
+            turnId: 'turn_escaped_quotes',
+            item: {
+                type: 'commandExecution',
+                id: 'item_escaped_quotes',
+                status: 'inProgress',
+                command: 'cat "nested \\"quotes\\".md"',
+            },
+        });
+        await adapter.handleCodexNotification('item/completed', {
+            threadId: 'thread_escaped_quotes',
+            turnId: 'turn_escaped_quotes',
+            item: {
+                type: 'commandExecution',
+                id: 'item_escaped_quotes',
+                status: 'completed',
+                command: 'cat "nested \\"quotes\\".md"',
+            },
+        });
+        expect(connection.sessionUpdate.mock.calls).toEqual(expect.arrayContaining([
+            [
+                expect.objectContaining({
+                    update: expect.objectContaining({
+                        sessionUpdate: 'tool_call',
+                        title: 'Read nested "quotes".md',
+                        kind: 'read',
+                        locations: [{ path: '/tmp/workspace/nested "quotes".md' }],
+                    }),
+                }),
+            ],
+            [
+                expect.objectContaining({
+                    update: expect.objectContaining({
+                        sessionUpdate: 'tool_call_update',
+                        title: 'Read nested "quotes".md',
+                        kind: 'read',
+                        locations: [{ path: '/tmp/workspace/nested "quotes".md' }],
+                    }),
+                }),
+            ],
+        ]));
+    });
+    it('parses escaped single quotes and escaped spaces in command metadata', async () => {
+        const { connection } = createMockConnection();
+        const { client: codexClient, mocks: codex } = createMockCodexClient();
+        const adapter = new CodexAppServerAcpAdapter(connection, codexClient);
+        await initializeAdapterWithDefaultModel(adapter, codex);
+        codex.request.mockResolvedValueOnce({
+            thread: { id: 'thread_escaped_single_quotes', cwd: '/tmp/workspace' },
+            approvalPolicy: DEFAULT_APPROVAL_POLICY,
+            reasoningEffort: 'medium',
+        });
+        await adapter.newSession({
+            cwd: '/tmp/workspace',
+            mcpServers: [],
+        });
+        await adapter.handleCodexNotification('item/started', {
+            threadId: 'thread_escaped_single_quotes',
+            turnId: 'turn_escaped_single_quotes',
+            item: {
+                type: 'commandExecution',
+                id: 'item_escaped_single_quotes',
+                status: 'inProgress',
+                command: "cat 'it\\'s file.txt'",
+            },
+        });
+        await adapter.handleCodexNotification('item/completed', {
+            threadId: 'thread_escaped_single_quotes',
+            turnId: 'turn_escaped_single_quotes',
+            item: {
+                type: 'commandExecution',
+                id: 'item_escaped_single_quotes',
+                status: 'completed',
+                command: "cat 'it\\'s file.txt'",
+            },
+        });
+        expect(connection.sessionUpdate.mock.calls).toEqual(expect.arrayContaining([
+            [
+                expect.objectContaining({
+                    update: expect.objectContaining({
+                        sessionUpdate: 'tool_call',
+                        title: "Read it's file.txt",
+                        kind: 'read',
+                        locations: [{ path: "/tmp/workspace/it's file.txt" }],
+                    }),
+                }),
+            ],
+            [
+                expect.objectContaining({
+                    update: expect.objectContaining({
+                        sessionUpdate: 'tool_call_update',
+                        title: "Read it's file.txt",
+                        kind: 'read',
+                        locations: [{ path: "/tmp/workspace/it's file.txt" }],
+                    }),
+                }),
+            ],
+        ]));
+    });
+    it('derives command metadata from actionable chained subcommands', async () => {
+        const { connection } = createMockConnection();
+        const { client: codexClient, mocks: codex } = createMockCodexClient();
+        const adapter = new CodexAppServerAcpAdapter(connection, codexClient);
+        await initializeAdapterWithDefaultModel(adapter, codex);
+        codex.request.mockResolvedValueOnce({
+            thread: { id: 'thread_chained_command', cwd: '/tmp/workspace' },
+            approvalPolicy: DEFAULT_APPROVAL_POLICY,
+            reasoningEffort: 'medium',
+        });
+        await adapter.newSession({
+            cwd: '/tmp/workspace',
+            mcpServers: [],
+        });
+        await adapter.handleCodexNotification('item/started', {
+            threadId: 'thread_chained_command',
+            turnId: 'turn_chained_command',
+            item: {
+                type: 'commandExecution',
+                id: 'item_chained_command',
+                status: 'inProgress',
+                command: 'cd src && rg "TODO" README.md',
+            },
+        });
+        expect(connection.sessionUpdate.mock.calls).toEqual(expect.arrayContaining([
+            [
+                expect.objectContaining({
+                    update: expect.objectContaining({
+                        sessionUpdate: 'tool_call',
+                        title: 'Search TODO in README.md',
+                        kind: 'search',
+                        locations: [{ path: '/tmp/workspace/README.md' }],
+                    }),
+                }),
+            ],
+        ]));
+    });
+    it('keeps escaped apostrophes inside single quotes when splitting chained commands', async () => {
+        const { connection } = createMockConnection();
+        const { client: codexClient, mocks: codex } = createMockCodexClient();
+        const adapter = new CodexAppServerAcpAdapter(connection, codexClient);
+        await initializeAdapterWithDefaultModel(adapter, codex);
+        codex.request.mockResolvedValueOnce({
+            thread: { id: 'thread_chain_single_quote_escape', cwd: '/tmp/workspace' },
+            approvalPolicy: DEFAULT_APPROVAL_POLICY,
+            reasoningEffort: 'medium',
+        });
+        await adapter.newSession({
+            cwd: '/tmp/workspace',
+            mcpServers: [],
+        });
+        await adapter.handleCodexNotification('item/started', {
+            threadId: 'thread_chain_single_quote_escape',
+            turnId: 'turn_chain_single_quote_escape',
+            item: {
+                type: 'commandExecution',
+                id: 'item_chain_single_quote_escape',
+                status: 'inProgress',
+                command: "cat 'it\\'s file.txt' && rg TODO README.md",
+            },
+        });
+        expect(connection.sessionUpdate.mock.calls).toEqual(expect.arrayContaining([
+            [
+                expect.objectContaining({
+                    update: expect.objectContaining({
+                        sessionUpdate: 'tool_call',
+                        title: "Read it's file.txt, Search TODO in README.md",
+                        kind: 'read',
+                        locations: [
+                            { path: "/tmp/workspace/it's file.txt" },
+                            { path: '/tmp/workspace/README.md' },
+                        ],
+                    }),
+                }),
+            ],
+        ]));
+    });
+    it('avoids duplicate thought chunks when reasoning started item already contains summary text', async () => {
+        const { connection } = createMockConnection();
+        const { client: codexClient, mocks: codex } = createMockCodexClient();
+        const adapter = new CodexAppServerAcpAdapter(connection, codexClient);
+        await initializeAdapterWithDefaultModel(adapter, codex);
+        codex.request.mockResolvedValueOnce({
+            thread: { id: 'thread_reasoning', cwd: '/tmp/workspace' },
+            approvalPolicy: DEFAULT_APPROVAL_POLICY,
+            reasoningEffort: 'medium',
+        });
+        await adapter.newSession({
+            cwd: '/tmp/workspace',
+            mcpServers: [],
+        });
+        await adapter.handleCodexNotification('item/started', {
+            threadId: 'thread_reasoning',
+            turnId: 'turn_reasoning',
+            item: {
+                type: 'reasoning',
+                id: 'item_reasoning',
+                status: 'inProgress',
+                summary: [{ type: 'summary_text', text: '**Analyzing approach**' }],
+            },
+        });
+        await adapter.handleCodexNotification('item/reasoning/summaryTextDelta', {
+            threadId: 'thread_reasoning',
+            turnId: 'turn_reasoning',
+            itemId: 'item_reasoning',
+            delta: '**Analyzing approach**',
+        });
+        await adapter.handleCodexNotification('item/completed', {
+            threadId: 'thread_reasoning',
+            turnId: 'turn_reasoning',
+            item: {
+                type: 'reasoning',
+                id: 'item_reasoning',
+                status: 'completed',
+                summary: [{ type: 'summary_text', text: '**Analyzing approach**' }],
+            },
+        });
+        const updates = connection.sessionUpdate.mock.calls.map((call) => call[0].update);
+        const thoughtChunks = updates.filter((update) => update.sessionUpdate === 'agent_thought_chunk');
+        expect(thoughtChunks).toEqual([
+            {
+                sessionUpdate: 'agent_thought_chunk',
+                content: { type: 'text', text: '**Analyzing approach**' },
+            },
+        ]);
+        expect(updates.some((update) => update.sessionUpdate === 'tool_call' &&
+            update.toolCallId === 'item_reasoning' &&
+            update.kind === 'think' &&
+            update.status === 'pending')).toBe(true);
+        expect(updates.some((update) => update.sessionUpdate === 'tool_call_update' &&
+            update.toolCallId === 'item_reasoning' &&
+            update.status === 'in_progress')).toBe(true);
+        expect(updates.some((update) => update.sessionUpdate === 'tool_call_update' &&
+            update.toolCallId === 'item_reasoning' &&
+            update.status === 'completed')).toBe(true);
     });
     it('writes provided MCP servers to Codex config and reloads on loadSession', async () => {
         const { connection } = createMockConnection();
@@ -567,7 +1069,7 @@ describe('CodexAppServerAcpAdapter', () => {
     it('requests ExitPlanMode approval after completed plan item in plan mode', async () => {
         const { connection } = createMockConnection();
         connection.requestPermission.mockResolvedValue({
-            outcome: { outcome: 'selected', optionId: 'allow_once' },
+            outcome: { outcome: 'selected', optionId: 'default' },
         });
         const { client: codexClient, mocks: codex } = createMockCodexClient();
         const adapter = new CodexAppServerAcpAdapter(connection, codexClient);
@@ -612,8 +1114,8 @@ describe('CodexAppServerAcpAdapter', () => {
                 kind: 'switch_mode',
             }),
             options: [
-                { optionId: 'allow_once', name: 'Approve plan', kind: 'allow_once' },
-                { optionId: 'reject_once', name: 'Request changes', kind: 'reject_once' },
+                { optionId: 'default', name: 'Approve and switch to Default', kind: 'allow_once' },
+                { optionId: 'plan', name: 'Keep planning', kind: 'reject_once' },
             ],
         }));
         expect(connection.sessionUpdate.mock.calls).toEqual(expect.arrayContaining([
@@ -659,6 +1161,77 @@ describe('CodexAppServerAcpAdapter', () => {
             ],
         ]));
     });
+    it('switches to the selected non-plan mode id when plan approval is accepted', async () => {
+        const { connection } = createMockConnection();
+        connection.requestPermission.mockResolvedValue({
+            outcome: { outcome: 'selected', optionId: 'code' },
+        });
+        const { client: codexClient, mocks: codex } = createMockCodexClient();
+        const adapter = new CodexAppServerAcpAdapter(connection, codexClient);
+        await initializeAdapterWithDefaultModel(adapter, codex, {
+            collaborationModes: [
+                { name: 'Default', mode: 'default' },
+                { name: 'Code', mode: 'code' },
+                { name: 'Plan', mode: 'plan' },
+            ],
+        });
+        codex.request.mockResolvedValueOnce({
+            thread: { id: 'thread_plan_mode_switch', cwd: '/tmp/workspace' },
+            approvalPolicy: DEFAULT_APPROVAL_POLICY,
+            reasoningEffort: 'medium',
+        });
+        const session = await adapter.newSession({
+            cwd: '/tmp/workspace',
+            mcpServers: [],
+        });
+        await adapter.setSessionMode({ sessionId: session.sessionId, modeId: 'plan' });
+        await adapter.handleCodexNotification('item/started', {
+            threadId: 'thread_plan_mode_switch',
+            turnId: 'turn_plan_mode_switch',
+            item: {
+                type: 'plan',
+                id: 'item_plan_mode_switch',
+                status: 'inProgress',
+            },
+        });
+        await adapter.handleCodexNotification('item/plan/delta', {
+            threadId: 'thread_plan_mode_switch',
+            turnId: 'turn_plan_mode_switch',
+            itemId: 'item_plan_mode_switch',
+            delta: '# Plan\n- implement this',
+        });
+        await adapter.handleCodexNotification('item/completed', {
+            threadId: 'thread_plan_mode_switch',
+            turnId: 'turn_plan_mode_switch',
+            item: {
+                type: 'plan',
+                id: 'item_plan_mode_switch',
+                status: 'completed',
+            },
+        });
+        expect(connection.requestPermission).toHaveBeenCalledWith(expect.objectContaining({
+            options: expect.arrayContaining([
+                expect.objectContaining({ optionId: 'default', kind: 'allow_once' }),
+                expect.objectContaining({ optionId: 'code', kind: 'allow_once' }),
+                expect.objectContaining({ optionId: 'plan', kind: 'reject_once' }),
+            ]),
+        }));
+        expect(connection.sessionUpdate.mock.calls).toEqual(expect.arrayContaining([
+            [
+                expect.objectContaining({
+                    update: expect.objectContaining({
+                        sessionUpdate: 'config_option_update',
+                        configOptions: expect.arrayContaining([
+                            expect.objectContaining({
+                                id: 'mode',
+                                currentValue: 'code',
+                            }),
+                        ]),
+                    }),
+                }),
+            ],
+        ]));
+    });
     it('holds prompt completion until plan approval resolves and exits plan mode', async () => {
         let resolvePlanApproval = () => {
             throw new Error('expected plan approval request callback');
@@ -727,7 +1300,7 @@ describe('CodexAppServerAcpAdapter', () => {
         await new Promise((resolve) => setTimeout(resolve, 0));
         expect(promptSettled).toBe(false);
         resolvePlanApproval({
-            outcome: { outcome: 'selected', optionId: 'allow_once' },
+            outcome: { outcome: 'selected', optionId: 'default' },
         });
         await itemCompletedPromise;
         await expect(promptPromise).resolves.toEqual({ stopReason: 'end_turn' });
@@ -751,7 +1324,7 @@ describe('CodexAppServerAcpAdapter', () => {
     it('marks synthetic ExitPlanMode approval as failed when user rejects', async () => {
         const { connection } = createMockConnection();
         connection.requestPermission.mockResolvedValue({
-            outcome: { outcome: 'selected', optionId: 'reject_once' },
+            outcome: { outcome: 'selected', optionId: 'plan' },
         });
         const { client: codexClient, mocks: codex } = createMockCodexClient();
         const adapter = new CodexAppServerAcpAdapter(connection, codexClient);
@@ -1287,6 +1860,14 @@ describe('CodexAppServerAcpAdapter', () => {
             },
         });
         expect(codex.respondSuccess).toHaveBeenCalledWith(18, { decision: 'decline' });
+        const sessionUpdateMock = connection.sessionUpdate;
+        const pendingPermissionUpdateIndex = sessionUpdateMock.mock.calls.findIndex((call) => call[0].update?.sessionUpdate === 'tool_call_update' && call[0].update?.status === 'pending');
+        expect(pendingPermissionUpdateIndex).toBeGreaterThanOrEqual(0);
+        const pendingPermissionInvocationOrder = sessionUpdateMock.mock.invocationCallOrder[pendingPermissionUpdateIndex];
+        const requestPermissionInvocationOrder = connection.requestPermission.mock.invocationCallOrder[0];
+        expect(pendingPermissionInvocationOrder).toBeDefined();
+        expect(requestPermissionInvocationOrder).toBeDefined();
+        expect(pendingPermissionInvocationOrder < requestPermissionInvocationOrder).toBe(true);
         expect(connection.sessionUpdate.mock.calls).toEqual(expect.arrayContaining([
             [
                 expect.objectContaining({
@@ -1298,6 +1879,152 @@ describe('CodexAppServerAcpAdapter', () => {
             ],
         ]));
     });
+    it('scopes allow_always command approvals by command pattern and cwd', async () => {
+        const { connection } = createMockConnection();
+        connection.requestPermission.mockResolvedValueOnce({
+            outcome: { outcome: 'selected', optionId: 'allow_always' },
+        });
+        const { client: codexClient, mocks: codex } = createMockCodexClient();
+        const adapter = new CodexAppServerAcpAdapter(connection, codexClient);
+        await initializeAdapterWithDefaultModel(adapter, codex);
+        codex.request.mockResolvedValueOnce({
+            thread: { id: 'thread_allow_always', cwd: '/tmp/workspace' },
+            approvalPolicy: DEFAULT_APPROVAL_POLICY,
+            reasoningEffort: 'medium',
+        });
+        await adapter.newSession({
+            cwd: '/tmp/workspace',
+            mcpServers: [],
+        });
+        await adapter.handleCodexServerRequest({
+            id: 91,
+            method: 'item/commandExecution/requestApproval',
+            params: {
+                threadId: 'thread_allow_always',
+                turnId: 'turn_allow_always',
+                itemId: 'item_allow_always',
+                command: 'cat README.md',
+                cwd: '/tmp/workspace',
+            },
+        });
+        expect(connection.requestPermission).toHaveBeenCalledWith(expect.objectContaining({
+            toolCall: expect.objectContaining({
+                title: 'Read README.md',
+                kind: 'read',
+            }),
+            options: expect.arrayContaining([
+                expect.objectContaining({ optionId: 'allow_always', kind: 'allow_always' }),
+                expect.objectContaining({ optionId: 'allow_once', kind: 'allow_once' }),
+                expect.objectContaining({ optionId: 'reject_once', kind: 'reject_once' }),
+            ]),
+        }));
+        expect(codex.respondSuccess).toHaveBeenCalledWith(91, { decision: 'accept' });
+        connection.requestPermission.mockClear();
+        codex.respondSuccess.mockClear();
+        await adapter.handleCodexServerRequest({
+            id: 92,
+            method: 'item/commandExecution/requestApproval',
+            params: {
+                threadId: 'thread_allow_always',
+                turnId: 'turn_allow_always',
+                itemId: 'item_allow_always_2',
+                command: 'cat README.md',
+                cwd: '/tmp/workspace',
+            },
+        });
+        expect(connection.requestPermission).not.toHaveBeenCalled();
+        expect(codex.respondSuccess).toHaveBeenCalledWith(92, { decision: 'accept' });
+        codex.respondSuccess.mockClear();
+        await adapter.handleCodexServerRequest({
+            id: 93,
+            method: 'item/commandExecution/requestApproval',
+            params: {
+                threadId: 'thread_allow_always',
+                turnId: 'turn_allow_always',
+                itemId: 'item_allow_always_3',
+                command: 'ls src',
+                cwd: '/tmp/workspace',
+            },
+        });
+        expect(connection.requestPermission).toHaveBeenCalledTimes(1);
+        expect(codex.respondSuccess).toHaveBeenCalledWith(93, { decision: 'accept' });
+        connection.requestPermission.mockClear();
+        codex.respondSuccess.mockClear();
+        await adapter.handleCodexServerRequest({
+            id: 94,
+            method: 'item/commandExecution/requestApproval',
+            params: {
+                threadId: 'thread_allow_always',
+                turnId: 'turn_allow_always',
+                itemId: 'item_allow_always_4',
+                command: 'cat README.md',
+                cwd: '/tmp/other-workspace',
+            },
+        });
+        expect(connection.requestPermission).toHaveBeenCalledTimes(1);
+        expect(codex.respondSuccess).toHaveBeenCalledWith(94, { decision: 'accept' });
+    });
+    it('does not reuse allow_always scope when a chained command changes cwd', async () => {
+        const { connection } = createMockConnection();
+        connection.requestPermission.mockResolvedValueOnce({
+            outcome: { outcome: 'selected', optionId: 'allow_always' },
+        });
+        const { client: codexClient, mocks: codex } = createMockCodexClient();
+        const adapter = new CodexAppServerAcpAdapter(connection, codexClient);
+        await initializeAdapterWithDefaultModel(adapter, codex);
+        codex.request.mockResolvedValueOnce({
+            thread: { id: 'thread_allow_always_cd_scope', cwd: '/tmp/workspace' },
+            approvalPolicy: DEFAULT_APPROVAL_POLICY,
+            reasoningEffort: 'medium',
+        });
+        await adapter.newSession({
+            cwd: '/tmp/workspace',
+            mcpServers: [],
+        });
+        await adapter.handleCodexServerRequest({
+            id: 101,
+            method: 'item/commandExecution/requestApproval',
+            params: {
+                threadId: 'thread_allow_always_cd_scope',
+                turnId: 'turn_allow_always_cd_scope',
+                itemId: 'item_allow_always_cd_scope_1',
+                command: 'cd nested && cat README.md',
+                cwd: '/tmp/workspace',
+            },
+        });
+        expect(connection.requestPermission).toHaveBeenCalledTimes(1);
+        expect(codex.respondSuccess).toHaveBeenCalledWith(101, { decision: 'accept' });
+        connection.requestPermission.mockClear();
+        codex.respondSuccess.mockClear();
+        await adapter.handleCodexServerRequest({
+            id: 102,
+            method: 'item/commandExecution/requestApproval',
+            params: {
+                threadId: 'thread_allow_always_cd_scope',
+                turnId: 'turn_allow_always_cd_scope',
+                itemId: 'item_allow_always_cd_scope_2',
+                command: 'cat README.md',
+                cwd: '/tmp/workspace',
+            },
+        });
+        expect(connection.requestPermission).toHaveBeenCalledTimes(1);
+        expect(codex.respondSuccess).toHaveBeenCalledWith(102, { decision: 'accept' });
+        connection.requestPermission.mockClear();
+        codex.respondSuccess.mockClear();
+        await adapter.handleCodexServerRequest({
+            id: 103,
+            method: 'item/commandExecution/requestApproval',
+            params: {
+                threadId: 'thread_allow_always_cd_scope',
+                turnId: 'turn_allow_always_cd_scope',
+                itemId: 'item_allow_always_cd_scope_3',
+                command: 'cd nested && cat README.md',
+                cwd: '/tmp/workspace',
+            },
+        });
+        expect(connection.requestPermission).not.toHaveBeenCalled();
+        expect(codex.respondSuccess).toHaveBeenCalledWith(103, { decision: 'accept' });
+    });
     it('reconciles turn/completed notifications that arrive before prompt attaches active turn', async () => {
         const { connection } = createMockConnection();
         const { client: codexClient, mocks: codex } = createMockCodexClient();