dsh-memu-memory 1.1.3 → 1.2.1

package/lib/memory.js

@@ -10,14 +10,16 @@ import {
   getLibrary, setSessionBinding, setRecallError, effectiveScope, listLibrariesAll,
 } from './state.js'
 import { stamp, redactSecrets, retryStoreWrite, warn } from './paths.js'
+import { scopeGenerationOf } from './consolidation-ledger.js'
 import { record } from './activity-log.js'
-import { BASE_AROUSAL, moodCongruence, moodDecay } from './mood.js'
+import { BASE_AROUSAL, derivedValence, dominanceBias, emotionActive, maxShare, moodCongruence, moodDecay, normalizeEmotion, overlap, readMood } from './mood.js'
 import { commit, retrieve, listFiles, forget } from './memu.js'
 import { bumpStats } from './stats.js'
-import { recallRelations } from './graph.js'
+import { recallRelations, pruneOrphanEntities } from './graph.js'
 import { attachmentRefs } from './media.js'
 import { normalizeMemoryContext, contextVisible, sameFactContext } from './context.js'
-import { assertGeneration, assertVectorWriteAllowed, captureGeneration, enrollActiveLibrary, hasActiveVectorGeneration, isVectorStateError, readVectorState, withVectorWrite } from './vector-profile.js'
+import { activeEntryStamp, assertGeneration, assertVectorWriteAllowed, captureGeneration, enrollActiveLibrary, hasActiveVectorGeneration, isVectorStateError, readVectorState, withVectorWrite } from './vector-profile.js'
+import { bigrams, dice, similarTexts, DUP_DICE, DUP_REJECT_DICE, TOPIC_DICE } from './text-similarity.js'
 
 const HALF_LIFE_DAYS = 14
 // A short-term entry is meant to live for the length of a conversation, not a
@@ -37,6 +39,11 @@ const HABITUATION_FLOOR = 0.5
 // library with three variants of the same decision would spend the whole block on it.
 // The top hit is always kept; later picks pay lambda x max-similarity-to-what-is-in.
 const MMR_LAMBDA = 0.72
+// Absolute floor on the retrieval share itself . The relative
+// relevanceThreshold cannot stop a near-empty result set from being padded to topK with
+// junk that only matched a duplicate cluster; a floor cuts those before selection.
+// 0 turns it off entirely — the calibrated default until §13.6 has run.
+const RETRIEVAL_FLOOR = 0
 // Semantic fusion uses RRF: each route contributes a
 // rank term and the merged score is normalised to the best fused hit before the
 // existing mood/strength/MMR pipeline sees it. The candidate cap keeps a long
@@ -93,7 +100,59 @@ function clearRecallError(exec) {
   if (sessionId) setRecallError(sessionId, null)
 }
 
