@yolk_vat-y/dsh-project-memory 0.5.5 → 0.5.7

package/src/readiness.js

@@ -16,6 +16,9 @@
  * @module dsh-project-memory/readiness
  */
 
+import { FALLBACK_OPS, WEAK_OPS, activityFromText, opForLegacyAction } from './ops.js'
+import { CJK_RANGE, tokenize } from './util/search.js'
+
 /**
  * 动作词典：动作 id → 匹配模式。命令形态与人类意图词都归一成同一套 id，
  * 于是"你顺便提交一下"与 `git commit -m x` 对 trigger 是同一件事。
@@ -79,8 +82,37 @@ export function buildReadinessContext(input = {}) {
   const humanText = String(input.humanText ?? input.query ?? '')
   const actionText = String(input.actionText || '')
   const actions = new Set([...(input.actions || []), ...detectActions(humanText), ...detectActions(actionText)])
-  const paths = new Set([...(input.paths || []), ...extractPaths(actionText), ...extractPaths(humanText)])
-  return { humanText, actionText, actions: [...actions], paths: [...paths] }
+  // 人类消息里提到的路径 = **动手前的写意图**（"帮我改 src/x.js"）；动作文本里的路径不区分读写，
+  // 读一个文件不该算写目标（否则 `read README.md` 会命中 writes:['README.md']）。
+  // 两者对外仍合并成 `paths`（兼容既有语义），写通道单看 humanPaths。
+  // 调用方若已带 humanPaths（injectForStep 构建后再传给 buildInjection），以它为准，
+  // 否则退回 paths —— 避免把上一次算出来的并集（含读路径）再当写意图。
+  const humanPaths = new Set([
+    ...(Array.isArray(input.humanPaths) ? input.humanPaths : (input.paths || [])),
+    ...extractPaths(humanText),
+  ])
+  const paths = new Set([...humanPaths, ...extractPaths(actionText)])
+  // 动作平面（S1）：结构化调用优先；没有结构化调用时对 actionText 跑一遍 shell 规则兜底。
+  const fromText = activityFromText(actionText)
+  const ops = new Set([...(input.ops || []), ...fromText.ops])
+  for (const a of actions) {
+    const op = opForLegacyAction(a)
+    if (op) ops.add(op)
+  }
+  const targets = new Set([...(input.targets || []), ...fromText.targets])
+  const hosts = new Set([...(input.hosts || []), ...fromText.hosts])
+  return {
+    humanText,
+    actionText,
+    actions: [...actions],
+    paths: [...paths],
+    humanPaths: [...humanPaths],
+    ops: [...ops],
+    targets: [...targets],
+    hosts: [...hosts],
+    intent: intentText(humanText),
+    tags: Array.isArray(input.tags) ? [...input.tags] : [],
+  }
 }
 
 /**
@@ -145,12 +177,12 @@ export function backfillDerivedTriggers(doc) {
 }
 
 /**
- * 提示通道的查询文本：剔除 1–2 个字符的拉丁 token。
+ * 提示通道的查询文本：剔除 1–3 个字符的拉丁 token。
  *
- * 为什么：`PR` / `CI` / `OS` 这类缩写太短、歧义太大，一个巧合命中就能当上该层最高分，
- * 于是以 `relative:1.00` 混进上下文（实测：人类消息里的 "PR" 把一条 task-tools 越权 lesson
- * 顶到了提示位）。内容词（≥3 字符的拉丁标识符、CJK 词）不受影响；
- * authored trigger 通道完全不走这里，确定性匹配保持字面语义。
+ * 为什么：`PR` / `CI` / `OS` / `WSL` / `npm` 这类缩写太短、歧义太大，一个巧合命中就能当上
+ * 该层最高分，于是以 `relative:1.00` 混进上下文（实测：人类消息里的 "PR" 把一条 task-tools
+ * 越权 lesson 顶到了提示位；"wsl" 又把一条 pnpm lesson 顶到了"改文件时间戳"的任务里）。
+ * 内容词（≥4 字符的拉丁标识符、CJK 词）不受影响；authored trigger 通道完全不走这里。
  * @param {string} text - 人类消息或工具参数。
  * @returns {string} 过滤后的查询文本。
  */
