@nightpainters/dsh-ling 1.6.0 → 1.6.2

package/README.md

@@ -21,6 +21,8 @@
 - 本插件的回答与记忆摘要**由人工智能生成**,可能存在错误,请自行判断。
 - 本项目面向**具备自行配置与运维能力**的用户;不面向未成年人,也不提供任何形式的在线陪伴服务。
 
+**想先知道它凭什么这么做?** 读 **[`PHILOSOPHY.md`](./PHILOSOPHY.md)** —— 目标为什么是"一种循环"、为什么复盘必须有"人在循环里"、它凭什么不越界、以及"不牺牲工作能力"背后的取舍。功能与设定的规格在本 README 的「设定全文」。
+
 ---
 
 <!-- 截图清单(仓库 images/ 目录):
@@ -68,7 +70,7 @@
 
 > **关于那道「手术门」**:亲手敲承诺句是**庄重感与自我提醒** —— 让你在改契约之前停一下、确认这是自己的决定;它**不是安全边界**(「禁粘贴」只是界面上的约定,挡不住任何有心的人)。真正把门的是**来源栅栏**:Host 必须是 loopback(或你显式写进受信名单的地址);另有一个**默认不开**的开关 `guard.allowLan` —— **一旦打开,整段局域网地址都算受信来源**(那是**放宽**,不是建议)。跨站请求直接拒,带 `Origin` 时其 host 必须等于请求的 Host(**带了但解析不出来就直接拒**),而**不带 `Origin` 的请求这条校验会跳过** —— 它不是"每个请求都必须带 Origin 且同源";再叠一道 cookie **名字**对撞 —— 期望名字按当前 Host 现算(`dsh-auth-` + 哈希),**只校验名字、不校验值的签名**。所以这道门挡的是"别的设备、别的页面"这类来源,而**本机原生进程本来就还能调用**(它也能直接读 `settings.json` 与记忆库,不算提权)—— 别的来源没有凭据就进不来这台机器上的 `/api`,敲对承诺句也没用。
 
-> **这道门现在长这样 —— 三条手续缺一不可**:① **只在本机做** —— 判据是"这次请求没有经过任何代理"(带代理头、或连 User-Agent 都没有的请求,都算非本机 ⇒ 拒,理由码 `surgery-local-only`);② **每次启动取一次票据** —— 票据每启动轮换,只下发给本机直连的请求(`POST /surgery/ticket`),客户端首次手术前取一次、之后随请求带上;③ **原句匹配** —— 敲出的承诺句要与当初写下的那一句相符。这三条由 `lib/host/surgery.js` 里**一处** `requireSurgery()` 判定,覆盖**全部 12 条**能改人格 / 规矩 / 习惯的写面(调用点不许再各写一份;曾有一条 `wantLock` 绕过分支,已删除)。每次手术都留痕:`$DSH_HOME/logs/surgery-YYYY-MM.jsonl`(append-only,整行哈希链,改一行即断链);`GET /surgery/events` 是只读事件面。
+> **这道门现在长这样 —— 三条手续缺一不可**:① **只在本机做** —— 判据是"这次请求没有经过任何代理"(带代理头、或连 User-Agent 都没有的请求,都算非本机 ⇒ 拒,理由码 `surgery-local-only`);② **每次启动取一次票据** —— 票据每启动轮换,只下发给本机直连的请求(`POST /surgery/ticket`),客户端首次手术前取一次、之后随请求带上;③ **原句匹配** —— 敲出的承诺句要与当初写下的那一句相符。这三条由 `lib/host/surgery.js` 里**一处** `requireSurgery()` 判定,覆盖**全部 14 条**能改人格 / 规矩 / 习惯的写面(调用点不许再各写一份;曾有一条 `wantLock` 绕过分支,已删除)。每次手术都留痕:`$DSH_HOME/logs/surgery-YYYY-MM.jsonl`(append-only,整行哈希链,改一行即断链);`GET /surgery/events` 是只读事件面。
 >
 > **承诺句只在本机回显**:`/state`(含面板档)、`/persona/history`、`/export` 这些读面,**带代理头**时只回 `hasSeal` 与 `phraseHidden`、不回原句,**本机直连**照旧回显 —— 所以你换台机器看面板不会因此被卡住,远端也拿不到原句。
 >
@@ -111,7 +113,7 @@
 - **不连乘**:血缘系数是**单值**,不沿路径累乘 —— 否则五层之后 `0.4^5 ≈ 0.01`,深层枝等于从记忆里消失。
 - **内容零改写**(硬性不变量):**除了"主脉提炼再次采纳会覆盖上一版"这一个例外**(覆盖前自动归档),任何树操作都不改写任何一条记忆的内容;分枝 / 并脉 / 连边只增加"关系",从不"融合内容"。
 - **矛盾只标记不改写**:一对记忆被判重复/矛盾时先**标记**;未复盘时检索**以较新的那条为准**(旧的一条降权 ×0.3,**不删除**;被**驳回**的与被标成**重复**的那一对不参与降权)。
-- **枝系数是预留字段**:复盘期可以调(0~2,夹紧后写入并显示),但它**当前不参与检索打分** —— 返回体里明确带 `applied:false`,别以为排序会跟着变。
+- **枝系数会真的改变排序**(1.6.2 起):复盘期可以调(0~2,夹紧后写入)。它按 `raw × 血缘 × 矛盾 × 枝系数` **参与检索打分** —— 调低某条枝的系数,从这条枝的会话里提炼出的结论就会在记忆开场里往后排(`1.0` = 不偏不倚,`0` = 排到最后,**不是禁用**)。
 
 **复盘 — 不是一个开关,是"左会话 + 右复盘栏"这个状态**:
 
@@ -175,7 +177,7 @@ dsh plugin --profile web add @nightpainters/dsh-ling
 # 2) 只验证配置层,先不启动
 dsh --profile web --dump-config     # 应能看到一行 "# == @nightpainters/dsh-ling" 层
 
-# 3) 给 DSH 核心打一行补丁(可取证访问日志要用;幂等/可回滚)
+# 3) 给 DSH 核心打一行补丁(可取证访问日志要用;幂等;这一页各步里**只有这一步**自带回滚)
 node ~/.dsh/profiles/web/node_modules/@nightpainters/dsh-ling/tools/apply-access-log-patch.mjs
 #    不打也一切照常 —— 只是访问日志为空;但**会提醒**:侧栏挂常驻 ⚠(判据 installed===false 且 reason 为 patch-missing;只有**有意关掉** config.accessLog.enabled=false ⇒ reason 为 disabled-by-config 才不染红)
 #    DSH 升级/重装后需重跑一次(补丁随包被覆盖)
