@smyslenny/agent-memory 4.3.1 → 5.0.1

package/dist/index.js

@@ -6,7 +6,7 @@ import { createHash as createHash2 } from "crypto";
 // src/core/db.ts
 import Database from "better-sqlite3";
 import { randomUUID } from "crypto";
-var SCHEMA_VERSION = 6;
+var SCHEMA_VERSION = 7;
 var SCHEMA_SQL = `
 -- Memory entries
 CREATE TABLE IF NOT EXISTS memories (
@@ -25,6 +25,9 @@ CREATE TABLE IF NOT EXISTS memories (
   agent_id      TEXT NOT NULL DEFAULT 'default',
   hash          TEXT,
   emotion_tag   TEXT,
+  source_session TEXT,
+  source_context TEXT,
+  observed_at   TEXT,
   UNIQUE(hash, agent_id)
 );
 
@@ -205,6 +208,11 @@ function migrateDatabase(db, from, to) {
       v = 6;
       continue;
     }
+    if (v === 6) {
+      migrateV6ToV7(db);
+      v = 7;
+      continue;
+    }
     throw new Error(`Unsupported schema migration path: v${from} \u2192 v${to} (stuck at v${v})`);
   }
 }
@@ -291,6 +299,8 @@ function inferSchemaVersion(db) {
   const hasMaintenanceJobs = tableExists(db, "maintenance_jobs");
   const hasFeedbackEvents = tableExists(db, "feedback_events");
   const hasEmotionTag = tableHasColumn(db, "memories", "emotion_tag");
+  const hasProvenance = tableHasColumn(db, "memories", "source_session") && tableHasColumn(db, "memories", "source_context") && tableHasColumn(db, "memories", "observed_at");
+  if (hasAgentScopedPaths && hasAgentScopedLinks && hasV4Embeddings && hasMaintenanceJobs && hasFeedbackEvents && hasEmotionTag && hasProvenance) return 7;
   if (hasAgentScopedPaths && hasAgentScopedLinks && hasV4Embeddings && hasMaintenanceJobs && hasFeedbackEvents && hasEmotionTag) return 6;
   if (hasAgentScopedPaths && hasAgentScopedLinks && hasV4Embeddings && hasMaintenanceJobs && hasFeedbackEvents) return 5;
   if (hasAgentScopedPaths && hasAgentScopedLinks && hasV4Embeddings) return 4;
@@ -321,6 +331,10 @@ function ensureIndexes(db) {
   if (tableHasColumn(db, "memories", "emotion_tag")) {
     db.exec("CREATE INDEX IF NOT EXISTS idx_memories_emotion_tag ON memories(emotion_tag) WHERE emotion_tag IS NOT NULL;");
   }
+  if (tableHasColumn(db, "memories", "observed_at")) {
+    db.exec("CREATE INDEX IF NOT EXISTS idx_memories_observed_at ON memories(observed_at) WHERE observed_at IS NOT NULL;");
+  }
+  db.exec("CREATE INDEX IF NOT EXISTS idx_memories_updated_at ON memories(updated_at);");
   if (tableExists(db, "feedback_events")) {
     db.exec("CREATE INDEX IF NOT EXISTS idx_feedback_events_memory ON feedback_events(memory_id, created_at DESC);");
     if (tableHasColumn(db, "feedback_events", "agent_id") && tableHasColumn(db, "feedback_events", "source")) {
@@ -473,6 +487,35 @@ function migrateV5ToV6(db) {
     throw e;
   }
 }
+function migrateV6ToV7(db) {
+  const alreadyMigrated = tableHasColumn(db, "memories", "source_session") && tableHasColumn(db, "memories", "source_context") && tableHasColumn(db, "memories", "observed_at");
+  if (alreadyMigrated) {
+    db.prepare("INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('version', ?)").run(String(7));
+    return;
+  }
+  try {
+    db.exec("BEGIN");
+    if (!tableHasColumn(db, "memories", "source_session")) {
+      db.exec("ALTER TABLE memories ADD COLUMN source_session TEXT;");
+    }
+    if (!tableHasColumn(db, "memories", "source_context")) {
+      db.exec("ALTER TABLE memories ADD COLUMN source_context TEXT;");
+    }
+    if (!tableHasColumn(db, "memories", "observed_at")) {
+      db.exec("ALTER TABLE memories ADD COLUMN observed_at TEXT;");
+    }
+    db.exec("CREATE INDEX IF NOT EXISTS idx_memories_observed_at ON memories(observed_at) WHERE observed_at IS NOT NULL;");
+    db.exec("CREATE INDEX IF NOT EXISTS idx_memories_updated_at ON memories(updated_at);");
+    db.prepare("INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('version', ?)").run(String(7));
+    db.exec("COMMIT");
+  } catch (e) {
+    try {
+      db.exec("ROLLBACK");
+    } catch {
+    }
+    throw e;
+  }
+}
 
 // src/search/tokenizer.ts
 import { readFileSync } from "fs";
@@ -940,6 +983,23 @@ function searchByVector(db, queryVector, opts) {
   const limit = opts.limit ?? 20;
   const agentId = opts.agent_id ?? "default";
   const minVitality = opts.min_vitality ?? 0;
+  const conditions = [
+    "e.provider_id = ?",
+    "e.status = 'ready'",
+    "e.vector IS NOT NULL",
+    "e.content_hash = m.hash",
+    "m.agent_id = ?",
+    "m.vitality >= ?"
+  ];
+  const params = [opts.providerId, agentId, minVitality];
+  if (opts.after) {
+    conditions.push("m.updated_at >= ?");
+    params.push(opts.after);
+  }
+  if (opts.before) {
+    conditions.push("m.updated_at <= ?");
+    params.push(opts.before);
+  }
   const rows = db.prepare(
     `SELECT e.provider_id, e.vector, e.content_hash,
             m.id, m.content, m.type, m.priority, m.emotion_val, m.vitality,