@@ -159,7 +191,7 @@ export function hintQueryText(text) {
     .split(/\s+/)
     // 路径形态的 token 原样保留（src/util/fs.js 里的 fs / js 是有效证据），
     // 只对独立词做缩写剔除。
-    .map((w) => (/[/.]/.test(w) ? w : w.replace(/\b[A-Za-z0-9_]{1,2}\b/g, ' ')))
+    .map((w) => (/[/.]/.test(w) ? w : w.replace(/\b[A-Za-z0-9_]{1,3}\b/g, ' ')))
     .join(' ')
     .replace(/\s+/g, ' ')
     .trim()
@@ -172,42 +204,275 @@ function globToRegExp(pattern) {
 }
 
 /**
- * trigger 命中判定（确定性，无打分）。
- * @param {object|null} trigger - `{ keywords?, symbols?, actions?, paths?, scope? }`。
- * @param {object} ctx - {@link buildReadinessContext} 的结果。
- * @returns {string|null} 命中原因（`keyword:…` / `symbol:…` / `action:…` / `path:…`），未命中为 null。
+ * 剥离**引用内容**：代码块、行内代码、引号内的路径/文件名、裸路径。
+ *
+ * 为什么必须剥：人类消息里的文件名是**数据**，不是意图。实测中"石啸天-LLM记忆方向调研.pptx"
+ * 这个文件名让一条"做调研要先扫 curated 列表"的经验在改文件时间戳的任务里被注入。
+ * @param {string} text - 人类消息原文
+ * @returns {string} 只保留意图文字的版本
  */
-export function matchTrigger(trigger, ctx) {
-  if (!trigger) return null
-  const haystack = `${ctx?.humanText || ''}\n${ctx?.actionText || ''}`
-  const lower = haystack.toLowerCase()
-  for (const kw of trigger.keywords || []) {
-    const k = String(kw || '')
-    if (k && lower.includes(k.toLowerCase())) return `keyword:${k}`
+export function intentText(text) {
+  return String(text || '')
+    .replace(/```[\s\S]*?```/g, ' ')
+    .replace(/`[^`]*`/g, ' ')
+    .replace(/"[^"\n]*"/g, ' ')
+    .replace(/“[^”\n]*”/g, ' ')
+    .replace(/[A-Za-z]:\\[^\s"']*/g, ' ')
+    .replace(/(?:[A-Za-z0-9_.@-]+\/)+[A-Za-z0-9_.@-]+/g, ' ')
+    // 带扩展名的**非 ASCII 文件名**（`石啸天-记忆方向调研.pptx` / `docs/面试演示-王金鹏.md`）：
+    // 只挡 ASCII 路径不够——中文文件名整块留下，"调研""面试"这类子串照样触发 when.intents，
+    // 正是引号剥离要防的那类假阳性。ASCII 裸名（如 de-TODO.md）保持原语义，不在这里动。
+    .replace(/\S*[^\x00-\x7F]\S*\.[A-Za-z][A-Za-z0-9]{0,7}\b/g, ' ')
+    // 仓库里的裸文件名（README / CHANGELOG …）也是语料，不是意图
+    .replace(/\b(?:README|CHANGELOG|LICENSE|AGENTS|CONTRIBUTING|Dockerfile|Makefile)\b/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+}
+
+/**
+ * 意图词是否值得作为触发信号（S2 的准入过滤）。
+ *
+ * 规则来自实测：`rm` 命中 `dcterms`、`ppt` 命中 `pptx`、`ms` 命中任何含 ms 的词——短拉丁词
+ * 是假阳性制造机；含 `_`/`.`/`/` 的是标识符或路径，属于语料平面，不是意图。
+ */
+export function isIntentWord(word) {
+  const s = String(word || '').trim()
+  if (!s) return false
+  if (CJK_RANGE.test(s)) return s.length >= 2
+  if (s.length < 5) return false
+  if (/[_./\\*]/.test(s)) return false
+  if (/\s/.test(s)) return s.length >= 8
+  return true
+}
+
+const GLOB_RE = /\*/
+/** 扩展名 glob（`*.pptx`）与泛名 glob（`README*`）：只能撒谎，不能收窄。 */
+export function isDroppableGlob(pattern) {
+  const p = String(pattern || '')
+  if (!GLOB_RE.test(p)) return false
+  if (/^\*\.\w+$/.test(p)) return true
+  if (/^[A-Za-z][A-Za-z0-9_-]*\*$/.test(p)) return true
+  return false
+}
+
+/**
+ * 意图词命中：CJK 用包含，拉丁用词边界（避免 `ppt` 命中 `pptx`）。
+ * @param {string} word
+ * @param {string} text - 已经是 {@link intentText} 处理过的意图文本
+ */
+export function matchIntent(word, text) {
+  const w = String(word || '').trim()
+  const hay = String(text || '')
+  if (!w || !hay) return false
+  if (CJK_RANGE.test(w)) return w.length >= 2 && hay.includes(w)
+  if (w.length < 4) return false
+  const esc = w.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  return new RegExp(`(^|[^A-Za-z0-9_])${esc}([^A-Za-z0-9_]|$)`, 'i').test(hay)
+}
+
+function matchAnyPath(pattern, targets) {
+  const p = String(pattern || '')
+  if (!p) return false
+  const re = globToRegExp(p)
+  return (targets || []).some((cand) => {
+    const c = String(cand || '')
+    if (!c) return false
+    return re.test(c) || re.test(c.split(/[\\/]/).pop() || '')
+  })
+}
+
+/** guard 是**收窄**条件：全部满足才放行；它自己不能触发任何东西。 */
+function guardPass(guard, ctx) {
+  if (!guard || typeof guard !== 'object') return true
+  const targets = ctx?.targets || []
+  if (Array.isArray(guard.paths) && guard.paths.length && !guard.paths.some((p) => matchAnyPath(p, targets))) return false
+  if (Array.isArray(guard.not_paths) && guard.not_paths.some((p) => matchAnyPath(p, targets))) return false
+  if (Array.isArray(guard.hosts) && guard.hosts.length && !guard.hosts.some((h) => (ctx?.hosts || []).includes(String(h)))) return false
+  if (Array.isArray(guard.tags) && guard.tags.length) {
+    const tags = ctx?.tags || []
+    // 画像未知（tags 为空）时不过滤：这是既有语义，保持兼容。
+    if (tags.length && !guard.tags.some((t) => tags.includes(String(t)))) return false
   }
-  for (const sym of trigger.symbols || []) {
-    const s = String(sym || '')
-    if (s && haystack.includes(s)) return `symbol:${s}`
+  return true
+}
+
+/**
+ * trigger 命中判定（确定性，无打分）——**准入化后的语义**。
+ *
+ * `when` 是唯一的触发面，三个成员按 OR：`ops`（动作）／`writes`（本次要写的文件）／
+ * `intents`（人类消息里剥离引用后的意图词）。`guard` 只能收窄。
+ * **没有 `when` 的条目不再触发任何东西**（降级为可发现 + 按需拉取）。
+ *
+ * @param {object|null} trigger
+ * @param {object} ctx - {@link buildReadinessContext} 的结果
+ * @returns {string|null} 命中原因（`op:…` / `write:…` / `intent:…`），未命中为 null
+ */
+export function matchTrigger(trigger, ctx) {
+  if (!trigger || typeof trigger !== 'object') return null
+  const when = trigger.when
+  if (!when || typeof when !== 'object') return null
+  if (!guardPass(trigger.guard, ctx)) return null
+  for (const op of when.ops || []) {
+    if (op && (ctx?.ops || []).includes(String(op))) return `op:${op}`
   }
-  const actions = new Set(ctx?.actions || [])
-  for (const a of trigger.actions || []) {
-    const id = String(a || '')
-    if (id && actions.has(id)) return `action:${id}`
+  // 写目标 = 已观察到的结构化写调用 ∪ 人类消息里提到的路径（动手前的写意图）。
+  // DSH 没有工具执行前拦截钩子，动手前唯一能拿到的写意图就是人类消息里的路径；
+  // 但动作文本里的**读**路径不算（`read README.md` 不是"即将写 README.md"）。
+  const writeTargets = [...(ctx?.targets || []), ...(ctx?.humanPaths || [])]
+  for (const w of when.writes || []) {
+    // 扩展名/泛名 glob 在这里被硬性忽略：`*.pptx` 这类条件只能撒谎，不能收窄。
+    if (!w || isDroppableGlob(w)) continue
+    if (matchAnyPath(w, writeTargets)) return `write:${w}`
   }
-  for (const p of trigger.paths || []) {
-    const pattern = String(p || '')
-    if (!pattern) continue
-    const re = globToRegExp(pattern)
-    const hit = (ctx?.paths || []).some((cand) => {
-      const c = String(cand || '')
-      if (!c) return false
-      return re.test(c) || re.test(c.split(/[\\/]/).pop() || '')
-    })
-    if (hit) return `path:${pattern}`
+  const intent = ctx?.intent ?? ctx?.humanText ?? ''
+  for (const it of when.intents || []) {
+    if (it && matchIntent(it, intent)) return `intent:${it}`
   }
   return null
 }
 
+/**
+ * 旧 trigger → 新 schema（纯函数、幂等、不改原对象）。
+ *
+ * 迁移规则（都在实测里有据）：
+ *   - `actions` → `when.ops`（经 {@link opForLegacyAction} 映射；死值记录进 `triggerNormalized.dropped`）
+ *   - 具体的 `paths` → `when.writes`（"我要改这个文件"）；扩展名/泛名 glob 直接丢弃
+ *   - `keywords` → `when.intents`，只留通过 {@link isIntentWord} 的
+ *   - `scope` → 默认忽略（它的值不在项目画像 tag 空间里，实测把最相关的一条 procedure 判了死刑）
+ *
+ * @param {object} it
+ * @param {{legacyScope?: 'ignore'|'filter'}} [opts]
+ */
+export function normalizeTrigger(it, opts = {}) {
+  const t = it && it.trigger
+  if (!t || typeof t !== 'object') return it
+  if (t.when && typeof t.when === 'object') return it // 已是新 schema：幂等
+  const dropped = []
+  const writes = []
+  for (const p of t.paths || []) {
+    if (!p) continue
+    if (isDroppableGlob(p)) dropped.push(`path:${p}`)
+    else writes.push(String(p))
+  }
+  const ops = new Set()
+  for (const a of t.actions || []) {
+    const op = opForLegacyAction(a)
+    if (!op) {
+      dropped.push(`action:${a}`)
+      continue
+    }
+    // 有精确 writes 时丢掉弱 op：留着它只会把"改这个文件时"扩大成"任何一次提交时"。
+    if (writes.length && WEAK_OPS.has(op)) {
+      dropped.push(`weak-action:${a}`)
+      continue
+    }
+    ops.add(op)
+  }
+  // 具体路径只写进 `when.writes`，**不要**再补一个 `file-write` 到 ops：
+  // when 的成员是取或的，补进去等于让"写了任何文件"就命中，把路径条件短路掉
+  // （实测：那样会让 D 场景一次多出 6 条假阳性）。
+  const intents = []
+  for (const k of t.keywords || []) if (isIntentWord(k)) intents.push(String(k))
+  // 旧 `symbols` 也走文本平面：不归一就等于静默丢掉一个作者写下的触发面
+  // （README 承诺 keywords/symbols/actions/paths/scope 都会迁移）。与 keywords 同一把准入尺子。
+  for (const s of t.symbols || []) if (isIntentWord(s)) intents.push(String(s))
+  const when = {}
+  if (ops.size) when.ops = [...ops].sort()
+  if (writes.length) when.writes = [...new Set(writes)]
+  if (intents.length) when.intents = [...new Set(intents)]
+  const out = { ...t, when }
+  const scopeIgnored = Array.isArray(t.scope) && t.scope.length > 0
+  if (scopeIgnored && opts.legacyScope !== 'ignore') out.guard = { ...(t.guard || {}), tags: t.scope }
+  return { ...it, trigger: out, triggerNormalized: { dropped, scopeIgnored } }
+}
+
+/**
+ * trigger 自检（S5）：把"哪些条目其实推不动、哪些声明是死的"变成可数的事实。
+ * @param {object[]} items
+ */
+export function auditTriggers(items, opts = {}) {
+  const out = {
+    total: 0,
+    pushable: 0,
+    pullOnly: [],
+    deadActions: [],
+    droppedGlobs: [],
+    weakDropped: [],
+    fallbackOps: [],
+    scopeIgnored: [],
+    missingPrevents: [],
+  }
+  for (const raw of items || []) {
+    if (!raw || !raw.id) continue
+    out.total++
+    const it = normalizeTrigger(raw, opts)
+    const meta = it.triggerNormalized || {}
+    for (const d of meta.dropped || []) {
+      if (d.startsWith('action:')) out.deadActions.push({ id: it.id, value: d.slice(7) })
+      else if (d.startsWith('path:')) out.droppedGlobs.push({ id: it.id, value: d.slice(5) })
+      else if (d.startsWith('weak-action:')) out.weakDropped.push({ id: it.id, value: d.slice(12) })
+    }
+    if (meta.scopeIgnored) out.scopeIgnored.push(it.id)
+    const when = it.trigger?.when
+    for (const w of when?.writes || []) {
+      if (isDroppableGlob(w)) out.droppedGlobs.push({ id: it.id, value: w })
+    }
+    const hasWhen = Boolean(when && ((when.ops || []).length || (when.writes || []).length || (when.intents || []).length))
+    if (hasWhen) {
+      out.pushable++
+      // 兜底 op 出现在 when.ops 里：不是错误，但这条触发面比它看起来宽得多。
+      const fb = (when.ops || []).filter((o) => FALLBACK_OPS.has(o))
+      if (fb.length) out.fallbackOps.push({ id: it.id, ops: fb })
+    } else {
+      out.pullOnly.push(it.id)
+    }
+    if (!it.trigger?.prevents) out.missingPrevents.push(it.id)
+  }
+  return out
+}
+
+/**
+ * IDF 加权覆盖率（S4 的**绝对**门槛）：条目覆盖了查询里多少**信息量**，而不是多少个 token。
+ *
+ * 为什么需要它：`relativeHits` 只看"层内最高分的比例"，而最高分本身可能就是噪声——
+ * 实测 `relative:1.00` 出现在和查询毫无关系的条目上。归一在 [0,1]、有真零点，才能设下限。
+ *
+ * 返回四个量，调用方要一起看：
+ *   - `coverage`：在**语料能表示**的词里，条目覆盖了多少信息量（分母不含 df=0 的词——
+ *     自然语言查询总有语料没有的词，把它们算成未命中会让任何正常查询都趋零）。
+ *   - `matched`：命中的词数。单个通用词（"插件"）也能拿到 coverage=1.00。
+ *   - `supported` / `terms`：语料里有对应词的比例。长句子里只有一两个词能在语料中找到对应时，
+ *     "覆盖率 1.00"是假象（实测：一句 19 个词的改时间戳请求，只与 WSL 笔记共享一个"文件"，
+ *     却拿到 cov=1.00），调用方据此让**整条通道沉默**。
+ * @returns {{coverage: number, matched: number, supported: number, terms: number}}
+ */
+export function idfCoverage(query, itemText, corpusTexts) {
+  const q = [...new Set(tokenize(query))]
+  if (!q.length) return { coverage: 0, matched: 0, supported: 0, terms: 0 }
+  const item = new Set(tokenize(itemText))
+  const corpus = (corpusTexts || []).map((t) => new Set(tokenize(t)))
+  const n = Math.max(corpus.length, 1)
+  let total = 0
+  let hit = 0
+  let matched = 0
+  let supported = 0
+  for (const term of q) {
+    let df = 0
+    for (const doc of corpus) if (doc.has(term)) df++
+    // df=0 的词不计入分母：它对"选哪一条"没有分辨力。但 supported 会记下有多少词是
+    // 语料根本无法表示的——那是"这条查询整体上离语料太远"的证据，交给调用方决定沉默。
+    if (df === 0) continue
+    supported++
+    const w = Math.log(1 + n / (1 + df))
+    total += w
+    if (item.has(term)) {
+      hit += w
+      matched++
+    }
+  }
+  return { coverage: total > 0 ? hit / total : 0, matched, supported, terms: q.length }
+}
+
 /**
  * 层内相对阈值：命中分至少达到该层最高分的 `ratioMin`。尺度无关（BM25 分数无上界），
  * 取代"整条消息 vs 整条 insight 的集合重叠 ÷ 较大集合"这种长度敏感判据。
@@ -219,6 +484,9 @@ export function relativeHits(scored, { ratioMin = 0.5 } = {}) {
   const list = (scored || []).filter((r) => r && Number.isFinite(r.score) && r.score > 0)
   if (!list.length) return []
   const top = list[0].score
-  const floor = top * (typeof ratioMin === 'number' && ratioMin > 0 ? ratioMin : 0.5)
+  // 显式的 0 表示"关掉相对门槛"（只剩 score>0）；未给/非法值才回退 0.5。
+  // 旧写法 `ratioMin > 0 ? ratioMin : 0.5` 把 0 当成"没配"，配置上无法关闭。
+  const ratio = typeof ratioMin === 'number' && Number.isFinite(ratioMin) ? ratioMin : 0.5
+  const floor = top * Math.max(0, Math.min(1, ratio))
   return list.filter((r) => r.score >= floor)
 }

package/src/recall.js

@@ -101,6 +101,21 @@ export function insightToEntry(ins) {
   }
 }
 
+/**
+ * 一条 insight 的**打分文本**（BM25 与 IDF 覆盖率必须用同一份）。
+ *
+ * 为什么要有这个函数：提示通道的"这条查询离语料有多远"（`idfCoverage` 的 df）曾经用
+ * `insightMatchText` 计算，而排序用 `insightToEntry`（含 fix/solution/reason/steps）。
+ * 于是"只在解药里有匹配"的查询词 df=0 → supportRatio=0 → **整条提示通道本轮沉默**，
+ * 而排序明明给了它高分。两份文本永远来自同一个 entry，才不会再漂移。
+ * @param {object} ins
+ * @returns {string}
+ */
+export function insightScoringText(ins) {
+  const e = insightToEntry(ins)
+  return [e.title, e.summary, e.terms, ...(e.keywords || [])].filter(Boolean).join('\n')
+}
+
 /**
  * 召回可见的 insight 集合：作用域可见性跟随会话绑定。
  *   - project / global：始终可见（归档除外）；
@@ -127,6 +142,9 @@ export function visibleInsights({ store = null, globalStore = null, boundTaskId
     const task = store.getTask(boundTaskId)
     for (const it of (task && task.insights) || []) {
       if (!it || it.archived) continue
+      // 任务级也要挡草稿：reflection 写的是 draft:true，未确认前不该被 query_memory 召回
+      // （project/global 一直有这道闸，任务级漏了）。
+      if (it.draft === true) continue
       out.push({ ...it, scope: it.scope || 'task' })
     }
   }
@@ -163,15 +181,17 @@ export function recallItems(opts = {}) {
   if (want.has('doc') || want.has('symbol')) {
     const pool = (entries || (store && typeof store.allEntries === 'function' ? store.allEntries() : []) || [])
       .filter((e) => e && (e.type === 'doc' || e.type === 'symbol') && want.has(e.type))
-    const scored = rankEntriesStreaming(pool, qs, idf, limit)
-    const byLayer = new Map([['doc', []], ['symbol', []]])
-    for (const { entry, score } of scored) {
-      const prior = entry.type === 'doc' ? normativePrior(entry) : LAYER_PRIORS.symbol
-      byLayer.get(entry.type).push({ item: entry, score, prior, weightedScore: score * prior })
-    }
+    // 每层各自 top-k（不变量 #2）：一次跨类型取 top-k 会让文档把符号挤出结果——
+    // 20 条命中文档 + 1 条命中符号、limit 8 时符号层直接消失。分类型各取一次再分桶。
     for (const layer of ['doc', 'symbol']) {
-      const hits = byLayer.get(layer)
-      if (!hits.length) continue
+      const layerPool = pool.filter((e) => e.type === layer)
+      if (!layerPool.length) continue
+      const scored = rankEntriesStreaming(layerPool, qs, idf, limit)
+      if (!scored.length) continue
+      const hits = scored.map(({ entry, score }) => {
+        const prior = layer === 'doc' ? normativePrior(entry) : LAYER_PRIORS.symbol
+        return { item: entry, score, prior, weightedScore: score * prior }
+      })
       hits.sort((a, b) => b.weightedScore - a.weightedScore)
       const top = hits[0].weightedScore || 1
       buckets.push({

package/src/setup/taskbridge.js

@@ -2,7 +2,7 @@
 // 事实依据：dsh session/event 签名 (session, event)；todo/write data.todos；
 // tool/call data.arguments 为 JSON 字符串；fs 工具名 read/write/edit/read_image，参数 file_path。
 import path from 'node:path'
-import { createHash } from 'node:crypto'
+import { createHash, randomUUID } from 'node:crypto'
 import { memoryRootFor } from '../util/fs.js'
 import { findProjectRoot } from '../lazy.js'
 import { ProjectMemoryStore } from '../store.js'
@@ -27,7 +27,9 @@ export function slugifyTitle(text) {
 
 export function genTaskId(projectRoot, title) {
   const slug = slugifyTitle(title) || 'task'
-  return `tsk_${hash8(projectRoot)}_${slug}_${Date.now()}`
+  // 毫秒不是唯一性保证：两个会话在同一毫秒建同名任务会拿到同一个 id，
+  // addTask 变成"同一 id 两次"，两个会话的绑定互相串台。补 6 位随机后缀。
+  return `tsk_${hash8(projectRoot)}_${slug}_${Date.now().toString(36)}_${randomUUID().slice(0, 6)}`
 }
 
 /** 项目根推导：findProjectRoot 期望文件路径，传目录会从父级起跳，故用目录内探针路径。 */
@@ -138,13 +140,7 @@ export function hotSortFiles(files, meta) {
 /** 触碰文件后更新元数据并重排 task.files（写 vs 读分别记时间/次数）。 */
 export function touchTaskFile(task, rel, kind, now) {
   task.fileMeta = task.fileMeta || {}
-  if (!task.files.includes(rel)) {
-    task.files.push(rel)
-    if (task.files.length > MAX_FILES_PER_TASK) {
-      const dropped = task.files.shift()
-      delete task.fileMeta[dropped]
-    }
-  }
+  if (!task.files.includes(rel)) task.files.push(rel)
   const m = task.fileMeta[rel] || {}
   m.n = (m.n || 0) + 1 // 兼容旧字段：读+写总数（保留，避免老任务语义漂移）
   // 读/写分计数（先只采集，不消费 —— 排序与注入仍只用 lastWriteAt/lastReadAt）
@@ -157,6 +153,12 @@ export function touchTaskFile(task, rel, kind, now) {
   m.lastReadAt = now
   task.fileMeta[rel] = m
   task.files = hotSortFiles(task.files, task.fileMeta)
+  // 超限丢最冷的：列表已按热度降序，末尾即最冷。旧代码在**重排前** shift()，
+  // 而那时 files 本身就是热序，shift 恰好把最热的那个文件（刚写的）丢掉、留下最冷的。
+  while (task.files.length > MAX_FILES_PER_TASK) {
+    const dropped = task.files.pop()
+    delete task.fileMeta[dropped]
+  }
 }
 
 /**

package/src/store.js

@@ -17,6 +17,14 @@ const SHARDS_DIR = 'shards'
 const storeCache = new Map()
 const STORE_CACHE_MAX = 32
 
+/** 已就"无法迁移的旧 store"告警过的目录：避免每次 load() 都刷一行。 */
+const migrationWarned = new Set()
+
+/** 纯对象判定（排除 null / 数组）：磁盘读入的 JSON 形状校验统一走它。 */
+function isRecord(value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value)
+}
+
 function loadJson(filePath, fallback) {
   let raw
   try {
@@ -82,7 +90,9 @@ export class ProjectMemoryStore {
   load() {
     const key = path.resolve(this.dir)
     const hot = storeCache.get(key)
-    if (hot && hot !== this) return hot
+    // 缓存命中即返回：`hot === this` 时再读一遍盘会静默丢弃本实例尚未 save() 的变更
+    // （_loadSharded/_loadInsights 会重新赋值 experience/tasks/insights…）。
+    if (hot) return hot
     this._migrateLegacyIfNeeded()
     this._loadSharded()
     this._loadInsights()
@@ -114,9 +124,34 @@ export class ProjectMemoryStore {
     }
     const legacyEntriesPath = path.join(this.dir, ENTRIES_FILE)
     if (!existsSafe(legacyEntriesPath)) return
-    const index = loadJson(path.join(this.dir, INDEX_FILE), {})
-    const files = index.files || {}
-    const entries = loadJson(legacyEntriesPath, {})
+    const legacyIndexPath = path.join(this.dir, INDEX_FILE)
+    // 先读两份旧文件：损坏的那份会在这里被 loadJson 备份为 .corrupt（保留现场）。
+    const index = loadJson(legacyIndexPath, null)
+    const entries = loadJson(legacyEntriesPath, null)
+    if (!isRecord(index) || !isRecord(entries)) {
+      const hasEntries = isRecord(entries) && Object.keys(entries).length > 0
+      if (!hasEntries) {
+        // entries 损坏（已备份）或本就是空的：没有可保护的数据，按空旧库收尾。
+        writeJsonAtomic(formatPath, { version: 2, layout: 'sharded' })
+        for (const stale of [legacyEntriesPath, legacyIndexPath]) {
+          try {
+            unlinkSync(stale)
+          } catch {
+            // already renamed away by corrupt backup, or gone; nothing to do
+          }
+        }
+        return
+      }
+      // index.json 是 entries.json → rel 的唯一映射。它缺失或损坏时继续迁移，会写出 0 个
+      // shard、打上 v2 标记、再把**完好的** entries.json 删掉——等于一次静默的数据清空。
+      // 保留现场，不写 format 标记，等 index.json 修好后再迁（每次进程只提示一次）。
+      if (!migrationWarned.has(this.dir)) {
+        migrationWarned.add(this.dir)
+        console.error(`[dsh-project-memory] legacy store at ${this.dir} has ${ENTRIES_FILE} but no readable ${INDEX_FILE}; migration skipped to protect it`)
+      }
+      return
+    }
+    const files = isRecord(index.files) ? index.files : {}
     const orphans = Object.keys(entries).filter((rel) => !(rel in files))
     if (orphans.length) {
       console.error(
@@ -147,9 +182,11 @@ export class ProjectMemoryStore {
     }
     for (const name of shardNames) {
       const shard = loadJson(path.join(this.dir, SHARDS_DIR, name), null)
-      if (!shard || typeof shard.relPath !== 'string' || !shard.record) continue
+      if (!shard || typeof shard.relPath !== 'string' || !isRecord(shard.record)) continue
       this.files[shard.relPath] = shard.record
-      this.entries[shard.relPath] = shard.entries || []
+      // 畸形 shard（entries 被写成对象/null）不能让 allEntries() 在 `for…of` 上抛错，
+      // 否则一个坏文件会拖垮整个进程的每一次读取。
+      this.entries[shard.relPath] = Array.isArray(shard.entries) ? shard.entries.filter(isRecord) : []
     }
     this.experience = loadJson(path.join(this.dir, EXPERIENCE_FILE), [])
     this.tasks = loadJson(path.join(this.dir, TASKS_FILE), [])
@@ -165,7 +202,10 @@ export class ProjectMemoryStore {
   // migratedAt 落盘保证跨进程/崩溃幂等。销毁式收敛放到 recall 统一 PR。
   _loadInsights() {
     const doc = loadJson(path.join(this.dir, INSIGHTS_FILE), null)
-    this.insights = doc && typeof doc === 'object' && Array.isArray(doc.items) ? doc : { version: 1, migratedAt: null, items: [] }
+    this.insights = isRecord(doc) && Array.isArray(doc.items)
+      // items 里混进 null/非对象（手改或旧版写入）会让迁移与召回逐个 `.title` 抛错——过滤掉。
+      ? { ...doc, items: doc.items.filter(isRecord) }
+      : { version: 1, migratedAt: null, items: [] }
     this._migrateExperienceToInsights()
     // PR3：v1 → v2 懒回填派生 trigger（纯确定性、幂等；不调用模型，不改写已有字段）
     if (backfillDerivedTriggers(this.insights)) this._dirtyInsights = true
@@ -551,15 +591,14 @@ export class ProjectMemoryStore {
     return result
   }
 
-  applyFileUpdate(relPath, { expectedHash, hash, entries, meta, deleted, type, size }) {
-    const cur = this.fileRecord(relPath)
-    if (!deleted && (cur?.sha256 ?? null) !== (expectedHash ?? null)) {
-      return { skipped: true }
-    }
-    if (deleted) {
-      this.removeFile(relPath)
-      return { ok: true }
-    }
+  /**
+   * 写入一条文件更新，以 expectedHash 做 CAS。
+   * @returns {boolean} true = 已写入；false = 文件自扫描后又被改动，本次拒绝
+   *   （调用方让该条目保持未落快照，下一轮重试）。
+   * 移除条目不经过这里：调用方在 commit 里直接 removeFile（见 index-pipeline.js）。
+   */
+  applyFileUpdate(relPath, { expectedHash, hash, entries, type, size }) {
+    if ((this.fileRecord(relPath)?.sha256 ?? null) !== (expectedHash ?? null)) return false
     this.markFile(relPath, {
       sha256: hash,
       size,
@@ -567,7 +606,7 @@ export class ProjectMemoryStore {
       indexedAt: new Date().toISOString(),
     })
     this.setEntries(relPath, entries)
-    return { ok: true }
+    return true
   }
 }