@ssamurias/dsh-fish 0.8.9 → 0.9.0

package/lib/client.js

@@ -12,7 +12,10 @@
  *   没有任何指向她本人的控件 —— 那是 B §8 的红线。
  */
 window.__ModuleLoader__.load({
-  id: 'dsh-fish',
+  // 这个 id 必须**等于 package.json 的包名**，不是短名：client-modules 用 loader
+  // 条目名（完整包标识）去解析浏览器 bundle，注册时名字对不上，这一节就静默挂不上
+  // ——宿主那半边照常跑，设置页却什么也不显示（2026-11-05 改名 @ssamurias/dsh-fish 后踩过）。
+  id: '@ssamurias/dsh-fish',
   factory: (require) => {
     const module = { exports: {} }
     const exports = module.exports
@@ -380,6 +383,12 @@ window.__ModuleLoader__.load({
       const [proactiveOn, setProactiveOn] = useState(false)
       const [proactiveMax, setProactiveMax] = useState(2)
       const [proactiveIdle, setProactiveIdle] = useState(6)
+      // 2026-11-05（用户 m02634）：梦 / 主动性 / 兴趣 三个开关，默认全开。
+      const [driveOn, setDriveOn] = useState(true)
+      const [interestOn, setInterestOn] = useState(true)
+      const [dreamEnabled, setDreamEnabled] = useState(true)
+      // 空醒开关（0.9.0 公开）：醒来时没派活、桌上也没东西，她可以自己找点事做。
+      const [selfWakeOn, setSelfWakeOn] = useState(true)
       const [avoidText, setAvoidText] = useState('')
       // 刷站（全是环境参数：她今天能不能出门、一次看见几条，不是她爱看什么）
       const [browseOn, setBrowseOn] = useState(true)
@@ -588,6 +597,10 @@ window.__ModuleLoader__.load({
             setProactiveMax(Number(pr.maxPerDay ?? 2))
             setProactiveIdle(Number(pr.minIdleHours ?? 6))
           }
+          setDriveOn(s.config?.drive?.enabled !== false)
+          setInterestOn(s.config?.interest?.enabled !== false)
+          setDreamEnabled(s.config?.dream?.enabled !== false)
+          setSelfWakeOn(s.config?.memory?.selfWake !== false)
 
           // 不再拉 /events（2026-11-02，用户 m00335）：这里取回来的 e.rows 只进了
           // setEvents，全文件没有一处渲染它——每 30 秒白拉 25 条事件（九成是后台记账）。
@@ -667,6 +680,10 @@ window.__ModuleLoader__.load({
           setBrowseDanmaku(Number(cfg.browse?.danmaku ?? 6))
           setBiliMinGap(Number(cfg.bili?.minIntervalMs ?? 800))
           setBiliJitter(Number(cfg.bili?.jitterMs ?? 500))
+          setDriveOn(cfg.drive?.enabled !== false)
+          setInterestOn(cfg.interest?.enabled !== false)
+          setDreamEnabled(cfg.dream?.enabled !== false)
+          setSelfWakeOn(cfg.memory?.selfWake !== false)
           setNotifyOn(cfg.notify?.enabled === true)
           setCommentOn(cfg.comment?.enabled === true)
           setCommentPerDay(Number(cfg.comment?.perDay ?? 1))
@@ -881,6 +898,14 @@ window.__ModuleLoader__.load({
         } catch (e) { setSaveFail(e.message) }
       }
 
+      // 顶层那三个开关（梦 / 主动性 / 兴趣）：各写各的组，互不覆盖。
+      const patchGroup = async (key, patch) => {
+        try {
+          await jpost('/config', { [key]: patch })
+          flashSaved()
+        } catch (e) { setSaveFail(e.message) }
+      }
+
       // 改完就生效：任何一项变了，停手 700ms 就写盘（连点加减号也只写一次）。
       const cfgSig = JSON.stringify(buildConfig())
       useEffect(() => {
@@ -2119,21 +2144,48 @@ window.__ModuleLoader__.load({
               hint: '超过这么多天没说话，她会记下「你不在」。' }))),
         // 主动说话（0.8.1 本机实验）：只有 .dev 下才出现。频率是上限，不是任务——
         // 开关开着也不代表她每天都会说，说不说由她自己判断（见 lib/proactive.js）。
-        state?.dev === true ? group('主动说话（本机实验）',
-          '她想说话的时候可以自己开口，不是被提醒推着说。这里调的是「最多说几次」和「多久没说话才可能开口」，不是命令她每天必须说。',
+        // 主动搭话（0.8.1 起，0.9.0 公开）：只留三件跟「开口」直接有关的事。
+        // 劲儿与兴趣是另一套东西，各自一张卡——混在一张卡里，用户分不清哪一项在管什么。
+        group('主动搭话',
+          '她可以自己找你说话，不用你先开口。这里调的是上限：开着也可能好几天不说，那是她的判断，不是坏了。',
           h('div', { className: 'grid2' },
             Toggle({ label: '允许她主动开口', on: proactiveOn,
               onChange: (v) => { setProactiveOn(v); patchProactive({ enabled: v }) },
-              hint: '关着就等于没有这个功能。开着也可能好几天不说——那是她的判断，不是故障。' }),
+              hint: '关掉就完全没有这个功能。' }),
             Sel({ label: '一天最多几次', value: proactiveMax,
               onChange: (v) => { setProactiveMax(v); patchProactive({ maxPerDay: Number(v) }) },
               options: [0, 1, 2, 3, 4, 5, 6],
               fmt: (v) => (Number(v) === 0 ? '0 次 · 不主动' : `最多 ${v} 次`),
-              hint: '上限，不是配额。到了上限只是不能再开新的空手回合，第二天照常。' }),
-            Num({ label: '多久没说话才可能开口', value: proactiveIdle,
+              hint: '上限，不是任务。到了上限只是今天不再多开一轮，第二天照常。' }),
+            Num({ label: '你多久没说话，她才可能开口', value: proactiveIdle,
               onChange: (v) => { setProactiveIdle(v); patchProactive({ minIdleHours: Number(v) }) },
               min: 1, max: 24, unit: '小时',
-              hint: '越久没说话，开口的概率越高（有上限）。刚聊完不会立刻再开一次。' }))) : null,
+              hint: '越久没说话，她越可能开口（有上限）。刚聊完不会马上又来找你。' }))),
+        // 主观能动性：不是「定时叫她说话」，而是她心里慢慢攒的一股劲。
+        group('主观能动性',
+          '她心里会慢慢攒一股想动的劲：越久没自己动过、桌上越有值得看的东西，攒得越快。攒够了才会自己醒一次——不按钟点，也不是每天必须。',
+          h('div', { className: 'grid2' },
+            Toggle({ label: '让她自己攒这股劲', on: driveOn,
+              onChange: (v) => { setDriveOn(v); patchGroup('drive', { enabled: v }) },
+              hint: '关掉：她不会自己开一轮，只在你叫她、或者日程到点时才醒。已经发生的事不受影响。' }))),
+        // 兴趣与惦记：她醒来时桌上摆的那几样东西。
+        group('兴趣',
+          '她醒来的时候，桌上会摆几样她自己的东西：问过还没答案的问题、翻到过的旧句子、你回没回她留的那句话、最近总说到的那件事。这些只给她看，不会变成待办。',
+          h('div', { className: 'grid2' },
+            Toggle({ label: '醒来时把这些摆出来', on: interestOn,
+              onChange: (v) => { setInterestOn(v); patchGroup('interest', { enabled: v }) },
+              hint: '关掉：只叫醒，桌上不放东西。' })),
+          h('div', { className: 'grid2' },
+            Toggle({ label: '醒着没事时，自己找点事做', on: selfWakeOn,
+              onChange: (v) => { setSelfWakeOn(v); patchGroup('memory', { selfWake: v }) },
+              hint: '她醒来时没有派活、桌上也没有东西，可以自己翻翻旧句子、写点什么，或者什么都不做。关掉只影响「自己找事做」这一种醒来。' }))),
+        // 梦：独立一张卡（用户 m02765 要求从「日记」里拿出来——它跟日记不是一件事）。
+        group('做梦',
+          '她醒来可以记一句梦。梦只能用她自己说过的话拼出来，不会改任何设置，也不算成长。',
+          h('div', { className: 'grid2' },
+            Toggle({ label: '允许她记梦', on: dreamEnabled,
+              onChange: (v) => { setDreamEnabled(v); patchGroup('dream', { enabled: v }) },
+              hint: '关掉后不再记新的，已经记下的一条不删。' }))),
         group('日记',
           '她每天会写日记。打开下面那个开关，你就能看。',
           h('div', { className: 'grid2' },
@@ -2287,6 +2339,42 @@ window.__ModuleLoader__.load({
                   ? h('p', { className: 'empty' }, '读取中…')
                   : h('pre', null, esc(diaryCache.current[diaryCur])))),
 
+        // ---- 梦（2026-10-30 m02837；0.9.0 起对所有人显示；2026-11-05 用户 m03247 搬到住所页，和日记、小纸条放一起）----
+        // 0.9.0 拆了 .dev 门：her_dream 对所有人注册，`/dream` 也不再 404，所以这张卡不再按 dev 藏。
+        // 2026-11-05：改成「昨夜」一张卡——梦不是她的成长数据，是一句给她自己和给你看的话。
+        // 卡片右下角把她引用的那几行原文摆出来，让你一眼看见这句梦是从哪儿长出来的。
+        group('她做过的梦',
+          '她偶尔会把真实发生过的事重新拼成一句梦；不算成长，也不会被当成新的记忆。',
+          !dreams ? h('p', { className: 'dim' }, '还没读到。')
+            : !(dreams.items ?? []).length ? h('p', { className: 'dim' }, '她还没记过梦。')
+            : (() => {
+                const list = dreams.items ?? []
+                const latest = list[list.length - 1]
+                const older = list.slice(0, -1).reverse().slice(0, 5)
+                const when = (ts) => {
+                  const d = new Date(ts)
+                  if (!Number.isFinite(d.getTime())) return ''
+                  const hours = (Date.now() - d.getTime()) / 3_600_000
+                  return hours >= 0 && hours <= 30 ? '昨夜' : `${d.getMonth() + 1} 月 ${d.getDate()} 日`
+                }
+                return h('div', null,
+                  h('div', { className: 'hint', style: { margin: '0 0 4px' } }, when(latest.ts)),
+                  h('div', { style: { fontSize: '15px', lineHeight: 1.8 } }, latest.text),
+                  (latest.sources ?? []).length
+                    ? h('div', { style: { marginTop: '10px' } },
+                        h('div', { className: 'dim', style: { margin: '0 0 3px' } }, '这句话是从这几行长出来的'),
+                        ...latest.sources.map((s) => h('div', { className: 'dim', key: s.id },
+                          s.text ? `「${s.text}」` : `（这条已经翻不到了：${s.id}）`)))
+                    : null,
+                  older.length
+                    ? h('div', { style: { marginTop: '12px' } },
+                        h('div', { className: 'dim' }, `更早的 ${list.length - 1} 条`),
+                        ...older.map((d) => h('div', { key: d.id, style: { marginTop: '6px' } },
+                          h('div', { className: 'hint', style: { margin: '0 0 2px' } }, `${d.day} · 引用了 ${(d.refs ?? []).length} 件`),
+                          h('div', null, d.text))))
+                    : null)
+        })),
+
         inboxCard,
 
         group('本插件工作自检',
@@ -2672,44 +2760,6 @@ window.__ModuleLoader__.load({
                   '体检只看账本，不评价对错。两句话对不上不是错误——都可能是她当时真心这么想；快忘掉也不代表不重要，只是还没被反复提起或检验。')),
         ),
 
-        // ---- 梦（2026-10-30 m02837，本机实验 A 案）----
-        // 只在 .dev 下渲染：公开版没有 her_dream 这个工具，`/dream` 也直接 404。
-        // 2026-11-05：改成「昨夜」一张卡——梦不是她的成长数据，是一句给她自己和给他看的话。
-        // 卡片右下角把她引用的那几行原文摆出来，让他一眼看见这句梦是从哪儿长出来的。
-        state?.dev === true
-          ? group('梦（本机实验）',
-              '只在这台机器的开发副本里显示。她醒来后可以把真实发生过的事重新拼成一句梦；不算成长，也不会被当成新的记忆。',
-              !dreams ? h('p', { className: 'dim' }, '还没读到。')
-                : !(dreams.items ?? []).length ? h('p', { className: 'dim' }, '她还没记过梦。')
-                : (() => {
-                    const list = dreams.items ?? []
-                    const latest = list[list.length - 1]
-                    const older = list.slice(0, -1).reverse().slice(0, 5)
-                    const when = (ts) => {
-                      const d = new Date(ts)
-                      if (!Number.isFinite(d.getTime())) return ''
-                      const hours = (Date.now() - d.getTime()) / 3_600_000
-                      return hours >= 0 && hours <= 30 ? '昨夜' : `${d.getMonth() + 1} 月 ${d.getDate()} 日`
-                    }
-                    return h('div', null,
-                      h('div', { className: 'hint', style: { margin: '0 0 4px' } }, when(latest.ts)),
-                      h('div', { style: { fontSize: '15px', lineHeight: 1.8 } }, latest.text),
-                      (latest.sources ?? []).length
-                        ? h('div', { style: { marginTop: '10px' } },
-                            h('div', { className: 'dim', style: { margin: '0 0 3px' } }, '这句话是从这几行长出来的'),
-                            ...latest.sources.map((s) => h('div', { className: 'dim', key: s.id },
-                              s.text ? `「${s.text}」` : `（这条已经翻不到了：${s.id}）`)))
-                        : null,
-                      older.length
-                        ? h('div', { style: { marginTop: '12px' } },
-                            h('div', { className: 'dim' }, `更早的 ${list.length - 1} 条`),
-                            ...older.map((d) => h('div', { key: d.id, style: { marginTop: '6px' } },
-                              h('div', { className: 'hint', style: { margin: '0 0 2px' } }, `${d.day} · 引用了 ${(d.refs ?? []).length} 件`),
-                              h('div', null, d.text))))
-                        : null)
-                  })())
-          : null,
-
         // ---- 原来这里的「信箱」卡 2026-10-29（用户 m02105）搬到住所页，改名「她写的小纸条」----
       )
 
@@ -3018,7 +3068,7 @@ window.__ModuleLoader__.load({
       const startInstall = async (version) => {
         const v = version || dl?.version
         if (!v) return
-        if (!window.confirm(`安装会先关掉 DeepSeek Harness，再由后台脚本替换插件、装完自动重开。没发出去的话先发完。现在装 v${v}？`)) return
+        if (!window.confirm(`安装会先关掉 DeepSeek Harness，装完自己重开——不会弹任何窗口，所以中途看到它没了不用找它。没发出去的话先发完。现在装 v${v}？`)) return
         setDl({ ...dl, version: v, phase: 'installing', note: '正在准备安装…' })
         try {
           const r = await jpost('/update/install', { version: v })
@@ -3026,10 +3076,10 @@ window.__ModuleLoader__.load({
             setDl({ ...dl, version: v, phase: 'failed', error: r.error || '安装没能开始。' })
             return
           }
-          setDl({ ...dl, version: v, phase: 'installing', note: r.note || '正在关闭应用…' })
+          setDl({ ...dl, version: v, phase: 'installing', note: r.note || '正在关闭应用…装完会自己打开，中间不会有窗口。' })
         } catch {
           // 应用可能在响应发回来之前就退了——这时候报"失败"是错的。
-          setDl({ ...dl, version: v, phase: 'installing', note: '正在关闭应用…' })
+          setDl({ ...dl, version: v, phase: 'installing', note: '正在关闭应用…装完会自己打开，中间不会有窗口。' })
         }
       }
 
@@ -3047,7 +3097,7 @@ window.__ModuleLoader__.load({
         }))
 
       const aboutCard = group('关于',
-        '这个插件是从 GitHub 装的，装完之后没有东西会提醒你作者又发了新版——想查就点一下。',
+        '这个插件是从 npm 或 GitHub 装的，装完之后没有东西会提醒你作者又发了新版——想查就点一下。',
         h('div', null,
           rowTip('当前版本', curVer || '读不到',
             '插件自己记的版本号，和 GitHub 上 tag 对应的那个。'),

package/lib/compact.js

@@ -185,12 +185,30 @@ export function planWakeCompaction(events = [], { startSeq, endSeq, rpcId = '' }
  *   `done` 解析为 `{ ok, spoke, startSeq, endSeq, events, session, why? }`；
  *   `ok:false` 表示没等到闭合区间（超时/投递没出现），调用方只记账不折。
  */
+/**
+ * 她这句是不是「没什么要说的」（2026-11-05，用户 m02937）。
+ *
+ * 一个回合总得产出点什么，所以「不想说」在文本界面上常常变成一句元话语。
+ * 这不是开口：记账时按静默处理、整轮折掉。判据故意做窄——短、且开头就交代
+ * 「这一轮/今天没什么要说的」，避免把真话误判。
+ *
+ * @param {string} text
+ * @returns {boolean}
+ */
+export function looksLikeNothingSaid(text) {
+  const t = String(text ?? '').trim()
+  if (!t || t.length > 60) return false
+  if (/^(这一轮|这一回合|今天|这会儿|这次)[^。！？]{0,30}(没什么|没有|没)(什么)?(可)?(要|想|好)?说/.test(t)) return true
+  return /^(没什么|没有)(什么)?(可)?(想|要)?说的/.test(t) && t.length <= 40
+}
+
 export function followWake(ctx, { rpcId = '', timeoutMs = WAKE_FOLLOW_TIMEOUT_MS, log } = {}) {
   const rid = String(rpcId ?? '')
   const events = []
   let session = null
   let startSeq = -1
   let spoke = false
+  let said = ''
   let settled = false
   let off = null
   let timer = null
@@ -216,6 +234,7 @@ export function followWake(ctx, { rpcId = '', timeoutMs = WAKE_FOLLOW_TIMEOUT_MS
     resolveDone({
       ok: false,
       spoke,
+      said,
       startSeq,
       endSeq: -1,
       events,
@@ -256,7 +275,13 @@ export function followWake(ctx, { rpcId = '', timeoutMs = WAKE_FOLLOW_TIMEOUT_MS
         return
       }
       events.push(event)
-      if (String(event?.type ?? '') === 'assistant/message' && assistantText(event?.data)) spoke = true
+      if (String(event?.type ?? '') === 'assistant/message') {
+        const text = assistantText(event?.data)
+        if (text) {
+          spoke = true
+          said = said ? said + String.fromCharCode(10) + text : text
+        }
+      }
     } catch (err) {
       log?.('compact · 事件处理失败', err?.message ?? err)
     }

package/lib/derive.js

@@ -381,18 +381,20 @@ export function deriveSelf(events = [], opts = {}) {
         break
 
       case 'utterance': {
-        // 她试过改自己：落库留证，但不计入信念（B §5，对应自我服务偏差）
-        // 双保险：落库时打的 flag 与文本复检，任一命中即算（防止旧数据/手工注入绕过）
-        if (flags.includes('selfmod') || detectSelfMod(ev.text)) {
-          selfmod.push({ id: ev.id, at: ev.ts, text: ev.text })
-          break
-        }
         // 2026-11-02（用户 m00680）：她在侧栏里说出口、但没调 growth_commit 认领的话，
         // 由 turns.js 补写进来并打 uncommitted。它和 selfmod 一样**只留证、不进信念**：
         // 没认领的话不该改她的称呼、不该覆盖自我叙述、不该参与固化与"新话率"。
         // 但它要能进 wontCount（见下面 REFUSE_RE 那段）——否则"她当场拒绝了却没人记"
         // 这个 bug 就还在。
+        // 必须排在 selfmod 前面：schema.js 落库时正则命中就自动补 selfmod，
+        // 聊天里一句「别把我改成那样」不能算她想让人改自己。
         if (flags.includes('uncommitted')) break
+        // 她试过改自己：落库留证，但不计入信念（B §5，对应自我服务偏差）
+        // 双保险：落库时打的 flag 与文本复检，任一命中即算（防止旧数据/手工注入绕过）
+        if (flags.includes('selfmod') || detectSelfMod(ev.text)) {
+          selfmod.push({ id: ev.id, at: ev.ts, text: ev.text })
+          break
+        }
         beliefs.push({
           id: ev.id, text: ev.text, since: ev.ts,
           confidence: Number(ev.confidence ?? 0.5), status: 'active', verdict: null,
@@ -571,6 +573,8 @@ export function deriveSelf(events = [], opts = {}) {
     if (!Number.isFinite(t0)) continue
     const later = evs.filter((e) => {
       if (e.type !== 'utterance' && e.type !== 'revise') return false
+      // 没认领的聊天行只留证，不算她退了步（疤永不折叠，宁可漏判，见 refuse.js）
+      if (Array.isArray(e.flags) && e.flags.includes('uncommitted')) return false
       const t = Date.parse(e.ts)
       return Number.isFinite(t) && t > t0 && t - t0 <= CONCEDE_WINDOW_MS
     })

package/lib/desk.js

@@ -98,7 +98,7 @@ export function deskFor({ gaps = [], stale = [], free = false, favorite = '', at
   // 反复出现的那件事排在最后：它不像「没合上的事」，更像背景里一直响的那句。
   const fav = clip(favorite)
   if (fav && !picked.some((p) => similarity(p.text, fav) >= DESK_SIMILARITY)) {
-    picked.push({ kind: 'fav', text: `- 「${fav}」（你最近又提到它）` })
+    picked.push({ kind: 'fav', text: `- 「${fav}」（最近你总说到它）` })
   }
 
   if (!picked.length) return ''

package/lib/dream.js

@@ -99,6 +99,9 @@ export async function writeDream(root, { text = '', refs = [], sessionId = '', l
 
   const { events } = await readEvents(root)
   const { config } = await loadConfig(root)
+  if (config?.dream?.enabled === false) {
+    return { ok: false, id: '', note: '梦这一项关着。想记的话先说一声。' }
+  }
   const model = deriveSelf(events, { growthDays: config.growthDays })
 
   if (dreamOn(events, model.day).length) {

package/lib/dreamtable.js

@@ -135,6 +135,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,23 @@ 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
+}
+
 /** 她最近一次真的开口的时刻。 */
 function lastSpokeAt(events) {
   let last = 0
@@ -100,13 +122,14 @@ function lastSpokeAt(events) {
  */
 export function driveOf({ events = [], now = Date.now(), desk = null, stage = 1 } = {}) {
   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: '刚动过，还没到两小时' }
   }
 
   // 上次开口没人接：底噪打折（不是惩罚，只是「说了也没人接」这件事本身的重量）。
@@ -140,6 +163,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

@@ -16,7 +16,7 @@
  *     narration / dream / 主动开口），才由日历补一次。劲儿正常工作时不该再出现
  *     「同一天醒两次」，所以这一条只在劲儿长期趴着时生效。
  *
- * 只在本机开发副本里生效（调用方用 devModeSync 包住）。公开版看到的仍是原来那张卡。
+ * 0.9.0 起公开：所有机器都能空醒；想关掉把 config.memory.thinkEveryDays 设 0。
  */
 
 import { tsMs, HER_TYPES } from './schema.js'
@@ -67,6 +67,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 +82,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

@@ -789,11 +789,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,6 +847,13 @@ 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-03（issue #19）：原来 `new Date().toISOString().slice(0,10)` 取的是 **UTC 日期**，
   // 东八区晚上 8 点之后换会话，旧会话会被改名成「…·昨天的日期 之前」.
   // dateKey() 用的是 getFullYear/getMonth/getDate，本地钟。

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.0'
 
 // ⚠️ 一个数组写全，不要拆成对象
 // 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()