@ssamurias/dsh-fish 0.8.9 → 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')
 }
@@ -135,6 +146,21 @@ export function tableFor(opts = {}) {
   return renderTable(opts.rows ?? [], { gapHours: gap })
 }
 
+/**
+ * 旧句子在空醒那一轮只摆一处（2026-11-05 真机 18:44 那次）。
+ *
+ * 摆料已经由 tableFor 渲染成「这次隔了 N 个小时。你写下的几行字还摊在那儿…」，
+ * 同一批行又被 deskFor 当 stale 摆进「桌上摊着这几样东西：」——她那一轮读到的是
+ * 同三句原话出现两遍，像系统在盘货。所以 tableText 非空时，桌子不再收 stale。
+ *
+ * @param {string} tableText
+ * @param {Array} rows staleLines() 的结果
+ * @returns {Array}
+ */
+export function staleForDesk(tableText, rows = []) {
+  return String(tableText ?? '').trim() ? [] : rows
+}
+
 /** 上一次叫醒到现在隔了多久（小时）。没有记录就返回 0。 */
 export function hoursSinceLastWake(events = [], now = Date.now()) {
   let last = 0

package/lib/drive.js

@@ -1,7 +1,7 @@
 /**
  * drive.js —— 「劲儿」：她什么时候攒够了想动一动（2026-11-05，用户 m02031）
  *
- * 由来：江屿那条线的做法是「攒一个 0..1 的数，到 0.8 想动一次，动完扣 0.55」。
+ * 由来：江屿那条线的做法是「攒一个 0..1 的数，到 0.8 想动一次，动完扣一点」。
  * 用户认可这个手感，但要它**从事件流算出来**，不另存一份 `drive.json`：
  * 落盘的状态会跟事件流各说各话，而她是谁只该由事件流决定。
  *
@@ -21,8 +21,8 @@
 export const DRIVE = Object.freeze({
   growthPerHour: 0.12,
   threshold: 0.8,
-  cost: 0.55,
-  minGapMs: 40 * 60_000,
+  cost: 0.8,
+  minGapMs: 2 * 60 * 60_000,
   /** 桌上每一样没合上的事 / 每一行旧句子各加多少（各最多算两份 / 三份）。 */
   boostGap: 0.06,
   boostStale: 0.04,
@@ -42,8 +42,13 @@ const HOUR = 3_600_000
 const DAY = 86_400_000
 
 function tsOf(e) {
-  const t = Number(e?.ts ?? e?.time ?? e?.at)
-  if (Number.isFinite(t) && t > 0) return t
+  const raw = e?.ts ?? e?.time ?? e?.at
+  // 事件里的 `ts` 是 ISO 字符串（不是毫秒数）：先按数字试，再按日期解析。
+  // 2026-11-05 真机：只写 `Number(raw)` 时字符串一律 NaN，出生时刻与「上次动过」
+  // 全被算成 0，劲儿永远 0.00（`还没有任何记录，不急着动`），修了锚点也没用。
+  if (typeof raw === 'number') return Number.isFinite(raw) && raw > 0 ? raw : 0
+  const asDate = Date.parse(String(raw ?? ''))
+  if (Number.isFinite(asDate) && asDate > 0) return asDate
   const d = Date.parse(String(e?.iso ?? e?.date ?? ''))
   return Number.isFinite(d) ? d : 0
 }
@@ -73,6 +78,34 @@ function lastHeardAt(events) {
   return last
 }
 
+/**
+ * 最早一条事件的时刻（她开始存在的那一刻）。
+ *
+ * 为什么要它：只认 `drive-spend:` / `proactive-turn:` / `proactive-silent:`
+ * 时，一个从没主动过的她会永远算成 0.00——那三类事件本来就要「先动一次」
+ * 才会写，于是第一动永远等不到（2026-11-05 真机 `drive 0.00 · 还没有任何记录`）。
+ * 出生就是起跑线：从她存在那一刻起，时间就在攒劲儿。
+ */
+function firstAt(events) {
+  let first = 0
+  for (const e of events) {
+    const ts = tsOf(e)
+    if (ts > 0 && (!first || ts < first)) first = ts
+  }
+  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
@@ -98,20 +131,22 @@ 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 }
-  const last = lastActionAt(events)
+  // 动过就从那次算；一次都没动过，就从她出生那一刻算（不能永远停在 0.00）。
+  const last = lastActionAt(events) || firstAt(events)
   if (!last) return { ...base, why: '还没有任何记录，不急着动' }
 
   const hoursSince = Math.max(0, (now - last) / HOUR)
   // 刚动过：哪怕攒得快，也得隔开一点——两次冲动贴在一起就不像冲动了。
   if (now - last < DRIVE.minGapMs) {
-    return { ...base, hoursSince, why: '刚动过，还没到 40 分钟' }
+    return { ...base, hoursSince, why: '刚动过，还没到两小时' }
   }
 
   // 上次开口没人接：底噪打折（不是惩罚，只是「说了也没人接」这件事本身的重量）。
   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)
