@machina.ai/cell-cli-core 1.41.1-rc2 → 1.45.1-rc2

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

@@ -28,6 +28,7 @@ vi.mock('../tools/mcp-client-manager.js', () => ({
     },
 }));
 import { debugLogger } from '../utils/debugLogger.js';
+import { runWithToolCallContext } from '../utils/toolCallContext.js';
 import { LocalAgentExecutor } from './local-executor.js';
 import { makeFakeConfig } from '../test-utils/config.js';
 import { ToolRegistry } from '../tools/tool-registry.js';
@@ -46,6 +47,7 @@ import { promptIdContext } from '../utils/promptIdContext.js';
 import { logAgentStart, logAgentFinish, logRecoveryAttempt, } from '../telemetry/loggers.js';
 import { LlmRole, AgentStartEvent, AgentFinishEvent, RecoveryAttemptEvent, } from '../telemetry/types.js';
 import { AgentTerminateMode, SubagentActivityErrorType, } from './types.js';
+import { ApprovalMode } from '../policy/types.js';
 import { ToolConfirmationOutcome, Kind, } from '../tools/tools.js';
 import { CoreToolCallStatus, } from '../scheduler/types.js';
 import { CompressionStatus } from '../core/turn.js';
@@ -120,11 +122,15 @@ vi.mock('../config/scoped-config.js', async (importOriginal) => {
         ...actual,
         runWithScopedWorkspaceContext: vi.fn(actual.runWithScopedWorkspaceContext),
         createScopedWorkspaceContext: vi.fn(actual.createScopedWorkspaceContext),
+        runWithScopedAutoMemoryExtractionWriteAccess: vi.fn(actual.runWithScopedAutoMemoryExtractionWriteAccess),
+        runWithScopedMemoryInboxAccess: vi.fn(actual.runWithScopedMemoryInboxAccess),
     };
 });
-import { runWithScopedWorkspaceContext, createScopedWorkspaceContext, } from '../config/scoped-config.js';
+import { runWithScopedWorkspaceContext, createScopedWorkspaceContext, runWithScopedAutoMemoryExtractionWriteAccess, runWithScopedMemoryInboxAccess, } from '../config/scoped-config.js';
 const mockedRunWithScopedWorkspaceContext = vi.mocked(runWithScopedWorkspaceContext);
 const mockedCreateScopedWorkspaceContext = vi.mocked(createScopedWorkspaceContext);
+const mockedRunWithScopedMemoryInboxAccess = vi.mocked(runWithScopedMemoryInboxAccess);
+const mockedRunWithScopedAutoMemoryExtractionWriteAccess = vi.mocked(runWithScopedAutoMemoryExtractionWriteAccess);
 const MockedGeminiChat = vi.mocked(GeminiChat);
 const mockedGetDirectoryContextString = vi.mocked(getDirectoryContextString);
 const mockedPromptIdContext = vi.mocked(promptIdContext);
