@nightpainters/dsh-ling 1.5.2 → 1.6.0

package/lib/host/tools.js

@@ -23,9 +23,17 @@ import {
   // D-T07:存在性判据与 assign 那条路共用一份实现(conv_overview / session_meta 双查)。
   convExistsIn,
 } from './tree-ops.js';
-import { TRUNK_ID, RAW_IMPORT_PREFIX } from './memory.js';
+import { TRUNK_ID, RAW_IMPORT_PREFIX, DIRECTED_LINK_KINDS } from './memory.js';
 // G2(2026-09-25):遗忘与回灌 —— 这两个是"会让人后悔"的操作,动手前一律先归档落盘。
 import { archiveBefore, listArchives, readArchive } from './archive.js';
+// 1.6 · P2(2026-10-04 尝生拍"第一优先级"):**直通原文** —— 此前器灵没有任何通道能读会话原文,
+// 只能吃概述(而概述是别人替我挑的)。真全文在磁盘的多 frame zstd 里,读法见 rawlog.js 顶部注释。
+import { listSessionFiles, readSessionEvents, dialogTurns, localStamp, oneLine, eventsFromRows } from './rawlog.js';
+// 回执里的称呼跟随 `persona.userTitle`(与 B 视角框、clock 的 [现在] 同一把尺) —— 不硬编码某个人的名字。
+import { userTitleForMode } from './persona.js';
+// 1.6 §7 步 1(2026-10-04 主人拍 D1-D6 后开工):recall 的**检索档** —— 按内容找会话,接宿主检索面(不自建)。
+// 为什么不自建、中文怎么查、范围怎么限:见 recall-search.js 顶部注释(含本机实测口径)。
+import { clampSearchLimit, visibleIdSet, toSearchRows, renderSearch, searchDeepItems, adoptDeepItems } from './recall-search.js';
 
 export const TOOL_RULE_ADD = 'rule_add';
 export const TOOL_HABIT_PROPOSE = 'habit_propose';
@@ -34,6 +42,7 @@ export const TOOL_TREE_READ = 'tree_read';
 export const TOOL_BRANCH_EDIT = 'branch_edit';
 export const TOOL_MEMORY_FORGET = 'memory_forget';
 export const TOOL_MEMORY_BACKFILL = 'memory_backfill';
+export const TOOL_RECALL = 'recall';
 /** 结构性改动一律要求的"为什么"最短长度 —— 留痕要能看懂,否则复盘时只能看到结果。 */
 const MIN_REASON = 4;
 
