dsh-pisces 0.2.7 → 0.2.8

package/lib/noise.js

@@ -0,0 +1,68 @@
+// 宿主夹带在 user 消息里的系统噪声：计时行、时区行、运行时上下文行，以及一整块注入
+// （知识库大纲、技能清单、<system-reminder>、会话标题生成请求）。它们不是他说的。
+//
+// 写入时：attach.js 记 heard 之前过一遍，剥完为空就不落库。
+// 读取时：归因（reflect.js）和检索（search.js）也过同一份规则，这样早先已经落库的
+// 脏 heard 不会被判成她的话、也不会被 recall 翻出来（历史数据不改不删）。
+//
+// 口径：噪声整行删；尾部附加块从标记行起删到结尾；有闭合标签的块删到闭合行；
+// 一行全是 ─（U+2500，≥8）也是块头。剥完 trim，可能返回空串。
+const NOISE_LINE = /^(?:Time sampled while preparing turn\b|Browser time zone\b|Elapsed since the preceding model-visible message:|Elapsed since the preceding step context:|Current runtime context\.|Current working directory:|Current DSH file policy:|Current DeepSeek Harness implementation checkout:|Current DeepSeek Harness Web GUI URL:|Approval prompts are disabled in this session:|关于这个工作区的知识库|<available_skills|<\/available_skills>)/i
+const NOISE_BLOCK_MARKERS = [
+  '这个文件属于',
+  '关于这个工作的知识库',
+  '关于这个工作区的知识库',
+  '知识库（指令见前文',
+]
+const RULE_LINE = /^─{8,}$/
+
+// 会话标题生成：宿主让模型给会话起名的请求，真机形状是整条 user 消息
+// 「Generate the session title from this JSON array of human messages:」+ 一段 JSON。
+// 只认英文祈使句 + title，宁可漏洗；JSON 是尾随块，所以从这行删到结尾。
+const TITLE_PROMPT = /^\s*Generate (?:a |the )?(?:session|conversation|chat) title\b/i
+
+// <system-reminder> / <系统提醒> 整块注入（技能目录等）。有闭合标签就只删这一块，
+// 没有闭合就当尾部块删到结尾——不把块后面的他自己的话带走。
+const REMINDER_OPEN = /<system-reminder>|<系统提醒>/i
+const REMINDER_CLOSE = /<\/system-reminder>|<\/系统提醒>/i
+
+/**
+ * 剥掉宿主夹带在用户消息里的系统噪声；只用于"他说的话"，utterance 不清洗。
+ * 剥完 trim；可能返回空串（整条都是注入块），调用方据此不落库/跳过。
+ */
+export function stripHarnessNoise(text) {
+  const raw = String(text ?? '')
+  if (!raw) return ''
+  const lines = raw.split(/\r?\n/)
+  const out = []
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]
+    const trimmed = line.trim()
+    // 分隔线之后到结尾都是宿主附加块（真机形状：一条长横线把对话和注入切开）。
+    if (RULE_LINE.test(trimmed)) break
+    // 这几个标记开头的一段是宿主附加的尾部整块：连标记行一起删到结尾。
+    if (NOISE_BLOCK_MARKERS.some((m) => line.includes(m))) break
+    // 会话标题生成请求是尾部整块：正文是 human messages 的 JSON，一起删。
+    if (TITLE_PROMPT.test(line)) break
+    if (line.includes('<available_skills')) {
+      // 技能清单有闭合标签：整块（含闭合行）删掉；没有闭合就当尾部块删到结尾。
+      let j = i
+      while (j < lines.length && !lines[j].includes('</available_skills>')) j++
+      i = j
+      continue
+    }
+    if (line.includes('</available_skills>')) continue
+    if (REMINDER_OPEN.test(line)) {
+      // 同一行就闭合的块只删这一行；否则删到闭合行；没有闭合就删到结尾。
+      if (REMINDER_CLOSE.test(line)) continue
+      let j = i + 1
+      while (j < lines.length && !REMINDER_CLOSE.test(lines[j])) j++
+      i = j
+      continue
+    }
+    if (REMINDER_CLOSE.test(line)) continue
+    if (NOISE_LINE.test(trimmed)) continue
+    out.push(line)
+  }
+  return out.join('\n').trim()
+}

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/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),

package/lib/settings.js

@@ -68,10 +68,10 @@ export const SCHEMA = [
     path: 'dual.mode',
     kind: 'enum',
     label: '双流档位',
-    hint: 'A 暗栏 / B 顺序；只有双流开着才有用',
+    hint: 'A 暗栏多一次暗中重写（更圆、更长）；B 顺序先算约束再写（少一层重写，更直接）。只有双流开着才有用。',
     options: [
-      { value: 'A', label: 'A 档（暗栏）' },
-      { value: 'B', label: 'B 档（顺序）' },
+      { value: 'A', label: 'A 档（暗栏）：先暗中算一遍再重写，话更圆更长' },
+      { value: 'B', label: 'B 档（顺序）：先算约束再写，少一层重写，更直接' },
     ],
     restart: true,
   },

package/lib/store.js

