dsh-pisces 0.1.4 → 0.2.0

package/README.md

@@ -35,14 +35,11 @@
 
 这些是**思路借鉴**，不是代码依赖；每个项目的代码各自独立，本仓库没有复制它们的实现。
 
-- **dsh-fish** —— 宿主骨架、四阶段门、叫醒只给处境；本项目从它的形态长出来。npm：<https://www.npmjs.com/package/dsh-fish>
-- **dsh-fish-memory** —— 记忆鲜活度与半衰期、中文双字组检索、命中才注入。
-- **dsh-fish-river** —— 三层记忆（成长 / 关系 / 流水）、群聊不污染人格。
+- **dsh-fish** —— 事件流 + 纯函数派生 + 面板形态，本项目的骨架从它长出来。npm：<https://www.npmjs.com/package/@ssamurias/dsh-fish>
+- **dsh-fish-memory** —— 记忆鲜活度与半衰期、中文检索。
+- **Character Card V2** —— `export.js` 的 CCv2 导出格式。
 - **dsh-companion** —— 好感分档、关系产品化的样本。
-- **Character Card V2** —— 卡片格式兼容（CCv2 导出）。
-- **Generative Agents** —— memory stream + 定期 reflection。
-- **DUMA / 双流** —— 快慢两模型、冲突才二次调用。
-- **dsh-fish-tone / persona_core** —— 语病密度、单轮人格变化上限。
+- **Generative Agents** —— memory stream + 定期 reflection 的启发。
 - **DeepSeek Harness** —— 宿主、插件体系、slots / systemPrompt / tools。
 - **双鱼座性格的公开资料**（经 Exa 检索整理）—— 她的性格起点。
 - **所有养过鱼的人** —— 社区里"把 AI 当室友养"的尝试。

package/client.js

