solopup-memory 0.21.0-beta.3 → 0.23.0-beta.1

package/RELEASE.md

@@ -1,3 +1,39 @@
+# 0.23.0-beta.1 — project memory across worktrees
+
+This version adds opt-in, reviewed linking between worktrees of the same local Git repository. If a Super Agent prepare command fails after creating the directory, its prototype can skip preparation on retry and start the worker without the intended link; inspect the leftover directory and do not retry until preparation will run again. It does not automatically merge pre-existing project stores or link clones. Review the worktree identity, performance and recovery limits before use. G1 remains unpassed; real-model semantics and cross-platform operation have not been validated. Existing conversation or provider copies are not erased.
+
+Unlink changes future directory resolution and is not an immediate revocation barrier for already resolved paths or in-flight capture. Stop affected Workers and capture before unlinking and review retained copies.
+
+The tested Super Agent prototype does not expose `memory_search` or `memory_write` to Workers by default. Linking enables project context injection; it does not establish direct Worker memory tool access.
+
+A local candidate was installed and loaded in one daily DSH profile; its health check detected pre-existing pending withdrawal cleanup. Real-model semantic acceptance remains outstanding. The npm beta tag and GitHub Releases identify versions that have actually been published.
+
+# 0.22.0-beta.3 — DSH 0.2.2 compatibility and first-run integration
+
+**Published public beta.** Published to npm as `0.22.0-beta.3` (dist-tag `beta`) and to GitHub Releases on 2026-11-09; the npm tarball sha256 `621bf9c0d21e39d769377a421e80330402c7d9d5840745209b8500a11c9f2fe2` matches the release `SHA256SUMS`. `memory_status` should report `0.22.0-beta.3` after a clean restart. This version integrates the onboarding/test-layout work with current main and waits for DSH asynchronous Session Projection registration before exposing dependent features. New hosts use retained projection handles; older hosts retain their registry-reader path. Existing beta tags and the published registry version are not rewritten.
+
+The isolated Linux host checks use the official npm CLI distributions for DSH 0.2.1-rc.5 and 0.2.2-rc.1, synthetic Sessions, no user profile or credentials, and no model calls. They cover six-tool activation, live projection state, exact removal of obsolete memory sections while preserving other content, cold replay, rejected registrations and owner disposal. This is not real-model semantic acceptance or daily desktop verification. See [COMPATIBILITY.md](COMPATIBILITY.md) and the integration receipt for exact results and remaining gates.
+
+# 0.22.0-beta.2 — detection layer, semantic pipeline gate, dream P0/P1
+
+**Superseded by 0.22.0-beta.3; never published.** (v0.22.0-beta.1 tag failed before submission because npm 11 parsed the relative tarball path as a GitHub shorthand; no npm version was published. This beta.2 commit fixes the path and passes the same gates, but publication completed only with beta.3.) This commit adds engineering infrastructure and read-only/planning features; stable semantic acceptance is still not claimed.
+
+- L0 detection: `detect.mjs` + `scripts/detect.mjs` read-only invariant checks (index format, projection consistency, anchors, withdrawal residue, duplicates/conflicts, budgets, scope, version drift, topic structure, duplicate stores). `memory_status` exposes a bounded `lint` summary.
+- L2 pipeline-fidelity suite: 10 frozen cases (~190ms) checking that a correct or deliberately wrong candidate keeps its conditions/meaning/expiry/scope through write → projection → retrieval. `semanticTruthEvaluated` stays false (no real extraction model run).
+- L3 telemetry: capture success rate, zero-output days, stale pending candidates, short-session skips.
+- Dream P0 shadow plan: read-only op list from L0+L3 with evidence, zero model calls. Dream P1 applies only `compact-index` (reuses deterministic `pruneStore`) behind `--reviewed <planHash>`, after a file backup, with post-apply L0 verification; every other op remains human-only.
+- Short sessions below the auto-capture turn threshold now emit `capture/skipped/short-session-below-threshold` instead of silently losing context.
+- Add a mechanical security self-check (`scripts/security-check.mjs`, wired into `verify`): zero runtime dependencies and install hooks; no runtime network calls or listening sockets; the single subprocess is `restore.mjs` invoking fixed-argument `tar` without a shell; no secrets or machine absolute paths in shipped files; workflow actions pinned to commit SHAs with `contents: read`, no `secrets.*` and no `pull_request_target`; package contents exclude research/logs/tarballs; MIT license, engines and `.gitignore` present.
+- Add a reliability test (`scripts/soak.mjs`) on the official offline install path: repeated real DSH host start/stop, SIGKILL recovery with no leftover `.write.lock`/`.publication.json`, two concurrent hosts on one store followed by a clean reload, unchanged memory content files across cycles, and store permissions 0700 (files 0600).
+
+Known gaps: no real-model semantic acceptance; no per-memory usage counters; dream P1 does not apply merges, conflict arbitration or transcript-based corrections.
+
+# 0.21.0-beta.4 — automated beta release infrastructure
+
+This maintenance version adds the repository release workflow, OIDC publishing support, immutable artifact checks and post-publish GitHub/market updates. Memory behavior and data formats are unchanged. Hosted workflow success and trusted-publisher validation must be checked in the release receipts; a workflow file alone does not establish them. Stable semantic acceptance and historical erasure remain outside this release.
+
+## Historical beta.3 release evidence
+
 # 0.21.0-beta.3 - private-memory exposure reduction
 
 Public beta. Conservative known-category filtering, not full privacy isolation or stable semantic acceptance.

