@machina.ai/cell-cli-core 1.36.0-rc1 → 1.38.1-rc2

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

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { describe, it, expect, vi, beforeEach, afterEach, } from 'vitest';
-const { mockSendMessageStream, mockScheduleAgentTools, mockSetSystemInstruction, mockCompress, mockMaybeDiscoverMcpServer, mockStopMcp, } = vi.hoisted(() => ({
+const { mockSendMessageStream, mockScheduleAgentTools, mockSetSystemInstruction, mockRecordCompletedToolCalls, mockSaveSummary, mockCompress, mockMaybeDiscoverMcpServer, mockStopMcp, } = vi.hoisted(() => ({
     mockSendMessageStream: vi.fn().mockResolvedValue({
         async *[Symbol.asyncIterator]() {
             yield {
@@ -15,6 +15,8 @@ const { mockSendMessageStream, mockScheduleAgentTools, mockSetSystemInstruction,
     }),
     mockScheduleAgentTools: vi.fn(),
     mockSetSystemInstruction: vi.fn(),
+    mockRecordCompletedToolCalls: vi.fn(),
+    mockSaveSummary: vi.fn(),
     mockCompress: vi.fn(),
     mockMaybeDiscoverMcpServer: vi.fn().mockResolvedValue(undefined),
     mockStopMcp: vi.fn().mockResolvedValue(undefined),
@@ -33,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';
@@ -47,29 +49,32 @@ import { AgentTerminateMode, SubagentActivityErrorType, } from './types.js';
 import { ToolConfirmationOutcome, } from '../tools/tools.js';
 import { CoreToolCallStatus, } from '../scheduler/types.js';
 import { CompressionStatus } from '../core/turn.js';
-import { ChatCompressionService } from '../services/chatCompressionService.js';
+import { ChatCompressionService } from '../context/chatCompressionService.js';
 import { getModelConfigAlias } from './registry.js';
 let mockChatHistory = [];
 const mockSetHistory = vi.fn((newHistory) => {
     mockChatHistory = newHistory;
 });
-vi.mock('../services/chatCompressionService.js', () => ({
+vi.mock('../context/chatCompressionService.js', () => ({
     ChatCompressionService: vi.fn().mockImplementation(() => ({
         compress: mockCompress,
     })),
 }));
-vi.mock('../core/geminiChat.js', async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        GeminiChat: vi.fn().mockImplementation(() => ({
-            sendMessageStream: mockSendMessageStream,
-            getHistory: vi.fn((_curated) => [...mockChatHistory]),
-            setHistory: mockSetHistory,
-            setSystemInstruction: mockSetSystemInstruction,
-        })),
-    };
-});
+vi.mock('../core/geminiChat.js', () => ({
+    StreamEventType: {
+        CHUNK: 'chunk',
+    },
+    GeminiChat: vi.fn().mockImplementation(() => ({
+        sendMessageStream: mockSendMessageStream,
+        getHistory: vi.fn((_curated) => [...mockChatHistory]),
+        setHistory: mockSetHistory,
+        setSystemInstruction: mockSetSystemInstruction,
+        recordCompletedToolCalls: mockRecordCompletedToolCalls,
+        getChatRecordingService: vi.fn().mockReturnValue({
+            saveSummary: mockSaveSummary,
+        }),
+    })),
+}));
 vi.mock('./agent-scheduler.js', () => ({
     scheduleAgentTools: mockScheduleAgentTools,
 }));
@@ -108,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);
@@ -115,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.
@@ -207,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(() => ({
@@ -227,6 +305,10 @@ describe('LocalAgentExecutor', () => {
             getHistory: vi.fn((_curated) => [...mockChatHistory]),
             getLastPromptTokenCount: vi.fn(() => 100),
             setHistory: mockSetHistory,
+            recordCompletedToolCalls: mockRecordCompletedToolCalls,
+            getChatRecordingService: vi.fn().mockReturnValue({
+                saveSummary: mockSaveSummary,
+            }),
         }));
         vi.useFakeTimers();
         mockConfig = makeFakeConfig();
@@ -272,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',
                 },
@@ -282,7 +364,7 @@ describe('LocalAgentExecutor', () => {
             const executionContext = chatConstructorArgs[0];
             expect(executionContext).toBeDefined();
             expect(executionContext.config).toBe(extendedContext.config);
-            expect(executionContext.promptId).toBe(extendedContext.promptId);
+            expect(executionContext.promptId).toBeDefined();
             expect(executionContext.geminiClient).toBe(extendedContext.geminiClient);
             expect(executionContext.sandboxManager).toBe(extendedContext.sandboxManager);
             const agentToolRegistry = executor['toolRegistry'];
@@ -299,7 +381,84 @@ describe('LocalAgentExecutor', () => {
             expect(executionContext.toolRegistry).not.toBe(extendedContext.toolRegistry);
             expect(executionContext.messageBus).not.toBe(extendedContext.messageBus);
         });
-        it('should create successfully with allowed tools', async () => {
+        it('should propagate parentSessionId from context when creating executionContext', async () => {
+            const parentSessionId = 'top-level-session-id';
+            const currentPromptId = 'subagent-a-id';
+            const mockGeminiClient = {};
+            const mockSandboxManager = {};
+            const mockMessageBus = {
+                derive: () => ({}),
+            };
+            const mockToolRegistry = {
+                getMessageBus: () => mockMessageBus,
+                getAllToolNames: () => [],
+                sortTools: () => { },
+            };
+            const context = {
+                config: mockConfig,
+                promptId: currentPromptId,
+                parentSessionId,
+                toolRegistry: mockToolRegistry,
+                promptRegistry: {},
+                resourceRegistry: {},
+                geminiClient: mockGeminiClient,
+                sandboxManager: mockSandboxManager,
+                messageBus: mockMessageBus,
+            };
+            const definition = createTestDefinition([]);
+            const executor = await LocalAgentExecutor.create(definition, context);
+            mockModelResponse([
+                {
+                    name: COMPLETE_TASK_TOOL_NAME,
+                    args: { finalResult: 'done' },
+                    id: 'call1',
+                },
+            ]);
+            await executor.run({ goal: 'test' }, signal);
+            const chatConstructorArgs = MockedGeminiChat.mock.calls[MockedGeminiChat.mock.calls.length - 1];
+            const executionContext = chatConstructorArgs[0];
+            expect(executionContext.parentSessionId).toBe(parentSessionId);
+            expect(executionContext.promptId).toBe(executor['agentId']);
+        });
+        it('should fall back to promptId if parentSessionId is missing (top-level subagent)', async () => {
+            const rootSessionId = 'root-session-id';
+            const mockGeminiClient = {};
+            const mockSandboxManager = {};
+            const mockMessageBus = {
+                derive: () => ({}),
+            };
+            const mockToolRegistry = {
+                getMessageBus: () => mockMessageBus,
+                getAllToolNames: () => [],
+                sortTools: () => { },
+            };
+            const context = {
+                config: mockConfig,
+                promptId: rootSessionId,
+                // parentSessionId is undefined
+                toolRegistry: mockToolRegistry,
+                promptRegistry: {},
+                resourceRegistry: {},
+                geminiClient: mockGeminiClient,
+                sandboxManager: mockSandboxManager,
+                messageBus: mockMessageBus,
+            };
+            const definition = createTestDefinition([]);
+            const executor = await LocalAgentExecutor.create(definition, context);
+            mockModelResponse([
+                {
+                    name: COMPLETE_TASK_TOOL_NAME,
+                    args: { finalResult: 'done' },
+                    id: 'call1',
+                },
+            ]);
+            await executor.run({ goal: 'test' }, signal);
+            const chatConstructorArgs = MockedGeminiChat.mock.calls[MockedGeminiChat.mock.calls.length - 1];
+            const executionContext = chatConstructorArgs[0];
+            expect(executionContext.parentSessionId).toBe(rootSessionId);
+            expect(executionContext.promptId).toBe(executor['agentId']);
+        });
+        it('should successfully with allowed tools', async () => {
             const definition = createTestDefinition([LS_TOOL_NAME]);
             const executor = await LocalAgentExecutor.create(definition, mockConfig, onActivity);
             expect(executor).toBeInstanceOf(LocalAgentExecutor);
@@ -317,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 () => {
@@ -329,7 +492,7 @@ describe('LocalAgentExecutor', () => {
             });
             const definition = createTestDefinition();
             const executor = await LocalAgentExecutor.create(definition, mockConfig, onActivity);
-            expect(executor['agentId']).toMatch(new RegExp(`^${parentId}-${definition.name}-`));
+            expect(executor['agentId']).toBeDefined();
         });
         it('should correctly apply templates to initialMessages', async () => {
             const definition = createTestDefinition();
@@ -344,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',
                 },
@@ -450,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();
@@ -509,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');
@@ -530,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
@@ -545,6 +770,17 @@ describe('LocalAgentExecutor', () => {
             expect(finishEvent.terminate_reason).toBe(AgentTerminateMode.GOAL);
             // Context checks
             expect(mockedPromptIdContext.run).toHaveBeenCalledTimes(2); // Two turns
+            // Recording checks
+            expect(mockRecordCompletedToolCalls).toHaveBeenCalledTimes(2);
+            expect(mockRecordCompletedToolCalls).toHaveBeenNthCalledWith(1, expect.any(String), // model
+            expect.arrayContaining([
+                expect.objectContaining({
+                    status: 'success',
+                    request: expect.objectContaining({ name: LS_TOOL_NAME }),
+                }),
+            ]));
+            expect(mockSaveSummary).toHaveBeenCalledTimes(1);
+            expect(mockSaveSummary).toHaveBeenCalledWith('Found file1.txt');
             const agentId = executor['agentId'];
             expect(mockedPromptIdContext.run).toHaveBeenNthCalledWith(1, `${agentId}#0`, expect.any(Function));
             expect(mockedPromptIdContext.run).toHaveBeenNthCalledWith(2, `${agentId}#1`, expect.any(Function));
@@ -563,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'),
                     }),
                 }),
@@ -614,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));
@@ -626,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();
@@ -674,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
@@ -696,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,
                 }),
@@ -727,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',
                 }),
@@ -735,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]);
@@ -784,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',
                 },
@@ -827,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);
@@ -858,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',
                 },
@@ -866,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();
@@ -903,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,
                 }),
@@ -935,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',
                     }),