@@ -140,6 +175,20 @@ export function driveOf({ events = [], now = Date.now(), desk = null, stage = 1
   }
 }
 
+/**
+ * 桌上有没有可说的东西（2026-11-05，用户 m02937）。
+ *
+ * 劲儿只回答「攒够了没有」，不回答「攒够了有没有事可说」。空桌醒来她只能回一句
+ * 「没什么要说的」——那既占额度，又在对话里留一条噪音。所以材料也是判据，不是装饰。
+ *
+ * @param {{gaps?:number, stale?:number, echo?:boolean, favorite?:boolean}|null} desk
+ * @returns {boolean}
+ */
+export function deskHasMaterial(desk) {
+  if (!desk) return false
+  return Number(desk.gaps) > 0 || Number(desk.stale) > 0 || desk.echo === true || desk.favorite === true
+}
+
 /** 一次行动的代价（动完扣掉）。留给记账用，纯数值。 */
 export function driveCost() {
   return DRIVE.cost

package/lib/freewake.js

@@ -13,10 +13,10 @@
  *   - table：旧句子要摆出来的那一次（lib/dreamtable.js 的三道门已经判过）。
  *   - think：**兜底**（2026-11-05，用户 m02008 拍板）。原来按「每 3 天一次」的日历开，
  *     现在改成：过去 `QUIET_DAYS` 天里她一件自发的事都没有（没有 utterance /
- *     narration / dream / 主动开口），才由日历补一次。劲儿正常工作时不该再出现
+ *     narration / dream / 主动开口；聊天回合补写的 uncommitted 行不算），才由日历补一次。劲儿正常工作时不该再出现
  *     「同一天醒两次」，所以这一条只在劲儿长期趴着时生效。
  *
- * 只在本机开发副本里生效（调用方用 devModeSync 包住）。公开版看到的仍是原来那张卡。
+ * 0.9.0 起公开：所有机器都能空醒；想关掉把 config.memory.thinkEveryDays 设 0。
  */
 
 import { tsMs, HER_TYPES } from './schema.js'
@@ -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
   }