package/SECURITY.md

@@ -75,3 +75,10 @@
 ## beta.3 privacy boundary
 
 Recognized private records, including their quoted evidence, are omitted from automatic projection and unrelated saved-memory contexts. The classifier is heuristic and incomplete; explicit [private] or [private:category] text is conservatively treated as on-demand. Searches default to excluding recognized private content; includePrivate=true is a disclosure control, not a user authentication boundary. Other tools can read the raw files. Private facts explicitly present in the current conversation or prior ordinary messages remain in that conversation. Existing append-only archives, caches, exports, backups and provider-side copies are not purged. Never claim that hiding an index or memory_forget erases those copies. Physical raw-index migration and reviewed local erasure are separate work.
+
+## 发版前机械自查（0.22.0-beta.1 起）
+
+`node scripts/security-check.mjs` 只读检查发行面的机械项：零运行时依赖与安装钩子、运行时无网络/监听面、唯一子进程是 `restore.mjs` 以固定参数调用 `tar`（无 shell）、发行文件无密钥与机器绝对路径、工作流 action 按 commit pin 且权限为 `contents: read`、无 `secrets.*`/`pull_request_target`、发行包不含研究目录与日志、MIT 许可与引擎声明。
+
+这不是独立安全审计，也不覆盖：依赖供应链以外的攻击、宿主自身的模型/网络行为、物理访问、已知的隐私分类器不完整、以及“记忆被用户自己手工编辑”的情形。可靠性验证见 `node scripts/soak.mjs`（官方离线安装 + 真实宿主多轮启停 + SIGKILL 恢复 + 并发宿主 + 数据指纹不变）。
+

package/context-history.mjs

