@ssamurias/dsh-fish 0.9.1 → 0.9.3

package/lib/anchor.js

@@ -0,0 +1,57 @@
+/**
+ * anchor.js —— 把一件事挂回她当时那句话（2026-11-07，用户 m00493 的 ⑤）。
+ *
+ * 「用过 her_note，记下了：…」这句话本身没有来路。翻旧事时她看不出那次是为了
+ * 什么——是回一句话，还是记一件刚发生的事。而事件流里那笔账旁边的她那句话
+ * 就是答案：同一个 sessionId，就在调用之前几分钟。
+ *
+ * 只读事件流，不写、不改。找不到就返回空串，绝不编一句。
+ */
+
+import { HER_TYPES } from './schema.js'
+
+/** 往前找多久：一轮里她一句话说完就动手，超过十分钟多半是别的事了。 */
+export const ANCHOR_WINDOW_MS = 10 * 60 * 1000
+/** 锚点只用来认路，不是复述：一句问话的开头足够。 */
+export const ANCHOR_TEXT_MAX = 40
+
+const clip = (text, n) => (text.length > n ? `${text.slice(0, n - 1).replace(/[\uD800-\uDBFF]$/, '')}…` : text)
+
+function tsOf(ev) {
+  const n = Date.parse(String(ev?.ts ?? ''))
+  return Number.isFinite(n) ? n : 0
+}
+
+/**
+ * 她这次动手之前，最近说过的、属于她自己的一句话。
+ *
+ * @param {object[]} events 全量事件
+ * @param {string} sessionId 这次调用的会话；没有就不锚（宁可没有来路，也别挂错人）
+ * @param {number|string|Date} before 调用发生的时刻
+ * @param {{windowMs?:number, max?:number}} [o]
+ * @returns {string} 已截断的一句话；找不到是空串
+ */
+export function anchorOf(events, sessionId, before, o = {}) {
+  const sid = String(sessionId ?? '').trim()
+  if (!sid) return ''
+  const at = before instanceof Date
+    ? before.getTime()
+    : typeof before === 'number'
+      ? before
+      : Date.parse(String(before ?? ''))
+  if (!Number.isFinite(at)) return ''
+  const windowMs = Math.max(0, Number(o.windowMs ?? ANCHOR_WINDOW_MS))
+  const max = Math.max(1, Number(o.max ?? ANCHOR_TEXT_MAX))
+  const types = new Set(HER_TYPES)
+  let best = null
+  for (const ev of Array.isArray(events) ? events : []) {
+    if (!ev || String(ev.sessionId ?? '') !== sid) continue
+    if (!types.has(String(ev.type))) continue
+    const ts = tsOf(ev)
+    if (!ts || ts > at || at - ts > windowMs) continue
+    const text = String(ev.text ?? '').replace(/\s+/g, ' ').trim()
+    if (!text) continue
+    if (!best || ts > best.ts) best = { ts, text }
+  }
+  return best ? clip(best.text, max) : ''
+}

package/lib/ask.js

@@ -27,7 +27,9 @@
  */
 
 import { toJsonSchema } from './toolschema.js'
-import { rootDir, readEvents, appendEvent } from './store.js'
+import { appendFile } from 'node:fs/promises'
+
+import { rootDir, readEvents, appendEvent, paths } from './store.js'
 import { loadConfig, updateConfig, dateKey } from './settings.js'
 import { deriveSelf } from './derive.js'
 import { defineTool } from './tool.js'
