@nightpainters/dsh-ling 1.5.1

package/lib/host/habit-gen.js

@@ -0,0 +1,273 @@
+// dsh-ling host — 习惯候选生成器(通道 A:零模型数纠正;通道 B:一次 LLM 读记忆回想)
+//
+// 为什么需要它(2026-09-16 与用户定稿):规矩/习惯拆开之后,"习惯"必须由器灵长出来,
+// 但当时只有"会话内即时提议"这一条路 —— 没有任何东西会回头读我们一年多的相处。
+//   - **通道 A(数出来的)**:纯本地规则扫描,零模型、确定性、可单测;
+//   - **通道 B(想出来的)**:一次 LLM 调用,读最近的记忆概述 + A 的统计,归纳 1~3 条候选。
+// 两者都只到"提议"为止 —— 落成习惯必须经用户确认(见 rules.proposeHabit / resolveHabit)。
+//
+// 判定口径(通道 A,**跨会话才叫模式**):
+//   - 同一类纠正(太啰嗦/太文言/太虚/太冷/格式…)累计 ≥4 次,且**分布在 ≥3 个不同会话**(阈值变更记录见下方 SCAN_DEFAULTS);
+//   - 候选文本直接取自 corpus-suggest 里那套纠正桶的规则文案(与语料提炼共用一份口径,避免两套标准)。
+//
+// 本模块只读库、零副作用(不写库、不发消息),便于在接口层决定要不要落成提议。
+
+import { CORRECTION_BUCKETS } from './corpus-suggest.js';
+import { extractJson } from './genesis.js';
+import { isoDate } from './util.js';
+
+export const SCAN_DEFAULTS = Object.freeze({
+  minHits: 4,        // 同类纠正至少出现几次(2026-09-16 用户定案:3 → 4)
+  minSessions: 3,    // 至少跨几个会话(单次会话里被说三遍不算"模式";2 → 3)
+  maxTurns: 20000,   // 最多回看多少条真人轮次(防大库拖慢空闲边界)
+  sampleLimit: 3,    // 每条候选带几段原话摘录
+});
+
+const clean = (s) => String(s ?? '').replace(/\s+/g, ' ').trim();
+
+/**
+ * 扫描纠正信号(纯读)。
+ * @param {{db:{prepare:Function}}} memory MemoryStore 实例
+ * @returns {Array<{key:string, rule:string, hits:number, sessions:number, samples:string[]}>}
+ */
+export function scanCorrections(memory, opts = {}) {
+  const { minHits, minSessions, maxTurns, sampleLimit } = { ...SCAN_DEFAULTS, ...opts };
+  let rows = [];
+  try {
+    rows = memory.db.prepare(
+      // G4:习惯只能从「主人自己的会话」长出来 —— 排除导入命名空间(别人的对话)
+      "SELECT session_id, text FROM dsh_turns_raw WHERE role='user' AND session_id NOT LIKE 'import:%' ORDER BY seq DESC LIMIT ?",
+    ).all(maxTurns);
+  } catch {
+    return [];   // 库结构异常时静默退化(生成器不能拖累别处)
+  }
+
+  const buckets = new Map(CORRECTION_BUCKETS.map((b) => [b.key, {
+    key: b.key, rule: b.rule, hits: 0, sessions: new Set(), samples: [],
+  }]));
+
+  for (const r of rows) {
+    const text = clean(r.text);
+    if (!text) continue;
+    for (const b of CORRECTION_BUCKETS) {
+      if (!b.re.test(text)) continue;
+      const item = buckets.get(b.key);
+      item.hits += 1;
+      item.sessions.add(String(r.session_id ?? ''));
+      if (item.samples.length < sampleLimit) item.samples.push(text.slice(0, 80));
+    }
+  }
+
+  return [...buckets.values()]
+    .filter((b) => b.hits >= minHits && b.sessions.size >= minSessions)
+    .map((b) => ({ key: b.key, rule: b.rule, hits: b.hits, sessions: b.sessions.size, samples: b.samples }))
+    .sort((a, b) => (b.hits - a.hits) || (b.sessions - a.sessions));
+}
+
+/** 人读证据串(≤300 字,写进习惯提议的 evidence 字段)。 */
+export function evidenceOf(cand) {
+  const samples = (cand.samples || []).map((s) => `「${s}」`).join(' / ');
+  return clean(`跨 ${cand.sessions} 个会话、共 ${cand.hits} 次纠正:${samples}`).slice(0, 300);
+}
+
+/** 给面板/接口的人读摘要(不落库)。 */
+export function summarizeScan(candidates) {
+  return candidates.map((c) => ({
+    key: c.key, text: c.rule, hits: c.hits, sessions: c.sessions, evidence: evidenceOf(c),
+  }));
+}
+
+// ── 通道 B:「让她回想最近的相处」 ───────────────────────────────────────────
+// 与通道 A 的分工:A 是"数出来的"(零模型、确定性),B 是"想出来的"(一次 LLM,读记忆概述)。
+// B 同样只产出**提议**,落地仍须用户确认。
+
+export const REFLECT_DEFAULTS = Object.freeze({
+  overviewLimit: 200,    // 回看多少条记忆概述(手动触发,不必省)
+  turnLimit: 800,        // 回看多少条主人的真人原话
+  budgetChars: 200000,   // 材料字符预算(远小于 1M 上下文,留足模型思考空间)
+  maxTokens: 4000,       // 输出预算:够写 1~5 条候选 + 各自的证据
+  maxHabits: 5,          // 一次最多提几条
+  effort: 'off',         // 归纳任务:实测 'low' 只出思考、正文为空且慢十倍(2026-09-16);要更深可在设置里提高
+});
+
+export const HABIT_REFLECT_SYS = `你是器灵的"习惯观察员"。材料是她与主人最近的相处:主人的真人原话、她读过的会话概述、主人反复纠正过的地方,以及她现在的规矩与习惯。
+任务:判断她是否值得新增 1~5 条「习惯」—— 即她**自己长出来的行为倾向**(语气、表达方式、做事节奏、提及记忆的方式),
+而不是主人给她的指令(指令属于「规矩」,不由你提议)。
+
+规则:
+1. 只在材料里确有迹象时才提;迹象不足就返回空数组 —— **宁缺勿滥**;证据越具体,越要提;
+2. 每条 ≤40 字,写成"她自己的倾向"(例:先给结论再展开;夜里说话更轻;不确定就直说不确定);
+3. 每条必须给出证据:依据材料里的哪些原话/哪些重复出现的迹象;
+4. 不要提"称呼、名字、底线、安全"相关内容 —— 那些属于契约,需要主人亲自解锁,不属于习惯;
+5. 不要提泛泛的美德(如"要更努力"),要具体到行为;
+6. 不要重复她已有的规矩或习惯。
+
+只输出 JSON,不要解释:{"habits":[{"text":"…","evidence":"…"}]}`;
+
+/**
+ * 组装"回想"材料(纯读,不落库)。手动触发的调用,材料要给足 —— 预算默认 20 万字符(远小于 1M 上下文)。
+ * 优先级:她现在的规矩/习惯 → 主人反复纠正处 → 主人的真人原话 → 她读过的概述;超预算时从尾部截断。
+ * @returns {{ text: string, stats: {turns:number, overviews:number, corrections:number, chars:number} }}
+ */
+export function buildReflectMaterial(memory, opts = {}) {
+  const {
+    overviewLimit = REFLECT_DEFAULTS.overviewLimit,
+    turnLimit = REFLECT_DEFAULTS.turnLimit,
+    budgetChars = REFLECT_DEFAULTS.budgetChars,
+    scan = [], rules = [], habits = [],
+    cursor = null,
+  } = opts;
+  const textOf = (x) => clean(typeof x === 'string' ? x : x?.text);
+  const blocks = [];
+  const stats = {
+    turns: 0, overviews: 0, corrections: 0, chars: 0,
+    round: Math.max(1, Number(cursor?.round) || 1),
+    turnOffset: 0, turnTotal: 0, ovOffset: 0, ovTotal: 0, wrapped: false,
+  };
+  let nextTurnOffset = 0;
+  let nextOvOffset = 0;
+
+  // ① 她现在的规矩与习惯 —— 让模型知道"已经有了什么",避免重复提议
+  const curRules = (rules || []).map(textOf).filter(Boolean);
+  const curHabits = (habits || []).map(textOf).filter(Boolean);
+  if (curRules.length || curHabits.length) {
+    const lines = [];
+    if (curRules.length) lines.push('规矩(主人的指令):' + curRules.join(' / '));
+    if (curHabits.length) lines.push('已有习惯:' + curHabits.join(' / '));
+    blocks.push({ title: '【她现在的规矩与习惯(不要重复提议)】', lines });
+  }
+
+  // ② 主人反复纠正过的地方
+  const cands = Array.isArray(scan) ? scan : [];
+  if (cands.length) {
+    stats.corrections = cands.length;
+    blocks.push({
+      title: '【主人反复纠正过的地方(本地统计:跨会话计数)】',
+      lines: cands.map((c) => `- ${c.rule || c.text || c.key}(出现在 ${c.sessions} 个会话 / 共 ${c.hits} 次)`),
+    });
+  }
+
+  // ③ 主人说过的话(真人原话;分轮读取 —— 每轮读上一轮没读过的那一段)
+  try {
+    const total = Number(memory?.db?.prepare?.("SELECT COUNT(*) n FROM dsh_turns_raw WHERE role='user' AND session_id NOT LIKE 'import:%'").get()?.n) || 0;
+    stats.turnTotal = total;
+    let off = Math.max(0, Number(cursor?.turnOffset) || 0);
+    if (total > 0 && off >= total) { off = 0; stats.wrapped = true; }
+    const rows = total > 0
+      ? (memory.db.prepare("SELECT ts, text FROM dsh_turns_raw WHERE role='user' AND session_id NOT LIKE 'import:%' ORDER BY rowid DESC LIMIT ? OFFSET ?").all(turnLimit, off) || [])
+      : [];
+    const lines = rows
+      .map((r) => { const t = clean(r?.text); return t ? `- (${isoDate(r?.ts) || '?'}) ${t.slice(0, 140)}` : ''; })
+      .filter(Boolean)
+      .reverse();
+    stats.turns = lines.length;
+    stats.turnOffset = off;
+    nextTurnOffset = (total > 0 && off + turnLimit >= total) ? 0 : off + turnLimit;
+    if (lines.length) blocks.push({ title: '【主人最近说过的话(真人原话,旧→新)】', lines });
+  } catch { /* 库不可读时跳过该块 */ }
+
+  // ④ 她读过的会话概述(同样分轮读取)
+  try {
+    const all = typeof memory?.listOverviews === 'function' ? memory.listOverviews({ onlyOk: true }) : [];
+    const sorted = [...all].sort((a, b) => String(b?.updated_at || b?.started_at || '').localeCompare(String(a?.updated_at || a?.started_at || '')));
+    stats.ovTotal = sorted.length;
+    let off = Math.max(0, Number(cursor?.ovOffset) || 0);
+    if (sorted.length > 0 && off >= sorted.length) { off = 0; stats.wrapped = true; }
+    stats.ovOffset = off;
+    nextOvOffset = (sorted.length > 0 && off + overviewLimit >= sorted.length) ? 0 : off + overviewLimit;
+    const lines = sorted
+      .slice(off, off + overviewLimit)
+      .map((r) => {
+        const date = String(r?.updated_at || r?.started_at || '').slice(0, 10);
+        const sum = clean(r?.summary).slice(0, 120);
+        const title = clean(r?.title).slice(0, 50);
+        return `- [${r?.category || '?'}] (${date}) ${title}${sum && sum !== title ? '：' + sum : ''}`;
+      })
+      .filter((l) => l.length > 12);
+    stats.overviews = lines.length;
+    if (lines.length) blocks.push({ title: '【她读过的会话概述(新→旧)】', lines });
+  } catch { /* 同上 */ }
+
+  // 按预算拼装(超预算从块尾截断)
+  const out = [];
+  let used = 0;
+  for (const b of blocks) {
+    const head = b.title + '\n';
+    if (used + head.length >= budgetChars) break;
+    const kept = [];
+    let size = 0;
+    for (const line of b.lines) {
+      if (used + head.length + size + line.length + 1 > budgetChars) break;
+      kept.push(line);
+      size += line.length + 1;
+    }
+    if (!kept.length) continue;
+    const text = head + kept.join('\n');
+    out.push(text);
+    used += text.length + 2;
+  }
+  stats.chars = used;
+  // 本轮覆盖情况(人读;接口与面板共用同一份措辞)
+  const rng = (start, count, total) => (total ? `第 ${start + 1}–${start + count} 条 / 共 ${total} 条` : '无');
+  stats.coverage = `第 ${stats.round} 轮 · 你的原话 ${rng(stats.turnOffset, stats.turns, stats.turnTotal)} · 会话概述 ${rng(stats.ovOffset, stats.overviews, stats.ovTotal)}` +
+    (stats.wrapped ? ' · 已读完一圈,回到最新' : '');
+  const nextCursor = { round: stats.round + 1, turnOffset: nextTurnOffset, ovOffset: nextOvOffset };
+  if (!out.length) return { text: '', stats, nextCursor };   // 无任何材料 → 空串(接口据此提示,不要只给一行统计)
+  const header = `（回想材料 · ${stats.coverage}）`;
+  const text = (header + '\n\n' + out.join('\n\n') +
+    `\n\n（材料统计:真人原话 ${stats.turns} 条 · 概述 ${stats.overviews} 条 · 纠正类型 ${stats.corrections} 类 · 共约 ${stats.chars} 字）`).trim();
+  return { text, stats, nextCursor };
+}
+
+/** 回想调用的重试策略(复刻 probeLLM 的既有经验:思考档可能把预算吃光 → 空回复)。 */
+export const REFLECT_RETRY = Object.freeze({
+  retryEffort: 'off',          // 不思考,保证有可见输出
+  retryMaterialChars: 80000,   // 重试时裁短材料,兼顾上下文较小的模型
+});
+
+/**
+ * 发起"回想"调用;若空回复(或抛错),用 off 档 + 裁短材料再试一次。
+ * 传入 llmOnce 而不是 ctx,便于单测注入假实现。
+ * @returns {Promise<{text:string, attempts:Array, retried:boolean}>}
+ */
+export async function reflectWithRetry(llmOnceFn, { system, material, maxTokens, effort }) {
+  const attempts = [];
+  const run = async (eff, mat, tag) => {
+    const t0 = Date.now();
+    try {
+      const r = await llmOnceFn({ system, text: mat, maxTokens, effort: eff });
+      const text = String(r?.text ?? '');
+      attempts.push({
+        tag, effort: eff, maxTokens, chars: mat.length, ok: text.trim().length > 0,
+        len: text.length, chunkTypes: r?.chunkLog || null, target: r?.target || null, ms: Date.now() - t0,
+      });
+      return text;
+    } catch (e) {
+      attempts.push({ tag, effort: eff, maxTokens, chars: mat.length, ok: false, error: String(e?.message ?? e).slice(0, 200), ms: Date.now() - t0 });
+      return '';
+    }
+  };
+  let text = await run(effort, material, 'first');
+  if (!text.trim()) {
+    const short = material.slice(0, REFLECT_RETRY.retryMaterialChars);
+    text = await run(REFLECT_RETRY.retryEffort, short, 'retry-off');
+  }
+  return { text, attempts, retried: attempts.length > 1 };
+}
+
+/** 解析"回想"结果(容错:围栏剥离、中/英字段、超长丢弃、去重)。 */
+export function parseReflect(text, { max = REFLECT_DEFAULTS.maxHabits, maxChars = 40 } = {}) {
+  const obj = extractJson(String(text || ''));
+  const arr = Array.isArray(obj?.habits) ? obj.habits : (Array.isArray(obj) ? obj : []);
+  const out = [];
+  for (const it of arr) {
+    const t = clean(it?.text ?? it?.habit).slice(0, 200);
+    if (!t || t.length > maxChars) continue;
+    const ev = clean(it?.evidence ?? it?.why).slice(0, 300);
+    if (out.some((x) => x.text === t)) continue;
+    out.push({ text: t, evidence: ev });
+    if (out.length >= max) break;
+  }
+  return out;
+}
+

