@ssamurias/dsh-fish 0.9.0 → 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/browse.js

@@ -540,6 +540,7 @@ export const LOOK_BRIEF = [
   '  what=search  搜一个词（要带 keyword）',
   '  what=related 看某个视频之后，平台又接着推什么（要带 bvid）',
   '  what=video   看指定的那一条（要带 bvid：BV 号，或者他递过来的链接）',
+  '  what=replies 看你自己发过的评论下面有没有人回你（可带 bvid 只看那一条）',
   '它只读，不会留下任何痕迹，也不会让别人知道你在看。',
   '它能给你标题、简介、标签、热评、弹幕——给不了视频画面。',
   '和 growth_commit 一样，你不用它也可以。',

package/lib/capture.js

@@ -23,6 +23,7 @@ import { inWake } from './wakewin.js'
 import { refreshSelfDoc } from './selfdoc.js'
 import { guardWrite } from './tenant.js'
 import { activeOf, activePossessionOf, readOutings, readPossessions } from './outing.js'
+import { readChannels } from './channels.js'
 import { tripKey } from './keepsake.js'
 
 /**
@@ -185,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,
             },
@@ -206,7 +225,21 @@ export function registerCapture(ctx, deps = {}) {
           // 坑（p1.test.mjs 抓到的）：这里的 source 必须是 'system'。
           // 写成 'tool' 时 schema 会以 NOT_HER_TYPE 拒掉 meta，而外面套着 .catch(()=>{})，
           // 于是 seen 永远写不进去 → 冷落检测永远返回 no-contact-yet → 整条链路静默失效。
-          if (!inWake()) {
+          //
+          // issue #34：这条判据以前只看「在不在叫醒窗口里」，不看这句话是在哪说的。
+          // 群聊那轮她调一次 growth_commit，就给群里多记一条 `seen:` —— 群友说一百句
+          // 也算「他来过」，冷落检测于是永远不触发（他一周没露面，面板还显示今天聊过）。
+          // AGENTS.md §7.2 第 2 条本来就要求「外客不动生命体征」，这里补上：
+          // 这条会话如果是群房，就当他在场这件事没发生过。
+          //
+          // 为什么只跳群房（2026-11-05 用户确认）：另外两处「窗口外的自己醒」——
+          // 换房前问她上一间还有没有话（home.js:753）、定时任务与 goal——
+          // 一个通常是在应他上一轮的话，一个分不出是不是在回他，所以照记。
+          // 要再收紧得先给每种叫醒打标记，不在 #34 这一刀里做。
+          const outsideWake = !inWake()
+          const inGroupRoom = outsideWake && (await readChannels(root).catch(() => []))
+            .some((r) => who.sessionId && r.sessionId === who.sessionId && r.scene === 'group')
+          if (outsideWake && !inGroupRoom) {
             await appendEvent(
               { type: 'meta', text: `seen:${new Date().toISOString()}` },
               { day: model.day, stage: model.stage, source: 'system' },

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

@@ -383,6 +383,10 @@ window.__ModuleLoader__.load({
       const [proactiveOn, setProactiveOn] = useState(false)
       const [proactiveMax, setProactiveMax] = useState(2)
       const [proactiveIdle, setProactiveIdle] = useState(6)
+      const [proactiveTools, setProactiveTools] = useState('')
+      const proactiveToolsTimer = useRef(null)
+      const [proactiveCompact, setProactiveCompact] = useState(true)
+      const [proactiveSeen, setProactiveSeen] = useState(false)
       // 2026-11-05（用户 m02634）：梦 / 主动性 / 兴趣 三个开关，默认全开。
       const [driveOn, setDriveOn] = useState(true)
       const [interestOn, setInterestOn] = useState(true)
@@ -448,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')
@@ -596,6 +604,9 @@ window.__ModuleLoader__.load({
             setProactiveOn(pr.enabled === true)
             setProactiveMax(Number(pr.maxPerDay ?? 2))
             setProactiveIdle(Number(pr.minIdleHours ?? 6))
+            setProactiveTools(Array.isArray(pr.sendTools) ? pr.sendTools.join(', ') : '')
+            setProactiveCompact(pr.foldSilent !== false)
+            setProactiveSeen(pr.idleCountsSeen === true)
           }
           setDriveOn(s.config?.drive?.enabled !== false)
           setInterestOn(s.config?.interest?.enabled !== false)
@@ -988,8 +999,14 @@ window.__ModuleLoader__.load({
       const saveOwnerCard = async () => {
         setBusy('owner'); setOwNote('')
         try {
-          const body = { mid: owMid, nickname: owName }
+          // 2026-11-06（用户反馈）：这三格原来是「一律原样提交」，于是只粘 cookie、两格
+          // 没填（或先清空了）的人，点一次保存就把 mid / 昵称覆写成空串 —— 昵称一空，
+          // mentionPrefix 就返回空串，评论里再也 @ 不出来。现在只提交填了的格子。
+          const body = {}
+          if (owMid.trim()) body.mid = owMid.trim()
+          if (owName.trim()) body.nickname = owName.trim()
           if (owCookie.trim()) body.cookie = owCookie.trim()
+          if (!Object.keys(body).length) { setOwNote('三格都是空的，没东西可存。'); setBusy(''); return }
           const r = await jpost('/owner', body)
           setOwNote(r.note || (r.ok ? '存下了。' : '没存上。'))
           setOwCookie('')
@@ -997,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 {
@@ -1329,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),
@@ -1336,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)
       }
 
       // 工具面：把限制的理由写给用户看，给一个总开关，另留一处额外放行口。
@@ -2051,7 +2103,9 @@ window.__ModuleLoader__.load({
               : rowTip('立场', '还没开始', '要等四个阶段（信任 / 自主 / 主动 / 整合）都走完，立场才开始产生。'),
           rowTip('最近的称呼', s.name ? s.name : '还没想好', '她自己决定怎么称呼你。这个不是设置项，改不了。'),
           rowTip('冷落', s.absenceDays > 0 ? `${s.absenceDays} 天` : '没有', '你多久没说话了。超过门槛她会记下「你不在」。'),
-          rowTip('互动计数', `说 ${s.counts.utterance} · 改口 ${s.counts.revise} · 拒绝 ${s.counts.refusal} · 重聚 ${s.counts.reunion}`, '说=她写过几句自己的判断（含留话）；改口=按照规则推翻历史认知并指明改的是哪条；拒绝=她明确登记拒绝过什么；重聚=久别之后她自己写下的感受。'),
+          // issue #32：`counts.utterance` 含对话行（flags 带 uncommitted），把它们减掉之后
+          // 才是「她自己写下、不是答他的话」的句数；那些行单列成「聊天」。
+          rowTip('互动计数', `说 ${Math.max(0, (s.counts.utterance ?? 0) - (s.counts.chat ?? 0))} · 改口 ${s.counts.revise} · 拒绝 ${s.counts.refusal} · 重聚 ${s.counts.reunion}${s.counts.chat ? ` · 聊天 ${s.counts.chat}` : ''}`, '说=她写过几句自己的判断（含留话）；改口=按照规则推翻历史认知并指明改的是哪条；拒绝=她明确登记拒绝过什么；重聚=久别之后她自己写下的感受。聊天=对话里她回你的话，单列，不算进「说」。'),
           s.quality ? h('div', { style: { marginTop: '4px', marginBottom: '2px' } },
             h('div', {
               style: { display: 'flex', gap: '8px', alignItems: 'baseline', fontSize: '13px', marginBottom: '5px' },
@@ -2144,14 +2198,14 @@ window.__ModuleLoader__.load({
               hint: '超过这么多天没说话，她会记下「你不在」。' }))),
         // 主动说话（0.8.1 本机实验）：只有 .dev 下才出现。频率是上限，不是任务——
         // 开关开着也不代表她每天都会说，说不说由她自己判断（见 lib/proactive.js）。
-        // 主动搭话（0.8.1 起，0.9.0 公开）：只留三件跟「开口」直接有关的事。
+        // 主动搭话（0.8.1 起，0.9.0 公开）：只留跟「开口」直接有关的事。
         // 劲儿与兴趣是另一套东西，各自一张卡——混在一张卡里，用户分不清哪一项在管什么。
         group('主动搭话',
           '她可以自己找你说话，不用你先开口。这里调的是上限：开着也可能好几天不说，那是她的判断，不是坏了。',
           h('div', { className: 'grid2' },
             Toggle({ label: '允许她主动开口', on: proactiveOn,
               onChange: (v) => { setProactiveOn(v); patchProactive({ enabled: v }) },
-              hint: '关掉就完全没有这个功能。' }),
+              hint: '关掉：她不会自己开一轮来找你。her_say 这个工具还在，她想说时仍可以用，只是不再由系统替她开这一轮。' }),
             Sel({ label: '一天最多几次', value: proactiveMax,
               onChange: (v) => { setProactiveMax(v); patchProactive({ maxPerDay: Number(v) }) },
               options: [0, 1, 2, 3, 4, 5, 6],
@@ -2160,7 +2214,22 @@ window.__ModuleLoader__.load({
             Num({ label: '你多久没说话，她才可能开口', value: proactiveIdle,
               onChange: (v) => { setProactiveIdle(v); patchProactive({ minIdleHours: Number(v) }) },
               min: 1, max: 24, unit: '小时',
-              hint: '越久没说话，她越可能开口（有上限）。刚聊完不会马上又来找你。' }))),
+              hint: '越久没说话，她越可能开口（有上限）。刚聊完不会马上又来找你。' }),
+            Text({ label: '她靠哪些工具把话发出去', value: proactiveTools, wide: true,
+              placeholder: '工具名，逗号分隔；不填就只认正文',
+              // 打字时不逐键保存：停手 700ms 再存，和这一页别的自动保存一样
+              onChange: (v) => {
+                setProactiveTools(v)
+                clearTimeout(proactiveToolsTimer.current)
+                proactiveToolsTimer.current = setTimeout(() => patchProactive({ sendTools: v.split(/[,，\s]+/).filter(Boolean) }), 700)
+              },
+              hint: '她写的字不会被插件自动发出去、要调工具才发得出去时才填，并且要放进下面的插件能力白名单。填了之后只有工具调成功才算她开了口。' }),
+            Toggle({ label: '没开口的那一轮折起来', on: proactiveCompact,
+              onChange: (v) => { setProactiveCompact(v); patchProactive({ foldSilent: v }) },
+              hint: '省上下文。上下文很大、靠缓存省钱时可以关：改历史会让缓存失效。' }),
+            Toggle({ label: '你来过也算打断安静', on: proactiveSeen,
+              onChange: (v) => { setProactiveSeen(v); patchProactive({ idleCountsSeen: v }) },
+              hint: '你只从聊天软件找她、她又不写正文时才开，不然你刚聊完她也觉得安静了很久。代价是你在这台机器上和别的 agent 说话也算。' }))),
         // 主观能动性：不是「定时叫她说话」，而是她心里慢慢攒的一股劲。
         group('主观能动性',
           '她心里会慢慢攒一股想动的劲：越久没自己动过、桌上越有值得看的东西，攒得越快。攒够了才会自己醒一次——不按钟点，也不是每天必须。',
@@ -2170,7 +2239,7 @@ window.__ModuleLoader__.load({
               hint: '关掉：她不会自己开一轮，只在你叫她、或者日程到点时才醒。已经发生的事不受影响。' }))),
         // 兴趣与惦记：她醒来时桌上摆的那几样东西。
         group('兴趣',
-          '她醒来的时候，桌上会摆几样她自己的东西：问过还没答案的问题、翻到过的旧句子、你回没回她留的那句话、最近总说到的那件事。这些只给她看，不会变成待办。',
+          '她醒来的时候，桌上会摆几样她自己的东西：她反复问起过的事、翻到过的旧句子、你回没回她留的那句话、最近总说到的那件事。这些只给她看，不会变成待办。关掉之后连旧句子也不再摆，她只会按时被叫醒。',
           h('div', { className: 'grid2' },
             Toggle({ label: '醒来时把这些摆出来', on: interestOn,
               onChange: (v) => { setInterestOn(v); patchGroup('interest', { enabled: v }) },
@@ -2240,6 +2309,8 @@ window.__ModuleLoader__.load({
           else setAskMsg(String(r?.why || '没答上。'))
         } catch (e) {
           setAskMsg(`没答上：${e.message}`)
+          // 多半是别的地方先答了：把列表刷新一下，别还留着这张卡
+          jget('/ask').then(setAsks).catch(() => {})
         }
       }
 
@@ -2517,15 +2588,21 @@ 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,
               hint: '就是 B 站个人主页地址里那串数字。' }),
             Text({ label: '要 @ 的 B 站昵称', value: owName, onChange: setOwName, placeholder: '评论里 @ 的就是这个名字', wide: true,
-              hint: '没填昵称就 @ 不出来——空的 @ 只是一串没人认领的字符。' }),
+              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 站登录',
           '她刷视频、发评论用的账号，建议放一个小号。没存也能看视频，只是不能说话。',
           // 两个入口：扫码是给人用的，粘贴是退路（扫码不顺利、或者想换个号）。
@@ -2536,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'
@@ -2551,7 +2628,7 @@ window.__ModuleLoader__.load({
                 qrNote ? h('span', { className: 'qrerr', style: { margin: 0 } }, qrNote) : null))
             : h('div', null,
               h('p', { className: 'hint', style: { margin: '0 0 8px' } },
-                'cookie 存好之后为隐私起见不再回显，输入框永远是空的。'),
+                'cookie 存好之后为隐私起见不再回显，输入框永远是空的——空着不代表没存上，上面那行「已存…」才是凭据。'),
               h('textarea', {
                 rows: 3,
                 value: owCookie,
@@ -2562,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',
@@ -2577,6 +2659,9 @@ window.__ModuleLoader__.load({
                   clearLogin()
                 },
               }, busy === 'owclear' ? '清除中…' : '清除登录')
+              : null,
+            ow?.hasCookie
+              ? h('span', { className: 'hint' }, '测试只验这份 cookie，不保存、也不动上面那两格。')
               : null)),
 
         // ---- 以前看了什么（视频观看历史，分页） ----
@@ -2658,7 +2743,7 @@ window.__ModuleLoader__.load({
           '一个侧栏会话聊到几百轮，上下文必然撑爆——不是变慢，是每轮都为几十万字付费，最后直接失败。',
           h('div', { className: 'grid2' },
             Num({ label: '聊满多少轮换新会话', value: rotateAfter, onChange: setRotateAfter, min: 0, max: 500, unit: '轮',
-              hint: '请在不断的循环中，找到能引发本质变化的唯一解。0 = 永不换。上下文占满后会将当前已形成的核心认知和初始信息，作为提示词带到新会话。' }),
+              hint: '请在不断的循环中，找到能引发本质变化的唯一解。0 = 永不换——那条会话会一直聊到宿主上下文撑不住为止，之后这一轮会直接失败（不会自动换）。换的时候会把当前已形成的核心认知和初始信息，作为提示词带到新会话。' }),
             Num({ label: '单次上下文限制（身份文档多少字）', value: docBudget, onChange: setDocBudget, min: 600, max: 4000, step: 100, unit: '字',
               hint: '超了按照规则遗忘部分认知/经历；「初始人格」和四条禁令不会遗忘。根据经历不同，部分认知可能会变成永久记忆不再遗忘。' }))),
 
@@ -2705,7 +2790,9 @@ window.__ModuleLoader__.load({
                   mem.sections?.voiceLast
                     ? h('div', { className: 'dim' }, `　最近读到：「${mem.sections.voiceLast.text}」${mem.sections.voiceLast.echoed ? '（她认下了）' : ''}`)
                     : null,
-                  h('div', null, `· 记下的事：${mem.events ?? 0} 条 · 日记 ${mem.diaries ?? 0} 篇`),
+                  // issue #32：口径同面板标题那行——含她读到的别人说法与开局起点，不只她写的。
+                  h('div', { title: '她自己写的判断、留话、日记，加上她读到并记下的别人说法和开局那份起点；不含系统后台记账。' },
+                    `· 记下的事：${mem.events ?? 0} 条 · 日记 ${mem.diaries ?? 0} 篇`),
                   h('div', null, `· 这条会话：${mem.session?.rotateAfter > 0
                     ? `${mem.session?.turns ?? 0} / ${mem.session.rotateAfter} 轮，满了自动换新会话`
                     : '不自动换'}`),
@@ -3311,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))
@@ -3321,6 +3409,8 @@ window.__ModuleLoader__.load({
           )
         } catch (e) {
           setOutingMsg(`没处理成：${e.message}`)
+          // 多半是别的地方先答了：刷新一下，别还留着这一行
+          refreshOuting()
         } finally {
           setOutingBusy(false)
         }
@@ -4082,7 +4172,14 @@ window.__ModuleLoader__.load({
 
       return h('div', { className: 'dfish', ref: (el) => { topEl = el } },
         h('h2', null, '大肥鱼'),
-        h('p', { className: 'sub' },
+        h('p', {
+          className: 'sub',
+          // issue #32：这个数字（counts.total = countEvents().real）从来不只是「她写的」——
+          // 她读到的别人说法、开局那份起点、日记、答你的话都在里面。以前文案写「她记下
+          // N 条」，跟面板上「记下的事」一起被当成了「她写了 N 条」，于是永远对不上。
+          // 口径不改（改 real 的定义会动事件流语义与一堆派生数字），把话说清楚。
+          title: '她自己写的判断、留话、日记，加上她读到并记下的别人说法和开局那份起点；不含系统后台记账（另计）。',
+        },
           s ? `第 ${s.day} / ${s.growthDays} 天 · ${s.stageName} · 她记下 ${s.counts.total} 条${s.counts.meta ? `，另有 ${s.counts.meta} 条系统记录` : ''}` : '读取中…'),
         err ? h('pre', { className: 'err' }, err) : null,
         note ? h('pre', { className: 'ok' }, note) : null,