@ssamurias/dsh-fish 0.9.0 → 0.9.2

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 定时器，不再有任何后台活动（不靠"记得关"）。
  *
@@ -16,32 +17,33 @@ import { join } from 'node:path'
 import { deriveSelf } from './derive.js'
 import { validateEvent } from './schema.js'
 import { readEvents, appendEvent, rootDir, ensureHer, paths, readJson } from './store.js'
-import { loadConfig, dateKey, inWindow, pickWakeTime } from './settings.js'
+import { loadConfig, dateKey, inWindow, pickWakeTime, updateConfig } from './settings.js'
 import { plan } from './generator.js'
 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 } from './comment.js'
+import { scanReplies, renderReplies, repliesScanDue, markRepliesSeen, REPLY_SHOW_MAX } from './comment.js'
 import { flushReport } from './report.js'
-import { talkSessionId } from './home.js'
+import { talkSessionId, homeStatus } from './home.js'
 import { refreshSelfDoc } from './selfdoc.js'
-import { setWakeSection, clearWakeSection, getWakeSection } from './identity.js'
+import { setWakeSection, clearWakeSection, getWakeSection, liveAgentOf } from './identity.js'
+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 { proactiveState, proactiveSection, recentMaterial, looseEnds, TOOL_ASK_NOTE } from './proactive.js'
-import { deliverWake, ensureSessionLive, WAKE_PING } from './deliver.js'
-import { followWake, planWakeCompaction, compactWake, looksLikeNothingSaid } from './compact.js'
+import { proactiveConfig, proactiveState, proactiveSection, recentMaterial, looseEnds, TOOL_ASK_NOTE } 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'
@@ -61,6 +63,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,18 +103,45 @@ 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。
+ *
+ * 为什么要有这一步（真机抓到）：`sessionController.prompt()` 在把消息**排进队列**时就
+ * resolve 了，模型还在后面慢慢想。之前紧接着就 flushReport，报告在她开口前 8 秒就写完，
+ * 于是 out/YYYY-MM-DD.md 永远显示「今天她什么都没说」——她其实说了，只是晚了。
  *
- * 坑（真机抓到）：`sessionController.prompt()` 在把消息**排进队列**时就 resolve 了，
- * 模型还在后面慢慢想。之前紧接着就 flushReport，报告在她开口前 8 秒就写完，
- * 于是 out/YYYY-MM-DD.md 永远显示"今天她什么都没说"——她其实说了，只是晚了。
+ * 坑（issue #36）：以前只认会话不认回合——同一会话里任何一个 turn/end 都算数。
+ * 手动「叫她一次」时她往往正开在别的一轮里（比如他刚发过话），宿主的 `agent.followup`
+ * 会把我们这条排进下一轮，于是**当前那一轮**先 turn/end，处境段（fish:wake）当场被清，
+ * 真正醒来那一轮反而什么都没有。
  *
