@swarmclawai/swarmclaw 0.8.4 → 0.8.7

package/src/lib/server/memory-db.test.ts

@@ -0,0 +1,485 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { after, before, describe, it } from 'node:test'
+
+const originalEnv = {
+  DATA_DIR: process.env.DATA_DIR,
+  WORKSPACE_DIR: process.env.WORKSPACE_DIR,
+  SWARMCLAW_BUILD_MODE: process.env.SWARMCLAW_BUILD_MODE,
+}
+
+let tempDir = ''
+let memDb: typeof import('./memory-db')
+
+before(async () => {
+  tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-memory-db-'))
+  process.env.DATA_DIR = path.join(tempDir, 'data')
+  process.env.WORKSPACE_DIR = path.join(tempDir, 'workspace')
+  process.env.SWARMCLAW_BUILD_MODE = '1'
+  memDb = await import('./memory-db')
+})
+
+after(() => {
+  if (originalEnv.DATA_DIR === undefined) delete process.env.DATA_DIR
+  else process.env.DATA_DIR = originalEnv.DATA_DIR
+  if (originalEnv.WORKSPACE_DIR === undefined) delete process.env.WORKSPACE_DIR
+  else process.env.WORKSPACE_DIR = originalEnv.WORKSPACE_DIR
+  if (originalEnv.SWARMCLAW_BUILD_MODE === undefined) delete process.env.SWARMCLAW_BUILD_MODE
+  else process.env.SWARMCLAW_BUILD_MODE = originalEnv.SWARMCLAW_BUILD_MODE
+  fs.rmSync(tempDir, { recursive: true, force: true })
+})
+
+describe('memory-db', () => {
+  // --- Basic CRUD ---
+
+  describe('add and get', () => {
+    it('stores a memory and retrieves it by ID', () => {
+      const db = memDb.getMemoryDb()
+      const entry = db.add({
+        agentId: 'agent-1',
+        sessionId: 'session-1',
+        category: 'note',
+        title: 'Test Memory',
+        content: 'This is a test memory entry.',
+      })
+      assert.ok(entry.id)
+      assert.equal(entry.title, 'Test Memory')
+      assert.equal(entry.content, 'This is a test memory entry.')
+      assert.equal(entry.category, 'note')
+      assert.equal(entry.agentId, 'agent-1')
+
+      const retrieved = db.get(entry.id)
+      assert.ok(retrieved)
+      assert.equal(retrieved!.id, entry.id)
+      assert.equal(retrieved!.title, 'Test Memory')
+    })
+
+    it('generates unique IDs for each entry', () => {
+      const db = memDb.getMemoryDb()
+      const e1 = db.add({ agentId: null, category: 'note', title: 'A', content: 'a-content' })
+      const e2 = db.add({ agentId: null, category: 'note', title: 'B', content: 'b-content' })
+      assert.notEqual(e1.id, e2.id)
+    })
+
+    it('returns null for non-existent ID', () => {
+      const db = memDb.getMemoryDb()
+      assert.equal(db.get('nonexistent-id-xyz'), null)
+    })
+  })
+
+  // --- Update ---
+
+  describe('update', () => {
+    it('updates a memory entry', () => {
+      const db = memDb.getMemoryDb()
+      const entry = db.add({
+        agentId: 'agent-up',
+        category: 'note',
+        title: 'Original Title',
+        content: 'Original content.',
+      })
+      const updated = db.update(entry.id, { title: 'Updated Title', content: 'Updated content.' })
+      assert.ok(updated)
+      assert.equal(updated!.title, 'Updated Title')
+      assert.equal(updated!.content, 'Updated content.')
+      assert.equal(updated!.agentId, 'agent-up')
+    })
+
+    it('returns null when updating non-existent entry', () => {
+      const db = memDb.getMemoryDb()
+      assert.equal(db.update('nonexistent-id', { title: 'Nope' }), null)
+    })
+  })
+
+  // --- Delete ---
+
+  describe('delete', () => {
+    it('removes a memory entry', () => {
+      const db = memDb.getMemoryDb()
+      const entry = db.add({
+        agentId: 'agent-del',
+        category: 'note',
+        title: 'To Delete',
+        content: 'This will be deleted.',
+      })
+      assert.ok(db.get(entry.id))
+      db.delete(entry.id)
+      assert.equal(db.get(entry.id), null)
+    })
+  })
+
+  // --- List ---
+
+  describe('list', () => {
+    it('lists memories for an agent', () => {
+      const db = memDb.getMemoryDb()
+      const agentId = `agent-list-${Date.now()}`
+      db.add({ agentId, category: 'note', title: 'List 1', content: 'Content 1' })
+      db.add({ agentId, category: 'note', title: 'List 2', content: 'Content 2' })
+      db.add({ agentId: 'other-agent', category: 'note', title: 'Other', content: 'Other content' })
+
+      const agentMemories = db.list(agentId)
+      assert.ok(agentMemories.length >= 2, `Expected at least 2 agent memories, got ${agentMemories.length}`)
+      const titles = agentMemories.map((m) => m.title)
+      assert.ok(titles.includes('List 1'))
+      assert.ok(titles.includes('List 2'))
+    })
+
+    it('respects limit parameter', () => {
+      const db = memDb.getMemoryDb()
+      const agentId = `agent-limit-${Date.now()}`
+      for (let i = 0; i < 10; i++) {
+        db.add({ agentId, category: 'note', title: `Mem ${i}`, content: `Content ${i}` })
+      }
+      const limited = db.list(agentId, 3)
+      assert.equal(limited.length, 3)
+    })
+  })
+
+  // --- FTS5 Search ---
+
+  describe('search (FTS5)', () => {
+    it('finds memories by content keyword', () => {
+      const db = memDb.getMemoryDb()
+      const agentId = `agent-fts-${Date.now()}`
+      db.add({
+        agentId,
+        category: 'note',
+        title: 'Kubernetes Deployment',
+        content: 'Deployed the application to a Kubernetes cluster using Helm charts.',
+      })
+      db.add({
+        agentId,
+        category: 'note',
+        title: 'Database Migration',
+        content: 'Ran the PostgreSQL migration scripts successfully.',
+      })
+
+      const results = db.search('kubernetes deployment helm', agentId)
+      assert.ok(results.length >= 1, `Expected FTS results for kubernetes, got ${results.length}`)
+      const titles = results.map((r) => r.title)
+      assert.ok(titles.includes('Kubernetes Deployment'))
+    })
+
+    it('returns empty for skip-query patterns', () => {
+      const db = memDb.getMemoryDb()
+      assert.deepEqual(db.search(''), [])
+      assert.deepEqual(db.search('swarm_heartbeat_check'), [])
+    })
+
+    it('returns empty for very long queries', () => {
+      const db = memDb.getMemoryDb()
+      const longQuery = 'x'.repeat(1300)
+      assert.deepEqual(db.search(longQuery), [])
+    })
+  })
+
+  // --- buildFtsQuery ---
+
+  describe('buildFtsQuery', () => {
+    it('removes stop words', () => {
+      const query = memDb.buildFtsQuery('what is the purpose of this')
+      // 'what', 'is', 'the', 'of', 'this' are stop words; 'purpose' should remain
+      assert.ok(query.includes('purpose'))
+      assert.ok(!query.includes('"the"'))
+    })
+
+    it('returns empty for all stop words', () => {
+      const query = memDb.buildFtsQuery('the is a an')
+      assert.equal(query, '')
+    })
+
+    it('limits to MAX_FTS_QUERY_TERMS', () => {
+      const query = memDb.buildFtsQuery('alpha bravo charlie delta echo foxtrot golf hotel india juliet')
+      // Should have at most 4 terms (slice 0..4)
+      const termCount = (query.match(/AND/g) || []).length + 1
+      assert.ok(termCount <= 4, `Expected at most 4 terms, got ${termCount}`)
+    })
+
+    it('handles empty input', () => {
+      assert.equal(memDb.buildFtsQuery(''), '')
+    })
+
+    it('deduplicates terms', () => {
+      const query = memDb.buildFtsQuery('kubernetes kubernetes kubernetes')
+      // Should only have one kubernetes
+      const occurrences = (query.match(/kubernetes/g) || []).length
+      assert.equal(occurrences, 1)
+    })
+
+    it('skips very short terms', () => {
+      const query = memDb.buildFtsQuery('go is ok no')
+      // All terms are <3 chars or stop words
+      assert.equal(query, '')
+    })
+  })
+
+  // --- Content hash dedup ---
+
+  describe('content hash dedup', () => {
+    it('reinforces instead of duplicating same content for same agent', () => {
+      const db = memDb.getMemoryDb()
+      const agentId = `agent-dedup-${Date.now()}`
+      const first = db.add({
+        agentId,
+        category: 'fact',
+        title: 'Dedup Test',
+        content: 'Identical content for dedup testing.',
+      })
+      const second = db.add({
+        agentId,
+        category: 'fact',
+        title: 'Dedup Test Different Title',
+        content: 'Identical content for dedup testing.',
+      })
+      // Should return the same ID (reinforced, not duplicated)
+      assert.equal(second.id, first.id)
+      assert.ok((second.reinforcementCount || 0) >= 1, 'Expected reinforcement count to increase')
+    })
+  })
+
+  // --- Memory linking ---
+
+  describe('link and unlink', () => {
+    it('links two memories bidirectionally', () => {
+      const db = memDb.getMemoryDb()
+      const a = db.add({ agentId: 'agent-link', category: 'note', title: 'Memory A', content: 'Content A' })
+      const b = db.add({ agentId: 'agent-link', category: 'note', title: 'Memory B', content: 'Content B' })
+
+      db.link(a.id, [b.id])
+
+      const aAfter = db.get(a.id)
+      const bAfter = db.get(b.id)
+      assert.ok(aAfter!.linkedMemoryIds?.includes(b.id), 'A should link to B')
+      assert.ok(bAfter!.linkedMemoryIds?.includes(a.id), 'B should link back to A')
+    })
+
+    it('unlinks memories bidirectionally', () => {
+      const db = memDb.getMemoryDb()
+      const a = db.add({ agentId: 'agent-unlink', category: 'note', title: 'Unlink A', content: 'Unlink Content A' })
+      const b = db.add({ agentId: 'agent-unlink', category: 'note', title: 'Unlink B', content: 'Unlink Content B' })
+
+      db.link(a.id, [b.id])
+      db.unlink(a.id, [b.id])
+
+      const aAfter = db.get(a.id)
+      const bAfter = db.get(b.id)
+      const aLinks = aAfter?.linkedMemoryIds || []
+      const bLinks = bAfter?.linkedMemoryIds || []
+      assert.ok(!aLinks.includes(b.id), 'A should no longer link to B')
+      assert.ok(!bLinks.includes(a.id), 'B should no longer link to A')
+    })
+
+    it('link returns null for non-existent source', () => {
+      const db = memDb.getMemoryDb()
+      assert.equal(db.link('nonexistent', ['also-nonexistent']), null)
+    })
+  })
+
+  // --- Pinned memories ---
+
+  describe('pinned memories', () => {
+    it('lists pinned memories for an agent', () => {
+      const db = memDb.getMemoryDb()
+      const agentId = `agent-pinned-${Date.now()}`
+      db.add({ agentId, category: 'note', title: 'Regular', content: 'Not pinned' })
+      db.add({ agentId, category: 'note', title: 'Pinned One', content: 'This is pinned', pinned: true })
+
+      const pinned = db.listPinned(agentId)
+      assert.ok(pinned.length >= 1)
+      assert.ok(pinned.some((m) => m.title === 'Pinned One'))
+      assert.ok(pinned.every((m) => m.pinned === true))
+    })
+  })
+
+  // --- Scope filtering ---
+
+  describe('filterMemoriesByScope', () => {
+    it('returns all entries with mode=all', () => {
+      const entries = [
+        { id: '1', agentId: 'a1', category: 'note', title: 'x', content: 'y', createdAt: 0, updatedAt: 0 },
+        { id: '2', agentId: null, category: 'note', title: 'x', content: 'y', createdAt: 0, updatedAt: 0 },
+      ]
+      const result = memDb.filterMemoriesByScope(entries, { mode: 'all' })
+      assert.equal(result.length, 2)
+    })
+
+    it('filters to global-only with mode=global', () => {
+      const entries = [
+        { id: '1', agentId: 'a1', category: 'note', title: 'x', content: 'y', createdAt: 0, updatedAt: 0 },
+        { id: '2', agentId: null, category: 'note', title: 'x', content: 'y', createdAt: 0, updatedAt: 0 },
+      ]
+      const result = memDb.filterMemoriesByScope(entries, { mode: 'global' })
+      assert.equal(result.length, 1)
+      assert.equal(result[0].id, '2')
+    })
+
+    it('filters by agent with mode=agent', () => {
+      const entries = [
+        { id: '1', agentId: 'a1', category: 'note', title: 'x', content: 'y', createdAt: 0, updatedAt: 0 },
+        { id: '2', agentId: 'a2', category: 'note', title: 'x', content: 'y', createdAt: 0, updatedAt: 0 },
+      ]
+      const result = memDb.filterMemoriesByScope(entries, { mode: 'agent', agentId: 'a1' })
+      assert.equal(result.length, 1)
+      assert.equal(result[0].agentId, 'a1')
+    })
+
+    it('includes shared-with entries in agent mode', () => {
+      const entries = [
+        { id: '1', agentId: 'a2', sharedWith: ['a1'], category: 'note', title: 'x', content: 'y', createdAt: 0, updatedAt: 0 },
+      ]
+      const result = memDb.filterMemoriesByScope(entries, { mode: 'agent', agentId: 'a1' })
+      assert.equal(result.length, 1)
+    })
+
+    it('returns empty for agent mode without agentId', () => {
+      const entries = [
+        { id: '1', agentId: 'a1', category: 'note', title: 'x', content: 'y', createdAt: 0, updatedAt: 0 },
+      ]
+      const result = memDb.filterMemoriesByScope(entries, { mode: 'agent' })
+      assert.equal(result.length, 0)
+    })
+
+    it('filters by session with mode=session', () => {
+      const entries = [
+        { id: '1', agentId: 'a1', sessionId: 's1', category: 'note', title: 'x', content: 'y', createdAt: 0, updatedAt: 0 },
+        { id: '2', agentId: 'a1', sessionId: 's2', category: 'note', title: 'x', content: 'y', createdAt: 0, updatedAt: 0 },
+      ]
+      const result = memDb.filterMemoriesByScope(entries, { mode: 'session', sessionId: 's1' })
+      assert.equal(result.length, 1)
+      assert.equal(result[0].sessionId, 's1')
+    })
+  })
+
+  // --- normalizeMemoryScopeMode ---
+
+  describe('normalizeMemoryScopeMode', () => {
+    it('normalizes known modes', () => {
+      assert.equal(memDb.normalizeMemoryScopeMode('all'), 'all')
+      assert.equal(memDb.normalizeMemoryScopeMode('global'), 'global')
+      assert.equal(memDb.normalizeMemoryScopeMode('agent'), 'agent')
+      assert.equal(memDb.normalizeMemoryScopeMode('session'), 'session')
+      assert.equal(memDb.normalizeMemoryScopeMode('project'), 'project')
+    })
+
+    it('maps shared to global', () => {
+      assert.equal(memDb.normalizeMemoryScopeMode('shared'), 'global')
+    })
+
+    it('defaults to auto for unknown', () => {
+      assert.equal(memDb.normalizeMemoryScopeMode('invalid'), 'auto')
+      assert.equal(memDb.normalizeMemoryScopeMode(''), 'auto')
+      assert.equal(memDb.normalizeMemoryScopeMode(null), 'auto')
+      assert.equal(memDb.normalizeMemoryScopeMode(undefined), 'auto')
+    })
+  })
+
+  // --- getLatestBySessionCategory ---
+
+  describe('getLatestBySessionCategory', () => {
+    it('returns a memory for a valid session+category', () => {
+      const db = memDb.getMemoryDb()
+      const sessionId = `sess-latest-${Date.now()}`
+      db.add({ agentId: 'a', sessionId, category: 'working/context', title: 'Entry A', content: 'content alpha unique' })
+      db.add({ agentId: 'a', sessionId, category: 'working/context', title: 'Entry B', content: 'content beta unique' })
+
+      const latest = db.getLatestBySessionCategory(sessionId, 'working/context')
+      assert.ok(latest, 'Should return a memory entry')
+      assert.equal(latest!.sessionId, sessionId)
+      assert.equal(latest!.category, 'working/context')
+    })
+
+    it('returns null for non-matching category', () => {
+      const db = memDb.getMemoryDb()
+      const sessionId = `sess-nomatch-${Date.now()}`
+      db.add({ agentId: 'a', sessionId, category: 'note', title: 'X', content: 'x content unique nomatch' })
+      assert.equal(db.getLatestBySessionCategory(sessionId, 'working/context'), null)
+    })
+
+    it('returns null for empty session/category', () => {
+      const db = memDb.getMemoryDb()
+      assert.equal(db.getLatestBySessionCategory('', 'note'), null)
+      assert.equal(db.getLatestBySessionCategory('valid', ''), null)
+    })
+  })
+
+  // --- countsByAgent ---
+
+  describe('countsByAgent', () => {
+    it('returns counts grouped by agent', () => {
+      const db = memDb.getMemoryDb()
+      // Data already exists from previous tests — just verify the shape
+      const counts = db.countsByAgent()
+      assert.equal(typeof counts, 'object')
+      // Should have at least one key
+      assert.ok(Object.keys(counts).length >= 1)
+      for (const [, val] of Object.entries(counts)) {
+        assert.equal(typeof val, 'number')
+        assert.ok(val > 0)
+      }
+    })
+  })
+
+  // --- Delete cleans up links ---
+
+  describe('delete cleans up linked references', () => {
+    it('removes deleted ID from other memories linkedMemoryIds', () => {
+      const db = memDb.getMemoryDb()
+      const a = db.add({ agentId: 'agent-cleanup', category: 'note', title: 'Cleanup A', content: 'Cleanup A content' })
+      const b = db.add({ agentId: 'agent-cleanup', category: 'note', title: 'Cleanup B', content: 'Cleanup B content' })
+      const c = db.add({ agentId: 'agent-cleanup', category: 'note', title: 'Cleanup C', content: 'Cleanup C content' })
+
+      db.link(a.id, [b.id, c.id])
+
+      // Verify links exist
+      const bBefore = db.get(b.id)
+      assert.ok(bBefore?.linkedMemoryIds?.includes(a.id))
+
+      // Delete A
+      db.delete(a.id)
+
+      // B and C should no longer reference A
+      const bAfter = db.get(b.id)
+      const cAfter = db.get(c.id)
+      const bLinks = bAfter?.linkedMemoryIds || []
+      const cLinks = cAfter?.linkedMemoryIds || []
+      assert.ok(!bLinks.includes(a.id), 'B should not reference deleted A')
+      assert.ok(!cLinks.includes(a.id), 'C should not reference deleted A')
+    })
+  })
+
+  // --- addKnowledge ---
+
+  describe('addKnowledge', () => {
+    it('creates a global knowledge entry', () => {
+      const entry = memDb.addKnowledge({
+        title: 'API Rate Limits',
+        content: 'The API has a rate limit of 100 requests per minute.',
+        tags: ['api', 'limits'],
+      })
+      assert.ok(entry.id)
+      assert.equal(entry.category, 'knowledge')
+      assert.equal(entry.agentId, null)
+      assert.equal(entry.title, 'API Rate Limits')
+    })
+  })
+
+  // --- searchKnowledge ---
+
+  describe('searchKnowledge', () => {
+    it('finds knowledge entries by query', () => {
+      // Add a knowledge entry with a unique term
+      memDb.addKnowledge({
+        title: 'Photosynthesis Process',
+        content: 'Chlorophyll absorbs sunlight to convert carbon dioxide into glucose.',
+        tags: ['biology', 'science'],
+      })
+
+      const results = memDb.searchKnowledge('chlorophyll photosynthesis glucose')
+      assert.ok(results.length >= 1, `Expected at least 1 result, got ${results.length}`)
+      assert.ok(results.every((r) => r.category === 'knowledge'))
+    })
+  })
+})