@@ -947,13 +1007,8 @@ function searchByVector(db, queryVector, opts) {
             m.updated_at, m.source, m.agent_id, m.hash
      FROM embeddings e
      JOIN memories m ON m.id = e.memory_id
-     WHERE e.provider_id = ?
-       AND e.status = 'ready'
-       AND e.vector IS NOT NULL
-       AND e.content_hash = m.hash
-       AND m.agent_id = ?
-       AND m.vitality >= ?`
-  ).all(opts.providerId, agentId, minVitality);
+     WHERE ${conditions.join(" AND ")}`
+  ).all(...params);
   const scored = rows.map((row) => ({
     provider_id: row.provider_id,
     memory: {
@@ -1026,10 +1081,12 @@ function createMemory(db, input) {
   }
   const id = newId();
   const timestamp = now();
+  const sourceContext = input.source_context ? input.source_context.slice(0, 200) : null;
   db.prepare(
     `INSERT INTO memories (id, content, type, priority, emotion_val, vitality, stability,
-     access_count, created_at, updated_at, source, agent_id, hash, emotion_tag)
-     VALUES (?, ?, ?, ?, ?, 1.0, ?, 0, ?, ?, ?, ?, ?, ?)`
+     access_count, created_at, updated_at, source, agent_id, hash, emotion_tag,
+     source_session, source_context, observed_at)
+     VALUES (?, ?, ?, ?, ?, 1.0, ?, 0, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
   ).run(
     id,
     input.content,
@@ -1042,7 +1099,10 @@ function createMemory(db, input) {
     input.source ?? null,
     agentId,
     hash,
-    input.emotion_tag ?? null
+    input.emotion_tag ?? null,
+    input.source_session ?? null,
+    sourceContext,
+    input.observed_at ?? null
   );
   db.prepare("INSERT INTO memories_fts (id, content) VALUES (?, ?)").run(id, tokenizeForIndex(input.content));
   markEmbeddingDirtyIfNeeded(db, id, hash, resolveEmbeddingProviderId(input.embedding_provider_id));
@@ -1217,16 +1277,25 @@ function searchBM25(db, query, opts) {
   const ftsQuery = buildFtsQuery(query);
   if (!ftsQuery) return [];
   try {
+    const conditions = ["memories_fts MATCH ?", "m.agent_id = ?", "m.vitality >= ?"];
+    const params = [ftsQuery, agentId, minVitality];
+    if (opts?.after) {
+      conditions.push("m.updated_at >= ?");
+      params.push(opts.after);
+    }
+    if (opts?.before) {
+      conditions.push("m.updated_at <= ?");
+      params.push(opts.before);
+    }
+    params.push(limit);
     const rows = db.prepare(
       `SELECT m.*, rank AS score
          FROM memories_fts f
          JOIN memories m ON m.id = f.id
-         WHERE memories_fts MATCH ?
-           AND m.agent_id = ?
-           AND m.vitality >= ?
+         WHERE ${conditions.join(" AND ")}
          ORDER BY rank
          LIMIT ?`
-    ).all(ftsQuery, agentId, minVitality, limit);
+    ).all(...params);
     return rows.map((row, index) => {
       const { score: _score, ...memoryFields } = row;
       return {
@@ -1310,16 +1379,23 @@ function priorityPrior(priority) {
 function fusionScore(input) {
   const lexical = input.bm25Rank ? 0.45 / (60 + input.bm25Rank) : 0;
   const semantic = input.vectorRank ? 0.45 / (60 + input.vectorRank) : 0;
-  return lexical + semantic + 0.05 * priorityPrior(input.memory.priority) + 0.05 * input.memory.vitality;
-}
-function fuseHybridResults(lexical, vector, limit) {
+  const baseScore = lexical + semantic + 0.05 * priorityPrior(input.memory.priority) + 0.05 * input.memory.vitality;
+  const boost = input.recency_boost ?? 0;
+  if (boost <= 0) return baseScore;
+  const updatedAt = new Date(input.memory.updated_at).getTime();
+  const daysSince = Math.max(0, (Date.now() - updatedAt) / (1e3 * 60 * 60 * 24));
+  const recencyScore = Math.exp(-daysSince / 30);
+  return (1 - boost) * baseScore + boost * recencyScore;
+}
+function fuseHybridResults(lexical, vector, limit, recency_boost) {
   const candidates = /* @__PURE__ */ new Map();
   for (const row of lexical) {
     candidates.set(row.memory.id, {
       memory: row.memory,
       score: 0,
       bm25_rank: row.rank,
-      bm25_score: row.score
+      bm25_score: row.score,
+      match_type: "direct"
     });
   }
   for (const row of vector) {
@@ -1332,13 +1408,14 @@ function fuseHybridResults(lexical, vector, limit) {
         memory: row.memory,
         score: 0,
         vector_rank: row.rank,
-        vector_score: row.similarity
+        vector_score: row.similarity,
+        match_type: "direct"
       });
     }
   }
   return [...candidates.values()].map((row) => ({
     ...row,
-    score: fusionScore({ memory: row.memory, bm25Rank: row.bm25_rank, vectorRank: row.vector_rank })
+    score: fusionScore({ memory: row.memory, bm25Rank: row.bm25_rank, vectorRank: row.vector_rank, recency_boost })
   })).sort((left, right) => {
     if (right.score !== left.score) return right.score - left.score;
     return right.memory.updated_at.localeCompare(left.memory.updated_at);
@@ -1351,9 +1428,61 @@ async function searchVectorBranch(db, query, opts) {
     providerId: opts.provider.id,
     agent_id: opts.agent_id,
     limit: opts.limit,
-    min_vitality: opts.min_vitality
+    min_vitality: opts.min_vitality,
+    after: opts.after,
+    before: opts.before
   });
 }
+function expandRelated(db, results, agentId, maxTotal) {
+  const existingIds = new Set(results.map((r) => r.memory.id));
+  const related = [];
+  for (const result of results) {
+    const links = db.prepare(
+      `SELECT l.target_id, l.weight, m.*
+       FROM links l
+       JOIN memories m ON m.id = l.target_id
+       WHERE l.agent_id = ? AND l.source_id = ?
+       ORDER BY l.weight DESC
+       LIMIT 5`
+    ).all(agentId, result.memory.id);
+    for (const link of links) {
+      if (existingIds.has(link.target_id)) continue;
+      existingIds.add(link.target_id);
+      const relatedMemory = {
+        id: link.id,
+        content: link.content,
+        type: link.type,
+        priority: link.priority,
+        emotion_val: link.emotion_val,
+        vitality: link.vitality,
+        stability: link.stability,
+        access_count: link.access_count,
+        last_accessed: link.last_accessed,
+        created_at: link.created_at,
+        updated_at: link.updated_at,
+        source: link.source,
+        agent_id: link.agent_id,
+        hash: link.hash,
+        emotion_tag: link.emotion_tag,
+        source_session: link.source_session ?? null,
+        source_context: link.source_context ?? null,
+        observed_at: link.observed_at ?? null
+      };
+      related.push({
+        memory: relatedMemory,
+        score: result.score * link.weight * 0.6,
+        related_source_id: result.memory.id,
+        match_type: "related"
+      });
+    }
+  }
+  const directResults = results.map((r) => ({
+    ...r,
+    match_type: "direct"
+  }));
+  const combined = [...directResults, ...related].sort((a, b) => b.score - a.score).slice(0, maxTotal);
+  return combined;
+}
 async function recallMemories(db, query, opts) {
   const limit = opts?.limit ?? 10;
   const agentId = opts?.agent_id ?? "default";
@@ -1361,10 +1490,15 @@ async function recallMemories(db, query, opts) {
   const lexicalLimit = opts?.lexicalLimit ?? Math.max(limit * 2, limit);
   const vectorLimit = opts?.vectorLimit ?? Math.max(limit * 2, limit);
   const provider = opts?.provider === void 0 ? getEmbeddingProviderFromEnv() : opts.provider;
+  const recencyBoost = opts?.recency_boost;
+  const after = opts?.after;
+  const before = opts?.before;
   const lexical = searchBM25(db, query, {
     agent_id: agentId,
     limit: lexicalLimit,
-    min_vitality: minVitality
+    min_vitality: minVitality,
+    after,
+    before
   });
   let vector = [];
   if (provider) {
@@ -1373,17 +1507,25 @@ async function recallMemories(db, query, opts) {
         provider,
         agent_id: agentId,
         limit: vectorLimit,
-        min_vitality: minVitality
+        min_vitality: minVitality,
+        after,
+        before
       });
     } catch {
       vector = [];
     }
   }
   const mode = vector.length > 0 && lexical.length > 0 ? "dual-path" : vector.length > 0 ? "vector-only" : "bm25-only";
-  const results = mode === "bm25-only" ? scoreBm25Only(lexical, limit) : fuseHybridResults(lexical, vector, limit);
+  let results = mode === "bm25-only" ? scoreBm25Only(lexical, limit) : fuseHybridResults(lexical, vector, limit, recencyBoost);
+  if (opts?.related) {
+    const maxTotal = Math.floor(limit * 1.5);
+    results = expandRelated(db, results, agentId, maxTotal);
+  }
   if (opts?.recordAccess !== false) {
     for (const row of results) {
-      recordAccess(db, row.memory.id);
+      if (row.match_type !== "related") {
+        recordAccess(db, row.memory.id);
+      }
     }
   }
   return {
@@ -1608,7 +1750,13 @@ function uriScopeMatch(inputUri, candidateUri) {
   }
   return 0.2;
 }
-function extractObservedAt(parts, fallback) {
+function extractObservedAt(parts, fallback, observedAt) {
+  if (observedAt) {
+    const parsed = new Date(observedAt);
+    if (!Number.isNaN(parsed.getTime())) {
+      return parsed;
+    }
+  }
   for (const part of parts) {
     if (!part) continue;
     const match = part.match(/(20\d{2}-\d{2}-\d{2})(?:[ T](\d{2}:\d{2}(?::\d{2})?))?/);
@@ -1631,8 +1779,16 @@ function timeProximity(input, memory, candidateUri) {
   if (input.type !== "event") {
     return 1;
   }
-  const inputTime = extractObservedAt([input.uri, input.source, input.content], input.now ?? null);
-  const existingTime = extractObservedAt([candidateUri, memory.source, memory.content], memory.created_at);
+  const inputTime = extractObservedAt(
+    [input.uri, input.source, input.content],
+    input.now ?? null,
+    input.observed_at ?? null
+  );
+  const existingTime = extractObservedAt(
+    [candidateUri, memory.source, memory.content],
+    memory.created_at,
+    memory.observed_at ?? null
+  );
   if (!inputTime || !existingTime) {
     return 0.5;
   }
@@ -1716,6 +1872,65 @@ function fourCriterionGate(input) {
     failedCriteria: failed
   };
 }
+var NEGATION_PATTERNS = /\b(不|没|禁止|无法|取消|no|not|never|don't|doesn't|isn't|aren't|won't|can't|cannot|shouldn't)\b/i;
+var STATUS_DONE_PATTERNS = /\b(完成|已完成|已修复|已解决|已关闭|DONE|FIXED|RESOLVED|CLOSED|SHIPPED|CANCELLED|取消|放弃|已取消|已放弃|ABANDONED)\b/i;
+var STATUS_ACTIVE_PATTERNS = /\b(正在|进行中|待办|TODO|WIP|IN.?PROGRESS|PENDING|WORKING|处理中|部署中|开发中|DEPLOYING)\b/i;
+function extractNumbers(text) {
+  return text.match(/\d+(?:\.\d+)+|\b\d{2,}\b/g) ?? [];
+}
+function detectConflict(inputContent, candidateContent, candidateId) {
+  let conflictScore = 0;
+  let conflictType = "negation";
+  const details = [];
+  const inputHasNegation = NEGATION_PATTERNS.test(inputContent);
+  const candidateHasNegation = NEGATION_PATTERNS.test(candidateContent);
+  if (inputHasNegation !== candidateHasNegation) {
+    conflictScore += 0.4;
+    conflictType = "negation";
+    details.push("negation mismatch");
+  }
+  const inputNumbers = extractNumbers(inputContent);
+  const candidateNumbers = extractNumbers(candidateContent);
+  if (inputNumbers.length > 0 && candidateNumbers.length > 0) {
+    const inputSet = new Set(inputNumbers);
+    const candidateSet = new Set(candidateNumbers);
+    const hasCommon = [...inputSet].some((n) => candidateSet.has(n));
+    const hasDiff = [...inputSet].some((n) => !candidateSet.has(n)) || [...candidateSet].some((n) => !inputSet.has(n));
+    if (hasDiff && !hasCommon) {
+      conflictScore += 0.3;
+      conflictType = "value";
+      details.push(`value diff: [${inputNumbers.join(",")}] vs [${candidateNumbers.join(",")}]`);
+    }
+  }
+  const inputDone = STATUS_DONE_PATTERNS.test(inputContent);
+  const inputActive = STATUS_ACTIVE_PATTERNS.test(inputContent);
+  const candidateDone = STATUS_DONE_PATTERNS.test(candidateContent);
+  const candidateActive = STATUS_ACTIVE_PATTERNS.test(candidateContent);
+  if (inputDone && candidateActive || inputActive && candidateDone) {
+    conflictScore += 0.3;
+    conflictType = "status";
+    details.push("status contradiction (done vs active)");
+  }
+  if (conflictScore <= 0.5) return null;
+  return {
+    memoryId: candidateId,
+    content: candidateContent,
+    conflict_score: Math.min(1, conflictScore),
+    conflict_type: conflictType,
+    detail: details.join("; ")
+  };
+}
+function detectConflicts(inputContent, candidates) {
+  const conflicts = [];
+  for (const candidate of candidates) {
+    if (candidate.score.dedup_score < 0.6) continue;
+    const conflict = detectConflict(inputContent, candidate.result.memory.content, candidate.result.memory.id);
+    if (conflict) {
+      conflicts.push(conflict);
+    }
+  }
+  return conflicts;
+}
 async function guard(db, input) {
   const hash = contentHash(input.content);
   const agentId = input.agent_id ?? "default";
@@ -1742,18 +1957,37 @@ async function guard(db, input) {
     return { action: "add", reason: "Conservative mode enabled; semantic dedup disabled" };
   }
   const candidates = await recallCandidates(db, input, agentId);
+  const candidatesList = candidates.map((c) => ({
+    memoryId: c.result.memory.id,
+    dedup_score: c.score.dedup_score
+  }));
+  const conflicts = detectConflicts(input.content, candidates);
   const best = candidates[0];
   if (!best) {
-    return { action: "add", reason: "No relevant semantic candidates found" };
+    return { action: "add", reason: "No relevant semantic candidates found", candidates: candidatesList };
   }
   const score = best.score;
   if (score.dedup_score >= NEAR_EXACT_THRESHOLD) {
+    const bestConflict = conflicts.find((c) => c.memoryId === best.result.memory.id);
+    if (bestConflict && (bestConflict.conflict_type === "status" || bestConflict.conflict_type === "value")) {
+      return {
+        action: "update",
+        reason: `Conflict override: ${bestConflict.conflict_type} conflict detected despite high dedup score (${score.dedup_score.toFixed(3)})`,
+        existingId: best.result.memory.id,
+        updatedContent: input.content,
+        score,
+        candidates: candidatesList,
+        conflicts
+      };
+    }
     const shouldUpdateMetadata = Boolean(input.uri && !getPathByUri(db, input.uri, agentId));
     return {
       action: shouldUpdateMetadata ? "update" : "skip",
       reason: shouldUpdateMetadata ? `Near-exact duplicate detected (score=${score.dedup_score.toFixed(3)}), updating metadata` : `Near-exact duplicate detected (score=${score.dedup_score.toFixed(3)})`,
       existingId: best.result.memory.id,
-      score
+      score,
+      candidates: candidatesList,
+      conflicts: conflicts.length > 0 ? conflicts : void 0
     };
   }
   if (score.dedup_score >= MERGE_THRESHOLD) {
@@ -1771,13 +2005,17 @@ async function guard(db, input) {
       existingId: best.result.memory.id,
       mergedContent: mergePlan.content,
       mergePlan,
-      score
+      score,
+      candidates: candidatesList,
+      conflicts: conflicts.length > 0 ? conflicts : void 0
     };
   }
   return {
     action: "add",
     reason: `Semantic score below merge threshold (score=${score.dedup_score.toFixed(3)})`,
-    score
+    score,
+    candidates: candidatesList,
+    conflicts: conflicts.length > 0 ? conflicts : void 0
   };
 }
 
@@ -1790,6 +2028,20 @@ function ensureUriPath(db, memoryId, uri, agentId) {
   } catch {
   }
 }
+function createAutoLinks(db, memoryId, candidates, agentId) {
+  if (!candidates || candidates.length === 0) return;
+  const linkCandidates = candidates.filter((c) => c.memoryId !== memoryId && c.dedup_score >= 0.45 && c.dedup_score < 0.82).sort((a, b) => b.dedup_score - a.dedup_score).slice(0, 5);
+  if (linkCandidates.length === 0) return;
+  const timestamp = now();
+  const insert = db.prepare(
+    `INSERT OR IGNORE INTO links (agent_id, source_id, target_id, relation, weight, created_at)
+     VALUES (?, ?, ?, 'related', ?, ?)`
+  );
+  for (const candidate of linkCandidates) {
+    insert.run(agentId, memoryId, candidate.memoryId, candidate.dedup_score, timestamp);
+    insert.run(agentId, candidate.memoryId, memoryId, candidate.dedup_score, timestamp);
+  }
+}
 async function syncOne(db, input) {
   const memInput = {
     content: input.content,
@@ -1801,17 +2053,22 @@ async function syncOne(db, input) {
     uri: input.uri,
     provider: input.provider,
     conservative: input.conservative,
-    emotion_tag: input.emotion_tag
+    emotion_tag: input.emotion_tag,
+    source_session: input.source_session,
+    source_context: input.source_context,
+    observed_at: input.observed_at
   };
   const guardResult = await guard(db, memInput);
+  const agentId = input.agent_id ?? "default";
   switch (guardResult.action) {
     case "skip":
-      return { action: "skipped", reason: guardResult.reason, memoryId: guardResult.existingId };
+      return { action: "skipped", reason: guardResult.reason, memoryId: guardResult.existingId, conflicts: guardResult.conflicts };
     case "add": {
       const mem = createMemory(db, memInput);
       if (!mem) return { action: "skipped", reason: "createMemory returned null" };
       ensureUriPath(db, mem.id, input.uri, input.agent_id);
-      return { action: "added", memoryId: mem.id, reason: guardResult.reason };
+      createAutoLinks(db, mem.id, guardResult.candidates, agentId);
+      return { action: "added", memoryId: mem.id, reason: guardResult.reason, conflicts: guardResult.conflicts };
     }
     case "update": {
       if (!guardResult.existingId) return { action: "skipped", reason: "No existing ID for update" };
@@ -1819,7 +2076,7 @@ async function syncOne(db, input) {
         updateMemory(db, guardResult.existingId, { content: guardResult.updatedContent });
       }
       ensureUriPath(db, guardResult.existingId, input.uri, input.agent_id);
-      return { action: "updated", memoryId: guardResult.existingId, reason: guardResult.reason };
+      return { action: "updated", memoryId: guardResult.existingId, reason: guardResult.reason, conflicts: guardResult.conflicts };
     }
     case "merge": {
       if (!guardResult.existingId || !guardResult.mergedContent) {
@@ -1827,7 +2084,8 @@ async function syncOne(db, input) {
       }
       updateMemory(db, guardResult.existingId, { content: guardResult.mergedContent });
       ensureUriPath(db, guardResult.existingId, input.uri, input.agent_id);
-      return { action: "merged", memoryId: guardResult.existingId, reason: guardResult.reason };
+      createAutoLinks(db, guardResult.existingId, guardResult.candidates, agentId);
+      return { action: "merged", memoryId: guardResult.existingId, reason: guardResult.reason, conflicts: guardResult.conflicts };
     }
   }
 }
@@ -1851,27 +2109,13 @@ async function rememberMemory(db, input) {
     agent_id: input.agent_id,
     provider: input.provider,
     conservative: input.conservative,
-    emotion_tag: input.emotion_tag
+    emotion_tag: input.emotion_tag,
+    source_session: input.source_session,
+    source_context: input.source_context,
+    observed_at: input.observed_at
   });
 }
 
-// src/app/recall.ts
-async function recallMemory(db, input) {
-  const result = await recallMemories(db, input.query, {
-    agent_id: input.agent_id,
-    limit: input.emotion_tag ? (input.limit ?? 10) * 3 : input.limit,
-    min_vitality: input.min_vitality,
-    lexicalLimit: input.lexicalLimit,
-    vectorLimit: input.vectorLimit,
-    provider: input.provider,
-    recordAccess: input.recordAccess
-  });
-  if (input.emotion_tag) {
-    result.results = result.results.filter((r) => r.memory.emotion_tag === input.emotion_tag).slice(0, input.limit ?? 10);
-  }
-  return result;
-}
-
 // src/app/feedback.ts
 function clamp012(value) {
   if (!Number.isFinite(value)) return 0;
@@ -1951,6 +2195,70 @@ function getFeedbackSummary(db, memoryId, agentId) {
 function getFeedbackScore(db, memoryId, agentId) {
   return getFeedbackSummary(db, memoryId, agentId).score;
 }
+function recordPassiveFeedback(db, memoryIds, agentId) {
+  if (memoryIds.length === 0) return 0;
+  const effectiveAgentId = agentId ?? "default";
+  const cutoff = new Date(Date.now() - 24 * 60 * 60 * 1e3).toISOString();
+  const placeholders = memoryIds.map(() => "?").join(",");
+  const recentCounts = /* @__PURE__ */ new Map();
+  try {
+    const rows = db.prepare(
+      `SELECT memory_id, COUNT(*) as c
+       FROM feedback_events
+       WHERE memory_id IN (${placeholders})
+         AND source = 'passive'
+         AND created_at > ?
+       GROUP BY memory_id`
+    ).all(...memoryIds, cutoff);
+    for (const row of rows) {
+      recentCounts.set(row.memory_id, row.c);
+    }
+  } catch {
+  }
+  let recorded = 0;
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const insert = db.prepare(
+    `INSERT INTO feedback_events (id, memory_id, source, useful, agent_id, event_type, value, created_at)
+     VALUES (?, ?, 'passive', 1, ?, 'passive:useful', 0.7, ?)`
+  );
+  for (const memoryId of memoryIds) {
+    const count = recentCounts.get(memoryId) ?? 0;
+    if (count >= 3) continue;
+    try {
+      insert.run(newId(), memoryId, effectiveAgentId, timestamp);
+      recorded++;
+    } catch {
+    }
+  }
+  return recorded;
+}
+
+// src/app/recall.ts
+async function recallMemory(db, input) {
+  const result = await recallMemories(db, input.query, {
+    agent_id: input.agent_id,
+    limit: input.emotion_tag ? (input.limit ?? 10) * 3 : input.limit,
+    min_vitality: input.min_vitality,
+    lexicalLimit: input.lexicalLimit,
+    vectorLimit: input.vectorLimit,
+    provider: input.provider,
+    recordAccess: input.recordAccess,
+    related: input.related,
+    after: input.after,
+    before: input.before,
+    recency_boost: input.recency_boost
+  });
+  if (input.emotion_tag) {
+    result.results = result.results.filter((r) => r.memory.emotion_tag === input.emotion_tag).slice(0, input.limit ?? 10);
+  }
+  if (input.recordAccess !== false) {
+    const top3DirectIds = result.results.filter((r) => r.match_type !== "related").slice(0, 3).map((r) => r.memory.id);
+    if (top3DirectIds.length > 0) {
+      recordPassiveFeedback(db, top3DirectIds, input.agent_id);
+    }
+  }
+  return result;
+}
 
 // src/app/surface.ts
 var INTENT_PRIORS = {
@@ -2092,7 +2400,9 @@ async function surfaceMemories(db, input) {
       searchBM25(db, trimmedQuery, {
         agent_id: agentId,
         limit: lexicalWindow,
-        min_vitality: minVitality
+        min_vitality: minVitality,
+        after: input.after,
+        before: input.before
       }),
       "queryRank"
     );
@@ -2103,7 +2413,9 @@ async function surfaceMemories(db, input) {
       searchBM25(db, trimmedTask, {
         agent_id: agentId,
         limit: lexicalWindow,
-        min_vitality: minVitality
+        min_vitality: minVitality,
+        after: input.after,
+        before: input.before
       }),
       "taskRank"
     );
@@ -2114,7 +2426,9 @@ async function surfaceMemories(db, input) {
       searchBM25(db, recentTurns.join(" "), {
         agent_id: agentId,
         limit: lexicalWindow,
-        min_vitality: minVitality
+        min_vitality: minVitality,
+        after: input.after,
+        before: input.before
       }),
       "recentRank"
     );
@@ -2128,7 +2442,9 @@ async function surfaceMemories(db, input) {
           providerId: provider.id,
           agent_id: agentId,
           limit: lexicalWindow,
-          min_vitality: minVitality
+          min_vitality: minVitality,
+          after: input.after,
+          before: input.before
         });
         const similarity = new Map(vectorRows.map((row) => [row.memory.id, row.similarity]));
         collectBranch(signals, vectorRows, "semanticRank", similarity);
@@ -2264,19 +2580,73 @@ function getDecayedMemories(db, threshold = 0.05, opts) {
 }
 
 // src/sleep/tidy.ts
+var EVENT_STALE_PATTERNS = [
+  { pattern: /正在|进行中|部署中|处理中|in progress|deploying|working on/i, type: "in_progress", decay: 0.3, maxAgeDays: 7 },
+  { pattern: /待办|TODO|等.*回复|等.*确认|需要.*确认/i, type: "pending", decay: 0.5, maxAgeDays: 14 },
+  { pattern: /刚才|刚刚|just now|a moment ago/i, type: "ephemeral", decay: 0.2, maxAgeDays: 3 }
+];
+var KNOWLEDGE_STALE_PATTERNS = [
+  { pattern: /^(TODO|WIP|FIXME|待办|进行中)[：:]/im, type: "pending", decay: 0.5, maxAgeDays: 14 },
+  { pattern: /^(刚才|刚刚)/m, type: "ephemeral", decay: 0.2, maxAgeDays: 3 }
+];
+function isStaleContent(content, type) {
+  if (type === "identity" || type === "emotion") {
+    return { stale: false, reason: "type excluded", decay_factor: 1 };
+  }
+  const patterns = type === "event" ? EVENT_STALE_PATTERNS : KNOWLEDGE_STALE_PATTERNS;
+  for (const { pattern, type: staleType, decay } of patterns) {
+    if (pattern.test(content)) {
+      return { stale: true, reason: staleType, decay_factor: decay };
+    }
+  }
+  return { stale: false, reason: "no stale patterns matched", decay_factor: 1 };
+}
+function getAgeThresholdDays(staleType) {
+  const thresholds = {
+    in_progress: 7,
+    pending: 14,
+    ephemeral: 3
+  };
+  return thresholds[staleType] ?? 7;
+}
 function runTidy(db, opts) {
   const threshold = opts?.vitalityThreshold ?? 0.05;
   const agentId = opts?.agent_id;
   let archived = 0;
+  let staleDecayed = 0;
   const transaction = db.transaction(() => {
     const decayed = getDecayedMemories(db, threshold, agentId ? { agent_id: agentId } : void 0);
     for (const mem of decayed) {
       deleteMemory(db, mem.id);
       archived += 1;
     }
+    const currentMs = Date.now();
+    const currentTime = now();
+    const agentCondition = agentId ? "AND agent_id = ?" : "";
+    const agentParams = agentId ? [agentId] : [];
+    const candidates = db.prepare(
+      `SELECT id, content, type, created_at, updated_at, vitality
+       FROM memories
+       WHERE priority >= 2 AND vitality >= ?
+       ${agentCondition}`
+    ).all(threshold, ...agentParams);
+    const updateStmt = db.prepare("UPDATE memories SET vitality = ?, updated_at = ? WHERE id = ?");
+    for (const mem of candidates) {
+      const detection = isStaleContent(mem.content, mem.type);
+      if (!detection.stale) continue;
+      const createdMs = new Date(mem.created_at).getTime();
+      const ageDays = (currentMs - createdMs) / (1e3 * 60 * 60 * 24);
+      const thresholdDays = getAgeThresholdDays(detection.reason);
+      if (ageDays < thresholdDays) continue;
+      const newVitality = Math.max(0, mem.vitality * detection.decay_factor);
+      if (Math.abs(newVitality - mem.vitality) > 1e-3) {
+        updateStmt.run(newVitality, currentTime, mem.id);
+        staleDecayed += 1;
+      }
+    }
   });
   transaction();
-  return { archived, orphansCleaned: 0 };
+  return { archived, orphansCleaned: 0, staleDecayed };
 }
 
 // src/sleep/govern.ts
@@ -3304,6 +3674,7 @@ function runAutoIngestWatcher(options) {
   const memoryMdPath = join2(workspaceDir, "MEMORY.md");
   const debounceMs = options.debounceMs ?? 1200;
   const initialScan = options.initialScan ?? true;
+  const ingestDaily = process.env.AGENT_MEMORY_AUTO_INGEST_DAILY === "1";
   const logger = options.logger ?? console;
   const timers = /* @__PURE__ */ new Map();
   const watchers = [];
@@ -3324,6 +3695,10 @@ function runAutoIngestWatcher(options) {
   const isTrackedMarkdownFile = (absPath) => {
     if (!absPath.endsWith(".md")) return false;
     if (resolve(absPath) === memoryMdPath) return true;
+    if (!ingestDaily) {
+      const basename = absPath.split("/").pop() ?? "";
+      if (/^\d{4}-\d{2}-\d{2}\.md$/.test(basename)) return false;
+    }
     const rel = relative(memoryDir, absPath).replace(/\\/g, "/");
     if (rel.startsWith("..") || rel === "") return false;
     return !rel.includes("/");
@@ -3604,6 +3979,7 @@ export {
   healthcheckEmbeddingProvider,
   ingestText,
   isCountRow,
+  isStaleContent,
   listMemories,
   listPendingEmbeddings,
   loadWarmBootLayers,
@@ -3619,6 +3995,7 @@ export {
   recallMemory,
   recordAccess,
   recordFeedbackEvent,
+  recordPassiveFeedback,
   reflectMemories,
   reindexEmbeddings,
   reindexMemories,