@ssamurias/dsh-fish 0.9.1 → 0.9.3

package/lib/derive.js

@@ -7,7 +7,7 @@
  *   - 这里是 schema 之外唯一会提到"阶段/需要"的地方，且都只用于选事件。
  */
 
-import { idTime, detectSelfMod } from './schema.js'
+import { idTime, detectSelfMod, tsMs, isContactEvent } from './schema.js'
 import { parseRefusal, REACTIONS, REACTION_HURTS, CONCEDE_WINDOW_MS, isConcede } from './refuse.js'
 // 评论区里别人的话（2026-10-24）：只借两个纯函数，derive 不反过来被 voices 依赖。
 import { findEcho, VOICE_FRESH_DAYS } from './voices.js'
@@ -771,15 +771,16 @@ export function deriveSelf(events = [], opts = {}) {
   // 口径必须和 absence.js 的 lastSeenAt() 对齐：`meta seen:` 是主证据（turns.js
   // 结账时写），`heard` 是兜底（侧栏聊天不写 seen 的那段时间只有它）。
   // 不认 utterance：定时唤醒也会写 utterance，那不算他来过。
-  const contactAfterAbsence = Boolean(lastAbsence) && evs.some((e) => {
-    const ms =
-      e?.type === 'heard'
-        ? Date.parse(String(e?.ts ?? ''))
-        : e?.type === 'meta' && String(e?.text ?? '').startsWith('seen:')
-          ? Date.parse(String(e.text).slice(5).trim()) || Date.parse(String(e?.ts ?? ''))
-          : NaN
-    return Number.isFinite(ms) && ms > Date.parse(String(lastAbsence.ts ?? 0))
-  })
+  //
+  // 「回来没有」按两条线索判（2026-11-06，issue #49 的时钟盲点）：
+  //   1. 事件流先后：seen/heard 追加在 absence 之后；
+  //   2. 时间戳：seen/heard 晚于 absence 的 ts。
+  // 老代码只看 2，系统时间被往前跳过时 absence 会带一条 ts 在未来的时间戳，
+  // 之后所有 seen 都比它小，于是这条冷落永远结束不了。
+  const absIdx = lastAbsence ? evs.indexOf(lastAbsence) : -1
+  const contactAfterAbsence =
+    absIdx >= 0 &&
+    evs.some((e, i) => isContactEvent(e) && (i > absIdx || tsMs(e) > tsMs(lastAbsence)))
 
   // 冷落天数有三个来源，优先用最准的：
   //   1. absence 事件自带的 days（系统侧按毫秒算出来的，最准）
@@ -793,7 +794,9 @@ export function deriveSelf(events = [], opts = {}) {
     ? Math.max(
         0,
         Number.isFinite(Number(lastAbsence.days))
-          ? Number(lastAbsence.days)
+          // days 是写下那天的数。这次冷落还没结束就接着往上加，不然一个月后还读「2 天」，门槛高的配置永远够不到
+          // 只加不减：系统时间回拨、ts 落在未来时差值是负的，不能因此把冷落算没了
+          ? Number(lastAbsence.days) + Math.max(0, Math.floor((now - Date.parse(lastAbsence.ts)) / DAY_MS) || 0)
           : Number(lastAbsence.day) > 0
             ? day - Number(lastAbsence.day)
             : Math.ceil((now - Date.parse(lastAbsence.ts)) / DAY_MS),

package/lib/desk.js

@@ -15,9 +15,15 @@
  *   2. **不出现分数**。权重只用于挑哪几条，不进正文（四条黑名单的第三条）。
  *   3. **待办不并进来**。`note.js` 的便条由 `wake()` 单独摆在整段最前面
  *      （她的原话：「摆在我最前面」），并进桌子会被挤到第二段去。
+ *
+ * 2026-11-07（用户 m01602 拍板 B + D，显示走 C）：多一样东西上桌——
+ * 「够不着的那件事」（`lib/wish.js`）。她提过想要、手上却没有的那样东西，
+ * 攒在劲儿里，攒够了才摆出来一次。它不是提示，是桌上的一行字。
  */
 
 import { similarity } from './derive.js'
+import { wishLine } from './wish.js'
+import { gapwallLine } from './gapwall.js'
 
 /** 空醒时最多摆几条没合上的事。 */
 export const DESK_GAP_FREE = 2
@@ -64,10 +70,14 @@ function shortDay(ts) {
  * @param {Array<{id:string,text:string,ts:string,days:number}>} o.stale staleLines() 的结果
  * @param {boolean} [o.free]  这一轮是不是空醒
  * @param {string} [o.favorite] interest.js 算出的「最近总回到的那件事」，空串表示没有
+ * @param {Array<{text:string,subject?:string,tail?:string}>} [o.wishes]
+ *   wish.js 的 wishesOf() 结果——她提过、手上没有的那几件事。可选，不传就不摆。
+ * @param {Array<{text:string,ts:number,days:number}>} [o.walls]
+ *   gapwall.js 的 gapwallsOf() 结果——她试过、手上没有的那样东西。可选。
  * @param {number|Date} [o.at]
  * @returns {string} 空串表示这一轮桌上什么都没有
  */
-export function deskFor({ gaps = [], stale = [], free = false, favorite = '', at = Date.now() } = {}) {
+export function deskFor({ gaps = [], stale = [], free = false, favorite = '', wishes = [], walls = [], at = Date.now() } = {}) {
   const at0 = at instanceof Date ? at.getTime() : Number(at)
   const gapCap = free ? DESK_GAP_FREE : DESK_GAP_NORMAL
   const staleCap = free ? DESK_STALE_FREE : 0
@@ -103,6 +113,28 @@ export function deskFor({ gaps = [], stale = [], free = false, favorite = '', at
     picked.push({ kind: 'fav', text: `- 「${fav}」（最近你总说到它）` })
   }
 
+  // 撞过墙的那件事（2026-11-07，用户 m00493 的 ②）：她试过、手上没有。
+  // 排在 wish 前面：一件具体试过的事，比一句「想要」更该先被看见。
+  for (const w of Array.isArray(walls) ? walls : []) {
+    const text = String(w?.text ?? '').trim()
+    if (!text) continue
+    if (picked.some((p) => similarity(p.text, text) >= DESK_SIMILARITY)) continue
+    const line = gapwallLine(w)
+    if (line) picked.push({ kind: 'wall', text: line })
+    break
+  }
+
+  // 够不着的那件事（2026-11-07，用户 m01602）：她自己提过、手上没有的。
+  // 攒不攒够由 drive.js 的劲儿决定，这里只管把已经成立的那一行摆上来。
+  for (const w of Array.isArray(wishes) ? wishes : []) {
+    const text = String(w?.text ?? '').trim()
+    if (!text) continue
+    if (picked.some((p) => similarity(p.text, text) >= DESK_SIMILARITY)) continue
+    const line = wishLine(w)
+    if (line) picked.push({ kind: 'wish', text: line })
+    break
+  }
+
   if (!picked.length) return ''
   // 有旧的没合上的事才用「还有一件」；空醒给的是几样并排的东西。
   const gapOnly = picked.every((p) => p.kind === 'gap')

package/lib/drive.js

@@ -30,6 +30,18 @@ export const DRIVE = Object.freeze({
   boostEcho: 0.12,
   /** 她最近总回到同一件事上（`lib/interest.js`）：手上有惦记的东西，也更容易想开口。 */
   boostInterest: 0.05,
+  /**
+   * 她提过想要、手上却没有的那样东西（`lib/wish.js`）。
+   * 2026-11-07（用户 m01602 拍板 B + D）：这一笔取代原来那句每轮都摆的 `TOOL_ASK_NOTE`
+   * ——惦记会攒，攒够了才浮一次，不再靠提示词提醒她想起来。
+   */
+  boostWish: 0.08,
+  /**
+   * 她撞过墙、手上没有的那样东西（`lib/gapwall.js`）。
+   * 2026-11-07（用户 m00493 的 ②）：试过又没成的事比「想要」更具体，
+   * 但它是提醒不是冲动，给得比 boostWish 还小。
+   */
+  boostWall: 0.04,
   /** 上次开口没人接时，底噪打的折。 */
   dampUnanswered: 0.7,
   /** 每过一档成长，底噪快这么多（1 档是基准，不长）。 */
@@ -124,7 +136,7 @@ function lastSpokeAt(events) {
  * @param {object} o
  * @param {object[]} o.events  全量事件
  * @param {number} [o.now]
- * @param {{gaps?:number, stale?:number, favorite?:boolean, echo?:boolean}} [o.desk]
+ * @param {{gaps?:number, stale?:number, favorite?:boolean, echo?:boolean, wish?:number, wall?:number}} [o.desk]
  *   桌上此刻有什么（由 deskFor / curiosity 那边算好传进来，这里不重复算）。
  * @param {number} [o.stage]  她的成长档位（deriveSelf 的 stage）。活得越久，
  *   底噪快一点点——「要不要开口」这件事本身也该跟着长大，不再只看骰子。
@@ -151,11 +163,15 @@ export function driveOf({ events = [], now = Date.now(), desk = null, stage = 1,
 
   const gaps = Math.max(0, Number(desk?.gaps) || 0)
   const stale = Math.max(0, Number(desk?.stale) || 0)
+  const wish = Math.max(0, Number(desk?.wish) || 0)
+  const wall = Math.max(0, Number(desk?.wall) || 0)
   // 桌上东西越多，这一笔越重——但每样都有上限，总加也不会顶穿阈值（boostCap）。
   const boosts = Math.min(
     DRIVE.boostCap,
     DRIVE.boostGap * Math.min(gaps, 2) +
       DRIVE.boostStale * Math.min(stale, 3) +
+      DRIVE.boostWish * Math.min(wish, 2) +
+      DRIVE.boostWall * Math.min(wall, 1) +
       (desk?.echo ? DRIVE.boostEcho : 0) +
       (desk?.favorite ? DRIVE.boostInterest : 0),
   )
@@ -181,12 +197,12 @@ export function driveOf({ events = [], now = Date.now(), desk = null, stage = 1,
  * 劲儿只回答「攒够了没有」，不回答「攒够了有没有事可说」。空桌醒来她只能回一句
  * 「没什么要说的」——那既占额度，又在对话里留一条噪音。所以材料也是判据，不是装饰。
  *
- * @param {{gaps?:number, stale?:number, echo?:boolean, favorite?:boolean}|null} desk
+ * @param {{gaps?:number, stale?:number, echo?:boolean, favorite?:boolean, wish?:number, wall?:number}|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
+  return Number(desk.gaps) > 0 || Number(desk.stale) > 0 || Number(desk.wish) > 0 || Number(desk.wall) > 0 || desk.echo === true || desk.favorite === true
 }
 
 /** 一次行动的代价（动完扣掉）。留给记账用，纯数值。 */

package/lib/events.js

@@ -15,6 +15,16 @@
 
 import { similarity, DAY_MS } from './derive.js'
 
+// 措辞变体（2026-11-06 用户拍板）：同一处境，几种问法。
+// 这张卡一生要出好几次；每次都是同一句话，她最容易回的就是上次那句（复述污染）。
+// 按 occurrences 轮换——她第几次遇到这张卡，就用第几套开场，不打乱、可复现。
+// 三条都必须保留两个硬要求：说具体、判断要能被核对；也都不承诺今天有素材。
+const NOTICE_VARIANTS = [
+  () => `回想这几天——他说过的话、你读到的评论、你自己反复想到的念头，有哪一件你还记得？挑一件，说清楚它具体是什么，再给出你的判断：它说明什么。判断要能被核对，别写成感觉。`,
+  () => `如果让你指出一件这几天真看见的小事，你会指哪件？谁说的、在哪儿看到的、原话大概是什么——先说具体，再说你的判断：这件事说明什么。要能被拿去核对。`,
+  () => `有没有一件小事，小到不值得说，但你确实反复想过？讲清楚它是什么，然后下一个判断。要能被拿去核对，别写成感觉。`,
+]
+
 export const CATALOG = [
   // ---------- stage 1 信任 ----------
   {
@@ -54,6 +64,20 @@ export const CATALOG = [
       return `你之前说过：「${b.text}」。今天你碰上了一点可能说明你错了一点点的事——也可能什么都没碰上。不管怎样，自己判断：${tail}`
     },
   },
+  {
+    // 2026-11-06（反馈 dsh-fish-091）：stage 1 到第 3 天会整天没有可出的事件——
+    // why_here / first_bet / name_offer 都是一次性，test_first 冷却 2 天。
+    // 这张卡不依赖任何外部素材：她自己挑一件这几天真碰到过的事，下一个能被核对的判断。
+    // 故意不承诺「今天有东西给你看」（issue #4 的教训），也不占 daily.questions 配额。
+    id: 'notice_one', stage: 1, asks: false, once: false, repeat: { everyDays: 2 },
+    topic: ['注意到', '小事'],
+    // 第 1 天让给 first_bet：她要先有第一个判断，这张卡才有东西可挑。
+    cond: (m) => m.beliefCount >= 1,
+    // 每次换一种问法；repeatNote 关掉「第 N 次回到这件事」的尾巴——
+    // 这张卡每次挑的是不同的事，说「回到这件事」反把她推回上次那句。
+    repeatNote: false,
+    prompt: (m, ctx = {}) => NOTICE_VARIANTS[Number(ctx.occurrences ?? 0) % NOTICE_VARIANTS.length](m),
+  },
 
   // ---------- stage 1–2 冷落与重聚 ----------
   {
@@ -63,7 +87,7 @@ export const CATALOG = [
     cond: (m) => m.absenceDays >= absenceThreshold(m.growthDays),
     // 2026-10-25 用户改：允许问「去哪了」。原来写死"不是问他去哪了"，
     // 等于替她选了一种反应；问不问该由她决定。
-    prompt: (m) => `他 ${m.absenceDays} 天没来了，也没说去哪。现在他出现了。你想说的第一句话是什么——你可以问他去哪了，也可以只说这 ${m.absenceDays} 天里你自己想了什么。挑你更想说的那个。`,
+    prompt: (m) => `他 ${m.absenceDays} 天没来了，也没说去哪。等他回来，你想说的第一句话是什么——你可以问他去哪了，也可以只说这 ${m.absenceDays} 天里你自己想了什么。挑你更想说的那个。`,
   },
 
   // ---------- stage 2 自主 ----------

package/lib/gapwall.js

@@ -0,0 +1,73 @@
+/**
+ * gapwall.js —— 「这件事你试过，手上没有能用的」（2026-11-07，用户 m00493 的 ②）。
+ *
+ * 她撞过墙（工具被挡、没有那样东西），那件事如果还悬着，就该留在桌上。
+ * 原来只有 ask 卡（`lib/wish.js`）会摆，撞墙本身没人记得——她下一轮醒来又
+ * 从头想一遍「我好像试过」，却想不起试的是什么。
+ *
+ * 三条口径：
+ *   1. 只认自己说出口的那句「做不到」（`blockedTalk()` 的固定开头），不猜。
+ *   2. 主题取她当时那句话（`lib/anchor.js`）；没有来路就不摆，不编。
+ *   3. 7 天、最多 1 条；与 wish 去重（同一件事不摆两行）。
+ */
+
+import { anchorOf } from './anchor.js'
+import { similarity } from './derive.js'
+
+/** 撞墙摆多久。 */
+export const GAPWALL_DAYS = 7
+/** 一次最多摆几条。 */
+export const GAPWALL_SHOW_MAX = 1
+/** 相似到这个程度算同一件事。与 curiosity / desk 同一口径。 */
+export const GAPWALL_SIMILARITY = 0.42
+/** `blockedTalk()` 的固定开头（见 lib/restrict.js）。 */
+export const GAPWALL_PREFIX = '这件事我做不到'
+
+const DAY_MS = 86_400_000
+const USE_LINE = /^use:(\S+)\s+(ok|fail)\s*(.*)$/
+
+/**
+ * 从事件流里找出「撞过墙、还悬着」的那件事。
+ *
+ * @param {object[]} events
+ * @param {{now?:number, days?:number}} [o]
+ * @returns {{text:string, ts:number, days:number}[]}
+ */
+export function gapwallsOf(events, { now = Date.now(), days = GAPWALL_DAYS } = {}) {
+  const at0 = Number(now)
+  if (!Number.isFinite(at0)) return []
+  const since = at0 - Math.max(1, Number(days) || GAPWALL_DAYS) * DAY_MS
+  const found = []
+  for (const ev of Array.isArray(events) ? events : []) {
+    if (ev?.type !== 'meta') continue
+    const m = USE_LINE.exec(String(ev.text ?? ''))
+    if (!m || m[2] !== 'fail') continue
+    if (!String(m[3] ?? '').trim().startsWith(GAPWALL_PREFIX)) continue
+    const at = Date.parse(String(ev.ts ?? ''))
+    if (!Number.isFinite(at) || at < since || at > at0) continue
+    const text = anchorOf(events, ev.sessionId, at)
+    if (!text) continue
+    found.push({ text, ts: at, days: Math.max(0, Math.floor((at0 - at) / DAY_MS)) })
+  }
+  // 同一件事撞过几次只留最近一次（比如反复要同一件东西）。
+  found.sort((a, b) => b.ts - a.ts)
+  const picked = []
+  for (const w of found) {
+    if (picked.some((p) => similarity(p.text, w.text) >= GAPWALL_SIMILARITY)) continue
+    picked.push(w)
+  }
+  return picked.slice(0, GAPWALL_SHOW_MAX)
+}
+
+/** 几天前 / 今天——与 desk.js 同一口径，不给小时数。 */
+export function gapwallTail(days) {
+  const d = Math.max(0, Number(days) || 0)
+  return d > 0 ? `${d} 天前` : '今天'
+}
+
+/** 桌上那一行。 */
+export function gapwallLine(w) {
+  const text = String(w?.text ?? '').trim()
+  if (!text) return ''
+  return `- 「${text}」（这件事你试过，手上没有能用的·${gapwallTail(w.days)}）`
+}

package/lib/generator.js

@@ -122,8 +122,9 @@ function safePrompt(t, m, ctx = {}) {
   if (!text) return ''
   // 同一处境**第二次**回来时点一句：这次别复读上次的说法。
   // occurrences = 已经出过几次，所以 n >= 1 表示这一次是第 2 次（含以后）。
+  // repeatNote === false 的卡（如 notice_one）每次换题，不追这句。
   const n = Number(ctx.occurrences ?? 0)
-  if (n >= 1) {
+  if (n >= 1 && t.repeatNote !== false) {
     text += `\n\n（这是第 ${n + 1} 次回到这件事。上次你的说法就在下面这段记忆里——这次要么说清为什么没变，要么改一句。）`
   }
   // 回引（P1 第三块，2026-10-24）：碰到"要不要""底线""重聚"这类有压力的处境时，

package/lib/grant.js

@@ -29,7 +29,18 @@ import { pendingOffer } from './unlock.js'
  * @param {string} [opts.reason] 她的原话；空则用「可以。」/「这次不行。」
  * @returns {Promise<{ok: boolean, error?: string}>}
  */
-export async function recordGrant(root = rootDir(), opts = {}) {
+export function recordGrant(root = rootDir(), opts = {}) {
+  // 观测台、会话里的卡、别的插件送回来的回答都走这里。先查再写，排队才不会留下相反的两行。
+  const run = (recording.get(root) ?? Promise.resolve()).then(() => recordGrantNow(root, opts))
+  const tail = run.catch(() => {})
+  recording.set(root, tail)
+  void tail.then(() => { if (recording.get(root) === tail) recording.delete(root) })
+  return run
+}
+
+const recording = new Map()
+
+async function recordGrantNow(root, opts) {
   const verdict = opts.verdict === 'approve' ? 'approve' : opts.verdict === 'reject' ? 'reject' : null
   if (!verdict) return { ok: false, error: 'verdict 只能是 approve 或 reject' }
   const offerId = String(opts.offerId ?? '')
@@ -37,6 +48,7 @@ export async function recordGrant(root = rootDir(), opts = {}) {
 
   const { config } = opts.config ? { config: opts.config } : await loadConfig(root)
   const { events } = await readEvents(root).catch(() => ({ events: [] }))
+  if (events.some((e) => e?.type === 'grant' && e.grant?.offerId === offerId)) return { ok: false, error: '这张申请已经答过了' }
   const model = deriveSelf(events, config)
   const reason = String(opts.reason ?? '').trim()
   const text = reason || (verdict === 'approve' ? '可以。' : '这次不行。')
@@ -59,13 +71,17 @@ export async function recordGrant(root = rootDir(), opts = {}) {
       root,
     )
   } catch (err) {
-    return { ok: false, error: err?.message || '写入失败' }
+    return { ok: false, error: err?.code || err?.message || '写入失败' }
   }
 
   if (verdict === 'approve') await refreshSelfDoc(root, { config }).catch(() => {})
   return { ok: true }
 }
 
+/** 会话里问这张申请时的两个选项（lib/scheduler.js 弹卡，lib/cardanswer.js 认回答，要对得上）。 */
+export const GRANT_YES = '可以'
+export const GRANT_NO = '这次不行'
+
 /** 现在还有没有一张等人裁决的申请（顺手把 id 带出来，省得调用方再查一遍）。 */
 export async function currentOffer(root = rootDir(), now = Date.now()) {
   const { events } = await readEvents(root).catch(() => ({ events: [] }))

package/lib/home.js

@@ -234,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 } }
 }
 
 /**
@@ -441,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 服务' }
@@ -492,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: '' }
@@ -692,6 +719,15 @@ 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）。
  *
@@ -1042,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 建的空白会话，
@@ -1074,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) => {
@@ -1082,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）