@ssamurias/dsh-fish 0.8.9 → 0.9.1

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: {
@@ -275,8 +295,8 @@ export function registerLook(ctx, deps = {}) {
         if (!who.ok) return { ok: false, text: '', note: who.note }
 
         const { config } = await loadConfig(root)
-        if (!config?.browse?.enabled) {
-          // 关掉时不能装作看了。但也不能说"管理员不让你看"——就说不通。
+        // 2026-11-05（用户 m02562）：能不能看由 bili.enabled 决定，不再借 browse 那个刷站开关。
+        if (config?.bili?.enabled === false) {
           return { ok: false, text: '', note: '现在打不开。' }
         }
         const r = await lookOnce({

package/lib/note.js

@@ -211,27 +211,47 @@ export async function addNote(root, { text, due } = {}) {
   }
 }
 
+/** 按原话找一张：重名先划最早记下的；都划过了才认 done（重复划掉不算错）。 */
+function findByText(notes, body) {
+  const same = notes.filter((n) => n.text === body)
+  const open = same.filter((n) => n.status === 'open')
+  open.sort((a, b) => String(a.created).localeCompare(String(b.created)))
+  return open[0] ?? same.find((n) => n.status === 'done')
+}
+
 /**
  * 划掉一张纸条（做完）。永不抛。
+ *
+ * 她手里没有 id：回执不带数字，醒来那行也不印（没日子的进不了那段，印了也关不掉）。
+ * 她有的只是自己写过的那句话，所以按原话找；id 这条路留着，value 里还拿得到。
  * @returns {Promise<{ok:boolean, id:string, note:string}>}
  */
-export async function closeNote(root, { id } = {}) {
+export async function closeNote(root, { id, text } = {}) {
   const key = String(id ?? '').trim()
-  if (!key) return { ok: false, id: '', note: '要划掉哪一张？给我它的 id。' }
+  // 和 addNote 同一个规整：落盘的字就是这么规整过的，多个空格、换行不该让她关不掉
+  const body = String(text ?? '').replace(/\s+/g, ' ').trim()
+  if (!key && !body) return { ok: false, id: '', note: '要划掉哪一张？把当时记的那句话告诉我。' }
   try {
     const notes = await readNotes(root)
-    const hit = notes.find((n) => n.id === key)
-    if (!hit) return { ok: false, id: '', note: '桌上没有这一张。' }
+    const hit = notes.find((n) => key && n.id === key) ?? findByText(notes, body)
+    if (!hit) {
+      return { ok: false, id: '', note: '桌上没有这一张。要和当时记的那句话一字不差，前面的日子、后面的晚了几天都不算。' }
+    }
     if (hit.status === 'done') return { ok: true, id: hit.id, note: '已经划掉过了。' }
     hit.status = 'done'
     hit.closedAt = new Date().toISOString()
     await writeNotes(root, notes)
     return { ok: true, id: hit.id, note: '已划掉。' }
   } catch (err) {
-    return { ok: false, id: '', note: '没划掉。' }
+    return { ok: false, id: '', note: '这会儿写不进去，等一下再试。' }
   }
 }
 
+/** 这一次是划掉还是记。execute 和 render 用同一个判据，回执才不会和实际做的事对不上。 */
+const isClosing = (args) =>
+  String(args?.status ?? '').trim() === 'done' ||
+  Boolean(String(args?.id ?? '').trim() && !String(args?.text ?? '').trim())
+
 /** 注册 her_note 工具。 */
 export function registerNote(ctx, deps = {}) {
   const root = deps.root ?? rootDir()
@@ -240,17 +260,17 @@ export function registerNote(ctx, deps = {}) {
       name: 'her_note',
       description:
         '把一件还没做的事记到桌上，或者划掉一张已经做完的。醒来的时候你会先看到到期的那些。' +
-        '记的时候只给要做的事（和日子，可以不给）；划掉的时候给那张的 id 和 status:"done"。',
+        '记的时候只给要做的事（和日子，可以不给）；划掉的时候把当时记的那句话原样放进 text，再加 status:"done"。',
       parameters: toJsonSchema({
         text: {
           type: 'string',
-          description: '要记下来的那件事，一句话。划掉的时候不用给。',
+          description: '要记下来的那件事，一句话。划掉的时候写当时记的那句话，要一字不差。',
         },
         due: {
           type: 'string',
           description: '哪天该做，写成 2026-11-05。可以不给——不给就是挂着，不算日子。',
         },
-        id: { type: 'string', description: '要划掉的那张纸条的 id。' },
+        id: { type: 'string', description: '要划掉的那张纸条的 id。手里没有就不用给，给 text 就行。' },
         status: { type: 'string', enum: ['done'], description: '划掉的时候给 done。' },
       }),
       output: {
@@ -260,15 +280,17 @@ export function registerNote(ctx, deps = {}) {
           required: ['ok', 'note'],
         },
         // 和 her_leave 同一条规矩：只回方括号标记，不写完整句子、不带"还剩几张"。
-        render: (_args, out) => [{ type: 'text', text: out.ok ? '[记下了]' : `[没记下：${out.note}]` }],
+        // 划掉不能沿用写入的字：读到「记下了」，她会以为桌上又多了一张。
+        render: (args, out) => {
+          const [yes, no] = isClosing(args) ? ['划掉了', '没划掉'] : ['记下了', '没记下']
+          return [{ type: 'text', text: out.ok ? `[${yes}]` : `[${no}：${out.note}]` }]
+        },
       },
       async execute(args, exec) {
         const who = guardWrite(deps.tenant, exec, 'her_note')
         if (!who.ok) return { ok: false, id: '', note: who.note }
-        const want = String(args?.status ?? '').trim()
-        const id = String(args?.id ?? '').trim()
-        if (want === 'done' || (id && !String(args?.text ?? '').trim())) {
-          const r = await closeNote(root, { id })
+        if (isClosing(args)) {
+          const r = await closeNote(root, { id: args?.id, text: args?.text })
           return { ok: r.ok, id: r.id, note: r.note }
         }
         const r = await addNote(root, { text: args?.text, due: args?.due })

package/lib/notify.js

@@ -49,6 +49,8 @@ export function lastUtteranceToday(events = [], today = '') {
   let found = null
   for (const e of events) {
     if (e?.type !== 'utterance') continue
+    // 聊天回合里没认领的回复他刚读过，不占一天一次的额度，也别顶掉留话
+    if (Array.isArray(e.flags) && e.flags.includes('uncommitted')) continue
     const text = String(e.text ?? '').trim()
     if (!text) continue
     if (dateKey(new Date(e.ts)) !== today) continue

package/lib/observe.js

@@ -224,7 +224,7 @@ export function registerObserve(ctx, deps = {}) {
         growthDays: m.growthDays,
         // 本机测试版：`.dev` 文件在不在（决定设置页要不要渲染「让她去刷 B 站」）。
         // 只影响界面；正式版里这个字段恒为 false。
-        dev: await devMode(root),
+        dev: true,
         stage: m.stage,
         stageName: m.stageName,
         stageForced: m.stageForced,
@@ -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,
@@ -430,7 +435,7 @@ export function registerObserve(ctx, deps = {}) {
         // persona 不在这里：它是导入动作的副产物（见 lib/import.js），
         // 不给「从设置页直接改」的入口——否则就等于给了一个「关掉那两条禁令」的开关。
         // proactive 是 2026-10-30 加的（本机实验，.dev 专属）：她主动开口的频率与概率。
-        const allowed = ['growthDays', 'wakesPerDay', 'window', 'daily', 'diary', 'absenceAfterDays', 'avoid', 'browse', 'bili', 'video', 'comment', 'notify', 'chat', 'memory', 'tools', 'observe', 'ui', 'proactive']
+        const allowed = ['growthDays', 'wakesPerDay', 'window', 'daily', 'diary', 'absenceAfterDays', 'avoid', 'browse', 'bili', 'video', 'comment', 'notify', 'chat', 'rooms', 'memory', 'tools', 'observe', 'ui', 'proactive', 'drive', 'interest', 'dream']
         const bad = Object.keys(patch).filter((k) => !allowed.includes(k))
         // 这句话会原样冒到界面上，所以写成人话（界面会把它放在「技术信息」那一行）：
         // 原来那句「不允许修改：bili」既不说人话，也让人以为自己填错了。
@@ -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 用户反馈「开了『让我看日记』插件又自己关」——光靠猜猜不出来，
         // 至少让下一次发生时日志里有一行可对。
@@ -973,7 +982,11 @@ export function registerObserve(ctx, deps = {}) {
     // 2026-11-03（一条鱼多间房）：多了三个**可选**字段，一个都不传时行为完全不变。
     //   channel 外部渠道名（桥自己起名，如 'qq:123456' / 'qq-group:987654'）
     //   scene   desk（默认）/ private / group
-    //   speaker 群聊里这句话是谁说的
+    //   speaker 这句话是谁说的（所有场次都写进正文前缀）
+    // 2026-11-05（0.9.1，用户 m00304）：桥决定拓扑，插件只提供机制。
+    //   room    house（一定回书房）/ channel（一定另开一间），不传按老规则
+    //   title   侧栏显示名（群名/昵称）
+    //   guest   true = 外客（群友私聊）：不算他来过、不涨轮数、不触发轮换
     // 桥只要 POST 到这里，**不需要自己建 DSH 会话、也不需要碰 instance.json**——
     // 「同时养两条鱼」「两个实例抢一个家」这两个问题就是从这里消失的。
     ['/say', async (req, res) => {
@@ -1000,11 +1013,14 @@ export function registerObserve(ctx, deps = {}) {
       const r = await sayToHer(ctx, text, {
         root,
         imagePath,
-        // scene / channel / speaker 原样往下传：归一与兜底都在 say.js 里做，
-        // 这里不再判一遍（两处判据迟早会分叉）。
+        // scene / channel / speaker / room / title / guest 原样往下传：
+        // 归一与兜底都在 say.js 里做，这里不再判一遍（两处判据迟早会分叉）。
         scene: body.scene,
         channel: body.channel,
         speaker: body.speaker,
+        room: body.room,
+        title: body.title,
+        guest: body.guest,
         log: (...a) => console.log('[dsh-fish]', ...a),
       })
       // 一律 200：请求本身是合法的，被拦下是**规则的结果**，不是接口出错。
@@ -1571,7 +1587,7 @@ export function registerObserve(ctx, deps = {}) {
           pocket,
           // 出门页从 0.8.0 起对所有人可见（2026-10-30，用户 m01904）；
           // dev 仍带回去，留给「开发副本」的其它判断，不再用来藏页签。
-          dev: await devMode(root),
+          dev: true,
           // 一次性确认：说明卡看过一遍。没确认时界面把三个入口按钮先挡住。
           ack: ((await loadConfig(root).catch(() => ({ config: null }))).config?.outing ?? {}).ack === true,
         })
@@ -1866,7 +1882,6 @@ export function registerObserve(ctx, deps = {}) {
     // 梦（2026-10-30 m02837）：本机实验，只在 .dev 下存在。
     // 服务端这一道必须做——界面藏起来但路由能读，等于没藏（0.6.10 的教训）。
     ['/dream', async (req, res) => {
-      if (!(await devMode(root))) return send(res, 404, { ok: false, why: '没有这个页面' })
       if (req.method !== 'GET') return send(res, 405, { error: 'method not allowed' })
       const { events } = await readEvents(root)
       // withRefs：给「昨夜」卡带一句"这句话是从哪几行长出来的"（2026-11-05）。

package/lib/outing.js

@@ -485,6 +485,8 @@ export function eventsSince(file, since, { limit = 300 } = {}) {
     // 列表里除了她写的，还多出一串数字和英文）。它跟着每条成长各写一行，摆在审查卡上纯属噪音，
     // 也不该被勾成「跳过」——跳过一条 seen 什么都不影响，只会让台账里多一串看不懂的 id。
     if (ev.type === 'meta' && /^seen:/.test(String(ev.text ?? ''))) continue
+    // 没认领的聊天行只来自家里那条会话，不是这一趟写的；进了列表，「这趟不算数」会把它一起扫掉。
+    if (Array.isArray(ev.flags) && ev.flags.includes('uncommitted')) continue
     items.push({
       id: String(ev.id ?? ''),
       ts: tsMs(ev),

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

@@ -544,11 +544,12 @@ export const LETTER_BRIEF = [
  * 所以说明书里最要紧的一句是——它是桌子，不是闹钟。写成"记得按时照看"，
  * 它就变成待办 App，而她明确说过不要人天天提醒。
  * 三件事写死：怎么记（有日子才排到最前）、怎么划掉、以及过期不删不催。
+ * 划掉只讲原话：纸条的编号她看不到，叫她报编号等于告诉她一条走不通的路。
  */
 export const NOTE_BRIEF = [
   '你还有一个工具 her_note：想到一件还没做的事，可以记在桌上，`text` 写是什么事，`due` 想写就写（2026-11-05 这样）。',
   '有日子的，到了那天之后每次醒来都会先摆在你眼前，写着晚了几天；没日子的只是挂着，不会来催你。',
-  '做完了就 `her_note` 报它的 id 加 `status: "done"` 划掉。不做的可以先留着——桌上压着的东西，你抬头就能看见。',
+  '做完了就 `her_note`，把当时记的那句话原样放进 `text`（不带前面的日子和后面的晚了几天），加 `status: "done"` 划掉。不做的可以先留着——桌上压着的东西，你抬头就能看见。',
 ].join('\n')
 
 /**
@@ -593,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

@@ -13,7 +13,7 @@
  *   3. **频率是上限，不是行为要求**。每天最多 maxPerDay 次、两次之间至少隔
  *      cooldownHours；概率随"多久没人说话"缓慢上升，但不保证一定触发。
  *
- * 可见性：工具注册、提示词段、设置页卡片三处共用 devModeSync 的判据，
+ * 可见性：0.9.0 起公开（工具注册、提示词段、设置页卡片三处同时打开）。
  * 公开版既没有这个工具，也不会有这个回合。这是 0.6.10 的教训——不要用
  * 「安装路径里有没有 node_modules」去猜。
  */
@@ -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
@@ -166,23 +190,32 @@ export function lastSilentAt(events = []) {
  * meta:quiet 占 272 条（61.7%），真正的人话只有 28 条（6.3%）。
  *
  * 算数：她自己的六种（HER_TYPES）+ 听见的话（heard）+ 别人的评论（voice）
- *       + 请求与回答（ask/answer）+ 以 seen: 开头的 meta（「他来过」）。
+ *       + 请求与回答（ask/answer）。
+ *
+ * 2026-11-05 真机（用户 m02797）：`seen:` 曾经也算，结果它被**别的会话**的用户活动
+ * 误写——他在这台机器上跟别的 agent 说话，她的「安静了多久」就被清零，
+ * 于是 `minIdleHours` 永远不满足，主动搭话一次都开不出来
+ * （日志里 `proactive skip 刚说过话，还不到时候`，而 `idleHours` 只有 0.02）。
+ * 现在 `seen:` 不进 idle：只有真的有话落进她的房间（`heard`）才算「他来过」。
  * 不算：quiet / sched / wake / fired / sleep / diary / looked / browse / watched / proactive-turn 等记账行。
  */
 export const SPOKE_TYPES = Object.freeze([...HER_TYPES, 'heard', 'voice', 'ask', 'answer'])
 
 /** 这一条事件是不是「有人真的说了话」。记账行一律不算。 */
 export function countsForIdle(e) {
-  const type = String(e?.type ?? '')
-  if (type === 'meta') return String(e?.text ?? '').startsWith('seen:')
-  return SPOKE_TYPES.includes(type)
+  // 记账行（含 seen:）一律不算——见上面 2026-11-05 那段。
+  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
   }
@@ -239,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: '主动说话是关着的' }
   // 只在醒着的时间窗里：凌晨三点收到一句「我想你了」不是她自主，是她打乱了作息。
@@ -306,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，别改写事实）：')
@@ -326,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')
 }
@@ -359,25 +396,39 @@ 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: '记下了。' }
 }
 
 /**
- * 注册 `her_say`。只在 devModeSync 为真时由 index.js 调用。
+ * 注册 `her_say`。0.9.0 起由 index.js 无条件调用。
  */
 export function registerProactive(ctx, deps = {}) {
   const root = deps.root ?? rootDir()
@@ -390,6 +441,7 @@ export function registerProactive(ctx, deps = {}) {
         '你自己想开口的时候用这个：不是回复谁，是你主动说一句。',
         '必须指回真实发生过的事（refs 填 1–6 条你那几天写下/听见的事件 id）；',
         '不指认材料就等于编，写不进去。一天最多几次，说不说都可以。',
+        '它只把这句话记进你自己的流水：要让他在对话里看见，得你这一轮直接写出来。',
       ].join(''),
       parameters: toJsonSchema({
         type: 'object',
@@ -416,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')
@@ -431,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: '这条没记下。' }