@swarmclawai/swarmclaw 0.6.0 → 0.6.2

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

@@ -2,14 +2,27 @@ import { genId } from '@/lib/id'
 import {
   loadConnectors, saveConnectors, loadSessions, saveSessions,
   loadAgents, loadCredentials, decryptKey, loadSettings, loadSkills,
+  loadChatrooms, saveChatrooms,
 } from '../storage'
 import { WORKSPACE_DIR } from '../data-dir'
+import { UPLOAD_DIR } from '../storage'
+import fs from 'fs'
+import path from 'path'
 import { streamAgentChat } from '../stream-agent-chat'
 import { notify } from '../ws-hub'
 import { logExecution } from '../execution-log'
 import { enqueueSystemEvent } from '../system-events'
 import { requestHeartbeatNow } from '../heartbeat-wake'
-import type { Connector } from '@/types'
+import { buildCurrentDateTimePromptContext } from '../prompt-runtime-context'
+import {
+  parseMentions,
+  buildChatroomSystemPrompt,
+  buildSyntheticSession,
+  buildAgentSystemPromptForChatroom,
+  buildHistoryForAgent,
+  resolveApiKey as resolveApiKeyHelper,
+} from '../chatroom-helpers'
+import type { Connector, MessageSource, Chatroom, ChatroomMessage } from '@/types'
 import type { ConnectorInstance, InboundMessage, InboundMedia } from './types'
 import {
   addAllowedSender,
@@ -23,6 +36,30 @@ import {
   type PairingPolicy,
 } from './pairing'
 
+/**
+ * Extract embedded media references from agent response text.
+ * Parses markdown image/link patterns like ![alt](/api/uploads/filename)
+ * and resolves them to actual file paths on disk.
+ */
+function extractEmbeddedMedia(text: string): { cleanText: string; files: Array<{ path: string; alt: string }> } {
+  const files: Array<{ path: string; alt: string }> = []
+  // Match markdown images: ![alt](/api/uploads/filename)
+  const imgRegex = /!\[([^\]]*)\]\(\/api\/uploads\/([^)]+)\)/g
+  let match: RegExpExecArray | null
+  while ((match = imgRegex.exec(text)) !== null) {
+    const [, alt, filename] = match
+    const safeName = filename.replace(/[^a-zA-Z0-9._-]/g, '')
+    const filePath = path.join(UPLOAD_DIR, safeName)
+    if (fs.existsSync(filePath)) {
+      files.push({ path: filePath, alt: alt || '' })
+    }
+  }
+  if (files.length === 0) return { cleanText: text, files }
+  // Strip the image markdown from text — the files will be sent as separate media
+  const cleanText = text.replace(imgRegex, '').replace(/\n{3,}/g, '\n\n').trim()
+  return { cleanText, files }
+}
+
 /** Sentinel value agents return when no outbound reply should be sent */
 export const NO_MESSAGE_SENTINEL = 'NO_MESSAGE'
 
