@ssamurias/dsh-fish 0.8.9 → 0.9.1

package/lib/scheduler.js

@@ -16,7 +16,7 @@ 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'
@@ -29,28 +29,28 @@ 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 } 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 { devModeSync } from './devmode.js'
-import { proactiveState, proactiveSection, recentMaterial, looseEnds, TOOL_ASK_NOTE } from './proactive.js'
+import { proactiveConfig, proactiveState, proactiveSection, recentMaterial, looseEnds, TOOL_ASK_NOTE } from './proactive.js'
 import { deliverWake, ensureSessionLive, WAKE_PING } from './deliver.js'
-import { followWake, planWakeCompaction, compactWake } from './compact.js'
+import { followWake, planWakeCompaction, compactWake, looksLikeNothingSaid, looksLikeStreamFailure } from './compact.js'
 import { logLine } from './log.js'
 import { recordGrant } from './grant.js'
 import { readNotes, renderNotes } from './note.js'
 import { curiosityOf, renderEcho } from './curiosity.js'
 import { deskFor } from './desk.js'
-import { driveOf } from './drive.js'
-import { interestOf, renderInterest } from './interest.js'
+import { driveOf, deskHasMaterial } from './drive.js'
+import { interestOf, topicLabel } from './interest.js'
 import { lastLeaveAt, lastSeenAt } from './curiosity.js'
 import { dreamOn } from './dream.js'
-import { hoursSinceLastWake, staleLines, tableFor } from './dreamtable.js'
+import { hoursSinceLastWake, staleForDesk, staleLines, tableFor } from './dreamtable.js'
 import { freeWakeFor } from './freewake.js'
 import { readOutings, readPossessions } from './outing.js'
 
