dsh-memu-memory 1.2.0 → 1.2.2

package/lib/text-similarity.js

@@ -0,0 +1,124 @@
+// One ruler for "do these two memories say the same thing".
+//
+// 5: the recall side (candidate folding, MMR hard skip) and the
+// write side (the duplicate gate) must measure with the same formula, or recall
+// folds what write kept and vice versa. Everything here is deliberately
+// dependency-free — two bigram sets and the Dice coefficient — and the text
+// preprocessing is the one the contradiction check always used (lowercase, strip
+// whitespace/punctuation/symbols), so findConflict's behaviour is unchanged by
+// this extraction.
+
+// Same fact: a recall cluster keeps one candidate, MMR hard-skips the rest.
+export const DUP_DICE = 0.82
+// Write-side reject: a new memory this close to an existing one is refused.
+export const DUP_REJECT_DICE = 0.90
+// Same topic, different fact: soft-penalty band on recall, duplicateOf tag on write.
+export const TOPIC_DICE = 0.55
+// Write-side pruning: skip the bigram pass when two texts differ in length by more
+// than this fraction of the longer one. At this ratio Dice cannot reach the reject
+// band even with zero unique bigrams on the short side.
+export const LENGTH_PRUNE_RATIO = 0.5
+
+// Length-disparate pairs (gap > LENGTH_PRUNE_RATIO) do not go through Dice — the
+// ratio math makes a reject-band Dice impossible, which is exactly the hole a
+// "rewrite it much longer" evader walks through. Two cheap containment probes
+// close the hole without paying the full bigram pass:
+//   * verbatim containment — the short cleaned text is a substring of the long one;
+//   * core coverage — every character bigram of the short text occurs somewhere in
+//     the long one ("核心词全含"), probed with String.includes so the long side is
+//     never materialised into a bigram set and a miss fails fast on the first
+//     absent gram.
+// Both are strictly stronger signals than Dice ≥ DUP_REJECT_DICE (a verbatim or
+// all-grams-contained overlap cannot be an accident), so they report a floor in
+// the reject band instead of a made-up Dice value. Partial coverage deliberately
+// reports 0: with a >0.5 length gap there is no honest way to say "same topic",
+// and a false reject on the write side is worse than a rare paraphrase bypass —
+// the residual risk (heavily reworded padding) is documented in 
+export const CONTAINMENT_FLOOR = 0.92
+export const CORE_COVER_FLOOR = DUP_REJECT_DICE
+// Below this many cleaned characters the probe has too little signal (a 4-char
+// string and its bigrams occur in unrelated texts all the time); above the max the
+// probe budget is exceeded and both sides are substantial enough to trust the
+// length prune again. Bounds keep the write-side gate O(|short|·|long|) native
+// scans per pruned pair instead of O(N²) bigram-set construction.
+const PROBE_MIN_CHARS = 6
+const PROBE_MAX_CHARS = 240
+
+/** The one text preprocessing every measurement here shares. */
+export function clean(text) {
+  return String(text || '').toLowerCase().replace(/[\s\p{P}\p{S}]+/gu, '')
+}
+
+/** Lowercase, strip whitespace/punctuation/symbols, then collect character bigrams. */
+export function bigrams(text) {
+  const c = clean(text)
+  const out = new Set()
+  for (let i = 0; i < c.length - 1; i += 1) out.add(c.slice(i, i + 2))
+  return out
+}
+
+/** Dice coefficient over two bigram sets; 0 when either side is empty. */
+export 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)
+}
+
+/** |len(A)-len(B)| / max(len); 0 when both sides are empty. */
+export function lengthGap(aText, bText) {
+  const a = String(aText || '').length
+  const b = String(bText || '').length
+  return Math.abs(a - b) / Math.max(a, b, 1)
+}
+
+/**
+ * The full probe result behind similarTexts. `dice` is the plain bigram Dice
+ * when the pair is length-comparable; when the length prune fires, `dice` is 0
+ * and `containment` carries whichever probe (verbatim CONTAINMENT_FLOOR or
+ * core-coverage CORE_COVER_FLOOR) closed the hole, else 0. `lengthGap` is the
+ * raw length ratio the prune decision was made on.
+ *
+ * similarTexts stays `max(dice, containment)` — call sites that need to know
+ * *why* two texts matched read the fields instead of reverse-engineering the
+ * max (the curator pair features keep "verbatim containment" apart from "high
+ * Dice" so the §4.8 conflict carve-outs can tell duplication from rewriting).
+ */
+export function similarityDetail(aText, bText) {
+  const a = String(aText || '')
+  const b = String(bText || '')
+  const gap = lengthGap(a, b)
+  if (gap > LENGTH_PRUNE_RATIO) {
+    const aClean = clean(a)
+    const bClean = clean(b)
+    if (!aClean || !bClean) return { dice: 0, containment: 0, lengthGap: gap }
+    const shortClean = aClean.length <= bClean.length ? aClean : bClean
+    const longClean = aClean.length <= bClean.length ? bClean : aClean
+    if (shortClean.length < PROBE_MIN_CHARS || shortClean.length > PROBE_MAX_CHARS) {
+      return { dice: 0, containment: 0, lengthGap: gap }
+    }
+    // Probe 1: verbatim containment of the short text inside the long one.
+    if (longClean.includes(shortClean)) return { dice: 0, containment: CONTAINMENT_FLOOR, lengthGap: gap }
+    // Probe 2: core coverage — every bigram of the short text occurs in the long
+    // one; includes() over the cleaned long text is exactly long-bigram-set
+    // membership, so no long-side set is ever built.
+    for (let i = 0; i < shortClean.length - 1; i += 1) {
+      if (!longClean.includes(shortClean.slice(i, i + 2))) return { dice: 0, containment: 0, lengthGap: gap }
+    }
+    return { dice: 0, containment: CORE_COVER_FLOOR, lengthGap: gap }
+  }
+  return { dice: dice(bigrams(a), bigrams(b)), containment: 0, lengthGap: gap }
+}
+
+/**
+ * Dice over raw texts with the write-side length pruning applied: pairs whose
+ * lengths differ too much return 0 without paying for the bigram build (the
+ * gate runs over the whole library on every write). 0 can never win a
+ * max-similarity scan, so pruned pairs simply never become the best match —
+ * unless they hit one of the two containment probes below, which are the only
+ * way a length-disparate pair reaches the reject band.
+ */
+export function similarTexts(aText, bText) {
+  const detail = similarityDetail(aText, bText)
+  return Math.max(detail.dice, detail.containment)
+}

