factory-factory 0.3.20 → 0.4.0

package/dist/src/backend/services/session/service/chat/chat-message-handlers/handlers/load-session.handler.test.js

@@ -1,4 +1,7 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 const mocks = vi.hoisted(() => ({
     findById: vi.fn(),
     loadClaudeSessionHistory: vi.fn(),
@@ -10,6 +13,7 @@ const mocks = vi.hoisted(() => ({
     emitDelta: vi.fn(),
     getTranscriptSnapshot: vi.fn(),
     isHistoryHydrated: vi.fn(),
+    getHistoryHydrationSource: vi.fn(),
     canAttemptHistoryHydration: vi.fn(),
     setHistoryRetryAt: vi.fn(),
     clearHistoryRetryCooldown: vi.fn(),
@@ -48,6 +52,7 @@ vi.mock('@/backend/services/session/service/session-domain.service', () => ({
         emitDelta: mocks.emitDelta,
         getTranscriptSnapshot: mocks.getTranscriptSnapshot,
         isHistoryHydrated: mocks.isHistoryHydrated,
+        getHistoryHydrationSource: mocks.getHistoryHydrationSource,
         canAttemptHistoryHydration: mocks.canAttemptHistoryHydration,
         setHistoryRetryAt: mocks.setHistoryRetryAt,
         clearHistoryRetryCooldown: mocks.clearHistoryRetryCooldown,
@@ -72,6 +77,7 @@ vi.mock('@/backend/services/logger.service', () => ({
 }));
 import { createLoadSessionHandler } from './load-session.handler.js';
 describe('createLoadSessionHandler', () => {
+    const tempDirs = [];
     beforeEach(() => {
         const historyRetryAtBySession = new Map();
         const pruneExpiredHistoryRetryEntries = (now) => {
@@ -137,11 +143,17 @@ describe('createLoadSessionHandler', () => {
         mocks.getSessionConfigOptionsWithFallback.mockResolvedValue([]);
         mocks.getTranscriptSnapshot.mockReturnValue([]);
         mocks.isHistoryHydrated.mockReturnValue(true);
+        mocks.getHistoryHydrationSource.mockReturnValue(undefined);
         mocks.consumeInitialMessage.mockReturnValue(null);
         mocks.enqueue.mockReturnValue({ position: 0 });
         mocks.loadClaudeSessionHistory.mockResolvedValue({ status: 'not_found' });
         mocks.loadCodexSessionHistory.mockResolvedValue({ status: 'not_found' });
     });
+    afterEach(() => {
+        for (const dir of tempDirs.splice(0)) {
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
     it('hydrates Claude transcript from JSONL history', async () => {
         mocks.findById.mockResolvedValue({
             provider: 'CLAUDE',
@@ -448,6 +460,160 @@ describe('createLoadSessionHandler', () => {
         expect(mocks.loadCodexSessionHistory).not.toHaveBeenCalled();
         expect(mocks.markHistoryHydrated).not.toHaveBeenCalled();
     });
+    it('hydrates CODEX transcript using metadata providerSessionId when column is null', async () => {
+        mocks.findById.mockResolvedValue({
+            provider: 'CODEX',
+            status: 'IDLE',
+            model: 'gpt-5.3-codex',
+            providerSessionId: null,
+            providerMetadata: {
+                acpConfigSnapshot: {
+                    provider: 'CODEX',
+                    providerSessionId: 'codex-provider-session-from-metadata',
+                    capturedAt: '2026-02-14T00:00:00.000Z',
+                    configOptions: [],
+                },
+            },
+            workspace: { status: 'READY', worktreePath: '/tmp/worktree' },
+        });
+        mocks.isHistoryHydrated.mockReturnValue(false);
+        mocks.loadCodexSessionHistory.mockResolvedValue({
+            status: 'loaded',
+            filePath: '/tmp/.codex/sessions/2026/02/14/rollout-2026-02-14T00-00-00-codex-provider-session-from-metadata.jsonl',
+            history: [
+                {
+                    type: 'user',
+                    content: 'recovered from metadata id',
+                    timestamp: '2026-02-14T00:00:00.000Z',
+                },
+            ],
+        });
+        const handler = createLoadSessionHandler({
+            getClientCreator: () => null,
+            tryDispatchNextMessage: mocks.tryDispatchNextMessage,
+            setManualDispatchResume: vi.fn(),
+        });
+        const ws = { send: vi.fn() };
+        await handler({
+            ws: ws,
+            sessionId: 'session-codex-metadata-id',
+            workingDir: '/tmp/worktree',
+            message: { type: 'load_session' },
+        });
+        expect(mocks.loadCodexSessionHistory).toHaveBeenCalledWith({
+            providerSessionId: 'codex-provider-session-from-metadata',
+            workingDir: '/tmp/worktree',
+        });
+        expect(mocks.replaceTranscript).toHaveBeenCalledWith('session-codex-metadata-id', expect.arrayContaining([
+            expect.objectContaining({
+                source: 'user',
+                text: 'recovered from metadata id',
+            }),
+        ]), { historySource: 'jsonl' });
+        expect(mocks.markHistoryHydrated).not.toHaveBeenCalledWith('session-codex-metadata-id', 'none');
+    });
+    it('hydrates CODEX transcript using metadata providerSessionId when column is empty', async () => {
+        mocks.findById.mockResolvedValue({
+            provider: 'CODEX',
+            status: 'IDLE',
+            model: 'gpt-5.3-codex',
+            providerSessionId: '',
+            providerMetadata: {
+                acpConfigSnapshot: {
+                    provider: 'CODEX',
+                    providerSessionId: 'codex-provider-session-from-metadata',
+                    capturedAt: '2026-02-14T00:00:00.000Z',
+                    configOptions: [],
+                },
+            },
+            workspace: { status: 'READY', worktreePath: '/tmp/worktree' },
+        });
+        mocks.isHistoryHydrated.mockReturnValue(false);
+        mocks.loadCodexSessionHistory.mockResolvedValue({ status: 'not_found' });
+        const handler = createLoadSessionHandler({
+            getClientCreator: () => null,
+            tryDispatchNextMessage: mocks.tryDispatchNextMessage,
+            setManualDispatchResume: vi.fn(),
+        });
+        const ws = { send: vi.fn() };
+        await handler({
+            ws: ws,
+            sessionId: 'session-codex-empty-column-id',
+            workingDir: '/tmp/worktree',
+            message: { type: 'load_session' },
+        });
+        expect(mocks.loadCodexSessionHistory).toHaveBeenCalledWith({
+            providerSessionId: 'codex-provider-session-from-metadata',
+            workingDir: '/tmp/worktree',
+        });
+    });
+    it('prefers CODEX providerSessionId column over metadata fallback', async () => {
+        mocks.findById.mockResolvedValue({
+            provider: 'CODEX',
+            status: 'IDLE',
+            model: 'gpt-5.3-codex',
+            providerSessionId: 'codex-provider-session-column',
+            providerMetadata: {
+                acpConfigSnapshot: {
+                    provider: 'CODEX',
+                    providerSessionId: 'codex-provider-session-metadata',
+                    capturedAt: '2026-02-14T00:00:00.000Z',
+                    configOptions: [],
+                },
+            },
+            workspace: { status: 'READY', worktreePath: '/tmp/worktree' },
+        });
+        mocks.isHistoryHydrated.mockReturnValue(false);
+        mocks.loadCodexSessionHistory.mockResolvedValue({ status: 'not_found' });
+        const handler = createLoadSessionHandler({
+            getClientCreator: () => null,
+            tryDispatchNextMessage: mocks.tryDispatchNextMessage,
+            setManualDispatchResume: vi.fn(),
+        });
+        const ws = { send: vi.fn() };
+        await handler({
+            ws: ws,
+            sessionId: 'session-codex-column-id',
+            workingDir: '/tmp/worktree',
+            message: { type: 'load_session' },
+        });
+        expect(mocks.loadCodexSessionHistory).toHaveBeenCalledWith({
+            providerSessionId: 'codex-provider-session-column',
+            workingDir: '/tmp/worktree',
+        });
+    });
+    it('ignores metadata providerSessionId when snapshot provider differs', async () => {
+        mocks.findById.mockResolvedValue({
+            provider: 'CODEX',
+            status: 'IDLE',
+            model: 'gpt-5.3-codex',
+            providerSessionId: null,
+            providerMetadata: {
+                acpConfigSnapshot: {
+                    provider: 'CLAUDE',
+                    providerSessionId: 'claude-provider-session-from-metadata',
+                    capturedAt: '2026-02-14T00:00:00.000Z',
+                    configOptions: [],
+                },
+            },
+            workspace: { status: 'READY', worktreePath: '/tmp/worktree' },
+        });
+        mocks.isHistoryHydrated.mockReturnValue(false);
+        const handler = createLoadSessionHandler({
+            getClientCreator: () => null,
+            tryDispatchNextMessage: mocks.tryDispatchNextMessage,
+            setManualDispatchResume: vi.fn(),
+        });
+        const ws = { send: vi.fn() };
+        await handler({
+            ws: ws,
+            sessionId: 'session-codex-mismatched-metadata-id',
+            workingDir: '/tmp/worktree',
+            message: { type: 'load_session' },
+        });
+        expect(mocks.loadCodexSessionHistory).not.toHaveBeenCalled();
+        expect(mocks.markHistoryHydrated).toHaveBeenCalledWith('session-codex-mismatched-metadata-id', 'none');
+    });
     it('hydrates CODEX transcript from JSONL history', async () => {
         mocks.findById.mockResolvedValue({
             provider: 'CODEX',
@@ -495,6 +661,493 @@ describe('createLoadSessionHandler', () => {
             loadRequestId: 'load-codex-1',
         }));
     });
+    it('backfills missing CODEX tool calls from JSONL when a live transcript already exists', async () => {
+        const existingTranscript = [
+            {
+                id: 'existing-user',
+                source: 'user',
+                text: 'start',
+                timestamp: '2026-02-14T00:00:00.000Z',
+                order: 0,
+            },
+            {
+                id: 'existing-assistant-1',
+                source: 'agent',
+                message: {
+                    type: 'assistant',
+                    message: { role: 'assistant', content: [{ type: 'text', text: 'before tool' }] },
+                },
+                timestamp: '2026-02-14T00:00:01.000Z',
+                order: 1,
+            },
+            {
+                id: 'existing-assistant-2',
+                source: 'agent',
+                message: {
+                    type: 'assistant',
+                    message: { role: 'assistant', content: [{ type: 'text', text: 'after tool' }] },
+                },
+                timestamp: '2026-02-14T00:00:04.000Z',
+                order: 2,
+            },
+        ];
+        mocks.findById.mockResolvedValue({
+            provider: 'CODEX',
+            status: 'RUNNING',
+            model: 'gpt-5.3-codex',
+            providerSessionId: 'codex-provider-session-1',
+            workspace: { status: 'READY', worktreePath: '/tmp/worktree' },
+        });
+        mocks.isHistoryHydrated.mockReturnValue(true);
+        mocks.getTranscriptSnapshot.mockReturnValue(existingTranscript);
+        mocks.loadCodexSessionHistory.mockResolvedValue({
+            status: 'loaded',
+            filePath: '/tmp/.codex/sessions/2026/02/14/rollout-2026-02-14T00-00-00-codex-provider-session-1.jsonl',
+            history: [
+                {
+                    type: 'assistant',
+                    content: 'before tool',
+                    timestamp: '2026-02-14T00:00:01.000Z',
+                },
+                {
+                    type: 'tool_use',
+                    content: '',
+                    timestamp: '2026-02-14T00:00:02.000Z',
+                    toolName: 'exec_command',
+                    toolId: 'call-missing',
+                    toolInput: { cmd: 'pwd', workdir: '/missing' },
+                },
+                {
+                    type: 'tool_result',
+                    content: 'failed before process start',
+                    timestamp: '2026-02-14T00:00:03.000Z',
+                    toolId: 'call-missing',
+                    isError: true,
+                },
+                {
+                    type: 'assistant',
+                    content: 'after tool',
+                    timestamp: '2026-02-14T00:00:04.000Z',
+                },
+            ],
+        });
+        const handler = createLoadSessionHandler({
+            getClientCreator: () => null,
+            tryDispatchNextMessage: mocks.tryDispatchNextMessage,
+            setManualDispatchResume: vi.fn(),
+        });
+        const ws = { send: vi.fn() };
+        await handler({
+            ws: ws,
+            sessionId: 'session-codex-backfill',
+            workingDir: '/tmp/worktree',
+            message: { type: 'load_session' },
+        });
+        expect(mocks.loadCodexSessionHistory).toHaveBeenCalledWith({
+            providerSessionId: 'codex-provider-session-1',
+            workingDir: '/tmp/worktree',
+        });
+        expect(mocks.replaceTranscript).toHaveBeenCalledTimes(1);
+        const backfilledTranscript = mocks.replaceTranscript.mock.calls[0]?.[1] ?? [];
+        expect(backfilledTranscript).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                source: 'agent',
+                message: expect.objectContaining({
+                    type: 'stream_event',
+                    event: expect.objectContaining({
+                        content_block: expect.objectContaining({
+                            type: 'tool_use',
+                            id: 'call-missing',
+                            name: 'exec_command',
+                        }),
+                    }),
+                }),
+            }),
+            expect.objectContaining({
+                source: 'agent',
+                message: expect.objectContaining({
+                    type: 'user',
+                    message: expect.objectContaining({
+                        content: expect.arrayContaining([
+                            expect.objectContaining({
+                                type: 'tool_result',
+                                tool_use_id: 'call-missing',
+                                content: 'failed before process start',
+                                is_error: true,
+                            }),
+                        ]),
+                    }),
+                }),
+            }),
+        ]));
+        expect(backfilledTranscript.map((message) => message.order)).toEqual([
+            0, 1, 2, 3, 4,
+        ]);
+        expect(mocks.replaceTranscript).toHaveBeenCalledWith('session-codex-backfill', expect.any(Array), {
+            historySource: 'jsonl',
+        });
+    });
+    it('does not duplicate CODEX tool calls already captured by the live transcript', async () => {
+        const existingTranscript = [
+            {
+                id: 'existing-tool',
+                source: 'agent',
+                message: {
+                    type: 'stream_event',
+                    event: {
+                        type: 'content_block_start',
+                        index: 0,
+                        content_block: {
+                            type: 'tool_use',
+                            id: 'call-present',
+                            name: 'exec_command',
+                            input: { cmd: 'pwd' },
+                        },
+                    },
+                },
+                timestamp: '2026-02-14T00:00:02.000Z',
+                order: 0,
+            },
+            {
+                id: 'existing-result',
+                source: 'agent',
+                message: {
+                    type: 'user',
+                    message: {
+                        role: 'user',
+                        content: [{ type: 'tool_result', tool_use_id: 'call-present', content: 'ok' }],
+                    },
+                },
+                timestamp: '2026-02-14T00:00:03.000Z',
+                order: 1,
+            },
+        ];
+        mocks.findById.mockResolvedValue({
+            provider: 'CODEX',
+            status: 'RUNNING',
+            model: 'gpt-5.3-codex',
+            providerSessionId: 'codex-provider-session-1',
+            workspace: { status: 'READY', worktreePath: '/tmp/worktree' },
+        });
+        mocks.isHistoryHydrated.mockReturnValue(true);
+        mocks.getTranscriptSnapshot.mockReturnValue(existingTranscript);
+        mocks.loadCodexSessionHistory.mockResolvedValue({
+            status: 'loaded',
+            filePath: '/tmp/.codex/sessions/2026/02/14/rollout-2026-02-14T00-00-00-codex-provider-session-1.jsonl',
+            history: [
+                {
+                    type: 'tool_use',
+                    content: '',
+                    timestamp: '2026-02-14T00:00:02.000Z',
+                    toolName: 'exec_command',
+                    toolId: 'call-present',
+                    toolInput: { cmd: 'pwd' },
+                },
+                {
+                    type: 'tool_result',
+                    content: 'ok',
+                    timestamp: '2026-02-14T00:00:03.000Z',
+                    toolId: 'call-present',
+                },
+            ],
+        });
+        const handler = createLoadSessionHandler({
+            getClientCreator: () => null,
+            tryDispatchNextMessage: mocks.tryDispatchNextMessage,
+            setManualDispatchResume: vi.fn(),
+        });
+        const ws = { send: vi.fn() };
+        await handler({
+            ws: ws,
+            sessionId: 'session-codex-no-dup',
+            workingDir: '/tmp/worktree',
+            message: { type: 'load_session' },
+        });
+        expect(mocks.loadCodexSessionHistory).toHaveBeenCalledTimes(1);
+        expect(mocks.replaceTranscript).not.toHaveBeenCalled();
+        expect(mocks.markHistoryHydrated).toHaveBeenCalledWith('session-codex-no-dup', 'none');
+    });
+    it('BUG: concurrent load_session calls can corrupt historyHydrationSource from jsonl to none', async () => {
+        const existingTranscript = [
+            {
+                id: 'existing-user',
+                source: 'user',
+                text: 'start',
+                timestamp: '2026-02-14T00:00:00.000Z',
+                order: 0,
+            },
+            {
+                id: 'existing-assistant-1',
+                source: 'agent',
+                message: {
+                    type: 'assistant',
+                    message: { role: 'assistant', content: [{ type: 'text', text: 'before tool' }] },
+                },
+                timestamp: '2026-02-14T00:00:01.000Z',
+                order: 1,
+            },
+            {
+                id: 'existing-assistant-2',
+                source: 'agent',
+                message: {
+                    type: 'assistant',
+                    message: { role: 'assistant', content: [{ type: 'text', text: 'after tool' }] },
+                },
+                timestamp: '2026-02-14T00:00:04.000Z',
+                order: 2,
+            },
+        ];
+        const loadedHistory = {
+            status: 'loaded',
+            filePath: '/tmp/.codex/sessions/2026/02/14/rollout-2026-02-14T00-00-00-codex-provider-session-1.jsonl',
+            history: [
+                {
+                    type: 'assistant',
+                    content: 'before tool',
+                    timestamp: '2026-02-14T00:00:01.000Z',
+                },
+                {
+                    type: 'tool_use',
+                    content: '',
+                    timestamp: '2026-02-14T00:00:02.000Z',
+                    toolName: 'exec_command',
+                    toolId: 'call-concurrent',
+                    toolInput: { cmd: 'pwd', workdir: '/race' },
+                },
+                {
+                    type: 'tool_result',
+                    content: '/race',
+                    timestamp: '2026-02-14T00:00:03.000Z',
+                    toolId: 'call-concurrent',
+                },
+                {
+                    type: 'assistant',
+                    content: 'after tool',
+                    timestamp: '2026-02-14T00:00:04.000Z',
+                },
+            ],
+        };
+        let historyHydrationSource = 'none';
+        let latestTranscript = existingTranscript;
+        mocks.findById.mockResolvedValue({
+            provider: 'CODEX',
+            status: 'RUNNING',
+            model: 'gpt-5.3-codex',
+            providerSessionId: 'codex-provider-session-1',
+            workspace: { status: 'READY', worktreePath: '/tmp/worktree' },
+        });
+        mocks.isHistoryHydrated.mockImplementation(() => historyHydrationSource !== undefined);
+        mocks.getHistoryHydrationSource.mockImplementation(() => historyHydrationSource);
+        mocks.getTranscriptSnapshot.mockImplementation(() => latestTranscript);
+        mocks.markHistoryHydrated.mockImplementation((_sessionId, source) => {
+            historyHydrationSource = source;
+        });
+        mocks.replaceTranscript.mockImplementation((_sessionId, transcript) => {
+            latestTranscript = transcript;
+            historyHydrationSource = 'jsonl';
+        });
+        let resolveFirstLoad;
+        let resolveSecondLoad;
+        const firstLoad = new Promise((resolve) => {
+            resolveFirstLoad = resolve;
+        });
+        const secondLoad = new Promise((resolve) => {
+            resolveSecondLoad = resolve;
+        });
+        mocks.loadCodexSessionHistory.mockReturnValueOnce(firstLoad).mockReturnValueOnce(secondLoad);
+        const handler = createLoadSessionHandler({
+            getClientCreator: () => null,
+            tryDispatchNextMessage: mocks.tryDispatchNextMessage,
+            setManualDispatchResume: vi.fn(),
+        });
+        const ws = { send: vi.fn() };
+        const firstHandle = handler({
+            ws: ws,
+            sessionId: 'session-codex-concurrent',
+            workingDir: '/tmp/worktree',
+            message: { type: 'load_session' },
+        });
+        const secondHandle = handler({
+            ws: ws,
+            sessionId: 'session-codex-concurrent',
+            workingDir: '/tmp/worktree',
+            message: { type: 'load_session' },
+        });
+        await vi.waitFor(() => {
+            expect(mocks.loadCodexSessionHistory).toHaveBeenCalledTimes(2);
+        });
+        resolveFirstLoad?.(loadedHistory);
+        await firstHandle;
+        expect(historyHydrationSource).toBe('jsonl');
+        resolveSecondLoad?.(loadedHistory);
+        await secondHandle;
+        expect(mocks.replaceTranscript).toHaveBeenCalledTimes(1);
+        expect(mocks.markHistoryHydrated).not.toHaveBeenCalledWith('session-codex-concurrent', 'none');
+        expect(historyHydrationSource).toBe('jsonl');
+    });
+    it('rechecks CODEX tool backfill after a no-op cooldown', async () => {
+        vi.useFakeTimers();
+        vi.setSystemTime(new Date('2026-02-14T00:00:10.000Z'));
+        const existingTranscript = [
+            {
+                id: 'existing-tool',
+                source: 'agent',
+                message: {
+                    type: 'stream_event',
+                    event: {
+                        type: 'content_block_start',
+                        index: 0,
+                        content_block: {
+                            type: 'tool_use',
+                            id: 'call-present',
+                            name: 'exec_command',
+                            input: { cmd: 'pwd' },
+                        },
+                    },
+                },
+                timestamp: '2026-02-14T00:00:02.000Z',
+                order: 0,
+            },
+            {
+                id: 'existing-result',
+                source: 'agent',
+                message: {
+                    type: 'user',
+                    message: {
+                        role: 'user',
+                        content: [{ type: 'tool_result', tool_use_id: 'call-present', content: 'ok' }],
+                    },
+                },
+                timestamp: '2026-02-14T00:00:03.000Z',
+                order: 1,
+            },
+        ];
+        mocks.findById.mockResolvedValue({
+            provider: 'CODEX',
+            status: 'RUNNING',
+            model: 'gpt-5.3-codex',
+            providerSessionId: 'codex-provider-session-1',
+            workspace: { status: 'READY', worktreePath: '/tmp/worktree' },
+        });
+        mocks.isHistoryHydrated.mockReturnValue(true);
+        mocks.getHistoryHydrationSource.mockReturnValueOnce(undefined).mockReturnValue('none');
+        mocks.getTranscriptSnapshot.mockReturnValue(existingTranscript);
+        mocks.loadCodexSessionHistory
+            .mockResolvedValueOnce({
+            status: 'loaded',
+            filePath: '/tmp/.codex/sessions/2026/02/14/rollout-2026-02-14T00-00-00-codex-provider-session-1.jsonl',
+            history: [
+                {
+                    type: 'tool_use',
+                    content: '',
+                    timestamp: '2026-02-14T00:00:02.000Z',
+                    toolName: 'exec_command',
+                    toolId: 'call-present',
+                    toolInput: { cmd: 'pwd' },
+                },
+                {
+                    type: 'tool_result',
+                    content: 'ok',
+                    timestamp: '2026-02-14T00:00:03.000Z',
+                    toolId: 'call-present',
+                },
+            ],
+        })
+            .mockResolvedValueOnce({
+            status: 'loaded',
+            filePath: '/tmp/.codex/sessions/2026/02/14/rollout-2026-02-14T00-00-00-codex-provider-session-1.jsonl',
+            history: [
+                {
+                    type: 'tool_use',
+                    content: '',
+                    timestamp: '2026-02-14T00:00:02.000Z',
+                    toolName: 'exec_command',
+                    toolId: 'call-present',
+                    toolInput: { cmd: 'pwd' },
+                },
+                {
+                    type: 'tool_result',
+                    content: 'ok',
+                    timestamp: '2026-02-14T00:00:03.000Z',
+                    toolId: 'call-present',
+                },
+                {
+                    type: 'tool_use',
+                    content: '',
+                    timestamp: '2026-02-14T00:00:04.000Z',
+                    toolName: 'exec_command',
+                    toolId: 'call-missing',
+                    toolInput: { cmd: 'whoami' },
+                },
+                {
+                    type: 'tool_result',
+                    content: 'martin',
+                    timestamp: '2026-02-14T00:00:05.000Z',
+                    toolId: 'call-missing',
+                },
+            ],
+        });
+        const handler = createLoadSessionHandler({
+            getClientCreator: () => null,
+            tryDispatchNextMessage: mocks.tryDispatchNextMessage,
+            setManualDispatchResume: vi.fn(),
+        });
+        const ws = { send: vi.fn() };
+        await handler({
+            ws: ws,
+            sessionId: 'session-codex-recheck',
+            workingDir: '/tmp/worktree',
+            message: { type: 'load_session' },
+        });
+        expect(mocks.loadCodexSessionHistory).toHaveBeenCalledTimes(1);
+        expect(mocks.replaceTranscript).not.toHaveBeenCalled();
+        expect(mocks.markHistoryHydrated).toHaveBeenCalledWith('session-codex-recheck', 'none');
+        await handler({
+            ws: ws,
+            sessionId: 'session-codex-recheck',
+            workingDir: '/tmp/worktree',
+            message: { type: 'load_session' },
+        });
+        expect(mocks.loadCodexSessionHistory).toHaveBeenCalledTimes(1);
+        await vi.advanceTimersByTimeAsync(5000);
+        await handler({
+            ws: ws,
+            sessionId: 'session-codex-recheck',
+            workingDir: '/tmp/worktree',
+            message: { type: 'load_session' },
+        });
+        expect(mocks.loadCodexSessionHistory).toHaveBeenCalledTimes(2);
+        expect(mocks.replaceTranscript).toHaveBeenCalledWith('session-codex-recheck', expect.arrayContaining([
+            expect.objectContaining({
+                source: 'agent',
+                message: expect.objectContaining({
+                    type: 'stream_event',
+                    event: expect.objectContaining({
+                        content_block: expect.objectContaining({
+                            type: 'tool_use',
+                            id: 'call-missing',
+                            name: 'exec_command',
+                        }),
+                    }),
+                }),
+            }),
+            expect.objectContaining({
+                source: 'agent',
+                message: expect.objectContaining({
+                    type: 'user',
+                    message: expect.objectContaining({
+                        content: expect.arrayContaining([
+                            expect.objectContaining({
+                                type: 'tool_result',
+                                tool_use_id: 'call-missing',
+                                content: 'martin',
+                            }),
+                        ]),
+                    }),
+                }),
+            }),
+        ]), { historySource: 'jsonl' });
+    });
     it('emits config options using fallback-aware session service method', async () => {
         mocks.findById.mockResolvedValue({
             provider: 'CLAUDE',
@@ -541,6 +1194,46 @@ describe('createLoadSessionHandler', () => {
             ],
         });
     });
+    it('prefers fresh workspace Claude commands over cached globals on passive load', async () => {
+        const worktreePath = mkdtempSync(join(tmpdir(), 'ff-slash-commands-'));
+        tempDirs.push(worktreePath);
+        const commandsDir = join(worktreePath, '.claude', 'commands');
+        mkdirSync(commandsDir, { recursive: true });
+        writeFileSync(join(commandsDir, 'workspace-only.md'), '---\ndescription: Workspace only\n---\n');
+        writeFileSync(join(commandsDir, 'duplicate.md'), '---\ndescription: Workspace duplicate\n---\n');
+        mocks.findById.mockResolvedValue({
+            provider: 'CLAUDE',
+            status: 'IDLE',
+            model: 'claude-sonnet-4-5',
+            workspace: { status: 'READY', worktreePath },
+            providerSessionId: null,
+            providerProjectPath: null,
+        });
+        mocks.getCachedCommands.mockResolvedValue([
+            { name: '/global-only', description: 'Global only' },
+            { name: '/duplicate', description: 'Cached global duplicate' },
+        ]);
+        const handler = createLoadSessionHandler({
+            getClientCreator: () => null,
+            tryDispatchNextMessage: mocks.tryDispatchNextMessage,
+            setManualDispatchResume: vi.fn(),
+        });
+        const ws = { send: vi.fn() };
+        await handler({
+            ws: ws,
+            sessionId: 'session-1',
+            workingDir: worktreePath,
+            message: { type: 'load_session' },
+        });
+        expect(mocks.emitDelta).toHaveBeenCalledWith('session-1', {
+            type: 'slash_commands',
+            slashCommands: [
+                { name: 'duplicate', description: 'Workspace duplicate' },
+                { name: 'workspace-only', description: 'Workspace only' },
+                { name: '/global-only', description: 'Global only' },
+            ],
+        });
+    });
     it('auto-enqueues and dispatches initial message when present', async () => {
         mocks.findById.mockResolvedValue({
             provider: 'CLAUDE',