package/src/lib/server/memory-db.ts

@@ -16,10 +16,13 @@ import {
 } from './memory-graph'
 import { isWorkingMemoryCategory } from './memory-tiers'
 
-import { DATA_DIR } from './data-dir'
+import { DATA_DIR, MEMORY_IMAGES_DIR, WORKSPACE_DIR } from './data-dir'
+import { safeJsonParse } from './json-utils'
+import { tryResolvePathWithinBaseDir } from './path-utils'
 
 const DB_PATH = path.join(DATA_DIR, 'memory.db')
-const IMAGES_DIR = path.join(DATA_DIR, 'memory-images')
+const IMAGES_DIR = MEMORY_IMAGES_DIR
+const APP_STATE_ROOT_DIR = path.dirname(DATA_DIR)
 
 const MAX_IMAGE_INPUT_BYTES = 10 * 1024 * 1024 // 10MB
 const IMAGE_EXT_WHITELIST = new Set(['.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp', '.tiff'])
@@ -303,15 +306,6 @@ export function getMemoryLookupLimits(settingsOverride?: Record<string, unknown>
   return normalizeMemoryLookupLimits(settings)
 }
 
-function parseJsonSafe<T>(value: unknown, fallback: T): T {
-  if (typeof value !== 'string' || !value.trim()) return fallback
-  try {
-    return JSON.parse(value) as T
-  } catch {
-    return fallback
-  }
-}
-
 function normalizeReferencePath(raw: unknown): string | undefined {
   if (typeof raw !== 'string') return undefined
   const value = raw.trim()
@@ -354,9 +348,15 @@ export function buildFtsQuery(input: string): string {
 
 function resolveExists(pathValue: string | undefined): boolean | undefined {
   if (!pathValue) return undefined
-  const absolute = path.isAbsolute(pathValue) ? pathValue : path.resolve(process.cwd(), pathValue)
+  const candidates = path.isAbsolute(pathValue)
+    ? [pathValue]
+    : [
+      tryResolvePathWithinBaseDir(APP_STATE_ROOT_DIR, pathValue),
+      tryResolvePathWithinBaseDir(WORKSPACE_DIR, pathValue),
+    ].filter((candidate): candidate is string => !!candidate)
+  if (candidates.length === 0) return undefined
   try {
-    return fs.existsSync(absolute)
+    return candidates.some((candidate) => fs.existsSync(candidate))
   } catch {
     return undefined
   }
@@ -577,10 +577,10 @@ function initDb() {
   const migrateLegacyRows = db.transaction(() => {
     let migrated = 0
     for (const row of rowsForMigration) {
-      const legacyFilePaths = parseJsonSafe<FileReference[]>(row.filePaths, [])
-      const refs = normalizeReferences(parseJsonSafe<MemoryReference[]>(row.refs, []), legacyFilePaths)
-      const image = normalizeImage(parseJsonSafe<MemoryImage | null>(row.image, null), row.imagePath)
-      const linkedIds = normalizeLinkedMemoryIds(parseJsonSafe<string[]>(row.linkedMemoryIds, []), row.id)
+      const legacyFilePaths = safeJsonParse<FileReference[]>(row.filePaths, [])
+      const refs = normalizeReferences(safeJsonParse<MemoryReference[]>(row.refs, []), legacyFilePaths)
+      const image = normalizeImage(safeJsonParse<MemoryImage | null>(row.image, null), row.imagePath)
+      const linkedIds = normalizeLinkedMemoryIds(safeJsonParse<string[]>(row.linkedMemoryIds, []), row.id)
 
       const nextRefs = refs?.length ? JSON.stringify(refs) : null
       const nextImage = image ? JSON.stringify(image) : null
@@ -699,11 +699,11 @@ function initDb() {
   }
 
   function rowToEntry(row: Record<string, unknown>): MemoryEntry {
-    const legacyFilePaths = parseJsonSafe<FileReference[]>(row.filePaths, [])
-    const references = normalizeReferences(parseJsonSafe<MemoryReference[]>(row.references, []), legacyFilePaths)
-    const image = normalizeImage(parseJsonSafe<MemoryImage | null>(row.image, null), typeof row.imagePath === 'string' ? row.imagePath : null)
+    const legacyFilePaths = safeJsonParse<FileReference[]>(row.filePaths, [])
+    const references = normalizeReferences(safeJsonParse<MemoryReference[]>(row.references, []), legacyFilePaths)
+    const image = normalizeImage(safeJsonParse<MemoryImage | null>(row.image, null), typeof row.imagePath === 'string' ? row.imagePath : null)
     const filePaths = referencesToLegacyFilePaths(references)
-    const linkedMemoryIds = normalizeLinkedMemoryIds(parseJsonSafe<string[]>(row.linkedMemoryIds, []), typeof row.id === 'string' ? row.id : undefined)
+    const linkedMemoryIds = normalizeLinkedMemoryIds(safeJsonParse<string[]>(row.linkedMemoryIds, []), typeof row.id === 'string' ? row.id : undefined)
 
     return {
       id: String(row.id || ''),
@@ -712,14 +712,14 @@ function initDb() {
       category: typeof row.category === 'string' ? row.category : 'note',
       title: typeof row.title === 'string' ? row.title : 'Untitled',
       content: typeof row.content === 'string' ? row.content : '',
-      metadata: parseJsonSafe<Record<string, unknown> | undefined>(row.metadata, undefined),
+      metadata: safeJsonParse<Record<string, unknown> | undefined>(row.metadata, undefined),
       references,
       filePaths,
       image,
       imagePath: image?.path || undefined,
       linkedMemoryIds: linkedMemoryIds.length ? linkedMemoryIds : undefined,
       pinned: row.pinned === 1,
-      sharedWith: parseJsonSafe<string[]>(row.sharedWith, []).length ? parseJsonSafe<string[]>(row.sharedWith, []) : undefined,
+      sharedWith: safeJsonParse<string[]>(row.sharedWith, []).length ? safeJsonParse<string[]>(row.sharedWith, []) : undefined,
       accessCount: typeof row.accessCount === 'number' ? row.accessCount : 0,
       lastAccessedAt: typeof row.lastAccessedAt === 'number' ? row.lastAccessedAt : 0,
       contentHash: typeof row.contentHash === 'string' ? row.contentHash : undefined,
@@ -888,14 +888,27 @@ function initDb() {
       const row = stmts.getById.get(id) as Record<string, unknown> | undefined
       const entry = row ? rowToEntry(row) : null
       if (entry?.image?.path || entry?.imagePath) {
-        const imgPath = path.join(process.cwd(), entry.image?.path || entry.imagePath || '')
-        try { fs.unlinkSync(imgPath) } catch { /* file may not exist */ }
+        const imagePath = entry.image?.path || entry.imagePath || ''
+        const candidatePaths = path.isAbsolute(imagePath)
+          ? [imagePath]
+          : [
+            tryResolvePathWithinBaseDir(APP_STATE_ROOT_DIR, imagePath),
+            tryResolvePathWithinBaseDir(WORKSPACE_DIR, imagePath),
+          ].filter((candidate): candidate is string => !!candidate)
+        for (const imgPath of candidatePaths) {
+          try {
+            fs.unlinkSync(imgPath)
+            break
+          } catch {
+            // file may not exist
+          }
+        }
       }
       stmts.delete.run(id)
       // Remove this ID from any other memory's linkedMemoryIds
       const linking = stmts.findMemoriesLinkingTo.all(`%"${id}"%`) as any[]
       for (const row of linking) {
-        const ids = normalizeLinkedMemoryIds(parseJsonSafe<string[]>(row.linkedMemoryIds, []), row.id)
+        const ids = normalizeLinkedMemoryIds(safeJsonParse<string[]>(row.linkedMemoryIds, []), row.id)
         const filtered = ids.filter((lid: string) => lid !== id)
         stmts.updateLinks.run(filtered.length ? JSON.stringify(filtered) : null, Date.now(), row.id)
       }

package/src/lib/server/memory-graph.test.ts

@@ -5,8 +5,8 @@ import {
   normalizeMemoryLookupLimits,
   resolveLookupRequest,
   traverseLinkedMemoryGraph,
-} from './memory-graph.ts'
-import type { MemoryLookupLimits, LinkedMemoryNode } from './memory-graph.ts'
+} from './memory-graph'
+import type { MemoryLookupLimits, LinkedMemoryNode } from './memory-graph'
 
 describe('normalizeLinkedMemoryIds', () => {
   it('filters empty strings and self-references', () => {

package/src/lib/server/memory-policy.test.ts

@@ -10,10 +10,10 @@ import {
 } from './memory-policy'
 
 test('normalizeMemoryCategory maps flat categories into hierarchical buckets', () => {
-  assert.equal(normalizeMemoryCategory('preference', 'User prefers terse replies'), 'identity/preferences')
-  assert.equal(normalizeMemoryCategory('decision', 'Ship the Docker path'), 'projects/decisions')
-  assert.equal(normalizeMemoryCategory('error', 'Root cause found'), 'execution/errors')
-  assert.equal(normalizeMemoryCategory('project', 'Repo setup'), 'projects/context')
+  assert.equal(normalizeMemoryCategory('preference', 'User prefers terse replies', null), 'identity/preferences')
+  assert.equal(normalizeMemoryCategory('decision', 'Ship the Docker path', null), 'projects/decisions')
+  assert.equal(normalizeMemoryCategory('error', 'Root cause found', null), 'execution/errors')
+  assert.equal(normalizeMemoryCategory('project', 'Repo setup', null), 'projects/context')
 })
 
 test('shouldInjectMemoryContext skips low-signal greetings and acknowledgements', () => {
@@ -54,12 +54,12 @@ test('isDirectMemoryWriteRequest detects remember-and-confirm turns without matc
 })
 
 test('shouldAutoCaptureMemory filters noisy turns', () => {
-  assert.equal(shouldAutoCaptureMemory({ message: 'thanks', response: 'Happy to help with that.', source: 'chat' }), false)
-  assert.equal(shouldAutoCaptureMemory({ message: 'Please save this to memory', response: 'Stored memory "note".', source: 'chat' }), false)
+  assert.equal(shouldAutoCaptureMemory({ message: 'thanks', response: 'Happy to help with that.' }), false)
+  assert.equal(shouldAutoCaptureMemory({ message: 'Please save this to memory', response: 'Stored memory "note".' }), false)
   assert.equal(shouldAutoCaptureMemory({
     message: 'We decided to use the shared staging environment and keep the worker count at 2 for now.',
     response: 'Decision captured: shared staging, worker count 2, and we will revisit after load testing next week.',
-    source: 'chat',
+    // source: 'chat',
   }), true)
 })
 

package/src/lib/server/memory-retrieval.test.ts

@@ -1,7 +1,7 @@
 import assert from 'node:assert/strict'
 import { test } from 'node:test'
 import type { MemoryEntry } from '@/types'
-import { filterMemoriesByScope, normalizeMemoryScopeMode } from './memory-db.ts'
+import { filterMemoriesByScope, normalizeMemoryScopeMode } from './memory-db'
 
 function makeEntry(id: string, patch: Partial<MemoryEntry> = {}): MemoryEntry {
   return {