@google/gemini-cli-core 0.30.0-preview.6 → 0.31.0-preview.0

package/dist/src/scheduler/scheduler.test.js

@@ -12,7 +12,6 @@ vi.mock('../telemetry/trace.js', () => ({
     runInDevTraceSpan: vi.fn(async (_opts, fn) => fn({ metadata: { input: {}, output: {} } })),
 }));
 import { logToolCall } from '../telemetry/loggers.js';
-import { ToolCallEvent } from '../telemetry/types.js';
 vi.mock('../telemetry/loggers.js', () => ({
     logToolCall: vi.fn(),
 }));
@@ -43,6 +42,7 @@ import { CoreToolCallStatus, ROOT_SCHEDULER_ID } from './types.js';
 import { ToolErrorType } from '../tools/tool-error.js';
 import * as ToolUtils from '../utils/tool-utils.js';
 import { getToolCallContext, } from '../utils/toolCallContext.js';
+import { coreEvents, CoreEvent, } from '../utils/events.js';
 describe('Scheduler (Orchestrator)', () => {
     let scheduler;
     let signal;
@@ -109,28 +109,61 @@ describe('Scheduler (Orchestrator)', () => {
         };
         getPreferredEditor = vi.fn().mockReturnValue('vim');
         // --- Setup Sub-component Mocks ---
+        const mockActiveCallsMap = new Map();
+        const mockQueue = [];
         mockStateManager = {
-            enqueue: vi.fn(),
-            dequeue: vi.fn(),
-            getToolCall: vi.fn(),
-            updateStatus: vi.fn(),
-            finalizeCall: vi.fn(),
+            enqueue: vi.fn((calls) => {
+                // Clone to preserve initial state for Phase 1 tests
+                mockQueue.push(...calls.map((c) => ({ ...c })));
+            }),
+            dequeue: vi.fn(() => {
+                const next = mockQueue.shift();
+                if (next)
+                    mockActiveCallsMap.set(next.request.callId, next);
+                return next;
+            }),
+            peekQueue: vi.fn(() => mockQueue[0]),
+            getToolCall: vi.fn((id) => mockActiveCallsMap.get(id)),
+            updateStatus: vi.fn((id, status) => {
+                const call = mockActiveCallsMap.get(id);
+                if (call)
+                    call.status = status;
+            }),
+            finalizeCall: vi.fn((id) => {
+                const call = mockActiveCallsMap.get(id);
+                if (call) {
+                    mockActiveCallsMap.delete(id);
+                    capturedTerminalHandler?.(call);
+                }
+            }),
             updateArgs: vi.fn(),
             setOutcome: vi.fn(),
-            cancelAllQueued: vi.fn(),
+            cancelAllQueued: vi.fn(() => {
+                mockQueue.length = 0;
+            }),
             clearBatch: vi.fn(),
+            replaceActiveCallWithTailCall: vi.fn((id, nextCall) => {
+                if (mockActiveCallsMap.has(id)) {
+                    mockActiveCallsMap.delete(id);
+                    mockQueue.unshift(nextCall);
+                }
+            }),
         };
         // Define getters for accessors idiomatically
         Object.defineProperty(mockStateManager, 'isActive', {
-            get: vi.fn().mockReturnValue(false),
+            get: vi.fn(() => mockActiveCallsMap.size > 0),
+            configurable: true,
+        });
+        Object.defineProperty(mockStateManager, 'allActiveCalls', {
+            get: vi.fn(() => Array.from(mockActiveCallsMap.values())),
             configurable: true,
         });
         Object.defineProperty(mockStateManager, 'queueLength', {
-            get: vi.fn().mockReturnValue(0),
+            get: vi.fn(() => mockQueue.length),
             configurable: true,
         });
         Object.defineProperty(mockStateManager, 'firstActiveCall', {
-            get: vi.fn().mockReturnValue(undefined),
+            get: vi.fn(() => mockActiveCallsMap.values().next().value),
             configurable: true,
         });
         Object.defineProperty(mockStateManager, 'completedBatch', {
@@ -159,8 +192,9 @@ describe('Scheduler (Orchestrator)', () => {
             return mockStateManager;
         });
         mockStateManager.finalizeCall.mockImplementation((callId) => {
-            const call = mockStateManager.getToolCall(callId);
+            const call = mockActiveCallsMap.get(callId);
             if (call) {
+                mockActiveCallsMap.delete(callId);
                 capturedTerminalHandler?.(call);
             }
         });
@@ -170,6 +204,13 @@ describe('Scheduler (Orchestrator)', () => {
             // but most tests here check if finalizing is called.
         });
         vi.mocked(ToolExecutor).mockReturnValue(mockExecutor);
+        mockExecutor.execute.mockResolvedValue({
+            status: 'success',
+            response: {
+                callId: 'default',
+                responseParts: [],
+            },
+        });
         vi.mocked(ToolModificationHandler).mockReturnValue(mockModifier);
         // Initialize Scheduler
         scheduler = new Scheduler({
@@ -239,79 +280,16 @@ describe('Scheduler (Orchestrator)', () => {
     });
     describe('Phase 2: Queue Management', () => {
         it('should drain the queue if multiple calls are scheduled', async () => {
-            const validatingCall = {
-                status: CoreToolCallStatus.Validating,
-                request: req1,
-                tool: mockTool,
-                invocation: mockInvocation,
-            };
-            // Setup queue simulation: two items
-            Object.defineProperty(mockStateManager, 'queueLength', {
-                get: vi
-                    .fn()
-                    .mockReturnValueOnce(2)
-                    .mockReturnValueOnce(1)
-                    .mockReturnValue(0),
-                configurable: true,
-            });
-            Object.defineProperty(mockStateManager, 'isActive', {
-                get: vi.fn().mockReturnValue(false),
-                configurable: true,
-            });
-            mockStateManager.dequeue.mockReturnValue(validatingCall);
-            vi.mocked(mockStateManager.dequeue).mockReturnValue(validatingCall);
-            Object.defineProperty(mockStateManager, 'firstActiveCall', {
-                get: vi.fn().mockReturnValue(validatingCall),
-                configurable: true,
-            });
             // Execute is the end of the loop, stub it
             mockExecutor.execute.mockResolvedValue({
                 status: CoreToolCallStatus.Success,
             });
             await scheduler.schedule(req1, signal);
-            // Verify loop ran twice
-            expect(mockStateManager.dequeue).toHaveBeenCalledTimes(2);
-            expect(mockStateManager.finalizeCall).toHaveBeenCalledTimes(2);
+            // Verify loop ran once for this schedule call (which had 1 request)
+            // schedule(req1) enqueues 1 request.
+            expect(mockExecutor.execute).toHaveBeenCalledTimes(1);
         });
         it('should execute tool calls sequentially (first completes before second starts)', async () => {
-            // Setup queue simulation: two items
-            Object.defineProperty(mockStateManager, 'queueLength', {
-                get: vi
-                    .fn()
-                    .mockReturnValueOnce(2)
-                    .mockReturnValueOnce(1)
-                    .mockReturnValue(0),
-                configurable: true,
-            });
-            Object.defineProperty(mockStateManager, 'isActive', {
-                get: vi.fn().mockReturnValue(false),
-                configurable: true,
-            });
-            const validatingCall1 = {
-                status: CoreToolCallStatus.Validating,
-                request: req1,
-                tool: mockTool,
-                invocation: mockInvocation,
-            };
-            const validatingCall2 = {
-                status: CoreToolCallStatus.Validating,
-                request: req2,
-                tool: mockTool,
-                invocation: mockInvocation,
-            };
-            vi.mocked(mockStateManager.dequeue)
-                .mockReturnValueOnce(validatingCall1)
-                .mockReturnValueOnce(validatingCall2)
-                .mockReturnValue(undefined);
-            Object.defineProperty(mockStateManager, 'firstActiveCall', {
-                get: vi
-                    .fn()
-                    .mockReturnValueOnce(validatingCall1) // Used in loop check for call 1
-                    .mockReturnValueOnce(validatingCall1) // Used in _execute for call 1
-                    .mockReturnValueOnce(validatingCall2) // Used in loop check for call 2
-                    .mockReturnValueOnce(validatingCall2), // Used in _execute for call 2
-                configurable: true,
-            });
             const executionLog = [];
             // Mock executor to push to log with a deterministic microtask delay
             mockExecutor.execute.mockImplementation(async ({ call }) => {
@@ -335,47 +313,6 @@ describe('Scheduler (Orchestrator)', () => {
             ]);
         });
         it('should queue and process multiple schedule() calls made synchronously', async () => {
-            const validatingCall1 = {
-                status: CoreToolCallStatus.Validating,
-                request: req1,
-                tool: mockTool,
-                invocation: mockInvocation,
-            };
-            const validatingCall2 = {
-                status: CoreToolCallStatus.Validating,
-                request: req2, // Second request
-                tool: mockTool,
-                invocation: mockInvocation,
-            };
-            // Mock state responses dynamically
-            Object.defineProperty(mockStateManager, 'isActive', {
-                get: vi.fn().mockReturnValue(false),
-                configurable: true,
-            });
-            // Queue state responses for the two batches:
-            // Batch 1: length 1 -> 0
-            // Batch 2: length 1 -> 0
-            Object.defineProperty(mockStateManager, 'queueLength', {
-                get: vi
-                    .fn()
-                    .mockReturnValueOnce(1)
-                    .mockReturnValueOnce(0)
-                    .mockReturnValueOnce(1)
-                    .mockReturnValue(0),
-                configurable: true,
-            });
-            vi.mocked(mockStateManager.dequeue)
-                .mockReturnValueOnce(validatingCall1)
-                .mockReturnValueOnce(validatingCall2);
-            Object.defineProperty(mockStateManager, 'firstActiveCall', {
-                get: vi
-                    .fn()
-                    .mockReturnValueOnce(validatingCall1)
-                    .mockReturnValueOnce(validatingCall1)
-                    .mockReturnValueOnce(validatingCall2)
-                    .mockReturnValueOnce(validatingCall2),
-                configurable: true,
-            });
             // Executor succeeds instantly
             mockExecutor.execute.mockResolvedValue({
                 status: CoreToolCallStatus.Success,
@@ -390,44 +327,6 @@ describe('Scheduler (Orchestrator)', () => {
             expect(mockStateManager.finalizeCall).toHaveBeenCalledWith('call-2');
         });
         it('should queue requests when scheduler is busy (overlapping batches)', async () => {
-            const validatingCall1 = {
-                status: CoreToolCallStatus.Validating,
-                request: req1,
-                tool: mockTool,
-                invocation: mockInvocation,
-            };
-            const validatingCall2 = {
-                status: CoreToolCallStatus.Validating,
-                request: req2, // Second request
-                tool: mockTool,
-                invocation: mockInvocation,
-            };
-            // 1. Setup State Manager for 2 sequential batches
-            Object.defineProperty(mockStateManager, 'isActive', {
-                get: vi.fn().mockReturnValue(false),
-                configurable: true,
-            });
-            Object.defineProperty(mockStateManager, 'queueLength', {
-                get: vi
-                    .fn()
-                    .mockReturnValueOnce(1) // Batch 1
-                    .mockReturnValueOnce(0)
-                    .mockReturnValueOnce(1) // Batch 2
-                    .mockReturnValue(0),
-                configurable: true,
-            });
-            vi.mocked(mockStateManager.dequeue)
-                .mockReturnValueOnce(validatingCall1)
-                .mockReturnValueOnce(validatingCall2);
-            Object.defineProperty(mockStateManager, 'firstActiveCall', {
-                get: vi
-                    .fn()
-                    .mockReturnValueOnce(validatingCall1)
-                    .mockReturnValueOnce(validatingCall1)
-                    .mockReturnValueOnce(validatingCall2)
-                    .mockReturnValueOnce(validatingCall2),
-                configurable: true,
-            });
             // 2. Setup Executor with a controllable lock for the first batch
             const executionLog = [];
             let finishFirstBatch;
@@ -487,10 +386,8 @@ describe('Scheduler (Orchestrator)', () => {
                 tool: mockTool,
                 invocation: mockInvocation,
             };
-            Object.defineProperty(mockStateManager, 'firstActiveCall', {
-                get: vi.fn().mockReturnValue(activeCall),
-                configurable: true,
-            });
+            mockStateManager.enqueue([activeCall]);
+            mockStateManager.dequeue();
             scheduler.cancelAll();
             expect(mockStateManager.updateStatus).toHaveBeenCalledWith('call-1', CoreToolCallStatus.Cancelled, 'Operation cancelled by user');
             // finalizeCall is handled by the processing loop, not synchronously by cancelAll
@@ -515,23 +412,7 @@ describe('Scheduler (Orchestrator)', () => {
         });
     });
     describe('Phase 3: Policy & Confirmation Loop', () => {
-        const validatingCall = {
-            status: CoreToolCallStatus.Validating,
-            request: req1,
-            tool: mockTool,
-            invocation: mockInvocation,
-        };
-        beforeEach(() => {
-            Object.defineProperty(mockStateManager, 'queueLength', {
-                get: vi.fn().mockReturnValueOnce(1).mockReturnValue(0),
-                configurable: true,
-            });
-            vi.mocked(mockStateManager.dequeue).mockReturnValue(validatingCall);
-            Object.defineProperty(mockStateManager, 'firstActiveCall', {
-                get: vi.fn().mockReturnValue(validatingCall),
-                configurable: true,
-            });
-        });
+        beforeEach(() => { });
         it('should update state to error with POLICY_VIOLATION if Policy returns DENY', async () => {
             vi.mocked(checkPolicy).mockResolvedValue({
                 decision: PolicyDecision.DENY,
@@ -641,27 +522,6 @@ describe('Scheduler (Orchestrator)', () => {
             expect(mockExecutor.execute).toHaveBeenCalled();
         });
         it('should auto-approve remaining identical tools in batch after ProceedAlways', async () => {
-            // Setup: two identical tools
-            const validatingCall1 = {
-                status: CoreToolCallStatus.Validating,
-                request: req1,
-                tool: mockTool,
-                invocation: mockInvocation,
-            };
-            const validatingCall2 = {
-                status: CoreToolCallStatus.Validating,
-                request: req2,
-                tool: mockTool,
-                invocation: mockInvocation,
-            };
-            vi.mocked(mockStateManager.dequeue)
-                .mockReturnValueOnce(validatingCall1)
-                .mockReturnValueOnce(validatingCall2)
-                .mockReturnValue(undefined);
-            vi.spyOn(mockStateManager, 'queueLength', 'get')
-                .mockReturnValueOnce(2)
-                .mockReturnValueOnce(1)
-                .mockReturnValue(0);
             // First call requires confirmation, second is auto-approved (simulating policy update)
             vi.mocked(checkPolicy)
                 .mockResolvedValueOnce({
@@ -730,6 +590,7 @@ describe('Scheduler (Orchestrator)', () => {
             vi.mocked(resolveConfirmation).mockResolvedValue(resolution);
             await scheduler.schedule(req1, signal);
             expect(mockStateManager.updateStatus).toHaveBeenCalledWith('call-1', CoreToolCallStatus.Cancelled, 'User denied execution.');
+            expect(mockStateManager.setOutcome).toHaveBeenCalledWith('call-1', ToolConfirmationOutcome.Cancel);
             expect(mockStateManager.cancelAllQueued).toHaveBeenCalledWith('User cancelled operation');
             expect(mockExecutor.execute).not.toHaveBeenCalled();
         });
@@ -777,18 +638,7 @@ describe('Scheduler (Orchestrator)', () => {
         });
     });
     describe('Phase 4: Execution Outcomes', () => {
-        const validatingCall = {
-            status: CoreToolCallStatus.Validating,
-            request: req1,
-            tool: mockTool,
-            invocation: mockInvocation,
-        };
         beforeEach(() => {
-            vi.spyOn(mockStateManager, 'queueLength', 'get')
-                .mockReturnValueOnce(1)
-                .mockReturnValue(0);
-            mockStateManager.dequeue.mockReturnValue(validatingCall);
-            vi.spyOn(mockStateManager, 'firstActiveCall', 'get').mockReturnValue(validatingCall);
             mockPolicyEngine.check.mockResolvedValue({
                 decision: PolicyDecision.ALLOW,
             }); // Bypass confirmation
@@ -835,25 +685,11 @@ describe('Scheduler (Orchestrator)', () => {
                 status: CoreToolCallStatus.Success,
                 response: mockResponse,
             });
-            // Mock the state manager to return a SUCCESS state when getToolCall is
-            // called
-            const successfulCall = {
-                status: CoreToolCallStatus.Success,
-                request: req1,
-                response: mockResponse,
-                tool: mockTool,
-                invocation: mockInvocation,
-            };
-            mockStateManager.getToolCall.mockReturnValue(successfulCall);
-            Object.defineProperty(mockStateManager, 'completedBatch', {
-                get: vi.fn().mockReturnValue([successfulCall]),
-                configurable: true,
-            });
             await scheduler.schedule(req1, signal);
             // Verify the finalizer and logger were called
             expect(mockStateManager.finalizeCall).toHaveBeenCalledWith('call-1');
-            expect(ToolCallEvent).toHaveBeenCalledWith(successfulCall);
-            expect(logToolCall).toHaveBeenCalledWith(mockConfig, expect.objectContaining(successfulCall));
+            // We check that logToolCall was called (it's called via the state manager's terminal handler)
+            expect(logToolCall).toHaveBeenCalled();
         });
         it('should not double-report completed tools when concurrent completions occur', async () => {
             // Simulate a race where execution finishes but cancelAll is called immediately after
@@ -876,6 +712,114 @@ describe('Scheduler (Orchestrator)', () => {
             expect(mockStateManager.finalizeCall).toHaveBeenCalledTimes(1);
             expect(mockStateManager.finalizeCall).toHaveBeenCalledWith('call-1');
         });
+        it('should break the loop if no progress is made (safeguard against stuck states)', async () => {
+            // Setup: A tool that is 'validating' but stays 'validating' even after processing
+            // This simulates a bug in state management or a weird edge case.
+            const stuckCall = {
+                status: CoreToolCallStatus.Validating,
+                request: req1,
+                tool: mockTool,
+                invocation: mockInvocation,
+            };
+            // Mock dequeue to keep returning the same stuck call
+            mockStateManager.dequeue.mockReturnValue(stuckCall);
+            // Mock isActive to be true
+            Object.defineProperty(mockStateManager, 'isActive', {
+                get: vi.fn().mockReturnValue(true),
+                configurable: true,
+            });
+            // Mock updateStatus to do NOTHING (simulating no progress)
+            mockStateManager.updateStatus.mockImplementation(() => { });
+            // This should return false (break loop) instead of hanging indefinitely
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const result = await scheduler._processNextItem(signal);
+            expect(result).toBe(false);
+        });
+        describe('Tail Calls', () => {
+            it('should replace the active call with a new tool call and re-run the loop when tail call is requested', async () => {
+                // Setup: Tool A will return a success with a tail call request to Tool B
+                const mockResponse = {
+                    callId: 'call-1',
+                    responseParts: [],
+                };
+                mockExecutor.execute
+                    .mockResolvedValueOnce({
+                    status: 'success',
+                    response: mockResponse,
+                    tailToolCallRequest: {
+                        name: 'tool-b',
+                        args: { key: 'value' },
+                    },
+                    request: req1,
+                })
+                    .mockResolvedValueOnce({
+                    status: 'success',
+                    response: mockResponse,
+                    request: {
+                        ...req1,
+                        name: 'tool-b',
+                        args: { key: 'value' },
+                        originalRequestName: 'test-tool',
+                    },
+                });
+                const mockToolB = {
+                    name: 'tool-b',
+                    build: vi.fn().mockReturnValue({}),
+                };
+                vi.mocked(mockToolRegistry.getTool).mockReturnValue(mockToolB);
+                await scheduler.schedule(req1, signal);
+                // Assert: The state manager is instructed to replace the call
+                expect(mockStateManager.replaceActiveCallWithTailCall).toHaveBeenCalledWith('call-1', expect.objectContaining({
+                    request: expect.objectContaining({
+                        callId: 'call-1',
+                        name: 'tool-b',
+                        args: { key: 'value' },
+                        originalRequestName: 'test-tool', // Preserves original name
+                    }),
+                    tool: mockToolB,
+                }));
+                // Assert: The executor should be called twice (once for Tool A, once for Tool B)
+                expect(mockExecutor.execute).toHaveBeenCalledTimes(2);
+            });
+            it('should inject an errored tool call if the tail tool is not found', async () => {
+                const mockResponse = {
+                    callId: 'call-1',
+                    responseParts: [],
+                };
+                mockExecutor.execute.mockResolvedValue({
+                    status: 'success',
+                    response: mockResponse,
+                    tailToolCallRequest: {
+                        name: 'missing-tool',
+                        args: {},
+                    },
+                    request: req1,
+                });
+                // Tool registry returns undefined for missing-tool, but valid tool for test-tool
+                vi.mocked(mockToolRegistry.getTool).mockImplementation((name) => {
+                    if (name === 'test-tool') {
+                        return {
+                            name: 'test-tool',
+                            build: vi.fn().mockReturnValue({}),
+                        };
+                    }
+                    return undefined;
+                });
+                await scheduler.schedule(req1, signal);
+                // Assert: Replaces active call with an errored call
+                expect(mockStateManager.replaceActiveCallWithTailCall).toHaveBeenCalledWith('call-1', expect.objectContaining({
+                    status: 'error',
+                    request: expect.objectContaining({
+                        callId: 'call-1',
+                        name: 'missing-tool', // Name of the failed tail call
+                        originalRequestName: 'test-tool',
+                    }),
+                    response: expect.objectContaining({
+                        errorType: ToolErrorType.TOOL_NOT_REGISTERED,
+                    }),
+                }));
+            });
+        });
     });
     describe('Tool Call Context Propagation', () => {
         it('should propagate context to the tool executor', async () => {
@@ -888,23 +832,6 @@ describe('Scheduler (Orchestrator)', () => {
                 schedulerId,
                 parentCallId,
             });
-            const validatingCall = {
-                status: CoreToolCallStatus.Validating,
-                request: req1,
-                tool: mockTool,
-                invocation: mockInvocation,
-            };
-            // Mock queueLength to run the loop once
-            Object.defineProperty(mockStateManager, 'queueLength', {
-                get: vi.fn().mockReturnValueOnce(1).mockReturnValue(0),
-                configurable: true,
-            });
-            vi.mocked(mockStateManager.dequeue).mockReturnValue(validatingCall);
-            Object.defineProperty(mockStateManager, 'firstActiveCall', {
-                get: vi.fn().mockReturnValue(validatingCall),
-                configurable: true,
-            });
-            vi.mocked(mockStateManager.getToolCall).mockReturnValue(validatingCall);
             mockToolRegistry.getTool.mockReturnValue(mockTool);
             mockPolicyEngine.check.mockResolvedValue({
                 decision: PolicyDecision.ALLOW,
@@ -933,5 +860,177 @@ describe('Scheduler (Orchestrator)', () => {
             expect(capturedContext.parentCallId).toBe(parentCallId);
         });
     });
+    describe('Cleanup', () => {
+        it('should unregister McpProgress listener on dispose()', () => {
+            const onSpy = vi.spyOn(coreEvents, 'on');
+            const offSpy = vi.spyOn(coreEvents, 'off');
+            const s = new Scheduler({
+                config: mockConfig,
+                messageBus: mockMessageBus,
+                getPreferredEditor,
+                schedulerId: 'cleanup-test',
+            });
+            expect(onSpy).toHaveBeenCalledWith(CoreEvent.McpProgress, expect.any(Function));
+            s.dispose();
+            expect(offSpy).toHaveBeenCalledWith(CoreEvent.McpProgress, expect.any(Function));
+        });
+    });
+});
+describe('Scheduler MCP Progress', () => {
+    let scheduler;
+    let mockStateManager;
+    let mockActiveCallsMap;
+    let mockConfig;
+    let mockMessageBus;
+    let getPreferredEditor;
+    const makePayload = (callId, progress, overrides = {}) => ({
+        serverName: 'test-server',
+        callId,
+        progressToken: 'tok-1',
+        progress,
+        ...overrides,
+    });
+    const makeExecutingCall = (callId) => ({
+        status: CoreToolCallStatus.Executing,
+        request: {
+            callId,
+            name: 'mcp-tool',
+            args: {},
+            isClientInitiated: false,
+            prompt_id: 'p-1',
+            schedulerId: ROOT_SCHEDULER_ID,
+            parentCallId: undefined,
+        },
+        tool: {
+            name: 'mcp-tool',
+            build: vi.fn(),
+        },
+        invocation: {},
+    });
+    beforeEach(() => {
+        vi.mocked(randomUUID).mockReturnValue('123e4567-e89b-12d3-a456-426614174000');
+        mockActiveCallsMap = new Map();
+        mockStateManager = {
+            enqueue: vi.fn(),
+            dequeue: vi.fn(),
+            peekQueue: vi.fn(),
+            getToolCall: vi.fn((id) => mockActiveCallsMap.get(id)),
+            updateStatus: vi.fn(),
+            finalizeCall: vi.fn(),
+            updateArgs: vi.fn(),
+            setOutcome: vi.fn(),
+            cancelAllQueued: vi.fn(),
+            clearBatch: vi.fn(),
+        };
+        Object.defineProperty(mockStateManager, 'isActive', {
+            get: vi.fn(() => mockActiveCallsMap.size > 0),
+            configurable: true,
+        });
+        Object.defineProperty(mockStateManager, 'allActiveCalls', {
+            get: vi.fn(() => Array.from(mockActiveCallsMap.values())),
+            configurable: true,
+        });
+        Object.defineProperty(mockStateManager, 'queueLength', {
+            get: vi.fn(() => 0),
+            configurable: true,
+        });
+        Object.defineProperty(mockStateManager, 'firstActiveCall', {
+            get: vi.fn(() => mockActiveCallsMap.values().next().value),
+            configurable: true,
+        });
+        Object.defineProperty(mockStateManager, 'completedBatch', {
+            get: vi.fn().mockReturnValue([]),
+            configurable: true,
+        });
+        const mockPolicyEngine = {
+            check: vi.fn().mockResolvedValue({ decision: PolicyDecision.ALLOW }),
+        };
+        const mockToolRegistry = {
+            getTool: vi.fn(),
+            getAllToolNames: vi.fn().mockReturnValue([]),
+        };
+        mockConfig = {
+            getPolicyEngine: vi.fn().mockReturnValue(mockPolicyEngine),
+            getToolRegistry: vi.fn().mockReturnValue(mockToolRegistry),
+            isInteractive: vi.fn().mockReturnValue(true),
+            getEnableHooks: vi.fn().mockReturnValue(true),
+            setApprovalMode: vi.fn(),
+            getApprovalMode: vi.fn().mockReturnValue(ApprovalMode.DEFAULT),
+        };
+        mockMessageBus = {
+            publish: vi.fn(),
+            subscribe: vi.fn(),
+        };
+        getPreferredEditor = vi.fn().mockReturnValue('vim');
+        vi.mocked(SchedulerStateManager).mockImplementation((_messageBus, _schedulerId, _onTerminalCall) => mockStateManager);
+        scheduler = new Scheduler({
+            config: mockConfig,
+            messageBus: mockMessageBus,
+            getPreferredEditor,
+            schedulerId: 'progress-test',
+        });
+    });
+    afterEach(() => {
+        scheduler.dispose();
+        vi.clearAllMocks();
+    });
+    it('should update state on progress event', () => {
+        const call = makeExecutingCall('call-A');
+        mockActiveCallsMap.set('call-A', call);
+        coreEvents.emit(CoreEvent.McpProgress, makePayload('call-A', 10));
+        expect(mockStateManager.updateStatus).toHaveBeenCalledTimes(1);
+        expect(mockStateManager.updateStatus).toHaveBeenCalledWith('call-A', CoreToolCallStatus.Executing, expect.objectContaining({ progress: 10 }));
+    });
+    it('should not respond to progress events after dispose()', () => {
+        const call = makeExecutingCall('call-A');
+        mockActiveCallsMap.set('call-A', call);
+        scheduler.dispose();
+        coreEvents.emit(CoreEvent.McpProgress, makePayload('call-A', 10));
+        expect(mockStateManager.updateStatus).not.toHaveBeenCalled();
+    });
+    it('should handle concurrent calls independently', () => {
+        const callA = makeExecutingCall('call-A');
+        const callB = makeExecutingCall('call-B');
+        mockActiveCallsMap.set('call-A', callA);
+        mockActiveCallsMap.set('call-B', callB);
+        coreEvents.emit(CoreEvent.McpProgress, makePayload('call-A', 10));
+        coreEvents.emit(CoreEvent.McpProgress, makePayload('call-B', 20));
+        expect(mockStateManager.updateStatus).toHaveBeenCalledTimes(2);
+        expect(mockStateManager.updateStatus).toHaveBeenCalledWith('call-A', CoreToolCallStatus.Executing, expect.objectContaining({ progress: 10 }));
+        expect(mockStateManager.updateStatus).toHaveBeenCalledWith('call-B', CoreToolCallStatus.Executing, expect.objectContaining({ progress: 20 }));
+    });
+    it('should ignore progress for a callId not in active calls', () => {
+        coreEvents.emit(CoreEvent.McpProgress, makePayload('unknown-call', 10));
+        expect(mockStateManager.updateStatus).not.toHaveBeenCalled();
+    });
+    it('should ignore progress for a call in a terminal state', () => {
+        const successCall = {
+            status: CoreToolCallStatus.Success,
+            request: {
+                callId: 'call-done',
+                name: 'mcp-tool',
+                args: {},
+                isClientInitiated: false,
+                prompt_id: 'p-1',
+                schedulerId: ROOT_SCHEDULER_ID,
+                parentCallId: undefined,
+            },
+            tool: { name: 'mcp-tool' },
+            response: { callId: 'call-done', responseParts: [] },
+        };
+        mockActiveCallsMap.set('call-done', successCall);
+        coreEvents.emit(CoreEvent.McpProgress, makePayload('call-done', 50));
+        expect(mockStateManager.updateStatus).not.toHaveBeenCalled();
+    });
+    it('should compute validTotal and percentage for determinate progress', () => {
+        const call = makeExecutingCall('call-A');
+        mockActiveCallsMap.set('call-A', call);
+        coreEvents.emit(CoreEvent.McpProgress, makePayload('call-A', 50, { total: 100 }));
+        expect(mockStateManager.updateStatus).toHaveBeenCalledWith('call-A', CoreToolCallStatus.Executing, expect.objectContaining({
+            progress: 50,
+            progressTotal: 100,
+            progressPercent: 50,
+        }));
+    });
 });
 //# sourceMappingURL=scheduler.test.js.map