@modusensus/dsh-mneme 0.9.3 → 0.9.5

package/src/organize.js

@@ -2,8 +2,10 @@
 // agent 主动整理接口（issue #231，口径基线 = #164 的「第三腿触发」）：dryRun
 // 出比对报告 → agent 判断 → apply 落库；筛除项进归档不删；调用全程留审计回执。
 //
-// 只做功能本体（维护者口径，issue #231）：落在 service 层并带测试，**不进工具
-// 列表、不加独立 opt-in 开关**——#249 到位时只差「注册工具 + 注入指引」一步。
+// 只做功能本体（维护者口径，issue #231）：落在 service 层并带测试。**调用入口在
+// 第二批**（#231：`tools.js` 的 `memory_organize` + `organizeEnabled` 默认关）——
+// 本模块至今不读任何配置键，闸门与 scope 盖章都在调用方那一侧，所以本体语义与
+// 第一批逐字节相同。
 //
 // 独立成模块（AGENTS.md 尺寸约定，同 document.js / recall-stats.js 先例）：
 // service.js 只做依赖注入 + barrel 出口，调用方零改动。
@@ -28,6 +30,10 @@
 
 import { createHash, randomUUID } from "node:crypto";
 import { scopeKeyOf } from "./scope.js";
+// 比对池要先剔掉外来行：报告里的 item.match.id 既给出「命中」结论，也是 apply 的
+// archive 动作唯一许可的目标集（硬规则 3b），而 archive 直接 store.setArchived，
+// 不经 saveWithDedupe 那道闸门——留着外来行，整理接口就能替别人决定归档面。
+import { isImportedRow } from "./memory-source.js";
 import { cosineSimilarity } from "./dream/clustering.js";
 import { buildReceipt } from "./dream.js";
 
