@ssamurias/dsh-fish 0.9.1 → 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 定时器，不再有任何后台活动（不靠"记得关"）。
  *
@@ -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'
@@ -39,10 +40,10 @@ 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 { 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'
@@ -62,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,6 +102,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 +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）：同一小时、同一原因只记一次。
@@ -286,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 })`，
@@ -295,10 +321,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 +350,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 +395,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 +410,7 @@ export function startScheduler(ctx, deps = {}) {
     } catch (err) {
       // 没送进去就没有这一轮：处境和窗口当场收掉，监听也摘掉，
       // 不然要等到别的哪一轮结束才清，那一轮开头还挂着这次的处境（跟 wake() 失败时一样）
-      clearWakeSection(gen)
+      clearWakeSection(gen, sessionId)
       releaseWake()
       try { watcher.off?.() } catch { /* ignore */ }
       throw err
@@ -422,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()
 
@@ -455,12 +494,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 +515,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 +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)) })
@@ -867,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 才写），
     // 不在这儿重复。
@@ -1008,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 定时器一起删掉了。
@@ -1045,17 +1099,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 +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: 处境是空的')
@@ -1151,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
       }
@@ -1160,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(() => {})
@@ -1197,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 }],
         },
       ],
     })
@@ -1211,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/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 })
       // 「醒来失败」「没有该问的事」正是这一块为什么什么都没做的原因，必须留下来，

package/lib/turns.js

@@ -54,6 +54,7 @@ import { refreshSelfDoc } from './selfdoc.js'
 import { growthDay, stageOf } from './derive.js'
 import { hearTurn } from './hear.js'
 import { stripToolMarkup, hasToolMarkup } from './markup.js'
+import { clearWakeSectionFor } from './identity.js'
 
 /**
  * 我们自己 prompt 进去的消息，rpcId 会带这些前缀。
@@ -240,6 +241,9 @@ function cut(s) {
   return t.length > TURN_TEXT_MAX ? t.slice(0, TURN_TEXT_MAX) + '…' : t
 }
 
+/** 已经挂过观察者的宿主上下文（同一进程只挂一次，见 registerTurns） */
+const TURNS_BOUND = new WeakSet()
+
 /**
  * 注册"侧栏轮数"观察者。
  *
@@ -252,6 +256,30 @@ export function registerTurns(ctx, deps = {}) {
   const log = deps.log ?? (() => {})
   if (typeof ctx?.on !== 'function') return () => {}
 
+  /**
+   * 2026-11-06（外部日志：被占用的实例照样往共享事件流里写 `seen:`）。
+   *
+   * 观测者以前是**无条件**写盘的：它看到「他来过」就 appendEvent，从不过问这个
+   * 家是不是自己的。于是同一个数据目录被两个实例开着时，只读那一侧也在写——
+   * 日志里那三条同一毫秒的 `seen:` 就是两个写者各写一遍。
+   *
+   * 这里和工具侧用同一道闸（tenant.js 的 guardWrite）：房主身份 ok===false 时
+   * 一句都不写。tenant 是**活引用**（占用权丢了会原地改写成 ok:false），
+   * 所以必须在每次写之前现查，不能在注册时查一次就完。
+   */
+  const tenant = deps.tenant ?? null
+  const writable = () => !(tenant && tenant.ok === false)
+
+  /**
+   * 同一份宿主上下文只挂一次。
+   *
+   * 2026-11-06：插件被同一个进程加载两遍时（两个入口 / bundles 里重复），
+   * 两个观察者各有各的节流记忆，同一条人话会写出两条同一毫秒的 `seen:`——
+   * 记账行一重复，事件流就再也不能当证据用。第二次注册直接交白卷。
+   */
+  if (TURNS_BOUND.has(ctx)) return () => {}
+  TURNS_BOUND.add(ctx)
+
   /** 正在等 turn/end 的那一轮：{ sessionId, msgs:[], sinceId, at } */
   let pending = null
   /** 正在异步认来源的那条人话（见 takeTurnEnd：事件跟得太紧时要等它） */
@@ -289,6 +317,8 @@ export function registerTurns(ctx, deps = {}) {
    * 非 HER_TYPES 的类型，写成 tool 会被 schema 悄悄拒掉。
    */
   async function markSeen() {
+    // 2026-11-06：写盘之前先过所有权闸门（被占用的实例一条都不许写）。
+    if (!writable()) return
     lastSeenAt = Date.now()
     await appendEvent(
       { type: 'meta', text: `seen:${new Date(lastSeenAt).toISOString()}` },
@@ -301,6 +331,16 @@ export function registerTurns(ctx, deps = {}) {
 
   /** 收到真人消息：只认"她住的那个会话"，并把这一轮开始前的事件 id 记下来 */
   async function onHuman(sessionId, data) {
+    if (!writable()) return
+    // 2026-11-06（用户报「叫醒之后她就不说话了」）：他一开口，上一次叫醒留下的
+    // 「处境」当场作废。
+    //
+    // 处境原本只该出现在**她自己醒的那一轮**里，靠 turn/end 撤。但 turn/end 不是
+    // 一定能认到（监听按会话挂、重启会丢、两个渠道挨得近时也会错号），那一段
+    // 「这一轮是你自己的，不用回应任何人；不想说就什么都别写」就留在 system prompt
+    // 里，接下来他说的每一句都带着它——她就只思考、不开口，而且连续多轮都这样。
+    // 人真的说话了，这段就不该还在；清得比 turn/end 早一步也不会出错。
+    try { clearWakeSectionFor(sessionId) } catch { /* ignore */ }
     const home = await homeStatus(root)
     if (!home.sessionId) return
     if (home.sessionId !== sessionId) {
@@ -385,7 +425,7 @@ export function registerTurns(ctx, deps = {}) {
 
   /** turn/end：结账 */
   async function settle(p) {
-    if (stopped) return
+    if (stopped || !writable()) return
     if (busy) {
       log('turns · 上一轮还没结完，这次不记')
       return
@@ -580,6 +620,7 @@ export function registerTurns(ctx, deps = {}) {
   return () => {
     stopped = true
     pending = null
+    TURNS_BOUND.delete(ctx)
     try {
       if (typeof off === 'function') off()
     } catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ssamurias/dsh-fish",
-  "version": "0.9.1",
+  "version": "0.9.2",
   "description": "养一条会自己长大的鱼：没有人格设置，通过事件流长大。她可以自己刷 B 站、会写日记给你看，四个阶段完成后才会开始有立场。状态库在 ~/.dsh-fish，不能删除记录。",
   "type": "module",
   "main": "lib/index.js",