package/lib/tools.js

@@ -7,7 +7,9 @@ import {
 import { engineStatus, ENGINE_VERSION } from './engine.js'
 import { centeredSnippet } from './snippet.js'
 import { redactSecrets } from './paths.js'
-import { linkEntries, createEntity, updateRelationship } from './graph.js'
+import { linkEntries, createEntity, listEntities, updateRelationship } from './graph.js'
+import { normalizeEntityName } from './private-links.js'
+import { autoLinkPrivateMemories } from './private-links.js'
 import { getSettings, listLibraries, getLibrary, loadPrivateIndex, loadGlobalIndex, storageHealth, syncActivity } from './state.js'
 
 function text(value) {
@@ -33,6 +35,19 @@ function errorText(error) {
   return `dsh-memu-memory error: ${message}`
 }
 
+// 词典核心（lib/lexicon.js）按需加载：工具注册面不能被一个
+// 尚未落地的模块卡死；集成落地后这里可以改回静态 import。
+let lexiconModulePromise = null
+function lexiconApi() {
+  if (!lexiconModulePromise) {
+    lexiconModulePromise = import('./lexicon.js').catch((error) => {
+      lexiconModulePromise = null
+      throw error
+    })
+  }
+  return lexiconModulePromise
+}
+
 // Registration is per-tool fail-open. defineTool compiles the schema the moment it
 // is called, and the first throw used to abort registerTools() before a single
 // register() ran — so one schema the host DSL rejects silently removed all ten
@@ -162,19 +177,23 @@ function formatGlobalItem(item, index, options = {}) {
   return lines.join('\n')
 }
 
-export function registerTools(ctx) {
+export function registerTools(ctx, { only = null } = {}) {
   const tools = []
-  registrationReport = { attempted: 0, registered: 0, failures: [] }
+  // 全量注册（宿主装载）才更新全局 registrationReport：整理 worker 的按需挂载
+  // （private.js attachWorkerTools，only=worker 读写面）不能把 memu_status 的注册清单
+  // 覆盖成 4/4，否则其它会话看到的是 worker 的子集，可观测性就断了。
+  const reportSaved = only ? registrationReport : null
+  if (!only) registrationReport = { attempted: 0, registered: 0, failures: [] }
   tools.push(toolBase(
     'memu_private_link',
-    'Connect two existing memories or a memory and an existing entity in the bound library. kind is relation, commitment, event, person or conflict. Requires an evidence note of 8-500 characters; confidence defaults to 0.7. Cannot delete links or cross conversation visibility boundaries.',
+    'Connect two existing memories or a memory and an existing entity in the bound library. kind is relation, commitment, event, person or conflict. Requires an evidence note of 8-500 characters; confidence defaults to 0.7. This is also the adjudication tool for memu_private_link_suggest candidates: link a pair only when the note cites concrete evidence of the same entity or event, and pass entity {name, kind} to create or reuse that named entity. Cannot delete links or cross conversation visibility boundaries.',
     {
       from: { type: 'string', description: 'Exact source memory id; required unless updating a relationship snapshot.' },
       to: { type: 'string', description: 'Exact target memory or entity id; required unless entity or relationship is supplied.' },
       kind: { type: 'string', description: 'relation, commitment, event, person or conflict; required when linking.' },
-      note: { type: 'string', required: true, description: '8-500 character reason grounded in the conversation, not a guess.' },
+      note: { type: 'string', required: true, description: '8-500 character reason grounded in the conversation, not a guess. For a memu_private_link_suggest candidate, quote the transcript line that proves the same entity or event.' },
       confidence: { type: 'number', description: '0-1 confidence, default 0.7.' },
-      entity: { type: 'object', properties: { name: { type: 'string' }, kind: { type: 'string' } }, additionalProperties: true, description: 'Optional named entity to create and link to instead of to. Use only an explicit identity, never infer a person from an ambiguous pronoun.' },
+      entity: { type: 'object', properties: { name: { type: 'string' }, kind: { type: 'string' } }, additionalProperties: true, description: 'Optional named entity to create and link to instead of to; an entity with the same normalized name is reused (case/width-insensitive). Use only an explicit identity, never infer a person from an ambiguous pronoun.' },
       relationship: { type: 'object', properties: {
         fromEntity: { type: 'string' }, toEntity: { type: 'string' },
         evidenceIds: { type: 'array', items: { type: 'string' } },
@@ -187,17 +206,64 @@ export function registerTools(ctx) {
         const relation = args.relationship
         return JSON.stringify(updateRelationship({ exec, fromId: relation.fromEntity, toId: relation.toEntity, state: relation.state, evidenceIds: relation.evidenceIds, reason: args.note }))
       }
-      const toId = args.entity ? createEntity({ exec, name: args.entity.name, kind: args.entity.kind || 'person' }).id : args.to
+      let toId = args.to
+      if (args.entity) {
+        const name = String(args.entity.name || '').trim()
+        const kind = args.entity.kind || 'person'
+        const normalized = normalizeEntityName(name)
+        const existing = listEntities({ exec }).items.find((item) => normalizeEntityName(item.name) === normalized
+          || (Array.isArray(item.aliases) && item.aliases.some((alias) => normalizeEntityName(alias) === normalized)))
+        if (existing) {
+          if (existing.kind !== kind) throw new Error(`entity "${name}" already exists as ${existing.kind}; use that kind instead of ${kind}`)
+          toId = existing.id
+        } else {
+          toId = createEntity({ exec, name, kind }).id
+        }
+      }
       return JSON.stringify(linkEntries({ exec, fromId: args.from, toId, kind: args.kind, note: args.note, confidence: args.confidence }))
     },
   ))
 
+  tools.push(toolBase(
+    'memu_private_link_suggest',
+    'Local algorithm pass over the memories this consolidation just wrote. It applies the high-confidence memory↔memory links and entity hubs itself and returns ONLY the uncertain candidate pairs for you to adjudicate with memu_private_link. Call it once after writing, with the ids you created or updated; it needs no extra transcript read and never returns full memory bodies.',
+    {
+      ids: {
+        type: 'array',
+        items: { type: 'string' },
+        // 宿主 schema DSL 不允许在数组节点上写 required（与 tags/aliases 同），
+        // 所以"必填"由描述 + 运行时校验表达，schema 面只能标成可选。
+        description: 'Required: ids created or updated in this consolidation, 1-20. Only the entries this run touched need to be listed.',
+      },
+    },
+    async (args, exec) => {
+      // Read-only for the binding itself: an unbound chat gets an answer, not a library.
+      const binding = peekBinding(exec)
+      if (!binding?.libraryId) return '当前对话没有绑定记忆库，无法计算私有自动关联候选。'
+      const ids = (Array.isArray(args.ids) ? args.ids : [])
+        .map((id) => String(id ?? '').trim())
+        .filter(Boolean)
+        .slice(0, 20)
+      if (!ids.length) return '没有可关联的 id：请传本轮创建/更新的记忆 id（1-20 个）。'
+      const result = await autoLinkPrivateMemories({
+        libraryId: binding.libraryId,
+        sessionId: sessionIdOf(exec),
+        ids,
+      })
+      // Compact contract: what was already linked, then the uncertain pairs. A run
+      // with no candidates still reports autoLinked so "nothing applied" and
+      // "nothing needed" stay distinguishable.
+      return JSON.stringify({ autoLinked: result.autoLinked || [], candidates: result.candidates || [] })
+    },
+    { isConcurrencySafe: () => false, timeoutMs: 120_000 },
+  ))
+
   tools.push(toolBase(
     'memu_private_remember',
     'Write one useful private memory in the bound library. Match the domain: engineering facts, logic and verification in coding; grounded in-character experiences in RP; neutral facts and preferences in general. Do not copy a transcript or invent evidence. layer=must_remember requires pin_reason and pin_source (user_explicit, side_event, self).',
     {
       content: { type: 'string', required: true, description: 'Self-contained content appropriate to the domain. Coding: conclusion, scope/symbol, logic/conditions and verification; preserve necessary minimal code exactly. RP: an evidenced moment and its effect on later interaction, without invented facts.' },
-      title: { type: 'string', description: 'Short title; defaults to the content.' },
+      title: { type: 'string', description: '8-40 characters. This title is a permanent index: the anchor and turn recall show it WITHOUT the body, so it must name the concrete fact — people/objects/events or the conclusion keywords ("Yuike 名字来自小时候的白猫", "Postgres 连接池上限改为 40"). Never an empty label like "一些事" / "那段对话" / "关于XX的事"; the details belong in content. Defaults to the content when omitted.' },
       layer: { type: 'string', description: 'long_term (default), short_term, or must_remember. short_term is a draft with a deadline: it expires after shortTermTtlHours unless promoted to long_term before then. Use it for what only has to survive this stretch of conversation.' },
       pin_reason: { type: 'string', description: 'Required for must_remember; first-person reason.' },
       pin_source: { type: 'string', description: 'user_explicit, side_event, or self.' },
@@ -223,6 +289,7 @@ export function registerTools(ctx) {
       },
       dominance: { type: 'number', description: '谁在掌控：-1 完全失控 … +1 完全掌控。省略=继承当前会话。' },
       peak: { type: 'boolean', description: 'A high point or low point of the arc — peaks and endings stay easier to recall.' },
+      allow_duplicate: { type: 'boolean', description: 'Only for two genuinely independent observations of the same fact (e.g. the same event recorded twice in one day). The default false refuses a near-identical rewrite and returns the existing memory id; passing true states you looked at that existing memory and still want a separate entry.' },
       salient_date: { type: 'string', description: 'MM-DD for something that comes back every year (a birthday, an anniversary of an event); it resurfaces on that day each year. YYYY-MM-DD for a one-off dated commitment or appointment: it is raised the day before and on the day itself, and never again after it has passed. Use the annual form only when the day really does recur. A relative day (今天/明天/后天/today/tomorrow) must be resolved to the absolute date it points at: sending a bare MM-DD turns one appointment into a yearly reminder. If the content itself names a date, pass it here too: when this field is empty the plugin only falls back to a single unambiguous YYYY-MM-DD found in the text.' },
       track: { type: 'string', description: 'memory (default) or habit for an aggregated expression/sticker habit; do not write one habit per occurrence.' },
       attachments: { type: 'array', items: { type: 'object', properties: { sha256: { type: 'string', required: true } }, additionalProperties: true }, description: 'At most 8 sha256 references received in this conversation. Never supply paths or bytes. Ordinary image memories default to short_term if layer is omitted; choose long_term explicitly only when important.' },
@@ -259,7 +326,16 @@ export function registerTools(ctx) {
         dominance: args.dominance ?? null,
         peak: args.peak === true,
         salientDate: args.salient_date ?? null,
+        allowDuplicate: args.allow_duplicate === true,
       })
+      // 事实级去重：几乎相同的重写被拒，返回的是
+      // { deduped, existingId, hint }，没有 entry——必须先接住，否则 result.entry.layer 抛错。
+      if (result.deduped === true) {
+        return [
+          `未写入：库内已有几乎相同的记忆 [${result.existingId}]（相似度 ${(Number(result.similarity) || 0).toFixed(2)}）。`,
+          `要补充内容请改用 memu_private_update 传该 id 合并；若确属两次独立观测，带 allow_duplicate=true 重写。`,
+        ].join('\n')
+      }
       const entry = result.entry
       if (result.conflict) {
         // The entry is held (pending_review): it is stored, but excluded from
@@ -326,11 +402,11 @@ export function registerTools(ctx) {
 
   tools.push(toolBase(
     'memu_private_update',
-    'Update a private memory in the bound library. Changing content rewrites the memory in MemU; metadata-only changes stay local.',
+    'Update a private memory in the bound library. Changing content rewrites the memory in MemU; metadata-only changes stay local. If the new content covers more than the old title says, rewrite the title under the same rule.',
     {
       id: { type: 'string', required: true, description: 'Memory id.' },
       content: { type: 'string', description: 'New body.' },
-      title: { type: 'string' },
+      title: { type: 'string', description: 'New title under the same rule as memu_private_remember.title: 8-40 characters that name the concrete fact (people/objects/events or conclusion keywords), because the anchor shows only titles. Never an empty label like "关于XX的事"; details stay in content. Omit to keep the current title.' },
       tags: { type: 'array', items: { type: 'string' } },
       status: { type: 'string', description: 'active, archived, fragment, suppressed, or expired.' },
       layer: { type: 'string', description: 'long_term to promote a short_term draft once it has proven worth keeping, or short_term to re-arm the deadline. must_remember needs a pin_reason and is only writable through memu_private_remember.' },
@@ -396,6 +472,101 @@ export function registerTools(ctx) {
     },
   ))
 
+  tools.push(toolBase(
+    'memu_lexicon_search',
+    'Search the ACTIVE lexicon (user-coined slang, memes, triggers and terms) of the library bound to this conversation; archived entries are excluded. Read-only. When a user-coined word or phrase appears and you are not sure what it means, look it up here before asking or guessing; returns term → meaning/usage with short evidence.',
+    {
+      query: { type: 'string', required: true, description: 'The word or phrase to look up. Exact term/alias match first with a bounded fuzzy fallback; short queries work best.' },
+    },
+    async (args, exec) => {
+      // Read-only: never materialize a binding or a library from a lexicon query,
+      // same rule as memu_private_recall.
+      const binding = peekBinding(exec)
+      if (!binding?.libraryId) return '当前对话没有绑定记忆库，无法查询词典。请先初始化或绑定记忆库。'
+      const lexicon = await lexiconApi()
+      const hits = await lexicon.searchLexicon(
+        { libraryId: binding.libraryId, query: String(args.query || ''), memoryContext: binding.memoryContext || {} },
+        { includeArchived: false },
+      )
+      const rows = (Array.isArray(hits) ? hits : []).map((hit) => (hit?.entry && typeof hit.entry === 'object' ? hit.entry : hit))
+      if (!rows.length) return `词典（library=${binding.libraryId}）没有命中「${truncate(args.query, 80)}」。`
+      const lines = [`词典命中（library=${binding.libraryId}，${rows.length} 条）`]
+      for (const [index, e] of rows.entries()) {
+        const evidence = (Array.isArray(e.evidence) ? e.evidence : []).slice(0, 2)
+          .map((item) => String(item?.quote || item?.id || '')).filter(Boolean).join(' / ')
+        lines.push([
+          `${index + 1}. [${e.term || '?'}] kind=${e.kind || 'term'} status=${e.status || 'active'}`,
+          `   meaning=${truncate(e.meaning, 300)}`,
+          e.usage ? `   usage=${truncate(e.usage, 200)}` : '',
+          evidence ? `   evidence=${truncate(evidence, 200)}` : '',
+        ].filter(Boolean).join('\n'))
+      }
+      return lines.join('\n')
+    },
+    { isConcurrencySafe: () => true },
+  ))
+
+  tools.push(toolBase(
+    'memu_lexicon_propose',
+    'Write one lexicon entry (slang / meme / term) for the library bound to this conversation. The entry becomes ACTIVE immediately: there is no pending state and no human review, and it is injected from the next turn. term is the index key, meaning is the explanation. Search first with memu_lexicon_search and propose only what this conversation evidences, one entry per term. Sensitive triggers cannot be created or updated by the model — those stay user-managed. There is no lexicon delete from the model side.',
+    {
+      term: { type: 'string', required: true, description: 'The index key / title of the entry: short, stable, spelled the way the user actually writes it (normally 1-12 characters, at most a short phrase). Not a sentence and not the explanation — that goes in meaning.' },
+      kind: { type: 'string', required: true, description: 'slang, meme, trigger, or term. trigger is rejected here: sensitive triggers are user-managed.' },
+      meaning: { type: 'string', required: true, description: 'The explanation of term: what it means in this library, in one or two sentences.' },
+      usage: { type: 'string', description: 'When or how the word is used.' },
+      aliases: { type: 'array', items: { type: 'string' }, description: 'Alternative spellings or short forms, at most 20.' },
+      examples: { type: 'array', items: { type: 'string' }, description: 'Short real quotes from this conversation showing the usage, at most 8. Never invent quotes.' },
+      evidence: { type: 'array', items: { type: 'object', properties: { kind: { type: 'string' }, id: { type: 'string' }, quote: { type: 'string' } }, additionalProperties: true }, description: 'Where the meaning came from: short quotes with stable ids only, no full transcripts.' },
+      confidence: { type: 'number', description: '0-1; how sure you are of the meaning. Use it honestly — it sets the entry display strength.' },
+    },
+    async (args, exec) => {
+      const binding = peekBinding(exec)
+      if (!binding?.libraryId) return '当前对话没有绑定记忆库，无法写入词条。请先初始化或绑定记忆库。'
+      const lexicon = await lexiconApi()
+      let result
+      try {
+        result = await lexicon.upsertLexiconTerm({
+          libraryId: binding.libraryId,
+          term: args.term,
+          kind: args.kind,
+          meaning: args.meaning,
+          usage: args.usage,
+          aliases: args.aliases,
+          examples: args.examples,
+          // 词条继承当前会话的场景身份；没有场景就是空 context（全场景可见）。
+          context: binding.memoryContext || {},
+          evidence: args.evidence,
+          confidence: args.confidence,
+          // 来源固定 model-proposal；普通词条直接 active（§2.1），sensitive trigger 由
+          // 核心层 typed 拒绝。
+          source: 'model-proposal',
+        })
+      } catch (error) {
+        // typed rejection 翻译：sensitive trigger 不允许模型写入是核心层的硬规则，
+        // 原始错误码对模型没有行动价值，翻成"该让用户做什么"。
+        const code = String(error?.code || '')
+        const message = String(error?.message || error)
+        if (/sensitive/i.test(code) || (/sensitive/i.test(message) && /trigger/i.test(message))) {
+          return '未写入：sensitive trigger 不能由模型写入或修改。这类触发词请让用户在词典页手动添加。'
+        }
+        throw error
+      }
+      // 核心返回 { term: 词条对象(含 termId), created, notOwned? }。
+      const termLabel = result?.term && typeof result.term === 'object' ? String(result.term.term || args.term) : String(result?.term || args.term)
+      if (result?.created === false) {
+        // 没新建：要么词条归用户（归档/墓碑/草稿），要么同名 active 词条被原地更新。
+        if (result?.notOwned === true) {
+          return `未改动：词条「${termLabel}」已归档或归用户管理，模型不能覆盖它。如需恢复或编辑请让用户在词典页操作。`
+        }
+        return `已更新现有生效词条「${termLabel}」（status=active）；若字段与原来一致则等于没变。sensitive trigger 只能由用户手动管理。`
+      }
+      return [
+        `已写入词条「${termLabel}」（status=active，下一回合起参与注入）。`,
+        '词条已自动生效，无需用户审核；sensitive trigger 只能由用户手动添加。',
+      ].join('\n')
+    },
+  ))
+
   tools.push(toolBase(
     'memu_global_recall',
     'Retrieve cross-session global memories applicable to the current domain. Global memory is read-only for the main agent.',
@@ -501,17 +672,60 @@ export function registerTools(ctx) {
     { isConcurrencySafe: () => true },
   ))
 
-  const usable = tools.filter((tool) => tool)
-  registrationReport.registered = usable.length
-  if (registrationReport.failures.length > 0) {
+  // 整理 worker 的挂载面（private.js 的 fork 兼容）：只挂 WORKER_WRITE_TOOLS +
+  // WORKER_READ_TOOLS（记忆读写 + 关联裁决/候选 + 词典检索/写入），不把
+  // archive/delete/unpin 这些破坏性工具暴露给一个后台子会话。
+  const wanted = Array.isArray(only) && only.length > 0 ? only : null
+  const usable = tools.filter((tool) => tool && (!wanted || wanted.includes(tool.name)))
+  if (only) {
+    registrationReport = reportSaved
+    if (usable.length !== wanted.length) {
+      try {
+        ctx?.logger?.warn?.(`dsh-memu-memory: worker tool mount compiled ${usable.length}/${wanted.length}: ${wanted.join(', ')}`)
+      } catch {}
+    }
+  } else {
+    registrationReport.registered = usable.length
+    if (registrationReport.failures.length > 0) {
+      try {
+        ctx?.logger?.warn?.(`dsh-memu-memory: host schema DSL refused ${registrationReport.failures.length} of ${registrationReport.attempted} tools: ${registrationReport.failures.map((failure) => `${failure.name} (${failure.message})`).join('; ')}`)
+      } catch {}
+    }
+  }
+  // register 这一步也逐件 fail-open（与 toolBase 的编译 fail-open 同一哲学）：宿主
+  // 注册表拒一件（重名、scope 锁定）不能掀翻整组挂载——原来的 `.map()` 一件抛错就连
+  // 前面已注册成功的 disposer 一起丢掉，在 worker scope 上留下卸不掉的常驻注册。
+  const disposers = []
+  const attached = []
+  const refused = []
+  for (const tool of usable) {
+    try {
+      const dispose = ctx.tools.register(tool)
+      disposers.push(typeof dispose === 'function' ? dispose : null)
+      attached.push(tool.name)
+    } catch (error) {
+      refused.push(`${tool.name} (${String(error?.message || error)})`)
+      // 全量装载（宿主）才进 registrationReport：memu_status 的 refused 清单要如实反映
+      // 编译 + register 两道关都被拒了谁；worker 的按需挂载照旧不碰全局报告。
+      if (!only) registrationReport.failures.push({ name: tool.name, message: String(error?.message || error) })
+    }
+  }
+  if (refused.length > 0) {
+    if (!only) registrationReport.registered = attached.length
     try {
-      ctx?.logger?.warn?.(`dsh-memu-memory: host schema DSL refused ${registrationReport.failures.length} of ${registrationReport.attempted} tools: ${registrationReport.failures.map((failure) => `${failure.name} (${failure.message})`).join('; ')}`)
+      ctx?.logger?.warn?.(`dsh-memu-memory: tool mount refused ${refused.length}/${usable.length} at register: ${refused.join('; ')}`)
     } catch {}
   }
-  const disposers = usable.map((tool) => ctx.tools.register(tool))
-  return () => {
+  // 返回值仍是可直接调用的 disposer（private.js attachWorkerTools 与宿主装载都这么用），
+  // 但附挂结构化名单：attached = 编译 + register 都真正成功的工具名；requested = 请求
+  // 名单（宿主全量装载没有 only，为 null）。部分编译/注册失败时调用方据此写活动日志，
+  // 不再把 wanted 全量误报成已挂载。
+  const disposeAll = () => {
     for (const dispose of disposers) {
       try { dispose?.() } catch {}
     }
   }
+  disposeAll.attached = attached
+  disposeAll.requested = wanted
+  return disposeAll
 }

package/lib/vector-migration.js

@@ -849,8 +849,13 @@ export function createVectorMigrator(options = {}) {
     ledger: readLedger,
     /**
      * 当前生效代际里"哪些 id 已经写进向量库"（按 scope key：libraryId 或 'global'）。
-     * 迁移写库时刻意不碰索引，所以索引里的老条目没有 entry.vector 戳；界面要回答
-     * "这条在不在向量库"只能查账本。
+     * 两条腿合成，缺一都会数错：
+     *   * 账本腿：迁移写库时刻意不碰索引，所以迁移写入的条目没有 entry.vector 戳，
+     *     只能查账本。但永久删除（forget）只删引擎行和索引行、不动账本，所以账本里的
+     *     id 还要扣掉"索引里已经没有的"（删掉的条目必然已从索引移除）。
+     *   * 戳腿：迁移之后的写入（remember/import/review/update/curator）在索引条目上带
+     *     entry.vector 戳。只认当前代际的戳 —— 旧代际的戳说明它属于旧空间，是否还在
+     *     当前空间由账本腿回答（切代际会把当时可准入的条目全部重写一遍并记账）。
      */
     membership: () => {
       const state = vectorState()
@@ -858,10 +863,30 @@ export function createVectorMigrator(options = {}) {
       if (!active) return null
       const ledger = readLedger({ fingerprint: active.fingerprint, generation: active.generation })
       if (!ledger) return null
+      const generation = Number(active.generation)
       const out = {}
       for (const scope of scopesFor(active.databases)) {
         const bucket = ledger.libraries?.[scope.key]
-        out[scope.key] = bucket?.items && typeof bucket.items === 'object' ? Object.keys(bucket.items) : []
+        const migrated = bucket?.items && typeof bucket.items === 'object' ? Object.keys(bucket.items) : []
+        let entries = null
+        try {
+          const loaded = impl.loadIndex(scope.libraryId)
+          // loadIndex 的约定是同步读盘；拿到 Promise（测试替身）时按读不到处理，不猜。
+          entries = loaded && typeof loaded.then === 'function' ? null : (loaded?.entries || {})
+        } catch { entries = null }
+        const ids = new Set()
+        for (const id of migrated) {
+          // 索引读不出来时宁可贵一点按"还在"算：损坏是暂时的，误扣会让用户以为记忆丢了。
+          if (!entries || Object.prototype.hasOwnProperty.call(entries, id)) ids.add(id)
+        }
+        if (entries) {
+          for (const [id, entry] of Object.entries(entries)) {
+            // remote-api 的戳描述的是远端空间，不属于本地代际；词法路径没有戳。
+            if (!entry || typeof entry !== 'object' || entry.vector?.route !== 'managed-local') continue
+            if (Number(entry.vector.generation) === generation) ids.add(id)
+          }
+        }
+        out[scope.key] = [...ids]
       }
       return out
     },

package/lib/vector-profile.js

@@ -522,6 +522,30 @@ export function activeGeneration() {
   return state?.active?.generation ?? null
 }
 
+/**
+ * 条目级"已入向量库"戳（entry.vector）。迁移写库故意不碰索引，所以迁移写入的条目没有
+ * 戳、只有账本知道；而迁移之后的每一次向量写入（remember/import/review/update/curator）
+ * 都必须在提交成功后把这条戳落进索引。词法路径没写库，不戳；remote-api 沿用历史口径
+ * （本地还留着 active 代际时照样记，界面只拿它回答"进没进向量后端"）。空间归属由
+ * membership() 的戳腿自行过滤：只认 route === 'managed-local' 且代际匹配的戳。只读不抛错。
+ */
+export function activeEntryStamp(route) {
+  if (route === 'lexical') return null
+  try {
+    const active = readVectorState({ tolerateMissing: true }).state?.active
+    if (!active) return null
+    return {
+      route,
+      model: active.profile?.catalogId || null,
+      generation: active.generation,
+      fingerprint: String(active.fingerprint || '').slice(0, 8),
+      at: stamp(),
+    }
+  } catch {
+    return null
+  }
+}
+
 /** active manifest 里的 DB 集合，一次性取得（避免多库逐个换混空间）。 */
 export function activeDatabases() {
   return databaseMapFor(vectorState()?.active)

package/lib/webui/standalone.css

@@ -1146,3 +1146,20 @@ html[data-standalone] .dshm-wall-graph {
 }
 
 html[data-standalone] .dshm-relation-field textarea{border-radius:12px;border-color:var(--dshm-line-strong);background:var(--dshm-field);padding:9px 11px;font-size:13px;color:inherit}
+
+/* The standalone field rules set `background` (a shorthand) with !important, so
+   the generic chevron in client.js was being erased. Keep the theme fill and add
+   the chevron in one place for every select in this shell. */
+html[data-standalone] .dshm-root select {
+  padding-right: 36px !important;
+  background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='10' height='6' viewBox='0 0 10 6'%3E%3Cpath d='M1 1l4 4 4-4' fill='none' stroke='%23808a99' stroke-width='1.5' stroke-linecap='round' stroke-linejoin='round'/%3E%3C/svg%3E") !important;
+  background-repeat: no-repeat !important;
+  background-position: right 14px center !important;
+  background-size: 10px 6px !important;
+}
+html[data-standalone] .dshm-root select:focus {
+  background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='10' height='6' viewBox='0 0 10 6'%3E%3Cpath d='M1 1l4 4 4-4' fill='none' stroke='%23808a99' stroke-width='1.5' stroke-linecap='round' stroke-linejoin='round'/%3E%3C/svg%3E") !important;
+  background-repeat: no-repeat !important;
+  background-position: right 14px center !important;
+  background-size: 10px 6px !important;
+}

package/lib/webui/standalone.js

@@ -23,10 +23,12 @@
     zh: {
       engine: '引擎与连接', settings: '记忆设置', folders: '文件夹', libraries: '记忆库',
       browser: '记忆浏览', global: '全局记忆', prompts: '提示词', stats: '统计', memories: '记忆总览',
+      lexicon: '词典', help: '帮助',
     },
     en: {
       engine: 'Engine & connection', settings: 'Memory settings', folders: 'Folders', libraries: 'Libraries',
       browser: 'Memory browser', global: 'Global memory', prompts: 'Prompts', stats: 'Stats', memories: 'Memories',
+      lexicon: 'Lexicon', help: 'Help',
     },
   }
   var copy = COPY[locale]

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-memu-memory",
   "icon": "./assets/icon.png",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "面向长篇 RP 与陪伴对话的 DeepSeek Harness 记忆插件：三层记忆、逐轮召回、来源标注、关系图、图片附件与独立 WebUI。",
   "keywords": [
     "deepseek-harness",
@@ -61,7 +61,8 @@
     "check": "node scripts/check-all.mjs",
     "setup": "node scripts/setup.mjs",
     "test": "node --import ./tests/loader-register.mjs --test tests/*.test.mjs",
-    "test:chain": "node scripts/chain-matrix.mjs"
+    "test:chain": "node scripts/chain-matrix.mjs",
+    "replay": "node --import ./tests/loader-register.mjs scripts/replay.mjs"
   },
   "engines": {
     "node": ">=20.9.0",

package/scripts/acceptance-local.mjs

@@ -294,7 +294,10 @@ await auto('B-4', 'a Chinese anchor lands inside its token budget', async () =>
   const anchor = inject.buildAnchor(binding, settings, null)
   const tokens = budget.estTokens(anchor.text)
   const target = Number(settings.anchorTokens || 700)
-  const low = Math.floor(target * 0.85)
+  // Title cards spend less than the old full-text cards: the invariant is that the
+  // anchor never exceeds its budget and still renders a useful block, not that it
+  // fills the budget to 85%.
+  const low = Math.min(120, target)
   const high = target
   assert.ok(tokens >= low && tokens <= high,
     'estimated ' + tokens + ' tokens, wanted ' + low + '..' + high + ' for a ' + target + ' budget')
@@ -858,16 +861,16 @@ await auto('H-4', 'a contradiction is held back until someone settles it', async
   return 'same-title conflict held, accepted, and rejected'
 })
 
-await auto('H-5', 'a memory on the tip of the tongue arrives without its body', async () => {
+await auto('H-5', 'a memory on the tip of the tongue arrives as a title without its body', async () => {
   const lib = makeLibrary('h5')
   const long = '那年夏天我们在旧办公室最后一晚把所有抽屉清空，有人把钥匙挂在门框上，谁也没说要走，但所有人都知道第二周不会再来。'
   // Not must_remember: a pinned memory is never on the tip of the tongue by design.
   seed(lib.id, 'mem-h5a', { layer: 'long_term', title: 'the last night', content: long, confidence: 0.4 })
   const anchor = inject.buildAnchor({ libraryId: lib.id }, state.getSettings(), null)
-  assert.ok(anchor.text.includes('只记得大概'), 'it says up front that only the gist is left')
+  assert.ok(anchor.text.includes('the last night'), 'the title is the directory entry')
   assert.ok(anchor.text.includes('mem-h5a'), 'and points at the id so a recall can finish the job')
-  assert.ok(!anchor.text.includes('第二周不会再来'), 'while withholding the tail of the text')
-  return 'gist only, id included'
+  assert.ok(!anchor.text.includes('第二周不会再来'), 'while withholding the body')
+  return 'title only, id included'
 })
 await auto('H-6', 'a held claim is visible in the browser, with its library named', async () => {
   const lib = makeLibrary('h6')