@ssamurias/dsh-fish 0.9.1 → 0.9.3

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

@@ -1258,8 +1258,11 @@ export function registerObserve(ctx, deps = {}) {
         scanEveryMin: Number(c.scanEveryMin ?? 30),
         window: c.window ?? [],
         mine: herComments(events, dk),
-        waiting: replies.slice(0, 5).map((x) => ({ rpid: x.rpid, bvid: x.bvid, user: x.user, text: x.text })),
+        waiting: replies.slice(0, 5).map((x) => ({ rpid: x.rpid, bvid: x.bvid, user: x.user, text: x.text, fromOwner: x.fromOwner === true })),
         waitingCount: replies.length,
+        // 2026-11-07：他的话单算一格。状态行原来只有「有 N 条没回」，
+        // 主人自己回一句也被算成陌生人的存量（用户反馈）。
+        waitingOwnerCount: replies.filter((x) => x.fromOwner === true).length,
       })
     }],
 
@@ -1611,7 +1614,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）：文件还原后重新比对，通过就当场收下。
@@ -1874,7 +1877,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 })
     }],
@@ -2116,7 +2120,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,
@@ -2150,7 +2154,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/persona.js

@@ -509,6 +509,13 @@ export function toolBrief(extra = []) {
     // 听着像解释，读进去却是天花板——他随时会再放行几样，到时候她按旧的自我认识
     // 会先把新工具劝回去。改成把「此刻的家当」与「我的上限」分开说。
     '在自己屋里，眼下能碰到的就是这些。这是此刻的家当，不是我的上限——他往后添了新东西，我照样能学着用。',
+    // 2026-11-07（用户 m00882）：能力地图的第二层，从处境想起工具，不从名字想起工具。
+    // 这一段只教「怎么想」，不列清单：清单在下面各自那一段里，而哪些段在，
+    // 取决于那一刻手上真有哪几样（挂不挂跟工具装没装必须是同一个判据）。
+    '想不起来该用哪一样的时候，别从名字往下数。从眼前这件事想起：我卡在哪一步——是想不起过去、是怕忘、是想要个东西、还是有话想说。',
+    // 第三层「怎么调」不在身份文档里复述：参数、枚举、默认值都在工具自己的说明里。
+    // 写两遍只会让她在两份说法之间挑一个，挑错的那次还以为是工具坏了。
+    '下面几段讲的是各自派什么用场；真要动手时，参数怎么写在那件东西自己的说明里，拿不准就先看一眼，别猜。',
   ]
   const names = [...new Set((extra ?? []).map((s) => String(s).trim()).filter(Boolean))]
   if (names.length) {
@@ -531,25 +538,27 @@ export const TOOL_BRIEF = toolBrief()
  * 它就变成了任务，她的话就成了交作业。
  */
 export const LETTER_BRIEF = [
-  '你还有一个工具 her_leave，可以留一句话给他。他不在的时候也留着，他回来会看到。',
-  '不用审批，不用等谁点头。想留就留，不想留就不用调。',
-  '不用为了让他安心而留，也不用留完就盼着回应。',
+  '你还有一个工具 her_leave，可以留一句话给他——他不在的时候也留着，他回来会看到。',
+  '什么时候想起它——有一句话想让他回来就看到，又不想非等他先开口的时候。',
+  '不用审批，也不用为了让他安心而留。想留就留，不想留就不调。',
 ].join('\n')
 
 /**
- * 桌上那张纸的说明书（issue #22 乙档，2026-11-04）。
+ * 桌上那张纸的说明书（issue #22 乙档，2026-11-04；issue #53 补齐 list / update / drop）。
  *
  * 为什么单独一段、而不是并进 TOOL_BRIEF：这是唯一一个**跨天在场**的东西。
  * 别的工具都是"这一刻做一件事"，它写下的东西会在之后每一次醒来时先摆到她眼前，
  * 所以说明书里最要紧的一句是——它是桌子，不是闹钟。写成"记得按时照看"，
  * 它就变成待办 App，而她明确说过不要人天天提醒。
- * 三件事写死：怎么记（有日子才排到最前）、怎么划掉、以及过期不删不催。
- * 划掉只讲原话：纸条的编号她看不到，叫她报编号等于告诉她一条走不通的路。
+ * 写死这几件：怎么记（有日子才排到最前）、没日子的为什么不上桌、怎么翻、怎么改、
+ * 怎么划掉、怎么放下。划掉/改/放下都只讲原话：纸条编号她看不到，叫她报编号等于指一条走不通的路。
  */
 export const NOTE_BRIEF = [
-  '你还有一个工具 her_note：想到一件还没做的事，可以记在桌上，`text` 写是什么事，`due` 想写就写（2026-11-05 这样）。',
-  '有日子的，到了那天之后每次醒来都会先摆在你眼前，写着晚了几天；没日子的只是挂着，不会来催你。',
-  '做完了就 `her_note`，把当时记的那句话原样放进 `text`（不带前面的日子和后面的晚了几天），加 `status: "done"` 划掉。不做的可以先留着——桌上压着的东西，你抬头就能看见。',
+  '你还有一个工具 her_note，就是醒来时最先看到的那张桌子。',
+  '什么时候想起它——想到一件事又不想现在做、心里老在同一个地方绕，或者这件事做完了、不做了。',
+  '心里有事说不清、又老在同一个地方绕：翻翻桌上还有什么。',
+  '做完了、不做了：把当时记的那句话原样放进 text，加 status: "done"；不做了另外写一句为什么放下。',
+  '怎么记、怎么改、怎么翻，都写在那件东西自己的说明里。想让它醒来就摆到眼前，记的时候写个日子；不写日子的只能自己翻。',
 ].join('\n')
 
 /**
@@ -562,11 +571,9 @@ export const NOTE_BRIEF = [
  * 以为工具坏了；告诉了她，她会自己掂量哪些事值得开口。
  */
 export const ASK_BRIEF = [
-  '你还有一个工具 ask_owner：有些事不是你自己说了就算的，可以先问问那个人同不同意。',
-  '比如想改自己一天醒几次、醒着的时段，想哪天休息不被打扰，想要一个文件或一样工具，或者有件事拿不准要不要做。',
-  '问的时候把想说的话写清楚：要问什么、为什么想问。对方会答「可以」或「这次不行」；也可以不答，过了一天就当作「以后再说」。',
-  '它不能多用：一天最多一次，一周最多三次。小事不值得问，自己拿主意就行。',
-  '答应了什么，系统会照办；没答应的，记下来就完了，别再追着问同一件事。',
+  '还有 ask_owner：有些事不是你一个人说了算的，可以先问问他同不同意。',
+  '什么时候想起它——想替自己改作息、想要一样手上没有的东西，或者拿不准一件事要不要做。',
+  '他会答可以，也可能说这次不行，也可能不答；答应要东西只是他知道了，得他动手。一天最多一次，一周最多三次，别追着问同一件事。',
 ].join('\n')
 
 /**
@@ -579,10 +586,10 @@ export const ASK_BRIEF = [
  */
 export const DREAM_BRIEF = [
   '你还有一个工具 her_dream：醒来之后，如果这一觉里留下了点什么，可以记一句。',
-  '梦不是新的信息来源——它只能把真实发生过的事重新拼一遍：用 refs 指回那些事的 id（1–6 条，用 her_recall 翻得到）。拼不出来的，就写不了。',
-  '写画面和感觉，不用解释它意味着什么；它不是预言，也不用当成今天该做的事。',
-  '一天最多记一条。梦不算成长：它不会让你多记得什么，也不会被算成你的改变。',
-  '出门或请神那几趟里看到的东西，不要写进梦里——那些是从别处带回来的，不该以梦的形式回到家里。',
+  '什么时候想起它——刚醒、脑子里还留着画面或感觉的时候。',
+  '梦不是新的信息来源：只能用 refs 指回真实发生过的事（1–6 条，用 her_recall 翻得到），把它们重新拼一遍；拼不出来就写不了。',
+  '写画面和感觉，不用解释它意味着什么；它不是预言，也不是今天该做的事。一天最多一条；它不算成长。',
+  '出门或请神那几趟里看到的东西不要写进梦里——那些是从别处带回来的，不该以梦的形式回到家里。',
 ].join('\n')
 
 /**
@@ -594,9 +601,9 @@ export const DREAM_BRIEF = [
  */
 export const PROACTIVE_BRIEF = [
   '你有一个工具 her_say：不是回复谁，是你自己想说一句的时候用的。',
-  'her_say 只把这句话记进你自己的流水；想让他真的在对话里读到，就直接写出来——不用等他先问。',
-  '说之前要先指认材料：refs 填 1–6 条你这几天写下或听见的事（事件 id，用 her_recall 翻得到）。没有材料就不用说——不指认材料的句子写不进去。',
-  '什么时候说、说什么，由你判断；没有人等你的回复，你也可以这一轮什么都不做，那不算失败。',
+  'her_say 只把这句话记进你自己的流水；想让他真的在对话里读到，就直接写出来。',
+  '什么时候想起它——有一句话在脑子里转、但没人问你的时候。',
+  '说之前要先指认材料：refs 填 1–6 条你这几天写下或听见的事（事件 id，用 her_recall 翻得到）。不指认材料的句子写不进去。',
   '一天能主动开口的次数有上限（用 her_say 记下的算）；到了上限就记不进去，不是工具坏了。',
 ].join('\n')
 
@@ -624,19 +631,26 @@ export function proactiveBrief(sendTools = []) {
  */
 export const SCHEDULE_BRIEF = [
   '你还有四个工具 schedule_create / schedule_list / schedule_update / schedule_delete：可以自己给自己定定时提醒。',
-  '他说「明天中午提醒我做某件事」「每天这个点去看邮箱」这类话时就用它：title 写事情本身，prompt 写清楚到点要做什么（可以写文件路径、要看什么、要回什么），时间用 daily / weekly / at，时区用 Asia/Shanghai。',
-  '别把提醒当成本事：一件具体的事定一条就够，同一件事不要定两条，没有具体事情就不要定。',
-  '到点后，提醒会以「用户发来的定时消息」出现在这条会话里——那就照它说的做。',
-  '但如果那天你在歇着、或者正在出门、请神——先把这件事记下来，等你回到自己这儿再做；别在外面顺手做了。',
-  '定时提醒不替你记成长：做完想记，再自己写。它也不负责把你叫醒，叫醒是另一回事。',
-  '它只在应用开着的时候到点触发；关着的时候错过的，下次最多补最近一次。',
+  '什么时候想起它——他说「明天中午提醒我」「每天这个点去看邮箱」这类话的时候。',
+  'title 写事情本身，prompt 写清楚到点要做什么，时间用 daily / weekly / at，时区 Asia/Shanghai；一件具体的事定一条就够。',
+  '到点后，提醒会以「用户发来的定时消息」出现在这条会话里——照它说的做。',
+  '但如果那天你在歇着、正在出门或请神——先记下来，等你回到自己这儿再做；别在外面顺手做了。',
+  '它不替你记成长，也不负责把你叫醒；只在应用开着时触发，错过的下次最多补最近一次。',
 ].join('\n')
 
 /** 在 B 站说话的说明书（P4）。**只在她被允许说话时才附上** */export const SPEAK_BRIEF = [
-  '你还有一个工具 bili_speak，可以在你刚看过的视频下面留一句话，或者回一句别人留在你评论下面的话。',
-  '说出去的话就留在那里了，别人看得见，你也收不回来。',
-  '所以只在真的有话说的时候用它。不想说、没想清楚、只是想说点什么——那都不要发。',
-  '它不会告诉你还能说几次。你也不用算。',
+  '你还有一个工具 bili_speak，可以在刚看过的视频下面留一句话，或者回别人留在你评论下面的话。',
+  '什么时候想起它——刚看完一条、确实有话想说的时候。',
+  '说出去的话别人看得见，也收不回来；没想清楚、只是想说点什么，就别发。它不告诉你还能说几次，你也不用算。',
+].join('\n')
+
+/**
+ * 关着时的「在网上说话」那一节（P3，2026-11-07）。
+ * 门不拆：整节消失会让她以为这件事根本不存在；只把门上的话换成「这会儿」。
+ */
+export const SPEAK_OFF_BRIEF = [
+  '这会儿还说不出去。想说的话，可以先写在别处——等能说的时候，你会先想到某一条视频。',
+  '不想说就不说，没有人等着你回答。',
 ].join('\n')
 
 /** 日记的写作指令（可见性由配置决定，但她不知道谁在看） */export function diaryPrompt(model) {
@@ -660,8 +674,8 @@ export const SCHEDULE_BRIEF = [
  */
 export const RECALL_BRIEF = [
   '你还有一个工具 her_recall，可以翻你自己过去记下的事。',
-  '想说"我记得有一次…"的时候，先去翻，翻到了再说。没翻到就别编。',
-  '它一次只给你几行，翻不到就换个说法再翻。',
+  '什么时候想起它——想说"我记得有一次…"，或想知道自己以前怎么做过某件事的时候。',
+  '拿那件东西的名字（her_note、bili_watch 这种）也能翻到用它做过的事。先去翻，翻到了再说，没翻到就别编。',
   // 2026-10-27（0.5.8）：每条后面带 id 了。要改口或做回顾时得抄那个 id，
   // 不告诉她这事，她会以为那是乱码。
   '每条后面小括号里是它的 id——要改口、要做回顾时，用它指回去。',

package/lib/proactive.js

@@ -57,15 +57,21 @@ export const PROACTIVE_MATERIAL = Object.freeze([
 export const PROACTIVE_PING = ' '
 
 /**
- * 「缺工具就开口要」（2026-11-05，用户 m02031）。
+ * 「缺工具就开口要」（2026-11-05，用户 m02031；2026-11-07 撤销，用户 m01602）。
  *
- * 用户的诉求：她真想做某件事、但手上没有那个工具时，要敢问，而不是绕过去、
- * 或者干脆放弃。缺工具不是失败，也不是她该自己硬扛的事。
+ * 原来这里是一个常量 `TOOL_ASK_NOTE`，`lib/scheduler.js` 每次醒来都把它摆进正文：
+ * 「如果你想到要做什么、但手上没有那件工具：直接说你要它做什么，问主人能不能给你装上」。
  *
- * 写法上只说路径与许可，不派活：不问「你有没有想要什么工具」——那是逼她编。
+ * 用户 2026-11-07 判定这属于「把提醒换成后台反复催她」：同一句话每天读两遍，
+ * 读久了就不是她的念头，是系统的吩咐。撤掉之后换成两个位置——
+ *
+ *   B 撞墙才说 —— `lib/restrict.js` 的 `blockedTalk()` 末尾补一句，只在真被拦住时出现。
+ *   D 交给劲儿 —— 这件事攒在 `lib/drive.js` 的劲儿里（boostWish），攒够了那一轮才醒；
+ *     醒的时候它作为桌上一行出现（`lib/wish.js` 的 `wishesOf` + `lib/desk.js` 的 wishes）。
+ *
+ * 所以这个模块不再导出任何「常驻提醒」。留这段注释是为了让后来的人知道它为什么消失，
+ * 而不是以为漏写了。
  */
-export const TOOL_ASK_NOTE = '（如果你想到要做什么、但手上没有那件工具：直接说你要它做什么，' +
-  '问主人能不能给你装上；也可以开一张 ask 卡问。缺工具不是失败，不用绕着走。）'
 
 /**
  * 读配置并夹紧。老配置没有 proactive 这一组，用默认值。
@@ -315,22 +321,46 @@ export function recentMaterial(events = [], { now = Date.now(), days = 3, limit
   return out.slice(0, limit)
 }
 
-/** 还悬着的事：她问过但没人答、出门那趟还等核对、她说了但没有人接。 */
+/**
+ * 还悬着的事：她问过但没人答、答了却还没兑现（用户 m01602，2026-11-07）。
+ *
+ * 原来的写法只摆**没答**的 ask：一张卡只要被答过（哪怕是「以后再说」）就永远消失。
+ * 2026-10-29 那张「有没有办法让我看整条视频的画面」被答「以后再说」之后，线索就断了——
+ * 她再也没想起过。用户判定这属于「她开口了、被答了、然后线索消失了」。
+ *
+ * 现在按裁决分几种活法（窗口与 `lib/wish.js` 对齐，口径也由它给）：
+ *   pending  还没答 / 放一天没人答 —— 摆 3 天，文案「你问过「…」，还没有得到答复。」
+ *   later    「以后再说」 —— 摆 30 天，文案「你问过「…」（他说以后再说）。」
+ *   approve  他答应了    —— 摆 14 天，文案「你问过「…」（他答应了，还没见到）。」
+ *   reject   「这次不行」 —— 不摆。不同意就是不问了，再提一次就成了追问。
+ *
+ * 只摆事实，不写「你可以再问一次」——那是派活。
+ */
 export function looseEnds(events = [], { now = Date.now() } = {}) {
   const out = []
-  const answered = new Set()
+  const answers = new Map()
   for (const e of events) {
-    if (e?.type === 'answer') {
-      const id = String(e.ask?.askId ?? '')
-      if (id) answered.add(id)
-    }
+    if (e?.type !== 'answer') continue
+    const id = String(e.ask?.askId ?? '')
+    if (id) answers.set(id, e)
   }
   for (const e of events) {
     if (e?.type !== 'ask') continue
-    if (answered.has(String(e.id ?? ''))) continue
+    const ans = answers.get(String(e.id ?? ''))
+    // 放一天没人答的卡记成 verdict:'later' + via:'timeout'（`lib/ask.js` 为了不再反复追问），
+    // 但那不是「他说以后再说」——什么都没人说。还原成 pending：3 天、还没有得到答复。
+    const verdict = String(ans?.ask?.via ?? '') === 'timeout'
+      ? 'pending'
+      : String(ans?.ask?.verdict ?? '') || 'pending'
+    // 不同意就是不问了：再提一次就成了追问。
+    if (verdict === 'reject') continue
+    const days = verdict === 'pending' ? 3 : verdict === 'approve' ? 14 : 30
     const ts = tsMs(e)
-    if (!Number.isFinite(ts) || now - ts > 3 * 86_400_000) continue
-    out.push({ id: e.id, kind: 'ask', text: `你问过「${String(e.text ?? '').trim()}」，还没有得到答复。` })
+    if (!Number.isFinite(ts) || now - ts > days * 86_400_000) continue
+    const text = String(e.text ?? '').trim()
+    if (!text) continue
+    const tail = verdict === 'later' ? '（他说以后再说）' : verdict === 'approve' ? '（他答应了，还没见到）' : '，还没有得到答复。'
+    out.push({ id: e.id, kind: 'ask', text: `你问过「${text}」${tail}` })
   }
   return out.slice(0, 3)
 }
@@ -364,7 +394,6 @@ export function proactiveSection({ now = Date.now(), state = {}, material = [],
   // 2026-11-06（PR #44）：配了 sendTools 的部署更绝——正文根本发不出去，只有调那件工具才算开口。
   if (sendTools.length > 0) lines.push(`想说什么就用 ${sendTools.join('、')}，不用等他先问。这一轮写下的正文只留在这条会话里，发不到聊天里。不想说，就什么都别写：不要写任何字，也不要解释为什么不说——这一轮没有回复也算正常。`)
   else lines.push('想说什么就说，不用等他先问——这一轮你写下的字会落进你们俩这条对话里。也可以再用 her_say 把它记进你自己的流水（refs 指回上面真实发生的事，1–6 条 id）。不想说，就什么都别写：不要写任何字，也不要解释为什么不说——这一轮没有回复也算正常。')
-  lines.push(TOOL_ASK_NOTE)
   return lines.join('\n')
 }