@ssamurias/dsh-fish 0.9.1 → 0.9.3

package/lib/scheduler.js

@@ -5,7 +5,8 @@
  * （身份由 identity.js 以 system prompt 段承载、每轮现读，不拼进唤醒消息）。
  *
  * 三条安全线（B §7）：
- *   1. 定时器只是**提议**。任何一次唤醒失败都不重试、不阻塞下一分钟。
+ *   1. 定时器只是**提议**。唤醒失败不算今天的这一次，之后还会再试，但会隔开再试，同一天
+ *      最多试 WAKE_FAIL_MAX 次（wakeRetryBlocked）：事件流只能追加，不能每分钟写一行。
  *   2. 一天之内同一条事件模板不重复触发（once 靠 fired 标记，非 once 靠 daily 配额）。
  *   3. 停用插件 = dispose 定时器，不再有任何后台活动（不靠"记得关"）。
  *
@@ -22,14 +23,14 @@ import { findTemplate } from './events.js'
 import { offerPrompt, SLEEP_TODAY } from './persona.js'
 import { offerDueDay, pendingOffer, grantableRules } from './unlock.js'
 import { holdWake } from './wakewin.js'
-import { detectAbsence } from './absence.js'
+import { detectAbsence, lastAbsenceEvent } from './absence.js'
 import { createClient } from './bili.js'
 import { gather, browseCountToday, recordBrowse } from './browse.js'
 import { seenOn } from './whatseen.js'
 import { renderWatchList } from './history.js'
 import { fetchCover, coverLines } from './cover.js'
 import { riskState, browsePlan, noteRisk, isRiskCode } from './risk.js'
-import { scanReplies, renderReplies, repliesScanDue } from './comment.js'
+import { scanReplies, renderReplies, repliesScanDue, markRepliesSeen, REPLY_SHOW_MAX } from './comment.js'
 import { flushReport } from './report.js'
 import { talkSessionId, homeStatus } from './home.js'
 import { refreshSelfDoc } from './selfdoc.js'
@@ -38,14 +39,16 @@ import { queueNote, deliverQueued } from './sessionnote.js'
 import { awayNow, awayLine } from './outing.js'
 import { askInChat, picked } from './askinchat.js'
 import { restedToday, settleStaleAsks } from './ask.js'
-import { proactiveConfig, proactiveState, proactiveSection, recentMaterial, looseEnds, TOOL_ASK_NOTE } from './proactive.js'
-import { deliverWake, ensureSessionLive, WAKE_PING } from './deliver.js'
+import { proactiveConfig, proactiveState, proactiveSection, recentMaterial, looseEnds } from './proactive.js'
+import { deliverWake, ensureSessionLive, reviveIfBlank, WAKE_PING } from './deliver.js'
 import { followWake, planWakeCompaction, compactWake, looksLikeNothingSaid, looksLikeStreamFailure } from './compact.js'
 import { logLine } from './log.js'
-import { recordGrant } from './grant.js'
+import { recordGrant, GRANT_YES, GRANT_NO } from './grant.js'
 import { readNotes, renderNotes } from './note.js'
 import { curiosityOf, renderEcho } from './curiosity.js'
 import { deskFor } from './desk.js'
+import { wishesOf } from './wish.js'
+import { gapwallsOf } from './gapwall.js'
 import { driveOf, deskHasMaterial } from './drive.js'
 import { interestOf, topicLabel } from './interest.js'
 import { lastLeaveAt, lastSeenAt } from './curiosity.js'
@@ -62,6 +65,12 @@ const WAKE_TIMEOUT_MS = 5 * 60_000
 const REPORT_WAIT_MS = 90_000
 // 一天的第二次及以后的叫醒，离上一次至少隔这么久（见 nextWakeAt）
 const WAKE_MIN_GAP_MS = 45 * 60_000
+/** 一天最多试几次失败的叫醒。之后当天不再定时叫，手动叫不受影响。 */
+const WAKE_FAIL_MAX = 3
+/** 失败之后隔多久再试：第一次很快，时段快结束时只失败一次也不至于丢掉今天这一次。 */
+const WAKE_FAIL_GAPS_MS = [5 * 60_000, WAKE_MIN_GAP_MS]
+/** 手动叫醒失败只留记录，不算进定时的账：有人点了一下按钮，不该用掉今天定时的机会。 */
+const WAKE_FAIL_MANUAL = '手动 '
 // 她正在某一轮里时先等她说完，最多等这么久
 const IDLE_WAIT_MS = 10 * 60_000
 // turn/start 之后迟迟等不到 turn/end（宿主重启、事件丢了），超过这么久就不再当她在忙