@@ -90,8 +90,25 @@ export function assertCurrentMemoryRequest(messages,currentText) {
 
 export function setupMemoryHistory(ctx,render) {
   const projections = optionalService(ctx, 'sessionProjections')
-  if(typeof projections?.register!=='function'||typeof projections?.stateOf!=='function')return{available:false,observe:()=>{}}
-  projections.register(memoryContextProjection())
+  if(typeof projections?.register!=='function')return{available:false,observe:()=>{}}
+  const registration=projections.register(memoryContextProjection())
+  // DSH 0.2.2 returns a callable thenable. Await it before publishing hooks,
+  // while retaining synchronous support for the older registry API.
+  const ready=handle=>{
+    // Disposal can win after the host resolves registration but before this
+    // continuation runs. The owning fiber already releases its registration.
+    if(ctx.fiber?.uid===null)return{available:false,observe:()=>{}}
+    return installMemoryHistory(ctx,render,typeof handle?.stateOf==='function'
+      ? session=>handle.stateOf(session)
+      : typeof projections.stateOf==='function'
+        ? session=>projections.stateOf(session,HISTORY_PROJECTION_KEY)
+        : undefined)
+  }
+  return typeof registration?.then==='function'?Promise.resolve(registration).then(ready):ready(registration)
+}
+
+function installMemoryHistory(ctx,render,stateOf) {
+  if(!stateOf)fail('memory-context-reader-unavailable')
   const sessions=new Map()
   const cwdFor=(session,fallback)=>typeof ctx.workingDirectory?.get==='function'?ctx.workingDirectory.get(session):fallback
   const refresh=(input,next)=>{
@@ -99,7 +116,7 @@ export function setupMemoryHistory(ctx,render) {
     if(!session)fail('memory-context-session-unavailable')
     const cwd=cwdFor(session)
     sessions.set(session.id,{ref:new WeakRef(session),cwd})
-    reconcileMemoryContext(session,projections.stateOf(session,HISTORY_PROJECTION_KEY),render(cwd))
+    reconcileMemoryContext(session,stateOf(session),render(cwd))
     return next()
   }
   // Run before pre-step consumers (including summarizers), then recheck at

package/detect.mjs

@@ -0,0 +1,441 @@
+/**
+ * 记忆层检测框架 · L0 不变量层。
+ *
+ * 只读：不改任何记忆数据，不调用模型。输出结构化 findings，供 CLI、测试与人工复核共用。
+ * 设计原则：每一条“我们踩过的坑”都必须有一个可复现的检查项；查不出来就明说“未知”，
+ * 不把“没发现”写成“没问题”。
+ *
+ * 分层约定（完整框架见 DETECTION.md）：
+ *   L0 不变量（本文件，确定性、毫秒级）
+ *   L1 管道行为（脚本模型，确定性）
+ *   L2 真实语义（真模型，冻结留出集，按需）
+ *   L3 长期观测（遥测：捕获成功率、零产出天数、待审年龄）
+ *   L4 安全与隐私（生成式对抗集 + 隐私覆盖）
+ *   L5 性能与容量
+ */
+
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs'
+import { createHash } from 'node:crypto'
+import { join } from 'node:path'
+
+import { candidateSnapshot, withdrawalPolicy } from './candidates.mjs'
+import { filterWithdrawn } from './withdrawal.mjs'
+import { privateMemory } from './privacy.mjs'
+import { VERSION } from './version.mjs'
+import { SIMILARITY, TYPES, conflictSignature, isExpired, similarity, summaryOf } from './index.mjs'
+
+const INDEX_LINE = /^- \[(user|feedback|project|reference)\] /
+const TOPIC_REF = /\s—\s([A-Za-z0-9._-]+\.md)(?:#(.+))?$/
+const SUMMARY_MAX = 200
+const LIMITS = { indexMaxLines: 300, indexMaxBytes: 25 * 1024, storeMaxBytes: 2 * 1024 * 1024 }
+const VERSION_TOKEN = /\bv\d+\.\d+\.\d+(?:-[0-9A-Za-z.]+)?\b/g
+
+/** 索引里的锚点是人写的，标题是带标点的；比较前统一折叠空白与标点。 */
+function foldAnchor(text) {
+  return String(text ?? '')
+    .normalize('NFC')
+    .toLowerCase()
+    .replace(/[\s\-_·、，。；：！？（）()【】\[\]《》〈〉「」『』"'“”‘’/\\|]+/g, '')
+}
+
+function readText(file) {
+  try {
+    return readFileSync(file, 'utf8')
+  } catch {
+    return undefined
+  }
+}
+
+function active(records) {
+  return records.filter((record) => ['recorded', 'adopted'].includes(record.status))
+}
+
+function storeBytes(dir) {
+  let total = 0
+  const walk = (current, depth) => {
+    for (const entry of readdirSync(current, { withFileTypes: true })) {
+      if (entry.name.startsWith('.')) continue
+      if (depth === 0 && entry.name === 'projects') continue
+      const full = join(current, entry.name)
+      if (entry.isDirectory()) {
+        walk(full, depth + 1)
+        continue
+      }
+      if (entry.isFile()) {
+        try {
+          total += statSync(full).size
+        } catch {
+          /* 读不到就不计 */
+        }
+      }
+    }
+  }
+  try {
+    walk(dir, 0)
+  } catch {
+    /* 目录不存在按 0 算 */
+  }
+  return total
+}
+
+function bySeverity(findings, severity) {
+  return findings.filter((item) => item.severity === severity).length
+}
+
+/**
+ * 检测单个库（全局库或项目库）。
+ * @param {string} dir - 库目录。
+ * @param {{scope?: 'global'|'project', now?: number, root?: string}} options
+ */
+export function detectStore(dir, options = {}) {
+  const scope = options.scope ?? 'global'
+  const now = options.now ?? Date.now()
+  const findings = []
+  const ref = (file, line) => (line === undefined ? { file } : { file, line })
+  const add = (id, severity, message, refs = [], fixHint) =>
+    findings.push({ id, severity, message, ...(refs.length ? { refs } : {}), ...(fixHint ? { fixHint } : {}) })
+
+  const indexText = readText(join(dir, 'MEMORY.md'))
+  const hasIndex = indexText !== undefined
+  const text = indexText ?? ''
+  const rawLines = text.replace(/\n$/, '').split(/\r?\n/)
+  const entries = []
+  rawLines.forEach((line, index) => {
+    if (line.trim().startsWith('- [')) entries.push({ line: line.trim(), lineNo: index + 1, raw: line })
+  })
+
+  // I1 索引行格式：类型、摘要长度、期限语法
+  for (const entry of entries) {
+    if (!INDEX_LINE.test(entry.line)) {
+      add('I1-invalid-index-line', 'error', '索引行类型不合法，宿主与检索都不会把它当条目', [ref('MEMORY.md', entry.lineNo)], '改成 - [user|feedback|project|reference] 摘要 — 文件')
+      continue
+    }
+    if (summaryOf(entry.line).length > SUMMARY_MAX) {
+      add('I1-summary-too-long', 'warning', `摘要超过 ${SUMMARY_MAX} 字（${summaryOf(entry.line).length}）`, [ref('MEMORY.md', entry.lineNo)])
+    }
+    if (entry.line.includes('(exp:') && !/\(exp:\d{4}-\d{2}-\d{2}\)/.test(entry.line)) {
+      add('I1-invalid-expiry', 'error', '期限标记语法错误，过期判断会静默失效', [ref('MEMORY.md', entry.lineNo)])
+    }
+  }
+
+  // I2 索引指向的正文与锚点必须存在
+  const topicCache = new Map()
+  const topicText = (name) => {
+    if (!topicCache.has(name)) topicCache.set(name, readText(join(dir, name)))
+    return topicCache.get(name)
+  }
+  for (const entry of entries) {
+    if (/—\s*索引摘要(?: \(exp:\d{4}-\d{2}-\d{2}\))?$/.test(entry.line)) continue
+    const match = TOPIC_REF.exec(entry.line)
+    if (match === null) {
+      if (!argLooksLegacy(entry.line)) {
+        add('I2-unresolvable-topic-ref', 'warning', '索引行既没有正文引用，也没有“索引摘要”标记', [ref('MEMORY.md', entry.lineNo)])
+      }
+      continue
+    }
+    const file = match[1]
+    const topic = topicText(file)
+    if (topic === undefined) {
+      add('I2-missing-topic-file', 'error', `索引指向的 ${file} 不存在`, [ref('MEMORY.md', entry.lineNo)], '补回主题文件或改成“— 索引摘要”')
+      continue
+    }
+    if (match[2] !== undefined) {
+      const wanted = foldAnchor(match[2])
+      const headings = [...topic.matchAll(/^#{2,6}\s*(.+)$/gm)].map((heading) => foldAnchor(heading[1]))
+      if (!headings.some((heading) => heading === wanted || heading.includes(wanted) || wanted.includes(heading))) {
+        add('I2-missing-anchor', 'warning', `锚点在 ${file} 中找不到：${match[2]}`, [ref('MEMORY.md', entry.lineNo)], '改锚点或补标题')
+      }
+    }
+  }
+
+  // 账本
+  let snapshot = null
+  try {
+    snapshot = candidateSnapshot(dir, scope)
+  } catch (error) {
+    // 项目库可能以另一作用域登记；只报告，不猜。
+    add('I0-snapshot-error', 'error', `候选账本不可读：${error.message}`)
+  }
+  const records = snapshot?.records ?? []
+  const current = active(records)
+  const pending = records.filter((record) => record.status === 'pending')
+
+  // I3 有效记录必须出现在索引里（投影不丢条目）
+  for (const record of current) {
+    const line = (record.indexLine ?? `- [${record.type}] ${record.summary}`).trim()
+    if (!entries.some((entry) => entry.line === line)) {
+      add('I3-record-missing-from-index', 'error', `有效记录未投影到索引：${record.id}`, [], '从账本重建索引，或确认该记录已过期')
+    }
+    if (record.detail !== undefined) {
+      const topic = topicText(`${record.type}.md`)
+      if (topic === undefined) {
+        add('I3-detail-topic-missing', 'error', `记录 ${record.id} 的正文文件 ${record.type}.md 不存在`)
+      } else if (!topic.includes(`[candidate:${record.id}]\n${record.detail}`)) {
+        add('I3-detail-mismatch', 'error', `记录 ${record.id} 的正文与账本不一致（索引会指向错误内容）`, [ref(`${record.type}.md`)], '以账本为准重建正文块')
+      }
+    }
+  }
+
+  // I4 索引行是否有账本依据（手工条目允许，但必须可见）
+  const knownLines = new Set(current.map((record) => (record.indexLine ?? `- [${record.type}] ${record.summary}`).trim()))
+  let unclassified = 0
+  for (const entry of entries) {
+    if (!knownLines.has(entry.line)) unclassified += 1
+  }
+  if (unclassified > 0) {
+    add('I4-index-without-ledger', 'info', `${unclassified} 条索引没有对应账本记录（手工或旧格式，不能当已审查证据）`)
+  }
+
+  // I5 撤回必须传播到索引
+  try {
+    const policy = withdrawalPolicy(dir)
+    if (filterWithdrawn(text, policy, true) !== text) {
+      add('I5-withdrawal-residue', 'error', '索引里仍有已撤回内容', [], '重新发布撤回或修复投影')
+    }
+  } catch (error) {
+    add('I5-withdrawal-unreadable', 'warning', `撤回策略不可读：${error.message}`)
+  }
+
+  // I6 重复与近重复
+  const seen = new Map()
+  for (const entry of entries) {
+    const key = entry.line
+    seen.set(key, (seen.get(key) ?? 0) + 1)
+  }
+  for (const [line, count] of seen) if (count > 1) add('I6-duplicate-line', 'warning', `完全重复的索引行 ×${count}：${line.slice(0, 60)}`)
+  // 相似度对是 O(n²)：索引上限 300 行时约 4.5 万次比较，可接受；
+  // 超过 400 行只比前 400 条，并显式说明，避免把检测器变成慢查询。
+  const PAIR_LIMIT = 400
+  if (entries.length > PAIR_LIMIT) {
+    add('I6-similarity-truncated', 'info', `索引 ${entries.length} 行，相似度比对只覆盖前 ${PAIR_LIMIT} 条（全量重复检查仍覆盖全部）`)
+  }
+  const pairEntries = entries.slice(0, PAIR_LIMIT)
+  for (let i = 0; i < pairEntries.length; i += 1) {
+    for (let j = i + 1; j < pairEntries.length; j += 1) {
+      const score = similarity(summaryOf(pairEntries[i].line), summaryOf(pairEntries[j].line))
+      if (score >= SIMILARITY.reject) {
+        add('I6-near-duplicate', 'warning', `疑似重复（相似度 ${score.toFixed(2)}）：MEMORY.md:${pairEntries[i].lineNo} 与 :${pairEntries[j].lineNo}`, [], '用 supersedes 合并，不要并排堆两条')
+      }
+    }
+  }
+
+  // I7 冲突签名：同一属性的不同取值同时有效
+  const signatures = new Map()
+  for (const entry of entries) {
+    const sig = conflictSignature(summaryOf(entry.line))
+    if (sig.values.length === 0) continue
+    if (!signatures.has(sig.signature)) signatures.set(sig.signature, [])
+    signatures.get(sig.signature).push(entry)
+  }
+  for (const [signature, group] of signatures) {
+    if (group.length > 1) {
+      add('I7-conflict', 'warning', `同一属性有 ${group.length} 个并存取值（${signature.slice(0, 40)}）：` + group.map((entry) => `MEMORY.md:${entry.lineNo}`).join('、'), [], '确认哪个现行，用 supersedes 收敛')
+    }
+  }
+
+  // I8 预算
+  const indexBytes = Buffer.byteLength(text, 'utf8')
+  if (entries.length > LIMITS.indexMaxLines) add('I8-budget-lines', 'error', `索引 ${entries.length} 行，超过 ${LIMITS.indexMaxLines} 行上限`, [], '运行 memory_prune 或把细节移到主题文件')
+  if (indexBytes > LIMITS.indexMaxBytes) add('I8-budget-bytes', 'error', `索引 ${indexBytes} 字节，超过 ${LIMITS.indexMaxBytes} 上限`)
+  const bytes = storeBytes(dir)
+  if (bytes > LIMITS.storeMaxBytes) add('I8-budget-store', 'error', `库占用 ${bytes} 字节，超过 ${LIMITS.storeMaxBytes} 上限`)
+
+  // I9 作用域
+  for (const record of current) {
+    if (record.scope !== scope) add('I9-scope-mismatch', 'error', `记录 ${record.id} 的作用域是 ${record.scope}，不应出现在 ${scope} 库`)
+  }
+
+  // I10 版本/规则漂移：只能提示，不能自动判定哪边是真相
+  const versions = [...new Set((text.match(VERSION_TOKEN) ?? []).map((token) => token.replace(/^v/, '')))]
+  const stale = versions.filter((token) => token !== VERSION)
+  if (stale.length > 0) add('I10-version-mention', 'info', `索引提到与当前版本（${VERSION}）不同的版本号：${stale.join('、')}`, [], '确认是否已过时，过时就 supersedes')
+
+  // I11 隐私：只报告暴露面，不做“已保护”的假承诺
+  const privateRecords = current.filter((record) => privateMemory(record))
+  if (privateRecords.length > 0) add('I11-private-records', 'info', `${privateRecords.length} 条记录按隐私规则只在按需检索时返回；主题文件与账本仍是明文`)
+
+  // I12 历史账本
+  if (entries.length > 0 && !existsSync(join(dir, '.episodes.json'))) {
+    add('I12-no-history-ledger', 'info', '有索引但没有历史账本，无法回答“当时怎么记的”')
+  }
+
+  // 主题文件反向检查：正文块必须有索引行
+  const anchorsByFile = new Map()
+  for (const entry of entries) {
+    const match = TOPIC_REF.exec(entry.line)
+    if (match === null) continue
+    if (!anchorsByFile.has(match[1])) anchorsByFile.set(match[1], new Set())
+    if (match[2] !== undefined) anchorsByFile.get(match[1]).add(foldAnchor(match[2]))
+  }
+  for (const type of TYPES) {
+    const file = `${type}.md`
+    const topic = topicText(file)
+    if (topic === undefined) continue
+    for (const match of topic.matchAll(/\[candidate:([0-9a-f]{8,64})\]/g)) {
+      const id = match[1]
+      const record = records.find((item) => item.id === id)
+      if (record === undefined) {
+        add('I13-detail-without-record', 'warning', `正文块 ${id} 在账本里不存在（孤立正文）`, [ref(file)])
+      } else if (!['recorded', 'adopted'].includes(record.status)) {
+        add('I13-detail-by-inactive-record', 'warning', `正文块 ${id} 对应的记录状态是 ${record.status}`, [ref(file)])
+      }
+    }
+    // I14 结构：正文块必须在某个 ## 标题之下；文件末行不能是半句。
+    const lines = topic.split(/\r?\n/)
+    let sawHeading = false
+    lines.forEach((line, index) => {
+      if (/^#{2,6}\s+/.test(line)) sawHeading = true
+      else if (line.includes('[candidate:') && !sawHeading) {
+        add('I14-candidate-without-heading', 'warning', '正文块出现在任何 ## 标题之前，按标题读取时会被漏掉', [ref(file, index + 1)])
+      }
+    })
+    lines.forEach((line, index) => {
+      const trimmed = line.trim()
+      if (trimmed.length === 0 || trimmed.startsWith('#')) return
+      const next = lines[index + 1]
+      const isParagraphEnd = next === undefined || next.trim().length === 0
+      if (!isParagraphEnd) return
+      if (!/[，、：；,;]$/.test(trimmed)) return
+      const isBullet = /^([-*]|\d+\.)\s/.test(trimmed)
+      // 非列表行以冒号结尾、下一段是列表：这是引导句，不是截断。
+      const nextNonEmpty = lines.slice(index + 1).find((item) => item.trim().length > 0)
+      const leadIn = !isBullet && /[：:]$/.test(trimmed) && (nextNonEmpty?.trim().startsWith('- ') ?? false)
+      if (leadIn) return
+      add('I14-truncated-paragraph', 'warning', `段落以未完成标点结尾，像被截断：${trimmed.slice(-40)}`, [ref(file, index + 1)])
+    })
+    // I15 标题与索引锚点的对应：只有该文件已经使用锚点引用时才检查，避免把旧格式误报。
+    const used = anchorsByFile.get(file)
+    if (used !== undefined && used.size > 0) {
+      for (const match of topic.matchAll(/^#{2,6}\s*(.+)$/gm)) {
+        const heading = foldAnchor(match[1])
+        if (heading.length === 0) continue
+        if (![...used].some((anchor) => anchor === heading || heading.includes(anchor) || anchor.includes(heading))) {
+          add('I15-heading-without-index', 'info', `标题没有索引指向：${match[1].trim().slice(0, 40)}`, [ref(file)])
+        }
+      }
+    }
+  }
+
+  return {
+    kind: 'store',
+    version: VERSION,
+    dir,
+    scope,
+    generatedAt: new Date().toISOString(),
+    summary: { errors: bySeverity(findings, 'error'), warnings: bySeverity(findings, 'warning'), infos: bySeverity(findings, 'info') },
+    metrics: {
+      indexExists: hasIndex,
+      indexLines: entries.length,
+      indexBytes,
+      limitLines: LIMITS.indexMaxLines,
+      limitBytes: LIMITS.indexMaxBytes,
+      storeBytes: bytes,
+      storeLimitBytes: LIMITS.storeMaxBytes,
+      activeRecords: current.length,
+      pendingRecords: pending.length,
+      privateRecords: privateRecords.length,
+      unclassifiedIndexLines: unclassified,
+      expiredIndexLines: entries.filter((entry) => isExpired(entry.line, now)).length,
+    },
+    findings,
+  }
+}
+
+/** 旧格式索引行常见形态：以“— 文件名”之外的破折号结尾，例如手工补的说明。 */
+function argLooksLegacy(line) {
+  return /—\s*[^\s].*[，。；,;]$/.test(line) || !line.includes('—')
+}
+
+function hashPolicy(dir) {
+  const parts = []
+  for (const name of ['MEMORY.md', ...TYPES.map((type) => `${type}.md`)]) {
+    const text = readText(join(dir, name))
+    if (text !== undefined) parts.push(`${name}\n${text}`)
+  }
+  return createHash('sha256').update(parts.join('\n')).digest('hex')
+}
+
+/**
+ * 检测整棵记忆根目录：全局库 + 各项目库，并做跨库检查。
+ * @param {string} root - 记忆根（通常是 ~/.dsh/memory）。
+ */
+export function detectRoot(root, options = {}) {
+  const stores = []
+  const globalReport = detectStore(root, { ...options, scope: 'global' })
+  stores.push(globalReport)
+
+  const projectsDir = join(root, 'projects')
+  let names = []
+  try {
+    names = readdirSync(projectsDir, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory() && !entry.name.startsWith('.'))
+      .map((entry) => entry.name)
+      .sort()
+  } catch {
+    names = []
+  }
+
+  const crossFindings = []
+  const hashes = new Map()
+  const hashStore = (dir, name) => {
+    const digest = hashPolicy(dir)
+    if (!hashes.has(digest)) hashes.set(digest, [])
+    hashes.get(digest).push(name)
+  }
+  if (globalReport.metrics.indexLines > 0) hashStore(root, 'global')
+  const emptyStores = []
+  const legacyNamed = []
+  for (const name of names) {
+    const dir = join(projectsDir, name)
+    let scope = 'project'
+    let report
+    try {
+      report = detectStore(dir, { ...options, scope })
+    } catch (error) {
+      report = {
+        kind: 'store', version: VERSION, dir, scope, generatedAt: new Date().toISOString(),
+        summary: { errors: 1, warnings: 0, infos: 0 }, metrics: null,
+        findings: [{ id: 'I0-detect-error', severity: 'error', message: error.message }],
+      }
+      report.findings[0].refs = []
+    }
+    stores.push(report)
+    if (report.metrics && report.metrics.indexLines === 0 && report.metrics.activeRecords === 0) emptyStores.push(name)
+    if (report.metrics && report.metrics.indexLines === 0 && report.metrics.activeRecords === 0) legacyNamed.push(name)
+    if (report.metrics.indexLines > 0) hashStore(dir, name)
+  }
+  for (const name of emptyStores) {
+    crossFindings.push({ id: 'X1-empty-project-store', severity: 'info', message: `空项目库：${name}`, refs: [] })
+  }
+  for (const [digest, namesWithSame] of hashes) {
+    if (namesWithSame.length > 1) {
+      crossFindings.push({ id: 'X2-duplicate-store', severity: 'warning', message: `内容完全相同的库：${namesWithSame.join('、')}（sha256 ${digest.slice(0, 12)}…）`, refs: [] })
+    }
+  }
+  if (names.length > 0) {
+    // 项目库数量与真实工作区数量不必相等，但空库/测试夹具必须显式可见。
+    crossFindings.push({ id: 'X3-project-store-count', severity: 'info', message: `项目库 ${names.length} 个，其中空库 ${emptyStores.length} 个`, refs: [] })
+  }
+
+  const totals = stores.reduce(
+    (acc, store) => ({
+      errors: acc.errors + store.summary.errors,
+      warnings: acc.warnings + store.summary.warnings,
+      infos: acc.infos + store.summary.infos,
+    }),
+    { errors: 0, warnings: 0, infos: 0 },
+  )
+  for (const finding of crossFindings) totals[finding.severity === 'error' ? 'errors' : finding.severity === 'warning' ? 'warnings' : 'infos'] += 1
+
+  return {
+    kind: 'root',
+    version: VERSION,
+    root,
+    generatedAt: new Date().toISOString(),
+    summary: totals,
+    stores,
+    crossFindings,
+  }
+}
+
+export { LIMITS as DETECT_LIMITS }

package/eval/bench-detect.mjs

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+/**
+ * 对比实验：L0 检测器 vs 人工审计基线 + 各门禁环节的耗时。
+ *
+ * 基线来自 2026-11-08 的人工只读审计（data-audit 报告）。每一条都标了归属层：
+ *   detect = 应由 L0 检测器抓到；blind-spot = 已知 L0 抓不到（语义/跨措辞）；
+ *   telemetry = 属于 L3；doc = 文档/引用一致性；accepted = 设计上允许。
+ *
+ *   node eval/bench-detect.mjs            # 人类可读
+ *   node eval/bench-detect.mjs --json     # 机器可读
+ */
+
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+
+import { collect as collectTelemetry } from '../scripts/telemetry.mjs'
+import { detectRoot, detectStore } from '../detect.mjs'
+
+const ROOT = process.env.SOLOPUP_MEMORY_ROOT ?? process.env.DSH_HOME ?? `${process.env.HOME}/.dsh`
+const MEMORY_ROOT = ROOT.endsWith('memory') ? ROOT : `${ROOT}/memory`
+
+export const BASELINE = [
+  { id: 'duplicate-popscriptH-store', layer: 'detect', find: (report) => report.crossFindings.some((row) => row.id === 'X2-duplicate-store') },
+  { id: 'fixture-stores-duplicated', layer: 'accepted', find: () => false },
+  { id: 'empty-project-stores', layer: 'detect', find: (report) => report.crossFindings.some((row) => row.id === 'X1-empty-project-store') },
+  { id: 'stale-version-v0.2.0', layer: 'detect', find: (report) => report.stores.some((store) => store.findings.some((row) => row.id === 'I10-version-mention')) },
+  { id: 'truncated-paragraph-user-md', layer: 'detect', find: (report) => report.stores.some((store) => store.findings.some((row) => row.id === 'I14-truncated-paragraph' && row.refs?.[0]?.file === 'user.md')) },
+  { id: 'orphan-heading-without-index', layer: 'detect', find: (report) => report.stores.some((store) => store.findings.some((row) => row.id === 'I15-heading-without-index')) },
+  { id: 'private-plaintext-exposure', layer: 'detect', find: (report) => report.stores.some((store) => store.findings.some((row) => row.id === 'I11-private-records')) },
+  { id: 'numeric-contradiction-5/5-vs-6/6', layer: 'blind-spot', find: () => false },
+  { id: 'rule-conflict-100-vs-200-lines', layer: 'blind-spot', find: () => false },
+  { id: 'pending-candidate-8-days', layer: 'telemetry', find: () => false },
+  { id: 'state-field-lastCaptureAt-missing', layer: 'doc', find: () => false },
+  { id: 'index-summary-without-detail', layer: 'accepted', find: () => false },
+]
+
+function bench(fn, rounds = 20) {
+  const times = []
+  for (let index = 0; index < rounds; index += 1) {
+    const started = performance.now()
+    fn()
+    times.push(performance.now() - started)
+  }
+  times.sort((left, right) => left - right)
+  return { medianMs: Number(times[Math.floor(times.length / 2)].toFixed(2)), minMs: Number(times[0].toFixed(2)), maxMs: Number(times.at(-1).toFixed(2)) }
+}
+
+function syntheticStore(entries) {
+  const dir = mkdtempSync(join(tmpdir(), 'dsh-scale-'))
+  const lines = ['# 索引', '', '## project', '']
+  for (let index = 0; index < entries; index += 1) lines.push(`- [project] 规模测试条目 ${index} 编号 ${index} — project.md`)
+  writeFileSync(join(dir, 'MEMORY.md'), lines.join('\n') + '\n')
+  writeFileSync(join(dir, 'project.md'), '# project\n')
+  return dir
+}
+
+export function run() {
+  const report = detectRoot(MEMORY_ROOT)
+  const findings = report.stores.flatMap((store) => store.findings.map((row) => ({ store: store.scope, ...row })))
+  const rows = BASELINE.map((item) => ({ id: item.id, layer: item.layer, detected: item.find(report) }))
+  const detectable = rows.filter((row) => row.layer === 'detect')
+  const detected = detectable.filter((row) => row.detected)
+  return {
+    root: MEMORY_ROOT,
+    generatedAt: new Date().toISOString(),
+    recall: {
+      detectable: detectable.length,
+      detected: detected.length,
+      rate: detected.length / detectable.length,
+      missed: detectable.filter((row) => !row.detected).map((row) => row.id),
+    },
+    blindSpots: rows.filter((row) => row.layer === 'blind-spot').map((row) => row.id),
+    otherLayers: rows.filter((row) => ['telemetry', 'doc', 'accepted'].includes(row.layer)).map((row) => ({ id: row.id, layer: row.layer })),
+    detector: { findings: findings.length, errors: report.summary.errors, warnings: report.summary.warnings, infos: report.summary.infos, ...bench(() => detectRoot(MEMORY_ROOT)) },
+    telemetry: { ...bench(() => collectTelemetry(MEMORY_ROOT)) },
+    scale: (() => {
+      const rooms = { 300: syntheticStore(300), 1000: syntheticStore(1000) }
+      try {
+        return {
+          300: { ...bench(() => detectStore(rooms[300], { scope: 'project' }), 10) },
+          1000: { ...bench(() => detectStore(rooms[1000], { scope: 'project' }), 5) },
+        }
+      } finally {
+        for (const dir of Object.values(rooms)) rmSync(dir, { recursive: true, force: true })
+      }
+    })(),
+  }
+}
+
+if (process.argv[1] !== undefined && import.meta.url === `file://${process.argv[1]}`) {
+  const result = run()
+  if (process.argv.includes('--json')) process.stdout.write(JSON.stringify(result, null, 2) + '\n')
+  else {
+    const lines = [
+      `对比实验 · ${result.generatedAt}`,
+      `根目录：${result.root}`,
+      `检测器召回（只算“应由 L0 抓”的项）：${result.recall.detected}/${result.recall.detectable} = ${(result.recall.rate * 100).toFixed(0)}%${result.recall.missed.length ? '；漏：' + result.recall.missed.join('、') : ''}`,
+      `已知盲区（不冒充已覆盖）：${result.blindSpots.join('、') || '无'}`,
+      `其他层：${result.otherLayers.map((row) => `${row.id}[${row.layer}]`).join('、') || '无'}`,
+      `L0 检测耗时（20 次）：中位 ${result.detector.medianMs}ms，范围 ${result.detector.minMs}–${result.detector.maxMs}ms；存储级 findings ${result.detector.findings} 条（error ${result.detector.errors} / warning ${result.detector.warnings} / info ${result.detector.infos}）`,
+      `L3 遥测耗时（20 次）：中位 ${result.telemetry.medianMs}ms，范围 ${result.telemetry.minMs}–${result.telemetry.maxMs}ms`,
+      `规模对照：300 行索引中位 ${result.scale[300].medianMs}ms；1000 行中位 ${result.scale[1000].medianMs}ms（相似度对上限 400）`,
+    ]
+    process.stdout.write(lines.join('\n') + '\n')
+  }
+}