dsh-prime-memory 0.26.10 → 0.26.11

package/README.en.md

@@ -565,9 +565,9 @@ directly ("zero source-less facts" invariant: every edge traces back to live L1
 | Action | Tool | Preconditions | Notes |
 | --- | --- | --- | --- |
 | Revise one memory | `memory_update` | high-privilege mode | Read old → create new (`version+1`, new id) → old row retires via the shared soft-delete confluence with a `superseded` marker (restorable) → new version enters retrieval; then both [old, new] ids are force-reprojected so graph edges follow (edges supported only by the old source get tombstoned). Not a physical delete; the JSONL fact source is append-only and never rewritten |
-| Force reprojection | `memory_reproject` | `graph.enabled` | Erases the "already projected at current version" receipts and re-enqueues at top priority, bypassing the permanent `projector_version` skip. Idempotent: in-flight jobs never pile up. **Manually added/imported memories that never showed up in the graph: this is the back-fill projection channel** (non-distilled writes now auto-enqueue; the tool remains the correction path for legacy rows and post-edit freshness) |
+| Force reprojection | `memory_reproject` | Overview → Knowledge graph switch, or `graph.enabled` | Erases the "already projected at current version" receipts and re-enqueues at top priority, bypassing the permanent `projector_version` skip. Idempotent: in-flight jobs never pile up. **Manually added/imported memories that never showed up in the graph: this is the back-fill projection channel** (non-distilled writes now auto-enqueue; the tool remains the correction path for legacy rows and post-edit freshness) |
 | Migrate one relation | `memory_migrate_relation` | high-privilege mode | Source-derived semantics: hard-validate that every `source_record_ids` is live and un-retired → the new relation lands through the deterministic projection branch (same (from, relation) with a new target closes the old edge) → a new L1 carrier record is written as the traceable basis (tagged `proposal_source=tool` plus a decision receipt). Old edges are not flipped back by later rejections: the reprojection batch pulls only the carrier, not sources whose text still describes the old relation |
-| Non-distilled writes auto-enqueue | `memory_add` / `memory_import` | `graph.enabled` | After a successful write, records join the projection queue at the same priority as distillation output (`GRAPH_PRIORITY_NEW`) — the "only distillation projects" bypass is closed |
+| Non-distilled writes auto-enqueue | `memory_add` / `memory_import` | Overview → Knowledge graph switch, or `graph.enabled` | After a successful write, records join the projection queue at the same priority as distillation output (`GRAPH_PRIORITY_NEW`) — the "only distillation projects" bypass is closed |
 
 Two boundaries worth knowing:
 

package/README.md

@@ -436,6 +436,13 @@ dsh 宿主把插件日志打到控制台；插件另把 info 级以上镜像到
 前 400 字符；所有失败告警带堆栈首帧。JSONL 事实源按轮次追加、依赖操作系统写回（不做逐条
 fsync），断电等极端崩溃最多丢最后一小段尾部，检索库可用「重建记忆」从事实源全量重导。
 
+> **重建的事实源边界（0.26.11 起要说清楚）**：重建只能重蒸**事实源覆盖到的那一刻之前**的记忆。L0 正文自 T8.4 起已停写（历史面由 DRSC 供给），所以水位之后新增的记忆**不会被重新蒸馏**——它们会被**原样保留**（保留理由 `post-watermark`：来源消息不在本次快照内），不会丢。确认弹窗会直接写出「事实源覆盖到 X」与「可重造 N 条 / 原样保留 M 条」；若晚于水位的记录超过一半，启动需要二次确认（`force`）——这是**提示**而非永久拒绝（否则停写的库上重建会被永久锁死）。
+
+> **重建的事实源可切换（`rebuild.factSource`，默认 `local`）**：
+> - `local`：本地 `l0_conversations`（已停写的冻结存量），**按会话流式读**——峰值只占单会话，不再把全量正文（3 万条量级约 88MB）驻留整个重建期；
+> - `drsc`（实验性）：`reference-session-collector` 的投影——先枚举会话、再逐会话拉全量，**恒带 `redact=1`**（collector 的 `session` 缺省是原文臂，而捕获侧是写前脱敏）。选了 drsc 但 collector 未装配会**显式报错中止**，不静默回退本地表。
+> - 注意：DRSC 无法枚举消息 id（`drsc:<sid>:<seq>` 与事实源的 `source_message_ids` 不同域），所以 `drsc` 模式下所有有来源的记忆都会被判为**不可重蒸并原样保留**（保守侧失败，不丢数据）。
+
 ## 与 MemoryCore 的差异
 
 - 内嵌完整管线（不依赖外部 Gateway），蒸馏复用 DSH 自己的 LLM；
@@ -513,9 +520,9 @@ fsync），断电等极端崩溃最多丢最后一小段尾部，检索库可用
 | 动作 | 工具 | 前提 | 说明 |
 | --- | --- | --- | --- |
 | 修订一条记忆 | `memory_update` | 高权限模式 | 读旧 → 造新（`version+1`，新 id）→ 旧行经退场汇流口 `superseded` 软删（可恢复）→ 新版进检索面；随后对 [旧,新] 强制重投，图谱边跟随（旧源支撑的边自动标墓碑）。不是物理删，也不覆写 JSONL 事实源 |
-| 强制重投 | `memory_reproject` | 配置 `graph.enabled` | 抹掉"已按当前版本投影"凭证、按高优先级重新入队——绕开 `projector_version` 的永久跳过。幂等：在途任务不堆重。**手加/导入的记忆长期不出现在图谱里，用它补投影**（非蒸馏写入现已自动入队，此工具是给存量与改后保鲜的纠正通道） |
+| 强制重投 | `memory_reproject` | 概览「知识图谱」开关 或 部署 `graph.enabled` | 抹掉"已按当前版本投影"凭证、按高优先级重新入队——绕开 `projector_version` 的永久跳过。幂等：在途任务不堆重。**手加/导入的记忆长期不出现在图谱里，用它补投影**（非蒸馏写入现已自动入队，此工具是给存量与改后保鲜的纠正通道） |
 | 迁移一条关系 | `memory_migrate_relation` | 高权限模式 | 源导语义：先硬校验 `source_record_ids` 全部"现存未退场" → 新关系经确定性投影支路落库（同 (起点,关系) 换目标自动闭旧边出新边）→ 新增一条承载新关系的 L1 源记录留可回溯根据（带 `proposal_source=tool` 审计标记与决策凭证）。旧边不会因后续重投被翻回：重投批只拉载体记录，不拉描述旧关系的旧源 |
-| 非蒸馏写入自动入队 | `memory_add` / `memory_import` | 配置 `graph.enabled` | 落库成功后与蒸馏产出同优先级（`GRAPH_PRIORITY_NEW`）进投影队——"只有蒸馏才投影"的旁路缺口已闭合 |
+| 非蒸馏写入自动入队 | `memory_add` / `memory_import` | 概览「知识图谱」开关 或 部署 `graph.enabled` | 落库成功后与蒸馏产出同优先级（`GRAPH_PRIORITY_NEW`）进投影队——"只有蒸馏才投影"的旁路缺口已闭合 |
 
 两条必须知道的边界：
 

package/dist/bench-control.js

@@ -4,7 +4,9 @@ export const BENCH_CONTROL_SERVICE = 'dsh-memory-bench';
 /** 注册控制服务,返回注销函数(调用方在插件 dispose 时执行)。 */
 export function registerBenchControl(ctx, rebuild, modes, logger) {
     const surface = {
-        rebuildStart: () => rebuild.start(),
+        // bench 场景自带可控数据集，需要确定性重建：水位落差的“二次确认”
+        // 属于人机交互护栏，不该阻断自动化赛道，故显式 force。
+        rebuildStart: () => rebuild.start(true),
         rebuildStatus: () => rebuild.getStatus(),
         setSessionMode: (sessionId, mode) => modes.set(sessionId, mode),
         getSessionMode: (sessionId) => modes.get(sessionId),

package/dist/client.js

@@ -49,9 +49,9 @@ var __create = Object.create;
 		var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 		var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
 		
-		// node_modules/@antv/g6/dist/g6.min.js
+		// node_modules/.pnpm/@antv+g6@5.1.1/node_modules/@antv/g6/dist/g6.min.js
 		var require_g6_min = __commonJS({
-		  "node_modules/@antv/g6/dist/g6.min.js"(exports, module2) {
+		  "node_modules/.pnpm/@antv+g6@5.1.1/node_modules/@antv/g6/dist/g6.min.js"(exports, module2) {
 		    !(function(t, e) {
 		      "object" == typeof exports && "undefined" != typeof module2 ? e(exports) : "function" == typeof define && define.amd ? define(["exports"], e) : e((t = "undefined" != typeof globalThis ? globalThis : t || self).G6 = {});
 		    })(exports, function(t) {
@@ -37508,6 +37508,17 @@ var __create = Object.create;
 		  return "关闭";
 		}
 		
+		// client/src/copy.ts
+		var GRAPH_FEATURE_LABEL = "知识图谱";
+		var GRAPH_TOOL_LABEL = "图谱读工具";
+		var GRAPH_BUDGET_LABEL = "图谱投影预算";
+		function graphEnableHint() {
+		  return `在设置页「概览 → ${GRAPH_FEATURE_LABEL}」打开开关后，存量记忆会逐批投影成实体与关系。`;
+		}
+		function graphSwitchDesc(on) {
+		  return on ? "已开启：L1 记忆会投影成实体与关系，存量在启动/开启后逐批补齐（可与「图谱读工具」独立开关）" : "默认关闭：开启后才会生成知识图谱；这一步会逐条走 LLM，首次开启前会先给出预计耗时";
+		}
+		
 		// client/src/tabs/ArchiveSection.tsx
 		var import_react7 = require("react");
 		var import_jsx_runtime7 = require("react/jsx-runtime");
@@ -37788,7 +37799,9 @@ var __create = Object.create;
 		  ["dedup", "去重"],
 		  ["l2", "L2 场景"],
 		  ["l3", "L3 画像"],
-		  ["graph", "图谱投影"]
+		  // 这不是“投影开关”，是投影这一步的**输出预算**（issue #16：旧标签就叫“图谱投影”，
+		  // 与概览页那个功能开关撞名，用户点了以为开了投影，实际只是改了 token 预算）。
+		  ["graph", GRAPH_BUDGET_LABEL]
 		];
 		var SCOPE_KEYS = {
 		  l1: ["extract", "dedup"],
@@ -39314,6 +39327,7 @@ var __create = Object.create;
 		  const [confirmOpen, setConfirmOpen] = (0, import_react14.useState)(false);
 		  const [busy, setBusy] = (0, import_react14.useState)(false);
 		  const [rbError, setRbError] = (0, import_react14.useState)(null);
+		  const [canForce, setCanForce] = (0, import_react14.useState)(false);
 		  const refresh = (0, import_react14.useCallback)(() => {
 		    rpc("dsh-memory/rebuild-status", {}).then((r) => {
 		      if (r && r.ok) setRb(r.value);
@@ -39334,20 +39348,25 @@ var __create = Object.create;
 		  if (!rbRaw || rbRaw.supported === false) return null;
 		  const rb = rbRaw;
 		  ensureThemeStyle();
-		  const start = () => {
+		  const start = (force = false) => {
 		    setBusy(true);
 		    setRbError(null);
-		    rpc("dsh-memory/rebuild-start", {}).then((r) => {
+		    setCanForce(false);
+		    rpc("dsh-memory/rebuild-start", force ? { force: true } : {}).then((r) => {
 		      setBusy(false);
 		      if (r && r.ok) {
 		        setConfirmOpen(false);
 		        setRb(r.value);
 		      } else {
-		        setRbError(r && r.error ? r.error.message : "启动失败");
+		        const msg = r && r.error ? r.error.message : "启动失败";
+		        setRbError(msg);
+		        setCanForce(/force/.test(msg));
 		      }
 		    }).catch((e) => {
 		      setBusy(false);
-		      setRbError(String(e && e.message || e));
+		      const msg = String(e && e.message || e);
+		      setRbError(msg);
+		      setCanForce(/force/.test(msg));
 		    });
 		  };
 		  const cancel = () => {
@@ -39391,7 +39410,13 @@ var __create = Object.create;
 		      /* @__PURE__ */ (0, import_jsx_runtime14.jsx)("span", { className: "dsh-mem-rb-muted", style: { whiteSpace: "nowrap" }, children: "产出 " + rb.recordsBuilt + " 条" })
 		    ] }) : null,
 		    lastNote ? /* @__PURE__ */ (0, import_jsx_runtime14.jsx)("div", { className: "dsh-mem-rb-muted", style: { marginTop: 8 }, children: lastNote }) : null,
-		    rbError ? /* @__PURE__ */ (0, import_jsx_runtime14.jsx)("div", { style: { marginTop: 8, fontSize: 12, color: "var(--dsh-mem-danger)" }, children: rbError }) : null,
+		    rb.rederivableCount !== null || rb.preserveCount !== null ? /* @__PURE__ */ (0, import_jsx_runtime14.jsx)("div", { className: "dsh-mem-rb-muted", style: { marginTop: 6 }, children: "本次计划：可重造 " + (rb.rederivableCount ?? 0) + " 条 · 原样保留 " + (rb.preserveCount ?? 0) + " 条（无来源或来源不在本次快照）" }) : null,
+		    rbError ? /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)("div", { style: { marginTop: 8, fontSize: 12, color: "var(--dsh-mem-danger)" }, children: [
+		      rbError,
+		      canForce ? /* @__PURE__ */ (0, import_jsx_runtime14.jsx)("div", { style: { marginTop: 6 }, children: /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(NButton, { disabled: busy, onClick: () => {
+		        start(true);
+		      }, children: busy ? "启动中…" : "我已了解，仍要继续（不重蒸水位后的记录）" }) }) : null
+		    ] }) : null,
 		    confirmOpen ? /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(
 		      NModal,
 		      {
@@ -39411,7 +39436,9 @@ var __create = Object.create;
 		            },
 		            "cancel"
 		          ),
-		          /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(NButton, { variant: "primary", disabled: busy, onClick: start, children: busy ? "启动中…" : "开始重建" }, "confirm")
+		          /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(NButton, { variant: "primary", disabled: busy, onClick: () => {
+		            start();
+		          }, children: busy ? "启动中…" : "开始重建" }, "confirm")
 		        ],
 		        children: [
 		          /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)("div", { children: [
@@ -39419,6 +39446,11 @@ var __create = Object.create;
 		            /* @__PURE__ */ (0, import_jsx_runtime14.jsx)("b", { children: rb.sessionCount + " 个会话 · " + rb.messageCount + " 条消息" }),
 		            "，预计 ≥" + rb.estCalls + " 次蒸馏调用。"
 		          ] }),
+		          /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)("div", { style: { marginTop: 8 }, children: [
+		            "事实源覆盖到：",
+		            /* @__PURE__ */ (0, import_jsx_runtime14.jsx)("b", { children: rb.factWatermark ? fmtTime(rb.factWatermark) : "无（本地 L0 没有任何正文）" }),
+		            rb.factWatermark ? "；晚于此时刻的记忆会被原样保留、不重新蒸馏（不会丢）。" : "。"
+		          ] }),
 		          /* @__PURE__ */ (0, import_jsx_runtime14.jsx)("div", { style: { marginTop: 8 }, children: "现有 L1 记忆 / L2 场景 / L3 画像会整体归档（*.bak.时间戳，可手工找回），随后清空重建；重建期间可正常对话，新对话的蒸馏优先进行；中途可取消，已重建部分保留。" })
 		        ]
 		      }
@@ -39929,6 +39961,7 @@ var __create = Object.create;
 		  const [stats, setStats] = (0, import_react17.useState)(null);
 		  const [settingsData, setSettingsData] = (0, import_react17.useState)(null);
 		  const [error, setError] = (0, import_react17.useState)(null);
+		  const [graphConfirm, setGraphConfirm] = (0, import_react17.useState)(null);
 		  const load = (0, import_react17.useCallback)(() => {
 		    rpc("dsh-memory/stats", {}).then((r) => {
 		      if (r && r.ok) setStats(r.value);
@@ -39966,6 +39999,14 @@ var __create = Object.create;
 		      setError("开关写入失败：" + String(e && e.message || e));
 		    });
 		  };
+		  const requestGraphOn = () => {
+		    rpc("dsh-memory/graph-preview", {}).then((r) => {
+		      const missing = r && r.ok ? r.value.stats?.missing ?? 0 : 0;
+		      setGraphConfirm({ missing });
+		    }).catch(() => {
+		      setGraphConfirm({ missing: 0 });
+		    });
+		  };
 		  const setNum = (key, value) => {
 		    if (!settingsData) return;
 		    const prev = settingsData;
@@ -40021,6 +40062,7 @@ var __create = Object.create;
 		  const toolMutate = settingsData && settingsData.settings ? settingsData.settings.toolMutate !== false : true;
 		  const toolSkills = settingsData && settingsData.settings ? settingsData.settings.toolSkills !== false : true;
 		  const skillsEnabled = settingsData && settingsData.settings ? settingsData.settings.skillsEnabled === true : false;
+		  const graphEnabled = settingsData && settingsData.settings ? settingsData.settings.graphEnabled === true : false;
 		  const keywordEnabled = settingsData && settingsData.settings ? settingsData.settings.keywordEnabled === true : false;
 		  const redistillEnabled = settingsData && settingsData.settings ? settingsData.settings.redistillEnabled === true : false;
 		  const mdSyncEnabled = settingsData && settingsData.settings ? settingsData.settings.mdSyncEnabled === true : false;
@@ -40100,6 +40142,23 @@ var __create = Object.create;
 		          }
 		        }
 		      ),
+		      /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("div", { style: S.panelLabel, children: GRAPH_FEATURE_LABEL }),
+		      /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+		        SwitchRow,
+		        {
+		          label: `${GRAPH_FEATURE_LABEL}投影`,
+		          desc: graphSwitchDesc(graphEnabled),
+		          checked: graphEnabled,
+		          disabled: !master,
+		          onChange: (v) => {
+		            if (v) {
+		              requestGraphOn();
+		            } else {
+		              toggle("graphEnabled", false);
+		            }
+		          }
+		        }
+		      ),
 		      /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("div", { style: S.panelLabel, children: "工具封印" }),
 		      /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
 		        SwitchRow,
@@ -40115,7 +40174,7 @@ var __create = Object.create;
 		      /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
 		        SwitchRow,
 		        {
-		          label: "图谱工具",
+		          label: GRAPH_TOOL_LABEL,
 		          desc: toolGraph ? "已注册：memory_search_graph / memory_expand_graph_node" : "已封印：图谱读工具从模型工具列表移除",
 		          checked: toolGraph,
 		          onChange: (v) => {
@@ -40271,7 +40330,53 @@ var __create = Object.create;
 		      })
 		    ] }),
 		    /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(ArchiveSection, { rpc }),
-		    /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("p", { style: S.hint, children: "浏览各层记忆内容请切换上方 Tab；原始对话（L0）不入浏览器，可由模型侧 conversation_search 工具查询。" })
+		    /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("p", { style: S.hint, children: "浏览各层记忆内容请切换上方 Tab；原始对话（L0）不入浏览器，可由模型侧 conversation_search 工具查询。" }),
+		    graphConfirm ? /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)(
+		      NModal,
+		      {
+		        open: true,
+		        onClose: () => {
+		          setGraphConfirm(null);
+		        },
+		        title: `开启${GRAPH_FEATURE_LABEL}投影？`,
+		        footer: [
+		          /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+		            NButton,
+		            {
+		              onClick: () => {
+		                setGraphConfirm(null);
+		              },
+		              children: "取消"
+		            },
+		            "cancel"
+		          ),
+		          /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+		            NButton,
+		            {
+		              variant: "primary",
+		              onClick: () => {
+		                setGraphConfirm(null);
+		                toggle("graphEnabled", true);
+		              },
+		              children: "开启"
+		            },
+		            "confirm"
+		          )
+		        ],
+		        children: [
+		          graphConfirm.missing > 0 ? /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)("div", { children: [
+		            "待投影记忆 ",
+		            /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("b", { children: graphConfirm.missing }),
+		            " 条，按每批 8 条约 ",
+		            /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("b", { children: Math.ceil(graphConfirm.missing / 8) }),
+		            " 个作业；每个作业一次 LLM 抽取（单批约 2 分钟），预计总计 ",
+		            /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("b", { children: Math.max(1, Math.round(Math.ceil(graphConfirm.missing / 8) * 2 / 60)) }),
+		            " 小时量级。"
+		          ] }) : /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("div", { children: "当前没有待投影的记忆，开启后新蒸馏的记忆会陆续进图。" }),
+		          /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("div", { style: { marginTop: 8 }, children: "投影在后台串行跑，不会阻断对话（新蒸馏的记录优先级恒高于存量补投影）；进度可在「图谱」页看，随时可关开关停下来。" })
+		        ]
+		      }
+		    ) : null
 		  ] });
 		}
 		
