@a9i5k4/dsh-auto-memory 2.2.5 → 2.2.7

package/lib/context-host.js

@@ -19,6 +19,7 @@ import {
   buildContextPushEnvelopePre, buildAuthorizedMemoryRefFromRecord, createAccessEvidencePre,
   createCiteEvidencesFromText, createCorrectionEvidencesFromText, computeReadCoverage,
   createContextPushBridge, createNullContextSinkPre, createFakeContextSinkPre,
+  CORRECTION_LEXICON_V1,
   CONTEXT_BRIDGE_BUDGET_V1, CONTEXT_BRIDGE_POLICY_VERSION, EVIDENCE_POLICY_VERSION,
 } from './context-bridge.js'
 import { EvidenceEventStore, rebuildAggregates, workspaceRefOf } from './evidence-store.js'
@@ -41,6 +42,49 @@ function diagCtx(msg) {
   } catch (e) {}
 }
 
+/**
+ * P9a correction 归因选择器(纯函数,零 IO;precision-first):
+ * 从 evidence store 事件(loadEvents 投影形态)里选「最近一条被 cite/read 的记忆」作为
+ * correction 归因对象。用户纠正时几乎不可能手打完整 memoryId,故归因到最近被引用/读取
+ * 的记忆而非用户消息内新找的 id(原 createCorrectionEvidencesFromText 路径保留不动)。
+ * - 只认 kind∈{cite,read} 且带 memoryId;时间窗口 [now-windowMs, +∞),默认 5 分钟;
+ * - 按 ts 降序取第 1 条;ts 平局按 memoryId 升序保证确定性;
+ * - 窗口内已有 correction 的 memoryId 跳过(同一记忆一轮最多一条,防连续段重复惩罚);
+ * - ts 取 event.ts(投影形态);兼容内存形态顶层 ts/createdAt;
+ * - 任何异常/非法输入返回 null(调用方静默不发)。
+ */
+export function selectCorrectionAttributionPre(input) {
+  try {
+    const events = Array.isArray(input && input.events) ? input.events : []
+    const now = Number.isFinite(input && input.now) ? input.now : Date.now()
+    const windowMs = Number.isFinite(input && input.windowMs) && input.windowMs > 0 ? input.windowMs : 300000
+    const cutoff = now - windowMs
+    const correctedRecently = new Set()
+    let best = null
+    let bestTs = -1
+    for (const e of events) {
+      if (!e || typeof e !== 'object') continue
+      if (e.kind === 'correction' && e.memoryId) {
+        const cts = Number(e.event && e.event.ts) || Number(e.ts) || Number(e.createdAt) || 0
+        if (cts >= cutoff) correctedRecently.add(String(e.memoryId))
+      }
+    }
+    for (const e of events) {
+      if (!e || typeof e !== 'object') continue
+      if (e.kind !== 'cite' && e.kind !== 'read') continue
+      if (!e.memoryId) continue
+      if (correctedRecently.has(String(e.memoryId))) continue
+      const ets = Number(e.event && e.event.ts) || Number(e.ts) || Number(e.createdAt) || 0
+      if (ets < cutoff) continue
+      if (!best || ets > bestTs || (ets === bestTs && String(e.memoryId) < String(best.memoryId))) {
+        best = e
+        bestTs = ets
+      }
+    }
+    return best
+  } catch (_) { return null }
+}
+
 export function createContextHost(opts = {}) {
   const engine = opts.engine
   if (!engine) throw new Error('context-host: engine required')
@@ -497,7 +541,36 @@ export function createContextHost(opts = {}) {
     const corrections = seg.kind === 'user'
       ? createCorrectionEvidencesFromText({ text: seg.text, knownRecords: corpusSnap.records, coords })
       : []
-    await persistEvidence([...cites, ...corrections])
+    // P9a:用户段命中纠正词典但文本不含完整 memoryId 时(现实常态),把 correction 归因到
+    // 最近一条被 cite/read 的记忆(5 分钟窗口,同记忆一轮最多一条);无命中静默不发。
+    // 原 cite/correction 产出零改动;store 读取仅在词典命中时发生;fail-soft + diag(不记用户原文)。
+    const attributed = []
+    if (seg.kind === 'user') {
+      let lexHits = 0
+      let attributedPrefix = 'none'
+      try {
+        const norm = String(seg.text == null ? '' : seg.text).normalize('NFKC').replace(/[A-Z]/g, (c) => c.toLowerCase())
+        lexHits = CORRECTION_LEXICON_V1.filter((w) => norm.includes(w)).length
+        if (lexHits > 0) {
+          const st = storeFor()
+          const recent = selectCorrectionAttributionPre({ events: st.loadEvents().events, now: Date.now() })
+          if (recent) {
+            const r = createAccessEvidencePre({
+              ...coords, kind: 'correction', memoryId: recent.memoryId, anchorId: recent.anchorId, scope: recent.scope,
+              sourceRef: recent.source && recent.source.sourceRef, sourceEpoch: recent.source && recent.source.sourceEpoch,
+              sourceVersion: recent.source && recent.source.sourceVersion,
+              fileDigest: recent.source && recent.source.fileDigest, recordDigest: recent.source && recent.source.recordDigest,
+            })
+            if (r.ok) { attributed.push(r.evidence); attributedPrefix = String(recent.memoryId).slice(0, 12) }
+          }
+        }
+      } catch (eP9a) {
+        diagCtx('p9a correction attribution error: ' + String(eP9a && eP9a.message || eP9a).slice(0, 100))
+      }
+      // 隐私:diag 只记词典词计数 + 归因 memoryId 前 12 位,绝不记录用户原文。
+      diagCtx('p9a correction attribution: lexHits=' + lexHits + ' attributed=' + attributedPrefix)
+    }
+    await persistEvidence([...cites, ...corrections, ...attributed])
   }
 
   /**
@@ -696,7 +769,9 @@ export function createContextHost(opts = {}) {
         const cutoff = Date.now() - (Number(windowMs) || 300000)
         const out = new Map()
         for (const e of events) {
-          const ets = e.ts || e.createdAt || 0
+          // P9d:store 投影事件 ts 在 event.ts(顶层无 ts/createdAt),与 selectCorrectionAttributionPre 同口径;
+          // 旧写法 e.ts || e.createdAt || 0 恒为 0 → 窗口全跳过 → success 证据链结构性断裂。
+          const ets = Number(e.event && e.event.ts) || Number(e.ts) || Number(e.createdAt) || 0
           if (ets < cutoff) continue
           if (e.kind !== 'read' && e.kind !== 'cite') continue
           if (!e.memoryId) continue

package/lib/evidence-agg.js

@@ -0,0 +1,81 @@
+/**
+ * evidence-agg-pre —— evidence 事件 → 聚合 → importance 输入契约(M8-2b, 2026-09-09)。
+ *
+ * 管道:evidence/events/*.jsonl(写入侧 context-bridge-pre,只读)→ 有界扫描 →
+ * 按 memoryId 聚合六类计数 + distinctSessions → 交给 memory-importance-pre.computeImportancePre
+ * → 作为 recall() L0 融合的加权因子之一(P8 融合入口)。
+ *
+ * 契约:
+ *   - 纯函数 + IO 注入(io = { listFiles(), readFile(name) }),模块零内置 IO、零写入。
+ *   - 有界读取:文件名日期在窗口内(默认近 7 天)且每文件只取末 N 行(默认 400),绝不全量扫描历史。
+ *     文件名约定 YYYY-MM-DD.jsonl(EvidenceEventStore 落盘惯例,实测样本确认);无法解析日期的文件跳过(确定性)。
+ *   - 事件行结构(实测 2026-09-09.jsonl 确认):kind/memoryId 在顶层,会话= event.sessionRef,时间= event.ts。
+ *   - 聚合输出形状 = memory-importance-pre.computeImportancePre 的输入契约(以其源码为准,不另立)。
+ *   - fail-soft:行损坏跳过;io 抛错由调用方处理(模块内不吞 IO 异常——io 是注入的,调用方决定降级)。
+ */
+
+export const EVIDENCE_AGG_VERSION = 'evidence_agg_v1'
+
+/** 有界读取默认值。 */
+export const EVIDENCE_AGG_DEFAULTS_V1 = Object.freeze({
+  maxAgeDays: 7, // 文件名日期距 now 的最大天数
+  maxLinesPerFile: 400, // 每文件末 N 行(沿用 index.js 证据读取范式 slice(-400))
+})
+
+const KINDS = ['seen', 'read', 'cite', 'reuse', 'success', 'correction']
+
+/**
+ * 有界扫描 evidence 事件(只读)。io 注入;文件按名字日期过滤 + 每文件末 N 行。
+ * @param {{listFiles:Function, readFile:Function}} io listFiles()→文件名数组;readFile(name)→全文
+ * @param {{maxAgeDays?:number, maxLinesPerFile?:number, now?:Function}} opts
+ * @returns {Array<object>} 解析后的事件对象(损坏行跳过;任何字段缺失由聚合层兜底)
+ */
+export function scanEvidenceEventsPre(io, opts = {}) {
+  const d = Object.assign({}, EVIDENCE_AGG_DEFAULTS_V1, opts)
+  const now = d.now || Date.now
+  const files = (io.listFiles() || []).slice().sort()
+  const cutoff = now() - d.maxAgeDays * 86400000
+  const out = []
+  for (const name of files) {
+    const m = /^(\d{4})-(\d{2})-(\d{2})\.jsonl$/.exec(String(name))
+    if (!m) continue // 非日期命名 → 跳过(确定性;不做全量兜底)
+    const fileTs = Date.UTC(Number(m[1]), Number(m[2]) - 1, Number(m[3]), 23, 59, 59)
+    if (fileTs < cutoff) continue
+    const lines = String(io.readFile(name) || '').split('\n').filter(Boolean)
+    for (const ln of lines.slice(-d.maxLinesPerFile)) {
+      try { out.push(JSON.parse(ln)) } catch (_) {}
+    }
+  }
+  return out
+}
+
+/**
+ * 按 memoryId 聚合六类计数与去重会话数。输出形状 = computeImportancePre 的输入契约。
+ * @param {Array<{kind?:string, memoryId?:string, event?:{sessionRef?:string}, sessionRef?:string}>} events
+ * @returns {Map<string, {distinctSessions:number, seen:number, read:number, cite:number, reuse:number, success:number, correction:number}>}
+ */
+export function aggregateEvidenceEventsPre(events) {
+  const list = Array.isArray(events) ? events : []
+  const byId = new Map()
+  for (const e of list) {
+    if (!e || typeof e.memoryId !== 'string' || !e.memoryId) continue
+    const kind = e.kind
+    if (!KINDS.includes(kind)) continue // 非六类事件不计数(与 evidenceFor 口径一致)
+    let agg = byId.get(e.memoryId)
+    if (!agg) {
+      agg = { distinctSessions: 0, seen: 0, read: 0, cite: 0, reuse: 0, success: 0, correction: 0 }
+      byId.set(e.memoryId, agg)
+    }
+    agg[kind]++
+    const sessionRef = (e.event && e.event.sessionRef) || e.sessionRef
+    if (sessionRef) {
+      if (!agg._sessions) agg._sessions = new Set()
+      agg._sessions.add(sessionRef)
+    }
+  }
+  for (const agg of byId.values()) {
+    agg.distinctSessions = agg._sessions ? agg._sessions.size : 0
+    delete agg._sessions
+  }
+  return byId
+}

package/lib/fact-store.js

@@ -37,6 +37,12 @@ export const FACT_ID_RE = /^fact_[0-9a-f]{32}$/
 /** scope 枚举: 与 M5/M6 的 scope 对齐(User=跨工作区, Workspace=当前工作区)。 */
 export const FACT_SCOPES_V1 = Object.freeze(['User', 'Workspace'])
 
+/** M8-1 认识论状态枚举: fact=证据/不可推导, observation=推断/可重算, directive=行为指令。 */
+export const FACT_EPISTEMIC_STATUSES_V1 = Object.freeze(['fact', 'observation', 'directive'])
+
+/** M8-1 趋势枚举: 相对上次确认的生命周期走向。 */
+export const FACT_TRENDS_V1 = Object.freeze(['new', 'strengthening', 'stable', 'weakening', 'stale'])
+
 /** sourceClass 枚举: 与 m4-corpus-pre 的 sourceClass 对齐。 */
 export const FACT_SOURCE_CLASSES_V1 = Object.freeze([
   'user-memory', 'workspace-notes', 'workspace-log', 'semantic-candidate', 'profile-candidate',
@@ -69,6 +75,12 @@ export function validateFactCandidatePre(cand) {
   if (cand.provenance !== undefined && (!Array.isArray(cand.provenance) || cand.provenance.some((s) => typeof s !== 'string'))) p.push('provenance')
   if (cand.confidence !== undefined && (typeof cand.confidence !== 'number' || !Number.isFinite(cand.confidence) || cand.confidence < 0 || cand.confidence > 1)) p.push('confidence')
   if (cand.ttl !== undefined && (typeof cand.ttl !== 'number' || !Number.isFinite(cand.ttl) || cand.ttl < 0)) p.push('ttl')
+  // M8-1 时间三价 + 认识论状态 + 趋势(全部可选;缺省放行 → 旧结构/旧调用方不受影响)
+  for (const k of ['occurredAt', 'mentionedAt', 'ingestedAt']) {
+    if (cand[k] !== undefined && (typeof cand[k] !== 'number' || !Number.isFinite(cand[k]) || cand[k] < 0)) p.push(k)
+  }
+  if (cand.epistemicStatus !== undefined && !FACT_EPISTEMIC_STATUSES_V1.includes(cand.epistemicStatus)) p.push('epistemicStatus')
+  if (cand.trend !== undefined && !FACT_TRENDS_V1.includes(cand.trend)) p.push('trend')
   if (p.length) return { ok: false, reason: 'invalid:' + p.join(',') }
   return { ok: true, candidate: cand }
 }
@@ -89,6 +101,12 @@ export function validateFactPre(fact) {
   if (typeof fact.confirmedAt !== 'number' || !Number.isFinite(fact.confirmedAt)) p.push('confirmedAt')
   if (fact.ttl !== undefined && (typeof fact.ttl !== 'number' || !Number.isFinite(fact.ttl))) p.push('ttl')
   if (fact.revoked !== undefined && typeof fact.revoked !== 'boolean') p.push('revoked')
+  // M8-1 新字段(全部可选;缺字段=旧数据,放行 → 既有 facts.json 可读,不报错不丢弃)
+  for (const k of ['occurredAt', 'mentionedAt', 'ingestedAt']) {
+    if (fact[k] !== undefined && (typeof fact[k] !== 'number' || !Number.isFinite(fact[k]))) p.push(k)
+  }
+  if (fact.epistemicStatus !== undefined && !FACT_EPISTEMIC_STATUSES_V1.includes(fact.epistemicStatus)) p.push('epistemicStatus')
+  if (fact.trend !== undefined && !FACT_TRENDS_V1.includes(fact.trend)) p.push('trend')
   if (p.length) return { ok: false, reason: 'invalid:' + p.join(',') }
   return { ok: true, fact }
 }
@@ -190,6 +208,12 @@ export function createFactStorePre(opts = {}) {
         confidence: c.confidence !== undefined ? c.confidence : null,
         confirmedAt: now, ttl: c.ttl !== undefined ? c.ttl : FACT_TTL_DEFAULT_V1,
         revoked: false,
+        // M8-1 时间三价:入库时间必填(=本次确认);发生/陈述时间候选提供则透传,缺省 undefined(落盘时省略)
+        ingestedAt: now,
+        occurredAt: c.occurredAt,
+        mentionedAt: c.mentionedAt,
+        ...(c.epistemicStatus !== undefined ? { epistemicStatus: c.epistemicStatus } : {}),
+        ...(c.trend !== undefined ? { trend: c.trend } : {}),
       }
       const fv = validateFactPre(fact)
       if (!fv.ok) return { ok: false, reason: 'fact-invalid:' + fv.reason, outcome: 'invalid' }
@@ -210,7 +234,15 @@ export function createFactStorePre(opts = {}) {
       for (const s of c.provenance) if (!seen.has(s)) prev.provenance.push(s)
     }
     if (c.confidence !== undefined && c.confidence !== null) prev.confidence = c.confidence
+    // M8-1 向后兼容回填(须在 confirmedAt 更新前执行):旧记录(无 ingestedAt)首次合并时补齐,
+    // 取其原始确认时间(=首次入库);不改变其余合并语义
+    if (prev.ingestedAt === undefined && Number.isFinite(prev.confirmedAt)) prev.ingestedAt = prev.confirmedAt
     prev.confirmedAt = now // 合并视为重新确认
+    // M8-1 可选元数据透传:重新陈述时更新发生/陈述时间与认识论状态/趋势(候选提供才写,加法性)
+    if (c.occurredAt !== undefined) prev.occurredAt = c.occurredAt
+    if (c.mentionedAt !== undefined) prev.mentionedAt = c.mentionedAt
+    if (c.epistemicStatus !== undefined) prev.epistemicStatus = c.epistemicStatus
+    if (c.trend !== undefined) prev.trend = c.trend
     if (c.ttl !== undefined) prev.ttl = c.ttl
     stats.merged++
     void persist()

package/lib/handoff-anchor.js

@@ -0,0 +1,114 @@
+/**
+ * P6(2026-09-09) 账本权重化截断纯核心(handoff_ledger_weight_v1)。
+ *
+ * 背景:buildContinueCarry 的 `ledger.slice(0, 8000)` 是位置截断,而账本段内异质——
+ * 位置截可能把高价值段整体截掉(M-CM7 §C/§G4)。本模块按账本自身四段标题赋权:
+ *   已试方案与失败原因 .35 > 进度与下一步 .30 > 目标 .20 > 任务状态 .15
+ * 预算不足时从最低权重段开始截(保留段标题行),预算充足时逐字节原样返回。
+ *
+ * 契约:
+ *   - 标题字符串来自账本文件本身(写入侧骨架逐字一致),不做内容语义标注——禁止把"成功解法"误标为"失败原因"。
+ *   - 纯函数、零 IO、零依赖;同输入逐字节确定;非法输入 fail closed(返回 null,调用方回落位置截断)。
+ *   - 只影响注入,不动文件原文。
+ */
+
+export const HANDOFF_LEDGER_WEIGHT_VERSION = 'handoff_ledger_weight_v1'
+
+/** 四段标题 → 权重(降序)。标题为账本中的原样标题行(半角 '## '+单空格,不含行尾 \r)。 */
+export const HANDOFF_LEDGER_SECTION_WEIGHTS_V1 = Object.freeze([
+  Object.freeze({ title: '已试方案与失败原因', weight: 0.35 }),
+  Object.freeze({ title: '进度与下一步', weight: 0.30 }),
+  Object.freeze({ title: '目标', weight: 0.20 }),
+  Object.freeze({ title: '任务状态', weight: 0.15 }),
+])
+
+const TITLE_WEIGHT = new Map(HANDOFF_LEDGER_SECTION_WEIGHTS_V1.map((x) => [x.title, x.weight]))
+/** 未知 '## ' 段:权重最低(最先被截),但仍保留标题与内容直到轮到它。 */
+const UNKNOWN_WEIGHT = 0.05
+const TRIM_MARK = '…(已按预算截断,全文见 handoff/ 最新账本)'
+
+function weightOf(titleText) {
+  const name = String(titleText || '').replace(/^##\s*/, '').replace(/\s+$/, '')
+  return TITLE_WEIGHT.has(name) ? TITLE_WEIGHT.get(name) : UNKNOWN_WEIGHT
+}
+
+/**
+ * 解析账本四段。行级切分:遇到 `## ` 开头行即开新段;首个标题行之前的内容为 preamble(如 `# 交接账本 · …` 大标题)。
+ * title 保留原样行(含 '## ' 前缀,容忍尾随 \r);body 为两标题行之间的原始行(不做 trim,保证原样回装)。
+ * @returns {{preamble: string[], sections: Array<{title: string, body: string[], weight: number}>} | null}
+ *  无任何 '## ' 段或输入非法 → null(fail closed)。
+ */
+export function parseHandoffLedgerPre(text) {
+  const src = typeof text === 'string' ? text : ''
+  if (!src.trim()) return null
+  const lines = src.split('\n')
+  const preamble = []
+  const sections = []
+  let cur = null
+  for (const line of lines) {
+    if (/^## (.+)$/.test(line.replace(/\r$/, ''))) {
+      if (cur) sections.push(cur)
+      cur = { title: line, body: [], weight: weightOf(line) }
+    } else if (cur) cur.body.push(line)
+    else preamble.push(line)
+  }
+  if (cur) sections.push(cur)
+  if (!sections.length) return null
+  return { preamble, sections }
+}
+
+/** 回装:preamble + 各段(title 行 + body 行)以 \n 连接;对无 \r 输入逐字节还原原文本。 */
+function assemble(preamble, sections) {
+  const parts = []
+  if (preamble.length) parts.push(preamble.join('\n'))
+  for (const s of sections) parts.push(s.body.length ? s.title + '\n' + s.body.join('\n') : s.title)
+  return parts.join('\n')
+}
+
+/** 段内按行收缩:从 body 尾部丢行(保头部,与 slice(0,N) 语义一致),返回新 body(≤keepChars 字符)。 */
+function shrinkBody(body, keepChars) {
+  if (keepChars <= 0) return []
+  const out = []
+  let used = 0
+  for (let i = 0; i < body.length; i++) {
+    const cost = body[i].length + (i > 0 ? 1 : 0)
+    if (used + cost > keepChars) break
+    out.push(body[i])
+    used += cost
+  }
+  return out
+}
+
+/**
+ * 权重化截断。预算充足(原文 ≤budget)→ 返回与原文逐字节相同的字符串;
+ * 不足 → 从最低权重段开始截 body(段标题保留,截点带 TRIM_MARK),直到进入预算;
+ * 全部段收缩后仍超预算(如 preamble/标题行本身超限)→ 最后回落 `slice(0, budget)`。
+ * 解析失败(非法输入/无已知段结构)→ 返回 null,调用方自行回落。
+ * @param {string} text 账本全文
+ * @param {number} budget 注入预算(字符)
+ * @returns {string | null}
+ */
+export function weightedTrimHandoffLedgerPre(text, budget) {
+  const b = Number(budget)
+  if (!Number.isFinite(b) || b <= 0) return null
+  const parsed = parseHandoffLedgerPre(text)
+  if (!parsed) return null
+  const original = assemble(parsed.preamble, parsed.sections)
+  if (original.length <= b) return original
+
+  // 截断顺序:权重升序(稳定:同权重保持文内出现顺序)
+  const order = parsed.sections.map((s, i) => ({ s, i })).sort((x, y) => x.s.weight - y.s.weight || x.i - y.i)
+  const markCost = TRIM_MARK.length + 1 // 截点换行 + marker 本身,预留避免逐段收敛震荡
+  for (const { s } of order) {
+    const current = assemble(parsed.preamble, parsed.sections)
+    if (current.length <= b) break
+    const bodyLen = s.body.join('\n').length
+    if (bodyLen <= 0) continue
+    const excess = current.length - b
+    const keep = Math.max(0, bodyLen - excess - markCost)
+    s.body = shrinkBody(s.body, keep)
+    s.body = s.body.length ? s.body.concat([TRIM_MARK]) : [TRIM_MARK]
+  }
+  const out = assemble(parsed.preamble, parsed.sections)
+  return out.length <= b ? out : out.slice(0, b)
+}