dsh-memu-memory 1.1.3 → 1.2.1

package/lib/tools.js

@@ -80,6 +80,28 @@ function salientTag(entry) {
   return isDatedSalientDate(entry.salientDate) ? `date=${entry.salientDate}` : `anniversary=${entry.salientDate}`
 }
 
+// 四轴名在展示层就地映射：这是给人读的一行摘要，不是本地化词条。
+const EMOTION_LABELS = { joy: '喜', anger: '怒', sorrow: '哀', fear: '惧' }
+const EMOTION_AXES_IN_ORDER = ['joy', 'anger', 'sorrow', 'fear']
+
+// 只留够显眼的份额，最多两项：四项全列会把一行标签读成噪声。
+function emotionBrief(entry) {
+  const emotion = entry.emotion
+  if (!emotion || typeof emotion !== 'object') return ''
+  const shares = EMOTION_AXES_IN_ORDER
+    .map((axis) => ({ axis, share: Number(emotion[axis]) || 0 }))
+    .filter((item) => item.share >= 0.05)
+    .sort((a, b) => b.share - a.share)
+    .slice(0, 2)
+  if (!shares.length) return ''
+  const parts = shares.map((item) => `${EMOTION_LABELS[item.axis]}${item.share.toFixed(2)}`)
+  const dominance = Number(entry.dominance)
+  if (Number.isFinite(dominance)) parts.push(`dom${dominance >= 0 ? '+' : ''}${dominance.toFixed(2)}`)
+  const arousal = Number(entry.arousal)
+  if (Number.isFinite(arousal)) parts.push(`a${arousal.toFixed(2)}`)
+  return parts.join(' · ')
+}
+
 function formatPrivateItem(item, index, options = {}) {
   const entry = item.entry || {}
   const lines = [
@@ -107,7 +129,10 @@ function formatPrivateItem(item, index, options = {}) {
   // way made "the test is tomorrow" read like a recurring commemorative date.
   const tag = salientTag(entry)
   if (tag) lines.push(`   ${tag}`)
-  if (typeof entry.moodValence === 'number' && entry.moodValence !== 0) lines.push(`   mood=${entry.moodValence.toFixed(2)}`)
+  // 有构成就讲构成：同一个 valence 可能来自怒，也可能来自哀，一个数字分不出来。
+  const brief = emotionBrief(entry)
+  if (brief) lines.push(`   emo=${brief}`)
+  else if (typeof entry.moodValence === 'number' && entry.moodValence !== 0) lines.push(`   mood=${entry.moodValence.toFixed(2)}`)
   if (item.content) {
     const body = options.query
       ? centeredSnippet(item.content, options.query)
@@ -137,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.',
@@ -187,9 +216,18 @@ export function registerTools(ctx) {
         description: 'Where this came from: inferred (default — you concluded it), user_said (only when the words are actually theirs and quotable), imagined, or told.',
       },
       confidence: { type: 'number', description: '0-1 confidence in this memory. Below 0.45 it is injected as a hedge, so use it honestly.' },
-      mood_valence: { type: 'number', description: 'How this moment felt, -1 (bad) to 1 (good). Omit to inherit the current conversation mood.' },
+      mood_valence: { type: 'number', description: '派生值：给了 emotion 时由四项算出，-1（坏）到 1（好）。省略则沿用当前会话读数。' },
       arousal: { type: 'number', description: 'How strongly it hit, 0-1.' },
+      emotion: {
+        type: 'object',
+        properties: { joy: { type: 'number' }, anger: { type: 'number' }, sorrow: { type: 'number' }, fear: { type: 'number' } },
+        // 四个轴是封闭集合：多写的键只会被误当成第五种情绪。
+        additionalProperties: false,
+        description: '情绪构成：喜悦/愤怒/哀伤/恐惧，四项自动归一化到和为 1。填记忆所述那件事的情绪，不是此刻整理时的心情。省略=继承当前会话读数；显式全零=明确中性；工程事实请用中性，不要因为 bug 难修或结论重要就填负面情绪。',
+      },
+      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.' },
@@ -219,9 +257,23 @@ export function registerTools(ctx) {
         confidence: args.confidence,
         moodValence: args.mood_valence ?? null,
         arousal: args.arousal ?? null,
+        // `undefined` means "the model said nothing" and is allowed to inherit the
+        // turn's mood; `null` means "explicitly neutral" and must survive as such. Using
+        // `?? null` here would erase that difference and re-inherit on a neutral call.
+        emotion: args.emotion,
+        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
@@ -309,6 +361,13 @@ export function registerTools(ctx) {
       peak: { type: 'boolean', description: 'Flashbulb flag: the moment was charged. Changing it recomputes accuracy.' },
       mood_valence: { type: 'number', description: 'How the moment felt, -1..1. Used as a retrieval lens; omitted keeps the stored value.' },
       arousal: { type: 'number', description: 'How charged the moment was, 0..1. Used as a retrieval lens; omitted keeps the stored value.' },
+      emotion: {
+        type: 'object',
+        properties: { joy: { type: 'number' }, anger: { type: 'number' }, sorrow: { type: 'number' }, fear: { type: 'number' } },
+        additionalProperties: false,
+        description: '情绪构成，三项语义不同：省略=保留原值；显式 null=清除 emotion，来源变 unknown；显式对象=校验并归一化后整份替换。改的是那条记忆所述事件的感受，不是此刻的心情。',
+      },
+      dominance: { type: 'number', description: '谁在掌控：-1 完全失控 … +1 完全掌控。省略=保留原值。' },
       salient_date: { type: 'string', description: 'Re-date the memory: MM-DD for an annual anniversary, YYYY-MM-DD for a one-off dated commitment, or an empty string to remove the date. Use this to repair a date that was stored without its year.' },
     },
     async (args, exec) => {
@@ -318,6 +377,8 @@ export function registerTools(ctx) {
         layer: args.layer, owner: args.owner, visibility: args.visibility,
         source: args.source, track: args.track, peak: args.peak,
         moodValence: args.mood_valence, arousal: args.arousal,
+        // undefined 就是"省略"，必须原样传下去；换成 null 会把保留变成清除。
+        emotion: args.emotion, dominance: args.dominance,
         // Sentinel: absent means "leave the date as it is", '' means "clear it".
         salientDate: args.salient_date,
       })
@@ -454,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)
@@ -565,6 +589,33 @@ export function dbPathFor(libraryId = null) {
  * loadIndex must be synchronous; by default the authoritative raw index is read.
  * A nonempty, corrupt, quarantined or unknown-shaped index requires rebuilding.
  */
+/**
+ * Remove one library from the active database map under the manifest lock.
+ * The caller owns filesystem cleanup; returning the captured absolute path keeps
+ * the manifest mutation atomic without deleting a possibly newer generation.
+ */
+export function removeActiveLibrary(libraryId) {
+  if (!isSafeId(libraryId) || libraryId === 'global') throw vectorError(VECTOR_ERROR_CODES.PATH_ESCAPE, 'unsafe private library id: ' + JSON.stringify(libraryId))
+  let removed = null
+  updateVectorStateSync(state => {
+    const guard = liveGuard(state.writeGuard)
+    if (guard.frozen || Object.keys(guard.leases).length) {
+      throw vectorError('VECTOR_WRITE_BUSY', 'an in-flight vector write prevents deleting a library; retry shortly', { libraryId })
+    }
+    if (state.pending) {
+      throw vectorError('VECTOR_WRITE_BUSY', 'a vector generation switch prevents deleting a library; retry shortly', { libraryId })
+    }
+    const active = state.active
+    const entry = active?.databases?.libraries?.[libraryId]
+    if (!active || !entry) return null
+    removed = resolveVectorPath(entry.path)
+    const libraries = { ...active.databases.libraries }
+    delete libraries[libraryId]
+    return { ...state, active: { ...active, databases: { ...active.databases, libraries } } }
+  })
+  return removed
+}
+
 export function enrollActiveLibrary(libraryId, { loadIndex } = {}) {
   if (!isSafeId(libraryId) || libraryId === 'global') throw vectorError(VECTOR_ERROR_CODES.PATH_ESCAPE, 'unsafe private library id: ' + JSON.stringify(libraryId))
   let db = null

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-memu-memory",
   "icon": "./assets/icon.png",
-  "version": "1.1.3",
+  "version": "1.2.1",
   "description": "面向长篇 RP 与陪伴对话的 DeepSeek Harness 记忆插件：三层记忆、逐轮召回、来源标注、关系图、图片附件与独立 WebUI。",
   "keywords": [
     "deepseek-harness",
@@ -45,6 +45,7 @@
   "files": [
     "lib",
     "scripts",
+    "tests",
     "cordis.patch.yml",
     "requirements.lock",
     "README.md",
@@ -60,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

@@ -699,7 +699,8 @@ await auto('G-1', 'the kept docs exist and nothing points at a retired one', asy
   for (const rel of ['assets/icon.png', 'assets/icon-256.png', 'assets/icon.svg']) {
     assert.ok(fs.existsSync(path.join(ROOT, rel)), rel + ' exists')
   }
-  assert.ok(!fs.existsSync(path.join(ROOT, 'CHANGELOG' + '.md')), 'the retired changelog is gone')
+  // Since 1.1.3 the changelog is the source for release notes (release.yml), so it is kept.
+  assert.ok(fs.existsSync(path.join(ROOT, 'CHANGELOG' + '.md')), 'CHANGELOG.md carries release notes')
   // 细节从 AGENTS.md 搬进了 docs/：索引必须短，指针必须都能落地
   const agents = fs.readFileSync(path.join(ROOT, 'AGENTS.md'), 'utf8')
   assert.ok(agents.includes('plugin:dsh-memu-memory'), 'the notes carry the real source kind, not the old one')