@nightpainters/dsh-ling 1.7.0 → 1.7.2

package/lib/host/memory.js

@@ -5,6 +5,7 @@ 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';
@@ -14,7 +15,7 @@ const SCHEMA_VERSION = 17;
  *  为什么用哨兵而不是新列:所有"排除已被取代"的读路径(开场选择 / 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:提炼必须走审核,不直接进记忆);
+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):存量会话与记忆天然属于主干。 */
@@ -1003,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' };
     }
@@ -1226,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)
@@ -1400,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 = (() => {
@@ -1450,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,与双水位同批上)────────────────────────────
@@ -2141,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):提炼素材**必须排除已遗忘的记忆**。
@@ -2175,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 {
@@ -2938,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/rawlog.js

@@ -320,9 +320,166 @@ 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);
+}
+
+// ══ 1.7.2 · recall 回执降噪(2026-10-23)══════════════════════════════════════════
+// 三个纯函数,对应交接单的 M1 / M3 / M6。**放在文本出口这一层,不塞进渲染器** ——
+// 回执有四个出口(检索档、目录档、原文档、错误档),每个各写一份就会各错一处
+// (1.7 的 F-01 正是"修了三处、漏了两处"的现场)。
+
+/** 删掉 `token` **最后出现**的那一处(只用于末尾未闭合的标记,不重排正文)。 */
+function cutLastToken(t, token) {
+  const i = t.lastIndexOf(token);
+  if (i < 0) return t;
+  return t.slice(0, i) + t.slice(i + token.length);
+}
+
+/** **M1 · 截断后清理未闭合标记**(不补闭合,只剥掉末尾那个)。
+ *
+ *  现场:实测 51 条回执平均 1,211 字符,`**`/`` ` `` 约占 3.5%;而截断常常落在标记中间,
+ *  于是回执末尾留一个孤零零的 `**` 或 `` ` `` —— 模型读到的是一段**语法已坏**的文本,
+ *  却看不出这是截断造成的(它会以为正文里本来就有个星号)。
+ *
+ *  口径三条:
+ *   ① 只数 `**` / `` ` `` / `[` / `【` 的**奇偶**;奇数 ⇒ 最后一个没闭合 ⇒ 剥掉它
+ *      (`【` 是回执自己的大纲符号,清单 §3 M1 明确要求一起数);
+ *   ② **不补**闭合标记 —— 补会凭空造字(补在句中断句处,读起来更假);
+ *   ③ 只动**末尾那一处**,中间成对的标记是回执自己的格式,一个字不动。 */
+export function stripDanglingMarkers(s) {
+  let t = String(s ?? '');
+  for (let round = 0; round < 4; round += 1) {
+    const before = t;
+    // ⚠️ 代码围栏 ` ``` ` 必须**整体**算一个标记(2026-10-23 夜 · 对抗审计 A 抓到):
+    //   围栏是 3 个反引号,按"单个反引号"的奇偶去算会把它拆成 2+1 —— 于是截断后的围栏
+    //   会剩两个反引号(` ``js`)、甚至反过来把前文成对的行内代码当成悬空的那个。
+    //   先整段剥围栏,再数单个反引号,两个口径就不会互相污染。
+    if ((t.split('```').length - 1) % 2 === 1) t = cutLastToken(t, '```');
+    if ((t.split('**').length - 1) % 2 === 1) t = cutLastToken(t, '**');
+    if ((t.split('`').length - 1) % 2 === 1) t = cutLastToken(t, '`');
+    const open = (t.match(/\[/g) || []).length;
+    const close = (t.match(/]/g) || []).length;
+    if (open > close) t = cutLastToken(t, '[');
+    const openCjk = (t.match(/【/g) || []).length;
+    const closeCjk = (t.match(/】/g) || []).length;
+    if (openCjk > closeCjk) t = cutLastToken(t, '【');
+    if (t === before) break;
+  }
+  return t;
+}
+
+/** **M3 · 只剥 snippet 里的成对标记**(选项 C:回执自身格式保留)。
+ *
+ *  为什么只剥"成对"的:`**粗体**` 在 GUI 里有意义,在上下文里只是两个字符;
+ *  但**没配对的**那个是截断残渣,归 M1 管 —— 两件事分开做,才各自可测。
+ *  支持三种成对形态:粗体 `**x**` · 行内代码 `` `x` `` · 行内链接 `[x](url)`(留文字丢地址)。 */
+export function stripPairedMarkdown(s) {
+  let t = String(s ?? '');
+  for (let round = 0; round < 3; round += 1) {
+    const before = t;
+    t = t
+      .replace(/\*\*([^*\n]+)\*\*/g, '$1')
+      .replace(/`([^`\n]+)`/g, '$1')
+      .replace(/\[([^\]\n]+)\]\(([^)\n]+)\)/g, '$1');
+    if (t === before) break;
+  }
+  return t;
+}
+
+/** **M6 · 回执总字数上限**(默认 4,000)。
+ *
+ *  超了**截断并报出还剩多少** —— 绝不静默截断(那会让"没显示"读成"没有")。
+ *  返回 `{ text, truncated, remaining }`;`remaining` 是被切掉的**字符数**(UTF-16 单元),
+ *  报给模型的是"还有多少没看到",不是"还有多少轮"(轮数是 read 档的 `remaining`,别混)。
+ *  ⚠️ 切点走 `clipChars`(不切半个 emoji) —— 与 F4 同一道防线。
+ *
+ *  ⚠️⚠️ `keepTail`(2026-10-23 夜 · 对抗审计抓到后加的):**末尾的语义警告必须保住**。
+ *  回执的"本会话被排除 N 轮 / 被范围挡掉 N 条 / 还有更多 / 库里另有 N 条只有概述"全都拼在**末尾**
+ *  —— 直接按字数截断会把它们连正文一起切掉,于是"排除了 7 轮"变成"没有这回事"。
+ *  实测(审计员给的数):search 40 条长片段时三者**全部消失**,布尔 self/scope/more 均 false。
+ *  ⇒ 口径:截断只截**正文**,`keepTail` 那段**原样保留**,并从预算里先扣掉它的长度。 */
+export const RECEIPT_CHARS_MAX = 4000;
+export function capReceiptText(s, cap = RECEIPT_CHARS_MAX, keepTail = '') {
+  const t = String(s ?? '');
+  const tail = String(keepTail ?? '');
+  const k = Math.max(400, Number(cap) || RECEIPT_CHARS_MAX);
+  if (t.length <= k) return { text: t, truncated: false, remaining: 0 };
+  const budget = Math.max(200, k - tail.length);
+  const head = clipChars(t, budget);
+  const shown = Math.max(0, head.length - 1); // 末尾那个 '…' 不算正文
+  const remaining = Math.max(0, t.length - shown - tail.length);
+  return {
+    text: head
+      + `\n\n…(回执到 ${k} 字上限,**还有 ${remaining} 字没显示** —— 缩小查询词,或分次取(原文档用 from/to,清单档用更小的 limit)。)`
+      + tail,
+    truncated: true,
+    remaining,
+  };
 }

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, stripPairedMarkdown, stripDanglingMarkers, capReceiptText, RECEIPT_CHARS_MAX } from './rawlog.js';
 
 /** 一页几个会话(默认):**5 条**(2026-10-05 主人拍板 B2,原为 10)。
  *  起因:实测"搜什么都中今天" —— 全文索引里**当前会话自己**也在,任何词都能命中几十秒前刚打的那句话,
@@ -179,8 +179,13 @@ 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)。
+      // M3(1.7.2):snippet 是**别人的原文**,可能带 Markdown —— 只剥成对标记(选项 C);
+      //   回执自己的格式由模板负责,不在这里动。M1 再兜住截断留下的未闭合残渣。
+      snippet: stripDanglingMarkers(stripPairedMarkdown(oneLine(safeSlice(text, from, from + SEARCH_SNIPPET_CHARS), SEARCH_SNIPPET_CHARS))),
       isSelf: Boolean(self) && id === self,
     };
   });
@@ -262,8 +267,8 @@ 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 : '鱼姬',
-      snippet: oneLine(m.snippet || '', SEARCH_SNIPPET_CHARS),
+      who: isUser ? callName : '器灵',
+      snippet: stripDanglingMarkers(stripPairedMarkdown(oneLine(m.snippet || '', SEARCH_SNIPPET_CHARS))),
       isSelf: Boolean(self) && String(id) === self,
     });
   }
@@ -279,8 +284,75 @@ export function toSearchRows(hits, { visible = null, all = false, callName = '
   return { rows, skipped, degraded: !all && !visible };
 }
 
+/** **M5(1.7.2) · 深层库条目去重 + 同类折叠**。
+ *
+ *  现场(修改清单 §3 M5):样本里 4 条深层库条目全是「记忆树」相关事实、来自两个会话 ——
+ *  同一类目一次刷一屏,把**真正不同的**条目挤下去。
+ *  两条口径(**清单给的"或"两条都做,都不静默丢弃**):
+ *   ① 完全重复(`conv_id` + `text` 都相同)只留第一条;
+ *   ② 同一 `kind` 超过 `perKind`(默认 3)条时,前 `perKind` 条照常给,
+ *      其余**折叠成一行并报出条数** —— "没显示"不许读成"没有"。
+ *  ⚠️ 不按 `conv_id` 把条目合并成一条:那会丢掉"这是两件事"这个信息(清单也把它列为风险)。
+ *     同源只做**去重**(①),不做语义合并。 */
+export const DEEP_ROWS_PER_KIND = 3;
+export function groupDeepRows(rows, perKind = DEEP_ROWS_PER_KIND) {
+  const keep = [];
+  const seen = new Set();
+  const byKind = new Map();
+  for (const d of Array.isArray(rows) ? rows : []) {
+    const key = `${d?.conv_id ?? ''}\u0000${d?.text ?? ''}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const kind = String(d?.kind || '未分类');
+    const n = byKind.get(kind) || 0;
+    byKind.set(kind, n + 1);
+    if (n < perKind) keep.push(d);
+  }
+  const folded = [];
+  for (const [kind, total] of byKind) {
+    if (total > perKind) {
+      folded.push(`· …[${kind}] **另有 ${total - perKind} 条未展开**(同类目超 ${perKind} 条时折叠;要全看请缩小查询词)…`);
+    }
+  }
+  return { rows: keep, folded };
+}
+
 /** 检索档的人读回执(纯函数,模型可见)。 */
 export function renderSearch(v) {
+  // ⚠️ F4(2026-10-17):**出口兜底净化**。snippet 有三个来源(宿主 `bestMatch` / 库内原文层 /
+  //   `rawlog` 目录),逐处修容易漏一处;这里对**整段回执**做一次 —— 任何落单代理(半个 emoji)
+  //   都换成 `U+FFFD`,保证"进模型上下文的文本"永远是合法 UTF-16(见 `rawlog.wellFormed` 的事故记录)。
+  // M1/M6(1.7.2):先按 4,000 字上限截断(超了**报出还剩多少**),再剥末尾未闭合标记 ——
+  //   顺序不能反:截断本身会造出新的未闭合标记。
+  // ⚠️ 1.7.2 自查抓到的真缺陷:**search 档会被套两次上限**(renderSearch 一次 + renderRecall 一次)
+  const full = renderSearchText(v);
+  // ⚠️ 2026-10-23 夜(对抗审计 B 抓到):**末尾警告要保住** —— selfExcluded / skipped / hasMore
+  //   原先都会被 4,000 字上限连正文一起切掉,于是"排除了 N 轮"变成"没有这回事"。
+  //   只有真有命中(rows/deep 非空)时才走这条;零命中/超时/失败的回执本来就短。
+  const hasHits = (Array.isArray(v?.rows) && v.rows.length > 0) || (Array.isArray(v?.deep) && v.deep.length > 0);
+  const tail = hasHits ? searchTailNotes(v) : '';
+  const capped = capReceiptText(full, RECEIPT_CHARS_MAX, tail);
+  return wellFormed(stripDanglingMarkers(capped.text));
+}
+
+/** 回执**末尾的语义警告**(与 `renderSearchText` 末尾逐字同源 —— 两处必须一起改)。
+ *  之所以抽出来:上限截断时要把这段**整段保住**(见 `capReceiptText` 的 `keepTail`)。 */
+function searchTailNotes(v) {
+  const timeoutNote = v.timedOut
+    ? `\n\n⚠️ **原文层超时**(等满 ${Math.round((Number(v.timeoutMs) || SEARCH_TIMEOUT_MS) / 1000)} 秒没返回,多半是宿主在补索引对账):`
+      + ((Array.isArray(v.deep) && v.deep.length) ? '**条目层是本地库,不受影响,就在上面** —— 先把它们用起来。' : '这次连条目也没命中。')
+      + '要原文就**重发同一条**(多数第二次会快,对账已经补过了),或换更窄的词。'
+    : '';
+  const selfNote = Number(v.selfExcluded) > 0
+    ? `\n(另有 ${v.selfExcluded} 轮命中属于**当前会话自己**,已按默认排除 —— 要看自己刚说的传 \`includeSelf=true\`。)`
+    : '';
+  return timeoutNote + selfNote
+    + (v.skipped ? `\n(${v.skipped} 条被范围挡掉 —— 要看它们得显式传 all=true。)` : '')
+    + (v.hasMore ? '\n(这一页满了,**还有更多** —— 把 limit 调大,或换个更窄的词。)' : '');
+}
+
+/** 回执正文(不做净化)—— 出口在 `renderSearch`。 */
+function renderSearchText(v) {
   if (!v || v.ok !== true) {
     // ⚠️ 兜底必须在**构造字符串之前** —— 表里的模板是立即求值的,`v` 为 null 时
     //   `v.message` 会在构造这一步就抛。这不是防御性编程:工具回执抛异常 = 模型那一步直接失败,
@@ -325,17 +397,21 @@ export function renderSearch(v) {
     : '';
   const hitRows = Array.isArray(v.rows) ? v.rows : [];
   const deepRows = Array.isArray(v.deep) ? v.deep : [];
+  // M5(1.7.2):条目去重 + 同类目超 3 条折叠成汇总行(见 groupDeepRows)。
+  const grouped = groupDeepRows(deepRows);
   // 条目排在前:它是**结论层**(一句话说完),会话在后(要下钻才知道内容)。
   const deepBlock = deepRows.length
-    ? '【深层库条目 · 结论层(从他的会话里提炼出来的,可直接用)】\n' + deepRows.map((d) => {
+    ? '【深层库条目 · 结论层(从他的会话里提炼出来的,可直接用)】\n' + grouped.rows.map((d) => {
       const pin = Number(d.pinned) ? '📌 ' : '';
       // ⚠️ **不要在这里印 `from=`**(红队 2026-10-04):条目的 `seq_from/seq_to` 是**事件流 seq**
       //   (提炼料里的 `#N`,即 `dsh_turns_raw.seq`),而 `recall(conv, from, to)` 收的是
       //   **对话轮序号 n** —— 两个坐标系在"注入消息被折叠"的会话里会叉开。实测 274 条可比条目里
       //   **207 条(75.5%)照这条指引会直接 `out-of-range`**;偶有落在范围内的,读到的也是不相干的
       //   轮次,还会顺手给不相干条目计一次"采用"。⇒ 只给会话 id,让调用方**先看目录再取原文**。
-      return `· ${pin}[${d.kind}] ${d.text}\n  ↳ 出自 ${d.conv_id} —— 要看原话:先 \`recall(conv="${d.conv_id}")\` 拿轮次,再按目录里的 \`#N\` 取`;
-    }).join('\n') + '\n\n'
+      // M2(1.7.2):这条指引原先**每条条目都印一遍**(6 条就是 6 遍)。现在只印一次(见下方块尾)。
+      return `· ${pin}[${d.kind}] ${d.text}\n  ↳ 出自 ${d.conv_id}`;
+    }).join('\n') + (grouped.folded.length ? '\n' + grouped.folded.join('\n') : '')
+    + '\n(要原话:把上面的 conv 传给 `recall(conv=…)` 拿轮次,再按目录里的 `#N` 取 —— 别直接给 from,两个坐标系不同)' + '\n\n'
     : '';
   if (!hitRows.length && !deepRows.length) {
     // 超时是**另一种结论**,不能说成"没找到" —— 前者该"重发或换窄词",后者该"换词",
@@ -349,8 +425,9 @@ export function renderSearch(v) {
     }
     return `按内容没找到(查询「${v.q}」· ${scope})${layerNote}。`
       + (v.skipped ? `\n(有 ${v.skipped} 条被范围挡掉 —— 要看它们得显式传 all=true。)\n` : '\n')
-      + '换词试试:中文 **2~4 字**短词命中最好(`记忆树` / `血缘` / `注入面`);'
-      + '**多个词用空格分隔 = 同时满足**(AND);**没有子串匹配**(`call` 搜不到 `recall`)。';
+      // M2(1.7.2):完整"换词口径"已收进工具 description(模型每次都看得见);
+      //   回执只留本次特有信息。同一段话印两遍是纯噪音。
+      + '换词再试一次(口径见工具说明:中文 2~4 字、多词 = AND、无子串匹配)。';
   }
   const rows = hitRows.map((r) => {
     const at = [r.seq !== null && r.seq !== undefined ? `#${r.seq}` : '', r.time].filter(Boolean).join(' ');
@@ -365,21 +442,8 @@ export function renderSearch(v) {
       ? `按内容命中 **${deepRows.length} 条深层库条目**(查询「${v.q}」· ${scope})${layerNote}:`
       : `按内容找到 ${rows.length} 轮原文(查询「${v.q}」· ${scope})${layerNote}:`;
   const convBlock = rows.length ? `${v.local ? '【库内原文层】' : '【会话原文层】'}\n${rows.join('\n')}` : '';
-  // ⚠️ 超时**不算失败**:条目层已经拿到了(本地库),必须照常交出去。这一行是"如实说明少了一半",
-  //   而不是"报错" —— 两者的下一步动作不同(前者重发/换窄词,后者换通道)。
-  const timeoutNote = v.timedOut
-    ? `\n\n⚠️ **原文层超时**(等满 ${Math.round((Number(v.timeoutMs) || SEARCH_TIMEOUT_MS) / 1000)} 秒没返回,多半是宿主在补索引对账):`
-      + (deepRows.length ? '**条目层是本地库,不受影响,就在上面** —— 先把它们用起来。' : '这次连条目也没命中。')
-      + '要原文就**重发同一条**(多数第二次会快,对账已经补过了),或换更窄的词。'
-    : '';
-  // ⚠️ 排除本会话要**说出来**:不说就会被读成"库里只有这些"(那是说假话)。
-  const selfNote = Number(v.selfExcluded) > 0
-    ? `\n(另有 ${v.selfExcluded} 轮命中属于**当前会话自己**,已按默认排除 —— 要看自己刚说的传 \`includeSelf=true\`。)`
-    : '';
-  return `${head}\n${deepBlock}${convBlock}${timeoutNote}${selfNote}`
-    + (v.skipped ? `\n(${v.skipped} 条被范围挡掉 —— 要看它们得显式传 all=true。)` : '')
-    + (v.hasMore ? '\n(这一页满了,**还有更多** —— 把 limit 调大,或换个更窄的词。)' : '')
-    + (deepRows.length
-      ? '\n\n**下一步**:条目已经是可以直接用的结论;**要它背后那句话**就把上面的 conv 传给 `recall(conv=…)` 拿对话目录,再按目录里的 `#N` 取原文(`recall(conv, from, to)`)。'
-      : '\n\n**下一步**:把某个 conv 原样传给 `recall(conv)` 看它的**对话目录**,再 `recall(conv, from, to)` 取原文。');
+  // ⚠️ 超时 / 排除本会话 / 被范围挡掉 / 还有更多 —— 这四段**全在回执末尾**,统一由
+  //   `searchTailNotes()` 产出:① 它们语义上同属"本次特有的警告";② 上限截断时要把它们
+  //   **整段保住**(`keepTail`) —— 拆开各写一份,截断那天就会漏掉其中一段(审计实测漏的就是这三段)。
+  return `${head}\n${deepBlock}${convBlock}` + searchTailNotes(v);
 }

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 || '') }));
 }

