@ssamurias/dsh-fish 0.9.0 → 0.9.2

package/lib/persona.js

@@ -537,19 +537,22 @@ export const LETTER_BRIEF = [
 ].join('\n')
 
 /**
- * 桌上那张纸的说明书（issue #22 乙档，2026-11-04）。
+ * 桌上那张纸的说明书（issue #22 乙档，2026-11-04；issue #53 补齐 list / update / drop）。
  *
  * 为什么单独一段、而不是并进 TOOL_BRIEF：这是唯一一个**跨天在场**的东西。
  * 别的工具都是"这一刻做一件事"，它写下的东西会在之后每一次醒来时先摆到她眼前，
  * 所以说明书里最要紧的一句是——它是桌子，不是闹钟。写成"记得按时照看"，
  * 它就变成待办 App，而她明确说过不要人天天提醒。
- * 三件事写死：怎么记（有日子才排到最前）、怎么划掉、以及过期不删不催。
- * 划掉只讲原话：纸条的编号她看不到，叫她报编号等于告诉她一条走不通的路。
+ * 写死这几件：怎么记（有日子才排到最前）、没日子的为什么不上桌、怎么翻、怎么改、
+ * 怎么划掉、怎么放下。划掉/改/放下都只讲原话：纸条编号她看不到，叫她报编号等于指一条走不通的路。
  */
 export const NOTE_BRIEF = [
-  '你还有一个工具 her_note：想到一件还没做的事，可以记在桌上，`text` 写是什么事，`due` 想写就写（2026-11-05 这样）。',
-  '有日子的，到了那天之后每次醒来都会先摆在你眼前，写着晚了几天；没日子的只是挂着，不会来催你。',
-  '做完了就 `her_note`，把当时记的那句话原样放进 `text`（不带前面的日子和后面的晚了几天），加 `status: "done"` 划掉。不做的可以先留着——桌上压着的东西，你抬头就能看见。',
+  '你还有一个工具 her_note，就是醒来时最先看到的那张桌子：记一张、翻一翻、划掉、放下，都在它这里。',
+  '记一张：`text` 写是什么事，`due` 想写就写（2026-11-05 这样）。有日子的到了那天之后每次醒来先摆在你眼前，写着晚了几天；没写日子的不会在醒来时出现，只能自己翻。',
+  '翻一翻：`action: "list"`。`filter` 可以给 `open`（默认，还没关掉的）、`due`（写了日子的）、`done`（划掉的）、`dropped`（放下的）、`all`；一次列不完，`offset` 往后翻。',
+  '做完了就划掉：把当时记的那句话原样放进 `text`，加 `status: "done"`——不带前面的日子和后面的晚了几天。',
+  '写错了可以改：`action: "update"`，`text` 放原来那句，`newText` 放新的；想改日子就带上 `due`，给空串是去掉日子。',
+  '决定不做了就放下：`action: "drop"`，同样用 `text` 指认，`reason` 写一句为什么。放下跟划掉不一样的地方就是这一句——写下来才知道是改了主意，还是怕了。',
 ].join('\n')
 
 /**
@@ -566,7 +569,7 @@ export const ASK_BRIEF = [
   '比如想改自己一天醒几次、醒着的时段，想哪天休息不被打扰，想要一个文件或一样工具，或者有件事拿不准要不要做。',
   '问的时候把想说的话写清楚：要问什么、为什么想问。对方会答「可以」或「这次不行」；也可以不答，过了一天就当作「以后再说」。',
   '它不能多用：一天最多一次，一周最多三次。小事不值得问，自己拿主意就行。',
-  '答应了什么，系统会照办；没答应的，记下来就完了，别再追着问同一件事。',
+  '改作息、请假，答应了系统会照办；要文件、要工具这些，答应了只是他知道了，得他动手给你；没答应的，记下来就完了，别再追着问同一件事。',
 ].join('\n')
 
 /**
@@ -594,12 +597,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: '这条没记下。' }

package/lib/say.js

@@ -16,7 +16,12 @@
  *     像人一样记得刚才说过什么；跨天换新会话，避免上下文无限膨胀。
  *
  * 她写话仍然只能走 growth_commit 工具（硬约束 N4 不变）。
- * 这里不会替她写任何 utterance —— 我们只把话递进去。
+ * 这里不会替她写任何 utterance 事件 —— 我们只把话递进去。
+ *
+ * 但返回值不一样（issue #51）：她正常回话走助理消息，从不写事件流，
+ * 外客（QQ 桥）只看 `said`，于是她明明答了、对方收到的却是空。
+ * 现在这一轮她在会话里说出口的正文也会进 `said`，并打上 `uncommitted` 标记
+ * ——**只活在这一次返回值里**，不落盘、不进时间线、不涨轮数。
  */
 
 import { readEvents, appendEvent, rootDir, ensureHer } from './store.js'
