@ssamurias/dsh-fish 0.9.0 → 0.9.1

package/lib/dreamtable.js

@@ -13,10 +13,14 @@
  * 三条边界（沿用 dream.js 的四条硬约束）：
  *   - 只用她自己说过的话（utterance / revise / reunion / narration / refusal），
  *     别人的话、系统记录一律不进；refs 的合法性因此天然满足。
+ *     只留证的也不进（isProofOnly）：没认领的聊天行不是「写下的」，
+ *     想改自己的话不算她的判断（derive.js 同样不算信念）。
  *   - 出门/请神那几趟写下的事件不摆（与 writeDream 的拒绝规则同源）。
  *   - 只陈述事实，不给台词、不派活：不出现「梦」「记一句」「你可以」。
  */
 
+import { isProofOnly } from './derive.js'
+
 /** 一句话要淡多久才值得被摆出来。太新的还热着，太旧的可能她已经不认了。 */
 export const STALE_MIN_DAYS = 7
 export const STALE_MAX_DAYS = 30
@@ -65,6 +69,7 @@ export function staleLines(events = [], opts = {}) {
   const rows = []
   for (const e of events) {
     if (!HER_WORDS.has(e?.type)) continue
+    if (isProofOnly(e)) continue
     if (trips.has(String(e?.sessionId ?? ''))) continue
     const t = Date.parse(e?.ts ?? '')
     if (!Number.isFinite(t)) continue
@@ -107,12 +112,18 @@ export function clipLine(text, max = LINE_CLIP) {
 export function renderTable(rows = [], { gapHours = 0 } = {}) {
   const list = (Array.isArray(rows) ? rows : []).filter((r) => r && r.id && String(r.text ?? '').trim())
   if (list.length < TABLE_MIN) return ''
-  const head = gapHours >= 1 ? `这次隔了 ${Math.round(gapHours)} 个小时。` : ''
+  // 2026-11-06（issue #42）：原来写「这次隔了 N 个小时」，读起来像「她睡了 N 小时」。
+  // hoursSinceLastWake 只数 `wake:`，中间她可能一直在跟人说话、开过好几轮。
+  // 改成只说它真算的那件事：距上一次醒来多久。
+  const head = gapHours >= 1 ? `距你上次醒来，隔了 ${Math.round(gapHours)} 个小时。` : ''
   const lines = list.slice(0, TABLE_MAX).map((r) => {
     const when = shortDay(r.ts)
     return `- 「${clipLine(r.text)}」${when ? ` · ${when}` : ''} · ${r.id}`
   })
-  return [head, '你写下的几行字还摊在那儿，这些天再没被提起过：', '', ...lines]
+  // 2026-11-06（issue #42）：原来后半句写「这些天再没被提起过」。判据其实只是
+  // 「之后有没有事件 refs 指回它」——她闲聊时提过一句但没有 refs，就仍然会被说成「没提起过」。
+  // 这句是给她读的，不该撒谎，所以把那半句去掉，只陈述摆在那儿这件事。
+  return [head, '你写下的几行字还摊在那儿：', '', ...lines]
     .filter((x) => x !== '')
     .join('\n')
 }

package/lib/drive.js

@@ -95,6 +95,17 @@ function firstAt(events) {
   return first
 }
 
+/** 他最近一次来过（`meta seen:`）的时刻。 */
+function lastSeenLine(events) {
+  let last = 0
+  for (const e of events) {
+    if (e?.type !== 'meta' || !String(e.text ?? '').startsWith('seen:')) continue
+    const ts = tsOf(e)
+    if (ts > last) last = ts
+  }
+  return last
+}
+
 /** 她最近一次真的开口的时刻。 */
 function lastSpokeAt(events) {
   let last = 0
@@ -120,7 +131,7 @@ function lastSpokeAt(events) {
  * @returns {{value:number, threshold:number, ready:boolean, why:string,
  *   hoursSince:number, boosts:number, damp:number}}
  */
-export function driveOf({ events = [], now = Date.now(), desk = null, stage = 1 } = {}) {
+export function driveOf({ events = [], now = Date.now(), desk = null, stage = 1, seenCountsAsHeard = false } = {}) {
   const base = { value: 0, threshold: DRIVE.threshold, ready: false, why: '', hoursSince: 0, boosts: 0, damp: 1, speed: DRIVE.growthPerHour }
   // 动过就从那次算；一次都没动过，就从她出生那一刻算（不能永远停在 0.00）。
   const last = lastActionAt(events) || firstAt(events)
@@ -134,7 +145,8 @@ export function driveOf({ events = [], now = Date.now(), desk = null, stage = 1
 
   // 上次开口没人接：底噪打折（不是惩罚，只是「说了也没人接」这件事本身的重量）。
   const spoke = lastSpokeAt(events)
-  const heard = lastHeardAt(events)
+  // 对话不进事件流的部署（proactive.idleCountsSeen）：他来过就算接了，否则这个折扣永远解不掉
+  const heard = Math.max(lastHeardAt(events), seenCountsAsHeard ? lastSeenLine(events) : 0)
   const damp = spoke && heard < spoke ? DRIVE.dampUnanswered : 1
 
   const gaps = Math.max(0, Number(desk?.gaps) || 0)

package/lib/freewake.js

@@ -13,7 +13,7 @@
  *   - table：旧句子要摆出来的那一次（lib/dreamtable.js 的三道门已经判过）。
  *   - think：**兜底**（2026-11-05，用户 m02008 拍板）。原来按「每 3 天一次」的日历开，
  *     现在改成：过去 `QUIET_DAYS` 天里她一件自发的事都没有（没有 utterance /
- *     narration / dream / 主动开口），才由日历补一次。劲儿正常工作时不该再出现
+ *     narration / dream / 主动开口；聊天回合补写的 uncommitted 行不算），才由日历补一次。劲儿正常工作时不该再出现
  *     「同一天醒两次」，所以这一条只在劲儿长期趴着时生效。
  *
  * 0.9.0 起公开：所有机器都能空醒；想关掉把 config.memory.thinkEveryDays 设 0。
@@ -45,6 +45,9 @@ export function quietDays(events = [], now = Date.now()) {
       continue
     }
     if (!HER_TYPES.includes(e?.type)) continue
+    // 聊天回合里的回复不是她自己动的，否则每天有人聊，这条兜底就永远等不到。
+    // selfmod 不跳：想改自己也是她自己动过，这里问的不是算不算信念。
+    if (Array.isArray(e.flags) && e.flags.includes('uncommitted')) continue
     const ts = tsMs(e)
     if (Number.isFinite(ts) && ts > last) last = ts
   }

package/lib/home.js

@@ -197,8 +197,16 @@ export async function ensureTalkSession(ctx, opts = {}) {
  * 现在先把「归档的那条」和「这个工作区里另外的活会话」分开判断：只要还有一条
  * 没归档的，就认它，而不是让整个家停摆。
  *
- * 取最后一条（宿主按创建顺序往 sessionIds 里追加，末尾即最近那条），但不做别的假设：
- * 拿不到 registry、sessionIds 不是数组、全是归档的，都退回空串，由调用方按原样拒绝。
+ * 取最前面那条（宿主建会话时是 `sessionIds: [新id, ...旧的]`，往**前**插，
+ * 所以头部才是最新那条），但不做别的假设：拿不到 registry、sessionIds 不是数组、
+ * 全是归档的，都退回空串，由调用方按原样拒绝。
+ *
+ * issue #33：这里以前取 `live[live.length - 1]`，注释还写着「宿主按创建顺序往
+ * sessionIds 里追加」——方向反了。结果是当前会话被归档、同一工作区还有别的活会话时，
+ * 认回来的是**最旧**那条，她于是坐进一条早就没在用的对话。
+ * 需要提醒的是：用户在侧栏拖动过顺序时 `live[0]` 是列表最上面那条，未必就是最新；
+ * 真要按时间严格排序，得问 `sessionController.list()`（`sessionListed` 那条路）。
+ * 这里只修「明显反了」的方向，不对侧栏顺序做额外假设。
  */
 function pickLiveSession(reg, wsId, avoid = '') {
   try {
@@ -208,7 +216,7 @@ function pickLiveSession(reg, wsId, avoid = '') {
     const live = ids
       .map((id) => String(id ?? ''))
       .filter((id) => id && id !== avoid && !archived.includes(id))
-    return live.length ? live[live.length - 1] : ''
+    return live.length ? live[0] : ''
   } catch { return '' }
 }
 
@@ -684,6 +692,35 @@ export const LAST_WORDS_WAIT_MS = 60_000
  */
 export const WAKE_VERIFY_MS = 12_000
 
+/**
+ * 换会话失败之后多久再试（2026-11-06）。
+ *
+ * 结账那条路上每次人说话都会 bumpTurns，`turns` 到了线就试着换。换失败时
+ * `turns` 不归零（这是对的：屋子确实还没换），于是下一轮又会试——宿主真
+ * 建不出会话时就成了每回一句话都重试一次。这里记下失败的时刻，冷却期内
+ * 直接跳过，不再打扰宿主，也不再往对话里发东西。
+ */
+export const ROTATE_RETRY_MS = 5 * 60_000
+
+/**
+ * 记一笔「这次没换成」。只写 home.json 的两个字段，任何失败都吞掉：
+ * 记不下来顶多是下次不回退避，不能让记账本身把错误放大。
+ */
+async function noteRotateFail(root, why) {
+  const at = new Date().toISOString()
+  try {
+    await mutateHome(async () => {
+      const fresh = (await readJson(homeFile(root), null)) ?? {}
+      await writeAtomic(
+        homeFile(root),
+        JSON.stringify({ ...fresh, rotateFailAt: at, rotateFailWhy: String(why ?? '').slice(0, 160) }, null, 2),
+      )
+    })
+  } catch {
+    /* 记不下来就算了 */
+  }
+}
+
 /** 她说「不用」的各种说法。命中就当没留。 */
 const DECLINE_RE = /^(不用|不想留|不想|不留|不了|算了|没事|没有|无|no|nope)[。.!！…\s]*$/i
 
@@ -854,24 +891,65 @@ async function rotateTalkSessionOnce(ctx, { root = rootDir(), wsId, title = TITL
     log?.(`换会话跳过：这次要换的是 ${fromId}，屋子已经指向 ${old}`)
     return { ok: true, sessionId: old, old: String(saved.rotatedFrom ?? ''), skipped: true }
   }
+  // 2026-11-06：建会话失败后冷却一段时间再试。
+  // 不冷却的话，结账每轮都会走到这里：`turns` 没清零，下一轮结账又到点，
+  // 于是每回一句话都重试一次（旧版还会每次都先问一遍「要不要留话」，见 2.5 步）。
+  // 宿主建不出会话多半是这类问题要待一会儿才好，5 分钟够它缓过来，也不至于
+  // 让屋子永远卡在旧会话里。
+  const failAt = Date.parse(String(saved.rotateFailAt ?? ''))
+  if (Number.isFinite(failAt) && Date.now() - failAt < ROTATE_RETRY_MS) {
+    return {
+      ok: false,
+      sessionId: '',
+      cooled: true,
+      why: `上次没换成（${String(saved.rotateFailWhy ?? '原因不明').slice(0, 80)}），${Math.ceil((ROTATE_RETRY_MS - (Date.now() - failAt)) / 60_000)} 分钟后再试`,
+    }
+  }
+
   // 2026-11-03（issue #19）：原来 `new Date().toISOString().slice(0,10)` 取的是 **UTC 日期**，
   // 东八区晚上 8 点之后换会话，旧会话会被改名成「…·昨天的日期 之前」.
   // dateKey() 用的是 getFullYear/getMonth/getDate，本地钟。
   const when = stamp ?? dateKey()
 
+  // 1) 旧会话改名留档。失败不影响后面（改不了名也还是那条会话）。
+  if (old && typeof sc.rename === 'function') {
+    await sc.rename({ sessionId: old, title: `${title}·${when} 之前` }).catch(() => {})
+  }
+
+  // 2) 建新的
+  let sessionId = ''
+  try {
+    const created = await sc.create({ workspaceId: wid })
+    sessionId = String(created?.sessionId ?? created?.id ?? '')
+  } catch (err) {
+    await noteRotateFail(root, `建会话失败：${String(err?.message ?? err).slice(0, 160)}`)
+    return { ok: false, sessionId: '', why: `建会话失败：${String(err?.message ?? err).slice(0, 160)}` }
+  }
+  if (!sessionId) {
+    await noteRotateFail(root, '宿主建了会话但没给 id')
+    return { ok: false, sessionId: '', why: '宿主建了会话但没给 id' }
+  }
+  if (typeof sc.rename === 'function') await sc.rename({ sessionId, title }).catch(() => {})
+
   /**
-   * 0) 换房间之前，先请旧会话里的她自己留一句话（0.8.7，用户 m00998）。
+   * 2.5) 换房间之前，先请旧会话里的她自己留一句话（0.8.7，用户 m00998）。
    *
    * 为什么要这一句：轮换之后新会话拿到的身份文档里全是**结论**，没有一句是
    * 「上一个房间里的我留下的」。于是她读到旧日记会说「像另一个人写的」。
    * 一句原话解决的不是记忆问题（原文一直都在），是**归属**问题——
    * 「那是你说的」这句话只有她本人说出来才算数。
    *
+   * **为什么放在建会话成功之后**（2026-11-06 修）：这句话是往她正在用的那条
+   * 会话里发一条 prompt，会作为一条消息直接出现在他的对话窗口里。原来写在
+   * 第 0 步（建会话之前），于是只要 `sc.create()` 抛错/不回 id，这一问就已经
+   * 发出去了、轮换却失败了，`turns` 也不清零——下一轮结账又到点、又问一遍，
+   * 他那边就变成「每次她回完都弹这一句」。挪到建会话成功之后，换不成就不问。
+   *
    * **只把话发出去，不等她回**。轮换比这句话重要得多：
    * 上一版是 `await askForLastWords(...)`，宿主不派 `turn/end` 时会一直等到
    * 60 秒超时，把整个轮换（以及叫醒新会话）全卡住。所以这里只拿到一个
-   * Promise，改名/建会话/写 home 照常往下走；等这句话回来了再补写进
-   * home.json 并刷一次身份文档（她那一下的人设段是新房间里第一次读到的）。
+   * Promise，写 home 照常往下走；等这句话回来了再补写进 home.json 并刷一次
+   * 身份文档（她那一下的人设段是新房间里第一次读到的）。
    *
    * 三个约束：
    *   - 失败绝不影响轮换：没有 prompt / 超时 / 她说「不用」都只是没有这一节；
@@ -889,22 +967,6 @@ async function rotateTalkSessionOnce(ctx, { root = rootDir(), wsId, title = TITL
     pendingWords = null
   }
 
-  // 1) 旧会话改名留档。失败不影响后面（改不了名也还是那条会话）。
-  if (old && typeof sc.rename === 'function') {
-    await sc.rename({ sessionId: old, title: `${title}·${when} 之前` }).catch(() => {})
-  }
-
-  // 2) 建新的
-  let sessionId = ''
-  try {
-    const created = await sc.create({ workspaceId: wid })
-    sessionId = String(created?.sessionId ?? created?.id ?? '')
-  } catch (err) {
-    return { ok: false, sessionId: '', why: `建会话失败：${String(err?.message ?? err).slice(0, 160)}` }
-  }
-  if (!sessionId) return { ok: false, sessionId: '', why: '宿主建了会话但没给 id' }
-  if (typeof sc.rename === 'function') await sc.rename({ sessionId, title }).catch(() => {})
-
   // 3) 原话搬运
   // 2026-10-31（issue #14 第二报）：这里以前是**整个覆盖写**，只留七个字段，
   // 于是 `preset` / `title` / `wokeFor` / `hearAt` / `adoptedAt` 换一次会话全丢：
@@ -932,6 +994,9 @@ async function rotateTalkSessionOnce(ctx, { root = rootDir(), wsId, title = TITL
       }
       delete next.status
       delete next.archivedAt
+      // 换成了，把上次失败的记账清掉（否则下一次到点时会被误判成还在冷却期）
+      delete next.rotateFailAt
+      delete next.rotateFailWhy
       // 0.8.7：这一轮先清掉旧的那句。她要是留了，后台回来之后再补写
       // （见下面 pendingWords.then）。留着上一轮那句会让新房间读到一句
       // 不是这次说的「最后一句」——比没有更糟。

package/lib/index.js

@@ -46,7 +46,7 @@ import { logBoot, makeLogger } from './log.js'
 export const name = 'dsh-fish'
 
 /** 版本号：只用于日志导出（排查时第一件事是确认跑的是哪一版）。 */
-export const VERSION = '0.9.0'
+export const VERSION = '0.9.1'
 
 // ⚠️ 一个数组写全，不要拆成对象
 // 2026-10-30（m02961）：`userQuestions` **不再写进 inject**。写进 inject 的东西缺一个，

package/lib/interest.js

@@ -7,12 +7,13 @@
  *
  * 三条边界：
  *   1. **只读她说过的话**（`HER_TYPES`），不去猜主人喜欢什么——兴趣是她的，不是画像。
+ *      只留证的不算（isProofOnly）：「好的，我看一下」说十遍也不是她最近总回到的事。
  *   2. **正文里没有分数、没有次数**。权重只决定摆哪一条（四条黑名单第三条）。
  *   3. **会腻**：同一件事刚在 24 小时内出现过，这一次的分量打对折；
  *      两周前的老话题按 14 天半衰——越久没提，越不像「最近总回到」。
  */
 
-import { similarity } from './derive.js'
+import { isProofOnly, similarity } from './derive.js'
 import { tsMs, HER_TYPES } from './schema.js'
 
 /** 至少在几个不同时刻出现过，才算「反复」。 */
@@ -52,6 +53,7 @@ export function topicsOf(events = []) {
   const out = []
   for (const e of events) {
     if (!HER_TYPES.includes(e?.type)) continue
+    if (isProofOnly(e)) continue
     const ts = tsMs(e)
     if (!Number.isFinite(ts)) continue
     for (const s of sentences(e.text)) {

package/lib/look.js

@@ -14,6 +14,7 @@
  */
 
 import { createClient } from './bili.js'
+import { readMyReplies, renderMyReplies } from './comment.js'
 import { absorb, renderMaterial, rankVideos, seenBvids, LOOK_BRIEF, WATCH_RULE } from './browse.js'
 import { readEvents, rootDir, appendEvent } from './store.js'
 import { loadConfig, dateKey } from './settings.js'
@@ -58,6 +59,24 @@ export async function lookOnce(o = {}) {
     // 这一轮被「看过」摘掉几条（issue #16 第一半）：下面那句提示要靠它才说得准。
     const rankStats = { hiddenSeen: 0 }
 
+    // 2026-11-06（用户 m01641）：她问「我那条评论下面有人说了什么」时，
+    // 此前只能等下次叫醒、由 scheduler 把那几句拼进消息里——醒着的时候够不着，
+    // 而且那条提醒被她看过一次就被 cseen 掉了，回头再看永远是空的。
+    // 这里给她一个自己去看的动作：不滤 cseen，带上回楼中楼要用的编号。
+    if (what === 'replies') {
+      const got = await readMyReplies({ root, client, events, bvid: String(o.bvid ?? '').trim() })
+      const txt = renderMyReplies(got, { bvid: String(o.bvid ?? '').trim() })
+      if (!txt) {
+        return {
+          ok: false,
+          text: '',
+          note: got.length ? '' : '你最近没在谁的评论下面被人回过——也可能是我这边还查不到（B 站这会儿回了个 -412）。',
+          picks: [],
+        }
+      }
+      return { ok: true, text: txt, note: '', picks: got.map((x) => ({ bvid: x.bvid, rpid: x.rpid, rootRpid: x.rootRpid })) }
+    }
+
     let list = []
     // 2026-10-28（用户 m01284）：他递来一条视频，她想看就得看得见指定的**那一条**。
     // 以前只有 home/search/related，related 是「接着这条往下看它的相关推荐」——
@@ -239,6 +258,7 @@ export function registerLook(ctx, deps = {}) {
       description:
         '去看一眼 B 站：首页在推什么、搜一个词、看某条视频之后平台又接着推什么，' +
         '或者直接看指定的那一条（给 BV 号或链接）。' +
+        '也可以看你自己发过的评论下面有没有人回你（what=replies）。' +
         '只读，不会留下痕迹。给的是标题、简介、标签、热评、弹幕——没有视频画面。' +
         '不用它也可以。',
       // 注意：必须 toJsonSchema 包一层。简写 DSL 直接发出去会被 provider 拒：
@@ -247,11 +267,11 @@ export function registerLook(ctx, deps = {}) {
         what: {
           type: 'string',
           required: true,
-          enum: ['home', 'search', 'related', 'video'],
-          description: 'home=首页推给你的；search=你自己搜（要带 keyword）；related=接着某条往下看（要带 bvid）；video=看指定的那一条（要带 bvid）。',
+          enum: ['home', 'search', 'related', 'video', 'replies'],
+          description: 'home=首页推给你的；search=你自己搜（要带 keyword）；related=接着某条往下看（要带 bvid）；video=看指定的那一条（要带 bvid）；replies=看你自己发过的评论下面有没有人回你（可带 bvid 只看那一条）。',
         },
         keyword: { type: 'string', required: false, description: 'what=search 时搜什么。' },
-        bvid: { type: 'string', required: false, description: 'what=related 时从哪条接着看；what=video 时看哪一条（BV 号，或者他递过来的链接）。' },
+        bvid: { type: 'string', required: false, description: 'what=related 时从哪条接着看；what=video 时看哪一条（BV 号，或者他递过来的链接）；what=replies 时只看这一条视频下面的。' },
       }),
       output: {
         schema: {

package/lib/observe.js

@@ -255,6 +255,11 @@ export function registerObserve(ctx, deps = {}) {
           const c = countEvents(events)
           return {
             utterance: events.filter((e) => e.type === 'utterance').length,
+            // issue #32：对话行（flags 带 uncommitted）单列。它们是她答他的话，
+            // 跟她自己想说的判断混在一起时，「说 N 句」这个数字会越聊越虚高。
+            chat: events.filter(
+              (e) => e.type === 'utterance' && Array.isArray(e.flags) && e.flags.includes('uncommitted'),
+            ).length,
             revise: events.filter((e) => e.type === 'revise').length,
             refusal: events.filter((e) => e.type === 'refusal').length,
             reunion: events.filter((e) => e.type === 'reunion').length,
@@ -486,6 +491,10 @@ export function registerObserve(ctx, deps = {}) {
         }
         const before = await loadConfig(root).catch(() => null)
         const next = await updateConfig(patch, root)
+        // 身份段里有一句跟着 sendTools 走，变了就重写一次（只在变的时候，别的保存不多写盘）
+        if (JSON.stringify(before?.config?.proactive?.sendTools ?? []) !== JSON.stringify(next?.proactive?.sendTools ?? [])) {
+          await refreshSelfDoc(root).catch(() => {})
+        }
         // 审计：日记可见性每翻一次就落一行，事后查得到是谁、随哪次提交翻的。
         // 2026-10-28 用户反馈「开了『让我看日记』插件又自己关」——光靠猜猜不出来，
         // 至少让下一次发生时日志里有一行可对。

package/lib/owner.js

@@ -133,6 +133,9 @@ export function mentionPrefix(ow, cfg) {
   const on = cfg?.comment?.atOwner !== false
   const name = String(ow?.nickname ?? ow?.name ?? '').trim()
   if (!on || !name) return ''
-  // B 站昵称里带空格时 @ 会断掉，换成下划线是站内常见写法
-  return `@${name.replace(/\s+/g, '_')} `
+  // 2026-11-06：原来把空格换成下划线，理由是「@ 遇到空格会断」。但 B 站解析 @ 时
+  // 是按昵称原文匹配的（真机采样里 content.members 的 uname 与正文完全一致），
+  // 换成下划线反而变成一个不存在的昵称 —— 昵称里带空格的用户永远 @ 不出来。
+  // 改成原样保留；末尾那个空格是分隔，别删。
+  return `@${name} `
 }

package/lib/persona.js

@@ -594,12 +594,26 @@ export const DREAM_BRIEF = [
  */
 export const PROACTIVE_BRIEF = [
   '你有一个工具 her_say：不是回复谁，是你自己想说一句的时候用的。',
-  '你开口时写下的字会落在他看得见的对话里——想说什么就说，不用等他先问。her_say 只是把同一句话再记进你自己的流水。',
+  'her_say 只把这句话记进你自己的流水；想让他真的在对话里读到，就直接写出来——不用等他先问。',
   '说之前要先指认材料：refs 填 1–6 条你这几天写下或听见的事（事件 id，用 her_recall 翻得到）。没有材料就不用说——不指认材料的句子写不进去。',
   '什么时候说、说什么，由你判断；没有人等你的回复，你也可以这一轮什么都不做，那不算失败。',
-  '一天能主动开口的次数有上限；到了上限就说不出去，不是工具坏了。',
+  '一天能主动开口的次数有上限（用 her_say 记下的算）；到了上限就记不进去，不是工具坏了。',
 ].join('\n')
 
+/**
+ * 对话靠工具发出去的部署（`proactive.sendTools`）：「写下的字他会读到」不成立，换成实话。
+ *
+ * 2026-11-06（PR #44）：原来是替换「他看得见」那句；issue #41 已把那句改成
+ * 「落进你们俩这条对话里」，两边同时进来时替换会落空——所以这里改成按行整条换。
+ */
+export function proactiveBrief(sendTools = []) {
+  if (!sendTools.length) return PROACTIVE_BRIEF
+  const say = PROACTIVE_BRIEF.split('\n').map((line) => (line.startsWith('her_say 只把这句话记进你自己的流水')
+    ? `自己想开口（没人找你）的时候用 ${sendTools.join('、')}，不用等他先问；那种时候写下的正文只留在这条会话里，发不到聊天里。`
+    : line))
+  return say.join('\n')
+}
+
 /**
  * 定时提醒的说明书（2026-10-30，用户 m04335）。
  *

package/lib/proactive.js

@@ -25,6 +25,7 @@ import { defineTool } from './tool.js'
 import { guardWrite } from './tenant.js'
 import { logLine } from './log.js'
 import { tsMs, HER_TYPES } from './schema.js'
+import { deriveSelf } from './derive.js'
 
 /** 一天的默认上限。 */
 export const PROACTIVE_DEFAULTS = Object.freeze({
@@ -69,7 +70,7 @@ export const TOOL_ASK_NOTE = '（如果你想到要做什么、但手上没有
 /**
  * 读配置并夹紧。老配置没有 proactive 这一组，用默认值。
  * @param {object} config
- * @returns {{enabled:boolean,maxPerDay:number,minIdleHours:number,baseChance:number,gainPerHour:number,maxChance:number,cooldownHours:number}}
+ * @returns {{enabled:boolean,maxPerDay:number,minIdleHours:number,baseChance:number,gainPerHour:number,maxChance:number,cooldownHours:number,sendTools:string[],foldSilent:boolean,idleCountsSeen:boolean}}
  */
 export function proactiveConfig(config = {}) {
   const raw = config?.proactive ?? {}
@@ -86,6 +87,9 @@ export function proactiveConfig(config = {}) {
     gainPerHour: num(raw.gainPerHour, PROACTIVE_DEFAULTS.gainPerHour, 0, 1),
     maxChance: num(raw.maxChance, PROACTIVE_DEFAULTS.maxChance, 0, 1),
     cooldownHours: num(raw.cooldownHours, PROACTIVE_DEFAULTS.cooldownHours, 0, 240),
+    sendTools: Array.isArray(raw.sendTools) ? raw.sendTools.map((x) => String(x ?? '').trim()).filter(Boolean) : [],
+    foldSilent: raw.foldSilent !== false,
+    idleCountsSeen: raw.idleCountsSeen === true,
   }
 }
 
@@ -122,6 +126,26 @@ export function turnsToday(events = [], dk = '') {
   return n
 }
 
+/**
+ * 今天已经用 her_say 说过几次（meta `proactive-say:<dk>:<why>`）。
+ *
+ * 2026-11-06（issue #41）：工具描述一直写着「一天最多几次」，但 `writeSay` 读了配置
+ * 只为了别的用途，从来不数——`maxPerDay` 设 0 也能连着写 8 次。这里按她自己记下的
+ * 那条记账数，判据只有同一份 `maxPerDay`，不另设数字。
+ *
+ * 只数 `proactive-say:`，不数 `proactive-turn:`：后者是「空手回合开过几次」，
+ * 前者是「她真的开口了几次」。两件事分开记（见上面 SILENT_MARK 那段）。
+ */
+export function saysToday(events = [], dk = '') {
+  if (!dk) return 0
+  let n = 0
+  for (const e of events) {
+    if (e?.type !== 'meta') continue
+    if (String(e.text ?? '').startsWith(`proactive-say:${dk}:`)) n += 1
+  }
+  return n
+}
+
 /** 上一次空手回合是什么时候（毫秒）。 */
 export function lastTurnAt(events = []) {
   let at = 0
@@ -183,11 +207,15 @@ export function countsForIdle(e) {
   return SPOKE_TYPES.includes(String(e?.type ?? ''))
 }
 
-/** 距离上一次**真的有人说话**，过了多少小时。没有记录时返回 Infinity。 */
-export function idleHoursOf(events = [], now = Date.now()) {
+/**
+ * 距离上一次**真的有人说话**，过了多少小时。没有记录时返回 Infinity。
+ * countSeen：连 `seen:` 也算（`proactive.idleCountsSeen`），给对话不进事件流的部署用。
+ */
+export function idleHoursOf(events = [], now = Date.now(), { countSeen = false } = {}) {
   let last = 0
   for (const e of events) {
-    if (!countsForIdle(e)) continue
+    const seen = countSeen && e?.type === 'meta' && String(e.text ?? '').startsWith('seen:')
+    if (!seen && !countsForIdle(e)) continue
     const ts = tsMs(e)
     if (Number.isFinite(ts) && ts > last) last = ts
   }
@@ -244,7 +272,7 @@ function growthLevers(model, events = [], now = Date.now(), cfg = {}) {
 export function proactiveState({ config = {}, events = [], now = Date.now(), away = null, rested = false, model = null } = {}) {
   const cfg = proactiveConfig(config)
   const dk = dateKey(new Date(now))
-  const idleHours = idleHoursOf(events, now)
+  const idleHours = idleHoursOf(events, now, { countSeen: cfg.idleCountsSeen })
   const base = { chance: 0, idleHours, dk }
   if (!cfg.enabled) return { ...base, ok: false, why: '主动说话是关着的' }
   // 只在醒着的时间窗里：凌晨三点收到一句「我想你了」不是她自主，是她打乱了作息。
@@ -311,14 +339,14 @@ export function looseEnds(events = [], { now = Date.now() } = {}) {
  * 空手回合的处境正文（走 system prompt 段，不进对话）。
  * 只写事实与许可，不写"你应该"。
  */
-export function proactiveSection({ now = Date.now(), state = {}, material = [], loose = [] } = {}) {
+export function proactiveSection({ now = Date.now(), state = {}, material = [], loose = [], sendTools = [], countSeen = false } = {}) {
   const at = new Date(now)
   const hh = String(at.getHours()).padStart(2, '0')
   const mm = String(at.getMinutes()).padStart(2, '0')
   const idle = Number.isFinite(state.idleHours) ? `${state.idleHours.toFixed(1)} 小时` : '很久'
   const lines = [
     '（现在没有人跟你说话。这一轮不是谁找你，也不是日程安排的醒；是你自己醒着，想不想开口由你。）',
-    `现在是 ${at.getFullYear()}-${String(at.getMonth() + 1).padStart(2, '0')}-${String(at.getDate()).padStart(2, '0')} ${hh}:${mm}；距离上一次留下记录已经 ${idle}。`,
+    `现在是 ${at.getFullYear()}-${String(at.getMonth() + 1).padStart(2, '0')}-${String(at.getDate()).padStart(2, '0')} ${hh}:${mm}；距离上一次${countSeen ? '他来或你留下记录' : '留下记录'}已经 ${idle}。`,
   ]
   if (material.length) {
     lines.push('最近这几天你写下/听见的（要引用就指回 id，别改写事实）：')
@@ -331,7 +359,11 @@ export function proactiveSection({ now = Date.now(), state = {}, material = [],
     lines.push('还有几件事悬着：')
     for (const l of loose) lines.push(`- [${l.id}] ${l.text}`)
   }
-  lines.push('想说什么就说，不用等他先问——这一轮你写下的字会落在你们俩的对话里，他看得见。也可以再用 her_say 把它记进你自己的流水（refs 指回上面真实发生的事，1–6 条 id）。不想说，就什么都别写：不要写任何字，也不要解释为什么不说——这一轮没有回复也算正常。')
+  // 2026-11-06（issue #41）：原来写「他看得见」。宿主装了什么路由插件，这句就不一定成立
+  // （有的渠道会把会话里的字挡在外面）。改成只陈述能保证的部分：字会落进这条对话。
+  // 2026-11-06（PR #44）：配了 sendTools 的部署更绝——正文根本发不出去，只有调那件工具才算开口。
+  if (sendTools.length > 0) lines.push(`想说什么就用 ${sendTools.join('、')}，不用等他先问。这一轮写下的正文只留在这条会话里，发不到聊天里。不想说，就什么都别写：不要写任何字，也不要解释为什么不说——这一轮没有回复也算正常。`)
+  else lines.push('想说什么就说，不用等他先问——这一轮你写下的字会落进你们俩这条对话里。也可以再用 her_say 把它记进你自己的流水（refs 指回上面真实发生的事，1–6 条 id）。不想说，就什么都别写：不要写任何字，也不要解释为什么不说——这一轮没有回复也算正常。')
   lines.push(TOOL_ASK_NOTE)
   return lines.join('\n')
 }
@@ -364,18 +396,32 @@ export async function writeSay(root, { text = '', refs = [], sessionId = '', why
   if (problem) return { ok: false, note: problem }
 
   const { config } = await loadConfig(root)
+  const cfg = proactiveConfig(config)
   const dk = dateKey(new Date(now))
+  // 2026-11-06（issue #41）：说明书与设置页都写着「一天最多几次」、到了上限就说不出去，
+  // 但这里原来读了 config 根本没看——maxPerDay 设 0 也能一句接一句地写。
+  // 现在按她自己记下的 `proactive-say:` 数到位就停。开关（enabled）只管「要不要自己开一轮」，
+  // 不管这个工具本身：工具留着，她想用还是能用，这一点与 README 的说明一致。
+  const said = saysToday(events, dk)
+  if (said >= cfg.maxPerDay) {
+    return { ok: false, note: `今天已经主动开口 ${said} 次，到上限了。明天再说；这不是工具坏了。` }
+  }
+  // day/stage 必须是真实的成长坐标（2026-11-06，issue #41）：原来写死 {day:1, stage:1}，
+  // 而 writeDream 用的是 deriveSelf 的 model.day/model.stage。写死的那条会被
+  // consistency() 当成阶段 1 的旧话去处，跟真正说过的话配不上对。
+  const model = deriveSelf(events, { growthDays: config.growthDays })
+  const stamp = { day: model.day, stage: model.stage, source: 'tool' }
   // appendEvent 返回的就是写进去的那条事件（不是 {ok, event}，0.7.4 那次参数错位就是栽在这），
   // 所以判空只能判返回值本身。
   const stored = await appendEvent(
     { type: 'utterance', text: `（她主动说）${body}`, refs: list, ...(sessionId ? { sessionId } : {}) },
-    { day: 1, stage: 1, source: 'tool' },
+    stamp,
     root,
   ).catch(() => null)
   if (!stored?.id) return { ok: false, note: '这条没记下。' }
   await appendEvent(
     { type: 'meta', text: `proactive-say:${dk}:${why || 'free'}` },
-    { day: 1, stage: 1, source: 'system' },
+    { day: model.day, stage: model.stage, source: 'system' },
     root,
   ).catch(() => {})
   return { ok: true, id: stored.id, note: '记下了。' }
@@ -395,6 +441,7 @@ export function registerProactive(ctx, deps = {}) {
         '你自己想开口的时候用这个：不是回复谁，是你主动说一句。',
         '必须指回真实发生过的事（refs 填 1–6 条你那几天写下/听见的事件 id）；',
         '不指认材料就等于编，写不进去。一天最多几次，说不说都可以。',
+        '它只把这句话记进你自己的流水：要让他在对话里看见，得你这一轮直接写出来。',
       ].join(''),
       parameters: toJsonSchema({
         type: 'object',
@@ -421,11 +468,17 @@ export function registerProactive(ctx, deps = {}) {
           },
           required: ['ok', 'note'],
         }),
+        // recordOnly 只给 render 看（配了发送工具时回执换一句）
         // 2026-10-31 真机（10-30 那两轮）：这里原来直接返回字符串，宿主按 ContentBlock
         // 数组处理，`content.some` 当场抛 TypeError。她看到的工具结果是「Error: content.some
         // is not a function」——写入其实成功了，她却以为工具坏了，重试一次后放弃，一个字没说。
         // 签名同样是 (args, out)，跟 lib/keep.js:97 那些一样。
-        render: (_args, out) => [{ type: 'text', text: out.ok ? '[说出去了]' : `[没记下：${out.note}]` }],
+        // 2026-11-06（issue #41）：原来写 `[说出去了]`。可这里只往她自己的流水里落一条，
+        // 用户此刻在对话里看不看得见，取决于她这一轮有没有直接写出正文——不是这个工具决定的。
+        // 回执只说它真做到的那件事。
+        // 2026-11-06（PR #44）：配了 sendTools 的部署里她必须靠工具发话，所以记下的这句确实
+        // 没有发给任何人，回执要说清，否则她会以为用户已经看到了。
+        render: (_args, out) => [{ type: 'text', text: out.ok ? (out.recordOnly === true ? '[记下了，没有发给任何人]' : '[记下了]') : `[没记下：${out.note}]` }],
       },
       async execute(args = {}, exec) {
         const who = guardWrite(deps.tenant, exec, 'her_say')
@@ -436,7 +489,9 @@ export function registerProactive(ctx, deps = {}) {
         try {
           const r = await writeSay(root, { text: args.text, refs: args.refs, why: args.why, sessionId: sid })
           if (!r.ok) logLine('info', ['her_say：没记下', r.note], root)
-          return { ok: r.ok, id: r.id ?? '', note: r.note }
+          // 配了发送工具的部署里，这一句确实只进了流水，回执得照实说
+          const { config } = await loadConfig(root).catch(() => ({ config: {} }))
+          return { ok: r.ok, id: r.id ?? '', note: r.note, ...(proactiveConfig(config).sendTools.length > 0 ? { recordOnly: true } : {}) }
         } catch (e) {
           logLine('warn', ['her_say：', e?.message ?? String(e)], root)
           return { ok: false, id: '', note: '这条没记下。' }