dsh-memu-memory 1.2.0 → 1.2.1

package/lib/private.js

@@ -181,8 +181,14 @@ export async function requestRemoteConsolidation(ctx, sessionId, { signal, timeo
       signal,
       timeoutMs,
     })
+    // 写入计数必须说真话：`memories` 是模型给的清单，逐条 privateRemember 可能被
+    // 事实级去重拒绝（deduped，不落库）或因矛盾暂扣（pending_review，仅入索引）。
+    // count 只数真正落库的；被拒/暂扣分列进 detail，否则"写入 N 条"就是误报。
+    let written = 0
+    let deduped = 0
+    let held = 0
     for (const memory of memories) {
-      await privateRemember({
+      const outcome = await privateRemember({
         ...memory,
         exec: { agent: { session: { header: { id: sessionId } } } },
         content: memory.content,
@@ -192,12 +198,17 @@ export async function requestRemoteConsolidation(ctx, sessionId, { signal, timeo
         confidence: memory.confidence,
         source: memory.source || 'inferred',
       })
+      if (outcome?.deduped === true) deduped += 1
+      else if (outcome?.entry?.status === 'pending_review') held += 1
+      else written += 1
     }
     setSessionBinding(sessionId, { lastSleepSeq: events[events.length - 1]?.seq })
-    const result = { ok: true, sessionId, backend: 'api', count: memories.length }
+    const result = { ok: true, sessionId, backend: 'api', count: written, deduped, held }
     record({
       kind: 'consolidate', scope: 'private', sessionId, libraryId: binding.libraryId || null, ok: true,
-      message: `整理完成（远程）· 写入 ${memories.length}`,
+      message: `整理完成（远程）· 写入 ${written}`
+        + (deduped ? ` · 去重拦下 ${deduped}` : '')
+        + (held ? ` · 待复核 ${held}` : ''),
       detail: { ...result, forced: force },
     })
     return result
@@ -264,10 +275,79 @@ function turnEndFailure(event) {
   return 'the fork turn ended ' + (reason.kind || 'without a reason') + (message ? ': ' + message : '')
 }
 
+// PTC 兼容（2026-10-31 现场 worker-tools-ptc-only）：PTC 会话的 header 工具表只有
+// run_code，其余工具走 run_code 程序里的 SDK 绑定（宿主 ptc.ts 用
+// tools.schemas(agent, toolSet) 枚举"调用 agent 的可见面"）。preset 组合没列出本插件
+// 时，fork 的注册表里根本没有 memu_*，worker 既不能原生调用也没有 SDK 绑定，回执只能
+// 是 tools-unavailable。修法与 preset-scope.js 的注入挂载同构：把读写四件挂进 fork
+// 自己的 ctx scope —— 注册表按 scope 链取可见面，所以只对这个 worker 可见，不扩散到
+// 其它会话；挂载点必须在 followup 之前（宿主在 step 开始时 resolve 一次 admitted set，
+// 之后注册的工具不进本步）。失败不阻断整理：worker 会按任务书如实回执 tools-unavailable。
+async function attachWorkerTools(agents, childId, parentId) {
+  const wanted = [...WORKER_WRITE_TOOLS, ...WORKER_READ_TOOLS]
+  const ctxOf = (record) => {
+    try { return record?.ctx || record?.agent?.ctx || null } catch { return null }
+  }
+  let parentHasCtx = null
+  for (let attempt = 0; attempt < 6; attempt += 1) {
+    let record = null
+    try { record = agents.get?.(childId) || null } catch { record = null }
+    if (record) {
+      const actx = ctxOf(record)
+      // 有记录但没有 ctx：这版宿主不暴露 agent context（preset-scope.js 的同款限制），
+      // 重试不会变出来。ctx 在但没有 tools 服务：组合里就没有。两者都直接放弃。
+      if (!actx || !(actx.tools && typeof actx.tools.register === 'function')) break
+      try {
+        const dispose = registerTools(actx, { only: wanted })
+        // tools.js 在 disposer 上附挂实际注册成功的名单（编译 + register 都过的那部分）。
+        // 读它，不再把 wanted 全量当成"已挂载"——部分挂载必须结构化可见。
+        const attached = Array.isArray(dispose?.attached) ? [...dispose.attached] : null
+        return {
+          dispose,
+          attached,
+          requested: wanted,
+          // 名单缺失 = 无法证明挂全：partial 照实标 true，attached 落 null（与失败同口径）。
+          partial: attached ? attached.length < wanted.length : true,
+        }
+      } catch (error) {
+        warn('consolidation worker tool attach failed: ' + String(error?.message || error))
+        return null
+      }
+    }
+    // 子记录还没出现：只在这个宿主确实会暴露 ctx（父记录带 ctx）时才值得短退避等它。
+    if (parentHasCtx === null) parentHasCtx = Boolean(ctxOf(agents.get?.(parentId)))
+    if (!parentHasCtx) break
+    await new Promise(resolve => setTimeout(resolve, 100))
+  }
+  warn('consolidation worker has no tools service on its own context; the worker may be unable to write memories')
+  return null
+}
+
+// 活动日志"整理已开始"条目的挂载元数据口径（workerTools* 三件）：
+//   workerToolsAttached  实际注册成功的工具名数组；null = 挂载没有完成或无法确认
+//                        （fork ctx 无 tools 服务、register 抛错、宿主没回名单），
+//                        与"挂全了"严格区分——这正是旧字段把 wanted 全量误报成
+//                        已挂载的教训。
+//   workerToolsRequested 请求挂载的完整 wanted 名单；与 attached 全等才是全量挂载。
+//   workerToolsPartial   true = 未证明 worker 拿到完整 wanted 集（子集、空集、或挂载
+//                        整体失败）。刻意把"一件都没挂上"也标 true：若失败标 false，
+//                        false 会被一眼读成"全量挂载"，元数据又不准了。
+function workerToolsMeta(workerTools) {
+  const wanted = [...WORKER_WRITE_TOOLS, ...WORKER_READ_TOOLS]
+  if (!workerTools) {
+    return { workerToolsAttached: null, workerToolsRequested: wanted, workerToolsPartial: true }
+  }
+  return {
+    workerToolsAttached: Array.isArray(workerTools.attached) ? workerTools.attached : null,
+    workerToolsRequested: Array.isArray(workerTools.requested) ? workerTools.requested : wanted,
+    workerToolsPartial: workerTools.partial === true,
+  }
+}
+
 const inFlight = new Map()
 
 // 这里的 import 刻意写在语句之后：lib/binding-diagnostics.js 的 RUNTIME_STATE 把 `inFlight`
-// 的 file:line 当成诊断契约（第 267 行），修改位置时同步更新该诊断映射，
+// 的 file:line 当成诊断契约（当前 lib/private.js:336），修改位置时同步更新该诊断映射，
 // 而那是别人的文件、本包不改。ESM 的 import 声明是提升的，写在语句之后合法。
 import { warn } from './paths.js'
 import { captureSessionSnapshot } from './consolidation-snapshot.js'
@@ -276,7 +356,8 @@ import {
   recoverStaleJobs, recordOperation, scopeGenerationOf,
 } from './consolidation-ledger.js'
 import { decideCompletion, receiptContractText } from './consolidation-receipt.js'
-import { buildWorkerBrief, probeToolSurface } from './consolidation-worker.js'
+import { buildWorkerBrief, probeToolSurface, WORKER_READ_TOOLS, WORKER_WRITE_TOOLS } from './consolidation-worker.js'
+import { registerTools } from './tools.js'
 
 // 账本异常必须可见；调用方只有拿到明确的持久租约才可启动 worker。
 // 其余读写失败返回保守结果，不得据此推进已确认边界。
@@ -325,6 +406,7 @@ export async function requestHistoricalConsolidation(ctx, sessionId, { maxWaitMs
   let turnEnd = null
   let jobId = null
   let scopeChanged = null
+  let workerTools = null
   const assistantTexts = []
   let childId = null
   // 每次整理都要在活动日志里留一条：谁触发（手动/空闲）、fork 有没有建、结果是完成、
@@ -522,6 +604,13 @@ export async function requestHistoricalConsolidation(ctx, sessionId, { maxWaitMs
       signal: abort.signal,
     })
 
+    // header 无法证明 worker 有写工具时（PTC 会话名单只有 run_code / 旧会话没有名单），
+    // 把读写四件挂进 fork 自己的 scope，保证 SDK 面（PTC）与原生面（普通会话）都真能写入。
+    // 标准 preset 的 fork 名单里已有 memu_*（probe.hasWrite === true），不重复挂。
+    if (probe.hasWrite !== true) {
+      workerTools = await attachWorkerTools(agents, childId, sessionId)
+    }
+
     // 先记"已开始"再等结果：一个大会话的 fork 可能跑好几分钟，没有这条记录，
     // 侧边栏和日志页在等待期间只会显示上一次的结果，用户会以为按钮没生效。
     record({
@@ -531,7 +620,9 @@ export async function requestHistoricalConsolidation(ctx, sessionId, { maxWaitMs
       libraryId: binding.libraryId || null,
       ok: true,
       message: '整理已开始 · ' + (force ? '手动' : '空闲') + ' · fork ' + childId.slice(-8) + ' · ' + events.length + ' 条事件 · 快照 ' + snapshot.hash,
-      detail: { childId, jobId, force, events: events.length, phase: 'started', snapshot: snapshotMeta },
+      detail: { childId, jobId, force, events: events.length, phase: 'started', snapshot: snapshotMeta,
+        probe: { source: probe.source, hasWrite: probe.hasWrite, ptc: probe.ptcObserved === true },
+        ...workerToolsMeta(workerTools) },
     })
 
     // turn/end 是这一轮的唯一权威结果；whenIdle 只说明 driver 停了（失败的回合也停）。
@@ -731,6 +822,7 @@ export async function requestHistoricalConsolidation(ctx, sessionId, { maxWaitMs
     inFlight.delete(sessionId)
     abort.abort()
     try { offSession?.() } catch {}
+    try { workerTools?.dispose?.() } catch {}
     try { await handle?.dispose?.() } catch {}
     try { if (childId) deleteSessionBinding(childId) } catch {}
   }

package/lib/rpc.js

@@ -18,7 +18,7 @@ import { statsView } from './stats.js'
 import { getMemuConfig, saveMemuConfig, setEmbeddingSource, testMemuConfig, getSummaryConfig, getVisionConfig } from './memu-config.js'
 import { getLocalVectorState, downloadLocalVectorModel, installLocalVectorRuntime, selectLocalVectorModel, switchLocalVectorProfile, rollbackLocalVectorProfile, abortLocalVectorMigration, testLocalVector } from './local-vector-service.js'
 import { webUiHtml, WEBUI_PATH, standaloneHtml, standaloneAsset, SETTINGS_PATH } from './webui.js'
-import { getGraph, listEntities, createEntity, renameEntity, linkEntries, unlinkEntry, getRelationship, updateRelationship, graphExport, restoreGraphData } from './graph.js'
+import { getGraph, listEntities, createEntity, renameEntity, deleteEntity, linkEntries, unlinkEntry, getRelationship, updateRelationship, graphExport, restoreGraphData } from './graph.js'
 import { getAttachment, attachmentThumbnail, attachmentPreview, exportMediaBundle, importMediaBundle, streamMediaExport, importMediaStream } from './media.js'
 import { listEvents, logStats, clearEvents } from './activity-log.js'
 
@@ -255,13 +255,44 @@ async function readSessionTitles(sessionQuery, ids) {
       for (const r of await sessionQuery.readTitleSnapshots(ids) || []) {
         if (r?.status !== 'fulfilled' || !r.sessionId) continue
         const title = r.value?.title?.title || r.value?.session?.title
-        if (title) titles.set(r.sessionId, title)
+        if (title && String(title).trim()) titles.set(r.sessionId, String(title).trim())
       }
     }
   } catch {}
   return titles
 }
 
+// 日志行原本只有 sessionId/libraryId 裸 id：日志页和侧边栏提醒要回答"这是哪个对话、
+// 哪个文件夹"，得在服务端把标题与库名拼上。标题走宿主 readTitleSnapshots（批量一次），
+// 查不到的行保留 null，客户端回退到短 id。
+async function decorateLogRows(ctx, rows) {
+  const ids = [...new Set(rows.map(row => row?.sessionId).filter(Boolean))]
+  const titles = await readSessionTitles(ctx?.get?.('sessionQuery'), ids)
+  return rows.map(row => ({
+    ...row,
+    sessionTitle: row?.sessionId ? (titles.get(row.sessionId) || null) : null,
+    libraryName: row?.libraryId ? (getLibrary(row.libraryId)?.name || null) : null,
+  }))
+}
+
+// 侧边栏"整理提醒"的数据源：跨会话（不按当前对话过滤），失败/成功两列分开，
+// 每列只取最新 limit 条。失败的行带会话标题与库名，客户端用它挂跳转按钮。
+async function consolidationFeed(ctx, payload = {}) {
+  const perColumn = Math.max(1, Math.min(20, Number(payload?.limit) || 6))
+  const rows = await decorateLogRows(ctx, listEvents({ kind: 'consolidate', limit: 80 }))
+  const slim = ({ detail, ...row }) => ({
+    ...row,
+    reasonCode: detail?.reasonCode || detail?.code || null,
+    timedOut: detail?.timedOut === true,
+    count: detail?.count ?? null,
+    force: detail?.force === true,
+  })
+  return {
+    failures: rows.filter(row => row.ok === false).slice(0, perColumn).map(slim),
+    successes: rows.filter(row => row.ok !== false).slice(0, perColumn).map(slim),
+  }
+}
+
 // The host's session corpus is the authority for "this conversation still
 // exists". A binding in state.json is deliberately kept after a conversation is
 // deleted so its memory library survives; it must not keep the dead row visible.
@@ -882,6 +913,8 @@ async function dispatch(ctx, endpoint, payload = {}) {
       return createEntity(payload || {})
     case 'renameEntity':
       return renameEntity(payload || {})
+    case 'deleteEntity':
+      return deleteEntity(payload || {})
     case 'linkEntries':
       return linkEntries(payload || {})
     case 'unlinkEntry':
@@ -1140,7 +1173,7 @@ async function dispatch(ctx, endpoint, payload = {}) {
       return engineView()
     case 'getActivityLog':
       return {
-        events: listEvents({
+        events: await decorateLogRows(ctx, listEvents({
           limit: payload?.limit,
           kind: payload?.kind,
           level: payload?.level,
@@ -1148,9 +1181,17 @@ async function dispatch(ctx, endpoint, payload = {}) {
           sessionId: payload?.sessionId,
           since: payload?.since,
           q: payload?.q,
-        }),
+        })),
         stats: logStats(),
       }
+    case 'getConsolidationFeed':
+      return await consolidationFeed(ctx, payload)
+    case 'clearConsolidationFailures': {
+      // 侧边栏失败提醒的"清除"：只删 consolidate 且 ok=false 的行。返回删除条数和
+      // 清除后的新 feed，客户端直接回填，不用二次拉取。
+      const cleared = clearEvents({ kind: 'consolidate', ok: false })
+      return { cleared: cleared.removed, feed: await consolidationFeed(ctx, payload) }
+    }
     case 'clearActivityLog':
       return clearEvents()
     default:

package/lib/text-similarity.js

@@ -0,0 +1,106 @@
+// 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)
+}
+
+/**
+ * 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 a = String(aText || '')
+  const b = String(bText || '')
+  if (lengthGap(a, b) > LENGTH_PRUNE_RATIO) {
+    const aClean = clean(a)
+    const bClean = clean(b)
+    if (!aClean || !bClean) return 0
+    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
+    // Probe 1: verbatim containment of the short text inside the long one.
+    if (longClean.includes(shortClean)) return CONTAINMENT_FLOOR
+    // 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.
+    for (let i = 0; i < shortClean.length - 1; i += 1) {
+      if (!longClean.includes(shortClean.slice(i, i + 2))) return 0
+    }
+    return CORE_COVER_FLOOR
+  }
+  return dice(bigrams(a), bigrams(b))
+}

package/lib/tools.js

@@ -162,9 +162,13 @@ 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=读写四件）不能把 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.',
@@ -223,6 +227,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 +264,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
@@ -501,17 +515,59 @@ 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 兼容）：只挂读写四件，不把
+  // 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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-memu-memory",
   "icon": "./assets/icon.png",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "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",