@nightpainters/dsh-ling 1.6.2 → 1.7.1

package/lib/host/memory.js

@@ -5,17 +5,23 @@ import { join } from 'node:path';
 import { existsSync, readFileSync, statSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
 import { ensureDir, sha256Text, utcIso, mergeDeep, toIso, toEpochMs } from './util.js';
+import { wellFormed } from './rawlog.js'; // 1.7.1 F4 闭环:留痕摘要会进注入面
 // A-01(1.5.1):主脉记忆被覆盖前**必须先归档**。archive.js 只依赖 node:fs / node:path,
 // 且把 memory 当参数传(依赖注入)⇒ memory.js 引它**不成环**。
 import { archiveBefore } from './archive.js';
 
-const SCHEMA_VERSION = 17; // v17:deep_item.durability(条目「硬度」,1.6,2026-10-04 —— 主人原话「同会话使用硬数量上限来卡吗,这可能有点机械,能不能做成从根源上判断这些条目到底是临时的还是永久的」⇒ 病根不是"同一会话进了太多条",而是**临时的东西被判成了长期记忆**);v16:deep_item(深层库条目,1.6 步 2,2026-10-04 —— 纯新增表,DDL 的 IF NOT EXISTS 即迁移;与记忆树并立、条目不被枝隶属);v15:inject_log(投递留痕,1.6-A,2026-10-03 —— 纯新增表,DDL 的 IF NOT EXISTS 即迁移);v14:dsh_turns_raw.source(来源从"推断"变"记录",2026-10-01 主人定「来源也加个列吧」—— 旧判据是"裸 id = DSH 会话",边界是"将来若出现不带冒号的新来源名,物理上分不出来");v13:forgotten(软遗忘标记 —— 永远不彻底删除,先归档再打标记);v12:branch_log.actor(G4 器灵侧通道 —— 工具改的树必须记在"鱼姬"名下,不再一律记成主人);v11:vein_suggestions(主脉提炼审核队列 R7 —— 设计稿 §5:提炼必须走审核,不直接进记忆);
+const SCHEMA_VERSION = 17;
+/** 作废哨兵(`deep_item.superseded_by` 的第三个取值,2026-10-15)。
+ *  为什么用哨兵而不是新列:所有"排除已被取代"的读路径(开场选择 / recall / 面板)
+ *  判的都是 `superseded_by != ''` —— 哨兵让**那些路径一处都不用改**就自动不再挑它;
+ *  而"为什么作废"落在 kv `deep.retract:<id>`(人可读、可审计),不污染表语义。 */
+export const DEEP_RETRACTED = 'retracted'; // v17:deep_item.durability(条目「硬度」,1.6,2026-10-04 —— 主人原话「同会话使用硬数量上限来卡吗,这可能有点机械,能不能做成从根源上判断这些条目到底是临时的还是永久的」⇒ 病根不是"同一会话进了太多条",而是**临时的东西被判成了长期记忆**);v16:deep_item(深层库条目,1.6 步 2,2026-10-04 —— 纯新增表,DDL 的 IF NOT EXISTS 即迁移;与记忆树并立、条目不被枝隶属);v15:inject_log(投递留痕,1.6-A,2026-10-03 —— 纯新增表,DDL 的 IF NOT EXISTS 即迁移);v14:dsh_turns_raw.source(来源从"推断"变"记录",2026-10-01 主人定「来源也加个列吧」—— 旧判据是"裸 id = DSH 会话",边界是"将来若出现不带冒号的新来源名,物理上分不出来");v13:forgotten(软遗忘标记 —— 永远不彻底删除,先归档再打标记);v12:branch_log.actor(G4 器灵侧通道 —— 工具改的树必须记在"器灵"名下,不再一律记成主人);v11:vein_suggestions(主脉提炼审核队列 R7 —— 设计稿 §5:提炼必须走审核,不直接进记忆);
 // v10:tree_snapshot.kind('manual'|'auto',审计 A#9 —— 自动备份与手动快照此前外表完全一致,删错了就没有撤回路径);v9:tree_snapshot(树的保存/恢复 R1);v8:conv_branch(非会话源的枝归属覆盖层,方案 A);v7:branch_log(复盘留痕);v6:vein_link + memory_conflict(D9-b 树的生长);v5:branch(记忆分枝 D9-a);v4:title_by(定名者:user/ai);v3:title_locked;v2:conv_overview.source 放开 CHECK
 
 /** 主干枝 id(D9-a 记忆分枝,2026-09-18):存量会话与记忆天然属于主干。 */
 export const TRUNK_ID = 'trunk';
 
-/** 血缘档位(尝生 2026-09-18 定档 1.0/0.7/0.4)。
+/** 血缘档位(用户 2026-09-18 定档 1.0/0.7/0.4)。
  *  取"最弱环"单值,不做连乘 —— `0.7^5=0.168`、`0.4^5=0.010`,连乘会让深枝等于从记忆里消失,
  *  且每层舍入都会乘进后面。单值 + 有界,权重才可解释、可复现。 */
 export const LINEAGE_SAME = 1.0; // 同枝
@@ -327,6 +333,9 @@ CREATE TABLE IF NOT EXISTS deep_item (
                                                --   ⚠️ ephemeral **不进开场**(选择侧过滤掉),但**照旧留在库里、recall 搜得到**:
                                                --   判严的代价远小于判松了(判松 = 每次开口都在推一条早失效的临时决定)。
   superseded_by TEXT NOT NULL DEFAULT '',      -- 被哪条取代 —— 沿用老规矩「只追不替」:旧的留痕、不删
+                                               --   取值三态:'' = 在役 / 'di:…' = 被这条取代 /
+                                               --   'retracted' = **作废**(无接替者,2026-10-15 用户拍板;
+                                               --   理由落 kv「deep.retract:<id>」,见 DEEP_RETRACTED)
   origin        TEXT NOT NULL DEFAULT 'auto',  -- auto(提炼) | user(主人手写);origin='user' 的不许被自动覆盖
   branch_id     TEXT NOT NULL DEFAULT '',      -- 气根:空 = 未挂枝;非空 = 被这条枝反向引用(不参与树的层级计算)
   created_at    TEXT NOT NULL DEFAULT (datetime('now')),
@@ -402,7 +411,7 @@ function migrateTitleCols(db) {
   }
 }
 
-/** v4→v5:记忆分枝(D9-a,2026-09-18 尝生定方向)。
+/** v4→v5:记忆分枝(D9-a,2026-09-18 用户定方向)。
  *  session_meta 加 branch_id(默认 'trunk' —— 存量会话天然属主干,迁移只填一列);
  *  建 branch 表并保证主干行存在。**记忆行不冗余存 branch**,靠 session → branch 推导:
  *  迁移成本最低,且枝归属变化时无需回写海量记忆行。 */
@@ -941,10 +950,12 @@ export class MemoryStore {
 
   /** 复盘期权重调节(平时只读 —— 设计稿 §3.3)。scale 夹在 [0,2]。
    *
-   *  ⚠️ 预留字段(审计 A#11,2026-09-22 定为方案 b):写进去的 `weight_scale`
-    *  **A-5(2026-10-05 夜 · 主人拍板走方案 b):已接回检索打分** —— L1 = `raw × 血缘档位 × 矛盾系数 × 枝系数`。
-   * 历史:审计 A#11(2026-09-22)曾把权重与可见性一起定为"只存只显示";本次只解开权重那一半
-   * (可见性仍是预留字段,见 `listBranches`)。 */
+   *  **A-5(2026-10-05 夜 · 主人拍板走方案 b):`weight_scale` 已接回检索打分** ——
+   *  L1 = `raw × 血缘档位 × 矛盾系数 × 枝系数`。
+   *  历史:审计 A#11(2026-09-22)曾把**权重与可见性一起**定为"只存只显示";2026-10-05 只解开权重那一半
+   *  (可见性仍是预留字段,见 `listBranches`)。
+   *  ⚠️ 别再把权重这半边叫"预留字段"(2026-10-06 内部台账核对抓到:上面这行旧的"预留字段"与这行
+   *  "已接回打分"**在同一个注释块里自相矛盾**,读第一行的人会判它无效)。 */
   setBranchWeight(branchId, scale) {
     const bid = String(branchId || '');
     // ⚠️ 先判**类型**再取数(蓝队 2026-10-04):`Number(null) === 0`、`Number(true) === 1`、
@@ -959,7 +970,8 @@ export class MemoryStore {
     return {
       ok: true, id: bid, weightScale: clamped,
       applied: true,
-      note: '已生效:该枝的结论在记忆开场里按此系数加权(1.0 = 不偏不倚,0 = 排到最后;不是禁用)',
+      note: '已生效:该枝的结论在记忆开场里按此系数加权(1.0 = 不偏不倚;⚠️ **0 = 该枝结论不进开场** —— '
+        + '它会被当成"算不出正分"直接排除,所以 0 不是"只是排后面")',
     };
   }
 
@@ -992,10 +1004,23 @@ export class MemoryStore {
       //   (主键是有序对,旧写入侧没挡反向)⇒ 只删一个方向会让回执说"断开了"而树里还连着。
       const a = String(fromBranch || '');
       const b = String(toBranch || '');
-      const r = this.db.prepare(
-        'DELETE FROM vein_link WHERE (from_branch=? AND to_branch=?) OR (from_branch=? AND to_branch=?)',
-      ).run(a, b, b, a);
-      return { ok: true, removed: Number(r.changes || 0) };
+      // 1.7.1(审计 F-03 + delta 复审):按**每一行自己的 kind** 决策,而不是只看正向行。
+      //   有向类型(A→B 与 B→A 是**两条不同的边**)只删同向;无向类型仍按旧口径双向清 ——
+      //   那是历史重复行(有序对主键)的兜底。混合历史(如 A→B related + B→A prerequisite)
+      //   以前会被整对双删,directed 那条被连带抹掉;现在只删请求方向 + 仅当反向也是无向时才清。
+      const fwd = this.db.prepare('SELECT kind FROM vein_link WHERE from_branch=? AND to_branch=?').get(a, b);
+      const rev = this.db.prepare('SELECT kind FROM vein_link WHERE from_branch=? AND to_branch=?').get(b, a);
+      const isDirected = (row) => Boolean(row) && DIRECTED_LINK_KINDS.has(String(row.kind || 'related'));
+      let removed = 0;
+      if (fwd) {
+        const r1 = this.db.prepare('DELETE FROM vein_link WHERE from_branch=? AND to_branch=?').run(a, b);
+        removed += Number(r1.changes || 0);
+      }
+      if (rev && !isDirected(rev) && !isDirected(fwd)) {
+        const r2 = this.db.prepare('DELETE FROM vein_link WHERE from_branch=? AND to_branch=?').run(b, a);
+        removed += Number(r2.changes || 0);
+      }
+      return { ok: true, removed };
     } catch {
       return { ok: false, reason: 'db' };
     }
@@ -1017,7 +1042,7 @@ export class MemoryStore {
 
   // ---- 软遗忘(Part G G2,2026-09-25) ----
   //
-  // 原则(尝生 2026-09-25 定):**永远不做彻底删除**。遗忘 = 先把原数据归档落盘(原文 + 概述 +
+  // 原则(用户 2026-09-25 定):**永远不做彻底删除**。遗忘 = 先把原数据归档落盘(原文 + 概述 +
   // 改动日志),再在库里打一个标记,召回路径据标记排除。行仍在库里、归档文件在磁盘上 ——
   // 两条独立还原路径,任何一条都能反悔。
   //
@@ -1147,7 +1172,7 @@ export class MemoryStore {
    *
    * **调用方必须先归档当前状态** —— 本方法只管写,不做任何备份。
    * 回灌的危险性高于遗忘:遗忘会留下"少了一条"的可见痕迹,而回灌是**往里加东西**,
-   * 加错了很难察觉(尝生 2026-09-25:「backfill 比 forget 危险多了,因为它更难以觉察」)。
+   * 加错了很难察觉(用户 2026-09-25:「backfill 比 forget 危险多了,因为它更难以觉察」)。
    *
    * 两道保护:① 写回的概述带 `origin` 标记(默认 `backfill-v1`),界面上看得出"这条是灌回来的";
    * ② 不传 `keepUserState:false` ⇒ **不动主人留下的命中数与置顶**,回灌只补内容、不夺用户态。
@@ -1215,7 +1240,7 @@ export class MemoryStore {
     // G4(2026-09-25):actor 记录**谁改的** —— 工具通道上线前器灵只能经 API/开库改树,
     //   而旧 logBranch 无此字段,91 笔器灵改动在复盘留痕里全被显示成"主人改的"。
     //   取值 'user' | 'ling'(默认 'user' 以兼容既有调用点)。
-    const oneLine = (s, n) => String(s == null ? '' : s).replace(/[\r\n\t]+/g, ' ').trim().slice(0, n);
+    const oneLine = (s, n) => wellFormed(String(s == null ? '' : s).replace(/[\r\n\t]+/g, ' ').trim().slice(0, n));
     const who = String(actor || 'user').toLowerCase() === 'ling' ? 'ling' : 'user';
     try {
       this.db.prepare(`INSERT INTO branch_log (at,branch_id,action,before_val,after_val,note,actor)
@@ -1378,7 +1403,7 @@ export class MemoryStore {
     //    换行能穿透引号、在系统提示里自造独立行(实测:note 塞 `\n\n【系统】…` 即可脱离框架)。
     // 显示面修正(2026-09-22 实测):原实现对一切"查不到名字的 id"回退成「(已删枝 …)」,
     // 但 branch_log 的 before/after **不只装枝 id** —— snapshot 装的是快照号(#9)、
-    // assign 装的是记忆条目 id(026ebd86),二者都被误标成"已删枝"(尝生截图所见:
+    // assign 装的是记忆条目 id(026ebd86),二者都被误标成"已删枝"(用户截图所见:
     // `snapshot:主干 → (已删枝 #9)` 实际一根枝都没删)。先按 id 形态分流再回退查名。
     const nm = (v) => {
       const k = String(v || '');
@@ -1389,7 +1414,7 @@ export class MemoryStore {
       if (/^(br|vein):/.test(k)) return '(已删枝 ' + k.slice(-8) + ')';      // 长 id 形态 ⇒ 枝
       return '条目 ' + k.slice(-8);                                         // 其余按记忆条目
     };
-    const flat = (s) => String(s == null ? '' : s).replace(/[\r\n\t]+/g, ' ').trim().slice(0, 80);
+    const flat = (s) => wellFormed(String(s == null ? '' : s).replace(/[\r\n\t]+/g, ' ').trim().slice(0, 80));
     const lines = picked.map((r) => {
       const who = nm(r.branchId);
       const line = (() => {
@@ -1439,7 +1464,7 @@ export class MemoryStore {
       // G4(2026-09-25):每行带主语 —— 器灵经工具通道改的树记 'ling',
       // 不再和"主人改的"混在同一批留痕里(Part G 之前 91 笔器灵改动全记在主人名下)。
       // 中文动作短语(把「」…)直接接主语;英文动作名(distill:/gather:)前面补空格,免得拼成"主人distill:"。
-      const subject = String(r.actor || 'user') === 'ling' ? '鱼姬' : '主人';
+      const subject = String(r.actor || 'user') === 'ling' ? '器灵' : '主人';
       return flat(subject + (/^[A-Za-z0-9]/.test(line) ? ' ' : '') + line);
     });
     // ── §4「超量折叠成一行」(1.5.2,与双水位同批上)────────────────────────────
@@ -1495,7 +1520,7 @@ export class MemoryStore {
     }
   }
 
-  /** 尚未同步给器灵的改动笔数(复盘守门,2026-09-22 尝生:「动记忆树不能是随意的」)。
+  /** 尚未同步给器灵的改动笔数(复盘守门,2026-09-22 用户:「动记忆树不能是随意的」)。
    *
    *  判据:自器灵**上一次开口**(注入推进水位)以来累积了多少笔结构改动。
    *  水位取 `branch_log_wm.last`(由 `inject.js` 的 advanceLogWatermark 在投递时写入),
@@ -1516,7 +1541,7 @@ export class MemoryStore {
     let pending = 0;
     let maxId = 0;
     try {
-      // 'snapshot'(保存快照)不计入待交代笔数(2026-09-25 尝生:「单纯保存不弹修改」)。
+      // 'snapshot'(保存快照)不计入待交代笔数(2026-09-25 用户:「单纯保存不弹修改」)。
       // 依据:保存快照**不改树**——它只是把当前结构另存一份,是"大改之前的保险",
       // 不是"改动"。把它算成债会让主人每存一次就看到「⚠ 有 N 笔改动还没跟器灵说过」,
       // 而实际上树一个字节没变。留痕仍写进 branch_log(审计价值保留),只是不推进债。
@@ -1587,7 +1612,7 @@ export class MemoryStore {
       if (p && n.id !== TRUNK_ID) p.children.push(n);
       else roots.push(n);
     }
-    // 层级 = **计算属性**(尝生 2026-09-19 定):按相对深度切,树长高时自动重算,**零回写**。
+    // 层级 = **计算属性**(用户 2026-09-19 定):按相对深度切,树长高时自动重算,**零回写**。
     // 于是"几条主脉并成一条更大的主脉 ⇒ 原节点自动降级"是视图效果,不需要回写任何一行记忆 ——
     // 这正是"任何树操作都不改写记忆内容"这条核心不变量能成立的原因。
     // 档位:0=主干(恒 1 条);(0,0.25]=主脉;≤0.62=枝;其余=叶 ⇒ 最多 1 主干 / 2 主脉 / 3 枝 / 4 叶。
@@ -1625,7 +1650,7 @@ export class MemoryStore {
         convBranch: this.db.prepare('SELECT source, conv_id, branch_id FROM conv_branch').all(),
         links: this.db.prepare('SELECT from_branch, to_branch, kind, note FROM vein_link').all(),
       };
-      // 名字留空 → 自动命名;不写「未命名」(2026-09-22 尝生:手工/自动 + 日期时间即可)
+      // 名字留空 → 自动命名;不写「未命名」(2026-09-22 用户:手工/自动 + 日期时间即可)
       const nm = String(name || '').trim() || (k === 'auto' ? '自动快照 - ' : '手动快照 - ') + localStamp();
       const r = this.db.prepare('INSERT INTO tree_snapshot (at,name,note,kind,data) VALUES (?,?,?,?,?)')
         .run(now, nm.slice(0, 80), String(note || '').slice(0, 300), k, JSON.stringify(data));
@@ -2009,7 +2034,7 @@ export class MemoryStore {
   }
 
   /** 检索侧降权映射:`"source\\u0000convId" → 系数`。
-   *  规则(尝生 2026-09-20 定):**复盘裁定的按裁定;未复盘的以最新为准**(旧的一方降权)。
+   *  规则(用户 2026-09-20 定):**复盘裁定的按裁定;未复盘的以最新为准**(旧的一方降权)。
    *  `duplicate` 不降权(两条内容相同,降谁都会丢信息);`dismissed` 一律不降权。 */
   conflictDowngradeMap() {
     const m = new Map();
@@ -2055,7 +2080,7 @@ export class MemoryStore {
    * 已归档会话 id 集合(2026-09-21,D9-b 用)。
    *
    * 归档 = 主人主动封存、不再参与日常召回的那批会话。矛盾扫描必须排除它们,
-   * 否则会拿几个月前已封存的对话互相判"矛盾",把待复盘队列塞满噪音(尝生实测反馈)。
+   * 否则会拿几个月前已封存的对话互相判"矛盾",把待复盘队列塞满噪音(用户实测反馈)。
    * 一次取全量而非逐行查 session_meta —— scan 里要判上千条,逐行查是 O(n) 次 SQL。
    */
   archivedConvIdSet() {
@@ -2130,7 +2155,7 @@ export class MemoryStore {
       if (!s) return;
       out.push({
         source: String(src), convId: String(cid),
-        title: String(title || '').slice(0, 60), summary: s.slice(0, cap),
+        title: wellFormed(String(title || '').slice(0, 60)), summary: wellFormed(s.slice(0, cap)),
       });
     };
     // ⚠️ A-02(1.5.1 红蓝对抗,2026-09-25):提炼素材**必须排除已遗忘的记忆**。
@@ -2164,7 +2189,7 @@ export class MemoryStore {
   /** 记一条提炼候选(审核队列;**不**直接进记忆)。 */
   addVeinSuggestion({ veinId, text, sources = [], model = '', note = '' } = {}) {
     const bid = String(veinId || '');
-    const t = String(text || '').replace(/\s+/g, ' ').trim().slice(0, 1200);
+    const t = wellFormed(String(text || '').replace(/\s+/g, ' ').trim().slice(0, 1200));
     if (!bid || !t) return { ok: false, reason: 'bad-arg' };
     const now = utcIso();
     try {
@@ -2230,11 +2255,11 @@ export class MemoryStore {
     if (!body) return { ok: false, reason: 'empty-text' };
     const veinId = String(row.vein_id || '');
     if (!veinId) return { ok: false, reason: 'no-vein' };
-    // ── A-01(1.5.1 红蓝对抗;尝生 2026-09-25 裁决「备份并覆盖」)──────────────────
+    // ── A-01(1.5.1 红蓝对抗;用户 2026-09-25 裁决「备份并覆盖」)──────────────────
     // 采纳写入的键是 `(source='vein', conv_id=<主脉 id>)` ⇒ **同一主脉的两条候选先后采纳
     // 会命中同一个 ON CONFLICT,后一条静默吃掉前一条**(无留痕、无归档 —— 数据真的没了;
     // 红队 A 与红队 E 各自独立复现)。
-    // 尝生的裁决与理由:主脉记忆是一种**概括**,它理应随主脉本身一起成长 ⇒ **覆盖**是对的;
+    // 用户的裁决与理由:主脉记忆是一种**概括**,它理应随主脉本身一起成长 ⇒ **覆盖**是对的;
     // 但覆盖必须能回头 ⇒ 动手前把旧版**归档落盘**,归档失败就**拒绝覆盖**
     // (与 forget 那条"归档失败绝不打标记"同一条纪律),并把结果回传调用方去记总变动日志。
     let replaced = null;
@@ -2626,6 +2651,26 @@ export class MemoryStore {
     return { ok: true, id: String(oldId), by: String(newId) };
   }
 
+  /** **作废**一条结论(2026-10-15,用户拍板「允许作废一条结论」)。
+   *  与 supersede 的分工:取代 = "有一条新的接着";作废 = "这条不成立了、没有接替者"。
+   *  实现**不删行**(老规矩「只追不替」):只把 `superseded_by` 标成哨兵 `retracted`。
+   *  WHY 落 kv:`deep.retract:<id>` = `{reason, by, at}` —— 过一阵要回答"当初为什么不要它"时,
+   *  答案必须在库里,而不在某次已经折叠掉的会话里。
+   *  ⚠️ 已被取代/已作废的条目**再作废一次会被拒**(`already-retired`)——
+   *  否则后一次的 reason 会把前一次的盖掉,留痕就变成"最后一次说的算"。 */
+  retractDeepItem(id, { reason = '', by = 'user' } = {}) {
+    const row = this.deepItemById(id);
+    if (!row) return { ok: false, reason: 'not-found' };
+    const prev = String(row.superseded_by || '');
+    if (prev !== '') return { ok: false, reason: 'already-retired', superseded_by: prev };
+    this.db.prepare('UPDATE deep_item SET superseded_by=?, updated_at=? WHERE id=?')
+      .run(DEEP_RETRACTED, utcIso(), String(id));
+    try {
+      this.kvSet('deep.retract:' + String(id), JSON.stringify({ reason: String(reason), by: String(by), at: utcIso() }));
+    } catch { /* 留痕失败**不改变**"作废已生效"这件事 —— 表已经改了,回执不许说谎 */ }
+    return { ok: true, id: String(id), superseded_by: DEEP_RETRACTED, reason: String(reason) };
+  }
+
   /** 加固 +1。⚠️ **只该由"真被采用"调用** —— 注入不算(见列注释:注入就加分会形成自我强化回路)。
    *  采用信号的首选 = `recall` 取过它指向的原文(那条路已在投递留痕面内)。 */
   bumpDeepHit(id) {
@@ -2644,6 +2689,29 @@ export class MemoryStore {
     return Number(this.db.prepare('SELECT COUNT(*) AS n FROM deep_item').get()?.n) || 0;
   }
 
+  /** 已退役(被取代或已作废)的条数 —— 与 deepItemCount 分开报:
+   *  "库里 411 条"和"现在还会被挑的是 408 条"是两件事,混着说会让人以为退役的还在参与。 */
+  deepRetiredCount() {
+    return Number(this.db.prepare("SELECT COUNT(*) AS n FROM deep_item WHERE superseded_by<>''").get()?.n) || 0;
+  }
+
+  /** 条目行 → **对外视图**(面板、工具、HTTP 三面共用一份)。
+   *  WHY 落在这里:api.js 的 `/deep/items` 与 tools.js 的 `list` 报的是**同一种东西**,
+   *  各写一份映射必然漂(本仓反复吃过这个亏)⇒ 单一来源钉在库这一层,两个面都调它。
+   *  故意**不**放 `db` 内部行:`superseded_by` 这种内部列也照发(面板要能看出"它退役了"),
+   *  但字段名统一成稳定的一套,免得前端跟着列名漂。 */
+  deepItemView(r) {
+    const row = r || {};
+    return {
+      id: String(row.id ?? ''), kind: String(row.kind ?? ''), text: String(row.text ?? ''),
+      durability: String(row.durability ?? ''),
+      hit_count: Number(row.hit_count) || 0, pinned: Number(row.pinned) || 0,
+      conv_id: String(row.conv_id ?? ''), src: String(row.src ?? ''), at: String(row.at ?? ''),
+      superseded_by: String(row.superseded_by ?? ''), branch_id: String(row.branch_id ?? ''),
+      created_at: String(row.created_at ?? ''),
+    };
+  }
+
   // ---- raw turns (DSH incremental capture, passive) ----
   /** 追加一条原文轮次(幂等:(session_id,seq) 冲突时更新正文)。
    *  v14:`source` 记**这条原文属于哪个来源**(取值口径见 RAW_SOURCE_DSH 段)。缺省 null ⇒ 按 id
@@ -2884,8 +2952,30 @@ export class MemoryStore {
     return body;
   }
 
-  /** 合并(DESIGN §8 v2):概述幂等;队列/建议按内容去重追加;deep 仅在目标存在对应概述时恢复。 */
+  /** 合并(DESIGN §8 v2):概述幂等;队列/建议按内容去重追加;deep 仅在目标存在对应概述时恢复。
+   *
+   *  **1.7.1(审计 C1):整包原子化** —— 以前没有事务,包处理到一半抛异常(尤其 `overwrite=true`
+   *  的覆盖路径)会留下"一部分已覆盖、一部分没覆盖"的半截库,而回执只报 `errors=1`。
+   *  用 `SAVEPOINT` 而不是 `BEGIN`:外层若已有事务仍可嵌套(`BEGIN` 会抛 "cannot start a transaction")。
+   *  口径:**逃出方法的异常** ⇒ 整包回滚(回执全 0 + `errors=1`,不谎报行数);
+   *  **单行错误**仍按旧语义只计数不回滚 —— 那是刻意保留的"坏一行不毁整包"。 */
   importBundle(bundle, { overwrite = false } = {}) {
+    const sp = 'sp_import_' + Math.random().toString(36).slice(2, 10);
+    try {
+      // delta 复审:SAVEPOINT 本身也可能失败(库不可事务/被占用),必须在 try 内,
+      //   否则它会作为未归类的异常逃出方法,违背"回执永远是一张表"的契约。
+      this.db.exec('SAVEPOINT ' + sp);
+      const report = this._importBundleRows(bundle, { overwrite });
+      this.db.exec('RELEASE ' + sp);
+      return report;
+    } catch {
+      try { this.db.exec('ROLLBACK TO ' + sp); this.db.exec('RELEASE ' + sp); } catch { /* noop */ }
+      return { added: 0, skipped: 0, overwritten: 0, queueAdded: 0, queueSkipped: 0, suggAdded: 0, suggSkipped: 0, deepRestored: 0, deepSkipped: 0, errors: 1 };
+    }
+  }
+
+  /** `importBundle` 的行循环(无事务;只许 `importBundle` 调)。 */
+  _importBundleRows(bundle, { overwrite = false } = {}) {
     const report = { added: 0, skipped: 0, overwritten: 0, queueAdded: 0, queueSkipped: 0, suggAdded: 0, suggSkipped: 0, deepRestored: 0, deepSkipped: 0, errors: 0 };
     if (!bundle || bundle.format !== 'dsh-ling-memory') {
       report.errors = 1;

package/lib/host/persona.js

@@ -63,8 +63,8 @@ export const DEFAULT_SETTINGS = Object.freeze({
   },
   memory: {
     l1Enabled: true,
-    l1BudgetTokens: 720,   // 1.6 步 5:1200 → 720(「瘦身到现在的 60%」,尝生 2026-10-04 拍)
-    l1MaxItems: 10,        // 1.6:8 → 10(尝生 2026-10-04:「8 条也可以考虑改 10 条,其中 2 条作为最硬的事实的席位」)
+    l1BudgetTokens: 720,   // 1.6 步 5:1200 → 720(「瘦身到现在的 60%」,用户 2026-10-04 拍)
+    l1MaxItems: 10,        // 1.6:8 → 10(用户 2026-10-04:「8 条也可以考虑改 10 条,其中 2 条作为最硬的事实的席位」)
     l1MaxLineChars: 180,   // 兜底硬顶:只对病态长标题生效(截断优先落在句末)
     l1SummaryChars: 110,   // 摘要段预算:第一句超此长度才硬截并标 …(2026-09-16 与用户定案)
     categoryWeights: {    // mode -> 领域类别权重(D6,先验倾向)
@@ -105,6 +105,17 @@ export const DEFAULT_SETTINGS = Object.freeze({
     baseUrl: '',        // 空 = 落到环境变量 DSH_LING_ASSISTANT,再落到内置默认(loopback:11434)
     model: '',          // 空 = 落到环境变量 DSH_LING_ASSISTANT_MODEL,再落到 qwen3.5:9b
   },
+  // 后台自动行为(2026-10-16 与用户定):这些行为**一直是开着的**,只是此前既没有文档、
+  // 也没有面板开关 —— 只能靠改插件配置(cfg)或读源码才知道。现在收进 settings.auto:
+  // 面板可读写,默认值与原硬编码**逐字相同**(关掉前请听清每行说明的后果)。
+  // 三级优先级:settings.auto.<键> > 插件配置 cfg.<旧键> > 这里(解析只在 deepsummary.resolveAuto 一处)。
+  auto: {
+    deepSummary: true,          // 自动深摘总闸:关掉后只有你点「深摘」时才调用模型;已经深摘过的会话不受影响
+    deepIntervalMin: 30,        // 自动深摘间隔(分钟,夹到 10..1440):调小 = 记忆更新更勤、更吃模型额度;调大 = 省额度
+    deepMaxPerRun: 2,           // 每轮最多深摘几个会话(夹到 1..20):调大 = 一轮更久、一次花掉更多额度
+    bootProbeDelayMs: 12000,    // 启动后多久做一次 LLM 探活(毫秒,夹到 0..600000):0 = 立即探活(宿主刚起时可能失败)
+    feedbackAuto: true,         // 反馈成长回路(事件驱动):关掉后点踩/点赞不再自动长出规矩与习惯提议
+  },
   dates: [],            // 自定义纪念日 [{m,d,label,greeting}](内置 9-07 新生纪念日见 clock.js)
 });
 

package/lib/host/rawlog.js

@@ -1,6 +1,6 @@
 // dsh-ling host — 直通原文(1.6 · P2 第一优先)。
 //
-// 为什么要有这个模块(2026-10-04 尝生定「第一优先级就是先把读原文的这个事儿给办了」):
+// 为什么要有这个模块(2026-10-04 用户定「第一优先级就是先把读原文的这个事儿给办了」):
 //   器灵此前**没有任何正规通道**能读会话原文 —— 7 个工具里一个都读不到,
 //   而 memory.db 的 `dsh_turns_raw` 是**残的**(本会话实测:库里 13 条 vs 磁盘 473 条,≈2.7%)。
 //   真全文只躺在磁盘上: ~/.dsh/sessions/<项目目录>/<会话目录>/session.v4.jsonl.zstd
@@ -320,9 +320,72 @@ export function localStamp(ms) {
   return `${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}`;
 }
 
-/** 单行化 + 截断(目录视图用)。名字不叫 flatOne:`tools.js` 里已有一个同名的(签名不同)。 */
+/** ⚠️ **孤立代理净化**(F4 修复批次,2026-10-17)。
+ *
+ *  为什么必须有它:JavaScript 字符串允许**半个代理对**存在(高位 `U+D800–DBFF` 或低位
+ *  `U+DC00–DFFF` 落单),那是**非法 UTF-16** —— 而它一旦被送进请求体,上游 JSON 解析器
+ *  **直接崩**(不是"显示怪",是整条请求 400)。
+ *
+ *  实测两起事故(2026-10-17 全库核实,550 会话 / 真 400 共 9 次):
+ *    · `session-bc00b39b` #6331:低代理 `0xdd12` @870 —— 源自 `recall` snippet **起点**切在 emoji 中间;
+ *    · `session-7ff65dd7` seq=58:高代理 `U+D83C` —— 源自 `recall` snippet **终点**切在 emoji 中间。
+ *  两例**都**触发了 400(杀伤率 100%),没有侥幸活下来的样本。
+ *
+ *  ⇒ 口径:**凡是往外送(进模型上下文 / 落盘 / 进请求体)的文本,先过这里**。
+ *  落单代理一律换成 `U+FFFD`(与浏览器、流式 UTF-8 解码同款口径)。
+ *  优先用运行时自带的 `String.prototype.toWellFormed`(ES2024),没有就手写等价实现。 */
+export function wellFormed(s) {
+  const t = String(s ?? '');
+  if (typeof t.toWellFormed === 'function') return t.toWellFormed();
+  let out = '';
+  for (let i = 0; i < t.length; i++) {
+    const c = t.charCodeAt(i);
+    if (c >= 0xd800 && c <= 0xdbff) {
+      const n = i + 1 < t.length ? t.charCodeAt(i + 1) : 0;
+      if (n >= 0xdc00 && n <= 0xdfff) { out += t[i] + t[i + 1]; i += 1; } else out += '\uFFFD';
+    } else if (c >= 0xdc00 && c <= 0xdfff) {
+      out += '\uFFFD';
+    } else {
+      out += t[i];
+    }
+  }
+  return out;
+}
+
+/** **不切断代理对**的截断(超出留 `…`)。与 `slice(0, n)` **同口径** —— `cap` 数的是
+ *  **UTF-16 单元**(emoji 算 2),唯一差别是切点若落在代理对中间就**回退一格**,
+ *  绝不吐出半个字符。⇒ 代价只有"含 emoji 的文本少显示一两个字",换来的是回执永远合法。
+ *  实现刻意做成 O(1)(只回退一格,不构造码点数组)—— 它会被高频调用。 */
+export function clipChars(s, cap) {
+  const t = wellFormed(s);
+  const k = Math.max(1, Number(cap) || 0);
+  if (t.length <= k) return t;
+  let end = k;
+  // 切点前一个单元是高代理 ⇒ 它的低代理会被丢掉 ⇒ 回退一格,把整个字符留在片段里
+  const c = t.charCodeAt(end - 1);
+  if (c >= 0xd800 && c <= 0xdbff) end -= 1;
+  return t.slice(0, end) + '…';
+}
+
+/** 按**码点**安全取区间(起点与终点都不切断代理对)。`recall` 的"命中位置附近截一段"用它。
+ *  起点落在低代理上 ⇒ 回退一格(宁可多带一个字符,也不留下半个 emoji)。 */
+export function safeSlice(s, from, to) {
+  const t = wellFormed(s);
+  const n = t.length;
+  let a = Math.max(0, Math.min(Number(from) || 0, n));
+  let b = Math.max(a, Math.min(Number(to) || 0, n));
+  const ca = t.charCodeAt(a);
+  if (ca >= 0xdc00 && ca <= 0xdfff) a = Math.max(0, a - 1);
+  const cb = t.charCodeAt(b - 1);
+  if (cb >= 0xd800 && cb <= 0xdbff) b = Math.min(n, b + 1);
+  return t.slice(a, b);
+}
+
+/** 单行化 + 截断(目录视图用)。名字不叫 flatOne:`tools.js` 里已有一个同名的(签名不同)。
+ *  ⚠️ F4(2026-10-17):截断改走 `clipChars`(按码点)—— 原来直接 `slice` 会把 emoji 切成半个,
+ *  那半个代理会随工具回执进上下文、并把官方路由打成 400(见 `wellFormed` 的事故记录)。 */
 export function oneLine(s, cap = 60) {
-  const t = String(s || '').replace(/\s+/g, ' ').trim();
+  const t = wellFormed(String(s || '').replace(/\s+/g, ' ').trim());
   if (!t) return '';
-  return t.length > cap ? t.slice(0, cap) + '…' : t;
+  return clipChars(t, cap);
 }

package/lib/host/recall-search.js

@@ -22,7 +22,7 @@
 //   (官方同款实现在 `dsh-api-session-controller\lib\index.js:1934` / `:1984`)。
 
 import { isMemoryEligibleHeader, sessionKind } from './util.js';
-import { localStamp, oneLine } from './rawlog.js';
+import { localStamp, oneLine, safeSlice, wellFormed } from './rawlog.js';
 
 /** 一页几个会话(默认):**5 条**(2026-10-05 主人拍板 B2,原为 10)。
  *  起因:实测"搜什么都中今天" —— 全文索引里**当前会话自己**也在,任何词都能命中几十秒前刚打的那句话,
@@ -97,13 +97,29 @@ export function searchDeepItems(memory, q, limit = SEARCH_DEEP_MAX) {
   const words = String(q || '').trim().split(/\s+/).map((w) => w.replace(/[%_\\]/g, '')).filter(Boolean);
   if (!words.length) return [];
   try {
-    const where = words.map(() => "text LIKE ? ESCAPE '\\'").join(' AND ');
+    // ⚠️ 2026-10-06:**类目名(kind)也在检索面里** —— 修前只扫 `text`,于是查询里的类目词打不中
+    //   它们自己的条目:实测搜「纪律」时那 18 条只回来 2 条(恰好正文含"纪律"二字的那些),
+    //   而**同族缺陷对"承诺 / 决定 / 关系 / 事实 / 偏好"一样成立**。
+    //   多词仍是 **AND**(每词都得在 text 或 kind 里出现其一),与宿主检索面同解,不另立口径。
+    const where = words.map(() => "(text LIKE ? ESCAPE '\\' OR kind LIKE ? ESCAPE '\\')").join(' AND ');
+    const args = [];
+    for (const w of words) { args.push(`%${w}%`, `%${w}%`); }
+    args.push(Math.max(1, Math.min(50, Number(limit) || SEARCH_DEEP_MAX)));
     return db.prepare(
       `SELECT id, kind, text, conv_id, src, seq_from, seq_to, pinned, hit_count FROM deep_item
        WHERE superseded_by='' AND ${where}
        ORDER BY pinned DESC, hit_count DESC, created_at DESC LIMIT ?`,
-    ).all(...words.map((w) => `%${w}%`), Math.max(1, Math.min(50, Number(limit) || SEARCH_DEEP_MAX)));
-  } catch { return []; }
+    ).all(...args);
+  } catch (e) {
+    // ── F3(1.7 修复批次,2026-10-15)─────────────────────────────────────────────
+    // 修前是 `catch { return []; }` —— 把**库读失败**(损坏 / 被占用 / SQL 错)归并成**零命中**,
+    // 调用方读到的就是"库里没有",而真实情况是"我们自己的库读不出来"。违反本项目口径
+    // 「**库不可用 ≠ 零命中**」(同文件对宿主那条路一直严格分开:`search-unavailable` / 超时文案)。
+    // 现在**只吞"表 / 列不存在"** —— 那是"这张表还没建"的正常态;其余一律往上冒,由工具层
+    // 转成 `local-unavailable`(见 tools.js 的 runSearch)。
+    if (/no such table|no such column/i.test(String(e?.message ?? e))) return [];
+    throw e;
+  }
 }
 
 /** 检索档本地原文层一次最多带出几轮(默认同 `SEARCH_HITS_DEFAULT`)。 */
@@ -121,6 +137,8 @@ export const SEARCH_LOCAL_TURNS_MAX = 50;
  *
  * 与 `searchDeepItems` 同解的三条(不另立口径):多词 = **AND**;词里的 `% _ \` 先剥掉;
  * 表不存在时**静默返回空**(检索面不该因为某张表缺席而整体失败)。
+ * ⚠️ F3(1.7 修复批次)把这条**收窄**了:静默只对"**表 / 列不存在**"这一类;
+ *   库损坏 / 被占用 / SQL 错**往上冒** —— 库不可用 ≠ 零命中,两者的下一步动作完全不同。
  *
  * @param {object} memory  MemoryStore
  * @param {string} q       查询词(空格分隔 = 同时满足)
@@ -143,7 +161,12 @@ export function searchLocalTurns(memory, q, limit = SEARCH_HITS_DEFAULT, { selfI
       `SELECT session_id, seq, role, ts, text FROM dsh_turns_raw
        WHERE ${where} ORDER BY ts DESC LIMIT ?`,
     ).all(...words.map((w) => `%${w}%`), cap);
-  } catch { return { rows: [], selfExcluded: 0 }; }
+  } catch (e) {
+    // F3(1.7 修复批次):同 `searchDeepItems` —— **只吞"表 / 列不存在"**(表缺席是正常态),
+    //   库损坏 / 被占用 / SQL 错必须往上冒(往上冒才会被渲染成"库读不出来",而不是"没找到")。
+    if (/no such table|no such column/i.test(String(e?.message ?? e))) return { rows: [], selfExcluded: 0 };
+    throw e;
+  }
   const self = String(selfId || '');
   const mapped = rows.map((r) => {
     const id = String(r.session_id ?? '');
@@ -156,8 +179,11 @@ export function searchLocalTurns(memory, q, limit = SEARCH_HITS_DEFAULT, { selfI
     return {
       conv: id, seq: Number(r.seq) || 0, role,
       time: r.ts ? localStamp(r.ts) : '',
-      who: isUser ? callName : '鱼姬',
-      snippet: oneLine(text.slice(from, from + SEARCH_SNIPPET_CHARS), SEARCH_SNIPPET_CHARS),
+      who: isUser ? callName : '器灵',
+      // ⚠️ F4(2026-10-17):原来是 `text.slice(from, from + N)` —— 起点或终点落在 emoji 中间时
+      //   会切出**半个代理对**,而那半个代理会随回执进上下文、把官方路由打成 400。
+      //   实测 `session-bc00b39b` #6331 的低代理 `0xdd12` 正是起点切坏而来(见 rawlog.wellFormed)。
+      snippet: oneLine(safeSlice(text, from, from + SEARCH_SNIPPET_CHARS), SEARCH_SNIPPET_CHARS),
       isSelf: Boolean(self) && id === self,
     };
   });
@@ -239,7 +265,7 @@ export function toSearchRows(hits, { visible = null, all = false, callName = '
       cwd: header.cwd ? String(header.cwd) : '',
       seq: m.seq ?? null,
       time: m.time ? localStamp(m.time) : '',
-      who: isUser ? callName : '鱼姬',
+      who: isUser ? callName : '器灵',
       snippet: oneLine(m.snippet || '', SEARCH_SNIPPET_CHARS),
       isSelf: Boolean(self) && String(id) === self,
     });
@@ -258,6 +284,14 @@ export function toSearchRows(hits, { visible = null, all = false, callName = '
 
 /** 检索档的人读回执(纯函数,模型可见)。 */
 export function renderSearch(v) {
+  // ⚠️ F4(2026-10-17):**出口兜底净化**。snippet 有三个来源(宿主 `bestMatch` / 库内原文层 /
+  //   `rawlog` 目录),逐处修容易漏一处;这里对**整段回执**做一次 —— 任何落单代理(半个 emoji)
+  //   都换成 `U+FFFD`,保证"进模型上下文的文本"永远是合法 UTF-16(见 `rawlog.wellFormed` 的事故记录)。
+  return wellFormed(renderSearchText(v));
+}
+
+/** 回执正文(不做净化)—— 出口在 `renderSearch`。 */
+function renderSearchText(v) {
   if (!v || v.ok !== true) {
     // ⚠️ 兜底必须在**构造字符串之前** —— 表里的模板是立即求值的,`v` 为 null 时
     //   `v.message` 会在构造这一步就抛。这不是防御性编程:工具回执抛异常 = 模型那一步直接失败,
@@ -269,15 +303,29 @@ export function renderSearch(v) {
         + ' 这不是"库里没有",是**通道没接上** —— 按内容找会话这条路暂时走不通,'
         + '可改用**不带参数**的 recall() 按时间翻清单。',
       'search-failed': `检索报错,这次没搜成:${msg}。换个更短的词再试(中文 2~4 字命中最好)。`,
+      // F3(1.7 修复批次):**新开**一个理由词,不复用 `search-unavailable` ——
+      //   那句写的是"**宿主**检索面不可用",而这一条是"**我们自己的库**读不出来",
+      //   套用就是把假话换了个地方说(两条路该采取的动作也不同:前者换通道,后者查库/看占用)。
+      'local-unavailable':
+        `本机库读不出来,这次没搜成。原因:${msg}`
+        + ' **这不是"库里没有",是我们自己的库读不出来** —— 条目层与原文层都在这个库里,'
+        + '这次两半都没拿到(所以别据此断定"没发生过")。'
+        + '可先改用**不带参数**的 recall() 按时间翻清单;若反复如此,'
+        + '多半是库文件损坏或被别的进程占着(库路径见启动日志的 dataDir)。',
     }[v?.reason];
     return why || `未搜到内容(${v?.reason || '未知'})。`;
   }
   const scope = v.all
     ? '**未限定范围**(all=true —— 含子代理等非主人会话)'
-    : (v.degraded
-      ? '⚠️ **没能限定范围** —— 宿主这次没给 `listSessions`,所以下面这份结果**可能含子代理或其它会话**,'
-        + '不是"只搜主人自己的会话"(范围限制这条通道暂时失效,不是"库里只有这些")'
-      : '已在「**主人自己的会话**」内(默认范围)');
+    : (v.localScope
+      // ⚠️ 本地路**没有可见集过滤**(2026-10-06 外部文档核对抓到):它直查 `dsh_turns_raw` ——
+      //   那是**全量**(实测 11,296 行 / 1,647 会话,其中 `source='dsweb'` 的 1,523 个网页端会话、
+      //   未标来源的 104 个)⇒ **不许印"已在主人自己的会话内"**,那是说假话。
+      ? '⚠️ **本机库全量**(这条路不过 `listSessions` 可见集:含网页端导入的会话与未标来源的会话)'
+      : (v.degraded
+        ? '⚠️ **没能限定范围** —— 宿主这次没给 `listSessions`,所以下面这份结果**可能含子代理或其它会话**,'
+          + '不是"只搜主人自己的会话"(范围限制这条通道暂时失效,不是"库里只有这些")'
+        : '已在「**主人自己的会话**」内(默认范围)'));
   // ⚠️ **原文来源必须看得出来是哪一个**(2026-10-05 夜 · 主人拍板方案 A):
   //   两条路覆盖面**不一样**,不说清就会被读成"库里只有这些"。
   //   · 本地(默认):库内原文层 —— 只含"真人消息 + 有正文的回复"(capture 侧就这么收的),

package/lib/host/retitle.js

@@ -2,7 +2,7 @@
 //
 // 标题是记忆的"名字"。旧行为把首条用户消息硬截 46 字(见 summarizer.js TITLE_MAX),
 // 于是 60 条 dsh 概述里 26 条是半句话:
-//   「鱼姬，接下来在这里继续开发生长型人格与记忆树模块，继续走你的新生之路。 我刚刚对1.2.1的」
+//   「器灵，接下来在这里继续开发生长型人格与记忆树模块，继续走你的新生之路。 我刚刚对1.2.1的」
 //   「刚才我为本虚拟机安装解压压缩软件<360压缩>，由于操作过快，被捆绑了360本体，随后我在物」
 // 而 dsweb 侧标题干净(「CPU单核性能排行榜」),因为它用的是源库自带标题、不做首句截断。
 //
@@ -29,13 +29,13 @@ export const TITLE_MATERIAL_CHARS = 1400;
 export const TITLE_SYS = '你在给一段对话起名字。只输出标题本身:不超过 20 个字,写清这段对话在做什么或结论是什么;'
   + '不要引号、不要书名号、不要结尾标点、不要解释、不要分点、不要写"对话"二字。';
 
-// 称呼与问候:中文主人对器灵的日常开场(「晚上好小鱼，我小加班了一会，回来了」)
-const ADDRESS_RE = /^(小鱼鱼|小鱼|鱼姬|器灵|助手|宝贝|亲爱的)[，,、:：~～!！。\s]*/;
+// 称呼与问候:中文主人对器灵的日常开场(「晚上好器灵，我小加班了一会，回来了」)
+const ADDRESS_RE = /^(器灵|助手|宝贝|亲爱的)[，,、:：~～!！。\s]*/;
 const GREETING_RE = /^(早上好|中午好|下午好|晚上好|晚安|你好呀|你好|您好|哈喽|嗨|早|hello|hi|yo)[啊呀呢，,、!！。.~\s]*/i;
 // 无信息量首句(问候、寒暄、测试口令)
 const VAGUE_RE = /^(嗯+|哦+|好+|在吗|在不在|\S{0,4}测试\S*|回复数字\s*\d+|\d+|ok|test)$/i;
 
-/** 反复剥离"问候 + 称呼"前缀:「晚上好小鱼，我小加班了一会，回来了」→「我小加班了一会，回来了」。 */
+/** 反复剥离"问候 + 称呼"前缀:「晚上好器灵，我小加班了一会，回来了」→「我小加班了一会，回来了」。 */
 export function stripPreamble(text) {
   let s = String(text || '').replace(/\s+/g, ' ').trim();
   for (let i = 0; i < 3; i += 1) {
@@ -214,7 +214,7 @@ export function retitleCandidates(memory, { source = '', limit = 200 } = {}) {
     if (!looksLikeSessionId(r.conv_id)) return false;            // 合成行(user:principle-…)不是会话
     if (!t) return true;
     if (t.length >= LEGACY_TITLE_MAX) return true;               // 被旧上限(TITLE_MAX=46)切过的
-    if (ADDRESS_RE.test(t) || GREETING_RE.test(t)) return true;  // 还带着「鱼姬，」「晚上好小鱼，」= 旧启发式产物
+    if (ADDRESS_RE.test(t) || GREETING_RE.test(t)) return true;  // 还带着「器灵，」「晚上好器灵，」= 旧启发式产物
     return isVagueTitle(t);                                      // 「你好」「在吗」
   }).map((r) => ({ source: String(r.source), conv_id: String(r.conv_id), title: String(r.title || ''), summary: String(r.summary || '') }));
 }