@vibe-forge/tsconfigs 0.7.1 → 0.8.0

package/dist/scripts/__tests__/adapter-e2e/cases.js

@@ -0,0 +1,283 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSelectedAdapterE2ECases = exports.parseAdapterE2ESelection = exports.collectCaseMockScenarios = exports.resolveAdapterE2ECase = exports.ADAPTER_E2E_CASES = exports.defineAdapterE2ECase = void 0;
+const rules_1 = require("../../adapter-e2e/mock-llm/rules");
+const runtime_1 = require("../../adapter-e2e/runtime");
+const scenarios_1 = require("../../adapter-e2e/scenarios");
+const defineAdapterE2ECase = (testCase) => testCase;
+exports.defineAdapterE2ECase = defineAdapterE2ECase;
+const TOOL_CASES = {
+    codex: {
+        prompt: 'Use the Read tool exactly once on README.md, then reply with exactly E2E_CODEX and nothing else.',
+        output: 'E2E_CODEX',
+        toolName: 'exec_command',
+        title: 'Codex hook smoke'
+    },
+    'claude-code': {
+        prompt: 'Use the Read tool exactly once on README.md, then reply with exactly E2E_CLAUDE and nothing else.',
+        output: 'E2E_CLAUDE',
+        toolName: 'Read',
+        title: 'Claude hook smoke'
+    },
+    opencode: {
+        prompt: 'Use the read tool exactly once on README.md, then reply with exactly E2E_OPENCODE and nothing else.',
+        output: 'E2E_OPENCODE',
+        toolName: 'read',
+        title: 'OpenCode hook smoke'
+    }
+};
+const NO_TOOL_CASES = {
+    codex: {
+        prompt: 'Do not use any tool. Reply with exactly E2E_CODEX_DIRECT and nothing else.',
+        output: 'E2E_CODEX_DIRECT',
+        title: 'Codex direct answer smoke'
+    },
+    'claude-code': {
+        prompt: 'Do not use any tool. Reply with exactly E2E_CLAUDE_DIRECT and nothing else.',
+        output: 'E2E_CLAUDE_DIRECT',
+        title: 'Claude direct answer smoke'
+    },
+    opencode: {
+        prompt: 'Do not use any tool. Reply with exactly E2E_OPENCODE_DIRECT and nothing else.',
+        output: 'E2E_OPENCODE_DIRECT',
+        title: 'OpenCode direct answer smoke'
+    }
+};
+const resolveModelProvider = (adapter) => ((scenarios_1.ADAPTER_E2E_DEFAULTS[adapter].model.split(',')[0] ?? scenarios_1.ADAPTER_E2E_DEFAULTS[adapter].model).trim());
+const createCaseModel = (adapter, caseId) => (`${resolveModelProvider(adapter)},${caseId}`);
+const createToolCaseMockScenario = (scenarioId, title, finalOutput, requestNeedles) => (0, rules_1.createRuleBasedMockScenario)({
+    id: scenarioId,
+    title,
+    finalOutput,
+    rules: [
+        (0, rules_1.defineMockScenarioRule)({
+            id: 'title-generation',
+            when: (0, rules_1.whenTitleGeneration)(),
+            respond: (0, rules_1.messageTurn)(title)
+        }),
+        (0, rules_1.defineMockScenarioRule)({
+            id: 'tool-result',
+            when: (0, rules_1.whenToolResult)(),
+            respond: (0, rules_1.messageTurn)(finalOutput)
+        }),
+        (0, rules_1.defineMockScenarioRule)({
+            id: 'tool-call',
+            when: (0, rules_1.andPredicates)((0, rules_1.whenToolsAvailable)(), (0, rules_1.whenRequestTextIncludes)(...requestNeedles)),
+            respond: (0, rules_1.selectedToolTurn)((0, rules_1.messageTurn)(finalOutput))
+        })
+    ],
+    fallback: (0, rules_1.messageTurn)(finalOutput)
+});
+const createNoToolCaseMockScenario = (scenarioId, title, finalOutput) => (0, rules_1.createRuleBasedMockScenario)({
+    id: scenarioId,
+    title,
+    finalOutput,
+    rules: [
+        (0, rules_1.defineMockScenarioRule)({
+            id: 'title-generation',
+            when: (0, rules_1.whenTitleGeneration)(),
+            respond: (0, rules_1.messageTurn)(title)
+        })
+    ],
+    fallback: (0, rules_1.messageTurn)(finalOutput)
+});
+const createCommonExpectations = (finalOutput) => ({
+    outputContains: [finalOutput],
+    hooks: [
+        { event: 'GenerateSystemPrompt', minCount: 1 },
+        { event: 'TaskStart', minCount: 1 },
+        { event: 'SessionStart', minCount: 1 },
+        { event: 'UserPromptSubmit', minCount: 1 },
+        { event: 'Stop', minCount: 1 }
+    ]
+});
+const createToolCaseExpectations = (adapter, finalOutput, toolName) => {
+    const base = createCommonExpectations(finalOutput);
+    return {
+        ...base,
+        hooks: [
+            ...(base.hooks ?? []),
+            ...(adapter === 'codex'
+                ? []
+                : [
+                    { event: 'PreToolUse', count: 1 },
+                    { event: 'PostToolUse', count: 1 }
+                ])
+        ],
+        mockTrace: {
+            minRequests: 2,
+            requiredToolNames: [toolName],
+            maxToolCalls: 1,
+            finalResponseText: finalOutput
+        }
+    };
+};
+const createNoToolCaseExpectations = (finalOutput) => {
+    const base = createCommonExpectations(finalOutput);
+    return {
+        ...base,
+        hooks: [
+            ...(base.hooks ?? []),
+            { event: 'PreToolUse', maxCount: 0 },
+            { event: 'PostToolUse', maxCount: 0 }
+        ],
+        mockTrace: {
+            minRequests: 1,
+            maxToolCalls: 0,
+            finalResponseText: finalOutput
+        }
+    };
+};
+const toolCase = (adapter, id) => {
+    const config = TOOL_CASES[adapter];
+    return (0, exports.defineAdapterE2ECase)({
+        id,
+        title: config.title,
+        adapter,
+        model: createCaseModel(adapter, id),
+        prompt: config.prompt,
+        allowedTransports: adapter === 'opencode'
+            ? ['wrapper', 'upstream-fallback']
+            : ['wrapper'],
+        mockScenarios: [
+            createToolCaseMockScenario(id, config.title, config.output, ['README.md', config.output])
+        ],
+        expectations: createToolCaseExpectations(adapter, config.output, config.toolName)
+    });
+};
+const directAnswerCase = (adapter, id) => {
+    const config = NO_TOOL_CASES[adapter];
+    return (0, exports.defineAdapterE2ECase)({
+        id,
+        title: config.title,
+        adapter,
+        model: createCaseModel(adapter, id),
+        prompt: config.prompt,
+        allowedTransports: adapter === 'opencode'
+            ? ['wrapper', 'upstream-fallback']
+            : ['wrapper'],
+        mockScenarios: [
+            createNoToolCaseMockScenario(id, config.title, config.output)
+        ],
+        expectations: createNoToolCaseExpectations(config.output)
+    });
+};
+exports.ADAPTER_E2E_CASES = [
+    toolCase('codex', 'codex-read-once'),
+    toolCase('claude-code', 'claude-read-once'),
+    toolCase('opencode', 'opencode-read-once'),
+    directAnswerCase('codex', 'codex-direct-answer'),
+    directAnswerCase('claude-code', 'claude-direct-answer'),
+    directAnswerCase('opencode', 'opencode-direct-answer')
+];
+const buildAdapterArgs = (adapter, model, prompt, sessionId, extraArgs) => {
+    if (adapter === 'codex') {
+        return [
+            runtime_1.cliPath,
+            '--adapter',
+            'codex',
+            '--model',
+            model,
+            '--print',
+            '--no-inject-default-system-prompt',
+            '--permission-mode',
+            'bypassPermissions',
+            '--exclude-mcp-server',
+            'ChromeDevtools',
+            '--session-id',
+            sessionId,
+            ...extraArgs,
+            prompt
+        ];
+    }
+    if (adapter === 'claude-code') {
+        return [
+            runtime_1.cliPath,
+            '--adapter',
+            'claude-code',
+            '--model',
+            model,
+            '--print',
+            '--no-inject-default-system-prompt',
+            '--exclude-mcp-server',
+            'ChromeDevtools',
+            '--include-tool',
+            'Read',
+            '--permission-mode',
+            'bypassPermissions',
+            '--session-id',
+            sessionId,
+            ...extraArgs,
+            prompt
+        ];
+    }
+    return [
+        runtime_1.cliPath,
+        '--adapter',
+        'opencode',
+        '--model',
+        model,
+        '--print',
+        '--no-inject-default-system-prompt',
+        '--exclude-mcp-server',
+        'ChromeDevtools',
+        '--session-id',
+        sessionId,
+        ...extraArgs,
+        prompt
+    ];
+};
+const resolveAdapterE2ECase = (testCase) => {
+    const base = scenarios_1.ADAPTER_E2E_DEFAULTS[testCase.adapter];
+    const model = testCase.model ?? base.model;
+    const prompt = testCase.prompt ?? base.prompt;
+    const extraArgs = testCase.extraArgs ?? [];
+    return {
+        id: testCase.id,
+        title: testCase.title,
+        adapter: testCase.adapter,
+        model,
+        prompt,
+        allowedTransports: testCase.allowedTransports ?? ['wrapper'],
+        args: (sessionId) => buildAdapterArgs(testCase.adapter, model, prompt, sessionId, extraArgs),
+        mockScenarios: testCase.mockScenarios ?? [],
+        expectations: testCase.expectations ?? {}
+    };
+};
+exports.resolveAdapterE2ECase = resolveAdapterE2ECase;
+const collectCaseMockScenarios = (cases) => {
+    const scenarios = new Map();
+    for (const testCase of cases) {
+        for (const scenario of testCase.mockScenarios ?? []) {
+            scenarios.set(scenario.id, scenario);
+        }
+    }
+    return Array.from(scenarios.values());
+};
+exports.collectCaseMockScenarios = collectCaseMockScenarios;
+const isAdapterTarget = (value) => (scenarios_1.ADAPTER_E2E_TARGETS.includes(value));
+const parseAdapterE2ESelection = (value, cases = exports.ADAPTER_E2E_CASES) => {
+    const normalized = value?.trim() ?? 'all';
+    if (normalized === 'all')
+        return normalized;
+    if (isAdapterTarget(normalized))
+        return normalized;
+    if (cases.some(testCase => testCase.id === normalized))
+        return normalized;
+    throw new Error(`Unsupported adapter e2e selection: ${normalized}`);
+};
+exports.parseAdapterE2ESelection = parseAdapterE2ESelection;
+const resolveSelectedAdapterE2ECases = (selection, cases = exports.ADAPTER_E2E_CASES) => {
+    const normalized = (0, exports.parseAdapterE2ESelection)(selection, cases);
+    if (normalized === 'all')
+        return [...cases];
+    if (isAdapterTarget(normalized)) {
+        return cases.filter(testCase => testCase.adapter === normalized);
+    }
+    const matchedCase = cases.find(testCase => testCase.id === normalized);
+    if (matchedCase == null) {
+        throw new Error(`Adapter e2e case not found: ${normalized}`);
+    }
+    return [matchedCase];
+};
+exports.resolveSelectedAdapterE2ECases = resolveSelectedAdapterE2ECases;