@@ -24,12 +29,13 @@ import { parseWatchIntent, watchHint } from './intent.js'
 import { loadConfig, dateKey } from './settings.js'
 import { deriveSelf } from './derive.js'
 import { writeInboxFile, newHerEventsSince } from './inbox.js'
+import { assistantText } from './turns.js'
 import { bumpTurns, rotateTalkSession, talkSessionId, homeStatus } from './home.js'
 import { addExchange } from './talkmem.js'
 import { hearTurn } from './hear.js'
 import { slashed } from './posix.js'
 import { refreshSelfDoc } from './selfdoc.js'
-import { ensureSessionLive } from './deliver.js'
+import { ensureSessionLive, reviveIfBlank } from './deliver.js'
 import { looksLikeRewriting, sanitizeForeign } from './guard.js'
 import { resolveChannel, saveChannel, channelKey, channelTitle, channelExpired } from './channels.js'
 import { normalizeScene } from './schema.js'
@@ -62,19 +68,35 @@ function beginTurnWait(ctx, sessionId, timeoutMs) {
   let timer = null
   let off = null
   let settle = () => {}
+  // issue #51：她这一轮在会话里**说出口的正文**。
+  // 她正常回话走 assistant/message，从不写事件流；原来这里只等 turn/end，
+  // herReply 又只看事件流，于是外客（guest）通路永远收到「她这次没说话」。
+  // 按 message.id 去重：同一条消息会因 interrupted / 续写被重放几次。
+  const spoken = []
+  const spokenIds = new Set()
   const promise = new Promise((resolve) => { settle = resolve })
   const finish = () => {
     if (done) return
     done = true
     if (timer) clearTimeout(timer)
     try { off?.() } catch { /* ignore */ }
-    settle()
+    settle({ spoken: spoken.slice() })
   }
   // 挂监听这一步一定要早于投递（见上面那段注释），所以放在定时器之前。
   if (typeof ctx.on === 'function') {
     off = ctx.on('session/event', (session, event) => {
       const id = session?.header?.id ?? session?.id
       if (id !== sessionId) return
+      if (event?.type === 'assistant/message') {
+        const mid = String(event?.data?.message?.id ?? '')
+        if (mid) {
+          if (spokenIds.has(mid)) return
+          spokenIds.add(mid)
+        }
+        const text = assistantText(event?.data)
+        if (text) spoken.push(text)
+        return
+      }
       if (event?.type === 'turn/end') finish()
     })
     if (typeof off !== 'function') off = null
@@ -360,10 +382,11 @@ export async function sayToHer(ctx, text, deps = {}) {
   // 现在只探活：会话还在就什么都不做；不在了（或老宿主没有 resolveAgent）才退回建一条。
   const live = await ensureSessionLive(sc, sessionId)
   if (!live.live) {
-    log?.('say: 会话探活没通过，退回新建一条', live.why ?? '')
-    try {
-      await sc.create({ sessionId, cwd: herDir })
-    } catch { /* 已存在就用旧的，上下文接着聊 */ }
+    log?.('say: 会话探活没通过，看看能不能按原 id 唤回来', live.why ?? '')
+    // 2026-11-06（换房报告）：裸 create 对跑过 turn 的会话只会另开一条空壳
+    // （宿主 create 是「按 cwd 开一条」，不是「恢复这一条」），详见 deliver.js 的
+    // reviveIfBlank。只有宿主确实给不出这一条时才建。
+    await reviveIfBlank(sc, sessionId, herDir, (msg) => log?.(`say: ${msg}`)).catch(() => {})
   }
 
   const ac = new AbortController()
@@ -399,7 +422,7 @@ export async function sayToHer(ctx, text, deps = {}) {
       ).catch(() => {})
     }
 
-    await turnWait.wait()
+    const turn = await turnWait.wait()
 
     // 她这一轮新写的话（可能一句都没有——允许她不回）
     const after = await readEvents(root)
@@ -411,10 +434,39 @@ export async function sayToHer(ctx, text, deps = {}) {
       verdict: e.verdict ?? null,
       ...(foreign ? { scene: 'group' } : {}),
     }))