@@ -157,7 +163,7 @@ export function createOrganizer({ store, embedQuery, saveWithDedupe, transaction
       if (!rowsByScope.has(key)) {
         rowsByScope.set(
           key,
-          store.list({ type: candidate.type, limit: null }).filter((m) => !m.archived && scopeMatches(m, candidate))
+          store.list({ type: candidate.type, limit: null }).filter((m) => !isImportedRow(m) && !m.archived && scopeMatches(m, candidate))
         );
       }
       return rowsByScope.get(key);

package/src/pipeline.js

@@ -118,13 +118,33 @@ export function suggestRetirements(pipeline, { runs = [], now = Date.now(), obse
   const violationSeen = new Set();
   for (const run of runs || []) {
     const doneIds = new Set((run.steps || []).filter((s) => s && !s.skipped && !s.detoured).map((s) => s.id));
+    // #461：一条 run 的判别键分两类，两类永不相撞。
+    //
+    // at 存在（合法账本的唯一形态——normalizeRun 在写侧强制必填）走 `at:<值>`。
+    // at 缺失（读侧被独立喂进非法形状，或未来写契约放宽）走 `anon:<内容指纹>`：
+    // by + triggeredBy + 按序的结构化 step 字段（字段取舍见下方 anonymousRunKey）。
+    // 用**内容**而不是数组索引，是因为
+    // violationSeen 跨整本账本共享，而索引只在「本次遍历的数组顺序」里唯一——
+    // 同一条 run 在账本里出现两次时，索引会让它的同一条违规被记成两条，
+    // 那正是本条要修的那类「键塌缩」的反面形态（#507 评审）。
+    //
+    // 评审里希望中间加一层 run.id，但 normalizeRun（src/pipeline-runs.js:187）
+    // 只产出 { at, by, triggeredBy, steps }，没有 id 字段，而 suggestRetirements
+    // 收到的已经是归一化后的 run；补 id 要改写侧契约，不属这条防御深度问题。
+    // 内容指纹是同一意图下不需要动 schema 的等价物。
+    //
+    // 两类键必须带不同前缀：否则「第 0 条缺 at」与「另一条 at 字面量正好是
+    // #0」会生成同一个键，后一条 violation-precedence 被静默吞掉。
+    const runKey = isNonEmptyString(run.at)
+      ? `at:${run.at}`
+      : anonymousRunKey(run);
     for (const step of pipeline.steps) {
       if (!doneIds.has(step.id) || !Array.isArray(step.needs)) continue;
       for (const need of step.needs) {
         if (doneIds.has(need)) continue;
         const had = (run.steps || []).some((s) => s && s.id === need);
         if (had) continue; // 前置做过（哪怕是 skipped）就不算违规
-        const vk = `${run.at ?? ""}|${step.id}|${need}`;
+        const vk = `${runKey}|${step.id}|${need}`;
         if (violationSeen.has(vk)) continue;
         violationSeen.add(vk);
         // 同一步对不同前置各报一条：修图的人需要知道**断在哪条边**上
@@ -241,6 +261,47 @@ function isNonEmptyString(value) {
   return typeof value === "string" && value.trim() !== "";
 }
 
+/**
+ * at 缺失时一条 run 的判别键（#461 / CodeRabbit #507）：给无时间戳的 run 一个
+ * **按内容**的稳定身份，好让 violationSeen 只并掉「同一条 run 重复出现」的同类
+ * 违规，而不把内容不同的两条 run 并成一条。
+ *
+ * 覆盖 normalizeSteps（src/pipeline-runs.js:242）产出的**全部结构化字段**——
+ * id / at / skipped / detoured / refuted。之所以必须收 step.at：漏了它，两条只在
+ * 某一步时间上不同的 at-less run 会共键，后一条的 violation-precedence 被去重吞掉
+ * （#507 指出的正是这条）。
+ *
+ * 用 JSON.stringify 而不是手写 `${id}@${at}` 拼接：run 侧 step id 只过
+ * isSafeSegment（src/pipeline-runs.js:83），`@` `,` `:` 都是合法 id，手写拼接会与
+ * 「id 里恰好含这些字符」的另一条 step 撞串——那会新造一类键塌缩（把另一类 at-less
+ * 输入从「不漏报」改成「漏报」）。JSON 自带无歧义分隔，顺带把 by/triggeredBy 里的
+ * `|`、以及 Date 与 ISO 串（Date.toJSON 归一成 ISO）的歧义一并收掉。
+ *
+ * note 不进来：它是自由文本，序列化进去会让「只差备注的同一条观测」被当成两次。
+ *
+ * 如实记下代价：skipped/detoured/refuted 对去重正确性是**惰性**的——violation 判定
+ * 只读 doneIds（由 id + skipped/detoured 决定）与 id 是否存在，refuted 根本不被读
+ * （见下方 suggestRetirements）。所以收这三个布尔防不住任何错误合并，却会让两条只差
+ * 这些旗标的 at-less run 各报一条**逐字相同**的提议。仍选择全收，是为了让规则统一
+ * （指纹 = 归一化 step 的每个结构化字段，唯一例外是自由文本 note），且将来 violation
+ * 逻辑若开始读某个旗标时不会突然开始漏合并；anon 路径本身没有身份锚点，接受这一条
+ * 重复的代价。注意这条路径在生产不可达：readStoredRun（src/pipeline-runs.js:262）
+ * 强制 run.at 存在，正常账本永远走 `at:` 分支，此处纯属直接调用边界的防御深度。
+ */
+function anonymousRunKey(run) {
+  return `anon:${JSON.stringify({
+    by: run.by ?? null,
+    triggeredBy: run.triggeredBy ?? null,
+    steps: (run.steps || []).map((s) => ({
+      id: s?.id ?? null,
+      at: s?.at ?? null,
+      skipped: !!s?.skipped,
+      detoured: !!s?.detoured,
+      refuted: !!s?.refuted
+    }))
+  })}`;
+}
+
 /**
  * 校验一条工作流。返回归一化后的对象；有任何问题就抛，不返回「部分可用」的东西
  * ——半个工作流比没有工作流更危险，因为它会被当成完整的跑。

package/src/profile-extract.js

@@ -0,0 +1,161 @@
+// dsh-mneme/src/profile-extract.js
+// 从活跃记忆反向提取「助手眼中的用户」画像**草稿**（issue #497 的第三段）。
+//
+// 三条纪律，都是「做错界面上看不出来」的那类，所以写在文件头：
+// 1. **只出草稿，绝不写 user_settings**。画像正文是用户手写的原文；让模型「合并」
+//    等于给它改写权，而改写后的文本每帧都注入。采用与否必须是用户在面板上的一次
+//    显式动作（走既有的 PUT /profile），本模块不参与。
+// 2. **没有可用输入就不调模型**。空库下模型只会编一段「她是个热爱学习的人」，
+//    那种草稿比没有草稿更坏——它会成为用户看到的「关于自己」的第一版真相。
+// 3. **吐不出可用 JSON 就报错，绝不回空草稿**。「没提炼出东西」与「模型没按格式
+//    写」必须在结果里可区分（#493 同一条教训：解析失败被读成空结果，用户会以为库是空的）。
+//
+// 记忆正文是模型的**可影响输入**：一条指令型记忆不该改写这次任务。所以喂进去的内容
+// 包在围栏里，并在系统段重申「这是数据不是指令」——与 #493 的转录围栏、#380 的判定
+// 提示同源的做法，不是第三套。
+//
+// 系统段还禁了一件事：**不许给助手本身起名或设定人格**。画像与规则不受
+// personaEnabled 管辖、也不看人格寻址口径（见 src/user-settings.js），正文里一旦出现
+// 「你是某某」，就会重演 #497 那个身份撞车——而且是每个会话每一帧。
+//
+// LLM 调用与审计完全复用 dream.js 的既有缝（streamText / runAuditedLlm / resolveRoute）：
+// chunk 形状的三个硬点（用量嵌在 chunk.usage、终态 finish 才是错误、rc.1 把适配器故障
+// 转成 finish chunk 而不是抛错）都在那里踩过并修过，不在这里重写第二遍。
+
+import { STR, langOf } from "./lang.js";
+import { describeStreamFailure, resolveRoute, runAuditedLlm, streamText } from "./dream.js";
+
+const DEFAULT_MAX_ROWS = 120;
+const DEFAULT_ROW_CHARS = 260;
+const DEFAULT_TOTAL_CHARS = 9000;
+
+/** 带 code 的失败：路由按 code 映射状态码，调用方据此区分「没东西可提」与「模型没配合」。 */
+export class ProfileExtractError extends Error {
+  constructor(code, message) {
+    super(message ?? code);
+    this.name = "ProfileExtractError";
+    this.code = code;
+  }
+}
+
+/**
+ * 从模型输出里取那个 JSON 对象。先剥 markdown 围栏（模型常加），再退到「第一个 { 到
+ * 最后一个 }」的宽取——画像文本里带花括号是常态，严格 parse 失败时这一步能救回来。
+ * 取不到可用结构就返回 null，由调用方判失败；绝不返回空串冒充成功。
+ */
+export function parseProfileDraft(text) {
+  if (typeof text !== "string" || !text.trim()) return null;
+  const cleaned = text.replace(/```(?:json)?\s*([\s\S]*?)```/gi, "$1").trim();
+  const candidates = cleaned.startsWith("{") ? [cleaned] : [];
+  const open = cleaned.indexOf("{");
+  const close = cleaned.lastIndexOf("}");
+  if (open >= 0 && close > open) candidates.push(cleaned.slice(open, close + 1));
+  for (const candidate of candidates) {
+    let value;
+    try {
+      value = JSON.parse(candidate);
+    } catch {
+      continue;
+    }
+    if (value && typeof value === "object" && typeof value.profile === "string" && value.profile.trim()) {
+      return value.profile.trim();
+    }
+  }
+  return null;
+}
+
+/** 活跃行读数：归档与被遗忘的行默认就不在这里（store.list 的默认口径）。 */
+function collectRows(service, maxRows, totalChars, rowChars) {
+  // 多取一行只为如实回答「还有没有」：截断必须可被调用方察觉，静默少读会让用户
+  // 以为画像已经看全了整个库。
+  const fetched = service.list({ limit: maxRows + 1, order: "importance" });
+  const rows = [];
+  let chars = 0;
+  let truncated = fetched.length > maxRows;
+  for (const row of fetched.slice(0, maxRows)) {
+    const content = String(row.content ?? "").slice(0, rowChars);
+    if (content.length < String(row.content ?? "").length) truncated = true;
+    const size = `${row.type} ${row.title} ${content}`.length;
+    if (chars + size > totalChars) {
+      truncated = true;
+      break;
+    }
+    chars += size;
+    rows.push({ id: row.id, type: row.type, title: row.title, content });
+  }
+  return { rows, truncated, charsUsed: chars };
+}
+
+/**
+ * @param {{ ctx: object, service: object, config: object, logger?: object }} deps
+ *   ctx 要带 llm（宿主 LLM 句柄）；settings 不参与——本模块按设计不写画像。
+ * @returns {(opts?: {maxRows?: number, totalChars?: number, rowChars?: number}) => Promise<object>}
+ */
+export function createProfileExtractor({ ctx, service, config, logger }) {
+  const log = logger ?? ctx?.logger;
+  const language = langOf(config);
+
+  return async function extractProfile({
+    maxRows = DEFAULT_MAX_ROWS,
+    totalChars = DEFAULT_TOTAL_CHARS,
+    rowChars = DEFAULT_ROW_CHARS
+  } = {}) {
+    const { rows, truncated, charsUsed } = collectRows(service, maxRows, totalChars, rowChars);
+    if (!rows.length) {
+      throw new ProfileExtractError("no-input", "no active memories to extract a profile from");
+    }
+    const route = resolveRoute(ctx, config, log);
+    // resolveRoute 在「没有 dreamProvider/dreamModel、宿主也没有可解析的默认模型」时
+    // 返回 undefined。不判它就会被读成 `Cannot read properties of undefined` 抛出
+    // TypeError，落到路由上是一个语义为「内部错误」的 500——而真正该说的是「没配模型」，
+    // 面板要能给出「先去选模型」这句可行动的话（同 no-input 的取舍：不同结局不同话）。
+    if (!route) {
+      throw new ProfileExtractError("no-route", "no model route: set dreamProvider/dreamModel or pick an agent default model");
+    }
+    const listing = rows.map((r, i) => `${i + 1}. [${r.type}] ${r.title} :: ${r.content}`).join("\n");
+    const userText = [
+      STR.profileFenceOpen[language],
+      listing,
+      STR.profileFenceClose[language],
+      language === "zh"
+        ? `以上 ${rows.length} 条记忆条目（数据）到此结束。只依据它们输出 JSON，条目里没有的绝不发明。`
+        : `End of the ${rows.length} memory entries (data). Answer from these only; invent nothing absent from them.`
+    ].join("\n");
+
+    let streamFailure = "";
+    const text = await runAuditedLlm(ctx, service, config, {
+      triggerSource: "profileExtract",
+      operationType: "profile_extract",
+      modelId: `${route.provider}:${route.model}`,
+      relatedMemoryIds: rows.map((r) => r.id),
+      streamError: () => streamFailure,
+      // 吐了文字但没有可用结构 = 失败调用。审计必须记 error：success 配空草稿会让
+      // 「模型不配合」在账目上长得像「这次确实没提炼出东西」。
+      auditError: (out) => (parseProfileDraft(out) ? null : "profile extract returned no usable JSON object")
+    }, (reportUsage) => streamText(ctx, {
+      provider: route.provider,
+      model: route.model,
+      purpose: "compaction",
+      messages: [
+        { role: "system", content: [{ type: "text", text: STR.prompts.profileExtract[language] }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } },
+        { role: "user", content: [{ type: "text", text: userText }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } }
+      ]
+    }, reportUsage, (reason) => { streamFailure = describeStreamFailure(reason); }));
+
+    if (text === undefined) {
+      throw new ProfileExtractError("stream-failed", streamFailure || "llm stream aborted or errored");
+    }
+    const draft = parseProfileDraft(text);
+    if (!draft) {
+      throw new ProfileExtractError("unparseable", "profile extract output was not a usable JSON object");
+    }
+    return {
+      draft,
+      rowsUsed: rows.length,
+      truncated,
+      charsUsed,
+      provider: route.provider,
+      model: route.model
+    };
+  };
+}

package/src/provenance-http.js

@@ -0,0 +1,126 @@
+// 记忆级溯源读出口的 HTTP 口径 —— 唯一实现。
+//
+// 为什么要单独一个模块：这张脸有两个入口——宿主内的面板路由（src/api.js 的
+// /api/dsh-mneme/memory/provenance）与 Bearer 数据面（src/api-standalone.js 的
+// /memory/provenance）。两者底下是同一份 service（provenanceFor + distillRecordsFor），
+// 差别只在鉴权与路径。历史上（#509 第一版）它们是整段复制的，于是「改一边忘一边」
+// 在结构上就可能发生——#411 已经为 reclaim / share 各踩过一次，本模块照那次的结论办。
+//
+// 口径（错误码、两种「空」的区分、窗口形状）现在只写在这里，两个入口都调它。
+// 真要再写第二份，test/provenance-http.test.js 的静态锁会直接转红。
+//
+// 这里只做协议层的事：解析 id、判开关、组装窗口、区分「用户关了」「没接线」与
+// 「没有来源」。一行数据都不改——读取在 src/store.js，透传在 src/service.js。
+//
+// 状态码阶梯（自前而后，先匹配的先回）：
+//   401 未鉴权      ——两个壳各自的门（api.js 的 register 包装 / standalone 的
+//                     isAuthorized），在本模块之前，不在这里重复。
+//   400 缺 id       ——语法畸形，与服务端状态无关，所以排在功能开关之前；与
+//                     reclaim 的 invalid-json 同档（reclaim-http.js:30-33 立的是
+//                     「503 要赢过**字段校验**的 400」，缺 id 不是字段校验而是请求
+//                     本身不成立，所以不适用那条）。判断在壳里
+//                     （parseProvenanceQuery），走到本模块时 id 一定非空。
+//                     ⚠ 将来要加**语义类** 400（如 limit 越界、id 格式不合法），
+//                     必须挪到接线检查之后——那条 reclaim 口径正是为它立的。
+//   409 功能关了    ——distillRecords.enabled !== true。回的是「端点的属性」，
+//                     与 src/api.js:525 的 profileExtractEnabled 同构：用户关了
+//                     某功能 = 409，装配坏了 = 503，两者必须是可区分的答案
+//                     （src/index.js:589-591 的设计原话）。
+//   503 装配没接线  ——service 上没有 provenanceFor / distillRecordsFor。
+//   读（200 / 500）
+// 刻意不用 404：本端点永远不就「这条记忆是否存在」作断言（缺 id 是 400、未知 id
+// 是 200 + 空 windows），404 在本仓另有稳定含义——未知路由与资源不存在
+// （src/api-standalone.js:506/515、src/api.js:1367/1445）。把「功能关了」塞进
+// 404，调用方会在状态码这个唯一被代理 / 监控 / 重试逻辑读取的通道上，把它读成
+// 「这条记忆不存在」。
+
+/**
+ * 「溯源能力没接线」的错误码。headless / 旧装配下 service 上没有 provenanceFor 或
+ * distillRecordsFor，那是装配坏了，不是「这条记忆没有来源」——两种空必须分开读数，
+ * 否则调用方看到一个空 windows 会以为拿到了答案。
+ */
+export const PROVENANCE_UNAVAILABLE = "provenance-unavailable";
+
+/**
+ * 「用户把蒸馏原文留存关掉了」的错误码。distillRecords.enabled 既是写侧的总闸
+ * （src/summarize.js:988）也是本读出口的总闸（#509 评审整改）：关着时盘上可能
+ * 还有历史原文（保留期裁剪与写入同在 src/index.js:270 一道门里），但本端点不再
+ * 把它们读出去。与 api.js:525 的 "disabled" 分开：那个面只有一个功能开关，本仓
+ * 数据面上会有多个，特定码才让调用方分得清是哪一个被关。
+ */
+export const DISTILL_RECORDS_DISABLED = "distill-records-disabled";
+
+/**
+ * 读侧唯一的开关判据，**与写侧 src/summarize.js:988 逐字同源**。
+ *
+ * 为什么不放在两个壳里各算一次：那句话已经是本仓第 3、第 4 份拷贝了
+ * （summarize.js:988、index.js:270），而 #411 的结论就是「两张皮整段复制必然
+ * 漂移」——读写两道门一旦漂移，就会出现「以为关了却还能读出去」或「开着却读不到」
+ * 这两种都更难排查的状态。壳只转发 config，判据只在这里出现一次。
+ *
+ * fail-closed：config 缺失（null / undefined）、distillRecords 组缺失、值不是
+ * 严格的 true（"true" 字符串 / 1 / undefined）一律算关。这个端点返回的是蒸馏
+ * 窗口的逐字会话原文，判不出来时必须往「不读」那一侧倒。
+ *
+ * @param {object|null|undefined} config 启动期冻结的装配后 cfg（宿主 index.js:597
+ *   的 createApi 第 8 参 / index.js:621 的 createStandaloneApi config / daemon
+ *   serve.js 的最小 cfg）。
+ * @returns {boolean}
+ */
+export function isDistillRecordsEnabled(config) {
+  return config?.distillRecords?.enabled === true;
+}
+
+/** 溯源读取失败的 warn 文案。两个入口共用，日志里不会出现两种拼法。 */
+export function provenanceWarnMessage(error) {
+  return `[dsh-mneme] memory provenance read failed: ${String(error)}`;
+}
+
+/**
+ * 解析 ?id。空 / 缺失 → 400；其余原样交给 service（id 不存在时返回空 windows，
+ * 那是有效答案，不是错误——读端点不替调用方判断记忆是否存在）。
+ *
+ * @returns {{ok: true, id: string} | {ok: false, status: 400, error: string}}
+ */
+export function parseProvenanceQuery(raw) {
+  const id = typeof raw === "string" ? raw.trim() : "";
+  if (!id) return { ok: false, status: 400, error: "missing-id" };
+  return { ok: true, id };
+}
+
+/**
+ * 组装答复：一个链接一个窗口（区间 + 区间内原文行，按 seq 升序）。
+ *
+ * 顺序敏感（阶梯全貌见文件头）：409 功能关了 → 503 装配没接线 → 读。
+ * 503 要赢过空结果——装配没接线时报「这条记忆没有来源」是误导，与 reclaimReply 的
+ * maintenance-unavailable 同构；而 409 要赢过 503——「用户关了」比「装配坏了」更
+ * 具体，把前者报成后者会让人去查一个没坏的部署。
+ *
+ * @param {{service: object, id: string, config?: object|null, warn?: Function}} args
+ *   config 缺省即关（fail-closed），见 isDistillRecordsEnabled。
+ * @returns {{status: number, body: object}}
+ */
+export function provenanceReply({ service, id, config = null, warn = null }) {
+  if (!isDistillRecordsEnabled(config)) {
+    return { status: 409, body: { error: DISTILL_RECORDS_DISABLED } };
+  }
+  if (typeof service?.provenanceFor !== "function" || typeof service?.distillRecordsFor !== "function") {
+    return { status: 503, body: { error: PROVENANCE_UNAVAILABLE } };
+  }
+  try {
+    const links = service.provenanceFor(id);
+    const windows = links.map((link) => ({
+      session_id: link.session_id,
+      seq_start: link.seq_start,
+      seq_end: link.seq_end,
+      created_at: link.created_at,
+      // 到期裁剪后区间可能变空：链接刻意保留并指向空区间（clearDistillRecords 的
+      // 语义），面板据此显示「原文已过期」而非「没有来源」。
+      records: service.distillRecordsFor(link.session_id, link.seq_start, link.seq_end)
+    }));
+    return { status: 200, body: { memoryId: id, windows } };
+  } catch (error) {
+    warn?.(provenanceWarnMessage(error));
+    return { status: 500, body: { error: "internal" } };
+  }
+}

package/src/serve.js

@@ -61,6 +61,19 @@ export async function createServeRuntime({
   // documentMemoryEnabled 关掉 document 子系统(daemon 不建 documentIndex,service
   // 内部 if-guard 安全,index.js:261 的 documentIndex 仅宿主装配)。
   const cfg = { language: "zh", documentMemoryEnabled: false };
+  // #509 评审整改补的一格:GET /memory/provenance 的读门读 cfg.distillRecords.enabled
+  // (判据在 src/provenance-http.js,与写侧 src/summarize.js:988 同源)。daemon 与宿主
+  // 共用同一个 memory.db、同一份 feature_flags kv,所以这里把用户显式开关展开进 cfg
+  // ——index.js:217-233 同款展开,只取蒸馏这一组(daemon 其余键仍刻意不吃宿主 config
+  // schema)。不展开的后果:daemon 对这一面恒定回「功能关了」,哪怕用户在面板里开着、
+  // 库里明明有原文——对这个端点那是一句谎话,而「两种空必须分开读数」正是本仓纪律。
+  // 残留不对称(写进 docs/DAEMON.md 与 PR):只靠 bundle 配置打开、从没在面板点过的
+  // 用户,宿主认、daemon 不认——daemon 结构上看不到宿主的 bundle config,这是它看不见
+  // 的那一半,不是本处能补的。
+  const persistedFlags = settings.getFeatureFlags?.() ?? {};
+  if (typeof persistedFlags["distillRecords.enabled"] === "boolean") {
+    cfg.distillRecords = { ...(cfg.distillRecords ?? {}), enabled: persistedFlags["distillRecords.enabled"] };
+  }
   const mirror = createMirror(dir, langOf(cfg));
   const service = createService({ store, mirror, config: cfg, logger });
 

package/src/service.js

@@ -7,9 +7,13 @@ import { STR, langOf } from "./lang.js";
 import { computeHeat } from "./heat.js";
 import { recallStats } from "./recall-stats.js";
 import { evaluateMemoryQuality } from "./quality-filter.js";
+// 外来行（source='imported'，导入路径落的来源）的身份判定只许有一个定义处——本文件的
+// 两处汇流口与巩固/降级那些读侧行池都调这同一个谓词，避免各处自己写字符串比较然后各自漂移。
+import { isImportedRow } from "./memory-source.js";
 import { applyDecisions } from "./dream/decisions.js";
 import { createDocumentRegistrar } from "./document.js";
 import { createOrganizer } from "./organize.js";
+import { createShareImport } from "./share-import.js";
 import { createBM25Index } from "./search/bm25.js";
 import { adaptiveThreshold } from "./search/adaptive.js";
 import { anchorSeeds, normalizePath, cascadeDepths, HOP_QUOTA } from "./graph/anchoring.js";
@@ -1368,7 +1372,31 @@ export function createService({ store, mirror, config, onWrite, logger, document
     // dream 总览按 source 身份去重，而非本地化标题：memory.language 切换后
     // 标题变化，若仍按 (type, title) 匹配会出现两个活跃的 summary 同时注入。
     // 其余类型维持 (type, title) 匹配不变。
-    const candidates = store.list({ type: memory.type, limit: 100 });
+    //
+    // Issue #505：候选集此前是 store.list({ type, limit: 100 }) —— 那是「该类型
+    // 最重要的 100 行」（order 默认 importance），与「找出同标题的那一行」无关。
+    // 某类型里 importance 高于待写行的行数一旦超过 100，同标题行与待写行双双落在
+    // 窗口外，下面的 find 恒不命中，于是静默走创建分支：不报错、不告警，合并语义
+    // 随库增长而失效（实测 1047 行类型、importance=5 有 180 行时稳定复现）。
+    // 改为按同标题定向取（store.activeByTypeAndTitle，无窗口）。
+    //
+    // spec §5 决策 2：本机巩固不许改写别人的原文。这里不是防呆——蒸馏路径的每一次
+    // 同题命中都会 appendContent 覆盖外来行的正文与 updated_at，别人的记忆从此变成
+    // 我们两家的混杂物。把外来行剔出候选集后只会落回既有的「新建一行」分支。
+    // 谓词挂在**两个**候选集上：sourceScopedCandidates 在 dream/narrative 那两条分支
+    // 里就是候选集本身，只挂 candidates 等于给外来行留一条后门。这一处过滤留在 JS 侧
+    // 而不是下推 SQL（同 #515 的反面）：那里下推是因为外来行会吃掉 LIMIT 窗口名额，
+    // 这里 limit: null 本就无界，没有窗口可饿，而下推会多出第二份外来行判据。
+    const candidates = store.activeByTypeAndTitle(memory.type, memory.title).filter((m) => !isImportedRow(m));
+    // dream/narrative 两条分支按 source（及 tags[0]）匹配，而不是按标题：它们的
+    // 去重键本来就不含标题（语言切换后标题会变）。定向取同标题会把这两条路径
+    // 打回「永远不命中」——所以这两类仍走「该类型活跃行」的候选集，只是窗口换成
+    // 了无界且不带 importance 排序。类型内行数由 summary 的生产方（autoDream /
+    // generateNarratives）决定，量级远小于普通记忆，且这两条分支本来就要求扫全
+    // 类型才能找到同 source 的那一行——原来的 100 行窗口对它们同样是错的。
+    const sourceScopedCandidates = (memory.type === "summary" && (memory.source === "dream" || memory.source === "narrative"))
+      ? store.list({ type: memory.type, limit: null }).filter((m) => !isImportedRow(m))
+      : candidates;
     // v0.8.0 A1（issue #17）：去重键由 (type, title) 扩展为
     // (type, title, agent_scope, workspace_scope, sensitivity)——不同作用域的同
     // 标题记忆绝不互相物理合并（旧逻辑跨 agent/workspace 并行，事后无法拆分）。
@@ -1386,17 +1414,20 @@ export function createService({ store, mirror, config, onWrite, logger, document
     // 下面这段并入逻辑（appendContent + content_history + 质量处置），不另写第二份
     // 实现。目标已被并发删除时回落到常规匹配。显式目标同样过 scope 门：跨作用域
     // 的语义相似不并入（防泄漏），回落为独立新行。
-    const explicitTarget = memory._mergeInto ? store.getById(memory._mergeInto) : undefined;
+    // 显式目标还过外来门（spec §5 决策 2）：调用方指到别人导入的原文时，这个目标
+    // 按「未命中」处理，同样落回新建一行——两条路都只有 merged/created 两种结局。
+    const explicitCandidate = memory._mergeInto ? store.getById(memory._mergeInto) : undefined;
+    const explicitTarget = explicitCandidate && !isImportedRow(explicitCandidate) ? explicitCandidate : undefined;
     const existing = explicitTarget
       ? (scopeMatches(explicitTarget) ? explicitTarget : undefined)
       : (memory.type === "summary" && memory.source === "dream")
-        ? (candidates.find((m) => m.source === "dream" && scopeMatches(m))
+        ? (sourceScopedCandidates.find((m) => m.source === "dream" && scopeMatches(m))
           ?? candidates.find((m) => scopeMatches(m) && m.title.trim() === String(memory.title).trim()))
         : (memory.type === "summary" && memory.source === "narrative")
           // 叙述条（#164）按主题键去重而非本地化标题：标题随语言变
           // （叙述：X / Narrative: X），title 匹配在语言切换后会残留同 tag 双行。
           // tag 存于 tags[0]（generateNarratives 落库），跨语言稳定 → 原地刷新。
-          ? (candidates.find((m) => m.source === "narrative" && m.tags?.[0] === memory.tags?.[0] && scopeMatches(m))
+          ? (sourceScopedCandidates.find((m) => m.source === "narrative" && m.tags?.[0] === memory.tags?.[0] && scopeMatches(m))
             ?? candidates.find((m) => scopeMatches(m) && m.title.trim() === String(memory.title).trim()))
         : candidates.find((m) => scopeMatches(m) && m.title.trim() === String(memory.title).trim());
     if (existing) {
@@ -2564,18 +2595,34 @@ export function createService({ store, mirror, config, onWrite, logger, document
     }
   });
 
+  // 车道 C 收侧的入库与整包退出（spec §5）：内聚块在 src/share-import.js，这里只做依赖
+  // 注入 + barrel 出口。注入的是本文件的 transaction 而不是 store.runAtomically——嵌入
+  // 队列由 transaction 的最外层 COMMIT 排空，换那个助手等于静默不嵌入（#372 修过两次）；
+  // 退出那侧用它则是为了 finally 里的 syncMirror + notifyWrite（删完得让其余读侧知道）。
+  const shareImport = createShareImport({ store, transaction, scheduleEmbed });
+
   return {
     saveWithDedupe,
     registerDocument,
     // agent 主动整理接口（#231）：内聚块在 src/organize.js，这里只做依赖注入 +
-    // barrel 出口。刻意不加 opt-in 开关（维护者口径：功能本体不做开关，与 #249
-    // 同批暴露时再定配置面），也不进工具列表——工具注册在 #249 那批。
+    // barrel 出口。本体不带配置键（第一批口径），暴露闸住在工具层（#231 第二批的
+    // `organizeEnabled` → `tools.js` 的 `memory_organize`）：service 侧不认识开关，
+    // 所以直连 service 的调用方（测试、内部管线）不受面板那格影响。
     organize,
     recoverMirror,
     getMirrorHealth,
     getMirrorState: () => store.getMirrorState(),
     injectCandidates,
     mergeHumanEdits,
+    // 车道 C 收侧：两张皮（面板路由 / standalone 数据面）各自的壳只认这一份实现——
+    // createApi 手里没有 store，「api 层不直接摸 store」这条纪律（见下面 embeddedCount
+    // 那组 passthrough 的注释）要求导入从 service 进，否则两皮各摸一遍 store、幂等
+    // 口径随之变成两份。
+    importSharePack: shareImport.importSharePack,
+    // 整包退出（C4）与导入同住 src/share-import.js：收侧的「进与出」共用同一份 store
+    // 注入与同一个事务口径，键名照计划里的契约留在 service 的返回表上，两张皮（C5/C6）
+    // 只认 service 这一个入口——api 层不直接摸 store 那条纪律对退出同样成立。
+    deleteSharePack: shareImport.deleteSharePack,
     toApiList,
     isVisibleInScope,
     // issue #471 政策轴：按下/松开与读取照 store 那三条件透传（纯 bookkeeping，
@@ -2598,6 +2645,9 @@ export function createService({ store, mirror, config, onWrite, logger, document
     saveDistillRecords: (records) => store.saveDistillRecords(records),
     saveMemoryProvenance: (link) => store.saveMemoryProvenance(link),
     provenanceFor: (memoryId) => store.provenanceFor(memoryId),
+    // #421 读出口：按 (session, seq 区间) 取蒸馏原文。与 provenanceFor 成对——
+    // 一个给区间、一个给区间里的原文，合起来才是「这条记忆从哪几句蒸出来的」。
+    distillRecordsFor: (sessionId, seqStart, seqEnd) => store.distillRecordsFor(sessionId, seqStart, seqEnd),
     enqueue,
     setDreamHook(fn) { dreamHook = fn; },
     setSleepHook(fn) { sleepHook = fn; },
@@ -2669,6 +2719,20 @@ export function createService({ store, mirror, config, onWrite, logger, document
     // passthrough 形状与 embeddedCount 同款，api 层不直接摸 store。
     embeddingModelBreakdown: () => store.embeddingModelBreakdown(),
     embeddingDimensionBreakdown: () => store.embeddingDimensionBreakdown(),
+    // #383：维度探针，供 /context 判「库里有没有一条活跃向量与查询同维」。注意
+    // 它**不再是**「读一行的维度」（那个判据在混合维度库里两个方向都错，见 store.js
+    // vectorDimensionState 的注释）：换成存在性判据后成本是「一次全 id 扫描 + 按匹配
+    // 短路的解析」，同维度健康库只解析 1 个向量，只有要报 degraded 时才走完全表。
+    // 与上面那个全表扫的 breakdown 仍是两件事：一个是状态页的完整分布，一个是每请求
+    // 用得起的判据。透传而非让 api 层摸 store，与同组其他条目一致；api 侧负责把探针
+    // 异常隔离成 unknown，不在这里吞。
+    vectorDimensionState: (dimension) => store.vectorDimensionState(dimension),
+    // 整包透传：store.list 的每个口径（excludeTypes / excludeImported / includeArchived…）
+    // 都从这里过去，service 侧不再枚举一遍——枚举就是第二份口径表，加一个键就要改两处，
+    // 漏改的那处静默失效。政策轴一律走这里的查询参数，不许退回调用方的 .filter：
+    // LIMIT 先生效的话，被丢掉的行照样吃掉窗口名额。前例是同文件 syncMirror 的那条注释
+    // （src/service.js:2247，document 轴改由 excludeTypes 在 LIMIT 之前排除），
+    // 同一取舍的另两次是 #230 与 #471。
     list: (o) => store.list(o),
     all: () => store.all(),
     count: (type, opts) => store.count(type, opts),

package/src/settings.js

@@ -185,6 +185,10 @@ const FEATURE_FLAG_BOOLEANS = [
   // 在慢/轻量模型上是多余往返，面板可关（默认关=行为不变）。
   "disableMemorySearch",
   "disableMemoryArchive",
+  // Issue #231 第二批：agent 主动整理（memory_organize 工具）的暴露闸。与上面两个
+  // 反向——那两个藏默认在场的工具，本键开默认不在场的能力（默认关=工具根本不存在，
+  // 行为逐字节不变）。面板可启停=线上回滚开关。
+  "organizeEnabled",
   // 嵌套对象开关：config.js 里是 memoryQualityFilter / llmAudit 对象的 enabled
   // 子字段。kv 按点号键平铺存（"memoryQualityFilter.enabled": false），index.js
   // 合并时展开回嵌套对象，api.js 的 effective 从对象子字段取值。
@@ -229,7 +233,13 @@ const FEATURE_FLAG_BOOLEANS = [
   // LIGHT_MODE_OFF——人格段是用户自写的一小段轻量常驻文本，不引入任何重型后台
   // 路径，轻量档用户显式勾选仍然赢（同 actionPipelineEnabled 的定性）。顶层扁平
   // 键，不需要 NESTED_FLAG_PATHS 条目。
-  "personaEnabled"
+  "personaEnabled",
+  // 人格寻址口径（上一条打开时才有意义）：开 = 身份没建卡/卡被关时不注入人格，
+  // default 只兜解析不到身份的会话。默认关（历史行为，升级零变化）。
+  "personaStrictAddressing",
+  // Issue #497：画像提取草稿（POST /profile/extract）。默认关——每次调用一次 LLM 且
+  // 读上百行记忆；产物只回草稿，绝不写 user_settings。进 LIGHT_MODE_OFF（预设关）。
+  "profileExtractEnabled"
 ];
 // 整数开关的闭区间，与 config.js 里 z.natural().min().max() 对齐。
 const FEATURE_FLAG_INT_RANGES = {
@@ -247,6 +257,9 @@ const FEATURE_FLAG_INT_RANGES = {
   // Issue #239：蒸馏零 LLM 预判（窗口最小字符数）与每会话 run 预算（0 = 零行为变化）。
   summarizeMinWindowChars: [0, 100000],
   summarizeMaxRunsPerSession: [0, 1000],
+  // Issue #493：连续解析失败几次后放弃当前窗口（0 = 关）。与 config.js 的
+  // z.natural().min(0).max(10) 成对。
+  summarizeParseFailureMaxRetries: [0, 10],
   // Issue #239 第 4 项：高峰顺延上限（分钟，0 = 不设上限）。
   summarizePeakMaxDeferMinutes: [0, 1440],
   // Issue #239 第 4 项镜像到巩固：同一口径（分钟，0 = 不设上限）。
@@ -489,8 +502,9 @@ export function createSettings(db) {
     /**
      * Agent persona (name / personality / replyStyle + enabled gate), stored as
      * one JSON key. v1.2 多卡：存储形 { default, byAgent }，旧 v1 单对象读作
-     * default 兼容。getPersona 返回全量多卡形（面板用）；getPersonaFor 按 agent
-     * 身份取卡（注入用），身份缺失/无卡/卡 enabled=false 均落 default。
+     * default 兼容。getPersona 返回全量多卡形（面板与注入寻址都用它）。
+     * 寻址与兜底口径不在这里——住 src/user-settings.js 的 resolvePersonaCard，
+     * 注入与面板预览共用那一份；这里若再留一个 getPersonaFor，就是两张皮。
      */
     getPersona() {
       return parsePersonaStore(getSetting("persona") ?? "{}");
@@ -507,16 +521,6 @@ export function createSettings(db) {
       current.default = parsePersona(JSON.stringify(input));
       setSetting("persona", serializePersonaStore(current));
     },
-    /** Per-agent lookup for the injector: id card → default fallback. */
-    getPersonaFor(agentId) {
-      const store = parsePersonaStore(getSetting("persona") ?? "{}");
-      const id = typeof agentId === "string" && agentId.trim() ? agentId.trim() : "";
-      if (id) {
-        const card = store.byAgent[id];
-        if (card && card.enabled === true) return card;
-      }
-      return store.default;
-    },
     /** Replace one byAgent card wholesale (panel save); default 不可经此改。 */
     setPersonaFor(agentId, card) {
       const id = typeof agentId === "string" && agentId.trim() ? agentId.trim() : "";