@ssamurias/dsh-fish 0.9.1 → 0.9.2

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）

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'
@@ -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/keep.js

@@ -20,8 +20,8 @@ import { askKeepsake, decideKeepsake } from './keepsake.js'
 import { askInChat, picked } from './askinchat.js'
 
 /** 点头的两个选项。文案用她那个人的语气，不用「批准/拒绝」。 */
-const YES = '准了'
-const NO = '算了'
+export const YES = '准了'
+export const NO = '算了'
 
 /**
  * 把「想带这个回去」问进会话里，等一个人选。
@@ -31,12 +31,20 @@ const NO = '算了'
  *   算了 → 这东西留在原地
  *   没答（超时/没人接）→ 还挂着，出门页里仍可以点头
  */
-async function askBack(ctx, root, { sessionId, item, signal }) {
+/** 卡开着的时候别处（观测台、接卡的插件）先答了：回执照账上的说，不照这张卡上点的说。 */
+function handledElsewhere(d) {
+  return { state: 'answered', note: d.item?.status === 'kept' ? '别处先答了，带回来了。' : '别处先答了，没带。', said: 'failed' }
+}
+
+async function askBack(ctx, root, { sessionId, item, signal, rawWhy }) {
   const why = String(item?.why ?? '').trim()
   const name = String(item?.rel ?? '').split(/[\\/]/).pop() || String(item?.rel ?? '')
   const r = await askInChat(ctx, {
     sessionId,
     signal,
+    root,
+    rawTexts: [rawWhy],
+    cardId: `keepsake:${item?.id ?? ''}`,
     questions: [
       {
         id: 'keepsake',
@@ -52,12 +60,14 @@ async function askBack(ctx, root, { sessionId, item, signal }) {
   const said = picked(r.answers, 'keepsake')
   if (said === YES) {
     const d = decideKeepsake(root, { id: item.id, yes: true })
+    if (d.handled) return handledElsewhere(d)
     return d.ok
       ? { state: 'answered', note: '准了，带回来了。', said: 'yes' }
-      : { state: 'answered', note: '准了，没复制成。', said: 'yes' }
+      : { state: 'answered', note: `准了，${d.note}`, said: 'failed' }
   }
   if (said === NO) {
-    decideKeepsake(root, { id: item.id, yes: false })
+    const d = decideKeepsake(root, { id: item.id, yes: false })
+    if (d.handled) return handledElsewhere(d)
     return { state: 'answered', note: '没带。', said: 'no' }
   }
   return { state: 'unanswered', note: '问了。等他点头。', said: '' }
@@ -101,9 +111,11 @@ export function registerBringBack(ctx, deps = {}) {
               ? `[没问：${out.note}]`
               : out.said === 'yes'
                 ? '[准了]'
-                : out.said === 'no'
-                  ? '[算了]'
-                  : '[已问]',
+                : out.said === 'failed'
+                  ? `[${out.note}]`
+                  : out.said === 'no'
+                    ? '[算了]'
+                    : '[已问]',
           },
         ],
       },
@@ -135,7 +147,7 @@ export function registerBringBack(ctx, deps = {}) {
 
         // 0.7.5：问她那个人。这一步会等到有人选或者超时（默认 5 分钟），
         // 但无论走哪条路，台账里都已经有一条 asked——不会因为没人答就丢掉这件事。
-        const back = await askBack(ctx, root, { sessionId, item: r.item, signal: exec?.signal })
+        const back = await askBack(ctx, root, { sessionId, item: r.item, signal: exec?.signal, rawWhy: args?.why })
         return { ok: true, note: back.note, said: back.said }
       },
     }),

package/lib/keepsake.js

@@ -115,7 +115,9 @@ export function askKeepsake(root, { outing = null, sessionId = '', rel = '', why
   if (mine.length >= KEEPSAKES_PER_TRIP) {
     return { ok: false, note: '这一趟带得够多了。' }
   }
-  if (open.length >= 1) return { ok: false, note: '上一件还等着点头。' }
+  if (open.length >= 1) {
+    return { ok: false, note: open.some((it) => it.copyFailedAt) ? '上一件他点了头，只是没复制成，还没带回来。' : '上一件还等着点头。' }
+  }
 
   const cwd = String(outing.cwd ?? '')
   const target = resolve(cwd, raw)
@@ -156,7 +158,7 @@ export function decideKeepsake(root, { id = '', yes = false, now = Date.now() }
   const db = readDb(root)
   const item = db.items.find((it) => it && it.id === String(id))
   if (!item) return { ok: false, note: '没找到这一件。' }
-  if (item.status !== 'asked') return { ok: false, note: '这一件已经处理过了。' }
+  if (item.status !== 'asked') return { ok: false, item, handled: true, note: '这一件已经处理过了。' }
 
   if (!yes) {
     item.status = 'declined'
@@ -187,23 +189,28 @@ export function decideKeepsake(root, { id = '', yes = false, now = Date.now() }
 
   const dk = dateKey(new Date(now))
   const dir = keepsakesDir(root, dk)
+  const dest = join(dir, `${item.id}-${basename(target)}`)
   try {
     mkdirSync(dir, { recursive: true })
-    const dest = join(dir, `${item.id}-${basename(target)}`)
     copyFileSync(target, dest)
-    item.status = 'kept'
-    item.decidedAt = now
-    item.keptAs = `${dk}/${basename(dest)}`
-    item.size = st.size
-    writeDb(root, db)
-    return { ok: true, item, note: '带回来了。' }
   } catch (err) {
-    item.status = 'declined'
-    item.decidedAt = now
-    item.why = `复制失败：${String(err?.message ?? err).slice(0, 120)}`
+    // 他说的是准了，只是这次没复制成（占用、权限）。还挂着，再答一次再试，不记成没带。
+    item.copyFailedAt = now
+    try { writeDb(root, db) } catch { /* 写不进去也还是 asked，只是下一件的说法不准 */ }
+    return { ok: false, item, note: `没复制成（${String(err?.code ?? '出错了')}）。` }
+  }
+  item.status = 'kept'
+  item.decidedAt = now
+  item.keptAs = `${dk}/${basename(dest)}`
+  item.size = st.size
+  delete item.copyFailedAt
+  try {
     writeDb(root, db)
-    return { ok: false, item, note: '没复制成。' }
+  } catch (err) {
+    // 盘上还是 asked：再答一次会覆盖同名文件，把账补上
+    return { ok: false, item, note: `文件到家了，账没记上（${String(err?.code ?? '出错了')}），再答一次。` }
   }
+  return { ok: true, item, note: '带回来了。' }
 }
 
 /** 还等着点头的那几件（界面用）。 */