@@ -96,18 +96,27 @@ const DAY_END_CUE = '（今天到这里了。这一刻是我自己的。）'
 
 
 /**
- * 等这一次唤醒的回合真正结束。
+ * 等这一轮真说完：认准「我们自己排进去的那一轮」的 turn/end。
  *
- * 坑（真机抓到）：`sessionController.prompt()` 在把消息**排进队列**时就 resolve 了，
- * 模型还在后面慢慢想。之前紧接着就 flushReport，报告在她开口前 8 秒就写完，
- * 于是 out/YYYY-MM-DD.md 永远显示"今天她什么都没说"——她其实说了，只是晚了。
+ * 为什么要有这一步（真机抓到）：`sessionController.prompt()` 在把消息**排进队列**时就
+ * resolve 了，模型还在后面慢慢想。之前紧接着就 flushReport，报告在她开口前 8 秒就写完，
+ * 于是 out/YYYY-MM-DD.md 永远显示「今天她什么都没说」——她其实说了，只是晚了。
  *
- * 宿主的信号是 `session/event`，事件里 `type === 'turn/end'`。
- * 拿不到事件总线（单测/老宿主）时退回"等一会儿再写一次"，
- * 反正 flushReport 是幂等的重写，多写一次不会错。
+ * 坑（issue #36）：以前只认会话不认回合——同一会话里任何一个 turn/end 都算数。
+ * 手动「叫她一次」时她往往正开在别的一轮里（比如他刚发过话），宿主的 `agent.followup`
+ * 会把我们这条排进下一轮，于是**当前那一轮**先 turn/end，处境段（fish:wake）当场被清，
+ * 真正醒来那一轮反而什么都没有。
+ *
+ * 现在的判据：监听挂上之后，必须先见到本条会话的 `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
@@ -116,7 +125,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 } }
 }
@@ -162,6 +172,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))
@@ -179,12 +200,18 @@ export function startScheduler(ctx, deps = {}) {
    * 她可以选择开口，也可以什么都不做——不写任何「你应该」。
    */
   async function maybeProactive({ events, config, dk, now }) {
-    if (!devModeSync(root)) return false
+    // 2026-11-05（用户 m02634）：「主动性」有开关。关着 = 她不会自己攒劲儿开一轮；
+    // 日程唤醒与手动叫醒都不经过这里，照样能用。
+    if (config?.drive?.enabled === false) {
+      if (proactiveSkip !== '主动性关着') { proactiveSkip = '主动性关着'; log('proactive skip', '主动性关着') }
+      return false
+    }
     // 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) {
@@ -198,7 +225,7 @@ export function startScheduler(ctx, deps = {}) {
     lastProbe = now
     // ---- 劲儿（2026-11-05，用户 m02031）----
     // 用户的定案：把「什么时候开这一轮」从掷骰子换成攒劲儿。
-    //   底噪：每小时 0.12，攒到 0.8 想动一次，动完扣 0.55，两次至少隔 40 分钟；
+    //   底噪：每小时 0.12，攒到 0.8 想动一次，两次至少隔两小时；
     //   冲动：桌上有没答的问题 +0.06、有新句子 +0.04、他回了她留的话 +0.12（封顶 +0.3）；
     //   折扣：她上一次开口没人接，底噪 ×0.7（打扰成本，Horvitz）。
     // 这张桌子是**判据用的摘要**，不是正文那段（正文那段在 wake() 里现算现摆）。
@@ -210,7 +237,19 @@ 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 drv = driveOf({ events, now, stage: model.stage, desk: { gaps: gaps.length, stale: 0, echo: echoBack, favorite: interest.length > 0 } })
+    const driveDesk = { gaps: gaps.length, stale: 0, echo: echoBack, favorite: interest.length > 0 }
+    const pc = proactiveConfig(config)
+    const drv = driveOf({ events, now, stage: model.stage, desk: driveDesk, seenCountsAsHeard: pc.idleCountsSeen })
+    // 空桌不醒（2026-11-05，用户 m02937）：桌上什么都没有时，劲儿再满也不起——
+    // 否则她只能回一句「没什么要说的」，既占额度又在对话里留一条噪音。
+    if (!deskHasMaterial(driveDesk)) {
+      const why = `桌上没有可说的东西（劲儿 ${drv.value.toFixed(2)}）`
+      if (why !== proactiveSkip) {
+        proactiveSkip = why
+        log('drive', why)
+      }
+      return false
+    }
     if (!drv.ready) {
       if (drv.why && drv.why !== proactiveSkip) {
         proactiveSkip = `drive ${drv.value.toFixed(2)} · ${drv.why}`
@@ -222,10 +261,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），
@@ -254,7 +302,7 @@ export function startScheduler(ctx, deps = {}) {
 
       // 投递之前先把这一轮盯起来（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()`。宿主把它画成一张默认收起的折叠条，
@@ -297,22 +345,32 @@ export function startScheduler(ctx, deps = {}) {
             return
           }
           const meta = { day: model.day, stage: model.stage, source: 'timer' }
-          if (out.spoke === true) {
+          // 「没什么要说的」不是开口（2026-11-05，用户 m02937）：她写一句元话语
+          // 交代「这轮没话说」，在文本界面上几乎不可避免；按静默记、折掉，别当一次开口。
+          // 配了发送工具时正文到不了人，只认工具；没配时还是看正文
+          // 上游断流写成的那行红字也不是她开口（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)}）`)
             return
           }
           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 = broken ? '，这一轮上游断流了（那行报错不算她开口）'
+            : out.spoke === true ? '，只说了句没什么要说的' : ''
           log('proactive', folded > 0
-            ? `醒了一次，没有开口（这一轮折成 ${folded} 行，盖住 ${plan.shadowed} 个节点）`
-            : `醒了一次，没有开口（${out.ok ? '这轮没什么可折' : out.why}）`)
+            ? `醒了一次，没有开口${tail}（这一轮折成 ${folded} 行，盖住 ${plan.shadowed} 个节点）`
+            : `醒了一次，没有开口${tail}（${out.ok ? '这轮没什么可折' : out.why}）`)
         } catch (err) {
           log('proactive settle', err?.message ?? err)
         }
@@ -386,6 +444,31 @@ 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) {
+            const txt = renderReplies(waiting)
+            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)
+              log('comment', `有人回她了（${waiting.length} 条），已经递过去。`)
+            }
+          }
+        }
+      } catch (err) {
+        log('comment', `扫回复失败：${err?.message ?? err}`)
+      }
+
       // ---- 主动说话（0.8.1 本机实验，2026-10-30 用户 m04610）----
       // 它不是唤醒：不占 wakesPerDay，也不推成长事件。只在 .dev 下生效。
       // 开了就 return——这一趟由她自己决定说还是不说，不再叠一次醒一醒。
