dsh-memu-memory 1.1.3 → 1.2.1

package/lib/prompts/private-consolidation.rp.md

@@ -30,6 +30,7 @@
 - open_loop：只标真实未完的承诺或已铺垫且影响后续的悬念；普通沉默和未说出口的念头不自动标 true，兑现或明确取消后才关闭。
 - confidence：不确定就低一点。
 - mood_valence/arousal 是感受，confidence 是证据，不把情绪强度当准确性。owner 区分自己的体验、共同经历与对方明确说出的事；不为好召回而夸大 peak。
+- 情绪按事件所在回合还原：emotion 填的是那一瞬间的感受，取那一轮对话里的情绪，不是整理时的心情。同一轮的多条条目各写各的，一场争吵的情绪不串到所有条目。工程事实（owner=about_project）固定中性。dominance 跟着 emotion 一起填：那一刻是自己推动的（正）还是被推着走的（负），没把握就省略，不要用 0 凑数。
 
 永久记忆只在对方明确要求、随机侧事件、或极少数「忘了就不再是我」时使用；不要为了显得深刻而 pin。
 不要写全局记忆；全局记忆只由 curator 写。

package/lib/prompts.js

@@ -19,7 +19,7 @@ export const PROMPT_DEFS = [
     key: 'system-guide',
     file: 'system-guide.md',
     title: '记忆使用指南',
-    description: '注入 system prompt 的常驻记忆规则：什么时候检索、什么时候写入、永久记忆与 unpin 的边界。',
+    description: '以插件消息投放的常驻记忆规则：什么时候检索、什么时候写入、永久记忆与 unpin 的边界；按 domain 选变体，规则变化会在下一回合首步重新投放。',
     variables: ['mustRememberCap', 'unpinBudget', 'shortTermTtlHours', 'anchorTokens', 'turnTokens'],
     scope: 'private',
     domainLayered: true,
@@ -28,7 +28,7 @@ export const PROMPT_DEFS = [
     key: 'private-policy',
     file: 'private-policy.md',
     title: '私有记忆策略',
-    description: '按领域约束主 agent 的记忆写入：代码逻辑与验证、角色连续性、事实与推断、永久记忆与披露边界。',
+    description: '字段规约模板；当前版本不再自动投放主会话，字段契约由工具 schema 与运行校验提供。保留供查阅和覆盖记录。',
     variables: ['mustRememberCap', 'unpinBudget', 'shortTermTtlHours', 'anchorTokens', 'turnTokens'],
     scope: 'private',
     domainLayered: true,
@@ -84,8 +84,8 @@ export const CONSOLIDATION_CONTRACTS = {
   local: '使用当前可用的记忆工具，先按主题检索去重。兼容细节用 memu_private_update 合并；真正新增或矛盾待复核的内容用 memu_private_remember，一条一件，不自行裁定冲突。不能查询或更新时如实保留限制，不宣称已核对或已修改。没有值得留的就直接结束，不要勉强写。',
   remote: [
     '只输出一个 JSON 对象，不要任何解释或 Markdown 代码块：',
-    '{"memories":[{"title":"≤30字","content":"完整正文","layer":"long_term|short_term","tags":["可选"],"open_loop":false,"confidence":0.0,"source":"inferred|user_said|imagined|told","visibility":"session|shared|secret","disclosure":"can_tell|only_if_asked|never_say","owner":"me|us|about_user|about_project","mood_valence":0.0,"arousal":0.35,"peak":false,"salient_date":null}]}',
-    '你没有记忆工具，也没有输入以外的索引：只返回最多 3 条候选，不声称已检索、合并、更新、裁决或完成写入。不要输出工具调用或 must_remember；矛盾候选在 content 中保留来源、时间与不确定性，交给后续复核。领域表达服从上文，字段服从本 JSON 协议。未确定的感受/日期用 null，不为填字段编造。',
+    '{"memories":[{"title":"≤30字","content":"完整正文","layer":"long_term|short_term","tags":["可选"],"open_loop":false,"confidence":0.0,"source":"inferred|user_said|imagined|told","visibility":"shared|secret","disclosure":"can_tell|only_if_asked|never_say","owner":"me|us|about_user|about_project","emotion":null,"dominance":0,"mood_valence":0.0,"arousal":0.35,"peak":false,"salient_date":null}]}',
+    '你没有记忆工具，也没有输入以外的索引：只返回最多 3 条候选，不声称已检索、合并、更新、裁决或完成写入。不要输出工具调用或 must_remember；矛盾候选在 content 中保留来源、时间与不确定性，交给后续复核。领域表达服从上文，字段服从本 JSON 协议。emotion 只接受四轴 {"joy","anger","sorrow","fear"} 的份额对象，没有明确依据就用 null；dominance 是 -1..1 的掌控感。未确定的感受/日期用 null，不为填字段编造。',
     '没有值得留的就输出 {"memories":[]}。',
   ].join('\n'),
 }

package/lib/remote-summary.js

@@ -1,6 +1,8 @@
 import { getSummaryConfig } from './memu-config.js'
 import { loadPromptForDomain, CONSOLIDATION_CONTRACTS } from './prompts.js'
 import { getSettings } from './state.js'
+import { normalizeEmotion } from './mood.js'
+import { record } from './activity-log.js'
 
 function parseJsonObject(text) {
   const raw = String(text || '').trim()
@@ -12,31 +14,42 @@ function parseJsonObject(text) {
   try { return JSON.parse(raw.slice(start, end + 1)) } catch { return null }
 }
 
-function cleanMemories(value) {
+// 逐条清洗。非法字段不修，只把这一条连同原因丢进 problems：一条坏数据不该让
+// 整批整理白跑，也不该被悄悄改成"看起来合法"的情绪留在库里。
+function cleanMemories(value, problems = []) {
   const list = Array.isArray(value) ? value : []
-  return list
-    .map((m) => ({
-      title: String(m?.title || '').trim().slice(0, 120),
-      content: String(m?.content || '').trim(),
-      tags: Array.isArray(m?.tags) ? m.tags.slice(0, 20).map((t) => String(t)) : [],
-      openLoop: m?.open_loop === true || m?.openLoop === true,
-      confidence: Number.isFinite(Number(m?.confidence)) ? Number(m.confidence) : 0.8,
-      layer: ['long_term', 'short_term'].includes(m?.layer) ? m.layer : 'long_term',
-      disclosure: ['can_tell', 'only_if_asked', 'never_say'].includes(m?.disclosure) ? m.disclosure : 'can_tell',
-      // A consolidation pass that forgets the field must not invent a scope: the default
-      // here has to match the tool path (`privateRemember`, which defaults to 'shared').
-      // 'session' used to be the fallback, which silently turned every sloppy summary into
-      // a memory that died with its conversation (and the level itself is gone now).
-      visibility: ['shared', 'secret'].includes(m?.visibility) ? m.visibility : 'shared',
-      owner: ['me', 'us', 'about_user', 'about_project'].includes(m?.owner) ? m.owner : 'me',
-      source: ['user_said', 'inferred', 'imagined', 'told'].includes(m?.source) ? m.source : 'inferred',
-      moodValence: Number.isFinite(m?.mood_valence) ? Math.max(-1, Math.min(1, m.mood_valence)) : null,
-      arousal: Number.isFinite(m?.arousal) ? Math.max(0, Math.min(1, m.arousal)) : null,
-      peak: m?.peak === true,
-      salientDate: typeof m?.salient_date === 'string' ? m.salient_date : null,
-    }))
-    .filter((m) => m.content)
-    .slice(0, 20)
+  const out = []
+  list.forEach((m, index) => {
+    try {
+      out.push({
+        title: String(m?.title || '').trim().slice(0, 120),
+        content: String(m?.content || '').trim(),
+        tags: Array.isArray(m?.tags) ? m.tags.slice(0, 20).map((t) => String(t)) : [],
+        openLoop: m?.open_loop === true || m?.openLoop === true,
+        confidence: Number.isFinite(Number(m?.confidence)) ? Number(m.confidence) : 0.8,
+        layer: ['long_term', 'short_term'].includes(m?.layer) ? m.layer : 'long_term',
+        disclosure: ['can_tell', 'only_if_asked', 'never_say'].includes(m?.disclosure) ? m.disclosure : 'can_tell',
+        // A consolidation pass that forgets the field must not invent a scope: the default
+        // here has to match the tool path (`privateRemember`, which defaults to 'shared').
+        // 'session' used to be the fallback, which silently turned every sloppy summary into
+        // a memory that died with its conversation (and the level itself is gone now).
+        visibility: ['shared', 'secret'].includes(m?.visibility) ? m.visibility : 'shared',
+        owner: ['me', 'us', 'about_user', 'about_project'].includes(m?.owner) ? m.owner : 'me',
+        source: ['user_said', 'inferred', 'imagined', 'told'].includes(m?.source) ? m.source : 'inferred',
+        // 缺字段是"没读到情绪"，null 才是；这里不能拿 valence 反推四轴。
+        emotion: normalizeEmotion(m?.emotion ?? null),
+        // 缺失或非法给 null 而不是 0：0 表示"明确中性"，不是"不知道"。
+        dominance: Number.isFinite(m?.dominance) ? Math.max(-1, Math.min(1, m.dominance)) : null,
+        moodValence: Number.isFinite(m?.mood_valence) ? Math.max(-1, Math.min(1, m.mood_valence)) : null,
+        arousal: Number.isFinite(m?.arousal) ? Math.max(0, Math.min(1, m.arousal)) : null,
+        peak: m?.peak === true,
+        salientDate: typeof m?.salient_date === 'string' ? m.salient_date : null,
+      })
+    } catch (error) {
+      problems.push({ index, title: String(m?.title || '').slice(0, 120), error: String(error?.message || error) })
+    }
+  })
+  return out.filter((m) => m.content).slice(0, 20)
 }
 
 // Remote mode: the configured chat endpoint does the summarizing. The session
@@ -87,7 +100,20 @@ export async function summarizeRemote({ transcript, libraryName, domain, signal,
     const text = data?.choices?.[0]?.message?.content
     const parsed = parseJsonObject(text)
     if (!parsed) throw new Error(`remote summary returned non-JSON: ${String(text || body).slice(0, 600)}`)
-    return cleanMemories(parsed.memories)
+    const problems = []
+    const memories = cleanMemories(parsed.memories, problems)
+    if (problems.length) {
+      // 远程模型的错误只能靠日志查，静默丢弃等于把问题留给下一个人复现。
+      record({
+        kind: 'consolidate',
+        scope: 'private',
+        ok: false,
+        level: 'warn',
+        message: `远程整理有 ${problems.length} 条被拒绝：${problems[0].error}`,
+        detail: { rejected: problems },
+      })
+    }
+    return memories
   } finally {
     clearTimeout(timer)
     signal?.removeEventListener?.('abort', onAbort)

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'
 
@@ -86,6 +86,11 @@ async function privateListView(scope) {
     decay: Math.min(1, Math.max(0, decayStrength(e) / 1.5)),
     moodValence: e?.moodValence ?? null,
     arousal: e?.arousal ?? null,
+    // 构成与掌控感分开投影：同一个 valence 说得出"多难过"，说不出"是怒还是怕"。
+    emotion: e?.emotion ?? null,
+    dominance: e?.dominance ?? null,
+    // 来源是审计字段，只读：面板显示"这个情绪是谁给的"，不给改。
+    emotionSource: e?.emotionSource ?? null,
     peak: e?.peak === true,
     salientDate: e?.salientDate || null,
     attachments: attachmentPreview(libraryId, e || {}),
@@ -250,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.
@@ -453,6 +489,7 @@ async function dispatch(ctx, endpoint, payload = {}) {
       } catch {}
       const rows = Object.entries(state.sessions || {})
         .map(([sessionId, binding]) => {
+          if (binding.consolidationFork) return null
           const inFolder = binding.scopeKey === scopeKey
             || (binding.libraryId && state.libraries?.[binding.libraryId]?.scopeKey === scopeKey)
           if (!inFolder) return null
@@ -771,7 +808,9 @@ async function dispatch(ctx, endpoint, payload = {}) {
       // `source` is writable: correcting provenance is the point of showing it.
       // `salientDate` is writable for the same reason: an entry whose year was
       // dropped has to be repairable from the browser, not only from JSON.
-      const allowed = ['content', 'title', 'tags', 'status', 'openLoop', 'disclosure', 'confidence', 'owner', 'visibility', 'layer', 'source', 'salientDate', 'track', 'peak', 'moodValence', 'arousal', 'attachments', 'context']
+      // `emotion`/`dominance` 可写：面板修的是那条记忆所述事件的感受。
+      // `emotionSource` 故意不在名单里：来源是审计结论，能改就等于能伪造。
+      const allowed = ['content', 'title', 'tags', 'status', 'openLoop', 'disclosure', 'confidence', 'owner', 'visibility', 'layer', 'source', 'salientDate', 'track', 'peak', 'moodValence', 'arousal', 'emotion', 'dominance', 'attachments', 'context']
       // An unknown key used to be dropped in silence, so a typo here or in a script
       // came back as a successful save that changed nothing. Refuse instead: the
       // caller can only fix a field name it is told is wrong.
@@ -874,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':
@@ -1132,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,
@@ -1140,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/state.js

@@ -10,7 +10,8 @@ import {
   pruneBackups, restoreFromBackup, withBackupLock,
 } from './backup.js'
 import { migrateIndexVisibility } from './visibility.js'
-import { memuDbFor, memuGlobalDbFor } from './vector-profile.js'
+import { memuDbFor, memuGlobalDbFor, removeActiveLibrary } from './vector-profile.js'
+import { normalizeEmotion, derivedValence } from './mood.js'
 
 const STATE_FILE = () => path.join(dataDir(), 'state.json')
 const GLOBAL_DB = () => path.join(dataDir(), 'global.sqlite3')
@@ -94,6 +95,12 @@ export const DEFAULT_SETTINGS = {
   // "gone", and short enough that a conversation which ended gets tidied in the
   // same sitting instead of waiting for a quiet hour that may never arrive.
   sleepAfterIdleMinutes: 3,
+  // 主动记忆：分数门槛、饥饿阈值（空闲超过它无条件检查）、两种抑制冷却（分钟；整理冷却默认 0，
+  // 薄证据的重复 fork 由评分拦截，只有用户显式配置才启用硬冷却）。
+  activeMemoryMinScore: 0.8,
+  activeMemoryStarvationMinutes: 15,
+  activeMemoryCooldownMinutes: 0,
+  activeMemoryRecallCooldownMinutes: 15,
   autoCurateEveryHours: 0,
   autoCurateSessionLimit: 8,
   // 'local' keeps every memory on this machine; 'cloud' hands MemU's own backend
@@ -343,6 +350,8 @@ export function updateSettings(patch) {
     mustRememberCap: [1, 100], randomCueChance: [0, 1], shortTermTtlHours: [0, 8760],
     unpinBudgetPerSession: [1, 20], unpinCooldownMinutes: [0, 1440], sleepAfterIdleMinutes: [1, 1440],
     autoCurateEveryHours: [0, 8760], autoCurateSessionLimit: [1, 10], purgeArchivedAfterDays: [0, 36500],
+    activeMemoryMinScore: [0, 10], activeMemoryStarvationMinutes: [1, 1440],
+    activeMemoryCooldownMinutes: [0, 10080], activeMemoryRecallCooldownMinutes: [0, 10080],
   }
   const enums = { autoInject: ['smart', 'anchor-only', 'per-turn', 'off'], memoryMode: ['local', 'cloud'], memoryBackend: ['agent', 'api'], vectorSource: ['local', 'api'], newSessionDefault: ['off', 'auto', 'global', 'both'] }
   for (const [key, value] of Object.entries(patch || {})) {
@@ -541,13 +550,20 @@ export function deleteLibrary(id) {
   const state = loadState()
   if (!state.libraries[id]) return { ok: false, error: 'library not found' }
   if (state.libraries[id].archived !== true) return { ok: false, error: 'archive the library before deleting it' }
+  const activeVectorDb = removeActiveLibrary(id)
+  const legacyVectorDb = path.join(librariesDir(), id + '.sqlite3')
   delete state.libraries[id]
   for (const [sessionId, binding] of Object.entries(state.sessions || {})) {
     if (binding?.libraryId === id) delete state.sessions[sessionId]
   }
   saveState(state)
   const removed = []
-  for (const file of [memoryDbPath(id), ...['json', 'entities.json', 'media.json', 'stats.json'].map(suffix => path.join(indexDir(), `${id}.${suffix}`))]) {
+  const vectorPrefix = id + '.'
+  const vectorGenerationFiles = fs.existsSync(librariesDir())
+    ? fs.readdirSync(librariesDir()).filter(name => name.startsWith(vectorPrefix) && name.endsWith('.sqlite3')).map(name => path.join(librariesDir(), name))
+    : []
+  for (const file of [activeVectorDb, legacyVectorDb, ...vectorGenerationFiles, ...['json', 'entities.json', 'media.json', 'stats.json'].map(suffix => path.join(indexDir(), `${id}.${suffix}`))]) {
+    if (!file) continue
     try {
       if (fs.existsSync(file)) { fs.rmSync(file, { force: true }); removed.push(file) }
     } catch {}
@@ -791,6 +807,8 @@ export function markInjected(sessionId, ids, turn) {
     for (const id of ids || []) at[id] = turn ?? Date.now()
     binding.injectedAt = at
     binding.lastInjectedTurn = turn ?? binding.lastInjectedTurn ?? 0
+    // 主动记忆抑制要一个"最近一次真正注入了记忆"的墙钟时间；turn 号不能跨会话比较。
+    binding.lastInjectedAt = stamp()
     return state
   })
 }
@@ -870,17 +888,16 @@ export function consumeCue(sessionId, cueId) {
   return true
 }
 
-// The session's running mood, kept on the binding rather than in a memory entry:
-// it is a retrieval lens, not a fact about the user, and must never be recalled
-// as a stored memory.
+// The session's running mood is a retrieval lens on the binding, not a fact about
+// the user: it must never be recalled as a stored memory.
 export function setSessionMood(sessionId, mood) {
-  return setSessionBinding(sessionId, {
-    mood: {
-      valence: Math.max(-1, Math.min(1, Number(mood?.valence) || 0)),
-      arousal: Math.max(0, Math.min(1, Number(mood?.arousal) || 0)),
-      at: Date.now(),
-    },
-  })
+  // 给了 emotion 就以四轴为准，valence 只是投影；只有 valence 的旧形状原样存，不反推四轴。
+  const emotion = normalizeEmotion(mood?.emotion ?? null)
+  const bounded = (raw, min, max) => Math.max(min, Math.min(max, Number.isFinite(raw) ? raw : 0)) // 显式 0 是读数的一部分，不能用 `|| 默认值`
+  return setSessionBinding(sessionId, { mood: {
+    valence: emotion ? derivedValence(emotion) : bounded(mood?.valence, -1, 1),
+    emotion, arousal: bounded(mood?.arousal, 0, 1), dominance: bounded(mood?.dominance, -1, 1), at: Date.now(),
+  } })
 }
 
 export function getSessionMood(sessionId) {

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))
+}