@@ -184,6 +186,8 @@ node ~/.dsh/profiles/web/node_modules/@nightpainters/dsh-ling/tools/apply-access
 # 4) 重启宿主(host),然后浏览器 Ctrl+Shift+R 硬刷
 ```
 
+> ⚠️ **「可回滚 / 先备份」的确切范围(别读宽了 —— 2026-10-05 现场复核)**:**两套步骤里只有打补丁这一步自带回滚** —— 脚本动手前先把被改的那个 core 文件另存一份 `<文件>.e4-access-log.orig`(**同名备份已存在时不覆盖**);要撤,就在上面那条命令后加 `--revert`(**手动**跑,详见下文「访问日志与核心补丁的总开关」)。⚠️ 撤法是"**删掉插进去的那几行**",不是把整份备份还原回去(备份只用来对拍:不一致时它会如实报 `⚠ 与备份不一致`)。**安装与升级本身既不先备份、也不会失败自动回滚**:插件只**读** profile 的 `package.json` 与 `cordis.patch.yml` 做自检(`tools/check-install.mjs`),**从不改写、也不备份**它们 —— 那两处改动是你手动做的,撤回也是手动(删掉那一行 + 撤依赖,见 `DESIGN.md` §10「回滚」)。想留后路,**动手前自己把这两个文件复制一份**。锚点漂移 / 歧义时脚本的行为是**一个字都不改**(安全失败),不是"改了再回滚"。
+
 > 发布名是 **`@nightpainters/dsh-ling`**,不是 `dsh-ling` —— npm 上 `dsh-ling` 这个名字已被他人占用。
 > 插件在配置里的注册 id 仍是 `dsh-ling`,两者不是一回事。
 
@@ -202,7 +206,7 @@ pnpm add file:<路径>/dsh-ling      # 或 npm install file:<路径>/dsh-ling
 #          name: '@nightpainters/dsh-ling'
 #    (id 保持 dsh-ling;name 用包名,Node 才解析得到代码)
 
-# 2) 给 DSH 核心打一行补丁(可取证访问日志要用;幂等/可回滚)
+# 2) 给 DSH 核心打一行补丁(可取证访问日志要用;幂等;这一页各步里**只有这一步**自带回滚)
 cd <路径>/dsh-ling
 node tools/apply-access-log-patch.mjs   # 只在 core 的 /api 栅栏处插一行可选调用
 #    不打也一切照常 —— 只是访问日志为空;但**会提醒**:侧栏挂常驻 ⚠(判据 installed===false 且 reason 为 patch-missing;只有**有意关掉** config.accessLog.enabled=false ⇒ reason 为 disabled-by-config 才不染红)
@@ -211,11 +215,13 @@ node tools/apply-access-log-patch.mjs   # 只在 core 的 /api 栅栏处插一
 # 3) 重启宿主(host),然后浏览器 Ctrl+Shift+R 硬刷
 ```
 
