dsh-reference-session-collector 0.1.0 → 0.2.0

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "dsh-reference-session-collector",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
-    "tag": "latest",
+    "tag": "beta",
     "access": "public"
   },
   "description": "DSH Web 插件：会话原文投影同步器（DRS）——只读扫描 ~/.dsh/sessions 会话日志，解码后投影进自有 SQLite（segments/replaces/FTS5），经 /api/dsh-reference-session-collector 提供 surface 标记、召回对账与内容检索面。绝不写会话文件。",
@@ -49,6 +49,7 @@
     "prepack": "npm run build",
     "typecheck": "tsc -p tsconfig.json --noEmit --pretty false",
     "smoke": "node scripts/smoke-lib.mjs",
+    "smoke:real": "node scripts/rebuild-smoke.mjs",
     "test": "vitest run",
     "lint": "eslint src tests eslint.config.js",
     "check": "npm run typecheck && npm run lint && npm run test && npm run build && npm run smoke"

package/src/blocks.ts

@@ -0,0 +1,45 @@
+/**
+ * 字块字典（schema v5，2026-10-20 用户定标「整条一起存相同字块」）：
+ * segments 的 text/search_text/redacted_* 一律以 sha256 全串等值 hash 入
+ * 本字典，行内只存引用；同文=同 hash=单份存储（INSERT OR IGNORE 幂等）。
+ *
+ * 选型依据（真机实测）：surface_text 1768 行仅 23 distinct（99.2%）；
+ * text 11% / search_text 12% 整段重复；重复组字节跨度大→前缀键/分块切分
+ * 会撕裂等值判定，全串 hash 是唯一可靠粒度。hash 用 node:crypto sha256
+ * （零新增依赖；弃 blake3）。
+ *
+ * 纪律：字典只增不删（deleteSession 清行不清块——共享块归属不可知），
+ * 投影可重建、体积有上界（语料 distinct 集）；GC 属明示不做项。
+ */
+import { createHash } from 'node:crypto'
+import type { DatabaseSync } from 'node:sqlite'
+
+/** blocks 表 DDL（单一事实源：schema.ts 与测试拼库都引本常量）。 */
+export const BLOCKS_DDL = `CREATE TABLE IF NOT EXISTS blocks(
+  hash TEXT PRIMARY KEY, body TEXT NOT NULL, bytes INTEGER NOT NULL,
+  created_at TEXT DEFAULT (datetime('now')));`
+
+/** sha256 hex（64 字符）——全串等值键。 */
+export function hashOf(text: string): string {
+  return createHash('sha256').update(text, 'utf8').digest('hex')
+}
+
+export class BlocksStore {
+  private readonly insert: ReturnType<DatabaseSync['prepare']>
+
+  constructor(db: DatabaseSync) {
+    this.insert = db.prepare('INSERT OR IGNORE INTO blocks(hash, body, bytes) VALUES(?,?,?)')
+  }
+
+  /**
+   * 入字典并返回引用 hash；空文本不入典返回 null（hash 列存 NULL，读侧还原
+   * 为 ''——「未落行文本」与「空文本」在 v4 就靠此区分，语义不变）。
+   * 幂等：同文重复 ensure 只落一份（INSERT OR IGNORE + hash 主键）。
+   */
+  ensure(text: string): string | null {
+    if (text === '') return null
+    const hash = hashOf(text)
+    this.insert.run(hash, text, Buffer.byteLength(text, 'utf8'))
+    return hash
+  }
+}

package/src/index.ts

@@ -104,6 +104,9 @@ function isTrustedRequest(req: IncomingMessage, trustedHosts: readonly string[]
   return trustedHosts.some(trusted => trusted.toLowerCase() === host.toLowerCase())
 }
 