@@ -291,6 +297,8 @@ describe('LocalAgentExecutor', () => {
         mockedLogAgentFinish.mockReset();
         mockedRunWithScopedWorkspaceContext.mockClear();
         mockedCreateScopedWorkspaceContext.mockClear();
+        mockedRunWithScopedMemoryInboxAccess.mockClear();
+        mockedRunWithScopedAutoMemoryExtractionWriteAccess.mockClear();
         mockedPromptIdContext.getStore.mockReset();
         mockedPromptIdContext.run.mockImplementation((_id, fn) => fn());
         ChatCompressionService.mockImplementation(() => ({
@@ -486,15 +494,12 @@ describe('LocalAgentExecutor', () => {
             expect(agentRegistry.getAllToolNames()).toHaveLength(3);
             expect(agentRegistry.getTool(MOCK_TOOL_NOT_ALLOWED.name)).toBeUndefined();
         });
-        it('should use parentPromptId from context to create agentId', async () => {
-            const parentId = 'parent-id';
-            Object.defineProperty(mockConfig, 'promptId', {
-                get: () => parentId,
-                configurable: true,
-            });
+        it('should not include parentCallId in agentId even when available', async () => {
             const definition = createTestDefinition();
-            const executor = await LocalAgentExecutor.create(definition, mockConfig, onActivity);
-            expect(executor['agentId']).toBeDefined();
+            const parentCallId = 'parent-call-123';
+            const executor = await runWithToolCallContext({ callId: parentCallId, schedulerId: 'test-scheduler' }, () => LocalAgentExecutor.create(definition, mockConfig, onActivity));
+            expect(executor['agentId']).not.toContain(parentCallId);
+            expect(executor['agentId']).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i);
         });
         it('should correctly apply templates to initialMessages', async () => {
             const definition = createTestDefinition();
@@ -520,10 +525,15 @@ describe('LocalAgentExecutor', () => {
             const startHistory = chatConstructorArgs[3]; // history is the 4th arg
             expect(startHistory).toBeDefined();
             expect(startHistory).toHaveLength(2);
+            const history = startHistory;
             // Perform checks on defined objects to satisfy TS
-            const firstPart = startHistory?.[0]?.parts?.[0];
+            const firstPart = 'content' in history[0]
+                ? history[0].content.parts?.[0]
+                : history[0].parts?.[0];
             expect(firstPart?.text).toBe('Goal: TestGoal');
-            const secondPart = startHistory?.[1]?.parts?.[0];
+            const secondPart = 'content' in history[1]
+                ? history[1].content.parts?.[0]
+                : history[1].parts?.[0];
             expect(secondPart?.text).toBe('OK, starting on TestGoal.');
         });
         it('should filter out subagent tools to prevent recursion', async () => {
@@ -632,6 +642,34 @@ describe('LocalAgentExecutor', () => {
             expect(mockedCreateScopedWorkspaceContext).toHaveBeenCalledOnce();
             expect(mockedRunWithScopedWorkspaceContext).toHaveBeenCalledOnce();
         });
+        it('should use runWithScopedMemoryInboxAccess when memoryInboxAccess is set', async () => {
+            const definition = createTestDefinition();
+            definition.memoryInboxAccess = true;
+            const executor = await LocalAgentExecutor.create(definition, mockConfig, onActivity);
+            mockModelResponse([
+                {
+                    name: COMPLETE_TASK_TOOL_NAME,
+                    args: { finalResult: 'done' },
+                    id: 'c1',
+                },
+            ]);
+            await executor.run({ goal: 'test' }, signal);
+            expect(mockedRunWithScopedMemoryInboxAccess).toHaveBeenCalledOnce();
+        });
+        it('should use the extraction write scope when autoMemoryExtractionWriteAccess is set', async () => {
+            const definition = createTestDefinition();
+            definition.autoMemoryExtractionWriteAccess = true;
+            const executor = await LocalAgentExecutor.create(definition, mockConfig, onActivity);
+            mockModelResponse([
+                {
+                    name: COMPLETE_TASK_TOOL_NAME,
+                    args: { finalResult: 'done' },
+                    id: 'c1',
+                },
+            ]);
+            await executor.run({ goal: 'test' }, signal);
+            expect(mockedRunWithScopedAutoMemoryExtractionWriteAccess).toHaveBeenCalledOnce();
+        });
         it('should not use runWithScopedWorkspaceContext when workspaceDirectories is not set', async () => {
             const definition = createTestDefinition();
             const executor = await LocalAgentExecutor.create(definition, mockConfig, onActivity);
@@ -646,6 +684,8 @@ describe('LocalAgentExecutor', () => {
             await executor.run({ goal: 'test' }, signal);
             expect(mockedCreateScopedWorkspaceContext).not.toHaveBeenCalled();
             expect(mockedRunWithScopedWorkspaceContext).not.toHaveBeenCalled();
+            expect(mockedRunWithScopedMemoryInboxAccess).not.toHaveBeenCalled();
+            expect(mockedRunWithScopedAutoMemoryExtractionWriteAccess).not.toHaveBeenCalled();
         });
     });
     describe('run (Execution Loop and Logic)', () => {
@@ -873,6 +913,24 @@ describe('LocalAgentExecutor', () => {
             expect(output.terminate_reason).toBe(AgentTerminateMode.GOAL);
             expect(mockScheduleAgentTools).toHaveBeenCalledTimes(2);
         });
+        it('should inject Plan Mode context into the system prompt when in Plan Mode', async () => {
+            const definition = createTestDefinition([LS_TOOL_NAME], {}, 'none');
+            vi.spyOn(mockConfig, 'getApprovalMode').mockReturnValue(ApprovalMode.PLAN);
+            vi.spyOn(mockConfig.storage, 'getPlansDir').mockReturnValue('/mock/plans');
+            const executor = await LocalAgentExecutor.create(definition, mockConfig, onActivity);
+            // Turn 1: Model calls complete_task immediately
+            mockModelResponse([
+                {
+                    name: COMPLETE_TASK_TOOL_NAME,
+                    args: { result: 'Plan done' },
+                    id: 'call1',
+                },
+            ], 'Task finished.');
+            await executor.run({ goal: 'Do plan' }, signal);
+            const systemInstruction = MockedGeminiChat.mock.calls[0][1];
+            expect(systemInstruction).toContain('Execution Constraints');
+            expect(systemInstruction).toContain('You are currently operating in Plan Mode. Your write tools are globally restricted to only modifying plan (.md) files in the plans directory: /mock/plans/');
+        });
         it('should error immediately if the model stops tools without calling complete_task (Protocol Violation)', async () => {
             const definition = createTestDefinition();
             const executor = await LocalAgentExecutor.create(definition, mockConfig, onActivity);
@@ -1550,6 +1608,45 @@ describe('LocalAgentExecutor', () => {
             // Agent should terminate with ABORTED status
             expect(output.terminate_reason).toBe(AgentTerminateMode.ABORTED);
         });
+        it('should throw a critical error when a tool response is dropped by the scheduler', async () => {
+            const definition = createTestDefinition([LS_TOOL_NAME]);
+            const executor = await LocalAgentExecutor.create(definition, mockConfig, onActivity);
+            // Turn 1: Model calls two tools
+            mockModelResponse([
+                { name: LS_TOOL_NAME, args: { path: 'dir1' }, id: 'call1' },
+                { name: LS_TOOL_NAME, args: { path: 'dir2' }, id: 'call2' },
+            ]);
+            // Simulate scheduler returning only ONE result for TWO calls (dropped response)
+            mockScheduleAgentTools.mockResolvedValueOnce([
+                {
+                    status: 'success',
+                    request: { callId: 'call1', name: LS_TOOL_NAME },
+                    response: {
+                        responseParts: [
+                            {
+                                functionResponse: {
+                                    name: LS_TOOL_NAME,
+                                    id: 'call1',
+                                    response: { ok: true },
+                                },
+                            },
+                        ],
+                    },
+                },
+            ]);
+            await expect(executor.run({ goal: 'Protocol test' }, signal)).rejects.toThrow('Critical System Failure: Tool execution result was lost/dropped by the scheduler');
+        });
+        it('should throw a critical error when all scheduler results are missing/dropped', async () => {
+            const definition = createTestDefinition([LS_TOOL_NAME]);
+            const executor = await LocalAgentExecutor.create(definition, mockConfig, onActivity);
+            // Turn 1: Model calls one tool
+            mockModelResponse([
+                { name: LS_TOOL_NAME, args: { path: 'dir1' }, id: 'call1' },
+            ]);
+            // Simulate scheduler returning NO results (dropped response)
+            mockScheduleAgentTools.mockResolvedValueOnce([]);
+            await expect(executor.run({ goal: 'Protocol test 2' }, signal)).rejects.toThrow('Critical System Failure: Tool execution result was lost/dropped by the scheduler');
+        });
     });
     describe('Model Routing', () => {
         it('should use model routing when the agent model is "auto"', async () => {
@@ -1579,6 +1676,66 @@ describe('LocalAgentExecutor', () => {
             expect(mockRouter.route).toHaveBeenCalled();
             expect(mockSendMessageStream).toHaveBeenCalledWith(expect.objectContaining({ model: 'routed-model' }), expect.any(Array), expect.any(String), expect.any(AbortSignal), LlmRole.SUBAGENT);
         });
+        it('should cache the routing decision across multiple turns', async () => {
+            const definition = createTestDefinition();
+            definition.modelConfig.model = 'auto';
+            definition.runConfig.maxTurns = 3;
+            const mockRouter = {
+                route: vi.fn().mockResolvedValue({
+                    model: 'routed-model',
+                    metadata: { source: 'test', reasoning: 'test' },
+                }),
+            };
+            vi.spyOn(mockConfig, 'getModelRouterService').mockReturnValue(mockRouter);
+            vi.spyOn(mockConfig.modelConfigService, 'getResolvedConfig').mockReturnValue({
+                model: 'auto',
+                generateContentConfig: {},
+            });
+            const executor = await LocalAgentExecutor.create(definition, mockConfig, onActivity);
+            mockModelResponse([
+                {
+                    name: LS_TOOL_NAME,
+                    args: {},
+                    id: 'call1',
+                },
+            ]);
+            mockModelResponse([
+                {
+                    name: COMPLETE_TASK_TOOL_NAME,
+                    args: { finalResult: 'done' },
+                    id: 'call2',
+                },
+            ]);
+            mockScheduleAgentTools.mockResolvedValueOnce([
+                {
+                    status: 'success',
+                    request: {
+                        callId: 'call1',
+                        name: LS_TOOL_NAME,
+                        args: {},
+                        prompt_id: 'test-prompt',
+                    },
+                    response: {
+                        resultDisplay: 'ls result',
+                        responseParts: [
+                            {
+                                functionResponse: {
+                                    name: LS_TOOL_NAME,
+                                    id: 'call1',
+                                    response: { ok: true },
+                                },
+                            },
+                        ],
+                        data: {},
+                    },
+                },
+            ]);
+            await executor.run({ goal: 'test' }, signal);
+            expect(mockRouter.route).toHaveBeenCalledTimes(1);
+            expect(mockSendMessageStream).toHaveBeenCalledTimes(2);
+            expect(mockSendMessageStream).toHaveBeenNthCalledWith(1, expect.objectContaining({ model: 'routed-model' }), expect.any(Array), expect.any(String), expect.any(AbortSignal), LlmRole.SUBAGENT);
+            expect(mockSendMessageStream).toHaveBeenNthCalledWith(2, expect.objectContaining({ model: 'routed-model' }), expect.any(Array), expect.any(String), expect.any(AbortSignal), LlmRole.SUBAGENT);
+        });
         it('should NOT use model routing when the agent model is NOT "auto"', async () => {
             const definition = createTestDefinition();
             definition.modelConfig.model = 'concrete-model';
@@ -2390,7 +2547,12 @@ describe('LocalAgentExecutor', () => {
             await executor.run({ goal: 'Compress success' }, signal);
             expect(mockCompress).toHaveBeenCalledTimes(1);
             expect(mockSetHistory).toHaveBeenCalledTimes(1);
-            expect(mockSetHistory).toHaveBeenCalledWith(compressedHistory);
+            // History turns are now wrapped with IDs
+            expect(mockSetHistory).toHaveBeenCalledWith(expect.arrayContaining([
+                expect.objectContaining({
+                    content: expect.objectContaining({ role: 'user' }),
+                }),
+            ]));
         });
         it('should pass hasFailedCompressionAttempt=true to compression after a failure', async () => {
             const definition = createTestDefinition();
@@ -2468,7 +2630,12 @@ describe('LocalAgentExecutor', () => {
             // Call 3: hasFailed... is false again
             expect(mockCompress.mock.calls[2][5]).toBe(false);
             expect(mockSetHistory).toHaveBeenCalledTimes(1);
-            expect(mockSetHistory).toHaveBeenCalledWith(compressedHistory);
+            // History turns are now wrapped with IDs
+            expect(mockSetHistory).toHaveBeenCalledWith(expect.arrayContaining([
+                expect.objectContaining({
+                    content: expect.objectContaining({ role: 'user' }),
+                }),
+            ]));
         });
     });
     describe('MCP Isolation', () => {
@@ -2781,12 +2948,11 @@ describe('LocalAgentExecutor', () => {
                 expect(systemInstruction).toContain(mockMemory);
                 expect(systemInstruction).toContain('<loaded_context>');
             });
-            it('should inject environment memory into the first message when JIT is disabled', async () => {
+            it('should inject session memory into the first message', async () => {
                 const definition = createTestDefinition();
                 const executor = await LocalAgentExecutor.create(definition, mockConfig, onActivity);
-                const mockMemory = 'Project memory rule';
-                vi.spyOn(mockConfig, 'getEnvironmentMemory').mockReturnValue(mockMemory);
-                vi.spyOn(mockConfig, 'isJitContextEnabled').mockReturnValue(false);
+                const mockMemory = '<loaded_context>\nExtension memory rule\n</loaded_context>';
+                vi.spyOn(mockConfig, 'getSessionMemory').mockReturnValue(mockMemory);
                 mockModelResponse([
                     {
                         name: COMPLETE_TASK_TOOL_NAME,
@@ -2798,16 +2964,19 @@ describe('LocalAgentExecutor', () => {
                 const { message } = getMockMessageParams(0);
                 const parts = message;
                 expect(parts).toBeDefined();
-                const memoryPart = parts.find((p) => p.text?.includes(mockMemory));
+                const memoryPart = parts.find((p) => p.text?.includes('Extension memory rule'));
                 expect(memoryPart).toBeDefined();
-                expect(memoryPart?.text).toBe(mockMemory);
+                expect(memoryPart?.text).toContain(mockMemory);
             });
-            it('should inject session memory into the first message when JIT is enabled', async () => {
+            it('should omit extension context from session memory when disabled by the agent', async () => {
                 const definition = createTestDefinition();
+                definition.includeExtensionContext = false;
                 const executor = await LocalAgentExecutor.create(definition, mockConfig, onActivity);
-                const mockMemory = '<loaded_context>\nExtension memory rule\n</loaded_context>';
-                vi.spyOn(mockConfig, 'getSessionMemory').mockReturnValue(mockMemory);
-                vi.spyOn(mockConfig, 'isJitContextEnabled').mockReturnValue(true);
+                const getSessionMemorySpy = vi
+                    .spyOn(mockConfig, 'getSessionMemory')
+                    .mockImplementation((options) => options?.includeExtensionContext === false
+                    ? '<loaded_context>\n<project_context>\nProject memory rule\n</project_context>\n</loaded_context>'
+                    : '<loaded_context>\n<extension_context>\nExtension memory rule\n</extension_context>\n<project_context>\nProject memory rule\n</project_context>\n</loaded_context>');
                 mockModelResponse([
                     {
                         name: COMPLETE_TASK_TOOL_NAME,
@@ -2816,12 +2985,15 @@ describe('LocalAgentExecutor', () => {
                     },
                 ]);
                 await executor.run({ goal: 'test' }, signal);
+                expect(getSessionMemorySpy).toHaveBeenCalledWith({
+                    includeExtensionContext: false,
+                });
                 const { message } = getMockMessageParams(0);
                 const parts = message;
-                expect(parts).toBeDefined();
-                const memoryPart = parts.find((p) => p.text?.includes('Extension memory rule'));
-                expect(memoryPart).toBeDefined();
-                expect(memoryPart?.text).toContain(mockMemory);
+                const memoryPart = parts.find((p) => p.text?.includes('<loaded_context>'));
+                expect(memoryPart?.text).toContain('Project memory rule');
+                expect(memoryPart?.text).not.toContain('<extension_context>');
+                expect(memoryPart?.text).not.toContain('Extension memory rule');
             });
         });
     });