@@ -1008,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({
@@ -1086,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',
                 },
@@ -1186,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',
                 },
@@ -1210,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',
                 },
@@ -1390,7 +1772,7 @@ describe('LocalAgentExecutor', () => {
             // Recovery Turn (succeeds)
             mockModelResponse([
                 {
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     args: { finalResult: 'Recovered!' },
                     id: 't2',
                 },
@@ -1445,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',
                 },
@@ -1473,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({
@@ -1502,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',
                 },
@@ -1624,7 +2006,7 @@ describe('LocalAgentExecutor', () => {
             // Recovery Turn (succeeds)
             mockModelResponse([
                 {
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     args: { finalResult: 'Recovered!' },
                     id: 't2',
                 },
@@ -1635,6 +2017,9 @@ describe('LocalAgentExecutor', () => {
             expect(recoveryEvent).toBeInstanceOf(RecoveryAttemptEvent);
             expect(recoveryEvent.success).toBe(true);
             expect(recoveryEvent.reason).toBe(AgentTerminateMode.MAX_TURNS);
+            // Verify that the summary is saved upon successful recovery
+            expect(mockSaveSummary).toHaveBeenCalledTimes(1);
+            expect(mockSaveSummary).toHaveBeenCalledWith('Recovered!');
         });
         describe('Model Steering', () => {
             let configWithHints;
@@ -1659,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',
                     },
@@ -1711,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',
                     },
@@ -1741,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',
                     },
@@ -1809,7 +2194,7 @@ describe('LocalAgentExecutor', () => {
                 mockScheduleAgentTools.mockReturnValueOnce(toolCallPromise);
                 mockModelResponse([
                     {
-                        name: TASK_COMPLETE_TOOL_NAME,
+                        name: COMPLETE_TASK_TOOL_NAME,
                         args: { finalResult: 'Done' },
                         id: 'call2',
                     },
@@ -1864,7 +2249,7 @@ describe('LocalAgentExecutor', () => {
                 mockScheduleAgentTools.mockReturnValueOnce(toolCallPromise);
                 mockModelResponse([
                     {
-                        name: TASK_COMPLETE_TOOL_NAME,
+                        name: COMPLETE_TASK_TOOL_NAME,
                         args: { finalResult: 'Done' },
                         id: 'call2',
                     },
@@ -1918,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',
                     },
@@ -1974,7 +2359,7 @@ describe('LocalAgentExecutor', () => {
             // Turn 2: Complete
             mockModelResponse([
                 {
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     args: { finalResult: 'Done' },
                     id: 'call2',
                 },
@@ -1995,7 +2380,7 @@ describe('LocalAgentExecutor', () => {
             // Turn 1: Complete
             mockModelResponse([
                 {
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     args: { finalResult: 'Done' },
                     id: 'call1',
                 },
@@ -2025,7 +2410,7 @@ describe('LocalAgentExecutor', () => {
             // Turn 2: Complete
             mockModelResponse([
                 {
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     args: { finalResult: 'Done' },
                     id: 't2',
                 },
@@ -2067,7 +2452,7 @@ describe('LocalAgentExecutor', () => {
             // Turn 3: Complete
             mockModelResponse([
                 {
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     args: { finalResult: 'Done' },
                     id: 't3',
                 },
@@ -2183,7 +2568,7 @@ describe('LocalAgentExecutor', () => {
             ]);
             mockModelResponse([
                 {
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     args: { finalResult: 'done' },
                     id: 'c1',
                 },
@@ -2242,7 +2627,7 @@ describe('LocalAgentExecutor', () => {
             };
             mockModelResponse([
                 {
-                    name: TASK_COMPLETE_TOOL_NAME,
+                    name: COMPLETE_TASK_TOOL_NAME,
                     args: { finalResult: 'ok' },
                     id: 'c1',
                 },
@@ -2253,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);
         });
@@ -2301,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',
                 },
@@ -2320,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',
                 },
@@ -2329,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);
         });
@@ -2355,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',
                 },
@@ -2383,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',
                     },
@@ -2402,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',
                     },
@@ -2423,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',
                     },