@nightpainters/dsh-ling 1.5.1

package/lib/host/l1.js

@@ -0,0 +1,282 @@
+// dsh-ling host — L1 opener selection v0 (DESIGN §6.2).
+// heat = α·recency + β·freq + γ·importance (exponential decay, half-life configurable);
+// mode weights by category (knowledge/daily/feeling); optional keyword pre-match.
+import { toEpochMs, isoDate } from './util.js';
+
+const DAY_MS = 86_400_000;
+
+export function decayWeight(daysSince, halfLifeDays) {
+  if (halfLifeDays <= 0) return 0;
+  return Math.pow(0.5, daysSince / halfLifeDays);
+}
+
+export function computeHeat(row, nowMs, cfg) {
+  const c = cfg || {};
+  const half = Number(c.halfLifeDays ?? 90);
+  const t = toEpochMs(row.updated_at || row.started_at);
+  // 解析不出来时按"刚更新"处理(不惩罚未知),但绝不再让坏串长期拿满分:
+  // 只要能被 toEpochMs 认出(含 "1789006881011.0"),就照真实时间衰减。
+  const days = t === null ? 0 : Math.max(0, (nowMs - t) / DAY_MS);
+  const recency = decayWeight(days, half);
+  const freq = Math.min(1, (Number(row.hit_count ?? 0) + Number(row.importance ?? 0)) / 20);
+  const alpha = Number(c.heatAlpha ?? 0.5);
+  const beta = Number(c.heatBeta ?? 0.3);
+  const gamma = Number(c.heatGamma ?? 0.2);
+  return alpha * recency + beta * freq + gamma * Math.min(1, Number(row.importance ?? 0));
+}
+
+const CATEGORY_DEFAULTS = { knowledge: 1, daily: 0.5, feeling: 0.3 };
+
+/** 3-gram set of a token (CJK-agnostic). */
+function grams3(s) {
+  const out = new Set();
+  for (let i = 0; i + 3 <= s.length; i++) out.add(s.slice(i, i + 3));
+  return out;
+}
+
+/**
+ * keyword overlap between query tokens and row keywords:
+ * hit when a pair (1) contains the other (len>=2), or (2) shares a 3-gram —
+ * robust to token-window offsets (query 4-grams vs stored 6-grams).
+ */
+function kwOverlap(queryKeywords, rowKeywords) {
+  if (!queryKeywords || !queryKeywords.length || !rowKeywords || !rowKeywords.length) return 0;
+  let hit = 0;
+  for (const q of queryKeywords) {
+    const qs = String(q).toLowerCase();
+    if (qs.length < 2) continue;
+    const qg = grams3(qs);
+    for (const k of rowKeywords) {
+      const ks = String(k).toLowerCase();
+      if (ks.length < 2) continue;
+      if (ks.includes(qs) || qs.includes(ks)) {
+        hit += 1;
+        break;
+      }
+      if (qg.size) {
+        let shared = false;
+        for (let i = 0; i + 3 <= ks.length; i++) {
+          if (qg.has(ks.slice(i, i + 3))) {
+            shared = true;
+            break;
+          }
+        }
+        if (shared) {
+          hit += 1;
+          break;
+        }
+      }
+    }
+  }
+  return hit;
+}
+
+const KW_BONUS_PER_HIT = 0.6;
+const KW_BONUS_CAP = 1.8;
+/** 「有信息量的摘要」加权(2026-09-16):只有标题的行(如全部 dsweb 行)不加分,
+ *  真正带摘要的行加分 —— 用相对分差把"信息密度低"的行往后压,而不是硬过滤。
+ *  判定:摘要去掉"标题前缀"与"— N 条消息"尾巴后仍 ≥ 20 字才算有信息量。 */
+const SUMMARY_BONUS_DEFAULT = 0.25;
+
+export function summaryWeight(row) {
+  const s = String(row?.summary || '').trim();
+  if (!s) return 0;
+  const t = String(row?.title || '').trim();
+  let body = s;
+  if (t && body.startsWith(t)) body = body.slice(t.length).replace(/^[\s:：—\-]+/, '');
+  body = body.replace(/\s*[—\-]\s*\d+\s*条消息\s*$/, '').trim();
+  return body.length >= 20 ? 1 : 0;
+}
+
+/** 主干枝 id(与 `memory.js` 的 `TRUNK_ID` 一致;算法模块不耦合存储层,故此处独立定义)。 */
+const TRUNK_BRANCH = 'trunk';
+/** 血缘档位兜底:未知枝按"旁系"算(与 memory.js 的 `LINEAGE_SIDE` 一致)。 */
+const LINEAGE_SIDE_FALLBACK = 0.4;
+
+/** D9-a:取当前会话的血缘上下文(所属枝 + 枝权重表 + 会话→枝 表)。
+ *  任一步不可用则返回 null —— 此时不加权(等价于旧行为),保证向后兼容。 */
+/** D9-a/D9-b:取当前会话的血缘上下文(所属枝 + 枝权重表 + 会话→枝 表 + 矛盾降权表)。
+ *  **矛盾降权与血缘正交** —— 即使不传 sessionId(不加血缘权重),矛盾降权也必须生效;
+ *  两者都拿不到时才返回 null(等价于旧行为),保证向后兼容。 */
+function lineageContext(store, sessionId) {
+  try {
+    if (!store) return null;
+    const sid = String(sessionId || '');
+    const conflicts = typeof store.conflictDowngradeMap === 'function' ? store.conflictDowngradeMap() : null;
+    const noLineage = !sid || typeof store.branchOfSession !== 'function';
+    const branch = noLineage ? TRUNK_BRANCH : store.branchOfSession(sid);
+    const weights = noLineage
+      ? null
+      : (typeof store.lineageWeightMap === 'function' ? store.lineageWeightMap(branch) : null);
+    const sessionBranch = noLineage
+      ? null
+      : (typeof store.sessionBranchMap === 'function' ? store.sessionBranchMap() : null);
+    // 方案 A(2026-09-21):非会话源的**显式**归属覆盖层 —— dsweb/import 的历史条目没有会话身份,
+    //   靠 session_meta 推不出枝。与血缘正交(枝归属不依赖"当前会话"),故独立于 noLineage 取值。
+    const convBranch = typeof store.convBranchMap === 'function' ? store.convBranchMap() : null;
+    if (!weights && !conflicts) return null;
+    return { branch, weights, sessionBranch, convBranch, conflicts };
+  } catch {
+    return null;
+  }
+}
+
+/** D9-a:一条记忆行所属枝的血缘档位。
+ *  方案 A(2026-09-21):`conv_branch` 显式覆盖**优先** —— dsweb/import 的历史条目靠它挂枝;
+ *  未覆盖时,dsh 源走会话推导,其余归主干。 */
+function lineageOf(ctx, row) {
+  if (!ctx || !ctx.weights) return 1;
+  const src = String(row?.source || '');
+  const cid = String(row?.conv_id || '');
+  const ov = ctx.convBranch && ctx.convBranch.size ? ctx.convBranch.get(src + '\u0000' + cid) : undefined;
+  if (ov) return ctx.weights.get(ov) ?? LINEAGE_SIDE_FALLBACK;
+  let bid = TRUNK_BRANCH;
+  if (src === 'dsh' && ctx.sessionBranch) {
+    bid = ctx.sessionBranch.get(cid) || TRUNK_BRANCH;
+  }
+  return ctx.weights.get(bid) ?? LINEAGE_SIDE_FALLBACK;
+}
+
+/** D9-b:矛盾降权因子。命中 `"source\u0000convId"` 即乘系数(默认 0.3)。
+ *  规则见 `memory.js` 的 `conflictDowngradeMap()`:复盘裁定的按裁定,**未复盘的以最新为准**;
+ *  只降权,不删除、不改写内容 —— 这是记忆树的核心不变量。 */
+function conflictOf(ctx, row) {
+  if (!ctx || !ctx.conflicts || !ctx.conflicts.size) return 1;
+  const key = String(row?.source || '') + '\u0000' + String(row?.conv_id || '');
+  return ctx.conflicts.get(key) ?? 1;
+}
+
+/**
+ * Pick Top-N overviews for the L1 opener.
+ * @param {MemoryStore} store
+ * @param {object} opts { mode, keywords[], categoryWeights, maxItems, budgetChars, sessionId }
+ *   `sessionId`(D9-a 起):用于血缘加权 —— 不传则不加权(旧行为)。
+ * @returns {{items: Array, dropped: number, totalChars: number}}
+ */
+export function selectL1(store, opts) {
+  const o = opts || {};
+  const mode = o.mode === 'work' ? 'work' : 'life';
+  const weights = Object.assign({}, CATEGORY_DEFAULTS, (o.categoryWeights || {})[mode] || {});
+  const max = Math.max(1, Math.min(50, Number(o.maxItems ?? 8)));
+  const budget = Math.max(200, Number(o.budgetChars ?? 6000)); // ~1.5 chars/token 中文估
+  const now = Date.now();
+  const summaryBonus = Number.isFinite(Number(o.summaryBonus)) ? Number(o.summaryBonus) : SUMMARY_BONUS_DEFAULT;
+  // 2026-09-21:归档会话不参与召回 —— 归档是主人的明确动作("这条别再提了"),
+  //   而此前 selectL1 直接吃 listOverviews 全量:归档只影响界面,召回照旧(用户实测反馈)。
+  //   只对 source='dsh' 生效:archived 是会话级标记,历史网页端/导入条目没有会话行。
+  const archived = (() => {
+    try {
+      return typeof store.archivedConvIdSet === 'function' ? store.archivedConvIdSet() : new Set();
+    } catch {
+      return new Set();
+    }
+  })();
+  // Part G G2(2026-09-25):被"遗忘"的条目不再参与召回。
+  //   遗忘是**软标记**(库里行还在,归档文件也在),所以撤销标记就恢复 —— 但召回必须真的不再选它,
+  //   否则"忘了"只是界面上的幻觉:主人说要忘,我却还在每一次开口时想起来。
+  //   键是 `source|conv_id`:历史网页端与导入条目没有会话行,不能只按会话判。
+  const forgotten = (() => {
+    try {
+      return typeof store.forgottenConvIdSet === 'function' ? store.forgottenConvIdSet() : new Set();
+    } catch {
+      return new Set();
+    }
+  })();
+  const all = store.listOverviews({ onlyOk: true });
+  // D9-a 血缘加权(2026-09-18):当前会话所属枝 → 每条记忆所属枝的档位
+  //   (同枝 1.0 / 祖先 0.7 / 旁系或后代 0.4)。取"最弱环"单值,**不做连乘** ——
+  //   `0.7^5=0.168`、`0.4^5=0.010`,连乘会让深枝等于从记忆里消失(见 `memory.js` 的 `LINEAGE_*`)。
+  //   记忆行不冗余存 branch,靠 `session_meta.branch_id` 推导(见内部记忆树设计笔记 §2.2)。
+  const ctx = lineageContext(store, o.sessionId);
+  const scored = all
+    .map((row) => {
+      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;
+      const lineage = lineageOf(ctx, row);
+      // D9-b:矛盾降权 —— 检出矛盾但未复盘时"以最新为准",旧的一方乘 CONFLICT_DOWNWEIGHT(0.3)。
+      //   只降权、不删除、不改内容(设计稿 §4 的核心不变量)。
+      const conf = conflictOf(ctx, row);
+      return { row, score: raw * lineage * conf, lineage, raw, heat, kw, rich, conf };
+    })
+    .filter((x) => x.score > 0
+      && !(x.row.source === 'dsh' && archived.has(String(x.row.conv_id)))
+      && !forgotten.has(String(x.row.source) + '|' + String(x.row.conv_id)))
+    .sort((a, b) => b.score - a.score || String(b.row.updated_at || '').localeCompare(String(a.row.updated_at || '')));
+  const chosen = scored.slice(0, max);
+  // budget-aware trim
+  const items = [];
+  let totalChars = 0;
+  for (const c of chosen) {
+    const line = lineFor(c.row, { maxChars: o.maxLineChars, summaryChars: o.summaryChars });
+    if (items.length >= max || totalChars + line.length > budget) break;
+    items.push({ ...c.row, score: +c.score.toFixed(3), lineage: +Number(c.lineage).toFixed(2), conf: +Number(c.conf ?? 1).toFixed(2), raw: +Number(c.raw).toFixed(3), kw: c.kw, rich: c.rich, line });
+    totalChars += line.length;
+  }
+  return {
+    items,
+    dropped: scored.length - items.length,
+    totalChars,
+    mode,
+    budget,
+  };
+}
+
+const SUMMARY_CHARS_DEFAULT = 110;
+/** 取"第一句":按中文句末标点(。；！？及英文 !?;)切;切完仍超 cap 则硬截并标 …。
+ *  cap ≤ 0 = 不截(供测试与向后兼容)。 */
+export function firstSentence(text, cap = SUMMARY_CHARS_DEFAULT) {
+  const t = String(text || '').trim();
+  if (!t) return '';
+  const m = t.match(/^[\s\S]*?[。；！？!?;]/);
+  let head = (m ? m[0] : t).trim();
+  const limit = Number(cap) > 0 ? Math.max(40, Number(cap)) : 0;
+  if (limit && head.length > limit) {
+    const slice = head.slice(0, limit);
+    const cut = Math.max(slice.lastIndexOf('，'), slice.lastIndexOf(','), slice.lastIndexOf('、'));
+    head = (cut >= Math.floor(limit * 0.6) ? slice.slice(0, cut) : slice) + '…';
+  }
+  return head;
+}
+
+/**
+ * 一行 L1 记忆(两段结构 + 允许缺省,2026-09-16 与用户定案):
+ *   有摘要 → `标题 —— 摘要第一句`(第一句超 summaryChars 再硬截)
+ *   无摘要 → 只用标题(信息量优先,不截;仍受 maxChars 兜底)
+ *   摘要自带标题(概述器/深摘的常态)→ 不重复前缀,只留正文
+ * @param {object} row
+ * @param {{maxChars?:number, summaryChars?:number}} opts
+ */
+function lineFor(row, { maxChars = 0, summaryChars = SUMMARY_CHARS_DEFAULT } = {}) {
+  const date = isoDate(row.updated_at || row.started_at);
+  const tags = Array.isArray(row.domain_tags) && row.domain_tags.length ? `[${row.domain_tags.slice(0, 2).join('/')}]` : `[${row.category}]`;
+  const title = String(row.title || '').trim();
+  const summary = String(row.summary || '').trim();
+  // 摘要去掉标题前缀,只留正文(摘要自带标题时不重复)
+  let body = summary;
+  if (title && body.startsWith(title)) body = body.slice(title.length).replace(/^[\s:：—-]+/, '');
+  if (body === title) body = '';
+  const text = (title && body) ? `${title} —— ${firstSentence(body, summaryChars)}` : (title || firstSentence(body, summaryChars));
+  // 兜底硬顶:只对病态长标题生效(摘要侧已由 summaryChars 控住)
+  const cap = Number(maxChars) > 0 ? Math.max(60, Number(maxChars)) : 0;
+  let out = text;
+  if (cap && out.length > cap) {
+    const slice = out.slice(0, cap);
+    const cut = Math.max(slice.lastIndexOf('。'), slice.lastIndexOf('；'), slice.lastIndexOf('！'), slice.lastIndexOf('？'), slice.lastIndexOf('\n'));
+    out = (cut >= Math.floor(cap * 0.5) ? slice.slice(0, cut + 1) : slice) + '…';
+  }
+  const srcName = row.source === 'dsh' ? 'DSH 会话' : row.source === 'import' ? '文件导入' : '历史会话';
+  // DSH 会话 id 一律以 "session-" 开头,取前 8 位会全都一样 —— 这时取前缀之后的那一段才可区分
+  const cid = String(row.conv_id || '');
+  const short = cid.startsWith('session-') ? cid.slice(8, 16) : cid.slice(0, 8);
+  return `- ${tags} ${date ? `(${date})` : ''}${out ? ' ' + out : ''} (来源: ${srcName}/${short})`;
+}
+
+export function formatL1Section(result) {
+  if (!result || !result.items.length) return '';
+  const lines = result.items.map((i) => i.line);
+  if (result.dropped > 0) lines.push(`(已省略 ${result.dropped} 条较低相关记忆)`);
+  return '[记忆·开场]\n' + lines.join('\n');
+}