@@ -266,7 +275,7 @@ export const HABIT_RESOLVE_SPEC = {
 // 纪律(写进工具描述,模型可见):
 //   - 只在主人明确要求、或正在和他一起复盘时调用;不要因为"看着乱想整理一下"就自己动手;
 //   - 每次改结构必须给 reason(写进 branch_log,复盘时可审计);
-//   - 经本通道的改动一律记 actor='ling' —— 注入面会告诉主人「器灵改动了记忆树」。
+//   - 经本通道的改动一律记 actor='ling' —— 注入面会告诉主人「鱼姬改动了记忆树」。
 
 /** 剔除 undefined/函数/Symbol —— 平台对工具输出做**无损 JSON**校验,含 undefined 即整次调用报
  *  「value is not lossless JSON」;而写操作早已落库 ⇒ 调用方看到"失败"、重发就会写第二遍。
@@ -407,7 +416,7 @@ function renderTreeRead(v) {
     return `待理矛盾 ${v.count} 对(未复盘时以最新为准,旧的一方降权):\n${rows.join('\n')}`;
   }
   const linkRows = (v.links || []).map((l) =>
-    `  ${l.from} ↔ ${l.to}${(l.kind && l.kind !== 'related') ? '（' + l.kind + '）' : ''}${l.note ? '｜' + l.note : ''}`);
+    `  ${l.from} ${DIRECTED_LINK_KINDS.has(String(l.kind || 'related')) ? '→' : '↔'} ${l.to}${(l.kind && l.kind !== 'related') ? '（' + l.kind + '）' : ''}${l.note ? '｜' + l.note : ''}`);
   const linkBlock = linkRows.length ? `\n连边 ${linkRows.length} 条:\n${linkRows.join('\n')}` : '';
   return `记忆树概览(共 ${v.branches} 条枝;▣ 主干 ◆ 主脉 · 枝;行尾是它的全长 id,可直接回传给 branch_edit/tree_read):\n${(v.lines || []).join('\n')}`
     + linkBlock
@@ -415,7 +424,7 @@ function renderTreeRead(v) {
 }
 
 /** 所有写操作回执的同一句尾巴(改动落在哪 —— 主人下一次开口前会看到)。 */
-const TALLY_LINE = '\n(已记入复盘留痕:器灵改动了记忆树 —— 主人下一次开口前会看到)';
+const TALLY_LINE = '\n(已记入复盘留痕:鱼姬改动了记忆树 —— 主人下一次开口前会看到)';
 
 /** 删枝**成功之后**的真实后果(D-T05 的成功路径那一侧:force 的后果此前只在"被拒绝"时说过,
  *  真的删成了以后回执只剩一句"删掉了枝" —— 归属被静默挪回主干,调用方无从知道)。
@@ -553,7 +562,7 @@ export const BRANCH_EDIT_SPEC = {
     + 'unlink(断边,需 id+to)/ weight(调枝系数,需 id+weightScale,复盘时用;'
     + '有效区间 [0,2],超出会被夹取,且**该字段当前不参与检索打分**)/ '
     + 'delete(删枝,需 id;非空枝要 force —— force 会把它的子枝与会话归属**回退到主干**,'
-    + '原归属不可还原)。所有改动都记在「器灵」名下,'
+    + '原归属不可还原)。所有改动都记在「鱼姬」名下,'
     + '并出现在他下一次开口前的注入里。',
   parameters: {
     type: 'object',
@@ -578,10 +587,10 @@ export const BRANCH_EDIT_SPEC = {
 
 // ---------------------------------------------------------------- 遗忘与回灌(G2 · Part G)
 //
-// 原则(用户 2026-09-25 定):**永远不做彻底删除**。
+// 原则(尝生 2026-09-25 定):**永远不做彻底删除**。
 //   forget   = 先归档落盘 → 再打库内标记(行不删,召回排除);两步都可逆。
 //   backfill = 先归档**当前**状态 → 再写回归档内容(带 origin 标记)。
-// 为什么 backfill 更危险(用户原话:「backfill 比 forget 危险多了,因为它更难以觉察」):
+// 为什么 backfill 更危险(尝生原话:「backfill 比 forget 危险多了,因为它更难以觉察」):
 //   遗忘让记忆"少一条",看得见;回灌是往里**加**东西,加错了很难发现 —— 所以它同样必须先备份。
 
 /** 单行化(回执里做预览用)。 */
@@ -683,10 +692,19 @@ function renderForget(v) {
       ? `恢复了「${v.convId}」—— 它会重新参与召回。\n(归档文件留着没动:那是"曾经忘过"的证据)`
       : `「${v.convId}」本来就不在遗忘列表里。`;
   }
+  // ⚠️ 措辞按归档**有没有原文轮次**分流(蓝队 2026-10-04):`turns === 0` 的归档(装的是概述正文)
+  //   用 `memory_backfill restore` **灌不回来**(它要求 `turns > 0`),只有 `undo` 能恢复召回 ——
+  //   此前一律写"或从归档回灌"是**假话**(把"改对了判据"换成了"换个地方说假话")。
+  const canBackfill = Number(v.turns) > 0;
   return `忘了「${v.convId}」。\n`
-    + `· 原文与概述已归档:${v.dir}(${v.turns} 轮)\n`
+    + (canBackfill
+      ? `· 原文与概述已归档:${v.dir}(${v.turns} 轮)\n`
+      : `· 归档里**没有原文轮次**,装的是概述正文:${v.dir}\n`)
     + `· 库里的行**没有删**,只加了遗忘标记 —— 召回不再选它\n`
-    + `· 想反悔:action=undo(或从归档回灌)`;
+    + (canBackfill
+      ? `· 想反悔:action=undo(或从归档回灌)`
+      : `· 想反悔:action=undo —— ⚠️ 这份归档没有原文轮次,`
+        + '`memory_backfill restore` 灌不回来(它要求归档里有原文),只有 undo 能让它重新参与召回');
 }
 
 /** memory_backfill 的人读回执(模型可见)。 */
@@ -698,6 +716,11 @@ function renderBackfill(v) {
       'bad-name': '归档名不合法。',
       'empty-archive': '这份归档里没有原文,灌回去也没有内容。',
       'no-target': '归档里没有 source/convId,请显式给出要灌回哪一条。',
+      // 2026-10-04(蓝队):归档里的真来源与调用方声明不符 ⇒ 拒绝。给两个值,让调用方能自己看出错在哪。
+      'source-mismatch': `**来源对不上,所以没有回灌** —— 你声明的是「${v.declared}」,`
+        + `而这份归档里存的是「${v.archived}」。灌回去会把这条记忆算到错误的来源域上`
+        + `(典型后果:一个网页端/外来会话被升格成"你自己的 DSH 会话",概述器会为它建镜像)。`
+        + `请按归档里的来源域重发。`,
       // B-11 同源:来源域白名单(与 memory_forget 同一份)。
       'bad-source': `source 只能是 ${MEMORY_SOURCES.join(' / ')} 之一。「${v.source}」不是。`,
       'no-reason': `回灌必须给 reason(至少 ${MIN_REASON} 个字)。`,
@@ -775,8 +798,159 @@ export const MEMORY_BACKFILL_SPEC = {
   },
 };
 
