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

package/dist/src/services/memoryService.test.js

@@ -8,6 +8,8 @@ import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import * as os from 'node:os';
 import { SESSION_FILE_PREFIX, } from './chatRecordingService.js';
+import { coreEvents } from '../utils/events.js';
+import { Storage } from '../config/storage.js';
 // Mock external modules used by startMemoryService
 vi.mock('../agents/local-executor.js', () => ({
     LocalAgentExecutor: {
@@ -22,6 +24,7 @@ vi.mock('../agents/skill-extraction-agent.js', () => ({
         promptConfig: { systemPrompt: 'test' },
         tools: [],
         outputSchema: {},
+        modelConfig: { model: 'test-model' },
     }),
 }));
 vi.mock('./executionLifecycleService.js', () => ({
@@ -39,6 +42,27 @@ vi.mock('../prompts/prompt-registry.js', () => ({
 vi.mock('../resources/resource-registry.js', () => ({
     ResourceRegistry: vi.fn(),
 }));
+vi.mock('../policy/policy-engine.js', () => ({
+    PolicyEngine: vi.fn(),
+}));
+vi.mock('../policy/types.js', () => ({
+    PolicyDecision: { ALLOW: 'ALLOW' },
+}));
+vi.mock('../confirmation-bus/message-bus.js', () => ({
+    MessageBus: vi.fn(),
+}));
+vi.mock('../agents/registry.js', () => ({
+    getModelConfigAlias: vi.fn().mockReturnValue('skill-extraction-config'),
+}));
+vi.mock('../config/storage.js', () => ({
+    Storage: {
+        getUserSkillsDir: vi.fn().mockReturnValue('/tmp/fake-user-skills'),
+    },
+}));
+vi.mock('../skills/skillLoader.js', () => ({
+    FRONTMATTER_REGEX: /^---\n([\s\S]*?)\n---/,
+    parseFrontmatter: vi.fn().mockReturnValue(null),
+}));
 vi.mock('../utils/debugLogger.js', () => ({
     debugLogger: {
         debug: vi.fn(),
@@ -46,6 +70,11 @@ vi.mock('../utils/debugLogger.js', () => ({
         warn: vi.fn(),
     },
 }));
+vi.mock('../utils/events.js', () => ({
+    coreEvents: {
+        emitFeedback: vi.fn(),
+    },
+}));
 // Helper to create a minimal ConversationRecord
 function createConversation(overrides = {}) {
     const { messageCount = 4, ...rest } = overrides;
@@ -64,6 +93,23 @@ function createConversation(overrides = {}) {
         ...rest,
     };
 }
+async function writeConversationJsonl(filePath, conversation) {
+    const metadata = {
+        sessionId: conversation.sessionId,
+        projectHash: conversation.projectHash,
+        startTime: conversation.startTime,
+        lastUpdated: conversation.lastUpdated,
+        summary: conversation.summary,
+        directories: conversation.directories,
+        kind: conversation.kind,
+    };
+    const records = [metadata, ...conversation.messages];
+    await fs.writeFile(filePath, records.map((record) => JSON.stringify(record)).join('\n') + '\n');
+}
+async function setSessionMtime(filePath, timestamp) {
+    const date = new Date(timestamp);
+    await fs.utimes(filePath, date, date);
+}
 describe('memoryService', () => {
     let tmpDir;
     beforeEach(async () => {
@@ -321,6 +367,175 @@ describe('memoryService', () => {
                 error: expect.any(Error),
             }));
         });
+        it('emits feedback when new skills are created during extraction', async () => {
+            const { startMemoryService } = await import('./memoryService.js');
+            const { LocalAgentExecutor } = await import('../agents/local-executor.js');
+            // Reset mocks that may carry state from prior tests
+            vi.mocked(coreEvents.emitFeedback).mockClear();
+            vi.mocked(LocalAgentExecutor.create).mockReset();
+            const memoryDir = path.join(tmpDir, 'memory4');
+            const skillsDir = path.join(tmpDir, 'skills4');
+            const projectTempDir = path.join(tmpDir, 'temp4');
+            const chatsDir = path.join(projectTempDir, 'chats');
+            await fs.mkdir(memoryDir, { recursive: true });
+            await fs.mkdir(skillsDir, { recursive: true });
+            await fs.mkdir(chatsDir, { recursive: true });
+            // Write a valid session with enough messages to pass the filter
+            const conversation = createConversation({
+                sessionId: 'skill-session',
+                messageCount: 20,
+            });
+            await fs.writeFile(path.join(chatsDir, 'session-2025-01-01T00-00-skill001.json'), JSON.stringify(conversation));
+            // Override LocalAgentExecutor.create to return an executor whose run
+            // creates a new skill directory with a SKILL.md in the skillsDir
+            vi.mocked(LocalAgentExecutor.create).mockResolvedValueOnce({
+                run: vi.fn().mockImplementation(async () => {
+                    const newSkillDir = path.join(skillsDir, 'my-new-skill');
+                    await fs.mkdir(newSkillDir, { recursive: true });
+                    await fs.writeFile(path.join(newSkillDir, 'SKILL.md'), '# My New Skill');
+                    return undefined;
+                }),
+            });
+            const mockConfig = {
+                storage: {
+                    getProjectMemoryDir: vi.fn().mockReturnValue(memoryDir),
+                    getProjectMemoryTempDir: vi.fn().mockReturnValue(memoryDir),
+                    getProjectSkillsMemoryDir: vi.fn().mockReturnValue(skillsDir),
+                    getProjectTempDir: vi.fn().mockReturnValue(projectTempDir),
+                },
+                getToolRegistry: vi.fn(),
+                getMessageBus: vi.fn(),
+                getGeminiClient: vi.fn(),
+                getSkillManager: vi.fn().mockReturnValue({ getSkills: () => [] }),
+                modelConfigService: {
+                    registerRuntimeModelConfig: vi.fn(),
+                },
+                sandboxManager: undefined,
+            };
+            await startMemoryService(mockConfig);
+            expect(coreEvents.emitFeedback).toHaveBeenCalledWith('info', expect.stringContaining('my-new-skill'));
+            expect(coreEvents.emitFeedback).toHaveBeenCalledWith('info', expect.stringContaining('/memory inbox'));
+        });
+        it('records only sessions whose read_file calls succeed as processed', async () => {
+            const { startMemoryService, readExtractionState } = await import('./memoryService.js');
+            const { LocalAgentExecutor } = await import('../agents/local-executor.js');
+            vi.mocked(LocalAgentExecutor.create).mockReset();
+            const memoryDir = path.join(tmpDir, 'memory-read-tracking');
+            const skillsDir = path.join(tmpDir, 'skills-read-tracking');
+            const projectTempDir = path.join(tmpDir, 'temp-read-tracking');
+            const chatsDir = path.join(projectTempDir, 'chats');
+            await fs.mkdir(memoryDir, { recursive: true });
+            await fs.mkdir(skillsDir, { recursive: true });
+            await fs.mkdir(chatsDir, { recursive: true });
+            const openedConversation = createConversation({
+                sessionId: 'opened-session',
+                summary: 'Read this one',
+                messageCount: 20,
+                lastUpdated: '2025-01-02T01:00:00Z',
+            });
+            const skippedConversation = createConversation({
+                sessionId: 'skipped-session',
+                summary: 'Do not read this one',
+                messageCount: 20,
+                lastUpdated: '2025-01-01T01:00:00Z',
+            });
+            const openedPath = path.join(chatsDir, `${SESSION_FILE_PREFIX}2025-01-02T00-00-opened.jsonl`);
+            const skippedPath = path.join(chatsDir, `${SESSION_FILE_PREFIX}2025-01-01T00-00-skipped.jsonl`);
+            await writeConversationJsonl(openedPath, openedConversation);
+            await writeConversationJsonl(skippedPath, skippedConversation);
+            vi.mocked(LocalAgentExecutor.create).mockImplementationOnce(async (_definition, _context, onActivity) => ({
+                run: vi.fn().mockImplementation(async () => {
+                    onActivity?.({
+                        isSubagentActivityEvent: true,
+                        agentName: 'Skill Extractor',
+                        type: 'TOOL_CALL_START',
+                        data: {
+                            name: 'read_file',
+                            args: { file_path: openedPath },
+                            callId: 'call-opened',
+                        },
+                    });
+                    onActivity?.({
+                        isSubagentActivityEvent: true,
+                        agentName: 'Skill Extractor',
+                        type: 'TOOL_CALL_START',
+                        data: {
+                            name: 'read_file',
+                            args: { file_path: skippedPath },
+                            callId: 'call-skipped',
+                        },
+                    });
+                    onActivity?.({
+                        isSubagentActivityEvent: true,
+                        agentName: 'Skill Extractor',
+                        type: 'ERROR',
+                        data: {
+                            name: 'read_file',
+                            callId: 'call-skipped',
+                            error: 'access denied',
+                        },
+                    });
+                    onActivity?.({
+                        isSubagentActivityEvent: true,
+                        agentName: 'Skill Extractor',
+                        type: 'TOOL_CALL_END',
+                        data: {
+                            name: 'read_file',
+                            id: 'call-opened',
+                            data: { content: 'Read this one' },
+                        },
+                    });
+                    onActivity?.({
+                        isSubagentActivityEvent: true,
+                        agentName: 'Skill Extractor',
+                        type: 'TOOL_CALL_START',
+                        data: {
+                            name: 'read_file',
+                            args: { file_path: path.join(chatsDir, 'unrelated.jsonl') },
+                            callId: 'call-unrelated',
+                        },
+                    });
+                    return undefined;
+                }),
+            }));
+            const mockConfig = {
+                storage: {
+                    getProjectMemoryDir: vi.fn().mockReturnValue(memoryDir),
+                    getProjectMemoryTempDir: vi.fn().mockReturnValue(memoryDir),
+                    getProjectSkillsMemoryDir: vi.fn().mockReturnValue(skillsDir),
+                    getProjectTempDir: vi.fn().mockReturnValue(projectTempDir),
+                },
+                getToolRegistry: vi.fn(),
+                getMessageBus: vi.fn(),
+                getGeminiClient: vi.fn(),
+                getSkillManager: vi.fn().mockReturnValue({ getSkills: () => [] }),
+                modelConfigService: {
+                    registerRuntimeModelConfig: vi.fn(),
+                },
+                getTargetDir: vi.fn().mockReturnValue(tmpDir),
+                sandboxManager: undefined,
+            };
+            await startMemoryService(mockConfig);
+            const state = await readExtractionState(path.join(memoryDir, '.extraction-state.json'));
+            expect(state.runs).toHaveLength(1);
+            expect(state.runs[0].candidateSessions).toEqual([
+                {
+                    sessionId: 'opened-session',
+                    lastUpdated: '2025-01-02T01:00:00Z',
+                },
+                {
+                    sessionId: 'skipped-session',
+                    lastUpdated: '2025-01-01T01:00:00Z',
+                },
+            ]);
+            expect(state.runs[0].processedSessions).toEqual([
+                {
+                    sessionId: 'opened-session',
+                    lastUpdated: '2025-01-02T01:00:00Z',
+                },
+            ]);
+            expect(state.runs[0].sessionIds).toEqual(['opened-session']);
+        });
     });
     describe('getProcessedSessionIds', () => {
         it('returns empty set for empty state', async () => {
@@ -411,7 +626,7 @@ describe('memoryService', () => {
             const state = {
                 runs: [
                     {
-                        runAt: '2025-01-01T00:00:00Z',
+                        runAt: '2025-01-01T02:00:00Z',
                         sessionIds: ['old-session'],
                         skillsCreated: [],
                     },
@@ -421,6 +636,28 @@ describe('memoryService', () => {
             expect(result.sessionIndex).toContain('[old]');
             expect(result.sessionIndex).not.toContain('[NEW]');
         });
+        it('treats resumed legacy sessions as [NEW] when lastUpdated moved past the old run', async () => {
+            const { buildSessionIndex } = await import('./memoryService.js');
+            const conversation = createConversation({
+                sessionId: 'resumed-session',
+                summary: 'Resumed after extraction',
+                messageCount: 20,
+                lastUpdated: '2025-01-01T03:00:00Z',
+            });
+            await fs.writeFile(path.join(chatsDir, `${SESSION_FILE_PREFIX}2025-01-01T00-00-resumed01.json`), JSON.stringify(conversation));
+            const state = {
+                runs: [
+                    {
+                        runAt: '2025-01-01T02:00:00Z',
+                        sessionIds: ['resumed-session'],
+                        skillsCreated: [],
+                    },
+                ],
+            };
+            const result = await buildSessionIndex(chatsDir, state);
+            expect(result.sessionIndex).toContain('[NEW]');
+            expect(result.newSessionIds).toEqual(['resumed-session']);
+        });
         it('includes file path and summary in each line', async () => {
             const { buildSessionIndex } = await import('./memoryService.js');
             const conversation = createConversation({
@@ -493,7 +730,7 @@ describe('memoryService', () => {
             const state = {
                 runs: [
                     {
-                        runAt: '2025-01-01T00:00:00Z',
+                        runAt: '2025-01-01T02:00:00Z',
                         sessionIds: ['processed-one'],
                         skillsCreated: [],
                     },
@@ -506,6 +743,97 @@ describe('memoryService', () => {
             expect(result.sessionIndex).toContain('[NEW]');
             expect(result.sessionIndex).toContain('[old]');
         });
+        it('reads JSONL sessions and sorts by actual lastUpdated instead of filename', async () => {
+            const { buildSessionIndex } = await import('./memoryService.js');
+            const olderByName = createConversation({
+                sessionId: 'older-by-name',
+                summary: 'Filename looks newer',
+                messageCount: 20,
+                lastUpdated: '2025-01-01T01:00:00Z',
+            });
+            const newerByActivity = createConversation({
+                sessionId: 'newer-by-activity',
+                summary: 'Actually most recent',
+                messageCount: 20,
+                lastUpdated: '2025-02-01T01:00:00Z',
+            });
+            await writeConversationJsonl(path.join(chatsDir, `${SESSION_FILE_PREFIX}2025-02-01T00-00-oldername.jsonl`), olderByName);
+            await writeConversationJsonl(path.join(chatsDir, `${SESSION_FILE_PREFIX}2025-01-01T00-00-neweractv.jsonl`), newerByActivity);
+            const result = await buildSessionIndex(chatsDir, { runs: [] });
+            const firstLine = result.sessionIndex.split('\n')[0];
+            expect(firstLine).toContain('Actually most recent');
+            expect(firstLine).not.toContain('Filename looks newer');
+        });
+        it('rotates in older unprocessed sessions instead of starving them behind retried recent ones', async () => {
+            const { buildSessionIndex } = await import('./memoryService.js');
+            for (let i = 0; i < 11; i++) {
+                const day = String(11 - i).padStart(2, '0');
+                const conversation = createConversation({
+                    sessionId: `backlog-${i}`,
+                    summary: `Backlog ${i}`,
+                    messageCount: 20,
+                    lastUpdated: `2025-01-${day}T01:00:00Z`,
+                });
+                await fs.writeFile(path.join(chatsDir, `${SESSION_FILE_PREFIX}2025-01-${day}T00-00-backlog${i}.json`), JSON.stringify(conversation));
+            }
+            const state = {
+                runs: [
+                    {
+                        runAt: '2025-02-01T00:00:00Z',
+                        sessionIds: [],
+                        candidateSessions: Array.from({ length: 10 }, (_, i) => ({
+                            sessionId: `backlog-${i}`,
+                            lastUpdated: `2025-01-${String(11 - i).padStart(2, '0')}T01:00:00Z`,
+                        })),
+                        skillsCreated: [],
+                    },
+                ],
+            };
+            const result = await buildSessionIndex(chatsDir, state);
+            expect(result.newSessionIds).toContain('backlog-10');
+            expect(result.newSessionIds).not.toContain('backlog-9');
+        });
+        it('surfaces older unprocessed sessions even when the newest 100 files were already processed', async () => {
+            const { buildSessionIndex } = await import('./memoryService.js');
+            const processedSessions = [];
+            for (let i = 0; i < 105; i++) {
+                const timestamp = new Date(Date.UTC(2025, 0, 1, 0, 0, 105 - i)).toISOString();
+                const conversation = createConversation({
+                    sessionId: `backlog-${i}`,
+                    summary: `Backlog ${i}`,
+                    messageCount: 20,
+                    lastUpdated: timestamp,
+                });
+                const filePath = path.join(chatsDir, `${SESSION_FILE_PREFIX}2025-01-01T00-00-backlog${String(i).padStart(3, '0')}.json`);
+                await fs.writeFile(filePath, JSON.stringify(conversation));
+                await setSessionMtime(filePath, timestamp);
+                if (i < 100) {
+                    processedSessions.push({
+                        sessionId: conversation.sessionId,
+                        lastUpdated: conversation.lastUpdated,
+                    });
+                }
+            }
+            const result = await buildSessionIndex(chatsDir, {
+                runs: [
+                    {
+                        runAt: '2025-02-01T00:00:00Z',
+                        sessionIds: processedSessions.map((session) => session.sessionId),
+                        processedSessions,
+                        skillsCreated: [],
+                    },
+                ],
+            });
+            expect(result.newSessionIds).toEqual([
+                'backlog-100',
+                'backlog-101',
+                'backlog-102',
+                'backlog-103',
+                'backlog-104',
+            ]);
+            expect(result.sessionIndex).toContain('Backlog 100');
+            expect(result.sessionIndex).toContain('Backlog 104');
+        });
     });
     describe('ExtractionState runs tracking', () => {
         it('readExtractionState parses runs array with skillsCreated', async () => {
@@ -516,6 +844,18 @@ describe('memoryService', () => {
                     {
                         runAt: '2025-06-01T00:00:00Z',
                         sessionIds: ['s1'],
+                        candidateSessions: [
+                            {
+                                sessionId: 's1',
+                                lastUpdated: '2025-05-31T12:00:00Z',
+                            },
+                        ],
+                        processedSessions: [
+                            {
+                                sessionId: 's1',
+                                lastUpdated: '2025-05-31T12:00:00Z',
+                            },
+                        ],
                         skillsCreated: ['debug-helper', 'test-gen'],
                     },
                 ],
@@ -527,6 +867,18 @@ describe('memoryService', () => {
                 'debug-helper',
                 'test-gen',
             ]);
+            expect(result.runs[0].candidateSessions).toEqual([
+                {
+                    sessionId: 's1',
+                    lastUpdated: '2025-05-31T12:00:00Z',
+                },
+            ]);
+            expect(result.runs[0].processedSessions).toEqual([
+                {
+                    sessionId: 's1',
+                    lastUpdated: '2025-05-31T12:00:00Z',
+                },
+            ]);
             expect(result.runs[0].sessionIds).toEqual(['s1']);
             expect(result.runs[0].runAt).toBe('2025-06-01T00:00:00Z');
         });
@@ -537,6 +889,26 @@ describe('memoryService', () => {
                 {
                     runAt: '2025-01-01T00:00:00Z',
                     sessionIds: ['a', 'b'],
+                    candidateSessions: [
+                        {
+                            sessionId: 'a',
+                            lastUpdated: '2024-12-31T23:00:00Z',
+                        },
+                        {
+                            sessionId: 'b',
+                            lastUpdated: '2024-12-31T22:00:00Z',
+                        },
+                    ],
+                    processedSessions: [
+                        {
+                            sessionId: 'a',
+                            lastUpdated: '2024-12-31T23:00:00Z',
+                        },
+                        {
+                            sessionId: 'b',
+                            lastUpdated: '2024-12-31T22:00:00Z',
+                        },
+                    ],
                     skillsCreated: ['skill-x'],
                 },
                 {
@@ -559,5 +931,317 @@ describe('memoryService', () => {
             expect(result).toEqual({ runs: [] });
         });
     });
+    describe('validatePatches', () => {
+        let skillsDir;
+        let globalSkillsDir;
+        let projectSkillsDir;
+        let validateConfig;
+        beforeEach(() => {
+            skillsDir = path.join(tmpDir, 'skills');
+            globalSkillsDir = path.join(tmpDir, 'global-skills');
+            projectSkillsDir = path.join(tmpDir, 'project-skills');
+            vi.mocked(Storage.getUserSkillsDir).mockReturnValue(globalSkillsDir);
+            validateConfig = {
+                storage: {
+                    getProjectSkillsDir: () => projectSkillsDir,
+                },
+            };
+        });
+        it('returns empty array when no patch files exist', async () => {
+            const { validatePatches } = await import('./memoryService.js');
+            await fs.mkdir(skillsDir, { recursive: true });
+            // Add a non-patch file to ensure it's ignored
+            await fs.writeFile(path.join(skillsDir, 'some-file.txt'), 'hello');
+            const result = await validatePatches(skillsDir, validateConfig);
+            expect(result).toEqual([]);
+        });
+        it('returns empty array when directory does not exist', async () => {
+            const { validatePatches } = await import('./memoryService.js');
+            const result = await validatePatches(path.join(tmpDir, 'nonexistent-dir'), validateConfig);
+            expect(result).toEqual([]);
+        });
+        it('removes invalid patch files', async () => {
+            const { validatePatches } = await import('./memoryService.js');
+            await fs.mkdir(skillsDir, { recursive: true });
+            // Write a malformed patch
+            const patchPath = path.join(skillsDir, 'bad-skill.patch');
+            await fs.writeFile(patchPath, 'this is not a valid patch');
+            const result = await validatePatches(skillsDir, validateConfig);
+            expect(result).toEqual([]);
+            // Verify the invalid patch was deleted
+            await expect(fs.access(patchPath)).rejects.toThrow();
+        });
+        it('keeps valid patch files', async () => {
+            const { validatePatches } = await import('./memoryService.js');
+            await fs.mkdir(skillsDir, { recursive: true });
+            await fs.mkdir(projectSkillsDir, { recursive: true });
+            // Create a real target file to patch
+            const targetFile = path.join(projectSkillsDir, 'target.md');
+            await fs.writeFile(targetFile, 'line1\nline2\nline3\n');
+            // Write a valid unified diff patch with absolute paths
+            const patchContent = [
+                `--- ${targetFile}`,
+                `+++ ${targetFile}`,
+                '@@ -1,3 +1,4 @@',
+                ' line1',
+                ' line2',
+                '+line2.5',
+                ' line3',
+                '',
+            ].join('\n');
+            const patchPath = path.join(skillsDir, 'good-skill.patch');
+            await fs.writeFile(patchPath, patchContent);
+            const result = await validatePatches(skillsDir, validateConfig);
+            expect(result).toEqual(['good-skill.patch']);
+            // Verify the valid patch still exists
+            await expect(fs.access(patchPath)).resolves.toBeUndefined();
+        });
+        it('keeps patches with repeated sections for the same file when hunks apply cumulatively', async () => {
+            const { validatePatches } = await import('./memoryService.js');
+            await fs.mkdir(skillsDir, { recursive: true });
+            await fs.mkdir(projectSkillsDir, { recursive: true });
+            const targetFile = path.join(projectSkillsDir, 'target.md');
+            await fs.writeFile(targetFile, 'alpha\nbeta\ngamma\ndelta\n');
+            const patchPath = path.join(skillsDir, 'multi-section.patch');
+            await fs.writeFile(patchPath, [
+                `--- ${targetFile}`,
+                `+++ ${targetFile}`,
+                '@@ -1,4 +1,5 @@',
+                ' alpha',
+                ' beta',
+                '+beta2',
+                ' gamma',
+                ' delta',
+                `--- ${targetFile}`,
+                `+++ ${targetFile}`,
+                '@@ -2,4 +2,5 @@',
+                ' beta',
+                ' beta2',
+                ' gamma',
+                '+gamma2',
+                ' delta',
+                '',
+            ].join('\n'));
+            const result = await validatePatches(skillsDir, validateConfig);
+            expect(result).toEqual(['multi-section.patch']);
+            await expect(fs.access(patchPath)).resolves.toBeUndefined();
+        });
+        it('removes /dev/null patches that target an existing skill file', async () => {
+            const { validatePatches } = await import('./memoryService.js');
+            await fs.mkdir(skillsDir, { recursive: true });
+            await fs.mkdir(projectSkillsDir, { recursive: true });
+            const targetFile = path.join(projectSkillsDir, 'existing-skill.md');
+            await fs.writeFile(targetFile, 'original content\n');
+            const patchPath = path.join(skillsDir, 'bad-new-file.patch');
+            await fs.writeFile(patchPath, [
+                '--- /dev/null',
+                `+++ ${targetFile}`,
+                '@@ -0,0 +1 @@',
+                '+replacement content',
+                '',
+            ].join('\n'));
+            const result = await validatePatches(skillsDir, validateConfig);
+            expect(result).toEqual([]);
+            await expect(fs.access(patchPath)).rejects.toThrow();
+            expect(await fs.readFile(targetFile, 'utf-8')).toBe('original content\n');
+        });
+        it('removes patches with malformed diff headers', async () => {
+            const { validatePatches } = await import('./memoryService.js');
+            await fs.mkdir(skillsDir, { recursive: true });
+            await fs.mkdir(projectSkillsDir, { recursive: true });
+            const targetFile = path.join(projectSkillsDir, 'target.md');
+            await fs.writeFile(targetFile, 'line1\nline2\nline3\n');
+            const patchPath = path.join(skillsDir, 'bad-headers.patch');
+            await fs.writeFile(patchPath, [
+                `--- ${targetFile}`,
+                '+++ .cell-cli/skills/foo/SKILL.md',
+                '@@ -1,3 +1,4 @@',
+                ' line1',
+                ' line2',
+                '+line2.5',
+                ' line3',
+                '',
+            ].join('\n'));
+            const result = await validatePatches(skillsDir, validateConfig);
+            expect(result).toEqual([]);
+            await expect(fs.access(patchPath)).rejects.toThrow();
+            expect(await fs.readFile(targetFile, 'utf-8')).toBe('line1\nline2\nline3\n');
+        });
+        it('removes patches that contain no hunks', async () => {
+            const { validatePatches } = await import('./memoryService.js');
+            await fs.mkdir(skillsDir, { recursive: true });
+            const patchPath = path.join(skillsDir, 'empty.patch');
+            await fs.writeFile(patchPath, [
+                `--- ${path.join(projectSkillsDir, 'target.md')}`,
+                `+++ ${path.join(projectSkillsDir, 'target.md')}`,
+                '',
+            ].join('\n'));
+            const result = await validatePatches(skillsDir, validateConfig);
+            expect(result).toEqual([]);
+            await expect(fs.access(patchPath)).rejects.toThrow();
+        });
+        it('removes patches that target files outside the allowed skill roots', async () => {
+            const { validatePatches } = await import('./memoryService.js');
+            await fs.mkdir(skillsDir, { recursive: true });
+            const outsideFile = path.join(tmpDir, 'outside.md');
+            await fs.writeFile(outsideFile, 'line1\nline2\nline3\n');
+            const patchPath = path.join(skillsDir, 'outside.patch');
+            await fs.writeFile(patchPath, [
+                `--- ${outsideFile}`,
+                `+++ ${outsideFile}`,
+                '@@ -1,3 +1,4 @@',
+                ' line1',
+                ' line2',
+                '+line2.5',
+                ' line3',
+                '',
+            ].join('\n'));
+            const result = await validatePatches(skillsDir, validateConfig);
+            expect(result).toEqual([]);
+            await expect(fs.access(patchPath)).rejects.toThrow();
+        });
+        it('removes patches that escape the allowed roots through a symlinked parent', async () => {
+            const { validatePatches } = await import('./memoryService.js');
+            await fs.mkdir(skillsDir, { recursive: true });
+            await fs.mkdir(projectSkillsDir, { recursive: true });
+            const outsideDir = path.join(tmpDir, 'outside-dir');
+            const linkedDir = path.join(projectSkillsDir, 'linked');
+            await fs.mkdir(outsideDir, { recursive: true });
+            await fs.symlink(outsideDir, linkedDir, process.platform === 'win32' ? 'junction' : 'dir');
+            const outsideFile = path.join(outsideDir, 'escaped.md');
+            await fs.writeFile(outsideFile, 'line1\nline2\nline3\n');
+            const patchPath = path.join(skillsDir, 'symlink.patch');
+            await fs.writeFile(patchPath, [
+                `--- ${path.join(linkedDir, 'escaped.md')}`,
+                `+++ ${path.join(linkedDir, 'escaped.md')}`,
+                '@@ -1,3 +1,4 @@',
+                ' line1',
+                ' line2',
+                '+line2.5',
+                ' line3',
+                '',
+            ].join('\n'));
+            const result = await validatePatches(skillsDir, validateConfig);
+            expect(result).toEqual([]);
+            await expect(fs.access(patchPath)).rejects.toThrow();
+            expect(await fs.readFile(outsideFile, 'utf-8')).not.toContain('line2.5');
+        });
+    });
+    describe('startMemoryService feedback for patch-only runs', () => {
+        it('emits feedback when extraction produces only patch suggestions', async () => {
+            const { startMemoryService } = await import('./memoryService.js');
+            const { LocalAgentExecutor } = await import('../agents/local-executor.js');
+            vi.mocked(coreEvents.emitFeedback).mockClear();
+            vi.mocked(LocalAgentExecutor.create).mockReset();
+            const memoryDir = path.join(tmpDir, 'memory-patch-only');
+            const skillsDir = path.join(tmpDir, 'skills-patch-only');
+            const projectTempDir = path.join(tmpDir, 'temp-patch-only');
+            const chatsDir = path.join(projectTempDir, 'chats');
+            const projectSkillsDir = path.join(tmpDir, 'workspace-skills');
+            await fs.mkdir(memoryDir, { recursive: true });
+            await fs.mkdir(skillsDir, { recursive: true });
+            await fs.mkdir(chatsDir, { recursive: true });
+            await fs.mkdir(projectSkillsDir, { recursive: true });
+            const existingSkill = path.join(projectSkillsDir, 'existing-skill.md');
+            await fs.writeFile(existingSkill, 'line1\nline2\nline3\n');
+            const conversation = createConversation({
+                sessionId: 'patch-only-session',
+                messageCount: 20,
+            });
+            await fs.writeFile(path.join(chatsDir, 'session-2025-01-01T00-00-patchonly.json'), JSON.stringify(conversation));
+            vi.mocked(Storage.getUserSkillsDir).mockReturnValue(path.join(tmpDir, 'global-skills'));
+            vi.mocked(LocalAgentExecutor.create).mockResolvedValueOnce({
+                run: vi.fn().mockImplementation(async () => {
+                    const patchPath = path.join(skillsDir, 'existing-skill.patch');
+                    await fs.writeFile(patchPath, [
+                        `--- ${existingSkill}`,
+                        `+++ ${existingSkill}`,
+                        '@@ -1,3 +1,4 @@',
+                        ' line1',
+                        ' line2',
+                        '+line2.5',
+                        ' line3',
+                        '',
+                    ].join('\n'));
+                    return undefined;
+                }),
+            });
+            const mockConfig = {
+                storage: {
+                    getProjectMemoryDir: vi.fn().mockReturnValue(memoryDir),
+                    getProjectMemoryTempDir: vi.fn().mockReturnValue(memoryDir),
+                    getProjectSkillsMemoryDir: vi.fn().mockReturnValue(skillsDir),
+                    getProjectSkillsDir: vi.fn().mockReturnValue(projectSkillsDir),
+                    getProjectTempDir: vi.fn().mockReturnValue(projectTempDir),
+                },
+                getToolRegistry: vi.fn(),
+                getMessageBus: vi.fn(),
+                getGeminiClient: vi.fn(),
+                getSkillManager: vi.fn().mockReturnValue({ getSkills: () => [] }),
+                modelConfigService: {
+                    registerRuntimeModelConfig: vi.fn(),
+                },
+                sandboxManager: undefined,
+            };
+            await startMemoryService(mockConfig);
+            expect(coreEvents.emitFeedback).toHaveBeenCalledWith('info', expect.stringContaining('skill update'));
+            expect(coreEvents.emitFeedback).toHaveBeenCalledWith('info', expect.stringContaining('/memory inbox'));
+        });
+        it('does not emit feedback for old inbox patches when this run creates none', async () => {
+            const { startMemoryService } = await import('./memoryService.js');
+            const { LocalAgentExecutor } = await import('../agents/local-executor.js');
+            vi.mocked(coreEvents.emitFeedback).mockClear();
+            vi.mocked(LocalAgentExecutor.create).mockReset();
+            const memoryDir = path.join(tmpDir, 'memory-old-patch');
+            const skillsDir = path.join(tmpDir, 'skills-old-patch');
+            const projectTempDir = path.join(tmpDir, 'temp-old-patch');
+            const chatsDir = path.join(projectTempDir, 'chats');
+            const projectSkillsDir = path.join(tmpDir, 'workspace-old-patch');
+            await fs.mkdir(memoryDir, { recursive: true });
+            await fs.mkdir(skillsDir, { recursive: true });
+            await fs.mkdir(chatsDir, { recursive: true });
+            await fs.mkdir(projectSkillsDir, { recursive: true });
+            const existingSkill = path.join(projectSkillsDir, 'existing-skill.md');
+            await fs.writeFile(existingSkill, 'line1\nline2\nline3\n');
+            await fs.writeFile(path.join(skillsDir, 'existing-skill.patch'), [
+                `--- ${existingSkill}`,
+                `+++ ${existingSkill}`,
+                '@@ -1,3 +1,4 @@',
+                ' line1',
+                ' line2',
+                '+line2.5',
+                ' line3',
+                '',
+            ].join('\n'));
+            const conversation = createConversation({
+                sessionId: 'old-patch-session',
+                messageCount: 20,
+            });
+            await fs.writeFile(path.join(chatsDir, 'session-2025-01-01T00-00-oldpatch.json'), JSON.stringify(conversation));
+            vi.mocked(Storage.getUserSkillsDir).mockReturnValue(path.join(tmpDir, 'global-skills'));
+            vi.mocked(LocalAgentExecutor.create).mockResolvedValueOnce({
+                run: vi.fn().mockResolvedValue(undefined),
+            });
+            const mockConfig = {
+                storage: {
+                    getProjectMemoryDir: vi.fn().mockReturnValue(memoryDir),
+                    getProjectMemoryTempDir: vi.fn().mockReturnValue(memoryDir),
+                    getProjectSkillsMemoryDir: vi.fn().mockReturnValue(skillsDir),
+                    getProjectSkillsDir: vi.fn().mockReturnValue(projectSkillsDir),
+                    getProjectTempDir: vi.fn().mockReturnValue(projectTempDir),
+                },
+                getToolRegistry: vi.fn(),
+                getMessageBus: vi.fn(),
+                getGeminiClient: vi.fn(),
+                getSkillManager: vi.fn().mockReturnValue({ getSkills: () => [] }),
+                modelConfigService: {
+                    registerRuntimeModelConfig: vi.fn(),
+                },
+                sandboxManager: undefined,
+            };
+            await startMemoryService(mockConfig);
+            expect(coreEvents.emitFeedback).not.toHaveBeenCalled();
+        });
+    });
 });
 //# sourceMappingURL=memoryService.test.js.map