+    // issue #51：她正常回话走 assistant/message，从不写事件流（只有调 growth_commit
+    // 才进 HER_TYPES）。外客（QQ 桥）只看 `said`，于是她答了、调用方却收到空数组。
+    // 现在把这一轮她在会话里说出口的正文也并进 `said`，但打上 uncommitted 标记：
+    // 那不是她自己认下的判断，不落盘、不进时间线、不涨轮数，只活在这一次返回值里。
+    const flat = (s) => String(s ?? '').replace(/\s+/g, ' ').trim()
+    const seenTexts = said.map((s) => flat(s.text)).filter(Boolean)
+    let spokenNo = 0
+    for (const block of Array.isArray(turn?.spoken) ? turn.spoken : []) {
+      // 一次回话可能是好几段（说一句、调个工具、再补一句），按空行分段。
+      for (const piece of String(block).split(/\n{2,}/)) {
+        const text = piece.trim()
+        const key = flat(text)
+        if (!key) continue
+        // 她已经用 growth_commit 把同一句写进事件流时，不再重复一遍。
+        if (seenTexts.some((k) => k === key || k.includes(key) || key.includes(k))) continue
+        seenTexts.push(key)
+        spokenNo += 1
+        said.push({
+          id: `turn-${dk}-${spokenNo}`,
+          type: 'utterance',
+          text,
+          verdict: null,
+          uncommitted: true,
+          ...(foreign ? { scene: 'group' } : {}),
+        })
+      }
+    }
+    // 事件流里的条数（真正落了盘的）。时间线、轮数、信箱都只认这个数。
+    const committed = fresh.length
     const herReply = said.map((s) => s.text).join('\n\n')
 
-    // 信箱落盘：她开口了才重写（没开口就没必要动文件）
-    if (said.length) {
+    // 信箱落盘：真有话写进事件流了才重写（没落盘就没必要动文件）
+    if (committed) {
       await writeInboxFile(root).catch(() => null)
     }
 
@@ -422,7 +474,11 @@ export async function sayToHer(ctx, text, deps = {}) {
     // 满了就换，旧的改名留档，原话搬几句到新会话（talkmem）。
     // 换失败不算对话失败：她还在旧会话里，只是这次没换成。
     let rotated = ''
-    let note = said.length ? '' : '她这次没说话。'
+    // issue #51：她在会话里答了、只是没写事件流时，不能报「没说话」——
+    // 调用方（QQ 桥、外客）会以为她没回应。标一句「没调 growth_commit」，别让人以为落了盘。
+    let note = said.length
+      ? (committed ? '' : '她回了，但这句没写进事件流（没调 growth_commit）。')
+      : '她这次没说话。'
     // 2026-11-03：群聊不挤占书房的那几轮。talkmem 分桶，见 talkmem.js 的注释。
     // 2026-11-05：外客私聊同群聊——它不属于「我们俩说到哪了」。
     await addExchange(root, { me: body, her: herReply, scene: foreign ? 'group' : scene }).catch(() => {})
@@ -467,8 +523,12 @@ export async function sayToHer(ctx, text, deps = {}) {
     // 2026-10-29（用户 m02241）：投递成功的收尾也留一行，但压到最短。
     // 只在「她一条都没说」时记——她开口了的话事件流里本来就有；
     // 这里要能回答的只是「话送进去了吗、她为什么没回」。
-    if (!said.length) {
-      log?.('say: 递进去了，她这次没说话', `session=${sessionId}`, `waited=${Date.now() - t0}ms`)
+    if (!committed) {
+      log?.(
+        said.length ? 'say: 她回了会话正文，但没写进事件流' : 'say: 递进去了，她这次没说话',
+        `session=${sessionId}`,
+        `waited=${Date.now() - t0}ms`,
+      )
     }
 
     return {