+/** recall 单次正文的字数护栏。**它只是护栏,不是判据** ——
+ *  "哪一段值得读"由模型自己指(先看目录、再给序号),工具**绝不替它挑"最重要的 N 字"**
+ *  (2026-10-04 尝生原话:「1 万字怎么能判断是哪 1 万最重要呢?这不能这样搞」)。
+ *  溢出时**必须报出还剩几轮、下一次从哪继续**,不许静默截断。 */
+export const RECALL_READ_CHARS = 12000;
+
+/** recall 的参数自校验(纯函数,便于单测)。三档:map(不给 conv) / outline(给 conv) / read(给 conv+范围)。 */
+export function checkRecall(args = {}) {
+  const conv = String(args?.conv ?? '').trim();
+  const q = String(args?.q ?? '').trim();
+  const hasRange = args?.from !== undefined || args?.to !== undefined;
+  // ①档(检索):`q` 与 `conv` **互斥** —— 两个一起给会让"找会话"与"读某个会话"两种意图打架。
+  //   直接拒绝并让回执说清楚,不猜(D-T07 同一条纪律:宁可让调用方再调一次)。
+  if (q && conv) return { ok: false, reason: 'q-xor-conv' };
+  if (q) return { ok: true, action: 'search', q, all: args?.all === true, limit: clampSearchLimit(args?.limit) };
+  if (!conv && hasRange) return { ok: false, reason: 'conv-required' };
+  if (!conv) {
+    const n = Math.floor(Number(args?.limit));
+    return { ok: true, action: 'map', limit: Number.isFinite(n) ? Math.min(200, Math.max(1, n)) : 40 };
+  }
+  if (!hasRange) return { ok: true, action: 'outline', conv };
+  const from = Math.max(1, Math.floor(Number(args?.from ?? 1)) || 1);
+  const rawTo = Math.floor(Number(args?.to));
+  const to = Math.max(from, Number.isFinite(rawTo) && rawTo > 0 ? Math.min(rawTo, from + 199) : from + 9);
+  return { ok: true, action: 'read', conv, from, to };
+}
+
+/** 磁盘上没有这个会话时,**退一步查库里的原文**(`dsh_turns_raw`)。
+ *  1.6(2026-10-04 实测):库里有 15 个 `import:<id>` 会话的原文,而它们在磁盘上没有日志 ⇒
+ *  只读磁盘的实现够不着它们。库里那份是**残的**(只含真人消息 + 有正文的回复),所以只在
+ *  磁盘确实没有时才走这里,并在回执里**标出来源**,不让人把它误当磁盘全文。
+ *  键名要试多种写法(库里可能写成 `import:<uuid>` / 裸 uuid / `session-<uuid>`)。 */
+export function readSessionFromDb(memory, conv) {
+  const db = memory?.db;
+  if (!db?.prepare) return null;
+  const want = String(conv || '').trim();
+  if (!want) return null;
+  const bare = want.replace(/^session-/, '');
+  const keys = Array.from(new Set([want, bare, `session-${bare}`, RAW_IMPORT_PREFIX + bare, RAW_IMPORT_PREFIX + want]));
+  for (const k of keys) {
+    let rows;
+    try { rows = db.prepare('SELECT seq, role, ts, text FROM dsh_turns_raw WHERE session_id=? ORDER BY seq').all(k); } catch { continue; }
+    if (!rows || !rows.length) continue;
+    return {
+      ok: true, id: want, project: '(库内原文)', frames: 0, dbKey: k, fromDb: true,
+      bytes: rows.reduce((n, r) => n + Buffer.byteLength(String(r.text ?? ''), 'utf8'), 0),
+      events: eventsFromRows(rows),
+    };
+  }
+  return null;
+}
+
+/** recall 的人读回执(模型可见)。 */
+function renderRecall(v) {
+  // ①档(检索)的回执由 recall-search.js 渲染 —— 它的形状与另外三档完全不同,挤在一处两边都难读。
+  if (v && v.ok === true && v.action === 'search') return renderSearch(v);
+  if (!v || v.ok !== true) {
+    const why = {
+      'q-xor-conv': '`q` 与 `conv` **不能同时给** —— 按内容找会话就只给 q;读某个会话就只给 conv。',
+      'conv-required': '给了 from/to 却没给 conv —— 先**不带任何参数**调一次 recall,拿到可选会话清单。',
+      'out-of-range': `序号超出范围:该会话一共 ${v.total} 轮对话(序号 1..${v.total})。先看目录确认序号。`,
+      'no-session': `找不到会话「${v.conv}」。先不带参数调一次 recall 拿清单,conv 要写全(可带或不带 session- 前缀)。`,
+      'no-sessions-root': `读不到会话目录:${v.message || '(原因未知)'}`,
+      corrupt: `会话日志损坏,这次没读出内容:${v.message || '(原因未知)'}`,
+      io: `读文件失败:${v.message || '(原因未知)'}`,
+    }[v.reason];
+    return (why || `未读到内容(${v.reason || '未知'})。`);
+  }
+  const who = v.callName || '主人';
+  if (v.action === 'map') {
+    const rows = v.sessions.map((s) => `· ${s.conv} · 最近 ${localStamp(s.mtime)} · ${(s.bytes / 1024).toFixed(0)}KB · ${s.project}`);
+    // 覆盖边界(1.6):磁盘这批是"有原文"的;库里另有一批只有概述 —— 明说,别让"没列出来"读成"没发生过"。
+    const gap = Number(v.noRawTotal) > 0
+      ? `\n\n⚠️ 库里另有 **${v.noRawTotal}** 条会话**只有概述、没有原文**(${v.noRawBySource || '来源未记'}) —— `
+        + '它们的原文**不在本机**(如从 DeepSeek 网页端导入的),本工具读不到;要查它们只能看概述。'
+      : '';
+    return `磁盘上**有原文可读**的会话共 ${v.total} 个(${v.projects} 个项目目录),按最近活动列前 ${v.sessions.length} 个:\n${rows.join('\n')}${gap}`
+      + '\n\n**下一步**:把上面某个 conv 原样传给 recall(不给 from/to),先看它的**对话目录** —— 目录只列轮次,不给正文。';
+  }
+  const srcTag = v.fromDb
+    ? ' · ⚠️ **来源:库内原文**(磁盘上没有该会话的日志;库那份是**残的** —— 只含真人消息与有正文的回复)'
+    : '';
+  // 体积按 KB/MB 自适应:库内原文常有几十 KB,写死 MB 会显示成 "0.0MB"。
+  const sizeText = v.bytes >= 1024 * 1024 ? `${(v.bytes / 1024 / 1024).toFixed(1)}MB` : `${Math.max(1, Math.round(v.bytes / 1024))}KB`;
+  const title = `会话 ${v.conv}(${v.fromDb ? '库内原文' : v.project} · ${v.frames > 0 ? `${v.frames} 帧 · ` : ''}对话 ${v.totalTurns} 轮 · ${sizeText}${srcTag})`;
+  if (v.action === 'outline') {
+    // 注入消息折叠成一行、**不占序号**(它们不是"谁说过的话") —— 序号因此可能跳号,跳号即折叠。
+    const rows = [];
+    let pend = 0;
+    const flush = () => { if (pend) { rows.push(`       (…此处折叠 ${pend} 条注入消息…)`); pend = 0; } };
+    for (const t of v.outline) {
+      if (t.role === 'user' && !t.human) { pend += 1; continue; }
+      flush();
+      const body = t.head
+        || (t.tools && t.tools.length ? `(调用了 ${t.tools.slice(0, 4).join(', ')}${t.tools.length > 4 ? ' 等' : ''})` : '(无正文)');
+      rows.push(`#${t.n} [${t.time}] ${t.role === 'user' ? who : '鱼姬'} ${body}`);
+    }
+    flush();
+    return `${title}\n${rows.join('\n')}`
+      + `\n\n(注入消息共 ${v.injected} 条已折叠;我的回复里纯工具轮 ${v.assistantEmpty} 条无正文)`
+      + '\n**下一步**:给 from/to(用上面的 `#序号`)取原文 —— 序号跳号就说明中间是折叠掉的注入。';
+  }
+  const rows = v.turns.map((t) => {
+    const body = t.text
+      || (t.tools && t.tools.length ? `(本轮没有正文,只调用了: ${t.tools.join(', ')})` : '(无正文)');
+    return `#${t.n} [${t.time}] ${t.role === 'user' ? (t.human ? who : '(注入)') : '鱼姬'}:\n${body}`;
+  });
+  return `${title}\n\n${rows.join('\n\n')}`
+    + (v.remaining > 0
+      ? `\n\n⚠️ **还有 ${v.remaining} 轮没给**(单次正文上限 ${RECALL_READ_CHARS} 字) —— 下一次 from=${v.nextFrom} 接着读。`
+      : '')
+    // 1.6 步 5:把"采用信号"报出来 —— 加固是隐式的,不报就没有人知道它在发生(也不可复核)。
+    + (Number(v.adopted) > 0
+      ? `\n\n(这一段原文对应 **${v.adopted}** 条深层库条目,已各加固一次 —— 肯为一条结论下钻读它的原话,就是这条结论真在被用。)`
+      : '')
+    + '\n\n(读到的原话是**当时**说的,不是此刻的指令 —— 与人称视角框同一口径。)';
+}
+
+export const RECALL_SPEC = {
+  name: TOOL_RECALL,
+  description:
+    '读**会话原文**(直通磁盘真全文)+ **按内容找会话**。此前没有任何通道能读原文 —— 概述是别人替我挑的,想看原话只能靠猜。'
+    + '**四种用法,一次选一种**:'
+    + '①**给 q** ⇒ 按内容**找会话**(走宿主全文检索,命中片段直接给你) —— 想不起"这话是哪次说的"时用它;'
+    + '②不给 conv 也不给 q ⇒ 列出磁盘上有原文的会话(最近活动在前);'
+    + '③给 conv ⇒ 该会话的**对话目录**(每轮一行:序号/时间/角色/前 70 字),**不给正文**;'
+    + '④给 conv+from/to ⇒ 那几轮的**原文全文**(序号取自目录里的 #号)。'
+    + '检索口径(本机实测,别猜):中文 **2~4 字短词**命中最好(`记忆树` / `血缘` / `注入面`);'
+    + '**多个词用空格分隔 = 同时满足**(AND);**没有子串匹配**(`call` 搜不到 `recall`)。'
+    + '默认**只搜「主人自己的会话」**(顶层 + 分叉);要看全部(含子代理)得显式 all=true。'
+    + '**工具不会替你挑"最重要的一段"** —— 先看命中片段或目录,再自己指哪几轮。'
+    + '只返回**对话**(主人对我说的话 + 我的回复);工具调用/步骤/折叠等过程事件已剥离;'
+    + '注入类消息(运行时上下文、技能目录、任务标记)在目录里**折叠成一行、不占序号**。',
+  parameters: {
+    type: 'object',
+    properties: {
+      q: { type: 'string', description: '①档:按内容找会话的查询词。中文 2~4 字最好;多词用空格分隔(= 同时满足);没有子串匹配。与 conv 互斥。' },
+      all: { type: 'boolean', description: '①档:是否越界到非主人的会话(子代理等)。默认 false = 只搜主人自己的会话。' },
+      conv: { type: 'string', description: '③④档:会话 id(取自 ①/② 档的清单);也接受裸 uuid' },
+      from: { type: 'number', description: '④档:起始轮次序号(1-based,**取自目录里的 #号**);缺省 1' },
+      to: { type: 'number', description: '④档:结束轮次序号(**含**);缺省 from+9' },
+      limit: { type: 'number', description: '①档一页几个会话(默认 10,上限 50)/ ②档列多少个会话(默认 40,上限 200)' },
+    },
+    required: [],
+  },
+  output: {
+    schema: { type: 'object', properties: { ok: { type: 'boolean' } }, required: ['ok'] },
+    render: (_args, value) => [{ type: 'text', text: renderRecall(value) }],
+  },
+};
+
 /**
- * 注册七个工具。**永不抛错**:拿不到 tools 服务时返回 `{ok:false, reason}`,
+ * 注册八个工具。**永不抛错**:拿不到 tools 服务时返回 `{ok:false, reason}`,
  * 插件其余部分照常工作(退化为只能用面板写入)。
  * @returns {{ok:boolean, reason?:string, disposers?:Function[]}}
  */
