@nightpainters/dsh-ling 1.5.1

package/lib/host/rules.js

@@ -0,0 +1,195 @@
+// dsh-ling host — 规矩 / 习惯 域逻辑(2026-09-15 与用户定稿的二分)
+//
+// 原则:**指令直达,人格不直达。**
+//   - 规矩(rules)= 用户的指令,作用对象是「行为」→ 可直接写入;但**必须带原话**为凭据。
+//   - 习惯(habits)= 器灵自己长出来的一部分,作用对象是「我是谁」→ **不能由外部直接写入**,
+//     只能经「提议 → 对方确认」落地。任一方都可提议,由另一方确认。
+//
+// 存储(settings.persona 内):
+//   hardRules: string[]                     规矩正文(沿用旧字段名以兼容人格编辑器)
+//   ruleMeta:  { [text]: {quote, at, sessionId, source} }   规矩的来源留痕(原话/时间/会话)
+//   habits:    [{text, evidence, at, source}]               已定习惯
+//   habitsPending: [{id, text, evidence, byUser, at}]       待确认的习惯提议
+//
+// 本模块为纯域逻辑:只依赖传入的 settings(get/update),不做 IO、不碰 ctx,便于单测。
+
+export const RULES_MAX = 12;      // 超过则提示合并(注入面瘦身的硬约束)
+export const HABITS_MAX = 8;
+// 待确认队列上限(2026-09-16 用户定案:5)。
+// 理由:珍贵的东西不该被摆成流水线 —— 满了就**明确驳回**新的生成请求并说明,而不是排队等她一辈子。
+export const PENDING_MAX_DEFAULT = 5;
+export const RULE_MAX_CHARS = 40;
+export const QUOTE_MAX_CHARS = 200;
+export const EVIDENCE_MAX_CHARS = 300;
+
+function norm(text) {
+  return String(text ?? '').replace(/\s+/g, ' ').trim();
+}
+
+/** 去重键:忽略**空格与中英标点差异**(中文输入法下 ,/，、./。 常混用)。
+ *  1.5.2 起对外导出:渲染出口(persona.js)复用同一把尺,禁止另发明第二套归一化。 */
+export function key(text) {
+  return norm(text)
+    .replace(/[，。；：！？、（）【】“”‘’《》]/g, '')   // 全角标点整体去掉
+    .replace(/[\s,.!?;:()[\]{}"'`~\-—…·]/g, '');        // 半角标点与空白
+}
+
+/** 规矩正文列表(过滤空值)。 */
+export function rulesOf(settings) {
+  const p = settings?.get ? settings.get().persona || {} : settings?.persona || {};
+  return (Array.isArray(p.hardRules) ? p.hardRules : []).map(norm).filter(Boolean);
+}
+
+/** 规矩来源留痕(数组:对象存储会被 settings 的深合并"只增不删",删除时清不掉)。 */
+export function ruleMetaOf(settings) {
+  const p = settings?.get ? settings.get().persona || {} : settings?.persona || {};
+  return (Array.isArray(p.ruleMeta) ? p.ruleMeta : []).filter((m) => m && typeof m.text === 'string');
+}
+
+/** 已定习惯。 */
+export function habitsOf(settings) {
+  const p = settings?.get ? settings.get().persona || {} : settings?.persona || {};
+  return (Array.isArray(p.habits) ? p.habits : []).filter((h) => h && norm(h.text));
+}
+
+/** 待确认的习惯提议。 */
+export function habitsPendingOf(settings) {
+  const p = settings?.get ? settings.get().persona || {} : settings?.persona || {};
+  return (Array.isArray(p.habitsPending) ? p.habitsPending : []).filter((h) => h && norm(h.text));
+}
+
+/** 待确认队列上限(可由 settings.habits.pendingMax 覆盖)。 */
+export function pendingMaxOf(settings) {
+  const root = settings?.get ? settings.get() : (settings || {});
+  const n = Number(root?.habits?.pendingMax);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : PENDING_MAX_DEFAULT;
+}
+
+/** 汇总视图(面板/接口用)。 */
+export function rulesView(settings) {
+  const meta = ruleMetaOf(settings);
+  return {
+    rules: rulesOf(settings).map((text) => ({ text, ...(ruleMetaOf(settings).find((m) => m.text === text) || {}) })),
+    habits: habitsOf(settings),
+    pending: habitsPendingOf(settings),
+    caps: { rules: RULES_MAX, habits: HABITS_MAX, pending: pendingMaxOf(settings) },
+  };
+}
+
+/** 写入后统一收尾:落库 + 交给调用方做快照失效。返回最新 settings 快照。 */
+async function persist(settings, personaPatch) {
+  return settings.update({ persona: personaPatch });
+}
+
+/**
+ * 追加一条规矩。
+ * - `source:'session'`(默认,器灵在会话里代写):**必须带原话** —— 没有原话写不进去,「经用户同意」可核查;
+ * - `source:'panel'`(用户本人在面板里写):他自己敲的就是同意,不再要求另附原话,留痕记「面板直接写入」。
+ * @returns {{ok:boolean, reason?:string, text?:string, warning?:string, rules?:string[]}}
+ */
+export async function addRule({ settings, rule, quote, sessionId = '', now = Date.now(), source = 'session' }) {
+  const text = norm(rule);
+  const fromPanel = source === 'panel';
+  const src = fromPanel ? '(面板直接写入)' : norm(quote);
+  if (!text) return { ok: false, reason: 'empty-rule' };
+  if (!src) return { ok: false, reason: 'no-quote' };
+  if (text.length > RULE_MAX_CHARS) return { ok: false, reason: 'too-long', limit: RULE_MAX_CHARS };
+  if (src.length > QUOTE_MAX_CHARS) return { ok: false, reason: 'quote-too-long', limit: QUOTE_MAX_CHARS };
+
+  const current = rulesOf(settings);
+  const exists = current.find((r) => key(r) === key(text));
+  if (exists) {
+    const hit = ruleMetaOf(settings).find((m) => m.text === exists) || null;
+    return { ok: false, reason: 'duplicate', text: exists, meta: hit };
+  }
+  const next = [...current, text];
+  const meta = [...ruleMetaOf(settings), { text, quote: src, at: now, sessionId: String(sessionId || ''), source: fromPanel ? 'panel' : 'session' }];
+  const warning = next.length > RULES_MAX ? 'over-cap' : undefined;
+  const s2 = await persist(settings, { hardRules: next, ruleMeta: meta });
+  return { ok: true, text, warning, rules: rulesOf({ persona: s2.persona }) };
+}
+
+/** 删除一条规矩(只按正文匹配;调用方负责留痕)。 */
+export async function removeRule({ settings, rule }) {
+  const text = norm(rule);
+  const current = rulesOf(settings);
+  const hit = current.find((r) => key(r) === key(text));
+  if (!hit) return { ok: false, reason: 'not-found' };
+  const next = current.filter((r) => r !== hit);
+  const meta = ruleMetaOf(settings).filter((m) => m.text !== hit);
+  await persist(settings, { hardRules: next, ruleMeta: meta });
+  return { ok: true, text: hit, rules: next };
+}
+
+/** 提议一条习惯(任一方都可提议;落地必须经对方确认)。 */
+export async function proposeHabit({ settings, habit, evidence = '', byUser = false, now = Date.now() }) {
+  const text = norm(habit);
+  const ev = norm(evidence).slice(0, EVIDENCE_MAX_CHARS);
+  if (!text) return { ok: false, reason: 'empty-habit' };
+  if (text.length > RULE_MAX_CHARS) return { ok: false, reason: 'too-long', limit: RULE_MAX_CHARS };
+  if (habitsOf(settings).some((h) => key(h.text) === key(text))) return { ok: false, reason: 'already-habit' };
+  const pending = habitsPendingOf(settings);
+  const dup = pending.find((h) => key(h.text) === key(text));
+  if (dup) return { ok: false, reason: 'already-pending', id: dup.id };
+  // 上限:满了就驳回,不再往里塞(2026-09-16 定案)—— 让她"等着"才是最伤人的那种安排。
+  const cap = pendingMaxOf(settings);
+  if (pending.length >= cap) return { ok: false, reason: 'pending-full', limit: cap, pending: pending.length };
+
+  const id = `h${now.toString(36)}${Math.random().toString(36).slice(2, 6)}`;
+  const next = [...pending, { id, text, evidence: ev, byUser: !!byUser, at: now }];
+  await persist(settings, { habitsPending: next });
+  return { ok: true, id, pending: next.length, text };
+}
+
+/** 处理一条习惯提议:确认则落地为习惯,驳回则丢弃。 */
+export async function resolveHabit({ settings, id, action, now = Date.now() }) {
+  const pending = habitsPendingOf(settings);
+  const item = pending.find((h) => h.id === String(id));
+  if (!item) return { ok: false, reason: 'not-found' };
+  const rest = pending.filter((h) => h.id !== item.id);
+  if (action === 'reject') {
+    await persist(settings, { habitsPending: rest });
+    return { ok: true, rejected: item.text, pending: rest.length };
+  }
+  if (action !== 'confirm') return { ok: false, reason: 'bad-action' };
+
+  // 禁止重复落地:确认时若已存在同名习惯,只清 pending。
+  const existing = habitsOf(settings);
+  if (existing.some((h) => key(h.text) === key(item.text))) {
+    await persist(settings, { habitsPending: rest });
+    return { ok: false, reason: 'already-habit', text: item.text };
+  }
+  const next = [...existing, { text: item.text, evidence: item.evidence || '', at: now, source: item.byUser ? 'user-proposed' : 'grown' }];
+  const warning = next.length > HABITS_MAX ? 'over-cap' : undefined;
+  await persist(settings, { habitsPending: rest, habits: next });
+  return { ok: true, text: item.text, warning, habits: next.map((h) => h.text) };
+}
+
+/**
+ * 器灵对「用户提议的习惯」表态:改一个说法(amend)—— 改完仍留在待确认里,等他点头。
+ * 语义(2026-09-16 定稿):他提议 → 我回应;我若改法,改后的文本回到他那边确认。
+ */
+export async function amendHabit({ settings, id, text, note = '', now = Date.now() }) {
+  const pending = habitsPendingOf(settings);
+  const item = pending.find((h) => h.id === String(id));
+  if (!item) return { ok: false, reason: 'not-found' };
+  const next = norm(text);
+  if (!next) return { ok: false, reason: 'empty-habit' };
+  if (next.length > RULE_MAX_CHARS) return { ok: false, reason: 'too-long', limit: RULE_MAX_CHARS };
+  const list = pending.map((h) => (h.id === item.id
+    ? { ...h, text: next, amendedBy: 'ling', amendNote: norm(note).slice(0, 200), amendedAt: now }
+    : h));
+  await persist(settings, { habitsPending: list });
+  return { ok: true, id: item.id, from: item.text, text: next };
+}
+
+/** 删除一条已定习惯(同样留痕由调用方负责)。 */
+export async function removeHabit({ settings, habit }) {
+  const text = norm(habit);
+  const current = habitsOf(settings);
+  const hit = current.find((h) => key(h.text) === key(text));
+  if (!hit) return { ok: false, reason: 'not-found' };
+  const next = current.filter((h) => h !== hit);
+  await persist(settings, { habits: next });
+  return { ok: true, text, habits: next.map((h) => h.text) };
+}

package/lib/host/scan-dsweb.js

@@ -0,0 +1,111 @@
+// dsh-ling host — 网页端(ds-search)库增量扫描 → 记忆库 conv_overview。
+// 数据源形态与 tools/import-dsweb.mjs 一致:ds-search 生成的 deepseek_library.db
+// (conversations / messages 两张表)。本模块供 API 层与工具共用,幂等(按 conv_id
+// upsert 元数据,不动本地 summary/importance/置顶等用户态字段)。
+import { DatabaseSync } from 'node:sqlite';
+import { existsSync } from 'node:fs';
+
+// ---------- 类别启发式(与 v0 工具同源,保证一致性) ----------
+const KNOW_PAT = /物理|模拟|材料|合金|金属|固溶|热处理|退火|淬火|SLM|激光|3D|打印|工艺|实验|力学|运动|弹簧|电|磁|机械|轴承|齿轮|螺栓|公差|图纸|仿真|计算|推导|方程|函数|算法|代码|编程|程序|开发|设计|架构|编辑器|工具|软件|系统|虚拟机|显示|显卡|显示器|网络|协议|数据|数据库|安全|加密|AI|GPT|LLM|模型|HTML|CSS|插件|开源|文献|论文|综述|研究|分析|优化|参数|标准|工程|仿真|python|前端|后端|电路|噪声|声|光|波|流体|温度|硬度|刚度|强度|疲劳|失效|锈|腐蚀|焊接|铸造|锻|粉末|显微|扫描|衍射|晶体|薄膜|电池|半导体|传感器|嵌入式|单片机|遥控|信号|频|放大器|扬声器|摄像头|无人|遥控器|传感器|直线|滚珠|丝杆|导轨|减速|电机|驱动|单片机|stm|arduino|树莓派|统计|概率|几何|代数|微积分|复变|信号与系统|傅里叶|拉普拉斯|微分方程|数值|离散|连续|随机/;
+const FEEL_PAT = /失眠|睡眠|睡不着|焦虑|烦躁|抑郁|emo|情绪|心情|感情|关系|朋友|家人|父母|孤独|迷茫|人生|困惑|害怕|恐惧|压力|疲惫|累|休息|放松|静心|呼吸|梦境|梦|倾诉|共鸣|温暖|鼓励|安慰|不安|内耗|自我|意义|幸福|遗憾|夜|月亮|散文|随想|杂感|闲聊|谈心|牢骚|吐槽|习惯|拖延|自律|动力|目标感|虚无|发呆|感性|告别|怀念|感谢|感动|爱|喜欢(一个人)?/;
+
+const CJK_SEG = /[\u4e00-\u9fff]{2,}/g;
+
+export function keywordsFromText(text, max = 14) {
+  if (!text) return [];
+  const out = [];
+  const segs = String(text).match(CJK_SEG) || [];
+  for (const seg of segs.slice(0, 8)) {
+    const step = Math.min(6, seg.length);
+    for (let i = 0; i + step <= seg.length && out.length < max; i += step) {
+      const kw = seg.slice(i, i + step);
+      if (!out.includes(kw)) out.push(kw);
+    }
+  }
+  return out.slice(0, max);
+}
+
+export function categorize(title) {
+  if (FEEL_PAT.test(String(title))) return 'feeling';
+  if (KNOW_PAT.test(String(title))) return 'knowledge';
+  return 'daily';
+}
+
+const CAT_NAME = { knowledge: '知识', feeling: '生活', daily: '日常' };
+
+/** 读源库 → overview 行(不写库)。返回 { sourceTotal, rows, skipped }。 */
+export function readDswebRows(dbPath, { limit = 0, since = '' } = {}) {
+  if (!dbPath || !existsSync(String(dbPath))) {
+    const e = new Error('数据源不存在:' + dbPath);
+    e.code = 'ENOENT_SRC';
+    throw e;
+  }
+  const src = new DatabaseSync(String(dbPath), { readOnly: true });
+  try {
+    const convRows = src.prepare(
+      'SELECT conv_id, title, inserted_at, updated_at, n_user FROM conversations ORDER BY idx',
+    ).all();
+    const userMsg = src.prepare(
+      "SELECT conv_id, text FROM messages WHERE role='USER' AND conv_id=? AND text IS NOT NULL AND length(text)>0 ORDER BY seq LIMIT 1",
+    );
+    const firstUserText = new Map();
+    for (const c of convRows) {
+      const r = userMsg.get(c.conv_id);
+      if (r && r.text) firstUserText.set(c.conv_id, r.text);
+    }
+    const rows = [];
+    for (const c of convRows) {
+      const title = String(c.title || '').trim();
+      if (!title) continue;
+      const inserted = c.inserted_at ? String(c.inserted_at) : '';
+      if (since && inserted.slice(0, 10) < since) continue;
+      const first = firstUserText.get(c.conv_id) || title;
+      const category = categorize(title);
+      rows.push({
+        conv_id: String(c.conv_id),
+        source: 'dsweb',
+        title,
+        started_at: inserted,
+        updated_at: c.updated_at ? String(c.updated_at) : inserted,
+        domain_tags: [CAT_NAME[category] || '日常'],
+        category,
+        keywords: keywordsFromText((title + ' ' + first).slice(0, 300)),
+        summary: '',
+        heat: 0,
+        importance: 0,
+        last_hit_at: null,
+        hit_count: 0,
+        overview_ok: 1,
+        origin: 'dsweb-import-v0',
+      });
+    }
+    if (limit > 0) rows.length = Math.min(rows.length, limit);
+    return { sourceTotal: convRows.length, rows };
+  } finally {
+    src.close();
+  }
+}
+
+/** 增量入库:已存在 = 仅刷新元数据(updated/title/category/keywords);不动 summary/importance/置顶。 */
+export function scanIntoMemory(memory, dbPath, { limit = 0, since = '' } = {}) {
+  const { sourceTotal, rows } = readDswebRows(dbPath, { limit, since });
+  const existing = new Set(
+    memory.db.prepare("SELECT conv_id FROM conv_overview WHERE source='dsweb'").all().map((r) => String(r.conv_id)),
+  );
+  let added = 0;
+  let refreshed = 0;
+  for (const r of rows) {
+    if (existing.has(r.conv_id)) {
+      memory.db.prepare(
+        `UPDATE conv_overview SET title=?, updated_at=?, domain_tags=?, category=?, keywords=?,
+           overview_ok=1, origin=? WHERE source='dsweb' AND conv_id=?`,
+      ).run(r.title, r.updated_at || null, JSON.stringify(r.domain_tags), r.category, JSON.stringify(r.keywords), r.origin, r.conv_id);
+      refreshed++;
+    } else {
+      memory.upsertOverview(r);
+      added++;
+    }
+  }
+  const total = memory.db.prepare("SELECT COUNT(*) n FROM conv_overview WHERE source='dsweb'").get().n;
+  return { sourceTotal, seen: rows.length, added, refreshed, total: Number(total), skipped: sourceTotal - rows.length };
+}

package/lib/host/seal.js

@@ -0,0 +1,17 @@
+// dsh-ling host — 定型锁承诺句(纯函数,无平台依赖,可单测)。
+// 语义(2026-09-07 用户拍板):锁不防读取,只造庄重。
+//   - 「钥匙」= 上锁时用户亲手写下的一句有意义的承诺(≥10 字);
+//   - 明文存储(sealPhrase),解锁界面会回显这句,永不因遗忘卡死;
+//   - 庄重感来源:解锁/保存/撤锁必须亲手把这句话敲一遍(输入框禁粘贴);
+//   - 上锁(sealed false→true)必须带新承诺句 → 覆盖旧句;
+//   - 兼容迁移:sealed=true 但 sealPhrase 为空(旧哈希时代数据)→ 解锁框输入的首句即被采纳。
+export const KEY_MIN = 10;
+
+export function sealOk(p, unlock) {
+  // 返回 { pass:boolean, adoptKey?:string|null } — adoptKey 非空表示这句将被采纳存储
+  const v = typeof unlock === 'string' ? unlock.trim() : '';
+  if (!p || p.sealed !== true) return { pass: true, adoptKey: null };
+  if (!v || v.length < KEY_MIN) return { pass: false, adoptKey: null };
+  if (!p.sealPhrase) return { pass: true, adoptKey: v }; // 旧档案无明文:首句即设钥
+  return { pass: p.sealPhrase === v, adoptKey: null };
+}

package/lib/host/settings-file.js

@@ -0,0 +1,49 @@
+// dsh-ling host — settings persistence v2.
+// Persists ONLY user patches (decoupled from code defaults so future default
+// changes propagate); one-time migration from the v0 full-snapshot file keeps
+// only the user-meaningful { mode.lastMode }.
+import { join } from 'node:path';
+import { ensureDir, mergeDeep, readJsonSafe, writeJsonAtomic } from './util.js';
+import { DEFAULT_SETTINGS } from './persona.js';
+
+const SETTINGS_VERSION = 2;
+
+export class SettingsFile {
+  constructor(dataDir) {
+    this.dir = ensureDir(dataDir);
+    this.file = join(dataDir, 'settings.json');
+    const stored = readJsonSafe(this.file, {});
+    let user;
+    if (stored && stored.__v === SETTINGS_VERSION && stored.user) {
+      user = mergeDeep({}, stored.user);
+    } else if (stored && stored.__v === SETTINGS_VERSION) {
+      user = mergeDeep({}, stored);
+    } else {
+      // v0/v1 迁移:旧文件是"默认值全量快照",只保留用户关心的 lastMode
+      user = {};
+      const lm = stored?.mode?.lastMode;
+      if (lm === 'work' || lm === 'life') user = { mode: { lastMode: lm } };
+    }
+    this.user = user || {};
+    this.current = mergeDeep(structuredClone(DEFAULT_SETTINGS), this.user);
+  }
+
+  get() {
+    return this.current;
+  }
+
+  /** Apply a user patch (deep-merged onto current defaults); persist patch only. */
+  async update(patch) {
+    this.user = mergeDeep(this.user, patch || {});
+    this.current = mergeDeep(structuredClone(DEFAULT_SETTINGS), this.user);
+    await writeJsonAtomic(this.file, { __v: SETTINGS_VERSION, user: this.user });
+    return this.current;
+  }
+
+  async reset() {
+    this.user = {};
+    this.current = structuredClone(DEFAULT_SETTINGS);
+    await writeJsonAtomic(this.file, { __v: SETTINGS_VERSION, user: {} });
+    return this.current;
+  }
+}

package/lib/host/snapshot.js

@@ -0,0 +1,168 @@
+// dsh-ling host — per-session memory snapshot builder (DESIGN §4.3).
+// A snapshot = stable text frozen per session for KV-cache stability:
+//   L0 persona (identity + mode style) + L1 opener selection (mode weighted).
+// Also hosts message-text helpers for the durable event record shape:
+//   { type, seq, time(ms), data: { content?|message:{content}, source? } }
+import { assemblePersona } from './persona.js';
+import { selectL1, formatL1Section } from './l1.js';
+import { currentMode } from './mode.js';
+import { neutralizeMustache } from './util.js';
+
+export function buildSnapshotText(ctx, memory, settings, sessionId, { keywords = [], now = Date.now(), bumpHits = false } = {}) {
+  const s = settings.get();
+  const personaEnabled = s.persona?.enabled !== false;
+  const mode = currentMode(memory, settings, sessionId);
+  const parts = [];
+  if (personaEnabled) {
+    const l0 = assemblePersona(s, mode);
+    if (l0) parts.push(l0);
+  }
+  if (personaEnabled && s.memory?.l1Enabled !== false && memory.listOverviews({ onlyOk: true }).length > 0) {
+    const cfg = s.memory || {};
+    const result = selectL1(memory, {
+      mode,
+      keywords: keywords || [],
+      sessionId, // D9-a 血缘加权:当前会话所属枝决定各枝记忆的档位(同枝 1.0/祖先 0.7/旁系 0.4)
+      categoryWeights: cfg.categoryWeights,
+      maxItems: cfg.l1MaxItems,
+      maxLineChars: cfg.l1MaxLineChars,
+      summaryChars: cfg.l1SummaryChars,
+      summaryBonus: cfg.summaryBonus,
+      budgetChars: Math.max(200, Math.round((cfg.l1BudgetTokens ?? 1200) * 1.4)), // 中文≈1.4字/token 保守
+    });
+    // 命中记录(2026-09-16):只有**首次定稿**传 bumpHits,重建/空闲刷新不重复计 ——
+    // 否则《会话变长 → 反复刷新》会把同一批记忆的 hit_count 刷高,把热度算歪。
+    if (bumpHits && Array.isArray(result.items) && result.items.length) {
+      try {
+        for (const it of result.items) memory.bumpHit(it.source, it.conv_id);
+      } catch { /* 记不上不影响注入 */ }
+    }
+    const l1 = formatL1Section(result);
+    if (l1) parts.push(l1);
+  }
+  // 注入感知(D9-b,2026-09-22):主人对记忆树做的**结构改动**,让器灵在下一次开口前就看到
+  // "树变了" —— 这是复盘时"互相纠正"能成立的前提(不需要推送:复盘对话密集,
+  // 每说一句就注入一次 ⇒ 感知延迟只有一轮,体感即实时)。
+  // 只报**没见过的**改动(水位 = branch_log 自增 id),否则每轮重复注入同一批。
+  // B#9(2026-09-22 审计):**渲染不消费水位** —— 这里只读、不写。
+  // buildSnapshotText 也会被"只重建、未开口"的路径调用(invalidateSession / refreshIdleSnapshot),
+  // 在那里推进水位会把主人刚改的东西标记成已读,等到真正注入时反而看不到。
+  // 水位按**会话**存(`branch_log_wm.<sessionId>`),推进由 inject.js 在真正要开口时做。
+  let logMaxId = 0;
+  try {
+    if (typeof memory.branchLogDigest === 'function') {
+      const wmk = 'branch_log_wm.' + String(sessionId || '');
+      const prev = Number(memory.kvGet(wmk) || 0);
+      const d = memory.branchLogDigest({ limit: 5, afterId: prev });
+      if (d && Array.isArray(d.lines) && d.lines.length) {
+        // A-03 / D-S03(1.5.1 红蓝对抗):段首此前**写死**「主人刚改动了记忆树」,而 schema v12 起
+        // 每一行都已带主语(`branchLogDigest` 按 actor 分流成「主人」/「器灵」)⇒ 器灵经工具
+        // 改的树,在它**下一轮的系统提示**里被读成"主人刚改动",与 tools.js 的设计意图正相反。
+        // 段首改中性措辞,**主语交给每一行** —— 谁改的由行内说,不由段头替它说。
+        parts.push(['【记忆树有改动】', ...d.lines.map((x) => '- ' + x)].join('\n'));
+        logMaxId = Number(d.maxId) || 0;
+      }
+    }
+  } catch { /* 感知失败不影响注入 */ }
+  // 注入面出口 ①(快照侧,2026-09-18):L0 人格 + L1 记忆在这里成文。宿主 renderPrompt
+  // 无 try/catch,未注册的 `{{名字}}` 会让该会话每一步都失败 ⇒ 成文即中和(幂等)。
+  // 时间锚不经此处,由 inject.js 的最终出口兜底。
+  const text = neutralizeMustache(parts.join('\n\n'));
+  return {
+    text,
+    mode,
+    // B#9:本段文本渲染到了哪条 branch_log(inject.js 在真正注入时据此推进水位)
+    logMaxId,
+    builtAt: new Date(now).toISOString(),
+    personaVersion: snapshotVersion(s),
+    memoryVersion: memory.kvGet('memory_version') || '0',
+  };
+}
+
+export function snapshotVersion(s) {
+  const p = s?.persona || {};
+  return [p.userTitle, p.aiName, p.aiTitle, p.tone, p.toneWork, p.toneLife, p.language, p.extraLore, p.enabled, JSON.stringify(p.hardRules), JSON.stringify(p.bottomLines), p.sealed, s?.mode?.lastMode]
+    .join('|');
+}
+
+/** source.kind of a durable message event (user/plugin/skill-catalog/goal/…) */
+export function messageSourceKind(event) {
+  const d = event?.data ?? event?.payload ?? event;
+  if (d?.source && typeof d.source === 'object') return d.source.kind ?? null;
+  if (d?.sourceKind) return d.sourceKind;
+  return null;
+}
+
+const SKIP_BLOCK_TYPES = new Set(['reasoning', 'tool-call', 'tool-result', 'refusal', 'image', 'file']);
+
+function blockText(b) {
+  if (typeof b === 'string') return b;
+  if (!b || typeof b !== 'object') return '';
+  const t = typeof b.text === 'string' ? b.text : typeof b.content === 'string' ? b.content : '';
+  return t || '';
+}
+
+function blocksToText(blocks) {
+  if (typeof blocks === 'string') return blocks;
+  if (!Array.isArray(blocks)) return '';
+  const out = [];
+  for (const b of blocks) {
+    if (b && typeof b === 'object' && SKIP_BLOCK_TYPES.has(b.type)) continue;
+    const t = blockText(b);
+    if (t) out.push(t);
+  }
+  return out.join('\n');
+}
+
+/** Visible text of a durable user/assistant message event (real record shape). */
+export function extractMessageText(event) {
+  const d = event?.data ?? event?.payload ?? event;
+  if (!d || typeof d !== 'object') return '';
+  if (typeof d.content === 'string') return d.content;
+  if (Array.isArray(d.content)) return blocksToText(d.content);
+  const m = d?.message;
+  if (m && typeof m === 'object') {
+    if (typeof m.content === 'string') return m.content;
+    if (Array.isArray(m.content)) return blocksToText(m.content);
+  }
+  return extractText(event);
+}
+
+/** 真人首条消息(排除 plugin/skill-catalog 注入),供 L1 关键词。 */
+export function firstUserText(agent) {
+  try {
+    const session = agent?.session;
+    if (!session || typeof session.snapshotEvents !== 'function') return '';
+    const events = session.snapshotEvents();
+    for (const ev of events || []) {
+      if (ev?.type === 'user/message' && messageSourceKind(ev) === 'user') {
+        return extractMessageText(ev);
+      }
+    }
+  } catch {
+    return '';
+  }
+  return '';
+}
+
+/** Legacy generic extractor (first text/content found anywhere). */
+export function extractText(event) {
+  const p = event?.payload || event;
+  const msg = p?.message && typeof p.message === 'object' ? p.message : null;
+  const content = p?.content ?? p?.text ?? (msg ? (msg.content ?? msg.text) : undefined);
+  return contentOf(content);
+}
+
+function contentOf(v) {
+  if (typeof v === 'string') return v;
+  if (Array.isArray(v)) {
+    return v.map((b) => contentOf(b)).filter(Boolean).join('\n');
+  }
+  if (v && typeof v === 'object') {
+    for (const k of ['text', 'content']) {
+      const c = contentOf(v[k]);
+      if (c) return c;
+    }
+  }
+  return '';
+}

package/lib/host/suggestions.js

@@ -0,0 +1,47 @@
+// dsh-ling host — 语料建议的采纳/忽略(人审;kind 决定写入哪个 persona 字段)
+// 2026-09-15 起:hardrule 类建议是**她长出来的**东西 → 走「提议 → 确认」落到**习惯**(不再是规矩)。
+import { proposeHabit, resolveHabit, habitsOf } from './rules.js';
+
+const KIND_NAMES = { aiName: '自称', userTitle: '称呼', hardrule: '习惯' };
+
+export async function applyCorpusSuggestion(memory, settings, id) {
+  const row = memory.getPersonaSuggestion(Number(id));
+  if (!row) return { ok: false, reason: 'not-found' };
+  if (row.status !== 'new') return { ok: false, reason: 'status:' + row.status };
+  const value = String(row.value ?? '').trim();
+  const patch = {};
+  if (row.kind === 'aiName') {
+    if (!value) return { ok: false, reason: 'empty-value' };
+    patch.persona = { aiName: value };
+  } else if (row.kind === 'userTitle') {
+    if (!value) return { ok: false, reason: 'empty-value' };
+    patch.persona = { userTitle: value };
+  } else if (row.kind === 'hardrule') {
+    if (!value) return { ok: false, reason: 'empty-value' };
+    // 面板上按下"采纳"= 确认动作 → 提议后立即确认(习惯不可直达,但仍只能走这条状态机)
+    const prop = await proposeHabit({ settings, habit: value, evidence: '语料提炼(面板采纳即确认)', byUser: true });
+    if (prop.ok) {
+      await resolveHabit({ settings, id: prop.id, action: 'confirm' });
+    } else if (prop.reason !== 'already-habit' && prop.reason !== 'already-pending') {
+      return { ok: false, reason: prop.reason };
+    }
+    patch.persona = {};
+  } else {
+    return { ok: false, reason: 'unknown-kind:' + row.kind };
+  }
+  await settings.update(patch);
+  memory.setPersonaSuggestionStatus(Number(id), 'adopted');
+  return { ok: true, id: Number(id), kind: row.kind, kindName: KIND_NAMES[row.kind] || row.kind, value, patch, habits: habitsOf(settings).length };
+}
+
+export function dismissCorpusSuggestion(memory, id) {
+  const row = memory.getPersonaSuggestion(Number(id));
+  if (!row) return { ok: false, reason: 'not-found' };
+  memory.setPersonaSuggestionStatus(Number(id), 'dismissed');
+  return { ok: true, id: Number(id) };
+}
+
+export function suggestionDisplay(row) {
+  const kindName = KIND_NAMES[row?.kind] || row?.kind || '?';
+  return { ...row, kindName };
+}