+// Serialize backend-bearing private writes across every route in this module.
+// Acquire this queue BEFORE the vector lease; neither waits while holding a
+// synchronous file lock. This is not a cross-process/backend transaction.
+const privateWriteTails = new Map()
 async function withManagedPrivateWrite(libraryId, action) {
+  const previous = privateWriteTails.get(libraryId) || Promise.resolve()
+  const running = previous.then(() => withManagedPrivateWriteImpl(libraryId, action))
+  const settled = running.then(() => {}, () => {})
+  privateWriteTails.set(libraryId, settled)
+  try { return await running } finally {
+    if (privateWriteTails.get(libraryId) === settled) privateWriteTails.delete(libraryId)
+  }
+}
+
+function assertCompensationResult(result, operation) {
+  if (!result || typeof result !== 'object' || Array.isArray(result) || result.ok === false || result.error || result.parseWarning
+    || (operation === 'backend compensation delete' && (!Number.isSafeInteger(result.deleted) || result.deleted < 0))) {
+    throw new Error(operation + ' was not acknowledged')
+  }
+}
+
+// The index remains authoritative. Refuse destructive repair if another index
+// writer replaced the expected pre-await entry; otherwise rebuild that old row.
+// No transaction spans these external calls: crashes/other processes can still
+// interrupt compensation. Never describe an uncertain repair as success.
+async function compensatePrivateCommit(error, { libraryId, id, route, db, expectedEntry }) {
+  try {
+    const current = loadPrivateIndex(libraryId).entries[id]
+    if (JSON.stringify(current ?? null) !== JSON.stringify(expectedEntry ?? null)) {
+      throw new Error('memory changed before backend compensation')
+    }
+    const snapshot = JSON.stringify(current)
+    assertCompensationResult(await forget({ route, db, name: id }), 'backend compensation delete')
+    if (current && !['pending_review', 'superseded'].includes(current.status)) {
+      assertCompensationResult(await commit({ route, db, payload: {
+        recall_files: [{ name: id, track: current.track || 'memory', description: clampText(current.title, 180), content: current.content }],
+        resource: [], user: {},
+      } }), 'backend compensation restore')
+    }
+    if (JSON.stringify(loadPrivateIndex(libraryId).entries[id]) !== snapshot) {
+      throw new Error('memory changed during backend compensation')
+    }
+  } catch (compensationError) {
+    const failure = new Error('private memory index write failed; backend compensation uncertain: ' + String(compensationError?.message || compensationError), { cause: error })
+    failure.code = 'PRIVATE_BACKEND_COMPENSATION_FAILED'
+    failure.compensationError = compensationError
+    warn(failure.message)
+    throw failure
+  }
+  throw error
+}
+
+async function withManagedPrivateWriteImpl(libraryId, action) {
   const intent = managedVectorIntent()
   if (!intent.managed) return action()
   // 选了本地向量、但下载完模型后从没跑过迁移（vector-active 只有 requested）：这里
@@ -219,6 +278,7 @@ export function resolveLibrary({ exec, libraryId, readOnly = false }) {
   }
   const binding = readOnly ? peekBinding(exec) : bindingFor(exec)
   if (!binding) throw new Error('no bound session')
+  assertConsolidationParent(binding)
   // A binding without a library means the conversation explicitly opted out of
   // private memory. Writing through it used to land in `index/null.json` — a
   // "successful" write that can never be recalled. Refuse with an actionable
@@ -232,8 +292,18 @@ export function resolveLibrary({ exec, libraryId, readOnly = false }) {
 // The sidebar switches (and the folder ceiling behind them) must constrain tool
 // calls too, not just injection. One gate, sourced from `effectiveScope` so the
 // folder policy is always part of the answer.
+function assertConsolidationParent(binding) {
+  if (!binding?.consolidationFork) return
+  const parent = getSessionBinding(binding.parentSessionId)
+  if (!parent || !binding.parentScopeGeneration || scopeGenerationOf(parent) !== binding.parentScopeGeneration) {
+    throw new Error('DSH_MEMU_SCOPE_STALE: consolidation worker parent authorization changed')
+  }
+}
+
 function assertScopeEnabled(binding, { layer = 'library' } = {}) {
   if (!binding) return
+  assertConsolidationParent(binding)
+  if (binding.consolidationFork && layer === 'global') throw new Error('DSH_MEMU_WORKER_RESTRICTED: private worker cannot access global memory')
   const scope = effectiveScope(binding)
   if (layer === 'library' && !scope.useLibrary) {
     throw new Error(scope.libraryBlocked
@@ -491,20 +561,8 @@ export function isTipOfTongue(entry) {
 // Not semantic entailment: two bigram sets and a negation test. It only has to be
 // good enough to stop "he likes tea" and "he hates tea" from sitting side by side
 // as equally true, and quiet enough that ordinary rewordings do not trip it.
-function bigrams(text) {
-  const clean = String(text || '').toLowerCase().replace(/[\s\p{P}\p{S}]+/gu, '')
-  const out = new Set()
-  for (let i = 0; i < clean.length - 1; i += 1) out.add(clean.slice(i, i + 2))
-  return out
-}
-
-function dice(a, b) {
-  if (a.size === 0 || b.size === 0) return 0
-  let shared = 0
-  for (const gram of a) if (b.has(gram)) shared += 1
-  return (2 * shared) / (a.size + b.size)
-}
-
+// The bigrams/dice measure lives in lib/text-similarity.js so recall-side folding
+// and the write-side duplicate gate measure with the exact same ruler.
 const NEGATION_RE = /不|没|别|无|never|not|no longer|doesn't|don't/i
 
 /**
@@ -706,27 +764,47 @@ export function fuseRecallCandidates({ local = [], semantic = [], index, limit =
     if (automatic && entry.visibility === 'secret') return null
     return { id, entry, file, route, rank }
   }
-  const take = (files, route) => {
+  const take = (files, route, collapsed) => {
     const picked = []
     // One route can name the same canonical entry more than once: a caller may
     // pass both `mem-x` and `mem-x.md`, and an engine can repeat a hit. Dedupe by
     // canonical id before scoring and truncating, keeping the first (best) rank.
     // Otherwise every duplicate adds another 1/(k+rank) and consumes a slot.
     const seen = new Set()
+    // Fact-level folding : id dedupe cannot see "same fact,
+    // different id", so a paraphrase cluster would spend one candidate slot per
+    // member and crowd real memories out before any ranking runs. A candidate that
+    // a accepted candidate already speaks for (dice ≥ DUP_DICE on title + body)
+    // is recorded and skipped: one cluster, one candidate slot.
+    const gramsCache = new Map()
+    const gramsOf = (item) => {
+      let set = gramsCache.get(item.id)
+      if (!set) {
+        set = bigrams(String(item.entry?.title || '') + ' ' + String(item.entry?.content || ''))
+        gramsCache.set(item.id, set)
+      }
+      return set
+    }
     for (const file of Array.isArray(files) ? files : []) {
       const item = eligible(file, route, picked.length + 1)
       if (!item || seen.has(item.id)) continue
       seen.add(item.id)
+      const twin = picked.find((accepted) => dice(gramsOf(item), gramsOf(accepted)) >= DUP_DICE)
+      if (twin) {
+        collapsed.push({ kept: twin.id, dropped: item.id })
+        continue
+      }
       picked.push(item)
       if (picked.length >= limit) break
     }
     return picked
   }
-  const localPicked = take(local, 'local')
-  const semanticPicked = take(semantic, 'semantic')
+  const routeCollapsed = []
+  const localPicked = take(local, 'local', routeCollapsed)
+  const semanticPicked = take(semantic, 'semantic', routeCollapsed)
   const merged = new Map()
   const add = (item) => {
-    const current = merged.get(item.id) || { id: item.id, entry: item.entry, file: item.file, rrf: 0, bestRank: Infinity, localRank: null, semanticRank: null, routes: [] }
+    const current = merged.get(item.id) || { id: item.id, entry: item.entry, file: item.file, rrf: 0, bestRank: Infinity, localRank: null, semanticRank: null, routes: [], mergedTogether: [] }
     current.rrf += 1 / (HYBRID_RRF_K + item.rank)
     current.bestRank = Math.min(current.bestRank, item.rank)
     if (item.route === 'local') current.localRank = item.rank
@@ -740,14 +818,51 @@ export function fuseRecallCandidates({ local = [], semantic = [], index, limit =
   for (const item of localPicked) add(item)
   for (const item of semanticPicked) add(item)
   const rows = [...merged.values()]
+  // Cross-leg folding . Each leg folded within itself, but the
+  // two legs can still meet the same fact under two ids. Keep the highest-rrf member
+  // of each cross-leg cluster and let the rest ride along as mergedTogether metadata
+  // instead of spending recall slots; this must happen BEFORE mmrSelect, so the
+  // diversity ceiling is set by a real spread of memories rather than a cluster.
+  const fusionCollapsed = []
+  const absorbed = new Set()
+  const rowGrams = new Map()
+  const gramsOfRow = (row) => {
+    let set = rowGrams.get(row.id)
+    if (!set) {
+      set = bigrams(String(row.entry?.title || '') + ' ' + String(row.entry?.content || ''))
+      rowGrams.set(row.id, set)
+    }
+    return set
+  }
+  const hosts = []
+  for (const row of rows.slice().sort((a, b) => b.rrf - a.rrf || a.id.localeCompare(b.id))) {
+    const host = hosts.find((kept) => dice(gramsOfRow(row), gramsOfRow(kept)) >= DUP_DICE)
+    if (host) {
+      host.mergedTogether.push(row.id)
+      absorbed.add(row.id)
+      fusionCollapsed.push({ kept: host.id, dropped: row.id })
+    } else {
+      hosts.push(row)
+    }
+  }
+  const collapsedGroups = new Map()
+  for (const { kept, dropped } of [...routeCollapsed, ...fusionCollapsed]) {
+    if (!collapsedGroups.has(kept)) collapsedGroups.set(kept, { kept, dropped: [] })
+    const group = collapsedGroups.get(kept)
+    // The same pair can meet on both routes; report it once.
+    if (!group.dropped.includes(dropped)) group.dropped.push(dropped)
+  }
+  const collapsed = [...collapsedGroups.values()]
   const maxRrf = rows.reduce((max, row) => Math.max(max, row.rrf), 0) || 1
   const files = rows
+    .filter((row) => !absorbed.has(row.id))
     .map((row) => ({
       ...row.file,
       name: row.id,
       entry: row.entry,
       retrievalScore: row.rrf / maxRrf,
       fusion: { rrf: row.rrf, bestRank: row.bestRank, localRank: row.localRank, semanticRank: row.semanticRank, routes: row.routes.slice() },
+      ...(row.mergedTogether.length ? { mergedTogether: row.mergedTogether.slice() } : {}),
     }))
     .sort((a, b) => b.retrievalScore - a.retrievalScore
       || a.fusion.bestRank - b.fusion.bestRank
@@ -766,10 +881,21 @@ export function fuseRecallCandidates({ local = [], semantic = [], index, limit =
       localOnly: [...localIds].filter((id) => !semanticIds.has(id)).length,
       semanticOnly: [...semanticIds].filter((id) => !localIds.has(id)).length,
       shared: [...localIds].filter((id) => semanticIds.has(id)).length,
+      collapsed,
+      clusterCount: collapsed.length,
     },
   }
 }
 
+// The retrieval component of recallScore: a fused file carries its own normalised
+// RRF share; falling back to the old rank decay keeps every lexical caller
+// byte-for-byte compatible. Shared with the retrieval-floor cut so the two can
+// never disagree about what "retrieval" means.
+function retrievalShare(file, rank) {
+  const fused = Number(file?.retrievalScore)
+  return Number.isFinite(fused) ? Math.max(0, Math.min(1, fused)) : 1 / (rank + 1)
+}
+
 // Human-like recall ordering. Retrieval answers first (semantic match is still
 // the primary signal, which is why it stays a rank decay), then these biases
 // re-order within that set:
@@ -779,18 +905,22 @@ export function fuseRecallCandidates({ local = [], semantic = [], index, limit =
 // Every factor is bounded so no bias can outrank a good semantic hit by luck.
 function recallScore(file, rank, context) {
   const entry = file.entry || {}
-  // A fused file carries its own normalised RRF share. Falling back to the old
-  // rank decay keeps every lexical caller byte-for-byte compatible.
-  const fused = Number(file.retrievalScore)
-  const retrieval = Number.isFinite(fused) ? Math.max(0, Math.min(1, fused)) : 1 / (rank + 1)
+  const retrieval = retrievalShare(file, rank)
   const strengthTerm = 0.6 + 0.4 * file.strength
   const marginal = entry.marginalized ? 0.35 : 1
 
   // Fading affect bias: what pulls is the tint the memory still carries today, not
   // the one it was written with. Old grievances quieten down; old fondness does not.
-  const moodBias = context.moodEnabled
-    ? 1 + 0.3 * moodCongruence(fadedValence(entry, context.now), context.moodValence)
-    : 1
+  //
+  // Two paths, one decision: when both sides carry a composition, compare the
+  // compositions (how much of the present shape the memory shares). Otherwise fall
+  // back to the legacy signed-valence congruence. Entries written before this model
+  // existed have no composition and must keep working unchanged.
+  const moodBias = !context.moodEnabled
+    ? 1
+    : (context.emotion && entry.emotion
+      ? 1 + 0.3 * affectFadeFactor(entry, context.now) * (2 * overlap(entry.emotion, context.emotion) - 1)
+      : 1 + 0.3 * moodCongruence(fadedValence(entry, context.now), context.moodValence))
   const peak = entry.peak === true ? 1 : Math.max(0, Number(entry.arousal || 0))
   const end = context.lastCreatedAt && file.createdAtIdentity === context.lastCreatedAt ? 1 : 0
   const peakEnd = 1 + 0.25 * Math.max(peak, end)
@@ -802,13 +932,38 @@ function recallScore(file, rank, context) {
   // this asks "does its loudness match the room right now?" — different questions that
   // only look like duplicates.
   const arousalTerm = context.moodEnabled ? arousalBias(entry, context) : 1
+  // Dominance asks a third question: who was steering. Two equally sad memories pull
+  // differently depending on whether the present state is "I can fix this" or "nothing
+  // I do matters". Bounded to +-10% so it can only reorder near-ties.
+  const dominanceTerm = context.moodEnabled ? dominanceBias(entry.dominance, context.dominance) : 1
   // An open loop is an unfinished thread — a promise, a question, a plan nobody
   // closed. Those are what a person brings up unprompted, so they get a nudge and not
   // a trump card: 1.25 still loses to a clearly better semantic hit.
   const openLoopBias = entry.openLoop ? 1.25 : 1
   const habituation = habituationFactor(entry, context.now)
+  // Fact-level dedup down-weight . A near-copy that arrived
+  // later is tagged duplicateOf at write time; without this factor the copy would
+  // ride the same touch/decay loop as the original and could outlive it in rank —
+  // the "duplicates age better than the truth" loop this closes.
+  const duplicateFactor = entry.duplicateOf ? 0.7 : 1
 
-  return retrieval * strengthTerm * marginal * moodBias * peakEnd * primacy * openLoopBias * habituation * arousalTerm
+  return retrieval * strengthTerm * marginal * moodBias * peakEnd * primacy * openLoopBias * habituation * arousalTerm * dominanceTerm * duplicateFactor
+}
+
+/**
+ * How much of a memory's original tint is still there, 0..1.
+ *
+ * Same curve as `fadedValence`, but returned as a bare factor so the composition path
+ * applies the *fading* to the whole comparison instead of decaying the shares (shares
+ * sum to 1, so decaying them proportionally would change nothing).
+ */
+function affectFadeFactor(entry, now = Date.now()) {
+  const valence = entry.emotion ? derivedValence(entry.emotion) : Number(entry.moodValence || 0)
+  if (!valence) return 0
+  const updated = Date.parse(entry.updatedAt || entry.createdAt || '') || now
+  const days = Math.max(0, (now - updated) / 86_400_000)
+  const halfLife = valence < 0 ? FAB_HALF_LIFE_DAYS.negative : FAB_HALF_LIFE_DAYS.positive
+  return Math.pow(0.5, days / halfLife)
 }
 
 /**
@@ -822,9 +977,12 @@ function recallScore(file, rank, context) {
 function arousalBias(entry, context) {
   const present = Number(context.arousal == null ? BASE_AROUSAL : context.arousal)
   const drive = Math.max(-0.35, Math.min(0.65, present - BASE_AROUSAL))
+  // A composed entry can be *very* angry while its legacy valence projection looks
+  // mild, so the largest share counts as intensity alongside the stored arousal.
   const intensity = Math.max(
     entry.peak === true ? 1 : 0,
     Math.min(1, Math.max(0, Number(entry.arousal || 0))),
+    Math.min(1, maxShare(entry.emotion)),
     Math.min(1, Math.abs(Number(entry.moodValence || 0)) * 0.8),
   )
   return 1 + 0.5 * drive * (intensity - 0.5)
@@ -846,23 +1004,33 @@ function habituationFactor(entry, now = Date.now()) {
 // bounded biases, so its scale depends on the library and a fixed cutoff would mean
 // different things in different conversations. "Keep what scores within N of the best
 // hit" is scale-free, and 0 turns the filter off entirely.
-function cutWeakScores(files, threshold) {
+// `retrievalFloor` is the absolute complement : whatever the
+// library looks like, a hit whose retrieval share never cleared the floor must not
+// pad a topK that a duplicate cluster emptied. 0 turns it off entirely.
+function cutWeakScores(files, threshold, retrievalFloor = 0) {
+  let out = files
   const cut = Number(threshold)
-  if (!Number.isFinite(cut) || cut <= 0) return files
-  const best = Number(files[0]?.score || 0)
-  if (best <= 0) return files
-  return files.filter((f) => Number(f.score || 0) >= best * cut)
+  if (Number.isFinite(cut) && cut > 0) {
+    const best = Number(out[0]?.score || 0)
+    if (best > 0) out = out.filter((f) => Number(f.score || 0) >= best * cut)
+  }
+  const floor = Number(retrievalFloor)
+  if (Number.isFinite(floor) && floor > 0) out = out.filter((f) => Number(f.retrieval ?? retrievalShare(f, 0)) >= floor)
+  return out
 }
 
 function privateWeighted(result, max, context = {}) {
   const ctx = {
     moodEnabled: false,
     moodValence: 0,
+    emotion: null,
     arousal: BASE_AROUSAL,
+    dominance: 0,
     firstCreatedAt: null,
     lastCreatedAt: null,
     sessionId: null,
     now: Date.now(),
+    retrievalFloor: RETRIEVAL_FLOOR,
     ...context,
   }
   const items = (result.files || [])
@@ -873,55 +1041,79 @@ function privateWeighted(result, max, context = {}) {
     // memories. Filtering here keeps the anchor and the recall block in agreement.
     .filter((f) => visibleToSession(f.entry, ctx.sessionId))
     .filter((f) => !ctx.automatic || f.entry?.visibility !== 'secret')
-    .map((f, i) => ({ ...f, score: recallScore(f, i, ctx) }))
+    .map((f, i) => ({ ...f, score: recallScore(f, i, ctx), retrieval: retrievalShare(f, i) }))
     .sort((a, b) => b.score - a.score)
-  return { ...result, files: mmrSelect(cutWeakScores(items, ctx.relevanceThreshold), max) }
+  const { chosen, skipped } = mmrSelect(cutWeakScores(items, ctx.relevanceThreshold, ctx.retrievalFloor), max)
+  // Observation for the dedup thresholds : candidate folding
+  // (①②) reports through result.fusion, the ranking-level hard skips (③) come back
+  // from mmrSelect. One merged list — without it, a mistuned threshold eats real
+  // memories invisibly. Fail-open: metadata only, never a recall failure.
+  const fusionCollapsed = Array.isArray(result.fusion?.collapsed) ? result.fusion.collapsed : []
+  const collapsed = [...fusionCollapsed, ...skipped]
+  return { ...result, files: chosen, dedup: { collapsed, clusterCount: collapsed.length } }
 }
 
 /**
  * Greedy maximal marginal relevance over already-scored files.
  *
- * Similarity is lexical (queryTokens + Jaccard) on purpose: it must be cheap enough
- * to run on every recall and predictable enough to explain. An embedding version
- * would need a second engine round trip just to de-duplicate four lines.
+ * Similarity is lexical on purpose (dice over title+body bigrams, the same shared
+ * ruler the write-side duplicate gate uses): it must be cheap enough to run on every
+ * recall and predictable enough to explain. An embedding version would need a second
+ * engine round trip just to de-duplicate four lines.
+ *
+ * Two bands :
+ *   · dice >= DUP_DICE  — the candidate describes a fact something already chosen
+ *     describes: it is never selected, only reported as `skipped`. A soft penalty
+ *     cannot bound how many seats one fact takes; this can.
+ *   · TOPIC_DICE <= dice < DUP_DICE — same topic, different fact: the existing soft
+ *     penalty (lambda x overlap x ceiling) still applies.
+ * Below TOPIC_DICE the two memories do not interact.
  */
 function mmrSelect(items, max, lambda = MMR_LAMBDA) {
   const limit = Number(max || 0)
-  if (!(limit > 0)) return items
-  if (items.length <= 1) return items.slice(0, limit)
+  if (!(limit > 0)) return { chosen: items, skipped: [] }
+  if (items.length <= 1) return { chosen: items.slice(0, limit), skipped: [] }
   const chosen = []
   const pool = items.slice()
-  const tokenCache = new Map()
-  const tokensOf = (file) => {
+  const gramsCache = new Map()
+  const gramsOf = (file) => {
     const key = file.name
-    if (tokenCache.has(key)) return tokenCache.get(key)
-    const set = new Set(queryTokens(String(file.entry?.title || '') + ' ' + String(file.entry?.content || '')))
-    tokenCache.set(key, set)
+    if (gramsCache.has(key)) return gramsCache.get(key)
+    const set = bigrams(String(file.entry?.title || '') + ' ' + String(file.entry?.content || ''))
+    gramsCache.set(key, set)
     return set
   }
   // Anchor the penalty to the best raw score so the diversity term is on the same
   // scale as relevance instead of being dominated by it.
   const ceiling = Number(items[0]?.score || 0) || 1
+  // dropped id -> kept id. Recorded across rounds; an item hard-blocked in one round
+  // stays blocked (chosen only grows), and the map keeps it reported exactly once.
+  const blocked = new Map()
   while (pool.length > 0 && chosen.length < limit) {
-    let bestIdx = 0
+    let bestIdx = -1
     let bestScore = -Infinity
     for (let i = 0; i < pool.length; i += 1) {
       let overlap = 0
-      for (const picked of chosen) overlap = Math.max(overlap, jaccard(tokensOf(pool[i]), tokensOf(picked)))
+      let twin = null
+      for (const picked of chosen) {
+        const similarity = dice(gramsOf(pool[i]), gramsOf(picked))
+        if (similarity >= DUP_DICE) { twin = picked.name; break }
+        if (similarity >= TOPIC_DICE) overlap = Math.max(overlap, similarity)
+      }
+      if (twin) { blocked.set(pool[i].name, twin); continue }
       const adjusted = Number(pool[i].score || 0) - lambda * overlap * ceiling
       if (adjusted > bestScore) { bestScore = adjusted; bestIdx = i }
     }
+    if (bestIdx === -1) break // nothing selectable is left: only hard duplicates remain
     chosen.push(pool.splice(bestIdx, 1)[0])
   }
-  return chosen
-}
-
-/** Jaccard overlap of two token sets; 0 when either side is empty. */
-function jaccard(a, b) {
-  if (!a || !b || a.size === 0 || b.size === 0) return 0
-  let shared = 0
-  for (const token of a) if (b.has(token)) shared += 1
-  return shared / (a.size + b.size - shared)
+  const skipped = []
+  for (const [dropped, kept] of blocked) {
+    let group = skipped.find((g) => g.kept === kept)
+    if (!group) { group = { kept, dropped: [] }; skipped.push(group) }
+    group.dropped.push(dropped)
+  }
+  return { chosen, skipped }
 }
 
 /**
@@ -952,13 +1144,72 @@ function createdAtSpan(files) {
   return { first: stamps[0] || null, last: stamps[stamps.length - 1] || null }
 }
 
+/**
+ * Decide what an entry's affect actually is, and which tier answered.
+ *
+ * Order: the model said it; the conversation is in a mood and inheritance is allowed;
+ * the memory's own text reads as emotional; nothing. `emotionSource` keeps "neutral"
+ * and "no idea" distinguishable — they drive the same recall multiplier, but only one
+ * of them means the write path worked.
+ *
+ * Engineering facts stay neutral on purpose. A bug being hard to fix is not the
+ * project feeling sad, and letting the turn's mood leak into a technical entry is how
+ * "the deployment failed and we were furious" becomes a fact about the deployment.
+ */
+function resolveEntryEmotion({ emotion, dominance, emotionSource, owner, content, binding }) {
+  const providedDominance = Number(dominance)
+  const explicitDominance = dominance !== null && dominance !== undefined && Number.isFinite(providedDominance)
+    ? Math.max(-1, Math.min(1, providedDominance))
+    : null
+  // Three states, and they are not the same thing: omitted = inherit (a caller that
+  // says nothing wants the turn's context), null = explicitly neutral (the model looked
+  // and found nothing), an object = the model's reading. Collapsing null into "omitted"
+  // would silently reinstate inherited mood on a memory the model called neutral.
+  const explicitNeutral = emotion === null
+  const fromModel = emotion !== undefined && emotion !== null
+  let resolved = null
+  let sourceName = 'unknown'
+  let inheritedDominance = null
+  if (fromModel) {
+    resolved = normalizeEmotion(emotion)
+    sourceName = 'model'
+  } else if (!explicitNeutral && owner !== 'about_project') {
+    const sessionMood = binding && binding.mood ? binding.mood : null
+    if (sessionMood && sessionMood.emotion) {
+      resolved = normalizeEmotion(sessionMood.emotion)
+      sourceName = resolved ? 'session' : 'unknown'
+      const sessionDominance = Number(sessionMood.dominance)
+      if (Number.isFinite(sessionDominance)) inheritedDominance = Math.max(-1, Math.min(1, sessionDominance))
+    }
+    if (resolved === null && sourceName === 'unknown') {
+      const read = readMood(content)
+      if (read.emotion) {
+        resolved = read.emotion
+        sourceName = 'content'
+        inheritedDominance = read.dominance
+      }
+    }
+  }
+  return {
+    emotion: resolved,
+    dominance: explicitDominance === null ? (inheritedDominance === null ? 0 : inheritedDominance) : explicitDominance,
+    source: explicitNeutral ? 'model' : (emotionSource || sourceName),
+    neutral: explicitNeutral,
+  }
+}
+
 async function privateRememberImpl({
   exec, libraryId, content, title, layer, pinReason = null, pinSource = null,
   sideEventId = null, tags = [], openLoop = false, disclosure = 'can_tell',
   owner = 'me', visibility = 'shared', source = 'inferred', confidence = 0.8,
   moodValence = null, arousal = null, peak = false, salientDate = null,
+  emotion = undefined, dominance = undefined, emotionSource = null,
   attachments, track = 'memory',
   context,
+  // Escape hatch for the duplicate gate : two genuine
+  // observations of the same fact on the same day are a legal write. Off by
+  // default — the model must say it looked, not default past the gate.
+  allowDuplicate = false,
 }) {
   const scope = resolveLibrary({ exec, libraryId })
   const binding = scope.binding
@@ -1036,6 +1287,12 @@ async function privateRememberImpl({
       && (item.attachments || []).some(attachment => media.some(candidate => candidate.sha256 === attachment.sha256)))
     : null
   const id = previousHabit?.[0] || newMemoryId('mem')
+  // A malformed share is refused here rather than clamped later: a negative or
+  // non-finite composition is a caller bug, and repairing it silently would keep the
+  // bug alive while the entry looks fine.
+  if (emotion !== null && emotion !== undefined) normalizeEmotion(emotion)
+  if (dominance !== null && dominance !== undefined && !Number.isFinite(Number(dominance))) throw new Error('dominance must be a number between -1 and 1')
+  const resolvedAffect = resolveEntryEmotion({ emotion, dominance, owner, content: String(content), binding })
   const entry = {
     ...(previousHabit?.[1] || {}),
     track,
@@ -1068,9 +1325,18 @@ async function privateRememberImpl({
     // Retrieval lens + resurface metadata. When the agent does not state a mood,
     // the current session read is stored instead, so a memory written during a
     // hard conversation is tinted by it without the model having to name it.
-    moodValence: moodValence === null || moodValence === undefined
-      ? (binding?.mood ? Number(binding.mood.valence) || 0 : 0)
-      : Math.max(-1, Math.min(1, Number(moodValence) || 0)),
+    // `moodValence` stays as the legacy projection of the four shares; the shares
+    // themselves are what the new recall path compares.
+    moodValence: resolvedAffect.emotion
+      ? derivedValence(resolvedAffect.emotion)
+      : (resolvedAffect.neutral
+        ? 0
+        : (moodValence === null || moodValence === undefined
+          ? (binding?.mood ? Number(binding.mood.valence) || 0 : 0)
+          : Math.max(-1, Math.min(1, Number(moodValence) || 0)))),
+    emotion: resolvedAffect.emotion,
+    dominance: resolvedAffect.dominance,
+    emotionSource: resolvedAffect.source,
     arousal: arousal === null || arousal === undefined
       ? (binding?.mood ? Number(binding.mood.arousal) || 0.35 : 0.35)
       : Math.max(0, Math.min(1, Number(arousal) || 0)),
@@ -1092,6 +1358,35 @@ async function privateRememberImpl({
       ? `与已有记忆「${clampText(conflict.entry.title || conflict.id, 60)}」同题但内容不同`
       : `与已有记忆「${clampText(conflict.entry.title || conflict.id, 60)}」说法相反`
   }
+  // Fact-level duplicate gate . Strictly AFTER the conflict
+  // check — in the same-title band a contradictory rewording must land as
+  // pending_review, not be swallowed as a duplicate — and strictly AFTER
+  // redactSecrets, so key material cannot leak into the similarity metric. Measures
+  // with the shared dice the recall side folds with: one ruler for "same fact".
+  // Never deletes or rewrites anything: a hit either refuses the new entry, or tags
+  // it duplicateOf so recall can keep one seat per fact.
+  let duplicate = null
+  if (!conflict && allowDuplicate !== true) {
+    const text = `${entry.title || ''} ${content || ''}`
+    const grams = bigrams(text)
+    for (const [otherId, other] of Object.entries(index.entries)) {
+      // Same filter set the recall side uses: only an entry a recall could actually
+      // surface can be "the same fact" — and a duplicateOf tag must point at one.
+      if (otherId === id || !isMemoryEligible(other)) continue
+      if (!sameFactContext(other.context, entry.context)) continue
+      const similarity = similarTexts(text, `${other.title || ''} ${other.content || ''}`)
+      if (similarity > (duplicate?.similarity ?? 0)) duplicate = { id: otherId, similarity }
+    }
+  }
+  if (duplicate && duplicate.similarity >= DUP_REJECT_DICE) {
+    return {
+      deduped: true,
+      existingId: duplicate.id,
+      similarity: duplicate.similarity,
+      hint: '库内已有一条几乎相同的记忆；改用 memu_private_update 合并内容。若确属两次独立观测，带 allowDuplicate=true 重写',
+    }
+  }
+  if (duplicate && duplicate.similarity >= TOPIC_DICE) entry.duplicateOf = duplicate.id
   const payload = {
     recall_files: [{
       name: id,
@@ -1106,22 +1401,15 @@ async function privateRememberImpl({
   // would make a contested memory retrievable before anyone decided it. Accepting
   // the review later is what commits it (see resolveReview → privateUpdate).
   const route = engineRoute()
-  const result = (route !== 'lexical') && !conflict
-    ? await commit({ payload, route, db: memoryDbPath(scope.libraryId) })
+  const db = route !== 'lexical' && !conflict ? memoryDbPath(scope.libraryId) : null
+  const result = db
+    ? await commit({ payload, route, db })
     : { ok: true, backend: route, held: conflict ? true : undefined }
+  try {
   // 记下"这条进没进向量库"：只有真的带代际提交成功才写，冲突暂扣/降级都不写。
   // 之前没有任何字段能回答"哪条记忆进向量库了"，只能靠猜。
   if (route !== 'lexical' && !conflict && result?.ok !== false && !result?.parseWarning) {
-    const active = readVectorState({ tolerateMissing: true }).state?.active
-    if (active) {
-      entry.vector = {
-        route,
-        model: active.profile?.catalogId || null,
-        generation: active.generation,
-        fingerprint: String(active.fingerprint || '').slice(0, 8),
-        at: stamp(),
-      }
-    }
+    entry.vector = activeEntryStamp(route) || entry.vector
   }
   // Re-read after the await: a curator job or another turn may have written in
   // the meantime, and saving the pre-await snapshot would erase it.
@@ -1132,6 +1420,7 @@ async function privateRememberImpl({
     if (previousHabit && JSON.stringify(fresh.entries[id]) !== JSON.stringify(previousHabit[1])) throw new Error('habit changed concurrently; recall and retry')
     const latestConflict = findConflict(Object.fromEntries(Object.entries(fresh.entries).filter(([key]) => key !== id)), entry)
     if (latestConflict && !conflict) {
+      if (db) throw new Error('memory conflict changed during write; retry for review')
       entry.status = 'pending_review'
       entry.conflictingWith = latestConflict.id
       entry.reviewReason = 'concurrent conflicting memory; review required'
@@ -1142,6 +1431,10 @@ async function privateRememberImpl({
     }
     fresh.entries[id] = entry
   }))
+  } catch (error) {
+    if (db) await compensatePrivateCommit(error, { libraryId: scope.libraryId, id, route, db, expectedEntry: previousHabit?.[1] || null })
+    throw error
+  }
   if (!previousHabit) bumpStats(scope.libraryId, 'written')
   if (layer === 'must_remember' && pinSource === 'side_event') {
     consumeCue(sessionIdOf(exec), sideEventId)
@@ -1305,6 +1598,12 @@ async function importMemoriesImpl({ libraryId, memories, maxFiles = 2000, now =
       engineWarning = String(error?.message || error)
     }
   }
+  // 批量恢复与单条写入同口径：提交成功就在条目上落"已入向量库"戳，否则这些条目
+  // 在向量计数（membership 的戳腿）里永远缺失。受管提交失败直接抛，不会走到这里。
+  if (route !== 'lexical' && engineWarning === null) {
+    const vector = activeEntryStamp(route)
+    if (vector) for (const item of entries) item.entry.vector = vector
+  }
   const idMap = Object.fromEntries(entries.filter(item => item.entry.importedFrom).map(item => [item.entry.importedFrom, item.id]))
   await retryStoreWrite(() => updatePrivateIndex(libraryId, (fresh) => {
     for (const { id, entry } of entries) {
@@ -1343,11 +1642,14 @@ export async function privateRecall({ exec, query, topK, relevanceThreshold, pur
   const span = createdAtSpan(Object.values(index.entries || {}).map((entry) => ({ entry })))
   const mood = moodDecay(binding.mood)
   const scored = privateWeighted(enriched, Number(topK || settings.privateTopK || 4), {
-    // Arousal is used even when valence is near neutral: a tense room with no clear
-    // good/bad reading still changes which memories come up.
-    moodEnabled: Math.abs(mood.valence) >= MOOD_MIN_STRENGTH || Math.abs(mood.arousal - BASE_AROUSAL) >= 0.1,
+    // Three independent legs: a clear composition, an arousal away from rest, or a
+    // clear sense of control. A null composition only closes the first one — a tense
+    // room with no clear good/bad reading still changes which memories come up.
+    moodEnabled: emotionActive({ emotion: mood.emotion, arousal: mood.arousal, dominance: mood.dominance }),
     moodValence: mood.valence,
+    emotion: mood.emotion,
     arousal: mood.arousal,
+    dominance: mood.dominance,
     firstCreatedAt: span.first,
     lastCreatedAt: span.last,
     relevanceThreshold: threshold,
@@ -1360,6 +1662,21 @@ export async function privateRecall({ exec, query, topK, relevanceThreshold, pur
   // like one nobody ever touches. Batched into a single index write.
   if (purpose !== 'automatic') touchAccessMany({ libraryId: binding.libraryId, ids: (scored.files || []).map((f) => f.name) })
   bumpStats(binding.libraryId, 'recalled', (scored.files || []).length)
+  // Fact-level dedup observation . Fail-open signal, not
+  // bookkeeping: without it a mistuned DUP_DICE silently eats real memories and
+  // nobody can tell "recalled N" from "recalled N members of one fact".
+  if (scored.dedup?.collapsed?.length) {
+    const folded = scored.dedup.collapsed.reduce((n, group) => n + group.dropped.length, 0)
+    record({
+      kind: 'recall',
+      scope: 'private',
+      sessionId: memorySessionId(exec),
+      libraryId: binding.libraryId,
+      message: `去重折叠 ${folded} 条候选（${scored.dedup.clusterCount} 簇）`,
+      detail: { collapsed: scored.dedup.collapsed, clusterCount: scored.dedup.clusterCount },
+      refs: scored.dedup.collapsed.map((group) => group.kept).slice(0, 20),
+    })
+  }
   for (const file of scored.files || []) {
     if (file.entry?.attachments?.length) {
       file.entry = { ...file.entry, attachments: file.entry.attachments.map(item => {
@@ -1419,7 +1736,7 @@ export async function privateList({ exec, libraryId, preferIndex = false }) {
 // mood lens and the attachment list all change how an entry is scored, aggregated or
 // rendered, so a wrong value in any of them was a permanent mis-filing that could
 // only be undone by archiving the memory and writing it again.
-async function privateUpdateImpl({ exec, libraryId, id, content, title, tags, status, openLoop, disclosure, confidence, layer, owner, visibility, source, salientDate, track, peak, moodValence, arousal, attachments, context }) {
+async function privateUpdateImpl({ exec, libraryId, id, content, title, tags, status, openLoop, disclosure, confidence, layer, owner, visibility, source, salientDate, track, peak, moodValence, arousal, emotion, dominance, attachments, context }) {
   // `source` is editable because it is a claim about provenance, and claims get
   // corrected: a memory the model first filed as `inferred` may turn out to be
   // something the user actually said. Enum-checked like the rest — a typo here
@@ -1441,6 +1758,8 @@ async function privateUpdateImpl({ exec, libraryId, id, content, title, tags, st
   if (confidence !== undefined && !Number.isFinite(Number(confidence))) throw new Error('confidence must be a number between 0 and 1')
   if (moodValence !== undefined && !Number.isFinite(Number(moodValence))) throw new Error('moodValence must be a number between -1 and 1')
   if (arousal !== undefined && !Number.isFinite(Number(arousal))) throw new Error('arousal must be a number between 0 and 1')
+  if (emotion !== undefined && emotion !== null) normalizeEmotion(emotion)
+  if (dominance !== undefined && dominance !== null && !Number.isFinite(Number(dominance))) throw new Error('dominance must be a number between -1 and 1')
   // Throws for anything the library never received: an attachment list you cannot
   // correct would leave a mis-filed image attached forever.
   const nextAttachments = attachments === undefined ? undefined : attachmentRefs(scope.libraryId, attachments)
@@ -1448,13 +1767,43 @@ async function privateUpdateImpl({ exec, libraryId, id, content, title, tags, st
   // the same way. Capture before the update: `entry` is the pre-update snapshot.
   const wasArchived = entry.status === 'archived'
   const nextContent = content === undefined ? undefined : redactSecrets(content)
-  if (nextContent !== undefined && entry.status !== 'pending_review') {
+  // 改写文本（title 或 content 任一变化）要过与 remember 写入门同口径的两道门
+  // ：先矛盾、后重复，度量是同一把 dice 尺。此前只有新建
+  // 被拦——把一条记忆改写成与另一条几乎相同就能从更新路径绕开门，这里补上。
+  // 门在 backend commit 之前跑：拒绝时引擎里什么都没写，compensation 路径不受影响。
+  const textChanged = nextContent !== undefined || title !== undefined
+  const nextTitle = title !== undefined ? clampText(title, 120) : (entry.title || '')
+  const nextContext = context === undefined ? entry.context : normalizeMemoryContext(context)
+  const scanned = textChanged && entry.status !== 'pending_review'
+  let duplicate = null
+  let text = null
+  if (scanned) {
     const others = Object.fromEntries(Object.entries(index.entries).filter(([key]) => key !== id_))
-    const conflict = findConflict(others, { ...entry, title: title ?? entry.title, content: nextContent })
+    const conflict = findConflict(others, { ...entry, title: nextTitle, content: nextContent ?? entry.content })
     if (conflict) throw new Error(`content conflicts with ${conflict.id}; write a new memory for review`)
+    text = `${nextTitle} ${nextContent ?? entry.content}`
+    for (const [otherId, other] of Object.entries(others)) {
+      // 与 remember 的门同一过滤集（isMemoryEligible + sameFactContext），再排除它原本的
+      // duplicateOf 关系——那对条目是写入时就获准共存的，向它继续靠拢不该被拦。
+      if (!isMemoryEligible(other)) continue
+      if (otherId === entry.duplicateOf) continue
+      if (!sameFactContext(other.context, nextContext)) continue
+      const similarity = similarTexts(text, `${other.title || ''} ${other.content || ''}`)
+      if (similarity > (duplicate?.similarity ?? 0)) duplicate = { id: otherId, similarity }
+    }
+    if (duplicate && duplicate.similarity >= DUP_REJECT_DICE) {
+      record({
+        kind: 'write', scope: 'private', sessionId: sessionIdOf(exec) || null, libraryId: scope.libraryId,
+        message: '拒绝重复更新：' + id_ + ' 改写后与 ' + duplicate.id + ' 几乎相同',
+        detail: { id: id_, deduped: true, existingId: duplicate.id, similarity: duplicate.similarity },
+        refs: [id_, duplicate.id],
+      })
+      throw new Error(`update refused: the rewritten text is nearly identical to ${duplicate.id} (dice ${duplicate.similarity.toFixed(2)}); merge into ${duplicate.id} or archive one of the two instead`)
+    }
   }
   const route = engineRoute()
   const managed = route === 'managed-local'
+  let committedDb = null
   if ((nextContent !== undefined || managed) && entry.status !== 'pending_review' && status !== 'pending_review') {
     const payload = {
       recall_files: [{
@@ -1467,10 +1816,14 @@ async function privateUpdateImpl({ exec, libraryId, id, content, title, tags, st
       user: {},
     }
     if (route !== 'lexical') {
-      await commit({ payload, route, db: memoryDbPath(scope.libraryId) })
+      const db = memoryDbPath(scope.libraryId)
+      await commit({ payload, route, db })
+      committedDb = db
     }
   }
-  const updated = await retryStoreWrite(() => updatePrivateIndex(scope.libraryId, (fresh) => {
+  let updated
+  try {
+  updated = await retryStoreWrite(() => updatePrivateIndex(scope.libraryId, (fresh) => {
     const target = fresh.entries[id_]
     if (!target) throw new Error(`unknown memory: ${id_}`)
     if (JSON.stringify(target) !== JSON.stringify(entry)) throw new Error('memory changed concurrently; reload and retry')
@@ -1480,6 +1833,18 @@ async function privateUpdateImpl({ exec, libraryId, id, content, title, tags, st
     if (currentBinding) assertScopeEnabled(currentBinding)
     if (title !== undefined) target.title = clampText(title, 120)
     if (nextContent !== undefined) target.content = nextContent
+    // 打标带与 remember 同口径：[0.55, 0.90) 改写后仍与另一条同主题 → duplicateOf。
+    // 旧打标的去留也按同一把尺重新裁定：文本改过、且与新文本最相似的条目不在打标带，
+    // 但原 duplicateOf 对象仍与改写后文本同主题（它被排除在拒绝扫描之外，不代表相似
+    // 消失）→ 保留；否则（相似依据消失，或原指向对象已不可召回）摘除——留着会错误
+    // 压低这条记忆的召回权重。未扫（无文本变化）不动。
+    if (scanned) {
+      const previousHost = target.duplicateOf ? fresh.entries[target.duplicateOf] : null
+      const stillHosted = previousHost && isMemoryEligible(previousHost)
+        && similarTexts(text, `${previousHost.title || ''} ${previousHost.content || ''}`) >= TOPIC_DICE
+      if (duplicate && duplicate.similarity >= TOPIC_DICE) target.duplicateOf = duplicate.id
+      else if (!stillHosted) delete target.duplicateOf
+    }
     if (tags !== undefined) target.tags = Array.isArray(tags) ? tags.slice(0, 20) : target.tags
     if (status !== undefined) target.status = status
     if (openLoop !== undefined) target.openLoop = !!openLoop
@@ -1513,7 +1878,28 @@ async function privateUpdateImpl({ exec, libraryId, id, content, title, tags, st
     if (peak !== undefined) target.peak = peak === true
     if (moodValence !== undefined) target.moodValence = Math.max(-1, Math.min(1, Number(moodValence)))
     if (arousal !== undefined) target.arousal = Math.max(0, Math.min(1, Number(arousal)))
+    // Three states, not two: omitted keeps the stored composition, an explicit null
+    // clears it (and the source becomes "we no longer know"), an object replaces it.
+    // Collapsing null into "keep" would make it impossible to repair a wrong reading.
+    if (emotion !== undefined) {
+      if (emotion === null) {
+        target.emotion = null
+        target.emotionSource = 'unknown'
+        target.moodValence = Number(moodValence) || 0
+      } else {
+        target.emotion = normalizeEmotion(emotion)
+        target.emotionSource = 'model'
+        target.moodValence = derivedValence(target.emotion)
+      }
+    }
+    if (dominance !== undefined) target.dominance = dominance === null ? 0 : Math.max(-1, Math.min(1, Number(dominance)))
     if (nextAttachments !== undefined) target.attachments = nextAttachments
+    // 受管路由下这次更新把这一行重新提交进了当前向量空间（managed 时 commit 无条件发生）。
+    // 戳要跟着刷新：它现在描述的是"这条在当前代际的空间里"，membership 的戳腿靠它计数。
+    if (committedDb) {
+      const vector = activeEntryStamp(route)
+      if (vector) target.vector = vector
+    }
     // Vividness and accuracy are derived, not typed in: correcting the peak flag or
     // the arousal reading has to move `accuracy` too, otherwise the repair would only
     // change how the entry is stored and not how much it is trusted when recalled.
@@ -1552,6 +1938,10 @@ async function privateUpdateImpl({ exec, libraryId, id, content, title, tags, st
     }
     target.updatedAt = stamp()
   }))
+  } catch (error) {
+    if (committedDb) await compensatePrivateCommit(error, { libraryId: scope.libraryId, id: id_, route, db: committedDb, expectedEntry: entry })
+    throw error
+  }
   if (status === 'archived' && !wasArchived) bumpStats(scope.libraryId, 'archived')
   return { id: id_, entry: updated.entries[id_] }
 }
@@ -1569,6 +1959,30 @@ async function resolveMemoryReviewImpl({ libraryId = null, id, action, resolutio
   if (action === 'accept') {
     if (typeof content === 'string' && content.trim()) next.content = content
     if (typeof title === 'string' && title.trim()) next.title = title
+    // 接受即写入（accept 会把这条提交进向量库并转为 active），所以它与 remember /
+    // privateUpdate 过同一道重复门：≥ 0.90 拒绝接受（复核保持
+    // 暂扣，不丢数据——换内容或先归档对方后可重试），[0.55, 0.90) 接受但打 duplicateOf。
+    // 排除它自己和 conflictingWith：后者正是这次复核要替代/共存的对象，与它相似是
+    // 复核的本来含义，不是重复。
+    const text = `${next.title || ''} ${next.content || ''}`
+    let duplicate = null
+    for (const [otherId, other] of Object.entries(index.entries || {})) {
+      if (otherId === id || otherId === entry.conflictingWith) continue
+      if (!isMemoryEligible(other)) continue
+      if (!sameFactContext(other.context, next.context)) continue
+      const similarity = similarTexts(text, `${other.title || ''} ${other.content || ''}`)
+      if (similarity > (duplicate?.similarity ?? 0)) duplicate = { id: otherId, similarity }
+    }
+    if (duplicate && duplicate.similarity >= DUP_REJECT_DICE) {
+      record({
+        kind: 'write', scope: libraryId ? 'private' : 'global', libraryId: libraryId || null,
+        message: '拒绝复核接受：' + id + ' 与 ' + duplicate.id + ' 几乎相同',
+        detail: { id, deduped: true, existingId: duplicate.id, similarity: duplicate.similarity },
+        refs: [id, duplicate.id],
+      })
+      throw new Error(`review accept refused: the accepted text is nearly identical to ${duplicate.id} (dice ${duplicate.similarity.toFixed(2)}); pass different content or archive ${duplicate.id} first`)
+    }
+    if (duplicate && duplicate.similarity >= TOPIC_DICE) next.duplicateOf = duplicate.id
     const reviewRoute = engineRoute()
     if (reviewRoute !== 'lexical') {
       await commit({
@@ -1576,6 +1990,9 @@ async function resolveMemoryReviewImpl({ libraryId = null, id, action, resolutio
         route: reviewRoute,
         db: libraryId ? memoryDbPath(libraryId) : globalDbPath(),
       })
+      // pending_review 从不提交，所以被接受的那一刻才第一次真正进向量库：补上戳，
+      // 否则这条在向量计数里永远缺失。
+      next.vector = activeEntryStamp(reviewRoute) || next.vector
     }
   }
   const mutate = fresh => {
@@ -1695,7 +2112,27 @@ async function privateDeleteImpl({ exec, libraryId, id }) {
   await retryStoreWrite(() => updatePrivateIndex(scope.libraryId, (fresh) => {
     if (JSON.stringify(fresh.entries[id_]) !== JSON.stringify(entry)) throw new Error('memory changed during deletion; reload and retry')
     delete fresh.entries[id_]
+    // Cascade: inbound edges live in *other* entries' links[], so dropping the
+    // row without sweeping them leaves links that point at a memory nothing can
+    // resolve any more (outbound links die with the row itself). In place, O(N
+    // over links) — same style as the unlink mutator, no deep clone. Archived /
+    // suppressed entries keep their links on purpose: only this permanent path
+    // cascades, so archiving stays reversible.
+    for (const other of Object.values(fresh.entries)) {
+      if (Array.isArray(other.links) && other.links.some(link => link.to === id_)) {
+        other.links = other.links.filter(link => link.to !== id_)
+      }
+    }
   }))
+  // Collect entities this row was the last thing keeping alive. Cleanup after
+  // the fact, not a correctness step: if it fails (lock contention, a store
+  // another writer holds) the delete stands, and the startup sweep gets the
+  // orphans on the next launch.
+  try {
+    pruneOrphanEntities(scope.libraryId)
+  } catch (error) {
+    warn(`orphan entity prune after permanent delete skipped: ${error?.message || error}`)
+  }
   return { id: id_, libraryId: scope.libraryId, deleted: true, backend, engine }
 }
 
@@ -1761,22 +2198,27 @@ export function privateUnpin({ exec, id, reason }) {
 
 export async function privateRemember(args) {
   const libraryId = resolveLibrary(args).libraryId
-  const result = await withManagedPrivateWrite(libraryId, () => privateRememberImpl(args))
+  const result = await withManagedPrivateWrite(libraryId, () => privateRememberImpl({ ...args, libraryId }))
+  const deduped = result?.deduped === true
   record({
     kind: 'write',
     scope: 'private',
     sessionId: sessionIdOf(args.exec) || null,
     libraryId,
-    message: '写入 ' + (result?.id || '?') + '：' + clampText(args.title || args.content, 60) + (result?.conflict ? '（待复核）' : ''),
-    detail: { id: result?.id || null, title: args.title || null, layer: args.layer || null, conflict: result?.conflict || null },
-    refs: result?.id ? [result.id] : [],
+    message: deduped
+      ? '拒绝重复写入：与 ' + (result.existingId || '?') + ' 几乎相同'
+      : '写入 ' + (result?.id || '?') + '：' + clampText(args.title || args.content, 60) + (result?.conflict ? '（待复核）' : ''),
+    detail: deduped
+      ? { deduped: true, existingId: result.existingId || null, similarity: result.similarity ?? null }
+      : { id: result?.id || null, title: args.title || null, layer: args.layer || null, conflict: result?.conflict || null },
+    refs: deduped ? [result.existingId] : (result?.id ? [result.id] : []),
   })
   return result
 }
 
 export async function privateUpdate(args) {
   const libraryId = resolveLibrary(args).libraryId
-  const result = await withManagedPrivateWrite(libraryId, () => privateUpdateImpl(args))
+  const result = await withManagedPrivateWrite(libraryId, () => privateUpdateImpl({ ...args, libraryId }))
   record({
     kind: 'write',
     scope: 'private',
@@ -1791,7 +2233,7 @@ export async function privateUpdate(args) {
 
 export async function privateDelete(args) {
   const libraryId = resolveLibrary(args).libraryId
-  const result = await withManagedPrivateWrite(libraryId, () => privateDeleteImpl(args))
+  const result = await withManagedPrivateWrite(libraryId, () => privateDeleteImpl({ ...args, libraryId }))
   record({
     kind: 'write',
     scope: 'private',
@@ -1884,15 +2326,19 @@ export async function globalRecall({ exec, query, topK, relevanceThreshold, retr
       ...f,
       // Local lexical rank is already meaningful; confidence still nudges ties, and
       // a cross-session fact that has been injected three turns running gets the same
-      // wear penalty as a private one.
+      // wear penalty as a private one. `retrieval` mirrors the retrieval term of the
+      // score so the absolute floor cut sees the same number the score was built from.
+      retrieval: Number.isFinite(f.retrievalScore) ? f.retrievalScore : f.lexical > 0 ? f.lexical : 1 / (i + 1),
       score: (Number.isFinite(f.retrievalScore) ? f.retrievalScore : f.lexical > 0 ? f.lexical : 1 / (i + 1))
         * (0.85 + 0.15 * Number(f.entry.confidence ?? 0.5))
         * habituationFactor(f.entry),
     }))
     .sort((a, b) => b.score - a.score)
+  const ranked = mmrSelect(cutWeakScores(filtered, threshold, RETRIEVAL_FLOOR), Number(topK || settings.globalTopK || 3))
   return {
     ...enriched,
-    files: mmrSelect(cutWeakScores(filtered, threshold), Number(topK || settings.globalTopK || 3)),
+    files: ranked.chosen,
+    dedup: { collapsed: ranked.skipped, clusterCount: ranked.skipped.length },
     domain: domainOf(binding),
     unbound: !peeked,
   }