+> 备份与回滚的确切范围见上文路径 A 之后那段(要点:**只有核心补丁这一步可回滚**;安装本身既无自动备份、也无自动回滚)。
+
 自检安装是否成功(**下面四个脚本不在 npm 包内**,只有源码路径能用:`tools/check-install.mjs` / `tools/check-publish.mjs` / `tools/clean-archived.mjs` / `tools/check-peers.mjs`;`tools/apply-access-log-patch.mjs` 则**在包内**,从 npm 装的人也能直接跑,见上面第 3 步):
 
 ```bash
 node tools/check-install.mjs          # 只读自检:入口是否直连仓库、patch 是否启用、数据目录是否就绪
-node tools/check-install.mjs --fix    # 若入口变成"复制副本"(DSH 升级/回退常见)则备份并重挂链接
+node tools/check-install.mjs --fix    # 若入口变成"复制副本"(DSH 升级/回退常见)则改名备份为 <入口>.bak-<时间戳> 后重挂链接;⚠️ 重挂若失败,备份留在原地但**不会自动改回**,按它打印的 mklink /J 手动修
 node tools/apply-access-log-patch.mjs --check   # 访问日志核心补丁是否在位(未打/锚点漂移时退出码 2)
 node tools/check-publish.mjs          # 上传/发布前跑一次:揪出记忆库、设置、密钥、绝对路径等不该公开的东西
 node tools/check-peers.mjs            # 声明与宿主对不上?退出码三态:0 合规 / 1 有不合规(宿主会把本插件丢进 skippedBundles,不激活)/ 2 无法判定(2 不算通过)
@@ -427,11 +433,12 @@ npm test        # 43 套:人格组装(含冻结门 · L1 选择)/ 归档清理(
 
 | 文件 | 内容 |
 |---|---|
+| [`PHILOSOPHY.md`](./PHILOSOPHY.md) | **理念**:为什么值得做、凭什么这样做(目标循环 · 复盘与"人在循环" · 关系与边界 · 能力取舍) |
 | [`CHANGELOG.md`](./CHANGELOG.md) | 版本更新记录(最新一节即当前版本) |
 | [`DESIGN.md`](./DESIGN.md) | 架构与设计决策(三层记忆、冻结门、注入面、存储结构) |
 | [`ACCESS-DESIGN.md`](./ACCESS-DESIGN.md) | 历史接入蓝图:三条通道、会话契约格式、导入流水线 |
 
-> ⚠️ **从 npm 安装的人**:本包 `files` 白名单**不含 `images/`**(图只随 git 仓库公开) ⇒ 上表里前两份文档能正常打开;「界面」一节的**四张截图**引用的是仓库里的**绝对地址**,所以 npmjs.com 上**能正常显示**,但**包里没有图片文件**(离线环境读不到)。想看原图请到仓库:<https://github.com/NightPainters/DSH-Ling>。
+> ⚠️ **从 npm 安装的人**:本包 `files` 白名单**不含 `images/`**(图只随 git 仓库公开) ⇒ 上表里**四份文档**都随包发出(`PHILOSOPHY.md` · `CHANGELOG.md` · `DESIGN.md` · `ACCESS-DESIGN.md`),能正常打开;「界面」一节的**四张截图**引用的是仓库里的**绝对地址**,所以 npmjs.com 上**能正常显示**,但**包里没有图片文件**(离线环境读不到)。想看原图请到仓库:<https://github.com/NightPainters/DSH-Ling>。
 
 > 📄 **关于出处记录**:内部案卷、探针脚本与开发台账(`plans\`、`release\`、`_probe\`)属**作者本地开发物,不随本包公开**。正文或代码注释里若出现对它们的引用,那是**开发期的出处记录**,不是包内容。
 

package/lib/host/api.js

@@ -478,7 +478,9 @@ export function registerApi(ctx, deps, config) {
     ]);
     // ── 手术门下沉(2026-09-30 深夜;规格 §1.3「门下沉为一处」)──────────────────────────
     // 判据本体**只在** lib/host/surgery.js 的 requireSurgery() 里;这里只是**唯一**的调用点。
-    // 覆盖面 = 全部 12 条能改人格/规矩/习惯的写面(逐条清单见 surgery.js 头部注释):挂在 guard(handler)
+    // 覆盖面 = 全部 14 条能改人格/规矩/习惯的写面(逐条清单见 surgery.js 头部注释):挂在 guard(handler)
+    //   ⚠️ 条数 2026-10-05 夜由 12 订正为 14(B-5):清单逐条列了 14 行,而这里与 surgery.js:15 一直写"12"
+    //      ⇒ 三处不一致的根源是"没人拿清单行数当唯一真值"。现口径:**以清单行数为准**,改清单须同批改这两处。
     // 上就"一眼看全、零回归面",与 POST_ONLY / 413 出口同一个取舍 —— 而不是在 49 个 register 调用点各写一遍。
     // 安全的位置:本调用在 POST_ONLY(405)与 guardVerdict(403)**之后** ⇒ 被挡下的请求绝不会走到 handler。
     // ⚠️ 承诺句必须**惰性**取:多数写端点的载荷由 `await readBody(req)` 消费,而请求流**只能读一次** ——
@@ -2303,7 +2305,17 @@ export function registerApi(ctx, deps, config) {
 
     // POST /persona/habits/scan  通道 A:零模型,扫"跨会话重复出现的纠正"→ 落成习惯候选(待确认)
     //   阈值:同类纠正 ≥4 次 且 跨 ≥3 个会话(单次会话里被说三遍不算模式;口径与变更记录见 habit-gen.js 的 SCAN_DEFAULTS)
-    disposers.push(register('/persona/habits/scan', async (_req, res) => {
+    disposers.push(register('/persona/habits/scan', async (req, res) => {
+      // ── 手术门(A-1,2026-10-05 夜;交办单 HANDOFF-机制面复核交办单 §A-1)──────────────────
+      //   ⚠️ 本端点**会写 `habitsPending`** ⇒ 它进的是**人格面** ⇒ 按 P-5 第 5 条必须过闸。
+      //   改前它是 12 条清单外的漏点:确认侧 `/persona/habit`(:2276)**过门**,而两条**产出候选**
+      //   的写面(`scan` / `reflect`)不过门 —— 一条通路的两半只改了一半,正是
+      //   DESIGN §0.1 工程理念 9「两半同批」的反例(2026-10-05 机制面复核 A-1)。
+      //   接线形状照抄 `/persona/habit`:必须先 `readBody` 再判门(请求流只能读一次,门要拿
+      //   `unlock` 原句);空 body 用 `|| '{}'` 兜住(面板按钮不带 body)。
+      //   判据本体仍**只在** `surgery.js` 的 `requireSurgery()` 一处,这里只接线、不重判。
+      const body = JSON.parse((await readBody(req)) || '{}');
+      if (!gateSurgery(req, res, sendJson, { unlock: body.unlock }, { settings, logFile: surgeryLog, endpoint: '/persona/habits/scan' })) return;
       try {
         // 上限(2026-09-16 定案):待确认满了就**明确驳回**,并说明为什么 —— 不排队、不静默丢弃。
         const capS = pendingMaxOf(settings);
@@ -2341,7 +2353,13 @@ export function registerApi(ctx, deps, config) {
 
     // POST /persona/habits/reflect  通道 B:让她"回想最近的相处" → 1~5 条习惯候选(一次 LLM,只提议不落盘)
     // 手动触发,材料给足:主人真人原话 + 记忆概述 + 纠正统计 + 她现状(默认预算 20 万字符,可用 settings.habits.reflect* 覆盖)
-    disposers.push(register('/persona/habits/reflect', async (_req, res) => {
+    disposers.push(register('/persona/habits/reflect', async (req, res) => {
+      // ── 手术门(A-1,同 scan;两处必须同批改 —— 它们共享 `proposeHabit` 这一半)──────────
+      //   `reflect` 的候选经 `parseReflect` → `proposeHabit`(:2436)落进 `habitsPending` ⇒ 同属写面。
+      //   注意它另有 kv 写入(`habits.reflect.cursor` / `.last` / `.debug`)—— 那些是**运行记录**,
+      //   不是人格面内容 ⇒ 单独看它们不构成"必须过门"的理由;过门的理由是候选落进人格面。
+      const body = JSON.parse((await readBody(req)) || '{}');
+      if (!gateSurgery(req, res, sendJson, { unlock: body.unlock }, { settings, logFile: surgeryLog, endpoint: '/persona/habits/reflect' })) return;
       try {
         // 上限(2026-09-16 定案):与 scan 同一条规则 —— 满了明确驳回,不排队、不静默丢弃。
         const capR = pendingMaxOf(settings);

package/lib/host/deep-index-skill.js

@@ -48,6 +48,15 @@ export const INDEX_SKILL_CONTENT = `# 深层库索引 · 我记住的事分 11
 - 想知道一条结论的**原话** ⇒ 条目回执里带 \`conv\` 与 \`#序号\`,用 \`recall({ conv, from, to })\` 取那几轮
 - 按时间浏览 ⇒ \`recall()\` 不带参数,列出磁盘上有原文的会话
 
+## 条目还带一个「类」(kind)
+每条结论都标了它是哪一种:**承诺 / 决定 / 事实 / 偏好 / 关系 / 纪律**。
+上面的 11 **主题簇**回答"这事关于什么",这里的 **kind** 回答"这是哪一种话" —— 两个维度,不冲突。
+
+**纪律**是其中最特别的一类:一次拍板,管的是**以后每一次**。它进库要同时满足三条 ——
+① 来源是主人授权的一句指令;② 作用对象是**行为**;③ **违反时能被某条判据红出来**。
+三条缺一条就退回收在别处(不进这里):答不出"哪条判据会红"的,只是一句话,不是纪律。
+⇒ 看到 \`[纪律]\` 开头的条目,可以按"这是必须遵守的"来对待,而不只是"他说过一次"。
+
 ## 11 类与触发线索
 
 | 类 | 这一簇装什么 | 触发线索 |

package/lib/host/l1.js

@@ -168,7 +168,12 @@ const DURABILITY_BONUS = { durable: 0.6, long: 0, ephemeral: 0 };
  *  「某插件的档位细节」(偏好)两条"不该在这里" —— 它们都是**关于事**的;而器灵最该先看见的
  *  是**关于人**的(承诺/关系/偏好)。⇒ 用 `kind` 把这两类分开,不必新增字段。
  *  ⚠️ 这是本夜新加的判据(主人未逐字拍过)⇒ 值可调、可整体否掉;`hit`(+1.0)仍是最强信号。 */
-const KIND_WEIGHT = { 承诺: 0.4, 关系: 0.3, 偏好: 0.2, 决定: 0.1, 事实: 0 };
+const KIND_WEIGHT = { 承诺: 0.4, 纪律: 0.35, 关系: 0.3, 偏好: 0.2, 决定: 0.1, 事实: 0 };
+// 「纪律」= 2026-10-05 夜主人裁决新增的**第六类**(原话口径:**决定管一次,纪律管以后每一次**;
+//   进库三条判据写在 `memory.js` 的 `deep_item.kind` 列注释里)。
+//   权重取 0.35 —— **高于关系、略低于承诺**:它与承诺同族(都是"我说过的话"),
+//   但承诺是对某件事的,纪律是对**我的行为**的;留一点差距,是为了关键词打平时仍让
+//   "对主人的承诺"排在前面。可调、可整体否掉(与上一条注释同一口径)。
 /** **同源限额**:同一次会话最多进 N 条(置顶不受此限)。见 `selectL1` 里的同源循环。 */
 const MAX_PER_CONV = 2;
 
@@ -203,6 +208,9 @@ export function explainScore(x) {
     //   分项之间是加法,`血缘`/`矛盾` 是**乘数**,不能混进加法列表。
     const mult = [`× 血缘${f(x.lineage)}`];
     if (Number(x.conf ?? 1) < 1) mult.push(`× 矛盾${f(x.conf)}`);
+    // A-5(2026-10-05):枝系数是**第三个乘数**(`raw × 血缘 × 矛盾 × 枝系数`)。默认 1 时不印
+    //   (留痕与接线前逐字相同);一旦有人调过枝系数就必须印 —— 否则留痕与公式不符,又是说谎。
+    if (Number(x.scale ?? 1) !== 1) mult.push(`× 枝系数${f(x.scale)}`);
     return `(${bits.join(' + ')}) ${mult.join(' ')} ⇒ ${f(x.score, 3)}`;
   }
   const bits = [];
@@ -219,6 +227,7 @@ export function explainScore(x) {
   //   现在显式写成 `(分项和) × 血缘 × 矛盾 ⇒ 总分`,让留痕与公式一一对得上。
   const mult = [`× 血缘${f(x.lineage)}`];
   if (Number(x.conf ?? 1) < 1) mult.push(`× 矛盾${f(x.conf)}`);
+  if (Number(x.scale ?? 1) !== 1) mult.push(`× 枝系数${f(x.scale)}`); // A-5:同概述路,见上
   return `(${bits.join(' + ')}) ${mult.join(' ')} ⇒ ${f(x.score, 3)}`;
 }
 
@@ -339,6 +348,39 @@ export function selectL1(store, opts) {
   //   `0.7^5=0.168`、`0.4^5=0.010`,连乘会让深枝等于从记忆里消失(见 `memory.js` 的 `LINEAGE_*`)。
   //   条目沿用同一把尺:血缘与矛盾降权都按 `source|conv_id` 索引,与"选的是概述还是条目"无关。
   const ctx = lineageContext(store, o.sessionId);
+  // ── A-5(2026-10-05 夜 · 主人拍板走 (b)):枝系数**接回打分** ──────────────────────────
+  //   语义:一条记忆的枝 = **它来源会话所在的枝**。**不是**读 `deep_item.branch_id` ——
+  //   真库实测 **393/393 条全为空**(schema 注释早写明"记忆树是空间维度、深层库是内容维度,
+  //   条目不隶属任何枝"),照那个字段接等于"接了也没接"。走会话归属才有意义:
+  //   dsh 侧实测主干 73 / 开发日志 25 / 运维排障 18 / 日常 4,非 dsh 侧已挂枝 34、未挂枝 179。
+  //   取值:默认 1.0 ⇒ **接线当下零行为变化**(实测全库 20 条枝的 weight_scale 全是 1);
+  //   复盘期调过谁,谁的记忆才在开场里前后移动 —— 这就是 `README` U-10「装饰性交互要么真生效、
+  //   要么删掉」要的那个"真生效"。
+  //   ⚠️ 它乘在**最后**一项(`raw × 血缘 × 矛盾 × 枝系数`),与 `LINEAGE_*` 同一层:*打对折*,
+  //     不是"禁用"(禁用是 forget / `ephemeral` 的事)。区间夹在 [0,2] 与 `setBranchWeight` 同口径。
+  //   ⚠️ 零开销路径:全库枝系数都是 1 时**连映射都不建**(`branchScale.size === 0` ⇒ 不查库)。
+  const branchScale = (() => {
+    const m = new Map();
+    try {
+      const rows = typeof store.listBranches === 'function' ? store.listBranches() : [];
+      for (const b of rows) {
+        const w = Number(b?.weightScale);
+        if (Number.isFinite(w) && w !== 1) m.set(String(b.id), Math.min(2, Math.max(0, w)));
+      }
+    } catch { /* 读不到枝表 ⇒ 全按 1.0(与接线前逐字同解) */ }
+    return m;
+  })();
+  const branchOfRow = (() => {
+    if (!branchScale.size) return null;
+    const convMap = (typeof store.convBranchMap === 'function' ? store.convBranchMap() : new Map());
+    const sessMap = (typeof store.sessionBranchMap === 'function' ? store.sessionBranchMap() : new Map());
+    return (src, convId) => {
+      const k = String(src) + '\u0000' + String(convId);
+      if (convMap.has(k)) return String(convMap.get(k));
+      if (String(src) === 'dsh') return String(sessMap.get(String(convId)) || TRUNK_BRANCH);
+      return TRUNK_BRANCH; // 非 dsh 且未显式挂枝 ⇒ 主干(与 `branchOfConv` 同解)
+    };
+  })();
   // 1.6-A 投递留痕:过滤口径必须**可报告**。原来是一条 `.filter()` 链 —— 丢了多少、为什么丢,
   //   出了函数就查不到(只剩 `dropped` 一个净差)。改成显式循环,顺手留下三类计数:
   //   archived / forgotten 是**主动排除**(主人的明确动作),zero 是"算不出正分"(无信息量)。
@@ -373,14 +415,16 @@ export function selectL1(store, opts) {
         + Math.min(KW_BONUS_CAP, kw * KW_BONUS_PER_HIT)
         + RECENCY_W * recency;
       const pinned = Number(row.pinned ?? 0) === 1;
-      x = { row, score: raw * lineage * conf, lineage, raw, hit, kw, recency, conf, pinned, dur, durBonus, kindW, useDeep };
+      const scale = branchOfRow ? (branchScale.get(branchOfRow(srcOf, row.conv_id)) ?? 1) : 1;
+      x = { row, score: raw * lineage * conf * scale, lineage, raw, hit, kw, recency, conf, pinned, dur, durBonus, kindW, scale, useDeep };
     } else {
       const heat = computeHeat(row, now, {});
       const catW = weights[row.category] ?? weights.daily ?? 0.5;
       const kw = kwOverlap(o.keywords || [], row.keywords);
       const rich = summaryWeight(row) * summaryBonus;
       const raw = catW * heat + Math.min(KW_BONUS_CAP, kw * KW_BONUS_PER_HIT) + (row.importance >= 1 ? 0.8 : 0) + rich;
-      x = { row, score: raw * lineage * conf, lineage, raw, heat, catW, kw, rich, conf, pinned: false, useDeep };
+      const scale = branchOfRow ? (branchScale.get(branchOfRow(srcOf, row.conv_id)) ?? 1) : 1;
+      x = { row, score: raw * lineage * conf * scale, lineage, raw, heat, catW, kw, rich, conf, pinned: false, scale, useDeep };
     }
     // 置顶是**必进**的(主人的明确动作)⇒ 即使分数算不出正分也不丢;其余零分者视为无信息量。
     if (!(x.score > 0) && !x.pinned) { excluded.zero += 1; continue; }

package/lib/host/lifecycle.js

@@ -56,6 +56,17 @@ export function wireLifecycle(ctx, gate, memory, settings, config) {
   memory.kvSet('dbg.first_event_sample', '');
   memory.kvSet('dbg.event_no_session', '');
   memory.kvSet('dbg.event_stats', '');
+  // ⚠️ P5①(蓝队 2026-10-04):上面三家清了,`dbg.diff_stats` 却漏了 —— 于是差分路的读数会
+  //   **跨重启残留**:新进程还没跑过任何一轮差分,诊断里却躺着一个旧时间戳的"本轮画像",
+  //   看起来像"刚跑过、结果是这样"。它现在和另外三家同批清。
+  memory.kvSet('dbg.diff_stats', '');
+  // ⚠️ P5③(同一处):`evStats` 是**模块级**对象,只在模块加载时归零 —— 同一进程里若二次
+  //   `wireLifecycle`(换配置重载插件),计数会在上一轮的基数上继续累加,而 kv 里写的是"本轮"。
+  //   归零点放到这里,与 kv 的清理**同一时点**,两者才同义。
+  evStats.seen = 0; evStats.kept = 0; evStats.dropType = 0; evStats.dropSource = 0;
+  evStats.dropEmpty = 0; evStats.dropNoSession = 0; evStats.dropSubagent = 0;
+  evStats.types = {}; evStats.lastSid = '';
+  evStatsDirty = 0; evStatsAt = 0;
   memory.kvSet('lifecycle.wired', '1');
 
   const inTrackedWorkspace = () => {

package/lib/host/memory.js

@@ -167,7 +167,7 @@ CREATE TABLE IF NOT EXISTS branch (
   fork_at      TEXT,
   fork_seq     INTEGER,
   name_locked  INTEGER NOT NULL DEFAULT 0,
-  -- ⚠️ 预留字段(审计 A#11,2026-09-22):weight_scale / visibility 目前**只存与显示**,
+  -- weight_scale 自 1.6.2 起**参与检索打分**(见 setBranchWeight);visibility 仍是预留字段(只存与显示),
   -- **不参与任何打分**(L1 的 score 只看血缘档位 × 矛盾系数)。让它们真正生效会改变检索排序语义,
   -- 须主人拍板后再动;在那之前返回体里带 applied=false 标记,免得界面把"存了"当成"生效了"。
   weight_scale REAL NOT NULL DEFAULT 1.0,
@@ -304,7 +304,13 @@ CREATE INDEX IF NOT EXISTS inject_log_session ON inject_log(session_id);
 --   且**枝侧可反向引用条目**(气根供养树):一条枝能列出供养过它的条目,而条目的增删**不改动树结构**。
 CREATE TABLE IF NOT EXISTS deep_item (
   id            TEXT PRIMARY KEY,              -- 'di:' + uuid(与记忆树 br: 同风格;带前缀便于眼认)
-  kind          TEXT NOT NULL,                 -- commitment | decision | fact | preference | relation | todo
+  kind          TEXT NOT NULL,                 -- 承诺 | 决定 | 事实 | 偏好 | 关系 | 纪律(中文,1.6 实存值)
+                                               --   ⚠️ **纪律**是 2026-10-05 夜主人裁决新增的第六类(见 §D 的裁定):
+                                               --   与"决定"的区别是**决定管一次、纪律管以后每一次**。进库三条判据
+                                               --   (缺一条就退回收 kv / plans,不许进库):① 来源是**主人授权的一句指令**;
+                                               --   ② 作用对象是**行为**(与 README R-3 的"规矩"同族);③ **违反时能被判据红出来**
+                                               --   —— 答不出"哪条判据会红"就不是纪律,只是一句话(与 F-26 同一条线)。
+                                               --   注:列本身**无 CHECK 约束**(TEXT NOT NULL),故加这一类**不需要改 schema**。
   text          TEXT NOT NULL,                 -- 一句话 ≤80 字:它是**装配单元**(开场要从里面挑),必须独立读懂
   at            TEXT NOT NULL DEFAULT '',      -- 发生时间(取自原文那一轮;UTC ISO —— 与 dsh_turns_raw.ts 同口径)
   conv_id       TEXT NOT NULL DEFAULT '',      -- 来源会话(裸 id 或带命名空间前缀,与 conv_overview.conv_id 同口径)
@@ -637,12 +643,11 @@ export class MemoryStore {
 
   /** 全部枝(含主干)。
    *
-   *  ⚠️ 预留字段(审计 A#11,2026-09-22 定为方案 b):`weightScale` / `visibility`
-   *  目前**只存只显示,不参与任何打分** —— L1 的分数是 `raw × 血缘档位 × 矛盾系数`,
-   *  血缘档位由 `lineageWeightMap` 按树结构算(1.0 / 0.7 / 0.4),与这两个字段无关。
-   *  改语义(让权重真正乘进检索分)会改变所有既有记忆的排序结果,**需主人拍板**,
-   *  故这里不擅自改打分,只在返回体里如实标明 `weightScaleApplied/visibilityApplied = false`,
-   *  让界面与调用方知道"调了它也没用",避免把预留字段当成已生效的旋钮。 */
+   *  ✅ **A-5(2026-10-05 夜 · 主人拍板走方案 b):`weightScale` 已接回检索打分** ——
+   *  L1 的分数是 `raw × 血缘档位 × 矛盾系数 × 枝系数`,故这里如实标 `weightScaleApplied: true`。
+   *  ⚠️ `visibility` **仍是预留字段**(本次只拍了权重):它只存只显示,标 `visibilityApplied: false`,
+   *  界面不要给它做"生效中"的暗示。
+   *  历史:审计 A#11(2026-09-22)曾把两者一起定为"只存只显示";本次只解开权重那一半。 */
   listBranches() {
     try {
       return this.db.prepare('SELECT * FROM branch ORDER BY created_at, id').all().map((r) => ({
@@ -655,8 +660,8 @@ export class MemoryStore {
         nameLocked: Number(r.name_locked || 0),
         weightScale: Number(r.weight_scale ?? 1),
         visibility: String(r.visibility || 'lineage'),
-        // 预留标记:见上方注释(审计 A#11)。界面不要给这两个字段做"生效中"的暗示。
-        weightScaleApplied: false,
+        // A-5:权重已生效(见方法注释);visibility 仍为预留。
+        weightScaleApplied: true,
         visibilityApplied: false,
         status: String(r.status || 'active'),
         createdAt: r.created_at ? String(r.created_at) : null,
@@ -937,10 +942,9 @@ export class MemoryStore {
   /** 复盘期权重调节(平时只读 —— 设计稿 §3.3)。scale 夹在 [0,2]。
    *
    *  ⚠️ 预留字段(审计 A#11,2026-09-22 定为方案 b):写进去的 `weight_scale`
-   *  **当前不参与检索打分**(L1 = raw × 血缘档位 × 矛盾系数)。保留写入与显示,
-   * 是为了不破坏"复盘期可调"的界面与既有数据;但返回体里明确带
-   * `applied:false` + `note`,避免调用方(与主人)误以为检索排序已经跟着变。
-   * 让它真正生效属于**改变检索语义**,需主人拍板(方案 a),不在本次审计修法内。 */
+    *  **A-5(2026-10-05 夜 · 主人拍板走方案 b):已接回检索打分** —— L1 = `raw × 血缘档位 × 矛盾系数 × 枝系数`。
+   * 历史:审计 A#11(2026-09-22)曾把权重与可见性一起定为"只存只显示";本次只解开权重那一半
+   * (可见性仍是预留字段,见 `listBranches`)。 */
   setBranchWeight(branchId, scale) {
     const bid = String(branchId || '');
     // ⚠️ 先判**类型**再取数(蓝队 2026-10-04):`Number(null) === 0`、`Number(true) === 1`、
@@ -954,7 +958,8 @@ export class MemoryStore {
     this.db.prepare('UPDATE branch SET weight_scale=?, updated_at=? WHERE id=?').run(clamped, utcIso(), bid);
     return {
       ok: true, id: bid, weightScale: clamped,
-      applied: false, note: 'weight_scale 为预留字段:已写入并显示,当前不参与检索打分',
+      applied: true,
+      note: '已生效:该枝的结论在记忆开场里按此系数加权(1.0 = 不偏不倚,0 = 排到最后;不是禁用)',
     };
   }
 

package/lib/host/persona.js

@@ -85,7 +85,6 @@ export const DEFAULT_SETTINGS = Object.freeze({
     // ⚠️ 这是**内存态**设置(`settings-file.js` 的 get() 每轮读),面板 update() 立即改 ⇒ 不用重启宿主。
     sessionProgressLine: true,
   },
-  updates: { applyWhileRunning: false }, // D4 语义固化:默认冻结
   guard: {              // /api 守卫(2026-09-16 加固 ①+②;2026-09-17 加固 ③)
     enforce: true,        // false = 关掉来源栅栏与名字对撞(逃生开关;亦可用 DSH_LING_GUARD=off)
     trustedHosts: [],     // 显式受信的 authority 列表;loopback 恒受信,本机 LAN 地址**不再自动信任**

package/lib/host/rawlog.js

@@ -16,10 +16,9 @@
 //     实测 **516 帧扫描 1ms + 全量解压解析 53ms**(相对暴力法快约 2200 倍)。
 //     抄而不 import 的理由:不把插件绑到宿主内部包上(那是 P3 的劣,主人 2026-10-04 拍「先 P2」)。
 import fs from 'node:fs';
-import os from 'node:os';
 import path from 'node:path';
 import { zstdDecompressSync, constants as zc } from 'node:zlib';
-import { isMemoryEligibleHeader } from './util.js';   // F3(2026-10-04):真人判据要按**会话级**分通道
+import { isMemoryEligibleHeader, dshHome } from './util.js';   // F3(2026-10-04):真人判据要按**会话级**分通道
 
 /** Zstandard 帧魔数(小端读作 UInt32LE 时的值)。 */
 const ZSTD_MAGIC = 0xfd2fb528;
@@ -46,9 +45,15 @@ function findLogIn(dir) {
   return null;
 }
 
-/** 会话根目录: ~/.dsh/sessions。 */
+/** 会话根目录: `$DSH_HOME/sessions`(未设时 `~/.dsh/sessions`)。
+ *  ⚠️ 2026-10-05 修正(A-4,交办单最后一处漏点):本函数原先是 `join(os.homedir(), '.dsh', 'sessions')`
+ *  —— 绕过 `$DSH_HOME`,是全仓最后一处这么写的地方(`backfill.js:45-51` 记着另两处早在
+ *  2026-09-29 就统一到 `dshHome()` 了)。不设 `DSH_HOME` 时两者等价,**缺陷因此长期隐身**;
+ *  一旦设了(导入测试台就是靠它做隔离,`DESIGN-导入测试台.md:25` 明写"`DSH_HOME` 层面隔离才有效"),
+ *  这里就会去读**真机**会话目录 —— 不报错、只读,但结论不可复现,还会把真历史灌进测试库。
+ *  现统一到 `dshHome()`(= `$DSH_HOME` 优先,否则 `~/.dsh`),与扫描侧/取原文侧同源。 */
 export function sessionsRoot() {
-  return path.join(os.homedir(), '.dsh', 'sessions');
+  return path.join(dshHome(), 'sessions');
 }
 
 /**
@@ -234,8 +239,14 @@ export function dialogTurns(events) {
   //   子代理种子 387 条 **true→false 回归 0**。
   let sessionEligible = null;
   for (const e of evs) {
-    if (e && typeof e === 'object' && e.type === 'session' && e.header) {
-      sessionEligible = isMemoryEligibleHeader(e.header);
+    if (e && typeof e === 'object' && e.type === 'session') {
+      // ⚠️ **踩坑(2026-10-04,实测抓出)**:`session` 事件里**没有 `header` 子对象** ——
+      //   判据要的字段(`id` / `parentSession` / `delegationDepth` / `origin`)就**平铺在事件顶层**
+      //   (`{"type":"session","version":4,"id":"feishu-…","cwd":"…","isSeeded":false,"delegationDepth":0,"agentPreset":"standard"}`)。
+      //   第一版写成 `isMemoryEligibleHeader(e.header)` ⇒ 恒为 `undefined` ⇒ `sessionEligible` 永远取不到
+      //   ⇒ 判据退回 ⑤(只认 rpcId)⇒ **全盘净增 0、F3 一行没生效**,而注释里却写着"已修"。
+      //   所以这里传**事件本身**(兼容将来真加了 `header` 的形态)。
+      sessionEligible = isMemoryEligibleHeader(e.header ?? e);
       break;
     }
   }

package/lib/host/recall-search.js

@@ -24,14 +24,49 @@
 import { isMemoryEligibleHeader, sessionKind } from './util.js';
 import { localStamp, oneLine } from './rawlog.js';
 
-/** 一页几个会话(默认)。 */
-export const SEARCH_HITS_DEFAULT = 10;
+/** 一页几个会话(默认):**5 条**(2026-10-05 主人拍板 B2,原为 10)。
+ *  起因:实测"搜什么都中今天" —— 全文索引里**当前会话自己**也在,任何词都能命中几十秒前刚打的那句话,
+ *  而原文层默认 10 行会把上面的**条目层**(结论,一句话说完)挤到看不见。砍到 5 条让条目重新占视觉重心;
+ *  要更多**显式传 `limit`**(上限 50 不变,想翻就翻)。 */
+export const SEARCH_HITS_DEFAULT = 5;
 /** 一页几个会话(上限):给模型的是"下一步去哪",不是把库倒出来。 */
 export const SEARCH_HITS_MAX = 50;
 /** 单条摘要的显示字数 —— **报短摘要而不是 id**(2026-10-04 生态复核:同生态对手的 README 逐字
  *  「查 id 是什么的那一步最容易省略,省略了就等于没报」)。这一条是本次复核直接抄来的。 */
 export const SEARCH_SNIPPET_CHARS = 160;
 
+/** 宿主检索的**超时上限**(2026-10-05,主人定 20 秒)。
+ *
+ *  为什么必须有它:宿主的懒对账(`_reconcile` → `_observeStable`)是**串行化**的。一旦撞上卡住的对账,
+ *  `searchSessions` 就**一直不返回** —— 实测有一次挂了 **约 30 分钟**,而当时**没有任何中断入口**:
+ *  GUI 没有,工具层也没有。按本项目理念(「逃生开关永远可用」),**"不可中断"本身就该按最严重一级对待**,
+ *  与它挂了多久无关。
+ *  ⇒ 我们改不了宿主(拿不到取消口),但可以**不给它无限期**:超时后放弃原文层,并**照样把条目层交出去**
+ *  (条目是本地 SQLite,毫秒级,完全不受宿主影响)。
+ *  ⚠️ 别调小到 5 秒以下:一次"慢但对"的检索比"快速失败"有用得多;
+ *  也别指望它治并发 —— 并发撞对账是宿主侧的事,这里只保证**任何一次都不会挂死**。 */
+export const SEARCH_TIMEOUT_MS = 20000;
+
+/**
+ * 给 Promise 套超时(纯函数,可单测)。
+ * ⚠️ 超时**不取消**底层操作(宿主没给取消口),只是我们不再等它;它之后若返回,结果被丢弃 ——
+ *   检索是只读的,丢弃不影响任何状态。
+ * @returns `{ok:true, value}` | `{ok:false, reason:'timeout', ms, label}`
+ */
+export function withTimeout(promise, ms, label = '检索') {
+  const limit = Math.max(1, Number(ms) || SEARCH_TIMEOUT_MS);
+  let timer = null;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(() => resolve({ ok: false, reason: 'timeout', ms: limit, label }), limit);
+    // 别让这个定时器拖住进程退出(工具层常在短命进程里被调用)
+    if (typeof timer?.unref === 'function') timer.unref();
+  });
+  return Promise.race([
+    Promise.resolve(promise).then((value) => ({ ok: true, value })),
+    timeout,
+  ]).finally(() => { if (timer) clearTimeout(timer); });
+}
+
 /** 条数夹取(纯函数,便于单测)。 */
 export function clampSearchLimit(n) {
   const v = Math.floor(Number(n));
@@ -71,6 +106,71 @@ export function searchDeepItems(memory, q, limit = SEARCH_DEEP_MAX) {
   } catch { return []; }
 }
 
+/** 检索档本地原文层一次最多带出几轮(默认同 `SEARCH_HITS_DEFAULT`)。 */
+export const SEARCH_LOCAL_TURNS_MAX = 50;
+
+/**
+ * 在**我们自己的库**里按内容搜原文轮(`dsh_turns_raw`)—— 检索档的**默认**原文来源。
+ *
+ * 为什么默认走这里(2026-10-05 夜 · 主人拍板方案 A):
+ *   宿主 `sessionQuery` 的每次搜索都会做一遍**全量对账**(`_observeStable` 里 list 两遍、
+ *   最多重试 2 轮),实测**每次都超过 20 秒**(重启后第一次也一样),而这边的
+ *   同一个查询只要 **2~45 毫秒**。快的设成默认、慢的降级成显式选项,是这一档的取舍。
+ *   ⚠️ 代价**必须如实报出去**:库里这份原文是**残的** —— capture 侧只收"真人消息 +
+ *   有正文的回复",所以我自己的长回复**中段**搜不到。回执里要写明这一层是"库内原文层"。
+ *
+ * 与 `searchDeepItems` 同解的三条(不另立口径):多词 = **AND**;词里的 `% _ \` 先剥掉;
+ * 表不存在时**静默返回空**(检索面不该因为某张表缺席而整体失败)。
+ *
+ * @param {object} memory  MemoryStore
+ * @param {string} q       查询词(空格分隔 = 同时满足)
+ * @param {number} limit   最多几轮
+ * @param {object} [opts]  `{ selfId, callName, includeSelf }` —— `selfId` 是当前会话 id;
+ *   **默认把它整条排除**(见下方注释),要看自己刚说的传 `includeSelf:true`(那时它排到最后并标 `isSelf`)
+ * @returns `{{rows:object[], selfExcluded:number}}` —— `selfExcluded` 是**因为"是本会话"而被排除的条数**,
+ *   调用方**必须把它报出去**:不说就会被读成"库里只有这些"(那是说假话)
+ */
+export function searchLocalTurns(memory, q, limit = SEARCH_HITS_DEFAULT, { selfId = '', callName = '主人', includeSelf = false } = {}) {
+  const db = memory?.db;
+  if (!db?.prepare) return { rows: [], selfExcluded: 0 };
+  const words = String(q || '').trim().split(/\s+/).map((w) => w.replace(/[%_\\]/g, '')).filter(Boolean);
+  if (!words.length) return { rows: [], selfExcluded: 0 };
+  const cap = Math.max(1, Math.min(SEARCH_LOCAL_TURNS_MAX, Number(limit) || SEARCH_HITS_DEFAULT));
+  let rows;
+  try {
+    const where = words.map(() => "text LIKE ? ESCAPE '\\'").join(' AND ');
+    rows = db.prepare(
+      `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 }; }
+  const self = String(selfId || '');
+  const mapped = rows.map((r) => {
+    const id = String(r.session_id ?? '');
+    const role = String(r.role ?? '');
+    const isUser = role.startsWith('user');
+    // 命中位置附近截一段(而不是从头截):词可能出现在长回复的中间
+    const text = String(r.text ?? '');
+    const at = words.map((w) => text.indexOf(w)).filter((i) => i >= 0).sort((a, b) => a - b)[0] ?? 0;
+    const from = Math.max(0, at - 40);
+    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),
+      isSelf: Boolean(self) && id === self,
+    };
+  });
+  // ⚠️ **本会话默认排除**(2026-10-05 夜 · 主人拍板):它就在库里、而它的话又最新 ⇒ 任何词都能命中它,
+  //   把要回溯的历史**整页挤掉** —— 真机实测「检索」10 条里 9 条是本会话;光把它排到末尾只治了"占头部",
+  //   没治"占位"。而"我刚说过什么"**根本不需要搜**:它就在我的上下文里;
+  //   搜索这个动作的全部意义是回溯**我这里没有的**东西。要看自己刚说的传 `includeSelf:true`。
+  //   ⇒ 排除的条数**如实报出去**(`selfExcluded`),不说就会被读成"库里只有这些"。
+  const kept = includeSelf ? mapped : mapped.filter((r) => !r.isSelf);
+  const selfExcluded = includeSelf ? 0 : mapped.length - kept.length;
+  return { rows: kept.sort((a, b) => Number(a.isSelf) - Number(b.isSelf)), selfExcluded };
+}
+
 /**
  * 从 `listSessions()` 的记录里造「主人自己的会话」id 集(纯函数)。
  * 拿不到 header 的**不放入** —— 宁少不滥,这是可见性过滤,不是统计。
@@ -123,8 +223,9 @@ export function visibleIdSet(records) {
  * @param all 越界开关(D6:显式才生效)
  * @returns `{ rows, skipped }` —— `skipped` 是**被范围挡掉**的条数,必须报出来(不静默丢)
  */