package/dist/scripts/__tests__/adapter-e2e/harness.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/__tests__/adapter-e2e/harness.spec.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const harness_1 = require("../../adapter-e2e/harness");
+const createTraceEntry = (model, response) => ({
+    path: '/chat/completions',
+    model,
+    requestText: '',
+    inputTypes: ['system', 'user'],
+    requestedToolCount: 0,
+    selectedTool: undefined,
+    response
+});
+(0, vitest_1.describe)('collectCaseMockTrace', () => {
+    (0, vitest_1.it)('filters late trace entries from previous cases by resolved model', () => {
+        const resolvedCase = {
+            id: 'claude-read-once',
+            title: 'Claude read once',
+            adapter: 'claude-code',
+            prompt: 'prompt',
+            model: 'hook-smoke-mock-ccr,claude-read-once',
+            allowedTransports: ['wrapper'],
+            args: () => [],
+            mockScenarios: [],
+            expectations: {}
+        };
+        const trace = [
+            createTraceEntry('codex-read-once', {
+                kind: 'tool',
+                tool: {
+                    name: 'exec_command',
+                    args: {}
+                }
+            }),
+            createTraceEntry('codex-read-once', {
+                kind: 'tool',
+                tool: {
+                    name: 'exec_command',
+                    args: {}
+                }
+            }),
+            createTraceEntry('claude-read-once', {
+                kind: 'tool',
+                tool: {
+                    name: 'Read',
+                    args: {}
+                }
+            }),
+            createTraceEntry('claude-read-once', {
+                kind: 'message',
+                text: 'E2E_CLAUDE'
+            })
+        ];
+        (0, vitest_1.expect)((0, harness_1.collectCaseMockTrace)(trace, 1, resolvedCase)).toEqual([
+            trace[2],
+            trace[3]
+        ]);
+    });
+    (0, vitest_1.it)('falls back to trace slicing when the adapter rewrites request models', () => {
+        const resolvedCase = {
+            id: 'codex-direct-answer',
+            title: 'Codex direct answer',
+            adapter: 'codex',
+            prompt: 'prompt',
+            model: 'hook-smoke-mock,codex-direct-answer',
+            allowedTransports: ['wrapper'],
+            args: () => [],
+            mockScenarios: [],
+            expectations: {}
+        };
+        const trace = [
+            createTraceEntry('claude-read-once', {
+                kind: 'message',
+                text: 'E2E_CLAUDE'
+            }),
+            createTraceEntry('gpt-5.4-2026-03-05', {
+                kind: 'message',
+                text: 'E2E_CODEX_DIRECT'
+            })
+        ];
+        (0, vitest_1.expect)((0, harness_1.collectCaseMockTrace)(trace, 1, resolvedCase)).toEqual([
+            trace[1]
+        ]);
+    });
+});