@@ -421,6 +458,132 @@ async function handleConnectorCommand(params: {
   return 'Unknown command.'
 }
 
+/** Route an inbound message to a chatroom — process mentioned agents and return concatenated responses */
+async function routeMessageToChatroom(connector: Connector, msg: InboundMessage): Promise<string> {
+  const chatroomId = connector.chatroomId
+  if (!chatroomId) return '[Error] No chatroom configured.'
+
+  const chatrooms = loadChatrooms()
+  const chatroom = chatrooms[chatroomId] as Chatroom | undefined
+  if (!chatroom) return '[Error] Chatroom not found.'
+
+  const agents = loadAgents()
+  const source: MessageSource = {
+    platform: connector.platform,
+    connectorId: connector.id,
+    connectorName: connector.name,
+    senderName: msg.senderName,
+  }
+
+  // Parse mentions from the message text
+  let mentions = parseMentions(msg.text || '', agents, chatroom.agentIds)
+  // Auto-address: if enabled and no explicit mentions, address all agents
+  if (chatroom.autoAddress && mentions.length === 0) {
+    mentions = [...chatroom.agentIds]
+  }
+
+  // Create and persist the user message in the chatroom
+  const userMessage: ChatroomMessage = {
+    id: genId(),
+    senderId: 'user',
+    senderName: msg.senderName || 'User',
+    role: 'user',
+    text: msg.text || '',
+    mentions,
+    reactions: [],
+    time: Date.now(),
+    source,
+  }
+  chatroom.messages.push(userMessage)
+  chatroom.updatedAt = Date.now()
+  chatrooms[chatroomId] = chatroom
+  saveChatrooms(chatrooms)
+  notify('chatrooms')
+  notify(`chatroom:${chatroomId}`)
+
+  // Process mentioned agents sequentially and collect responses
+  const responses: string[] = []
+  for (const agentId of mentions) {
+    const agent = agents[agentId]
+    if (!agent) continue
+
+    const apiKey = resolveApiKeyHelper(agent.credentialId)
+    const freshChatrooms = loadChatrooms()
+    const freshChatroom = freshChatrooms[chatroomId] as Chatroom
+
+    const syntheticSession = buildSyntheticSession(agent, chatroomId)
+    const agentSystemPrompt = buildAgentSystemPromptForChatroom(agent)
+    const chatroomContext = buildChatroomSystemPrompt(freshChatroom, agents, agent.id)
+    const fullSystemPrompt = [agentSystemPrompt, chatroomContext].filter(Boolean).join('\n\n')
+    const history = buildHistoryForAgent(freshChatroom, agent.id)
+
+    try {
+      const result = await streamAgentChat({
+        session: syntheticSession,
+        message: msg.text || '',
+        apiKey,
+        systemPrompt: fullSystemPrompt,
+        write: () => {},
+        history,
+      })
+
+      const responseText = result.finalResponse || result.fullText
+      if (responseText.trim() && !isNoMessage(responseText)) {
+        // Persist agent response to chatroom
+        const agentSource: MessageSource = {
+          platform: connector.platform,
+          connectorId: connector.id,
+          connectorName: connector.name,
+        }
+        const agentMessage: ChatroomMessage = {
+          id: genId(),
+          senderId: agent.id,
+          senderName: agent.name,
+          role: 'assistant',
+          text: responseText,
+          mentions: parseMentions(responseText, agents, freshChatroom.agentIds),
+          reactions: [],
+          time: Date.now(),
+          source: agentSource,
+        }
+        const latestChatrooms = loadChatrooms()
+        const latestChatroom = latestChatrooms[chatroomId] as Chatroom
+        latestChatroom.messages.push(agentMessage)
+        latestChatroom.updatedAt = Date.now()
+        latestChatrooms[chatroomId] = latestChatroom
+        saveChatrooms(latestChatrooms)
+        notify(`chatroom:${chatroomId}`)
+
+        responses.push(`[${agent.name}] ${responseText}`)
+      }
+    } catch (err: unknown) {
+      const errMsg = err instanceof Error ? err.message : String(err)
+      console.error(`[connector] Chatroom agent ${agent.name} error:`, errMsg)
+    }
+  }
+
+  if (responses.length === 0) return NO_MESSAGE_SENTINEL
+
+  const joined = responses.join('\n\n')
+  // Extract embedded media from agent responses and send them via connector
+  const extracted = extractEmbeddedMedia(joined)
+  if (extracted.files.length > 0) {
+    const inst = running.get(connector.id)
+    if (inst?.sendMessage) {
+      for (const file of extracted.files) {
+        try {
+          await inst.sendMessage(msg.channelId, '', { mediaPath: file.path, caption: file.alt || undefined })
+          console.log(`[connector] Sent chatroom media to ${msg.platform}: ${path.basename(file.path)}`)
+        } catch (err: unknown) {
+          console.error(`[connector] Failed to send chatroom media ${path.basename(file.path)}:`, err instanceof Error ? err.message : String(err))
+        }
+      }
+    }
+    return extracted.cleanText || '(no response)'
+  }
+  return joined
+}
+
 /** Route an inbound message through the assigned agent and return the response */
 async function routeMessage(connector: Connector, msg: InboundMessage): Promise<string> {
   if (msg?.channelId) {
@@ -428,8 +591,14 @@ async function routeMessage(connector: Connector, msg: InboundMessage): Promise<
   }
   lastInboundTimeByConnector.set(connector.id, Date.now())
 
+  // Route to chatroom if configured
+  if (connector.chatroomId) {
+    return routeMessageToChatroom(connector, msg)
+  }
+
   const agents = loadAgents()
   const effectiveAgentId = msg.agentIdOverride || connector.agentId
+  if (!effectiveAgentId) return '[Error] Connector has no agent configured.'
   const agent = agents[effectiveAgentId]
   if (!agent) return '[Error] Connector agent not found.'
 
@@ -472,11 +641,16 @@ async function routeMessage(connector: Connector, msg: InboundMessage): Promise<
     }
   }
 
