@ssamurias/dsh-fish 0.9.1 → 0.9.3

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'
@@ -38,6 +41,7 @@ import { registerToolRestrict } from './restrict.js'
 // 停用时不清的话下次启用会带着上一次的残留（2026-10-25）。
 import { clearWakeSection, registerIdentity } from './identity.js'
 import { registerPossession } from './possess.js'
+import { withUseDuringRegistration } from './use.js'
 
 import { checkUpgrade } from './upgrade.js'
 import { checkHost, readHostVersion } from './hostver.js'
@@ -45,8 +49,11 @@ import { logBoot, makeLogger } from './log.js'
 
 export const name = 'dsh-fish'
 
-/** 版本号：只用于日志导出（排查时第一件事是确认跑的是哪一版）。 */
-export const VERSION = '0.9.1'
+/**
+ * 版本号，必须和 package.json 的 version 一样（test/boot.test.mjs 盯着）。
+ * 不只是日志：升级自检和设置页的「检查更新」拿它当「正在跑的版本」。
+ */
+export const VERSION = '0.9.3'
 
 // ⚠️ 一个数组写全，不要拆成对象
 // 2026-10-30（m02961）：`userQuestions` **不再写进 inject**。写进 inject 的东西缺一个，
@@ -81,6 +88,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 +131,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 +200,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 +225,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 +261,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 +290,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 +306,7 @@ export function apply(ctx, baseConfig = {}) {
       }
     }
 
+    if (stopped) return
     // ---- 身份文本再落一次盘：屋子建好之后 activeCarry 等才齐，内容可能变 ----
     // 这条改动之后它**不再被宿主注入**（那是旧的 AGENTS.md 通道），只是落盘副本；
     // 真正进她上下文的是上面注册的 system prompt 段（每轮组装时现读文件）。
@@ -311,11 +331,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)
@@ -324,50 +347,56 @@ export function apply(ctx, baseConfig = {}) {
     // 工具：一个写（growth_commit）、一个看（bili_look）。
     // 两者都必须成功注册；缺了任何一个她都会变残（只会说不会看，或只会记不会看）。
     if (ctx.tools?.register) {
-      for (const reg of [
-        () => registerCapture(ctx, { root, tenant: tenancy }),
-        // 2026-11-01（issue #16 第二半，用户 m03454）：这两个以前没拿到 tenancy，
-        // 于是同机任何工作区加载这个插件都能替她写一条 looked:（"她看过了"）——
-        // 看过就是永久判决，而按下判决的人不留名字。现在与 growth_commit 同一条闸。
-        () => registerLook(ctx, { root, client: baseConfig.client, tenant: tenancy }),
-        // 工具说明随说话开关走（2026-10-29）：关着时身份文档里没有「在网上说话」那一节，
-        // 说明里就不该再许诺"可以留评论"。启动时按当时读到的配置定一次，之后由 execute 同步。
-        () => registerSpeak(ctx, {
-          root,
-          client: baseConfig.client,
-          tenant: tenancy,
-          speakEnabled: config?.comment?.enabled === true,
-        }),
-        () => registerRecall(ctx, { root }),
-        // issue #7：日记不进事件流，所以她需要一个只读的窗口回头翻（her_diary）。
-        () => registerHerDiary(ctx, { root }),
-        () => registerWatch(ctx, { root, tenant: tenancy }),
-        // R4：留话（不审批）。和 growth_commit 一样是纯追加，但收件人明确。
-        () => registerLetter(ctx, { root, tenant: tenancy }),
-        // issue #22 乙档（2026-11-04）：醒来看的那张便条。写完会不会到期、
-        // 到期那天摆不摆在最前面，都由 lib/note.js 与 scheduler 的唤醒正文负责，
-        // 这个工具只做两件事：记一张、划掉一张。**常驻注册**，不像梦与主动说话那样要 .dev。
-        () => registerNote(ctx, { root, tenant: tenancy }),
-        // 0.6.17：纪念品。她只能「问」，真带回去要那个人在出门页点头。
-        () => registerBringBack(ctx, { root, tenant: tenancy }),
-        // 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 案——醒来记一句。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。
-        () => registerProactive(ctx, { root, tenant: tenancy, log: (...a) => logger.info(...a) }),
-      ]) {
-        try {
-          const d = reg()
-          if (typeof d === 'function') disposers.push(d)
-          else if (d && typeof d.dispose === 'function') disposers.push(() => d.dispose())
-        } catch (err) {
-          logger.warn('[dsh-fish] 工具注册失败', err?.message ?? err)
+      // 工具使用经验（2026-11-07，用户 m00882）：注册期间把 register 换成
+      // 「包一层 execute 再交出去」的版本，用完立刻换回来。这样 12 个 registerXxx
+      // 一行都不用改，`defineTool` 的「定义原样交出去」约定也不动。
+      withUseDuringRegistration(ctx, root, () => {
+        for (const reg of [
+          () => registerCapture(ctx, { root, tenant: tenancy }),
+          // 2026-11-01（issue #16 第二半，用户 m03454）：这两个以前没拿到 tenancy，
+          // 于是同机任何工作区加载这个插件都能替她写一条 looked:（"她看过了"）——
+          // 看过就是永久判决，而按下判决的人不留名字。现在与 growth_commit 同一条闸。
+          () => registerLook(ctx, { root, client: baseConfig.client, tenant: tenancy }),
+          // 工具说明随说话开关走（2026-10-29）：关着时说明里不该许诺"可以留评论"，
+          // 只说「这会儿还说不出去」（P3，2026-11-07：这一节本身不再消失）。
+          // 启动时按当时读到的配置定一次，之后由 execute 同步。
+          () => registerSpeak(ctx, {
+            root,
+            client: baseConfig.client,
+            tenant: tenancy,
+            speakEnabled: config?.comment?.enabled === true,
+          }),
+          () => registerRecall(ctx, { root }),
+          // issue #7：日记不进事件流，所以她需要一个只读的窗口回头翻（her_diary）。
+          () => registerHerDiary(ctx, { root }),
+          () => registerWatch(ctx, { root, tenant: tenancy }),
+          // R4：留话（不审批）。和 growth_commit 一样是纯追加，但收件人明确。
+          () => registerLetter(ctx, { root, tenant: tenancy }),
+          // issue #22 乙档（2026-11-04）：醒来看的那张便条。写完会不会到期、
+          // 到期那天摆不摆在最前面，都由 lib/note.js 与 scheduler 的唤醒正文负责，
+          // 这个工具只做两件事：记一张、划掉一张。**常驻注册**，不像梦与主动说话那样要 .dev。
+          () => registerNote(ctx, { root, tenant: tenancy }),
+          // 0.6.17：纪念品。她只能「问」，真带回去要那个人在出门页点头。
+          () => registerBringBack(ctx, { root, tenant: tenancy }),
+          // 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 案——醒来记一句。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。
+          () => registerProactive(ctx, { root, tenant: tenancy, log: (...a) => logger.info(...a) }),
+        ]) {
+          try {
+            const d = reg()
+            if (typeof d === 'function') disposers.push(d)
+            else if (d && typeof d.dispose === 'function') disposers.push(() => d.dispose())
+          } catch (err) {
+            logger.warn('[dsh-fish] 工具注册失败', err?.message ?? err)
+          }
         }
-      }
+      })
     }
 
     // 观测台路由
@@ -394,23 +423,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: '带回来了。' }
 }
 
 /** 还等着点头的那几件（界面用）。 */