aws-runtime-bridge 1.9.33 → 1.9.41

package/package/aws-client-agent-mcp/dist/memory-store.test.js

@@ -3,7 +3,7 @@ import { mkdtemp, readdir, readFile, rm } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { describe, it } from 'node:test';
-import { MemoryCapacityError, MemoryStore } from './memory-store.js';
+import { MemoryStore, normalizeBoundFilePath } from './memory-store.js';
 describe('MemoryStore', () => {
     it('creates and reads memory by uri', async () => {
         const dir = await mkdtemp(path.join(os.tmpdir(), 'aws-memory-store-'));
@@ -11,12 +11,12 @@ describe('MemoryStore', () => {
         const store = new MemoryStore(storePath);
         try {
             const created = await store.createMemory({
-                memory_type: 'memory',
+                memory_type: 'project_memory',
                 uri: 'core://agent/profile',
                 content: 'I am a backend expert.'
             });
             assert.equal(created.uri, 'core://agent/profile');
-            const loaded = await store.readMemory({ uri: 'core://agent/profile', memory_type: 'memory' });
+            const loaded = await store.readMemory({ uri: 'core://agent/profile', memory_type: 'project_memory' });
             assert.ok(loaded);
             assert.equal(loaded?.content, 'I am a backend expert.');
         }
@@ -30,19 +30,19 @@ describe('MemoryStore', () => {
         const store = new MemoryStore(storePath);
         try {
             await store.createMemory({
-                memory_type: 'memory',
+                memory_type: 'project_memory',
                 uri: 'notes://project/todo',
                 content: 'finish api docs'
             });
             const replaced = await store.updateMemory({
-                memory_type: 'memory',
+                memory_type: 'project_memory',
                 uri: 'notes://project/todo',
                 old_string: 'api docs',
                 new_string: 'API docs v2'
             });
             assert.equal(replaced.content, 'finish API docs v2');
             const appended = await store.updateMemory({
-                memory_type: 'memory',
+                memory_type: 'project_memory',
                 uri: 'notes://project/todo',
                 append: '\n- add memory tests'
             });
@@ -58,16 +58,16 @@ describe('MemoryStore', () => {
         const store = new MemoryStore(storePath);
         try {
             await store.createMemory({
-                memory_type: 'memory',
+                memory_type: 'project_memory',
                 uri: 'core://agent/skills',
                 content: 'java spring boot mysql'
             });
             await store.createMemory({
-                memory_type: 'memory',
+                memory_type: 'project_memory',
                 uri: 'notes://project/readme',
                 content: 'project setup and architecture'
             });
-            const result = await store.searchMemory({ query: 'project', limit: 1, memory_type: 'memory' });
+            const result = await store.searchMemory({ query: 'project', limit: 1, memory_type: 'project_memory' });
             assert.equal(result.results.length, 1);
             assert.equal(result.results[0]?.uri, 'notes://project/readme');
         }
@@ -81,13 +81,13 @@ describe('MemoryStore', () => {
         const store = new MemoryStore(storePath);
         try {
             await store.createMemory({
-                memory_type: 'memory',
+                memory_type: 'project_memory',
                 uri: 'core://agent/temp',
                 content: 'temporary memory'
             });
-            const deleted = await store.deleteMemory({ uri: 'core://agent/temp', memory_type: 'memory' });
+            const deleted = await store.deleteMemory({ uri: 'core://agent/temp', memory_type: 'project_memory' });
             assert.equal(deleted, true);
-            const loaded = await store.readMemory({ uri: 'core://agent/temp', memory_type: 'memory' });
+            const loaded = await store.readMemory({ uri: 'core://agent/temp', memory_type: 'project_memory' });
             assert.equal(loaded, null);
         }
         finally {
@@ -99,17 +99,17 @@ describe('MemoryStore', () => {
         const storePath = path.join(dir, 'memory');
         const store = new MemoryStore(storePath);
         try {
-            const types = ['task_list', 'recently_memory', 'memory'];
+            const types = ['recently_memory', 'agent_memory', 'project_memory'];
             await store.createMemory({ memory_type: types[0], uri: 'task://todo/1', content: 'fix tests' });
             await store.createMemory({ memory_type: types[1], uri: 'recent://ctx/1', content: 'just discussed API design' });
             await store.createMemory({ memory_type: types[2], uri: 'core://archive/1', content: 'long-term architecture decision' });
-            const taskList = await store.listByType('task_list');
+            const taskList = await store.listByType('recently_memory');
             assert.equal(taskList.length, 1);
-            assert.equal(taskList[0]?.memory_type, 'task_list');
-            const recentList = await store.listByType('recently_memory');
+            assert.equal(taskList[0]?.memory_type, 'recently_memory');
+            const recentList = await store.listByType('agent_memory');
             assert.equal(recentList.length, 1);
-            assert.equal(recentList[0]?.memory_type, 'recently_memory');
-            await assert.rejects(() => store.listByType('memory'), /Invalid memory_type/);
+            assert.equal(recentList[0]?.memory_type, 'agent_memory');
+            await assert.rejects(() => store.listByType('project_memory'), /Invalid memory_type/);
         }
         finally {
             await rm(dir, { recursive: true, force: true });
@@ -120,8 +120,8 @@ describe('MemoryStore', () => {
         const storePath = path.join(dir, 'memory');
         const store = new MemoryStore(storePath);
         try {
-            await store.createMemory({ memory_type: 'task_list', uri: 'task://todo/remove-1', content: 'to be removed' });
-            const deleted = await store.deleteMemory({ uri: 'task://todo/remove-1', memory_type: 'task_list' });
+            await store.createMemory({ memory_type: 'recently_memory', uri: 'task://todo/remove-1', content: 'to be removed' });
+            const deleted = await store.deleteMemory({ uri: 'task://todo/remove-1', memory_type: 'recently_memory' });
             assert.equal(deleted, true);
             assert.equal(await store.readMemory({ uri: 'task://todo/remove-1' }), null);
         }
@@ -129,47 +129,29 @@ describe('MemoryStore', () => {
             await rm(dir, { recursive: true, force: true });
         }
     });
-    it('archives recently_memory into memory', async () => {
-        const dir = await mkdtemp(path.join(os.tmpdir(), 'aws-memory-store-'));
-        const storePath = path.join(dir, 'memory');
-        const store = new MemoryStore(storePath);
-        try {
-            await store.createMemory({ memory_type: 'recently_memory', uri: 'recent://note/1', content: 'hot memory' });
-            const archived = await store.archiveRecentlyMemory('recent://note/1');
-            assert.equal(archived.memory_type, 'memory');
-            const loaded = await store.readMemory({ uri: 'recent://note/1', memory_type: 'memory' });
-            assert.ok(loaded);
-            assert.equal(loaded?.memory_type, 'memory');
-            await store.createMemory({ memory_type: 'memory', uri: 'core://cold/2', content: 'cold memory' });
-            await assert.rejects(() => store.archiveRecentlyMemory('core://cold/2'), /recently_memory_archive/);
-        }
-        finally {
-            await rm(dir, { recursive: true, force: true });
-        }
-    });
     it('reports memory stats with top-level counts and per-domain occupancy', async () => {
         const dir = await mkdtemp(path.join(os.tmpdir(), 'aws-memory-store-'));
         const storePath = path.join(dir, 'memory');
         const store = new MemoryStore(storePath);
         try {
-            await store.createMemory({ memory_type: 'task_list', uri: 'task://todo/stats', content: 'task' });
-            await store.createMemory({ memory_type: 'task_list', uri: 'task://todo/other', content: 'another task' });
-            await store.createMemory({ memory_type: 'recently_memory', uri: 'recent://ctx/stats', content: 'recent' });
-            await store.createMemory({ memory_type: 'recently_memory', uri: 'note://ctx/stats', content: 'recent note' });
-            await store.createMemory({ memory_type: 'memory', uri: 'core://stats/long-term', content: 'long term' });
+            await store.createMemory({ memory_type: 'recently_memory', uri: 'task://todo/stats', content: 'task' });
+            await store.createMemory({ memory_type: 'recently_memory', uri: 'task://todo/other', content: 'another task' });
+            await store.createMemory({ memory_type: 'agent_memory', uri: 'recent://ctx/stats', content: 'recent' });
+            await store.createMemory({ memory_type: 'agent_memory', uri: 'note://ctx/stats', content: 'recent note' });
+            await store.createMemory({ memory_type: 'project_memory', uri: 'core://stats/long-term', content: 'long term' });
             const stats = await store.getStats();
             assert.equal(stats.total, 5);
             assert.deepEqual(stats.listable, { count: 4, limit: 64, hardLimit: 128, exceeded: false, hardExceeded: false });
-            assert.equal(stats.by_type.task_list.count, 2);
-            assert.equal(stats.by_type.task_list.domainCount, 1);
-            assert.equal(stats.by_type.task_list.by_domain.task?.count, 2);
             assert.equal(stats.by_type.recently_memory.count, 2);
-            assert.equal(stats.by_type.recently_memory.domainCount, 2);
-            assert.equal(stats.by_type.recently_memory.by_domain.recent?.count, 1);
-            assert.equal(stats.by_type.recently_memory.by_domain.note?.count, 1);
-            assert.equal(stats.by_type.memory.count, 1);
-            assert.equal(stats.by_type.memory.domainCount, 1);
-            assert.equal(stats.by_type.memory.by_domain.core?.count, 1);
+            assert.equal(stats.by_type.recently_memory.domainCount, 1);
+            assert.equal(stats.by_type.recently_memory.by_domain.task?.count, 2);
+            assert.equal(stats.by_type.agent_memory.count, 2);
+            assert.equal(stats.by_type.agent_memory.domainCount, 2);
+            assert.equal(stats.by_type.agent_memory.by_domain.recent?.count, 1);
+            assert.equal(stats.by_type.agent_memory.by_domain.note?.count, 1);
+            assert.equal(stats.by_type.project_memory.count, 1);
+            assert.equal(stats.by_type.project_memory.domainCount, 1);
+            assert.equal(stats.by_type.project_memory.by_domain.core?.count, 1);
         }
         finally {
             await rm(dir, { recursive: true, force: true });
@@ -180,7 +162,7 @@ describe('MemoryStore', () => {
         const storePath = path.join(dir, 'memory');
         const store = new MemoryStore(storePath);
         try {
-            await store.createMemory({ memory_type: 'memory', uri: 'core://atomic/write', content: 'persisted' });
+            await store.createMemory({ memory_type: 'project_memory', uri: 'core://atomic/write', content: 'persisted' });
             const files = await readdir(storePath);
             assert.deepEqual(files, ['core.json']);
         }
@@ -193,14 +175,14 @@ describe('MemoryStore', () => {
         const storePath = path.join(dir, 'memory');
         const store = new MemoryStore(storePath);
         try {
-            await store.createMemory({ memory_type: 'memory', uri: 'core://agent/profile', content: 'profile' });
-            await store.createMemory({ memory_type: 'memory', uri: 'notes://project/readme', content: 'readme' });
+            await store.createMemory({ memory_type: 'project_memory', uri: 'core://agent/profile', content: 'profile' });
+            await store.createMemory({ memory_type: 'project_memory', uri: 'notes://project/readme', content: 'readme' });
             assert.deepEqual((await readdir(storePath)).sort(), ['core.json', 'notes.json']);
             const coreRaw = JSON.parse(await readFile(path.join(storePath, 'core.json'), 'utf-8'));
             const notesRaw = JSON.parse(await readFile(path.join(storePath, 'notes.json'), 'utf-8'));
             assert.equal(coreRaw.by_uri['core://agent/profile']?.content, 'profile');
             assert.equal(notesRaw.by_uri['notes://project/readme']?.content, 'readme');
-            const searched = await store.searchMemory({ query: 'readme', memory_type: 'memory' });
+            const searched = await store.searchMemory({ query: 'readme', memory_type: 'project_memory' });
             assert.equal(searched.results[0]?.uri, 'notes://project/readme');
         }
         finally {
@@ -212,54 +194,11 @@ describe('MemoryStore', () => {
         const storePath = path.join(dir, 'memory');
         const store = new MemoryStore(storePath);
         try {
-            await store.createMemory({ memory_type: 'memory', uri: 'core://agent/profile', content: 'profile' });
-            await store.createMemory({ memory_type: 'memory', uri: 'notes://project/readme', content: 'readme' });
-            assert.equal(await store.deleteMemory({ uri: 'notes://project/readme', memory_type: 'memory' }), true);
+            await store.createMemory({ memory_type: 'project_memory', uri: 'core://agent/profile', content: 'profile' });
+            await store.createMemory({ memory_type: 'project_memory', uri: 'notes://project/readme', content: 'readme' });
+            assert.equal(await store.deleteMemory({ uri: 'notes://project/readme', memory_type: 'project_memory' }), true);
             assert.deepEqual(await readdir(storePath), ['core.json']);
-            assert.equal(await store.readMemory({ uri: 'notes://project/readme', memory_type: 'memory' }), null);
-        }
-        finally {
-            await rm(dir, { recursive: true, force: true });
-        }
-    });
-    it('allows listable memory beyond soft limits and rejects at the doubled hard type limit', async () => {
-        const dir = await mkdtemp(path.join(os.tmpdir(), 'aws-memory-store-'));
-        const storePath = path.join(dir, 'memory');
-        const store = new MemoryStore(storePath);
-        try {
-            for (let index = 0; index < 64; index += 1) {
-                await store.createMemory({
-                    memory_type: 'recently_memory',
-                    uri: `recent://ctx/${index}`,
-                    content: `recent context ${index}`
-                });
-            }
-            await assert.rejects(async () => {
-                await store.createMemory({
-                    memory_type: 'recently_memory',
-                    uri: 'recent://ctx/overflow',
-                    content: 'overflow context'
-                });
-            }, (error) => {
-                assert.ok(error instanceof MemoryCapacityError);
-                assert.equal(error.details.code, 'MEMORY_TYPE_LIMIT_REACHED');
-                assert.equal(error.details.memory_type, 'recently_memory');
-                assert.equal(error.details.domain, 'recent');
-                assert.equal(error.details.limit, 64);
-                assert.equal(error.details.current, 64);
-                assert.ok(error.details.recommended_actions.includes('archive_recently_memory({ uri })'));
-                assert.match(error.message, /hard memory limit 64 reached under domain recent/s);
-                return true;
-            });
-            await store.archiveRecentlyMemory('recent://ctx/0');
-            const createdAfterArchive = await store.createMemory({
-                memory_type: 'recently_memory',
-                uri: 'recent://ctx/after-archive',
-                content: 'capacity restored by archive'
-            });
-            assert.equal(createdAfterArchive.memory_type, 'recently_memory');
-            const recentList = await store.listByType('recently_memory');
-            assert.equal(recentList.length, 64);
+            assert.equal(await store.readMemory({ uri: 'notes://project/readme', memory_type: 'project_memory' }), null);
         }
         finally {
             await rm(dir, { recursive: true, force: true });
@@ -272,38 +211,38 @@ describe('MemoryStore', () => {
         try {
             for (let index = 0; index < 32; index += 1) {
                 await store.createMemory({
-                    memory_type: 'task_list',
+                    memory_type: 'recently_memory',
                     uri: `task://todo/${index}`,
                     content: `task ${index}`
                 });
                 await store.createMemory({
-                    memory_type: 'recently_memory',
+                    memory_type: 'agent_memory',
                     uri: `recent://ctx/${index}`,
                     content: `recent context ${index}`
                 });
             }
             const longTermMemory = await store.createMemory({
-                memory_type: 'memory',
+                memory_type: 'project_memory',
                 uri: 'core://long-term/not-listable',
                 content: 'long-term memories are not constrained by listable limits'
             });
-            assert.equal(longTermMemory.memory_type, 'memory');
+            assert.equal(longTermMemory.memory_type, 'project_memory');
             const stats = await store.getStats();
             assert.equal(stats.listable.count, 64);
             assert.equal(stats.listable.exceeded, false);
             assert.equal(stats.listable.hardExceeded, false);
-            assert.equal(stats.by_type.task_list.exceeded, false);
             assert.equal(stats.by_type.recently_memory.exceeded, false);
+            assert.equal(stats.by_type.agent_memory.exceeded, false);
             const allowedBeyondSoftLimit = await store.createMemory({
-                memory_type: 'task_list',
+                memory_type: 'recently_memory',
                 uri: 'task://todo/beyond-soft-limit',
                 content: 'allowed beyond soft limit until hard limit'
             });
-            assert.equal(allowedBeyondSoftLimit.memory_type, 'task_list');
+            assert.equal(allowedBeyondSoftLimit.memory_type, 'recently_memory');
             const exceededStats = await store.getStats();
             assert.equal(exceededStats.listable.exceeded, true);
-            assert.equal(exceededStats.by_type.task_list.exceeded, false);
-            assert.equal(exceededStats.by_type.task_list.by_domain.task?.exceeded, true);
+            assert.equal(exceededStats.by_type.recently_memory.exceeded, false);
+            assert.equal(exceededStats.by_type.recently_memory.by_domain.task?.exceeded, true);
         }
         finally {
             await rm(dir, { recursive: true, force: true });
@@ -316,26 +255,26 @@ describe('MemoryStore', () => {
         try {
             for (let index = 0; index < 64; index += 1) {
                 await store.createMemory({
-                    memory_type: 'task_list',
+                    memory_type: 'recently_memory',
                     uri: `task${index}://todo/current`,
                     content: `task ${index}`
                 });
                 await store.createMemory({
-                    memory_type: 'recently_memory',
+                    memory_type: 'agent_memory',
                     uri: `recent${index}://ctx/current`,
                     content: `recent ${index}`
                 });
             }
             const created = await store.createMemory({
-                memory_type: 'task_list',
+                memory_type: 'recently_memory',
                 uri: 'task0://todo/extra',
                 content: 'same domain remains below item hard limit'
             });
-            assert.equal(created.memory_type, 'task_list');
+            assert.equal(created.memory_type, 'recently_memory');
             const stats = await store.getStats();
             assert.equal(stats.listable.hardExceeded, true);
-            assert.equal(stats.by_type.task_list.hardExceeded, true);
-            assert.equal(stats.by_type.task_list.by_domain.task0?.count, 2);
+            assert.equal(stats.by_type.recently_memory.hardExceeded, true);
+            assert.equal(stats.by_type.recently_memory.by_domain.task0?.count, 2);
         }
         finally {
             await rm(dir, { recursive: true, force: true });
@@ -358,7 +297,7 @@ describe('MemoryStore', () => {
         const store = new MemoryStore(storePath);
         try {
             const created = await store.createMemory({
-                memory_type: 'recently_memory',
+                memory_type: 'agent_memory',
                 uri: 'recent://expire/test1',
                 content: 'test expiration'
             });
@@ -366,11 +305,11 @@ describe('MemoryStore', () => {
             const expiresDate = new Date(created.expiresAt);
             const now = new Date();
             const diffHours = (expiresDate.getTime() - now.getTime()) / (60 * 60 * 1000);
-            // Should be approximately 24 hours from now
-            assert.ok(diffHours > 23 && diffHours < 25, `expiresAt should be ~24h from now, got ${diffHours}h`);
+            // Should be approximately 12 hours from now (initial TTL)
+            assert.ok(diffHours > 11 && diffHours < 13, `expiresAt should be ~12h from now, got ${diffHours}h`);
             // memory type should NOT have expiresAt
             const memoryCreated = await store.createMemory({
-                memory_type: 'memory',
+                memory_type: 'project_memory',
                 uri: 'core://perm/test1',
                 content: 'permanent'
             });
@@ -386,7 +325,7 @@ describe('MemoryStore', () => {
         const store = new MemoryStore(storePath);
         try {
             const created = await store.createMemory({
-                memory_type: 'recently_memory',
+                memory_type: 'agent_memory',
                 uri: 'recent://expire/test2',
                 content: 'original content'
             });
@@ -412,14 +351,14 @@ describe('MemoryStore', () => {
         try {
             // Already expired (pass expiresAt in the past)
             await store.createMemory({
-                memory_type: 'recently_memory',
+                memory_type: 'agent_memory',
                 uri: 'recent://expire/past1',
                 content: 'already expired',
                 expiresAt: new Date(Date.now() - 60_000).toISOString(), // 1 minute ago
             });
             // Future expiration
             await store.createMemory({
-                memory_type: 'recently_memory',
+                memory_type: 'agent_memory',
                 uri: 'recent://expire/future1',
                 content: 'not expired yet',
             });
@@ -431,72 +370,144 @@ describe('MemoryStore', () => {
             await rm(dir, { recursive: true, force: true });
         }
     });
-    // ========== todoCompleted 测试 (v1.14.0) ==========
-    it('todoCompleted marks single task as completed without cleaning', async () => {
-        const dir = await mkdtemp(path.join(os.tmpdir(), 'aws-memory-store-'));
+});
+// ========== listByFile 与 normalizeBoundFilePath 测试 ==========
+describe('normalizeBoundFilePath', () => {
+    it('normalizes @/ prefix to ./', () => {
+        assert.equal(normalizeBoundFilePath('@/src/main.ts'), './src/main.ts');
+    });
+    it('normalizes / prefix to ./', () => {
+        assert.equal(normalizeBoundFilePath('/src/main.ts'), './src/main.ts');
+    });
+    it('normalizes bare path to ./', () => {
+        assert.equal(normalizeBoundFilePath('src/main.ts'), './src/main.ts');
+    });
+    it('keeps ./ prefix as-is', () => {
+        assert.equal(normalizeBoundFilePath('./src/main.ts'), './src/main.ts');
+    });
+    it('trims whitespace', () => {
+        assert.equal(normalizeBoundFilePath('  ./src/main.ts  '), './src/main.ts');
+    });
+});
+describe('MemoryStore listByFile', () => {
+    it('finds memories by exact bound_files match', async () => {
+        const dir = await mkdtemp(path.join(os.tmpdir(), 'aws-memory-listbyfile-'));
         const storePath = path.join(dir, 'memory');
         const store = new MemoryStore(storePath);
         try {
-            await store.createMemory({ memory_type: 'task_list', uri: 'task://todo/a', content: 'task A' });
-            await store.createMemory({ memory_type: 'task_list', uri: 'task://todo/b', content: 'task B' });
-            const result = await store.todoCompleted('task://todo/a');
-            assert.equal(result.completed, true);
-            assert.equal(result.uri, 'task://todo/a');
-            assert.equal(result.allCleaned, false);
-            assert.equal(result.cleanedCount, 0);
-            // 第二条仍应为 pending
-            const pending = await store.listByTodoStatus('pending');
-            assert.equal(pending.length, 1);
-            assert.equal(pending[0]?.uri, 'task://todo/b');
-            // 第一条应为 completed
-            const completed = await store.listByTodoStatus('completed');
-            assert.equal(completed.length, 1);
-            assert.equal(completed[0]?.uri, 'task://todo/a');
+            await store.createMemory({
+                memory_type: 'project_memory',
+                uri: 'core://file/notes',
+                content: 'Notes about main.ts',
+                bound_files: ['./src/main.ts'],
+            });
+            await store.createMemory({
+                memory_type: 'project_memory',
+                uri: 'core://other/entry',
+                content: 'Unrelated memory',
+                bound_files: ['./src/utils.ts'],
+            });
+            const results = await store.listByFile('./src/main.ts');
+            assert.equal(results.length, 1);
+            assert.equal(results[0]?.uri, 'core://file/notes');
         }
         finally {
             await rm(dir, { recursive: true, force: true });
         }
     });
-    it('todoCompleted auto-cleans when all todos are completed', async () => {
-        const dir = await mkdtemp(path.join(os.tmpdir(), 'aws-memory-store-'));
+    it('normalizes file path before matching', async () => {
+        const dir = await mkdtemp(path.join(os.tmpdir(), 'aws-memory-listbyfile-'));
         const storePath = path.join(dir, 'memory');
         const store = new MemoryStore(storePath);
         try {
-            await store.createMemory({ memory_type: 'task_list', uri: 'task://todo/a', content: 'task A' });
-            await store.createMemory({ memory_type: 'task_list', uri: 'task://todo/b', content: 'task B' });
-            // 标记第一条完成
-            await store.todoCompleted('task://todo/a');
-            // 标记第二条完成（全部完成 -> 自动清理）
-            const result = await store.todoCompleted('task://todo/b');
-            assert.equal(result.completed, true);
-            assert.equal(result.allCleaned, true);
-            assert.equal(result.cleanedCount, 2);
-            // 清理后应无 task_list
-            const allTaskList = await store.listByType('task_list');
-            assert.equal(allTaskList.length, 0);
+            await store.createMemory({
+                memory_type: 'project_memory',
+                uri: 'core://file/notes',
+                content: 'Notes',
+                bound_files: ['./src/main.ts'],
+            });
+            // Search with @/ prefix should normalize to ./src/main.ts
+            const results = await store.listByFile('@/src/main.ts');
+            assert.equal(results.length, 1);
+            assert.equal(results[0]?.uri, 'core://file/notes');
+            // Search with bare path should also match
+            const results2 = await store.listByFile('src/main.ts');
+            assert.equal(results2.length, 1);
+            // Search with / prefix should also match
+            const results3 = await store.listByFile('/src/main.ts');
+            assert.equal(results3.length, 1);
         }
         finally {
             await rm(dir, { recursive: true, force: true });
         }
     });
-    it('todoCompleted rejects non-task_list type', async () => {
-        const dir = await mkdtemp(path.join(os.tmpdir(), 'aws-memory-store-'));
+    it('returns empty when no bound_files match', async () => {
+        const dir = await mkdtemp(path.join(os.tmpdir(), 'aws-memory-listbyfile-'));
         const storePath = path.join(dir, 'memory');
         const store = new MemoryStore(storePath);
         try {
-            await store.createMemory({ memory_type: 'recently_memory', uri: 'recent://note/1', content: 'a note' });
-            await assert.rejects(() => store.todoCompleted('recent://note/1'), { message: /todo_completed only supports task_list type/ });
+            await store.createMemory({
+                memory_type: 'project_memory',
+                uri: 'core://other/entry',
+                content: 'No files bound',
+            });
+            const results = await store.listByFile('./src/main.ts');
+            assert.equal(results.length, 0);
         }
         finally {
             await rm(dir, { recursive: true, force: true });
         }
     });
-    it('todoCompleted rejects nonexistent uri', async () => {
-        const dir = await mkdtemp(path.join(os.tmpdir(), 'aws-memory-store-'));
+    it('matches memories with multiple bound_files', async () => {
+        const dir = await mkdtemp(path.join(os.tmpdir(), 'aws-memory-listbyfile-'));
+        const storePath = path.join(dir, 'memory');
+        const store = new MemoryStore(storePath);
+        try {
+            await store.createMemory({
+                memory_type: 'project_memory',
+                uri: 'core://multi/file',
+                content: 'Multi-file memory',
+                bound_files: ['./src/main.ts', './src/utils.ts'],
+            });
+            const results1 = await store.listByFile('./src/main.ts');
+            assert.equal(results1.length, 1);
+            const results2 = await store.listByFile('./src/utils.ts');
+            assert.equal(results2.length, 1);
+            const results3 = await store.listByFile('./src/other.ts');
+            assert.equal(results3.length, 0);
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+    it('filters by memory_type when provided', async () => {
+        const dir = await mkdtemp(path.join(os.tmpdir(), 'aws-memory-listbyfile-'));
         const storePath = path.join(dir, 'memory');
         const store = new MemoryStore(storePath);
         try {
-            await assert.rejects(() => store.todoCompleted('task://nonexistent'), { message: /Memory not found/ });
+            await store.createMemory({
+                memory_type: 'project_memory',
+                uri: 'core://permanent/notes',
+                content: 'Permanent notes',
+                bound_files: ['./src/main.ts'],
+            });
+            await store.createMemory({
+                memory_type: 'agent_memory',
+                uri: 'recent://temp/notes',
+                content: 'Temporary notes',
+                bound_files: ['./src/main.ts'],
+            });
+            // Both types match without filter
+            const allResults = await store.listByFile('./src/main.ts');
+            assert.equal(allResults.length, 2);
+            // Filter by memory type
+            const memResults = await store.listByFile('./src/main.ts', 'project_memory');
+            assert.equal(memResults.length, 1);
+            assert.equal(memResults[0]?.memory_type, 'project_memory');
+            // Filter with options object
+            const recentResults = await store.listByFile('./src/main.ts', { memory_type: 'agent_memory' });
+            assert.equal(recentResults.length, 1);
+            assert.equal(recentResults[0]?.memory_type, 'agent_memory');
         }
         finally {
             await rm(dir, { recursive: true, force: true });