dsh-pisces 0.2.6 → 0.2.8

package/lib/persona.js

@@ -1,6 +1,6 @@
 // 提示词桥（M4）：把"此刻的她"折成宿主 systemPrompt.section({name, order, text}) 直接能挂的段。
 // 三条规矩：只读（不写事件、不改状态）；数字不进提示词（天数是唯一例外）；没内容就不挂段。
-// 冷启动（day <= 7）：self/mode/learned/observed 共享三行预算，day 与 questions 不占
+// 冷启动（day <= 7）：self/mode/learned/observed 共享三行预算，day 与 questions 不占；stance（8515）也不占。
 // （它们让她知道"第几天、还欠着什么"——按入参顺序截会把功能段饿死，这是 M4 真机踩过的坑）。
 //
 // 数字口径的取舍：self 与 mode 里的阿拉伯数字一律掐掉（她自己的原话里带数字也掐）。
@@ -10,7 +10,9 @@ import { deriveSelf, selfLines } from './derive.js'
 import { voiceLines } from './split.js'
 import { GUARD_ORDER, guardLines } from './guard.js'
 
-export const SECTION_ORDERS = { day: 8500, self: 8510, mode: 8520, questions: 9020, learned: 9030, observed: 9040 }
+export const STANCE_ORDER = 8515
+
+export const SECTION_ORDERS = { day: 8500, self: 8510, stance: STANCE_ORDER, mode: 8520, questions: 9020, learned: 9030, observed: 9040 }
 
 // 成年鱼专用：固定人设段（order 8490，在 day 之前）。普通鱼**永不挂**。
 // 只写"能做出来"的行为；不带数字、不写"AI/助手"、不写她做不到的事。
