@nightpainters/dsh-ling 1.5.1 → 1.5.2

package/lib/host/memory.js

@@ -2,7 +2,7 @@
 // Schema per DESIGN §7. All access single-process (host).
 import { DatabaseSync } from 'node:sqlite';
 import { join } from 'node:path';
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, readFileSync, statSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
 import { ensureDir, sha256Text, utcIso, mergeDeep, toIso, toEpochMs } from './util.js';
 // A-01(1.5.1):主脉记忆被覆盖前**必须先归档**。archive.js 只依赖 node:fs / node:path,
@@ -23,6 +23,26 @@ export const LINEAGE_ANCESTOR = 0.7; // 枝读其祖先(直系血缘:主干就
 export const LINEAGE_SIDE = 0.4; // 旁系 / 祖先读后代(枝的内容不构成主干的记忆)
 export const CONFLICT_DOWNWEIGHT = 0.3; // 矛盾败方降权系数(D9-b:未复盘时以最新为准,旧的一方乘此值)
 
+/** B3(1.5.2):树改动播报的**两条全局水位** —— 与按会话水位并存,语义各自独立:
+ *   · `announced`:全局"**已示人**"边界 —— 只推进到**真正渲染过**的行(branchLogDigest 的
+ *     shownMaxId)。它的职责是"已经给谁看过的不再重播"(修 B3-1:新会话从 0 起把最新 5 条又播一遍)。
+ *   · `retired`  :全局"**已按时间窗计数式处置**"的边界 —— 超窗老改动只计数、不展开,
+ *     **不算已示人**,所以必须独立成键。为什么不能复用它(1.5.2 定案:两条路都堵死):
+ *      (a) 不给独立游标 ⇒ 某一轮"可展开行 = 0"时 `shownMaxId=0`,**水位永不前进、每轮重播同一行**(死锁);
+ *      (b) 把它并进 `announced` ⇒ 把**从没展开过的**老账标成"已示人" = B3-2 的"没看就清"换个马甲。
+ *     回归:死锁构造(`id` 更大但 `at` 为 30 天前)见 tests/tree.test.mjs 第 9-4b / 9-4c 条。
+ *  另两个**本版一字未动**:`branch_log_wm.<sessionId>`(会话水位)与 `branch_log_wm.last`
+ *  (全表最大 id —— 复盘模式的退出判据,消费点见 branchLogPending)。 */
+export const BRANCH_LOG_WM_ANNOUNCED = 'branch_log_wm.announced';
+export const BRANCH_LOG_WM_RETIRED = 'branch_log_wm.retired';
+
+/** §2 时间窗默认天数(1.5.2):只**展开**最近这么多天的树改动,更老的只计数不展开。
+ *  取 3 的依据(实测 live 库,394 笔留痕):92% 是 ≥3 天前的程序批量(单日最高 243 笔),
+ *  近 3 天只占 32 笔 —— 3 天正好把"刚改的树"与"很久以前那批"分开;
+ *  改小(1 天)会把 09-24 那批 24 笔也算老账,改大(7 天)会把 09-23 的 243 笔重新拉回明细。
+ *  `<= 0` = 关闭时间窗(全部按近期展开)。 */
+export const BRANCH_LOG_WINDOW_DAYS = 3;
+
 /** 原文命名空间(G4/2026-09-17):dsh_turns_raw 无 source 维,DSH 会话与导入原文共表。
  *  若不隔离,概述器会把导入内容当成 DSH 会话重建(GROUP BY session_id 认领)→ 跨源双份;
  *  同 id 时更会互相覆盖原文(不可恢复)。故导入原文一律落 'import:<conv_id>'。
@@ -947,22 +967,52 @@ export class MemoryStore {
    * 水位用**自增 id** 而非时间戳 —— 同一毫秒内的多条改动用时间戳比较会漏。
    * 只报结构操作,不碰任何记忆内容(与"内容零改写"不变量一致)。
    */
