@ssamurias/dsh-fish 0.9.1 → 0.9.2

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/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) }
+  }
+}

package/lib/client.js

@@ -452,6 +452,10 @@ window.__ModuleLoader__.load({
       const [owCookie, setOwCookie] = useState('')
       const [atOwner, setAtOwner] = useState(true)
       const [owNote, setOwNote] = useState('')
+      // 2026-11-06（用户反馈）：领养人两格原来只有「B 站登录 → 粘贴 cookie」页签底部那一颗保存键，
+      // 停在「领养人验证」这一组里根本找不到保存路径，停在扫码页签里那颗键更是连渲染都不渲染。
+      // 这一组现在自带一颗，提示也写在这一组里，不再借用下面 cookie 那行的 owNote。
+      const [owIdNote, setOwIdNote] = useState('')
       // 扫码登录（2026-11-01）：浮层里的这张码。
       // qr 只在浮层开着的时候有值；关掉就 drop，宿主那边攥着的 cookie 一起忘掉。
       const [owTab, setOwTab] = useState('qr')
@@ -1010,6 +1014,26 @@ window.__ModuleLoader__.load({
         } catch (e) { setOwNote(e.message) } finally { setBusy('') }
       }
 
+      /**
+       * 只保存「领养人」那两格（2026-11-06，用户反馈）。
+       * 以前这两格唯一能存的地方挂在下面「B 站登录 → 粘贴 cookie」页签底部：
+       * 停在领养人这一组里找不到，停在扫码页签里那颗键压根不渲染，填完等于白填。
+       * 现在这组自带一颗，提交范围也只有这两格——不动下面那份 cookie，也不把空串写回去。
+       * 存完刷一次 /owner：旧版本写脏时那句提示会跟着消失，两格也换回服务端真正存下的值。
+       */
+      const saveOwnerIdentity = async () => {
+        setBusy('owid'); setOwIdNote('')
+        try {
+          const body = {}
+          if (owMid.trim()) body.mid = owMid.trim()
+          if (owName.trim()) body.nickname = owName.trim()
+          if (!Object.keys(body).length) { setOwIdNote('两格都空着，没有可存的。'); setBusy(''); return }
+          const r = await jpost('/owner', body)
+          setOwIdNote(r.note || (r.ok ? '存下了。' : '没存上。'))
+          if (r.ok) { flashSaved(); await load() }
+        } catch (e) { setOwIdNote(e.message) } finally { setBusy('') }
+      }
+
       const testOwner = async () => {
         setBusy('owtest'); setOwNote('')
         try {
@@ -1342,6 +1366,17 @@ window.__ModuleLoader__.load({
             onChange: (e) => o.onChange(e.target.value) }))
       }
       function TimeRange(o) {
+        // 2026-11-06（0.9.2 反馈）：原生时间框跟随系统 12 小时制，00:00 显示成
+        // 「上午 12:00」——中文用户会读成中午十二点，于是以为窗口是 12:00–23:00，
+        // 再看到凌晨五点醒来就当成 bug。输入框保留（有选择器），下面补一行
+        // 24 小时制把值说死；跨零点时标明「次日」。
+        const hhmm = (v) => {
+          const m = /^(\d{1,2}):(\d{2})$/.exec(String(v ?? ''))
+          return m ? `${m[1].padStart(2, '0')}:${m[2]}` : ''
+        }
+        const from = hhmm(o.from)
+        const to = hhmm(o.to)
+        const nextDay = from && to && to < from ? '次日 ' : ''
         return h('div', { className: 'fld' },
           h('div', { className: 'fl' },
             h('span', { className: 'flabel' }, o.label),
@@ -1349,7 +1384,11 @@ window.__ModuleLoader__.load({
           h('div', { className: 'row', style: { gap: '6px' } },
             h('input', { type: 'time', value: o.from, onChange: (e) => o.onFrom(e.target.value) }),
             h('span', { className: 'dim' }, '到'),
-            h('input', { type: 'time', value: o.to, onChange: (e) => o.onTo(e.target.value) })))
+            h('input', { type: 'time', value: o.to, onChange: (e) => o.onTo(e.target.value) })),
+          from && to
+            ? h('div', { className: 'dim', style: { fontSize: '12px', marginTop: '2px' } },
+                `24 小时制：${from} → ${nextDay}${to}`)
+            : null)
       }
 
       // 工具面：把限制的理由写给用户看，给一个总开关，另留一处额外放行口。
@@ -2270,6 +2309,8 @@ window.__ModuleLoader__.load({
           else setAskMsg(String(r?.why || '没答上。'))
         } catch (e) {
           setAskMsg(`没答上：${e.message}`)
+          // 多半是别的地方先答了：把列表刷新一下，别还留着这张卡
+          jget('/ask').then(setAsks).catch(() => {})
         }
       }
 
@@ -2547,7 +2588,7 @@ window.__ModuleLoader__.load({
           // 旧版本（≤0.5.9）会把登录账号写进这两格，只有点「保存」才会重写；这里点出来，别让人以为是刷新丢的。
           owMid && ow?.account?.mid && String(owMid) === String(ow.account.mid)
             ? h('p', { className: 'warn' },
-                '这两格现在跟下面登录的账号是同一个号，像是旧版本写进去的。改成你要 @ 的 uid 和昵称，再点「保存」。')
+                '这两格现在跟下面登录的账号是同一个号，像是旧版本写进去的。改成你要 @ 的 uid 和昵称，再点下面「保存这两格」。')
             : null,
           h('div', { className: 'grid2' },
             Text({ label: '要 @ 的 B 站 uid', value: owMid, onChange: setOwMid, placeholder: '数字，比如 12345678', wide: true,
@@ -2555,7 +2596,13 @@ window.__ModuleLoader__.load({
             Text({ label: '要 @ 的 B 站昵称', value: owName, onChange: setOwName, placeholder: '评论里 @ 的就是这个名字', wide: true,
               hint: '要跟 B 站上显示的一字不差（带空格也照填）。没填就 @ 不出来——空的 @ 只是一串没人认领的字符。' }),
             Toggle({ label: '发评论时在最前面 @ 你', on: atOwner, onChange: setAtOwner,
-              hint: '关掉就不 @，评论会显得更像自言自语。' }))),
+              hint: '关掉就不 @，评论会显得更像自言自语。这个开关改完就生效，不用按保存。' })),
+          // 这组自己的保存键（2026-11-06，用户反馈）：填完就地能存，不用再去下面 cookie 那栏找。
+          h('div', { className: 'row', style: { marginTop: '8px', gap: '8px' } },
+            h('button', { onClick: saveOwnerIdentity, disabled: busy === 'owid' },
+              busy === 'owid' ? '保存中…' : '保存这两格'),
+            h('span', { className: 'hint' }, '只存上面填了的格子，不动下面那份 cookie；留空的不改原值。'),
+            owIdNote ? h('span', { className: 'dim' }, owIdNote) : null)),
         group('B 站登录',
           '她刷视频、发评论用的账号，建议放一个小号。没存也能看视频，只是不能说话。',
           // 两个入口：扫码是给人用的，粘贴是退路（扫码不顺利、或者想换个号）。
@@ -2566,7 +2613,7 @@ window.__ModuleLoader__.load({
 
           h('div', { className: 'dim', style: { marginBottom: '8px' } },
             ow?.hasCookie
-              ? `已存${ow?.account?.name ? `，登录账号：${ow.account.name}${ow.account.mid ? `（uid ${ow.account.mid}）` : ''}` : '（点「测试能不能说话」认一下是哪个账号）'}${ow.hasCsrf ? '' : '，但少了 bili_jct（不能发评论）'}。换一份就重新登。`
+              ? `已存${ow?.account?.name ? `，登录账号：${ow.account.name}${ow.account.mid ? `（uid ${ow.account.mid}）` : ''}` : '（点下面的「测试 cookie 能不能说话」认一下是哪个账号）'}${ow.hasCsrf ? '' : '，但少了 bili_jct（不能发评论）'}。换一份就重新登。`
               : '还没存。'),
 
           owTab === 'qr'
@@ -2592,13 +2639,18 @@ window.__ModuleLoader__.load({
                 String(ow?.hint ?? '').split('\\n').map((line, i) => h('div', { key: i }, line))),
               h('div', { className: 'row', style: { marginTop: '8px' } },
                 h('button', { onClick: saveOwnerCard, disabled: busy === 'owner' },
-                  busy === 'owner' ? '保存中…' : '保存'),
-                h('button', { onClick: testOwner, disabled: busy === 'owtest' },
-                  busy === 'owtest' ? '测试中…' : '测试 cookie 能不能说话'),
-                h('span', { className: 'hint' }, '只验下面那份 cookie，不保存、不动上面两格；两格要改就点「保存」。'))),
+                  busy === 'owner' ? '保存中…' : '保存 cookie'),
+                h('span', { className: 'hint' }, '「保存 cookie」会顺带存一次上面填了的格子；只想改那两格就点上面那组里的「保存这两格」。'))),
 
           h('div', { className: 'row', style: { marginTop: '8px' } },
             owNote ? h('span', { className: 'dim' }, owNote) : null,
+            // 测试键原来只长在「粘贴 cookie」页签里（issue #52）：扫码登进来的人
+            // 想看「这份 cookie 还能不能说话」得先翻页签，上面那行「点测试认一下是哪个账号」
+            // 更是指向一颗不在当前页签上的按钮。挪到两组共用的这一行，两个页签都点得到。
+            ow?.hasCookie
+              ? h('button', { onClick: testOwner, disabled: busy === 'owtest' },
+                busy === 'owtest' ? '测试中…' : '测试 cookie 能不能说话')
+              : null,
             ow?.hasCookie
               ? h('button', {
                 disabled: busy === 'owclear',
@@ -2607,6 +2659,9 @@ window.__ModuleLoader__.load({
                   clearLogin()
                 },
               }, busy === 'owclear' ? '清除中…' : '清除登录')
+              : null,
+            ow?.hasCookie
+              ? h('span', { className: 'hint' }, '测试只验这份 cookie，不保存、也不动上面那两格。')
               : null)),
 
         // ---- 以前看了什么（视频观看历史，分页） ----
@@ -3343,6 +3398,7 @@ window.__ModuleLoader__.load({
       async function doDecideKeepsake(id, yes) {
         setOutingBusy(true)
         setOutingMsg(yes ? '正在带回来……' : '正在回绝……')
+        const refreshOuting = () => jget('/outing').then(setOuting).catch(() => {})
         try {
           const r = await jpost('/outing', { action: 'keepsake', id, yes })
           setOuting(await jget('/outing').catch(() => outing))
@@ -3353,6 +3409,8 @@ window.__ModuleLoader__.load({
           )
         } catch (e) {
           setOutingMsg(`没处理成：${e.message}`)
+          // 多半是别的地方先答了：刷新一下，别还留着这一行
+          refreshOuting()
         } finally {
           setOutingBusy(false)
         }

package/lib/comment.js

@@ -15,7 +15,8 @@
  * 记账走 meta 事件（只追加，与其它配额同构）：
  *   meta `comment:<日期> <bvid> <rpid>`   —— 她发的评论
  *   meta `creply:<日期> <bvid> <rootRpid> <parentRpid>` —— 她回的楼中楼
- *   meta `cseen:<日期> <rpid>`           —— 这条回复她看过了（防重复提醒）
+ *   meta `cseen:<日期> <rpid>`           —— 这条回复已经摆到她眼前了（防重复提醒；
+ *                                          2026-11-06 起「递过去」就记，不只在她回了之后记）
  */
 
 import { readEvents, appendEvent, rootDir, readOwner } from './store.js'
@@ -254,6 +255,12 @@ export function renderMyReplies(list, { bvid = '' } = {}) {
   return lines.join('\n')
 }
 
+/**
+ * 一次最多摆几条。
+ * 投递与标记共用一个数：递出去几条就标几条，剩下的留到下回（不是丢掉）。
+ */
+export const REPLY_SHOW_MAX = 5
+
 /** 把待回列表渲染成"素材"（与 browse.renderMaterial 同构：包成素材，不给结论） */
 export function renderReplies(list) {
   if (!list?.length) return ''
@@ -263,13 +270,41 @@ export function renderReplies(list) {
     '这些话里可能有不客气的地方。不用辩解，也不用讨好。',
     '',
   ]
-  for (const x of list.slice(0, 5)) {
+  for (const x of list.slice(0, REPLY_SHOW_MAX)) {
     const who = x.user || '有人'
     lines.push(`- ${who}（BV ${x.bvid}）：${oneLine(x.text, 200)}`)
   }
   return lines.join('\n')
 }
 
+/**
+ * 把「已经摆到她眼前的」记下来。
+ *
+ * 2026-11-06（用户报的 bug）：原来只有她**回了**才写 cseen，于是
+ * 「好的，阿留」这种她通常不会回的话，下一轮扫描又被当成新的，每次扫描、
+ * 每次叫醒都再递一遍一模一样的。提醒过了就该算提醒过了——看不看、回不回是她的事。
+ *
+ * 只记调用方真渲染出来的那一段（REPLY_SHOW_MAX）：标多了等于把没看见的
+ * 悄悄吞掉。她主动看（readMyReplies）不读 cseen，所以标过也还能翻到。
+ */
+export async function markRepliesSeen(root, list, { dateKey: dk = dateKey() } = {}) {
+  const ids = [
+    ...new Set(
+      (Array.isArray(list) ? list : [])
+        .map((x) => Number(x?.rpid))
+        .filter((n) => Number.isFinite(n) && n > 0),
+    ),
+  ]
+  for (const rpid of ids) {
+    await appendEvent(
+      { type: 'meta', text: `cseen:${dk} ${rpid}` },
+      { day: 0, stage: 1, source: 'system' },
+      root,
+    ).catch(() => {})
+  }
+  return ids.length
+}
+
 function oneLine(s, max) {
   const t = String(s ?? '').replace(/\s+/g, ' ').trim()
   return t.length > max ? t.slice(0, max) + '…' : t

package/lib/deliver.js

@@ -50,6 +50,7 @@
  */
 
 import { randomUUID } from 'node:crypto'
+import { sessionRow } from './home.js'
 
 /**
  * 我们自己起的来源名。
@@ -167,6 +168,51 @@ export async function ensureSessionLive(sc, sessionId) {
   }
 }
 
+/**
+ * 探活失败时，**只在宿主确实给不出这一条**的情况下才新建（2026-11-06 换房报告）。
+ *
+ * 老退路是裸 `sc.create({ sessionId, cwd })`，可宿主的 `create()` 是「按 cwd 开一条」：
+ * `claim()` 里 `reusable = request.reusable(sessionId) && !observed.events.some(e => e.type === 'turn/start')`，
+ * 只要这条会话跑过一轮，请求的 sessionId 就被丢掉、换成一个新 id 返回，
+ * 于是每递一次话就多一条空壳（本机实测见 `ensureSessionLive` 的注释）。
+ *
+ * 三条分支：
+ *
+ *   - **行在、跑过 turn（`blank === false`）**：宿主不会按这个 id 复用，create 只会
+ *     再造一条空壳 —— 跳过，让调用方拿现有的会话继续递。
+ *   - **行在、还空着（`blank === true`）**：还没 `turn/start`，宿主的 claim 会复用原 id，
+ *     create 是安全的「把它叫起来」。
+ *   - **查不到 / 老宿主不给 blank**：按不存在处理，create 走 `createAgent(sessionId)`
+ *     那条（宿主 `observeSession` 抛 `SESSION_QUERY_SESSION_NOT_FOUND` 时才用它）。
+ *
+ * 返回值里 `created !== sessionId` 一律判失败：那说明宿主又按 cwd 另开了一条，
+ * 这条新会话没挂工作区、侧栏也看不见，留在那里只会变成下一条空壳。
+ *
+ * @returns {Promise<{revived:boolean, created?:string, reason?:string}>} 永不抛
+ */
+export async function reviveIfBlank(sc, sessionId, cwd, log) {
+  const sid = String(sessionId ?? '')
+  if (!sid) return { revived: false, reason: 'no-id' }
+  const row = await sessionRow(sc, sid)
+  if (row.found && row.blank === false) {
+    log?.(`${sid} 已经跑过 turn，宿主不会按这个 id 复用，跳过新建`)
+    return { revived: false, reason: 'has-turns' }
+  }
+  try {
+    const item = await sc.create({ sessionId: sid, cwd })
+    const got = String(item?.sessionId ?? item?.id ?? '')
+    if (got && got !== sid) {
+      log?.(`宿主按 cwd 另开了 ${got}，不是 ${sid}；这条不并进工作区，丢着`)
+      return { revived: false, reason: 'new-id', created: got }
+    }
+    log?.(`按原 id 新建了 ${sid}`)
+    return { revived: true, created: got || sid }
+  } catch (err) {
+    log?.(`按原 id 新建失败：${String(err?.message ?? err).slice(0, 140)}`)
+    return { revived: false, reason: 'failed' }
+  }
+}
+
 /**
  * 叫醒她：递一条 `source.kind = fish-wake` 的消息，让她开一轮。
  *

package/lib/derive.js

@@ -7,7 +7,7 @@
  *   - 这里是 schema 之外唯一会提到"阶段/需要"的地方，且都只用于选事件。
  */
 
-import { idTime, detectSelfMod } from './schema.js'
+import { idTime, detectSelfMod, tsMs, isContactEvent } from './schema.js'
 import { parseRefusal, REACTIONS, REACTION_HURTS, CONCEDE_WINDOW_MS, isConcede } from './refuse.js'
 // 评论区里别人的话（2026-10-24）：只借两个纯函数，derive 不反过来被 voices 依赖。
 import { findEcho, VOICE_FRESH_DAYS } from './voices.js'
@@ -771,15 +771,16 @@ export function deriveSelf(events = [], opts = {}) {
   // 口径必须和 absence.js 的 lastSeenAt() 对齐：`meta seen:` 是主证据（turns.js
   // 结账时写），`heard` 是兜底（侧栏聊天不写 seen 的那段时间只有它）。
   // 不认 utterance：定时唤醒也会写 utterance，那不算他来过。
-  const contactAfterAbsence = Boolean(lastAbsence) && evs.some((e) => {
-    const ms =
-      e?.type === 'heard'
-        ? Date.parse(String(e?.ts ?? ''))
-        : e?.type === 'meta' && String(e?.text ?? '').startsWith('seen:')
-          ? Date.parse(String(e.text).slice(5).trim()) || Date.parse(String(e?.ts ?? ''))
-          : NaN
-    return Number.isFinite(ms) && ms > Date.parse(String(lastAbsence.ts ?? 0))
-  })
+  //
+  // 「回来没有」按两条线索判（2026-11-06，issue #49 的时钟盲点）：
+  //   1. 事件流先后：seen/heard 追加在 absence 之后；
+  //   2. 时间戳：seen/heard 晚于 absence 的 ts。
+  // 老代码只看 2，系统时间被往前跳过时 absence 会带一条 ts 在未来的时间戳，
+  // 之后所有 seen 都比它小，于是这条冷落永远结束不了。
+  const absIdx = lastAbsence ? evs.indexOf(lastAbsence) : -1
+  const contactAfterAbsence =
+    absIdx >= 0 &&
+    evs.some((e, i) => isContactEvent(e) && (i > absIdx || tsMs(e) > tsMs(lastAbsence)))
 
   // 冷落天数有三个来源，优先用最准的：
   //   1. absence 事件自带的 days（系统侧按毫秒算出来的，最准）
@@ -793,7 +794,9 @@ export function deriveSelf(events = [], opts = {}) {
     ? Math.max(
         0,
         Number.isFinite(Number(lastAbsence.days))
-          ? Number(lastAbsence.days)
+          // days 是写下那天的数。这次冷落还没结束就接着往上加，不然一个月后还读「2 天」，门槛高的配置永远够不到
+          // 只加不减：系统时间回拨、ts 落在未来时差值是负的，不能因此把冷落算没了
+          ? Number(lastAbsence.days) + Math.max(0, Math.floor((now - Date.parse(lastAbsence.ts)) / DAY_MS) || 0)
           : Number(lastAbsence.day) > 0
             ? day - Number(lastAbsence.day)
             : Math.ceil((now - Date.parse(lastAbsence.ts)) / DAY_MS),

package/lib/events.js

@@ -15,6 +15,16 @@
 
 import { similarity, DAY_MS } from './derive.js'
 
+// 措辞变体（2026-11-06 用户拍板）：同一处境，几种问法。
+// 这张卡一生要出好几次；每次都是同一句话，她最容易回的就是上次那句（复述污染）。
+// 按 occurrences 轮换——她第几次遇到这张卡，就用第几套开场，不打乱、可复现。
+// 三条都必须保留两个硬要求：说具体、判断要能被核对；也都不承诺今天有素材。
+const NOTICE_VARIANTS = [
+  () => `回想这几天——他说过的话、你读到的评论、你自己反复想到的念头，有哪一件你还记得？挑一件，说清楚它具体是什么，再给出你的判断：它说明什么。判断要能被核对，别写成感觉。`,
+  () => `如果让你指出一件这几天真看见的小事，你会指哪件？谁说的、在哪儿看到的、原话大概是什么——先说具体，再说你的判断：这件事说明什么。要能被拿去核对。`,
+  () => `有没有一件小事，小到不值得说，但你确实反复想过？讲清楚它是什么，然后下一个判断。要能被拿去核对，别写成感觉。`,
+]
+
 export const CATALOG = [
   // ---------- stage 1 信任 ----------
   {
@@ -54,6 +64,20 @@ export const CATALOG = [
       return `你之前说过：「${b.text}」。今天你碰上了一点可能说明你错了一点点的事——也可能什么都没碰上。不管怎样，自己判断：${tail}`
     },
   },
+  {
+    // 2026-11-06（反馈 dsh-fish-091）：stage 1 到第 3 天会整天没有可出的事件——
+    // why_here / first_bet / name_offer 都是一次性，test_first 冷却 2 天。
+    // 这张卡不依赖任何外部素材：她自己挑一件这几天真碰到过的事，下一个能被核对的判断。
+    // 故意不承诺「今天有东西给你看」（issue #4 的教训），也不占 daily.questions 配额。
+    id: 'notice_one', stage: 1, asks: false, once: false, repeat: { everyDays: 2 },
+    topic: ['注意到', '小事'],
+    // 第 1 天让给 first_bet：她要先有第一个判断，这张卡才有东西可挑。
+    cond: (m) => m.beliefCount >= 1,
+    // 每次换一种问法；repeatNote 关掉「第 N 次回到这件事」的尾巴——
+    // 这张卡每次挑的是不同的事，说「回到这件事」反把她推回上次那句。
+    repeatNote: false,
+    prompt: (m, ctx = {}) => NOTICE_VARIANTS[Number(ctx.occurrences ?? 0) % NOTICE_VARIANTS.length](m),
+  },
 
   // ---------- stage 1–2 冷落与重聚 ----------
   {
@@ -63,7 +87,7 @@ export const CATALOG = [
     cond: (m) => m.absenceDays >= absenceThreshold(m.growthDays),
     // 2026-10-25 用户改：允许问「去哪了」。原来写死"不是问他去哪了"，
     // 等于替她选了一种反应；问不问该由她决定。
-    prompt: (m) => `他 ${m.absenceDays} 天没来了，也没说去哪。现在他出现了。你想说的第一句话是什么——你可以问他去哪了，也可以只说这 ${m.absenceDays} 天里你自己想了什么。挑你更想说的那个。`,
+    prompt: (m) => `他 ${m.absenceDays} 天没来了，也没说去哪。等他回来，你想说的第一句话是什么——你可以问他去哪了，也可以只说这 ${m.absenceDays} 天里你自己想了什么。挑你更想说的那个。`,
   },
 
   // ---------- stage 2 自主 ----------

package/lib/generator.js

@@ -122,8 +122,9 @@ function safePrompt(t, m, ctx = {}) {
   if (!text) return ''
   // 同一处境**第二次**回来时点一句：这次别复读上次的说法。
   // occurrences = 已经出过几次，所以 n >= 1 表示这一次是第 2 次（含以后）。
+  // repeatNote === false 的卡（如 notice_one）每次换题，不追这句。
   const n = Number(ctx.occurrences ?? 0)
-  if (n >= 1) {
+  if (n >= 1 && t.repeatNote !== false) {
     text += `\n\n（这是第 ${n + 1} 次回到这件事。上次你的说法就在下面这段记忆里——这次要么说清为什么没变，要么改一句。）`
   }
   // 回引（P1 第三块，2026-10-24）：碰到"要不要""底线""重聚"这类有压力的处境时，