-export function toSearchRows(hits, { visible = null, all = false, callName = '主人' } = {}) {
+export function toSearchRows(hits, { visible = null, all = false, callName = '主人', selfId = '' } = {}) {
   const rows = [];
+  const self = String(selfId || '');
   let skipped = 0;
   for (const h of hits || []) {
     const header = h?.header ?? {};
@@ -140,8 +241,14 @@ export function toSearchRows(hits, { visible = null, all = false, callName = '
       time: m.time ? localStamp(m.time) : '',
       who: isUser ? callName : '鱼姬',
       snippet: oneLine(m.snippet || '', SEARCH_SNIPPET_CHARS),
+      isSelf: Boolean(self) && String(id) === self,
     });
   }
+  // ⚠️ 本会话排到最后(2026-10-05 主人拍板 C):**当前会话自己也在索引里**,于是"搜什么都中今天" ——
+  //   任何词都能命中几十秒前刚打的那句话,而它排在头一条,把要回溯的历史全挤下去。
+  //   **不删**它(有时确实要找自己刚才那句),只挪到末尾并标注「← 本会话」。
+  //   `sort` 在 V8 上是**稳定**的 ⇒ 其余命中保持宿主的原序(相关性+新近),不打乱。
+  if (self) rows.sort((a, b) => Number(a.isSelf) - Number(b.isSelf));
   // ⚠️ `degraded`(蓝队 2026-10-04 抓到 P3):宿主**没有** `listSessions` 时,`visible` 恒为 null
   //   ⇒ 范围限制**整条失效**(一条不挡),而回执却仍写着"已在主人自己的会话内" —— 那是**说假话**。
   //   取舍(主代理 2026-10-04 定):**保持 fail-open 但如实标注** —— 完全禁用会让"按内容找会话"
@@ -171,6 +278,14 @@ export function renderSearch(v) {
       ? '⚠️ **没能限定范围** —— 宿主这次没给 `listSessions`,所以下面这份结果**可能含子代理或其它会话**,'
         + '不是"只搜主人自己的会话"(范围限制这条通道暂时失效,不是"库里只有这些")'
       : '已在「**主人自己的会话**」内(默认范围)');
+  // ⚠️ **原文来源必须看得出来是哪一个**(2026-10-05 夜 · 主人拍板方案 A):
+  //   两条路覆盖面**不一样**,不说清就会被读成"库里只有这些"。
+  //   · 本地(默认):库内原文层 —— 只含"真人消息 + 有正文的回复"(capture 侧就这么收的),
+  //     我自己的长回复**中段搜不到**;代价换来的是 **2~45 毫秒**(实测)。
+  //   · 宿主(显式 hostSearch):覆盖全部事件,但每次**全量对账**、实测**每次 >20 秒**。
+  const layerNote = v.local
+    ? '(原文来源:**本机库内原文层** —— 只含真人消息与有正文的回复,毫秒级;要全量检索请传 hostSearch=true)'
+    : '';
   const hitRows = Array.isArray(v.rows) ? v.rows : [];
   const deepRows = Array.isArray(v.deep) ? v.deep : [];
   // 条目排在前:它是**结论层**(一句话说完),会话在后(要下钻才知道内容)。
@@ -186,22 +301,45 @@ export function renderSearch(v) {
     }).join('\n') + '\n\n'
     : '';
   if (!hitRows.length && !deepRows.length) {
-    return `按内容没找到(查询「${v.q}」· ${scope})。`
+    // 超时是**另一种结论**,不能说成"没找到" —— 前者该"重发或换窄词",后者该"换词",
+    //   而"库里没有"是第三种(最不该被误读成它)。
+    if (v.timedOut) {
+      return `查询「${v.q}」这次**没跑完**:宿主检索超过 ${Math.round((Number(v.timeoutMs) || SEARCH_TIMEOUT_MS) / 1000)} 秒没返回`
+        + '(多半是它在补索引对账 —— 宿主侧的串行操作,插件打断不了它)。'
+        + `\n条目层是本地库、毫秒级,它也没有命中 ⇒ 这次**两层都空**。`
+        + '\n换个更窄的词(中文 2~4 字)重发一次,或稍后再试。'
+        + `\n(范围:${scope})`;
+    }
+    return `按内容没找到(查询「${v.q}」· ${scope})${layerNote}。`
       + (v.skipped ? `\n(有 ${v.skipped} 条被范围挡掉 —— 要看它们得显式传 all=true。)\n` : '\n')
       + '换词试试:中文 **2~4 字**短词命中最好(`记忆树` / `血缘` / `注入面`);'
       + '**多个词用空格分隔 = 同时满足**(AND);**没有子串匹配**(`call` 搜不到 `recall`)。';
   }
   const rows = hitRows.map((r) => {
     const at = [r.seq !== null && r.seq !== undefined ? `#${r.seq}` : '', r.time].filter(Boolean).join(' ');
-    return `· ${r.conv} · ${at} ${r.who}\n  ${r.snippet}`;
+    // 「← 本会话」:它被排到了末尾(见 toSearchRows),标注是让模型知道**这条是刚发生的、不是历史** ——
+    //   否则它会把"我刚说的话"当成"主人当年说过的话"来引用。
+    const selfTag = r.isSelf ? ' **← 本会话(刚发生的)**' : '';
+    return `· ${r.conv}${selfTag} · ${at} ${r.who}\n  ${r.snippet}`;
   });
   const head = deepRows.length && rows.length
-    ? `按内容命中 **${deepRows.length} 条深层库条目** + ${rows.length} 个会话(查询「${v.q}」· ${scope}):`
+    ? `按内容命中 **${deepRows.length} 条深层库条目** + ${rows.length} 轮原文(查询「${v.q}」· ${scope})${layerNote}:`
     : deepRows.length
-      ? `按内容命中 **${deepRows.length} 条深层库条目**(查询「${v.q}」· ${scope}):`
-      : `按内容找到 ${rows.length} 个会话(查询「${v.q}」· ${scope}):`;
-  const convBlock = rows.length ? `【会话原文层】\n${rows.join('\n')}` : '';
-  return `${head}\n${deepBlock}${convBlock}`
+      ? `按内容命中 **${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