-  // Find or create a session keyed by platform + channel
+  // Find a session for this connector message.
+  // Prefer the agent's thread session (visible in the agent chat UI) so connector
+  // messages appear inline alongside web UI messages.
+  // Fall back to a connector-keyed session if the agent has no thread session.
   const sessionKey = `connector:${connector.id}:${msg.channelId}`
   const sessions = loadSessions()
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  let session = Object.values(sessions).find((s: any) => s.name === sessionKey)
+  let session = (agent.threadSessionId && sessions[agent.threadSessionId])
+    ? sessions[agent.threadSessionId]
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    : Object.values(sessions).find((s: any) => s.name === sessionKey)
   if (!session) {
     const id = genId()
     session = {
@@ -564,6 +738,7 @@ async function routeMessage(connector: Connector, msg: InboundMessage): Promise<
   const settings = loadSettings()
   const promptParts: string[] = []
   if (settings.userPrompt) promptParts.push(settings.userPrompt)
+  promptParts.push(buildCurrentDateTimePromptContext())
   if (agent.soul) promptParts.push(agent.soul)
   if (agent.systemPrompt) promptParts.push(agent.systemPrompt)
   if (agent.skillIds?.length) {
@@ -594,12 +769,22 @@ The test: would a thoughtful friend feel compelled to type something back? If no
   const firstImageUrl = msg.imageUrl || (firstImage?.url) || undefined
   const firstImagePath = firstImage?.localPath || undefined
   const inboundText = formatInboundUserText(msg)
+  // Store the raw user text for display (source.senderName handles attribution).
+  // The formatted text with [SenderName] prefix is only used for LLM history context.
+  const rawText = (msg.text || '').trim()
+  const messageSource: MessageSource = {
+    platform: connector.platform,
+    connectorId: connector.id,
+    connectorName: connector.name,
+    senderName: msg.senderName,
+  }
   session.messages.push({
     role: 'user',
-    text: inboundText,
+    text: rawText || inboundText,
     time: Date.now(),
     imageUrl: firstImageUrl,
     imagePath: firstImagePath,
+    source: messageSource,
   })
   session.lastActiveAt = Date.now()
   const s1 = loadSessions()
@@ -679,9 +864,14 @@ The test: would a thoughtful friend feel compelled to type something back? If no
     },
   })
 
-  // Save assistant response to session
+  // Save assistant response to session (full text with image markdown for web UI rendering)
+  const assistantSource: MessageSource = {
+    platform: connector.platform,
+    connectorId: connector.id,
+    connectorName: connector.name,
+  }
   if (fullText.trim()) {
-    session.messages.push({ role: 'assistant', text: fullText.trim(), time: Date.now() })
+    session.messages.push({ role: 'assistant', text: fullText.trim(), time: Date.now(), source: assistantSource })
     session.lastActiveAt = Date.now()
     const s2 = loadSessions()
     s2[session.id] = session
@@ -689,6 +879,24 @@ The test: would a thoughtful friend feel compelled to type something back? If no
     notify(`messages:${session.id}`)
   }
 
+  // Extract embedded media (screenshots, uploaded files) and send them as separate
+  // media messages via the connector, then return the cleaned text
+  const extracted = extractEmbeddedMedia(fullText)
+  if (extracted.files.length > 0) {
+    const inst = running.get(connector.id)
+    if (inst?.sendMessage) {
+      for (const file of extracted.files) {
+        try {
+          await inst.sendMessage(msg.channelId, '', { mediaPath: file.path, caption: file.alt || undefined })
+          console.log(`[connector] Sent media to ${msg.platform}: ${path.basename(file.path)}`)
+        } catch (err: unknown) {
+          console.error(`[connector] Failed to send media ${path.basename(file.path)}:`, err instanceof Error ? err.message : String(err))
+        }
+      }
+    }
+    return extracted.cleanText || '(no response)'
+  }
+
   return fullText || '(no response)'
 }
 
@@ -873,6 +1081,7 @@ export function listRunningConnectors(platform?: string): Array<{
   id: string
   name: string
   platform: string
+  agentId: string | null
   supportsSend: boolean
   configuredTargets: string[]
   recentChannelId: string | null
@@ -882,6 +1091,7 @@ export function listRunningConnectors(platform?: string): Array<{
     id: string
     name: string
     platform: string
+    agentId: string | null
     supportsSend: boolean
     configuredTargets: string[]
     recentChannelId: string | null
@@ -907,6 +1117,7 @@ export function listRunningConnectors(platform?: string): Array<{
       id,
       name: connector.name,
       platform: connector.platform,
+      agentId: connector.agentId || null,
       supportsSend: typeof instance.sendMessage === 'function',
       configuredTargets: Array.from(new Set(configuredTargets)),
       recentChannelId: lastInboundChannelByConnector.get(id) || null,

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 || '',