@ssamurias/dsh-fish 0.9.0 → 0.9.2

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 '' }
 }
 
@@ -226,12 +234,31 @@ function pickLiveSession(reg, wsId, avoid = '') {
  * （返回 false，维持原来的判定，不凭空认活）。
  */
 async function sessionListed(sc, sessionId) {
+  const row = await sessionRow(sc, sessionId)
+  return row.found
+}
+
+/**
+ * 在宿主会话列表里找这一条，把 `blank` 一起带出来。
+ *
+ * 为什么要看 `blank` 而不只是「在不在列表里」（2026-11-06 换房报告）：
+ * 宿主的 `list()` 会把**每一条活着的会话都推出来**（`summaryFor` 无条件 push），
+ * 空白会话也在里面，只是侧栏按 `blank && id !== current` 把它藏起来。
+ * 所以「列表里有这一行」只说明会话被持久化了，**不说明它跑出过内容**——
+ * 拿它当「叫醒落地了」的判据，会让复核永远当成功，那句「再叫一次」是死代码。
+ * 真正跑过一轮的标志是 `blank === false`（宿主在 `turn/start` 时清掉它）。
+ *
+ * @returns {Promise<{found:boolean, blank:boolean|undefined}>} 查不到/查失败都是 `found:false`
+ */
+export async function sessionRow(sc, sessionId) {
   try {
-    if (typeof sc?.list !== 'function') return false
+    if (typeof sc?.list !== 'function') return { found: false, blank: undefined }
     const l = await sc.list({})
     const items = l?.items ?? l?.value?.items ?? []
-    return items.some((x) => String(x?.sessionId ?? x?.id ?? '') === String(sessionId))
-  } catch { return false }
+    const row = items.find((x) => String(x?.sessionId ?? x?.id ?? '') === String(sessionId))
+    if (row === undefined) return { found: false, blank: undefined }
+    return { found: true, blank: typeof row.blank === 'boolean' ? row.blank : undefined }
+  } catch { return { found: false, blank: undefined } }
 }
 
 /**
@@ -433,7 +460,7 @@ async function ensureTalkSessionOnce(ctx, { root = rootDir(), wsId, title = TITL
  * 只记**成功送达**的那一次：宿主的 prompt 是「这一轮被收下了」就 resolve，
  * 收下就一定会跑出内容；抛错（比如漏传 signal）则不写，下次启动还会再试。
  */