package/lib/host/session-line.js

@@ -35,6 +35,9 @@ import { pick } from './util.js';
 import { firstSentence } from './l1.js';
 import { extractMessageText } from './snapshot.js';
 import { canInject, kindOfAgent, sessionIdOfAgent } from './inject.js';
+// F4(2026-10-17):按码点安全截断 —— 那一行会**进模型上下文**,原来直接 `slice` 会把 emoji
+// 切成半个代理对,而半个代理能把官方路由打成 400(见 `rawlog.wellFormed` 的事故记录)。
+import { clipChars } from './rawlog.js';
 
 /** 我们那条活行的 `source.kind` —— 也是"认出自己"的唯一判据(不用记下的 seq:折叠后可能已不在面上)。 */
 export const SESSION_LINE_SOURCE = 'dsh-ling:session-line';
@@ -74,11 +77,13 @@ function oneLine(t) {
   return String(t ?? '').replace(/\s+/g, ' ').trim();
 }
 
-/** 硬夹到 n 字(超出留 `…`)。 */
+/** 硬夹到 n 字(超出留 `…`)。⚠️ F4(2026-10-17):改走 `clipChars`(按码点)—— 原来直接
+ *  `slice(0, k-1)` 会把 emoji 切成半个代理对,而那一行会进模型上下文 ⇒ 半个代理能打成 400。
+ *  语义保持不变:**k 是含省略号的总长上限**。 */
 function clip(s, n) {
   const t = String(s ?? '');
   const k = Math.max(1, Number(n) || 0);
-  return t.length <= k ? t : t.slice(0, k - 1) + '…';
+  return t.length <= k ? t : clipChars(t, Math.max(1, k - 1));
 }
 
 /** 本地时刻 HH:MM(与主人看到的钟一致;探针里用它判断"文本是否随对话变")。 */