+/** R5 水位在 meta 表的键（DDL 冻结不动，kv 面落）。 */
+const BLOCKS_WATERMARK_META_KEY = 'blocks_watermark'
+
 /** sync 端口 → ProjectionStore 真身适配（dir 水位经常驻 Map 扫描）。 */
 export function createStorePort(store: ProjectionStore): SyncStorePort {
   return {
@@ -137,6 +140,16 @@ export function createStorePort(store: ProjectionStore): SyncStorePort {
     deleteSession(sessionId: string): void {
       store.deleteSession(sessionId)
     },
+    blocksWatermark(): { current: number; last: number } {
+      const current = Number((store.db.prepare('SELECT COALESCE(MAX(rowid), 0) AS m FROM blocks').get() as { m: number | bigint }).m)
+      const row = store.db.prepare('SELECT value FROM meta WHERE key=?').get(BLOCKS_WATERMARK_META_KEY) as { value: string } | undefined
+      const parsed = row === undefined ? 0 : Number(row.value)
+      return { current, last: Number.isFinite(parsed) ? parsed : 0 }
+    },
+    setBlocksWatermark(value: number): void {
+      store.db.prepare('INSERT INTO meta(key, value) VALUES(?, ?) ON CONFLICT(key) DO UPDATE SET value=excluded.value')
+        .run(BLOCKS_WATERMARK_META_KEY, String(value))
+    },
   }
 }
 
@@ -165,6 +178,22 @@ function resolveLatestSessionId(query: QueryContext): string | undefined {
   return bestId
 }
 
+/**
+ * v5 参数解析（R3/R4）：`redact` 仅 '1' 为真，其余/非法=0（缺省原文臂）；
+ * `tail` 正整数生效，非法/≤0=忽略（全量）。
+ */
+function parseRedact(url: URL): boolean {
+  return url.searchParams.get('redact') === '1'
+}
+
+function parseTail(url: URL): number | undefined {
+  const raw = url.searchParams.get('tail')
+  if (raw === null) return undefined
+  const parsed = Number(raw)
+  if (!Number.isFinite(parsed) || parsed <= 0) return undefined
+  return Math.floor(parsed)
+}
+
 /**
  * op 分发：GET `?op=…`；POST `{op:'sync'}` 触发后台同步。
  * 未知 op / 缺参 → 400（不留空壳）。
@@ -216,9 +245,13 @@ export async function handleDrsRequest(deps: DrsHandlerDeps, req: IncomingMessag
       }
       const turn = url.searchParams.get('turn') ?? undefined
       const fields = url.searchParams.get('fields') ?? undefined
+      const redact = parseRedact(url)
+      const tail = parseTail(url)
       const detail = sessionDetail(deps.query, sessionId, {
         ...(turn === undefined ? {} : { turn }),
         ...(fields === undefined ? {} : { fields }),
+        ...(tail === undefined ? {} : { tail }),
+        ...(redact ? { redact: true } : {}),
       })
       if (detail.session === undefined) {
         writeJson(res, 200, { ok: true, session: null, rows: [] })
@@ -257,6 +290,7 @@ export async function handleDrsRequest(deps: DrsHandlerDeps, req: IncomingMessag
         writeJson(res, 400, { ok: false, error: 'q parameter required' })
         return
       }
+      const redact = parseRedact(url)
       // 分组臂（steward 直连）：group=session 时走 searchGrouped，参数见
       // GroupedSearchRequest；缺省仍为逐文档平铺命中（CCI/既有调用不变）。
       if (url.searchParams.get('group') === 'session') {
@@ -275,6 +309,8 @@ export async function handleDrsRequest(deps: DrsHandlerDeps, req: IncomingMessag
           ...(url.searchParams.get('surface') === '0' ? { surfaceOnly: false } : {}),
           ...(url.searchParams.get('sort') === 'time' ? { sortBy: 'time' as const } : {}),
           ...(limitRaw !== null && Number.isFinite(Number(limitRaw)) ? { limit: Number(limitRaw) } : {}),
+          ...(url.searchParams.get('expand') === '1' ? { expand: true } : {}),
+          ...(redact ? { redact: true } : {}),
         })
         writeJson(res, 200, { ok: true, ...grouped })
         return
@@ -283,6 +319,7 @@ export async function handleDrsRequest(deps: DrsHandlerDeps, req: IncomingMessag
       writeJson(res, 200, { ok: true, ...search(deps.query, q, {
         ...(sessionId === '' ? {} : { session: sessionId }),
         ...(limitRaw === null ? {} : { limit: Number(limitRaw) }),
+        ...(redact ? { redact: true } : {}),
       }) })
       return
     }

package/src/redact.ts

@@ -0,0 +1,279 @@
+/**
+ * ⚠ VENDORED（回搬件）——源自 dsh-prime-memory `src/util/redact.ts`，
+ *   回搬时点 2026-10-20（schema v5 脱敏臂工程 task_1）。
+ *   回搬纪律：**文件级拷贝，禁止分叉**；memory 侧修复须整文件重拷并复核
+ *   对账（本文件除本头注外与源文件逐字节一致，tests/redact.spec.ts 同批
+ *   回搬仅改导入路径）。两侧共用同一引擎=脱敏口径天然一致（capture 单点
+ *   与 DRS 投影派生臂同源）。
+ */
+/**
+ * §C 载荷脱敏(memorax-absorb Wave 2 / task_14)——捕获边界的密钥擦除。
+ *
+ * 用户在对话里贴入的密钥(PEM/Bearer/JWT/Cookie/厂商 API key/邮箱/长号/高熵 ID)
+ * 若原样进 L0/L1,会被逐轮召回注入上下文并在 UI 展示。本模块在捕获单点把它们
+ * 替换为类型化占位符 `[REDACTED:<KIND>]`——占位符保留类别语义,关键词检索仍可命中。
+ *
+ * 词表/正则/allowlist/span 合并算法以 memorax `payload-redaction.ts` 为基准逐条移植
+ * (全文快照见计划 evidence/payload-redaction-snapshot.ts;findings.md 有等价内联)。
+ *
+ * 契约(sanitize 同款,tests/redact.test.ts 钉住):
+ * - 纯函数,零 I/O 零时钟零随机;输入原样返回(未命中)= 引用不变无关紧要,字符串不可变;
+ * - **幂等**:已是 `[REDACTED:KIND]` 的值不会被二次匹配;
+ * - 安全值 allowlist 命中不脱(`example`/`change-me`/`$VAR`/`${{…}}` 等);
+ * - 本函数**永不抛错**的保证由调用方 try/catch 兜底(capture 接线层,§C 红线:失败放行原文)。
+ */
+
+export type RedactionKind =
+  | 'PRIVATE_KEY'
+  | 'AUTH_TOKEN'
+  | 'COOKIE'
+  | 'API_KEY'
+  | 'CREDENTIAL'
+  | 'EMAIL'
+  | 'LONG_NUMBER'
+  | 'OPAQUE_ID';
+
+export interface RedactionResult {
+  text: string;
+  counts: Partial<Record<RedactionKind, number>>;
+  redacted: boolean;
+}
+
+interface RedactionSpan {
+  start: number;
+  end: number;
+  kind: RedactionKind;
+  priority: number;
+}
+
+interface RedactionRule {
+  pattern: RegExp;
+  kind: RedactionKind;
+  priority: number;
+  /** 取匹配的第几个分组作为敏感值(缺省 0 = 整个匹配)。 */
+  group?: number;
+  /** 值级放行判定(返回 false = 不脱)。 */
+  accept?: (value: string) => boolean;
+}
+
+const PLACEHOLDER_VALUE_PATTERN = /^\[REDACTED:[A-Z_]+\]$/;
+const SENSITIVE_KEY_SOURCE = String.raw`(?:[A-Za-z_$][A-Za-z0-9_$-]*)?(?:password|passwd|pwd|client[-_$]?secret|consumer[-_$]?secret|api[-_$]?key|access[-_$]?token|refresh[-_$]?token|auth[-_$]?token|id[-_$]?token|private[-_$]?key|secret[-_$]?access[-_$]?key|secret[-_$]?key|credential|secret|token)`;
+const CREDENTIAL_VALUE_SOURCE = String.raw`(?:\[REDACTED:[A-Z_]+\]|\$\{\{[^\r\n]*?\}\}|\{\{[^\r\n]*?\}\}|\$\{[^}\r\n]+\}|\$[A-Za-z_][A-Za-z0-9_]*|"(?:\\.|[^"\\\r\n])*"|'(?:\\.|[^'\\\r\n])*'|[^,;#}\]\)\r\n]+)`;
+/** 安全值 allowlist:命中即放行(示例/占位/环境变量引用/类型名等,脱了只会毁记忆)。 */
+const SAFE_CREDENTIAL_VALUE_PATTERN =
+  /^(?:\[REDACTED:[A-Z_]+\]|\$\{\{[^\r\n]*\}\}|\{\{[^\r\n]*\}\}|\$\{[A-Z_][A-Z0-9_]*\}|\$[A-Z_][A-Z0-9_]*|(?:process\.)?env\.[A-Z_][A-Z0-9_]*|<[^>]+>|--\S+|x{2,}|\*{2,}|\.{3}|sk[_-]x+|example|sample|change-?me|(?:your|replace)[-_][a-z0-9_-]+|string|str|number|boolean|unknown|any|null|undefined|none)$/i;
+
+const RULES: readonly RedactionRule[] = [
+  {
+    // PEM 私钥块:至对应 END,截断文件时取到文末
+    pattern: /-----BEGIN ((?:(?:RSA|EC|DSA|OPENSSH|ENCRYPTED) )?PRIVATE KEY|PGP PRIVATE KEY BLOCK)-----[\s\S]*?(?:-----END \1-----|$)/gi,
+    kind: 'PRIVATE_KEY',
+    priority: 100,
+  },
+  {
+    pattern: /(?:^|[\r\n])[ \t]*(?:Proxy-)?Authorization[ \t]*:[ \t]*([^ \t\r\n][^\r\n]*)/gim,
+    group: 1,
+    kind: 'AUTH_TOKEN',
+    priority: 95,
+  },
+  {
+    pattern: /(?:^|[^A-Za-z0-9_-])(?:Bearer|Basic)\s+["']?([A-Za-z0-9._~+/=-]{16,})(?![A-Za-z0-9._~+/=-])/gi,
+    group: 1,
+    kind: 'AUTH_TOKEN',
+    priority: 94,
+  },
+  {
+    // JWT 三段形态
+    pattern: /\beyJ[A-Za-z0-9_-]{5,}\.eyJ[A-Za-z0-9_-]{5,}\.[A-Za-z0-9_-]{16,}\b/g,
+    kind: 'AUTH_TOKEN',
+    priority: 94,
+  },
+  {
+    pattern: /(?:^|[\r\n])[ \t]*(?:Set-Cookie|Cookie)\s*:\s*([^\r\n]+)/gim,
+    group: 1,
+    kind: 'COOKIE',
+    priority: 92,
+  },
+  {
+    // 声明式赋值:key: value / key = value(含 export/const/let/var 前缀与引号键)
+    pattern: new RegExp(
+      String.raw`(?:^|[\r\n;,{}])[ \t]*(?:-[ \t]+)?(?:(?:export|const|let|var)[ \t]+)*["']?${SENSITIVE_KEY_SOURCE}["']?[ \t]*[:=][ \t]*(${CREDENTIAL_VALUE_SOURCE})`,
+      'gim',
+    ),
+    group: 1,
+    kind: 'CREDENTIAL',
+    priority: 85,
+    accept: (value) => !isSafeCredentialValue(value),
+  },
+  {
+    // CLI 形态:--api-key value / --api-key=value
+    pattern: new RegExp(
+      String.raw`--${SENSITIVE_KEY_SOURCE}(?![A-Za-z0-9_$-])(?:[ \t]+|=[ \t]*)(${CREDENTIAL_VALUE_SOURCE})`,
+      'gi',
+    ),
+    group: 1,
+    kind: 'CREDENTIAL',
+    priority: 85,
+    accept: (value) => !isSafeCredentialValue(value),
+  },
+  {
+    // URL query 形态:?api_key=...
+    pattern: new RegExp(
+      String.raw`[?&]${SENSITIVE_KEY_SOURCE}(?![A-Za-z0-9_$-])=([^&#\s"'<>]+)`,
+      'gi',
+    ),
+    group: 1,
+    kind: 'CREDENTIAL',
+    priority: 85,
+    accept: (value) => !isSafeCredentialValue(value),
+  },
+  {
+    // URL userinfo 形态:scheme://user:pass@
+    pattern: /\b[A-Za-z][A-Za-z0-9+.-]*:\/\/[^\s/:@]*:([^\s/@]+)@/g,
+    group: 1,
+    kind: 'CREDENTIAL',
+    priority: 85,
+    accept: (value) => !isSafeCredentialValue(value),
+  },
+  // ── 已知厂商 API key 形态(9 条) ──
+  { pattern: /\bsk-(?:proj-)?[A-Za-z0-9_-]{16,}[A-Za-z0-9]\b/g, kind: 'API_KEY', priority: 80 },
+  { pattern: /\bsk_[A-Za-z0-9_-]{8,}\b/g, kind: 'API_KEY', priority: 80 },
+  { pattern: /\b(?:gh[pousr]_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,})\b/g, kind: 'API_KEY', priority: 80 },
+  { pattern: /\b(?:AKIA|ASIA)[A-Z0-9]{16}\b/g, kind: 'API_KEY', priority: 80 },
+  { pattern: /\bxox[baprs]-[A-Za-z0-9-]{16,}[A-Za-z0-9]\b/g, kind: 'API_KEY', priority: 80 },
+  { pattern: /\b(?:(?:sk|rk)_live_[A-Za-z0-9]{16,}|whsec_[A-Za-z0-9]{16,})\b/g, kind: 'API_KEY', priority: 80 },
+  { pattern: /\bglpat-[A-Za-z0-9_-]{16,}[A-Za-z0-9]\b/g, kind: 'API_KEY', priority: 80 },
+  { pattern: /\bAIza[0-9A-Za-z_-]{35}\b/g, kind: 'API_KEY', priority: 80 },
+  { pattern: /\bnpm_[A-Za-z0-9]{36}\b/g, kind: 'API_KEY', priority: 80 },
+  {
+    // 邮箱(前后向断言防误切)
+    pattern: /(?<![A-Z0-9._%+-])[A-Z0-9._%+-]{1,64}@[A-Z0-9](?:[A-Z0-9.-]{0,251}[A-Z0-9])?\.[A-Z]{2,63}(?![A-Z0-9-]|\.[A-Z0-9])/gi,
+    kind: 'EMAIL',
+    priority: 70,
+  },
+  {
+    // UUID
+    pattern: /(?<![A-Za-z0-9])[0-9A-Fa-f]{8}-(?:[0-9A-Fa-f]{4}-){3}[0-9A-Fa-f]{12}(?![A-Za-z0-9])/g,
+    kind: 'OPAQUE_ID',
+    priority: 60,
+  },
+  {
+    // hex 64/40/32(含字母才脱——纯数字是普通长号,交 LONG_NUMBER)
+    pattern: /(?<![A-Za-z0-9])(?:[0-9A-Fa-f]{64}|[0-9A-Fa-f]{40}|[0-9A-Fa-f]{32})(?![A-Za-z0-9])/g,
+    kind: 'OPAQUE_ID',
+    priority: 60,
+    accept: (value) => /[A-Fa-f]/.test(value),
+  },
+  {
+    // ≥24 位字母数字高熵启发式(熵参数见 looksLikeHighEntropyOpaqueId)
+    pattern: /(?<![A-Za-z0-9])[A-Za-z0-9]{24,}(?![A-Za-z0-9])/g,
+    kind: 'OPAQUE_ID',
+    priority: 60,
+    accept: looksLikeHighEntropyOpaqueId,
+  },
+  {
+    // ≥9 位数字串(含电话形);日期形放行
+    pattern: /(?<![A-Za-z0-9.])\+?(?:\d|\(\d)[\d ()-]*\d[Xx]?\)?(?![A-Za-z0-9]|\.\d)/g,
+    kind: 'LONG_NUMBER',
+    priority: 50,
+    accept: (value) => {
+      if (value.replace(/\D/g, '').length < 9) return false;
+      const normalized = value.trim().replace(/[()]/g, '');
+      return (
+        !/^(?:19|20)\d{2}-\d{1,2}-\d{1,2}(?:[ T-]\d{1,2})?$/.test(normalized) &&
+        !/^(?:19|20)\d{2}\s+\d{1,2}\s+\d{1,2}(?:\s+\d{1,2})?$/.test(normalized)
+      );
+    },
+  },
+];
+
+/**
+ * 对文本执行 8 类脱敏。规则各自扫描 → 收集值级 span → 合并重叠 → 重拼插入占位符。
+ * 同一位置被多条规则命中时取更长/更高优先级的 span。
+ */
+export function redactSecrets(text: string): RedactionResult {
+  if (!text) return { text, counts: {}, redacted: false };
+  const spans: RedactionSpan[] = [];
+  for (const rule of RULES) collectRuleSpans(text, rule, spans);
+  const selected = mergeOverlappingSpans(spans);
+  if (selected.length === 0) return { text, counts: {}, redacted: false };
+  const counts: Partial<Record<RedactionKind, number>> = {};
+  const output: string[] = [];
+  let offset = 0;
+  for (const span of selected) {
+    output.push(text.slice(offset, span.start), `[REDACTED:${span.kind}]`);
+    counts[span.kind] = (counts[span.kind] ?? 0) + 1;
+    offset = span.end;
+  }
+  output.push(text.slice(offset));
+  return { text: output.join(''), counts, redacted: true };
+}
+
+function collectRuleSpans(text: string, rule: RedactionRule, spans: RedactionSpan[]): void {
+  rule.pattern.lastIndex = 0;
+  for (const match of text.matchAll(rule.pattern)) {
+    const value = match[rule.group ?? 0];
+    if (match.index === undefined || !value || PLACEHOLDER_VALUE_PATTERN.test(value.trim())) continue;
+    if (rule.accept && !rule.accept(value)) continue;
+    const relativeStart = match[0].lastIndexOf(value);
+    if (relativeStart < 0) continue;
+    spans.push({
+      start: match.index + relativeStart,
+      end: match.index + relativeStart + value.length,
+      kind: rule.kind,
+      priority: rule.priority,
+    });
+  }
+}
+
+function isSafeCredentialValue(rawValue: string): boolean {
+  let value = rawValue.trim();
+  if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+    value = value.slice(1, -1).trim();
+  }
+  return !value || SAFE_CREDENTIAL_VALUE_PATTERN.test(value);
+}
+
+/** 高熵判定:小写≥2 ∧ 大写≥2 ∧ 数字≥2 ∧ 字符类切换≥4 ∧ 最长连续字母段≤5 ∧ 去重字符≥12。 */
+function looksLikeHighEntropyOpaqueId(value: string): boolean {
+  let lowercase = 0;
+  let uppercase = 0;
+  let digits = 0;
+  let transitions = 0;
+  let letterRun = 0;
+  let longestLetterRun = 0;
+  let previousWasDigit: boolean | undefined;
+  const unique = new Set<string>();
+  for (const character of value) {
+    const isDigit = character >= '0' && character <= '9';
+    if (isDigit) {
+      digits += 1;
+      letterRun = 0;
+    } else {
+      if (character >= 'a' && character <= 'z') lowercase += 1;
+      else uppercase += 1;
+      letterRun += 1;
+      longestLetterRun = Math.max(longestLetterRun, letterRun);
+    }
+    if (previousWasDigit !== undefined && previousWasDigit !== isDigit) transitions += 1;
+    previousWasDigit = isDigit;
+    unique.add(character);
+  }
+  return lowercase >= 2 && uppercase >= 2 && digits >= 2 && transitions >= 4 && longestLetterRun <= 5 && unique.size >= 12;
+}
+
+function mergeOverlappingSpans(spans: RedactionSpan[]): RedactionSpan[] {
+  const sorted = [...spans].sort(
+    (left, right) => left.start - right.start || right.end - left.end || right.priority - left.priority,
+  );
+  const merged: RedactionSpan[] = [];
+  for (const span of sorted) {
+    const previous = merged.at(-1);
+    if (!previous || span.start >= previous.end) {
+      merged.push({ ...span });
+      continue;
+    }
+    previous.end = Math.max(previous.end, span.end);
+  }
+  return merged;
+}

