@office-ai/aioncli-core 0.26.0 → 0.30.1

package/dist/src/core/coreToolScheduler.test.js

@@ -5,12 +5,13 @@
  */
 import { describe, it, expect, vi } from 'vitest';
 import { CoreToolScheduler } from './coreToolScheduler.js';
-import { DEFAULT_TRUNCATE_TOOL_OUTPUT_LINES, DEFAULT_TRUNCATE_TOOL_OUTPUT_THRESHOLD, BaseDeclarativeTool, BaseToolInvocation, ToolConfirmationOutcome, Kind, ApprovalMode, HookSystem, } from '../index.js';
+import { CoreToolCallStatus, } from '../scheduler/types.js';
+import { DEFAULT_TRUNCATE_TOOL_OUTPUT_THRESHOLD, BaseDeclarativeTool, BaseToolInvocation, ToolConfirmationOutcome, Kind, ApprovalMode, HookSystem, PolicyDecision, ToolErrorType, } from '../index.js';
 import { createMockMessageBus } from '../test-utils/mock-message-bus.js';
 import { MockModifiableTool, MockTool, MOCK_TOOL_SHOULD_CONFIRM_EXECUTE, } from '../test-utils/mock-tool.js';
 import * as modifiableToolModule from '../tools/modifiable-tool.js';
-import { isShellInvocationAllowlisted } from '../utils/shell-permissions.js';
 import { DEFAULT_GEMINI_MODEL } from '../config/models.js';
+import { DiscoveredMCPTool } from '../tools/mcp-tool.js';
 vi.mock('fs/promises', () => ({
     writeFile: vi.fn(),
 }));
@@ -163,16 +164,34 @@ function createMockConfig(overrides = {}) {
             getProjectTempDir: () => '/tmp',
         },
         getTruncateToolOutputThreshold: () => DEFAULT_TRUNCATE_TOOL_OUTPUT_THRESHOLD,
-        getTruncateToolOutputLines: () => DEFAULT_TRUNCATE_TOOL_OUTPUT_LINES,
         getToolRegistry: () => defaultToolRegistry,
         getActiveModel: () => DEFAULT_GEMINI_MODEL,
         getGeminiClient: () => null,
         getMessageBus: () => createMockMessageBus(),
         getEnableHooks: () => false,
-        getPolicyEngine: () => null,
         getExperiments: () => { },
     };