package/dist/scripts/__tests__/adapter-e2e/log.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/__tests__/adapter-e2e/log.spec.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_path_1 = __importDefault(require("node:path"));
+const vitest_1 = require("vitest");
+const log_1 = require("../../adapter-e2e/log");
+const runtime_1 = require("../../adapter-e2e/runtime");
+const snapshot_1 = require("../../adapter-e2e/snapshot");
+const fixtureLog = `
+# [3/27/2026, 2:37:33 PM] __I__ [SessionStart] [plugin.logger]
+\`\`\`json
+{
+  "adapter": "codex",
+  "hookSource": "native",
+  "canBlock": true
+}
+\`\`\`
+# [3/27/2026, 2:37:33 PM] __I__ [PreToolUse] [plugin.logger] codex Bash
+\`\`\`json
+{
+  "command": "sed -n '1,200p' README.md"
+}
+\`\`\`
+# [3/27/2026, 2:37:33 PM] __I__ [PostToolUse] [plugin.logger] Bash
+\`\`\`json
+undefined
+\`\`\`
+\`\`\`text
+> sed -n '1,200p' README.md
+
+stdout: # Vibe Forge AI
+\`\`\`
+`.trim();
+const createResult = () => ({
+    caseId: 'codex-read-once',
+    adapter: 'codex',
+    ctxId: 'hooks-smoke-codex-1',
+    sessionId: '00000000-0000-0000-0000-000000000000',
+    logPath: node_path_1.default.resolve(runtime_1.repoRoot, '.ai/logs/hooks-smoke-codex-1/00000000-0000-0000-0000-000000000000.log.md'),
+    logContent: fixtureLog,
+    managedArtifacts: [],
+    stdout: 'E2E_CODEX',
+    stderr: '',
+    exitCode: 0,
+    transport: 'wrapper',
+    mockTrace: []
+});
+(0, vitest_1.describe)('adapter e2e hook log parsing', () => {
+    (0, vitest_1.it)('parses tool hook entries with header text and invalid json payloads', () => {
+        const entries = (0, log_1.parseHookLogEntries)(fixtureLog);
+        const counts = (0, log_1.countHookLogEvents)(entries);
+        (0, vitest_1.expect)(entries.map(entry => entry.eventName)).toEqual([
+            'SessionStart',
+            'PreToolUse',
+            'PostToolUse'
+        ]);
+        (0, vitest_1.expect)(entries[1]?.headerText).toBe('codex Bash');
+        (0, vitest_1.expect)(entries[2]?.headerText).toBe('Bash');
+        (0, vitest_1.expect)(entries[2]?.textBlock).toContain('stdout: # Vibe Forge AI');
+        (0, vitest_1.expect)(counts.get('PreToolUse')).toBe(1);
+        (0, vitest_1.expect)(counts.get('PostToolUse')).toBe(1);
+    });
+    (0, vitest_1.it)('keeps tool hook entries visible in the stable snapshot projection', () => {
+        const snapshot = (0, snapshot_1.createAdapterE2ESnapshot)(createResult());
+        (0, vitest_1.expect)(snapshot.log.entries).toEqual([
+            {
+                event: 'SessionStart',
+                adapter: 'codex',
+                hookSource: 'native',
+                canBlock: true
+            },
+            {
+                event: 'PreToolUse',
+                header: 'codex Bash',
+                toolName: 'Bash',
+                detail: "sed -n '1,200p' README.md"
+            },
+            {
+                event: 'PostToolUse',
+                header: 'Bash',
+                toolName: 'Bash',
+                detail: "> sed -n '1,200p' README.md"
+            }
+        ]);
+    });
+});

