dsh-memu-memory 1.2.1 → 1.2.2

package/lib/text-similarity.js

@@ -73,34 +73,52 @@ export function lengthGap(aText, bText) {
 }
 
 /**
- * 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.
+ * 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 similarTexts(aText, bText) {
+export function similarityDetail(aText, bText) {
   const a = String(aText || '')
   const b = String(bText || '')
-  if (lengthGap(a, b) > LENGTH_PRUNE_RATIO) {
+  const gap = lengthGap(a, b)
+  if (gap > LENGTH_PRUNE_RATIO) {
     const aClean = clean(a)
     const bClean = clean(b)
-    if (!aClean || !bClean) return 0
+    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 0
+    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 CONTAINMENT_FLOOR
+    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 (a hit means the two characters are adjacent somewhere in the
-    // long text), so no long-side set is ever built; the first absent gram ends
-    // the probe.
+    // 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 0
+      if (!longClean.includes(shortClean.slice(i, i + 2))) return { dice: 0, containment: 0, lengthGap: gap }
     }
-    return CORE_COVER_FLOOR
+    return { dice: 0, containment: CORE_COVER_FLOOR, lengthGap: gap }
   }
-  return dice(bigrams(a), bigrams(b))
+  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
@@ -165,20 +180,20 @@ function formatGlobalItem(item, index, options = {}) {
 export function registerTools(ctx, { only = null } = {}) {
   const tools = []
   // 全量注册（宿主装载）才更新全局 registrationReport：整理 worker 的按需挂载
-  // （private.js attachWorkerTools，only=读写四件）不能把 memu_status 的注册清单
+  // （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' } },
@@ -191,17 +206,64 @@ export function registerTools(ctx, { only = null } = {}) {
         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.' },
@@ -340,11 +402,11 @@ export function registerTools(ctx, { only = null } = {}) {
 
   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.' },
@@ -410,6 +472,101 @@ export function registerTools(ctx, { only = null } = {}) {
     },
   ))
 
+  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.',
@@ -515,7 +672,8 @@ export function registerTools(ctx, { only = null } = {}) {
     { isConcurrencySafe: () => true },
   ))
 
-  // 整理 worker 的挂载面（private.js 的 fork 兼容）：只挂读写四件，不把
+  // 整理 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)))

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.1",
+  "version": "1.2.2",
   "description": "面向长篇 RP 与陪伴对话的 DeepSeek Harness 记忆插件：三层记忆、逐轮召回、来源标注、关系图、图片附件与独立 WebUI。",
   "keywords": [
     "deepseek-harness",

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