@machina.ai/cell-cli 1.11.0-rc1 → 1.13.0-rc1

package/dist/src/nonInteractiveCli.test.js

@@ -3,11 +3,17 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { executeToolCall, ToolErrorType, shutdownTelemetry, GeminiEventType, OutputFormat, uiTelemetryService, FatalInputError, } from '@google/gemini-cli-core';
+import { executeToolCall, ToolErrorType, shutdownTelemetry, GeminiEventType, OutputFormat, uiTelemetryService, FatalInputError, CoreEvent, } from '@google/gemini-cli-core';
 import { runNonInteractive } from './nonInteractiveCli.js';
-import { vi } from 'vitest';
+import { describe, it, expect, beforeEach, afterEach, vi, } from 'vitest';
 // Mock core modules
 vi.mock('./ui/hooks/atCommandProcessor.js');
+const mockCoreEvents = vi.hoisted(() => ({
+    on: vi.fn(),
+    off: vi.fn(),
+    drainFeedbackBacklog: vi.fn(),
+    emit: vi.fn(),
+}));
 vi.mock('@google/gemini-cli-core', async (importOriginal) => {
     const original = await importOriginal();
     class MockChatRecordingService {
@@ -25,6 +31,7 @@ vi.mock('@google/gemini-cli-core', async (importOriginal) => {
         uiTelemetryService: {
             getMetrics: vi.fn(),
         },
+        coreEvents: mockCoreEvents,
     };
 });
 const mockGetCommands = vi.hoisted(() => vi.fn());
@@ -44,7 +51,28 @@ describe('runNonInteractive', () => {
     let mockShutdownTelemetry;
     let consoleErrorSpy;
     let processStdoutSpy;
+    let processStderrSpy;
     let mockGeminiClient;
+    const MOCK_SESSION_METRICS = {
+        models: {},
+        tools: {
+            totalCalls: 0,
+            totalSuccess: 0,
+            totalFail: 0,
+            totalDurationMs: 0,
+            totalDecisions: {
+                accept: 0,
+                reject: 0,
+                modify: 0,
+                auto_accept: 0,
+            },
+            byName: {},
+        },
+        files: {
+            totalLinesAdded: 0,
+            totalLinesRemoved: 0,
+        },
+    };
     beforeEach(async () => {
         mockCoreExecuteToolCall = vi.mocked(executeToolCall);
         mockShutdownTelemetry = vi.mocked(shutdownTelemetry);
@@ -55,6 +83,9 @@ describe('runNonInteractive', () => {
         processStdoutSpy = vi
             .spyOn(process.stdout, 'write')
             .mockImplementation(() => true);
+        processStderrSpy = vi
+            .spyOn(process.stderr, 'write')
+            .mockImplementation(() => true);
         vi.spyOn(process, 'exit').mockImplementation((code) => {
             throw new Error(`process.exit(${code}) called`);
         });
@@ -123,6 +154,7 @@ describe('runNonInteractive', () => {
             yield event;
         }
     }
+    const getWrittenOutput = () => processStdoutSpy.mock.calls.map((c) => c[0]).join('');
     it('should process input and write text output', async () => {
         const events = [
             { type: GeminiEventType.Content, value: 'Hello' },
@@ -133,11 +165,14 @@ describe('runNonInteractive', () => {
             },
         ];
         mockGeminiClient.sendMessageStream.mockReturnValue(createStreamFromEvents(events));
-        await runNonInteractive(mockConfig, mockSettings, 'Test input', 'prompt-id-1');
+        await runNonInteractive({
+            config: mockConfig,
+            settings: mockSettings,
+            input: 'Test input',
+            prompt_id: 'prompt-id-1',
+        });
         expect(mockGeminiClient.sendMessageStream).toHaveBeenCalledWith([{ text: 'Test input' }], expect.any(AbortSignal), 'prompt-id-1');
-        expect(processStdoutSpy).toHaveBeenCalledWith('Hello');
-        expect(processStdoutSpy).toHaveBeenCalledWith(' World');
-        expect(processStdoutSpy).toHaveBeenCalledWith('\n');
+        expect(getWrittenOutput()).toBe('Hello World\n');
         expect(mockShutdownTelemetry).toHaveBeenCalled();
     });
     it('should handle a single tool call and respond', async () => {
@@ -182,12 +217,78 @@ describe('runNonInteractive', () => {
         mockGeminiClient.sendMessageStream
             .mockReturnValueOnce(createStreamFromEvents(firstCallEvents))
             .mockReturnValueOnce(createStreamFromEvents(secondCallEvents));
-        await runNonInteractive(mockConfig, mockSettings, 'Use a tool', 'prompt-id-2');
+        await runNonInteractive({
+            config: mockConfig,
+            settings: mockSettings,
+            input: 'Use a tool',
+            prompt_id: 'prompt-id-2',
+        });
         expect(mockGeminiClient.sendMessageStream).toHaveBeenCalledTimes(2);
         expect(mockCoreExecuteToolCall).toHaveBeenCalledWith(mockConfig, expect.objectContaining({ name: 'testTool' }), expect.any(AbortSignal));
         expect(mockGeminiClient.sendMessageStream).toHaveBeenNthCalledWith(2, [{ text: 'Tool response' }], expect.any(AbortSignal), 'prompt-id-2');
-        expect(processStdoutSpy).toHaveBeenCalledWith('Final answer');
-        expect(processStdoutSpy).toHaveBeenCalledWith('\n');
+        expect(getWrittenOutput()).toBe('Final answer\n');
+    });
+    it('should write a single newline between sequential text outputs from the model', async () => {
+        // This test simulates a multi-turn conversation to ensure that a single newline
+        // is printed between each block of text output from the model.
+        // 1. Define the tool requests that the model will ask the CLI to run.
+        const toolCallEvent = {
+            type: GeminiEventType.ToolCallRequest,
+            value: {
+                callId: 'mock-tool',
+                name: 'mockTool',
+                args: {},
+                isClientInitiated: false,
+                prompt_id: 'prompt-id-multi',
+            },
+        };
+        // 2. Mock the execution of the tools. We just need them to succeed.
+        mockCoreExecuteToolCall.mockResolvedValue({
+            status: 'success',
+            request: toolCallEvent.value, // This is generic enough for both calls
+            tool: {},
+            invocation: {},
+            response: {
+                responseParts: [],
+                callId: 'mock-tool',
+            },
+        });
+        // 3. Define the sequence of events streamed from the mock model.
+        // Turn 1: Model outputs text, then requests a tool call.
+        const modelTurn1 = [
+            { type: GeminiEventType.Content, value: 'Use mock tool' },
+            toolCallEvent,
+        ];
+        // Turn 2: Model outputs more text, then requests another tool call.
+        const modelTurn2 = [
+            { type: GeminiEventType.Content, value: 'Use mock tool again' },
+            toolCallEvent,
+        ];
+        // Turn 3: Model outputs a final answer.
+        const modelTurn3 = [
+            { type: GeminiEventType.Content, value: 'Finished.' },
+            {
+                type: GeminiEventType.Finished,
+                value: { reason: undefined, usageMetadata: { totalTokenCount: 10 } },
+            },
+        ];
+        mockGeminiClient.sendMessageStream
+            .mockReturnValueOnce(createStreamFromEvents(modelTurn1))
+            .mockReturnValueOnce(createStreamFromEvents(modelTurn2))
+            .mockReturnValueOnce(createStreamFromEvents(modelTurn3));
+        // 4. Run the command.
+        await runNonInteractive({
+            config: mockConfig,
+            settings: mockSettings,
+            input: 'Use mock tool multiple times',
+            prompt_id: 'prompt-id-multi',
+        });
+        // 5. Verify the output.
+        // The rendered output should contain the text from each turn, separated by a
+        // single newline, with a final newline at the end.
+        expect(getWrittenOutput()).toMatchSnapshot();
+        // Also verify the tools were called as expected.
+        expect(mockCoreExecuteToolCall).toHaveBeenCalledTimes(2);
     });
     it('should handle error during tool execution and should send error back to the model', async () => {
         const toolCallEvent = {
@@ -241,7 +342,12 @@ describe('runNonInteractive', () => {
         mockGeminiClient.sendMessageStream
             .mockReturnValueOnce(createStreamFromEvents([toolCallEvent]))
             .mockReturnValueOnce(createStreamFromEvents(finalResponse));
-        await runNonInteractive(mockConfig, mockSettings, 'Trigger tool error', 'prompt-id-3');
+        await runNonInteractive({
+            config: mockConfig,
+            settings: mockSettings,
+            input: 'Trigger tool error',
+            prompt_id: 'prompt-id-3',
+        });
         expect(mockCoreExecuteToolCall).toHaveBeenCalled();
         expect(consoleErrorSpy).toHaveBeenCalledWith('Error executing tool errorTool: Execution failed');
         expect(mockGeminiClient.sendMessageStream).toHaveBeenCalledTimes(2);
@@ -255,14 +361,19 @@ describe('runNonInteractive', () => {
                 },
             },
         ], expect.any(AbortSignal), 'prompt-id-3');
-        expect(processStdoutSpy).toHaveBeenCalledWith('Sorry, let me try again.');
+        expect(getWrittenOutput()).toBe('Sorry, let me try again.\n');
     });
     it('should exit with error if sendMessageStream throws initially', async () => {
         const apiError = new Error('API connection failed');
         mockGeminiClient.sendMessageStream.mockImplementation(() => {
             throw apiError;
         });
-        await expect(runNonInteractive(mockConfig, mockSettings, 'Initial fail', 'prompt-id-4')).rejects.toThrow(apiError);
+        await expect(runNonInteractive({
+            config: mockConfig,
+            settings: mockSettings,
+            input: 'Initial fail',
+            prompt_id: 'prompt-id-4',
+        })).rejects.toThrow(apiError);
     });
     it('should not exit if a tool is not found, and should send error back to model', async () => {
         const toolCallEvent = {
@@ -306,15 +417,25 @@ describe('runNonInteractive', () => {
         mockGeminiClient.sendMessageStream
             .mockReturnValueOnce(createStreamFromEvents([toolCallEvent]))
             .mockReturnValueOnce(createStreamFromEvents(finalResponse));
-        await runNonInteractive(mockConfig, mockSettings, 'Trigger tool not found', 'prompt-id-5');
+        await runNonInteractive({
+            config: mockConfig,
+            settings: mockSettings,
+            input: 'Trigger tool not found',
+            prompt_id: 'prompt-id-5',
+        });
         expect(mockCoreExecuteToolCall).toHaveBeenCalled();
         expect(consoleErrorSpy).toHaveBeenCalledWith('Error executing tool nonexistentTool: Tool "nonexistentTool" not found in registry.');
         expect(mockGeminiClient.sendMessageStream).toHaveBeenCalledTimes(2);
-        expect(processStdoutSpy).toHaveBeenCalledWith("Sorry, I can't find that tool.");
+        expect(getWrittenOutput()).toBe("Sorry, I can't find that tool.\n");
     });
     it('should exit when max session turns are exceeded', async () => {
         vi.mocked(mockConfig.getMaxSessionTurns).mockReturnValue(0);
-        await expect(runNonInteractive(mockConfig, mockSettings, 'Trigger loop', 'prompt-id-6')).rejects.toThrow('process.exit(53) called');
+        await expect(runNonInteractive({
+            config: mockConfig,
+            settings: mockSettings,
+            input: 'Trigger loop',
+            prompt_id: 'prompt-id-6',
+        })).rejects.toThrow('process.exit(53) called');
     });
     it('should preprocess @include commands before sending to the model', async () => {
         // 1. Mock the imported atCommandProcessor
@@ -343,11 +464,16 @@ describe('runNonInteractive', () => {
         ];
         mockGeminiClient.sendMessageStream.mockReturnValue(createStreamFromEvents(events));
         // 4. Run the non-interactive mode with the raw input
-        await runNonInteractive(mockConfig, mockSettings, rawInput, 'prompt-id-7');
+        await runNonInteractive({
+            config: mockConfig,
+            settings: mockSettings,
+            input: rawInput,
+            prompt_id: 'prompt-id-7',
+        });
         // 5. Assert that sendMessageStream was called with the PROCESSED parts, not the raw input
         expect(mockGeminiClient.sendMessageStream).toHaveBeenCalledWith(processedParts, expect.any(AbortSignal), 'prompt-id-7');
         // 6. Assert the final output is correct
-        expect(processStdoutSpy).toHaveBeenCalledWith('Summary complete.');
+        expect(getWrittenOutput()).toBe('Summary complete.\n');
     });
     it('should process input and write JSON output with stats', async () => {
         const events = [
@@ -359,30 +485,15 @@ describe('runNonInteractive', () => {
         ];
         mockGeminiClient.sendMessageStream.mockReturnValue(createStreamFromEvents(events));
         vi.mocked(mockConfig.getOutputFormat).mockReturnValue(OutputFormat.JSON);
-        const mockMetrics = {
-            models: {},
-            tools: {
-                totalCalls: 0,
-                totalSuccess: 0,
-                totalFail: 0,
-                totalDurationMs: 0,
-                totalDecisions: {
-                    accept: 0,
-                    reject: 0,
-                    modify: 0,
-                    auto_accept: 0,
-                },
-                byName: {},
-            },
-            files: {
-                totalLinesAdded: 0,
-                totalLinesRemoved: 0,
-            },
-        };
-        vi.mocked(uiTelemetryService.getMetrics).mockReturnValue(mockMetrics);
-        await runNonInteractive(mockConfig, mockSettings, 'Test input', 'prompt-id-1');
+        vi.mocked(uiTelemetryService.getMetrics).mockReturnValue(MOCK_SESSION_METRICS);
+        await runNonInteractive({
+            config: mockConfig,
+            settings: mockSettings,
+            input: 'Test input',
+            prompt_id: 'prompt-id-1',
+        });
         expect(mockGeminiClient.sendMessageStream).toHaveBeenCalledWith([{ text: 'Test input' }], expect.any(AbortSignal), 'prompt-id-1');
-        expect(processStdoutSpy).toHaveBeenCalledWith(JSON.stringify({ response: 'Hello World', stats: mockMetrics }, null, 2));
+        expect(processStdoutSpy).toHaveBeenCalledWith(JSON.stringify({ response: 'Hello World', stats: MOCK_SESSION_METRICS }, null, 2));
     });
     it('should write JSON output with stats for tool-only commands (no text response)', async () => {
         // Test the scenario where a command completes successfully with only tool calls
@@ -436,45 +547,17 @@ describe('runNonInteractive', () => {
             .mockReturnValueOnce(createStreamFromEvents(firstCallEvents))
             .mockReturnValueOnce(createStreamFromEvents(secondCallEvents));
         vi.mocked(mockConfig.getOutputFormat).mockReturnValue(OutputFormat.JSON);
-        const mockMetrics = {
-            models: {},
-            tools: {
-                totalCalls: 1,
-                totalSuccess: 1,
-                totalFail: 0,
-                totalDurationMs: 100,
-                totalDecisions: {
-                    accept: 1,
-                    reject: 0,
-                    modify: 0,
-                    auto_accept: 0,
-                },
-                byName: {
-                    testTool: {
-                        count: 1,
-                        success: 1,
-                        fail: 0,
-                        durationMs: 100,
-                        decisions: {
-                            accept: 1,
-                            reject: 0,
-                            modify: 0,
-                            auto_accept: 0,
-                        },
-                    },
-                },
-            },
-            files: {
-                totalLinesAdded: 0,
-                totalLinesRemoved: 0,
-            },
-        };
-        vi.mocked(uiTelemetryService.getMetrics).mockReturnValue(mockMetrics);
-        await runNonInteractive(mockConfig, mockSettings, 'Execute tool only', 'prompt-id-tool-only');
+        vi.mocked(uiTelemetryService.getMetrics).mockReturnValue(MOCK_SESSION_METRICS);
+        await runNonInteractive({
+            config: mockConfig,
+            settings: mockSettings,
+            input: 'Execute tool only',
+            prompt_id: 'prompt-id-tool-only',
+        });
         expect(mockGeminiClient.sendMessageStream).toHaveBeenCalledTimes(2);
         expect(mockCoreExecuteToolCall).toHaveBeenCalledWith(mockConfig, expect.objectContaining({ name: 'testTool' }), expect.any(AbortSignal));
         // This should output JSON with empty response but include stats
-        expect(processStdoutSpy).toHaveBeenCalledWith(JSON.stringify({ response: '', stats: mockMetrics }, null, 2));
+        expect(processStdoutSpy).toHaveBeenCalledWith(JSON.stringify({ response: '', stats: MOCK_SESSION_METRICS }, null, 2));
     });
     it('should write JSON output with stats for empty response commands', async () => {
         // Test the scenario where a command completes but produces no content at all
@@ -486,31 +569,16 @@ describe('runNonInteractive', () => {
         ];
         mockGeminiClient.sendMessageStream.mockReturnValue(createStreamFromEvents(events));
         vi.mocked(mockConfig.getOutputFormat).mockReturnValue(OutputFormat.JSON);
-        const mockMetrics = {
-            models: {},
-            tools: {
-                totalCalls: 0,
-                totalSuccess: 0,
-                totalFail: 0,
-                totalDurationMs: 0,
-                totalDecisions: {
-                    accept: 0,
-                    reject: 0,
-                    modify: 0,
-                    auto_accept: 0,
-                },
-                byName: {},
-            },
-            files: {
-                totalLinesAdded: 0,
-                totalLinesRemoved: 0,
-            },
-        };
-        vi.mocked(uiTelemetryService.getMetrics).mockReturnValue(mockMetrics);
-        await runNonInteractive(mockConfig, mockSettings, 'Empty response test', 'prompt-id-empty');
+        vi.mocked(uiTelemetryService.getMetrics).mockReturnValue(MOCK_SESSION_METRICS);
+        await runNonInteractive({
+            config: mockConfig,
+            settings: mockSettings,
+            input: 'Empty response test',
+            prompt_id: 'prompt-id-empty',
+        });
         expect(mockGeminiClient.sendMessageStream).toHaveBeenCalledWith([{ text: 'Empty response test' }], expect.any(AbortSignal), 'prompt-id-empty');
         // This should output JSON with empty response but include stats
-        expect(processStdoutSpy).toHaveBeenCalledWith(JSON.stringify({ response: '', stats: mockMetrics }, null, 2));
+        expect(processStdoutSpy).toHaveBeenCalledWith(JSON.stringify({ response: '', stats: MOCK_SESSION_METRICS }, null, 2));
     });
     it('should handle errors in JSON format', async () => {
         vi.mocked(mockConfig.getOutputFormat).mockReturnValue(OutputFormat.JSON);
@@ -524,7 +592,12 @@ describe('runNonInteractive', () => {
             .mockImplementation(() => { });
         let thrownError = null;
         try {
-            await runNonInteractive(mockConfig, mockSettings, 'Test input', 'prompt-id-error');
+            await runNonInteractive({
+                config: mockConfig,
+                settings: mockSettings,
+                input: 'Test input',
+                prompt_id: 'prompt-id-error',
+            });
             // Should not reach here
             expect.fail('Expected process.exit to be called');
         }
@@ -553,7 +626,12 @@ describe('runNonInteractive', () => {
             .mockImplementation(() => { });
         let thrownError = null;
         try {
-            await runNonInteractive(mockConfig, mockSettings, 'Invalid syntax', 'prompt-id-fatal');
+            await runNonInteractive({
+                config: mockConfig,
+                settings: mockSettings,
+                input: 'Invalid syntax',
+                prompt_id: 'prompt-id-fatal',
+            });
             // Should not reach here
             expect.fail('Expected process.exit to be called');
         }
@@ -588,10 +666,15 @@ describe('runNonInteractive', () => {
             },
         ];
         mockGeminiClient.sendMessageStream.mockReturnValue(createStreamFromEvents(events));
-        await runNonInteractive(mockConfig, mockSettings, '/testcommand', 'prompt-id-slash');
+        await runNonInteractive({
+            config: mockConfig,
+            settings: mockSettings,
+            input: '/testcommand',
+            prompt_id: 'prompt-id-slash',
+        });
         // Ensure the prompt sent to the model is from the command, not the raw input
         expect(mockGeminiClient.sendMessageStream).toHaveBeenCalledWith([{ text: 'Prompt from command' }], expect.any(AbortSignal), 'prompt-id-slash');
-        expect(processStdoutSpy).toHaveBeenCalledWith('Response from command');
+        expect(getWrittenOutput()).toBe('Response from command\n');
     });
     it('should throw FatalInputError if a command requires confirmation', async () => {
         const mockCommand = {
@@ -603,7 +686,12 @@ describe('runNonInteractive', () => {
             }),
         };
         mockGetCommands.mockReturnValue([mockCommand]);
-        await expect(runNonInteractive(mockConfig, mockSettings, '/confirm', 'prompt-id-confirm')).rejects.toThrow('Exiting due to a confirmation prompt requested by the command.');
+        await expect(runNonInteractive({
+            config: mockConfig,
+            settings: mockSettings,
+            input: '/confirm',
+            prompt_id: 'prompt-id-confirm',
+        })).rejects.toThrow('Exiting due to a confirmation prompt requested by the command.');
     });
     it('should treat an unknown slash command as a regular prompt', async () => {
         // No commands are mocked, so any slash command is "unknown"
@@ -616,10 +704,15 @@ describe('runNonInteractive', () => {
             },
         ];
         mockGeminiClient.sendMessageStream.mockReturnValue(createStreamFromEvents(events));
-        await runNonInteractive(mockConfig, mockSettings, '/unknowncommand', 'prompt-id-unknown');
+        await runNonInteractive({
+            config: mockConfig,
+            settings: mockSettings,
+            input: '/unknowncommand',
+            prompt_id: 'prompt-id-unknown',
+        });
         // Ensure the raw input is sent to the model
         expect(mockGeminiClient.sendMessageStream).toHaveBeenCalledWith([{ text: '/unknowncommand' }], expect.any(AbortSignal), 'prompt-id-unknown');
-        expect(processStdoutSpy).toHaveBeenCalledWith('Response to unknown');
+        expect(getWrittenOutput()).toBe('Response to unknown\n');
     });
     it('should throw for unhandled command result types', async () => {
         const mockCommand = {
@@ -630,7 +723,12 @@ describe('runNonInteractive', () => {
             }),
         };
         mockGetCommands.mockReturnValue([mockCommand]);
-        await expect(runNonInteractive(mockConfig, mockSettings, '/noaction', 'prompt-id-unhandled')).rejects.toThrow('Exiting due to command result that is not supported in non-interactive mode.');
+        await expect(runNonInteractive({
+            config: mockConfig,
+            settings: mockSettings,
+            input: '/noaction',
+            prompt_id: 'prompt-id-unhandled',
+        })).rejects.toThrow('Exiting due to command result that is not supported in non-interactive mode.');
     });
     it('should pass arguments to the slash command action', async () => {
         const mockAction = vi.fn().mockResolvedValue({
@@ -651,9 +749,14 @@ describe('runNonInteractive', () => {
             },
         ];
         mockGeminiClient.sendMessageStream.mockReturnValue(createStreamFromEvents(events));
-        await runNonInteractive(mockConfig, mockSettings, '/testargs arg1 arg2', 'prompt-id-args');
+        await runNonInteractive({
+            config: mockConfig,
+            settings: mockSettings,
+            input: '/testargs arg1 arg2',
+            prompt_id: 'prompt-id-args',
+        });
         expect(mockAction).toHaveBeenCalledWith(expect.any(Object), 'arg1 arg2');
-        expect(processStdoutSpy).toHaveBeenCalledWith('Acknowledged');
+        expect(getWrittenOutput()).toBe('Acknowledged\n');
     });
     it('should instantiate CommandService with correct loaders for slash commands', async () => {
         // This test indirectly checks that handleSlashCommand is using the right loaders.
@@ -668,7 +771,12 @@ describe('runNonInteractive', () => {
             },
         ];
         mockGeminiClient.sendMessageStream.mockReturnValue(createStreamFromEvents(events));
-        await runNonInteractive(mockConfig, mockSettings, '/mycommand', 'prompt-id-loaders');
+        await runNonInteractive({
+            config: mockConfig,
+            settings: mockSettings,
+            input: '/mycommand',
+            prompt_id: 'prompt-id-loaders',
+        });
         // Check that loaders were instantiated with the config
         expect(FileCommandLoader).toHaveBeenCalledTimes(1);
         expect(FileCommandLoader).toHaveBeenCalledWith(mockConfig);
@@ -733,9 +841,144 @@ describe('runNonInteractive', () => {
         mockGeminiClient.sendMessageStream
             .mockReturnValueOnce(createStreamFromEvents(firstCallEvents))
             .mockReturnValueOnce(createStreamFromEvents(secondCallEvents));
-        await runNonInteractive(mockConfig, mockSettings, 'List the files', 'prompt-id-allowed');
+        await runNonInteractive({
+            config: mockConfig,
+            settings: mockSettings,
+            input: 'List the files',
+            prompt_id: 'prompt-id-allowed',
+        });
         expect(mockCoreExecuteToolCall).toHaveBeenCalledWith(mockConfig, expect.objectContaining({ name: 'ShellTool' }), expect.any(AbortSignal));
-        expect(processStdoutSpy).toHaveBeenCalledWith('file.txt');
+        expect(getWrittenOutput()).toBe('file.txt\n');
+    });
+    describe('CoreEvents Integration', () => {
+        it('subscribes to UserFeedback and drains backlog on start', async () => {
+            const events = [
+                {
+                    type: GeminiEventType.Finished,
+                    value: { reason: undefined, usageMetadata: { totalTokenCount: 0 } },
+                },
+            ];
+            mockGeminiClient.sendMessageStream.mockReturnValue(createStreamFromEvents(events));
+            await runNonInteractive({
+                config: mockConfig,
+                settings: mockSettings,
+                input: 'test',
+                prompt_id: 'prompt-id-events',
+            });
+            expect(mockCoreEvents.on).toHaveBeenCalledWith(CoreEvent.UserFeedback, expect.any(Function));
+            expect(mockCoreEvents.drainFeedbackBacklog).toHaveBeenCalledTimes(1);
+        });
+        it('unsubscribes from UserFeedback on finish', async () => {
+            const events = [
+                {
+                    type: GeminiEventType.Finished,
+                    value: { reason: undefined, usageMetadata: { totalTokenCount: 0 } },
+                },
+            ];
+            mockGeminiClient.sendMessageStream.mockReturnValue(createStreamFromEvents(events));
+            await runNonInteractive({
+                config: mockConfig,
+                settings: mockSettings,
+                input: 'test',
+                prompt_id: 'prompt-id-events',
+            });
+            expect(mockCoreEvents.off).toHaveBeenCalledWith(CoreEvent.UserFeedback, expect.any(Function));
+        });
+        it('logs to process.stderr when UserFeedback event is received', async () => {
+            const events = [
+                {
+                    type: GeminiEventType.Finished,
+                    value: { reason: undefined, usageMetadata: { totalTokenCount: 0 } },
+                },
+            ];
+            mockGeminiClient.sendMessageStream.mockReturnValue(createStreamFromEvents(events));
+            await runNonInteractive({
+                config: mockConfig,
+                settings: mockSettings,
+                input: 'test',
+                prompt_id: 'prompt-id-events',
+            });
+            // Get the registered handler
+            const handler = mockCoreEvents.on.mock.calls.find((call) => call[0] === CoreEvent.UserFeedback)?.[1];
+            expect(handler).toBeDefined();
+            // Simulate an event
+            const payload = {
+                severity: 'error',
+                message: 'Test error message',
+            };
+            handler(payload);
+            expect(processStderrSpy).toHaveBeenCalledWith('[ERROR] Test error message\n');
+        });
+        it('logs optional error object to process.stderr in debug mode', async () => {
+            vi.mocked(mockConfig.getDebugMode).mockReturnValue(true);
+            const events = [
+                {
+                    type: GeminiEventType.Finished,
+                    value: { reason: undefined, usageMetadata: { totalTokenCount: 0 } },
+                },
+            ];
+            mockGeminiClient.sendMessageStream.mockReturnValue(createStreamFromEvents(events));
+            await runNonInteractive({
+                config: mockConfig,
+                settings: mockSettings,
+                input: 'test',
+                prompt_id: 'prompt-id-events',
+            });
+            // Get the registered handler
+            const handler = mockCoreEvents.on.mock.calls.find((call) => call[0] === CoreEvent.UserFeedback)?.[1];
+            expect(handler).toBeDefined();
+            // Simulate an event with error object
+            const errorObj = new Error('Original error');
+            // Mock stack for deterministic testing
+            errorObj.stack = 'Error: Original error\n    at test';
+            const payload = {
+                severity: 'warning',
+                message: 'Test warning message',
+                error: errorObj,
+            };
+            handler(payload);
+            expect(processStderrSpy).toHaveBeenCalledWith('[WARNING] Test warning message\n');
+            expect(processStderrSpy).toHaveBeenCalledWith('Error: Original error\n    at test\n');
+        });
+    });
+    it('should display a deprecation warning if hasDeprecatedPromptArg is true', async () => {
+        const events = [
+            { type: GeminiEventType.Content, value: 'Final Answer' },
+            {
+                type: GeminiEventType.Finished,
+                value: { reason: undefined, usageMetadata: { totalTokenCount: 10 } },
+            },
+        ];
+        mockGeminiClient.sendMessageStream.mockReturnValue(createStreamFromEvents(events));
+        await runNonInteractive({
+            config: mockConfig,
+            settings: mockSettings,
+            input: 'Test input',
+            prompt_id: 'prompt-id-deprecated',
+            hasDeprecatedPromptArg: true,
+        });
+        expect(processStderrSpy).toHaveBeenCalledWith('The --prompt (-p) flag has been deprecated and will be removed in a future version. Please use a positional argument for your prompt. See gemini --help for more information.\n');
+        expect(processStdoutSpy).toHaveBeenCalledWith('Final Answer');
+    });
+    it('should display a deprecation warning for JSON format', async () => {
+        const events = [
+            { type: GeminiEventType.Content, value: 'Final Answer' },
+            {
+                type: GeminiEventType.Finished,
+                value: { reason: undefined, usageMetadata: { totalTokenCount: 10 } },
+            },
+        ];
+        mockGeminiClient.sendMessageStream.mockReturnValue(createStreamFromEvents(events));
+        vi.mocked(mockConfig.getOutputFormat).mockReturnValue(OutputFormat.JSON);
+        await runNonInteractive({
+            config: mockConfig,
+            settings: mockSettings,
+            input: 'Test input',
+            prompt_id: 'prompt-id-deprecated-json',
+            hasDeprecatedPromptArg: true,
+        });
+        const deprecateText = 'The --prompt (-p) flag has been deprecated and will be removed in a future version. Please use a positional argument for your prompt. See gemini --help for more information.\n';
+        expect(processStderrSpy).toHaveBeenCalledWith(deprecateText);
     });
 });
 //# sourceMappingURL=nonInteractiveCli.test.js.map