package/dist/scripts/__tests__/adapter-e2e/mock-llm.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/__tests__/adapter-e2e/mock-llm.spec.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const rules_1 = require("../../adapter-e2e/mock-llm/rules");
+const server_1 = require("../../adapter-e2e/mock-llm/server");
+const scenarios_1 = require("../../adapter-e2e/scenarios");
+const cases_1 = require("./cases");
+const createReadBody = () => ({
+    model: 'hook-smoke-mock,codex-read-once',
+    input: [
+        {
+            role: 'user',
+            content: scenarios_1.ADAPTER_E2E_DEFAULTS.codex.prompt
+        }
+    ],
+    tools: [
+        {
+            name: 'Read',
+            parameters: {
+                properties: {
+                    filePath: { type: 'string' }
+                }
+            }
+        }
+    ]
+});
+(0, vitest_1.describe)('mock llm server', () => {
+    let server;
+    const defaultScenarios = (0, cases_1.collectCaseMockScenarios)(cases_1.ADAPTER_E2E_CASES);
+    (0, vitest_1.afterEach)(async () => {
+        await server?.close();
+        server = undefined;
+    });
+    (0, vitest_1.it)('resolves a tool call before returning the final assistant message', () => {
+        const toolTurn = (0, server_1.resolveMockTurn)(defaultScenarios, 'hook-smoke-mock,codex-read-once', createReadBody());
+        (0, vitest_1.expect)(toolTurn.kind).toBe('tool');
+        (0, vitest_1.expect)(toolTurn.kind === 'tool' ? toolTurn.tool.name : '').toBe('Read');
+        const finalTurn = (0, server_1.resolveMockTurn)(defaultScenarios, 'hook-smoke-mock,codex-read-once', {
+            ...createReadBody(),
+            input: [
+                {
+                    type: 'function_call_output',
+                    call_id: 'call_1',
+                    output: 'README contents'
+                }
+            ]
+        });
+        (0, vitest_1.expect)(finalTurn).toEqual({
+            kind: 'message',
+            text: 'E2E_CODEX'
+        });
+    });
+    (0, vitest_1.it)('supports custom scenario registries for lightweight e2e authoring', async () => {
+        server = await (0, server_1.startMockLlmServer)({
+            scenarios: [
+                (0, rules_1.createRuleBasedMockScenario)({
+                    id: 'custom-flow',
+                    title: 'Custom title',
+                    finalOutput: 'CUSTOM_DONE',
+                    rules: [
+                        (0, rules_1.defineMockScenarioRule)({
+                            id: 'title',
+                            when: (0, rules_1.whenTitleGeneration)(),
+                            respond: (0, rules_1.messageTurn)('Custom title')
+                        }),
+                        (0, rules_1.defineMockScenarioRule)({
+                            id: 'final',
+                            when: (0, rules_1.whenToolResult)(),
+                            respond: (0, rules_1.messageTurn)('CUSTOM_DONE')
+                        }),
+                        (0, rules_1.defineMockScenarioRule)({
+                            id: 'tool',
+                            when: (0, rules_1.whenRequestTextIncludes)('Use a tool first'),
+                            respond: (0, rules_1.selectedToolTurn)((0, rules_1.messageTurn)('CUSTOM_DONE'))
+                        }),
+                        (0, rules_1.defineMockScenarioRule)({
+                            id: 'tool-fallback',
+                            when: (0, rules_1.whenToolsAvailable)(),
+                            respond: (0, rules_1.selectedToolTurn)((0, rules_1.messageTurn)('CUSTOM_DONE'))
+                        })
+                    ]
+                })
+            ]
+        });
+        const response = await fetch(`http://127.0.0.1:${server.port}/v1/responses`, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json'
+            },
+            body: JSON.stringify({
+                model: 'hook-smoke-mock,custom-flow',
+                input: [
+                    {
+                        role: 'user',
+                        content: 'Use a tool first'
+                    }
+                ],
+                tools: [
+                    {
+                        name: 'exec_command',
+                        parameters: {
+                            properties: {
+                                cmd: { type: 'string' }
+                            }
+                        }
+                    }
+                ]
+            })
+        });
+        (0, vitest_1.expect)(response.status).toBe(200);
+        const payload = await response.json();
+        (0, vitest_1.expect)(payload.output[0].type).toBe('function_call');
+        (0, vitest_1.expect)(payload.output[0].name).toBe('exec_command');
+    });
+    (0, vitest_1.it)('returns a controlled error for unknown scenario models', async () => {
+        server = await (0, server_1.startMockLlmServer)({
+            scenarios: []
+        });
+        const response = await fetch(`http://127.0.0.1:${server.port}/v1/responses`, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json'
+            },
+            body: JSON.stringify({
+                model: 'hook-smoke-mock,missing-case',
+                input: [
+                    {
+                        role: 'user',
+                        content: 'reply'
+                    }
+                ]
+            })
+        });
+        (0, vitest_1.expect)(response.status).toBe(404);
+        await (0, vitest_1.expect)(response.json()).resolves.toMatchObject({
+            error: 'unknown_model_scenario',
+            model: 'hook-smoke-mock,missing-case'
+        });
+    });
+    (0, vitest_1.it)('returns title text for title generation requests', () => {
+        const turn = (0, server_1.resolveMockTurn)(defaultScenarios, 'hook-smoke-mock-ccr,claude-read-once', {
+            model: 'hook-smoke-mock-ccr,claude-read-once',
+            input: [
+                {
+                    role: 'user',
+                    content: 'Generate a title for this conversation'
+                }
+            ]
+        });
+        (0, vitest_1.expect)(turn).toEqual({
+            kind: 'message',
+            text: 'Claude hook smoke'
+        });
+    });
+});