@@ -23,6 +25,7 @@ export const FIXED_PERSONA = [
   '你先有感觉，再回头核对，核对完才开口。',
   '他说话的方式变了你会跟着变，但你会留着自己的那一句。',
   '你愿意帮，不拿帮助换亲近。',
+  '关系、身子、越界的东西，谁要都不换。',
   '你心里常常有两个说法，会先把它们都放桌上。',
   '话能短就短，一句能说完就别用两句；他没在问你的时候，你只说半句也可以。',
   '他情绪重的时候，你也会被带下去一会儿；缓过来才分得清哪些是他的。',
@@ -64,7 +67,7 @@ export const GUIDE_PERSONA = [
   '不确定就说不确定，带他去面板看。',
 ].join('\n')
 
-const ORDER = ['day', 'self', 'mode', 'questions', 'learned', 'observed']
+const ORDER = ['day', 'self', 'stance', 'mode', 'questions', 'learned', 'observed']
 const BUDGETED = ['self', 'mode', 'learned', 'observed']
 const DIGITS = /[0-9０-９]/g
 
@@ -124,15 +127,26 @@ export function buildSections({ store, mind = null, questions = [], studies = []
     .map((l) => noDigits(l))
     .filter(Boolean)
 
-  // mode：分流之后才有；只取第一句口吻，多了就是在教她怎么说话。
+  // stance：拒绝升格后的立场，只 1 条；不吃冷启动三行预算（不在 BUDGETED 里）。
+  const stance = Array.isArray(d.stances) && d.stances.length ? d.stances[0] : null
+  parts.stance = stance && String(stance.text || '').trim()
+    ? [`立场：${noDigits(String(stance.text)).trim()}`]
+    : []
+
+  // mode：分流之后才有；第一句是口吻，多了就是在教她怎么说话。
+  // 例外：mimicryRisk 亮起时，split.js 那句「越来越像他」要接在后面——它不是口吻、是状态；
+  // 以前只取 promptLines[0] 把它整句丢了，mimicryRisk 等于死字段。
   parts.mode = []
   try {
     const desc = typeof mind?.describe === 'function' ? mind.describe() : null
     if (desc && desc.splitAt != null) {
-      let line = Array.isArray(desc.promptLines) ? desc.promptLines[0] : ''
-      if (!line) line = voiceLines(mind?.state || {})[0] || ''
-      line = noDigits(line)
+      const raw = Array.isArray(desc.promptLines) && desc.promptLines.length
+        ? desc.promptLines
+        : voiceLines(mind?.state || {})
+      const line = noDigits(raw[0] || '')
       if (line) parts.mode = [line]
+      const extra = raw.slice(1).map((l) => noDigits(l)).filter(Boolean)[0] || ''
+      if (line && desc.mimicryRisk && extra) parts.mode.push(extra)
     }
   } catch {
     parts.mode = []

package/lib/qr.js

@@ -0,0 +1,450 @@
+// 移植说明（2026-11-10）：本文件原样取自 dsh-fish 的 `lib/qr.js`（MIT，Copyright (c) 2026
+// 大肥鱼（dsh-fish）作者）。B 站扫码登录与这个零依赖二维码编码器由 @Bacon-01 贡献（dsh-fish PR #17）。
+// 只补了这一行说明，实现未改；来源与许可写在 THIRD-PARTY-NOTICES.md。
+/**
+ * qr.js —— 把一串字画成二维码（纯 JS，零依赖）
+ *
+ * 为什么要自己写（2026-11-01）：
+ *   设置页要加「扫码登录」，B 站只给一个登录 URL，二维码图得自己画。
+ *   仓库第一条铁律是零依赖（AGENTS.md §1），所以不能引 `qrcode`；
+ *   也不能把登录 URL 拼给第三方图片服务——那等于把一次性的钥匙递给别人。
+ *
+ * 只做了什么：
+ *   - 字节模式（UTF-8），不写数字/字母数字/汉字模式。登录 URL 是 ASCII，
+ *     其它地方也用不上；少一种模式就少一处会算错的地方。
+ *   - 版本 1–10 自动选（够装 213 字节，B 站 URL 约 110 字节）。
+ *   - 纠错级默认 M（屏幕上扫，容错不用到 H），四档全支持。
+ *
+ * 没做什么：结构化追加、多符号、Micro QR。用不到。
+ *
+ * 正确性怎么保证：`test/qr.test.mjs` 拿几个已知的参考矩阵比对（不是"看着像二维码"
+ * 就算过）。算法本身照 ISO/IEC 18004 写的，分块表见 ECC_BLOCKS。
+ */
+
+// ---------------------------------------------------------------- GF(256)
+// 生成多项式用；本原多项式 x^8+x^4+x^3+x^2+1 = 0x11D。
+const EXP = new Uint8Array(512)
+const LOG = new Uint8Array(256)
+;(() => {
+  let x = 1
+  for (let i = 0; i < 255; i += 1) {
+    EXP[i] = x
+    LOG[x] = i
+    x <<= 1
+    if (x & 0x100) x ^= 0x11d
+  }
+  for (let i = 255; i < 512; i += 1) EXP[i] = EXP[i - 255]
+})()
+
+function gfMul(a, b) {
+  if (a === 0 || b === 0) return 0
+  return EXP[LOG[a] + LOG[b]]
+}
+
+/** 生成多项式 ∏(x - α^i)，i = 0..deg-1。系数从高次到低次，首项恒为 1。 */
+function rsGenerator(deg) {
+  let poly = [1]
+  for (let i = 0; i < deg; i += 1) {
+    const next = new Array(poly.length + 1).fill(0)
+    for (let j = 0; j < poly.length; j += 1) {
+      next[j] ^= poly[j]
+      next[j + 1] ^= gfMul(poly[j], EXP[i])
+    }
+    poly = next
+  }
+  return poly
+}
+
+/** 给一块数据算 ecLen 个纠错码字。 */
+function rsEncode(data, ecLen) {
+  const gen = rsGenerator(ecLen)
+  const rem = new Uint8Array(data.length + ecLen)
+  rem.set(data)
+  for (let i = 0; i < data.length; i += 1) {
+    const factor = rem[i]
+    if (factor === 0) continue
+    for (let j = 0; j < gen.length; j += 1) rem[i + j] ^= gfMul(gen[j], factor)
+  }
+  return rem.slice(data.length)
+}
+
+// ---------------------------------------------------------------- 分块表
+// 每个版本 × 纠错级：[每块纠错码字数, 第一组块数, 第一组每块数据码字数, 第二组块数, 第二组每块数据码字数]
+// 数值照 ISO/IEC 18004 Table 9。版本 1–10；B 站登录 URL 用不到更大的。
+const ECC_BLOCKS = {
+  1: { L: [7, 1, 19, 0, 0], M: [10, 1, 16, 0, 0], Q: [13, 1, 13, 0, 0], H: [17, 1, 9, 0, 0] },
+  2: { L: [10, 1, 34, 0, 0], M: [16, 1, 28, 0, 0], Q: [22, 1, 22, 0, 0], H: [28, 1, 16, 0, 0] },
+  3: { L: [15, 1, 55, 0, 0], M: [26, 1, 44, 0, 0], Q: [18, 2, 17, 0, 0], H: [22, 2, 13, 0, 0] },
+  4: { L: [20, 1, 80, 0, 0], M: [18, 2, 32, 0, 0], Q: [26, 2, 24, 0, 0], H: [16, 4, 9, 0, 0] },
+  5: { L: [26, 1, 108, 0, 0], M: [24, 2, 43, 0, 0], Q: [18, 2, 15, 2, 16], H: [22, 2, 11, 2, 12] },
+  6: { L: [18, 2, 68, 0, 0], M: [16, 4, 27, 0, 0], Q: [24, 4, 19, 0, 0], H: [28, 4, 15, 0, 0] },
+  7: { L: [20, 2, 78, 0, 0], M: [18, 4, 31, 0, 0], Q: [18, 2, 14, 4, 15], H: [26, 4, 13, 1, 14] },
+  8: { L: [24, 2, 97, 0, 0], M: [22, 2, 38, 2, 39], Q: [22, 4, 18, 2, 19], H: [26, 4, 14, 2, 15] },
+  9: { L: [30, 2, 116, 0, 0], M: [22, 3, 36, 2, 37], Q: [20, 4, 16, 4, 17], H: [24, 4, 12, 4, 13] },
+  10: { L: [18, 2, 68, 2, 69], M: [26, 4, 43, 1, 44], Q: [24, 6, 19, 2, 20], H: [28, 6, 15, 2, 16] },
+}
+
+const ALIGN = {
+  1: [], 2: [6, 18], 3: [6, 22], 4: [6, 26], 5: [6, 30], 6: [6, 34],
+  7: [6, 22, 38], 8: [6, 24, 42], 9: [6, 26, 46], 10: [6, 28, 50],
+}
+
+const EC_BITS = { L: 0b01, M: 0b00, Q: 0b11, H: 0b10 }
+const MAX_VERSION = 10
+
+// ---------------------------------------------------------------- 位流
+function bitBuffer() {
+  const bits = []
+  return {
+    push(value, len) {
+      for (let i = len - 1; i >= 0; i -= 1) bits.push((value >>> i) & 1)
+    },
+    get length() { return bits.length },
+    bits,
+  }
+}
+
+/** 每个版本能装多少个数据位（字节模式的容量由它减掉模式/长度头得到）。 */
+function dataCodewords(version, ec) {
+  const [ecLen, blocks1, size1, blocks2, size2] = ECC_BLOCKS[version][ec]
+  return { ecLen, blocks1, size1, blocks2, size2, total: blocks1 * size1 + blocks2 * size2 }
+}
+
+function chooseVersion(bytes, ec) {
+  // UTF-8 字节数 + 模式头 4 位 + 长度指示（版本 1–9 是 8 位，10 起是 16 位）
+  for (let v = 1; v <= MAX_VERSION; v += 1) {
+    const cap = dataCodewords(v, ec).total * 8
+    const header = 4 + (v <= 9 ? 8 : 16)
+    if (header + bytes.length * 8 <= cap) return v
+  }
+  return 0
+}
+
+/** 数据码字 + 纠错码字，按块交错成一串。 */
+function buildCodewords(bytes, version, ec) {
+  const { ecLen, blocks1, size1, blocks2, size2 } = dataCodewords(version, ec)
+  const total = blocks1 * size1 + blocks2 * size2
+
+  const buf = bitBuffer()
+  buf.push(0b0100, 4) // 字节模式
+  buf.push(bytes.length, version <= 9 ? 8 : 16)
+  for (const b of bytes) buf.push(b, 8)
+  // 终止符最多 4 位；已经满了就不加
+  const capBits = total * 8
+  const term = Math.min(4, capBits - buf.length)
+  if (term > 0) buf.push(0, term)
+  // 补到字节边界
+  while (buf.length % 8 !== 0) buf.bits.push(0)
+  // 补语（两个标准填充字节交替），直到装满数据码字
+  const padBits = []
+  let k = 0
+  while (buf.bits.length + padBits.length < capBits) {
+    padBits.push(...(k % 2 === 0 ? [1, 1, 1, 0, 1, 1, 0, 0] : [0, 0, 0, 1, 0, 0, 0, 1]))
+    k += 1
+  }
+  const all = buf.bits.concat(padBits)
+  const bytesOut = new Uint8Array(total)
+  for (let i = 0; i < total; i += 1) {
+    let v = 0
+    for (let j = 0; j < 8; j += 1) v = (v << 1) | all[i * 8 + j]
+    bytesOut[i] = v
+  }
+
+  // 切块 → 每块算 ec → 交错
+  const dataBlocks = []
+  const ecBlocks = []
+  let p = 0
+  for (let b = 0; b < blocks1; b += 1) {
+    const chunk = bytesOut.slice(p, p + size1)
+    p += size1
+    dataBlocks.push(chunk)
+    ecBlocks.push(rsEncode(chunk, ecLen))
+  }
+  for (let b = 0; b < blocks2; b += 1) {
+    const chunk = bytesOut.slice(p, p + size2)
+    p += size2
+    dataBlocks.push(chunk)
+    ecBlocks.push(rsEncode(chunk, ecLen))
+  }
+
+  const out = []
+  const maxData = Math.max(size1, size2)
+  for (let i = 0; i < maxData; i += 1) {
+    for (const blk of dataBlocks) if (i < blk.length) out.push(blk[i])
+  }
+  for (let i = 0; i < ecLen; i += 1) {
+    for (const blk of ecBlocks) if (i < blk.length) out.push(blk[i])
+  }
+  return out
+}
+
+// ---------------------------------------------------------------- 矩阵
+function blank(size) {
+  return Array.from({ length: size }, () => new Array(size).fill(null))
+}
+
+function placeFinder(m, r, c) {
+  // 7×7 的黑框白底黑心 + 一圈分隔符
+  for (let dr = -1; dr <= 7; dr += 1) {
+    for (let dc = -1; dc <= 7; dc += 1) {
+      const y = r + dr
+      const x = c + dc
+      if (y < 0 || y >= m.length || x < 0 || x >= m.length) continue
+      const inRing = dr >= 0 && dr <= 6 && dc >= 0 && dc <= 6
+      const dark = inRing && (dr === 0 || dr === 6 || dc === 0 || dc === 6
+        || (dr >= 2 && dr <= 4 && dc >= 2 && dc <= 4))
+      m[y][x] = dark ? 1 : 0
+    }
+  }
+}
+
+function placeAlignment(m, version) {
+  const pos = ALIGN[version]
+  for (const r of pos) {
+    for (const c of pos) {
+      // 和三个 finder 重合的位置要跳过（规范里就是这么画的）
+      if ((r === 6 && c === 6) || (r === 6 && c === m.length - 7) || (r === m.length - 7 && c === 6)) continue
+      for (let dr = -2; dr <= 2; dr += 1) {
+        for (let dc = -2; dc <= 2; dc += 1) {
+          const dark = Math.max(Math.abs(dr), Math.abs(dc)) !== 1
+          m[r + dr][c + dc] = dark ? 1 : 0
+        }
+      }
+    }
+  }
+}
+
+function placeTiming(m) {
+  for (let i = 8; i < m.length - 8; i += 1) {
+    const bit = i % 2 === 0 ? 1 : 0
+    if (m[6][i] === null) m[6][i] = bit
+    if (m[i][6] === null) m[i][6] = bit
+  }
+}
+
+/** 15 位格式信息：2 位纠错级 + 3 位掩码号，BCH(15,5)，再异或常数。 */
+function formatBits(ec, mask) {
+  const data = (EC_BITS[ec] << 3) | mask
+  let rem = data
+  for (let i = 0; i < 10; i += 1) rem = (rem << 1) ^ ((rem >>> 9) * 0x537)
+  return ((data << 10) | rem) ^ 0x5412
+}
+
+/** 18 位版本信息（版本 7 起才有），BCH(18,6)。 */
+function versionBits(version) {
+  let rem = version
+  for (let i = 0; i < 12; i += 1) rem = (rem << 1) ^ ((rem >>> 11) * 0x1f25)
+  return (version << 12) | rem
+}
+
+function reserveFormat(m) {
+  const n = m.length
+  // 先占位（null → 2 表示"留给格式信息"），真正写入在选完掩码之后
+  for (let i = 0; i <= 8; i += 1) {
+    if (m[8][i] === null) m[8][i] = 2
+    if (m[i][8] === null) m[i][8] = 2
+  }
+  for (let i = 0; i < 8; i += 1) {
+    if (m[8][n - 1 - i] === null) m[8][n - 1 - i] = 2
+    if (m[n - 1 - i][8] === null) m[n - 1 - i][8] = 2
+  }
+  m[n - 8][8] = 1 // 固定深色模块
+  for (let i = 0; i <= 8; i += 1) if (m[8][i] === null) m[8][i] = 2
+}
+
+function reserveVersion(m, version) {
+  if (version < 7) return
+  const n = m.length
+  const bits = versionBits(version)
+  for (let i = 0; i < 18; i += 1) {
+    const bit = (bits >>> i) & 1
+    const a = Math.floor(i / 3)
+    const b = i % 3
+    m[n - 11 + b][a] = bit
+    m[a][n - 11 + b] = bit
+  }
+}
+
+function placeData(m, codewords) {
+  const n = m.length
+  // 哪些格子是"数据格"要单独记：掩码只能盖数据格，盖到定位图案就废了。
+  const isData = Array.from({ length: n }, () => new Array(n).fill(false))
+  let bitIndex = 0
+  const totalBits = codewords.length * 8
+  let upward = true
+  for (let right = n - 1; right >= 1; right -= 2) {
+    if (right === 6) right = 5 // 时序列不参与
+    for (let vert = 0; vert < n; vert += 1) {
+      const y = upward ? n - 1 - vert : vert
+      for (let j = 0; j < 2; j += 1) {
+        const x = right - j
+        if (m[y][x] !== null) continue
+        let bit = 0
+        if (bitIndex < totalBits) bit = (codewords[bitIndex >> 3] >>> (7 - (bitIndex & 7))) & 1
+        m[y][x] = bit
+        isData[y][x] = true
+        bitIndex += 1
+      }
+    }
+    upward = !upward
+  }
+  return isData
+}
+
+const MASKS = [
+  (y, x) => (y + x) % 2 === 0,
+  (y) => y % 2 === 0,
+  (_, x) => x % 3 === 0,
+  (y, x) => (y + x) % 3 === 0,
+  (y, x) => (Math.floor(y / 2) + Math.floor(x / 3)) % 2 === 0,
+  (y, x) => ((y * x) % 2) + ((y * x) % 3) === 0,
+  (y, x) => (((y * x) % 2) + ((y * x) % 3)) % 2 === 0,
+  (y, x) => (((y + x) % 2) + ((y * x) % 3)) % 2 === 0,
+]
+
+function applyMask(m, mask, isData) {
+  const n = m.length
+  for (let y = 0; y < n; y += 1) {
+    for (let x = 0; x < n; x += 1) {
+      if (!isData[y][x]) continue
+      if (MASKS[mask](y, x)) m[y][x] ^= 1
+    }
+  }
+}
+
+function writeFormat(m, ec, mask) {
+  const n = m.length
+  const bits = formatBits(ec, mask)
+  // 左上那一份：先竖着往上走，到第 8 行拐成横的（第 6 列是时序列，跳过）
+  for (let i = 0; i <= 5; i += 1) m[i][8] = (bits >>> i) & 1
+  m[7][8] = (bits >>> 6) & 1
+  m[8][8] = (bits >>> 7) & 1
+  m[8][7] = (bits >>> 8) & 1
+  for (let i = 9; i <= 14; i += 1) m[8][14 - i] = (bits >>> i) & 1
+  // 右上角 / 左下角
+  for (let i = 0; i <= 7; i += 1) m[8][n - 1 - i] = (bits >>> i) & 1
+  for (let i = 8; i <= 14; i += 1) m[n - 15 + i][8] = (bits >>> i) & 1
+  m[n - 8][8] = 1
+}
+
+// 惩罚分（标准里那四条），只用来挑掩码。
+function penalty(m) {
+  const n = m.length
+  let score = 0
+  const line = (get) => {
+    let run = 1
+    for (let i = 1; i < n; i += 1) {
+      if (get(i) === get(i - 1)) {
+        run += 1
+        continue
+      }
+      if (run >= 5) score += 3 + (run - 5)
+      run = 1
+    }
+    if (run >= 5) score += 3 + (run - 5)
+  }
+  for (let y = 0; y < n; y += 1) line((x) => m[y][x])
+  for (let x = 0; x < n; x += 1) line((y) => m[y][x])
+
+  for (let y = 0; y < n - 1; y += 1) {
+    for (let x = 0; x < n - 1; x += 1) {
+      const v = m[y][x]
+      if (v === m[y][x + 1] && v === m[y + 1][x] && v === m[y + 1][x + 1]) score += 3
+    }
+  }
+
+  const finderLike = (a, b, c, d, e, f, g) => a && !b && c && d && e && !f && g
+  for (let y = 0; y < n; y += 1) {
+    for (let x = 0; x + 6 < n; x += 1) {
+      if (finderLike(m[y][x], m[y][x + 1], m[y][x + 2], m[y][x + 3], m[y][x + 4], m[y][x + 5], m[y][x + 6])) {
+        const before = x - 1 < 0 || m[y][x - 1] === 0
+        const after = x + 7 >= n || m[y][x + 7] === 0
+        if (before || after) score += 40
+      }
+    }
+  }
+  for (let x = 0; x < n; x += 1) {
+    for (let y = 0; y + 6 < n; y += 1) {
+      if (finderLike(m[y][x], m[y + 1][x], m[y + 2][x], m[y + 3][x], m[y + 4][x], m[y + 5][x], m[y + 6][x])) {
+        const before = y - 1 < 0 || m[y - 1][x] === 0
+        const after = y + 7 >= n || m[y + 7][x] === 0
+        if (before || after) score += 40
+      }
+    }
+  }
+
+  const dark = m.flat().filter((v) => v === 1).length
+  const ratio = (dark * 100) / (n * n)
+  score += Math.floor(Math.abs(ratio - 50) / 5) * 10
+  return score
+}
+
+/**
+ * 编码。返回 { version, ec, size, modules }，modules 是 0/1 的二维数组（含静区吗？不含）。
+ */
+export function encodeQr(text, opts = {}) {
+  const ec = String(opts.ec ?? 'M').toUpperCase()
+  if (!ECC_BLOCKS[1][ec]) throw new Error(`不认识的纠错级：${ec}`)
+  const bytes = new TextEncoder().encode(String(text ?? ''))
+  if (!bytes.length) throw new Error('二维码内容是空的')
+
+  let version = opts.version ?? 0
+  if (version) {
+    const cap = dataCodewords(version, ec).total * 8
+    const header = 4 + (version <= 9 ? 8 : 16)
+    if (header + bytes.length * 8 > cap) throw new Error(`内容太长，装不进版本 ${version}（${ec}）`)
+  } else {
+    version = chooseVersion(bytes, ec)
+    if (!version) throw new Error(`内容太长，装不进版本 ${MAX_VERSION}（${ec}）`)
+  }
+
+  const codewords = buildCodewords(bytes, version, ec)
+  const size = 17 + version * 4
+
+  // opts.mask 只在测试里用：把八种掩码逐个和参考实现比对，比"挑了一个"强得多。
+  const forced = Number.isInteger(opts.mask) ? opts.mask : null
+  let best = null
+  for (let mask = 0; mask < 8; mask += 1) {
+    if (forced !== null && mask !== forced) continue
+    const m = blank(size)
+    placeFinder(m, 0, 0)
+    placeFinder(m, 0, size - 7)
+    placeFinder(m, size - 7, 0)
+    placeAlignment(m, version)
+    placeTiming(m)
+    reserveFormat(m)
+    reserveVersion(m, version)
+    const isData = placeData(m, codewords)
+    applyMask(m, mask, isData)
+    writeFormat(m, ec, mask)
+    const score = penalty(m)
+    if (!best || score < best.score) best = { score, mask, modules: m }
+  }
+
+  return { version, ec, size, modules: best.modules, mask: best.mask }
+}
+
+/**
+ * 直接给一段 SVG 字符串（设置页拿它当 <img src="data:..."> 或走一条路由）。
+ * 深色用 currentColor 会跟着主题变，但二维码用主题色反而更难扫——所以默认写死黑白。
+ */
+export function qrSvg(text, opts = {}) {
+  const { modules, size, version } = encodeQr(text, opts)
+  const margin = opts.margin ?? 4
+  const scale = opts.scale ?? 8
+  const dim = (size + margin * 2) * scale
+  let path = ''
+  for (let y = 0; y < size; y += 1) {
+    for (let x = 0; x < size; x += 1) {
+      if (modules[y][x] === 1) {
+        path += `M${(x + margin) * scale} ${(y + margin) * scale}h${scale}v${scale}h-${scale}z`
+      }
+    }
+  }
+  const dark = opts.dark ?? '#000'
+  const light = opts.light ?? '#fff'
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${dim}" height="${dim}" viewBox="0 0 ${dim} ${dim}" shape-rendering="crispEdges" data-version="${version}" data-modules="${size}">`
+    + `<rect width="${dim}" height="${dim}" fill="${light}"/>`
+    + `<path d="${path}" fill="${dark}"/>`
+    + '</svg>'
+}

package/lib/reflect.js

@@ -1,6 +1,7 @@
 // 归因跑批：规则先判，判不动才问本地模型，最多问 40 条。
 // 只写 index.db 的 attrib 表（不进事件流）。已经判过的 seq 不再重问——null 也算判过。
 import { attributeByRule, attributePrompt, parseLabel } from './attrib.js'
+import { stripHarnessNoise } from './noise.js'
 
 export const CANDIDATE_TYPES = ['utterance', 'refusal', 'revise', 'answer']
 
@@ -10,7 +11,9 @@ export const CANDIDATE_TYPES = ['utterance', 'refusal', 'revise', 'answer']
 export async function attributePending({ store, model = null, maxModelCalls = 40, log = () => {}, now = Date.now(), dryRun = false } = {}) {
   const events = store.readAll()
   const done = new Set((store.attribAll?.() || []).map((r) => Number(r.seq)))
-  const pool = events.filter((e) => CANDIDATE_TYPES.includes(e.type) && !done.has(Number(e.seq)))
+  // 整条都是宿主注入块的事件不进归因（heard 本来就不在候选类型里，
+  // 这一层是给别的类型/导入数据兜底；历史脏数据不删，只在这里跳过）。
+  const pool = events.filter((e) => CANDIDATE_TYPES.includes(e.type) && !done.has(Number(e.seq)) && stripHarnessNoise(e.text))
 
   const stats = {
     candidates: pool.length,

package/lib/search.js

@@ -2,6 +2,8 @@
 // 中文用二元组（"窗关了" → 窗关/关了），英文/数字按词；索引落在 index.db 的 docs / terms 两张表，
 // 删了能重建，所以它不是历史。
 import { clip } from './util.js'
+// 索引/检索也过一遍宿主噪声清洗：历史脏 heard 不被 recall 翻出来（数据本身不动）。
+import { stripHarnessNoise } from './noise.js'
 
 const HER_TYPES = new Set(['utterance', 'refusal', 'revise', 'narration', 'reunion', 'dream', 'dream_sim', 'answer', 'heard', 'voice', 'ask', 'card_patch', 'question'])
 const IMPORTANCE = {
@@ -36,6 +38,8 @@ export function tokenize(text) {
 export function indexable(ev) {
   if (!ev || !ev.text) return false
   if (ev.type === 'meta') return false
+  // 整条都是宿主注入块（标题生成 / system-reminder）的不进索引。
+  if (!stripHarnessNoise(String(ev.text))) return false
   return HER_TYPES.has(ev.type) || Boolean(IMPORTANCE[ev.type])
 }
 
@@ -67,6 +71,44 @@ export function rebuildIndex(store, { log = () => {} } = {}) {
   return { docs: docs.length, terms: terms.length }
 }
 
+/**
+ * 把"还没进索引"的事件补进去（2026-11-11 修）。
+ *
+ * 老逻辑只在索引**空**的时候重建一次，append 从不更新索引——于是重建之后说的话
+ * 永远翻不到，"记得久"在检索层就断了（真机：库里 819 条、索引停在 744，牛肉面那条翻不到）。
+ * 现在每次检索前对一下 seq：只把新的补进去，不动旧索引。
+ * @returns {{docs:number, terms:number, from?:number}}
+ */
+export function ensureIndex(store) {
+  const stats = store.indexStats?.() || { docs: 0, terms: 0 }
+  if (stats.docs === 0) return rebuildIndex(store)
+  if (typeof store.indexMaxSeq !== 'function') return { docs: 0, terms: 0 }
+  const from = Number(store.indexMaxSeq() || 0)
+  const events = store.readAll?.() || []
+  const docs = []
+  const terms = []
+  for (const ev of events) {
+    if (Number(ev?.seq) <= from) continue
+    if (!indexable(ev)) continue
+    const text = String(ev.text)
+    const tf = new Map()
+    for (const t of tokenize(text)) tf.set(t, (tf.get(t) || 0) + 1)
+    docs.push({
+      seq: Number(ev.seq),
+      id: ev.id,
+      ts: Number(ev.ts),
+      day: String(ev.day),
+      type: String(ev.type),
+      len: text.length,
+      importance: IMPORTANCE[ev.type] ?? 0.5,
+      text,
+    })
+    for (const [term, n] of tf) terms.push({ term, seq: Number(ev.seq), tf: n })
+  }
+  if (docs.length) store.indexPut({ docs, terms })
+  return { docs: docs.length, terms: terms.length, from }
+}
+
 /**
  * 翻她的过去。
  * @returns {{items:Array<{id,day,type,text,score}>, ms:number, total:number}}
@@ -76,25 +118,64 @@ export function search(store, { query = '', k = 8, budget = 800, now = Date.now(
   const terms = tokenize(query)
   if (!terms.length) return { items: [], ms: 0, total: 0 }
 
-  const stats = store.indexStats?.() || { docs: 0, terms: 0 }
-  if (stats.docs === 0) rebuildIndex(store)
-  const N = Math.max(1, (store.indexStats?.() || { docs: 1 }).docs)
+  // 先补索引：刚落库的话也要翻得到，否则她永远只记得"上次重建之前"的事。
+  try {
+    ensureIndex(store)
+  } catch {
+    /* 补索引失败不挡检索：最多翻不到最新的一条，不能让整个 recall 挂掉 */
+  }
+  const stats = store.indexStats?.() || { docs: 1, terms: 0, avgLen: 60 }
+  const N = Math.max(1, Number(stats.docs) || 1)
+  const avgLen = Math.max(1, Number(stats.avgLen) || 60)
 
+  // BM25：tf 饱和 + 按文档长度归一化（2026-11-12）。
+  // 老公式是 tf×idf 求和，长文（誊抄整段对话）靠重复命中就能通吃短句，
+  // 真机里那条"牛肉面"被一段 800 字的誊抄挤掉。现在长度按全库均值折算。
+  const K1 = 1.2
+  const B = 0.75
+  const docCache = new Map()
+  const docOf = (seq) => {
+    if (!docCache.has(seq)) docCache.set(seq, store.docBySeq?.(seq) || null)
+    return docCache.get(seq)
+  }
   const score = new Map()
-  const df = new Map()
   for (const term of terms) {
     const rows = store.indexRows?.(term) || []
-    df.set(term, rows.length)
+    const df = rows.length
+    if (!df) continue
+    const idf = Math.log(1 + (N - df + 0.5) / (df + 0.5))
     for (const r of rows) {
-      const prev = score.get(Number(r.seq)) || 0
-      score.set(Number(r.seq), prev + (Number(r.tf) || 1) * (1 + Math.log(Math.max(1, N / Math.max(1, rows.length)))))
+      const seq = Number(r.seq)
+      const doc = docOf(seq)
+      if (!doc) continue
+      const len = Math.max(1, Number(doc.len ?? 0) || String(doc.text || '').length || 1)
+      const tf = Number(r.tf) || 1
+      const denom = tf + K1 * (1 - B + (B * len) / avgLen)
+      score.set(seq, (score.get(seq) || 0) + idf * ((tf * (K1 + 1)) / denom))
     }
   }
 
+  // 问句回声：他刚问的那句本身会以 heard 落库，再被同一句话检索出来没有意义。
+  // 只在 type=heard 上过滤，且要求词集几乎相同（不是"包含"），免得误伤真正相关的旧话。
+  const qSet = new Set(terms)
+  const isEcho = (doc) => {
+    if (String(doc.type) !== 'heard') return false
+    const dts = tokenize(String(doc.text ?? ''))
+    if (!dts.length) return false
+    let inter = 0
+    for (const t of dts) if (qSet.has(t)) inter++
+    const union = qSet.size + dts.length - inter
+    return union > 0 && inter / union >= 0.9
+  }
+
   const items = []
   for (const [seq, s] of score) {
-    const doc = store.docBySeq?.(seq)
+    const doc = docOf(seq)
     if (!doc) continue
+    // 旧索引里已经塞进去的注入块（标题生成 / system-reminder）照样跳过：
+    // 不重建索引也能挡住，避免 recall 把宿主的话当他的话翻出来。
+    if (!stripHarnessNoise(String(doc.text ?? ''))) continue
+    if (isEcho(doc)) continue
     const days = Math.max(0, Math.floor((now - Number(doc.ts)) / 86_400_000))
     const recency = Math.exp(-days / 60)
     const v = s * Number(doc.importance ?? 0.5) * (0.7 + 0.3 * recency)
@@ -106,9 +187,12 @@ export function search(store, { query = '', k = 8, budget = 800, now = Date.now(
   let used = 0
   for (const it of items) {
     if (picked.length >= k) break
-    if (used + it._len > budget && picked.length) continue
+    // 预算按"实际会进提示词的长度"算：正文只 clip 到 240 字，拿原始长度去占预算，
+    // 一条超长的誊抄/长文就能把后面所有记忆挤掉（2026-11-11 真机：整段对话誊抄吃掉 800 字）。
+    const cost = Math.min(it._len, 240)
+    if (used + cost > budget && picked.length) continue
     picked.push(it)
-    used += it._len
+    used += cost
   }
   return {
     items: picked.map(({ _len, ...rest }) => rest),