@nightpainters/dsh-ling 1.5.2 → 1.6.0

package/lib/host/memory.js

@@ -9,13 +9,13 @@ import { ensureDir, sha256Text, utcIso, mergeDeep, toIso, toEpochMs } from './ut
 // 且把 memory 当参数传(依赖注入)⇒ memory.js 引它**不成环**。
 import { archiveBefore } from './archive.js';
 
-const SCHEMA_VERSION = 13; // v13:forgotten(软遗忘标记 —— 永远不彻底删除,先归档再打标记);v12:branch_log.actor(G4 器灵侧通道 —— 工具改的树必须记在"器灵"名下,不再一律记成主人);v11:vein_suggestions(主脉提炼审核队列 R7 —— 设计稿 §5:提炼必须走审核,不直接进记忆);
+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:提炼必须走审核,不直接进记忆);
 // 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; // 同枝
@@ -43,11 +43,58 @@ export const BRANCH_LOG_WM_RETIRED = 'branch_log_wm.retired';
  *  `<= 0` = 关闭时间窗(全部按近期展开)。 */
 export const BRANCH_LOG_WINDOW_DAYS = 3;
 
-/** 原文命名空间(G4/2026-09-17):dsh_turns_raw 无 source 维,DSH 会话与导入原文共表。
+/** 命名空间分隔符(原文 id 的 `<ns>:<id>` 形态)。**唯一定义处**在本模块:
+ *  summarizer.js 从这里取并再导出(既有导入面不变),免得"分隔符"出现两份定义。 */
+export const RAW_NS_SEP = ':';
+
+/** 原文命名空间(G4/2026-09-17):dsh_turns_raw 曾无 source 维,DSH 会话与导入原文共表。
  *  若不隔离,概述器会把导入内容当成 DSH 会话重建(GROUP BY session_id 认领)→ 跨源双份;
  *  同 id 时更会互相覆盖原文(不可恢复)。故导入原文一律落 'import:<conv_id>'。
  *  历史数据(1.2.2 之前)的导入原文仍是裸 id —— 读取侧保留回退,写入侧一律带前缀。 */