@@ -345,12 +345,22 @@ export async function createStore({ root, forceJsonl = false, log = () => {} } =
   }
   function indexStats() {
     if (index?.db) {
+      const docs = Number(index.db.prepare('SELECT COUNT(*) c FROM docs').get().c)
+      // 平均文档长度：BM25 的长度归一化要用（2026-11-12）。
+      const avgLen = Math.round(Number(index.db.prepare('SELECT AVG(len) a FROM docs').get()?.a || 0) * 10) / 10
       return {
-        docs: Number(index.db.prepare('SELECT COUNT(*) c FROM docs').get().c),
+        docs,
         terms: Number(index.db.prepare('SELECT COUNT(*) c FROM terms').get().c),
+        avgLen,
       }
     }
-    return { docs: docsMem.size, terms: termsMem.size }
+    let sum = 0
+    for (const d of docsMem.values()) sum += Number(d.len ?? String(d.text || '').length) || 0
+    return {
+      docs: docsMem.size,
+      terms: termsMem.size,
+      avgLen: docsMem.size ? Math.round((sum / docsMem.size) * 10) / 10 : 0,
+    }
   }
   function indexRows(term) {
     if (index?.db) {
@@ -365,6 +375,16 @@ export async function createStore({ root, forceJsonl = false, log = () => {} } =
     }
     return docsMem.get(Number(seq)) || null
   }
+  // 索引里最大的 seq：search 拿它跟事件流对，判断有没有"新说的还没进索引"。
+  function indexMaxSeq() {
+    if (index?.db) {
+      const r = index.db.prepare('SELECT MAX(seq) AS m FROM docs').get()
+      return Number(r?.m) || 0
+    }
+    let m = 0
+    for (const k of docsMem.keys()) if (Number(k) > m) m = Number(k)
+    return m
+  }
 
   // ---- 常识层：world.db ----
   function worldWrite({ elements = [], objects = [], scenes = [], unsettled = [] } = {}) {
@@ -421,6 +441,7 @@ export async function createStore({ root, forceJsonl = false, log = () => {} } =
     indexPut,
     indexStats,
     indexRows,
+    indexMaxSeq,
     docBySeq,
     worldWrite,
     worldRead,

package/lib/tools.js

@@ -350,23 +350,31 @@ function speakTool(deps) {
 
 function selfTool(deps) {
   const log = safeLog(deps)
+  const verify = typeof deps?.verifyDevkey === 'function' ? deps.verifyDevkey : () => false
   return {
     name: 'pisces_self',
-    description: '自查：你存在了几天、有几条判断/拒绝/疤、分流了没有。',
-    parameters: params({}, []),
+    description: '自查：你存在了几天、有几条判断/拒绝/疤、分流了没有（数字要验过钥匙才给）。',
+    parameters: params(
+      { key: { type: 'string', description: '开发者钥匙；不带就只回个大概，不给数字' } },
+      [],
+    ),
     output: output(),
-    execute: async () => {
+    execute: async (args) => {
       try {
+        const key = typeof args?.key === 'string' ? args.key.trim() : ''
         const r = await deps.selfView()
         if (!r || r.ok === false) return textOut('[看不到自己]')
         const v = r.view && typeof r.view === 'object' ? r.view : {}
         const day = numOf(v.day ?? v.days, 1)
+        const split = v.split === true || v.mode?.split === true
+        const splitText = split ? '分流了' : '还没分流'
+        // 数字只给验过钥匙的人：自称开发者的人套不到计数，也套不到路径。
+        if (!key || verify(key) !== true) return textOut(`[天 ${day} · 还记着些事 · ${splitText}]`)
         const beliefs = countOf(v.beliefs ?? v.beliefCount ?? v.judgements)
         const refusals = countOf(v.refusals ?? v.refusalCount)
         const scars = countOf(v.scars ?? v.scarCount)
-        const split = v.split === true || v.mode?.split === true
         // 只取天数与四个计数；dominance / weight / order 一律不出现在回执里。
-        return textOut(`[天 ${day} · 判断 ${beliefs} · 拒绝 ${refusals} · 疤 ${scars} · ${split ? '分流了' : '还没分流'}]`)
+        return textOut(`[天 ${day} · 判断 ${beliefs} · 拒绝 ${refusals} · 疤 ${scars} · ${splitText}]`)
       } catch (e) {
         log(`自查失败：${e?.message || e}`)
         return textOut('[看不到自己]')
@@ -441,13 +449,19 @@ function guideTool(deps) {
 
 function checkTool(deps) {
   const log = safeLog(deps)
+  const verify = typeof deps?.verifyDevkey === 'function' ? deps.verifyDevkey : () => false
   return {
     name: 'pisces_check',
-    description: '体检：读一遍她的库和状态，看有没有起点、多久没整理、有没有问题悬着、现在好感多少。',
-    parameters: params({}, []),
+    description: '体检：读一遍她的库和状态，看有没有起点、多久没整理、有没有问题悬着、现在好感多少（数字要验过钥匙才给）。',
+    parameters: params(
+      { key: { type: 'string', description: '开发者钥匙；不带就只说个大概，不给数字' } },
+      [],
+    ),
     output: output(),
-    execute: async () => {
+    execute: async (args) => {
       try {
+        const key = typeof args?.key === 'string' ? args.key.trim() : ''
+        if (!key || verify(key) !== true) return textOut('[看着没大毛病] 日子照走，没出什么事')
         const text = String((await deps.check()) ?? '').trim()
         return textOut(text || '[看不出] 面板没读出来')
       } catch (e) {

package/lib/version.js

@@ -1,2 +1,2 @@
 // 包版本：只给观测台/日志用，不参与任何判定。
-export const VERSION = '0.0.1'
+export const VERSION = '0.2.8'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-pisces",
-  "version": "0.2.7",
+  "version": "0.2.8",
   "private": false,
   "description": "鱼肥生双：一只会长大的本地小鱼（DSH 插件）。事件流记忆、渐进揭开、好感、新手引导；派希丝是养成目标。",
   "type": "module",