package/lib/host/snapshot.js

@@ -7,11 +7,12 @@ import { assemblePersona } from './persona.js';
 import { selectL1, formatL1Section } from './l1.js';
 import { currentMode } from './mode.js';
 import { neutralizeMustache } from './util.js';
+import { wellFormed } from './rawlog.js'; // 1.7.1 F4 闭环:快照是注入面主出口
 import { createHash } from 'node:crypto';
 
 // §4「超量折叠成一行」的那行计数(由 `memory.js` 的 branchLogDigest 在明细之后 push 进 `lines`)
 // —— 它是**汇总**,不是明细。零明细时它撑不起整段(见下方渲染判据);有明细时照旧显示。
-// 判据只用开头:明细行一律以主语(主人/鱼姬)或动作词开头,不会长成 `…另有 N 笔改动`。
+// 判据只用开头:明细行一律以主语(主人/器灵)或动作词开头,不会长成 `…另有 N 笔改动`。
 // 若哪天 memory.js 改了措辞,这里退化成"照旧渲染"(fail-open)—— 只影响占不占地方,不吞明细。
 const BRANCH_LOG_FOLD_LINE = /^…另有 \d+ 笔改动/;
 
@@ -28,7 +29,9 @@ export function buildSnapshotText(ctx, memory, settings, sessionId, { keywords =
     const l0 = assemblePersona(s, mode);
     if (l0) { l0Text = l0; parts.push(l0); }
   }
-  if (personaEnabled && s.memory?.l1Enabled !== false && memory.listOverviews({ onlyOk: true }).length > 0) {
+  // 1.7.1(审计 F-02):闸不再查 conv_overview —— 料已换成深层库(l1.js 的 deepLine),
+  //   查概述会在"只有深层条目"的库里把整段 L1 吞掉;交 selectL1 自己判空。
+  if (personaEnabled && s.memory?.l1Enabled !== false) {
     const cfg = s.memory || {};
     const result = selectL1(memory, {
       mode,
@@ -100,7 +103,7 @@ export function buildSnapshotText(ctx, memory, settings, sessionId, { keywords =
       // **开关只管"渲染",不管"交代记账"**(停推进会卡死复盘模式的退出,回归见 tree 套 9-5)。
       if (s.memory?.branchLogEnabled !== false && logDetailLines.length) {
         // A-03 / D-S03(1.5.1 红蓝对抗):段首此前**写死**「主人刚改动了记忆树」,而 schema v12 起
-        // 每一行都已带主语(`branchLogDigest` 按 actor 分流成「主人」/「鱼姬」)⇒ 器灵经工具
+        // 每一行都已带主语(`branchLogDigest` 按 actor 分流成「主人」/「器灵」)⇒ 器灵经工具
         // 改的树,在它**下一轮的系统提示**里被读成"主人刚改动",与 tools.js 的设计意图正相反。
         // 段首改中性措辞,**主语交给每一行** —— 谁改的由行内说,不由段头替它说。
         parts.push(['【记忆树有改动】', ...logLines.map((x) => '- ' + x)].join('\n'));
@@ -110,7 +113,7 @@ export function buildSnapshotText(ctx, memory, settings, sessionId, { keywords =
   // 注入面出口 ①(快照侧,2026-09-18):L0 人格 + L1 记忆在这里成文。宿主 renderPrompt
   // 无 try/catch,未注册的 `{{名字}}` 会让该会话每一步都失败 ⇒ 成文即中和(幂等)。
   // 时间锚不经此处,由 inject.js 的最终出口兜底。
-  const text = neutralizeMustache(parts.join('\n\n'));
+  const text = wellFormed(neutralizeMustache(parts.join('\n\n')));
   // ── 投递留痕(1.6-A,2026-10-03)──────────────────────────────────────────────
   // **只在首次定稿时落一条**(`bumpHits`):冻结快照的选取在此刻定下,此后同一会话每轮投递的都是同一段
   // 文本;重建/空闲刷新再记只会把表撑大而不增信息(与 `hit_count` 只记首次定稿同一取向,见上)。