@@ -95,6 +104,24 @@ const DAY_END_CUE = '（今天到这里了。这一刻是我自己的。）'
 
 
 
+/**
+ * 今天失败的叫醒是不是已经够多，或者刚失败过。账记在事件流里，重启也算数。
+ * @param {Array} events
+ * @param {string} dk 今天的日期键
+ * @param {number} now
+ */
+export function wakeRetryBlocked(events = [], dk = dateKey(), now = Date.now()) {
+  let n = 0
+  let last = 0
+  for (const e of events) {
+    if (e?.type !== 'meta' || !String(e.text ?? '').startsWith(`wakefail:${dk}`)) continue
+    if (String(e.text).startsWith(`wakefail:${dk} ${WAKE_FAIL_MANUAL}`)) continue
+    n += 1
+    last = Math.max(last, Date.parse(e.ts || '') || 0)
+  }
+  return n >= WAKE_FAIL_MAX || (last > 0 && now - last < WAKE_FAIL_GAPS_MS[Math.min(n, WAKE_FAIL_GAPS_MS.length) - 1])
+}
+
 /**
  * 等这一轮真说完：认准「我们自己排进去的那一轮」的 turn/end。
  *
@@ -139,6 +166,7 @@ export function startScheduler(ctx, deps = {}) {
   let lastTick = 0
   let running = false
   let disposed = false
+  let lastAbsenceKey = null
   let timer = null
   let wakeTimer = null
   // skip 日志去重（2026-10-28）：同一小时、同一原因只记一次。
@@ -237,7 +265,7 @@ export function startScheduler(ctx, deps = {}) {
     const leave = lastLeaveAt(events)
     const seen = lastSeenAt(events)
     const echoBack = !!(leave && seen && seen >= leave && now - leave <= 72 * 3600_000)
-    const driveDesk = { gaps: gaps.length, stale: 0, echo: echoBack, favorite: interest.length > 0 }
+    const driveDesk = { gaps: gaps.length, stale: 0, echo: echoBack, favorite: interest.length > 0, wish: wishesOf(events, { now }).length, wall: gapwallsOf(events, { now }).length }
     const pc = proactiveConfig(config)
     const drv = driveOf({ events, now, stage: model.stage, desk: driveDesk, seenCountsAsHeard: pc.idleCountsSeen })
     // 空桌不醒（2026-11-05，用户 m02937）：桌上什么都没有时，劲儿再满也不起——
@@ -286,7 +314,7 @@ export function startScheduler(ctx, deps = {}) {
     let gen = 0
     const watcher = watchTurnEnd(ctx, sessionId, () => {
       releaseWake()
-      clearWakeSection(gen)
+      clearWakeSection(gen, sessionId)
     })
     try {
       // 2026-11-05（用户 m03265）：原来这里是 `sc.create({ sessionId, cwd })`，
@@ -295,10 +323,12 @@ export function startScheduler(ctx, deps = {}) {
       // 现在先探活；探不通才退回建（老宿主没有 resolveAgent 时也走这条）。
       const live = await ensureSessionLive(sc, sessionId)
       if (!live.live) {
-        log('proactive: 会话探活没通过，退回新建一条', live.why ?? '')
-        await sc.create({ sessionId, cwd: await ensureHer(root) }).catch(() => {})
+        log('proactive: 会话探活没通过，看看能不能按原 id 唤回来', live.why ?? '')
+        // 2026-11-06（换房报告）：跑过 turn 的会话给不出原 id，裸 create 只会
+        // 另开一条空壳 —— 交给 reviveIfBlank 判，见 lib/deliver.js。
+        await reviveIfBlank(sc, sessionId, await ensureHer(root), (msg) => log(`proactive: ${msg}`)).catch(() => {})
       }
-      gen = setWakeSection(text)
+      gen = setWakeSection(text, sessionId)
 
       // 投递之前先把这一轮盯起来（2026-11-05，用户 m00803）。认领信号是 rpcId：
       // 每次投递一个唯一值，命中之前一律当「还没开始」，所以早挂不会认错轮。
@@ -322,7 +352,7 @@ export function startScheduler(ctx, deps = {}) {
         // 没送进去就没有这一轮：处境和窗口当场收掉，监听也摘掉，
         // 不然要等到别的哪一轮结束才清，那一轮开头还挂着这次的处境（跟 wake() 失败时一样）
         try { follow.off() } catch { /* ignore */ }