@@ -67,6 +70,8 @@ export function freeWakeFor({ tableText = '', events = [], dk = '', now = Date.n
   // 摆料优先：材料在那儿，这一轮就该只有材料。
   if (String(tableText ?? '').trim()) return { kind: 'table', note: FREE_NOTE }
 
+  // 0.9.0：空醒有一个设置页开关（memory.selfWake）。关掉就只剩摆料，不再自己找事做。
+  if (config?.memory?.selfWake === false) return null
   const every = Number(config?.memory?.thinkEveryDays ?? THINK_EVERY_DAYS)
   if (!(every > 0)) return null
 
@@ -80,3 +85,17 @@ export function freeWakeFor({ tableText = '', events = [], dk = '', now = Date.n
 
   return { kind: 'think', note: FREE_NOTE }
 }
+
+/**
+ * 这一轮还要不要摆世界动静与惦记清单。
+ *
+ * 2026-11-05 用户 m01128：table 那一轮连 B 站和桌子都去掉，只留便条、时间、
+ * 旧句子和「这一轮没有待办」——工具常量那一句留着，那不是活，是她世界里的常量。
+ * think 那一轮照旧：它本来就是「隔些日子空一次」，没有材料可给，世界动静是唯一的东西。
+ *
+ * @param {{kind:string}|null} free
+ * @returns {boolean}
+ */
+export function keepWorldOnWake(free) {
+  return free?.kind !== 'table'
+}

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
 
@@ -789,11 +826,56 @@ async function askForLastWords(ctx, { sessionId, root, log } = {}) {
   return pickLastWords(say.join('\n'))
 }
 
+// 同一个 root 只允许有一次「换房间」在飞（0.8.8 用户报的房间分裂）：
+// `/say` 的结账与 turns 的结账是两条独立路径，都可能在满 rotateAfter 时触发。
+// 没有互斥时各自 sc.create 一条新会话：侧栏多出一间同名空房，先建的那条
+// 还可能已经跑了一轮，从此成了看不到的孤儿；两条入口也各记各的轮数。
+// 进程内用这条 promise 链单飞；跨进程由 withFileLock + home.json 的 sessionId 比对兜住。
+const rotateInflight = new Map()
+
 /**
  * 换一个新会话：旧的改名留档，新的接管，原话搬过去。
- * @returns {Promise<{ok:boolean, sessionId:string, old?:string, why?:string}>}
+ *
+ * 0.8.8：并发调用合并成一次——后来者直接等前面那次的结果，不再各建一条。
+ * `from` 是调用方这句话真正投递进去的那条会话 id；home.json 已经指向别的会话，
+ * 说明另一条入口抢先换过了（或者人已经不在家记着的这条里说话），这次跳过不换。
+ *
+ * @returns {Promise<{ok:boolean, sessionId:string, old?:string, why?:string, skipped?:boolean}>}
  */
-export async function rotateTalkSession(ctx, { root = rootDir(), wsId, title = TITLE_SESSION, stamp, log } = {}) {
+export async function rotateTalkSession(ctx, opts = {}) {
+  const root = opts.root ?? rootDir()
+  const key = String(root).toLowerCase()
+  const flying = rotateInflight.get(key)
+  if (flying) return flying
+  const p = (async () => {
+    try {
+      const res = await withFileLock(
+        sessionLockFile(root),
+        () => rotateTalkSessionOnce(ctx, { ...opts, root }),
+        opts.lockOpts,
+      )
+      if (res && res.locked === false) {
+        // 另一个进程正在换：它换完会把 sessionId 写进 home.json，这里读一眼就跳过。
+        const saved = await readJson(homeFile(root), null).catch(() => null)
+        const sid = String(saved?.sessionId ?? '')
+        const from = String(opts.from ?? '')
+        if (sid && (!from || sid !== from)) {
+          return { ok: true, sessionId: sid, old: String(saved?.rotatedFrom ?? ''), skipped: true, why: res.why }
+        }
+        return { ok: false, sessionId: '', why: res.why }
+      }
+      return res
+    } catch (err) {
+      return { ok: false, sessionId: '', why: `换会话的锁没拿到：${String(err?.message ?? err).slice(0, 120)}` }
+    }
+  })().finally(() => {
+    if (rotateInflight.get(key) === p) rotateInflight.delete(key)
+  })
+  rotateInflight.set(key, p)
+  return p
+}
+
+async function rotateTalkSessionOnce(ctx, { root = rootDir(), wsId, title = TITLE_SESSION, stamp, log, from = '' } = {}) {
   const sc = ctx.sessionController
   if (!sc?.create) return { ok: false, sessionId: '', why: '宿主没有会话服务' }
 
@@ -802,24 +884,72 @@ export async function rotateTalkSession(ctx, { root = rootDir(), wsId, title = T
   if (!wid) return { ok: false, sessionId: '', why: '没有工作区 id' }
 
   const old = String(saved.sessionId ?? '')
+  // 0.8.8：这条路径进来时屋子已经换过了（另一条入口抢先、或 concurrent 的
+  // 第二次调用在单飞窗口之外到）——不要再建第二条。
+  const fromId = String(from ?? '')
+  if (fromId && old && fromId !== old) {
+    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 / 超时 / 她说「不用」都只是没有这一节；
@@ -837,22 +967,6 @@ export async function rotateTalkSession(ctx, { root = rootDir(), wsId, title = T
     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` 换一次会话全丢：
@@ -880,6 +994,9 @@ export async function rotateTalkSession(ctx, { root = rootDir(), wsId, title = T
       }
       delete next.status
       delete next.archivedAt
+      // 换成了，把上次失败的记账清掉（否则下一次到点时会被误判成还在冷却期）
+      delete next.rotateFailAt
+      delete next.rotateFailWhy
       // 0.8.7：这一轮先清掉旧的那句。她要是留了，后台回来之后再补写
       // （见下面 pendingWords.then）。留着上一轮那句会让新房间读到一句
       // 不是这次说的「最后一句」——比没有更糟。

package/lib/inbox.js

@@ -196,9 +196,14 @@ export async function writeInboxFile(root = rootDir(), { limit = 60 } = {}) {
   return file
 }
 
-/** 事件流里已经存在的她自己写的话（供 say/wake 判断"这轮她开没开口"） */
+/**
+ * 事件流里已经存在的她自己写的话（供 say/wake 判断"这轮她开没开口"）
+ *
+ * 不收 uncommitted：那是别处聊天回合结束时补写的，没认领，也不是这一轮说的。
+ * 群里 /say 最长等 75 秒，侧栏回合正好结束时，私聊原话会被当成她在群里的回复。
+ */
 export function newHerEventsSince(events, sinceId) {
   const idx = sinceId ? events.findIndex((e) => e.id === sinceId) : events.length
   const from = idx >= 0 ? idx + 1 : 0
-  return events.slice(from).filter((e) => SPEAK_TYPES.has(e.type))
+  return events.slice(from).filter((e) => SPEAK_TYPES.has(e.type) && !(Array.isArray(e.flags) && e.flags.includes('uncommitted')))
 }

package/lib/index.js

@@ -25,7 +25,6 @@ import { registerBringBack } from './keep.js'
 import { registerAsk } from './ask.js'
 import { registerDream } from './dream.js'
 import { registerProactive } from './proactive.js'
-import { devModeSync } from './devmode.js'
 import { registerObserve } from './observe.js'
 import { startScheduler } from './scheduler.js'
 import { registerTurns } from './turns.js'
@@ -47,7 +46,7 @@ import { logBoot, makeLogger } from './log.js'
 export const name = 'dsh-fish'
 
 /** 版本号：只用于日志导出（排查时第一件事是确认跑的是哪一版）。 */
-export const VERSION = '0.8.9'
+export const VERSION = '0.9.1'
 
 // ⚠️ 一个数组写全，不要拆成对象
 // 2026-10-30（m02961）：`userQuestions` **不再写进 inject**。写进 inject 的东西缺一个，
@@ -223,10 +222,9 @@ export function apply(ctx, baseConfig = {}) {
         herDir,
         extra: config?.tools?.allow ?? [],
         enabled: config?.tools?.restrict !== false,
-        // 本机实验工具（m02837）：与注册、提示词共用 devModeSync 一个判据。
-        dream: devModeSync(root),
-        // 主动说话（m04610）：her_say 同样只在 .dev 下进白名单。
-        proactive: devModeSync(root),
+        // 0.9.0 起公开：梦与主动说话不再是本机实验。
+        dream: true,
+        proactive: true,
         log: (...a) => logger.info(...a),
         onResult: (r) => { restrictState = r },
       })
@@ -355,14 +353,12 @@ export function apply(ctx, baseConfig = {}) {
         // 0.7.6（2026-10-30 m01274）：请求事件。她有事想征得同意时弹一张卡，
         // 每天 1 次、每周 3 次；只有 time / rest 真会改东西（见 lib/ask.js）。
         () => registerAsk(ctx, { root, tenant: tenancy }),
-        // 0.8.1 本机实验（2026-10-30 m02837）：梦 A 案——醒来记一句。
-        // **只在 .dev 存在时注册**：公开版里她既没有这个工具，也不该在身份里读到它。
-        ...(devModeSync(root) ? [() => registerDream(ctx, { root, tenant: tenancy })] : []),
-        // 0.8.1 本机实验（2026-10-30 m04610）：主动说话——她自己判断有没有话想说。
-        // 同样只在 .dev 下注册；公开版没有 her_say，也没有空手回合。
+        // 0.8.1 起（2026-10-30 m02837）：梦 A 案——醒来记一句。0.9.0 起公开。
+        () => registerDream(ctx, { root, tenant: tenancy }),
+        // 0.8.1 起（2026-10-30 m04610）：主动说话——她自己判断有没有话想说。0.9.0 起公开。
         // 2026-10-30 真机：这里原来只有 { root, log }，guardWrite 拿到 undefined 的 state，
         // checkCaller(undefined) 每次都判「不在这个家」；写入守卫要的是 tenancy。
-        ...(devModeSync(root) ? [() => registerProactive(ctx, { root, tenant: tenancy, log: (...a) => logger.info(...a) })] : []),
+        () => registerProactive(ctx, { root, tenant: tenancy, log: (...a) => logger.info(...a) }),
       ]) {
         try {
           const d = reg()

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)) {
@@ -103,13 +105,33 @@ export function interestOf(events = [], now = Date.now(), { minHits = INTEREST_M
 }
 
 /**
- * 摆到桌上的那一行。没有就返回空串（调用方直接不 push）。
+ * 把一整句话收成一个能读的短标签（2026-11-05 用户 m02562：原来的整句看不懂）。
+ *
+ * 四步，每一步都只在做「去掉不是主题的部分」，不改她自己的说法：
+ *   1. 去掉开头的旁注（`（她主动说）`这种，是我们加的标注，不是她的话）；
+ *   2. 内层引号换成双引号，避免 `「「` 嵌套；
+ *   3. 断在第一个逗号——后面的多半是她对这句话的解释；
+ *   4. 太长再截断。
  */
+export const TOPIC_LABEL_MAX = 24
+
+export function topicLabel(text, max = TOPIC_LABEL_MAX) {
+  let s = String(text ?? '').trim()
+  s = s.replace(/^（[^）]*）\s*/, '')
+  s = s.replace(/「/g, '“').replace(/」/g, '”')
+  s = s.split(/[，,。；;]/)[0].trim()
+  s = s.replace(/^[“”"']+|[“”"']+$/g, '')
+  if (!s) return ''
+  return s.length > max ? `${s.slice(0, max - 1)}…` : s
+}
+
+/** 摆到桌上的那一行。没有就返回空串（调用方直接不 push）。 */
 export function renderInterest(items = []) {
   const first = Array.isArray(items) ? items[0] : null
   if (!first?.text) return ''
-  const text = first.text.length > INTEREST_TEXT_MAX ? `${first.text.slice(0, INTEREST_TEXT_MAX - 1)}…` : first.text
-  return `最近你总回到「${text}」这件事上。`
+  const label = topicLabel(first.text)
+  if (!label) return ''
+  return `你最近总说到「${label}」。`
 }
 
 /** 把兴趣当劲儿的一笔冲动：有就返回 true。 */

package/lib/log.js

@@ -218,6 +218,27 @@ export function redactConfig(cfg) {
   return clone
 }
 
+/**
+ * 事件流尾巴的一行，进导出包之前过一遍。
+ *
+ * 设置页答应了「不含正文」「没有她说过的话」，导出又是让人转手交给别的 AI 的。
+ * 用白名单而不是删 text：refuse.quote、ask.subject 也带原话，以后加的字段也可能带。
+ * meta 不走白名单：`watched:` 这类计数和失败记录，正是这段尾巴存在的理由。它和别的行
+ * 一样还要过 scrub。
+ */
+function exportEventLine(line) {
+  let ev = null
+  try {
+    ev = JSON.parse(line)
+  } catch { /* 下面按坏行算 */ }
+  // 解析不了、不是对象（裸字符串之类），或没有 type 这个基本字段：不知道里面是什么，只报长度
+  if (!ev || typeof ev !== 'object' || Array.isArray(ev) || typeof ev.type !== 'string') return `(坏行，长 ${line.length} 字符，内容不导出)`
+  if (ev.type === 'meta') return line
+  const { id, ts, type } = ev
+  const flags = Array.isArray(ev.flags) ? ev.flags : []
+  return JSON.stringify({ id, ts, type, flags, textLen: typeof ev.text === 'string' ? ev.text.length : 0 })
+}
+
 /**
  * 导出包：一次给 AI 看够。
  * 顺序按"排查时最先想看什么"排：环境 → 模型 → 自检 → 工具面 → 事件流 → 日志 → 宿主报错。
@@ -286,7 +307,7 @@ export function buildBundle(root, {
   if (eventLines > 0) {
     const ev = tailEvents(root, { lines: eventLines })
     out.push('', `--- 事件流（最近 ${ev.lines.length} 条，文件共 ${ev.bytes} 字节）---`)
-    out.push(ev.exists ? (ev.lines.length ? ev.lines.map((l) => scrub(l)).join('\n') : '(空)') : '(还没有 events.jsonl)')
+    out.push(ev.exists ? (ev.lines.length ? ev.lines.map((l) => scrub(exportEventLine(l))).join('\n') : '(空)') : '(还没有 events.jsonl)')
   }
 
   const log = tailLog(root, { lines })