@google/gemini-cli-core 0.37.0-preview.1 → 0.38.0-preview.0

package/dist/src/agents/local-executor.test.js

@@ -35,7 +35,7 @@ import { PromptRegistry } from '../prompts/prompt-registry.js';
 import { ResourceRegistry } from '../resources/resource-registry.js';
 import { DiscoveredMCPTool } from '../tools/mcp-tool.js';
 import { LSTool } from '../tools/ls.js';
-import { LS_TOOL_NAME, READ_FILE_TOOL_NAME } from '../tools/tool-names.js';
+import { COMPLETE_TASK_TOOL_NAME, LS_TOOL_NAME, READ_FILE_TOOL_NAME, } from '../tools/tool-names.js';
 import { GeminiChat, StreamEventType, } from '../core/geminiChat.js';
 import {} from '@google/genai';
 import { MockTool } from '../test-utils/mock-tool.js';
@@ -113,6 +113,17 @@ vi.mock('../utils/promptIdContext.js', async (importOriginal) => {
         },
     };
 });
+vi.mock('../config/scoped-config.js', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        runWithScopedWorkspaceContext: vi.fn(actual.runWithScopedWorkspaceContext),
+        createScopedWorkspaceContext: vi.fn(actual.createScopedWorkspaceContext),
+    };
+});
+import { runWithScopedWorkspaceContext, createScopedWorkspaceContext, } from '../config/scoped-config.js';
+const mockedRunWithScopedWorkspaceContext = vi.mocked(runWithScopedWorkspaceContext);
+const mockedCreateScopedWorkspaceContext = vi.mocked(createScopedWorkspaceContext);
 const MockedGeminiChat = vi.mocked(GeminiChat);
 const mockedGetDirectoryContextString = vi.mocked(getDirectoryContextString);
 const mockedPromptIdContext = vi.mocked(promptIdContext);
@@ -120,8 +131,31 @@ const mockedLogAgentStart = vi.mocked(logAgentStart);
 const mockedLogAgentFinish = vi.mocked(logAgentFinish);
 const mockedLogRecoveryAttempt = vi.mocked(logRecoveryAttempt);
 // Constants for testing
-const TASK_COMPLETE_TOOL_NAME = 'complete_task';
 const MOCK_TOOL_NOT_ALLOWED = new MockTool({ name: 'write_file_interactive' });
