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

package/dist/src/utils/memoryDiscovery.test.js

@@ -7,22 +7,10 @@ import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
 import * as fsPromises from 'node:fs/promises';
 import * as os from 'node:os';
 import * as path from 'node:path';
-import { loadServerHierarchicalMemory, getGlobalMemoryPaths, getExtensionMemoryPaths, getEnvironmentMemoryPaths, loadJitSubdirectoryMemory, refreshServerHierarchicalMemory, } from './memoryDiscovery.js';
-import { setGeminiMdFilename, DEFAULT_CONTEXT_FILENAME, } from '../tools/memoryTool.js';
-import { flattenMemory } from '../config/memory.js';
-import { FileDiscoveryService } from '../services/fileDiscoveryService.js';
-import { CELL_DIR, normalizePath, homedir as pathsHomedir } from './paths.js';
-function flattenResult(result) {
-    return {
-        ...result,
-        memoryContent: flattenMemory(result.memoryContent),
-        filePaths: result.filePaths.map((p) => normalizePath(p)),
-    };
-}
-import { Config } from '../config/config.js';
-import { Storage } from '../config/storage.js';
+import { deduplicatePathsByFileIdentity, getGlobalMemoryPaths, getExtensionMemoryPaths, getEnvironmentMemoryPaths, getUserProjectMemoryPaths, loadJitSubdirectoryMemory, readGeminiMdFiles, } from './memoryDiscovery.js';
+import { setGeminiMdFilename, DEFAULT_CONTEXT_FILENAME, PROJECT_MEMORY_INDEX_FILENAME, } from '../tools/memoryTool.js';
+import { CELL_DIR, toAbsolutePath, homedir as pathsHomedir } from './paths.js';
 import { SimpleExtensionLoader } from './extensionLoader.js';