-  branchLogDigest({ limit = 5, afterId = null } = {}) {
+  branchLogDigest({ limit = 5, afterId = null, now = Date.now(), windowDays = BRANCH_LOG_WINDOW_DAYS } = {}) {
     const max = Math.max(1, Math.min(20, Number(limit) || 5));
     // B#9(2026-09-22 审计):水位必须**按会话** —— 全局键会让会话 A 消费之后、
     // 会话 B 再也看不到同一批改动。调用方传 afterId(取自 kv `branch_log_wm.<sessionId>`);
     // 未传才退回全局键(仅为兼容旧调用点,新代码不应依赖)。
-    const wm = (afterId !== null && afterId !== undefined && Number.isFinite(Number(afterId)))
+    // ── B3(1.5.2)在旁边加注:上面这条裁决**保留原文、今天依然成立** ——
+    // 它管的是"别漏";它没管另一头:新会话水位从 0 起会把**已经播过的**又播一遍(B3-1),
+    // 而"播完就把水位推到全表最新 id"会把**从没示人**的中间那些标成已读(B3-2)。
+    // 所以 1.5.2 **不是改回全局单键**,而是**两条并存**,有效下界取三者更大者:
+    //   · `branch_log_wm.<sessionId>` 本会话已看到哪(会话增量,B#9 原样保留);
+    //   · `branch_log_wm.announced`   **全局**"已示人"边界(只推进到真正渲染过的行 ⇒
+    //     已经给谁看过的不再重播,新会话因此不重播);
+    //   · `branch_log_wm.retired`     **全局**"已按时间窗计数式处置"的边界(§2 老改动
+    //     只计数不展开 ⇒ **不算已示人**,故独立成键,只防同一批老账每轮重复计数)。
+    const sessionWm = (afterId !== null && afterId !== undefined && Number.isFinite(Number(afterId)))
       ? Number(afterId)
       : Number(this.kvGet('branch_log_wm') || 0);
+    const wm = Math.max(
+      sessionWm,
+      Number(this.kvGet(BRANCH_LOG_WM_ANNOUNCED) || 0) || 0,
+      Number(this.kvGet(BRANCH_LOG_WM_RETIRED) || 0) || 0,
+    );
     let rows = [];
     try {
-      rows = this.listBranchLog({ limit: 120 });
+      // B3-2(1.5.2):候选从"全表最新 120 行里挑最新的 limit 条"改成**水位之上最早的 limit 条**
+      // (FIFO)。病根就在取数顺序 —— 这是本次修复的**实质**,别当成等价改写:
+      //   旧取数是 `ORDER BY id DESC` + `slice(0, max)`,渲染出来的是**最新那 5 条**(一个后缀);
+      //   于是原代码的 `maxId: Number(fresh[0].id)` **看着像"渲染到的最大 id",其实从来不是** ——
+      //   它取的是**最新那条**。水位一跳,落在"最新 5 条"与"上一轮水位"之间的那批改动
+      //   (**比这 5 条更老**)既没示人、又被标成已读:live 上实测中间 114 笔。
+      //   FIFO 之后"渲染到的最大 id"才真正小于"全表最新","下一轮还能看到剩下的"才成立。
+      rows = this.listBranchLog({ limit: 120, afterId: wm, ascending: true });
     } catch {
-      return { lines: [], maxId: wm, total: 0 };
+      return { lines: [], maxId: wm, shownMaxId: 0, retiredMaxId: 0, total: 0, expired: 0 };
     }
-    const fresh = rows.filter((r) => Number(r.id) > wm);
-    if (!fresh.length) return { lines: [], maxId: wm, total: 0 };
+    if (!rows.length) {
+      return { lines: [], maxId: wm, shownMaxId: 0, retiredMaxId: 0, total: 0, expired: 0 };
+    }
+    // 全表最大 id:与 1.5.1 同值(那时取 id DESC 结果的 `fresh[0].id`),现在显式问一次 MAX,
+    // 与取数顺序解耦。**只喂 `branch_log_wm.last`**(复盘退出判据),不参与"已示人"判定。
+    const windowMaxId = rows.reduce((m, r) => Math.max(m, Number(r.id) || 0), 0);
+    let tableMaxId = windowMaxId;
+    try {
+      const t = this.db.prepare('SELECT MAX(id) AS m FROM branch_log').get();
+      tableMaxId = Number((t && t.m) || 0) || windowMaxId;
+    } catch { /* 兜底:窗口内最大(已知下限) */ }
     // ── B1(1.5.1):真实剩余笔数**必须问库** ─────────────────────────────────────
     // 上面 listBranchLog 只取最近 120 行,积压超过 120 时窗口恒满;旧代码拿
     // `fresh.length - lines.length`(= limit 夹取差,恒为 120-5=115)当"另有 N 笔",
@@ -970,12 +1020,88 @@ export class MemoryStore {
     // 这里补一条独立 COUNT:branch_log.id 是 INTEGER PRIMARY KEY(AUTOINCREMENT),
     // `WHERE id > ?` 是主键范围扫描 —— 只走索引不拉行,代价与积压量无关,
     // 所以**不需要**把 limit 调大去"凑数"(那才是真把几百行读进内存)。
-    // 只服务展示:水位推进仍由下方 `maxId` 负责(B3 按主人的决定推迟到 1.5.2)。
-    let realTotal = fresh.length;            // 兜底:COUNT 失败时退回窗口内条数(已知下限)
+    // 只服务展示:水位推进 1.5.2 起由下方 `shownMaxId` / `retiredMaxId` 负责
+    // (1.5.1 时此处写的是"B3 按主人的决定推迟到 1.5.2",现已实现)。
+    let realTotal = rows.length;             // 兜底:COUNT 失败时退回窗口内条数(已知下限)
     try {
       const agg = this.db.prepare('SELECT COUNT(*) AS n FROM branch_log WHERE id > ?').get(wm);
-      if (agg) realTotal = Math.max(Number(agg.n) || 0, fresh.length);
+      if (agg) realTotal = Math.max(Number(agg.n) || 0, rows.length);
     } catch { /* 库出错时退回窗口口径:摘要宁可少报,也不能整段消失 */ }
+    // ── §2 时间窗(1.5.2):只**展开**最近 windowDays 天的改动 ─────────────────────
+    // 超窗行**只计数不展开**,并且**不算已示人** ⇒ 计数落在 retiredMaxId,由投递侧写进
+    // `branch_log_wm.retired`,让水位能越过它们(否则同一批老账每轮重算、水位永不前进)。
+    // 判定用 JS 逐行做(而不是在 SQL 里比字符串):展示口径只有一处;且"at 读不出来"的行
+    // 明确回退成**展开**(宁可多占一行,也不静默折叠)。windowDays<=0 ⇒ 不做时间窗。
+    const cutoff = Number(windowDays) > 0 ? Number(now) - Number(windowDays) * 864e5 : 0;
+    const isExpired = (r) => {
+      if (!cutoff) return false;
+      const t = Date.parse(String(r.at || ''));
+      return Number.isFinite(t) ? t < cutoff : false;
+    };
+    // 前缀扫描:水位之上按 id 升序,遇到第 max 条"要展开的"行即停 —— 这一段里每一行
+    // 要么展开(进 lines)、要么按超窗计数,**没有第三种**;而水位只推进到这一段之内,
+    // 所以水位之下的行全部已被处置,不会出现"跳过去又没交代"的空洞。
+    // ── expired 低报修复(B3 后续,2026-09-27 实测)────────────────────────────────
+    // 病根:`expired` 原先只在**扫描窗口内**(rows = 水位之上最早的 120 行)逐行累加,
+    //   而 ann/min(20,limit) 之外还有一个**常量 120** 的窗口上限 ⇒ 超窗行超过 120 时
+    //   计数**封顶在 120**。live 实测:真库 branch_log 395 行,真分界 id=368
+    //   (超窗 368 / 窗内 27),而注入面报的是「其中 120 笔已超过 3 天」——低报 248。
+    //   更糟的是它不是"暂时不准":`branch_log_wm.announced` 一旦推进到全表最新,
+    //   有效下界 wm = max(会话水位, announced, retired) 就把扫描顶死,**括号永不修正**。
+    // 修法(二选一中的**路径 b**):计数与取数**分开** ——
+    //   · 取明细仍用 120 行窗口(性能照旧,不把几百行读进内存);
+    //   · `expired` 单独再扫一遍**水位之上的全部行**只做计数(本机存量 395,量级很小)。
+    // 为什么不用 SQL COUNT(路径 a):`at` 是 TEXT 且**历史形态不齐** —— 写入端是 utcIso()
+    //   的 `…Z` 毫秒串,但库里有秒级/无毫秒/带偏移的存量行;SQL 的 `at < ?` 是**字符串比较**,
+    //   与 JS 的 `Date.parse` **不是同一个口径**(例:`'2026-09-24T01:05:48Z' < '2026-09-24T01:05:48.036Z'`
+    //   在字符串序里为真,而 parse 出来 t == cutoff ⇒ JS 判**不超窗**、SQL 判超窗)。
+    //   要"语义完全一致"就得在 SQL 里复刻 Date.parse 的宽松解析,那等于把口径写成两份 ⇒
+    //   违背本函数 `:1033` 那条「展示口径只有一处」的设计意图。JS 单点口径天然一致:
+    //   计数与渲染调的是**同一个** `isExpired`(含"at 读不出来 ⇒ 回退成展开"的分支)。
+    // 边界:JS 判 `t < cutoff`,即 `at` **恰好等于** cutoff 的行算**窗内**(不超窗)——
+    //   新计数与渲染同用它,故边界行既不进 expired、也不会被渲染侧判成超窗(回归见 tree 套 9-7)。
+    // 注意 `retiredMaxId` 在此处**仍只认扫描窗口内**超窗行的最大 id;窗口外的整段老账
+    //   由下面那段"连续超窗前缀"扫描补上(它不是"水位跳过未见过的行":前缀扫描碰到第一条
+    //   窗内行就停 ⇒ 不会略过任何还没轮到展开的行,而 B3-2 的病根正是那种略过)。
+    const picked = [];
+    let retiredMaxId = 0;
+    for (const r of rows) {
+      if (isExpired(r)) {
+        retiredMaxId = Math.max(retiredMaxId, Number(r.id) || 0);
+        continue;
+      }
+      picked.push(r);
+      if (picked.length >= max) break;
+    }
+    // 独立计数扫描:只数笔数,不取字段以外的任何东西(与上面 realTotal 的 COUNT 一样
+    // 走 `WHERE id > ?` 主键范围扫描);**只在需要出括号时**才扫(pending<=0 时括号不渲染)。
+    // 兜底:库出错 ⇒ 退回扫描窗口内的口径(已知下限),摘要宁可少报也不能整段消失。
+    let expired = rows.reduce((n, r) => n + (isExpired(r) ? 1 : 0), 0);
+    if (realTotal - picked.length > 0 && cutoff) {
+      try {
+        const above = this.db.prepare(
+          'SELECT id, at FROM branch_log WHERE id > ? ORDER BY id ASC LIMIT 100000'
+        ).all(wm);
+        expired = above.reduce((n, r) => n + (isExpired(r) ? 1 : 0), 0);
+        // ── 同一批老账还要能"越过"(2026-09-27,修 expired 时暴露的**饥饿**)──────────
+        // 上面把计数改真之后,暴露出原先没被看见的后果:`retiredMaxId` 只认**扫描窗口内**
+        // 超窗行的最大 id ⇒ 窗口(120 行)被老账占满时,水位每轮只前进 120,
+        // 而下一轮同样的老账又占满窗口 ⇒ **明细行永远渲染不出来**(live 实测:真库 368 条
+        // 超窗行、`retired` 卡在 120;注入面只剩一行计数,一条明细也看不到)。
+        // 修法:让 retired 一次走到**连续超窗前缀的末尾** —— 从"已处置游标 + 1"起按 id
+        // 升序走,只要还是超窗就继续,碰到**第一条窗内行即停**。它天然不越过任何窗内行
+        // (B3-2 的病根正是"水位跳过了没示人的行"),所以既解饥饿又不重蹈覆辙。
+        // 只**加宽**、不回退(游标单调),故与上面扫描窗口的结论取更大者。
+        let lastRetired = Number(this.kvGet(BRANCH_LOG_WM_RETIRED) || 0) || 0;
+        for (const r of above) {
+          if (Number(r.id) <= lastRetired) continue;
+          if (!isExpired(r)) break;
+          lastRetired = Number(r.id) || lastRetired;
+        }
+        retiredMaxId = Math.max(retiredMaxId, lastRetired);
+      } catch { /* 退回窗口口径(已知下限) */ }
+    }
+    const shownMaxId = picked.length ? Number(picked[picked.length - 1].id) || 0 : 0;
     const names = new Map(this.listBranches().map((b) => [b.id, b.name || b.id]));
     // 提示面净化(审计 §2.5 + B#2,2026-09-22):
     // ① 枝名/id 一律翻译或缩成短号,**永不吐裸 uuid**(实测:gather/autobuild 两支漏了 nm(),
@@ -996,7 +1122,7 @@ export class MemoryStore {
       return '条目 ' + k.slice(-8);                                         // 其余按记忆条目
     };
     const flat = (s) => String(s == null ? '' : s).replace(/[\r\n\t]+/g, ' ').trim().slice(0, 80);
-    const lines = fresh.slice(0, max).map((r) => {
+    const lines = picked.map((r) => {
       const who = nm(r.branchId);
       const line = (() => {
         switch (String(r.action || '')) {
@@ -1048,16 +1174,45 @@ export class MemoryStore {
       const subject = String(r.actor || 'user') === 'ling' ? '器灵' : '主人';
       return flat(subject + (/^[A-Za-z0-9]/.test(line) ? ' ' : '') + line);
     });
-    // 最多 max 行 + 一行计数。折算的**余量走 realTotal**(B1:真实剩余笔数)。
-    if (realTotal > lines.length) lines.push('…另有 ' + (realTotal - lines.length) + ' 笔改动');
-    return { lines, maxId: Number(fresh[0].id), total: realTotal };
-  }
-
-  /** 复盘留痕列表(最近的在前)。 */
-  listBranchLog({ limit = 100 } = {}) {
+    // ── §4「超量折叠成一行」(1.5.2,与双水位同批上)────────────────────────────
+    // 最多 max 行明细 + 一行计数;**折算的余量走 realTotal**(B1:真实剩余笔数,不是窗口差)。
+    // 这里能成立的关键是水位的口径:水位停在**最后一条明细行**(shownMaxId),被折掉的行
+    // id 仍在水位之上 ⇒ 它们**没被标成已示人**,下一轮继续展开,直到真的示人。
+    // 1.5.1 那次上折叠反效果的机制正在此:折叠了、水位却照样跳到全表最新 ⇒ 折掉的内容
+    // 再也看不见(改前至少还露出 5 条)。**永久折叠(超阈值只留一行摘要 + 推进水位)与
+    // "折掉的行仍是未示人"逻辑上不可两全**:折了不推进 ⇒ 每轮重播同一行,推进 ⇒ 内容丢失。
+    // 所以 1.5.2 只做这条**可收敛的折叠**,不设 BRANCH_LOG_FOLD_THRESHOLD 之类的阈值常量。
+    const pending = Math.max(0, realTotal - picked.length);
+    // 夹取保留(兜底:防"其中 N 笔"超过"另有 M 笔")。修好 expired 之后它**不会触发**:
+    // 计数扫描的范围是 `id > wm`,而 pending = realTotal - picked.length 是同一范围内
+    // 除已展开行以外的全部行 ⇒ 超窗行(既非 picked、又必在 realTotal 里)**是 pending 的子集**,
+    // 故恒有 expired <= pending。唯一例外是计数扫描失败退回窗口口径,那时夹取正好兜住低报方向的错。
+    if (pending > 0) {
+      lines.push('…另有 ' + pending + ' 笔改动'
+        + (expired > 0
+          ? '(其中 ' + Math.min(expired, pending) + ' 笔已超过 ' + Math.round(Number(windowDays)) + ' 天,只计数不展开)'
+          : ''));
+    }
+    return { lines, maxId: tableMaxId, shownMaxId, retiredMaxId, total: realTotal, expired };
+  }
+
+  /** 复盘留痕列表(默认最近的在前)。
+   *  B3(1.5.2)加了两个**可选**参数给播报用,不传时行为与 1.5.1 逐字一致(侧栏/API 照旧):
+   *   · `afterId`:只要 id 更大的行(主键范围扫描,配 ascending 取"水位之上最早的 N 条");
+   *   · `ascending`:按 id 升序(FIFO)。播报必须**从最早未示人的一条开始** —— 见
+   *     branchLogDigest 里 B3-2 的注解。 */
+  listBranchLog({ limit = 100, afterId = null, ascending = false } = {}) {
     try {
       const n = Math.max(1, Math.min(500, Number(limit) || 100));
-      return this.db.prepare('SELECT * FROM branch_log ORDER BY id DESC LIMIT ?').all(n).map((r) => ({
+      const floor = (afterId !== null && afterId !== undefined && Number.isFinite(Number(afterId)))
+        ? Number(afterId)
+        : null;
+      // ascending 只做字面拼接(调用方传布尔,不接外部输入);floor 走占位符。
+      const sql = 'SELECT * FROM branch_log'
+        + (floor === null ? '' : ' WHERE id > ?')
+        + ' ORDER BY id ' + (ascending ? 'ASC' : 'DESC') + ' LIMIT ?';
+      const args = floor === null ? [n] : [floor, n];
+      return this.db.prepare(sql).all(...args).map((r) => ({
         id: Number(r.id),
         at: String(r.at || ''),
         branchId: String(r.branch_id || ''),
@@ -1924,6 +2079,19 @@ export class MemoryStore {
     return rows.map(mapRow);
   }
 
+  /** 只数条数(1.5.2):`/state` 的两处调用点只要 `listOverviews({onlyOk:true}).length`,
+   *  而全表 `SELECT *` + mapRow×N 实测 4.82ms、`COUNT(*)` 0.08ms。where 口径与 `listOverviews` 逐字一致
+   *  ⇒ **同库同参下两者恒等**(只有"全表读"换成"计数")。返回 number。 */
+  countOverviews({ onlyOk, source } = {}) {
+    let sql = 'SELECT COUNT(*) AS n FROM conv_overview';
+    const where = [];
+    if (onlyOk) where.push('overview_ok=1');
+    if (source) where.push('source=?');
+    if (where.length) sql += ' WHERE ' + where.join(' AND ');
+    const row = source ? this.db.prepare(sql).get(source) : this.db.prepare(sql).get();
+    return Number(row?.n ?? 0);
+  }
+
   /** 记忆中心查询:过滤(source/category/q)+ 排序 + 分页;返回 {items,total}。
    *  source 不限 dsweb/dsh——文件导入等第三方来源(source='import')同样可按源过滤。 */
   queryOverviews({ source, category, q, branch, sort = 'updated', limit = 100, offset = 0 } = {}) {
@@ -2340,9 +2508,84 @@ export class MemoryStore {
     return report;
   }
 
+  /** WAL 守卫(1.5.2):缓存键的第二来源。
+   *  `total_changes()` 是**本连接**的计数 —— 别的进程在宿主运行期间直写 memory.db 时它一动不动,
+   *  只比 n 会让面板指纹**停在旧值**(旧实现每次全表读,是看得见的)。提交必然落进 `-wal`,
+   *  所以取 `-wal` 的 size + mtimeMs 并进键:外部写入 ⇒ 文件动 ⇒ 缓存失效。
+   *  实测两次 statSync 约 0.014ms(1500 行库,/state 上可忽略;一次重算实测约 10.7ms)。
+   *  `-wal` 不存在(非 WAL / 已关连接 / 连接刚开还没写过)⇒ 视为 0/0 哨兵,**绝不抛**:
+   *  这条路径挂在一个每拍都跑的面板接口上,statSync 抛错就会把 /state 变成 500。
+   *  ⚠️ 代价是 0/0 也是"合法键值",所以下面三个缓存字段**只在重算真正完成后才推**。
+   *  ⚠️ 别把这两个字段的存在当成"守卫一定在工作":`statSync` 抽风/漏 import 时它恒返 [0,0],
+   *  面板照旧显示、测试照旧全绿,而守卫是**静默空转**的(本轮就踩过:忘了 import statSync,
+   *  ReferenceError 被本方法的 catch 吞掉)。要确认它活着,见 _probe/tmp-fp-wal-guard.mjs 的
+   *  【陷阱守卫】断言:它必须返回真实 size/mtime,不能是 [0,0]。 */
+  _walStamp() {
+    try {
+      const s = statSync(this.dbPath + '-wal', { throwIfNoEntry: false });
+      return s ? [s.size, s.mtimeMs] : [0, 0];
+    } catch {
+      return [0, 0]; // EACCES/EBUSY 等一律降级为哨兵:宁可回退到"每次都重算",也不让 /state 炸
+    }
+  }
+
+  /** data_version 守卫(1.5.2):缓存键的**第三**来源,专补 `-wal` 那一维的盲区。
+   *  上面的 `_walStamp()` 有个洞:维护/备份脚本若用 `journal_mode=DELETE` 改库,**根本没有 `-wal`
+   *  文件**,stat 恒返 [0,0] 哨兵 ⇒ 外进程改完面板还是旧指纹。`PRAGMA data_version` 正好互补
+   *  (实测见 _probe/tmp-dv-semantics.mjs,数值原样):
+   *    · 本连接自己写 ⇒ **不变**(2→2)  ⇒ 它**不能**替代 `total_changes()`,只补位;
+   *    · 别的连接提交 ⇒ **变**(2→3;DELETE 模式 1→2);
+   *    · 外连接写完立刻 `wal_checkpoint(TRUNCATE)` 把 -wal 截成 0 ⇒ **照样变**(3→4);
+   *    · 本连接纯读 ⇒ **不变**(4→4)⇒ 不会平白抖掉缓存。
+   *  取不到(旧 SQLite / 语句被拒)⇒ 降级为 -1 哨兵,**绝不抛**(这条路径挂在每拍一次的 /state 上)。
+   *  ⚠️ 与 `_walStamp()` 同一个陷阱:降级值 -1 也是**合法键值**,长期取不到会静默退化成一维空转 ——
+   *  别把"字段存在"当成"守卫在工作"。探针的【陷阱守卫】断言要求这里必须是**真实整数**,不能是 -1。 */
+  _dataVersion() {
+    try {
+      const r = this.db.prepare('PRAGMA data_version').get();
+      const v = Number(r ? (r.data_version ?? Object.values(r)[0]) : NaN);
+      return Number.isInteger(v) ? v : -1;
+    } catch {
+      return -1; // 退化成"这一维不参与",由其余三维兜,行为等价于加它之前
+    }
+  }
+
+  /** 全表指纹:64 位小写 sha256(面板 client.js:980 取前 16 位展示,tests\unit.mjs:165 断言 length===64)。
+   *  1.5.2:唯一消费方是**每拍一次**的 `/state`,而这里每次全表读 + JSON + sha256 实测约 10.7ms
+   *  (库 1612 行 ⇒ JSON 910KB)⇒ 以**五维**缓存键替代重算,键没动就直接返回上次那个字符串:
+   *  `_fpN`(`total_changes()`,管本连接自己写)+ `_fpWalSize`/`_fpWalMtime`(兜外进程写)
+   *  + `_fpDv`(`PRAGMA data_version`,兜不经 -wal 的写)+ `_fpDb`(句柄,兜关连接再开)。
+   *  四者**互补**,任一维动都会重算 —— 宁可白算,不可漏读。**返回值逐字不变**。 */
   fingerprint() {
+    // `total_changes()` 是**本连接**的累计写行数:写就动、只读不动、0 行 UPDATE 不动
+    // ⇒ 偏保守(至多多算一次),不会漏算本连接的任何一次写入。
+    // 连 `this.db` 句柄一起比:万一将来出现"关连接再开"的替换,total_changes 会从 0 重来,
+    // 只比 n 就可能撞回上一世的旧值;比句柄则必然重算。
+    const n = this.db.prepare('SELECT total_changes() AS n').get().n;
+    const [walSize, walMtime] = this._walStamp(); // 兜**外进程**写入:它们不进本连接的计数
+    const dv = this._dataVersion(); // 兜**不经 -wal** 的写入(DELETE 模式维护脚本),见该方法注释
+    // ⚠️ 顺序有讲究:三维**必须先于**下面那次全表读。反过来(先读表、后读守卫)会出现:
+    // 表读到旧内容 → 外进程此刻提交 → 守卫读到新值 ⇒ 于是"旧内容哈希"被记在新键下,
+    // 下一次守卫与新键相等 ⇒ 命中 ⇒ 面板**永停在旧指纹**。守卫先读则最坏只是多算一次。
+    if (
+      this._fpVal !== undefined &&
+      this._fpN === n &&
+      this._fpWalSize === walSize &&
+      this._fpWalMtime === walMtime &&
+      this._fpDv === dv &&
+      this._fpDb === this.db
+    ) {
+      return this._fpVal;
+    }
     const rows = this.db.prepare('SELECT * FROM conv_overview ORDER BY source, conv_id').all();
-    return sha256Text(JSON.stringify(rows.map(mapRow)));
+    const val = sha256Text(JSON.stringify(rows.map(mapRow)));
+    this._fpN = n; // ⚠️ 缓存字段只在**重算真的完成之后**才推(中途抛错 ⇒ 键不动 ⇒ 下次仍重算)
+    this._fpWalSize = walSize;
+    this._fpWalMtime = walMtime;
+    this._fpDv = dv;
+    this._fpDb = this.db;
+    this._fpVal = val;
+    return val;
   }
 }
 

package/lib/host/persona.js

@@ -42,6 +42,10 @@ export const DEFAULT_SETTINGS = Object.freeze({
     toneWork: '',         // 工作模式语气('' = 跟随 tone)
     toneLife: '',         // 生活模式语气('' = 跟随 tone)
     extraLore: '',        // 自由扩展设定
+    duty: '',             // 职业/职责/责任(1.5.2 I-5):改变率极低的身份级设定。**只收陈述句**
+                          //   (「我承担/我擅长/我能给出」),**禁授权式**(「我应当/我必须/我的任务/我的责任是」)——
+                          //   授权式写法把人写成"被授权者",是语义劫持最好用的钩子(同 [规矩] 段头那次的教训)。
+                          //   默认只能是 ''(约束 B):机制不设非空默认、也不从历史/模式推断预填。
     pronoun: '她',        // 第三人称代词(她/他/TA/它,或自定义):用于「给模型看的提示词」;界面文案第二步跟随
   },
   styles: {
@@ -75,6 +79,11 @@ export const DEFAULT_SETTINGS = Object.freeze({
     trackWorkspaces: ['*'],
     idleRefresh: true,                // B:长会话在空闲边界按需刷新 L1(运行中永不刷新)
     idleRefreshMinIntervalMin: 10,    // 同一个会话两次空闲刷新的最小间隔(分钟;0 = 不限制)
+    // E0(1.5.2)「那一行跟着会话走」:每轮用户在 `agent/pre-step` 追加一条带序号的活行
+    // (标题 + 最新进展,只追不替,见 lib/host/session-line.js)。
+    // 关掉即回到原样:已写入的历史行留着(平台无删除),但不再追加。
+    // ⚠️ 这是**内存态**设置(`settings-file.js` 的 get() 每轮读),面板 update() 立即改 ⇒ 不用重启宿主。
+    sessionProgressLine: true,
   },
   updates: { applyWhileRunning: false }, // D4 语义固化:默认冻结
   guard: {              // /api 守卫(2026-09-16 加固 ①+②;2026-09-17 加固 ③)
@@ -160,12 +169,16 @@ export function assemblePersona(settings, modeKey) {
   // 为什么不把每条 push 都用 '\n\n' 连接:那样条目之间会变成双倍空行(段内反而更糊)。
   const segs = [];
   const self = [];
-  const who = p.aiName ? `你是"${p.aiName}"` : '你是 DeepSeek 助手';
+  // 身份段正文过 escSegBrackets:与底线/规矩/习惯/承担/设定同规格,禁止正文自造段边界。
+  // **只包正文**:段头 [身份·X] 的方括号是字面量,保持半角(段边界判据是"行首是不是 [")。
+  // 但段头里嵌着 aiName —— 名字本身是用户文本,所以**逐字段**转义:名字/称呼/自述各过一遍,
+  // 有意的引号(")、分号(;)、逗号(,)一律不动(它们不是段边界判据的一部分)。
+  const who = p.aiName ? `你是"${escSegBrackets(p.aiName)}"` : '你是 DeepSeek 助手';
   const callName = userTitleForMode(p.userTitle, mode); // 工作=正式名(首段),生活=昵称(尾段)
-  const call = callName ? `;你称用户为"${callName}"` : '';
+  const call = callName ? `;你称用户为"${escSegBrackets(callName)}"` : '';
   // 定位自述允许多行书写,注入时压缩为一行(避免破坏身份句段落)
   const titleOneLine = p.aiTitle ? p.aiTitle.replace(/\s+/g, ' ').trim() : '';
-  const title = titleOneLine ? `,${titleOneLine}` : '';
+  const title = titleOneLine ? `,${escSegBrackets(titleOneLine)}` : '';
   // 结尾标点归一:title 自带句尾标点时不重复补(否则会出现 "拜上。。")
   const headSelf = `${who}${call}${title}`;
   self.push(headSelf.replace(/([。.!！?？])\s*$/, '') + '。');
@@ -174,7 +187,10 @@ export function assemblePersona(settings, modeKey) {
   const tPick = mode === 'work' ? p.toneWork : p.toneLife;
   const tone = (tPick && TONES[tPick]) ? tPick : ((p.tone && TONES[p.tone]) ? p.tone : '');
   if (tone) self.push(`语气:${TONES[tone]}`);
-  segs.push([`[身份·${coreNameOf(p.aiName)}]`, ...self].join('\n'));
+  // 段头里的名字(aiName)与正文各字段一样是用户文本 ⇒ 那一处也必须转义(最容易漏的一处);
+  // 而 [身份· 与 ] 两个字面量**不转** —— 跟着一起转掉等于整段从注入面凭空消失。
+  // 正文再逐行兜一次(幂等):语气文案/语言文案将来若带上 [, 不必回来改这里。
+  segs.push([`[身份·${escSegBrackets(coreNameOf(p.aiName))}]`, ...self.map((s) => escSegBrackets(s))].join('\n'));
   if (Array.isArray(p.bottomLines) && p.bottomLines.length) {
     const seg = ['[底线]'];
     for (const r of p.bottomLines) if (typeof r === 'string' && r.trim()) seg.push(`- ${escSegBrackets(r.trim())}`);
@@ -199,16 +215,31 @@ export function assemblePersona(settings, modeKey) {
     (h) => h && h.byUser === true && h.amendedBy !== 'ling' && typeof h.text === 'string' && h.text.trim(),
   );
   if (awaiting.length) {
-    segs.push(`[待我回应] 用户提的习惯候选:${awaiting.map((h) => `「${h.text.trim()}」`).join('、')}`
+    // 正文(h.text)过 escSegBrackets:与底线/规矩/习惯/承担/设定同规格,禁止正文自造段边界。
+    // **只包正文**:段头 [待我回应] 保持半角;包在正文外的「」引号与 、 分隔符是有意的结构,不动它们
+    // (转义只落在引号**里面**的文本上,「」配对关系逐字不变)。
+    // 为什么这一段特别要兜:此处**直接读 p.habitsPending**(没走 habitsPendingOf() 的 norm()),
+    // 而 norm() 会把换行压成空格、trim() 不会 —— 所以手改 settings.json 往某条候选的 text 里
+    // 塞「换行 + 半角 [」是通的,注入面就会真多出一个行首段头。出口转义是这条路上唯一一道闸。
+    segs.push(`[待我回应] 用户提的习惯候选:${awaiting.map((h) => `「${escSegBrackets(h.text.trim())}」`).join('、')}`
       + '——用 habit_resolve 表态(accept / amend 改说法 / decline)');
   }
+  // 职责(1.5.2 I-5):身份级、改变率极低。空值**不渲染整段**(不留空段头 —— 空段头会被模型当成"有内容但被藏起来")。
+  // 正文过 escSegBrackets:与底线/规矩/习惯同规格,禁止正文自造段边界。
+  if (typeof p.duty === 'string' && p.duty.trim()) {
+    segs.push(`[承担]\n${escSegBrackets(p.duty.trim())}`);
+  }
+  // 正文过 escSegBrackets:与底线/规矩/习惯/承担同规格,禁止正文自造段边界。
+  // **只包正文**:段头 [设定] 必须保持半角 —— 段边界判据是"行首是不是 [",段头被转全角等于整段凭空消失。
   if (typeof p.extraLore === 'string' && p.extraLore.trim()) {
-    segs.push(`[设定]\n${p.extraLore.trim()}`);
+    segs.push(`[设定]\n${escSegBrackets(p.extraLore.trim())}`);
   }
   const style = settings?.styles?.[mode];
   if (typeof style === 'string' && style.trim()) {
     // 段头与内容合并为一行(2026-09-16 瘦身:原来两行且重复"本会话为X模式")
-    segs.push(`[${mode === 'work' ? '工作' : '生活'}模式]${style.trim()}`);
+    // 正文过 escSegBrackets:与底线/规矩/习惯/承担同规格,禁止正文自造段边界(style 里的换行 + [ 也能伪造段头)。
+    // **只包正文**:段头 [工作模式]/[生活模式] 保持半角,否则段边界判据失效。
+    segs.push(`[${mode === 'work' ? '工作' : '生活'}模式]${escSegBrackets(style.trim())}`);
   }
   return segs.join('\n\n');
 }