@@ -42711,7 +42816,11 @@ var __create = Object.create;
 		      " ",
 		      /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(NButton, { onClick: loadBoard, children: "重试" })
 		    ] }) : null,
-		    stats && stats.nodes === 0 && !error ? /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("p", { style: S.intro, children: "图谱还没有内容。它在设置里是独立开关(概览 → 图谱投影),开启后存量记忆会逐批投影成实体与关系。" }) : null,
+		    stats && stats.nodes === 0 && !error ? /* @__PURE__ */ (0, import_jsx_runtime23.jsxs)("p", { style: S.intro, children: [
+		      "图谱还没有内容。",
+		      graphEnableHint(),
+		      `（注意：这里指的是「${GRAPH_FEATURE_LABEL}」开关，不是「${GRAPH_TOOL_LABEL}」——后者只管模型能不能读图）`
+		    ] }) : null,
 		    board && board.seeds.length > 1 && view === "full" ? /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("div", { style: { ...S.flexRow, marginBottom: 8, flexWrap: "wrap", gap: 6 }, children: board.seeds.map((s) => /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(
 		      "button",
 		      {

package/dist/clients/drsc.d.ts

@@ -8,6 +8,10 @@
  * - 工具面 conversation_search → `op=search&redact=1`(命中基于原文 fts,
  *   返回 snippet 取脱敏锚定文本)。
  *
+ * 加上 issue #14-B 的**重建事实源**：`op=sessions` 枚举 + `op=session`（**不带 tail**）
+ * 逐会话拉全量——对全量重建来说“尾窗”不够用，而 collector 侧不带 tail 即 `ORDER BY seq ASC`
+ * 无 LIMIT。此路径同样恒带 `redact=1`。
+ *
  * 硬依赖纪律(对齐 T7.3 裁定):collector 缺席/超时/非 2xx/ok=false 一律抛
  * {@link DrscClientError}——**绝不回退本地 l0**(表已退役,无退路);调用方
  * 分口径处理:蒸馏背景窗空窗降级(runner),工具面显式报错(tools)。
@@ -55,6 +59,16 @@ export interface DrscSearchHit {
     on_surface: number;
     turn: number;
 }
+/** `op=sessions` 的一个会话摘要行（分页枚举用；wire 蛇形直取）。 */
+export interface DrscSessionSummary {
+    session_id: string;
+    title: string;
+    cwd: string;
+    event_count: number;
+    turn_count: number;
+    /** 末条消息时间（ms）—— collector 按它降序排，客户端用时注意反转。 */
+    last_time_ms: number;
+}
 /** kind → L0 角色词表(memory 只收 user/assistant 两类,其余(tool/* 等)不映射)。 */
 export declare function drscRoleOf(kind: string): 'user' | 'assistant' | undefined;
 /**
@@ -88,6 +102,26 @@ export declare class DrscClient {
      * collector 无此会话(session:null)返回空数组(新会话首轮的常态,非错误)。
      */
     sessionTail(sessionId: string, tail: number): Promise<DrscSessionRow[]>;
+    /**
+     * **整会话**正文（issue #14-B 重建事实源）：`op=session&session=<id>&redact=1`，
+     * **不带 `tail`** —— collector 侧 `tail` 未给时走 `ORDER BY s.seq ASC` 无 LIMIT，即全量。
+     *
+     * `redact=1` 是**硬要求**，不是可选项：collector 的 `session` 缺省是原文臂，
+     * 而 memory 捕获侧是写前单点脱敏；重建若走原文臂，产出的 L1 会比正常蒸馏「更脏」，
+     * 而且会经 md 投射落盘。
+     */
+    sessionAll(sessionId: string): Promise<DrscSessionRow[]>;
+    /**
+     * 会话枚举：`op=sessions&offset&limit`（collector 侧 limit 钳到 1..500）。
+     *
+     * 重建的事实源没有“全量导出”单口（也不应该有：一个响应装不下几万条正文），
+     * 所以走「枚举会话 → 逐会话拉全量」的 N+1 组合。采集端分页是 0-SQL 的内存切片，
+     * 代价仅在于请求数。
+     */
+    listSessions(offset: number, limit: number): Promise<{
+        total: number;
+        rows: DrscSessionSummary[];
+    }>;
     /** 原史检索:`op=search&q=<query>&limit=N&redact=1` → 脱敏 snippet 命中。 */
     search(query: string, limit: number): Promise<DrscSearchHit[]>;
 }

package/dist/clients/drsc.js

@@ -51,6 +51,26 @@ export function drscRowToConversationMessage(row, sessionId) {
     }
     return msg;
 }
+/**
+ * `op=session` 包络 → 行数组。
+ *
+ * `session:null` = collector 没有这个会话 —— 新会话首轮的常态，**不是错误**
+ * （“没有内容”与“没拿到”必须分开：前者空窗降级，后者抛 DrscClientError）。
+ */
+function parseSessionRows(body) {
+    if (body['session'] === null || body['session'] === undefined)
+        return [];
+    const rows = Array.isArray(body['rows']) ? body['rows'] : [];
+    return rows.map((r) => ({
+        seq: Number(r['seq'] ?? 0),
+        turn: Number(r['turn'] ?? 0),
+        step: Number(r['step'] ?? 0),
+        kind: String(r['kind'] ?? ''),
+        role: String(r['role'] ?? ''),
+        time: Number(r['time'] ?? 0),
+        text: String(r['text'] ?? ''),
+    }));
+}
 export class DrscClient {
     options;
     fetchImpl;
@@ -108,18 +128,43 @@ export class DrscClient {
      */
     async sessionTail(sessionId, tail) {
         const body = await this.getJson(`?op=session&session=${encodeURIComponent(sessionId)}&tail=${Math.max(0, Math.floor(tail))}&redact=1`);
-        if (body['session'] === null || body['session'] === undefined)
-            return [];
+        return parseSessionRows(body);
+    }
+    /**
+     * **整会话**正文（issue #14-B 重建事实源）：`op=session&session=<id>&redact=1`，
+     * **不带 `tail`** —— collector 侧 `tail` 未给时走 `ORDER BY s.seq ASC` 无 LIMIT，即全量。
+     *
+     * `redact=1` 是**硬要求**，不是可选项：collector 的 `session` 缺省是原文臂，
+     * 而 memory 捕获侧是写前单点脱敏；重建若走原文臂，产出的 L1 会比正常蒸馏「更脏」，
+     * 而且会经 md 投射落盘。
+     */
+    async sessionAll(sessionId) {
+        const body = await this.getJson(`?op=session&session=${encodeURIComponent(sessionId)}&redact=1`);
+        return parseSessionRows(body);
+    }
+    /**
+     * 会话枚举：`op=sessions&offset&limit`（collector 侧 limit 钳到 1..500）。
+     *
+     * 重建的事实源没有“全量导出”单口（也不应该有：一个响应装不下几万条正文），
+     * 所以走「枚举会话 → 逐会话拉全量」的 N+1 组合。采集端分页是 0-SQL 的内存切片，
+     * 代价仅在于请求数。
+     */
+    async listSessions(offset, limit) {
+        const from = Math.max(0, Math.floor(offset));
+        const size = Math.max(1, Math.min(500, Math.floor(limit)));
+        const body = await this.getJson(`?op=sessions&offset=${from}&limit=${size}`);
         const rows = Array.isArray(body['rows']) ? body['rows'] : [];
-        return rows.map((r) => ({
-            seq: Number(r['seq'] ?? 0),
-            turn: Number(r['turn'] ?? 0),
-            step: Number(r['step'] ?? 0),
-            kind: String(r['kind'] ?? ''),
-            role: String(r['role'] ?? ''),
-            time: Number(r['time'] ?? 0),
-            text: String(r['text'] ?? ''),
-        }));
+        return {
+            total: Number(body['total'] ?? rows.length),
+            rows: rows.map((r) => ({
+                session_id: String(r['session_id'] ?? ''),
+                title: String(r['title'] ?? ''),
+                cwd: String(r['cwd'] ?? ''),
+                event_count: Number(r['event_count'] ?? 0),
+                turn_count: Number(r['turn_count'] ?? 0),
+                last_time_ms: Number(r['last_time_ms'] ?? 0),
+            })),
+        };
     }
     /** 原史检索:`op=search&q=<query>&limit=N&redact=1` → 脱敏 snippet 命中。 */
     async search(query, limit) {

package/dist/config.d.ts

@@ -117,6 +117,15 @@ export interface MemoryConfig {
         /** 单源扫描记录上限(0 = 不限;仍受总护栏)。 */
         scanMaxRecords: number;
     };
+    /**
+     * 重建事实源（issue #14-B）。
+     *
+     * - `local`（默认）：本地 `l0_conversations` —— 已停写的冻结存量；
+     * - `drsc`（实验性）：`dsh-reference-session-collector` 的投影，枚举会话后逐会话拉全量。
+     */
+    rebuild: {
+        factSource: 'local' | 'drsc';
+    };
     /** 轨2 技能结晶(程序性记忆)。**默认关**：allowPromote 也默认关（上线先只计数不晋升，
      *  distinct-session 达阈后才开）；injectionTier 不用 union，消费侧归一。 */
     skills: {
@@ -193,7 +202,7 @@ export interface MemoryConfig {
      */
     workspaceSource: {
         enabled: boolean;
-        /** 路由表：按数组序取首个命中——dsh 侧在前，故双项目并存时归 dsh（用户口径）。 */
+        /** 路由表：按数组序取首个命中；**默认为空**，需按自己的项目自行配置（issue #13）。 */
         routes: WorkspaceRoute[];
         /** 存量 re-link 的单次护栏。 */
         maxRecords: number;

package/dist/config.js

@@ -82,6 +82,17 @@ export function liveSettingsSchema() {
         conflictFreeze: Schema.boolean().default(false),
         // 轨2 技能结晶总开关(看板可拨):默认 false。开=注册 memory_skill_* 工具 + 注入 active 技能 + skills-* 端点可用。
         skillsEnabled: Schema.boolean().default(false),
+        /**
+         * 知识图谱**投影**开关（issue #16，概览区可拨）。默认 false。
+         *
+         * 与部署 `graph.enabled` **取或**（照 keywordEnabled / validityTiering 先例）：
+         * 部署可强制开，面板只能追加开。
+         *
+         * 为什么它必须在 live：投影是**写侧派生**，关了只是不入队、不丢数据；
+         * 而它的入口以前只住 YAML，用户根本找不到（面板上那个“图谱投影”其实是蒸馏预算的
+         * 分层标签，点它改的是 token 预算）。
+         */
+        graphEnabled: Schema.boolean().default(false),
         // 存量回填/进阶功能的启用开关（概览「存量回填与整形」区可拨）：默认 false，
         // 与部署 cfg.<x>.enabled 取或（经 effectiveCfg）——部署可强制开，live 只能追加开。
         // 存在的理由：这些面都有对应按钮/端点，若开关只住 YAML，用户点了只会报“未开启”却没处翻。
@@ -184,6 +195,16 @@ export const memorySchema = Schema.object({
         // 单源扫描上限（防极端大包在事件循环里阻塞 RPC；scan 是手动触发，仍留护栏）。
         scanMaxRecords: Schema.number().min(0).max(20_000).default(5000),
     }),
+    // 重建事实源(issue #14-B)：默认 local（行为与改前一致）；drsc 需显式选，
+    // 且 collector 缺席时**报错中止**（不清库）——不静默回退本地，避免“以为用了新源其实还是旧表”。
+    rebuild: Schema.object({
+        /**
+         * 'local' = 本地 l0_conversations；'drsc' = reference-session-collector 投影。
+         *
+         * drsc 路径恒带 `redact=1`（collector 的 session 缺省是原文臂，而 capture 是写前脱敏）。
+         */
+        factSource: Schema.union(['local', 'drsc']).default('local'),
+    }),
     // 轨2 技能结晶：默认关 + allowPromote 关（先只计数不晋升）。
     skills: Schema.object({
         enabled: Schema.boolean().default(false),
@@ -210,7 +231,19 @@ export const memorySchema = Schema.object({
     }),
     /**
      * 内容路由：默认**开**（用户口径：谈到本仓/dsh 生态的记忆要归到本仓 workspace，
-     * 而不是全托底到 `<dataDir>/memories`）。默认路由表就是用户给的两条归类规则（路径可改，不需改码）。
+     * 而不是全托底到 `<dataDir>/memories`）。
+     *
+     * ⚠️ **默认路由表为空**（issue #13）。此前默认值写死了作者本机的 `E:\test\rewrite-agently`
+     * 与 `E:\test\agent-no-dsh`：装好即生效，凡正文含 `dsh`/`cordis`/`prime-memory` 等词的记忆
+     * 都被写上了别人机器上的路径。别人的机器没这个盘，于是
+     *  - `targetFor` 的护栏判定目录不存在 → 投射落点静默退回单根（日志一条 warn 而已）；
+     *  - 更严重的是 `scope: workspace` 时这些记录在**真实工作区**里按 workspace 过滤不可见，
+     *    表现为"记忆莫名其妙丢了"，而根源是默认值指向别人的机器。
+     *
+     * 默认值属于**可移植性契约**：不得含任何具体主机的绝对路径。要么由用户显式配置路由、
+     * 要么用 `$workspace` 之类的占位（由调用方在运行期替换为当前会话工作区），
+     * 要么不路由（`routes: []` → 全部落单根，行为与 `enabled:false` 等价但语义更诚实）。
+     * 想恢复旧的按内容归类，请在配置里自行写下自己的两条规则。
      */
     workspaceSource: Schema.object({
         enabled: Schema.boolean().default(true),
@@ -219,31 +252,17 @@ export const memorySchema = Schema.object({
              * 归到哪个 workspace（**workspace 根**，绝对路径；写入前过 normalizeWorkspacePath）。
              *
              * 存的不包含 `.agents/memory`：投射落点由 `targetFor` 算，它会在本值后拼上
-             * `WORKSPACE_SUBDIR = ['.agents','memory']`。旧默认值把它写成了
+             * `WORKSPACE_SUBDIR = ['.agents','memory']`。旧默认值曾把它写成
              * `E:\test\rewrite-agently\.agents`，于是落点变成 `.agents\.agents\memory\`——
              * 而 `.agents` 目录确实存在，"目录不存在则退回单根"的护栏救不了这种形状，
-             * 等于在仓里挂一棵没人认领的孤儿树。新增用例钉住这个不变式。
+             * 等于在仓里挂一棵没人认领的孤儿树。有用例钉住这个不变式。
              */
             path: Schema.string().default(''),
             /** 命中任一关键词即归此路（小写子串匹配，已 NFKC 归一）。 */
             anyOf: Schema.array(Schema.string()).default([]),
             /** 出现任一排除词则此路不命中（用于「无 dsh 才算非 dsh 项目」）。 */
             noneOf: Schema.array(Schema.string()).default([]),
-        })).default([
-            {
-                path: 'E:\\test\\rewrite-agently',
-                // 'dsh' 子串已覆盖 mine-dsh-plugins 下所有插件名；把目录名单列出来是因为
-                // 有些记忆只写了"某个插件"而没写 dsh- 前缀，那时这一项才顶用。
-                anyOf: ['dsh', 'mine-dsh-plugins', 'cordis', 'prime-memory', 'brief-sidebar', 'host farm', 'inferglow-dsh'],
-                noneOf: [],
-            },
-            {
-                path: 'E:\\test\\agent-no-dsh',
-                anyOf: ['hanako', 'hanaagent', 'openhanako', 'inferglow', 'pi-agent'],
-                // 同一段内容又谈到 dsh 时属于 dsh 生态（如 Hanako 逆向用于反推 dsh 机制），归 dsh 侧。
-                noneOf: ['dsh'],
-            },
-        ]),
+        })).default([]),
         maxRecords: Schema.number().min(1).max(10_000).default(300),
         timeBudgetMs: Schema.number().min(1000).max(1_800_000).default(120_000),
     }),

package/dist/contract.d.ts

@@ -111,6 +111,16 @@ export interface MemoryLiveSettings {
     /** 轨2 技能结晶总开关（看板可拨）:true = 注册 memory_skill_* 工具、注入 active 技能、skills-* 端点可用。
      *  默认 false（新功能默认关）；与部署 cfg.skills.enabled 取或（任一开则生效）。 */
     skillsEnabled: boolean;
+    /**
+     * 知识图谱**投影**开关（概览区可拨，issue #16）。
+     *
+     * true = 把 L1 记忆投影成 graph_nodes/graph_edges，并在启动/周期补齐存量；
+     * 与部署 `cfg.graph.enabled` **取或**（任一开则生效）。
+     *
+     * 注意与 `toolGraph` 的区别：后者封印的是**读**工具（memory_search_graph 等），
+     * 本键控的是**写**面（生成图谱）。两者同名接近，UI 文案必须分开写。
+     */
+    graphEnabled: boolean;
     /** 关键词回填启用开关（概览区可拨）:true = 放行 dsh-memory/keyword-backfill。与部署 cfg.keyword.enabled 取或。 */
     keywordEnabled: boolean;
     /** 重蒸馏整形启用开关（概览区可拨）:true = 放行 dsh-memory/redistill-backfill。与部署 cfg.redistill.enabled 取或。 */
@@ -185,6 +195,34 @@ export interface RebuildStatus {
      * null 表示尚未进入准备阶段。
      */
     preserveNote: string | null;
+    /**
+     * 本次重建**能够重蒸出来**的条数（来源全部落在 L0 快照内）。
+     *
+     * 与 `preserveCount` 一起构成"点下去会发生什么"的完整交代：
+     * 用户看得到多少条会被重造、多少条会被原样保住。
+     * null = 尚未出计划（未进入准备阶段）。
+     */
+    rederivableCount: number | null;
+    /** 本次重建**必须保留**的条数（无来源 / 来源不在快照 / 来源无从证明）。 */
+    preserveCount: number | null;
+    /**
+     * 事实源**覆盖到的时刻**（ISO；本地 L0 写停后即不再前移）。
+     *
+     * 这是给"这个按钮会不会倒退"提供可判依据的字段：重建只能重造到这个时刻
+     * 之前的正文。null = 本地 L0 一条正文都没有。
+     */
+    factWatermark: string | null;
+}
+/**
+ * 重建启动请求。
+ *
+ * `force` 只用于跨过**水位落差的二次确认**（见 `STALE_RATIO_THRESHOLD`）：
+ * L0 写停后“记忆晚于水位”是常态，把它做成硬拒会把重建永久锁死；
+ * 因此这里只要求调用方显式确认一次。
+ */
+export interface RebuildStartRequest {
+    /** true = 已确认“这批记录只保留、不重蒸”。 */
+    force?: boolean;
 }
 /** 反刍阶段。 */
 export type RuminatePhase = 'idle' | 'refreshing' | 'distilling' | 'consolidating' | 'updating' | 'relabeling' | 'done' | 'cancelled' | 'failed';
@@ -856,6 +894,8 @@ export interface SettingsSetRequest {
     memoryMutate?: boolean;
     /** §C 人工冲突裁决总开关(true = 冻结冲突对,停放到待人工裁决区)。 */
     conflictFreeze?: boolean;
+    /** 知识图谱投影开关(issue #16;与部署 cfg.graph.enabled 取或)。 */
+    graphEnabled?: boolean;
 }
 export interface SettingsSetResponse {
     ok: true;
@@ -1286,6 +1326,13 @@ export interface GraphPreviewResponse {
         jobsTotal: number;
         /** 永久失败作业数(dead),可选(零漂移先例);>0 → UI 拆成"完成/失败/排队"三档显示。 */
         deadJobs?: number;
+        /**
+         * 尚未投影的 L1 记录条数（issue #16），可选：为 0 时不写键。
+         *
+         * 首次开启投影前用它算“大概要花多少”：条数 ÷ 每批 8 条 = job 数，
+         * 每个 job 一次 LLM 抽取。
+         */
+        missing?: number;
     };
     /** mode==='full' 才出现;全图星图轻量块(可见节点×active 边,截断标记 truncated)。
      *  不带此键时响应与旧形状逐字节一致——消费方按需读 `res.full?`。 */
@@ -1868,7 +1915,7 @@ export interface DshMemoryRequestMap {
     'dsh-memory/log-tail': LogTailRequest;
     'dsh-memory/trace-tail': TraceTailRequest;
     'dsh-memory/rebuild-status': Record<string, never>;
-    'dsh-memory/rebuild-start': Record<string, never>;
+    'dsh-memory/rebuild-start': RebuildStartRequest;
     'dsh-memory/rebuild-cancel': Record<string, never>;
     'dsh-memory/ruminate-status': Record<string, never>;
     'dsh-memory/ruminate-start': Record<string, never>;