-export async function wakeIfBlank(ctx, { sessionId, root = '', log, freshOnly = false, rotated = false, force = false } = {}) {
+export async function wakeIfBlank(ctx, { sessionId, root = '', log, freshOnly = false, rotated = false, force = false, verify = false } = {}) {
   if (!sessionId) return { woke: false, why: '没有会话 id' }
   const sc = ctx?.get?.('sessionController') ?? ctx?.sessionController
   if (!sc) return { woke: false, why: '宿主没有 sessionController 服务' }
@@ -484,6 +511,14 @@ export async function wakeIfBlank(ctx, { sessionId, root = '', log, freshOnly =
       content: [{ type: 'text', text: freshWakeText(new Date(), { rotated }) }],
     }, new AbortController().signal)
     .then(() => markWoke(root, sessionId))
+    // 复核（2026-11-06 换房报告）：prompt 只等消息进收件箱，宿主收下了不等于
+    // 那一轮真跑了（wakeDriver 可能因为上一轮还没结束直接丢掉）。隔 12 秒回头
+    // 看 blank 翻没翻；没翻就再叫一次。默认关：测试里的替身不会真跑 turn，
+    // 挂了复核会在 12 秒后冒出第二次 prompt，把断言搅乱。
+    .then(() => {
+      if (!verify) return
+      void verifyWoke(ctx, { root, sessionId, log }).catch(() => {})
+    })
     .catch((err) => log?.(`新屋子唤醒失败：${String(err?.message ?? err).slice(0, 140)}`))
   log?.('新屋子还是空的，叫了她一声（要等她这一轮动起来，侧栏才会显示）')
   return { woke: true, why: '' }
@@ -684,6 +719,44 @@ export const LAST_WORDS_WAIT_MS = 60_000
  */
 export const WAKE_VERIFY_MS = 12_000
 
+/**
+ * 正在复核的会话 id（2026-11-06 换房报告）。
+ *
+ * 换房、`/reset`、`/home/rebuild` 都会在叫醒后挂一次复核，12 秒后各自问一遍。
+ * 同一批里挂两次，就会在这条新会话上连着叫两声——她那边看见的是两条「醒一醒」。
+ * 复核自己也会再叫一次（force），所以「同一条正在复核」必须直接跳过。
+ */
+const verifying = new Set()
+
+/**
+ * 换会话失败之后多久再试（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
 
@@ -854,24 +927,65 @@ async function rotateTalkSessionOnce(ctx, { root = rootDir(), wsId, title = TITL
     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 / 超时 / 她说「不用」都只是没有这一节；
@@ -889,22 +1003,6 @@ async function rotateTalkSessionOnce(ctx, { root = rootDir(), wsId, title = TITL
     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` 换一次会话全丢：
@@ -932,6 +1030,9 @@ async function rotateTalkSessionOnce(ctx, { root = rootDir(), wsId, title = TITL
       }
       delete next.status
       delete next.archivedAt
+      // 换成了，把上次失败的记账清掉（否则下一次到点时会被误判成还在冷却期）
+      delete next.rotateFailAt
+      delete next.rotateFailWhy
       // 0.8.7：这一轮先清掉旧的那句。她要是留了，后台回来之后再补写
       // （见下面 pendingWords.then）。留着上一轮那句会让新房间读到一句
       // 不是这次说的「最后一句」——比没有更糟。
@@ -977,7 +1078,7 @@ async function rotateTalkSessionOnce(ctx, { root = rootDir(), wsId, title = TITL
     // 2026-11-02（用户 m00324）：这条路是**换会话**，不是造新屋子。
     // 传 rotated:true 让触发语说「对话换了一条新的，屋子还是原来那间」，
     // 而不是「屋子刚建好」——后者会让她以为每 40 轮就变成新的一条鱼。
-    const woke = await wakeIfBlank(ctx, { sessionId, root, log, freshOnly: true, rotated: true })
+    const woke = await wakeIfBlank(ctx, { sessionId, root, log, freshOnly: true, rotated: true, verify: true })
     if (!woke.woke && woke.why) log?.(`轮换后没叫醒新会话：${woke.why}`)
     // 4.5) 叫了不等于叫醒（0.8.7，用户 m01775 那张截图里的第 4、5 条）
     // 宿主的 prompt 是「这一轮被收下了」就 resolve。可新会话是插件用 API 建的空白会话，
@@ -1009,6 +1110,10 @@ async function rotateTalkSessionOnce(ctx, { root = rootDir(), wsId, title = TITL
  */
 export async function verifyWoke(ctx, { root = '', sessionId = '', log, delayMs = WAKE_VERIFY_MS } = {}) {
   if (!sessionId) return { landed: false, rewoke: false }
+  // 同一批只复核一次：换房与 /reset 两条路都会顺手挂复核，重复挂会在她那里
+  // 变成两声「醒一醒」——那正是这段代码要防的事。
+  if (verifying.has(String(sessionId))) return { landed: false, rewoke: false, skipped: true }
+  verifying.add(String(sessionId))
   try {
     if (delayMs > 0) {
       await new Promise((ok) => {
@@ -1017,14 +1122,22 @@ export async function verifyWoke(ctx, { root = '', sessionId = '', log, delayMs
       })
     }
     const sc = ctx?.get?.('sessionController') ?? ctx?.sessionController
-    if (await sessionListed(sc, sessionId)) return { landed: true, rewoke: false }
-    log?.(`新会话 ${sessionId} 叫过一次还是不在宿主列表里，再叫一次`)
+    // 判据是 blank，不是「在不在列表里」：宿主的 list() 连空白会话一起推，
+    // 在列表里只说明它被持久化了，说明不了它跑出过内容（详见 sessionRow 的注释）。
+    // 老宿主不给 blank 字段时退回老判据——有这一行就当落地，宁可漏补一次。
+    const row = await sessionRow(sc, sessionId)
+    if (row.found && row.blank !== true) return { landed: true, rewoke: false }
+    log?.(row.found
+      ? `新会话 ${sessionId} 叫过一次还是空的（没跑出 turn），再叫一次`
+      : `新会话 ${sessionId} 叫过一次还是不在宿主列表里，再叫一次`)
     const again = await wakeIfBlank(ctx, { sessionId, root, log, freshOnly: true, rotated: true, force: true })
     if (!again.woke && again.why) log?.(`再叫一次也没成：${again.why}`)
     return { landed: false, rewoke: again.woke === true }
   } catch (err) {
     log?.(`复核叫醒失败：${String(err?.message ?? err).slice(0, 140)}`)
     return { landed: false, rewoke: false }
+  } finally {
+    verifying.delete(String(sessionId))
   }
 }
 

package/lib/identity.js

@@ -290,8 +290,18 @@ export function attachAssembleFix(agent, { log } = {}) {
   }
 }
 
-/** 这一次唤醒的处境正文；空串表示没有（正常聊天时就是空）。 */
-let wakeText = ''
+/**
+ * 这一次唤醒的处境正文，**按会话分开存**（2026-11-06，用户 m03265 二次报）。
+ *
+ * 原来是进程级的一个 `let wakeText = ''`。可一个进程里她可能同时有好几条会话——
+ * 家、群聊房间、轮换下来的旧房、出门那一条——而处境段是挂在**每个 agent** 上的
+ * 同一份闭包。于是 A 房间的一次叫醒，会把「这一轮是你自己的……不想说就什么都别写」
+ * 塞进 B 房间正在跑的那一轮：那边明明是他刚说的话，她却按「不用回应」处理，
+ * 只思考、一个字不写。宿主把空正文画成「已完成分析」，用户看到的就是
+ * 「她突然不说话了，连着好几轮」。
+ */
+const wakeBySession = new Map()
+
 /**
  * 处境段代次（2026-11-04，用户 m01466）。
  *
@@ -305,15 +315,48 @@ let wakeText = ''
  */
 let wakeGen = 0
 
+/**
+ * 处境最多活这么久。
+ *
+ * 为什么要有这条硬超时（2026-11-06）：清处境原来只有一条路——那条会话的 `turn/end`。
+ * 可 `turn/end` 可能永远不来：投递被丢弃、监听没挂上、插件重启把 watcher 丢了、
+ * `isBusy` 一直为真让兜底每 30 秒重排却永不收尾。于是这段「不用说话」的处境会
+ * **一直挂到进程退出**，之后她每一轮都只思考不开口——真机就是这样哑了一整晚。
+ * 处境本来就只属于那一次叫醒，它没有任何理由活过十分钟：到点无条件清掉。
+ * 宁可这一次叫醒白叫，也不能让她一直哑着。
+ */
+const WAKE_TTL_MS = 10 * 60_000
+
+/** 会话 id 两边写法不一定一样（带不带 `session-` 前缀），统一成一个键。 */
+function wakeKey(sessionId) {
+  return String(sessionId ?? '').replace(/^session-/, '')
+}
+
+function dropWake(key) {
+  const rec = wakeBySession.get(key)
+  if (!rec) return
+  if (rec.timer) clearTimeout(rec.timer)
+  wakeBySession.delete(key)
+}
+
 /**
  * 设这一次的处境正文。传空串等于清掉。
  * @param {string} text
- * @returns {number} 这一次的代次号；传给 `clearWakeSection(n)` 才清得掉。
+ * @param {string} [sessionId] 这条处境属于哪条会话
+ * @returns {number} 这一次的代次号；传给 `clearWakeSection(n, sessionId)` 才清得掉。
  */
-export function setWakeSection(text) {
-  wakeText = String(text ?? '')
+export function setWakeSection(text, sessionId = '') {
+  const key = wakeKey(sessionId)
+  dropWake(key)
   wakeGen += 1
-  return wakeGen
+  const gen = wakeGen
+  const rec = { text: String(text ?? ''), gen, timer: null }
+  rec.timer = setTimeout(() => {
+    if (wakeBySession.get(key)?.gen === gen) dropWake(key)
+  }, WAKE_TTL_MS)
+  rec.timer.unref?.()
+  wakeBySession.set(key, rec)
+  return gen
 }
 
 /**
@@ -321,22 +364,71 @@ export function setWakeSection(text) {
  * @param {number} [gen] 传了就在代次对不上时**不清**——
  *   防的是「后一轮刚挂上处境，前一轮的 turn/end 晚到把它的抹掉」。
  *   不传就无条件清（卸载、失败收尾这类场合）。
+ * @param {string} [sessionId] 只清这一条会话；不传就按下面的口径清
+ *   （带 gen 时清所有代次对得上的，不带 gen 时全清）。
+ */
+export function clearWakeSection(gen, sessionId) {
+  const only = sessionId === undefined ? undefined : wakeKey(sessionId)
+  for (const [key, rec] of [...wakeBySession]) {
+    if (only !== undefined && key !== only) continue
+    if (Number.isFinite(gen) && rec.gen !== gen) continue
+    dropWake(key)
+  }
+}
+
+/**
+ * 他一开口，那次叫醒就作废（2026-11-06）。
+ *
+ * 最后一道保险：不管是代次错配、硬超时没跑到、还是别的会话串过来的，只要有人
+ * 在这条会话里真的说了话，那段「这一轮是你自己的」就不该再影响这一轮。
+ * 认不出会话 id 的那一份（挂在空键上）也一起清——它只可能是没人认领的残留。
  */
-export function clearWakeSection(gen) {
-  if (Number.isFinite(gen) && gen !== wakeGen) return
-  wakeText = ''
+export function clearWakeSectionFor(sessionId) {
+  dropWake(wakeKey(sessionId))
+  dropWake('')
 }
 
-/** 测试用：看现在挂着什么。 */
-export function getWakeSection() {
-  return wakeText
+/**
+ * 看现在挂着什么。测试里不带会话就是「现在挂着的那一份」。
+ * 带了会话而键对不上（宿主换了 id 写法）时，只有一份才兜底返回，
+ * 免得处境凭空消失、叫醒变成一次空醒。
+ */
+export function getWakeSection(sessionId) {
+  if (sessionId === undefined) {
+    if (wakeBySession.size === 0) return ''
+    if (wakeBySession.size === 1) return [...wakeBySession.values()][0].text
+    return [...wakeBySession.values()].map((r) => r.text).filter(Boolean).join('\n')
+  }
+  const key = wakeKey(sessionId)
+  const rec = wakeBySession.get(key)
+  if (rec) return rec.text
+  // 宿主两处给的会话 id 写法可能不完全一样：带不带 `session-` 前缀已由 wakeKey 抹平，
+  // 剩下一种常见的是「完整 id 与它的后缀」。只有**一条**处境、且两边互为后缀时才兜底给，
+  // 免得叫醒变成一次空醒；两条不同的会话之间绝不允许串——那正是「只思考不说话」的成因。
+  if (wakeBySession.size === 1) {
+    const onlyKey = [...wakeBySession.keys()][0]
+    if (onlyKey && key && (onlyKey.endsWith(key) || key.endsWith(onlyKey))) {
+      return wakeBySession.get(onlyKey).text
+    }
+  }
+  return ''
 }
 
 /** 测试用：看现在的代次号。 */
-export function getWakeGen() {
+export function getWakeGen(sessionId) {
+  if (sessionId !== undefined) return wakeBySession.get(wakeKey(sessionId))?.gen ?? 0
   return wakeGen
 }
 
+/** 从 agent 上取会话 id（宿主不同版本字段位置不一样）。 */
+function sessionIdOf(agent) {
+  try {
+    return String(agent?.session?.header?.id ?? agent?.session?.id ?? '')
+  } catch {
+    return ''
+  }
+}
+
 const cache = { file: '', mtimeMs: -1, text: '' }
 
 /**
@@ -460,10 +552,15 @@ export function attachIdentity(agent, root, { frozen = '', herDir = '', log } =
     }))
     // 「这一次的处境」单独一段：平时是空串（等于不存在），唤醒前才填。
     // 它不进对话历史，所以他看不到系统在跟她说些什么。
+    //
+    // 2026-11-06：**按这条会话取**，不再读一个进程级变量。她可能同时住着好几条
+    // 会话（家 + 群房 + 旧房 + 出门那条），共用一个变量会把 A 房间的处境
+    // 塞进 B 房间正在跑的那一轮，那边她就只思考不说话了。
+    const wakeSid = sessionIdOf(agent)
     remember(agent, 'section', sp.section({
       name: WAKE_SECTION,
       order: WAKE_ORDER,
-      text: () => wakeText,
+      text: () => getWakeSection(wakeSid),
     }))
     // 「手边有什么」单独一段（2026-10-29，用户 m01276）。
     // 有些工具我们收不窄——注册在 agent 自己作用域里的（ops_*、Agent Teams）

package/lib/index.js

@@ -10,6 +10,8 @@
  *   dispose → 停定时器、注销路由。停用插件 = 零后台活动。
  */
 
+import { setTimeout as sleep } from 'node:timers/promises'
+
 import { rootDir, readEvents, appendEvent, readJson, paths, writeAtomic, ensureHer } from './store.js'
 import { loadConfig } from './settings.js'
 import { deriveSelf } from './derive.js'
@@ -23,6 +25,7 @@ import { registerLetter } from './letter.js'
 import { registerNote } from './note.js'
 import { registerBringBack } from './keep.js'
 import { registerAsk } from './ask.js'
+import { answerCard } from './cardanswer.js'
 import { registerDream } from './dream.js'
 import { registerProactive } from './proactive.js'
 import { registerObserve } from './observe.js'
@@ -46,7 +49,7 @@ import { logBoot, makeLogger } from './log.js'
 export const name = 'dsh-fish'
 
 /** 版本号：只用于日志导出（排查时第一件事是确认跑的是哪一版）。 */
-export const VERSION = '0.9.0'
+export const VERSION = '0.9.1'
 
 // ⚠️ 一个数组写全，不要拆成对象
 // 2026-10-30（m02961）：`userQuestions` **不再写进 inject**。写进 inject 的东西缺一个，
@@ -81,6 +84,11 @@ export function apply(ctx, baseConfig = {}) {
   // 写进 inject 的代价是「缺了就整个插件不装」——而缺的那个服务只关掉一条功能。
   const compat = { checked: false, userQuestions: false }
   let heartbeat = null
+  let stopped = false
+  // 正在认领的那次：shutdown 要等它放开，新实例才不会把旧认领读成「被占着」
+  let claiming = null
+  // 在途的那次心跳：放开之前要等它，不然它会把放开的认领写回去
+  let beating = null
 
   async function boot() {
     logBoot(root, `${VERSION} · ${process.version} · ${process.platform}`)
@@ -119,21 +127,24 @@ export function apply(ctx, baseConfig = {}) {
     // 她自己的房间必须先存在：她的会话 cwd 指向这里（不是 root），
     // 这样她不会一睁眼就站在自己的 events.jsonl 旁边。
     const herDir = await ensureHer(root)
+    if (stopped) return
 
     // ---- 一个 root 只认一个实例（2026-10-28 m01319）----
     // root 是进程级解析的：两个工作区如果都落到同一个家，光看调用者 cwd 分辨不出来
     // （两边 cwd 都在这个 root 里，校验会同时通过）。所以加载时先占位：
     // 谁先占谁是房主；后进来的认出来之后**不写也不崩** —— 她还能说话，只是不落盘。
     try {
-      const claim = await claimRoot(root, { version: VERSION })
+      claiming = claimRoot(root, { version: VERSION })
+      const claim = await claiming
       tenancy.tenant = claim
       tenancy.herDir = herDir
+      if (stopped) return
       if (!claim.ok) {
         logger.error(`[dsh-fish] ${claim.why}`)
       } else if (claim.instanceId) {
         const id = claim.instanceId
         heartbeat = setInterval(() => {
-          beatRoot(root, id)
+          beating = beatRoot(root, id)
             .then((still) => {
               if (still === false && tenancy.tenant.ok !== false) {
                 // 续不上 = 家被别人接管了。从此不再写，也不再抢回来（否则两边来回覆盖）。
@@ -185,6 +196,7 @@ export function apply(ctx, baseConfig = {}) {
     // 首次启动播种：她最初的那一点点性格，是**第一个事实**，不是可调参数。
     // 之所以写成事件而不是配置项：配置项会被"打开设置页改一下"，
     // 事件只能追加——想改就得由她自己 revise，这是 N4 的地基。
+    if (stopped) return
     const hasSeed = events.some((e) => e.type === 'seed')
     if (!hasSeed) {
       const seedText = String(
@@ -209,6 +221,7 @@ export function apply(ctx, baseConfig = {}) {
     }
 
     const model = deriveSelf(await readEvents(root).then((r) => r.events), { growthDays: config.growthDays })
+    if (stopped) return
 
     // ---- 她的屋子：工作区 + 专属会话（P3 核心）----
     // 这一步**先于**一切：她得先有个能被你看见的地方，才有"说话"这件事。
@@ -244,6 +257,7 @@ export function apply(ctx, baseConfig = {}) {
     } catch (err) {
       logger.warn('[dsh-fish] 身份文本预写失败', err?.message ?? err)
     }
+    if (stopped) return
     try {
       const off = registerIdentity(ctx, { root, herDir, log: (...a) => logger.info(...a) })
       if (typeof off === 'function') disposers.push(off)
@@ -272,6 +286,7 @@ export function apply(ctx, baseConfig = {}) {
     } catch (err) {
       home = { ok: false, why: String(err?.message ?? err).slice(0, 160), wsId: '', sessionId: '' }
     }
+    if (stopped) return
     // 观测台要能把「这个家在别处也开着」和普通失败分开报（2026-10-29 m02162）。
     tenancy.home = { ok: home.ok, blocked: home.blocked === true, sessionId: home.sessionId ?? '', why: home.why ?? '' }
     if (home.blocked === true) logger.warn(`[dsh-fish] ${home.why}`)
@@ -287,6 +302,7 @@ export function apply(ctx, baseConfig = {}) {
       }
     }
 
+    if (stopped) return
     // ---- 身份文本再落一次盘：屋子建好之后 activeCarry 等才齐，内容可能变 ----
     // 这条改动之后它**不再被宿主注入**（那是旧的 AGENTS.md 通道），只是落盘副本；
     // 真正进她上下文的是上面注册的 system prompt 段（每轮组装时现读文件）。
@@ -311,11 +327,14 @@ export function apply(ctx, baseConfig = {}) {
       logger.warn(`[dsh-fish] 口袋排序失败：${String(err?.message ?? err).slice(0, 120)}`)
     }
 
+    if (stopped) return
     // ---- 侧栏轮数：在侧栏亲口跟她说话也算一轮（issue #6，2026-10-28）----
     // 原来只有 /say 路由会 bumpTurns，用户直接打字时 rotateAfter 永不触发。
     // 观察者只读会话事件，认来源是"真人打的"，一轮结束再结账。
     try {
-      const off = registerTurns(ctx, { root, log: (...a) => logger.info(...a) })
+      // 2026-11-06（外部日志）：被占用的实例也在写 `seen:`。轮数观察者现在是写盘方，
+      // 必须拿到活着的房主身份——占用权丢了（心跳续不上）会当场改成 ok:false。
+      const off = registerTurns(ctx, { root, tenant: tenancy.tenant, log: (...a) => logger.info(...a) })
       if (typeof off === 'function') disposers.push(off)
     } catch (err) {
       logger.warn('[dsh-fish] 轮数观察没挂上', err?.message ?? err)
@@ -394,23 +413,44 @@ export function apply(ctx, baseConfig = {}) {
   }
 
   // 宿主可能不 await apply，所以自己兜住异常：启动失败不能带走整个插件树
-  boot().catch((err) => {
+  const booted = boot().catch((err) => {
     logger.error('[dsh-fish] 启动失败', err?.stack ?? err)
     console.error('[dsh-fish] 启动失败', err)
   })
 
+  // 卡片被别的插件接走之后（dsh-fish/card），人的回答从这里回来（lib/cardanswer.js）。
+  // 同步挂上：宿主重启后 IM 插件可能先连上、先收到人的回答，这时启动还没走完。等它走完才知道这个家是不是自己的。
+  // 没认领到就不写，和那些工具同一条理由：被占着，或者启动没走到认领那一步（默认值 ok 是真的，不能信）。
+  ctx.on?.('dsh-fish/answer', async (answer) => {
+    await booted
+    if (tenancy.tenant?.ok === false || !tenancy.tenant?.instanceId) {
+      return { ok: false, why: tenancy.tenant?.why || '启动没走完，不知道这个家是不是自己的，这次没写。' }
+    }
+    return answerCard(root, answer)
+  })
+
   function shutdown() {
+    if (stopped) return
+    stopped = true
     try { clearInterval(heartbeat) } catch { /* ignore */ }
-    try {
-      const id = tenancy.tenant?.instanceId
-      if (id) releaseRoot(root, id).catch(() => {})
-    } catch { /* ignore */ }
+    // 返回给 cordis：它等完 effect 才重新 apply，下一次认领一定在放开之后
+    const released = Promise.resolve(claiming)
+      .then(async (claim) => {
+        await beating
+        return claim?.ok && claim.instanceId ? releaseRoot(root, claim.instanceId) : false
+      })
+      .catch(() => {})
     try { scheduler?.dispose?.() } catch { /* ignore */ }
     try { clearWakeSection() } catch { /* ignore */ }
     for (const d of disposers) { try { d() } catch { /* ignore */ } }
+    // 磁盘卡住时别把卸载也挂住，依赖这个插件的服务要等它。用不 ref 的定时器，它不该拖住进程
+    return Promise.race([released, sleep(2000, undefined, { ref: false })])
   }
 
-  ctx.on?.('dispose', shutdown)
+  // 宿主的 cordis 4 没有 'dispose' 事件，也不管 apply 返回的 { dispose }，只认 ctx.effect。
+  // 只挂事件的话，插件停用后定时器还在跑，再启用时新旧两个调度器一起叫她。
+  if (typeof ctx.effect === 'function') ctx.effect(() => shutdown, 'dsh-fish.shutdown')
+  else ctx.on?.('dispose', shutdown)
 
   return {
     dispose() {

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)) {