@@ -43,13 +45,16 @@ export const ASK_KINDS = Object.freeze(['need-file', 'need-tool', 'time', 'rest'
 export const ASK_PER_DAY = 1
 export const ASK_PER_WEEK = 3
 
+/** kind=time 的时段，和 schema.js 存得下的一样。 */
+const HHMM = /^([01]\d|2[0-3]):[0-5]\d$/
+
 /** 超过这么久还没人答，记成 later（以后再说），不占着「待处理」。 */
 export const ASK_TTL_MS = 24 * 3600 * 1000
 
 /** 默认的两个选项。第一个是同意，第二个是不同意。 */
 const DEFAULT_OPTIONS = ['可以', '这次不行']
 
-const VIA_LABEL = { chat: '会话里答的', ui: '观测台答的', timeout: '一直没人答', tool: '工具里答的' }
+const VIA_LABEL = { chat: '会话里答的', ui: '观测台答的', timeout: '一直没人答', tool: '工具里答的', relay: '别的插件转回来的' }
 
 /** 从事件流里拿全部 ask / answer。 */
 export function asksOf(events = []) {
@@ -82,7 +87,8 @@ export function pendingAsks(events = [], now = Date.now()) {
 /** 配额：今天问过没有、最近七天问过几次。 */
 export function quotaOf(events = [], { now = Date.now(), dk = dateKey() } = {}) {
   const asks = asksOf(events)
-  const today = asks.filter((e) => String(e.day ?? '') === dk || dayKeyOf(e, now) === dk).length
+  // 真的事件上 day 是成长第几天（一个整数），不是日期，只能按时间算。
+  const today = asks.filter((e) => dateKey(new Date(tsMs(e) || now)) === dk).length
   const week = asks.filter((e) => now - tsMs(e) < 7 * 24 * 3600 * 1000).length
   return {
     day: today,
@@ -94,15 +100,6 @@ export function quotaOf(events = [], { now = Date.now(), dk = dateKey() } = {})
   }
 }
 
-/**
- * 事件上没写 day 时（老夹具、单测直接构造）用本地日期补一个。
- * 真实写入的事件都带 day（appendEvent 由 deriveSelf 算），这里只是兜底。
- */
-function dayKeyOf(ev, now = Date.now()) {
-  if (ev?.day) return String(ev.day)
-  return dateKey(new Date(tsMs(ev) || now))
-}
-
 /** 她今天请过假吗（rest 被同意后写一条 meta）。 */
 export function restedToday(events = [], dk = dateKey()) {
   return events.some((e) => e?.type === 'meta' && String(e.text ?? '').startsWith(`rest:${dk}`))
@@ -132,14 +129,16 @@ export function askView(events = [], now = Date.now()) {
 
 /** 选项列表（去掉空串，最多三个，保证第一个是「可以」）。 */
 function optionsOf(raw) {
-  const list = Array.isArray(raw) ? raw.map((x) => String(x ?? '').trim()).filter(Boolean).slice(0, 3) : []
+  // 事件里每个选项只存 24 个字（schema.js）。卡上的字要和账上一样，隔很久送回来的回答才对得上。
+  const list = Array.isArray(raw) ? raw.map((x) => String(x ?? '').trim().slice(0, 24).replace(/[\uD800-\uDBFF]$/, '').trim()).filter(Boolean).slice(0, 3) : []
   return list.length ? list : DEFAULT_OPTIONS.slice()
 }
 
 /** 裁决落地：只有 approve 会动东西，而且只动 time / rest 两种。 */
 async function applyVerdict(root, askEv, verdict, { log = () => {} } = {}) {
   const kind = String(askEv?.ask?.kind ?? '')
-  const dk = dateKey()
+  // 回答可能隔天才来。她问的是问的那一天能不能歇，不是答的这一天。
+  const dk = dateKey(new Date(tsMs(askEv) || Date.now()))
   const day = Number(askEv?.day ?? 0) || undefined
   const ctx = { day, stage: Number(askEv?.stage ?? 1) || 1, source: 'system' }
   try {
@@ -179,6 +178,7 @@ async function applyVerdict(root, askEv, verdict, { log = () => {} } = {}) {
     await appendEvent({ type: 'meta', text: `ask-ok:${askEv.id}` }, ctx, root)
   } catch (err) {
     log(`请求事件：裁决落地失败 ${String(err?.message ?? err).slice(0, 160)}`)
+    throw err
   }
 }
 
@@ -186,7 +186,19 @@ async function applyVerdict(root, askEv, verdict, { log = () => {} } = {}) {
  * 记下答案（这件事只做一次）。重复答会被拒。
  * @returns {Promise<{ok: boolean, why?: string, answer?: object}>}
  */
-export async function settleAsk(root, { askId, verdict, reason = '', via = 'ui', now = Date.now() } = {}) {
+export function settleAsk(root, opts = {}) {
+  // 先读账再写账，中间隔着好几次 await。回答可能从几条路同时来（卡片、观测台、别的插件、过期结算），
+  // 不排队的话两条都看到「还没答」，账上就留下相反的两个裁决，两边的效果还都生效了。
+  const run = (settling.get(root) ?? Promise.resolve()).then(() => settleAskNow(root, opts))
+  const tail = run.catch(() => {})
+  settling.set(root, tail)
+  void tail.then(() => { if (settling.get(root) === tail) settling.delete(root) })
+  return run
+}
+
+const settling = new Map()
+
+async function settleAskNow(root, { askId, verdict, reason = '', via = 'ui', now = Date.now() } = {}) {
   const id = String(askId ?? '')
   if (!id) return { ok: false, why: '没说是哪一条请求' }
   const v = verdict === 'approve' || verdict === 'reject' || verdict === 'later' ? verdict : ''
@@ -195,19 +207,28 @@ export async function settleAsk(root, { askId, verdict, reason = '', via = 'ui',
   const { events } = await readEvents(root)
   const askEv = events.find((e) => e?.id === id && e?.type === 'ask')
   if (!askEv) return { ok: false, why: '事件流里没有这一条请求' }
-  if (answersByAsk(events).has(id)) return { ok: false, why: '这条已经答过了' }
+  const prior = answersByAsk(events).get(id)
+  if (prior) return { ok: false, why: prior.ask?.via === 'timeout' ? '放了一天没人答，已经记成以后再说了' : '这条已经答过了' }
 
   const { config } = await loadConfig(root)
   const model = deriveSelf(events, { growthDays: config.growthDays })
   const word = v === 'approve' ? '可以' : v === 'reject' ? '这次不行' : '以后再说'
   const text = String(reason ?? '').trim().slice(0, 200) || word
+  // 先让裁决生效，再记「答过了」。反过来的话，配置写不进去也只会回「已经答过了」，再也改不回来，
+  // 账上和她听到的都是答应了，其实什么都没变。效果重放无害：同样的补丁，多一行 meta。
+  try {
+    // 账写不进去就别先改配置：不然他听到「没记上」，她的作息却已经变了。
+    await appendFile(paths(root).events, '')
+    await applyVerdict(root, askEv, v, { log: (m) => logLine('warn', [m], root) })
+  } catch (err) {
+    return { ok: false, why: `这次没落地：${String(err?.code ?? err?.message ?? err).slice(0, 80)}` }
+  }
   const answer = await appendEvent({
     type: 'answer',
     text,
     ask: { askId: id, verdict: v, reason: String(reason ?? '').slice(0, 200), via },
   }, { day: model.day, stage: model.stage, source: 'system' }, root)
 
-  await applyVerdict(root, askEv, v, { log: (m) => logLine('warn', [m], root) })
   return { ok: true, answer }
 }
 
@@ -256,21 +277,33 @@ export function askChoiceIndex(options = [], selected = '') {
   return -1
 }
 
+/** 改作息的问题，话是她写的，答应了改成什么是另一回事：把真的会写进配置的数写在卡上。 */
+function valueNote(value) {
+  const bits = []
+  if (Number.isFinite(Number(value?.wakesPerDay))) bits.push(`每天醒 ${Number(value.wakesPerDay)} 次`)
+  if (Array.isArray(value?.window) && value.window.length === 2) bits.push(`${value.window[0]}–${value.window[1]}`)
+  return bits.length ? `（答应了就改成：${bits.join('，')}）` : ''
+}
+
 /** 把她的问题丢进会话卡片，等人选。返回 {state, note, said, code, raw}。 */
-async function askInCard(ctx, { sessionId, ev, options, signal }) {
+async function askInCard(ctx, { sessionId, ev, options, signal, rawTexts, root }) {
   const r = await askInChat(ctx, {
     sessionId,
     signal,
+    rawTexts,
+    root,
+    cardId: `ask:${ev.id}`,
+    detail: String(ev?.ask?.reason ?? ''),
     questions: [
       {
         id: `ask-${ev.id}`,
         header: '大肥鱼有事想问你',
-        question: String(ev.text ?? ''),
+        question: `${String(ev.text ?? '')}${valueNote(ev?.ask?.value)}`,
         options: options.map((label) => ({ label })),
       },
     ],
   })
-  if (!r.ok) return { state: 'unanswered', note: '问了，还没答。', said: '', code: r.code ?? 'NO_ANSWER', raw: '' }
+  if (!r.ok) return { state: 'unanswered', note: '问了，还没答。', said: '', code: r.code ?? 'NO_ANSWER', raw: '', via: r.via ?? '' }
   const pid = `ask-${ev.id}`
   // issue #35：他直接在卡片里打字回答时，宿主回的是 `{id, selected: [], custom: '…'}`
   // （dsh-user-questions 的约定：custom 覆盖选项、selected 留空）。以前这里只看
@@ -348,6 +381,7 @@ export function registerAsk(ctx, deps = {}) {
             note: { type: 'string' },
             said: { type: 'string' },
             askId: { type: 'string' },
+            via: { type: 'string' },
           },
           required: ['ok', 'note'],
         },
@@ -362,7 +396,9 @@ export function registerAsk(ctx, deps = {}) {
                   ? '[这次不行]'
                   : out.said === 'later'
                     ? '[以后再说]'
-                    : '[已问]',
+                    : out.said === 'relayed'
+                      ? `[已问，送到了${out.via}，还没答]`
+                      : '[已问]',
           },
         ],
       },
@@ -386,10 +422,19 @@ export function registerAsk(ctx, deps = {}) {
         if (!quota.ok) return { ok: false, note: quota.why }
 
         const options = optionsOf(args?.options)
+        // 回答认的是选项原文，两个一样的话选第二个也算第一个。
+        if (new Set(options).size < options.length) return { ok: false, note: '选项的前 24 个字不能一样，不然他分不出来。' }
         const value = {}
         if (kind === 'time') {
-          if (Number.isFinite(Number(args?.wakesPerDay))) value.wakesPerDay = Number(args.wakesPerDay)
-          if (Array.isArray(args?.window) && args.window.length === 2) value.window = args.window.map((x) => String(x))
+          // 账上只存得下 0–4 的整数（schema.js 会悄悄改成最近的）。她传 5，答应后是 4，她却一直以为是 5；
+          // 传 -1 就成了 0，也就是不再定时醒。所以不认的都不问，这时还没写事件，不占额度。
+          const w = args?.wakesPerDay
+          if (/^[0-4]$/.test(String(typeof w === 'string' ? w.trim() : w))) value.wakesPerDay = Number(w)
+          const win = Array.isArray(args?.window) ? args.window.map((x) => String(x)) : null
+          if (win?.length === 2 && win.every((x) => HHMM.test(x)) && win[0] !== win[1]) value.window = win
+          if (!Object.keys(value).length || (w != null && value.wakesPerDay === undefined) || (args?.window != null && !value.window)) {
+            return { ok: false, note: 'kind=time 要写 wakesPerDay（0–4）或 window（两个不同的 HH:MM，比如 08:00）。写不对的话他答应了也改不了。' }
+          }
         }
 
         const { config } = await loadConfig(root)
@@ -407,7 +452,10 @@ export function registerAsk(ctx, deps = {}) {
         }, { day: model.day, stage: model.stage, source: 'system' }, root)
 
         // 卡片只挂在那条会话上；她这轮刚起来时 agent 可能在注册路上，askInChat 会等一小会儿。
-        const r = await askInCard(ctx, { sessionId, ev, options, signal: exec?.signal })
+        const rawTexts = [args?.question, args?.why, ...(Array.isArray(args?.options) ? args.options : [])]
+        const r = await askInCard(ctx, { sessionId, ev, options, signal: exec?.signal, rawTexts, root })
+        // 别的插件接走了：不是没人理，只是还没答。答了走 lib/cardanswer.js 结算，这里不等。
+        if (r.code === 'RELAYED') return { ok: true, note: `问了，送到了${r.via}，还没答。`, said: 'relayed', askId: ev.id, via: r.via }
         if (r.state === 'unanswered') {
           // 2026-10-30 真机（用户 m01756）：卡片消失了，事件流里却没有 answer 行，
           // 回执只写「已问」——事后完全看不出是「没答」还是「认不出选择」。
@@ -420,7 +468,7 @@ export function registerAsk(ctx, deps = {}) {
         return {
           ok: true,
           note: s.ok ? r.note : '问了，但这次没记下来。',
-          said: r.state,
+          said: s.ok ? r.state : '',
           askId: ev.id,
         }
       },

package/lib/askinchat.js

@@ -20,13 +20,79 @@
  *     否则 CALLER_NOT_LIVE / DELEGATED_CALLER
  *   - 没人在线时 noAnswerer 抛 NO_PROVIDER
  *   - 卡片挂在 `ctx.sessions.scopeOf(agent)` 那条会话上
+ *
+ * 人不在这条会话前的部署（都从 IM 上说话）：卡片他看不见，她这一轮还要白等 5 分钟，
+ * 一天后记成「一直没人答」。所以弹卡之前先问一声有没有插件能把话送到人在的地方
+ * （`dsh-fish/card`，AGENTS.md §7.3）。接走了就不弹卡、不等，回答走 `dsh-fish/answer`
+ * 回来（lib/cardanswer.js），人隔几个小时才答、中间重启过都能结算。
  */
 
+import { looksLikeRewriting, looksLikeSecret } from './guard.js'
 import { liveAgentOf } from './identity.js'
+import { logLine } from './log.js'
 
 /** 一次提问默认等多久：5 分钟。超时不当失败，当「这次没问到」。 */
 export const ASK_TIMEOUT_MS = 5 * 60_000
 
+/**
+ * 等别的插件接卡最多等多久。它发不出去，这张卡还来得及弹在会话上。
+ * 等得比一次发送的超时久（IM 插件常见 30 秒）：先放弃的话桌面弹一张、那边又送到一张，两边都能答。
+ */
+export const RELAY_WAIT_MS = 35_000
+
+/** 卡上有没有看着像凭据的字：她的问题、理由、选项都算（§3：秘密外发一律拦下）。 */
+function cardHasSecret(card) {
+  const texts = [card.detail]
+  for (const q of card.questions) texts.push(q?.header, q?.question, ...(Array.isArray(q?.options) ? q.options.map((o) => o?.label) : []))
+  return texts.some((text) => looksLikeSecret(text).hit)
+}
+
+/**
+ * 回执里要念给她听的去处。这是别的插件写的字（§3：新输入口都过 guard.js）。
+ * 空的算没接走；看着像改写指令的，卡还是接走了，只是不把这几个字念给她。
+ */
+function viaOf(taken) {
+  const raw = typeof taken?.via === 'string' ? taken.via : ''
+  const via = raw.replace(/\s+/g, ' ').trim().slice(0, 40)
+  if (!via) return ''
+  // 按行看：改写指令的判断认行首，压成一行之后「QQ\nsystem: …」就认不出来了
+  const risky = raw.split(/[\r\n\u2028\u2029]+/).some((line) => looksLikeRewriting(line).hit) || looksLikeRewriting(via).hit || looksLikeSecret(raw).hit
+  return risky ? '别的地方' : via
+}
+
+/**
+ * 问问有没有插件接这张卡。只有回了 `{ via: '说给她听的去处' }` 才算接走；
+ * 没人接、抛错、拒绝、超时、这一轮被取消都按没接，**绝不抛**。Promise 的拒绝由 race 接住：
+ * 宿主把未处理的拒绝当致命错误，超时之后才拒绝的也一样要接住。
+ * `bail` 停在第一个非空返回值上，所以 async 监听只有排第一的那个算数。
+ * 看着带凭据的卡不问：它只留在本机的卡片上，不发给任何插件。截断之前的原文也要看，
+ * 不然长 token 的前半段正好够不上判断的长度。这条判断偏严，长文件名也可能中，所以留一行日志，只记 id。
+ */
+async function relayCard(ctx, card, waitMs, signal, { rawTexts = [], root = undefined } = {}) {
+  if (cardHasSecret(card) || rawTexts.some((text) => looksLikeSecret(text).hit)) {
+    if (root) logLine('warn', ['卡上有看着像凭据的字，没转给别的插件，只留在本机：', card.id], root)
+    return ''
+  }
+  let timer
+  let onAbort
+  try {
+    const r = ctx?.bail?.('dsh-fish/card', card)
+    const taken = typeof r?.then === 'function'
+      ? await Promise.race([r, new Promise((resolve) => {
+        timer = setTimeout(() => resolve(null), waitMs)
+        onAbort = () => resolve(null)
+        signal?.addEventListener?.('abort', onAbort, { once: true })
+      })])
+      : r
+    return viaOf(taken)
+  } catch {
+    return ''
+  } finally {
+    clearTimeout(timer)
+    if (onAbort) signal?.removeEventListener?.('abort', onAbort)
+  }
+}
+
 /**
  * 把她想问的话丢进会话里，等那个人选一个。
  *
@@ -36,7 +102,12 @@ export const ASK_TIMEOUT_MS = 5 * 60_000
  * @param {Array}  opts.questions 宿主格式的问题数组
  * @param {number} [opts.timeoutMs]
  * @param {object} [opts.signal] 外部取消信号（例如这一轮已经结束了）
- * @returns {Promise<{ok: boolean, answers?: Array, code?: string}>}
+ * @param {string} [opts.cardId] 这张卡的 id（`ask:…` 等，见 lib/cardanswer.js）。不给就不会被别的插件接走
+ * @param {string} [opts.detail] 只给接卡的插件看的补充说明（卡片本身放不下的那句「为什么」）
+ * @param {Array} [opts.rawTexts] 卡上的字截断之前的原文，只用来判断带不带凭据
+ * @param {string} [opts.root] 这个家，用来留日志
+ * @returns {Promise<{ok: boolean, answers?: Array, code?: string, via?: string}>}
+ *   被接走时 `{ok:false, code:'RELAYED', via}`：调用方照「问了，还没答」处理
  */
 export async function askInChat(ctx, opts = {}) {
   const {
@@ -45,9 +116,20 @@ export async function askInChat(ctx, opts = {}) {
     timeoutMs = ASK_TIMEOUT_MS,
     signal = undefined,
     waitAgentMs = 10_000,
+    cardId = '',
+    detail = '',
+    relayWaitMs = RELAY_WAIT_MS,
+    rawTexts = [],
+    root = undefined,
   } = opts
   if (!Array.isArray(questions) || questions.length === 0) return { ok: false, code: 'NO_QUESTIONS' }
 
+  if (cardId && !signal?.aborted) {
+    const via = await relayCard(ctx, { id: cardId, sessionId, questions, detail }, relayWaitMs, signal, { rawTexts, root })
+    if (via) return { ok: false, code: 'RELAYED', via }
+    if (signal?.aborted) return { ok: false, code: 'AbortError' }
+  }
+
   // 宿主只接受 live root agent。她那轮刚被 wake 顶起来时，agent 可能还没就位，
   // 所以这里给一小段等待窗口（默认 10 秒）而不是一次查不到就放弃。
   const agent = await waitAgent(ctx, sessionId, { totalMs: waitAgentMs, signal })

package/lib/browse.js

@@ -546,6 +546,14 @@ export const LOOK_BRIEF = [
   '和 growth_commit 一样，你不用它也可以。',
 ].join('\n')
 
+/**
+ * 关着时的「上网」那一节（P3，2026-11-07）。
+ * 门不拆：整节消失会让她以为这件事根本不存在；只把门上的话换成「这会儿」。
+ */
+export const LOOK_OFF_BRIEF = [
+  '这会儿出不去。以前翻过、看过的东西还在；等能出去的时候，你会先看到它们。',
+].join('\n')
+
 /**
  * 他丢来一条视频的时候怎么办。
  *

package/lib/capture.js

@@ -186,13 +186,31 @@ export function registerCapture(ctx, deps = {}) {
             return { ok: true, id: dk, note: '写下了。' }
           }
 
+          // 写盘的 schema 会把越界的数字悄悄改成最近的（confidence 夹到 0–1）。
+          // 她传 5 会以为记下了 5，读回来却是 1——和 issue #43 的 wakesPerDay 是同一类问题。
+          // 入口先拒，别让「说好的」和「落地」不一样；这时还没写事件，可以改完重试。
+          if (args?.confidence != null) {
+            const c = Number(args.confidence)
+            if (!Number.isFinite(c) || c < 0 || c > 1) {
+              return {
+                ok: false,
+                id: '',
+                note: `confidence 要写 0–1 之间的小数（你写的是 ${String(args.confidence)}）。写盘时越界会被悄悄夹到边上，所以这里先不收。`,
+              }
+            }
+          }
+          // verdict 同理：schema 认不出来的会落成 null，她以为写了 confirmed。
+          if (args?.verdict != null && !['confirmed', 'refuted', 'refined'].includes(args.verdict)) {
+            return { ok: false, id: '', note: 'verdict 只能是 confirmed / refuted / refined。' }
+          }
+
           const ev = await appendEvent(
             {
               type: args?.type,
               text: args?.text,
               refs: args?.refs,
               verdict: args?.verdict,
-              confidence: args?.confidence,
+              confidence: args?.confidence == null ? undefined : Number(args.confidence),
               // 「谁写的」：这一条是她这条会话说的，不是别的屋子里那一位。
               sessionId: who.sessionId,
             },

package/lib/cardanswer.js

@@ -0,0 +1,84 @@
+/**
+ * cardanswer.js —— 卡片被别的插件接走之后，人的回答从这里回来
+ *
+ * 人不在她那条会话前的部署（都从 IM 上说话），插件可以用 `dsh-fish/card` 把卡接走
+ * （lib/askinchat.js，AGENTS.md §7.3）。人可能隔几个小时才答，中间宿主可能还重启过，
+ * 所以回答不靠闭包：插件记着卡的 id，答了就发
+ *
+ *   const r = await ctx.bail('dsh-fish/answer', { id: card.id, selected: ['可以'] })
+ *
+ * id 是 `种类:引用`：`ask:<事件 id>`、`keepsake:<条目 id>`、`grant:<申请 id>`。
+ * selected 和宿主 userQuestions 的回答同形，填选项原文。没选、对不上选项都不结算，
+ * 这张卡还开着：人回的可能只是一句话，猜成同意或以后再说都可能是错的，而且只结算一次，错了改不回来。
+ * 结算走的都是观测台和卡片用的同一条路，「只结算一次」也由它们管。
+ * `ok: false` 不代表这张卡结了，写盘失败也是它，接卡的插件留着 id，人再答一次就再试一次。
+ */
+
+import { rootDir, readEvents } from './store.js'
+import { ASK_TTL_MS, answersByAsk, asksOf, settleAsk, settleStaleAsks } from './ask.js'
+import { tsMs } from './schema.js'
+import { picked } from './askinchat.js'
+import { decideKeepsake } from './keepsake.js'
+import { YES as KEEP_YES, NO as KEEP_NO } from './keep.js'
+import { recordGrant, GRANT_YES, GRANT_NO } from './grant.js'
+import { pendingOffer } from './unlock.js'
+
+const ASK_VERDICTS = ['approve', 'reject', 'later']
+
+async function answerAsk(root, askId, label) {
+  // 过期结算是定时器做的，她出门或者宿主刚起来时可能没跑。过没过期要在这里就算数。
+  await settleStaleAsks(root)
+  const { events } = await readEvents(root)
+  const ev = asksOf(events).find((e) => e?.id === askId)
+  if (!ev) return { ok: false, why: '事件流里没有这一条请求' }
+  // 上面那次过期结算可能没写进去，过了一天的回答一样不算数。
+  if (!answersByAsk(events).has(askId) && Date.now() - tsMs(ev) >= ASK_TTL_MS) return { ok: false, why: '放了一天没人答，算以后再说了' }
+  // 只认选项原文。别的插件把人回的「1」直接传进来，不能按下标算成第二个。
+  const options = Array.isArray(ev?.ask?.options) ? ev.ask.options.map((x) => String(x ?? '').trim()) : []
+  const verdict = ASK_VERDICTS[options.indexOf(label)]
+  if (!verdict) return { ok: false, why: '这张卡没有这个选项' }
+  const r = await settleAsk(root, { askId, verdict, reason: label, via: 'relay' })
+  return r.ok ? { ok: true } : { ok: false, why: r.why }
+}
+
+function answerKeepsake(root, id, label) {
+  if (label !== KEEP_YES && label !== KEEP_NO) return { ok: false, why: '这张卡没有这个选项' }
+  const d = decideKeepsake(root, { id, yes: label === KEEP_YES })
+  return d.ok ? { ok: true } : { ok: false, why: d.note }
+}
+
+async function answerGrant(root, offerId, label) {
+  if (label !== GRANT_YES && label !== GRANT_NO) return { ok: false, why: '这张卡没有这个选项' }
+  // 读不到账要照实说，不能说成申请不在了。
+  const { events } = await readEvents(root)
+  const offer = pendingOffer(events)
+  if (offer?.id !== offerId) return { ok: false, why: '这张申请已经不在等了' }
+  const w = await recordGrant(root, { offerId, rule: offer.grant?.rule || '', verdict: label === GRANT_YES ? 'approve' : 'reject' })
+  return w.ok ? { ok: true } : { ok: false, why: w.error }
+}
+
+/**
+ * 结算一张被接走的卡。**绝不抛**，别的插件不用替我们兜底。
+ * @param {string} root
+ * @param {{id: string, selected?: Array}} answer
+ * @returns {Promise<{ok: boolean, why?: string}>}
+ */
+export async function answerCard(root = rootDir(), answer = {}) {
+  try {
+    const id = String(answer?.id ?? '')
+    const at = id.indexOf(':')
+    const ref = at > 0 ? id.slice(at + 1) : ''
+    if (!ref) return { ok: false, why: '没说是哪一张卡' }
+    const label = picked([{ id, selected: answer?.selected }], id)
+    if (!label) return { ok: false, why: '没选' }
+    switch (id.slice(0, at)) {
+      case 'ask': return await answerAsk(root, ref, label)
+      case 'keepsake': return answerKeepsake(root, ref, label)
+      case 'grant': return await answerGrant(root, ref, label)
+      default: return { ok: false, why: '不认识这种卡' }
+    }
+  } catch (err) {
+    // 原因可能转告给人，也可能送进她的对话：只说错误码，不带本机路径。
+    return { ok: false, why: String(err?.code ?? err?.message ?? err).slice(0, 160) }
+  }
+}