@ssamurias/dsh-fish 0.9.0 → 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,17 +29,18 @@ 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 { 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, looksLikeNothingSaid } 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'
@@ -95,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
@@ -115,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 } }
 }
@@ -161,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))
@@ -187,8 +209,9 @@ export function startScheduler(ctx, deps = {}) {
     // 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) {
@@ -215,7 +238,8 @@ export function startScheduler(ctx, deps = {}) {
     const seen = lastSeenAt(events)
     const echoBack = !!(leave && seen && seen >= leave && now - leave <= 72 * 3600_000)
     const driveDesk = { gaps: gaps.length, stale: 0, echo: echoBack, favorite: interest.length > 0 }
-    const drv = driveOf({ events, now, stage: model.stage, desk: driveDesk })
+    const pc = proactiveConfig(config)
+    const drv = driveOf({ events, now, stage: model.stage, desk: driveDesk, seenCountsAsHeard: pc.idleCountsSeen })
     // 空桌不醒（2026-11-05，用户 m02937）：桌上什么都没有时，劲儿再满也不起——
     // 否则她只能回一句「没什么要说的」，既占额度又在对话里留一条噪音。
     if (!deskHasMaterial(driveDesk)) {
@@ -237,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），
@@ -269,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()`。宿主把它画成一张默认收起的折叠条，
@@ -314,7 +347,12 @@ export function startScheduler(ctx, deps = {}) {
           const meta = { day: model.day, stage: model.stage, source: 'timer' }
           // 「没什么要说的」不是开口（2026-11-05，用户 m02937）：她写一句元话语
           // 交代「这轮没话说」，在文本界面上几乎不可避免；按静默记、折掉，别当一次开口。
-          const quiet = out.spoke !== true || looksLikeNothingSaid(out.said)
+          // 配了发送工具时正文到不了人，只认工具；没配时还是看正文
+          // 上游断流写成的那行红字也不是她开口（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)}）`)
@@ -322,13 +360,14 @@ export function startScheduler(ctx, deps = {}) {
           }
           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 = out.spoke === true ? '，只说了句没什么要说的' : ''
+          const tail = broken ? '，这一轮上游断流了（那行报错不算她开口）'
+            : out.spoke === true ? '，只说了句没什么要说的' : ''
           log('proactive', folded > 0
             ? `醒了一次，没有开口${tail}（这一轮折成 ${folded} 行，盖住 ${plan.shadowed} 个节点）`
             : `醒了一次，没有开口${tail}（${out.ok ? '这轮没什么可折' : out.why}）`)
@@ -405,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——这一趟由她自己决定说还是不说，不再叠一次醒一醒。
@@ -470,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
@@ -675,7 +740,13 @@ async function wake(ctx, root, model, config, decision, dk, log, deps = {}) {
   {
     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(
@@ -971,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) })

package/lib/selfdoc.js

@@ -27,7 +27,8 @@ import { join } from 'node:path'
 import { rootDir, paths, readEvents, readJson, writeAtomic, listDiary } from './store.js'
 import { loadConfig } from './settings.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'
@@ -120,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 自动生成」这类话。
     // 这个文件会被宿主原样渲染进她的会话——她能看见每一行。
@@ -166,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, ''] : []),
@@ -265,6 +266,7 @@ export async function writeSelfDoc(root = rootDir(), { log, exec, tenant } = {})
       // 梦（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'),
     })

package/lib/selfupdate.js

@@ -137,7 +137,14 @@ export function profileDirOf(moduleUrl) {
   // 两种都要认得，否则从 0.8.9 之前装上来的用户会被当成"没有 profile → 开发版"而永远升不了级。
   for (const marker of [`/node_modules/${PKG}/`, `/node_modules/${LEGACY_PKG}/`]) {
     const i = file.lastIndexOf(marker)
-    if (i >= 0) return file.slice(0, i)
+    if (i < 0) continue
+    const base = file.slice(0, i)
+    // pnpm 的 isolated 布局（issue #43）：真身常在
+    // `<profile>/node_modules/.pnpm/@ssamurias+dsh-fish@0.9.1/node_modules/@ssamurias/dsh-fish/lib/...`，
+    // 直接截到 marker 会得到 `.pnpm/.../node_modules`，那里没有 package.json，
+    // 于是 kind 判成 missing、managed 变 false，下载按钮永远不出现。往上退到 profile 根。
+    const pnpm = base.indexOf('/node_modules/.pnpm/')
+    return pnpm >= 0 ? base.slice(0, pnpm) : base
   }
   return ''
 }

package/lib/settings.js

@@ -70,6 +70,11 @@ export const DEFAULTS = {
     gainPerHour: 0.05,    // 超过 minIdleHours 之后，每多一小时加多少
     maxChance: 0.6,       // 概率上限
     cooldownHours: 4,     // 两次之间至少隔多久
+    // 下面三项给「对话要靠工具才发得出去」的部署（比如宿主里另有插件把多个聊天接进这条会话，
+    // 再给她一个发送工具）。默认值和原来的行为一样。
+    sendTools: [],      // 这些工具调成功才算她开了口；空 = 只认正文
+    foldSilent: true,     // 没开口的一轮折成一行；一条会话用很久、上下文很大时可以关
+    idleCountsSeen: false, // 「他来过」（seen:）也算打断安静；她的对话不进事件流时要开
   },
 
   // 她"不想看"的东西（可追加，用户说以后还会加）

