@nightpainters/dsh-ling 1.5.1

package/lib/host/import-log.js

@@ -0,0 +1,129 @@
+// dsh-ling host — 导入记录(每次把历史请进门,都留一笔可查的账)。
+// 设计(2026-09-11,作者拍板「甲」):
+//   - **一次导入 = 一条账**:传输层仍按批(200/批)发送,但每批带同一个 runId,
+//     host 端按 runId 累加进同一条账(批数/计数相加),日志不暴露 HTTP 细节;
+//   - `at` = **导入开始时刻并固定**(首批写入后不再变动,账不会在列表里跳位置);`updatedAt` 记最后一批;
+//   - 成功批由 /import/file/batch 自己记账;失败批由客户端经 /import/log 上报(只加 `errors` 批数);
+//   - 三条入口共用:文件导入 / 本机 DSH 扫描 / 网页端库扫描;
+//   - kv `import.log.<at>` 存 JSON;保留最近 50 条,满了作废最老的。
+
+export const IMPORT_LOG_PREFIX = 'import.log.';
+export const IMPORT_LOG_KEEP = 50;
+const AT_PAST_MS = 30 * 24 * 3600 * 1000; // 开始时刻最多回溯 30 天
+const AT_FUTURE_MS = 60 * 1000;           // 允许 1 分钟时钟偏差
+const NUM_KEYS = ['accepted', 'newRows', 'refreshed', 'upgraded', 'folded', 'removedImport', 'degraded', 'rejected', 'seen', 'errors'];
+
+function pad(n) { return n < 10 ? '0' + n : String(n); }
+
+/** 开始时刻归一:非法/越界一律退回 now —— 账的时间必须可信。 */
+export function cleanAt(value, now = Date.now()) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n <= 0) return now;
+  if (n > now + AT_FUTURE_MS) return now;
+  if (n < now - AT_PAST_MS) return now;
+  return Math.floor(n);
+}
+
+function numberFields(entry) {
+  const out = {};
+  for (const k of NUM_KEYS) out[k] = Number(entry?.[k]) || 0;
+  return out;
+}
+
+/** 同一次导入(runId)找已有账:账 ≤50 条,扫一遍的代价可忽略;坏值跳过。 */
+function findByRun(memory, runId) {
+  for (const r of memory.kvList(IMPORT_LOG_PREFIX)) {
+    try {
+      const v = JSON.parse(String(r.value));
+      if (v && typeof v === 'object' && v.runId === runId) return { key: String(r.key), value: v };
+    } catch { /* 坏值跳过 */ }
+  }
+  return null;
+}
+
+function prune(memory) {
+  const keys = memory.kvList(IMPORT_LOG_PREFIX).map((r) => String(r.key)).sort();
+  while (keys.length > IMPORT_LOG_KEEP) memory.kvDel(keys.shift());
+}
+
+/** 键 = 开始时刻(同毫秒重复导入时加补零序号兜底),保证列表排序≈时间序。 */
+function keyFor(memory, at) {
+  let key = IMPORT_LOG_PREFIX + at;
+  let n = 1;
+  while (memory.kvGet(key) !== undefined) key = IMPORT_LOG_PREFIX + at + '.' + String(++n).padStart(3, '0');
+  return key;
+}
+
+/**
+ * 记账。带 runId 时**累加**进同一条账(一次导入一条);不带则为独立一笔(单次扫描)。
+ * 返回落的 kv key。
+ */
+export function logImport(memory, entry) {
+  const now = Date.now();
+  const runId = String(entry?.runId || '').slice(0, 64);
+  const at = cleanAt(entry?.at, now);
+  const inc = numberFields(entry);
+  const batches = Math.max(1, Math.min(Number(entry?.batches) || 1, 5000));
+  const name = String(entry?.name || '').slice(0, 120);
+  const note = String(entry?.note || '').slice(0, 200);
+  const kind = String(entry?.kind || 'file');
+
+  if (runId) {
+    const found = findByRun(memory, runId);
+    if (found) {
+      const merged = { ...found.value, updatedAt: now };
+      merged.batches = (Number(found.value.batches) || 1) + batches;
+      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;                 // 备注取最新
+      // at / startedAt / runId / kind 保持首值
+      memory.kvSet(found.key, JSON.stringify(merged));
+      prune(memory);
+      return found.key;
+    }
+  }
+
+  const key = keyFor(memory, at);
+  memory.kvSet(key, JSON.stringify({
+    at, startedAt: at, updatedAt: now, runId: runId || null,
+    kind, name, batches, ...inc, note,
+  }));
+  prune(memory);
+  return key;
+}
+
+/** 读取最近 limit 条(倒序,新→旧)。 */
+export function listImportLog(memory, { limit = 50 } = {}) {
+  const rows = memory.kvList(IMPORT_LOG_PREFIX);
+  const items = [];
+  for (const r of rows) {
+    try {
+      const v = JSON.parse(String(r.value));
+      if (v && typeof v === 'object' && v.at) items.push(v);
+    } catch { /* 坏值跳过 */ }
+  }
+  items.sort((a, b) => Number(b.at) - Number(a.at));
+  return items.slice(0, Math.max(1, Math.min(limit, IMPORT_LOG_KEEP)));
+}
+
+/** 展示用的一行摘要(纯函数,便于单测)。 */
+export function formatLogLine(item) {
+  const d = new Date(Number(item.at));
+  const when = `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
+  if (item.kind === 'dsh') {
+    return `${when} · 本机 DSH 扫描 · 候选 ${item.seen || 0} · 新增 ${item.newRows}`;
+  }
+  if (item.kind === 'dsweb') {
+    return `${when} · 网页端库扫描 · 源库 ${item.seen || 0} 条 · 新增 ${item.newRows} · 刷新 ${item.refreshed}`;
+  }
+  const parts = [`新增 ${item.newRows}`, `刷新 ${item.refreshed}`];
+  if (item.upgraded) parts.push(`补全原文 ${item.upgraded}`);
+  if (item.folded) parts.push(`并入网页端 ${item.folded}`);
+  if (item.removedImport) parts.push(`清理副本 ${item.removedImport}`);
+  if (item.degraded) parts.push(`降级轻量 ${item.degraded}`);
+  if (item.rejected) parts.push(`拒绝 ${item.rejected}`);
+  const batches = Number(item.batches) || 0;
+  if (batches > 1) parts.push(`${batches} 批`);
+  if (item.errors) parts.push(`失败 ${item.errors} 批`);
+  return `${when} · 文件导入${item.name ? '(' + item.name + ')' : ''} · ${parts.join(' · ')}`;
+}

package/lib/host/inject-common.js

@@ -0,0 +1,25 @@
+// dsh-ling host — shared keyword helpers (used by inject & lifecycle).
+// v0 query tokenizer: overlapping 4-grams per CJK segment. Stored overview
+// keywords are 4..6-char windows; substring containment in l1.kwOverlap then
+// hits regardless of window offsets (e.g. stored "双份项目讨论" ⊃ query "项目讨论").
+export function keywordsFrom(text) {
+  if (!text) return [];
+  const segs = String(text).split(/[^\u4e00-\u9fff]+/).filter((s) => s.length >= 2);
+  const out = [];
+  for (const seg of segs.slice(0, 6)) {
+    if (seg.length <= 6) {
+      if (!out.includes(seg)) out.push(seg);
+      continue;
+    }
+    // 滑动 4-gram
+    for (let i = 0; i + 4 <= seg.length && out.length < 24; i += 2) {
+      const g = seg.slice(i, i + 4);
+      if (!out.includes(g)) out.push(g);
+    }
+    if (out.length < 24) {
+      const head = seg.slice(0, 6);
+      if (!out.includes(head)) out.push(head);
+    }
+  }
+  return out.slice(0, 16);
+}

package/lib/host/inject.js

@@ -0,0 +1,285 @@
+// dsh-ling host — system-prompt injection (DESIGN §4.2/4.3, REPORT-02).
+// One global section; text() is evaluated at every model-step assembly and is
+// a PURE READ of the session's frozen snapshot:
+//   - running sessions: always return the frozen snapshot (D4 — never mutate,
+//     never rebuild mid-run);
+//   - idle sessions with a stale snapshot: rebuild lazily (one-time invalidation);
+//   - subagent/child/unknown sessions: return '' (R5).
+import { svc, pick, neutralizeMustache, sessionKind } from './util.js';
+import { buildSnapshotText, firstUserText } from './snapshot.js';
+import { currentMode } from './mode.js';
+import { keywordsFrom } from './inject-common.js';
+import { timeAnchorDate, timeAnchorLive } from './clock.js';
+
+export const SECTION_NAME = 'dsh-ling.memory';
+export const SECTION_ORDER = 1500; // persona(order 0)之后、指令之前
+/** 时间锚 · context 侧(2026-09-23 搬迁):时段 + 间隔挂在**末条消息**上。
+ *  平台(context)只在本轮文本真的不同时才产出新快照,而 section 改一个字就作废整个前缀。
+ *  order 取 300:平台保留位只占 110/115/120,留出可读间隔。 */
+export const CLOCK_CONTEXT_NAME = 'dsh-ling.clock';
+export const CLOCK_CONTEXT_ORDER = 300;
+
+function agentOf(assembly) {
+  return pick(() => assembly?.agent, () => assembly?.scope?.agent, () => assembly?.ctx?.agent);
+}
+
+function sessionIdOfAgent(agent) {
+  return pick(
+    () => agent?.session?.id,
+    () => agent?.session?.header?.id,
+    () => agent?.sessionId,
+    () => agent?.id,
+  );
+}
+
+/** 会话种类(D9-a):'top' | 'fork' | 'subagent' | 'unknown'。
+ *  旧版把 fork 与 subagent 一并当 child 丢弃 ⇒ 分叉会话记忆真空;
+ *  现在**分叉会话照常注入**(读血缘链),只有子代理与"取不到 header"仍保守拒绝。 */
+function kindOfAgent(agent) {
+  const header = pick(
+    () => agent?.session?.header,
+    () => agent?.header,
+  );
+  return sessionKind(header);
+}
+
+/** 能否注入(D9-a):顶层与分叉会话可以,子代理/未知不可以。 */
+function canInject(kind) {
+  return kind === 'top' || kind === 'fork';
+}
+
+/** B#9(2026-09-22 审计):消费注入感知水位 —— **只在真正要把文本送进模型时调用**。
+ *  渲染(buildSnapshotText)本身不推进:它也会被"只重建、未开口"的路径调用
+ *  (invalidateSession / refreshIdleSnapshot),在那里推进会把主人刚改的东西
+ *  标记成已读,等真正开口时反而看不到。水位按会话、单调不回退。 */
+function advanceLogWatermark(memory, sessionId, maxId) {
+  const v = Number(maxId);
+  if (!sessionId || !Number.isFinite(v) || v <= 0) return;
+  try {
+    const k = 'branch_log_wm.' + String(sessionId);
+    if (v > Number(memory.kvGet(k) || 0)) memory.kvSet(k, String(v));
+    // 复盘守门(2026-09-22 用户:「动记忆树不能是随意的,应该是慎重严肃的」):
+    // 另记一个**全局最后同步**水位,回答"自器灵上次开口以来累积了多少笔改动还没交代"
+    // (memory.branchLogPending 读它)。与会话水位互补 —— 会话水位管"这个会话看到什么",
+    // 本键管"是否还没跟器灵交代过"。
+    if (v > Number(memory.kvGet('branch_log_wm.last') || 0)) memory.kvSet('branch_log_wm.last', String(v));
+  } catch { /* 推进失败仅导致下次重复提示,不影响注入 */ }
+}
+
+export function registerMemorySection(ctx, gate, memory, settings) {
+  const sp = svc(ctx, 'systemPrompt');
+  if (!sp || typeof sp.section !== 'function') {
+    console.debug('[dsh-ling] systemPrompt service unavailable; injection disabled');
+    memory.kvSet('inject.section_registered', '0:no-service');
+    return () => {};
+  }
+  let registered = false;
+  try {
+    const ret = sp.section({
+      name: SECTION_NAME,
+      order: SECTION_ORDER,
+      complete: false,
+      text: (assembly) => renderMemorySection(assembly, gate, memory, settings),
+    });
+    registered = true;
+    memory.kvSet('inject.section_registered', '1');
+    void ret;
+  } catch (e) {
+    console.debug('[dsh-ling] systemPrompt.section failed', e);
+    memory.kvSet('inject.section_registered', '0:' + String(e?.message ?? e).slice(0, 120));
+  }
+  // ── 时间锚 · context 侧(2026-09-23) ────────────────────────────────
+  // 时段与间隔挂末条消息,不再进 system 前缀。旧写法每请求一次前缀全废
+  // (实测回合内断裂 174 次 = 未缓存 token 43.96%);档位化后一天最多变几次。
+  let clockRegistered = false;
+  try {
+    const ret2 = sp.context({
+      name: CLOCK_CONTEXT_NAME,
+      order: CLOCK_CONTEXT_ORDER,
+      // ⚠️ C-03(1.5.1 红蓝对抗,2026-09-25):时间锚搬到 context 侧时**必须同样中和**。
+      //   锚里的称呼来自 `persona.userTitle` —— 那是**用户可编辑的自由文本**,而且
+      //   `corpus-suggest.js` 会从真实对话里挖出候选、经建议通道采纳写进 persona。
+      //   一旦它含 `{{x}}`,宿主 renderPrompt 的 interpolate 会**直接抛异常**,
+      //   而 agent-loop 调用处无 try/catch ⇒ **该会话每一步模型调用都失败**。
+      //   这正是 1.3.1 拆掉的那颗雷(S12)的同类面:section 侧一直有中和
+      //   (见 renderMemorySection 的 `neutralizeMustache(anchor)`),搬迁时漏了这一处。
+      text: () => neutralizeMustache(timeAnchorLive(memory, settings)),
+    });
+    clockRegistered = true;
+    memory.kvSet('inject.clock_ctx_registered', '1');
+    void ret2;
+  } catch (e) {
+    console.debug('[dsh-ling] systemPrompt.context failed', e);
+    memory.kvSet('inject.clock_ctx_registered', '0:' + String(e?.message ?? e).slice(0, 120));
+  }
+  return () => {
+    if (registered) {
+      try {
+        sp.section?.({ name: SECTION_NAME, order: SECTION_ORDER, complete: false, text: '' });
+      } catch {}
+      registered = false;
+    }
+    if (clockRegistered) {
+      try {
+        // 同名重注册即覆盖:与 section 的注销形态一致
+        sp.context?.({ name: CLOCK_CONTEXT_NAME, order: CLOCK_CONTEXT_ORDER, text: '' });
+      } catch {}
+      clockRegistered = false;
+    }
+  };
+}
+
+/** 注入面文本渲染(导出供回归断言直接调用,2026-09-23)。
+ *  导出是刻意的:`{{…}}` 与时间锚两处病灶都靠"跨分钟取样"的断言钉住,
+ *  没有导出就只能靠端到端间接验证。 */
+export function renderMemorySection(assembly, gate, memory, settings) {
+  try {
+    if (!assembly) return '';
+    const agent = agentOf(assembly);
+    const sessionId = agent ? sessionIdOfAgent(agent) : undefined;
+    if (!sessionId) return '';
+    if (!canInject(kindOfAgent(agent))) return ''; // 子代理/未知不注入(R5);D9-a:分叉会话注入血缘链
+    // 时间锚 · system 侧(2026-09-23 搬迁):**只有日期 + 星期**(-+纪念日)。
+    // 时分/时段/间隔已移出 —— 它们分钟级抖动,会让整段会话前缀每请求作废一次。
+    // 时段与间隔现在走 systemPrompt.context()(见 registerMemorySection 的 clock 段)。
+    const anchor = timeAnchorDate(memory, settings);
+    // 注入面出口 ②(最终侧,2026-09-18):时间锚不经快照,未来新增的 part 也只走这里,
+    // 故在最外层再中和一次(幂等)。①+② 合计覆盖全部注入文本。
+    const withAnchor = (text) => {
+      const body = neutralizeMustache(text || '');
+      if (!anchor) return body;
+      return (body ? body + '\n\n' : '') + neutralizeMustache(anchor);
+    };
+    const snap = gate.snapshotOf(sessionId);
+    if (!snap) {
+      // 首轮组装可能先于/晚于 session-start 事件:空闲时补建,运行时不建(D4)
+      if (gate.isRunning(sessionId)) return withAnchor('');
+      const mode = currentMode(memory, settings, sessionId);
+      const kw = keywordsFrom(firstUserText(agent));
+      const built = buildSnapshotText(null, memory, settings, sessionId, { keywords: kw, bumpHits: true });
+      gate.markSnap(sessionId, { ...built, sessionId, mode, keywords: kw });
+      advanceLogWatermark(memory, sessionId, built.logMaxId); // B#9:定稿即消费
+      return withAnchor(built.text);
+    }
+    // 冻结:running 一律返回既有快照(即使 stale);时间锚仍实时
+    if (gate.isRunning(sessionId)) {
+      advanceLogWatermark(memory, sessionId, snap.logMaxId); // B#9:冻结快照投递即消费
+      return withAnchor(snap.text || '');
+    }
+    // idle + stale → 懒重建(一次性失效);重建必须带上首次定稿时的关键词,否则排序口径会变
+    if (snap.stale) {
+      const mode = currentMode(memory, settings, sessionId);
+      const kw = Array.isArray(snap.keywords) ? snap.keywords : keywordsFrom(firstUserText(agent));
+      const built = buildSnapshotText(null, memory, settings, sessionId, { keywords: kw });
+      gate.markSnap(sessionId, { ...built, sessionId, mode, keywords: kw });
+      advanceLogWatermark(memory, sessionId, built.logMaxId); // B#9:重建后投递即消费
+      return withAnchor(built.text);
+    }
+    advanceLogWatermark(memory, sessionId, snap.logMaxId); // B#9:命中缓存快照投递即消费
+    return withAnchor(snap.text || '');
+  } catch (e) {
+    console.debug('[dsh-ling] textForAssembly failed', e);
+    return '';
+  }
+}
+
+/** 供 lifecycle:agent/session-start 时为新顶层会话定稿快照。 */
+export function freezeSnapshotForSession(gate, memory, settings, agent) {
+  const sessionId = agent ? sessionIdOfAgent(agent) : undefined;
+  if (!sessionId) return null;
+  const kind = kindOfAgent(agent);
+  if (!canInject(kind)) return null;
+  const mode = currentMode(memory, settings, sessionId);
+  // 关键词上下文必须随快照存下来:重建时若丢失,L1 的排序口径会悄悄换一套
+  // (关键词加成最高 +1.8,远大于热度项 0.3~0.5)
+  const kw = keywordsFrom(firstUserText(agent));
+  const built = buildSnapshotText(null, memory, settings, sessionId, { keywords: kw, bumpHits: true });
+  gate.markSnap(sessionId, { ...built, sessionId, mode, keywords: kw });
+  return { sessionId, mode, chars: built.text.length };
+}
+
+/** 人格/模式变更后的失效入口:运行中仅标记 stale(注入面不变),空闲立即重建。 */
+export function invalidateSession(gate, memory, settings, sessionId) {
+  if (!sessionId) return { invalidated: false };
+  const snap = gate.snapshotOf(sessionId);
+  if (gate.isRunning(sessionId)) {
+    gate.markSnapStale(sessionId);
+    return { invalidated: false, queued: true, running: true };
+  }
+  const mode = currentMode(memory, settings, sessionId);
+  const kw = Array.isArray(snap?.keywords) ? snap.keywords : [];
+  const built = buildSnapshotText(null, memory, settings, sessionId, { keywords: kw });
+  gate.markSnap(sessionId, { ...built, sessionId, mode, keywords: kw });
+  return { invalidated: true, mode };
+}
+
+// ---------------- B:空闲边界刷新(长会话在 idle 时把 L1 追平到最新) ----------------
+const REFRESH_KEY = 'snap.refresh:';
+
+function readRefreshRecord(memory, sessionId) {
+  try {
+    const raw = memory.kvGet(REFRESH_KEY + sessionId);
+    if (!raw) return { count: 0, lastAt: 0 };
+    const v = JSON.parse(String(raw));
+    return { count: Number(v?.count) || 0, lastAt: Number(v?.lastAt) || 0 };
+  } catch {
+    return { count: 0, lastAt: 0 };
+  }
+}
+
+/** 面板/状态接口用:该会话在空闲边界刷新过几次、最近一次何时。 */
+export function refreshStats(memory, sessionId) {
+  return sessionId ? readRefreshRecord(memory, sessionId) : { count: 0, lastAt: 0 };
+}
+
+/**
+ * 空闲边界刷新:仅当「快照存在 + 会话空闲 + memory_version 变了 + 距上次刷新 ≥ 最小间隔」时重建。
+ * 只会在 running→idle 时被调用,因此 D4 不变量(运行中注入面逐字节不变)天然保持。
+ *
+ * @param {object} opts
+ *   - now:注入时间(测试用)
+ *   - summarize:可选,刷新前先跑一次"本会话增量概述"(纯文本、零 LLM),否则追平的是上一轮概述
+ *   - minIntervalMin:覆盖最小间隔(测试用)
+ * @returns {{refreshed:boolean, reason:string, count?:number, chars?:number, lastAt?:number}}
+ */
+export function refreshIdleSnapshot(gate, memory, settings, sessionId, { now = Date.now(), summarize = null, minIntervalMin = null } = {}) {
+  try {
+    if (!sessionId) return { refreshed: false, reason: 'no-session' };
+    const s = settings && typeof settings.get === 'function' ? settings.get() : (settings || {});
+    const cfg = s.memory || {};
+    if (cfg.idleRefresh === false) return { refreshed: false, reason: 'disabled' };
+    if (gate.isRunning(sessionId)) return { refreshed: false, reason: 'running' };
+    const snap = gate.snapshotOf(sessionId);
+    if (!snap || !snap.text) return { refreshed: false, reason: 'no-snapshot' };
+    // ① 先让概述器落库(它会 bump memory_version),否则下面比对的是上一轮版本
+    if (typeof summarize === 'function') {
+      try {
+        summarize();
+      } catch (e) {
+        console.debug('[dsh-ling] idle summarize failed', e);
+      }
+    }
+    const cur = String(memory.kvGet('memory_version') || '0');
+    if (String(snap.memoryVersion || '0') === cur) return { refreshed: false, reason: 'unchanged' };
+    const minMs = Math.max(0, Number(minIntervalMin ?? cfg.idleRefreshMinIntervalMin ?? 10)) * 60000;
+    const rec = readRefreshRecord(memory, sessionId);
+    if (minMs > 0 && rec.lastAt && now - rec.lastAt < minMs) {
+      return { refreshed: false, reason: 'throttled', count: rec.count, lastAt: rec.lastAt };
+    }
+    const mode = currentMode(memory, settings, sessionId);
+    const kw = Array.isArray(snap.keywords) ? snap.keywords : [];
+    const built = buildSnapshotText(null, memory, settings, sessionId, { keywords: kw, now });
+    // ② 内容判等:文本没变 → 不计数(避免无谓的前缀失效),但仍刷新快照元信息
+    if (built.text === snap.text) {
+      gate.markSnap(sessionId, { ...built, sessionId, mode, keywords: kw });
+      return { refreshed: false, reason: 'same-text', count: rec.count };
+    }
+    gate.markSnap(sessionId, { ...built, sessionId, mode, keywords: kw });
+    const next = { count: rec.count + 1, lastAt: now };
+    memory.kvSet(REFRESH_KEY + sessionId, JSON.stringify(next));
+    return { refreshed: true, reason: 'rebuilt', count: next.count, chars: built.text.length };
+  } catch (e) {
+    console.debug('[dsh-ling] refreshIdleSnapshot failed', e);
+    return { refreshed: false, reason: 'error' };
+  }
+}