@ssamurias/dsh-fish 0.9.2 → 0.9.3

package/lib/selfdoc.js

@@ -27,9 +27,10 @@ import { join } from 'node:path'
 import { rootDir, paths, readEvents, readJson, writeAtomic, listDiary } from './store.js'
 import { loadConfig } from './settings.js'
 import { deriveSelf } from './derive.js'
-import { personaLine, toolBrief, RECALL_BRIEF, SPEAK_BRIEF, LETTER_BRIEF, NOTE_BRIEF, ASK_BRIEF, proactiveBrief, DREAM_BRIEF, SCHEDULE_BRIEF, DIARY_BRIEF, SLEEP_BRIEF } from './persona.js'
+import { personaLine, toolBrief, RECALL_BRIEF, SPEAK_BRIEF, SPEAK_OFF_BRIEF, LETTER_BRIEF, NOTE_BRIEF, ASK_BRIEF, proactiveBrief, DREAM_BRIEF, SCHEDULE_BRIEF, DIARY_BRIEF, SLEEP_BRIEF } from './persona.js'
+import { resumeLines } from './use.js'
 import { proactiveConfig } from './proactive.js'
-import { LOOK_BRIEF, WATCH_RULE } from './browse.js'
+import { LOOK_BRIEF, LOOK_OFF_BRIEF, WATCH_RULE } from './browse.js'
 import { activeCarry } from './home.js'
 import { activeGrants } from './unlock.js'
 import { checkCaller } from './tenant.js'