package/src/schema.ts

@@ -1,7 +1,8 @@
 /**
- * 投影库装配（spec §DDL）：node:sqlite 四表一虚表 + WAL/mmap 缓存层 1 +
- * sessions 汇总常驻 Map（缓存层 2）。写纪律：每 session 全量重写式替换
- * （事务内 DELETE+INSERT），幂等。
+ * 投影库装配（spec §DDL）：node:sqlite 五表一虚表（sessions/segments/replaces/
+ * blocks/meta + segments_fts）+ WAL/mmap 缓存层 1 + sessions 汇总常驻 Map
+ * （缓存层 2）。写纪律：每 session 全量重写式替换（事务内 DELETE+INSERT），
+ * 幂等；字块一律走 blocks 字典 hash 引用（v5），脱敏派生臂同源生成。
  *
  * 本库只落在 ~/.dsh-reference-session-collector/projection.db ——绝不触碰会话文件。
  */
@@ -10,15 +11,19 @@ import { mkdirSync } from 'node:fs'
 import { join } from 'node:path'
 import type { SessionProjection, SessionSummary } from './projection.ts'
 import { segmentForIndex } from './segment.ts'
+import { BlocksStore, BLOCKS_DDL } from './blocks.ts'
+import { redactSecrets } from './redact.ts'
 
 /** schema 版本（meta 表；断裂式迁移的比对基线）。
  * v2=加 sessions.format_generation；
- * v3=search_text 视界变更（剥离宿主注入样板段，strip-injected horizon v2）；
- * v4=账目双修（真机取证 2026-10-20）：① text/tokens 视界补 data.content 双臂
- *   （checkpoint 替身/用户消息旧视界全计 0）；② replaces 加 live 列——替身行
- *   被后续区间再覆盖时 delta 清除不入 gross（用户定标：checkpoint 只影响其后
- *   的积分）。旧行两项口径均错，整库清空重建（投影可重建，丢行无损）。 */
-export const PROJECTION_SCHEMA_VERSION = '4'
+ * v3=search_text 视界变更（剥离宿主注入样板段）；
+ * v4=账目双修（data.content 双臂 + replaces.live）；
+ * v5=字块共享 + 脱敏派生臂（2026-10-20 用户定标）：text/search_text/
+ *   surface_text 实列退役→blocks 字典 hash 引用（surface 经 replaced_by
+ *   链派生）；新 redacted_text_hash/redacted_search_text_hash（redactSecrets
+ *   派生臂，CCI 口径 text 的 token 数学不动）；旧库列形状断裂→DROP 重建
+ *   + VACUUM（投影可重建，丢行无损）。 */
+export const PROJECTION_SCHEMA_VERSION = '5'
 
 /** sessions 表原始行（snake_case 与 DDL 一致）。 */
 export interface SessionRow {
@@ -88,11 +93,12 @@ CREATE TABLE IF NOT EXISTS segments(
   session_id TEXT NOT NULL, seq INTEGER NOT NULL, turn INTEGER DEFAULT 0,
   step INTEGER DEFAULT 0, kind TEXT NOT NULL, role TEXT DEFAULT '',
   time INTEGER DEFAULT 0,
-  text TEXT DEFAULT '', tokens INTEGER DEFAULT 0,
-  search_text TEXT DEFAULT '',
+  text_hash TEXT, tokens INTEGER DEFAULT 0,
+  search_text_hash TEXT,
+  redacted_text_hash TEXT, redacted_search_text_hash TEXT,
   on_surface INTEGER DEFAULT 1,
   compressed INTEGER DEFAULT 0,
-  surface_text TEXT, surface_tokens INTEGER, replaced_by INTEGER,
+  surface_tokens INTEGER, replaced_by INTEGER,
   PRIMARY KEY(session_id, seq)) WITHOUT ROWID;
 CREATE INDEX IF NOT EXISTS idx_segments_turn ON segments(session_id, turn, step);
 CREATE TABLE IF NOT EXISTS replaces(
@@ -107,6 +113,7 @@ CREATE VIRTUAL TABLE IF NOT EXISTS segments_fts USING fts5(
   index_text, session_id UNINDEXED, seq UNINDEXED, kind UNINDEXED,
   tokenize='unicode61');
 CREATE TABLE IF NOT EXISTS meta(key TEXT PRIMARY KEY, value TEXT);
+${BLOCKS_DDL}
 `
 
 function summaryToRow(s: SessionSummary, artifactBytes: number, artifactMtimeMs: number, extra?: ReplaceSessionExtra): SessionRow {
@@ -150,32 +157,25 @@ PRAGMA cache_size=-32000;
 PRAGMA mmap_size=268435456;
 PRAGMA application_id=0x44525343;
 `)
-  db.exec(DDL)
-  // 断裂式迁移：旧库 schema_version 存在且与新串不同 → 整库清空（投影可重建）。
-  // v1→v2 时代旧库先补列再判（列检查幂等安全）。
-  const cols = db.prepare('PRAGMA table_info(sessions)').all() as unknown as { name: string }[]
-  if (!cols.some(c => c.name === 'format_generation')) {
-    db.exec('ALTER TABLE sessions ADD COLUMN format_generation INTEGER DEFAULT -1')
-  }
-  // v3→v4 旧库补列（列检查幂等安全；行数据随后被版本重置清空）。
-  const repCols = db.prepare('PRAGMA table_info(replaces)').all() as unknown as { name: string }[]
-  if (!repCols.some(c => c.name === 'live')) {
-    db.exec('ALTER TABLE replaces ADD COLUMN live INTEGER NOT NULL DEFAULT 1')
+  // 断裂式重置（v5 起）：旧库版本串不符 → 先 DROP 全建再跑 DDL（segments 列
+  // 形状断裂，ALTER 不可补；若先 DDL，legacy 旧表会让 CREATE INDEX 引用缺失列
+  // 直接炸）。重建后 VACUUM 一次回收碎片。投影可重建，丢行无损。
+  let previous: { value: string } | undefined
+  try {
+    previous = db.prepare("SELECT value FROM meta WHERE key='schema_version'").get() as { value: string } | undefined
+  } catch {
+    previous = undefined // 新库：meta 尚未存在
   }
-  const previous = db.prepare("SELECT value FROM meta WHERE key='schema_version'").get() as { value: string } | undefined
   if (previous !== undefined && previous.value !== PROJECTION_SCHEMA_VERSION) {
-    db.exec('BEGIN')
-    try {
-      db.prepare('DELETE FROM sessions').run()
-      db.prepare('DELETE FROM segments').run()
-      db.prepare('DELETE FROM replaces').run()
-      db.prepare('DELETE FROM segments_fts').run()
-      db.exec('COMMIT')
-    } catch (error) {
-      db.exec('ROLLBACK')
-      throw error
-    }
+    db.exec(`DROP TABLE IF EXISTS segments_fts;
+             DROP TABLE IF EXISTS segments;
+             DROP TABLE IF EXISTS replaces;
+             DROP TABLE IF EXISTS sessions;
+             DROP TABLE IF EXISTS blocks;
+             DROP TABLE IF EXISTS meta`)
   }
+  db.exec(DDL)
+  if (previous !== undefined && previous.value !== PROJECTION_SCHEMA_VERSION) db.exec('VACUUM')
   db.prepare('INSERT INTO meta(key, value) VALUES(?, ?) ON CONFLICT(key) DO UPDATE SET value=excluded.value')
     .run('schema_version', PROJECTION_SCHEMA_VERSION)
 
@@ -188,9 +188,11 @@ PRAGMA application_id=0x44525343;
   loadAll()
 
   const insertSegment = db.prepare(`INSERT INTO segments(
-    session_id, seq, turn, step, kind, role, time, text, tokens, search_text,
-    on_surface, compressed, surface_text, surface_tokens, replaced_by)
-    VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`)
+    session_id, seq, turn, step, kind, role, time, text_hash, tokens, search_text_hash,
+    redacted_text_hash, redacted_search_text_hash,
+    on_surface, compressed, surface_tokens, replaced_by)
+    VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`)
+  const blocks = new BlocksStore(db)
   const insertReplace = db.prepare(`INSERT INTO replaces(
     session_id, seq, start_seq, end_seq, a_tokens, b_tokens, kind, turn, step, live)
     VALUES(?,?,?,?,?,?,?,?,?,?)`)
@@ -224,9 +226,14 @@ PRAGMA application_id=0x44525343;
         db.prepare('DELETE FROM replaces WHERE session_id=?').run(row.session_id)
         db.prepare('DELETE FROM segments_fts WHERE session_id=?').run(row.session_id)
         for (const seg of segments) {
+          // v5 写路径：原文/检索文入典（地面真值不动）；redacted 臂同源
+          // redactSecrets 派生——未命中行与原文同串同 hash，字典自动共块。
+          const redText = redactSecrets(seg.text).text
+          const redSearch = redactSecrets(seg.searchText).text
           insertSegment.run(row.session_id, seg.seq, seg.turn, seg.step, seg.kind, seg.role,
-            seg.time, seg.text, seg.tokens, seg.searchText, seg.onSurface, seg.compressed,
-            seg.surfaceText, seg.surfaceTokens, seg.replacedBy)
+            seg.time, blocks.ensure(seg.text), seg.tokens, blocks.ensure(seg.searchText),
+            blocks.ensure(redText), blocks.ensure(redSearch),
+            seg.onSurface, seg.compressed, seg.surfaceTokens, seg.replacedBy)
         }
         for (const rep of replaces) {
           insertReplace.run(row.session_id, rep.seq, rep.startSeq, rep.endSeq,
@@ -264,6 +271,7 @@ PRAGMA application_id=0x44525343;
         db.prepare('DELETE FROM segments_fts WHERE session_id=?').run(sessionId)
         db.prepare('DELETE FROM replaces WHERE session_id=?').run(sessionId)
         const head = db.prepare('DELETE FROM sessions WHERE session_id=?').run(sessionId)
+        // v5 纪律：blocks 只增不删（共享块归属不可知；字典体积有上界=语料 distinct 集）。
         db.exec('COMMIT')
         if (!existed && Number(head.changes ?? 0) === 0) return false
       } catch (error) {