@swarmclawai/swarmclaw 0.6.0 → 0.6.3

package/src/lib/server/connectors/media.ts

@@ -74,6 +74,11 @@ export function isImageMime(mime: string): boolean {
   return mime.startsWith('image/')
 }
 
+/** Check if a MIME type is audio */
+export function isAudioMime(mime: string): boolean {
+  return mime.startsWith('audio/')
+}
+
 export function inferInboundMediaType(mimeType?: string, fileName?: string, fallback: InboundMediaType = 'file'): InboundMediaType {
   const probe = `${mimeType || ''} ${fileName || ''}`.toLowerCase()
   if (probe.includes('image')) return 'image'

package/src/lib/server/connectors/telegram.ts

@@ -3,7 +3,7 @@ import fs from 'fs'
 import path from 'path'
 import type { Connector } from '@/types'
 import type { PlatformConnector, ConnectorInstance, InboundMessage, InboundMediaType } from './types'
-import { downloadInboundMediaToUpload, inferInboundMediaType, mimeFromPath, isImageMime } from './media'
+import { downloadInboundMediaToUpload, inferInboundMediaType, mimeFromPath, isImageMime, isAudioMime } from './media'
 import { isNoMessage } from './manager'
 
 const telegram: PlatformConnector = {
@@ -181,6 +181,11 @@ const telegram: PlatformConnector = {
           if (isImageMime(mime)) {
             const msg = await bot.api.sendPhoto(chatId, inputFile, { caption })
             return { messageId: String(msg.message_id) }
+          } else if (isAudioMime(mime)) {
+            const msg = options?.ptt
+              ? await bot.api.sendVoice(chatId, inputFile, { caption })
+              : await bot.api.sendAudio(chatId, inputFile, { caption })
+            return { messageId: String(msg.message_id) }
           } else {
             const msg = await bot.api.sendDocument(chatId, inputFile, { caption })
             return { messageId: String(msg.message_id) }
@@ -193,7 +198,12 @@ const telegram: PlatformConnector = {
         }
         // URL-based file
         if (options?.fileUrl) {
-          const msg = await bot.api.sendDocument(chatId, options.fileUrl, { caption })
+          const mime = options.mimeType || ''
+          const msg = isAudioMime(mime)
+            ? options?.ptt
+              ? await bot.api.sendVoice(chatId, options.fileUrl, { caption })
+              : await bot.api.sendAudio(chatId, options.fileUrl, { caption })
+            : await bot.api.sendDocument(chatId, options.fileUrl, { caption })
           return { messageId: String(msg.message_id) }
         }
         // Text only

package/src/lib/server/connectors/types.ts

@@ -44,6 +44,8 @@ export interface ConnectorInstance {
       mimeType?: string
       fileName?: string
       caption?: string
+      /** Send audio as a WhatsApp voice note (push-to-talk) */
+      ptt?: boolean
     },
   ) => Promise<{ messageId?: string } | void>
   /** Current QR code data URL (WhatsApp only, null when paired) */

package/src/lib/server/connectors/whatsapp.ts

@@ -10,12 +10,13 @@ import path from 'path'
 import fs from 'fs'
 import type { Connector } from '@/types'
 import type { PlatformConnector, ConnectorInstance, InboundMessage } from './types'
-import { saveInboundMediaBuffer, mimeFromPath, isImageMime } from './media'
+import { saveInboundMediaBuffer, mimeFromPath, isImageMime, isAudioMime } from './media'
 import { isNoMessage } from './manager'
 
 import { DATA_DIR } from '../data-dir'
 
 const AUTH_DIR = path.join(DATA_DIR, 'whatsapp-auth')
+const INBOUND_DEDUPE_TTL_MS = 2 * 60 * 1000
 
 /** Normalize a phone number for JID matching — strip leading 0 or + */
 function normalizeNumber(num: string): string {
@@ -57,6 +58,7 @@ const whatsapp: PlatformConnector = {
     let sock: ReturnType<typeof makeWASocket> | null = null
     let stopped = false
     let socketGen = 0 // Track socket generation to ignore stale events
+    const seenInboundMessageIds = new Map<string, number>()
 
     const instance: ConnectorInstance = {
       connector,
@@ -74,7 +76,15 @@ const whatsapp: PlatformConnector = {
           const fName = options.fileName || path.basename(options.mediaPath)
           let sent
           if (isImageMime(mime)) {
-            sent = await sock.sendMessage(channelId, { image: buf, caption, mimetype: mime })
+            try {
+              sent = await sock.sendMessage(channelId, { image: buf, caption, mimetype: mime })
+            } catch (err: unknown) {
+              const errMsg = err instanceof Error ? err.message : String(err)
+              console.warn(`[whatsapp] Image send failed (${errMsg}); retrying as document: ${fName}`)
+              sent = await sock.sendMessage(channelId, { document: buf, fileName: fName, mimetype: mime, caption })
+            }
+          } else if (isAudioMime(mime)) {
+            sent = await sock.sendMessage(channelId, { audio: buf, mimetype: mime, ptt: options.ptt !== false })
           } else {
             sent = await sock.sendMessage(channelId, { document: buf, fileName: fName, mimetype: mime, caption })
           }
@@ -228,6 +238,22 @@ const whatsapp: PlatformConnector = {
 
           if (msg.key.remoteJid === 'status@broadcast') continue
 
+          const msgId = msg.key.id || ''
+          if (msgId) {
+            const now = Date.now()
+            const seenAt = seenInboundMessageIds.get(msgId)
+            if (typeof seenAt === 'number' && now - seenAt <= INBOUND_DEDUPE_TTL_MS) {
+              console.log(`[whatsapp] Skipping duplicate inbound message id: ${msgId}`)
+              continue
+            }
+            seenInboundMessageIds.set(msgId, now)
+            if (seenInboundMessageIds.size > 5000) {
+              for (const [id, ts] of seenInboundMessageIds.entries()) {
+                if (now - ts > INBOUND_DEDUPE_TTL_MS) seenInboundMessageIds.delete(id)
+              }
+            }
+          }
+
           // Skip messages sent by the bot itself (tracked by ID to prevent infinite loops)
           if (msg.key.id && sentMessageIds.has(msg.key.id)) {
             console.log(`[whatsapp] Skipping own bot reply: ${msg.key.id}`)

package/src/lib/server/elevenlabs.test.ts

@@ -0,0 +1,60 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { requestElevenLabsMp3Stream, synthesizeElevenLabsMp3 } from './elevenlabs'
+
+describe('elevenlabs helpers', () => {
+  it('synthesizeElevenLabsMp3 posts TTS request and returns audio bytes', async () => {
+    const originalFetch = global.fetch
+    const originalKey = process.env.ELEVENLABS_API_KEY
+    const originalVoice = process.env.ELEVENLABS_VOICE
+    process.env.ELEVENLABS_API_KEY = 'test-key'
+    process.env.ELEVENLABS_VOICE = 'voice-123'
+
+    let called = false
+    global.fetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
+      called = true
+      assert.equal(String(input), 'https://api.elevenlabs.io/v1/text-to-speech/voice-123')
+      assert.equal(init?.method, 'POST')
+      assert.equal((init?.headers as Record<string, string>)['xi-api-key'], 'test-key')
+      return new Response(Buffer.from('abc'), { status: 200, headers: { 'Content-Type': 'audio/mpeg' } })
+    }) as typeof fetch
+
+    try {
+      const out = await synthesizeElevenLabsMp3({ text: 'hello world' })
+      assert.ok(called)
+      assert.equal(out.toString('utf8'), 'abc')
+    } finally {
+      global.fetch = originalFetch
+      if (originalKey === undefined) delete process.env.ELEVENLABS_API_KEY
+      else process.env.ELEVENLABS_API_KEY = originalKey
+      if (originalVoice === undefined) delete process.env.ELEVENLABS_VOICE
+      else process.env.ELEVENLABS_VOICE = originalVoice
+    }
+  })
+
+  it('requestElevenLabsMp3Stream calls streaming endpoint', async () => {
+    const originalFetch = global.fetch
+    const originalKey = process.env.ELEVENLABS_API_KEY
+    const originalVoice = process.env.ELEVENLABS_VOICE
+    process.env.ELEVENLABS_API_KEY = 'test-key'
+    process.env.ELEVENLABS_VOICE = 'voice-xyz'
+
+    global.fetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
+      assert.equal(String(input), 'https://api.elevenlabs.io/v1/text-to-speech/voice-xyz/stream')
+      assert.equal(init?.method, 'POST')
+      return new Response('stream', { status: 200, headers: { 'Content-Type': 'audio/mpeg' } })
+    }) as typeof fetch
+
+    try {
+      const res = await requestElevenLabsMp3Stream({ text: 'streaming text' })
+      assert.equal(res.status, 200)
+      assert.equal(await res.text(), 'stream')
+    } finally {
+      global.fetch = originalFetch
+      if (originalKey === undefined) delete process.env.ELEVENLABS_API_KEY
+      else process.env.ELEVENLABS_API_KEY = originalKey
+      if (originalVoice === undefined) delete process.env.ELEVENLABS_VOICE
+      else process.env.ELEVENLABS_VOICE = originalVoice
+    }
+  })
+})

package/src/lib/server/elevenlabs.ts

@@ -0,0 +1,103 @@
+import { loadSettings } from './storage'
+
+const DEFAULT_VOICE_ID = 'JBFqnCBsd6RMkjVDRZzb'
+const DEFAULT_MODEL_ID = 'eleven_multilingual_v2'
+
+function getErrorMessage(err: unknown): string {
+  if (err instanceof Error && err.message) return err.message
+  return String(err)
+}
+
+export function resolveElevenLabsConfig(voiceId?: string | null): {
+  apiKey: string
+  voiceId: string
+} {
+  const settings = loadSettings()
+  const apiKey = String(settings.elevenLabsApiKey || process.env.ELEVENLABS_API_KEY || '').trim()
+  if (!apiKey) {
+    throw new Error('No ElevenLabs API key. Set one in Settings > Voice.')
+  }
+
+  const resolvedVoiceId = String(
+    voiceId
+    || settings.elevenLabsVoiceId
+    || process.env.ELEVENLABS_VOICE
+    || DEFAULT_VOICE_ID,
+  ).trim()
+
+  return { apiKey, voiceId: resolvedVoiceId || DEFAULT_VOICE_ID }
+}
+
+export async function synthesizeElevenLabsMp3(params: {
+  text: string
+  voiceId?: string | null
+  stability?: number
+  similarityBoost?: number
+}): Promise<Buffer> {
+  const text = params.text.trim()
+  if (!text) throw new Error('No text provided for ElevenLabs synthesis.')
+
+  const { apiKey, voiceId } = resolveElevenLabsConfig(params.voiceId)
+  const stability = Number.isFinite(params.stability) ? Math.max(0, Math.min(1, Number(params.stability))) : 0.5
+  const similarityBoost = Number.isFinite(params.similarityBoost) ? Math.max(0, Math.min(1, Number(params.similarityBoost))) : 0.75
+
+  const apiRes = await fetch(`https://api.elevenlabs.io/v1/text-to-speech/${voiceId}`, {
+    method: 'POST',
+    headers: {
+      'xi-api-key': apiKey,
+      'Content-Type': 'application/json',
+      Accept: 'audio/mpeg',
+    },
+    body: JSON.stringify({
+      text,
+      model_id: DEFAULT_MODEL_ID,
+      voice_settings: {
+        stability,
+        similarity_boost: similarityBoost,
+      },
+    }),
+  })
+
+  if (!apiRes.ok) {
+    const errBody = await apiRes.text().catch(() => '')
+    throw new Error(errBody || `ElevenLabs request failed (${apiRes.status})`)
+  }
+
+  const audioBuffer = await apiRes.arrayBuffer()
+  return Buffer.from(audioBuffer)
+}
+
+export async function requestElevenLabsMp3Stream(params: {
+  text: string
+  voiceId?: string | null
+}): Promise<Response> {
+  const text = params.text.trim()
+  if (!text) throw new Error('No text provided for ElevenLabs stream.')
+
+  const { apiKey, voiceId } = resolveElevenLabsConfig(params.voiceId)
+  const apiRes = await fetch(`https://api.elevenlabs.io/v1/text-to-speech/${voiceId}/stream`, {
+    method: 'POST',
+    headers: {
+      'xi-api-key': apiKey,
+      'Content-Type': 'application/json',
+      Accept: 'audio/mpeg',
+    },
+    body: JSON.stringify({
+      text: text.slice(0, 2000),
+      model_id: DEFAULT_MODEL_ID,
+      voice_settings: { stability: 0.5, similarity_boost: 0.75 },
+      output_format: 'mp3_22050_32',
+    }),
+  })
+
+  if (!apiRes.ok) {
+    const errBody = await apiRes.text().catch(() => '')
+    throw new Error(errBody || `ElevenLabs streaming request failed (${apiRes.status})`)
+  }
+
+  return apiRes
+}
+
+export function explainElevenLabsError(err: unknown): string {
+  return getErrorMessage(err)
+}

package/src/lib/server/heartbeat-service.ts

@@ -163,7 +163,13 @@ function buildAgentHeartbeatPrompt(session: any, agent: any, fallbackPrompt: str
   const goalSummary = systemPrompt.slice(0, 500)
   const recentMessages = (session.messages || []).slice(-5)
   const recentContext = recentMessages
-    .map((m: any) => `[${m.role}]: ${(m.text || '').slice(0, 200)}`)
+    .map((m: any) => {
+      const text = (m.text || '').slice(0, 200)
+      const tools = Array.isArray(m.toolEvents) && m.toolEvents.length > 0
+        ? ` [tools used: ${m.toolEvents.map((t: { name: string }) => t.name).join(', ')}]`
+        : ''
+      return `[${m.role}]: ${text}${tools}`
+    })
     .join('\n')
 
   // Don't inject effectively-empty HEARTBEAT.md content
@@ -187,6 +193,7 @@ function buildAgentHeartbeatPrompt(session: any, agent: any, fallbackPrompt: str
     'You are running an autonomous heartbeat tick. Review your goal and recent context.',
     'If there is meaningful work to do toward your goal, use your tools and take action.',
     'If nothing needs attention right now, reply exactly HEARTBEAT_OK.',
+    'IMPORTANT: Do NOT repeat actions you already performed in recent context. If you already searched for something or completed a task (shown above), report your findings or reply HEARTBEAT_OK — do not search or act again unless there is a NEW reason to do so.',
     'Do not ask clarifying questions. Take the most reasonable next action.',
     '',
     'To update your goal or plan, include this line in your response:',

package/src/lib/server/main-agent-loop.ts

@@ -728,7 +728,7 @@ export function stripMainLoopMetaForPersistence(text: string, internal: boolean)
   if (!text) return ''
   return text
     .split('\n')
-    .filter((line) => !line.includes('[MAIN_LOOP_META]') && !line.includes('[MAIN_LOOP_PLAN]') && !line.includes('[MAIN_LOOP_REVIEW]'))
+    .filter((line) => !line.includes('[MAIN_LOOP_META]') && !line.includes('[MAIN_LOOP_PLAN]') && !line.includes('[MAIN_LOOP_REVIEW]') && !line.includes('[AGENT_HEARTBEAT_META]'))
     .join('\n')
     .trim()
 }

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

@@ -38,10 +38,14 @@ export async function runDailyConsolidation(): Promise<{
 
       if (candidates.length < 5) continue
 
+      // Sort by reinforcement count descending so most-reinforced memories are prioritized in digest
+      candidates.sort((a, b) => (b.reinforcementCount || 0) - (a.reinforcementCount || 0))
+
       // Build summarization prompt
       const memoryLines = candidates.slice(0, 30).map((m) => {
+        const rc = m.reinforcementCount || 0
         const content = (m.content || '').slice(0, 300)
-        return `- [${m.category}] ${m.title}: ${content}`
+        return `- [${m.category}]${rc > 0 ? ` (reinforced x${rc})` : ''} ${m.title}: ${content}`
       })
 
       const prompt = [
@@ -65,7 +69,8 @@ export async function runDailyConsolidation(): Promise<{
 
       if (!digestContent.trim()) continue
 
-      const linkedMemoryIds = candidates.slice(0, 10).map((m) => m.id)
+      const digestCandidates = candidates.slice(0, 30)
+      const linkedMemoryIds = digestCandidates.slice(0, 10).map((m) => m.id)
       memDb.add({
         agentId,
         sessionId: null,
@@ -74,6 +79,14 @@ export async function runDailyConsolidation(): Promise<{
         content: digestContent.trim(),
         linkedMemoryIds,
       })
+
+      // Reset reinforcement counts on entries folded into the digest to prevent double-counting
+      for (const m of digestCandidates) {
+        if (m.reinforcementCount && m.reinforcementCount > 0) {
+          memDb.update(m.id, { reinforcementCount: 0 })
+        }
+      }
+
       digestsCreated++
     } catch (err: unknown) {
       errors.push(`Agent ${agentId}: ${err instanceof Error ? err.message : String(err)}`)

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

@@ -1,6 +1,7 @@
 import Database from 'better-sqlite3'
 import path from 'path'
 import fs from 'fs'
+import { createHash } from 'crypto'
 import { genId } from '@/lib/id'
 import type { MemoryEntry, FileReference, MemoryImage, MemoryReference } from '@/types'
 import { getEmbedding, cosineSimilarity, serializeEmbedding, deserializeEmbedding } from './embeddings'
@@ -32,6 +33,11 @@ export const MEMORY_FTS_STOP_WORDS = new Set([
   'you', 'your',
 ])
 
+function computeContentHash(category: string, content: string): string {
+  const normalized = `${category}|${content.toLowerCase().trim()}`
+  return createHash('sha256').update(normalized).digest('hex').slice(0, 16)
+}
+
 function shouldSkipSearchQuery(input: string): boolean {
   const text = String(input || '').toLowerCase().trim()
   if (!text) return true
@@ -357,6 +363,10 @@ function initDb() {
     'image TEXT',
     'pinned INTEGER DEFAULT 0',
     'sharedWith TEXT',
+    'accessCount INTEGER DEFAULT 0',
+    'lastAccessedAt INTEGER DEFAULT 0',
+    'contentHash TEXT',
+    'reinforcementCount INTEGER DEFAULT 0',
   ]) {
     try { db.exec(`ALTER TABLE memories ADD COLUMN ${col}`) } catch { /* already exists */ }
   }
@@ -364,6 +374,9 @@ function initDb() {
   // Partial index for fast pinned-memory lookups
   db.exec(`CREATE INDEX IF NOT EXISTS idx_memories_pinned ON memories(agentId, updatedAt DESC) WHERE pinned = 1`)
 
+  // Index for content hash dedup lookups
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_memories_content_hash ON memories(contentHash) WHERE contentHash IS NOT NULL`)
+
   // FTS5 virtual table for full-text search
   db.exec(`
     CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
@@ -447,6 +460,24 @@ function initDb() {
   })
   migrateLegacyRows()
 
+  // Backfill contentHash for existing rows that don't have one yet
+  const unhashed = (db.prepare(`SELECT COUNT(*) as cnt FROM memories WHERE contentHash IS NULL`).get() as { cnt: number }).cnt
+  if (unhashed > 0) {
+    const backfillRows = db.prepare(`SELECT id, category, content FROM memories WHERE contentHash IS NULL`).all() as Array<{ id: string; category: string; content: string }>
+    const backfillStmt = db.prepare(`UPDATE memories SET contentHash = ? WHERE id = ?`)
+    const BATCH = 500
+    for (let i = 0; i < backfillRows.length; i += BATCH) {
+      const batch = backfillRows.slice(i, i + BATCH)
+      const tx = db.transaction(() => {
+        for (const r of batch) {
+          backfillStmt.run(computeContentHash(r.category, r.content), r.id)
+        }
+      })
+      tx()
+    }
+    console.log(`[memory-db] Backfilled contentHash for ${backfillRows.length} memory row(s)`)
+  }
+
   // Fresh installs now start with an empty memory graph.
   // Durable memories are created only from actual user/agent interactions.
 
@@ -454,9 +485,9 @@ function initDb() {
     insert: db.prepare(`
       INSERT INTO memories (
         id, agentId, sessionId, category, title, content, metadata, embedding,
-        "references", filePaths, image, imagePath, linkedMemoryIds, pinned, sharedWith, createdAt, updatedAt
+        "references", filePaths, image, imagePath, linkedMemoryIds, pinned, sharedWith, contentHash, createdAt, updatedAt
       )
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `),
     update: db.prepare(`
       UPDATE memories
@@ -511,6 +542,24 @@ function initDb() {
       ORDER BY updatedAt DESC
       LIMIT 1
     `),
+    findByContentHash: db.prepare(`
+      SELECT * FROM memories
+      WHERE contentHash = ? AND agentId = ?
+      ORDER BY updatedAt DESC
+      LIMIT 1
+    `),
+    findByContentHashShared: db.prepare(`
+      SELECT * FROM memories
+      WHERE contentHash = ? AND agentId IS NULL
+      ORDER BY updatedAt DESC
+      LIMIT 1
+    `),
+    reinforceMemory: db.prepare(`
+      UPDATE memories SET reinforcementCount = reinforcementCount + 1, updatedAt = ? WHERE id = ?
+    `),
+    bumpAccessCount: db.prepare(`
+      UPDATE memories SET accessCount = accessCount + 1, lastAccessedAt = ? WHERE id = ?
+    `),
   }
 
   function rowToEntry(row: Record<string, unknown>): MemoryEntry {
@@ -535,6 +584,10 @@ function initDb() {
       linkedMemoryIds: linkedMemoryIds.length ? linkedMemoryIds : undefined,
       pinned: row.pinned === 1,
       sharedWith: parseJsonSafe<string[]>(row.sharedWith, []).length ? parseJsonSafe<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,
+      reinforcementCount: typeof row.reinforcementCount === 'number' ? row.reinforcementCount : 0,
       createdAt: typeof row.createdAt === 'number' ? row.createdAt : Date.now(),
       updatedAt: typeof row.updatedAt === 'number' ? row.updatedAt : Date.now(),
     }
@@ -574,6 +627,17 @@ function initDb() {
       const category = data.category || 'note'
       const title = data.title || 'Untitled'
       const content = data.content || ''
+      const contentHash = computeContentHash(category, content)
+
+      // Content-hash dedup: if same content already exists for this agent, reinforce instead of duplicating
+      const agentId = data.agentId || null
+      const existingByHash = agentId
+        ? stmts.findByContentHash.get(contentHash, agentId) as Record<string, unknown> | undefined
+        : stmts.findByContentHashShared.get(contentHash) as Record<string, unknown> | undefined
+      if (existingByHash) {
+        stmts.reinforceMemory.run(now, existingByHash.id)
+        return rowToEntry({ ...existingByHash, reinforcementCount: ((existingByHash.reinforcementCount as number) || 0) + 1, updatedAt: now })
+      }
 
       // Guard against exact duplicate memory spam for the same session/category.
       if (sessionId) {
@@ -583,7 +647,7 @@ function initDb() {
       const pinned = data.pinned ? 1 : 0
       const sharedWith = Array.isArray(data.sharedWith) && data.sharedWith.length ? JSON.stringify(data.sharedWith) : null
       stmts.insert.run(
-        id, data.agentId || null, sessionId,
+        id, agentId, sessionId,
         category, title, content,
         data.metadata ? JSON.stringify(data.metadata) : null,
         null, // embedding computed async
@@ -594,6 +658,7 @@ function initDb() {
         linkedMemoryIds.length ? JSON.stringify(linkedMemoryIds) : null,
         pinned,
         sharedWith,
+        contentHash,
         now, now,
       )
       // Compute embedding in background (fire-and-forget)
@@ -623,6 +688,10 @@ function initDb() {
         image,
         imagePath: image?.path || null,
         linkedMemoryIds,
+        accessCount: 0,
+        lastAccessedAt: 0,
+        contentHash,
+        reinforcementCount: 0,
         createdAt: now,
         updatedAt: now,
       }
@@ -699,6 +768,10 @@ function initDb() {
     get(id: string): MemoryEntry | null {
       const row = stmts.getById.get(id) as Record<string, unknown> | undefined
       if (!row) return null
+      // Bump access count (non-blocking)
+      setTimeout(() => {
+        try { stmts.bumpAccessCount.run(Date.now(), id) } catch { /* best-effort */ }
+      }, 0)
       return rowToEntry(row)
     },
 
@@ -791,6 +864,7 @@ function initDb() {
         : []
 
       // Attempt vector search (synchronous — uses cached embedding if available)
+      const vectorSimilarityScores = new Map<string, number>()
       let vectorResults: MemoryEntry[] = []
       try {
         const queryEmbedding = getEmbeddingSync(query)
@@ -809,13 +883,17 @@ function initDb() {
             .sort((a, b) => b.score - a.score)
             .slice(0, 20)
 
-          vectorResults = scored.map((s) => rowToEntry(s.row))
+          vectorResults = scored.map((s) => {
+            const entry = rowToEntry(s.row)
+            vectorSimilarityScores.set(entry.id, s.score)
+            return entry
+          })
         }
       } catch {
         // Vector search unavailable, use FTS only
       }
 
-      // Merge: deduplicate by id, FTS results first then vector-only
+      // Merge: deduplicate by id
       const seen = new Set<string>()
       const merged: MemoryEntry[] = []
       for (const entry of [...ftsResults, ...vectorResults]) {
@@ -824,7 +902,34 @@ function initDb() {
           merged.push(entry)
         }
       }
-      const out = merged.slice(0, MAX_MERGED_RESULTS)
+
+      // Apply salience scoring: similarity * recencyDecay * reinforcement * pinnedBoost
+      const now = Date.now()
+      const HALF_LIFE_DAYS = 30
+      const salienceScored = merged.map((entry) => {
+        const similarity = vectorSimilarityScores.get(entry.id) ?? 0.5
+        const daysSinceAccess = (now - (entry.lastAccessedAt || entry.updatedAt)) / 86_400_000
+        const recencyDecay = Math.exp(-0.693 * daysSinceAccess / HALF_LIFE_DAYS)
+        const reinforcement = Math.log((entry.reinforcementCount || 0) + 1) + 1
+        const pinnedBoost = entry.pinned ? 1.5 : 1.0
+        const salience = similarity * recencyDecay * reinforcement * pinnedBoost
+        return { entry, salience }
+      })
+      salienceScored.sort((a, b) => b.salience - a.salience)
+
+      const out = salienceScored.slice(0, MAX_MERGED_RESULTS).map((s) => s.entry)
+
+      // Bump access counts for returned results (non-blocking)
+      if (out.length) {
+        const returnedIds = out.map((e) => e.id)
+        setTimeout(() => {
+          try {
+            const ts = Date.now()
+            for (const mid of returnedIds) stmts.bumpAccessCount.run(ts, mid)
+          } catch { /* best-effort */ }
+        }, 0)
+      }
+
       const elapsed = Date.now() - startedAt
       if (elapsed > 1200) {
         console.warn(
@@ -965,9 +1070,32 @@ function initDb() {
       const pruneWorking = options.pruneWorking !== false
       const cutoff = Date.now() - Math.max(1, Math.min(24 * 365, Math.trunc(options.ttlHours || 24))) * 3600_000
 
+      // Hash-based dedup: group by contentHash + agentId, keep the one with highest reinforcementCount
+      if (dedupe && toDelete.size < deleteBudget) {
+        const hashGroups = new Map<string, MemoryEntry[]>()
+        for (const row of rows) {
+          if (!row.contentHash || toDelete.has(row.id)) continue
+          const groupKey = `${row.agentId || ''}|${row.contentHash}`
+          const group = hashGroups.get(groupKey)
+          if (group) group.push(row)
+          else hashGroups.set(groupKey, [row])
+        }
+        for (const group of hashGroups.values()) {
+          if (group.length <= 1) continue
+          group.sort((a, b) => (b.reinforcementCount || 0) - (a.reinforcementCount || 0))
+          for (let i = 1; i < group.length; i++) {
+            toDelete.add(group[i].id)
+            if (toDelete.size >= deleteBudget) break
+          }
+          if (toDelete.size >= deleteBudget) break
+        }
+      }
+
+      // Exact string-match dedup (legacy fallback for rows without contentHash)
       if (dedupe) {
         const seen = new Set<string>()
         for (const row of rows) {
+          if (toDelete.has(row.id)) continue
           const key = [
             row.agentId || '',
             row.sessionId || '',

package/src/lib/server/mime.ts

@@ -0,0 +1,51 @@
+export const MIME_TYPES: Record<string, string> = {
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.webp': 'image/webp',
+  '.svg': 'image/svg+xml',
+  '.bmp': 'image/bmp',
+  '.ico': 'image/x-icon',
+  '.mp4': 'video/mp4',
+  '.webm': 'video/webm',
+  '.mov': 'video/quicktime',
+  '.avi': 'video/x-msvideo',
+  '.mkv': 'video/x-matroska',
+  '.pdf': 'application/pdf',
+  '.json': 'application/json',
+  '.csv': 'text/csv',
+  '.txt': 'text/plain',
+  '.html': 'text/html',
+  '.xml': 'application/xml',
+  '.zip': 'application/zip',
+  '.tar': 'application/x-tar',
+  '.gz': 'application/gzip',
+  '.doc': 'application/msword',
+  '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  '.xls': 'application/vnd.ms-excel',
+  '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+  '.ppt': 'application/vnd.ms-powerpoint',
+  '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+  '.mp3': 'audio/mpeg',
+  '.wav': 'audio/wav',
+  '.ogg': 'audio/ogg',
+}
+
+const IMAGE_EXTS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg', '.bmp', '.ico'])
+const VIDEO_EXTS = new Set(['.mp4', '.webm', '.mov', '.avi', '.mkv'])
+const AUDIO_EXTS = new Set(['.mp3', '.wav', '.ogg'])
+const DOCUMENT_EXTS = new Set(['.pdf', '.json', '.csv', '.txt', '.html', '.xml', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx'])
+const ARCHIVE_EXTS = new Set(['.zip', '.tar', '.gz'])
+
+export type FileCategory = 'image' | 'video' | 'audio' | 'document' | 'archive' | 'other'
+
+export function getFileCategory(ext: string): FileCategory {
+  const lower = ext.toLowerCase()
+  if (IMAGE_EXTS.has(lower)) return 'image'
+  if (VIDEO_EXTS.has(lower)) return 'video'
+  if (AUDIO_EXTS.has(lower)) return 'audio'
+  if (DOCUMENT_EXTS.has(lower)) return 'document'
+  if (ARCHIVE_EXTS.has(lower)) return 'archive'
+  return 'other'
+}