- * 宿主的信号是 `session/event`，事件里 `type === 'turn/end'`。
- * 拿不到事件总线（单测/老宿主）时退回"等一会儿再写一次"，
- * 反正 flushReport 是幂等的重写，多写一次不会错。
+ * 现在的判据：监听挂上之后，必须先见到本条会话的 `turn/start`，之后的 `turn/end`
+ * 才算「我们这一轮说完了」；turn/start 之前来的 turn/end 属于上一轮，忽略。
+ * 拿不到事件总线（单测/老宿主）时退回原来的即时行为，反正就绪后写一次就够了，
+ * 而且 flushReport 是幂等的重写，多写一次不会错。
  */
 function watchTurnEnd(ctx, sessionId, done) {
   let fired = false
+  // 宿主没给事件总线：没有回合可认，退回「等一会儿就动手」的老行为。
+  const noBus = typeof ctx.on !== 'function'
+  let started = noBus
   const once = () => {
     if (fired) return
     fired = true
@@ -115,7 +150,8 @@ function watchTurnEnd(ctx, sessionId, done) {
   const off = ctx.on?.('session/event', (session, event) => {
     const id = session?.header?.id ?? session?.id
     if (id !== sessionId) return
-    if (event?.type === 'turn/end') once()
+    if (event?.type === 'turn/start') { started = true; return }
+    if (event?.type === 'turn/end' && started) once()
   })
   return { off, once, get fired() { return fired } }
 }
@@ -128,6 +164,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）：同一小时、同一原因只记一次。
@@ -161,6 +198,17 @@ export function startScheduler(ctx, deps = {}) {
     const t = busy.get(id)
     return t !== undefined && Date.now() - t < BUSY_STALE_MS
   }
+  // 别的插件知道她在忙（比如在打一局游戏），这个调度器不知道。它们可以
+  // `ctx.on('dsh-fish/busy', (sessionId) => true)`，不用知道这个包叫什么、装在哪。
+  // 监听要同步返回，只有 true 算忙。抛错、返回 Promise 都按不忙算；Promise 的拒绝要接住，
+  // 宿主把未处理的拒绝当致命错误，别人的一个监听不该把整个进程带走。
+  const busyElsewhere = (id) => {
+    try {
+      const r = ctx.bail?.('dsh-fish/busy', id)
+      if (typeof r?.then === 'function') r.then(undefined, (e) => log('dsh-fish/busy 监听拒绝', e?.message ?? e))
+      return r === true
+    } catch { return false }
+  }
   const waitIdle = async (id) => {
     const until = Date.now() + IDLE_WAIT_MS
     while (!disposed && isBusy(id) && Date.now() < until) await new Promise((r) => setTimeout(r, 2000))
@@ -187,8 +235,9 @@ export function startScheduler(ctx, deps = {}) {
     // 2026-11-04（用户 m01466）：把她的成长档案交给判定函数。
     // 之前这里是 `proactiveState({ config, events, now })` —— 它收不到 model，
     // 于是第 3 天和第 27 天算出来的概率一模一样（「自己开口的出口不该是恒温的」）。
-    // deriveSelf 在下面本来就要算一次，只是提前到判定之前。
-    const model = deriveSelf(events, { growthDays: config.growthDays })
+    // 关着的时候判定用不上 model，不算：tick 每分钟一次，deriveSelf 是同步的，
+    // 事件流长了会卡住主线程，而这个开关默认是关的。开着时和原来一样，先算再判定。
+    const model = proactiveConfig(config).enabled ? deriveSelf(events, { growthDays: config.growthDays }) : null
     const st = proactiveState({ config, events, now, model })
     if (!st.ok) {
       if (st.why && st.why !== proactiveSkip) {
@@ -215,7 +264,8 @@ export function startScheduler(ctx, deps = {}) {
     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 drv = driveOf({ events, now, stage: model.stage, desk: driveDesk })
+    const pc = proactiveConfig(config)
+    const drv = driveOf({ events, now, stage: model.stage, desk: driveDesk, seenCountsAsHeard: pc.idleCountsSeen })
     // 空桌不醒（2026-11-05，用户 m02937）：桌上什么都没有时，劲儿再满也不起——
     // 否则她只能回一句「没什么要说的」，既占额度又在对话里留一条噪音。
     if (!deskHasMaterial(driveDesk)) {
@@ -237,10 +287,19 @@ export function startScheduler(ctx, deps = {}) {
     if (!sc) return false
     const sessionId = await talkSessionId(ctx, { root, log })
     if (!sessionId) return false
+    // 她正忙时不投：处境段会挂在正在跑的那一轮上，那一轮结束又把它清掉，
+    // 真正的这一轮就只收到一个空格。过 5 分钟再看（定时叫醒那条路一直有这个判断）。
+    const elsewhere = busyElsewhere(sessionId)
+    if (elsewhere || isBusy(sessionId)) {
+      lastProbe = now - 25 * 60_000
+      const why = elsewhere ? '别的插件说她在忙（dsh-fish/busy）' : '她正忙'
+      if (proactiveSkip !== why) { proactiveSkip = why; log('proactive skip', why) }
+      return false
+    }
 
     const material = recentMaterial(events, { now })
     const loose = looseEnds(events, { now })
-    const text = proactiveSection({ now, state: st, material, loose })
+    const text = proactiveSection({ now, state: st, material, loose, sendTools: pc.sendTools, countSeen: pc.idleCountsSeen })
 
     const requestId = `proactive-${now}`
     // 这一轮她写的话不算他来过：唤醒时间窗开到 turn/end（投递只等入队，见 wakewin.js），
@@ -253,7 +312,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 })`，
@@ -262,14 +321,16 @@ 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：
       // 每次投递一个唯一值，命中之前一律当「还没开始」，所以早挂不会认错轮。
-      const follow = followWake(ctx, { rpcId: requestId, log })
+      const follow = followWake(ctx, { rpcId: requestId, log, sendTools: pc.sendTools })
 
       // 2026-11-04（用户 m00428）：投递换成正解 —— 自建 `source.kind='fish-wake'`
       // 的消息交给 `agent.followup()`。宿主把它画成一张默认收起的折叠条，
@@ -289,7 +350,7 @@ export function startScheduler(ctx, deps = {}) {
         // 没送进去就没有这一轮：处境和窗口当场收掉，监听也摘掉，
         // 不然要等到别的哪一轮结束才清，那一轮开头还挂着这次的处境（跟 wake() 失败时一样）
         try { follow.off() } catch { /* ignore */ }
-        clearWakeSection(gen)
+        clearWakeSection(gen, sessionId)
 
         releaseWake()
         try { watcher.off?.() } catch { /* ignore */ }
@@ -314,7 +375,12 @@ export function startScheduler(ctx, deps = {}) {
           const meta = { day: model.day, stage: model.stage, source: 'timer' }
           // 「没什么要说的」不是开口（2026-11-05，用户 m02937）：她写一句元话语
           // 交代「这轮没话说」，在文本界面上几乎不可避免；按静默记、折掉，别当一次开口。
-          const quiet = out.spoke !== true || looksLikeNothingSaid(out.said)
+          // 配了发送工具时正文到不了人，只认工具；没配时还是看正文
+          // 上游断流写成的那行红字也不是她开口（2026-11-06 真机看到的 `❌ [ACP] stream error`）
+          const broken = out.spoke === true && looksLikeStreamFailure(out.said)
+          const quiet = pc.sendTools.length > 0
+            ? out.toolSpoke !== true
+            : (out.spoke !== true || broken || looksLikeNothingSaid(out.said))
           if (!quiet) {
             await appendEvent({ type: 'meta', text: `proactive-turn:${dk}:${now}` }, meta, root).catch(() => {})
             log('proactive', `开了一次空手回合，她开口了（劲儿 ${drv.value.toFixed(2)}）`)
@@ -322,13 +388,17 @@ export function startScheduler(ctx, deps = {}) {
           }
           await appendEvent({ type: 'meta', text: `proactive-silent:${dk}:${now}` }, meta, root).catch(() => {})
           // 折叠只在拿到闭合区间时做：超时、或没认出那条 ping，out.endSeq 都是 -1。
-          const plan = out.endSeq >= 0
+          const plan = out.endSeq >= 0 && pc.foldSilent
             ? planWakeCompaction(out.events, { startSeq: out.startSeq, endSeq: out.endSeq, rpcId: requestId })
             : null
           // 一轮可能被宿主的投影切成几段：各段单独换，边界节点原样留着。
           let folded = 0
           if (plan) for (const run of plan.runs) if (await compactWake(out.session, run, { log })) folded += 1
-          const tail = out.spoke === true ? '，只说了句没什么要说的' : ''
+          const tail = broken ? '，这一轮上游断流了（那行报错不算她开口）'
+            : out.spoke !== true ? ''
+              // 配了发送工具时，只写正文是「没发出去」，不见得是没话说，这句可以写得很长。
+              // 也可能调了工具但失败了，所以不说「没调」
+              : pc.sendTools.length > 0 ? '，只写了正文，没发出去' : '，只说了句没什么要说的'
           log('proactive', folded > 0
             ? `醒了一次，没有开口${tail}（这一轮折成 ${folded} 行，盖住 ${plan.shadowed} 个节点）`
             : `醒了一次，没有开口${tail}（${out.ok ? '这轮没什么可折' : out.why}）`)
@@ -340,7 +410,7 @@ export function startScheduler(ctx, deps = {}) {
     } catch (err) {
       // 没送进去就没有这一轮：处境和窗口当场收掉，监听也摘掉，
       // 不然要等到别的哪一轮结束才清，那一轮开头还挂着这次的处境（跟 wake() 失败时一样）
-      clearWakeSection(gen)
+      clearWakeSection(gen, sessionId)
       releaseWake()
       try { watcher.off?.() } catch { /* ignore */ }
       throw err
@@ -383,11 +453,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()
 
@@ -405,11 +483,44 @@ export function startScheduler(ctx, deps = {}) {
         return
       }
 
+      // ---- 有人回她了吗（2026-11-06，用户 m01641）----
+      // 原来这里只有 wake() 拼正文时顺带扫一次：没被叫醒的那天就完全看不到回复，
+      // 而设置页那个「多久看一次有没有人回复」一直是个空旋钮（scanEveryMin
+      // 全仓没有消费者）。现在按那个间隔真去问一次，问到了就把那几句排队投给她。
+      // 投递用 queueNote：她醒着就立刻补进当前这条会话，没开着就等她下次打开。
+      try {
+        if (repliesScanDue(config?.comment, now)) {
+          const waiting = await scanReplies({ root, events, dateKey: dk }).catch(() => [])
+          // 无论有没有人回都记一次：不记的话每 30 秒就会重新问一遍 B 站（-412 就是这么撞出来的）。
+          await updateConfig({ comment: { lastScanAt: new Date(now).toISOString() } }, root).catch(() => {})
+          if (waiting.length) {
+            // 只递、只标前几条：标 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} 条），已经递过去。`)
+            }
+          }
+        }
+      } catch (err) {
+        log('comment', `扫回复失败：${err?.message ?? err}`)
+      }
+
       // ---- 主动说话（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))
       }
@@ -423,6 +534,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)) })
@@ -470,8 +584,9 @@ export function startScheduler(ctx, deps = {}) {
       // 轮换之后这里查的是旧会话忙不忙，新会话正说着话也照样插进去。
       const sid = (await readJson(join(paths(root).root, 'home.json'), null).catch(() => null))?.sessionId
         ?? deps.sessionId
-      if (sid && isBusy(sid)) {
-        const why = '她正在说话，等这一轮结束再叫'
+      const elsewhere = sid ? busyElsewhere(sid) : false
+      if (sid && (elsewhere || isBusy(sid))) {
+        const why = elsewhere ? '别的插件说她在忙（dsh-fish/busy），等一等再叫' : '她正在说话，等这一轮结束再叫'
         const next = shouldLogSkip(skipLogged, dk, now, why)
         if (next) { skipLogged = next; log('skip', why) }
         return
@@ -675,7 +790,13 @@ async function wake(ctx, root, model, config, decision, dk, log, deps = {}) {
   {
     try {
       const { events: evs } = await readEvents(root)
-      if (!dreamOn(evs, model.day).length) {
+      // 2026-11-06（issue #42）：「兴趣」关掉时不再摆旧句子。
+      // 原来 freeWakeFor 只要 tableText 非空就判成 table，而 tableText 根本不看 interest 开关——
+      // 于是「关掉摆东西」之后，每 6 小时还是会因为旧句子空醒一次，而且那一轮既不想一想、
+      // 也不给规则申请、也不给「今天到这里」：14 天里 14 次全是旧句子。
+      // 旧句子属于「桌上那几样东西」里的一样，跟着兴趣开关走才自洽。
+      const staleOn = config?.interest?.enabled !== false
+      if (staleOn && !dreamOn(evs, model.day).length) {
         const shownToday = evs.some((e) => e?.type === 'meta' && String(e.text ?? '').startsWith(`table:${dk}`))
         const [{ outings }, { possessions }] = await Promise.all([readOutings(root), readPossessions(root)])
         const tripSessions = new Set(
@@ -796,8 +917,13 @@ 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 才写），
     // 不在这儿重复。
@@ -937,10 +1063,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 定时器一起删掉了。
@@ -971,19 +1096,22 @@ async function wake(ctx, root, model, config, decision, dk, log, deps = {}) {
   }
 
   // 刷站那几十秒里她可能刚好开始了别的一轮（有人找她）。等那一轮说完再挂处境、再叫：
-  // watcher 认的是会话不是这一轮，挂早了会被那一轮的 turn/end 收走。
+  // 挂早了会被那一轮的 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 里的同一处注释。
-  // watcher 认的是会话不是这一轮，所以清的时候要带着自己挂上去时拿到的号。
+  // 清的时候要带着自己挂上去时拿到的号，别把别人后来挂的处境一起抹了。
   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 里一个字处境都没有」的一轮：
@@ -993,8 +1121,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: 处境是空的')
@@ -1079,7 +1207,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
       }
@@ -1088,16 +1216,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(() => {})
@@ -1125,12 +1253,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 }],
         },
       ],
     })
@@ -1139,7 +1269,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,7 +27,8 @@ 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, DREAM_BRIEF, PROACTIVE_BRIEF, SCHEDULE_BRIEF, DIARY_BRIEF, SLEEP_BRIEF } from './persona.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 { proactiveConfig } from './proactive.js'
 import { LOOK_BRIEF, WATCH_RULE } from './browse.js'
 import { activeCarry } from './home.js'
 import { activeGrants } from './unlock.js'
@@ -120,7 +121,7 @@ export async function continuityOf(root = rootDir(), now = Date.now()) {
  * @param {object} model deriveSelf 的结果
  * @returns {string}
  */
-export function renderSelfDoc(model, { 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 } = {}) {
   const head = [
     // 这里**故意不写**「由 dsh-fish 自动生成」这类话。
     // 这个文件会被宿主原样渲染进她的会话——她能看见每一行。
@@ -166,7 +167,7 @@ export function renderSelfDoc(model, { budget, carry, continuity, browse = true,
     ...(dream ? [DREAM_BRIEF, ''] : []),
     // 主动说话（2026-10-30，用户 m04610）：her_say 只在 .dev 下注册，
     // 说明书也只在同一个判据下挂——公开版不能让「她」以为有这个工具。
-    ...(proactive ? [PROACTIVE_BRIEF, ''] : []),
+    ...(proactive ? [proactiveBrief(sendTools), ''] : []),
     // 定时提醒（2026-10-30，用户 m04335 / m04504）：默认不放，只有用户把
     // schedule_create 加进白名单才挂——不然就是告诉她「你有这个工具」，伸手却没有。
     ...(schedule ? [SCHEDULE_BRIEF, ''] : []),
@@ -265,6 +266,7 @@ export async function writeSelfDoc(root = rootDir(), { log, exec, tenant } = {})
       // 梦（2026-10-30 m02837）与主动说话（m04610）：0.9.0 起公开，两处都恒为真。
       dream: true,
       proactive: true,
+      sendTools: proactiveConfig(config).sendTools,
       // 定时工具默认不放；用户在白名单里加了 schedule_create 才告诉他这条路通。
       schedule: (config?.tools?.allow ?? []).some((n) => String(n).trim() === 'schedule_create'),
     })

package/lib/selfupdate.js

@@ -137,7 +137,14 @@ export function profileDirOf(moduleUrl) {
   // 两种都要认得，否则从 0.8.9 之前装上来的用户会被当成"没有 profile → 开发版"而永远升不了级。
   for (const marker of [`/node_modules/${PKG}/`, `/node_modules/${LEGACY_PKG}/`]) {
     const i = file.lastIndexOf(marker)
-    if (i >= 0) return file.slice(0, i)
+    if (i < 0) continue
+    const base = file.slice(0, i)
+    // pnpm 的 isolated 布局（issue #43）：真身常在
+    // `<profile>/node_modules/.pnpm/@ssamurias+dsh-fish@0.9.1/node_modules/@ssamurias/dsh-fish/lib/...`，
+    // 直接截到 marker 会得到 `.pnpm/.../node_modules`，那里没有 package.json，
+    // 于是 kind 判成 missing、managed 变 false，下载按钮永远不出现。往上退到 profile 根。
+    const pnpm = base.indexOf('/node_modules/.pnpm/')
+    return pnpm >= 0 ? base.slice(0, pnpm) : base
   }
   return ''
 }

package/lib/settings.js

@@ -70,6 +70,11 @@ export const DEFAULTS = {
     gainPerHour: 0.05,    // 超过 minIdleHours 之后，每多一小时加多少
     maxChance: 0.6,       // 概率上限
     cooldownHours: 4,     // 两次之间至少隔多久
+    // 下面三项给「对话要靠工具才发得出去」的部署（比如宿主里另有插件把多个聊天接进这条会话，
+    // 再给她一个发送工具）。默认值和原来的行为一样。
+    sendTools: [],      // 这些工具调成功才算她开了口；空 = 只认正文
+    foldSilent: true,     // 没开口的一轮折成一行；一条会话用很久、上下文很大时可以关
+    idleCountsSeen: false, // 「他来过」（seen:）也算打断安静；她的对话不进事件流时要开
   },
 
   // 她"不想看"的东西（可追加，用户说以后还会加）