-    return { ...baseConfig, ...overrides };
+    const finalConfig = { ...baseConfig, ...overrides };
+    // Patch the policy engine to use the final config if not overridden
+    if (!overrides.getPolicyEngine) {
+        finalConfig.getPolicyEngine = () => ({
+            check: async (toolCall, _serverName) => {
+                // Mock simple policy logic for tests
+                const mode = finalConfig.getApprovalMode();
+                if (mode === ApprovalMode.YOLO) {
+                    return { decision: PolicyDecision.ALLOW };
+                }
+                const allowed = finalConfig.getAllowedTools();
+                if (allowed &&
+                    (allowed.includes(toolCall.name) ||
+                        allowed.some((p) => toolCall.name.startsWith(p)))) {
+                    return { decision: PolicyDecision.ALLOW };
+                }
+                return { decision: PolicyDecision.ASK_USER };
+            },
+        });
+    }
+    return finalConfig;
 }
 describe('CoreToolScheduler', () => {
     it('should cancel a tool call if the signal is aborted before confirmation', async () => {
@@ -219,7 +238,7 @@ describe('CoreToolScheduler', () => {
         expect(onAllToolCallsComplete).toHaveBeenCalled();
         const completedCalls = onAllToolCallsComplete.mock
             .calls[0][0];
-        expect(completedCalls[0].status).toBe('cancelled');
+        expect(completedCalls[0].status).toBe(CoreToolCallStatus.Cancelled);
     });
     it('should cancel all tools when cancelAll is called', async () => {
         const mockTool1 = new MockTool({
@@ -296,7 +315,7 @@ describe('CoreToolScheduler', () => {
         // Don't await, let it run in the background
         void scheduler.schedule(requests, abortController.signal);
         // Wait for the first tool to be awaiting approval
-        await waitForStatus(onToolCallsUpdate, 'awaiting_approval');
+        await waitForStatus(onToolCallsUpdate, CoreToolCallStatus.AwaitingApproval);
         // Cancel all operations
         scheduler.cancelAll(abortController.signal);
         abortController.abort(); // Also fire the signal
@@ -306,9 +325,9 @@ describe('CoreToolScheduler', () => {
         const completedCalls = onAllToolCallsComplete.mock
             .calls[0][0];
         expect(completedCalls).toHaveLength(3);
-        expect(completedCalls.find((c) => c.request.callId === '1')?.status).toBe('cancelled');
-        expect(completedCalls.find((c) => c.request.callId === '2')?.status).toBe('cancelled');
-        expect(completedCalls.find((c) => c.request.callId === '3')?.status).toBe('cancelled');
+        expect(completedCalls.find((c) => c.request.callId === '1')?.status).toBe(CoreToolCallStatus.Cancelled);
+        expect(completedCalls.find((c) => c.request.callId === '2')?.status).toBe(CoreToolCallStatus.Cancelled);
+        expect(completedCalls.find((c) => c.request.callId === '3')?.status).toBe(CoreToolCallStatus.Cancelled);
     });
     it('should cancel all tools in a batch when one is cancelled via confirmation', async () => {
         const mockTool1 = new MockTool({
@@ -385,9 +404,10 @@ describe('CoreToolScheduler', () => {
         // Don't await, let it run in the background
         void scheduler.schedule(requests, abortController.signal);
         // Wait for the first tool to be awaiting approval
-        const awaitingCall = (await waitForStatus(onToolCallsUpdate, 'awaiting_approval'));
+        const awaitingCall = (await waitForStatus(onToolCallsUpdate, CoreToolCallStatus.AwaitingApproval));
         // Cancel the first tool via its confirmation handler
-        await awaitingCall.confirmationDetails.onConfirm(ToolConfirmationOutcome.Cancel);
+        const confirmationDetails = awaitingCall.confirmationDetails;
+        await confirmationDetails.onConfirm(ToolConfirmationOutcome.Cancel);
         abortController.abort(); // User cancelling often involves an abort signal
         await vi.waitFor(() => {
             expect(onAllToolCallsComplete).toHaveBeenCalled();
@@ -395,9 +415,9 @@ describe('CoreToolScheduler', () => {
         const completedCalls = onAllToolCallsComplete.mock
             .calls[0][0];
         expect(completedCalls).toHaveLength(3);
-        expect(completedCalls.find((c) => c.request.callId === '1')?.status).toBe('cancelled');
-        expect(completedCalls.find((c) => c.request.callId === '2')?.status).toBe('cancelled');
-        expect(completedCalls.find((c) => c.request.callId === '3')?.status).toBe('cancelled');
+        expect(completedCalls.find((c) => c.request.callId === '1')?.status).toBe(CoreToolCallStatus.Cancelled);
+        expect(completedCalls.find((c) => c.request.callId === '2')?.status).toBe(CoreToolCallStatus.Cancelled);
+        expect(completedCalls.find((c) => c.request.callId === '3')?.status).toBe(CoreToolCallStatus.Cancelled);
     });
     it('should mark tool call as cancelled when abort happens during confirmation error', async () => {
         const abortController = new AbortController();
@@ -420,7 +440,7 @@ describe('CoreToolScheduler', () => {
         const onToolCallsUpdate = vi.fn();
         const mockConfig = createMockConfig({
             getToolRegistry: () => mockToolRegistry,
-            isInteractive: () => false,
+            isInteractive: () => true,
         });
         const scheduler = new CoreToolScheduler({
             config: mockConfig,
@@ -439,9 +459,9 @@ describe('CoreToolScheduler', () => {
         expect(onAllToolCallsComplete).toHaveBeenCalled();
         const completedCalls = onAllToolCallsComplete.mock
             .calls[0][0];
-        expect(completedCalls[0].status).toBe('cancelled');
+        expect(completedCalls[0].status).toBe(CoreToolCallStatus.Cancelled);
         const statuses = onToolCallsUpdate.mock.calls.flatMap((call) => call[0].map((toolCall) => toolCall.status));
-        expect(statuses).not.toContain('error');
+        expect(statuses).not.toContain(CoreToolCallStatus.Error);
     });
     it('should error when tool requires confirmation in non-interactive mode', async () => {
         const mockTool = new MockTool({
@@ -486,7 +506,7 @@ describe('CoreToolScheduler', () => {
         expect(onAllToolCallsComplete).toHaveBeenCalled();
         const completedCalls = onAllToolCallsComplete.mock
             .calls[0][0];
-        expect(completedCalls[0].status).toBe('error');
+        expect(completedCalls[0].status).toBe(CoreToolCallStatus.Error);
         const erroredCall = completedCalls[0];
         const errorResponse = erroredCall.response;
         const errorParts = errorResponse.responseParts;
@@ -539,19 +559,23 @@ describe('CoreToolScheduler with payload', () => {
             prompt_id: 'prompt-id-2',
         };
         await scheduler.schedule([request], abortController.signal);
-        const awaitingCall = (await waitForStatus(onToolCallsUpdate, 'awaiting_approval'));
+        const awaitingCall = (await waitForStatus(onToolCallsUpdate, CoreToolCallStatus.AwaitingApproval));
         const confirmationDetails = awaitingCall.confirmationDetails;
         if (confirmationDetails) {
             const payload = { newContent: 'final version' };
             await confirmationDetails.onConfirm(ToolConfirmationOutcome.ProceedOnce, payload);
         }
+        // After internal update, the tool should be awaiting approval again with the NEW content.
+        const updatedAwaitingCall = (await waitForStatus(onToolCallsUpdate, CoreToolCallStatus.AwaitingApproval));
+        // Now confirm for real to execute.
+        await updatedAwaitingCall.confirmationDetails.onConfirm(ToolConfirmationOutcome.ProceedOnce);
         // Wait for the tool execution to complete
         await vi.waitFor(() => {
             expect(onAllToolCallsComplete).toHaveBeenCalled();
         });
         const completedCalls = onAllToolCallsComplete.mock
             .calls[0][0];
-        expect(completedCalls[0].status).toBe('success');
+        expect(completedCalls[0].status).toBe(CoreToolCallStatus.Success);
         expect(mockTool.executeFn).toHaveBeenCalledWith({
             newContent: 'final version',
         });
@@ -633,7 +657,7 @@ describe('CoreToolScheduler edit cancellation', () => {
             prompt_id: 'prompt-id-1',
         };
         await scheduler.schedule([request], abortController.signal);
-        const awaitingCall = (await waitForStatus(onToolCallsUpdate, 'awaiting_approval'));
+        const awaitingCall = (await waitForStatus(onToolCallsUpdate, CoreToolCallStatus.AwaitingApproval));
         // Cancel the edit
         const confirmationDetails = awaitingCall.confirmationDetails;
         if (confirmationDetails) {
@@ -642,7 +666,7 @@ describe('CoreToolScheduler edit cancellation', () => {
         expect(onAllToolCallsComplete).toHaveBeenCalled();
         const completedCalls = onAllToolCallsComplete.mock
             .calls[0][0];
-        expect(completedCalls[0].status).toBe('cancelled');
+        expect(completedCalls[0].status).toBe(CoreToolCallStatus.Cancelled);
         // Check that the diff is preserved
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const cancelledCall = completedCalls[0];
@@ -715,24 +739,24 @@ describe('CoreToolScheduler YOLO mode', () => {
         // Assert
         // 1. The tool's execute method was called directly.
         expect(executeFn).toHaveBeenCalledWith({ param: 'value' });
-        // 2. The tool call status never entered 'awaiting_approval'.
+        // 2. The tool call status never entered CoreToolCallStatus.AwaitingApproval.
         const statusUpdates = onToolCallsUpdate.mock.calls
             .map((call) => call[0][0]?.status)
             .filter(Boolean);
-        expect(statusUpdates).not.toContain('awaiting_approval');
+        expect(statusUpdates).not.toContain(CoreToolCallStatus.AwaitingApproval);
         expect(statusUpdates).toEqual([
-            'validating',
-            'scheduled',
-            'executing',
-            'success',
+            CoreToolCallStatus.Validating,
+            CoreToolCallStatus.Scheduled,
+            CoreToolCallStatus.Executing,
+            CoreToolCallStatus.Success,
         ]);
         // 3. The final callback indicates the tool call was successful.
         const completedCalls = onAllToolCallsComplete.mock
             .calls[0][0];
         expect(completedCalls).toHaveLength(1);
         const completedCall = completedCalls[0];
-        expect(completedCall.status).toBe('success');
-        if (completedCall.status === 'success') {
+        expect(completedCall.status).toBe(CoreToolCallStatus.Success);
+        if (completedCall.status === CoreToolCallStatus.Success) {
             expect(completedCall.response.resultDisplay).toBe('Tool executed');
         }
     });
@@ -796,8 +820,8 @@ describe('CoreToolScheduler request queueing', () => {
         // Schedule the first call, which will pause execution.
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
         scheduler.schedule([request1], abortController.signal);
-        // Wait for the first call to be in the 'executing' state.
-        await waitForStatus(onToolCallsUpdate, 'executing');
+        // Wait for the first call to be in the CoreToolCallStatus.Executing state.
+        await waitForStatus(onToolCallsUpdate, CoreToolCallStatus.Executing);
         // Schedule the second call while the first is "running".
         const schedulePromise2 = scheduler.schedule([request2], abortController.signal);
         // Ensure the second tool call hasn't been executed yet.
@@ -827,8 +851,8 @@ describe('CoreToolScheduler request queueing', () => {
             expect(onAllToolCallsComplete).toHaveBeenCalledTimes(2);
         });
         // Verify the completion callbacks were called correctly.
-        expect(onAllToolCallsComplete.mock.calls[0][0][0].status).toBe('success');
-        expect(onAllToolCallsComplete.mock.calls[1][0][0].status).toBe('success');
+        expect(onAllToolCallsComplete.mock.calls[0][0][0].status).toBe(CoreToolCallStatus.Success);
+        expect(onAllToolCallsComplete.mock.calls[1][0][0].status).toBe(CoreToolCallStatus.Success);
     });
     it('should auto-approve a tool call if it is on the allowedTools list', async () => {
         // Arrange
@@ -901,16 +925,16 @@ describe('CoreToolScheduler request queueing', () => {
         // Assert
         // 1. The tool's execute method was called directly.
         expect(executeFn).toHaveBeenCalledWith({ param: 'value' });
-        // 2. The tool call status never entered 'awaiting_approval'.
+        // 2. The tool call status never entered CoreToolCallStatus.AwaitingApproval.
         const statusUpdates = onToolCallsUpdate.mock.calls
             .map((call) => call[0][0]?.status)
             .filter(Boolean);
-        expect(statusUpdates).not.toContain('awaiting_approval');
+        expect(statusUpdates).not.toContain(CoreToolCallStatus.AwaitingApproval);
         expect(statusUpdates).toEqual([
-            'validating',
-            'scheduled',
-            'executing',
-            'success',
+            CoreToolCallStatus.Validating,
+            CoreToolCallStatus.Scheduled,
+            CoreToolCallStatus.Executing,
+            CoreToolCallStatus.Success,
         ]);
         // 3. The final callback indicates the tool call was successful.
         expect(onAllToolCallsComplete).toHaveBeenCalled();
@@ -918,15 +942,12 @@ describe('CoreToolScheduler request queueing', () => {
             .calls[0][0];
         expect(completedCalls).toHaveLength(1);
         const completedCall = completedCalls[0];
-        expect(completedCall.status).toBe('success');
-        if (completedCall.status === 'success') {
+        expect(completedCall.status).toBe(CoreToolCallStatus.Success);
+        if (completedCall.status === CoreToolCallStatus.Success) {
             expect(completedCall.response.resultDisplay).toBe('Tool executed');
         }
     });
     it('should require approval for a chained shell command even when prefix is allowlisted', async () => {
-        expect(isShellInvocationAllowlisted({
-            params: { command: 'git status && rm -rf /tmp/should-not-run' },
-        }, ['run_shell_command(git)'])).toBe(false);
         const executeFn = vi.fn().mockResolvedValue({
             llmContent: 'Shell command executed',
             returnDisplay: 'Shell command executed',
@@ -938,6 +959,7 @@ describe('CoreToolScheduler request queueing', () => {
                 title: 'Confirm Shell Command',
                 command: String(params['command'] ?? ''),
                 rootCommand: 'git',
+                rootCommands: ['git'],
                 onConfirm: async () => { },
             }),
             execute: () => executeFn({}),
@@ -970,6 +992,9 @@ describe('CoreToolScheduler request queueing', () => {
             }),
             getToolRegistry: () => toolRegistry,
             getHookSystem: () => undefined,
+            getPolicyEngine: () => ({
+                check: async () => ({ decision: PolicyDecision.ASK_USER }),
+            }),
         });
         const scheduler = new CoreToolScheduler({
             config: mockConfig,
@@ -989,7 +1014,7 @@ describe('CoreToolScheduler request queueing', () => {
         const statusUpdates = onToolCallsUpdate.mock.calls
             .map((call) => call[0][0]?.status)
             .filter(Boolean);
-        expect(statusUpdates).toContain('awaiting_approval');
+        expect(statusUpdates).toContain(CoreToolCallStatus.AwaitingApproval);
         expect(executeFn).not.toHaveBeenCalled();
         expect(onAllToolCallsComplete).not.toHaveBeenCalled();
     }, 20000);
@@ -1104,12 +1129,13 @@ describe('CoreToolScheduler request queueing', () => {
                 onToolCallsUpdate(toolCalls);
                 // Capture confirmation handlers for awaiting_approval tools
                 toolCalls.forEach((call) => {
-                    if (call.status === 'awaiting_approval') {
+                    if (call.status === CoreToolCallStatus.AwaitingApproval) {
                         const waitingCall = call;
-                        if (waitingCall.confirmationDetails?.onConfirm) {
-                            const originalHandler = pendingConfirmations.find((h) => h === waitingCall.confirmationDetails.onConfirm);
+                        const details = waitingCall.confirmationDetails;
+                        if (details?.onConfirm) {
+                            const originalHandler = pendingConfirmations.find((h) => h === details.onConfirm);
                             if (!originalHandler) {
-                                pendingConfirmations.push(waitingCall.confirmationDetails.onConfirm);
+                                pendingConfirmations.push(details.onConfirm);
                             }
                         }
                     }
@@ -1148,11 +1174,11 @@ describe('CoreToolScheduler request queueing', () => {
             const calls = onToolCallsUpdate.mock.calls.at(-1)?.[0];
             // With the sequential scheduler, the update includes the active call and the queue.
             expect(calls?.length).toBe(3);
-            expect(calls?.[0].status).toBe('awaiting_approval');
+            expect(calls?.[0].status).toBe(CoreToolCallStatus.AwaitingApproval);
             expect(calls?.[0].request.callId).toBe('1');
-            // Check that the other two are in the queue (still in 'validating' state)
-            expect(calls?.[1].status).toBe('validating');
-            expect(calls?.[2].status).toBe('validating');
+            // Check that the other two are in the queue (still in CoreToolCallStatus.Validating state)
+            expect(calls?.[1].status).toBe(CoreToolCallStatus.Validating);
+            expect(calls?.[2].status).toBe(CoreToolCallStatus.Validating);
         });
         expect(pendingConfirmations.length).toBe(1);
         // Approve the first tool with ProceedAlways
@@ -1164,7 +1190,7 @@ describe('CoreToolScheduler request queueing', () => {
         });
         const completedCalls = onAllToolCallsComplete.mock.calls.at(-1)?.[0];
         expect(completedCalls?.length).toBe(3);
-        expect(completedCalls?.every((call) => call.status === 'success')).toBe(true);
+        expect(completedCalls?.every((call) => call.status === CoreToolCallStatus.Success)).toBe(true);
         // Verify approval mode was changed
         expect(approvalMode).toBe(ApprovalMode.AUTO_EDIT);
     });
@@ -1258,8 +1284,8 @@ describe('CoreToolScheduler Sequential Execution', () => {
         const completedCalls = onAllToolCallsComplete.mock
             .calls[0][0];
         expect(completedCalls).toHaveLength(2);
-        expect(completedCalls[0].status).toBe('success');
-        expect(completedCalls[1].status).toBe('success');
+        expect(completedCalls[0].status).toBe(CoreToolCallStatus.Success);
+        expect(completedCalls[1].status).toBe(CoreToolCallStatus.Success);
     });
     it('should cancel subsequent tools when the signal is aborted.', async () => {
         // Arrange
@@ -1362,9 +1388,9 @@ describe('CoreToolScheduler Sequential Execution', () => {
         const call1 = completedCalls.find((c) => c.request.callId === '1');
         const call2 = completedCalls.find((c) => c.request.callId === '2');
         const call3 = completedCalls.find((c) => c.request.callId === '3');
-        expect(call1?.status).toBe('success');
-        expect(call2?.status).toBe('cancelled');
-        expect(call3?.status).toBe('cancelled');
+        expect(call1?.status).toBe(CoreToolCallStatus.Success);
+        expect(call2?.status).toBe(CoreToolCallStatus.Cancelled);
+        expect(call3?.status).toBe(CoreToolCallStatus.Cancelled);
     });
     it('should pass confirmation diff data into modifyWithEditor overrides', async () => {
         const modifyWithEditorSpy = vi
@@ -1416,7 +1442,7 @@ describe('CoreToolScheduler Sequential Execution', () => {
         ], abortController.signal);
         const toolCall = scheduler
             .toolCalls[0];
-        expect(toolCall.status).toBe('awaiting_approval');
+        expect(toolCall.status).toBe(CoreToolCallStatus.AwaitingApproval);
         const confirmationSignal = new AbortController().signal;
         await scheduler.handleConfirmationResponse(toolCall.request.callId, async () => { }, ToolConfirmationOutcome.ModifyWithEditor, confirmationSignal);
         expect(modifyWithEditorSpy).toHaveBeenCalled();
@@ -1427,5 +1453,397 @@ describe('CoreToolScheduler Sequential Execution', () => {
         });
         modifyWithEditorSpy.mockRestore();
     });
+    it('should handle inline modify with empty new content', async () => {
+        // Mock the modifiable check to return true for this test
+        const isModifiableSpy = vi
+            .spyOn(modifiableToolModule, 'isModifiableDeclarativeTool')
+            .mockReturnValue(true);
+        const mockTool = new MockModifiableTool();
+        const mockToolRegistry = {
+            getTool: () => mockTool,
+            getAllToolNames: () => [],
+        };
+        const mockConfig = createMockConfig({
+            getToolRegistry: () => mockToolRegistry,
+            isInteractive: () => true,
+        });
+        mockConfig.getHookSystem = vi.fn().mockReturnValue(undefined);
+        const scheduler = new CoreToolScheduler({
+            config: mockConfig,
+            getPreferredEditor: () => 'vscode',
+        });
+        // Manually inject a waiting tool call
+        const callId = 'call-1';
+        const toolCall = {
+            status: CoreToolCallStatus.AwaitingApproval,
+            request: {
+                callId,
+                name: 'mockModifiableTool',
+                args: {},
+                isClientInitiated: false,
+                prompt_id: 'p1',
+            },
+            tool: mockTool,
+            invocation: {},
+            confirmationDetails: {
+                type: 'edit',
+                title: 'Confirm',
+                fileName: 'test.txt',
+                filePath: 'test.txt',
+                fileDiff: 'diff',
+                originalContent: 'old',
+                newContent: 'new',
+                onConfirm: async () => { },
+            },
+            startTime: Date.now(),
+        };
+        const schedulerInternals = scheduler;
+        schedulerInternals.toolCalls = [toolCall];
+        const applyInlineModifySpy = vi
+            .spyOn(schedulerInternals.toolModifier, 'applyInlineModify')
+            .mockResolvedValue({
+            updatedParams: { content: '' },
+            updatedDiff: 'diff-empty',
+        });
+        await scheduler.handleConfirmationResponse(callId, async () => { }, ToolConfirmationOutcome.ProceedOnce, new AbortController().signal, { newContent: '' });
+        expect(applyInlineModifySpy).toHaveBeenCalled();
+        isModifiableSpy.mockRestore();
+    });
+    it('should pass serverName to policy engine for DiscoveredMCPTool', async () => {
+        const mockMcpTool = {
+            tool: async () => ({ functionDeclarations: [] }),
+            callTool: async () => [],
+        };
+        const serverName = 'test-server';
+        const toolName = 'test-tool';
+        const mcpTool = new DiscoveredMCPTool(mockMcpTool, serverName, toolName, 'description', { type: 'object', properties: {} }, createMockMessageBus());
+        const mockToolRegistry = {
+            getTool: () => mcpTool,
+            getFunctionDeclarations: () => [],
+            tools: new Map(),
+            discovery: {},
+            registerTool: () => { },
+            getToolByName: () => mcpTool,
+            getToolByDisplayName: () => mcpTool,
+            getTools: () => [],
+            discoverTools: async () => { },
+            getAllTools: () => [],
+            getToolsByServer: () => [],
+        };
+        const mockPolicyEngineCheck = vi.fn().mockResolvedValue({
+            decision: PolicyDecision.ALLOW,
+        });
+        const mockConfig = createMockConfig({
+            getToolRegistry: () => mockToolRegistry,
+            getPolicyEngine: () => ({
+                check: mockPolicyEngineCheck,
+            }),
+            isInteractive: () => false,
+        });
+        mockConfig.getHookSystem = vi.fn().mockReturnValue(undefined);
+        const scheduler = new CoreToolScheduler({
+            config: mockConfig,
+            getPreferredEditor: () => 'vscode',
+        });
+        const abortController = new AbortController();
+        const request = {
+            callId: '1',
+            name: toolName,
+            args: {},
+            isClientInitiated: false,
+            prompt_id: 'prompt-id-1',
+        };
+        await scheduler.schedule(request, abortController.signal);
+        expect(mockPolicyEngineCheck).toHaveBeenCalledWith(expect.objectContaining({ name: toolName }), serverName);
+    });
+    it('should not double-report completed tools when concurrent completions occur', async () => {
+        // Arrange
+        const executeFn = vi
+            .fn()
+            .mockResolvedValue({ llmContent: CoreToolCallStatus.Success });
+        const mockTool = new MockTool({ name: 'mockTool', execute: executeFn });
+        const declarativeTool = mockTool;
+        const mockToolRegistry = {
+            getTool: () => declarativeTool,
+            getToolByName: () => declarativeTool,
+            getFunctionDeclarations: () => [],
+            tools: new Map(),
+            discovery: {},
+            registerTool: () => { },
+            getToolByDisplayName: () => declarativeTool,
+            getTools: () => [],
+            discoverTools: async () => { },
+            getAllTools: () => [],
+            getToolsByServer: () => [],
+        };
+        let completionCallCount = 0;
+        const onAllToolCallsComplete = vi.fn().mockImplementation(async () => {
+            completionCallCount++;
+            // Simulate slow reporting (e.g. Gemini API call)
+            await new Promise((resolve) => setTimeout(resolve, 50));
+        });
+        const mockConfig = createMockConfig({
+            getToolRegistry: () => mockToolRegistry,
+            getApprovalMode: () => ApprovalMode.YOLO,
+            isInteractive: () => false,
+        });
+        const mockMessageBus = createMockMessageBus();
+        mockConfig.getMessageBus = vi.fn().mockReturnValue(mockMessageBus);
+        mockConfig.getEnableHooks = vi.fn().mockReturnValue(false);
+        mockConfig.getHookSystem = vi
+            .fn()
+            .mockReturnValue(new HookSystem(mockConfig));
+        const scheduler = new CoreToolScheduler({
+            config: mockConfig,
+            onAllToolCallsComplete,
+            getPreferredEditor: () => 'vscode',
+        });
+        const abortController = new AbortController();
+        const request = {
+            callId: '1',
+            name: 'mockTool',
+            args: {},
+            isClientInitiated: false,
+            prompt_id: 'prompt-1',
+        };
+        // Act
+        // 1. Start execution
+        const schedulePromise = scheduler.schedule([request], abortController.signal);
+        // 2. Wait just enough for it to finish and enter checkAndNotifyCompletion
+        // (awaiting our slow mock)
+        await vi.waitFor(() => {
+            expect(completionCallCount).toBe(1);
+        });
+        // 3. Trigger a concurrent completion event (e.g. via cancelAll)
+        scheduler.cancelAll(abortController.signal);
+        await schedulePromise;
+        // Assert
+        // Even though cancelAll was called while the first completion was in progress,
+        // it should not have triggered a SECOND completion call because the first one
+        // was still 'finalizing' and will drain any new tools.
+        expect(onAllToolCallsComplete).toHaveBeenCalledTimes(1);
+    });
+    it('should complete reporting all tools even mid-callback during abort', async () => {
+        // Arrange
+        const onAllToolCallsComplete = vi.fn().mockImplementation(async () => {
+            // Simulate slow reporting
+            await new Promise((resolve) => setTimeout(resolve, 50));
+        });
+        const mockTool = new MockTool({ name: 'mockTool' });
+        const mockToolRegistry = {
+            getTool: () => mockTool,
+            getToolByName: () => mockTool,
+            getFunctionDeclarations: () => [],
+            tools: new Map(),
+            discovery: {},
+            registerTool: () => { },
+            getToolByDisplayName: () => mockTool,
+            getTools: () => [],
+            discoverTools: async () => { },
+            getAllTools: () => [],
+            getToolsByServer: () => [],
+        };
+        const mockConfig = createMockConfig({
+            getToolRegistry: () => mockToolRegistry,
+            getApprovalMode: () => ApprovalMode.YOLO,
+            isInteractive: () => false,
+        });
+        mockConfig.getHookSystem = vi.fn().mockReturnValue(undefined);
+        const scheduler = new CoreToolScheduler({
+            config: mockConfig,
+            onAllToolCallsComplete,
+            getPreferredEditor: () => 'vscode',
+        });
+        const abortController = new AbortController();
+        const signal = abortController.signal;
+        // Act
+        // 1. Start execution of two tools
+        const schedulePromise = scheduler.schedule([
+            {
+                callId: '1',
+                name: 'mockTool',
+                args: {},
+                isClientInitiated: false,
+                prompt_id: 'prompt-1',
+            },
+            {
+                callId: '2',
+                name: 'mockTool',
+                args: {},
+                isClientInitiated: false,
+                prompt_id: 'prompt-1',
+            },
+        ], signal);
+        // 2. Wait for reporting to start
+        await vi.waitFor(() => {
+            expect(onAllToolCallsComplete).toHaveBeenCalled();
+        });
+        // 3. Abort the signal while reporting is in progress
+        abortController.abort();
+        await schedulePromise;
+        // Assert
+        // Verify that onAllToolCallsComplete was called and processed the tools,
+        // and that the scheduler didn't just drop them because of the abort.
+        expect(onAllToolCallsComplete).toHaveBeenCalled();
+        const reportedTools = onAllToolCallsComplete.mock.calls.flatMap((call) => 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        call[0].map((t) => t.request.callId));
+        // Both tools should have been reported exactly once with success status
+        expect(reportedTools).toContain('1');
+        expect(reportedTools).toContain('2');
+        const allStatuses = onAllToolCallsComplete.mock.calls.flatMap((call) => 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        call[0].map((t) => t.status));
+        expect(allStatuses).toEqual([
+            CoreToolCallStatus.Success,
+            CoreToolCallStatus.Success,
+        ]);
+        expect(onAllToolCallsComplete).toHaveBeenCalledTimes(1);
+    });
+    describe('Policy Decisions in Plan Mode', () => {
+        it('should return POLICY_VIOLATION error type and informative message when denied in Plan Mode', async () => {
+            const mockTool = new MockTool({
+                name: 'dangerous_tool',
+                displayName: 'Dangerous Tool',
+                description: 'Does risky stuff',
+            });
+            const mockToolRegistry = {
+                getTool: () => mockTool,
+                getAllToolNames: () => ['dangerous_tool'],
+            };
+            const onAllToolCallsComplete = vi.fn();
+            const mockConfig = createMockConfig({
+                getToolRegistry: () => mockToolRegistry,
+                getApprovalMode: () => ApprovalMode.PLAN,
+                getPolicyEngine: () => ({
+                    check: async () => ({ decision: PolicyDecision.DENY }),
+                }),
+            });
+            mockConfig.getHookSystem = vi.fn().mockReturnValue(undefined);
+            const scheduler = new CoreToolScheduler({
+                config: mockConfig,
+                onAllToolCallsComplete,
+                getPreferredEditor: () => 'vscode',
+            });
+            const request = {
+                callId: 'call-1',
+                name: 'dangerous_tool',
+                args: {},
+                isClientInitiated: false,
+                prompt_id: 'prompt-1',
+            };
+            await scheduler.schedule(request, new AbortController().signal);
+            expect(onAllToolCallsComplete).toHaveBeenCalledTimes(1);
+            const reportedTools = onAllToolCallsComplete.mock.calls[0][0];
+            const result = reportedTools[0];
+            expect(result.status).toBe(CoreToolCallStatus.Error);
+            expect(result.response.errorType).toBe(ToolErrorType.POLICY_VIOLATION);
+            expect(result.response.error.message).toBe('Tool execution denied by policy.');
+        });
+        it('should return custom deny message when denied in Plan Mode with a specific rule message', async () => {
+            const mockTool = new MockTool({
+                name: 'dangerous_tool',
+                displayName: 'Dangerous Tool',
+                description: 'Does risky stuff',
+            });
+            const mockToolRegistry = {
+                getTool: () => mockTool,
+                getAllToolNames: () => ['dangerous_tool'],
+            };
+            const onAllToolCallsComplete = vi.fn();
+            const customDenyMessage = 'Custom denial message for testing';
+            const mockConfig = createMockConfig({
+                getToolRegistry: () => mockToolRegistry,
+                getApprovalMode: () => ApprovalMode.PLAN,
+                getPolicyEngine: () => ({
+                    check: async () => ({
+                        decision: PolicyDecision.DENY,
+                        rule: { denyMessage: customDenyMessage },
+                    }),
+                }),
+            });
+            mockConfig.getHookSystem = vi.fn().mockReturnValue(undefined);
+            const scheduler = new CoreToolScheduler({
+                config: mockConfig,
+                onAllToolCallsComplete,
+                getPreferredEditor: () => 'vscode',
+            });
+            const request = {
+                callId: 'call-1',
+                name: 'dangerous_tool',
+                args: {},
+                isClientInitiated: false,
+                prompt_id: 'prompt-1',
+            };
+            await scheduler.schedule(request, new AbortController().signal);
+            expect(onAllToolCallsComplete).toHaveBeenCalledTimes(1);
+            const reportedTools = onAllToolCallsComplete.mock.calls[0][0];
+            const result = reportedTools[0];
+            expect(result.status).toBe(CoreToolCallStatus.Error);
+            expect(result.response.errorType).toBe(ToolErrorType.POLICY_VIOLATION);
+            expect(result.response.error.message).toBe(`Tool execution denied by policy. ${customDenyMessage}`);
+        });
+    });
+    describe('ApprovalMode Preservation', () => {
+        it('should preserve approvalMode throughout tool lifecycle', async () => {
+            // Arrange
+            const executeFn = vi.fn().mockResolvedValue({
+                llmContent: 'Tool executed',
+                returnDisplay: 'Tool executed',
+            });
+            const mockTool = new MockTool({
+                name: 'mockTool',
+                execute: executeFn,
+                shouldConfirmExecute: MOCK_TOOL_SHOULD_CONFIRM_EXECUTE,
+            });
+            const mockToolRegistry = {
+                getTool: () => mockTool,
+                getAllToolNames: () => ['mockTool'],
+            };
+            const onAllToolCallsComplete = vi.fn();
+            const onToolCallsUpdate = vi.fn();
+            // Set approval mode to PLAN
+            const mockConfig = createMockConfig({
+                getToolRegistry: () => mockToolRegistry,
+                getApprovalMode: () => ApprovalMode.PLAN,
+                // Ensure policy engine returns ASK_USER to trigger AwaitingApproval state
+                getPolicyEngine: () => ({
+                    check: async () => ({ decision: PolicyDecision.ASK_USER }),
+                }),
+            });
+            mockConfig.getHookSystem = vi.fn().mockReturnValue(undefined);
+            const scheduler = new CoreToolScheduler({
+                config: mockConfig,
+                onAllToolCallsComplete,
+                onToolCallsUpdate,
+                getPreferredEditor: () => 'vscode',
+            });
+            const abortController = new AbortController();
+            const request = {
+                callId: '1',
+                name: 'mockTool',
+                args: { param: 'value' },
+                isClientInitiated: false,
+                prompt_id: 'test-prompt',
+            };
+            // Act - Schedule
+            const schedulePromise = scheduler.schedule(request, abortController.signal);
+            // Assert - Check AwaitingApproval state
+            const awaitingCall = (await waitForStatus(onToolCallsUpdate, CoreToolCallStatus.AwaitingApproval));
+            expect(awaitingCall).toBeDefined();
+            expect(awaitingCall.approvalMode).toBe(ApprovalMode.PLAN);
+            // Act - Confirm
+            await awaitingCall.confirmationDetails.onConfirm(ToolConfirmationOutcome.ProceedOnce);
+            // Wait for completion
+            await schedulePromise;
+            // Assert - Check Success state
+            expect(onAllToolCallsComplete).toHaveBeenCalled();
+            const completedCalls = onAllToolCallsComplete.mock
+                .calls[0][0];
+            expect(completedCalls).toHaveLength(1);
+            expect(completedCalls[0].status).toBe(CoreToolCallStatus.Success);
+            expect(completedCalls[0].approvalMode).toBe(ApprovalMode.PLAN);
+        });
+    });
 });
 //# sourceMappingURL=coreToolScheduler.test.js.map