package/lib/host/import-file.js

@@ -0,0 +1,291 @@
+// dsh-ling host — 会话契约文件导入(ACCESS-DESIGN §1/§3)。
+// 统一搬运格式:JSON {sessions:[…]}/数组 或 JSONL 逐行一会话;两档深度:
+//   完整档 messages[{role,text,at}] / 轻量档 summary+keywords(仅标题+时间也可)。
+// source 恒为 'import'(与 dsweb/dsh 区分),conv_id 建议含平台命名空间(如 "webchat:123")。
+// 2026-09-08:适配 DeepSeek 官方「导出所有历史会话」conversations.json(ChatGPT 风格 mapping 树:
+//   会话 {id,title,inserted_at,updated_at,mapping},消息在 mapping 节点的 message.fragments,
+//   REQUEST=用户 / RESPONSE=助手 / THINK/工具/FILE 忽略);同 uuid 命中 dsweb 旧域时自动折叠归并。
+import { sha256Text } from './util.js';
+import { heuristicTitle, TITLE_MAX_CHARS } from './retitle.js';
+import { rawSessionId, rawSessionCandidates } from './memory.js';
+import { categorizeTitle } from './classify.js';
+import { keywordsFrom } from './inject-common.js';
+
+export const IMPORT_SOURCE = 'import';
+export const CAT_NAME = { knowledge: '知识', daily: '日常', feeling: '生活' };
+
+function str(v) { return typeof v === 'string' ? v.trim() : ''; }
+
+/** 时间值清洗:ISO 字符串可能带 6 位微秒与偏移(如 .412000+08:00),截为 3 位毫秒再解析 */
+function cleanTimeStr(v) {
+  if (typeof v !== 'string') return v;
+  return v.replace(/(\.\d{3})\d+(?=(?:Z|[+-]\d{2}:?\d{2})?$)/, '$1');
+}
+/** epoch 归一:ChatGPT 的 create_time 是**秒**(浮点),DeepSeek 的是毫秒。
+ *  S5(2026-09-17):旧实现一律当毫秒,于是 ChatGPT 导出的时间全部落到 1970 年。 */
+function normEpoch(n) {
+  const x = Number(n);
+  if (!Number.isFinite(x) || x <= 0) return null;
+  if (x > 1e11) return x;       // 毫秒(13 位)
+  if (x > 1e8) return x * 1000; // 秒(10 位)→ 毫秒
+  return null;
+}
+function isoTime(v) {
+  if (v == null || v === '') return null;
+  const ms = typeof v === 'number' ? normEpoch(v) : null;
+  const t = ms != null ? new Date(ms) : new Date(cleanTimeStr(String(v)));
+  return Number.isNaN(t.getTime()) ? null : t.toISOString();
+}
+function toMs(v) {
+  if (v == null || v === '') return null;
+  if (typeof v === 'number') return normEpoch(v);
+  const t = Date.parse(cleanTimeStr(String(v)));
+  if (Number.isFinite(t)) return t;
+  return normEpoch(Number(v));
+}
+
+/** 从 mapping 节点取一轮(role,text)。兼容两种官方导出形态:
+ *  ① DeepSeek:fragments[{type:'REQUEST'|'RESPONSE', content}] —— REQUEST=主人 / RESPONSE=器灵
+ *  ② ChatGPT :author.role('user'|'assistant') + content.parts[] */
+function turnOfNode(node) {
+  const msg = node && typeof node.message === 'object' && node.message ? node.message : null;
+  if (!msg) return { role: '', text: '', ts: null };
+  const ts = toMs(msg.inserted_at ?? msg.insertedAt ?? msg.create_time ?? msg.createTime ?? msg.time);
+  const frags = Array.isArray(msg.fragments) ? msg.fragments : [];
+  let role = '';
+  const texts = [];
+  for (const fr of frags) {
+    if (!fr || typeof fr !== 'object') continue;
+    if (fr.type === 'REQUEST') role = 'user';
+    else if (fr.type === 'RESPONSE') role = 'assistant';
+    if (typeof fr.content === 'string' && fr.content.trim() && (fr.type === 'REQUEST' || fr.type === 'RESPONSE')) {
+      texts.push(fr.content.trim());
+    }
+  }
+  if (role && texts.length) return { role, text: texts.join('\n'), ts };
+  const ar = String((msg.author && msg.author.role) || '').toLowerCase();
+  const role2 = ar === 'user' ? 'user' : (ar === 'assistant' ? 'assistant' : '');
+  if (role2) {
+    const parts = Array.isArray(msg.content && msg.content.parts) ? msg.content.parts : [];
+    const text2 = parts.filter((p) => typeof p === 'string' && p.trim()).join('\n').trim();
+    if (text2) return { role: role2, text: text2, ts };
+  }
+  return { role: '', text: '', ts };
+}
+
+/**
+ * 官方导出:mapping 树 → 有序轮次(REQUEST→user / RESPONSE→assistant;
+ * THINK/FILE/SEARCH/TOOL_* 跳过;节点可混合多个 fragment)。
+ *
+ * S5(2026-09-17 导入诚实化):旧实现只走 `walk('root')`,而 **ChatGPT 的 mapping 根本没有 root 键**
+ * (根是 parent 为 null 的随机 uuid 节点)⇒ 真正的 ChatGPT 导出解析出 0 轮却仍报"导入完成"。
+ * 现在三级取链:
+ *   ① current_node 沿 parent 回溯(主对话链;ChatGPT 有重生成分支,回溯才不会把分支全算进来)
+ *   ② root + children 深度优先(DeepSeek 形态)
+ *   ③ 兜底:全节点按时间排序(结构异形时至少不丢内容)
+ * @returns [{seq,role,ts,text}]
+ */
+export function turnsFromOfficialMapping(mapping, { currentNode = '' } = {}) {
+  const map = mapping && typeof mapping === 'object' ? mapping : {};
+  const ids = Object.keys(map);
+  const order = [];
+  const seen = new Set();
+  const push = (id) => {
+    const k = String(id);
+    if (!k || !map[k] || seen.has(k)) return;
+    seen.add(k);
+    order.push(k);
+  };
+  // ① 主链回溯
+  const cur = str(currentNode) || str(map.current_node) || str(map.currentNode);
+  if (cur && map[cur]) {
+    const chain = [];
+    let id = cur;
+    const guard = new Set();
+    while (id && map[id] && !guard.has(id)) {
+      guard.add(id);
+      chain.push(id);
+      id = String(map[id].parent == null ? '' : map[id].parent);
+    }
+    chain.reverse().forEach(push);
+  }
+  // ② root + children DFS
+  if (!order.length && map.root) {
+    const walk = (id) => {
+      push(id);
+      const node = map[id];
+      if (node && Array.isArray(node.children)) node.children.forEach(walk);
+    };
+    walk('root');
+  }
+  // ③ 兜底:整表按时间排序
+  if (!order.length) {
+    const rows = ids.map((id) => ({ id, ts: turnOfNode(map[id]).ts }));
+    rows.sort((a, b) => (Number(a.ts || 0) - Number(b.ts || 0)));
+    rows.forEach((r) => push(r.id));
+  }
+  const turns = [];
+  let seq = 0;
+  for (const id of order) {
+    const t = turnOfNode(map[id]);
+    if (!t.role || !t.text) continue;
+    seq += 1;
+    turns.push({ seq, role: t.role, ts: t.ts, text: t.text });
+  }
+  return turns;
+}
+
+/** 规范化一个契约对象 → {ok, row, rawTurns?, degraded?, reason?} */
+export function normalizeImportItem(raw) {
+  if (!raw || typeof raw !== 'object') return { ok: false, reason: '非对象条目' };
+  const s = raw;
+  const title = str(s.title) || str(s.name);
+  // S5:补 ChatGPT 原生字段名(create_time/update_time/conversation_id) —— 它们此前不在别名链里,
+  // 于是真正的 ChatGPT 导出连时间都拿不到(叠加"秒被当毫秒"→ 落 1970)。
+  const started = isoTime(s.inserted_at ?? s.startedAt ?? s.started_at ?? s.insertedAt ?? s.startTime ?? s.time ?? s.create_time ?? s.createTime);
+  const updated = isoTime(s.updated_at ?? s.updatedAt ?? s.update_time ?? s.updateTime) || started;
+  if (!title && !started && !s.mapping) return { ok: false, reason: '缺标题与时间(至少要有一项)' };
+
+  // messages(完整档);官方导出走 mapping 树
+  const rawTurns = [];
+  const hasMapping = s.mapping && typeof s.mapping === 'object';
+  if (hasMapping) {
+    rawTurns.push(...turnsFromOfficialMapping(s.mapping, { currentNode: str(s.current_node ?? s.currentNode) }));
+  } else if (Array.isArray(s.messages) && s.messages.length) {
+    let seq = 0;
+    for (const m of s.messages) {
+      if (!m || typeof m !== 'object') continue;
+      const role = m.role === 'assistant' || m.role === 'bot' || m.role === 'ai' ? 'assistant'
+        : m.role === 'user' || m.role === 'human' ? 'user' : '';
+      const text = str(m.text ?? m.content);
+      if (!role || !text) continue;
+      seq += 1;
+      rawTurns.push({ seq, role, ts: toMs(m.at ?? m.ts ?? m.time), text });
+    }
+  }
+
+  const category = s.category === 'knowledge' || s.category === 'daily' || s.category === 'feeling'
+    ? s.category : categorizeTitle(title || (rawTurns.length ? rawTurns[0].text.slice(0, 80) : ''));
+  const firstUserText = rawTurns.length ? (rawTurns.find((t) => t.role === 'user')?.text || '') : '';
+  // D2(2026-09-17):与 DSH 会话侧共用同一套启发式(剥称呼/问候前缀、句读处收尾),不再硬截 46 字
+  const rawOne = (title || firstUserText).replace(/\s+/g, ' ').trim();
+  const oneLine = heuristicTitle(rawOne) || rawOne.slice(0, TITLE_MAX_CHARS);
+  const finalTitle = oneLine || '(未命名会话)';
+  const summary0 = rawTurns.length
+    ? (str(s.summary) || `${oneLine.slice(0, 140)} — ${rawTurns.length} 条消息`)
+    : str(s.summary);
+  const summary = summary0 || `${oneLine.slice(0, 140)}(轻量条目,摘要待深摘补充)`;
+  if (!rawTurns.length && !summary && !title) return { ok: false, reason: '既无消息也无摘要,无法成档' };
+  // S5(2026-09-17 导入诚实化):「说有内容、却解析不出任何轮次」一律标记 degraded,
+  // 且必须覆盖 mapping 分支 —— 旧判定只看 messages 数组,于是 mapping 树解析 0 轮
+  // (真正的 ChatGPT 导出 / 导出格式变更)被当成成功,界面显示"✓ 导入完成"而原文一条没进。
+  const claimed = (Array.isArray(s.messages) && s.messages.length > 0) || hasMapping;
+  const degraded = claimed && !rawTurns.length;
+  const degradedReason = degraded
+    ? (hasMapping ? 'mapping 树解析出 0 轮(导出格式未识别)' : 'messages 里没有可用的 user/assistant 文本')
+    : '';
+  const givenKw = Array.isArray(s.keywords) ? s.keywords.map((k) => str(k)).filter(Boolean).slice(0, 20) : [];
+  const keywords = givenKw.length
+    ? givenKw
+    : keywordsFrom((finalTitle + ' ' + (str(s.summary) || firstUserText)).slice(0, 400));
+
+  let id = str(s.id ?? s.convId ?? s.sessionId ?? s.conversation_id ?? s.conversationId);
+  if (!id) {
+    id = 'auto:' + sha256Text(String(finalTitle) + '|' + String(started || '')).slice(0, 16);
+  }
+  const row = {
+    conv_id: id,
+    source: IMPORT_SOURCE,
+    title: finalTitle,
+    started_at: started,
+    updated_at: updated,
+    domain_tags: [CAT_NAME[category] || '日常'],
+    category,
+    keywords,
+    summary,
+    heat: 0,
+    importance: 0,
+    last_hit_at: null,
+    hit_count: 0,
+    overview_ok: 1,
+    origin: 'import-file-v1',
+  };
+  return { ok: true, row, rawTurns, degraded, degradedReason };
+}
+
+/**
+ * 落库一批(≤500/批,幂等):
+ *  - 折叠:同 conv_id 命中 dsweb 旧域(官方导出与历史抓取同源)→ 元数据与原文并入 dsweb,
+ *    并移除本域残留副本(避免 L1 双份召回);
+ *  - 否则:新行全量 upsert;已存在只刷新 标题/时间/类别/关键词(不动 summary/importance/置顶/热度);
+ *  - 完整档 raw 轮次按 (session_id,seq) 覆盖写,重复导入天然幂等。
+ * @returns {{ok, newRows, refreshed, folded, removedImport, accepted, degraded, rejected}}
+ */
+export async function applyImportItems(memory, items) {
+  const rejected = [];
+  const stat = { ok: true, accepted: 0, newRows: 0, refreshed: 0, upgraded: 0, folded: 0, removedImport: 0, degraded: 0, degradedReasons: {} };
+  const list = Array.isArray(items) ? items : [];
+  for (let i = 0; i < list.length; i++) {
+    const n = normalizeImportItem(list[i]);
+    if (!n.ok) { rejected.push({ i, reason: n.reason }); continue; }
+    stat.accepted += 1;
+    if (n.degraded) {
+      stat.degraded += 1;
+      const why = n.degradedReason || '未识别';
+      stat.degradedReasons[why] = (Number(stat.degradedReasons[why]) || 0) + 1;
+    }
+    const id = n.row.conv_id;
+    const dswebRow = memory.overviewById('dsweb', id);
+    if (dswebRow) {
+      // 官方导出/历史抓取同源:并入 dsweb 域(不动其 summary/importance;raw 落到 dsweb conv)
+      memory.db.prepare(
+        `UPDATE conv_overview SET title=?, started_at=?, updated_at=?, domain_tags=?, category=?, keywords=?, origin=?
+         WHERE source='dsweb' AND conv_id=?`,
+      ).run(
+        n.row.title,
+        n.row.started_at ?? dswebRow.started_at,
+        n.row.updated_at ?? dswebRow.updated_at,
+        JSON.stringify(n.row.domain_tags), n.row.category, JSON.stringify(n.row.keywords),
+        n.row.origin, id,
+      );
+      const impDup = memory.overviewById(IMPORT_SOURCE, id);
+      if (impDup) {
+        memory.db.prepare("DELETE FROM conv_overview WHERE source=? AND conv_id=?").run(IMPORT_SOURCE, id);
+        stat.removedImport += 1;
+      }
+      stat.folded += 1;
+      // 折叠分支的原文归 dsweb 域(裸 id):它本就与 dsweb 抓取同源,G4 的 import 前缀不适用
+      for (const t of n.rawTurns) {
+        memory.appendRawTurn(id, { seq: t.seq, role: t.role, ts: t.ts, model: null, text: t.text });
+      }
+      continue;
+    }
+    const existed = memory.overviewById(IMPORT_SOURCE, id);
+    if (existed) {
+      memory.db.prepare(
+        `UPDATE conv_overview SET title=?, started_at=?, updated_at=?, domain_tags=?, category=?, keywords=?,
+           overview_ok=1, origin=? WHERE source=? AND conv_id=?`,
+      ).run(
+        n.row.title,
+        n.row.started_at ?? existed.started_at,
+        n.row.updated_at ?? existed.updated_at,
+        JSON.stringify(n.row.domain_tags), n.row.category, JSON.stringify(n.row.keywords),
+        n.row.origin, IMPORT_SOURCE, id,
+      );
+      stat.refreshed += 1;
+      // 轻量行升级为完整档:本次带来原文而原行没有 raw → 记为「补全原文」
+      // (G4:原文落在 import 命名空间,旧数据是裸 id —— 候选链任一有行即算已有原文)
+      if (n.rawTurns.length && !rawSessionCandidates(IMPORT_SOURCE, id).some((k) => memory.rawTurnCount(k) > 0)) stat.upgraded += 1;
+    } else {
+      memory.upsertOverview(n.row);
+      stat.newRows += 1;
+    }
+    // G4(2026-09-17):导入原文落 'import:<id>' 命名空间 —— 与 DSH 会话原文物理隔离。
+    // 否则概述器(GROUP BY session_id)会把它当成 DSH 会话重建(跨源双份),同 id 时还会互相覆盖原文。
+    const rawId = rawSessionId(IMPORT_SOURCE, id);
+    for (const t of n.rawTurns) {
+      memory.appendRawTurn(rawId, { seq: t.seq, role: t.role, ts: t.ts, model: null, text: t.text });
+    }
+  }
+  return { ok: true, ...stat, rejected };
+}