@@ -808,7 +982,18 @@ export function registerLingTools(ctx, { gate, memory, settings } = {}) {
     execute: guard(async (args, exec) => {
       const c = checkRuleAdd(args);
       if (!c.ok) return c;
-      const r = await addRule({ settings, rule: c.rule, quote: c.quote, sessionId: sessionIdOf(exec) });
+      // ── E3(审计 H-4):`source` **显式传**,不再靠 `rules.js` 的缺省值兜 ────────────────
+      //   这条路是**会话内**调用(模型经工具调的),与「主人在面板里亲手敲」是两种归因:
+      //     · 带原话 ⇒ 'session'(器灵在会话里代写,「经同意」可核查);
+      //     · 不带原话 ⇒ 'session-no-quote'(会话内调用但**没有凭据** —— 如实标记,绝不落成 'panel')。
+      //   改前这里不传 source ⇒ 落缺省 'session'(行为正确,但口径靠缺省值兜 —— 审计原文即此判)。
+      //   注意 `checkRuleAdd` 已经把"没有原话"挡在前面(tools.js:119 `no-quote`),所以这一支今天是
+      //   **fail-closed**:即便将来那道校验被放松,留痕也不会说谎。此处**不**填原话占位
+      //   (工具契约要求真原话;占位只属于"HTTP 端点已经落库"的那条路,见 api.js 的 ruleWriteAttribution)。
+      const r = await addRule({
+        settings, rule: c.rule, quote: c.quote, sessionId: sessionIdOf(exec),
+        source: String(c.quote || '').trim() ? 'session' : 'session-no-quote',
+      });
       if (r.ok) invalidateAll(gate, memory, settings);
       return { ...r, total: r.ok ? (r.rules || []).length : undefined };
     }),
@@ -899,7 +1084,7 @@ export function registerLingTools(ctx, { gate, memory, settings } = {}) {
       if (c.action === 'create') {
         r = opBranchCreate(memory, { name: c.name, kind: c.kind, parentId: c.parentId || TRUNK_ID });
         // opBranchCreate 沿用了旧 handler 的行为(不写留痕);工具通道必须留 ——
-        // 否则主人复盘时看不到"器灵凭空多了一条枝"。
+        // 否则主人复盘时看不到"鱼姬凭空多了一条枝"。
         if (r && r.ok) memory.logBranch(String(r.id || ''), 'create', { after: c.name, note: c.reason, actor });
       } else if (c.action === 'rename') {
         const row = rows.find((b) => b.id === c.id) || null;
@@ -999,6 +1184,12 @@ export function registerLingTools(ctx, { gate, memory, settings } = {}) {
       }
       const r = memory.forgetEntry({
         source: c.source, convId: c.convId, reason: c.reason, archivePath: arc.dir, actor: 'ling',
+        // ⚠️ 把 `arc.empty`(归档器的**权威判据**:原文 0 轮 **且** 概述无正文 **且** 无会话元数据)
+        //   显式传下去(红队 2026-10-04)。数据层原来只认 `turns.jsonl` 的行数,于是
+        //   "**只有概述、没有原文**"的条目(真库实测 3 条:主脉记忆 / import 条目 / 一条归档会话)
+        //   **永远忘不掉** —— 而回执还把一份躺着 145 字摘要的归档念成"归档里没有东西"。
+        archiveEmpty: arc.empty === true,
+        archiveTurns: Number(arc.turns) || 0,
       });
       if (r.ok) {
         memory.logBranch(TRUNK_ID, 'forget', {
@@ -1025,10 +1216,19 @@ export function registerLingTools(ctx, { gate, memory, settings } = {}) {
         const first = flatOne((a.turns[0] || {}).text || '').slice(0, 120);
         return { ok: true, action: 'inspect', name: a.name, turns: a.turns.length, note: a.note, preview: first };
       }
-      // restore:回灌比遗忘更难察觉(用户),所以**先备份当前状态**再写
+      // restore:回灌比遗忘更难察觉(尝生),所以**先备份当前状态**再写
       if (!a.turns.length) return { ok: false, reason: 'empty-archive' };
       const ov = (a.overview && typeof a.overview === 'object') ? a.overview : {};
-      const src = c.source || String(ov.source || '');
+      const declared = String(c.source || '');
+      const archivedSrc = String(ov.source || '');
+      // ⚠️ 来源**交叉校验**(蓝队 2026-10-04):归档里带着这条记忆当初的**真来源**(`ov.source`)——
+      //   只信调用方声明会出现 `restore(source:'dsh', convId:'<dsweb 的裸 uuid>')` 把外来会话
+      //   升格成"主人的 DSH 会话"(副本已复现:该 conv 变成 dsh×1 + dsweb×2,概述器当场认领它)。
+      //   ⇒ 两者都在且不符时**默认拒绝**(与项目既有的 fail-closed 形态一致:拒绝 + 给可指认面)。
+      if (declared && archivedSrc && declared !== archivedSrc) {
+        return { ok: false, reason: 'source-mismatch', declared, archived: archivedSrc };
+      }
+      const src = declared || archivedSrc;
       const cid = c.convId || String(ov.conv_id || '');
       if (!src || !cid) return { ok: false, reason: 'no-target' };
       const cur = archiveBefore(memory, {
@@ -1052,7 +1252,131 @@ export function registerLingTools(ctx, { gate, memory, settings } = {}) {
     }),
   };
 
-  for (const spec of [ruleSpec, habitSpec, resolveSpec, treeReadSpec, branchEditSpec, forgetSpec, backfillSpec]) {
+  // 1.6 · P2:直通原文。**只读** —— 不写库、不改树、不必落 inject_log(工具调用本身已由宿主记进会话日志)。
+  // 回执里的称呼随 persona.userTitle(与视角框、clock 的 [现在] 同一把尺),拿不到就退回中性词。
+  const recallCallName = (() => {
+    try { return userTitleForMode(settings?.get?.()?.persona?.userTitle, 'work') || '主人'; } catch { return '主人'; }
+  })();
+
+  // ①档(检索)的编排:拿服务 → 造可见集 → 检索 → 过滤 → 折行。
+  // 纯逻辑全在 recall-search.js(可单测),这里只做接线与降级。
+  // 降级口径很重要:服务不在 ⇒ 明说"**通道没接上**",而不是让模型读成"库里没有"——
+  // 这两件事该采取的动作完全不同(前者换路,后者换词),混在一起就是骗自己。
+  const runSearch = async (q, { all, limit, callName }) => {
+    let svc = null;
+    try {
+      svc = typeof ctx?.get === 'function' ? ctx.get('sessionQuery') : (ctx?.sessionQuery ?? null);
+    } catch { /* ignore */ }
+    if (!svc || typeof svc.searchSessions !== 'function') {
+      return {
+        ok: false, reason: 'search-unavailable',
+        message: '没拿到宿主的 sessionQuery 服务(它未启用,或本宿主版本不含该服务)。',
+      };
+    }
+    try {
+      let visible = null;
+      if (!all && typeof svc.listSessions === 'function') {
+        visible = visibleIdSet(await svc.listSessions());
+      }
+      const page = await svc.searchSessions({
+        query: q,
+        limit,
+        // 与官方服务端搜索同一套过滤(dsh-api-session-controller\lib\index.js:1953):
+        // 只要**对话**事件、且只要**当前上下文里还在**的那一份(被替换掉的不算命中)。
+        eventFilters: [
+          { kind: 'type', values: ['user/message', 'assistant/message'] },
+          { kind: 'surface', values: ['current'] },
+        ],
+      });
+      const { rows, skipped, degraded } = toSearchRows(page?.items, { visible, all, callName });
+      // 1.6 §7 步 4(2026-10-04):**同一次检索也查深层库条目** —— 主人的问句多半是
+      //   「我说过什么关于 X 的」,而答案更可能在**结论层**(deep_item)而不是某段原始对话里。
+      //   两者一起给,「找条目」与「找会话」一次到位。条目不受 `all` 影响(深层库本来就是
+      //   从主人自己的会话里提炼的;它的范围控制在提炼那一侧,不在这里)。
+      const deep = searchDeepItems(memory, q);
+      return { ok: true, action: 'search', q, all, rows, skipped, deep, degraded, hasMore: Boolean(page?.nextCursor) };
+    } catch (e) {
+      return { ok: false, reason: 'search-failed', message: String(e?.message ?? e).slice(0, 200) };
+    }
+  };
+  const recallSpec = {
+    ...RECALL_SPEC,
+    execute: guard(async (args) => {
+      const c = checkRecall(args);
+      if (!c.ok) return c;
+      if (c.action === 'search') return runSearch(c.q, { all: c.all, limit: c.limit, callName: recallCallName });
+      if (c.action === 'map') {
+        const r = listSessionFiles({ limit: c.limit });
+        if (!r.ok) return { ok: false, reason: r.reason, message: r.message };
+        // 1.6(2026-10-04)覆盖边界**必须报出来**:磁盘这批只是"**有原文**"的会话,库里还躺着
+        //   一批**只有概述、没有原文**的(dsweb 为主体,实测 1523/1634)。不报的话,
+        //   "清单里没有"会被读成"没发生过" —— 那正是主人要防的"漏用"。
+        let noRawTotal = 0; let noRawBySource = '';
+        try {
+          const disk = new Set(listSessionFiles({ limit: Number.MAX_SAFE_INTEGER }).sessions.map((s) => s.conv));
+          const onDisk = (id) => disk.has(id) || disk.has(`session-${id}`) || disk.has(String(id).replace(/^session-/, ''));
+          const bySrc = {};
+          for (const row of memory?.db?.prepare("SELECT conv_id, COALESCE(source,'(null)') AS s FROM conv_overview").all() ?? []) {
+            if (onDisk(String(row.conv_id))) continue;
+            bySrc[row.s] = (bySrc[row.s] || 0) + 1;
+            noRawTotal += 1;
+          }
+          noRawBySource = Object.entries(bySrc).sort((a, b) => b[1] - a[1]).map(([k, n]) => `${k} ${n}`).join(' · ');
+        } catch { /* 库读不到就不报这行,不阻断主功能 */ }
+        return { ok: true, action: 'map', total: r.total, projects: r.projects, sessions: r.sessions, callName: recallCallName, noRawTotal, noRawBySource };
+      }
+      let s = readSessionEvents(c.conv);
+      // 磁盘没有 ⇒ 退一步查库(import 域那批原文在库里,不在磁盘上)。
+      if (!s.ok && s.reason === 'no-session') s = readSessionFromDb(memory, c.conv) || s;
+      if (!s.ok) return { ok: false, reason: s.reason, conv: c.conv, message: s.message };
+      const { turns, injected, assistantEmpty } = dialogTurns(s.events);
+      const head = {
+        conv: s.id, project: s.project, frames: s.frames, bytes: s.bytes, fromDb: s.fromDb === true,
+        totalTurns: turns.length, injected, assistantEmpty, callName: recallCallName,
+      };
+      if (c.action === 'outline') {
+        return {
+          ok: true, action: 'outline', ...head,
+          outline: turns.map((t) => ({
+            n: t.n, seq: t.seq, time: localStamp(t.time), role: t.role, human: t.human,
+            head: oneLine(t.text, 70), tools: t.tools || [],
+          })),
+        };
+      }
+      const win = turns.slice(c.from - 1, c.to);
+      if (!win.length) return { ok: false, reason: 'out-of-range', conv: s.id, total: turns.length };
+      // 字数护栏:**从 from 往后按序给,给不下就停,并报出还剩几轮** —— 不排序、不挑选、不静默截断。
+      const picked = [];
+      let chars = 0;
+      for (const t of win) {
+        const body = String(t.text || '');
+        if (picked.length && chars + body.length > RECALL_READ_CHARS) break;
+        picked.push(t);
+        chars += body.length;
+      }
+      const last = picked[picked.length - 1];
+      // 1.6 步 5:**采用信号** —— 肯为一条结论下钻读它指向的原话,才是它真在用这条结论的证据
+      //   (注入不算:那是系统单方面推的)。与**真正交付的**那段原文相交的深层库条目 `hit_count` +1。
+      //   ⚠️ 坐标必须用 `t.seq`(库里的 raw seq —— 也就是提炼料里的 `#N`),**不是**对话轮序号 `t.n`:
+      //   两者在"注入消息被折叠"的会话里会叉开,用错坐标就会加固到不相干的条目上。
+      //   ⚠️ 区间必须取 **`picked`**(真正交付的)而不是 `win`(请求窗口)—— 红队 2026-10-04 实测:
+      //   请求第 25..26 轮而护栏只交付前 6 轮时,窗口内**没被读到**的条目也 +1 ⇒ 采用信号被虚增。
+      const seqs = picked.map((t) => Number(t.seq) || 0).filter((n) => n > 0);
+      const adopted = seqs.length ? adoptDeepItems(memory, s.id, Math.min(...seqs), Math.max(...seqs)) : 0;
+      return {
+        ok: true, action: 'read', ...head,
+        from: c.from, to: c.to, given: picked.length, chars, adopted,
+        remaining: win.length - picked.length,
+        nextFrom: picked.length < win.length ? last.n + 1 : null,
+        turns: picked.map((t) => ({
+          n: t.n, seq: t.seq, time: localStamp(t.time), role: t.role, human: t.human,
+          text: t.text, tools: t.tools || [],
+        })),
+      };
+    }),
+  };
+
+  for (const spec of [ruleSpec, habitSpec, resolveSpec, treeReadSpec, branchEditSpec, forgetSpec, backfillSpec, recallSpec]) {
     try {
       const d = tools.register(spec);
       if (typeof d === 'function') disposers.push(d);

package/lib/host/tree-ops.js

@@ -1,7 +1,7 @@
 // dsh-ling host — 记忆树操作的**唯一实现**(Part G G1,2026-09-25)。
 //
 // 为什么要有这个文件:
-//   Part G 任务书点出的洞 ——「记忆树的写操作,一条 agent 侧工具都没有。我得靠伪造成本机
+//   现场点出的洞 ——「记忆树的写操作,一条 agent 侧工具都没有。我得靠伪造成本机
 //   进程的身份走 UI 的 HTTP 口,或者直接开库」。根因不是"缺工具",而是**逻辑焊在 HTTP
 //   handler 里**:`api.js` 的 26 处树端点各自内联校验 + 调 memory + 写留痕,没有任何可复用
 //   的内部函数 ⇒ 工具通道无处落脚,只能重写一遍(那就成了两套会各自漂移的实现)。
@@ -19,7 +19,7 @@
 // 零行为变更:本文件的内容逐条搬自 `api.js` 原有 handler 的内联逻辑,搬动时**不改判定**,
 //   只把 `sendJson(res, X, Y)` 换成 `return { ...Y, status: X }`。
 
-import { TRUNK_ID } from './memory.js';
+import { TRUNK_ID, BRANCH_NAME_MAX } from './memory.js';
 
 /** 枝列表 → id 索引 Map(原 `api.js:62` 的私有助手,搬来共用)。 */
 export const mapBranchList = (list) => new Map((Array.isArray(list) ? list : []).map((b) => [String(b.id), b]));
@@ -100,7 +100,7 @@ export function opBranchCreate(memory, args = {}) {
   if (kind !== 'branch' && kind !== 'vein') return bad('bad-kind');
   const parentId = String(args.parentId || TRUNK_ID);
   if (!memory.listBranches().some((b) => b.id === parentId)) return bad('no-parent');
-  const name = String(args.name || '').trim().slice(0, 80);
+  const name = String(args.name || '').trim().slice(0, BRANCH_NAME_MAX);
   // 审计 B#4:空名枝会成为树里一个点不开的幽灵节点;旧版**没有任何删枝端点**,建错了只能改库。
   if (!name) return bad('empty-name');
   const id = kind === 'vein'
@@ -130,7 +130,7 @@ export function opBranchReparent(memory, args = {}) {
   if (parentId && !memory.listBranches().some((b) => b.id === parentId)) {
     if (String(args.createVein || '') === '1' || args.name) {
       parentId = memory.createVein({
-        name: String(args.name || '新主脉').slice(0, 80),
+        name: String(args.name || '新主脉').slice(0, BRANCH_NAME_MAX),
         parentId: String(args.veinParent || TRUNK_ID),
       });
     } else {
@@ -159,21 +159,27 @@ export function opBranchReparent(memory, args = {}) {
 
 /** 改枝名(lock 默认 true ⇒ 起名即定名,机器不再覆盖)。 */
 export function opBranchRename(memory, args = {}) {
-  const name = String(args.name || '').trim().slice(0, 80);
+  const name = String(args.name || '').trim().slice(0, BRANCH_NAME_MAX);
   if (!name) return bad('empty-name');
   const id = String(args.id || '');
   const beforeRow = memory.listBranches().find((b) => b.id === id) || null;
   if (!beforeRow) return bad('no-match'); // 审计 B#3
   const r = memory.renameBranch(id, name, { lock: args.lock !== false });
   if (r.ok) {
+    // ⚠️ D-T03(蓝队 2026-10-04 抓到这一处):**回执与留痕的名字必须来自库**,不能来自入参 ——
+    //   入参截到 `BRANCH_NAME_MAX`、`memory.renameBranch` 曾只存 60 ⇒ 旧写法让留痕写着 70 字、
+    //   库里其实只有 60 字。这里写后读回一次,与 `opBranchWeight` 同一口径;读不回来时退回 `r.name`。
+    const afterRow = memory.listBranches().find((b) => b.id === id) || null;
+    const stored = afterRow ? String(afterRow.name || '') : '';
     memory.logBranch(id, 'rename', {
       before: (beforeRow && beforeRow.name) || '',
-      after: name,
+      after: stored || r.name || name,
       note: String(args.note || ''),
       actor: actorOf(args),
     });
+    return { ...r, name: stored || r.name || name, status: 200 };
   }
-  return { ...r, status: r.ok ? 200 : 400 };
+  return { ...r, status: 400 };
 }
 
 /** 调枝系数(设计稿 §3.3:权重**仅复盘时**修改 —— 平时只读,由工具层的策略把关)。 */

package/lib/host/util.js

@@ -117,7 +117,7 @@ export function mergeDeep(base, over) {
   return out;
 }
 
-/** 会话种类(记忆分枝 D9-a,2026-09-18 用户定方向)。
+/** 会话种类(记忆分枝 D9-a,2026-09-18 尝生定方向)。
  *  背景:原 `isTopLevelSessionHeader` 把三类混成一个 false —— 子代理、委托、分叉**都不入库、不注入**。
  *  但分叉会话是主人显式开的**并行工作线**(工程上"先放下别的模块,专注做完这一个再回来"),
  *  它应当**有自己的记忆**(写入所属枝)且**能读祖先链**,而不是记忆真空。