@ssamurias/dsh-fish 0.9.0 → 0.9.2

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: '带回来了。' }
 }
 
 /** 还等着点头的那几件（界面用）。 */

package/lib/look.js

@@ -14,6 +14,7 @@
  */
 
 import { createClient } from './bili.js'
+import { readMyReplies, renderMyReplies } from './comment.js'
 import { absorb, renderMaterial, rankVideos, seenBvids, LOOK_BRIEF, WATCH_RULE } from './browse.js'
 import { readEvents, rootDir, appendEvent } from './store.js'
 import { loadConfig, dateKey } from './settings.js'
@@ -58,6 +59,24 @@ export async function lookOnce(o = {}) {
     // 这一轮被「看过」摘掉几条（issue #16 第一半）：下面那句提示要靠它才说得准。
     const rankStats = { hiddenSeen: 0 }
 
+    // 2026-11-06（用户 m01641）：她问「我那条评论下面有人说了什么」时，
+    // 此前只能等下次叫醒、由 scheduler 把那几句拼进消息里——醒着的时候够不着，
+    // 而且那条提醒被她看过一次就被 cseen 掉了，回头再看永远是空的。
+    // 这里给她一个自己去看的动作：不滤 cseen，带上回楼中楼要用的编号。
+    if (what === 'replies') {
+      const got = await readMyReplies({ root, client, events, bvid: String(o.bvid ?? '').trim() })
+      const txt = renderMyReplies(got, { bvid: String(o.bvid ?? '').trim() })
+      if (!txt) {
+        return {
+          ok: false,
+          text: '',
+          note: got.length ? '' : '你最近没在谁的评论下面被人回过——也可能是我这边还查不到（B 站这会儿回了个 -412）。',
+          picks: [],
+        }
+      }
+      return { ok: true, text: txt, note: '', picks: got.map((x) => ({ bvid: x.bvid, rpid: x.rpid, rootRpid: x.rootRpid })) }
+    }
+
     let list = []
     // 2026-10-28（用户 m01284）：他递来一条视频，她想看就得看得见指定的**那一条**。
     // 以前只有 home/search/related，related 是「接着这条往下看它的相关推荐」——
@@ -239,6 +258,7 @@ export function registerLook(ctx, deps = {}) {
       description:
         '去看一眼 B 站：首页在推什么、搜一个词、看某条视频之后平台又接着推什么，' +
         '或者直接看指定的那一条（给 BV 号或链接）。' +
+        '也可以看你自己发过的评论下面有没有人回你（what=replies）。' +
         '只读，不会留下痕迹。给的是标题、简介、标签、热评、弹幕——没有视频画面。' +
         '不用它也可以。',
       // 注意：必须 toJsonSchema 包一层。简写 DSL 直接发出去会被 provider 拒：
@@ -247,11 +267,11 @@ export function registerLook(ctx, deps = {}) {
         what: {
           type: 'string',
           required: true,
-          enum: ['home', 'search', 'related', 'video'],
-          description: 'home=首页推给你的；search=你自己搜（要带 keyword）；related=接着某条往下看（要带 bvid）；video=看指定的那一条（要带 bvid）。',
+          enum: ['home', 'search', 'related', 'video', 'replies'],
+          description: 'home=首页推给你的；search=你自己搜（要带 keyword）；related=接着某条往下看（要带 bvid）；video=看指定的那一条（要带 bvid）；replies=看你自己发过的评论下面有没有人回你（可带 bvid 只看那一条）。',
         },
         keyword: { type: 'string', required: false, description: 'what=search 时搜什么。' },
-        bvid: { type: 'string', required: false, description: 'what=related 时从哪条接着看；what=video 时看哪一条（BV 号，或者他递过来的链接）。' },
+        bvid: { type: 'string', required: false, description: 'what=related 时从哪条接着看；what=video 时看哪一条（BV 号，或者他递过来的链接）；what=replies 时只看这一条视频下面的。' },
       }),
       output: {
         schema: {

package/lib/note.js

@@ -9,10 +9,14 @@
  * 所以这不是闹钟（到点叫我），是一张**桌子**：一天看一次，睁眼知道欠几天。
  * 不做通知、不做界面卡片、不做红点——她要的是"睁眼时桌上有什么"。
  *
- * 乙档（用户 m01465：「那先做乙吧，先测试一段时间看看」）只做两件事：
- *   1. 醒来第一段摆出到期的（renderNotes，纯函数）；
- *   2. her_note 能写（text 必填、due 可选）、能划掉（status:'done'）。
- * 不做 dropped（不做要写一句为什么）、不做回翻、不做"没日子的只提一次"。
+ * 0.8.8 的乙档（用户 m01465）只做了两件事：醒来摆出到期的、her_note 能写能划掉。
+ * 2026-11-06（issue #53）补齐当初说好「跑一段再说」的三样，另修一个死锁：
+ *   1. 名额只算 open。原来 200 张名额连划掉的一起算，划满之后再也记不进（死锁）；
+ *   2. 回翻（list）：open / due / done / dropped / all，带 offset 往后翻；
+ *   3. 放下（drop，reason 必填）——issue #22 里设计好的第三种状态，数据层一直在等它。
+ * 「没日子的只提一次」落在 add 的回执里（写下的那一下回一句原文），**不进唤醒段**：
+ * 没日子就没有账可算，抬到桌上就变成催了。这跟「以后都不上桌」不冲突。
+ * update（改一句）暂不做：直接覆盖文本会把她改过什么抹掉，要做得先定好留痕的字段。
  *
  * 三条硬约束（从 letter.js 沿下来的同一条线）：
  *   1. **不审批**。记一张纸条不是改自己，不设关卡。
@@ -39,6 +43,10 @@ export const NOTES_MAX = 200
 export const NOTE_TEXT_MAX = 200
 /** 醒来那一段最多列几张，剩下的只报数。 */
 export const NOTE_SHOW_MAX = 5
+/** 一次 list 最多列几行。往后翻靠 offset，不一次把两百张全倒出来。 */
+export const NOTE_LIST_MAX = 20
+/** list 能看的几类：open=还没关掉的，due=写了日子的，done/dropped=关掉的，all=全要。 */
+export const NOTE_FILTERS = ['open', 'due', 'done', 'dropped', 'all']
 
 export function notesPath(root = rootDir()) {
   return join(root, NOTES_FILE)
@@ -73,6 +81,8 @@ export function normalizeNote(raw) {
     status,
     reason: raw.reason == null ? null : String(raw.reason).slice(0, 200),
     closedAt: raw.closedAt == null ? null : String(raw.closedAt),
+    // 只有 update 会写；其余时候是 null。留着它，改过的痕迹至少还在时间上
+    revisedAt: raw.revisedAt == null ? null : String(raw.revisedAt),
   }
 }
 
@@ -193,8 +203,11 @@ export async function addNote(root, { text, due } = {}) {
 
   try {
     const notes = await readNotes(root)
-    if (notes.length >= NOTES_MAX) {
-      return { ok: false, id: '', note: '桌上已经堆满了，先划掉几张再说。' }
+    // 名额只算还压在桌上的。划掉/放下的不占位——否则划满两百张之后再也记不进，
+    // 而拒绝的话还说「先划掉几张」，桌上根本没有能划的（issue #53 的死锁）。
+    const openCount = notes.filter((n) => n.status === 'open').length
+    if (openCount >= NOTES_MAX) {
+      return { ok: false, id: '', note: '桌上堆满两百张没动的了，先划掉几张，或者放下几张（放下要写一句为什么）再说。' }
     }
     const note = normalizeNote({
       id: newNoteId(),
@@ -205,7 +218,7 @@ export async function addNote(root, { text, due } = {}) {
     })
     notes.push(note)
     await writeNotes(root, notes)
-    return { ok: true, id: note.id, note: '已记。' }
+    return { ok: true, id: note.id, note: '已记。', echo: note.text }
   } catch (err) {
     return { ok: false, id: '', note: '这张没记下来。' }
   }
@@ -247,6 +260,179 @@ export async function closeNote(root, { id, text } = {}) {
   }
 }
 
+// ---- 回翻、改一句、放下（issue #53，2026-11-06）----
+// 三件事共用一套「按她看得见的东西找条」：她手里没有 id，只有自己写过的那句话。
+// 所以对外只认原话；id 这条路留着给代码用，不进说明书。
+
+/** list 里的一行。关掉的那几种带上关掉的日期，放下的还要带上那句为什么。 */
+function listLine(n) {
+  const md = (iso) => {
+    const d = String(iso ?? '').slice(0, 10)
+    return isDue(d) ? `${d.slice(5, 7)}-${d.slice(8, 10)}` : ''
+  }
+  if (n.status === 'done') {
+    const at = md(n.closedAt)
+    return `✓ ${n.text}${at ? `（${at} 划掉）` : ''}`
+  }
+  if (n.status === 'dropped') {
+    const at = md(n.closedAt)
+    return `✗ ${n.text}${at ? `（${at} 放下）` : ''}${n.reason ? `—— ${n.reason}` : ''}`
+  }
+  return n.due ? `${n.due.slice(5)} ${n.text}` : `（没日子）${n.text}`
+}
+
+/** 摊在桌上的先按到期日（没日子的排最后），关掉的按关掉的时间倒序。 */
+function sortForList(notes) {
+  const open = notes.filter((n) => n.status === 'open')
+  const closed = notes.filter((n) => n.status !== 'open')
+  open.sort((a, b) => {
+    if (a.due && b.due && a.due !== b.due) return a.due < b.due ? -1 : 1
+    if (a.due && !b.due) return -1
+    if (!a.due && b.due) return 1
+    return String(a.created).localeCompare(String(b.created))
+  })
+  closed.sort(
+    (a, b) =>
+      String(b.closedAt ?? '').localeCompare(String(a.closedAt ?? '')) ||
+      String(b.created).localeCompare(String(a.created)),
+  )
+  return [...open, ...closed]
+}
+
+/** 按 filter 挑出这一类（纯函数，可测）。filter 不认识就当 open。 */
+export function filterNotes(notes, filter = 'open') {
+  const f = NOTE_FILTERS.includes(String(filter)) ? String(filter) : 'open'
+  const list = (notes ?? []).filter(Boolean)
+  if (f === 'all') return sortForList(list)
+  if (f === 'open') return sortForList(list.filter((n) => n.status === 'open'))
+  if (f === 'due') return sortForList(list.filter((n) => n.status === 'open' && isDue(n.due)))
+  return sortForList(list.filter((n) => n.status === f))
+}
+
+const EMPTY_LIST = {
+  open: '桌上没有还没划掉的。',
+  due: '没有哪张写着日子。',
+  done: '还没有划掉的。',
+  dropped: '还没有放下的。',
+  all: '桌上什么都没有。',
+}
+
+/**
+ * 翻桌子（reading 用，改不了任何东西）。
+ *
+ * 只列字，不报总数——「你还有 3 条」这种句式谢绝。列不下的写一句「后面还有」，
+ * 往后翻用 offset。没日子那种的照旧标出来：它在桌上，但醒来时不会自己出现。
+ * @returns {Promise<{ok:boolean, text:string, note:string}>}
+ */
+export async function listNotes(root, { filter = 'open', offset = 0, limit = NOTE_LIST_MAX } = {}) {
+  const f = NOTE_FILTERS.includes(String(filter)) ? String(filter) : 'open'
+  const off = Number(offset) > 0 ? Math.trunc(Number(offset)) : 0
+  const lim = Number(limit) > 0 ? Math.min(Math.trunc(Number(limit)), NOTE_LIST_MAX) : NOTE_LIST_MAX
+  try {
+    const all = filterNotes(await readNotes(root), f)
+    if (!all.length) return { ok: true, text: EMPTY_LIST[f], note: '' }
+    const page = all.slice(off, off + lim)
+    if (!page.length) return { ok: true, text: '后面没有了。', note: '' }
+    const lines = page.map(listLine)
+    const rest = all.length - (off + page.length)
+    if (off > 0) lines.unshift(`（从第${cnNum(off + 1)}张接着看）`)
+    if (rest > 0) lines.push('……后面还有，没一次列完（offset 往后翻）。')
+    return { ok: true, text: lines.join('\n'), note: '' }
+  } catch (err) {
+    return { ok: false, text: '', note: '这会儿翻不开，等一下再试。' }
+  }
+}
+
+/** 按 id 或原话找一张；先 id，再原话（没关掉的优先，其次已划掉的）。 */
+function locate(notes, { id, text } = {}) {
+  const key = String(id ?? '').trim()
+  if (key) {
+    const byId = notes.find((n) => n.id === key)
+    if (byId) return byId
+  }
+  const body = String(text ?? '').replace(/\s+/g, ' ').trim()
+  return body ? findByText(notes, body) ?? null : null
+}
+
+/**
+ * 改一句（写错了）。永不抛。
+ *
+ * 只改没关掉的那张：划掉/放下了的改不了——回翻里留着当时那句话，改它等于改历史。
+ * `due` 不给就不动日子，给空串是去掉日子，给日期是改期。
+ * @returns {Promise<{ok:boolean, id:string, note:string, echo?:string}>}
+ */
+export async function updateNote(root, { id, text, newText, due } = {}) {
+  const key = String(id ?? '').trim()
+  const body = String(text ?? '').replace(/\s+/g, ' ').trim()
+  const next = String(newText ?? '').replace(/\s+/g, ' ').trim()
+  if (!key && !body) return { ok: false, id: '', note: '要改哪一张？把当时记的那句话告诉我。' }
+  if (!next) return { ok: false, id: '', note: '改成什么？把新的那句话告诉我。' }
+  if (next.length > NOTE_TEXT_MAX) {
+    return { ok: false, id: '', note: `太长了，压到 ${NOTE_TEXT_MAX} 字以内。` }
+  }
+  const day = due === undefined ? undefined : String(due ?? '').trim()
+  if (day !== undefined && day && !isDue(day)) {
+    return { ok: false, id: '', note: '日子要写成 2026-11-05 这样，或者给空串把日子去掉。' }
+  }
+  try {
+    const notes = await readNotes(root)
+    const hit = locate(notes, { id: key, text: body })
+    if (!hit) {
+      return { ok: false, id: '', note: '桌上没有这一张。要和当时记的那句话一字不差。' }
+    }
+    if (hit.status === 'done') return { ok: false, id: '', note: '这张已经划掉了，改不了。' }
+    if (hit.status === 'dropped') return { ok: false, id: '', note: '这张已经放下了，改不了。' }
+    hit.text = next.slice(0, NOTE_TEXT_MAX)
+    if (day !== undefined) hit.due = day
+    hit.revisedAt = new Date().toISOString()
+    await writeNotes(root, notes)
+    return { ok: true, id: hit.id, note: '改好了。', echo: hit.text }
+  } catch (err) {
+    return { ok: false, id: '', note: '这会儿写不进去，等一下再试。' }
+  }
+}
+
+/**
+ * 放下（决定不做，并写一句为什么）。永不抛。
+ *
+ * 跟划掉一样只是改状态、条目一条不删；差别只在多一句 reason，那句必须她自己写。
+ * 不检查写得好不好——只要求非空，不然就跟删掉没区别了。
+ * @returns {Promise<{ok:boolean, id:string, note:string}>}
+ */
+export async function dropNote(root, { id, text, reason } = {}) {
+  const key = String(id ?? '').trim()
+  const body = String(text ?? '').replace(/\s+/g, ' ').trim()
+  const why = String(reason ?? '').replace(/\s+/g, ' ').trim()
+  if (!key && !body) return { ok: false, id: '', note: '要放下哪一张？把当时记的那句话告诉我。' }
+  if (!why) return { ok: false, id: '', note: '放下还要说一句为什么——不然就跟删掉没区别了。' }
+  if (why.length > NOTE_TEXT_MAX) {
+    return { ok: false, id: '', note: `原因太长了，压到 ${NOTE_TEXT_MAX} 字以内。` }
+  }
+  try {
+    const notes = await readNotes(root)
+    const hit = locate(notes, { id: key, text: body })
+    if (!hit) {
+      return { ok: false, id: '', note: '桌上没有这一张。要和当时记的那句话一字不差。' }
+    }
+    if (hit.status === 'dropped') return { ok: true, id: hit.id, note: '之前就放下了。' }
+    if (hit.status === 'done') return { ok: false, id: '', note: '这张已经划掉了，不用再放下。' }
+    hit.status = 'dropped'
+    hit.reason = why.slice(0, 200)
+    hit.closedAt = new Date().toISOString()
+    await writeNotes(root, notes)
+    return { ok: true, id: hit.id, note: '放下了。' }
+  } catch (err) {
+    return { ok: false, id: '', note: '这会儿写不进去，等一下再试。' }
+  }
+}
+
+/** 这一次是哪件事。没写 action 的按老路走：status=done 或只给 id 是划掉，其余是记一张。 */
+export function noteAction(args = {}) {
+  const a = String(args?.action ?? '').trim()
+  if (['add', 'list', 'update', 'drop', 'done'].includes(a)) return a
+  return isClosing(args) ? 'done' : 'add'
+}
+
 /** 这一次是划掉还是记。execute 和 render 用同一个判据，回执才不会和实际做的事对不上。 */
 const isClosing = (args) =>
   String(args?.status ?? '').trim() === 'done' ||
@@ -259,42 +445,91 @@ export function registerNote(ctx, deps = {}) {
     defineTool({
       name: 'her_note',
       description:
-        '把一件还没做的事记到桌上，或者划掉一张已经做完的。醒来的时候你会先看到到期的那些。' +
-        '记的时候只给要做的事（和日子，可以不给）；划掉的时候把当时记的那句话原样放进 text，再加 status:"done"。',
+        '醒来时先看的那张桌子：记一张还没做的事、看看桌上都有什么、划掉做完的、或者放下决定不做的。' +
+        '记的时候给 text（和日子 due，可以不给）；划掉把当时记的那句话原样放进 text，再加 status:"done"；' +
+        '看桌上有什么给 action:"list"（filter 可以选 open / due / done / dropped / all，列不完用 offset 往后翻）；' +
+        '改一句给 action:"update"（text 指认原来那句，newText 写新的）；' +
+        '放下给 action:"drop"（同样用 text 指认，reason 写一句为什么）。',
       parameters: toJsonSchema({
+        action: {
+          type: 'string',
+          enum: ['add', 'list', 'update', 'drop', 'done'],
+          description: '要做哪件事：记一张（add，不给就是这个）、翻桌子（list）、改一句（update）、放下（drop）、划掉（done）。',
+        },
         text: {
           type: 'string',
-          description: '要记下来的那件事，一句话。划掉的时候写当时记的那句话，要一字不差。',
+          description: '要记下来的那件事，一句话。划掉、改、放下的时候写当时记的那句话，要一字不差。',
         },
         due: {
           type: 'string',
-          description: '哪天该做，写成 2026-11-05。可以不给——不给就是挂着，不算日子。',
+          description:
+            '哪天该做，写成 2026-11-05。不写就不会在醒来时出现，只能自己 list 看；改一句时给空串是把日子去掉。',
         },
-        id: { type: 'string', description: '要划掉的那张纸条的 id。手里没有就不用给，给 text 就行。' },
+        id: { type: 'string', description: '这张纸条的编号。手里没有就不用给，给 text 就行。' },
         status: { type: 'string', enum: ['done'], description: '划掉的时候给 done。' },
+        filter: {
+          type: 'string',
+          enum: ['open', 'due', 'done', 'dropped', 'all'],
+          description: 'list 时看哪一类，默认 open（还没关掉的）。',
+        },
+        offset: { type: 'integer', description: 'list 时从第几张往后翻，默认从最前面。' },
+        limit: { type: 'integer', description: 'list 时一次最多列几张，默认 20。' },
+        newText: { type: 'string', description: 'update 时改成哪句话。' },
+        reason: { type: 'string', description: 'drop 时为什么不做了，必填。' },
       }),
       output: {
         schema: {
           type: 'object',
-          properties: { ok: { type: 'boolean' }, id: { type: 'string' }, note: { type: 'string' } },
+          properties: {
+            ok: { type: 'boolean' },
+            id: { type: 'string' },
+            note: { type: 'string' },
+            echo: { type: 'string' },
+            text: { type: 'string' },
+          },
           required: ['ok', 'note'],
         },
         // 和 her_leave 同一条规矩：只回方括号标记，不写完整句子、不带"还剩几张"。
         // 划掉不能沿用写入的字：读到「记下了」，她会以为桌上又多了一张。
+        // list 例外：它列的本来就是字，不是回执。
         render: (args, out) => {
-          const [yes, no] = isClosing(args) ? ['划掉了', '没划掉'] : ['记下了', '没记下']
-          return [{ type: 'text', text: out.ok ? `[${yes}]` : `[${no}：${out.note}]` }]
+          const act = noteAction(args)
+          if (act === 'list') {
+            return [{ type: 'text', text: out.ok ? out.text : `[没列出来：${out.note}]` }]
+          }
+          if (act === 'update') {
+            return [{ type: 'text', text: out.ok ? '[改好了]' : `[没改：${out.note}]` }]
+          }
+          if (act === 'drop') {
+            return [{ type: 'text', text: out.ok ? '[放下了]' : `[没放下：${out.note}]` }]
+          }
+          if (act === 'done') {
+            return [{ type: 'text', text: out.ok ? '[划掉了]' : `[没划掉：${out.note}]` }]
+          }
+          if (!out.ok) return [{ type: 'text', text: `[没记下：${out.note}]` }]
+          // 没日子的那张以后不会上桌，所以它只在这里被提这一次——这不是提醒，是入账凭证。
+          const tail = String(args?.due ?? '').trim() ? '' : '（没写日子，醒来不会出现）'
+          return [{ type: 'text', text: `[记下了：${out.echo ?? ''}]${tail}` }]
         },
       },
       async execute(args, exec) {
         const who = guardWrite(deps.tenant, exec, 'her_note')
         if (!who.ok) return { ok: false, id: '', note: who.note }
-        if (isClosing(args)) {
-          const r = await closeNote(root, { id: args?.id, text: args?.text })
-          return { ok: r.ok, id: r.id, note: r.note }
+        const act = noteAction(args)
+        if (act === 'list') {
+          const r = await listNotes(root, { filter: args?.filter, offset: args?.offset, limit: args?.limit })
+          return { ok: r.ok, id: '', note: r.note, text: r.text }
+        }
+        if (act === 'update') {
+          return updateNote(root, { id: args?.id, text: args?.text, newText: args?.newText, due: args?.due })
+        }
+        if (act === 'drop') {
+          return dropNote(root, { id: args?.id, text: args?.text, reason: args?.reason })
+        }
+        if (act === 'done') {
+          return closeNote(root, { id: args?.id, text: args?.text })
         }
-        const r = await addNote(root, { text: args?.text, due: args?.due })
-        return { ok: r.ok, id: r.id, note: r.note }
+        return addNote(root, { text: args?.text, due: args?.due })
       },
     }),
   )

package/lib/observe.js

@@ -255,6 +255,11 @@ export function registerObserve(ctx, deps = {}) {
           const c = countEvents(events)
           return {
             utterance: events.filter((e) => e.type === 'utterance').length,
+            // issue #32：对话行（flags 带 uncommitted）单列。它们是她答他的话，
+            // 跟她自己想说的判断混在一起时，「说 N 句」这个数字会越聊越虚高。
+            chat: events.filter(
+              (e) => e.type === 'utterance' && Array.isArray(e.flags) && e.flags.includes('uncommitted'),
+            ).length,
             revise: events.filter((e) => e.type === 'revise').length,
             refusal: events.filter((e) => e.type === 'refusal').length,
             reunion: events.filter((e) => e.type === 'reunion').length,
@@ -486,6 +491,10 @@ export function registerObserve(ctx, deps = {}) {
         }
         const before = await loadConfig(root).catch(() => null)
         const next = await updateConfig(patch, root)
+        // 身份段里有一句跟着 sendTools 走，变了就重写一次（只在变的时候，别的保存不多写盘）
+        if (JSON.stringify(before?.config?.proactive?.sendTools ?? []) !== JSON.stringify(next?.proactive?.sendTools ?? [])) {
+          await refreshSelfDoc(root).catch(() => {})
+        }
         // 审计：日记可见性每翻一次就落一行，事后查得到是谁、随哪次提交翻的。
         // 2026-10-28 用户反馈「开了『让我看日记』插件又自己关」——光靠猜猜不出来，
         // 至少让下一次发生时日志里有一行可对。
@@ -1602,7 +1611,7 @@ export function registerObserve(ctx, deps = {}) {
         const said = b.yes === true
         const r = decideKeepsake(root, { id: String(b.id ?? ''), yes: said })
         logLine('info', ['纪念品：', said ? '准了' : '没带', r.item?.rel ?? '', r.item?.id ?? ''], root)
-        return send(res, r.ok ? 200 : 409, { ok: r.ok, item: r.item ?? null, note: r.note })
+        return send(res, r.ok ? 200 : 409, { ok: r.ok, item: r.item ?? null, note: r.note, ...(r.ok ? {} : { error: r.note }) })
       }
 
       // 复核上一次被拒收的那趟（0.6.32）：文件还原后重新比对，通过就当场收下。
@@ -1865,7 +1874,8 @@ export function registerObserve(ctx, deps = {}) {
         reason: b.reason,
         via: 'ui',
       })
-      if (!r.ok) return send(res, 409, { ok: false, why: r.why })
+      // jpost 只认 error：别的地方（IM、别的页面）先答过时，要让人看到原因，不是一个 HTTP 409
+      if (!r.ok) return send(res, 409, { ok: false, why: r.why, error: r.why })
       logLine('info', ['请求事件：回答', String(b.askId || ''), String(b.verdict || '')], root)
       return send(res, 200, { ok: true })
     }],
@@ -2107,7 +2117,7 @@ export function registerObserve(ctx, deps = {}) {
       // 空白会话在侧栏里是隐形的（宿主 sessionVisible：blank && id !== current → false）。
       // 插件用 API 建的会话不会被设成当前会话，所以要让她先动一轮，侧栏才看得见。
       const woke = fresh.ok
-        ? await wakeIfBlank(ctx, { sessionId: fresh.sessionId, root, log: (m) => console.log('[dsh-fish]', m), freshOnly: !fresh.reused })
+        ? await wakeIfBlank(ctx, { sessionId: fresh.sessionId, root, log: (m) => console.log('[dsh-fish]', m), freshOnly: !fresh.reused, verify: true })
         : { woke: false }
       send(res, 200, {
         ok: true,
@@ -2141,7 +2151,7 @@ export function registerObserve(ctx, deps = {}) {
         force: true,
       })
       const woke = fresh.ok
-        ? await wakeIfBlank(ctx, { sessionId: fresh.sessionId, root, log: (m) => console.log('[dsh-fish]', m), freshOnly: !fresh.reused })
+        ? await wakeIfBlank(ctx, { sessionId: fresh.sessionId, root, log: (m) => console.log('[dsh-fish]', m), freshOnly: !fresh.reused, verify: true })
         : { woke: false }
       send(res, fresh.ok ? 200 : 409, {
         ok: fresh.ok,

package/lib/owner.js

@@ -133,6 +133,9 @@ export function mentionPrefix(ow, cfg) {
   const on = cfg?.comment?.atOwner !== false
   const name = String(ow?.nickname ?? ow?.name ?? '').trim()
   if (!on || !name) return ''
-  // B 站昵称里带空格时 @ 会断掉，换成下划线是站内常见写法
-  return `@${name.replace(/\s+/g, '_')} `
+  // 2026-11-06：原来把空格换成下划线，理由是「@ 遇到空格会断」。但 B 站解析 @ 时
+  // 是按昵称原文匹配的（真机采样里 content.members 的 uname 与正文完全一致），
+  // 换成下划线反而变成一个不存在的昵称 —— 昵称里带空格的用户永远 @ 不出来。
+  // 改成原样保留；末尾那个空格是分隔，别删。
+  return `@${name} `
 }