package/dist/scripts/__tests__/adapter-e2e/snapshot.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/__tests__/adapter-e2e/snapshot.spec.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_path_1 = __importDefault(require("node:path"));
+const node_process_1 = __importDefault(require("node:process"));
+const vitest_1 = require("vitest");
+const runtime_1 = require("../../adapter-e2e/runtime");
+const snapshot_1 = require("../../adapter-e2e/snapshot");
+const createResult = (stderr) => ({
+    caseId: 'codex-direct-answer',
+    adapter: 'codex',
+    ctxId: 'hooks-smoke-codex-1',
+    sessionId: '00000000-0000-0000-0000-000000000000',
+    logPath: node_path_1.default.resolve(runtime_1.repoRoot, '.ai/logs/hooks-smoke-codex-1/00000000-0000-0000-0000-000000000000.log.md'),
+    logContent: '',
+    managedArtifacts: [],
+    stdout: 'E2E_CODEX_DIRECT',
+    stderr,
+    exitCode: 0,
+    transport: 'wrapper',
+    mockTrace: []
+});
+(0, vitest_1.describe)('adapter e2e snapshot stderr projection', () => {
+    (0, vitest_1.it)('filters codex featured-plugin sync html noise', () => {
+        const snapshot = (0, snapshot_1.createAdapterE2ESnapshot)(createResult([
+            'WARN codex_core::models_manager::model_info: Unknown model codex-direct-answer is used. This will use fallback model metadata.',
+            'WARN codex_core::plugins::manager: failed to warm featured plugin ids cache error=remote plugin sync request to https://chatgpt.com/backend-api/plugins/featured failed with status 403 Forbidden: <html>',
+            '<head>',
+            '<meta name="viewport" content="width=device-width, initial-scale=1" />',
+            '<body>',
+            'width="41"',
+            'height="41"',
+            '>',
+            '<path',
+            'd="M0 0"',
+            '/>'
+        ].join('\n')));
+        (0, vitest_1.expect)(snapshot.stderr).toEqual([
+            'WARN codex_core::models_manager::model_info: Unknown model codex-direct-answer is used. This will use fallback model metadata.'
+        ]);
+    });
+    (0, vitest_1.it)('normalizes the active node executable path', () => {
+        const snapshot = (0, snapshot_1.createAdapterE2ESnapshot)(createResult(node_process_1.default.execPath));
+        (0, vitest_1.expect)(snapshot.stderr).toEqual(['<node-path>']);
+    });
+});

package/dist/scripts/__tests__/cli.spec.d.ts

@@ -0,0 +1 @@
+export {};