+/**
+ * Helper to mock a successful completion result from the scheduler.
+ */
+const mockCompletionResult = (callId, submittedOutput, toolName = COMPLETE_TASK_TOOL_NAME) => {
+    mockScheduleAgentTools.mockResolvedValueOnce([
+        {
+            status: 'success',
+            request: {
+                callId,
+                name: toolName,
+                args: {},
+                prompt_id: 'test-prompt',
+            },
+            response: {
+                resultDisplay: 'Task completed.',
+                responseParts: [],
+                data: {
+                    taskCompleted: true,
+                    submittedOutput,
+                },
+            },
+        },
+    ]);
+};
 /**
  * Helper to create a mock API response chunk.
  * Uses conditional spread to handle readonly functionCalls property safely.
@@ -212,11 +246,50 @@ describe('LocalAgentExecutor', () => {
         vi.resetAllMocks();
         mockCompress.mockClear();
         mockSetHistory.mockClear();
-        mockSendMessageStream.mockReset();
+        mockSendMessageStream.mockReset().mockResolvedValue({
+            async *[Symbol.asyncIterator]() {
+                yield {
+                    type: StreamEventType.CHUNK,
+                    value: { candidates: [] },
+                };
+            },
+        });
         mockSetSystemInstruction.mockReset();
-        mockScheduleAgentTools.mockReset();
+        mockScheduleAgentTools
+            .mockReset()
+            .mockImplementation(async (_config, requests) => 
+        // Default mock behavior for scheduleAgentTools
+        requests.map((req) => {
+            if (req.name === COMPLETE_TASK_TOOL_NAME) {
+                return {
+                    status: 'success',
+                    request: req,
+                    response: {
+                        resultDisplay: 'Task completed.',
+                        responseParts: [],
+                        data: {
+                            taskCompleted: true,
+                            submittedOutput: req.args['finalResult'] ||
+                                req.args['result'] ||
+                                JSON.stringify(req.args),
+                        },
+                    },
+                };
+            }
+            return {
+                status: 'success',
+                request: req,
+                response: {
+                    resultDisplay: 'Mock tool executed',
+                    responseParts: [],
+                    data: {},
+                },
+            };
+        }));
         mockedLogAgentStart.mockReset();
         mockedLogAgentFinish.mockReset();
+        mockedRunWithScopedWorkspaceContext.mockClear();
+        mockedCreateScopedWorkspaceContext.mockClear();
         mockedPromptIdContext.getStore.mockReset();
         mockedPromptIdContext.run.mockImplementation((_id, fn) => fn());
         ChatCompressionService.mockImplementation(() => ({
@@ -281,7 +354,7 @@ describe('LocalAgentExecutor', () => {
             const executor = await LocalAgentExecutor.create(definition, extendedContext, onActivity);
             mockModelResponse([
                 {
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     args: { finalResult: 'done' },
                     id: 'call1',
                 },
@@ -336,7 +409,7 @@ describe('LocalAgentExecutor', () => {
             const executor = await LocalAgentExecutor.create(definition, context);
             mockModelResponse([
                 {
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     args: { finalResult: 'done' },
                     id: 'call1',
                 },
@@ -374,7 +447,7 @@ describe('LocalAgentExecutor', () => {
             const executor = await LocalAgentExecutor.create(definition, context);
             mockModelResponse([
                 {
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     args: { finalResult: 'done' },
                     id: 'call1',
                 },
@@ -403,8 +476,12 @@ describe('LocalAgentExecutor', () => {
             const executor = await LocalAgentExecutor.create(definition, mockConfig, onActivity);
             const agentRegistry = executor['toolRegistry'];
             expect(agentRegistry).not.toBe(parentToolRegistry);
-            expect(agentRegistry.getAllToolNames()).toEqual(expect.arrayContaining([LS_TOOL_NAME, READ_FILE_TOOL_NAME]));
-            expect(agentRegistry.getAllToolNames()).toHaveLength(2);
+            expect(agentRegistry.getAllToolNames()).toEqual(expect.arrayContaining([
+                LS_TOOL_NAME,
+                READ_FILE_TOOL_NAME,
+                COMPLETE_TASK_TOOL_NAME,
+            ]));
+            expect(agentRegistry.getAllToolNames()).toHaveLength(3);
             expect(agentRegistry.getTool(MOCK_TOOL_NOT_ALLOWED.name)).toBeUndefined();
         });
         it('should use parentPromptId from context to create agentId', async () => {
@@ -430,7 +507,7 @@ describe('LocalAgentExecutor', () => {
             // Mock a response to prevent the loop from running forever
             mockModelResponse([
                 {
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     args: { finalResult: 'done' },
                     id: 'call1',
                 },
@@ -536,6 +613,39 @@ describe('LocalAgentExecutor', () => {
             expect(toolNames).toContain(LS_TOOL_NAME);
         });
     });
+    describe('run (Workspace Scoping)', () => {
+        it('should use runWithScopedWorkspaceContext when workspaceDirectories is set', async () => {
+            const definition = createTestDefinition();
+            definition.workspaceDirectories = ['/tmp/extra-dir'];
+            const executor = await LocalAgentExecutor.create(definition, mockConfig, onActivity);
+            // Mock a simple complete_task response so run() terminates
+            mockModelResponse([
+                {
+                    name: COMPLETE_TASK_TOOL_NAME,
+                    args: { finalResult: 'done' },
+                    id: 'c1',
+                },
+            ]);
+            await executor.run({ goal: 'test' }, signal);
+            expect(mockedCreateScopedWorkspaceContext).toHaveBeenCalledOnce();
+            expect(mockedRunWithScopedWorkspaceContext).toHaveBeenCalledOnce();
+        });
+        it('should not use runWithScopedWorkspaceContext when workspaceDirectories is not set', async () => {
+            const definition = createTestDefinition();
+            const executor = await LocalAgentExecutor.create(definition, mockConfig, onActivity);
+            // Mock a simple complete_task response so run() terminates
+            mockModelResponse([
+                {
+                    name: COMPLETE_TASK_TOOL_NAME,
+                    args: { finalResult: 'done' },
+                    id: 'c1',
+                },
+            ]);
+            await executor.run({ goal: 'test' }, signal);
+            expect(mockedCreateScopedWorkspaceContext).not.toHaveBeenCalled();
+            expect(mockedRunWithScopedWorkspaceContext).not.toHaveBeenCalled();
+        });
+    });
     describe('run (Execution Loop and Logic)', () => {
         it('should log AgentFinish with error if run throws', async () => {
             const definition = createTestDefinition();
@@ -595,15 +705,43 @@ describe('LocalAgentExecutor', () => {
             // Turn 2: Model calls complete_task with required output
             mockModelResponse([
                 {
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     args: { finalResult: 'Found file1.txt' },
                     id: 'call2',
                 },
             ], 'T2: Done');
+            mockScheduleAgentTools.mockResolvedValueOnce([
+                {
+                    status: 'success',
+                    request: {
+                        callId: 'call2',
+                        name: COMPLETE_TASK_TOOL_NAME,
+                        args: { finalResult: 'Found file1.txt' },
+                        prompt_id: 'p1',
+                    },
+                    response: {
+                        resultDisplay: 'Output submitted and task completed.',
+                        responseParts: [
+                            {
+                                functionResponse: {
+                                    name: COMPLETE_TASK_TOOL_NAME,
+                                    id: 'call2',
+                                    response: { result: 'Output submitted and task completed.' },
+                                },
+                            },
+                        ],
+                        data: {
+                            taskCompleted: true,
+                            submittedOutput: 'Found file1.txt',
+                        },
+                    },
+                },
+            ]);
             const output = await executor.run(inputs, signal);
             expect(mockSendMessageStream).toHaveBeenCalledTimes(2);
+            expect(mockScheduleAgentTools).toHaveBeenCalledTimes(2);
             const systemInstruction = MockedGeminiChat.mock.calls[0][1];
-            expect(systemInstruction).toContain(`MUST call the \`${TASK_COMPLETE_TOOL_NAME}\` tool`);
+            expect(systemInstruction).toContain(`MUST call the \`${COMPLETE_TASK_TOOL_NAME}\` tool`);
             expect(systemInstruction).toContain('Mocked Environment Context');
             expect(systemInstruction).toContain('You are running in a non-interactive mode');
             expect(systemInstruction).toContain('Always use absolute paths');
@@ -616,10 +754,11 @@ describe('LocalAgentExecutor', () => {
             expect(sentTools).toBeDefined();
             expect(sentTools).toEqual(expect.arrayContaining([
                 expect.objectContaining({ name: LS_TOOL_NAME }),
-                expect.objectContaining({ name: TASK_COMPLETE_TOOL_NAME }),
+                expect.objectContaining({ name: COMPLETE_TASK_TOOL_NAME }),
             ]));
-            const completeToolDef = sentTools.find((t) => t.name === TASK_COMPLETE_TOOL_NAME);
-            expect(completeToolDef?.parameters?.required).toContain('finalResult');
+            const completeToolDef = sentTools.find((t) => t.name === COMPLETE_TASK_TOOL_NAME);
+            const completeSchema = completeToolDef?.parametersJsonSchema;
+            expect(completeSchema?.['required']).toContain('finalResult');
             expect(output.result).toBe('Found file1.txt');
             expect(output.terminate_reason).toBe(AgentTerminateMode.GOAL);
             // Telemetry checks
@@ -632,8 +771,8 @@ describe('LocalAgentExecutor', () => {
             // Context checks
             expect(mockedPromptIdContext.run).toHaveBeenCalledTimes(2); // Two turns
             // Recording checks
-            expect(mockRecordCompletedToolCalls).toHaveBeenCalledTimes(1);
-            expect(mockRecordCompletedToolCalls).toHaveBeenCalledWith(expect.any(String), // model
+            expect(mockRecordCompletedToolCalls).toHaveBeenCalledTimes(2);
+            expect(mockRecordCompletedToolCalls).toHaveBeenNthCalledWith(1, expect.any(String), // model
             expect.arrayContaining([
                 expect.objectContaining({
                     status: 'success',
@@ -660,14 +799,14 @@ describe('LocalAgentExecutor', () => {
                 expect.objectContaining({
                     type: 'TOOL_CALL_START',
                     data: expect.objectContaining({
-                        name: TASK_COMPLETE_TOOL_NAME,
+                        name: COMPLETE_TASK_TOOL_NAME,
                         args: { finalResult: 'Found file1.txt' },
                     }),
                 }),
                 expect.objectContaining({
                     type: 'TOOL_CALL_END',
                     data: expect.objectContaining({
-                        name: TASK_COMPLETE_TOOL_NAME,
+                        name: COMPLETE_TASK_TOOL_NAME,
                         output: expect.stringContaining('Output submitted'),
                     }),
                 }),
@@ -711,11 +850,12 @@ describe('LocalAgentExecutor', () => {
             ]);
             mockModelResponse([
                 {
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     args: { result: 'All work done' },
                     id: 'call2',
                 },
             ], 'Task finished.');
+            mockCompletionResult('call2', 'All work done');
             const output = await executor.run({ goal: 'Do work' }, signal);
             const { modelConfigKey } = getMockMessageParams(0);
             expect(modelConfigKey.model).toBe(getModelConfigAlias(definition));
@@ -723,11 +863,13 @@ describe('LocalAgentExecutor', () => {
             const passedToolsArg = chatConstructorArgs[2];
             const sentTools = passedToolsArg[0].functionDeclarations;
             expect(sentTools).toBeDefined();
-            const completeToolDef = sentTools.find((t) => t.name === TASK_COMPLETE_TOOL_NAME);
-            expect(completeToolDef?.parameters?.required).toEqual(['result']);
+            const completeToolDef = sentTools.find((t) => t.name === COMPLETE_TASK_TOOL_NAME);
+            const schema = completeToolDef?.parametersJsonSchema;
+            expect(schema?.['required']).toContain('result');
             expect(completeToolDef?.description).toContain('submit your final findings');
             expect(output.result).toBe('All work done');
             expect(output.terminate_reason).toBe(AgentTerminateMode.GOAL);
+            expect(mockScheduleAgentTools).toHaveBeenCalledTimes(2);
         });
         it('should error immediately if the model stops tools without calling complete_task (Protocol Violation)', async () => {
             const definition = createTestDefinition();
@@ -771,7 +913,7 @@ describe('LocalAgentExecutor', () => {
             mockModelResponse([], 'I still give up.');
             const output = await executor.run({ goal: 'Strict test' }, signal);
             expect(mockSendMessageStream).toHaveBeenCalledTimes(3);
-            const expectedError = `Agent stopped calling tools but did not call '${TASK_COMPLETE_TOOL_NAME}'.`;
+            const expectedError = `Agent stopped calling tools but did not call '${COMPLETE_TASK_TOOL_NAME}'.`;
             expect(output.terminate_reason).toBe(AgentTerminateMode.ERROR_NO_COMPLETE_TASK_CALL);
             expect(output.result).toBe(expectedError);
             // Telemetry check for error
@@ -793,27 +935,59 @@ describe('LocalAgentExecutor', () => {
             // Turn 1: Missing arg
             mockModelResponse([
                 {
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     args: { wrongArg: 'oops' },
                     id: 'call1',
                 },
             ]);
+            // Mock failure in scheduler for Turn 1
+            mockScheduleAgentTools.mockResolvedValueOnce([
+                {
+                    status: 'error',
+                    request: {
+                        callId: 'call1',
+                        name: COMPLETE_TASK_TOOL_NAME,
+                        args: { wrongArg: 'oops' },
+                        prompt_id: 'p1',
+                    },
+                    response: {
+                        resultDisplay: 'Error',
+                        responseParts: [
+                            {
+                                functionResponse: {
+                                    name: COMPLETE_TASK_TOOL_NAME,
+                                    id: 'call1',
+                                    response: {
+                                        error: "Missing required argument 'finalResult' for completion.",
+                                    },
+                                },
+                            },
+                        ],
+                        error: {
+                            message: "Missing required argument 'finalResult' for completion.",
+                            type: 'INVALID_TOOL_PARAMS',
+                        },
+                    },
+                },
+            ]);
             // Turn 2: Corrected
             mockModelResponse([
                 {
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     args: { finalResult: 'Corrected result' },
                     id: 'call2',
                 },
             ]);
+            mockCompletionResult('call2', 'Corrected result');
             const output = await executor.run({ goal: 'Error test' }, signal);
             expect(mockSendMessageStream).toHaveBeenCalledTimes(2);
+            expect(mockScheduleAgentTools).toHaveBeenCalledTimes(2);
             const expectedError = "Missing required argument 'finalResult' for completion.";
             expect(activities).toContainEqual(expect.objectContaining({
                 type: 'ERROR',
                 data: expect.objectContaining({
                     context: 'tool_call',
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     error: expectedError,
                     errorType: SubagentActivityErrorType.GENERIC,
                 }),
@@ -824,7 +998,7 @@ describe('LocalAgentExecutor', () => {
             expect(turn2Parts).toHaveLength(1);
             expect(turn2Parts[0]).toEqual(expect.objectContaining({
                 functionResponse: expect.objectContaining({
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     response: { error: expectedError },
                     id: 'call1',
                 }),
@@ -832,31 +1006,61 @@ describe('LocalAgentExecutor', () => {
             expect(output.result).toBe('Corrected result');
             expect(output.terminate_reason).toBe(AgentTerminateMode.GOAL);
         });
-        it('should handle multiple calls to complete_task in the same turn (accept first, block rest)', async () => {
+        it('should handle multiple calls to complete_task in the same turn', async () => {
             const definition = createTestDefinition([], {}, 'none');
             const executor = await LocalAgentExecutor.create(definition, mockConfig, onActivity);
             // Turn 1: Duplicate calls
             mockModelResponse([
                 {
-                    name: TASK_COMPLETE_TOOL_NAME,
-                    args: { result: 'done' },
+                    name: COMPLETE_TASK_TOOL_NAME,
+                    args: { result: 'first' },
                     id: 'call1',
                 },
                 {
-                    name: TASK_COMPLETE_TOOL_NAME,
-                    args: { result: 'ignored' },
+                    name: COMPLETE_TASK_TOOL_NAME,
+                    args: { result: 'second' },
                     id: 'call2',
                 },
             ]);
+            mockScheduleAgentTools.mockResolvedValueOnce([
+                {
+                    status: 'success',
+                    request: {
+                        callId: 'call1',
+                        name: COMPLETE_TASK_TOOL_NAME,
+                        args: { result: 'first' },
+                        prompt_id: 'p1',
+                    },
+                    response: {
+                        resultDisplay: 'ok',
+                        responseParts: [],
+                        data: { taskCompleted: true, submittedOutput: 'first' },
+                    },
+                },
+                {
+                    status: 'success',
+                    request: {
+                        callId: 'call2',
+                        name: COMPLETE_TASK_TOOL_NAME,
+                        args: { result: 'second' },
+                        prompt_id: 'p1',
+                    },
+                    response: {
+                        resultDisplay: 'ok',
+                        responseParts: [],
+                        data: { taskCompleted: true, submittedOutput: 'second' },
+                    },
+                },
+            ]);
             const output = await executor.run({ goal: 'Dup test' }, signal);
             expect(mockSendMessageStream).toHaveBeenCalledTimes(1);
+            expect(mockScheduleAgentTools).toHaveBeenCalledTimes(1);
             expect(output.terminate_reason).toBe(AgentTerminateMode.GOAL);
+            // In current impl, the first successful complete_task in the batch is respected.
+            expect(output.result).toBe('first');
             const completions = activities.filter((a) => a.type === 'TOOL_CALL_END' &&
-                a.data['name'] === TASK_COMPLETE_TOOL_NAME);
-            const errors = activities.filter((a) => a.type === 'ERROR' && a.data['name'] === TASK_COMPLETE_TOOL_NAME);
-            expect(completions).toHaveLength(1);
-            expect(errors).toHaveLength(1);
-            expect(errors[0].data['error']).toContain('Task already marked complete in this turn');
+                a.data['name'] === COMPLETE_TASK_TOOL_NAME);
+            expect(completions).toHaveLength(2);
         });
         it('should execute parallel tool calls and then complete', async () => {
             const definition = createTestDefinition([LS_TOOL_NAME]);
@@ -881,39 +1085,57 @@ describe('LocalAgentExecutor', () => {
             });
             mockScheduleAgentTools.mockImplementation(async (_ctx, requests) => {
                 const results = await Promise.all(requests.map(async (reqInfo) => {
-                    callsStarted++;
-                    if (callsStarted === 2)
-                        resolveCalls();
-                    await vi.advanceTimersByTimeAsync(100);
-                    return {
-                        status: CoreToolCallStatus.Success,
-                        request: reqInfo,
-                        tool: {},
-                        invocation: {},
-                        response: {
-                            callId: reqInfo.callId,
-                            resultDisplay: 'ok',
-                            responseParts: [
-                                {
-                                    functionResponse: {
-                                        name: reqInfo.name,
-                                        response: {},
-                                        id: reqInfo.callId,
+                    if (reqInfo.name === LS_TOOL_NAME) {
+                        callsStarted++;
+                        if (callsStarted === 2)
+                            resolveCalls();
+                        await vi.advanceTimersByTimeAsync(100);
+                        return {
+                            status: CoreToolCallStatus.Success,
+                            request: reqInfo,
+                            tool: {},
+                            invocation: {},
+                            response: {
+                                callId: reqInfo.callId,
+                                resultDisplay: 'ok',
+                                responseParts: [
+                                    {
+                                        functionResponse: {
+                                            name: reqInfo.name,
+                                            response: {},
+                                            id: reqInfo.callId,
+                                        },
                                     },
+                                ],
+                                error: undefined,
+                                errorType: undefined,
+                                contentLength: 0,
+                            },
+                        };
+                    }
+                    else if (reqInfo.name === COMPLETE_TASK_TOOL_NAME) {
+                        return {
+                            status: CoreToolCallStatus.Success,
+                            request: reqInfo,
+                            response: {
+                                callId: reqInfo.callId,
+                                resultDisplay: 'Task completed.',
+                                responseParts: [],
+                                data: {
+                                    taskCompleted: true,
+                                    submittedOutput: reqInfo.args['finalResult'],
                                 },
-                            ],
-                            error: undefined,
-                            errorType: undefined,
-                            contentLength: 0,
-                        },
-                    };
+                            },
+                        };
+                    }
+                    throw new Error(`Unexpected tool: ${reqInfo.name}`);
                 }));
                 return results;
             });
             // Turn 2: Completion
             mockModelResponse([
                 {
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     args: { finalResult: 'done' },
                     id: 'c3',
                 },
@@ -924,7 +1146,7 @@ describe('LocalAgentExecutor', () => {
             await vi.advanceTimersByTimeAsync(150);
             await vi.advanceTimersByTimeAsync(1);
             const output = await runPromise;
-            expect(mockScheduleAgentTools).toHaveBeenCalledTimes(1);
+            expect(mockScheduleAgentTools).toHaveBeenCalledTimes(2);
             expect(output.terminate_reason).toBe(AgentTerminateMode.GOAL);
             // Safe access to message parts
             const turn2Params = getMockMessageParams(1);
@@ -955,7 +1177,7 @@ describe('LocalAgentExecutor', () => {
             // Turn 2: Model gives up and completes
             mockModelResponse([
                 {
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     args: { finalResult: 'Could not read file.' },
                     id: 'c2',
                 },
@@ -963,9 +1185,28 @@ describe('LocalAgentExecutor', () => {
             const consoleWarnSpy = vi
                 .spyOn(debugLogger, 'warn')
                 .mockImplementation(() => { });
+            mockScheduleAgentTools.mockResolvedValueOnce([
+                {
+                    status: 'success',
+                    request: {
+                        callId: 'c2',
+                        name: COMPLETE_TASK_TOOL_NAME,
+                        args: { finalResult: 'Could not read file.' },
+                        prompt_id: 'p2',
+                    },
+                    response: {
+                        resultDisplay: 'Output submitted and task completed.',
+                        responseParts: [],
+                        data: {
+                            taskCompleted: true,
+                            submittedOutput: 'Could not read file.',
+                        },
+                    },
+                },
+            ]);
             await executor.run({ goal: 'Sec test' }, signal);
-            // Verify external executor was not called (Security held)
-            expect(mockScheduleAgentTools).not.toHaveBeenCalled();
+            // Verify external executor was called exactly once (for complete_task)
+            expect(mockScheduleAgentTools).toHaveBeenCalledTimes(1);
             // 2. Verify console warning
             expect(consoleWarnSpy).toHaveBeenCalledWith(expect.stringContaining(`[LocalAgentExecutor] Blocked call:`));
             consoleWarnSpy.mockRestore();
@@ -1000,28 +1241,53 @@ describe('LocalAgentExecutor', () => {
             // Turn 1: Invalid arg (too short)
             mockModelResponse([
                 {
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     args: { finalResult: 'short' },
                     id: 'call1',
                 },
             ]);
+            const expectedError = 'Output validation failed: {"formErrors":["String must contain at least 10 character(s)"],"fieldErrors":{}}';
+            mockScheduleAgentTools.mockResolvedValueOnce([
+                {
+                    status: 'error',
+                    request: {
+                        callId: 'call1',
+                        name: COMPLETE_TASK_TOOL_NAME,
+                        args: { finalResult: 'short' },
+                        prompt_id: 'p1',
+                    },
+                    response: {
+                        resultDisplay: expectedError,
+                        responseParts: [
+                            {
+                                functionResponse: {
+                                    name: COMPLETE_TASK_TOOL_NAME,
+                                    id: 'call1',
+                                    response: { error: expectedError },
+                                },
+                            },
+                        ],
+                        data: { taskCompleted: false },
+                        error: new Error(expectedError),
+                    },
+                },
+            ]);
             // Turn 2: Corrected
             mockModelResponse([
                 {
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     args: { finalResult: 'This is a much longer and valid result' },
                     id: 'call2',
                 },
             ]);
             const output = await executor.run({ goal: 'Validation test' }, signal);
             expect(mockSendMessageStream).toHaveBeenCalledTimes(2);
-            const expectedError = 'Output validation failed: {"formErrors":["String must contain at least 10 character(s)"],"fieldErrors":{}}';
             // Check that the error was reported in the activity stream
             expect(activities).toContainEqual(expect.objectContaining({
                 type: 'ERROR',
                 data: expect.objectContaining({
                     context: 'tool_call',
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     error: expect.stringContaining('Output validation failed'),
                     errorType: SubagentActivityErrorType.GENERIC,
                 }),
@@ -1032,7 +1298,7 @@ describe('LocalAgentExecutor', () => {
             expect(turn2Parts).toEqual([
                 expect.objectContaining({
                     functionResponse: expect.objectContaining({
-                        name: TASK_COMPLETE_TOOL_NAME,
+                        name: COMPLETE_TASK_TOOL_NAME,
                         response: { error: expectedError },
                         id: 'call1',
                     }),
@@ -1105,13 +1371,32 @@ describe('LocalAgentExecutor', () => {
             // Turn 2: Model sees the error and completes
             mockModelResponse([
                 {
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     args: { finalResult: 'Aborted due to tool failure.' },
                     id: 'call2',
                 },
             ]);
+            mockScheduleAgentTools.mockResolvedValueOnce([
+                {
+                    status: 'success',
+                    request: {
+                        callId: 'call2',
+                        name: COMPLETE_TASK_TOOL_NAME,
+                        args: { finalResult: 'Aborted due to tool failure.' },
+                        prompt_id: 'p2',
+                    },
+                    response: {
+                        resultDisplay: 'Task completed.',
+                        responseParts: [],
+                        data: {
+                            taskCompleted: true,
+                            submittedOutput: 'Aborted due to tool failure.',
+                        },
+                    },
+                },
+            ]);
             const output = await executor.run({ goal: 'Tool failure test' }, signal);
-            expect(mockScheduleAgentTools).toHaveBeenCalledTimes(1);
+            expect(mockScheduleAgentTools).toHaveBeenCalledTimes(2);
             expect(mockSendMessageStream).toHaveBeenCalledTimes(2);
             // Verify the error was reported in the activity stream
             expect(activities).toContainEqual(expect.objectContaining({
@@ -1183,7 +1468,7 @@ describe('LocalAgentExecutor', () => {
             // Turn 2: Model sees the rejection + consolidated instructions and completes
             mockModelResponse([
                 {
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     args: { finalResult: 'User rejected access to /secret.' },
                     id: 'call2',
                 },
@@ -1283,7 +1568,7 @@ describe('LocalAgentExecutor', () => {
             const executor = await LocalAgentExecutor.create(definition, mockConfig, onActivity);
             mockModelResponse([
                 {
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     args: { finalResult: 'done' },
                     id: 'call1',
                 },
@@ -1307,7 +1592,7 @@ describe('LocalAgentExecutor', () => {
             const executor = await LocalAgentExecutor.create(definition, mockConfig, onActivity);
             mockModelResponse([
                 {
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     args: { finalResult: 'done' },
                     id: 'call1',
                 },
@@ -1487,7 +1772,7 @@ describe('LocalAgentExecutor', () => {
             // Recovery Turn (succeeds)
             mockModelResponse([
                 {
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     args: { finalResult: 'Recovered!' },
                     id: 't2',
                 },
@@ -1542,7 +1827,7 @@ describe('LocalAgentExecutor', () => {
             // Turn 3: Recovery turn (succeeds)
             mockModelResponse([
                 {
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     args: { finalResult: 'Recovered from violation!' },
                     id: 't3',
                 },
@@ -1570,7 +1855,7 @@ describe('LocalAgentExecutor', () => {
             const output = await executor.run({ goal: 'Violation recovery fail' }, signal);
             expect(mockSendMessageStream).toHaveBeenCalledTimes(3);
             expect(output.terminate_reason).toBe(AgentTerminateMode.ERROR_NO_COMPLETE_TASK_CALL);
-            expect(output.result).toContain(`Agent stopped calling tools but did not call '${TASK_COMPLETE_TOOL_NAME}'`);
+            expect(output.result).toContain(`Agent stopped calling tools but did not call '${COMPLETE_TASK_TOOL_NAME}'`);
             expect(activities).toContainEqual(expect.objectContaining({
                 type: 'ERROR',
                 data: expect.objectContaining({
@@ -1599,7 +1884,7 @@ describe('LocalAgentExecutor', () => {
             // Recovery turn (succeeds)
             mockModelResponse([
                 {
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     args: { finalResult: 'Recovered from timeout!' },
                     id: 't2',
                 },
@@ -1721,7 +2006,7 @@ describe('LocalAgentExecutor', () => {
             // Recovery Turn (succeeds)
             mockModelResponse([
                 {
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     args: { finalResult: 'Recovered!' },
                     id: 't2',
                 },
@@ -1759,7 +2044,7 @@ describe('LocalAgentExecutor', () => {
                 // Turn 2: Model calls complete_task
                 mockModelResponse([
                     {
-                        name: TASK_COMPLETE_TOOL_NAME,
+                        name: COMPLETE_TASK_TOOL_NAME,
                         args: { finalResult: 'Done' },
                         id: 'call2',
                     },
@@ -1811,7 +2096,7 @@ describe('LocalAgentExecutor', () => {
                 const executor = await LocalAgentExecutor.create(definition, configWithHints);
                 mockModelResponse([
                     {
-                        name: TASK_COMPLETE_TOOL_NAME,
+                        name: COMPLETE_TASK_TOOL_NAME,
                         args: { finalResult: 'Done' },
                         id: 'call1',
                     },
@@ -1841,7 +2126,7 @@ describe('LocalAgentExecutor', () => {
                 // Turn 2: Model calls complete_task
                 mockModelResponse([
                     {
-                        name: TASK_COMPLETE_TOOL_NAME,
+                        name: COMPLETE_TASK_TOOL_NAME,
                         args: { finalResult: 'Done' },
                         id: 'call2',
                     },
@@ -1909,7 +2194,7 @@ describe('LocalAgentExecutor', () => {
                 mockScheduleAgentTools.mockReturnValueOnce(toolCallPromise);
                 mockModelResponse([
                     {
-                        name: TASK_COMPLETE_TOOL_NAME,
+                        name: COMPLETE_TASK_TOOL_NAME,
                         args: { finalResult: 'Done' },
                         id: 'call2',
                     },
@@ -1964,7 +2249,7 @@ describe('LocalAgentExecutor', () => {
                 mockScheduleAgentTools.mockReturnValueOnce(toolCallPromise);
                 mockModelResponse([
                     {
-                        name: TASK_COMPLETE_TOOL_NAME,
+                        name: COMPLETE_TASK_TOOL_NAME,
                         args: { finalResult: 'Done' },
                         id: 'call2',
                     },
@@ -2018,7 +2303,7 @@ describe('LocalAgentExecutor', () => {
                 expect(configWithHints.injectionService.getInjections('background_completion')).toEqual(['bg output']);
                 mockModelResponse([
                     {
-                        name: TASK_COMPLETE_TOOL_NAME,
+                        name: COMPLETE_TASK_TOOL_NAME,
                         args: { finalResult: 'Done' },
                         id: 'call1',
                     },
@@ -2074,7 +2359,7 @@ describe('LocalAgentExecutor', () => {
             // Turn 2: Complete
             mockModelResponse([
                 {
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     args: { finalResult: 'Done' },
                     id: 'call2',
                 },
@@ -2095,7 +2380,7 @@ describe('LocalAgentExecutor', () => {
             // Turn 1: Complete
             mockModelResponse([
                 {
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     args: { finalResult: 'Done' },
                     id: 'call1',
                 },
@@ -2125,7 +2410,7 @@ describe('LocalAgentExecutor', () => {
             // Turn 2: Complete
             mockModelResponse([
                 {
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     args: { finalResult: 'Done' },
                     id: 't2',
                 },
@@ -2167,7 +2452,7 @@ describe('LocalAgentExecutor', () => {
             // Turn 3: Complete
             mockModelResponse([
                 {
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     args: { finalResult: 'Done' },
                     id: 't3',
                 },
@@ -2283,7 +2568,7 @@ describe('LocalAgentExecutor', () => {
             ]);
             mockModelResponse([
                 {
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     args: { finalResult: 'done' },
                     id: 'c1',
                 },
@@ -2342,7 +2627,7 @@ describe('LocalAgentExecutor', () => {
             };
             mockModelResponse([
                 {
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     args: { finalResult: 'ok' },
                     id: 'c1',
                 },
@@ -2353,7 +2638,7 @@ describe('LocalAgentExecutor', () => {
             const names = declarations.map((d) => d.name);
             expect(names.filter((n) => n === LS_TOOL_NAME)).toHaveLength(1);
             expect(names.filter((n) => n === 'fill')).toHaveLength(1);
-            expect(names.filter((n) => n === TASK_COMPLETE_TOOL_NAME)).toHaveLength(1);
+            expect(names.filter((n) => n === COMPLETE_TASK_TOOL_NAME)).toHaveLength(1);
             // Total = ls + fill + complete_task
             expect(declarations).toHaveLength(3);
         });
@@ -2401,7 +2686,7 @@ describe('LocalAgentExecutor', () => {
             // Turn 2: Model completes
             mockModelResponse([
                 {
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     args: { finalResult: 'done' },
                     id: 'call-done',
                 },
@@ -2420,7 +2705,7 @@ describe('LocalAgentExecutor', () => {
             const definition = createInstanceToolDefinition([new MockTool({ name: 'take_snapshot' })], 'none');
             mockModelResponse([
                 {
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     args: { result: 'done' },
                     id: 'c1',
                 },
@@ -2429,7 +2714,7 @@ describe('LocalAgentExecutor', () => {
             await executor.run({ goal: 'Test' }, signal);
             const declarations = getSentFunctionDeclarations();
             const names = declarations.map((d) => d.name);
-            expect(names).toContain(TASK_COMPLETE_TOOL_NAME);
+            expect(names).toContain(COMPLETE_TASK_TOOL_NAME);
             expect(names).toContain('take_snapshot');
             expect(declarations).toHaveLength(2);
         });
@@ -2455,7 +2740,7 @@ describe('LocalAgentExecutor', () => {
             const definition = createInstanceToolDefinition(instanceTools);
             mockModelResponse([
                 {
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     args: { finalResult: 'done' },
                     id: 'c1',
                 },
@@ -2483,7 +2768,7 @@ describe('LocalAgentExecutor', () => {
                 vi.spyOn(mockConfig, 'getSystemInstructionMemory').mockReturnValue(mockMemory);
                 mockModelResponse([
                     {
-                        name: TASK_COMPLETE_TOOL_NAME,
+                        name: COMPLETE_TASK_TOOL_NAME,
                         args: { finalResult: 'done' },
                         id: 'call1',
                     },
@@ -2502,7 +2787,7 @@ describe('LocalAgentExecutor', () => {
                 vi.spyOn(mockConfig, 'isJitContextEnabled').mockReturnValue(false);
                 mockModelResponse([
                     {
-                        name: TASK_COMPLETE_TOOL_NAME,
+                        name: COMPLETE_TASK_TOOL_NAME,
                         args: { finalResult: 'done' },
                         id: 'call1',
                     },
@@ -2523,7 +2808,7 @@ describe('LocalAgentExecutor', () => {
                 vi.spyOn(mockConfig, 'isJitContextEnabled').mockReturnValue(true);
                 mockModelResponse([
                     {
-                        name: TASK_COMPLETE_TOOL_NAME,
+                        name: COMPLETE_TASK_TOOL_NAME,
                         args: { finalResult: 'done' },
                         id: 'call1',
                     },