package/lib/status.js

@@ -44,7 +44,7 @@ function dayMarker(text, prefix, dk) {
  * @param {{events:Array, config:object, now?:Date}} input
  * @returns {{phase:string, label:string, detail:string, since:string, minutesAgo:number|null,
  *            plannedWakeAt:string|null, nextWakeAt:string|null, awake:boolean,
- *            today:{wakes:number,idleWakes:number,browsed:number,said:number,comments:number,dairies:number},
+ *            today:{wakes:number,idleWakes:number,browsed:number,said:number,chat:number,comments:number,dairies:number},
  *            timeline:Array<{at:string,kind:string,text:string,idle?:boolean}>}}
  */
 export function deriveStatus({ events = [], config = {}, now = new Date() } = {}) {
@@ -73,7 +73,10 @@ export function deriveStatus({ events = [], config = {}, now = new Date() } = {}
 
   // ---- 把今天切成"醒来块"：每个 wake: 是起点，动作挂到它下面 ----
   const blocks = []
-  const counts = { wakes: 0, idleWakes: 0, browsed: 0, said: 0, comments: 0, dairies: 0 }
+  // chat（issue #32）：对话里她说的那些行。它们**不是**她在这一轮里主动做的事——
+  // 一次叫醒正好撞上他连说几十句，时间线 40 条会被这些行占满，`idleWakes` 也会被
+  // 一句「嗯」清零。所以单列一个计数，不进 said、不算 done、时间线上折叠成一行。
+  const counts = { wakes: 0, idleWakes: 0, browsed: 0, said: 0, chat: 0, comments: 0, dairies: 0 }
   let cur = null
   const orphan = { at: today[0]?.t ?? nowMs, actions: [], wake: null }
 
@@ -128,6 +131,25 @@ export function deriveStatus({ events = [], config = {}, now = new Date() } = {}
     }
     // 她的发言
     if (e?.type === 'utterance' || e?.type === 'narration' || e?.type === 'revise') {
+      // issue #32：`flags: ['uncommitted']` 是 turns.js 在她**答他的话**时打的标
+      // （settle 写进来的对话行，不是她自己认下的判断）。这类行以前混在 said 里：
+      // 一次 wake 加 45 句聊天，时间线 40 条全是「说了：…」，`idleWakes` 也从 1 变 0。
+      // 现在单列成 chat，只在时间线上折成一行「聊了 N 句」。
+      const isChat = Array.isArray(e?.flags) && e.flags.includes('uncommitted')
+      if (isChat) {
+        const last = cur ?? orphan
+        const prev = last.actions[last.actions.length - 1]
+        // 连续多句合进同一条，别让一次长对话把时间线刷成弹幕。
+        if (prev && prev.kind === 'chat') {
+          prev.n += 1
+          prev.at = t
+          prev.text = `聊了 ${prev.n} 句`
+        } else {
+          push(t, 'chat', '聊了 1 句', { n: 1 })
+        }
+        counts.chat += 1
+        continue
+      }
       counts.said += 1
       const one = text.replace(/\s+/g, ' ').slice(0, 60)
       push(t, 'say', one ? `说了：「${one}${text.length > 60 ? '…' : ''}」` : '说了点什么')
@@ -143,7 +165,9 @@ export function deriveStatus({ events = [], config = {}, now = new Date() } = {}
 
   // ---- 醒着但什么也没做的块，记成 idle ----
   for (const b of blocks) {
-    const done = b.actions.filter((a) => a.kind !== 'quiet' && a.kind !== 'fail')
+    // issue #32：chat 跟 quiet/fail 一样不算「做了什么」——聊天是她答他的话，
+    // 不是这一轮她自己起的动作。否则他在她醒着时随便接一句，这次 wake 就不算发呆了。
+    const done = b.actions.filter((a) => a.kind !== 'quiet' && a.kind !== 'fail' && a.kind !== 'chat')
     b.idle = done.length === 0
   }
   counts.idleWakes = blocks.filter((b) => b.idle).length
@@ -170,6 +194,10 @@ export function deriveStatus({ events = [], config = {}, now = new Date() } = {}
   } else if (recent && lastKind === 'say') {
     phase = 'talking'; label = '在想怎么回你'
     detail = activeBlock.actions[activeBlock.actions.length - 1].text
+  } else if (recent && lastKind === 'chat') {
+    // 刚跟他聊过几句：还是「在说话」，只是这些行不算她主动做的事（issue #32）。
+    phase = 'talking'; label = '在想怎么回你'
+    detail = ''
   } else if (recent && lastKind === 'diary') {
     phase = 'writing'; label = '在写日记'
     detail = ''

package/lib/store.js

@@ -14,6 +14,7 @@
  * API 全部 async：原子写用「写 tmp → rename」，避免断电留半行。
  */
 
+import { randomBytes } from 'node:crypto'
 import { promises as fs } from 'node:fs'
 import { dirname, join } from 'node:path'
 import { validateEvent, EVENT_SCHEMA_VERSION } from './schema.js'
@@ -89,7 +90,8 @@ const RENAME_RETRY = new Set(['EPERM', 'EACCES', 'EBUSY', 'ENOTEMPTY'])
 
 export async function writeAtomic(file, text, mode) {
   await ensureDir(dirname(file))
-  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`
+  // 随机后缀：同一进程同一毫秒的两次写不能共用一个临时文件，否则内容会交错，写出坏 JSON
+  const tmp = `${file}.${process.pid}.${Date.now()}.${randomBytes(4).toString('hex')}.tmp`
   await fs.writeFile(tmp, text, 'utf8')
   if (mode) await fs.chmod(tmp, mode).catch(() => {})
   for (let i = 0; i < RENAME_WAIT.length; i++) {
@@ -107,9 +109,19 @@ export async function writeAtomic(file, text, mode) {
   }
 }
 
+// issue #38：手改过的 JSON 常带 UTF-8 BOM（PowerShell 5.1 的
+// `Set-Content -Encoding UTF8`、记事本「带 BOM 的 UTF-8」都会写）。
+// `JSON.parse` 见到 BOM 直接抛 SyntaxError，于是**内容完好的文件**被下面的
+// 坏文件分支改名成 `.corrupt.<时间>`，config.json 退回全默认、owner.json 变 null、
+// home.json 直接新建一条会话——用户以为自己的改动丢了。
+// 只剥开头这一个字符；不动其余内容，也不改行号之外的任何字节。
+function stripBom(text) {
+  return typeof text === 'string' && text.charCodeAt(0) === 0xfeff ? text.slice(1) : text
+}
+
 export async function readJson(file, fallback = null) {
   try {
-    return JSON.parse(await fs.readFile(file, 'utf8'))
+    return JSON.parse(stripBom(await fs.readFile(file, 'utf8')))
   } catch (err) {
     if (err.code === 'ENOENT') return fallback
     // 坏文件不静默吞：留证据，返回 fallback 让上层能用

package/lib/tenant.js

@@ -62,6 +62,18 @@ export async function withFileLock(file, fn, { ttl = LOCK_TTL_MS, timeout = 8_00
       await fh.writeFile(JSON.stringify({ pid: process.pid, at: Date.now() }))
       break
     } catch (err) {
+      // issue #37：Windows 上文件正在被删除时，`open(file,'wx')` 返回 EPERM 而不是
+      // EEXIST。以前这会直接抛出去，ensureTalkSession 接住就返回「建会话的锁没拿到」，
+      // 这一次换会话就此失败；`test/tenant.test.mjs` 那条偶发红也是同一个原因。
+      //
+      // 注意**不能并进下面的 EEXIST 分支**：那里 stat 失败就判 stale 然后 continue，
+      // 不看 timeout，真的是权限错误时会死循环。EPERM 走独立分支、受 timeout 约束。
+      // 只认 win32：POSIX 上 EPERM 通常是真没权限，重试没有意义，照样抛。
+      if (err?.code === 'EPERM' && process.platform === 'win32') {
+        if (Date.now() - started > timeout) throw err
+        await new Promise((r) => setTimeout(r, wait))
+        continue
+      }
       if (err?.code !== 'EEXIST') throw err
       // 锁文件的 mtime 太老 = 上一任进程死在临界区里了（没来得及 unlink），直接接管。
       let stale = false

package/lib/turns.js

@@ -58,8 +58,12 @@ import { stripToolMarkup, hasToolMarkup } from './markup.js'
 /**
  * 我们自己 prompt 进去的消息，rpcId 会带这些前缀。
  * 只是"多一道保险"：真正的判据是 clientTimeZone（见 classifyMessage）。
+ *
+ * `carry` 是换会话前请她留话那条（home.js 的 `carry-ask-`）。少了它，那条
+ * 消息会掉进 `kind === 'user'` 且没有 clientTimeZone 的 `unknown` 分支：不进
+ * 轮数（行为正确），但每换一次会话就往日志里多一行「认不出来源」（2026-11-06）。
  */
-const PLUGIN_RPC = /^(wake|say|boot|report|letter|sleep|nudge|probe|turn|sys)[-_]/i
+const PLUGIN_RPC = /^(wake|say|boot|report|letter|sleep|nudge|probe|turn|sys|carry)[-_]/i
 
 /**
  * 宿主/我们这边自己拼的、**确定不是人打的** source.kind。

package/lib/upgrade.js

@@ -64,7 +64,10 @@ export function compareVersion(a, b) {
 
 async function readJson(file) {
   try {
-    return JSON.parse(await readFile(file, 'utf8'))
+    // issue #38：手改过的 package.json / 配置文件可能带 UTF-8 BOM。
+    // 这里以前直接 parse，BOM 会让内容完好的文件读成 null（升级自检于是当作没装）。
+    const text = await readFile(file, 'utf8')
+    return JSON.parse(text.charCodeAt(0) === 0xfeff ? text.slice(1) : text)
   } catch {
     return null
   }

package/package.json

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