-        clearWakeSection(gen)
+        clearWakeSection(gen, sessionId)
 
         releaseWake()
         try { watcher.off?.() } catch { /* ignore */ }
@@ -367,7 +397,10 @@ export function startScheduler(ctx, deps = {}) {
           let folded = 0
           if (plan) for (const run of plan.runs) if (await compactWake(out.session, run, { log })) folded += 1
           const tail = broken ? '，这一轮上游断流了（那行报错不算她开口）'
-            : out.spoke === true ? '，只说了句没什么要说的' : ''
+            : out.spoke !== true ? ''
+              // 配了发送工具时，只写正文是「没发出去」，不见得是没话说，这句可以写得很长。
+              // 也可能调了工具但失败了，所以不说「没调」
+              : pc.sendTools.length > 0 ? '，只写了正文，没发出去' : '，只说了句没什么要说的'
           log('proactive', folded > 0
             ? `醒了一次，没有开口${tail}（这一轮折成 ${folded} 行，盖住 ${plan.shadowed} 个节点）`
             : `醒了一次，没有开口${tail}（${out.ok ? '这轮没什么可折' : out.why}）`)
@@ -379,7 +412,7 @@ export function startScheduler(ctx, deps = {}) {
     } catch (err) {
       // 没送进去就没有这一轮：处境和窗口当场收掉，监听也摘掉，
       // 不然要等到别的哪一轮结束才清，那一轮开头还挂着这次的处境（跟 wake() 失败时一样）
-      clearWakeSection(gen)
+      clearWakeSection(gen, sessionId)
       releaseWake()
       try { watcher.off?.() } catch { /* ignore */ }
       throw err
@@ -422,11 +455,19 @@ export function startScheduler(ctx, deps = {}) {
       // 放在 tick 最前面，因为 wake 的提示词要读 absenceDays；
       // 晚一步的话今天这次唤醒就用的是昨天的冷落结论。
       const absence = await detectAbsence(root)
+      const { events } = await readEvents(root)
       // 冷落条数变了 = 她对自己的看法变了，身份文件要跟着重写。
       // 不写的话那份 system prompt 段会一直停在上一次的值上（她"不知道自己被晾过"）。
-      if (absence?.written) await refreshSelfDoc(root, { log })
+      // 他回来了、天数涨了也要重写：不然她一边跟他聊，身份里还写着「他有 2 天没出现」。
+      // 身份里的天数从 absence 写下那一刻起算，和 detectAbsence 的不在同一时刻跳（absence
+      // 写得晚的时候），两个都要看，不然会把旧数重写一遍，身份比叫醒的提示词晚一天。
+      // 初值是 null，因为启动时已经写过一次，第一拍不用再写。
+      const lastAbsence = lastAbsenceEvent(events)
+      const daysSinceWritten = lastAbsence ? Math.floor((now - Date.parse(String(lastAbsence.ts ?? 0))) / 86_400_000) : 0
+      const absenceKey = `${absence?.why ?? ''}:${absence?.days ?? 0}:${daysSinceWritten}`
+      if (absence?.written || (lastAbsenceKey !== null && absenceKey !== lastAbsenceKey)) await refreshSelfDoc(root, { log })
+      lastAbsenceKey = absenceKey
 
-      const { events } = await readEvents(root)
       const { config } = await loadConfig(root)
       const dk = dateKey()
 
@@ -455,12 +496,16 @@ export function startScheduler(ctx, deps = {}) {
           // 无论有没有人回都记一次：不记的话每 30 秒就会重新问一遍 B 站（-412 就是这么撞出来的）。
           await updateConfig({ comment: { lastScanAt: new Date(now).toISOString() } }, root).catch(() => {})
           if (waiting.length) {
-            const txt = renderReplies(waiting)
+            // 只递、只标前几条：标 seen 的是「真摆到她眼前的」，不是「扫到的」。
+            // 标多了等于把没看见的悄悄吞掉；不标就会一直重复投（2026-11-06 用户报的 bug）。
+            const shown = waiting.slice(0, REPLY_SHOW_MAX)
+            const txt = renderReplies(shown)
             if (txt) {
               await queueNote(root, txt).catch(() => null)
               const h = await homeStatus(root).catch(() => null)
               const agent = h?.sessionId ? liveAgentOf(ctx, h.sessionId) : null
               if (agent) await deliverQueued(agent, root, { home: true }).catch(() => null)
+              await markRepliesSeen(root, shown, { dateKey: dk }).catch(() => 0)
               log('comment', `有人回她了（${waiting.length} 条），已经递过去。`)
             }
           }
@@ -472,8 +517,12 @@ export function startScheduler(ctx, deps = {}) {
       // ---- 主动说话（0.8.1 本机实验，2026-10-30 用户 m04610）----
       // 它不是唤醒：不占 wakesPerDay，也不推成长事件。只在 .dev 下生效。
       // 开了就 return——这一趟由她自己决定说还是不说，不再叠一次醒一醒。
+      //
+      // 2026-11-06（0.9.2 反馈）：主动性也要受「每天几点醒」约束。
+      // 她要是能在窗口外自己醒过来找他，这个设置就等于没设——
+      // 用户关掉的是「这个时段别来打扰」，不是「别按日程醒来但可以主动开口」。
       try {
-        if (await maybeProactive({ events, config, dk, now })) return
+        if (inWindow(config, new Date(now)) && await maybeProactive({ events, config, dk, now })) return
       } catch (err) {
         log('proactive failed', err?.message ?? String(err))
       }
@@ -487,6 +536,9 @@ export function startScheduler(ctx, deps = {}) {
       const counts = await todayCounts(events, dk)
       if (now < scheduled.at) return    // 还没到今天的落点
 
+      // 叫醒一直失败时（会话没了、宿主起不来）别每分钟再试一次，每次都往事件流写一行 wakefail。
+      if (wakeRetryBlocked(events, dk, now)) return
+
       const model = deriveSelf(events, { growthDays: config.growthDays })
       // 空档补偿只影响这一次挑选的冷却判断（见 gapSqueeze）
       const decision = plan(model, config, counts, events, { squeeze: gapSqueeze(gapSinceLastWake(events)) })
@@ -821,8 +873,13 @@ async function wake(ctx, root, model, config, decision, dk, log, deps = {}) {
   // 交给 deskFor 并成一段，配额与去重都在那个纯函数里；回音是另一件事（他有没有来过），
   // 仍然单独一句话，不并进桌子。
   // 只摆**事实**：不派活、不写「你可以去想想」、不给任何数字——派活了就又变成任务清单。
-  // 2026-11-05（用户 m02634）：「兴趣」有开关。关掉 = 桌子那几行（好奇/旧句子/回音）
-  // 一概不摆；缺工具那句仍留着，它不是活、是她世界里的常量。
+  // 2026-11-05（用户 m02634）：「兴趣」有开关。关掉 = 桌子那几行（好奇/旧句子/回音/
+  // 够不着的那件事）一概不摆。
+  // 2026-11-07（用户 m01602）：「缺工具就开口要」原来那句每轮常量的 TOOL_ASK_NOTE
+  // 撤掉了。它读两天就成了系统的吩咐，不是她的念头。现在换成 B + D：
+  //   B —— 真被守卫拦下的那一下，在 blockedTalk() 里补一句（lib/restrict.js）。
+  //   D —— 这件事攒进劲儿里（lib/drive.js 的 boostWish），攒够了这一轮才醒；
+  //        醒的时候它作为桌上一行出现（lib/wish.js + deskFor 的 wishes）。
   // 读失败绝不拖垮一次唤醒：她醒着这件事比桌上的东西重要。
   if (config?.interest?.enabled !== false) {
     try {
@@ -840,15 +897,16 @@ async function wake(ctx, root, model, config, decision, dk, log, deps = {}) {
           stale: staleForDesk(tableText, staleRows),
           free: !!free,
           favorite: fav,
+          // 够不着的那件事：她提过、手上没有的（用户 m01602）。
+          wishes: wishesOf(evc, { now: now.getTime() }),
+          // 撞过墙的那件事：她试过、手上没有的（用户 m00493 的 ②）。
+          walls: gapwallsOf(evc, { now: now.getTime() }),
           at: now,
         })
         if (desk) parts.push('', desk)
         const echo = renderEcho(evc, now)
         if (echo) parts.push('', echo)
       }
-      // 缺工具就开口要：每次醒来都摆这一句，不派活，只给路径。
-      // 摆料那一轮也留着——它不是活，是她世界里的常量（用户 m01128）。
-      parts.push('', TOOL_ASK_NOTE)
     } catch (err) {
       log('curiosity', err?.message ?? err)
     }
@@ -867,11 +925,16 @@ async function wake(ctx, root, model, config, decision, dk, log, deps = {}) {
     const events = (await readEvents(root).catch(() => ({ events: [] }))).events
     const waiting = await scanReplies({ root, events, dateKey: dk }).catch(() => [])
     if (waiting.length) {
-      const txt = renderReplies(waiting)
-      if (txt) parts.push('', txt)
+      const shown = waiting.slice(0, REPLY_SHOW_MAX)
+      const txt = renderReplies(shown)
+      if (txt) {
+        parts.push('', txt)
+        // 摆进叫醒消息就算提醒过了：不标的话，她没回就会每次叫醒都再投一遍。
+        await markRepliesSeen(root, shown, { dateKey: dk }).catch(() => 0)
+      }
     }
-    // 能说话这件事的说明在身份文档的「在网上说话」一节（开关打开时 selfdoc 才写），
-    // 不在这儿重复。
+    // 能说话这件事的说明在身份文档的「在网上说话」一节（关着时那节写「这会儿还说不出去」，
+    // P3，2026-11-07），不在这儿重复。
   }
 
   // 日记：**不再在叫醒消息里推**（2026-10-26，用户 m00928：「叫醒仅仅只是叫醒」）。
@@ -1008,10 +1071,9 @@ async function wake(ctx, root, model, config, decision, dk, log, deps = {}) {
   // 先探活，探不通才退回建一条。
   const live = await ensureSessionLive(sc, sessionId)
   if (!live.live) {
-    log('wake: 会话探活没通过，退回新建一条', live.why ?? '')
-    try {
-      await sc.create({ sessionId, cwd: herDir })
-    } catch { /* 已存在，继续用 */ }
+    log('wake: 会话探活没通过，看看能不能按原 id 唤回来', live.why ?? '')
+    // 同上（2026-11-06 换房报告）：只有宿主确实给不出这一条时才建。
+    await reviveIfBlank(sc, sessionId, herDir, (msg) => log(`wake: ${msg}`)).catch(() => {})
   }
 
   // 2026-11-04：`AbortController` 与那个 5 分钟 kill 定时器一起删掉了。
@@ -1045,17 +1107,19 @@ async function wake(ctx, root, model, config, decision, dk, log, deps = {}) {
   // 挂早了会被那一轮的 turn/end 收走（issue #36 之前 watcher 只认会话不认回合，
   // 现在它至少要见到我们自己这一轮的 turn/start 才算数，双保险）。
   if (typeof deps.waitIdle === 'function') await deps.waitIdle(sessionId)
+  if (deps.isDisposed?.()) return
 
   // 这一轮她写的话不算他来过：唤醒时间窗开到 turn/end，不是开到入队（见 wakewin.js）。
   // turn/end 不来时跟处境一起由下面的兜底关；没送进去就在 catch 里关。
   // 处境代次（2026-11-04，用户 m01466）：见 maybeProactive 里的同一处注释。
   // 清的时候要带着自己挂上去时拿到的号，别把别人后来挂的处境一起抹了。
   let gen = 0
+  // 先挂监听再开窗：ctx 已停用时 ctx.on 会抛，开了窗就再也关不上
+  const watcher = watchTurnEnd(ctx, sessionId, () => { releaseWake(); void writeReport(); clearWakeSection(gen, sessionId) })
   const releaseWake = holdWake()
-  const watcher = watchTurnEnd(ctx, sessionId, () => { releaseWake(); void writeReport(); clearWakeSection(gen) })
 
   // 处境走 system prompt 段；对话里只留一个空投递（她看到的是「有人来了」，不是剧本）。
-  gen = setWakeSection(wakeText)
+  gen = setWakeSection(wakeText, sessionId)
   // 2026-11-04（用户 m01466）：投递前的最后一道护栏。
   //
   // 真机事故里出现过「消息投出去了、system prompt 里一个字处境都没有」的一轮：
@@ -1065,8 +1129,8 @@ async function wake(ctx, root, model, config, decision, dk, log, deps = {}) {
   //
   // 治本是上面的最小间隔（不该有两次挨这么近的唤醒）；这里只是兜底：
   // 万一处境真的空了，宁可不叫，也别投一条空壳让她自己找台阶下。
-  if (!getWakeSection().trim()) {
-    clearWakeSection(gen)
+  if (!getWakeSection(sessionId).trim()) {
+    clearWakeSection(gen, sessionId)
     releaseWake()
     try { watcher.off?.() } catch { /* ignore */ }
     log('wake skipped: 处境是空的')
@@ -1151,7 +1215,7 @@ async function wake(ctx, root, model, config, decision, dk, log, deps = {}) {
       // 上一个调度器留下的窗口没关，下一轮 turn/end 之后 inWake() 仍是 true。
       if (deps.isDisposed?.()) {
         try { watcher.off?.() } catch { /* ignore */ }
-        clearWakeSection(gen)
+        clearWakeSection(gen, sessionId)
         releaseWake()
         return
       }
@@ -1160,16 +1224,16 @@ async function wake(ctx, root, model, config, decision, dk, log, deps = {}) {
         return
       }
       try { watcher.off?.() } catch { /* ignore */ }
-      if (!watcher.fired) clearWakeSection(gen)
+      if (!watcher.fired) clearWakeSection(gen, sessionId)
       releaseWake()
     }
     setTimeout(fallback, REPORT_WAIT_MS).unref?.()
   } catch (err) {
     // 这一次没起来，处境要立刻清掉，唤醒时间窗也关上。
-    clearWakeSection(gen)
+    clearWakeSection(gen, sessionId)
     releaseWake()
     await appendEvent(
-      { type: 'meta', text: `wakefail:${dk} ${String(err?.message ?? err).slice(0, 120)}` },
+      { type: 'meta', text: `wakefail:${dk} ${deps.manual ? WAKE_FAIL_MANUAL : ''}${String(err?.message ?? err).slice(0, 120)}` },
       { day: model.day, stage: model.stage, source: 'timer' },
       root,
     ).catch(() => {})
@@ -1197,12 +1261,14 @@ async function askOfferInChat(ctx, root, { sessionId, offer, log = () => {} } =
   try {
     const r = await askInChat(ctx, {
       sessionId,
+      root,
+      cardId: `grant:${offer.id}`,
       questions: [
         {
           id: 'grant',
           header: '大肥鱼想申请一件事',
           question: `她想试试「${offer.title}」。不是现在就要，是想问问你。`,
-          options: [{ label: '可以' }, { label: '这次不行' }],
+          options: [{ label: GRANT_YES }, { label: GRANT_NO }],
         },
       ],
     })
@@ -1211,7 +1277,7 @@ async function askOfferInChat(ctx, root, { sessionId, offer, log = () => {} } =
       return
     }
     const said = picked(r.answers, 'grant')
-    const verdict = said === '可以' ? 'approve' : said === '这次不行' ? 'reject' : ''
+    const verdict = said === GRANT_YES ? 'approve' : said === GRANT_NO ? 'reject' : ''
     if (!verdict) return
     const w = await recordGrant(root, { offerId: offer.id, rule: offer.rule, verdict })
     if (!w.ok) log('offer grant failed', w.error)

package/lib/schema.js

@@ -167,6 +167,24 @@ export function tsMs(ev) {
   return Number.isFinite(t) ? t : 0
 }
 
+/**
+ * 这条事件算不算「他来过」的证据（2026-11-06，issue #49 的时钟盲点）。
+ *
+ * `meta seen:` 是主证据（turns.js 结账时写），`heard` 是兜底（侧栏聊天不写
+ * seen 的那段时间只有它）。放在 schema 里是为了让 absence.js 与 derive.js
+ * 共用同一份判定，别再各抄一遍——两处口径一旦分叉，就会出现「absence 认为
+ * 他回来了、persona 还在念 N 天」那种自相矛盾（issue #24 的老毛病）。
+ *
+ * 不认 `utterance`：定时唤醒也会让她写 utterance，那不算他来过。
+ */
+export function isContactEvent(e) {
+  if (e?.type === 'heard') return Number.isFinite(Date.parse(String(e.ts ?? '')))
+  if (e?.type !== 'meta') return false
+  const t = String(e.text ?? '')
+  if (!t.startsWith('seen:')) return false
+  return Number.isFinite(Date.parse(t.slice(5).trim()))
+}
+
 /** 从 id 反解时间（观测台排序用，不依赖 ts 字段） */
 export function idTime(id) {
   const body = String(id).replace(/^ev_/, '').slice(0, 10)

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/status.js

@@ -71,6 +71,11 @@ export function deriveStatus({ events = [], config = {}, now = new Date() } = {}
     if (Number.isFinite(at)) plannedWakeAt = at
   }
 
+  // 2026-11-06（0.9.1 反馈）：`quiet:` 是「落点到了，但没有可出的事件」，
+  // 不是「今天不会醒了」——quiet 之后冷却到期还会真醒（11-05 就是这样）。
+  // 所以它能解释「为什么没醒」，但不能用「今天」这种封死的说法。
+  const quietToday = today.some(({ e }) => e?.type === 'meta' && String(textOf(e) ?? '').startsWith(`quiet:${dk}`))
+
   // ---- 把今天切成"醒来块"：每个 wake: 是起点，动作挂到它下面 ----
   const blocks = []
   // chat（issue #32）：对话里她说的那些行。它们**不是**她在这一轮里主动做的事——
@@ -123,7 +128,10 @@ export function deriveStatus({ events = [], config = {}, now = new Date() } = {}
         continue
       }
       if (dayMarker(text, 'quiet', dk) !== null) {
-        push(t, 'quiet', '醒了，但今天没有该问的事')
+        // 没有 wake: 就没有「醒」这回事。旧文案「醒了，但今天没有该问的事」
+        // 会在时间线上凭空多出一次醒来，还和状态卡「还没醒」互相打脸。
+        // 「暂时」也不用「今天」：quiet 不封当天，冷却到期后她照样会醒。
+        push(t, 'quiet', '到点了，暂时没有可出的事件')
         continue
       }
       if (dayMarker(text, 'unrecorded', dk) !== null) continue
@@ -170,7 +178,9 @@ export function deriveStatus({ events = [], config = {}, now = new Date() } = {}
     const done = b.actions.filter((a) => a.kind !== 'quiet' && a.kind !== 'fail' && a.kind !== 'chat')
     b.idle = done.length === 0
   }
-  counts.idleWakes = blocks.filter((b) => b.idle).length
+  // 只有真醒过的块才算「醒着但没做」：没有 wake: 的那块（quiet / 他说话时插的几句）
+  // 根本不是一次醒来。以前它被算进 idleWakes，于是 wakes=0 而 idleWakes=1。
+  counts.idleWakes = blocks.filter((b) => b.wake !== null && b.idle).length
 
   // ---- 当前状态 ----
   const lastAct = today.length ? today[today.length - 1] : null
@@ -219,7 +229,9 @@ export function deriveStatus({ events = [], config = {}, now = new Date() } = {}
     const mins = plannedWakeAt ? Math.round((plannedWakeAt - nowMs) / 60_000) : null
     detail = plannedWakeAt && plannedWakeAt > nowMs
       ? `约 ${new Date(plannedWakeAt).toTimeString().slice(0, 5)} 会睡醒${mins !== null && mins >= 0 ? `（还有 ${mins} 分钟）` : ''}`
-      : '今天已经到点，但还没醒'
+      : (quietToday
+        ? '到点了，暂时没有可出的事件，还没醒'
+        : '今天已经到点，但还没醒')
   } else {
     phase = 'asleep'; label = '沉在水底'
     detail = plannedWakeAt && plannedWakeAt > nowMs
@@ -241,6 +253,16 @@ export function deriveStatus({ events = [], config = {}, now = new Date() } = {}
   const timeline = []
   for (const b of blocks) {
     const hhmm = new Date(b.at).toTimeString().slice(0, 5)
+    // 没有 wake: 的块不属于任何一次醒来（orphan）。以前拿当天第一条事件的时间
+    // 当块头，于是一天没醒过也会冒出「06:15 醒了，在发呆」（0.9.1 反馈）。
+    // 这些动作照原样列出来就好，别替她补一句「醒了」。
+    if (b.wake === null) {
+      for (const a of b.actions) {
+        const h2 = new Date(a.at).toTimeString().slice(0, 5)
+        timeline.push({ at: new Date(a.at).toISOString(), kind: a.kind, text: `${h2} ${a.text}` })
+      }
+      continue
+    }
     if (b.idle) {
       timeline.push({ at: new Date(b.at).toISOString(), kind: 'idle', text: `${hhmm} 醒了，在发呆`, idle: true })
       // 「醒来失败」「没有该问的事」正是这一块为什么什么都没做的原因，必须留下来，