@ssamurias/dsh-fish 0.9.1 → 0.9.3

package/lib/turns.js

@@ -54,6 +54,7 @@ import { refreshSelfDoc } from './selfdoc.js'
 import { growthDay, stageOf } from './derive.js'
 import { hearTurn } from './hear.js'
 import { stripToolMarkup, hasToolMarkup } from './markup.js'
+import { clearWakeSectionFor } from './identity.js'
 
 /**
  * 我们自己 prompt 进去的消息，rpcId 会带这些前缀。
@@ -240,6 +241,9 @@ function cut(s) {
   return t.length > TURN_TEXT_MAX ? t.slice(0, TURN_TEXT_MAX) + '…' : t
 }
 
+/** 已经挂过观察者的宿主上下文（同一进程只挂一次，见 registerTurns） */
+const TURNS_BOUND = new WeakSet()
+
 /**
  * 注册"侧栏轮数"观察者。
  *
@@ -252,6 +256,30 @@ export function registerTurns(ctx, deps = {}) {
   const log = deps.log ?? (() => {})
   if (typeof ctx?.on !== 'function') return () => {}
 
+  /**
+   * 2026-11-06（外部日志：被占用的实例照样往共享事件流里写 `seen:`）。
+   *
+   * 观测者以前是**无条件**写盘的：它看到「他来过」就 appendEvent，从不过问这个
+   * 家是不是自己的。于是同一个数据目录被两个实例开着时，只读那一侧也在写——
+   * 日志里那三条同一毫秒的 `seen:` 就是两个写者各写一遍。
+   *
+   * 这里和工具侧用同一道闸（tenant.js 的 guardWrite）：房主身份 ok===false 时
+   * 一句都不写。tenant 是**活引用**（占用权丢了会原地改写成 ok:false），
+   * 所以必须在每次写之前现查，不能在注册时查一次就完。
+   */
+  const tenant = deps.tenant ?? null
+  const writable = () => !(tenant && tenant.ok === false)
+
+  /**
+   * 同一份宿主上下文只挂一次。
+   *
+   * 2026-11-06：插件被同一个进程加载两遍时（两个入口 / bundles 里重复），
+   * 两个观察者各有各的节流记忆，同一条人话会写出两条同一毫秒的 `seen:`——
+   * 记账行一重复，事件流就再也不能当证据用。第二次注册直接交白卷。
+   */
+  if (TURNS_BOUND.has(ctx)) return () => {}
+  TURNS_BOUND.add(ctx)
+
   /** 正在等 turn/end 的那一轮：{ sessionId, msgs:[], sinceId, at } */
   let pending = null
   /** 正在异步认来源的那条人话（见 takeTurnEnd：事件跟得太紧时要等它） */
