@nightpainters/dsh-ling 1.5.2 → 1.5.3

package/lib/host/backfill.js

@@ -3,7 +3,7 @@
 // 写侧走传入的 MemoryStore(与运行中实例同库,免并发双开)。
 import { readdirSync, readFileSync, statSync } from 'node:fs';
 import { join } from 'node:path';
-import { homedir } from 'node:os';
+import { dshHome } from './util.js'; // $DSH_HOME 优先,否则 ~/.dsh —— 与 deepsummary.js 同一个来源
 import { categorizeTitle } from './classify.js';
 import { keywordsFrom } from './inject-common.js';
 import { decodeAll } from './zstd.js';
@@ -42,9 +42,15 @@ export function pickSessionFile(dir) {
  * 为什么必须是一个显式函数:不传 root 时,扫描侧有默认值照常工作,而归因探针侧
  * 拿到 `undefined` → `readdirSync(undefined)` 抛错被吞 → 恒判 `no-sessions-root`,
  * 界面渲染成「未找到 DSH 会话目录:undefined」(BUG-2 归因几乎不可达)。
+ * ⚠️ 2026-09-29 修正:本函数原先是 `join(homedir(), '.dsh', 'sessions')`,只与**扫描侧**
+ * 同源;而**取原文侧** `deepsummary.js` 的 `findSessionFile()` 走 `join(dshHome(), 'sessions')`
+ * —— 同一语义两个来源。本机不设 DSH_HOME 时两者等价(缺陷因此长期隐身);一旦设了
+ * (例如导入测试台),两者就分叉:「本机 DSH 扫描」会去读**真机**会话目录 —— 不报错、只读,
+ * 但结果不可复现,还会把真历史灌进测试库。
+ * 现统一到 `dshHome()`(= `$DSH_HOME` 优先,否则 `~/.dsh`):扫描侧 / 归因探针侧 / 取原文侧三者同一个来源。
  */
 export function defaultSessionsRoot() {
-  return join(homedir(), '.dsh', 'sessions');
+  return join(dshHome(), 'sessions');
 }
 
 /** 候选会话文件: ~/.dsh/sessions/<workspace>/<sid>/{session[.vN].jsonl.zstd} */

package/lib/host/feedback.js

@@ -1,5 +1,11 @@
 // dsh-ling host — 反馈成长回路(message-feedback 消费方,REPORT-04)。
-// 平台 messageFeedback 无推送 → 低频轮询 list()。
+// ⚠️ 2026-10-01 订正(旧注释"平台 messageFeedback 无推送 → 低频轮询 list()"**已被证伪**):
+//   宿主 `@deepseek-ai/dsh-message-feedback` 有推送 —— 冷会话写入 flush 后
+//   `lib/index.js:288` 发 **`feedback/committed`**(载荷 = SessionInspection:
+//   `{ meta, inheritedEventCount, events }`,末条即本次提交的事件);
+//   活会话消费方按它 README.zh.md:58 的口径看 `session/event` 里的
+//   `feedback/message-put` / `feedback/message-delete`。
+//   ⇒ 现走**事件驱动**(registerFeedbackListener),不再 60 秒轮询 sidecar。
 // 语义(人审闭环):
 //   negative + note → 修订建议队列(绝不自动改人格;用户在 UI 逐条 采纳/忽略)
 //   positive         → 该 DSH 会话概述热度加权(bumpHit)
@@ -69,9 +75,99 @@ export function ingestFeedbackEntries(memory, entries, { seen } = {}) {
   return out;
 }
 
+/** 事件名单一来源(测试钉它;改名时两处一起红,不会静默漂移)。 */
+export const FEEDBACK_COMMITTED_EVENT = 'feedback/committed';
+
+/**
+ * 提交事件列表 → 当前反馈条目(纯函数)。
+ * 与宿主 message-feedback 同口径:put 覆盖同 messageId 的旧值,delete 抹掉它。
+ * 末条是本次提交的事件 —— 无该项就返回空(不算错,也绝不抛)。
+ * @param {string} sid 所属会话
+ * @param {Array} events SessionInspection.events
+ * @returns {Array<{sessionId:string,messageId:string,rating:string,note:string,createdAt:number}>}
+ */
+export function entriesFromSessionEvents(sid, events) {
+  const list = Array.isArray(events) ? events : [];
+  const last = list[list.length - 1];
+  const t = last?.type;
+  if (t !== 'feedback/message-put' && t !== 'feedback/message-delete') return [];
+  const sessionId = String(sid ?? last?.data?.sessionId ?? '');
+  if (!sessionId) return [];
+  const map = new Map();
+  for (const ev of list) {
+    const d = ev?.data;
+    if (!d) continue;
+    if (ev.type === 'feedback/message-put' && d.item?.messageId && d.item?.rating) {
+      map.set(String(d.item.messageId), {
+        messageId: String(d.item.messageId),
+        rating: String(d.item.rating),
+        note: d.item.note ?? '',
+        createdAt: d.item.createdAt ?? d.item.updatedAt ?? Date.now(),
+      });
+    } else if (ev.type === 'feedback/message-delete' && d.messageId) {
+      map.delete(String(d.messageId));
+    }
+  }
+  return [...map.values()].map((it) => ({ sessionId, ...it }));
+}
+
+/**
+ * 挂推送监听(U7 正解)。
+ * - 冷会话:`feedback/committed`,载荷是完整事件日志 ⇒ 重放出**当前**条目(update/delete 都算准);
+ * - 活会话:`session/event` 的 `feedback/message-put|delete`,按事件本身取条目;
+ * - delete 事件**不**反向撤单:已入队的修订建议保持原状(与旧轮询口径一致,登记在案)。
+ * 绝不抛:宿主在 `feedback/committed` 上等观察方,抛错只会让它写日志。
+ * @returns {() => void} 卸载函数(交给 ctx.effect / disposers)
+ */
+export function registerFeedbackListener(ctx, memory) {
+  const offs = [];
+  const handle = (label, fn) => async (...args) => {
+    try {
+      fn(...args);
+    } catch (e) {
+      console.debug(`[dsh-ling] feedback ${label} handler error`, e);
+    }
+  };
+  try {
+    offs.push(ctx.on(FEEDBACK_COMMITTED_EVENT, handle('committed', (inspection) => {
+      // 只认驱动本回调的那条事件;其余类型视作"无提交"(宿主 no-op append 也会发这个通知)
+      const last = inspection?.events?.[inspection.events.length - 1];
+      if (last?.type !== 'feedback/message-put') return;
+      const sid = String(inspection?.meta?.id ?? last?.data?.sessionId ?? '');
+      const entries = entriesFromSessionEvents(sid, inspection?.events);
+      if (entries.length) processFeedbackEntries(memory, entries, { seen: loadSeen(memory) });
+    })));
+  } catch (e) {
+    console.debug('[dsh-ling] feedback committed subscribe failed', e);
+  }
+  try {
+    offs.push(ctx.on('session/event', handle('live-event', (session, event) => {
+      const t = event?.type;
+      if (t !== 'feedback/message-put' && t !== 'feedback/message-delete') return;
+      const sid = String(
+        session?.id ?? event?.data?.sessionId ?? session?.header?.id ?? '',
+      );
+      const entries = t === 'feedback/message-put'
+        ? entriesFromSessionEvents(sid, [event])
+        : [];
+      if (entries.length) processFeedbackEntries(memory, entries, { seen: loadSeen(memory) });
+    })));
+  } catch (e) {
+    console.debug('[dsh-ling] feedback live subscribe failed', e);
+  }
+  memory.kvSet('feedback.wired', FEEDBACK_COMMITTED_EVENT + '+session/event');
+  return () => {
+    for (const d of offs) {
+      try { d(); } catch { /* ignore */ }
+    }
+  };
+}
+
 /**
  * 从平台 message_feedback sidecar 文件结构映射条目(tables.sessions 形态)。
- * 服务 list() 需会话身份参数,不便轮询 → 直接读单文件 JSON。
+ * ⚠️ 2026-10-01 起**不再是活路径**:宿主推送已接管(见文件头);
+ * 该 sidecar 在 Web 组合下自 2026/9/11 起零写入。此处只服务
+ * `tools/process-feedback.mjs` 这个人工兜底 CLI 与既有回归测试。
  */
 export function entriesFromFeedbackFile(fileObj) {
   const out = [];
@@ -117,3 +213,17 @@ export function dismissSuggestion(memory, id) {
   memory.setFeedbackStatus(Number(id), 'dismissed');
   return { ok: true, id: Number(id) };
 }
+
+/**
+ * U7 正解入口:吃一批平台反馈,交给 ingestFeedbackEntries。
+ * 幂等:同一 (会话,消息) 只处理一次(kv `fb.seen`);返回 null = 这批没有可处理项。
+ * 注意 `{seen}` 必须是**本次调用前**的快照(调用后 seenSet 已含新键)。
+ */
+export function processFeedbackEntries(memory, entries, { seen } = {}) {
+  const res = ingestFeedbackEntries(memory, entries, { seen });
+  if (res.queued + res.boosted + res.seenAdded > 0) {
+    memory.kvSet('feedback.last', JSON.stringify({ at: utcIso(), ...res }));
+    return res;
+  }
+  return null;
+}

package/lib/host/freeze.js

@@ -6,11 +6,61 @@ import { pick } from './util.js';
 
 const MODES = new Set(['work', 'life']);
 
+/**
+ * A(审计 §四.4,2026-10-01 修):`_byId` 的**基数上限** —— 只对"全缺省空壳"条目生效。
+ *
+ * 为什么会有无界增长:`GET /state?sessionId=<任意字符串>` 经 stateFor → `gate.isRunning` /
+ * `pendingCount` / `snapshotOf`,而这三个方法都走 `_state()`,**先建条目再读** ⇒ 任意 id 都会
+ * 在内存里留下一条。条目不存在与条目为全缺省,对读者**不可区分**(实测:`/state` 这条路上
+ * 除 `_state()` 外没有任何写入点 —— mode 由 mode.js 从 memory/settings 读,不写 gate),
+ * 所以上限可以只清理空壳。
+ *
+ * 为什么不会动到真读数:带读数的条目**一律不淘汰** —— `running`(agent/status 写)、
+ * `pending`(act 写)、`snap`/`snapStale`(markSnap / 失效路径写)、`mode`(ensure 写)。
+ * 于是"已存在会话的读数不受影响"是**结构上**成立的(不是靠概率),
+ * `snapshotIds()` 枚举的定稿会话也不会因淘汰而消失。
+ *
+ * N=128 的依据:一台机器上真实并发的会话是个位数;带 snap 的定稿会话属于"非空壳",
+ * 根本不在这条上限的管辖内(故不会误伤历史)。128 比真实需要高约两个数量级,
+ * 同时把"任意 id ⇒ 无限增长"封成一个常数。要更紧/更松可经构造函数传 `maxIdleSessions`。
+ */
+const MAX_IDLE_SESSIONS_DEFAULT = 128;
+
 export class FreezeGate {
-  constructor({ onFlush } = {}) {
+  constructor({ onFlush, maxIdleSessions = MAX_IDLE_SESSIONS_DEFAULT } = {}) {
     this._byId = new Map();
     this._onFlush = onFlush || (() => {});
     this._recent = null; // 最近定稿快照的会话(API "当前会话"启发式)
+    const n = Number(maxIdleSessions);
+    this._maxIdle = Number.isFinite(n) && n >= 0 ? Math.floor(n) : MAX_IDLE_SESSIONS_DEFAULT;
+  }
+
+  /** 全缺省空壳?(新建时就是这个形状;任何真读数都会让它不再是空壳) */
+  _isIdleShell(s) {
+    return !s.running && !s.snap && !s.snapStale && !s.mode && s.pending.length === 0;
+  }
+
+  /**
+   * A:超过上限时,按**插入顺序**(Map 的迭代顺序)淘汰最老的**空壳**;带读数的一律留下。
+   * `keepId` = 刚建的那一条(它也是空壳,但必须留给本次调用方)。
+   * @returns {number} 本次淘汰条数(自检/测试可读)
+   */
+  _trimIdleShells(keepId) {
+    if (this._byId.size <= this._maxIdle) return 0;
+    let dropped = 0;
+    for (const [id, s] of this._byId) {
+      if (this._byId.size <= this._maxIdle) break;
+      if (id === keepId) continue;          // 本次要用的那一条不许被自己挤掉
+      if (!this._isIdleShell(s)) continue;  // 带读数:永不淘汰(这就是"读数不受影响"的保证)
+      this._byId.delete(id);
+      dropped += 1;
+    }
+    return dropped;
+  }
+
+  /** 门内会话条目数(自检/测试用;正常读者不需要它 —— 读数是 per-session 的)。 */
+  size() {
+    return this._byId.size;
   }
 
   /** @returns {{mode:string, running:boolean, pending:string[], snap:object|null}} */
@@ -19,6 +69,7 @@ export class FreezeGate {
     if (!s) {
       s = { mode: null, running: false, pending: [], snap: null, snapStale: false };
       this._byId.set(sessionId, s);
+      this._trimIdleShells(sessionId);
     }
     return s;
   }

package/lib/host/guard.js

@@ -105,6 +105,26 @@ export function cookieValueOf(cookieHeader, name) {
   return undefined;
 }
 
+/**
+ * 反向代理追加的**真实对端地址**(2026-09-30 加固⑤;判据与对照实验见 `tests\guard.test.mjs` 第 8 段「反代场景加固⑤」)。
+ *
+ * nginx 的 `$proxy_add_x_forwarded_for` = `$http_x_forwarded_for`, `$remote_addr`
+ * ⇒ **最后一段永远是 nginx 亲自追加、客户端无法影响的地址**(客户端伪造只能污染前面的段)。
+ * 无 XFF 时回退 `X-Real-IP`(同样是 nginx 亲自设置)。
+ *
+ * ⚠️ **不许"优化"成取第一段** —— 取首段时,攻击者只要自己先塞一句
+ * `X-Forwarded-For: 127.0.0.1`,整条判据立刻失效(同段「攻击②」有逐行对照)。
+ */
+export function realPeerAddress(headers) {
+  const xff = headerOf(headers, 'x-forwarded-for');
+  if (typeof xff === 'string' && xff.trim() !== '') {
+    const parts = xff.split(',').map((s) => s.trim()).filter(Boolean);
+    if (parts.length) return parts[parts.length - 1];
+  }
+  const real = headerOf(headers, 'x-real-ip');
+  return typeof real === 'string' && real.trim() !== '' ? real.trim() : undefined;
+}
+
 /**
  * 判定一次 /api 请求是否放行。
  * @param {object} headers 请求头
@@ -117,9 +137,26 @@ export function checkRequest(headers, { trustedHosts = [], allowLan = false } =
   if (!host) return { ok: false, reason: 'no-host' };
   const hostUrl = parseAuthority(host);
   if (!hostUrl) return { ok: false, reason: 'bad-host' };
+
+  const loopbackHost = isLoopbackHostname(hostUrl.hostname);
+
+  // ── 2026-09-30 加固⑤(反代场景):**loopback 免检只对"真的来自本机"的请求成立** ──────────
+  // 沿革:旧代码"Host 长得像 loopback 就直接短路跳过受信名单",这条假设在**引入反向代理之后失效** ——
+  // nginx 的 `proxy_set_header Host $http_host` 把 Host 变成**客户端的自我声明**,
+  // 而 cookie 那边只校验**名字**(名字是 `sha256(authority)` 的公开派生,客户端自算即可)⇒
+  // 「伪造 Host: 127.0.0.1:3080 + 自算 cookie 名」曾构成一条**不需要任何凭据**的公网通路。
+  // 判据:反向代理**一定会追加** XFF/X-Real-IP(`$proxy_add_x_forwarded_for` 把真实对端**追加在最后一段**),
+  //   所以"带着代理头、却声称自己是 loopback"= 伪造 ⇒ 拒。**无代理头的本机直连照旧免检**(见 §六 回归表)。
+  if (loopbackHost) {
+    const peer = realPeerAddress(headers);
+    if (peer !== undefined && !isLoopbackHostname(peer)) {
+      return { ok: false, reason: 'spoofed-loopback-host' };
+    }
+  }
+
   // 2026-09-17 加固③(G1):LAN 地址只在显式 allowLan 时才进受信集(旧版无条件并入,是整个 P0 的根)
   const trusted = allowLan ? [...lanAddresses(), ...trustedHosts] : trustedHosts;
-  if (!isLoopbackHostname(hostUrl.hostname) && !isTrustedAuthority(hostUrl, trusted)) {
+  if (!loopbackHost && !isTrustedAuthority(hostUrl, trusted)) {
     return { ok: false, reason: 'untrusted-host' };
   }
   if (headerOf(headers, 'sec-fetch-site') === 'cross-site') return { ok: false, reason: 'cross-site' };

package/lib/host/habit-gen.js

@@ -15,6 +15,10 @@
 import { CORRECTION_BUCKETS } from './corpus-suggest.js';
 import { extractJson } from './genesis.js';
 import { isoDate } from './util.js';
+// E2(2026-10-01):「哪些原文属于主人自己的会话」这一判据**不在这里另立一份** ——
+// 它是全包唯一一处定义,住在 summarizer.js(正向白名单 + 未知来源 kv 告警)。
+// 旧写法(黑名单式排除已知的 import: 前缀)在本文件里有 3 处,已统一改为共用判据。
+import { dshSessionSql, noteUnknownRawNamespaces } from './summarizer.js';
 
 export const SCAN_DEFAULTS = Object.freeze({
   minHits: 4,        // 同类纠正至少出现几次(2026-09-16 用户定案:3 → 4)
@@ -34,9 +38,11 @@ export function scanCorrections(memory, opts = {}) {
   const { minHits, minSessions, maxTurns, sampleLimit } = { ...SCAN_DEFAULTS, ...opts };
   let rows = [];
   try {
+    // E2:未知来源命名空间留痕(库干净时零写入);随后只扫 DSH 自己的会话。
+    noteUnknownRawNamespaces(memory, 'habit-gen.scanCorrections');
     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 ?",
+      // G4:习惯只能从「主人自己的会话」长出来 —— 排除一切非 DSH 命名空间(别人的对话)
+      `SELECT session_id, text FROM dsh_turns_raw WHERE role='user' AND ${dshSessionSql()} ORDER BY seq DESC LIMIT ?`,
     ).all(maxTurns);
   } catch {
     return [];   // 库结构异常时静默退化(生成器不能拖累别处)
@@ -149,12 +155,14 @@ export function buildReflectMaterial(memory, opts = {}) {
 
   // ③ 主人说过的话(真人原话;分轮读取 —— 每轮读上一轮没读过的那一段)
   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;
+    // E2:同上,未知来源命名空间留痕后按正向白名单统计(两处查询共用同一判据)
+    noteUnknownRawNamespaces(memory, 'habit-gen.buildReflectMaterial');
+    const total = Number(memory?.db?.prepare?.(`SELECT COUNT(*) n FROM dsh_turns_raw WHERE role='user' AND ${dshSessionSql()}`).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) || [])
+      ? (memory.db.prepare(`SELECT ts, text FROM dsh_turns_raw WHERE role='user' AND ${dshSessionSql()} 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)}` : ''; })

package/lib/host/import-file.js

@@ -217,13 +217,14 @@ export function normalizeImportItem(raw) {
  * 落库一批(≤500/批,幂等):
  *  - 折叠:同 conv_id 命中 dsweb 旧域(官方导出与历史抓取同源)→ 元数据与原文并入 dsweb,
  *    并移除本域残留副本(避免 L1 双份召回);
+ *    ⚠️ A(2026-09-30):折叠**绝不覆盖目标会话已有的原文** —— 详见下面折叠分支的注释与 `foldSkippedRaw`;
  *  - 否则:新行全量 upsert;已存在只刷新 标题/时间/类别/关键词(不动 summary/importance/置顶/热度);
  *  - 完整档 raw 轮次按 (session_id,seq) 覆盖写,重复导入天然幂等。
- * @returns {{ok, newRows, refreshed, folded, removedImport, accepted, degraded, rejected}}
+ * @returns {{ok, newRows, refreshed, folded, removedImport, foldSkippedRaw, 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 stat = { ok: true, accepted: 0, newRows: 0, refreshed: 0, upgraded: 0, folded: 0, removedImport: 0, foldSkippedRaw: 0, degraded: 0, degradedReasons: {} };
   const list = Array.isArray(items) ? items : [];
   for (let i = 0; i < list.length; i++) {
     const n = normalizeImportItem(list[i]);
@@ -254,9 +255,62 @@ export async function applyImportItems(memory, items) {
         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 });
+      // 折叠分支的原文归 dsweb 域(裸 id):它本就与 dsweb 抓取同源,G4 的 import 前缀不适用。
+      // ── A(2026-09-30,修缺陷「折叠覆盖真原文」)────────────────────────────────
+      // 缺陷:旧实现把**导入侧的 seq** 直接 appendRawTurn 进这个 dsweb 会话,而
+      //   `dsh_turns_raw` 的主键是 (session_id, seq)、`appendRawTurn` 是
+      //   `ON CONFLICT(session_id, seq) DO UPDATE SET text=excluded.text`
+      //   ⇒ 折叠侧 seq 从 1 重新数,与目标会话既有轮次**必然同号**,于是目标里的真原文
+      //   被逐条静默换成导入副本:**行数不增、内容被换、一个字都不报**(离线测试台 S6d 实测
+      //   clobbered=3)。属"会丢数据 + 静默"那一档。
+      // 判据(顺序不可调):
+      //   ① 目标**一个字原文都没有** ⇒ 照旧写入(这是"把原文补进去"的升级路径,**不许堵死**);
+      //   ② 目标已有原文 ⇒ 逐条按 (role,text) 比:
+      //        · 完全相同 ⇒ 跳过(幂等:重复导入同一份不报错、也不算丢失);
+      //        · 不同     ⇒ **保留现有的**(绝不覆盖),计入 `foldSkippedRaw`。
+      //   ⚠️ **不许**"按 max(seq) 往后追加"(同一段对话在库里变成两份 ⇒ 污染 L1 检索),
+      //      **也不许**整段替换(那是丢真的方向)。
+      //   代价(已留证):目标已有原文且内容不同时,导入侧的这几轮**进不去** —— 这是**故意的**取舍:
+      //     宁可少一份副本,不可换掉真原文。它必须**说出来**(foldSkippedRaw → 回执/界面/账本),
+      //     静默与丢失同样不可接受。
+      // ── A'(2026-09-30 补,G4 裂缝「判据漏了 import 命名空间」)────────────────────
+      //   只看写入目标(裸 id)会漏 `import:<id>` 侧:若该会话在 import 命名空间下**已有原文**
+      //   (例如先前做过一次普通文件导入),而裸 id 这侧 0 轮,折叠就会把同一段对话**再写一份**
+      //   进裸 id ⇒ 库里同一段对话出现两个 session_id、两份原文 —— 正是折叠机制本来要消灭的
+      //   「L1 双份召回」。故"已有原文"按**候选链任一侧**判(复用 memory.rawSessionCandidates,
+      //   与上方 upgraded 判据同一套口径,不另发明)。
+      //   任一侧已有原文 ⇒ 不写裸 id、也不动 `import:` 侧的行;被挡下的轮数照旧计入 foldSkippedRaw。
+      //   ⚠️ 这里**不做**数据迁移(把 `import:` 侧原文搬到裸 id):那是另一档风险,留待拍板。
+      const targetHasRaw = rawSessionCandidates(IMPORT_SOURCE, id).some((k) => memory.rawTurnCount(k) > 0);
+      if (!targetHasRaw) {
+        for (const t of n.rawTurns) {
+          // v14(2026-10-01)来源列:这里**刻意不给** source,由 appendRawTurn 按 id 形状推导(裸 id ⇒ 'dsh')。
+          // 两条理由:① 本分支的写入目标由候选链决定,来源应当与**实际写进去的那个 id**同解(读者的回落
+          //   判据就是这个),写死一个常量会在 id 形态变化时与它脱钩;② 折叠进来的原文按现有裁决**仍被
+          //   概述器认领**(它落在裸 id 上)—— 若改记成 'dsweb',这些轮次会当场从概述器眼里消失,
+          //   那是**越权改裁决**,不属于"加一列"的授权范围(真机库实测该分支 0 行,留作残余风险上报)。
+          memory.appendRawTurn(id, { seq: t.seq, role: t.role, ts: t.ts, model: null, text: t.text });
+        }
+      } else if (n.rawTurns.length) {
+        // (role,text) 指纹:JSON 化再比 —— role 与 text 里可能出现分隔符,拼接字符串会误判相同。
+        // ── A''(2026-09-30 补,C′ 裂缝「指纹只取写入目标」)─────────────────────────
+        //   A' 只把"要不要写"的存在判据扩到了候选链;**逐条比对的指纹**仍只取写入目标(裸 id)
+        //   ⇒ 两侧都有原文时,`import:` 侧**已有的同一轮**再次进来会被算成"未替换"
+        //   (计数偏大、方向保守:把幂等重复说成丢失)。既然"已有原文"按候选链任一侧判,
+        //   指纹集就必须**同一口径** —— 两侧的轮次合起来建集合,否则同一条链上并存两种口径。
+        //   ⚠️ 本分支以 `targetHasRaw === true` 进入,里面**一行都不写** ⇒ 这里只让**计数更准**:
+        //   不动任何数据、不做迁移(`import:` 侧的行原样留着)。
+        const fp = (role, text) => JSON.stringify([String(role), String(text)]);
+        const have = new Set();
+        for (const k of rawSessionCandidates(IMPORT_SOURCE, id)) {
+          for (const r of memory.db.prepare('SELECT role, text FROM dsh_turns_raw WHERE session_id=?').all(k)) {
+            have.add(fp(r.role, r.text));
+          }
+        }
+        for (const t of n.rawTurns) {
+          if (have.has(fp(t.role, t.text))) continue; // 幂等:同 (role,text) 已在 ⇒ 跳过,不计
+          stat.foldSkippedRaw += 1;                   // 不同 ⇒ 保留现有的,只计数(一个字节都不写)
+        }
       }
       continue;
     }
@@ -282,9 +336,11 @@ export async function applyImportItems(memory, items) {
     }
     // G4(2026-09-17):导入原文落 'import:<id>' 命名空间 —— 与 DSH 会话原文物理隔离。
     // 否则概述器(GROUP BY session_id)会把它当成 DSH 会话重建(跨源双份),同 id 时还会互相覆盖原文。
+    // 写入侧坐实(2026-10-01 grep):本文件的实际来源命名空间 = `IMPORT_SOURCE`('import'),
+    //   落成的 id = `rawSessionId(IMPORT_SOURCE, id)` = `import:<id>` ⇒ v14 的 source 列记 'import'。
     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 });
+      memory.appendRawTurn(rawId, { seq: t.seq, role: t.role, ts: t.ts, model: null, text: t.text, source: IMPORT_SOURCE });
     }
   }
   return { ok: true, ...stat, rejected };

package/lib/host/import-log.js

@@ -4,6 +4,10 @@
 //     host 端按 runId 累加进同一条账(批数/计数相加),日志不暴露 HTTP 细节;
 //   - `at` = **导入开始时刻并固定**(首批写入后不再变动,账不会在列表里跳位置);`updatedAt` 记最后一批;
 //   - 成功批由 /import/file/batch 自己记账;失败批由客户端经 /import/log 上报(只加 `errors` 批数);
+//   - #10(2026-09-29):被**跳过**的"单条过大"也进账(客户端在导入收尾时上报一次),但它记的是
+//     **跳过**、不是失败 ⇒ 走的是**不带 `errors`** 的那条路(`tooBig` / `tooBigNames`)。
+//     以前 `/import/log` 只认 `errors`(且强制 ≥1),客户端只能**故意不报** ⇒ 账本上
+//     完全看不出"有东西被跳过";现在这一笔补上了,且绝不混进"失败批"计数。
 //   - 三条入口共用:文件导入 / 本机 DSH 扫描 / 网页端库扫描;
 //   - kv `import.log.<at>` 存 JSON;保留最近 50 条,满了作废最老的。
 
@@ -24,6 +28,45 @@ export function cleanAt(value, now = Date.now()) {
   return Math.floor(n);
 }
 
+/** ── #10:被跳过的"单条过大"(跳过 ≠ 失败)──────────────────────────────────
+ *  三个上限是**输入护栏**,不是显示偏好:账本要长期留着,不许任意长度的用户输入原样进来
+ *  (`/import/log` 是 HTTP 端点)。`tooBig` 是"整次导入里被跳过的条数",10000 远超现实。
+ *  ⚠️ `cleanTooBig` / `cleanTooBigNames` 是**唯一一份**实现:端点(`api.js`)也调它们,
+ *  不许在端点里另抄一份口径(否则两处必漂移)。 */
+export const TOO_BIG_MAX = 10000;
+/** 账本里最多留几个被跳过的条目名:与界面点名(前 5 条)同口径 —— 账本是摘要,不是清单。 */
+export const TOO_BIG_NAMES_MAX = 5;
+/** 单个名字的字符数上限:名字只用来"让人认出是哪一条",40 字够;超了就截,不丢整条。 */
+export const TOO_BIG_NAME_CHARS = 40;
+
+/** `tooBig` 归一:非负整数,夹在 [0, TOO_BIG_MAX];非数字/负数 → 0(不是 NaN、不是 undefined)。 */
+export function cleanTooBig(v) {
+  const n = Math.floor(Number(v));
+  if (!Number.isFinite(n) || n <= 0) return 0;
+  return Math.min(n, TOO_BIG_MAX);
+}
+
+/** `tooBigNames` 归一:**只留非空字符串**、每条截到 40 字、最多 5 条(先来先留)。
+ *  非数组 → 空数组;坏输入只许"少记",绝不许抛(账本通路是尽力而为,不能因为一个字段 500)。 */
+export function cleanTooBigNames(v) {
+  if (!Array.isArray(v)) return [];
+  const out = [];
+  for (const x of v) {
+    if (typeof x !== 'string') continue;                       // 非字符串项丢弃
+    const s = x.trim();
+    if (!s) continue;                                          // 空/纯空白丢弃
+    out.push(s.length > TOO_BIG_NAME_CHARS ? s.slice(0, TOO_BIG_NAME_CHARS) : s);
+    if (out.length >= TOO_BIG_NAMES_MAX) break;                 // 只取前 5 条
+  }
+  return out;
+}
+
+/** `foldSkippedRaw` 归一:与 `cleanTooBig` **同口径**(非负整数,夹在 [0, TOO_BIG_MAX]) —— 口径只留一份
+ *  (两处各写一遍必漂移,这是本仓的老账)。
+ *  语义:A(2026-09-30)折叠时"因为目标会话**已有原文**而**没有替换**的轮数"。它同样是「跳过 ≠ 失败」
+ *  那一类(见 #10),所以:① **绝不**混进 `errors`;② `= 0`(含压根没这个字段)时落的账**逐字不变**。 */
+export function cleanFoldSkipped(v) { return cleanTooBig(v); }
+
 function numberFields(entry) {
   const out = {};
   for (const k of NUM_KEYS) out[k] = Number(entry?.[k]) || 0;
@@ -67,6 +110,15 @@ export function logImport(memory, entry) {
   const name = String(entry?.name || '').slice(0, 120);
   const note = String(entry?.note || '').slice(0, 200);
   const kind = String(entry?.kind || 'file');
+  // #10:被跳过的"单条过大" —— 只有**上报了**它(>0)才入账。
+  // ⚠️ `tooBig === 0`(含压根没这个字段)时,下面落的账**逐字不变**(不加键、不改值、不改键序):
+  //    这是负对照,`tests/importlog.test.mjs` 有断言 —— 别为了"形状统一"给它俩补默认值。
+  const tooBig = cleanTooBig(entry?.tooBig);
+  const tooBigNames = cleanTooBigNames(entry?.tooBigNames);
+  // A(2026-09-30):折叠时"因为目标已有原文而**没有替换**的轮数" —— 与 tooBig 同款:**只有 >0 才入账**。
+  // ⚠️ 同一个负对照同样适用于它:`foldSkippedRaw === 0`(或没这个字段)时,落的账**逐字不变**
+  //    (不进 NUM_KEYS:否则每一条文件导入的 JSON 都会凭空多一个 `foldSkippedRaw: 0` 键)。
+  const foldSkipped = cleanFoldSkipped(entry?.foldSkippedRaw);
 
   if (runId) {
     const found = findByRun(memory, runId);
@@ -76,6 +128,17 @@ export function logImport(memory, entry) {
       for (const k of NUM_KEYS) merged[k] = (Number(found.value[k]) || 0) + inc[k];
       if (!merged.name && name) merged.name = name; // 名字取首个非空
       if (note) merged.note = note;                 // 备注取最新
+      if (foldSkipped) {
+        // 同一 runId 的多批**累加**(与 tooBig/errors 同语义),合并后仍夹在上限内:
+        merged.foldSkippedRaw = Math.min(TOO_BIG_MAX, (Number(found.value.foldSkippedRaw) || 0) + foldSkipped);
+      }
+      if (tooBig) {
+        // 同一 runId 的多批**累加**(与 errors 同语义),但两项仍夹在上限内:
+        // 多批各报 5 个名字、30 批就是 150 个 —— 合并后同样只留前 5 条(账本是摘要不是清单)。
+        merged.tooBig = Math.min(TOO_BIG_MAX, (Number(found.value.tooBig) || 0) + tooBig);
+        const namesMerged = cleanTooBigNames([].concat(merged.tooBigNames || [], tooBigNames));
+        if (namesMerged.length) merged.tooBigNames = namesMerged;
+      }
       // at / startedAt / runId / kind 保持首值
       memory.kvSet(found.key, JSON.stringify(merged));
       prune(memory);
@@ -84,10 +147,16 @@ export function logImport(memory, entry) {
   }
 
   const key = keyFor(memory, at);
-  memory.kvSet(key, JSON.stringify({
+  const rec = {
     at, startedAt: at, updatedAt: now, runId: runId || null,
     kind, name, batches, ...inc, note,
-  }));
+  };
+  if (tooBig) {
+    rec.tooBig = tooBig;
+    if (tooBigNames.length) rec.tooBigNames = tooBigNames;
+  }
+  if (foldSkipped) rec.foldSkippedRaw = foldSkipped; // 同上:0 时不加键(键序与值逐字不变)
+  memory.kvSet(key, JSON.stringify(rec));
   prune(memory);
   return key;
 }
@@ -125,5 +194,14 @@ export function formatLogLine(item) {
   const batches = Number(item.batches) || 0;
   if (batches > 1) parts.push(`${batches} 批`);
   if (item.errors) parts.push(`失败 ${item.errors} 批`);
+  // #10:被跳过的"单条过大"必须在账本那一行上看得见(放在"失败 X 批"之后,只加不占位):
+  // 它是**已知且可解释**的一件事,与"失败批"是两码事 —— 不许因为没地方写就不写(那正是修前的样子)。
+  const tooBigN = Number(item.tooBig) || 0;
+  if (tooBigN > 0) parts.push(`单条过大 ${tooBigN}`);
+  // A(2026-09-30):折叠时"因为目标已有原文而**没有替换**的轮数"也要在账本这一行上看得见。
+  // 与「单条过大」同款:**只在末尾追加**(既有部分逐字不变),且 `= 0` 时行里一个字都不多 ——
+  // 它同样是**已知且可解释**的一件事(不是失败、不是丢失:目标是保住会话里原有的真原文)。
+  const foldSkippedN = Number(item.foldSkippedRaw) || 0;
+  if (foldSkippedN > 0) parts.push(`原文未替换 ${foldSkippedN}`);
   return `${when} · 文件导入${item.name ? '(' + item.name + ')' : ''} · ${parts.join(' · ')}`;
 }

package/lib/host/lifecycle.js

@@ -2,7 +2,7 @@
 //   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 { TRUNK_ID, RAW_SOURCE_DSH } from './memory.js';
 import { freezeSnapshotForSession, invalidateSession, refreshIdleSnapshot } from './inject.js';
 import { summarizeDsh } from './summarizer.js';
 import { extractMessageText, messageSourceKind } from './snapshot.js';
@@ -151,7 +151,13 @@ export function wireLifecycle(ctx, gate, memory, settings, config) {
         }
         return;
       }
-      if (type !== 'user/message' && type !== 'assistant/message') return;
+      // U7(2026-10-01):feedback/* 是平台消息反馈事件 —— 早先在这里被一并丢掉,
+      // 于是活会话里"当场点赞/点踩"根本没有下游。放行它们,交 feedback.js 的
+      // registerFeedbackListener 处理(它订阅同一个 session/event);本 handler 自己
+      // 只用 user/assistant 消息,下面照旧过滤,互不干扰。
+      const isFeedback = type === 'feedback/message-put' || type === 'feedback/message-delete';
+      if (!isFeedback && type !== 'user/message' && type !== 'assistant/message') return;
+      if (isFeedback) return; // 放行到下游订阅后,本 handler 不再往下走(免得写 dbg 诊断噪声)
       // 只留真人消息(排除 plugin/skill-catalog/goal 注入)
       if (type === 'user/message' && messageSourceKind(event) !== 'user') return;
       const sessionId = pick(
@@ -178,6 +184,9 @@ export function wireLifecycle(ctx, gate, memory, settings, config) {
         ts: time && !Number.isNaN(time) ? new Date(time).toISOString() : null,
         model: null,
         text,
+        // v14(2026-10-01):这里是**唯一**"主人自己的会话"写入点 ⇒ 来源当场记成 'dsh'。
+        // 不靠"id 里有没有冒号"推断:将来若宿主会话 id 形态变了(带冒号/带前缀),这一行仍然如实可读。
+        source: RAW_SOURCE_DSH,
       });
       if (isUser) stampModeIfFirstInput(memory, settings, String(sessionId));
     })),
@@ -352,6 +361,8 @@ export function captureSessionDiff(memory, session, settings = null) {
       ts: time && !Number.isNaN(time) ? new Date(time).toISOString() : null,
       model: null,
       text,
+      // v14:与 session/event 那条路同一来源口径(同一条链的两个入口,口径不许分叉)
+      source: RAW_SOURCE_DSH,
     });
     added += 1;
     if (type.startsWith('user')) userAdded += 1;