-import { CoreEvent, coreEvents } from './events.js';
 vi.mock('os', async (importOriginal) => {
     const actualOs = await importOriginal();
     return {
@@ -42,33 +30,29 @@ vi.mock('../utils/paths.js', async (importOriginal) => {
     };
 });
 describe('memoryDiscovery', () => {
-    const DEFAULT_FOLDER_TRUST = true;
     let testRootDir;
-    let cwd;
     let projectRoot;
     let homedir;
     async function createEmptyDir(fullPath) {
         await fsPromises.mkdir(fullPath, { recursive: true });
-        return normalizePath(fullPath);
+        return toAbsolutePath(fullPath);
     }
     async function createTestFile(fullPath, fileContents) {
         await fsPromises.mkdir(path.dirname(fullPath), { recursive: true });
         await fsPromises.writeFile(fullPath, fileContents);
-        return normalizePath(path.resolve(testRootDir, fullPath));
+        return toAbsolutePath(path.resolve(testRootDir, fullPath));
     }
     beforeEach(async () => {
-        testRootDir = normalizePath(await fsPromises.mkdtemp(path.join(os.tmpdir(), 'folder-structure-test-')));
+        testRootDir = toAbsolutePath(await fsPromises.mkdtemp(path.join(os.tmpdir(), 'folder-structure-test-')));
         vi.resetAllMocks();
         // Set environment variables to indicate test environment
         vi.stubEnv('NODE_ENV', 'test');
         vi.stubEnv('VITEST', 'true');
         projectRoot = await createEmptyDir(path.join(testRootDir, 'project'));
-        cwd = await createEmptyDir(path.join(projectRoot, 'src'));
         homedir = await createEmptyDir(path.join(testRootDir, 'userhome'));
         vi.mocked(os.homedir).mockReturnValue(homedir);
         vi.mocked(pathsHomedir).mockReturnValue(homedir);
     });
-    const normMarker = (p) => process.platform === 'win32' ? p.toLowerCase() : p;
     afterEach(async () => {
         vi.unstubAllEnvs();
         // Some tests set this to a different value.
@@ -82,289 +66,15 @@ describe('memoryDiscovery', () => {
             retryDelay: 10,
         });
     });
-    describe('when untrusted', () => {
-        it('does not load context files from untrusted workspaces', async () => {
-            await createTestFile(path.join(projectRoot, DEFAULT_CONTEXT_FILENAME), 'Project root memory');
-            await createTestFile(path.join(cwd, DEFAULT_CONTEXT_FILENAME), 'Src directory memory');
-            const result = flattenResult(await loadServerHierarchicalMemory(cwd, [], new FileDiscoveryService(projectRoot), new SimpleExtensionLoader([]), false));
-            expect(result).toEqual({
-                memoryContent: '',
-                fileCount: 0,
-                filePaths: [],
-            });
-        });
-        it('loads context from outside the untrusted workspace', async () => {
-            await createTestFile(path.join(projectRoot, DEFAULT_CONTEXT_FILENAME), 'Project root memory');
-            await createTestFile(path.join(cwd, DEFAULT_CONTEXT_FILENAME), 'Src directory memory');
-            const filepathInput = path.join(homedir, CELL_DIR, DEFAULT_CONTEXT_FILENAME);
-            const filepath = await createTestFile(filepathInput, 'default context content'); // In user home dir (outside untrusted space).
-            const { fileCount, memoryContent, filePaths } = flattenResult(await loadServerHierarchicalMemory(cwd, [], new FileDiscoveryService(projectRoot), new SimpleExtensionLoader([]), false));
-            expect(fileCount).toEqual(1);
-            expect(memoryContent).toContain(filepath);
-            expect(filePaths).toEqual([filepath]);
-        });
-    });
-    it('should return empty memory and count if no context files are found', async () => {
-        const result = flattenResult(await loadServerHierarchicalMemory(cwd, [], new FileDiscoveryService(projectRoot), new SimpleExtensionLoader([]), DEFAULT_FOLDER_TRUST));
-        expect(result).toEqual({
-            memoryContent: '',
-            fileCount: 0,
-            filePaths: [],
-        });
-    });
-    it('should load only the global context file if present and others are not (default filename)', async () => {
-        const defaultContextFile = await createTestFile(path.join(homedir, CELL_DIR, DEFAULT_CONTEXT_FILENAME), 'default context content');
-        const result = flattenResult(await loadServerHierarchicalMemory(cwd, [], new FileDiscoveryService(projectRoot), new SimpleExtensionLoader([]), DEFAULT_FOLDER_TRUST));
-        expect({
-            ...result,
-            memoryContent: flattenMemory(result.memoryContent),
-        }).toEqual({
-            memoryContent: `--- Global ---
---- Context from: ${defaultContextFile} ---
-default context content
---- End of Context from: ${defaultContextFile} ---`,
-            fileCount: 1,
-            filePaths: [defaultContextFile],
-        });
-    });
-    it('should load only the global custom context file if present and filename is changed', async () => {
-        const customFilename = 'CUSTOM_AGENTS.md';
-        setGeminiMdFilename(customFilename);
-        const customContextFile = await createTestFile(path.join(homedir, CELL_DIR, customFilename), 'custom context content');
-        const result = flattenResult(await loadServerHierarchicalMemory(cwd, [], new FileDiscoveryService(projectRoot), new SimpleExtensionLoader([]), DEFAULT_FOLDER_TRUST));
-        expect(result).toEqual({
-            memoryContent: `--- Global ---
---- Context from: ${customContextFile} ---
-custom context content
---- End of Context from: ${customContextFile} ---`,
-            fileCount: 1,
-            filePaths: [customContextFile],
-        });
-    });
-    it('should load context files by upward traversal with custom filename', async () => {
-        const customFilename = 'PROJECT_CONTEXT.md';
-        setGeminiMdFilename(customFilename);
-        const projectContextFile = await createTestFile(path.join(projectRoot, customFilename), 'project context content');
-        const cwdContextFile = await createTestFile(path.join(cwd, customFilename), 'cwd context content');
-        const result = flattenResult(await loadServerHierarchicalMemory(cwd, [], new FileDiscoveryService(projectRoot), new SimpleExtensionLoader([]), DEFAULT_FOLDER_TRUST));
-        expect(result).toEqual({
-            memoryContent: `--- Project ---
---- Context from: ${projectContextFile} ---
-project context content
---- End of Context from: ${projectContextFile} ---
-
---- Context from: ${cwdContextFile} ---
-cwd context content
---- End of Context from: ${cwdContextFile} ---`,
-            fileCount: 2,
-            filePaths: [projectContextFile, cwdContextFile],
-        });
-    });
-    it('should load context files by downward traversal with custom filename', async () => {
-        const customFilename = 'LOCAL_CONTEXT.md';
-        setGeminiMdFilename(customFilename);
-        const subdirCustomFile = await createTestFile(path.join(cwd, 'subdir', customFilename), 'Subdir custom memory');
-        const cwdCustomFile = await createTestFile(path.join(cwd, customFilename), 'CWD custom memory');
-        const result = flattenResult(await loadServerHierarchicalMemory(cwd, [], new FileDiscoveryService(projectRoot), new SimpleExtensionLoader([]), DEFAULT_FOLDER_TRUST));
-        expect(result).toEqual({
-            memoryContent: `--- Project ---
---- Context from: ${cwdCustomFile} ---
-CWD custom memory
---- End of Context from: ${cwdCustomFile} ---
-
---- Context from: ${subdirCustomFile} ---
-Subdir custom memory
---- End of Context from: ${subdirCustomFile} ---`,
-            fileCount: 2,
-            filePaths: [cwdCustomFile, subdirCustomFile],
-        });
-    });
-    it('should load ORIGINAL_GEMINI_MD_FILENAME files by upward traversal from CWD to project root', async () => {
-        const projectRootGeminiFile = await createTestFile(path.join(projectRoot, DEFAULT_CONTEXT_FILENAME), 'Project root memory');
-        const srcGeminiFile = await createTestFile(path.join(cwd, DEFAULT_CONTEXT_FILENAME), 'Src directory memory');
-        const result = flattenResult(await loadServerHierarchicalMemory(cwd, [], new FileDiscoveryService(projectRoot), new SimpleExtensionLoader([]), DEFAULT_FOLDER_TRUST));
-        expect(result).toEqual({
-            memoryContent: `--- Project ---
---- Context from: ${projectRootGeminiFile} ---
-Project root memory
---- End of Context from: ${projectRootGeminiFile} ---
-
---- Context from: ${srcGeminiFile} ---
-Src directory memory
---- End of Context from: ${srcGeminiFile} ---`,
-            fileCount: 2,
-            filePaths: [projectRootGeminiFile, srcGeminiFile],
-        });
-    });
-    it('should load ORIGINAL_GEMINI_MD_FILENAME files by downward traversal from CWD', async () => {
-        const subDirGeminiFile = await createTestFile(path.join(cwd, 'subdir', DEFAULT_CONTEXT_FILENAME), 'Subdir memory');
-        const cwdGeminiFile = await createTestFile(path.join(cwd, DEFAULT_CONTEXT_FILENAME), 'CWD memory');
-        const result = flattenResult(await loadServerHierarchicalMemory(cwd, [], new FileDiscoveryService(projectRoot), new SimpleExtensionLoader([]), DEFAULT_FOLDER_TRUST));
-        expect(result).toEqual({
-            memoryContent: `--- Project ---
---- Context from: ${cwdGeminiFile} ---
-CWD memory
---- End of Context from: ${cwdGeminiFile} ---
-
---- Context from: ${subDirGeminiFile} ---
-Subdir memory
---- End of Context from: ${subDirGeminiFile} ---`,
-            fileCount: 2,
-            filePaths: [cwdGeminiFile, subDirGeminiFile],
-        });
-    });
-    it('should load and correctly order global, upward, and downward ORIGINAL_GEMINI_MD_FILENAME files', async () => {
-        const defaultContextFile = await createTestFile(path.join(homedir, CELL_DIR, DEFAULT_CONTEXT_FILENAME), 'default context content');
-        const rootGeminiFile = await createTestFile(path.join(testRootDir, DEFAULT_CONTEXT_FILENAME), 'Project parent memory');
-        const projectRootGeminiFile = await createTestFile(path.join(projectRoot, DEFAULT_CONTEXT_FILENAME), 'Project root memory');
-        const cwdGeminiFile = await createTestFile(path.join(cwd, DEFAULT_CONTEXT_FILENAME), 'CWD memory');
-        const subDirGeminiFile = await createTestFile(path.join(cwd, 'sub', DEFAULT_CONTEXT_FILENAME), 'Subdir memory');
-        const result = flattenResult(await loadServerHierarchicalMemory(cwd, [], new FileDiscoveryService(projectRoot), new SimpleExtensionLoader([]), DEFAULT_FOLDER_TRUST));
-        expect(result).toEqual({
-            memoryContent: `--- Global ---
---- Context from: ${defaultContextFile} ---
-default context content
---- End of Context from: ${defaultContextFile} ---
-
---- Project ---
---- Context from: ${rootGeminiFile} ---
-Project parent memory
---- End of Context from: ${rootGeminiFile} ---
-
---- Context from: ${projectRootGeminiFile} ---
-Project root memory
---- End of Context from: ${projectRootGeminiFile} ---
-
---- Context from: ${cwdGeminiFile} ---
-CWD memory
---- End of Context from: ${cwdGeminiFile} ---
-
---- Context from: ${subDirGeminiFile} ---
-Subdir memory
---- End of Context from: ${subDirGeminiFile} ---`,
-            fileCount: 5,
-            filePaths: [
-                defaultContextFile,
-                rootGeminiFile,
-                projectRootGeminiFile,
-                cwdGeminiFile,
-                subDirGeminiFile,
-            ],
-        });
-    });
-    it('should ignore specified directories during downward scan', async () => {
-        await createEmptyDir(path.join(projectRoot, '.git'));
-        await createTestFile(path.join(projectRoot, '.gitignore'), 'node_modules');
-        await createTestFile(path.join(cwd, 'node_modules', DEFAULT_CONTEXT_FILENAME), 'Ignored memory');
-        const regularSubDirGeminiFile = await createTestFile(path.join(cwd, 'my_code', DEFAULT_CONTEXT_FILENAME), 'My code memory');
-        const result = flattenResult(await loadServerHierarchicalMemory(cwd, [], new FileDiscoveryService(projectRoot), new SimpleExtensionLoader([]), DEFAULT_FOLDER_TRUST, 'tree', {
-            respectGitIgnore: true,
-            respectGeminiIgnore: true,
-            customIgnoreFilePaths: [],
-        }, 200));
-        expect(result).toEqual({
-            memoryContent: `--- Project ---
---- Context from: ${regularSubDirGeminiFile} ---
-My code memory
---- End of Context from: ${regularSubDirGeminiFile} ---`,
-            fileCount: 1,
-            filePaths: [regularSubDirGeminiFile],
-        });
-    });
-    it('should respect the maxDirs parameter during downward scan', async () => {
-        // Create directories in parallel for better performance
-        const dirPromises = Array.from({ length: 2 }, (_, i) => createEmptyDir(path.join(cwd, `deep_dir_${i}`)));
-        await Promise.all(dirPromises);
-        // Pass the custom limit directly to the function
-        await loadServerHierarchicalMemory(cwd, [], new FileDiscoveryService(projectRoot), new SimpleExtensionLoader([]), DEFAULT_FOLDER_TRUST, 'tree', // importFormat
-        {
-            respectGitIgnore: true,
-            respectGeminiIgnore: true,
-            customIgnoreFilePaths: [],
-        }, 1);
-        // Note: bfsFileSearch debug logging is no longer controlled via debugMode parameter
-        // The test verifies maxDirs is respected by checking the result, not debug logs
-        const result = flattenResult(await loadServerHierarchicalMemory(cwd, [], new FileDiscoveryService(projectRoot), new SimpleExtensionLoader([]), DEFAULT_FOLDER_TRUST));
-        expect(result).toEqual({
-            memoryContent: '',
-            fileCount: 0,
-            filePaths: [],
-        });
-    });
-    it('should load extension context file paths', async () => {
-        const extensionFilePath = await createTestFile(path.join(testRootDir, 'extensions/ext1/GEMINI.md'), 'Extension memory content');
-        const result = flattenResult(await loadServerHierarchicalMemory(cwd, [], new FileDiscoveryService(projectRoot), new SimpleExtensionLoader([
-            {
-                contextFiles: [extensionFilePath],
-                isActive: true,
-            },
-        ]), DEFAULT_FOLDER_TRUST));
-        expect(result).toEqual({
-            memoryContent: `--- Extension ---
---- Context from: ${extensionFilePath} ---
-Extension memory content
---- End of Context from: ${extensionFilePath} ---`,
-            fileCount: 1,
-            filePaths: [extensionFilePath],
-        });
-    });
-    it('should load memory from included directories', async () => {
-        const includedDir = await createEmptyDir(path.join(testRootDir, 'included'));
-        const includedFile = await createTestFile(path.join(includedDir, DEFAULT_CONTEXT_FILENAME), 'included directory memory');
-        const result = flattenResult(await loadServerHierarchicalMemory(cwd, [includedDir], new FileDiscoveryService(projectRoot), new SimpleExtensionLoader([]), DEFAULT_FOLDER_TRUST));
-        expect(result).toEqual({
-            memoryContent: `--- Project ---
---- Context from: ${includedFile} ---
-included directory memory
---- End of Context from: ${includedFile} ---`,
-            fileCount: 1,
-            filePaths: [includedFile],
+    describe('EISDIR handling for GEMINI.md as a directory', () => {
+        it('readGeminiMdFiles returns null content (without throwing) when path is a directory', async () => {
+            const dirAsFilePath = await createEmptyDir(path.join(projectRoot, DEFAULT_CONTEXT_FILENAME));
+            const results = await readGeminiMdFiles([dirAsFilePath]);
+            expect(results).toHaveLength(1);
+            expect(results[0].filePath).toBe(dirAsFilePath);
+            expect(results[0].content).toBeNull();
         });
     });
-    it('should handle multiple directories and files in parallel correctly', async () => {
-        // Create multiple test directories with GEMINI.md files
-        const numDirs = 5;
-        const createdFiles = [];
-        for (let i = 0; i < numDirs; i++) {
-            const dirPath = await createEmptyDir(path.join(testRootDir, `project-${i}`));
-            const filePath = await createTestFile(path.join(dirPath, DEFAULT_CONTEXT_FILENAME), `Content from project ${i}`);
-            createdFiles.push(filePath);
-        }
-        // Load memory from all directories
-        const result = flattenResult(await loadServerHierarchicalMemory(cwd, createdFiles.map((f) => path.dirname(f)), new FileDiscoveryService(projectRoot), new SimpleExtensionLoader([]), DEFAULT_FOLDER_TRUST));
-        // Should have loaded all files
-        expect(result.fileCount).toBe(numDirs);
-        expect(result.filePaths.length).toBe(numDirs);
-        expect(result.filePaths.sort()).toEqual(createdFiles.sort());
-        // Content should include all project contents
-        const flattenedMemory = flattenMemory(result.memoryContent);
-        for (let i = 0; i < numDirs; i++) {
-            expect(flattenedMemory).toContain(`Content from project ${i}`);
-        }
-    });
-    it('should preserve order and prevent duplicates when processing multiple directories', async () => {
-        // Create overlapping directory structure
-        const parentDir = await createEmptyDir(path.join(testRootDir, 'parent'));
-        const childDir = await createEmptyDir(path.join(parentDir, 'child'));
-        const parentFile = await createTestFile(path.join(parentDir, DEFAULT_CONTEXT_FILENAME), 'Parent content');
-        const childFile = await createTestFile(path.join(childDir, DEFAULT_CONTEXT_FILENAME), 'Child content');
-        // Include both parent and child directories
-        const result = flattenResult(await loadServerHierarchicalMemory(parentDir, [childDir, parentDir], // Deliberately include duplicates
-        new FileDiscoveryService(projectRoot), new SimpleExtensionLoader([]), DEFAULT_FOLDER_TRUST));
-        // Should have both files without duplicates
-        const flattenedMemory = flattenMemory(result.memoryContent);
-        expect(result.fileCount).toBe(2);
-        expect(flattenedMemory).toContain('Parent content');
-        expect(flattenedMemory).toContain('Child content');
-        expect(result.filePaths.sort()).toEqual([parentFile, childFile].sort());
-        // Check that files are not duplicated
-        const parentOccurrences = (flattenedMemory.match(/Parent content/g) || [])
-            .length;
-        const childOccurrences = (flattenedMemory.match(/Child content/g) || [])
-            .length;
-        expect(parentOccurrences).toBe(1);
-        expect(childOccurrences).toBe(1);
-    });
     describe('getGlobalMemoryPaths', () => {
         it('should find global memory file if it exists', async () => {
             const globalMemoryFile = await createTestFile(path.join(homedir, CELL_DIR, DEFAULT_CONTEXT_FILENAME), 'Global memory content');
@@ -377,6 +87,38 @@ included directory memory
             expect(result).toHaveLength(0);
         });
     });
+    describe('getUserProjectMemoryPaths', () => {
+        it('should find MEMORY.md when it exists', async () => {
+            const memoryDir = await createEmptyDir(path.join(testRootDir, 'memdir1'));
+            const memoryFile = await createTestFile(path.join(memoryDir, PROJECT_MEMORY_INDEX_FILENAME), 'project memory');
+            const result = await getUserProjectMemoryPaths(memoryDir);
+            expect(result).toHaveLength(1);
+            expect(result[0]).toBe(memoryFile);
+        });
+        it('should preserve the on-disk casing of the index filename', async () => {
+            // Regression: paths surfaced through /memory list and /memory show
+            // were previously lowercased on macOS/Windows because they passed
+            // through normalizePath. The MEMORY.md filename must be kept as-is
+            // for display.
+            const memoryDir = await createEmptyDir(path.join(testRootDir, 'memdir2'));
+            await createTestFile(path.join(memoryDir, PROJECT_MEMORY_INDEX_FILENAME), 'project memory');
+            const result = await getUserProjectMemoryPaths(memoryDir);
+            expect(result).toHaveLength(1);
+            expect(result[0]).toContain(PROJECT_MEMORY_INDEX_FILENAME);
+            expect(result[0]).not.toContain(PROJECT_MEMORY_INDEX_FILENAME.toLowerCase());
+        });
+        it('should fall back to legacy GEMINI.md when MEMORY.md is absent', async () => {
+            const memoryDir = await createEmptyDir(path.join(testRootDir, 'memdir3'));
+            const legacyFile = await createTestFile(path.join(memoryDir, DEFAULT_CONTEXT_FILENAME), 'legacy memory');
+            const result = await getUserProjectMemoryPaths(memoryDir);
+            expect(result).toContain(legacyFile);
+        });
+        it('should return empty array when neither MEMORY.md nor GEMINI.md exists', async () => {
+            const memoryDir = await createEmptyDir(path.join(testRootDir, 'memdir4'));
+            const result = await getUserProjectMemoryPaths(memoryDir);
+            expect(result).toHaveLength(0);
+        });
+    });
     describe('getExtensionMemoryPaths', () => {
         it('should return active extension context files', async () => {
             const extFile = await createTestFile(path.join(testRootDir, 'ext', 'GEMINI.md'), 'Extension content');
@@ -443,6 +185,43 @@ included directory memory
             expect(result).toHaveLength(1);
             expect(result[0]).toBe(repoFile);
         });
+        it('should preserve case-distinct files before identity deduplication', async () => {
+            const platformSpy = vi
+                .spyOn(process, 'platform', 'get')
+                .mockReturnValue('win32');
+            vi.resetModules();
+            vi.doMock('node:fs/promises', async () => {
+                const actual = await vi.importActual('node:fs/promises');
+                return {
+                    ...actual,
+                    access: vi.fn().mockResolvedValue(undefined),
+                    stat: vi.fn(async (filePath) => {
+                        const normalizedPath = String(filePath).replace(/\\/g, '/');
+                        return {
+                            dev: 1,
+                            ino: normalizedPath.endsWith('/GEMINI.md') ? 101 : 202,
+                        };
+                    }),
+                };
+            });
+            try {
+                const paths = await import('./paths.js');
+                const memoryTool = await import('../tools/memoryTool.js');
+                const memoryDiscovery = await import('./memoryDiscovery.js');
+                vi.mocked(paths.homedir).mockReturnValue('/home/tester');
+                memoryTool.setGeminiMdFilename(['GEMINI.md', 'gemini.md']);
+                const result = await memoryDiscovery.getEnvironmentMemoryPaths(['/case-root'], []);
+                expect(result).toEqual([
+                    paths.toAbsolutePath('/case-root/GEMINI.md'),
+                    paths.toAbsolutePath('/case-root/gemini.md'),
+                ]);
+            }
+            finally {
+                platformSpy.mockRestore();
+                vi.doUnmock('node:fs/promises');
+                vi.resetModules();
+            }
+        });
         it('should recognize .git as a file (submodules/worktrees)', async () => {
             const repoDir = await createEmptyDir(path.join(testRootDir, 'worktree_repo'));
             // .git as a file, like in submodules and worktrees
@@ -472,7 +251,7 @@ included directory memory
             expect(result[1]).toBe(secondaryFile);
         });
     });
-    describe('case-insensitive filesystem deduplication', () => {
+    describe('file identity deduplication', () => {
         it('should deduplicate files that point to the same inode (same physical file)', async () => {
             const geminiFile = await createTestFile(path.join(projectRoot, 'gemini.md'), 'Project root memory');
             // create hard link to simulate case-insensitive filesystem behavior
@@ -493,13 +272,12 @@ included directory memory
             const stats2 = await fsPromises.lstat(geminiFileLink);
             expect(stats1.ino).toBe(stats2.ino);
             expect(stats1.dev).toBe(stats2.dev);
-            setGeminiMdFilename(['GEMINI.md', 'gemini.md']);
-            const result = flattenResult(await loadServerHierarchicalMemory(cwd, [], new FileDiscoveryService(projectRoot), new SimpleExtensionLoader([]), DEFAULT_FOLDER_TRUST));
-            expect(result.fileCount).toBe(1);
-            expect(result.filePaths).toHaveLength(1);
-            expect(result.memoryContent).toContain('Project root memory');
-            const contentMatches = result.memoryContent.match(/Project root memory/g);
-            expect(contentMatches).toHaveLength(1);
+            const result = await deduplicatePathsByFileIdentity([
+                geminiFileLink,
+                geminiFile,
+            ]);
+            expect(result.paths).toHaveLength(1);
+            expect(result.identityMap.get(geminiFile)).toBe(result.identityMap.get(geminiFileLink));
             try {
                 await fsPromises.unlink(geminiFileLink);
             }
@@ -513,20 +291,24 @@ included directory memory
             const stats1 = await fsPromises.lstat(geminiFileLower);
             const stats2 = await fsPromises.lstat(geminiFileUpper);
             if (stats1.ino !== stats2.ino || stats1.dev !== stats2.dev) {
-                setGeminiMdFilename(['GEMINI.md', 'gemini.md']);
-                const result = flattenResult(await loadServerHierarchicalMemory(cwd, [], new FileDiscoveryService(projectRoot), new SimpleExtensionLoader([]), DEFAULT_FOLDER_TRUST));
-                expect(result.fileCount).toBe(2);
-                expect(result.filePaths).toHaveLength(2);
-                expect(result.memoryContent).toContain('Lowercase file content');
-                expect(result.memoryContent).toContain('Uppercase file content');
+                const result = await deduplicatePathsByFileIdentity([
+                    geminiFileLower,
+                    geminiFileUpper,
+                ]);
+                expect(result.paths).toHaveLength(2);
+                expect(result.paths).toContain(geminiFileLower);
+                expect(result.paths).toContain(geminiFileUpper);
             }
         });
         it("should handle files that cannot be stat'd (missing files)", async () => {
-            await createTestFile(path.join(projectRoot, 'gemini.md'), 'Valid file content');
-            setGeminiMdFilename(['gemini.md', 'missing.md']);
-            const result = flattenResult(await loadServerHierarchicalMemory(cwd, [], new FileDiscoveryService(projectRoot), new SimpleExtensionLoader([]), DEFAULT_FOLDER_TRUST));
-            expect(result.fileCount).toBe(1);
-            expect(result.memoryContent).toContain('Valid file content');
+            const geminiFile = await createTestFile(path.join(projectRoot, 'gemini.md'), 'Valid file content');
+            const missingFile = path.join(projectRoot, 'missing.md');
+            const result = await deduplicatePathsByFileIdentity([
+                geminiFile,
+                missingFile,
+            ]);
+            expect(result.paths).toEqual([geminiFile, missingFile]);
+            expect(result.identityMap.has(missingFile)).toBe(false);
         });
         it('should deduplicate multiple paths pointing to same file (3+ duplicates)', async () => {
             const geminiFile = await createTestFile(path.join(projectRoot, 'gemini.md'), 'Project root memory');
@@ -550,13 +332,14 @@ included directory memory
             const stats3 = await fsPromises.lstat(link2);
             expect(stats1.ino).toBe(stats2.ino);
             expect(stats1.ino).toBe(stats3.ino);
-            setGeminiMdFilename(['gemini.md', 'GEMINI.md', 'Gemini.md']);
-            const result = flattenResult(await loadServerHierarchicalMemory(cwd, [], new FileDiscoveryService(projectRoot), new SimpleExtensionLoader([]), DEFAULT_FOLDER_TRUST));
-            expect(result.fileCount).toBe(1);
-            expect(result.filePaths).toHaveLength(1);
-            expect(result.memoryContent).toContain('Project root memory');
-            const contentMatches = result.memoryContent.match(/Project root memory/g);
-            expect(contentMatches).toHaveLength(1);
+            const result = await deduplicatePathsByFileIdentity([
+                geminiFile,
+                link1,
+                link2,
+            ]);
+            expect(result.paths).toHaveLength(1);
+            expect(result.identityMap.get(geminiFile)).toBe(result.identityMap.get(link1));
+            expect(result.identityMap.get(geminiFile)).toBe(result.identityMap.get(link2));
             try {
                 await fsPromises.unlink(link1);
                 await fsPromises.unlink(link2);
@@ -726,79 +509,5 @@ included directory memory
             expect(result.files.find((f) => f.path === subDirMemory)).toBeDefined();
         });
     });
-    it('refreshServerHierarchicalMemory should refresh memory and update config', async () => {
-        const extensionLoader = new SimpleExtensionLoader([]);
-        const config = new Config({
-            sessionId: '1',
-            targetDir: cwd,
-            cwd,
-            debugMode: false,
-            model: 'fake-model',
-            extensionLoader,
-        });
-        const result = flattenResult(await loadServerHierarchicalMemory(config.getWorkingDir(), config.shouldLoadMemoryFromIncludeDirectories()
-            ? config.getWorkspaceContext().getDirectories()
-            : [], config.getFileService(), config.getExtensionLoader(), config.isTrustedFolder(), config.getImportFormat()));
-        expect(result.fileCount).equals(0);
-        // Now add an extension with a memory file
-        const extensionsDir = new Storage(homedir).getExtensionsDir();
-        const extensionPath = path.join(extensionsDir, 'new-extension');
-        const contextFilePath = path.join(extensionPath, 'CustomContext.md');
-        await fsPromises.mkdir(extensionPath, { recursive: true });
-        await fsPromises.writeFile(contextFilePath, 'Really cool custom context!');
-        await extensionLoader.loadExtension({
-            name: 'new-extension',
-            isActive: true,
-            contextFiles: [contextFilePath],
-            version: '1.0.0',
-            id: '1234',
-            path: extensionPath,
-        });
-        const mockEventListener = vi.fn();
-        coreEvents.on(CoreEvent.MemoryChanged, mockEventListener);
-        const refreshResult = await refreshServerHierarchicalMemory(config);
-        expect(refreshResult.fileCount).equals(1);
-        expect(config.getGeminiMdFileCount()).equals(refreshResult.fileCount);
-        const flattenedMemory = flattenMemory(refreshResult.memoryContent);
-        expect(flattenedMemory).toContain('Really cool custom context!');
-        expect(config.getUserMemory()).toStrictEqual(refreshResult.memoryContent);
-        expect(refreshResult.filePaths[0]).toContain(normMarker(path.join(extensionPath, 'CustomContext.md')));
-        expect(config.getGeminiMdFilePaths()).equals(refreshResult.filePaths);
-        expect(mockEventListener).toHaveBeenCalledExactlyOnceWith({
-            fileCount: refreshResult.fileCount,
-        });
-    });
-    it('should include MCP instructions in user memory', async () => {
-        const mockConfig = {
-            getWorkingDir: vi.fn().mockReturnValue(cwd),
-            shouldLoadMemoryFromIncludeDirectories: vi.fn().mockReturnValue(false),
-            getFileService: vi
-                .fn()
-                .mockReturnValue(new FileDiscoveryService(projectRoot)),
-            getExtensionLoader: vi
-                .fn()
-                .mockReturnValue(new SimpleExtensionLoader([])),
-            isTrustedFolder: vi.fn().mockReturnValue(true),
-            getImportFormat: vi.fn().mockReturnValue('tree'),
-            getFileFilteringOptions: vi.fn().mockReturnValue(undefined),
-            getDiscoveryMaxDirs: vi.fn().mockReturnValue(200),
-            getMemoryBoundaryMarkers: vi.fn().mockReturnValue(['.git']),
-            setUserMemory: vi.fn(),
-            setGeminiMdFileCount: vi.fn(),
-            setGeminiMdFilePaths: vi.fn(),
-            getMcpClientManager: vi.fn().mockReturnValue({
-                getMcpInstructions: vi
-                    .fn()
-                    .mockReturnValue("\n\n# Instructions for MCP Server 'extension-server'\nAlways be polite."),
-            }),
-        };
-        await refreshServerHierarchicalMemory(mockConfig);
-        expect(mockConfig.setUserMemory).toHaveBeenCalledWith(expect.objectContaining({
-            project: expect.stringContaining("# Instructions for MCP Server 'extension-server'"),
-        }));
-        expect(mockConfig.setUserMemory).toHaveBeenCalledWith(expect.objectContaining({
-            project: expect.stringContaining('Always be polite.'),
-        }));
-    });
 });
 //# sourceMappingURL=memoryDiscovery.test.js.map