@@ -289,6 +317,8 @@ export function registerTurns(ctx, deps = {}) {
    * 非 HER_TYPES 的类型，写成 tool 会被 schema 悄悄拒掉。
    */
   async function markSeen() {
+    // 2026-11-06：写盘之前先过所有权闸门（被占用的实例一条都不许写）。
+    if (!writable()) return
     lastSeenAt = Date.now()
     await appendEvent(
       { type: 'meta', text: `seen:${new Date(lastSeenAt).toISOString()}` },
@@ -301,6 +331,16 @@ export function registerTurns(ctx, deps = {}) {
 
   /** 收到真人消息：只认"她住的那个会话"，并把这一轮开始前的事件 id 记下来 */
   async function onHuman(sessionId, data) {
+    if (!writable()) return
+    // 2026-11-06（用户报「叫醒之后她就不说话了」）：他一开口，上一次叫醒留下的
+    // 「处境」当场作废。
+    //
+    // 处境原本只该出现在**她自己醒的那一轮**里，靠 turn/end 撤。但 turn/end 不是
+    // 一定能认到（监听按会话挂、重启会丢、两个渠道挨得近时也会错号），那一段
+    // 「这一轮是你自己的，不用回应任何人；不想说就什么都别写」就留在 system prompt
+    // 里，接下来他说的每一句都带着它——她就只思考、不开口，而且连续多轮都这样。
+    // 人真的说话了，这段就不该还在；清得比 turn/end 早一步也不会出错。
+    try { clearWakeSectionFor(sessionId) } catch { /* ignore */ }
     const home = await homeStatus(root)
     if (!home.sessionId) return
     if (home.sessionId !== sessionId) {
@@ -385,7 +425,7 @@ export function registerTurns(ctx, deps = {}) {
 
   /** turn/end：结账 */
   async function settle(p) {
-    if (stopped) return
+    if (stopped || !writable()) return
     if (busy) {
       log('turns · 上一轮还没结完，这次不记')
       return
@@ -580,6 +620,7 @@ export function registerTurns(ctx, deps = {}) {
   return () => {
     stopped = true
     pending = null
+    TURNS_BOUND.delete(ctx)
     try {
       if (typeof off === 'function') off()
     } catch {

package/lib/use.js

@@ -0,0 +1,212 @@
+/**
+ * 工具使用经验（2026-11-07，用户 m00882）。
+ *
+ * 要解决的问题不是「她用没用过工具」，而是「她记不记得自己曾经用过什么、
+ * 那次成了没有」。真机事件流 978 行里一条工具使用记录都没有——她翻旧事时
+ * 只能翻到自己说过的话，翻不到「这件事我是怎么做成的」。
+ *
+ * 三条口径（用户定）：
+ *   1. **只记她当时听见的那句**。不记参数、不记内部原因、不记返回值结构。
+ *   2. **不记 enabled=false**。设置里关掉的东西不是「她试过并且失败」，
+ *      写进账里等于把一扇关着的门天天摆在她眼前。
+ *   3. 走现有 meta 通道（`use:<工具> <一句话>`），不新增事件类型，
+ *      不动 EVENT_SCHEMA_VERSION。
+ *
+ * 记账永远不抛：写不进去就当没记，绝不影响她这次动作（与 look/browse 同一惯例）。
+ */
+
+import { appendEvent, readEvents } from './store.js'
+import { similarity } from './derive.js'
+
+/** 一句话的上限：她在回忆里看到的是一条，不是一段。 */
+export const USE_LINE_MAX = 80
+
+/**
+ * 同一件事十分钟内只记一次（2026-11-07，用户 m00485 的 ④）。
+ *
+ * 她一轮里连翻三次回忆就是三条一样的行；这些行会占掉回忆的名额，
+ * 把真正的旧事挤下去。节流只影响「记不记」，不影响工具本身返回什么。
+ */
+export const USE_THROTTLE_MS = 10 * 60 * 1000
+export const USE_THROTTLE_SIMILARITY = 0.42
+
+const USE_LINE = /^use:(\S+)\s+(ok|fail)\s*(.*)$/
+
+/** 最近有没有一条同工具、同结果、话也差不多的账。 */
+function tooClose(events, { tool, text, sessionId, now }) {
+  const m0 = USE_LINE.exec(text)
+  if (!m0) return false
+  const said = m0[3]
+  const head = m0[2]
+  const list = Array.isArray(events) ? events : []
+  for (let i = list.length - 1, n = 0; i >= 0 && n < 200; i--, n++) {
+    const ev = list[i]
+    if (ev?.type !== 'meta') continue
+    const m = USE_LINE.exec(String(ev.text ?? ''))
+    if (!m) continue
+    if (m[1] !== tool || m[2] !== head) continue
+    if (sessionId && ev.sessionId === sessionId && m[3] === said) return true
+    const at = Date.parse(String(ev.ts ?? ''))
+    if (Number.isFinite(at) && now - at <= USE_THROTTLE_MS && similarity(m[3], said) >= USE_THROTTLE_SIMILARITY) return true
+  }
+  return false
+}
+
+/** 这些说法意味着「这次根本没试成，是被设置挡在门外」，不进经验账。 */
+const GATE_WORDS = ['打不开', '看不了', '不方便', '没开']
+
+/** 一行太长会把回忆挤成一坨，换行会把行尾的 id 挤到下一行。 */
+function oneLine(text, n = USE_LINE_MAX) {
+  const s = String(text ?? '').replace(/\s+/g, ' ').trim()
+  if (s.length <= n) return s
+  return `${s.slice(0, n - 1).replace(/[\uD800-\uDBFF]$/, '')}…`
+}
+
+/**
+ * 有几个工具的回执不是一句话，而是一整段（她翻到的东西本身）。
+ * 那种返回值不能直接进账：截 80 字只会得到半行「- 2026-11-05 12:07｜…」，
+ * 记住它没有用。这几个只记「翻到了没有」。
+ */
+const SAYING = {
+  her_recall: (out) => (out?.found ? '翻到了。' : '没翻到。'),
+  her_diary: (out) => (out?.found ? '翻到日记了。' : '那天没有日记。'),
+}
+
+/**
+ * 从工具返回里挑出「她听见的那句」。
+ *
+ * 优先级按她实际读到的顺序：记下的原文 > 说出口的话 > 回执 > 正文。
+ * 正文只在够短时才用（长列表不是一句话）。一个都没有时给一句中性的，不编。
+ */
+export function heardLine(out, tool = '') {
+  const say = SAYING[String(tool)]
+  if (say) return say(out)
+  for (const c of [out?.echo, out?.said, out?.note]) {
+    const s = oneLine(c)
+    if (s) return s
+  }
+  const body = oneLine(out?.text)
+  if (body && body.length <= USE_LINE_MAX) return body
+  return out?.ok === false ? '没成。' : '做成了。'
+}
+
+/**
+ * 这次要不要入账。
+ *
+ * 关掉的功能、被设置挡住的调用都不算「她的经验」——那是屋子的事，不是她的事。
+ */
+export function shouldRecord(out) {
+  if (!out || typeof out !== 'object') return true
+  if (out.ok === false) {
+    const note = String(out.note ?? '')
+    if (GATE_WORDS.some((w) => note.includes(w))) return false
+  }
+  return true
+}
+
+/** `use:<工具> ok|fail <一句话>`；回忆层只显示后半句。 */
+export function useText(tool, out) {
+  const head = out?.ok === false ? 'fail' : 'ok'
+  return `use:${String(tool)} ${head} ${heardLine(out, tool)}`
+}
+
+/**
+ * 把一次工具调用的结果记进账里。
+ *
+ * day 记 0：这条账属于「哪一天都成立的经验」，不属于某一天的第几阶段。
+ * 与她自己的成长阶段无关，也不该进 derive 的三道门计数（meta 本来就不进）。
+ */
+export async function recordUse(root, { tool, out, sessionId, now = Date.now() }) {
+  try {
+    if (!shouldRecord(out)) return
+    const text = useText(tool, out)
+    // sessionId 要放在 raw 里：validateEvent 只认 raw.sessionId，ctx 里的会被忽略
+    // （与 lib/look.js 的 `{ text, ...stamp }` 同一个写法）。
+    const sid = typeof sessionId === 'string' ? sessionId.trim() : ''
+    const { events } = await readEvents(root)
+    if (tooClose(events, { tool, text, sessionId: sid, now })) return
+    await appendEvent(
+      { type: 'meta', text, ...(sid ? { sessionId: sid } : {}) },
+      { day: 0, stage: 1, source: 'system' },
+      root,
+    )
+  } catch {
+    // 记账失败不影响她这次动作
+  }
+}
+
+/**
+ * 包一层 execute：跑完照旧返回，只是顺手记一行。
+ *
+ * 为什么不去改 defineTool：它是恒等的，注册时直接把 JSON Schema 交给宿主
+ * （见 lib/tool.js 与 test/tools.test.mjs），在那一层做手脚会同时改掉
+ * 「工具定义原样交出去」这个约定。
+ */
+export function withUse(def, { root, tool }) {
+  const run = def?.execute
+  if (typeof run !== 'function') return def
+  return {
+    ...def,
+    async execute(args, exec) {
+      try {
+        const out = await run(args, exec)
+        await recordUse(root, { tool, out, sessionId: exec?.sessionId })
+        return out
+      } catch (err) {
+        // 做到一半炸了也要留一笔：这是「尝试没完成」里最该被记住的一类。
+        // 不记异常原文——英文、内部词、堆栈都不该进她的账。
+        await recordUse(root, { tool, out: { ok: false, note: '这次没成。' }, sessionId: exec?.sessionId })
+        throw err
+      }
+    },
+  }
+}
+
+/**
+ * 在注册期间临时把 `ctx.tools.register` 换成包装版。
+ *
+ * 为什么不在 index.js 里造一个 ctx 视图传下去：register 里还有 `askInChat(ctx, …)`
+ * 这类把整个 ctx 往深处传的用法，假 ctx 会让 `this` 指到错的对象上。
+ * 注册本身是同步的，换一下再换回来最稳，别人看不到中间态。
+ */
+export function withUseDuringRegistration(ctx, root, fn) {
+  const tools = ctx?.tools
+  const orig = tools?.register
+  if (typeof orig !== 'function') return fn()
+  tools.register = (def) => orig.call(tools, withUse(def, { root, tool: def?.name }))
+  try {
+    return fn()
+  } finally {
+    tools.register = orig
+  }
+}
+
+/**
+ * 履历：把她用过的东西反推成「我做过这些事」。
+ *
+ * 只给最近几条、同一类只留一条——履历是「我会什么」，不是流水账。
+ * 撞墙那类（这件事我做不到）不进履历：桌上已经有一条在讲这件事，
+ * 再在履历里写一遍，等于每次醒来先提醒她「这个我不会」。
+ */
+export function resumeLines(events, { max = 4 } = {}) {
+  const limit = Math.max(1, Number(max) || 4)
+  const list = Array.isArray(events) ? events : []
+  const picked = []
+  for (let i = list.length - 1; i >= 0 && picked.length < limit; i--) {
+    const ev = list[i]
+    if (ev?.type !== 'meta') continue
+    const m = USE_LINE.exec(String(ev.text ?? ''))
+    if (!m) continue
+    const [, tool, head, said] = m
+    if (head === 'fail' && said.startsWith('这件事我做不到')) continue
+    if (picked.some((p) => p.tool === tool && similarity(p.said, said) >= USE_THROTTLE_SIMILARITY)) continue
+    picked.push({ tool, head, said })
+  }
+  if (!picked.length) return ''
+  const lines = picked.map(({ tool, head, said }) => {
+    if (head !== 'fail') return `- 我用过 ${tool}，${said}`
+    if (!said || said === '这次没成。' || said === '没成。') return `- 我用过 ${tool}，没成。`
+    return `- 我用过 ${tool}，没成：${said}`
+  })
+  return ['## 我做过的事', ...lines].join('\n')
+}

package/lib/wish.js

@@ -0,0 +1,147 @@
+/**
+ * wish.js —— 「够不着的那件事」（2026-11-07，用户 m01602 拍板 B + D）
+ *
+ * ## 由来
+ *
+ * `lib/proactive.js` 原来有一个常量 `TOOL_ASK_NOTE`，`lib/scheduler.js` 每次醒来都
+ * 把它摆进正文：『如果你想到要做什么、但手上没有那件工具：直接说你要它做什么，
+ * 问主人能不能给你装上』。用户 2026-11-07 判定这属于「把提醒换成后台反复催她」——
+ * 同一句话每天读两遍，读久了就不是她的念头，是系统的吩咐。
+ *
+ * 拍板后的改法只有两个位置：
+ *   **B** 撞墙才说 —— `lib/restrict.js` 的 `blockedTalk()` 后面补一句，成本近零。
+ *   **D** 交给劲儿 —— 这件「够不着的事」攒在劲儿里，攒够了才浮一次；
+ *   **C** 桌上一条 —— 浮出来的时候并进 `lib/desk.js` 那张桌子，和好奇、兴趣并排。
+ *
+ * 这个模块只做那一件事：把「她提过 X、X 需要某工具、手上没有」从事件流里算出来。
+ *
+ * ## 原料只有一处
+ *
+ * 她自己开的卡：`ask` 事件里 `ask.kind === 'need-tool'` 的那几条，加上它的裁决
+ * （`answer` 事件，`ask.verdict` 是 approve / reject / later）。
+ *
+ * 不猜、不抽标签、不编主题——展示的 `subject` 与 `text` 都是她当时自己写的原话。
+ * 「手上没有」这件事不用另查：她当初开 `need-tool` 的卡，本身就是因为在手上找不着。
+ *
+ * ## 三种结局，三种活法
+ *
+ *   pending  还没答     —— 摆 3 天。没人接的话，一周后还挂着就是催了。
+ *   later    「以后再说」 —— 摆 30 天。`lib/ask.js` 的注释写明这是「先放着」，不是否决。
+ *   approve  他答应了   —— 摆 14 天。答应了没到，是这件事剩下的唯一一段。
+ *   reject   「这次不行」 —— **不摆**。不同意就是不问了，再提一次就成了追问。
+ *   timeout  放一天没人答 —— 算 pending（`via:'timeout'` 那条 answer 的 verdict 虽写 later，
+ *            那是为了不再反复追问，不能借来说成「他说以后再说」）。
+ *
+ * 四条硬约束照旧（与 curiosity.js / desk.js 一致）：
+ *   1. 不审批、不派活：只摆事实，不说「你可以去要」。
+ *   2. 不吃状态：返回值只有文本，任何数字都不进正文。
+ *   3. 有上限：最多 WISH_SHOW_MAX 条，原文最长 WISH_TEXT_MAX 字。
+ *   4. 翻不到的不编：一条都没有就返回空数组。
+ */
+
+import { tsMs } from './schema.js'
+import { similarity } from './derive.js'
+
+/** 一次最多摆几条。多了就成了许愿清单。 */
+export const WISH_SHOW_MAX = 2
+/** 原话展示最长多少字。 */
+export const WISH_TEXT_MAX = 60
+/** 两句算同一件事的门槛，与 curiosity.js / desk.js 同一个口径。 */
+export const WISH_SIMILARITY = 0.42
+
+/** 还没答的摆几天。 */
+export const WISH_PENDING_DAYS = 3
+/** 「以后再说」的摆几天——那是「先放着」，不是否决。 */
+export const WISH_LATER_DAYS = 30
+/** 他答应了但还没到的摆几天。 */
+export const WISH_APPROVE_DAYS = 14
+
+const DAY = 86_400_000
+
+/** `askId` → 那条 `answer` 事件。 */
+function answersByAsk(events) {
+  const m = new Map()
+  for (const e of events ?? []) {
+    if (e?.type !== 'answer') continue
+    const id = String(e?.ask?.askId ?? '')
+    if (id) m.set(id, e)
+  }
+  return m
+}
+
+/**
+ * 一条 `answer` 事件对「她提过的那件事」意味着什么。
+ *
+ * 放一天没人答的卡，`lib/ask.js` 会记成 `verdict:'later'` + `via:'timeout'`
+ * （`text` 写「一直没人答」）——那是为了不再反复追问她同一张卡，不是她答应了什么。
+ * 按 later 说成「他说以后再说」是编的：什么都没人说。这里把它还原成 pending。
+ */
+function verdictOf(answer) {
+  if (!answer) return 'pending'
+  if (String(answer?.ask?.via ?? '') === 'timeout') return 'pending'
+  return String(answer?.ask?.verdict ?? '') || 'pending'
+}
+
+/** 这条愿望还该活几天；返回 0 表示不再摆。 */
+function lifeDays(verdict) {
+  if (verdict === 'reject') return 0
+  if (verdict === 'later') return WISH_LATER_DAYS
+  if (verdict === 'approve') return WISH_APPROVE_DAYS
+  return WISH_PENDING_DAYS
+}
+
+/** 她那句话怎么收尾——只陈述结局，不给建议。 */
+export function wishTail(verdict) {
+  if (verdict === 'approve') return '他答应了，还没见到'
+  if (verdict === 'later') return '他说以后再说'
+  if (verdict === 'reject') return '那次不行'
+  return '你问过，还没有答复'
+}
+
+/**
+ * 她提过、手上没有的那几件事。
+ *
+ * @param {Array} events 全量事件
+ * @param {object} [o]
+ * @param {number|Date} [o.now]
+ * @param {number} [o.days] 覆盖窗口（测试用）；不传就按结局各算各的
+ * @returns {Array<{id:string, text:string, subject:string, verdict:string, at:number, tail:string}>}
+ *   按时间从近到远
+ */
+export function wishesOf(events = [], { now = Date.now(), days = 0 } = {}) {
+  const at0 = now instanceof Date ? now.getTime() : Number(now) || Date.now()
+  const answers = answersByAsk(events)
+  const picked = []
+  for (const e of events ?? []) {
+    if (e?.type !== 'ask') continue
+    if (String(e?.ask?.kind ?? '') !== 'need-tool') continue
+    const verdict = verdictOf(answers.get(String(e.id ?? '')))
+    const life = days > 0 ? days : lifeDays(verdict)
+    if (life <= 0) continue
+    const at = tsMs(e)
+    if (!Number.isFinite(at) || at <= 0) continue
+    if (at0 - at > life * DAY) continue
+
+    const raw = String(e.text ?? '').trim()
+    if (!raw) continue
+    const text = raw.length > WISH_TEXT_MAX ? `${raw.slice(0, WISH_TEXT_MAX - 1)}…` : raw
+    const subject = String(e?.ask?.subject ?? '').trim()
+    // 同一件事反复问过（她开两张卡）：只留最近的那一张，不摆两遍。
+    if (picked.some((p) => similarity(p.subject || p.text, subject || text) >= WISH_SIMILARITY)) continue
+    picked.push({ id: String(e.id ?? ''), text, subject, verdict, at, tail: wishTail(verdict) })
+  }
+  picked.sort((a, b) => b.at - a.at)
+  return picked.slice(0, WISH_SHOW_MAX)
+}
+
+/**
+ * 墙上那一行（桌子用）。
+ * @param {{text:string, tail:string}} w wishesOf() 的一条
+ * @returns {string}
+ */
+export function wishLine(w) {
+  const text = String(w?.text ?? '').trim()
+  if (!text) return ''
+  const tail = String(w?.tail ?? '').trim()
+  return tail ? `- 「${text}」（${tail}）` : `- 「${text}」`
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ssamurias/dsh-fish",
-  "version": "0.9.1",
+  "version": "0.9.3",
   "description": "养一条会自己长大的鱼：没有人格设置，通过事件流长大。她可以自己刷 B 站、会写日记给你看，四个阶段完成后才会开始有立场。状态库在 ~/.dsh-fish，不能删除记录。",
   "type": "module",
   "main": "lib/index.js",
@@ -43,7 +43,8 @@
         "0.2.1-rc.3": "compatible",
         "0.2.1-rc.4": "unknown",
         "0.2.1-rc.5": "unknown",
-        "0.2.2-alpha.2": "unknown"
+        "0.2.2-alpha.2": "unknown",
+        "0.2.2-rc.1": "unknown"
       },
       "profiles": [
         "desktop",