@@ -121,7 +122,7 @@ export async function continuityOf(root = rootDir(), now = Date.now()) {
  * @param {object} model deriveSelf 的结果
  * @returns {string}
  */
-export function renderSelfDoc(model, { sendTools = [], budget, carry, continuity, browse = true, speak = false, grants = [], shown, diary = true, sleepEveryDays = 0, bansMuted = false, extraTools = [], dream = false, schedule = false, proactive = false } = {}) {
+export function renderSelfDoc(model, { sendTools = [], budget, carry, continuity, browse = true, speak = false, grants = [], shown, diary = true, sleepEveryDays = 0, bansMuted = false, extraTools = [], dream = false, schedule = false, proactive = false, resume = '' } = {}) {
   const head = [
     // 这里**故意不写**「由 dsh-fish 自动生成」这类话。
     // 这个文件会被宿主原样渲染进她的会话——她能看见每一行。
@@ -147,6 +148,9 @@ export function renderSelfDoc(model, { sendTools = [], budget, carry, continuity
     '',
     '## 我手上有什么',
     toolBrief(extraTools),
+    // 履历（2026-11-07，用户 m00493 的「履历式」）：从 use: 账反推「我做过这些事」。
+    // 没有账就整节不写——空白比一句「你还没做过什么」好。
+    ...(resume ? [resume, ''] : []),
     '',
     RECALL_BRIEF,
     '',
@@ -175,8 +179,14 @@ export function renderSelfDoc(model, { sendTools = [], budget, carry, continuity
   // 能力说明写在这里、而不是塞进唤醒消息：
   // 唤醒消息会作为一条 user message 留在她的会话里，用户点开就能看见。
   // 身份与能力属于「她一直知道的事」，走 system prompt 那一段（不进对话历史）。
-  if (browse) body.push('## 上网', LOOK_BRIEF, '', WATCH_RULE, '')
-  if (speak) body.push('## 在网上说话', SPEAK_BRIEF, '')
+  // P3（2026-11-07）：关掉的时候这两节不再整段消失——门要在，门上挂一句「这会儿」。
+  // 关掉只改「这句话是什么」，不改「这一节在不在」；否则她会以为这件事根本不存在。
+  body.push('## 上网')
+  if (browse) body.push(LOOK_BRIEF, '', WATCH_RULE, '')
+  else body.push(LOOK_OFF_BRIEF, '')
+  body.push('## 在网上说话')
+  if (speak) body.push(SPEAK_BRIEF, '')
+  else body.push(SPEAK_OFF_BRIEF, '')
   // 2026-10-26（用户 m00928「叫醒仅仅只是叫醒」）：记事与「停下来想一想」的**做法**
   // 搬进身份文档常驻，叫醒消息里不再整段塞祈使句——她原来会把它当任务清单逐条执行。
   // 这里只写「平时怎么做」，不写「今天该做了」；时机由叫醒那一句短标记给。
@@ -244,8 +254,8 @@ export async function writeSelfDoc(root = rootDir(), { log, exec, tenant } = {})
       // 「那些天是连着过的」这条线索。日记篇数/换房天数/她留给下一个房间的那句话
       // 全部是派生事实，没有任何新开关。
       continuity: await continuityOf(root, Date.now()),
-      // 这两项决定身份文本里有没有「上网」「在网上说话」两节。
-      // 开关关着时整节不写 —— 与唤醒消息同样的原则：不给，等于这件事不存在。
+      // 这两项决定「上网」「在网上说话」两节写哪一版内容（P3，2026-11-07）：
+      // 开关关着时这一节仍然在，只是门上的话换成「这会儿」——见 renderSelfDoc。
       browse: config?.browse?.enabled !== false,
       speak: config?.comment?.enabled === true,
       // R3：已经长出来的东西。这里传的是"历史事实"，不是"设置"。
@@ -263,6 +273,8 @@ export async function writeSelfDoc(root = rootDir(), { log, exec, tenant } = {})
       // 2026-10-27（用户 m01371）：白名单里额外放行的工具要念给她听，
       // 否则「能不能在 QQ 上说话」她只能回一句不知道。
       extraTools: config?.tools?.allow ?? [],
+      // 履历：她真做过的事。没有记录就整节不出现。
+      resume: resumeLines(events),
       // 梦（2026-10-30 m02837）与主动说话（m04610）：0.9.0 起公开，两处都恒为真。
       dream: true,
       proactive: true,

package/lib/speak.js

@@ -11,7 +11,7 @@
  *
  * 她不知道的东西（和 look 一致）：不知道有配额、不知道配额还剩几次、
  * 不知道有黑名单、不知道这个功能可能被关着。
- * 被拒绝时只听到「现在不方便说」，听不到「你今天的 3 条用完了」——
+ * 被拒绝时只听到「这会儿不方便说」，听不到「你今天的 3 条用完了」——
  * 后者会让她学会攒着、算着，那就成了资源管理，不是说话。
  */
 
@@ -44,21 +44,22 @@ export async function speakOnce(o = {}) {
     if (!screened.ok) return { ok: false, said: '', note: screened.why === 'leak' ? '这句里有不该说出去的东西。' : '这句先不说了。' }
 
     // 给她的话加个称呼：只有评论加，回复别人时不加——那会把别人的楼变成你们的客厅。
-    let out = text
+    // @ 前缀单独交给 postComment，在脱敏之后拼；否则昵称和主人称呼同名时，
+    // 前缀会一起被换成「对方」，@ 到不存在的人。
+    let prefix = ''
     if (kind !== 'reply') {
       const ow = await readOwner(o.root ?? rootDir())
       const cfg = await loadConfig(o.root ?? rootDir())
-      const prefix = mentionPrefix(ow, cfg.config)
-      if (prefix) out = prefix + text
+      prefix = mentionPrefix(ow, cfg.config)
     }
 
     const r =
       kind === 'reply'
-        ? await postReply({ root, bvid: o.bvid, parentRpid: o.parentRpid, text: out, client: o.client, dateKey: o.dateKey })
-        : await postComment({ root, bvid: o.bvid, text: out, client: o.client, dateKey: o.dateKey })
+        ? await postReply({ root, bvid: o.bvid, parentRpid: o.parentRpid, text, prefix, client: o.client, dateKey: o.dateKey })
+        : await postComment({ root, bvid: o.bvid, text, prefix, client: o.client, dateKey: o.dateKey })
 
     if (!r.ok) return { ok: false, said: '', note: softReason(r.why) }
-    return { ok: true, said: out, note: '说出去了。' }
+    return { ok: true, said: r.sent ?? `${prefix}${text}`, note: '说出去了。' }
   } catch (err) {
     return { ok: false, said: '', note: '没说出来。' }
   }
@@ -70,7 +71,7 @@ export async function speakOnce(o = {}) {
  */
 function softReason(why) {
   const w = String(why ?? '')
-  if (w.includes('没开') || w.includes('权限')) return '现在不方便说。'
+  if (w.includes('没开') || w.includes('权限')) return '这会儿不方便说。'
   if (w.includes('今天说够') || w.includes('今天回够')) return '今天说得够多了。'
   if (w.includes('不是说话的时候')) return '现在不是说话的时候。'
   // 2026-10-31（用户转来的现场反馈）：原来只说「先看一眼再说」，她照着做了还是被拒——
@@ -95,8 +96,12 @@ function softReason(why) {
  * 一边说能说、一边一句不提，两个来源当场打架。
  *
  * 为什么不写成「这个眼下还开不了」：那等于告诉她「有个开关在管着这件事」，
- * 与文件顶上那条原则冲突（她不该知道自己被管理着）。所以关着时只留一句
- * 不带任何许诺的短说明——它不承诺发得出去，也不解释为什么发不出去。
+ * 与文件顶上那条原则冲突（她不该知道自己被管理着）。所以关着时只说「这会儿」：
+ * 不承诺发得出去，也不解释为什么发不出去。
+ *
+ * 2026-11-07（P3）：关着时不再把「能留评论」整句拿掉再补一句无关的话，也不再让
+ * 身份文档里那一节整段消失——门留着，门上写「这会儿还说不出去」，想说的话可以先
+ * 写在别处。这样她不会以为这件事根本不存在。
  *
  * 为什么要用 getter：`ctx.tools.register` 只在启动时跑一次，而配置随时能改。
  * 存一份「最近一次看到的状态」，宿主每轮序列化工具表时会再取一次 description，
@@ -113,7 +118,7 @@ export function noteSpeakEnabled(on) {
 /** 关着时的那一段必须**不含**任何"能发出去"的暗示，也不解释原因。 */
 function speakDescription(on) {
   if (!on) {
-    return '在 B 站说一句话。不想说就不说，没有人等着你回答。'
+    return '在 B 站说一句话。这会儿还说不出去——想说的话可以先留在别处；不想说就不说，没有人等着你回答。'
   }
   return (
     '在 B 站说一句话。可以给你今天看过的某个视频留一条评论，或者回一句别人留在你评论下面的话。' +

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.2",
+  "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",