package/lib/host/lifecycle.js

@@ -0,0 +1,367 @@
+// dsh-ling host — lifecycle wiring (REPORT-02 / DESIGN §4.4):
+//   session events → freeze gate state, snapshot freeze, incremental capture.
+// Every handler is defensive (payload shapes verified at M1b live probe).
+import { svc, pick, isMemoryEligibleHeader, sessionKind, utcIso } from './util.js';
+import { TRUNK_ID } from './memory.js';
+import { freezeSnapshotForSession, invalidateSession, refreshIdleSnapshot } from './inject.js';
+import { summarizeDsh } from './summarizer.js';
+import { extractMessageText, messageSourceKind } from './snapshot.js';
+import { currentMode } from './mode.js';
+
+export function wireLifecycle(ctx, gate, memory, settings, config) {
+  const disposers = [];
+  const wrap = (label, fn) => {
+    const handler = (...args) => {
+      try {
+        fn(...args);
+      } catch (e) {
+        console.debug(`[dsh-ling] ${label} handler error`, e);
+      }
+    };
+    return handler;
+  };
+  // 清掉上次的诊断残留,保证每次重启后诊断只反映本轮真实情况
+  memory.kvSet('dbg.first_event_sample', '');
+  memory.kvSet('dbg.event_no_session', '');
+  memory.kvSet('lifecycle.wired', '1');
+
+  const inTrackedWorkspace = () => {
+    const t = config?.trackWorkspaces || settings.get().memory?.trackWorkspaces;
+    return !Array.isArray(t) || t.includes('*');
+  };
+
+  // ---- 会话启动(新会话 / resume / clear):顶层会话定稿快照 ----
+  //      事件名跨 cohort:`agent/created`(DSH ≥0.1.7)/ `agent/session-start`(≤0.1.6)
+  const startHandler = wrap('session-start', (payload) => {
+      if (!inTrackedWorkspace()) return;
+      const agent = pick(() => payload?.agent, () => payload?.session?.agent, () => payload?.agentCtx);
+      const sessionId = pick(
+        () => agent?.session?.id,
+        () => payload?.session?.id,
+        () => payload?.sessionId,
+        () => payload?.agent?.sessionId,
+      );
+      if (!sessionId) return;
+      const header = pick(() => agent?.session?.header, () => payload?.session?.header, () => payload?.header);
+      if (header && !isMemoryEligibleHeader(header)) return; // 子代理不建快照(R5);D9-a:分叉会话要建
+      // D9-a:分叉会话归枝(建枝 + 挂会话 + 定水位),之后照常定稿快照 —— 它能读到血缘链记忆
+      if (sessionKind(header) === 'fork') ensureForkBranch(memory, agent, header, String(sessionId));
+      const source = pick(() => payload?.source, () => agent?.sessionStartSource);
+      const meta = memory.sessionMeta(String(sessionId));
+      // 模式初始化(修法 A,2026-09-11):
+      //   空会话(含 DSH 复用的空壳/临时文件)不固化模式 —— 清掉旧值,跟随"当前默认";
+      //   只有真正说过话的会话才保留自己的模式;"首次真人输入"时才写下那一刻的默认。
+      const hasContent = memory.hasUserTurns(String(sessionId));
+      let mode = null;
+      if (!hasContent) {
+        memory.clearSessionMode(String(sessionId));
+        const last = settings.get().mode?.lastMode;
+        mode = (last === 'work' || last === 'life') ? last : platformDefaultMode(ctx, settings);
+      } else {
+        // resume/clear/compact = 保留既有 meta(该会话自己选过的模式优先)
+        if (source !== 'startup' && source !== undefined && meta?.mode && (meta.mode === 'work' || meta.mode === 'life')) {
+          mode = meta.mode;
+        }
+        if (!mode) mode = platformDefaultMode(ctx, settings);
+        memory.setSessionMode(String(sessionId), mode);
+      }
+      gate.ensure(String(sessionId), { mode });
+      freezeSnapshotForSession(gate, memory, settings, agent);
+    });
+  // ⚠️ 事件改名(2026-09-25 夜**实测**):`agent/session-start` 在 DSH **0.1.7** 的
+  //    `node_modules\@deepseek-ai\dsh\node_modules\@deepseek-ai\**` 里**一个都不存在**;
+  //    现在叫 **`agent/created`**,载荷是 `{ agent, source, signal }` —— 与本 handler 的
+  //    取值路径(`payload.agent` / `payload.source`)**完全一致**,只有事件名对不上。
+  //    后果极隐蔽:事件名不存在 ⇒ handler 永不触发 ⇒ **没有快照 ⇒ 记忆与人格注入整段
+  //    静默空白**(只剩时间锚),没有报错、没有日志、库里也不留痕迹。现场取证:
+  //    `last_hit_at` 与所有 `branch_log_wm.<会话>` 全部停在升级之前,`snap.refresh:*` 无新键。
+  //    这正是内部踩坑记录 **B19** 说的那类:**跨进程契约(事件名/字段)驱动的判据,平台升级后
+  //    必须复核一遍** —— 而且失败形态是静默的。
+  //    修法:**两个名字都注册**(跨 cohort 兼容,不赌平台只留哪一个),加短窗口去重
+  //    (将来两者同存时不会定稿两次 → 不会把 hit_count 刷两遍)。
+  const freezeSeen = new Map();
+  const dedupStart = (payload) => {
+    try {
+      const sid = pick(
+        () => payload?.agent?.session?.id,
+        () => payload?.session?.id,
+        () => payload?.sessionId,
+        () => payload?.agent?.sessionId,
+      );
+      const key = sid ? String(sid) : '';
+      const now = Date.now();
+      if (key && freezeSeen.get(key) && now - freezeSeen.get(key) < 3000) return; // 双事件同发时只定稿一次
+      if (key) freezeSeen.set(key, now);
+    } catch { /* 去重失败就照常执行,宁可多定稿一次也不漏 */ }
+    return startHandler(payload);
+  };
+  disposers.push(ctx.on('agent/created', dedupStart));       // DSH ≥0.1.7
+  disposers.push(ctx.on('agent/session-start', dedupStart)); // DSH ≤0.1.6(旧名,保留兼容)
+
+  // ---- agent/status: idle⇄running → 冻结门;running→idle flush pending ----
+  disposers.push(
+    ctx.on('agent/status', wrap('status', (payload) => {
+      const obs = gate.observeStatusEvent(payload);
+      let sid = null;
+      let running = null;
+      if (obs) {
+        sid = obs.sessionId;
+        running = obs.running === true;
+      } else {
+        sid = pick(() => payload?.agent?.session?.id, () => payload?.agent?.id, () => payload?.id);
+        const raw = pick(() => payload?.status, () => payload?.state);
+        if (sid && typeof raw === 'string') running = raw === 'running';
+      }
+      if (!sid || running === null) return;
+      const flippedIdle = gate.setRunning(String(sid), running);
+      if (flippedIdle) {
+        // 空闲边界:对会话日志做水位差分捕捉(与 session/event 双保险,幂等)
+        const sess = pick(() => payload?.agent?.session, () => payload?.session, () => payload?.agentSession);
+        try {
+          captureSessionDiff(memory, sess, settings);
+        } catch (e) {
+          console.debug('[dsh-ling] idle-diff capture failed', e);
+        }
+        // B:空闲边界刷新 —— 记忆长进之后,把该会话的 L1 追平到最新。
+        // 只可能在 running→idle 时发生,故 D4(运行中注入面逐字节不变)天然保持。
+        try {
+          refreshIdleSnapshot(gate, memory, settings, String(sid), {
+            summarize: () => summarizeDsh(memory, { force: false }),
+          });
+        } catch (e) {
+          console.debug('[dsh-ling] idle refresh failed', e);
+        }
+      }
+    })),
+  );
+
+  // ---- session/event: 逐条增量捕捉(顶层会话;被动记录,不受冻结门限制) ----
+  // 契约:('session/event', (session, event) => void)
+  // 真实事件形状(磁盘取证):{ type, seq, time(ms), data:{ content|message.content, source } }
+  disposers.push(
+    ctx.on('session/event', wrap('event-capture', (session, event) => {
+      const type = event?.type;
+      if (!event) {
+        if (!memory.kvGet('dbg.first_event_sample')) {
+          try {
+            memory.kvSet('dbg.first_event_sample', JSON.stringify({
+              note: 'event 参数缺失', sessionKeys: session ? Object.keys(session).slice(0, 10) : null,
+            }).slice(0, 300));
+          } catch {}
+        }
+        return;
+      }
+      if (type !== 'user/message' && type !== 'assistant/message') return;
+      // 只留真人消息(排除 plugin/skill-catalog/goal 注入)
+      if (type === 'user/message' && messageSourceKind(event) !== 'user') return;
+      const sessionId = pick(
+        () => session?.id,
+        () => session?.header?.id,
+        () => session?.sessionId,
+      );
+      if (!sessionId) {
+        if (!memory.kvGet('dbg.event_no_session')) {
+          memory.kvSet('dbg.event_no_session', JSON.stringify({ type, eventKeys: Object.keys(event).slice(0, 10) }).slice(0, 300));
+        }
+        return;
+      }
+      const header = pick(() => session?.header, () => session?.headerMeta);
+      if (header && !isMemoryEligibleHeader(header)) return; // 子代理/嵌套不入库(D9-a:分叉会话入枝)
+      const text = extractMessageText(event);
+      if (!text) return;
+      const seq = Number(event?.seq ?? (memory.rawTurnCount(sessionId) + 1));
+      const time = Number(event?.time);
+      const isUser = type.startsWith('user');
+      memory.appendRawTurn(String(sessionId), {
+        seq,
+        role: isUser ? 'user' : 'assistant',
+        ts: time && !Number.isNaN(time) ? new Date(time).toISOString() : null,
+        model: null,
+        text,
+      });
+      if (isUser) stampModeIfFirstInput(memory, settings, String(sessionId));
+    })),
+  );
+
+  // ---- session/disposed: 归档点(会话拆除后,天然安全) ----
+  disposers.push(
+    ctx.on('session/disposed', wrap('disposed', (payload) => {
+      const sessionId = pick(() => payload?.session?.id, () => payload?.sessionId, () => payload?.id);
+      if (!sessionId) return;
+      const sid = String(sessionId);
+      memory.markArchived(sid);
+      // (2026-09-16 用户定案 A)归档**不做自动清理**:归档只是标记"该会话结束了",
+      // 而 session/disposed 对每个关闭的会话都会触发 —— 自动删概述会长期把记忆库掏空。
+      // 清理改为人工:①DSH 官方「设置 → 归档会话」里直接删;②tools/clean-archived.mjs --write(先看清单)。
+      // 归档的语义保留为"停更":概述器跳过 archived=1 的会话(见 summarizer.js);该会话一旦有新轮次即复活。
+    })),
+  );
+
+  return () => {
+    for (const d of disposers) {
+      try {
+        d();
+      } catch {}
+    }
+  };
+}
+
+/** D9-a(2026-09-18):分叉会话自动建枝。
+ *  分叉 = 主人显式开的并行工作线,它**有自己的记忆**(写在所属枝里),同时**能读祖先链**。
+ *  - 父枝:父会话所属枝(逐级上溯,天然支持"枝上再分枝");
+ *  - 水位:分叉点之前属于父枝的历史,不重复计入本枝(见内部记忆树设计笔记 §6.1);
+ *  - 枝名:先留空,命名沿用 D2 的 retitle 链路(retitleOne 会补)。
+ *  幂等:重启/resume 时已挂枝则直接返回。 */
+function ensureForkBranch(memory, session, header, sessionId) {
+  try {
+    const parentSid = String(pick(() => header?.parentSession) ?? '');
+    if (!parentSid) return memory.branchOfSession(sessionId);
+    const existing = memory.branchOfSession(sessionId);
+    if (existing && existing !== TRUNK_ID) return existing; // 已建过
+    const parentBranch = memory.branchOfSession(parentSid);
+    let forkSeq =
+      Number(pick(() => session?.inheritedEventCount, () => session?.header?.inheritedEventCount) ?? 0) || 0;
+    // 兜底(2026-09-19 实机教训):平台没给出 inheritedEventCount 时水位会被写成 0,
+    // 于是 idle 边界上 captureSessionDiff 会把 seed(父会话继承来的全部历史)当成新轮次灌进枝。
+    // 取不到就退回"快照里已有的最大 seq"(≈ 分叉点),让水位落在正确位置。
+    if (!forkSeq && typeof session?.snapshotEvents === 'function') {
+      try {
+        const evs = session.snapshotEvents();
+        if (Array.isArray(evs) && evs.length) {
+          forkSeq = evs.reduce((mx, e) => Math.max(mx, Number(e?.seq ?? 0)), 0);
+        }
+      } catch {
+        /* 仍是 0:由 captureSessionDiff 的 isOwnSeq 过滤兜底 */
+      }
+    }
+    const branchId = memory.createBranch({
+      kind: 'branch',
+      parentId: parentBranch,
+      forkAt: parentSid,
+      forkSeq,
+      name: branchSeedName(memory, parentSid),
+    });
+    memory.setSessionBranch(sessionId, branchId);
+    if (memory.kvGet('wm:' + sessionId) == null) memory.kvSet('wm:' + sessionId, String(forkSeq));
+    memory.kvSet(
+      'branch.last_created',
+      JSON.stringify({ branchId, parentSid, parentBranch, forkSeq, at: utcIso() }).slice(0, 300),
+    );
+    return branchId;
+  } catch (e) {
+    console.debug('[dsh-ling] ensureForkBranch failed', e);
+    return TRUNK_ID;
+  }
+}
+
+/** D9-a 枝名种子:先借源会话的标题(器灵起名的第一层),复盘时可改、可上锁。
+ *  枝刚建立时还没有自己的内容,故这里不调模型 —— 免得"每开一个分叉就打一次 LLM"。 */
+function branchSeedName(memory, parentSid) {
+  try {
+    const t = memory.overviewTitleOf(parentSid);
+    return t ? String(t).slice(0, 40) : '';
+  } catch {
+    return '';
+  }
+}
+
+/** 首次真人输入时才固化会话模式(修法 A:空会话永远跟随当前默认)。 */
+function stampModeIfFirstInput(memory, settings, sessionId) {
+  const sid = String(sessionId);
+  const meta = memory.sessionMeta(sid);
+  if (meta && (meta.mode === 'work' || meta.mode === 'life')) return false;
+  memory.setSessionMode(sid, currentMode(memory, settings, sid));
+  return true;
+}
+
+/** 平台默认模型 → 模式:effort low/off=生活;max=工作;high/未知=回退 lastMode。 */
+function platformDefaultMode(ctx, settings) {
+  try {
+    const adm = svc(ctx, 'agentDefaultModel');
+    const sel = adm && typeof adm.currentSelection === 'function' ? adm.currentSelection() : null;
+    const eff = sel && sel.reasoningEffort;
+    if (eff === 'low' || eff === 'off') return 'life';
+    if (eff === 'max') return 'work';
+  } catch (e) {
+    console.debug('[dsh-ling] platformDefaultMode failed', e);
+  }
+  const last = settings.get().mode?.lastMode;
+  return last === 'work' ? 'work' : 'life';
+}
+
+/**
+ * 空闲边界差分捕捉:直接对会话快照事件日志按水位线(wm:<sid>)追加新增的
+ * user/assistant 消息;以 (session_id, seq) 为主键幂等,与 session/event 订阅双保险。
+ * @returns 新增入库条数
+ */
+export function captureSessionDiff(memory, session, settings = null) {
+  if (!session) return 0;
+  const sid = pick(() => session?.id, () => session?.header?.id);
+  if (!sid) return 0;
+  const header = pick(() => session?.header, () => session?.headerMeta);
+  if (header && !isMemoryEligibleHeader(header)) return 0; // 子代理不入库(R5);D9-a:分叉会话入枝
+  const kind = sessionKind(header);
+  if (typeof session.snapshotEvents !== 'function') return 0;
+  let events;
+  try {
+    events = session.snapshotEvents();
+  } catch {
+    return 0;
+  }
+  if (!Array.isArray(events)) return 0;
+  // D9-a:分叉会话的 seed 前缀是"父会话的历史",不是这条枝新产生的记忆 ——
+  // 平台用 isOwnSeq(seq >= inheritedEventCount) 标记自有事件;顶层会话该值为 0,过滤对它们无影响。
+  if (kind === 'fork' && typeof session.isOwnSeq === 'function') {
+    try {
+      events = events.filter((ev) => session.isOwnSeq(Number(ev?.seq ?? 0)));
+    } catch {
+      /* 过滤失败就按全量走,水位线仍是一道保险 */
+    }
+  }
+  const key = 'wm:' + sid;
+  let wm = Number(memory.kvGet(key) || 0);
+  let lastSeq = wm;
+  let added = 0;
+  let userAdded = 0;
+  const typeCount = {};
+  const msgLike = [];
+  for (const ev of events) {
+    const s = Number(ev?.seq ?? 0);
+    if (s > lastSeq) lastSeq = s;
+    if (!s || s <= wm) continue;
+    const type = ev?.type;
+    if (!type) continue;
+    typeCount[type] = (typeCount[type] || 0) + 1;
+    if (String(type).includes('message') && msgLike.length < 3) {
+      const data = ev?.data ?? {};
+      msgLike.push({
+        type,
+        dataKeys: Object.keys(data).slice(0, 8),
+        msgKeys: data?.message && typeof data.message === 'object' ? Object.keys(data.message).slice(0, 8) : null,
+      });
+    }
+    if (type !== 'user/message' && type !== 'assistant/message') continue;
+    // 只留真人消息
+    if (type === 'user/message' && messageSourceKind(ev) !== 'user') continue;
+    const text = extractMessageText(ev);
+    if (!text) continue;
+    const time = Number(ev?.time);
+    memory.appendRawTurn(String(sid), {
+      seq: s,
+      role: type.startsWith('user') ? 'user' : 'assistant',
+      ts: time && !Number.isNaN(time) ? new Date(time).toISOString() : null,
+      model: null,
+      text,
+    });
+    added += 1;
+    if (type.startsWith('user')) userAdded += 1;
+  }
+  if (lastSeq > wm) memory.kvSet(key, String(lastSeq));
+  if (userAdded > 0 && settings) stampModeIfFirstInput(memory, settings, sid);
+  if (added === 0 && !memory.kvGet('dbg.diff_types') && Object.keys(typeCount).length) {
+    try {
+      memory.kvSet('dbg.diff_types', JSON.stringify({ types: typeCount, msgLike }).slice(0, 900));
+    } catch {}
+  }
+  return added;
+}