@@ -451,8 +534,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
@@ -653,10 +737,16 @@ async function wake(ctx, root, model, config, decision, dk, log, deps = {}) {
   // 旧句子：判「要不要空醒」要用渲染好的那段，摆桌子要的是原始行——一次算好两处都用。
   let staleRows = []
   let free = null
-  if (devModeSync(root)) {
+  {
     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(
@@ -693,7 +783,15 @@ async function wake(ctx, root, model, config, decision, dk, log, deps = {}) {
   // 顺序是刻意的：先看，再想。如果先出事件提示再塞素材，
   // 她就会先按模板说话、再拿素材硬套——那是模板，不是她。
   // 反过来（先看见世界的动静，再问她怎么想）才像一个人醒来的样子。
-  const look = await lookBeforeWake(root, model, config, dk, deps, log)
+  //
+  // 2026-11-05（用户 m01128）：摆料那一轮不摆世界。这一轮只该有一张桌子——
+  // 旧句子 + 「这一轮没有待办」。B 站动静与惦记清单都会替她提供「最像活的那件事」，
+  // 18:44 真机她就是挑了旧句子里唯一像活的一条去核对，没往梦里想。
+  // 手动「让她去刷 B 站」（forceBrowse）本来就指定了这一轮做什么，不跟着空醒一起收。
+  // 2026-11-05（用户 m02562）：刷站不再挂在唤醒上。所有醒来都只有桌子与世界之外的事，
+  // 想上网由她自己调工具（bili_*），不再由唤醒替她决定看什么。
+  const showWorld = false
+  const look = showWorld ? await lookBeforeWake(root, model, config, dk, deps, log) : { text: '', intro: '', picks: [] }
   if (look.text) {
     parts.push('', look.intro, '', look.text)
     // 带链接的清单（2026-10-23 用户提）：她能说出"有一条是一个人跑不起来了"，
@@ -723,25 +821,33 @@ async function wake(ctx, root, model, config, decision, dk, log, deps = {}) {
   // 交给 deskFor 并成一段，配额与去重都在那个纯函数里；回音是另一件事（他有没有来过），
   // 仍然单独一句话，不并进桌子。
   // 只摆**事实**：不派活、不写「你可以去想想」、不给任何数字——派活了就又变成任务清单。
-  // 和这一版的其余实验一样先只在 .dev 里生效；公开版等劲儿那一版接通后再开。
+  // 2026-11-05（用户 m02634）：「兴趣」有开关。关掉 = 桌子那几行（好奇/旧句子/回音）
+  // 一概不摆；缺工具那句仍留着，它不是活、是她世界里的常量。
   // 读失败绝不拖垮一次唤醒：她醒着这件事比桌上的东西重要。
-  if (devModeSync(root)) {
+  if (config?.interest?.enabled !== false) {
     try {
-      const { events: evc } = await readEvents(root)
-      // 兴趣（2026-11-05，用户 m02031）：反复出现的那件事排进同一张桌子，
-      // 不另起一段——「一张桌子」是 L 文档定下的约定。
-      const fav = renderInterest(interestOf(evc, now.getTime()))
-      const desk = deskFor({
-        gaps: curiosityOf(evc, now),
-        stale: staleRows,
-        free: !!free,
-        favorite: fav ? fav.replace(/^最近你总回到「|」这件事上。$/g, '') : '',
-        at: now,
-      })
-      if (desk) parts.push('', desk)
-      const echo = renderEcho(evc, now)
-      if (echo) parts.push('', echo)
+      // 摆料那一轮不摆桌子：这一轮只留旧句子（用户 m01128）。
+      {
+        const { events: evc } = await readEvents(root)
+        // 兴趣（2026-11-05，用户 m02031）：反复出现的那件事排进同一张桌子，
+        // 不另起一段——「一张桌子」是 L 文档定下的约定。
+        const favItem = interestOf(evc, now.getTime())[0]
+        const fav = favItem ? topicLabel(favItem.text) : ''
+        const desk = deskFor({
+          gaps: curiosityOf(evc, now),
+          // 摆料那一轮 tableText 已经把旧句子摆出来了，桌子别再摆第二遍
+          // （2026-11-05 真机 18:44：同三句原话出现了两次）。
+          stale: staleForDesk(tableText, staleRows),
+          free: !!free,
+          favorite: fav,
+          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)
@@ -936,13 +1042,14 @@ 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)
 
   // 这一轮她写的话不算他来过：唤醒时间窗开到 turn/end，不是开到入队（见 wakewin.js）。
   // turn/end 不来时跟处境一起由下面的兜底关；没送进去就在 catch 里关。
   // 处境代次（2026-11-04，用户 m01466）：见 maybeProactive 里的同一处注释。
-  // watcher 认的是会话不是这一轮，所以清的时候要带着自己挂上去时拿到的号。
+  // 清的时候要带着自己挂上去时拿到的号，别把别人后来挂的处境一起抹了。
   let gen = 0
   const releaseWake = holdWake()
   const watcher = watchTurnEnd(ctx, sessionId, () => { releaseWake(); void writeReport(); clearWakeSection(gen) })
@@ -1159,14 +1266,9 @@ export async function wakeNow(ctx, deps = {}) {
   const model = deriveSelf(events, { growthDays: config.growthDays })
   const dk = dateKey()
   const counts = { dateKey: dk, sent: 0, questions: 0, proactive: 0 }
-  // focus='browse'：设置页那个「让她去刷 B 站」按钮（**仅本机测试版**，2026-10-26）。
-  // 不走 plan()——plan 判的是「今天该不该醒」，而这个按钮是人工要求她醒一次去看站；
-  // 语气也别写成"任务"，她看到"去看一眼"会自己决定看不看。
-  const forcedBrowse = deps.focus === 'browse'
-  if (forcedBrowse) deps = { ...deps, forceBrowse: true }
-  let decision = forcedBrowse
-    ? { action: 'wake', prompt: '（现在，去看一眼 B 站首页在推什么。）', template: { id: 'manual-browse' } }
-    : plan(model, config, counts, events, { squeeze: gapSqueeze(gapSinceLastWake(events)) })
+  // 2026-11-05（用户 m02562）：「让她去刷 B 站」这个按钮砍掉了，
+  // 手动叫醒一律走 plan()，和定时那条一样。
+  let decision = plan(model, config, counts, events, { squeeze: gapSqueeze(gapSinceLastWake(events)) })
   const log = deps.log ?? (() => {})
   // 2026-11-04（用户 m01466）：手动叫醒也要认最小间隔。
   //

package/lib/selfcheck.js

@@ -18,7 +18,6 @@ import { readConfig, readEvents, readOwner } from './store.js'
 import { inWindow, dateKey } from './settings.js'
 import { detectFfmpeg } from './media.js'
 import { FISH_TOOLS, HER_TOOLS, blockedTools } from './restrict.js'
-import { devModeSync } from './devmode.js'
 
 const MIN_NODE_MAJOR = 18
 
@@ -225,8 +224,8 @@ export async function runChecks(o = {}) {
   // 于是公开版装完自检必然报红：「有 1 个工具没注册上：her_dream」——
   // 和 2026-10-28 那次 read_image 误报同一类错误（拿「名单」当「真装上」的反面，
   // 这次是拿「本机清单」当「公开版清单」）。判据与注册处同一份：`devModeSync`。
-  const dev = devModeSync(root)
-  const expected = dev ? FISH_TOOLS : FISH_TOOLS.filter((n) => n !== 'her_dream')
+  // 0.9.0 起 her_dream 也恒注册，清单就是清单本身。
+  const expected = FISH_TOOLS
   const notRegistered = T && typeof T.get === 'function' ? expected.filter((n) => !T.get(n)) : []
   // read_image 是宿主的工具，别人的机器上可能没有。
   // 2026-10-28：以前它只是跟在「手上的工具」后面一句附注，而且那一项还是绿的。

package/lib/selfdoc.js

@@ -26,9 +26,9 @@ import { promises as fs } from 'node:fs'
 import { join } from 'node:path'
 import { rootDir, paths, readEvents, readJson, writeAtomic, listDiary } from './store.js'
 import { loadConfig } from './settings.js'
-import { devModeSync } from './devmode.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'
@@ -121,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 自动生成」这类话。
     // 这个文件会被宿主原样渲染进她的会话——她能看见每一行。
@@ -167,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, ''] : []),
@@ -263,11 +263,10 @@ export async function writeSelfDoc(root = rootDir(), { log, exec, tenant } = {})
       // 2026-10-27（用户 m01371）：白名单里额外放行的工具要念给她听，
       // 否则「能不能在 QQ 上说话」她只能回一句不知道。
       extraTools: config?.tools?.allow ?? [],
-      // 梦（2026-10-30 m02837）：与工具注册同一个判据（.dev 文件 / DSH_FISH_DEV）。
-      // 公开版既没有 her_dream，也不该在身份里读到它。
-      dream: devModeSync(root),
-      // 主动说话（2026-10-30 m04610）：同样只在 .dev 下挂。
-      proactive: devModeSync(root),
+      // 梦（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'),
     })