-export const RAW_IMPORT_PREFIX = 'import:';
+export const RAW_IMPORT_PREFIX = 'import' + RAW_NS_SEP;
+
+/* ── v14(2026-10-01)来源列:把"来源"从**推断**变成**记录** ─────────────────────────
+ *  为什么加(主人原话:「来源也加个列吧」):在此之前的范围判据全建在 id 文本的形状上
+ *  ("有没有冒号")—— 它是**推断**,边界很硬:将来出现一个**不带冒号**的新来源名,物理上
+ *  分不出来(会被当成主人的 DSH 会话认领)。有了这一列,写入者当场把来源记下来,读者照读。
+ *  取值口径(三方共用,不许各写一份):
+ *    · 'dsh'  —— DSH 宿主会话轮次(lifecycle.js 捕获)。**读者唯一认作"自己人"的来源**;
+ *    · 命名空间名(去尾冒号),如 'import' —— 一切外来来源(别人的对话);
+ *    · NULL/'' —— **只可能来自本列落地之前的存量行**(半迁移态)。读者对这类行回落到旧判据
+ *      "裸 id = DSH 会话"(见 summarizer 的整行判据),免得同一份库里两种行为并存。
+ *  ⚠️ 写侧一律落**非空**来源,故**新行永远不靠猜**;靠猜的只有历史行与"写入者没给来源"的缺省。 */
+export const RAW_SOURCE_DSH = 'dsh';
+
+/** 枝名的**唯一**长度上限(2026-10-04,蓝队抓到 rename 库侧 60 / 上层 80 两套数)。
+ *  ⚠️ 三处必须共用它:`memory.renameBranch`、`tree-ops.opBranchRename`、`tree-ops.opBranchCreate` ——
+ *  只要有一处自己写数,回执/留痕就会与库里那条不一致(违反 D-T03「回执的名字必须来自库」)。 */
+export const BRANCH_NAME_MAX = 80;
+
+/** **有向** kind 的连边:反向边是**不同语义**(「A 是 B 的前提」≠「B 是 A 的前提」)⇒ **不与反向合并**。
+ *  无向 kind(`related`/`example`/`contrast`)的两端互换是同一条边 ⇒ 合并成一行。
+ *  ⚠️ 2026-10-04(蓝队抓到"主代理引入的方向翻转"):上一版对**所有** kind 都做反向合并 ⇒
+ *  请求 `link B→A(prerequisite)` 会被落成 `A→B`,且原 `note` 被覆盖消失 —— 在有向边上是真错误。
+ *  ⚠️ 必须定义在**顶层**(它曾被误插进 class 体内 ⇒ 语法错)。 */
+export const DIRECTED_LINK_KINDS = new Set(['prerequisite', 'supersede']);
+
+/** 来源名归一:只做 TRIM(与读取侧 SQL 的 `TRIM(source)` **同解**,两形态必须逐字同判)。
+ *  ⚠️ 刻意不做别的花样(不去尾冒号、不转小写):归一每多一条规则,SQL 形态就得跟着模仿一条,
+ *  两处一旦漂移就会出现"JS 说在范围内、SQL 说不在"这种最难查的分歧。写侧本来就不会给出
+ *  带冒号的来源名(rawSourceOf 已去尾冒号),所以这里没有需要补救的畸形输入。 */
+export function normalizeRawSource(source) {
+  return String(source ?? '').trim();
+}
+
+/** 写入侧/回填侧:按 session_id 得出该行应落的来源名(裸 id ⇒ 'dsh';`<ns>:<id>` ⇒ 'ns')。
+ *  ⚠️ 注意这是**按 id 形状推导**、不是"记录" —— 它只用于两处:
+ *    ① 写入者没显式给 source 时的缺省(与读者回落判据同解 ⇒ 老裁决一个字都不变);
+ *    ② 存量行回填(显式动作,见 backfillRawSource)。
+ *  真来源应当由写入方**显式给**(lifecycle 给 'dsh'、导入给 'import'),那才是这一列的意义。 */
+export function rawSourceOf(sessionId) {
+  const id = String(sessionId ?? '');
+  const i = id.indexOf(RAW_NS_SEP);
+  return i < 0 ? RAW_SOURCE_DSH : id.slice(0, i);
+}
 
 /** 写入侧:按来源得出该会话原文应落的 session_id。 */
 export function rawSessionId(source, convId) {
@@ -98,6 +145,10 @@ CREATE TABLE IF NOT EXISTS dsh_turns_raw (
   ts TEXT,
   model TEXT,
   text TEXT NOT NULL DEFAULT '',
+  -- v14(2026-10-01):**真实来源标记**(dsh | import | … 见 RAW_SOURCE_DSH 段口径)。
+  -- 可空:NULL 只代表"本列落地之前的存量行"(半迁移态),读者对它回落到旧的"裸 id"判据。
+  -- ⚠️ 列尾追加(不换主键、不重建表、不动既有列)⇒ 老库上是一条秒级 ALTER。
+  source TEXT,
   PRIMARY KEY (session_id, seq)
 );
 CREATE TABLE IF NOT EXISTS session_meta (
@@ -214,6 +265,76 @@ CREATE TABLE IF NOT EXISTS forgotten (
   actor        TEXT NOT NULL DEFAULT 'user',
   PRIMARY KEY (source, conv_id)
 );
+-- v15(2026-10-03,1.6-A 投递留痕):**每一次真正定稿的注入**落一条 —— 回答「注入了谁 / 为什么是它 / 多少字」。
+--   与 tree_snapshot(树的结构快照)、branch_log(树的改动)都不同:它记的是**上下文投放这一动作**本身。
+--   动机(主人 2026-10-03 定的调子「目的不是省钱,是防止注意力稀释」):判据是**行为** ⇒ 行为必须先有仪表;
+--   此前"选得准不准 / 有没有漏用 / 面板读数是否等于实际注入"三问全无底账。
+--   ⚠️ **只写不读**:本轮不加工具、不进注入面、不占"工具面最多 +1"的预算(主人拍板前的形态选择见交接 §4)。
+CREATE TABLE IF NOT EXISTS inject_log (
+  id           INTEGER PRIMARY KEY AUTOINCREMENT,
+  at           TEXT NOT NULL,
+  session_id   TEXT NOT NULL DEFAULT '',
+  reason       TEXT NOT NULL DEFAULT '',    -- first(首次定稿=真注入) | rebuild | refresh | manual
+  mode         TEXT NOT NULL DEFAULT '',    -- work | life
+  text_hash    TEXT NOT NULL DEFAULT '',    -- 定稿全文 sha256 前 16 位(校验「面板读数 ≠ 实际注入」)
+  text_chars   INTEGER NOT NULL DEFAULT 0,  -- 定稿全文**字符数**(口径同面板 cliChars,**不是** token)
+  l0_chars     INTEGER NOT NULL DEFAULT 0,  -- 人格段字数
+  l1_chars     INTEGER NOT NULL DEFAULT 0,  -- 记忆开场段字数(含视角框)
+  budget_chars INTEGER NOT NULL DEFAULT 0,  -- L1 条目预算(= l1BudgetTokens × 1.4)
+  keywords     TEXT NOT NULL DEFAULT '[]',  -- 触发本轮选取的关键词(「为什么是它」的一半答案在问句里)
+  items        TEXT NOT NULL DEFAULT '[]',  -- 入选明细(含分数分解与 why 中文理由)
+  runner_ups   TEXT NOT NULL DEFAULT '[]',  -- **差一步落选**的若干条(含 budget/max 两种原因)
+  excluded     TEXT NOT NULL DEFAULT '{}',  -- 主动排除的计数(archived/forgotten/zero)
+  dropped      INTEGER NOT NULL DEFAULT 0,  -- 落选总数(= scored - items)
+  note         TEXT NOT NULL DEFAULT ''
+);
+CREATE INDEX IF NOT EXISTS inject_log_at ON inject_log(at);
+CREATE INDEX IF NOT EXISTS inject_log_session ON inject_log(session_id);
+-- v16(2026-10-04,1.6 深层库 · 步 2):**结论层**的落点。
+--   浅层库(dsh_turns_raw / conv_overview)存的是**过程与会话流水**;深层库装的是从原文里提炼出的、
+--   可独立读懂的**结论** —— 承诺 / 决定 / 事实 / 偏好 / 关系。
+--   主人 2026-10-04 给的架构口径(逐字):「从浅层记忆库落入深层库的时候,就是从浅层库中提取关键的东西,
+--   落入深层库,把浅层库的那些什么工具调用,还有过时历史,比如反复调节UI之类的东西剥离掉,重要的东西
+--   比如我答应过你要尽快做完记忆库然后做主动开口层。然后在召回的时候再重新装配。」
+--   为什么 kind 是必需列(它不只是分类标签):**它是主动召回的钩子** —— 「承诺」该在相关事情被提起时
+--   冒出来,「事实」不该主动冒头。而主动召回(push)的判据 = **反复加固 + 置顶**,主人 2026-10-04 拍板
+--   明确「面向的对象不是某条记忆的浅层库原文,而是深层库的条目」—— 即这张表的行。
+--   与记忆树的分工(D1 已拍,主人原话「相当于记忆树的根须或者榕树类气根」):**两者并立** ——
+--   条目**不隶属**任何枝(记忆树是空间维度、深层库是内容维度),但 branch_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
+  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 同口径)
+  seq_from      INTEGER NOT NULL DEFAULT 0,    -- 原文区间起点(**可下钻验证** —— 这是"可审计"的落点)
+  seq_to        INTEGER NOT NULL DEFAULT 0,    -- 原文区间终点(= seq_from 表示单轮)
+  src           TEXT NOT NULL DEFAULT '',      -- 来源域:dsh | dsweb | import | vein(口径见 RAW_SOURCE_DSH 段)
+  hit_count     INTEGER NOT NULL DEFAULT 0,    -- 加固次数。⚠️ **只该由"真被采用"推进,不由"被注入"推进** ——
+                                               --   注入就加分会造成自我强化(注入越多→分越高→越易被注入);
+                                               --   采用信号 = **recall 取过它指向的原文**(肯下钻读原话才算在用)。
+  pinned        INTEGER NOT NULL DEFAULT 0,    -- 主人置顶(主动召回的第二个判据)
+  durability    TEXT NOT NULL DEFAULT 'long',  -- 硬度(1.6 v17):durable(永久) | long(长期) | ephemeral(当次)。
+                                               --   判的是「**这条结论本身能活多久**」,不是它当时多重要 ——
+                                               --   主人拍板选了一个插件版本是 ephemeral,拍板"效果优先于成本"是 durable。
+                                               --   ⚠️ ephemeral **不进开场**(选择侧过滤掉),但**照旧留在库里、recall 搜得到**:
+                                               --   判严的代价远小于判松了(判松 = 每次开口都在推一条早失效的临时决定)。
+  superseded_by TEXT NOT NULL DEFAULT '',      -- 被哪条取代 —— 沿用老规矩「只追不替」:旧的留痕、不删
+  origin        TEXT NOT NULL DEFAULT 'auto',  -- auto(提炼) | user(主人手写);origin='user' 的不许被自动覆盖
+  branch_id     TEXT NOT NULL DEFAULT '',      -- 气根:空 = 未挂枝;非空 = 被这条枝反向引用(不参与树的层级计算)
+  created_at    TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at    TEXT NOT NULL DEFAULT ''
+);
+CREATE INDEX IF NOT EXISTS deep_item_kind ON deep_item(kind);
+CREATE INDEX IF NOT EXISTS deep_item_conv ON deep_item(conv_id);
+CREATE INDEX IF NOT EXISTS deep_item_branch ON deep_item(branch_id);
+CREATE INDEX IF NOT EXISTS deep_item_rank ON deep_item(pinned DESC, hit_count DESC);
+-- 注意:deep_item_durability 索引故意不在这里建 —— DDL 先于迁移执行,而老库的 deep_item 表已存在
+--   ⇒ CREATE INDEX ON deep_item(durability) 会因列还不存在而失败,且它与其他语句同在一个 db.exec(DDL) 里
+--   ⇒ 整条 DDL 失败 ⇒ 插件加载失败(2026-10-04 实测,全链 44 套全绿却没抓到 —— 因为测试库全是新建的,
+--   只有"老库 + 新代码"这一组合会炸,而生产库正是这个组合)。
+--   它的落点在 migrateDeepDurability 里(ALTER 之后建),新库与老库两条路都覆盖。
 CREATE TABLE IF NOT EXISTS kv (key TEXT PRIMARY KEY, value TEXT NOT NULL);
 `;
 
@@ -275,7 +396,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 推导:
  *  迁移成本最低,且枝归属变化时无需回写海量记忆行。 */
@@ -330,6 +451,58 @@ function migrateLogActor(db) {
   }
 }
 
+/** v16→v17:deep_item 增列 durability(条目的「硬度」,1.6,2026-10-04)。
+ *
+ *  为什么需要(主人原话,逐字):「**同会话使用硬数量上限来卡吗,这可能有点机械,能不能做成
+ *  从根源上判断这些条目到底是临时的还是永久的,或者加"硬度"评分**」。
+ *  他说得对:`MAX_PER_CONV = 2` 压的是**症状** —— 病根是"**临时的东西被判成了长期记忆**",
+ *  同源扎堆只是这个病根碰巧表现出的形状(临时决定往往扎堆在一次会话里)。硬度上线后,
+ *  选择侧按"这条能活多久"过滤,同源限额退居护栏(它仍在,防的是另一种极端)。
+ *
+ *  存量行没有硬度可考 ⇒ 默认回填 `'long'`(中性档:既不冒进进开场、也不被永久排除);
+ *  真正的分档由标注流程单独写入(不是本迁移的职责 —— 迁移只保证**列在**)。
+ *  返回 boolean 供 `schema_version` 前进判定(与 `migrateRawSource` 同一约定:失败则不前进,
+ *  下次启动再试;探列幂等,成功即跳过)。 */
+function migrateDeepDurability(db) {
+  try {
+    const cols = db.prepare('PRAGMA table_info(deep_item)').all().map((c) => String(c.name));
+    if (!cols.length) return true; // 表还不存在(极老的库,DDL 会建全)—— 没什么可迁的
+    if (!cols.includes('durability')) {
+      db.exec("ALTER TABLE deep_item ADD COLUMN durability TEXT NOT NULL DEFAULT 'long'");
+    }
+    // 索引**在这里**建,不在 DDL 里:DDL 先于迁移执行,老库建索引会因列不存在而让**整条 DDL** 失败。
+    //   放在 ALTER 之后 ⇒ 新库(列已由 DDL 建出)与老库(刚 ALTER 完)两条路都对。
+    db.exec('CREATE INDEX IF NOT EXISTS deep_item_durability ON deep_item(durability)');
+    return true;
+  } catch (e) {
+    console.warn('[dsh-ling] deep_item.durability 迁移失败(忽略):', String(e?.message ?? e).slice(0, 200));
+    return false;
+  }
+}
+
+/** v13→v14:dsh_turns_raw 增列 source(来源从**推断**变**记录**,2026-10-01 主人定)。
+ *
+ *  为什么必须是**纯增列**:这张表是记忆的**原文底账**(真机库 5062 轮 / 104 会话),任何
+ *  "重建表 / 换主键 / 重写行"的迁移都会在一条语句里同时动到全部行的字节;而 ADD COLUMN 是
+ *  SQLite 的**元数据操作** —— 不触碰任何既有行、不动主键,失败面最小(红线:不许重建表)。
+ *  故这一列**不做回填**:历史行的 source 留 NULL,读者按旧判据("裸 id = DSH 会话")回落 ⇒
+ *  迁移前后**裁决逐字一致**;要动历史行得走显式动作 backfillRawSource(会汇报条数)。
+ *  幂等:先 `PRAGMA table_info` 探列,已有直接返回 —— 可重复运行,第二遍是零写入。
+ *  代价:老库上一条 ALTER,毫秒级;不重建表 ⇒ 不阻塞宿主启动。
+ *  @returns {boolean} 列是否确实在位(迁移后自证 —— 供构造器写 `dbg.raw_source_col` 与失败告警) */
+function migrateRawSource(db) {
+  const has = () => {
+    try { return db.prepare('PRAGMA table_info(dsh_turns_raw)').all().some((c) => String(c.name) === 'source'); } catch { return false; }
+  };
+  try {
+    if (has()) return true; // 已迁移(或新库:DDL 里已带此列)
+    db.exec('ALTER TABLE dsh_turns_raw ADD COLUMN source TEXT');
+  } catch (e) {
+    console.warn('[dsh-ling] dsh_turns_raw.source 迁移失败(忽略):', String(e?.message ?? e).slice(0, 200));
+  }
+  return has(); // 自证:ALTER 是否真的生效(失败 ⇒ 构造器留一条可见的诊断,而不是让读侧静默抛错)
+}
+
 /** 会话级成员"可展开"的谓词(审计 A#6,2026-09-22)。
  *
  *  展开(`branchMembers`)与计数(`branchMemberCounts` / `branchTree().members`)必须共用这一份 SQL,
@@ -361,21 +534,55 @@ export class MemoryStore {
     ensureDir(dbPath.slice(0, Math.max(0, dbPath.lastIndexOf('/'), dbPath.lastIndexOf('\\'))) || '.');
     this.dbPath = dbPath; // archive.js 用它推导归档目录(与库同级)
     this.db = new DatabaseSync(dbPath);
-    this.db.exec('PRAGMA journal_mode=WAL;');
+    // ⚠️ **`busy_timeout` 必须在任何可能撞锁的语句之前**(蓝队 2026-10-04 实测):它原先在
+    //   `journal_mode=WAL` **之后**一行 ⇒ 非 WAL 库 + 别的进程持写锁时,`journal_mode` 那一句
+    //   **23 毫秒**就抛 `database is locked`,连等待都没等。换序后同一句会等满 timeout,
+    //   而"锁在等待期内释放"的情形直接构造成功(蓝队实测:4,000ms 的锁 ⇒ 4,072ms 构造成功)。
     this.db.exec('PRAGMA busy_timeout=15000;');
+    this.db.exec('PRAGMA journal_mode=WAL;');
     this.db.exec(DDL);
     migrateSourceCheck(this.db); // v1→v2:去掉 conv_overview.source 的两源 CHECK
     migrateTitleCols(this.db); // v2→v4:title_locked + title_by(主人改过的标题不被机器覆盖)
     migrateBranchCols(this.db); // v4→v5:branch 表 + session_meta.branch_id(记忆分枝 D9-a)
     migrateSnapshotKind(this.db); // v9→v10:tree_snapshot.kind(区分自动备份与手动快照,审计 A#9)
     migrateLogActor(this.db); // v11→v12:branch_log.actor(区分"谁改的树",Part G G4)
+    const rawSourceOk = migrateRawSource(this.db); // v13→v14:dsh_turns_raw.source(来源从推断变记录,2026-10-01)
+    const deepDurOk = migrateDeepDurability(this.db); // v16→v17:deep_item.durability(条目硬度,1.6)
     this._kvGet = this.db.prepare('SELECT value FROM kv WHERE key=?');
     this._kvSet = this.db.prepare('INSERT INTO kv(key,value) VALUES(?,?) ON CONFLICT(key) DO UPDATE SET value=excluded.value');
+    // 迁移**自证**(2026-10-01):纯增列理论上不会失败,但万一 ALTER 被库锁/权限挡下(它会静默 catch),
+    // 读侧的 source 判据就会去读一列不存在的列 —— 症状是"概述器/习惯扫描每次抛 no such column",
+    // 而它只会在 console.debug 里出现一次。故失败时留一条可查的 kv + 一行 warn(成功路径**零 kv 写入**,
+    // 免得"干净库的 kv 键集合不变"这条既有断言被诊断项污染;陈旧告警顺手清掉)。
+    if (rawSourceOk) {
+      try { this.kvDel('dbg.raw_source_col'); } catch { /* 旧告警清不掉不影响主流程 */ }
+    } else {
+      // ⚠️ 这一笔**必须**留在 try 里(红队 2026-10-01 实测的阻断项):库只读(SQLITE_READONLY)/被写锁(SQLITE_BUSY)时
+      // 它**一定**抛,而它只是"留一条可查的痕迹",不是主流程。修前异常一路冒到 lib/index.js 的 apply() ⇒ **整个插件
+      // 加载失败**,那条为迁移失败准备的降级路径(本 else 分支 + 读侧回落"裸 id"判据)反而永远走不到(形同死代码)。
+      // 只用 try 护**这一笔诊断写入**,不把 kvSet 整体改成吞异常(那会把别处的真错误一起吞掉);
+      // "库真的打不开/表都建不出来"这类错误仍照旧往上抛(见构造器开头,DDL 未做任何兜底)。
+      // ⚠️ 2026-10-04 补(主人拍板「按错误码分流」):**锁竞争不是"真的打不开"** ——
+      //   `errcode 5(SQLITE_BUSY)/ 6(SQLITE_LOCKED)` 是"等一会儿就能开",由 **apply 层**
+      //   (`lib/index.js`)按错误码做有界重试 + 降级;`8(READONLY)/ 11(CORRUPT)` 等才照旧上抛。
+      //   本构造器自己不吞异常(那一层不该决定"插件要不要活"),但**降级语义**在这里被保证:
+      //   构造失败的最终后果是"记忆功能不可用",而不是"插件加载失败"(后者是 fail-dead)。
+      try {
+        this.kvSet('dbg.raw_source_col', 'missing');
+      } catch (e) {
+        console.warn('[dsh-ling] 迁移诊断没能写进库(少了 dbg.raw_source_col 这条可查痕迹,不影响运行):'
+          + String(e?.message ?? e).slice(0, 200));
+      }
+      console.warn('[dsh-ling] dsh_turns_raw.source 列缺失(迁移未生效)—— 概述器与习惯扫描的来源判据会读不到该列,'
+        + '请检查库锁/磁盘权限;读侧回落判据(instr(session_id, 冒号) = 0)不受影响,但需人工处置。');
+    }
     // schema_version 必须跟随真实结构更新,不能只写一次:
     // v5 加了 branch 表与 session_meta.branch_id,若仍留 '4',后续会话会误判库结构。
     // v6 加 vein_link + memory_conflict 两张新表(纯新增,无 ALTER,DDL 的 IF NOT EXISTS 即迁移)。
     // v10 加 tree_snapshot.kind(ALTER,见 migrateSnapshotKind)。
-    if (this.kvGet('schema_version') !== String(SCHEMA_VERSION)) this.kvSet('schema_version', String(SCHEMA_VERSION));
+    // v14 加 dsh_turns_raw.source(ALTER,见 migrateRawSource);失败时 schema_version **不前进**,
+    // 下一次启动还会再试一遍(探列幂等 ⇒ 成功即跳过)。
+    if (rawSourceOk && deepDurOk && this.kvGet('schema_version') !== String(SCHEMA_VERSION)) this.kvSet('schema_version', String(SCHEMA_VERSION));
   }
 
   close() {
@@ -716,7 +923,10 @@ export class MemoryStore {
 
   renameBranch(branchId, name, { lock = true } = {}) {
     const bid = String(branchId || '');
-    const nm = String(name || '').trim().slice(0, 60);
+    // ⚠️ 上限与 `tree-ops.opBranchRename`(80)与 `opBranchCreate`(80)**必须同一个数**
+    //   (蓝队 2026-10-04):这里曾是 60、上层是 80 ⇒ 库里比回执短 20 字,而回执/留痕都拿
+    //   入参说话 ⇒ 违反本项目自己立的 D-T03(「回执的数字与名字必须来自库」)。
+    const nm = String(name || '').trim().slice(0, BRANCH_NAME_MAX);
     if (!bid) return { ok: false, reason: 'no-branch' };
     if (!nm) return { ok: false, reason: 'empty-name' };
     this.db.prepare('UPDATE branch SET name=?, name_locked=?, updated_at=? WHERE id=?')
@@ -733,8 +943,13 @@ export class MemoryStore {
    * 让它真正生效属于**改变检索语义**,需主人拍板(方案 a),不在本次审计修法内。 */
   setBranchWeight(branchId, scale) {
     const bid = String(branchId || '');
-    const v = Number(scale);
-    if (!bid || !Number.isFinite(v)) return { ok: false, reason: 'bad-arg' };
+    // ⚠️ 先判**类型**再取数(蓝队 2026-10-04):`Number(null) === 0`、`Number(true) === 1`、
+    //   `Number([]) === 0` —— 只过 `Number()` 会让"手滑传了 null / true / 空数组"**静默写成 0/1**,
+    //   而 0 在界面上是"这条枝权重为零"的**合法读数**,没人看得出它是误传(红队实测:
+    //   `weightScale: null` ⇒ `ok:true`、库里真写成 0、回执还当成主人的意图)。
+    if (typeof scale !== 'number' || !Number.isFinite(scale)) return { ok: false, reason: 'bad-arg' };
+    const v = scale;
+    if (!bid) return { ok: false, reason: 'bad-arg' };
     const clamped = Math.max(0, Math.min(2, v));
     this.db.prepare('UPDATE branch SET weight_scale=?, updated_at=? WHERE id=?').run(clamped, utcIso(), bid);
     return {
@@ -743,11 +958,22 @@ export class MemoryStore {
     };
   }
 
-  /** 连边:两条枝之间的横向关联(如 力学 ↔ 材料科学)。 */
+  /** 连边:两条枝之间的横向关联(如 力学 ↔ 材料科学)。
+   *  反向是否合并看 kind —— 见顶层的 `DIRECTED_LINK_KINDS`。 */
   linkVeins(fromBranch, toBranch, { kind = 'related', note = '' } = {}) {
     const a = String(fromBranch || '');
     const b = String(toBranch || '');
     if (!a || !b || a === b) return { ok: false, reason: 'bad-arg' };
+    // ⚠️ 反向去重(红队 2026-10-04):主键是**有序对** `(from_branch,to_branch)` ⇒
+    //   `link A→B` 之后再 `link B→A` 会落**两行**,而 `unlink A→B` 只删一条 ⇒
+    //   回执说"断开了边",树里其实还连着。连边是**无向关系**(related/prerequisite/…),
+    //   两端反写不构成第二条边 ⇒ 写入前先看反向在不在,在就原地更新那一行。
+    const rev = this.db.prepare('SELECT rowid AS rid FROM vein_link WHERE from_branch=? AND to_branch=?').get(b, a);
+    if (rev && !DIRECTED_LINK_KINDS.has(String(kind || 'related'))) {
+      this.db.prepare('UPDATE vein_link SET kind=?, note=? WHERE from_branch=? AND to_branch=?')
+        .run(String(kind || 'related'), String(note || '').slice(0, 300), b, a);
+      return { ok: true, from: a, to: b, reverse: true };
+    }
     this.db.prepare(`INSERT INTO vein_link (from_branch,to_branch,kind,note,created_at)
       VALUES (?,?,?,?,?)
       ON CONFLICT(from_branch,to_branch) DO UPDATE SET kind=excluded.kind, note=excluded.note`)
@@ -757,8 +983,13 @@ export class MemoryStore {
 
   unlinkVein(fromBranch, toBranch) {
     try {
-      const r = this.db.prepare('DELETE FROM vein_link WHERE from_branch=? AND to_branch=?')
-        .run(String(fromBranch || ''), String(toBranch || ''));
+      // ⚠️ 双向删(红队 2026-10-04):历史数据里可能已经同时躺着 `A→B` 与 `B→A` 两行
+      //   (主键是有序对,旧写入侧没挡反向)⇒ 只删一个方向会让回执说"断开了"而树里还连着。
+      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) };
     } catch {
       return { ok: false, reason: 'db' };
@@ -781,7 +1012,7 @@ export class MemoryStore {
 
   // ---- 软遗忘(Part G G2,2026-09-25) ----
   //
-  // 原则(用户 2026-09-25 定):**永远不做彻底删除**。遗忘 = 先把原数据归档落盘(原文 + 概述 +
+  // 原则(尝生 2026-09-25 定):**永远不做彻底删除**。遗忘 = 先把原数据归档落盘(原文 + 概述 +
   // 改动日志),再在库里打一个标记,召回路径据标记排除。行仍在库里、归档文件在磁盘上 ——
   // 两条独立还原路径,任何一条都能反悔。
   //
@@ -815,24 +1046,39 @@ export class MemoryStore {
    * ⚠️ 仍然缺的一环在**调用侧**(`tools.js` 的 forget handler):它只判 `arc.ok`,
    *    不判 `arc.empty` ⇒ 想彻底堵住 B-05 还得在那儿加一句守卫(见审计台账)。
    */
-  forgetEntry({ source, convId, reason = '', archivePath = '', actor = 'user', archiveTurns = null } = {}) {
+  forgetEntry({ source, convId, reason = '', archivePath = '', actor = 'user', archiveTurns = null, archiveEmpty = undefined } = {}) {
     const s = String(source || '').trim();
     const c = String(convId || '').trim();
     if (!s || !c) return { ok: false, reason: 'bad-key' };
     const dir = String(archivePath || '').trim();
     if (!dir) return { ok: false, reason: 'empty-archive', message: '没有归档路径 —— 先归档再打标记' };
-    if (archiveTurns === null || archiveTurns === undefined) {
-      let n = 0;
-      try {
-        n = existsSync(join(dir, 'turns.jsonl'))
-          ? readFileSync(join(dir, 'turns.jsonl'), 'utf8').split('\n').filter((l) => l.trim()).length
-          : 0;
-      } catch { n = 0; }
-      if (n === 0) {
-        return { ok: false, reason: 'empty-archive', message: '归档里没有原文(0 轮)', archivePath: dir };
+    // ⚠️ 判据来源(红队 2026-10-04):调用方(归档器)显式给出 `archiveEmpty` 时**以它为准** ——
+    //   它看的是"原文轮数 + 概述正文 + 会话元数据"**三样**;不给时才退回旧的验盘判据(只看
+    //   `turns.jsonl` 行数)。旧判据单独用会让"**只有概述、没有原文**"的条目永远忘不掉
+    //   (真库实测 3 条),而且回执会把一份装着摘要的归档说成"归档里什么都没有"。
+    if (archiveEmpty === true) {
+      return { ok: false, reason: 'empty-archive', message: '归档里没有任何内容(0 轮原文、概述也没有正文)', archivePath: dir };
+    }
+    // `archiveEmpty === false` = 归档器确认"**三样里至少一样有内容**"(典型:概述在、原文 0 轮)
+    //   ⇒ **放行**。这正是本次要修的那一类(旧判据只看 `turns.jsonl`,于是它永远忘不掉)。
+    // 其余情形(没给判定)按旧判据走:调用方声明的轮数优先,没声明就验盘 ——
+    //   **声明 0 轮同样拒绝**(声明不能把空的说成有的;这条语义有断言钉着,不许丢)。
+    if (archiveEmpty === undefined) {
+      if (archiveTurns !== null && archiveTurns !== undefined) {
+        if (!(Number(archiveTurns) > 0)) {
+          return { ok: false, reason: 'empty-archive', message: '归档里没有原文(0 轮)', archivePath: dir };
+        }
+      } else {
+        let n = 0;
+        try {
+          n = existsSync(join(dir, 'turns.jsonl'))
+            ? readFileSync(join(dir, 'turns.jsonl'), 'utf8').split('\n').filter((l) => l.trim()).length
+            : 0;
+        } catch { n = 0; }
+        if (n === 0) {
+          return { ok: false, reason: 'empty-archive', message: '归档里没有原文(0 轮)', archivePath: dir };
+        }
       }
-    } else if (!(Number(archiveTurns) > 0)) {
-      return { ok: false, reason: 'empty-archive', message: '归档里没有原文(0 轮)', archivePath: dir };
     }
     const oneLine = (x, n) => String(x == null ? '' : x).replace(/[\r\n\t]+/g, ' ').trim().slice(0, n);
     try {
@@ -896,7 +1142,7 @@ export class MemoryStore {
    *
    * **调用方必须先归档当前状态** —— 本方法只管写,不做任何备份。
    * 回灌的危险性高于遗忘:遗忘会留下"少了一条"的可见痕迹,而回灌是**往里加东西**,
-   * 加错了很难察觉(用户 2026-09-25:「backfill 比 forget 危险多了,因为它更难以觉察」)。
+   * 加错了很难察觉(尝生 2026-09-25:「backfill 比 forget 危险多了,因为它更难以觉察」)。
    *
    * 两道保护:① 写回的概述带 `origin` 标记(默认 `backfill-v1`),界面上看得出"这条是灌回来的";
    * ② 不传 `keepUserState:false` ⇒ **不动主人留下的命中数与置顶**,回灌只补内容、不夺用户态。
@@ -913,12 +1159,29 @@ export class MemoryStore {
     if (!s || !c) return { ok: false, reason: 'bad-key' };
     let wroteTurns = 0;
     try {
-      const ins = this.db.prepare(`INSERT INTO dsh_turns_raw (session_id,seq,role,ts,model,text)
-        VALUES (?,?,?,?,?,?) ON CONFLICT(session_id,seq) DO UPDATE SET
-        role=excluded.role, ts=excluded.ts, model=excluded.model, text=excluded.text`);
+      const ins = this.db.prepare(`INSERT INTO dsh_turns_raw (session_id,seq,role,ts,model,text,source)
+        VALUES (?,?,?,?,?,?,?) ON CONFLICT(session_id,seq) DO UPDATE SET
+        role=excluded.role, ts=excluded.ts, model=excluded.model, text=excluded.text,
+        source=COALESCE(dsh_turns_raw.source, excluded.source)`);
+      // v14:回灌也要带来源。取 `rawSourceOf(c)`(= 写入目标 id 的形状)而**不是**概述的 `source` 字段:
+      //   · 目标 id 带前缀(import:)⇒ 'import' —— 与写入侧同一口径;
+      //   · 目标 id 是裸的 ⇒ 'dsh' —— 与读者对空 source 的回落判据同解 ⇒ 回灌前后裁决一致
+      //     (若改按 `source` 字段记 'dsweb'/'vein',这些回灌的原文会**当场从概述器眼里消失**:越权改裁决)。
+      //   冲突分支同样 COALESCE(首写为准),不回退已记录的来源。
+      // ⚠️ 来源列优先取**调用方声明的** `s`,不再一律按目标 id 形状回推(红队 2026-10-04):
+      //   `rawSourceOf(裸 uuid)` 恒为 `'dsh'`,而 **dsweb 的 1,523 条 conv_id 全是裸 uuid**
+      //   ⇒ 回灌一条 dsweb 会让该会话多出 `source='dsh'` 的原文行,概述器(`TRIM(source)='dsh'`)
+      //   当场认领它 ⇒ **同 conv 双概述、双份记忆**,一个 DeepSeek 网页端的外来会话被升格成
+      //   "主人的 DSH 会话"(B-01 那类"同 id 双源"的第三次复发,当前触发口是 memory_backfill)。
+      //   规则:id 带 `import:` 前缀 ⇒ 来源必是 'import'(前缀本身即命名空间,与写入侧同解);
+      //   其余(裸 id)⇒ 用声明值(dsh / dsweb / vein)。⚠️ `s` 已在上面过了 bad-key(非空),
+      //   故这里**不需要**再回落 `rawSourceOf(c)`(蓝队指出那一支不可达,已删)。
+      const declared = String(s || '').trim();
+      const idHasImportPrefix = String(c).startsWith(RAW_IMPORT_PREFIX);
+      const rawSrc = idHasImportPrefix ? 'import' : declared;
       this.db.exec('BEGIN');
       for (const t of (Array.isArray(turns) ? turns : [])) {
-        ins.run(c, Number(t.seq) || 0, String(t.role || ''), t.ts ?? null, t.model ?? null, String(t.text ?? ''));
+        ins.run(c, Number(t.seq) || 0, String(t.role || ''), t.ts ?? null, t.model ?? null, String(t.text ?? ''), rawSrc);
         wroteTurns += 1;
       }
       this.db.exec('COMMIT');
@@ -1110,7 +1373,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 || '');
@@ -1171,7 +1434,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,与双水位同批上)────────────────────────────
@@ -1227,7 +1490,7 @@ export class MemoryStore {
     }
   }
 
-  /** 尚未同步给器灵的改动笔数(复盘守门,2026-09-22 用户:「动记忆树不能是随意的」)。
+  /** 尚未同步给器灵的改动笔数(复盘守门,2026-09-22 尝生:「动记忆树不能是随意的」)。
    *
    *  判据:自器灵**上一次开口**(注入推进水位)以来累积了多少笔结构改动。
    *  水位取 `branch_log_wm.last`(由 `inject.js` 的 advanceLogWatermark 在投递时写入),
@@ -1248,7 +1511,7 @@ export class MemoryStore {
     let pending = 0;
     let maxId = 0;
     try {
-      // 'snapshot'(保存快照)不计入待交代笔数(2026-09-25 用户:「单纯保存不弹修改」)。
+      // 'snapshot'(保存快照)不计入待交代笔数(2026-09-25 尝生:「单纯保存不弹修改」)。
       // 依据:保存快照**不改树**——它只是把当前结构另存一份,是"大改之前的保险",
       // 不是"改动"。把它算成债会让主人每存一次就看到「⚠ 有 N 笔改动还没跟器灵说过」,
       // 而实际上树一个字节没变。留痕仍写进 branch_log(审计价值保留),只是不推进债。
@@ -1319,7 +1582,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 叶。
@@ -1357,7 +1620,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));
@@ -1741,7 +2004,7 @@ export class MemoryStore {
   }
 
   /** 检索侧降权映射:`"source\\u0000convId" → 系数`。
-   *  规则(用户 2026-09-20 定):**复盘裁定的按裁定;未复盘的以最新为准**(旧的一方降权)。
+   *  规则(尝生 2026-09-20 定):**复盘裁定的按裁定;未复盘的以最新为准**(旧的一方降权)。
    *  `duplicate` 不降权(两条内容相同,降谁都会丢信息);`dismissed` 一律不降权。 */
   conflictDowngradeMap() {
     const m = new Map();
@@ -1787,7 +2050,7 @@ export class MemoryStore {
    * 已归档会话 id 集合(2026-09-21,D9-b 用)。
    *
    * 归档 = 主人主动封存、不再参与日常召回的那批会话。矛盾扫描必须排除它们,
-   * 否则会拿几个月前已封存的对话互相判"矛盾",把待复盘队列塞满噪音(用户实测反馈)。
+   * 否则会拿几个月前已封存的对话互相判"矛盾",把待复盘队列塞满噪音(尝生实测反馈)。
    * 一次取全量而非逐行查 session_meta —— scan 里要判上千条,逐行查是 O(n) 次 SQL。
    */
   archivedConvIdSet() {
@@ -1962,11 +2225,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;
@@ -2260,15 +2523,139 @@ export class MemoryStore {
     ).run(utcIso(), source, String(convId));
   }
 
+  // ---- 投递留痕(1.6-A,2026-10-03)----
+  /** 落一条**定稿注入**的留痕。调用方须自己 try/catch —— 这里是**仪表**,不是主流程:
+   *  少记一条是可惜,因留痕而让注入失败是事故(与 `bumpHit` 同一取向)。
+   *  入参一律宽容(缺项写默认):字段宁可空着,也不要为了"记全"把异常抛回注入路径。 */
+  logInjection({
+    sessionId = '', reason = '', mode = '', textHash = '', textChars = 0,
+    l0Chars = 0, l1Chars = 0, budgetChars = 0, keywords = null, items = null,
+    runnerUps = null, excluded = null, dropped = 0, note = '',
+  } = {}) {
+    const J = (v, dft) => JSON.stringify(v ?? dft);
+    this.db.prepare(
+      `INSERT INTO inject_log
+         (at, session_id, reason, mode, text_hash, text_chars, l0_chars, l1_chars, budget_chars,
+          keywords, items, runner_ups, excluded, dropped, note)
+       VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`,
+    ).run(
+      utcIso(), String(sessionId || ''), String(reason || ''), String(mode || ''),
+      String(textHash || ''), Number(textChars) || 0, Number(l0Chars) || 0, Number(l1Chars) || 0,
+      Number(budgetChars) || 0, J(keywords, []), J(items, []), J(runnerUps, []), J(excluded, {}),
+      Number(dropped) || 0, String(note || ''),
+    );
+  }
+
+  /** 读最近若干条投递留痕(新→旧)。本轮只给测试与将来的 `recall(query, kind)` 用:
+   *  **不挂读面** —— 不加工具、不进注入面(1.6 交接 §4 硬约束①「投放入口最多 +1」)。 */
+  listInjections({ limit = 20, sessionId = '', parse = true } = {}) {
+    const n = Math.max(1, Math.min(500, Number(limit) || 20));
+    const rows = sessionId
+      ? this.db.prepare('SELECT * FROM inject_log WHERE session_id=? ORDER BY id DESC LIMIT ?').all(String(sessionId), n)
+      : this.db.prepare('SELECT * FROM inject_log ORDER BY id DESC LIMIT ?').all(n);
+    if (!parse) return rows;
+    const j = (s, dft) => { try { return JSON.parse(s); } catch { return dft; } };
+    return rows.map((r) => ({
+      ...r,
+      keywords: j(r.keywords, []),
+      items: j(r.items, []),
+      runner_ups: j(r.runner_ups, []),
+      excluded: j(r.excluded, {}),
+    }));
+  }
+
+  // ---- 深层库条目(1.6 步 2/3,2026-10-04)----
+  //   主人给的架构口径(逐字):「从浅层记忆库落入深层库的时候,就是从浅层库中提取关键的东西,落入深层库,
+  //   把浅层库的那些什么工具调用,还有过时历史剥离掉……然后在召回的时候再重新装配」。
+  //   三条语义位(见 DDL 注释,谁改都不许违反):hit_count **只由"真被采用"推进** · superseded_by **只追不替** ·
+  //   branch_id 是**气根**(枝侧反向引用,不动树结构)。
+  /** 新增一条条目。**幂等判据 = (conv_id, seq_from, seq_to, text)** —— 同一段原文重复提炼不会写两遍
+   *  (与 appendRawTurn 的取向一致:提炼器可以安全重跑)。`origin='user'` 的条目由调用方自己保护,
+   *  本方法只管写。返回 `{ok,id,existed,reason?}`:existed=true 表示撞上了已有条目。 */
+  addDeepItem({ kind = '', text = '', at = '', convId = '', seqFrom = 0, seqTo = 0, src = '', origin = 'auto', branchId = '', durability = 'long' } = {}) {
+    const k = String(kind || '').trim();
+    const t = String(text || '').trim();
+    if (!k || !t) return { ok: false, id: '', existed: false, reason: 'empty' };
+    const cv = String(convId || '');
+    const a = Number(seqFrom) || 0;
+    const b = Number(seqTo) || 0;
+    const dup = this.db.prepare('SELECT id FROM deep_item WHERE conv_id=? AND seq_from=? AND seq_to=? AND text=?').get(cv, a, b, t);
+    if (dup) return { ok: true, id: dup.id, existed: true };
+    const id = 'di:' + randomUUID();
+    const srcV = String(src || '') || rawSourceOf(cv);
+    // 硬度(1.6 v17):只认三档,其余一律按 'long' —— 不让一个拼错的档名把条目变成"永不进场"。
+    const dur = ['durable', 'long', 'ephemeral'].includes(String(durability)) ? String(durability) : 'long';
+    this.db.prepare(
+      `INSERT INTO deep_item (id, kind, text, at, conv_id, seq_from, seq_to, src, origin, branch_id, durability, updated_at)
+       VALUES (?,?,?,?,?,?,?,?,?,?,?,?)`,
+    ).run(id, k, t, String(at || ''), cv, a, b, srcV, String(origin || 'auto'), String(branchId || ''), dur, utcIso());
+    return { ok: true, id, existed: false };
+  }
+
+  /** 读条目。默认**排除已被取代的**(`superseded_by` 非空)—— 那些是"曾经成立、现已作废"的留痕,
+   *  主动召回不该再挑它;复盘历史时显式 `includeSuperseded:true`。排面按置顶→加固→新。 */
+  listDeepItems({ kind = '', convId = '', branchId = '', limit = 50, includeSuperseded = false } = {}) {
+    const n = Math.max(1, Math.min(1000, Number(limit) || 50));
+    const w = [];
+    const p = [];
+    if (kind) { w.push('kind=?'); p.push(String(kind)); }
+    if (convId) { w.push('conv_id=?'); p.push(String(convId)); }
+    if (branchId) { w.push('branch_id=?'); p.push(String(branchId)); }
+    if (!includeSuperseded) w.push("superseded_by=''");
+    const sql = `SELECT * FROM deep_item${w.length ? ' WHERE ' + w.join(' AND ') : ''}`
+      + ' ORDER BY pinned DESC, hit_count DESC, created_at DESC LIMIT ?';
+    return this.db.prepare(sql).all(...p, n);
+  }
+
+  deepItemById(id) {
+    return this.db.prepare('SELECT * FROM deep_item WHERE id=?').get(String(id));
+  }
+
+  /** 取代:**只追不替** —— 旧的标上 `superseded_by`,**不删**(复盘时要能看见"当初是怎么定的")。 */
+  supersedeDeepItem(oldId, newId) {
+    const o = this.deepItemById(oldId);
+    const nw = this.deepItemById(newId);
+    if (!o || !nw) return { ok: false, reason: 'not-found' };
+    this.db.prepare('UPDATE deep_item SET superseded_by=?, updated_at=? WHERE id=?')
+      .run(String(newId), utcIso(), String(oldId));
+    return { ok: true, id: String(oldId), by: String(newId) };
+  }
+
+  /** 加固 +1。⚠️ **只该由"真被采用"调用** —— 注入不算(见列注释:注入就加分会形成自我强化回路)。
+   *  采用信号的首选 = `recall` 取过它指向的原文(那条路已在投递留痕面内)。 */
+  bumpDeepHit(id) {
+    const r = this.db.prepare('UPDATE deep_item SET hit_count=hit_count+1, updated_at=? WHERE id=?')
+      .run(utcIso(), String(id));
+    return { ok: r.changes > 0 };
+  }
+
+  setDeepPinned(id, pinned = true) {
+    const r = this.db.prepare('UPDATE deep_item SET pinned=?, updated_at=? WHERE id=?')
+      .run(pinned ? 1 : 0, utcIso(), String(id));
+    return { ok: r.changes > 0, pinned: pinned ? 1 : 0 };
+  }
+
+  deepItemCount() {
+    return Number(this.db.prepare('SELECT COUNT(*) AS n FROM deep_item').get()?.n) || 0;
+  }
+
   // ---- raw turns (DSH incremental capture, passive) ----
-  appendRawTurn(sessionId, { seq, role, ts, model, text }) {
+  /** 追加一条原文轮次(幂等:(session_id,seq) 冲突时更新正文)。
+   *  v14:`source` 记**这条原文属于哪个来源**(取值口径见 RAW_SOURCE_DSH 段)。缺省 null ⇒ 按 id
+   *  形状推导(rawSourceOf)—— 与读者对空 source 的回落判据**同解**,故老调用点一个字不改也写不错;
+   *  但**知道来源的调用方应当显式给**(lifecycle 给 'dsh'、导入给 'import'):那才是这一列的意义。 */
+  appendRawTurn(sessionId, { seq, role, ts, model, text, source = null }) {
     if (!sessionId || typeof text !== 'string' || !text) return;
+    const src = normalizeRawSource(source) || rawSourceOf(sessionId);
     this.db.prepare(
-      `INSERT INTO dsh_turns_raw (session_id, seq, role, ts, model, text)
-       VALUES (?,?,?,?,?,?)
-       ON CONFLICT(session_id, seq) DO UPDATE SET text=excluded.text`,
+      `INSERT INTO dsh_turns_raw (session_id, seq, role, ts, model, text, source)
+       VALUES (?,?,?,?,?,?,?)
+       ON CONFLICT(session_id, seq) DO UPDATE SET text=excluded.text,
+         source=COALESCE(dsh_turns_raw.source, excluded.source)`,
+      // 冲突分支的来源取 COALESCE(首写为准):同一轮被重扫/重导时**不把已记录的来源降级成推断值**
+      // (例如一行已被显式记成某个外来来源,重扫不该把它改回 'dsh');而 NULL 的存量行会被填上。
       // 写侧归一(修 A):一律存 ISO;数字/浮点串(如 "1789006881011.0")也归一后再落库。
-    ).run(String(sessionId), Number(seq), String(role ?? '?'), toIso(ts), model || null, text);
+    ).run(String(sessionId), Number(seq), String(role ?? '?'), toIso(ts), model || null, text, src || null);
     this.db.prepare(
       'INSERT INTO session_meta(session_id, raw_seq) VALUES(?,?) ON CONFLICT(session_id) DO UPDATE SET raw_seq=excluded.raw_seq',
     ).run(String(sessionId), Number(seq));
@@ -2276,6 +2663,54 @@ export class MemoryStore {
     this.db.prepare('UPDATE session_meta SET archived=0 WHERE session_id=? AND archived=1').run(String(sessionId));
   }
 
+  /** 存量行来源回填(v14,**可选**动作,2026-10-01)。**只有显式调用才会跑** —— 构造器与概述器
+   *  都不会自己碰它:这是唯一会**写历史行**的动作,偷偷跑等于让这一列的可信度打折(读者会以为
+   *  每行的来源都是写入当时记下来的)。规则(顺序不可调):
+   *    ① 只填 `source IS NULL` 或空串的行 —— **已有的非空来源绝不覆盖**(记录优先于推断);
+   *    ② 值按 session_id 推导(rawSourceOf:裸 id ⇒ 'dsh';`<ns>:<id>` ⇒ 'ns');
+   *    ③ 幂等(第二遍 filled=0);④ 汇报条数(filled / 按来源分组 / 推不出来的 unresolved)。
+   *  ⚠️ 回填只给**已经存在的行**加一个字段,**不改变任何裁决** —— 推导口径与读者的空 source 回落
+   *  判据同解(裸 id ⇒ dsh、带前缀 ⇒ 排除),迁移前后同一份库的概述集逐字相同。
+   *  ⚠️ 代价(明说):历史行的 source 是**事后推断**的,不是当场记的 —— 若某个老来源的 id 恰好是裸
+   *  形状(不带冒号),回填会把它**固化成 'dsh'**,此后再也分不出来。故本动作须由人显式触发。
+   *  @returns {{ok:boolean,filled:number,scanned:number,bySource:Object,unresolved:number}} */
+  backfillRawSource() {
+    const out = { ok: true, filled: 0, scanned: 0, bySource: {}, unresolved: 0 };
+    try {
+      const rows = this.db.prepare(
+        "SELECT session_id, COUNT(*) AS n FROM dsh_turns_raw WHERE source IS NULL OR TRIM(source)='' GROUP BY session_id",
+      ).all();
+      const upd = this.db.prepare(
+        "UPDATE dsh_turns_raw SET source=? WHERE session_id=? AND (source IS NULL OR TRIM(source)='')",
+      );
+      this.db.exec('BEGIN');
+      for (const r of rows) {
+        const sid = String(r?.session_id ?? '');
+        const n = Number(r?.n) || 0;
+        out.scanned += n;
+        const src = rawSourceOf(sid);            // 裸 id ⇒ 'dsh';'<ns>:<id>' ⇒ 'ns'
+        if (!src) { out.unresolved += n; continue; } // id 以冒号开头(推不出来源名)⇒ 留 NULL,交给读者回落/告警
+        const res = upd.run(src, sid);
+        const filled = Number(res?.changes || 0);
+        out.filled += filled;
+        out.bySource[src] = (out.bySource[src] || 0) + filled;
+      }
+      this.db.exec('COMMIT');
+    } catch (e) {
+      try { this.db.exec('ROLLBACK'); } catch { /* ignore */ }
+      return { ...out, ok: false, message: String(e?.message ?? e).slice(0, 160) };
+    }
+    return out;
+  }
+
+  /** 来源分布(只读;给报告/诊断用):`{[source]: 行数}`,NULL 记作 '(null)'。 */
+  rawSourceCounts() {
+    const rows = this.db.prepare(
+      "SELECT COALESCE(NULLIF(TRIM(source),''),'(null)') AS s, COUNT(*) AS n FROM dsh_turns_raw GROUP BY s ORDER BY n DESC",
+    ).all();
+    return Object.fromEntries(rows.map((r) => [String(r.s), Number(r.n)]));
+  }
+
   rawTurnCount(sessionId) {
     const r = this.db.prepare('SELECT COUNT(*) AS n FROM dsh_turns_raw WHERE session_id=?').get(String(sessionId));
     return r ? Number(r.n) : 0;
@@ -2518,7 +2953,7 @@ export class MemoryStore {
    *  ⚠️ 代价是 0/0 也是"合法键值",所以下面三个缓存字段**只在重算真正完成后才推**。
    *  ⚠️ 别把这两个字段的存在当成"守卫一定在工作":`statSync` 抽风/漏 import 时它恒返 [0,0],
    *  面板照旧显示、测试照旧全绿,而守卫是**静默空转**的(本轮就踩过:忘了 import statSync,
-   *  ReferenceError 被本方法的 catch 吞掉)。要确认它活着,见 _probe/tmp-fp-wal-guard.mjs 的
+   *  ReferenceError 被本方法的 catch 吞掉)。要确认它活着,得跑一次性运行时探针的
    *  【陷阱守卫】断言:它必须返回真实 size/mtime,不能是 [0,0]。 */
   _walStamp() {
     try {
@@ -2532,7 +2967,7 @@ export class MemoryStore {
   /** data_version 守卫(1.5.2):缓存键的**第三**来源,专补 `-wal` 那一维的盲区。
    *  上面的 `_walStamp()` 有个洞:维护/备份脚本若用 `journal_mode=DELETE` 改库,**根本没有 `-wal`
    *  文件**,stat 恒返 [0,0] 哨兵 ⇒ 外进程改完面板还是旧指纹。`PRAGMA data_version` 正好互补
-   *  (实测见 _probe/tmp-dv-semantics.mjs,数值原样):
+   *  (一次性运行时探针实测,数值原样):
    *    · 本连接自己写 ⇒ **不变**(2→2)  ⇒ 它**不能**替代 `total_changes()`,只补位;
    *    · 别的连接提交 ⇒ **变**(2→3;DELETE 模式 1→2);
    *    · 外连接写完立刻 `wal_checkpoint(TRUNCATE)` 把 -wal 截成 0 ⇒ **照样变**(3→4);