@@ -894,15 +894,12 @@ window.__ModuleLoader__.load({
     // -------------------------------------------------------------------------
 
     const THANKS = [
-      // 应谢尽谢：dsh-fish 排第一；隐藏项目与作者前作不列。
-      { name: 'dsh-fish', what: '宿主骨架、四阶段门、叫醒只给处境；本项目从它的形态长出来。', href: 'https://www.npmjs.com/package/dsh-fish' },
-      { name: 'dsh-fish-memory', what: '记忆鲜活度与半衰期、中文双字组检索、命中才注入。' },
-      { name: 'dsh-fish-river', what: '三层记忆（成长 / 关系 / 流水）、群聊不污染人格。' },
+      // 2026-11-10 定稿：八条；用户自己的插件/前作不鸣谢，dsh-fish 排第一。
+      { name: 'dsh-fish', what: '事件流 + 纯函数派生 + 面板形态，本项目的骨架从它长出来。', href: 'https://www.npmjs.com/package/@ssamurias/dsh-fish' },
+      { name: 'dsh-fish-memory', what: '记忆鲜活度与半衰期、中文检索。' },
+      { name: 'Character Card V2', what: '`export.js` 的 CCv2 导出格式。' },
       { name: 'dsh-companion', what: '好感分档、关系产品化的样本。' },
-      { name: 'Character Card V2', what: '卡片格式兼容（CCv2 导出）。' },
-      { name: 'Generative Agents', what: 'memory stream + 定期 reflection。' },
-      { name: 'DUMA / 双流', what: '快慢两模型、冲突才二次调用。' },
-      { name: 'dsh-fish-tone / persona_core', what: '语病密度、单轮人格变化上限。' },
+      { name: 'Generative Agents', what: 'memory stream + 定期 reflection 的启发。' },
       { name: 'DeepSeek Harness', what: '宿主、插件体系、slots / systemPrompt / tools。' },
       { name: '双鱼座性格的公开资料', what: '（经 Exa 检索整理）她的性格起点。' },
       { name: '所有养过鱼的人', what: '社区里"把 AI 当室友养"的尝试。' },

package/lib/attach.js

@@ -15,11 +15,51 @@
 // 记进她的库。写库是副作用：失败只吞掉，绝不拖慢/改变流。
 import { buildSections as defaultBuildSections } from './persona.js'
 import { steerLines } from './guard.js'
+import { search as defaultSearchMemory } from './search.js'
+import { clip } from './util.js'
 import { MAX_TEXT } from './schema.js'
 
 // getStore() 返回 null（ready 还没到）时的重试间隔。定时器 unref，不拦进程退出。
 const STORE_RETRY_MS = 250
 
+// 「此刻想起」：每轮按他刚说的话检索她的记忆，把最相关的几条只塞进这一次请求的
+// system（不写事件、不落库、不进对话）。检索失败/没结果就当没这回事，绝不报错。
+// 上限是保守值：单条 120 字、整段 800 字（约 800 tokens），超了截断。
+export const RECALL_HEADER = '[此刻想起]'
+export const RECALL_K = 5
+export const RECALL_ITEM_CHARS = 120
+export const RECALL_MAX_CHARS = 800
+
+/**
+ * 把检索结果折成这一次的注入块；没有可用条目返回空串。
+ * 格式固定：第一行标题，之后每条一行 `- 原文`。单条 ≤120 字、整段 ≤800 字，
+ * 超了截断（不会抛错）；不写"检索到/相关度"这类词，也不带 id/天数。
+ */
+export function recallBlockFrom(items, {
+  k = RECALL_K,
+  max = RECALL_MAX_CHARS,
+  itemChars = RECALL_ITEM_CHARS,
+} = {}) {
+  const list = Array.isArray(items) ? items : []
+  const lines = []
+  let used = RECALL_HEADER.length
+  let picked = 0
+  for (const it of list) {
+    if (picked >= k || used >= max) break
+    const text = clip(it?.text, itemChars)
+    if (!text) continue
+    // 留一个换行的位置；剩得太少就不塞了（半行没有意义）。
+    const room = max - used - 1
+    if (room < 4) break
+    const line = `- ${text}`
+    const body = line.length > room ? line.slice(0, room) : line
+    lines.push(body)
+    used += 1 + body.length
+    picked++
+  }
+  return lines.length ? [RECALL_HEADER, ...lines].join('\n') : ''
+}
+
 // 开发者钥匙命中时追加到这一次请求 system 的那段话。
 // 只在这里出现；钥匙本身一个字都不进来，也不写事件、不写日志。
 export const DEV_PROMPT =
@@ -292,6 +332,11 @@ function resolveSystemPrompt(agent) {
  *   waterfall，宿主每个会话的生成都会经过同一个监听器；只有它返回真才 recordHeard /
  *   wrapUtterance。返回假时这条流原样 next()：不改 options、不记事件、不包流。
  *   不传 = 默认不记（安全优先），并 log 一行「聊天落库：没有会话判据，跳过」。
+ *   searchMemory 可选：`(store, {query,k,budget}) => {items:[{text}]}`，默认用 lib/search.js
+ *   的 search。只在 isHerSession 为真、库就绪、且清洗后的他有话时说：取 top 5、单条 ≤120 字、
+ *   整段 ≤800 字，折成 `[此刻想起]` 追加到这一次请求的 system 末尾（排在 guard/dev 之后）。
+ *   只进 system，不写事件、不落库、不进对话；检索失败/没结果 = 不注入、不报错、不影响流。
+ *   注入次数进 state.recallInjected（只给 /bridge 看次数，不留正文）。
  * @returns {((() => void) & { info?: object, attachInfo?: object })}
  *   dispose()：摘掉 agent/created 与 llm/stream 监听，幂等。
  *   dispose.info / dispose.attachInfo：只读快照（enabled/storeReady/agentsSeen/sectionsAttached/stream…）。
@@ -303,6 +348,7 @@ export function attachToAgents(ctx, {
   isDevkey = null,
   shouldAttach = null,
   isHerSession = null,
+  searchMemory = defaultSearchMemory,
   config = {},
   log = () => {},
   now = () => Date.now(),
@@ -321,6 +367,8 @@ export function attachToAgents(ctx, {
     // 只给 /bridge 看的次数：命中几次，不给任何正文/原因。
     guardHits: 0,
     devHits: 0,
+    // 「此刻想起」注入过几次（只给 /bridge 看次数，不留正文）。
+    recallInjected: 0,
     // 聊天落库的可观测计数（只给次数/形状，不给正文）：
     // streamsWrapped 包过的流数（只数她的流）；streamsSkipped 判据判掉、原样放行的流数；
     // chunksSeen 看到的 chunk 总数；textParts 拼出文本的 chunk 数；
@@ -388,6 +436,7 @@ export function attachToAgents(ctx, {
     agentsNotHer: state.agentsNotHer,
     guardHits: state.guardHits,
     devHits: state.devHits,
+    recallInjected: state.recallInjected,
     // 平铺给 dispose.info，另外给一份 streamDebug 供 /bridge 白名单整块取。
     streamsWrapped: state.streamsWrapped,
     streamsSkipped: state.streamsSkipped,
@@ -662,6 +711,32 @@ export function attachToAgents(ctx, {
     if (appendChat('heard', 'owner', body)) entry.heard = body
   }
 
+  /**
+   * 按他刚说的话检索她的记忆，折成这一次的 `[此刻想起]` 块。
+   * 只读、只动这一次请求的 options：库没就绪 / 没 query / 检索抛错 / 没结果 → 原样返回。
+   * 不写事件、不落库、不进对话；注入次数只记 state.recallInjected。
+   */
+  function injectRecall(baseOptions, query) {
+    if (!query || !store || !state.storeReady) return baseOptions
+    if (typeof searchMemory !== 'function') return baseOptions
+    let found = null
+    try {
+      found = searchMemory(store, { query, k: RECALL_K, budget: RECALL_MAX_CHARS })
+    } catch {
+      // 检索失败：不注入、不报错、不影响流。
+      return baseOptions
+    }
+    let block = ''
+    try {
+      block = recallBlockFrom(found?.items)
+    } catch {
+      return baseOptions
+    }
+    if (!block) return baseOptions
+    state.recallInjected++
+    return withSystemLine(baseOptions, block)
+  }
+
   /**
    * 包住宿主拿到的流，把文本增量攒成一句，流结束（finally）时写一条 utterance。
    * - 只有 AsyncIterable 才包；其它返回值原样交回，不改变 next() 的语义；
@@ -769,10 +844,12 @@ export function attachToAgents(ctx, {
       const userText = lastUserText(options)
       // 聊天落库：只有 her 才记。会话 key 优先取 options；宿主没给就退回第一条
       // 挂上的 agent 的 sessionId/cwd。
+      let heardBody = ''
       if (her) {
         sessionKey = sessionKeyOf(options) || agentSessionKey
         // 往前找最多 4 条 user 消息：最后一条常常是宿主注入块，他的话在它前面。
-        recordHeard(recentUserText(options), sessionKey)
+        heardBody = recentUserText(options)
+        recordHeard(heardBody, sessionKey)
       }
       if (typeof scanGuard === 'function') {
         let verdict = null
@@ -806,6 +883,10 @@ export function attachToAgents(ctx, {
           nextOptions = withSystemLine(nextOptions, DEV_PROMPT)
         }
       }
+
+      // 此刻想起：排在 guard、dev 之后（先规矩，再身份，最后是记忆）。
+      // 检索用的是上面清洗过的他那句话；失败/没结果都不动 system。
+      if (her) nextOptions = injectRecall(nextOptions, heardBody)
     } catch (err) {
       log(`提示词桥：llm/stream 观察失败（${errText(err)}）`)
     }

package/lib/console.js

@@ -1097,6 +1097,8 @@ function bridgeRoute(deps) {
     agentsNotHer: pick('agentsNotHer'),
     guardHits: pick('guardHits'),
     devHits: pick('devHits'),
+    // 「此刻想起」注入过几次；只给次数，不给检索内容。
+    recallInjected: pick('recallInjected'),
     stream: pick('stream'),
     // 聊天落库诊断：只给次数/形状，不给正文。
     // { streamsWrapped, chunksSeen, textParts, utterancesWritten, lastChunkShape }

package/lib/nightly.js

@@ -7,7 +7,7 @@
 // - 任何一步抛错都只记进 `steps.x.error`，后面的照跑；跑完（非 dryRun）照常记"今天整理过"。
 // - 状态记在旧库同一处：index.db 的 modes 表，`nightly.last`（毫秒）和 `nightly.<YYYY-MM-DD>`（'1'）。
 import { attributePending } from './reflect.js'
-import { createMind } from './split.js'
+import { createMind, userDomOf } from './split.js'
 import { syncQuestions } from './questions.js'
 import { dream } from './dream.js'
 import { verifyDreams } from './verify.js'
@@ -147,9 +147,13 @@ export function createNightly({ store, log = () => {}, config = {}, model = null
         steps.mind = { ok: true, dryRun: true, folded: rows.length, ...m.describe() }
       } else {
         const m = mind && typeof mind.fold === 'function' ? mind : createMind({ store, log, config: cfg })
+        // 归因表里可能已经有几十条历史：按 seq 取"到这一条为止"的最近 20 条，算出 userDom 再传进去。
+        // 不指望缓存里的 recentLabels（老缓存没有），否则升级后要等 20 条新归因才判得出主导度。
+        const history = [...(store.attribAll?.() || [])].sort((a, b) => Number(a.seq) - Number(b.seq))
         let folded = 0
         for (const row of rows) {
-          m.fold(row, { now: at })
+          const upto = history.filter((r) => Number(r.seq) <= Number(row.seq))
+          m.fold(row, { now: at, userDom: userDomOf(upto) })
           folded += 1
         }
         steps.mind = { ok: true, folded, ...m.describe() }

package/lib/split.js

@@ -1,7 +1,8 @@
 // 分流（M2）：开局一条线；够了才分；分完才谈谁主导；主导会变，变要带证据。
 // 状态形状沿用旧实现的 modes.state：
 //   {version,w:{d,i},n,counts:{d,i},dominance,split:{at,ev,n,share,tension[]},order,shifts[],
-//    userDom:{d,i},lastDivergenceN,mimicryRisk,lastIds[],updatedAt}
+//    userDom:number|null,recentLabels[],lastDivergenceN,mimicryRisk,lastIds[],updatedAt}
+// userDom 是"最近 N 条归因里 d 占已判归因的比例"，没得判时是 null（不是 0）。
 // 这是可重建的小状态，不是历史：丢了可以从事件重放。
 import { clip } from './util.js'
 
@@ -15,7 +16,8 @@ export const ZERO_STATE = () => ({
   split: null,
   order: 'E=R',
   shifts: [],
-  userDom: { d: 0, i: 0 },
+  userDom: null,
+  recentLabels: [],
   lastDivergenceN: null,
   mimicryRisk: false,
   lastIds: [],
@@ -33,6 +35,8 @@ export const DEFAULT_MIND = {
   shiftCooldownDays: 30,
   shiftRefs: 2,
   mimicryN: 20,
+  // 用户主导度离 0.5 小于这个值，才算"看不出他偏哪边"——模仿风险的前提。
+  mimicryBand: 0.15,
 }
 
 const clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v))
@@ -50,6 +54,24 @@ export function orderOf(band) {
   return 'E=R'
 }
 
+/**
+ * 用户主导度：最近 n 条归因里 d 占已判归因（d + i）的比例。
+ * - 窗口按"最近 n 条归因"取，null（纯描述）占窗口位置但不进分母；
+ * - 窗口里一条 d/i 都没有 → null（还没得判，不是 0）。
+ * @param {Array<{label?:string}|string>} rows 归因行（或裸 label）
+ * @param {{n?:number}} [opts]
+ * @returns {number|null} 0–1
+ */
+export function userDomOf(rows = [], { n = DEFAULT_MIND.mimicryN } = {}) {
+  const limit = Math.max(1, Number(n) || DEFAULT_MIND.mimicryN)
+  const window = (Array.isArray(rows) ? rows : [])
+    .map((r) => (typeof r === 'string' ? r : r?.label))
+    .slice(-limit)
+  const judged = window.filter((l) => l === 'd' || l === 'i')
+  if (!judged.length) return null
+  return round(judged.filter((l) => l === 'd').length / judged.length, 3)
+}
+
 /** 口吻：只给说法，不给数字。 */
 export function voiceLines(state) {
   const lines = []
@@ -75,7 +97,19 @@ export function createMind({ store, log = () => {}, config = {}, startDominance
       const raw = store?.modeGet?.(KEY)
       if (raw) {
         const j = JSON.parse(raw)
-        if (j && Number(j.version) === 1) state = { ...ZERO_STATE(), ...j, w: { ...j.w }, counts: { ...j.counts }, userDom: { ...j.userDom } }
+        if (j && Number(j.version) === 1) {
+          state = {
+            ...ZERO_STATE(),
+            ...j,
+            w: { ...j.w },
+            counts: { ...j.counts },
+            // 老缓存里 userDom 是没喂过数据的 {d,i}：不认，归为 null，等下一次 fold 重算。
+            userDom: typeof j.userDom === 'number' && Number.isFinite(j.userDom) ? round(clamp(j.userDom, 0, 1), 3) : null,
+            recentLabels: Array.isArray(j.recentLabels)
+              ? j.recentLabels.map(String).filter((l) => l === 'd' || l === 'i' || l === 'null').slice(-cfg.mimicryN)
+              : [],
+          }
+        }
       }
     } catch (e) {
       log?.('读分流缓存失败，从头来：', e?.message || e)
@@ -91,9 +125,10 @@ export function createMind({ store, log = () => {}, config = {}, startDominance
 
   /**
    * 折一条归因。row: {seq, day, label:'d'|'i'|'null', conf, why, by, model, at, id?, text?}
+   * opts.userDom：调用方已经算好的"最近 N 条归因的 d 占比"（number|null）；不给就用内部窗口。
    * 返回 {changed, split?:{...}, bandChange?:{from,to}}。
    */
-  function fold(row = {}, { now = Date.now(), refs = [] } = {}) {
+  function fold(row = {}, { now = Date.now(), refs = [], userDom: givenUserDom } = {}) {
     const label = row.label === 'd' || row.label === 'i' ? row.label : null
     const before = { band: bandOf(state.dominance), order: state.order }
     state.n += 1
@@ -112,6 +147,17 @@ export function createMind({ store, log = () => {}, config = {}, startDominance
       state.lastIds = state.lastIds.slice(-4)
     }
 
+    // 用户主导度：最近 N 条归因里 d 的占比。null 归因占窗口位置，但不进分母。
+    // 老缓存没有 recentLabels，就从这一条开始重新攒——宁可先判"看不出来"，也不要拿全局比例冒充。
+    if (!Array.isArray(state.recentLabels)) state.recentLabels = []
+    state.recentLabels.push(label || 'null')
+    state.recentLabels = state.recentLabels.slice(-cfg.mimicryN)
+    state.userDom = givenUserDom === undefined
+      ? userDomOf(state.recentLabels, { n: cfg.mimicryN })
+      : (givenUserDom == null || !Number.isFinite(Number(givenUserDom))
+          ? null
+          : round(clamp(Number(givenUserDom), 0, 1), 3))
+
     // 分流：四条都满足才写，写一次就不回头。
     let splitNow = null
     if (!state.split && state.n >= cfg.splitN && state.counts.d >= cfg.sideMin && state.counts.i >= cfg.sideMin) {
@@ -141,9 +187,12 @@ export function createMind({ store, log = () => {}, config = {}, startDominance
     }
     state.order = orderOf(band)
 
-    // 模仿风险：连续很多条归因都没有"分歧"证据。
+    // 模仿风险：只有"连续很多条归因都没有分歧证据"、且"看不出他偏哪边"（userDom 在 0.5 附近）才亮。
+    // 没有 userDom（还没得判）一律不亮：不拿 null 当 0，否则 i 多的鱼会在第 20 条后恒为 true。
     if (String(row.why || '').includes('divergence')) state.lastDivergenceN = state.n
-    state.mimicryRisk = state.n - (state.lastDivergenceN ?? 0) >= cfg.mimicryN
+    const noDivergence = state.n - (state.lastDivergenceN ?? 0) >= cfg.mimicryN
+    const nearHalf = state.userDom != null && Math.abs(state.userDom - 0.5) < cfg.mimicryBand
+    state.mimicryRisk = noDivergence && nearHalf
 
     save(now)
     return { changed: true, split: splitNow, bandChange }
@@ -170,6 +219,7 @@ export function createMind({ store, log = () => {}, config = {}, startDominance
       splitShare: state.split?.share ?? null,
       tension: state.split?.tension ?? [],
       shifts: state.shifts.length,
+      userDom: state.userDom,
       mimicryRisk: state.mimicryRisk,
       promptLines: voiceLines(state),
       updatedAt: state.updatedAt,

package/package.json

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