@modusensus/dsh-mneme 0.9.3 → 0.9.5

package/src/api.js

@@ -1,6 +1,7 @@
 import { URL } from "node:url";
 import { isAbsolute } from "node:path";
 import { existsSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
 import { timingSafeEqual, randomBytes } from "node:crypto";
 import { FEATURE_FLAG_SPEC } from "./settings.js";
 import { TYPES } from "./store.js";
@@ -8,11 +9,17 @@ import { TYPE_FILE, renderMirrorText, renderFileHeader, parseHumanEdits, MIRROR_
 import { langOf } from "./lang.js";
 import { computeHeat } from "./heat.js";
 import { EFFORT_REJECT_RE, describeStreamFailure, resolveRoute, withEffortFallback } from "./dream.js";
+// Issue #521：面板要按归一化原因显示 skipped，归一化只有一份实现（住在
+// decisions.js，与产生这些 error 的校验器同一文件，避免措辞漂移）。
+import { summarizeSkipped } from "./dream/decisions.js";
 import { getInjectionSnapshot } from "./inject.js";
+import { renderUserSettingsBlock } from "./user-settings.js";
+import { parseProvenanceQuery, provenanceReply } from "./provenance-http.js";
 import { describeLocalRuntime, publicRuntimeStatus } from "./runtime/loader.js";
 import { hostModulesDir, provisionRuntime } from "./runtime/provision.js";
 import { classify, fetchLatestVersion, PACKAGE_VERSION } from "./version-check.js";
 import { parseReclaimQuery, parseReclaimJson, readReclaimFields, reclaimReply, RECLAIM_UNAVAILABLE } from "./reclaim-http.js";
+import { parseShareBody, shareReply, shareFilename, parseReceiveBody, receiveReply, parseUndoBody, undoReply } from "./share-http.js";
 import { readPipelineDoc, loadPipelines, projectPipelineDir } from "./pipeline.js";
 import { loadRunsById, runsDir, RUNS_SUFFIX } from "./pipeline-runs.js";
 import { observationDir, loadObservationsById } from "./pipeline-observations.js";
@@ -182,7 +189,7 @@ function parseBody(text) {
 // maintenance 是第 9 个位置参数，默认 null：既有调用点（测试里的 14 处）全是位置传参、
 // 不传它，必须继续工作——不传时 /maintenance/reclaim 回 503 maintenance-unavailable，
 // 而不是把「没接线」伪装成崩溃（#386 第 4 条）。
-export function createApi(ctx, service, settings, commands, embedder, semantic = null, apiToken = "", config = null, maintenance = null) {
+export function createApi(ctx, service, settings, commands, embedder, semantic = null, apiToken = "", config = null, maintenance = null, profileExtract = null) {
   const disposers = [];
 
   // #182 注入状态探测：面板状态页的「极简模式下注入按宿主设计关闭」提示需要
@@ -386,6 +393,15 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
           ...m,
           archived: rows[i].archived === true || rows[i].archived === 1,
           quality_score: rows[i].quality_score ?? null,
+          // 外来区的包号：抽屉里的「收起这个包」按 pack_id 整批删，寻址键必须由行自己带上。
+          // 与 heat 同一个做法——**缺省就不带键**，面板的撤销按钮因此天然自门控。
+          // /search 那一面为什么没有这一格，别说错原因：召回侧的候选行内存里带着
+          // share_pack_id（searchMemories 只是把 source 盖成渠道名），toApiList 也从不透出这一列；
+          // 真正的事实是这层扩展只长在 /list 的答复上，搜索面没有一处代码去补它。所以搜索态
+          // 按不了撤销，那条代价写在 docs/SHARE.md 的车道 D 一节。
+          // 扩展点留在 HTTP 层而不是 toApiList：模型工具严格复用后者（src/service.js:2094 与
+          // MEMORY_ITEM_SCHEMA），给它们加一格没有第二个消费者，却要多改一处 schema 声明。
+          ...(rows[i].share_pack_id ? { share_pack_id: rows[i].share_pack_id } : {}),
           ...(heatOn ? { heat: computeHeat(rows[i], Date.now(), config ?? {}) } : {})
         }));
         // Total honors the same filters as the rows, or the pager's
@@ -488,6 +504,49 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
     }
   });
 
+  // --- 画像提取（issue #497）：一次性从活跃记忆出「助手眼中的用户」**草稿** ------
+  // 语义上它是「读 + 一次模型调用」，不是写端点：草稿回给面板，采用与否是用户在那里
+  // 另一次显式 PUT /profile。所以这个路由永远不碰 user_settings——画像正文是用户
+  // 手写的原文，让模型合并等于给它改写权，而改写后的文本每帧都注入。
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/profile/extract",
+    // policy 是 `token` 而不是 `token-write`：这条路由**没有读分支**（非 POST 一律 405），
+    // 声明成 token-write 会让 SECURITY.md 的开放读清单按「GET 开放」把它算进去——
+    // 那张表是代码的投影，不是愿望清单（test/security-doc.test.js 就是钉这件事的）。
+    policy: "token",
+    handler(req, res) {
+      // 方法白名单在碰任何副作用之前：#489 的教训是「只拦 POST/PUT，其余直落
+      // run(null)」——那等于给带 token 的 PATCH/DELETE 开了一条静默花一次 LLM 的口子。
+      // 顺序也要紧：405 若挪到 readBody 之后，一个不带 body 的方法会把请求永远挂在
+      // 读体上（把这道判断改成只拦 GET 时实测卡住整条用例），等于一个免费的挂起面。
+      if (req.method !== "POST") {
+        res.writeHead(405, { Allow: "POST" });
+        res.end("");
+        return undefined;
+      }
+      if (config?.profileExtractEnabled !== true) return sendJson(res, 409, { error: "disabled" });
+      if (typeof profileExtract !== "function") return sendJson(res, 503, { error: "unavailable" });
+      return readBody(req, res).then((text) => {
+        if (text === null) return undefined; // 超限已在 readBody 里回过 413
+        return profileExtract().then(
+          (out) => sendJson(res, 200, out),
+          (error) => {
+            // 「没东西可提」与「模型没配合」必须能被调用方区分：把它们都压成 200 +
+            // 空草稿，面板就会把故障显示成「这次没提炼出东西」（#493 同一条教训）。
+            const code = typeof error?.code === "string" ? error.code : "";
+            if (code === "no-input") return sendJson(res, 409, { error: code });
+            // 没配模型是「环境缺东西」，与「模型不配合」两码：前者重跑也一样，后者可重试。
+            if (code === "no-route") return sendJson(res, 503, { error: code });
+            if (code === "unparseable" || code === "stream-failed") return sendJson(res, 502, { error: code });
+            ctx.logger?.warn?.(`dsh-mneme: profile extract failed: ${String(error?.message ?? error)}`);
+            return sendJson(res, 500, { error: "internal" });
+          }
+        );
+      });
+    }
+  });
+
   // --- agent persona（人格定义页，beta） -------------------------------------
   // 形状照抄 /profile 路由（设计稿②）：写方法走 requireAuth + readBody + parseBody。
   // v1.2 多卡：GET 回全量 { default, byAgent }；PUT 双形——单对象形（旧面板）只更新
@@ -519,7 +578,20 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
             sendJson(res, 200, { persona: settings.getPersona() });
           });
         }
-        sendJson(res, 200, { persona: settings.getPersona() });
+        const url = new URL(req.url, "http://localhost");
+        // 预览（面板「Agent 眼中的画像」用）：由注入器同一个渲染函数产出，前端只显示
+        // 返回的文本——以前端自己拼列表冒充「生效文本」是这个面板最容易漂的地方。
+        // ?agent=<身份> 让面板能逐张卡预览：传了就按那个身份寻址，没传按「解析不到身份」
+        // 走（也就是 default 卡的受众）。
+        // 这里不加鉴权是有意的：画像、规则、人格三处在同一条开放读面上本来就能各读一次
+        // （GET /profile 与 GET /persona 都无 token 可读），本字段只是把同样的内容拼成
+        // 模型实际看到的形状，没有新增可达面；真要锁，配 apiToken（写面与它同源）。
+        const preview = renderUserSettingsBlock({
+          settings,
+          config,
+          agentId: url.searchParams.get("agent")
+        });
+        sendJson(res, 200, { persona: settings.getPersona(), preview });
       } catch {
         sendJson(res, 500, { error: "internal" });
       }
@@ -1236,6 +1308,52 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
     }
   });
 
+  // --- 记忆级溯源读出口（#399 写、#421 读）-----------------------------------
+  // #399 把蒸馏窗口的原文落进 distill_records、把 memory → (session, seq 区间)
+  // 的归因写进 memory_provenance，但只做了写：库里有答案、service.provenanceFor
+  // 能查，外部（面板 / standalone API / 脚本）拿不到，「这条记忆是从哪几句蒸出来
+  // 的」只能开 sqlite 手写 JOIN。本端点补最后一段接线。
+  //
+  // 一个链接一个窗口：区间 + 区间里的原文行（按 seq 升序）。没有链接的记忆
+  // （memory_save / 工具写入 / 冷启动）返回空 windows——「不是蒸馏来的」本身是
+  // 有效答案，不是错误，所以不 404。
+  //
+  // policy 是 **token**，不是 open（#509 维护者评审定）：records 带的是蒸馏窗口的
+  // 逐条会话原文，而 /list 是 open 且逐条带 id——两者串起来等于「先枚举 id、再按 id
+  // 捞回原文」，可达结果与 /export（一次拿全库，本仓 2026-10 审计后列 gated）同量级，
+  // 只是换了形状。抽稀不该靠「调用方不知道有这条路」。
+  //
+  // 口径只在 src/provenance-http.js 写一份，两个入口都调它（#411 的教训：两张皮
+  // 整段复制必然漂移）。
+  //
+  // distillRecords.enabled 门（#509 评审整改）：这个读出口吃的是**写侧同一枚开关、
+  // 同一个判据**（isDistillRecordsEnabled，与 src/summarize.js:988 逐字同源；本文件
+  // 不重写那个表达式，静态锁盯着）。关着时回 409，错误码取共用模块导出的
+  // DISTILL_RECORDS_DISABLED——「用户关了」而不是「装配坏了」（后者是 503，
+  // src/index.js:589-591 立的可区分性原则），也不是 404（本端点刻意不就「这条记忆
+  // 是否存在」作断言）。cfg 是启动期冻结值，所以面板改开关要到下次重启才对这里生效；
+  // 该键在 settings 白名单与 NESTED_FLAG_PATHS 里都登记着，面板会显示「待重启」
+  // （#481 的教训）。阶梯全貌见 provenance-http.js 文件头。
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/memory/provenance",
+    policy: "token",
+    handler(req, res) {
+      try {
+        const url = new URL(req.url, "http://localhost");
+        const parsed = parseProvenanceQuery(url.searchParams.get("id"));
+        if (!parsed.ok) {
+          sendJson(res, parsed.status, { error: parsed.error });
+          return;
+        }
+        const { status, body } = provenanceReply({ service, id: parsed.id, config, warn: (m) => ctx.logger?.warn?.(m) });
+        sendJson(res, status, body);
+      } catch {
+        sendJson(res, 500, { error: "internal" });
+      }
+    }
+  });
+
   // --- ego graph: 1-2 hop neighborhood of one entity (graph panel P1) ---
   // Read-only like list/search/semantic, so it stays open when apiToken is set.
   // BFS from the root entity over entity_relations (both directions; the
@@ -1461,6 +1579,133 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
     }
   });
 
+  // --- 分享包（spec §4）------------------------------------------------------
+  // 读侧全库口径，鉴权与 /export 同门（token）：它导出的是**脱敏后**的行集，但
+  // 「谁在往外打整库」这件事本身就需要跟写路由一样登记在册。
+  // GET 不开口子：这条路由的存在感来自「有人主动按分享键」，不是给面板轮询用的。
+  // 判据一条都不在这里：哪些行进包、超没超限、抛错回什么码，全在 share-http.js 那份
+  // 共用实现里（#411 的口径——两张皮只许剩鉴权与路径不同）。本侧独有的只有两件事：
+  // Content-Disposition（sendJson 的 headers 第四参，数据面没有这个签名）和把
+  // shareReply 的 warn 接到宿主 logger 上——它兜住抛错回 500，不接日志就是静默失败。
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/share",
+    policy: "token",
+    handler(req, res) {
+      try {
+        if (req.method !== "POST") {
+          sendJson(res, 405, { error: "method-not-allowed" });
+          return;
+        }
+        return readBody(req, res).then((text) => {
+          if (text === null) return; // readBody 已经答过 413，再写一次就是双写响应
+          const parsed = parseShareBody(text);
+          if (!parsed.ok) {
+            sendJson(res, 400, { error: parsed.error });
+            return;
+          }
+          const out = shareReply({
+            service,
+            packageVersion: PACKAGE_VERSION,
+            homeDir: homedir(),
+            options: parsed.options,
+            warn: (msg) => ctx.logger?.warn?.(msg)
+          });
+          if (out.status === 200) {
+            sendJson(res, 200, out.body, {
+              "Content-Disposition": `attachment; filename="${shareFilename(out.body.pack_id)}"`
+            });
+            return;
+          }
+          sendJson(res, out.status, out.body);
+        }).catch(() => sendJson(res, 500, { error: "internal" }));
+        // .catch 与下面的外层 try 各挡一类：外层那个只包得住同步那半，而 readBody 的回调
+        // 抛出时它早已退栈。共用层从不抛（连 warn 自己坏都被守卫吞掉），所以这条链现在能被
+        // 走到的只剩**面自己**写答复那一步——sendJson 的 writeHead 在真 socket 上会因
+        // 「一个响应两写」抛 ERR_HTTP_HEADERS_SENT。少这一声就是 unhandled rejection +
+        // 一个字节都没回（#410），而下面 /receive 两条一直带着它。
+      } catch {
+        sendJson(res, 500, { error: "internal" });
+      }
+    }
+  });
+
+  // --- 分享包入库与整包退出（车道 C，spec §5）--------------------------------
+  // 写库的一面（token-write：非 GET 要 Bearer）。判据一条都不在这里：包体合格不合格住在
+  // share.js 的闸门（由 service 的 importSharePack 调），错误码 → 状态的映射住在
+  // share-http.js 那份共用实现里——#411 的口径是两张皮只许剩鉴权与路径不同。本侧独有的
+  // 只有把 warn 接到宿主 logger 上（不接就是一条静默的 500，现场只剩 internal）。
+  //
+  // 非 POST 一律 405。这**故意**与上面的 /maintenance/reclaim 不同（那边掉到末尾 404）：
+  // 每条 receive 都有一个数据面双胞胎（C6 的 POST /receive、/receive/undo），那里只认
+  // 405，状态码差一次就是第三处差别——一致性在这里比「照抄本文件的邻居」更硬。
+  //
+  // 外层 try 与 .catch 都要留着：外层那个在 .then 的回调里已经退栈，回调里抛出去就是没人接
+  // 的 rejection，客户端拿到的不是 500 而是「一个字节都没回」（#410）。
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/receive",
+    policy: "token-write",
+    handler(req, res) {
+      try {
+        if (req.method !== "POST") {
+          sendJson(res, 405, { error: "method-not-allowed" });
+          return;
+        }
+        return readBody(req, res).then((text) => {
+          if (text === null) return; // readBody 已经答过 413，再写一次就是双写响应
+          const parsed = parseReceiveBody(text);
+          if (!parsed.ok) {
+            sendJson(res, 400, { error: parsed.error });
+            return;
+          }
+          const out = receiveReply({
+            service,
+            pack: parsed.pack,
+            dryRun: parsed.dryRun,
+            warn: (msg) => ctx.logger?.warn?.(msg)
+          });
+          sendJson(res, out.status, out.body);
+        }).catch(() => sendJson(res, 500, { error: "internal" }));
+      } catch {
+        sendJson(res, 500, { error: "internal" });
+      }
+    }
+  });
+
+  // 退出按 pack_id 收起一整包（物删不归档，理由见 src/share-import.js）。dry-run 同样是
+  // 缺省：没带 confirm 就只报「会删掉几条」，与 reclaim、与入库那侧同一个脾气。
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/receive/undo",
+    policy: "token-write",
+    handler(req, res) {
+      try {
+        if (req.method !== "POST") {
+          sendJson(res, 405, { error: "method-not-allowed" });
+          return;
+        }
+        return readBody(req, res).then((text) => {
+          if (text === null) return;
+          const parsed = parseUndoBody(text);
+          if (!parsed.ok) {
+            sendJson(res, 400, { error: parsed.error });
+            return;
+          }
+          const out = undoReply({
+            service,
+            packId: parsed.packId,
+            dryRun: parsed.dryRun,
+            warn: (msg) => ctx.logger?.warn?.(msg)
+          });
+          sendJson(res, out.status, out.body);
+        }).catch(() => sendJson(res, 500, { error: "internal" }));
+      } catch {
+        sendJson(res, 500, { error: "internal" });
+      }
+    }
+  });
+
   // --- 导入（Markdown 镜像回填）----------------------------------------------
   // 写路径（requireAuth）。body {type, markdown}：type 是镜像 TYPE_FILE 键，
   // markdown 是与镜像文件同构的文本。解析复用 readHumanEdits 的纯函数核心 parseHumanEdits（同一实现，
@@ -1525,7 +1770,13 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
           // 数据来自 runSleep 写入的 decisions.demotion（{demoted,archived} 数组）。
           demotion: r.decisions?.demotion
             ? { demoted: (r.decisions.demotion.demoted ?? []).length, archived: (r.decisions.demotion.archived ?? []).length }
-            : null
+            : null,
+          // Issue #521：degraded 轮的 skipped 明细按归一化原因聚合。status:
+          // degraded + applied: 3 从外面看完全是健康轮的样子，不展开 skipped
+          // 看不出「一整个 action 类型 100% 失败」——实测那个 bug 跑了一整天才
+          // 被发现。这里只回聚合（原因 + 动作 + 条数），明细仍留在库里。
+          skippedCount: Array.isArray(r.skipped) ? r.skipped.length : 0,
+          skippedReasons: summarizeSkipped(r.skipped)
         }));
         const pendingConflicts = service.countConflictPending?.() ?? 0;
         const ids = new Set();

package/src/config.js

@@ -35,6 +35,14 @@ export const Config = z.object({
   // 额度浪费在零成本窗口上。计数是进程内 per-session（与最小间隔闸门同生命
   // 周期），宿主重启即清零，与 #229 的游标持久化是两件事。
   summarizeMaxRunsPerSession: z.natural().min(0).max(1000).default(0),
+  // Issue #493：连续解析失败几次后放弃当前窗口（0 = 关闭，行为与历史版本逐字节
+  // 一致）。失败默认不推进游标——语义是「这段还没提炼完，下次接着来」，这对
+  // 偶发失败（429/5xx/超时）是对的。但确定性失败（模型把转录当成该自己回话，
+  // finish_reason=stop，同文同温）重试收益为 0，而窗口只会随新事件继续变大，
+  // 于是一条会话能被同一窗口卡死几十轮、每轮都白烧一次完整调用。设成 2-3 即
+  // 可止血：达到阈值后强制消费游标跳过该窗口，并留一行带 streak/raw_head 的
+  // error 审计。默认关是因为放弃内容本身有代价——短窗口偶尔失败仍值得重试。
+  summarizeParseFailureMaxRetries: z.natural().min(0).max(10).default(0),
   // Issue #239（第 4 项，错峰队列）：高峰期蒸馏顺延。空串 = 关闭，行为与现状逐
   // 字节一致。取值是本地时间的时段列表（逗号分隔，支持跨零点），可带**星期前缀**
   // （可省；ISO 1=周一…7=周日，也认 mon..sun；省略 = 每天）：
@@ -841,6 +849,19 @@ export const Config = z.object({
   disableMemorySearch: z.boolean().default(false),
   disableMemoryArchive: z.boolean().default(false),
 
+  // Issue #231 第二批：agent 主动整理接口（src/organize.js）的**暴露**闸。引擎在
+  // PR #267 就造好了，当时刻意不进工具列表、不加开关（模块头注释：「与 #249 同批
+  // 暴露时只差『注册工具 + 注入指引』一步」），配置面留到这一批再定——就是这里。
+  // 与上面两个 disable* 是**反向**语义：那两个把默认在场的工具藏起来，本键把默认
+  // 不在场的能力开出来。因为 dryRun→apply 是一套两步协议（apply 必须引用真实报告
+  // 的 run_id），让 agent 未经用户同意就能整理记忆，不是「少一次往返」的成本问题，
+  // 而是「谁在改库」的授权问题。
+  // 进 LIGHT_MODE_OFF：两步协议在弱模型上最容易走歪（漏 run_id、或跳过报告直接
+  // apply——那一拒绝就是一次失败的工具调用），而一次 dryRun 的代价是一回嵌入调用
+  // 加按 type 有界扫库。这是预设给的默认值、不是强制：用户显式勾选仍然赢（合并顺序
+  // 「用户开关 > 轻量预设 > bundle」，同 continuityRescueEnabled / distillRecords.enabled）。
+  organizeEnabled: z.boolean().default(false),
+
   // --- scope: v0.8.0 A1 存储层（issue #17）--------------------------------
   // 总开关默认关：关闭时写入不标注 scope、去重维持 (type, title) 现状，行为
   // 逐字节不变。开启后**两条写入路径都自动盖章**（*_scope_source='auto'）：
@@ -925,7 +946,27 @@ export const Config = z.object({
   // 人格段是用户自写的一小段轻量常驻文本，不引入任何重型后台路径，轻量档用户
   // 显式勾选仍然赢（同 actionPipelineEnabled 的定性）。
   // 也走 feature_flags（FEATURE_FLAG_BOOLEANS 白名单），面板可启停=线上回滚开关。
-  personaEnabled: z.boolean().default(false)
+  personaEnabled: z.boolean().default(false),
+
+  // 人格寻址的兜底口径（只在上一个键打开时才有意义）。关（默认，= 历史行为）：
+  // 会话身份没有卡、或有卡但卡被关掉时，一律落 default 卡——于是 default 成了
+  // 「所有没建卡的 agent 都能拿到某个人格」，宿主里跑的外部 bot（自带身份与设定）
+  // 会在同一帧里收到两句「你是谁」。开：这两种情况都不注入人格，default 退回它的
+  // 本意——只兜「这一帧解析不到会话身份」的无名会话（无身份时行为不变）。
+  // 默认关是因为这是一次口径变更：老用户升级后注入文本不许静默变化。
+  // 不进 LIGHT_MODE_OFF：它只是取卡时的一个分支，不引入常驻文本、也不引入后台路径，
+  // 且它本身只在 personaEnabled 打开时才起作用（同 scopeState 的定性）。
+  personaStrictAddressing: z.boolean().default(false),
+
+  // Issue #497：从活跃记忆反向提取「助手眼中的用户」画像**草稿**（POST
+  // /api/dsh-mneme/profile/extract）。默认关有三层理由：① 它每次点一次就是一次 LLM
+  // 调用并读上百行记忆，成本与 dream/summarize 同级，不该在没人要求时挂在面上；
+  // ② 产物会被用户当成「关于我的第一版画像」读，编造的代价不对称——所以空库直接报错、
+  // 解析失败也报错，绝不回空草稿；③ 它**不写** user_settings，采用草稿是面板里另一次
+  // 显式保存，画像正文必须是用户手写的原文，不给模型改写权。
+  // 进 LIGHT_MODE_OFF：一次调用要读上百行记忆 + 一轮模型生成，与低资源档互斥（同
+  // preInjectGate.enabled 的定性）；是预设不是强制，用户显式勾选仍然赢。
+  profileExtractEnabled: z.boolean().default(false)
 });
 
 // Fields forced to false by the light-mode preset. Everything not listed here
@@ -958,6 +999,10 @@ const LIGHT_MODE_OFF = [
   "dreamNarrativeEnabled",
   // 轻量模式不开 document 指针行（#230，opt-in：注册/注入/检索增强全随闸）。
   "documentMemoryEnabled",
+  // #231 第二批：轻量档不开 agent 主动整理。理由不是成本而是协议——dryRun→apply
+  // 要求 agent 拿住上一轮的 run_id 再回来，弱模型漏这一环就是一次被拒的调用；
+  // 预设关、不剥夺显式开启的权利（合并顺序同 continuityRescueEnabled）。
+  "organizeEnabled",
   // 轻量模式不开热计算（heat 属于重型增强；关掉后 sleep 降级也退回纯时间分层）。
   "heatEnabled",
   // 轻量模式不开注入前判定（#380：LLM-per-turn 附加路径，每帧注入多一次池级
@@ -977,6 +1022,10 @@ const LIGHT_MODE_OFF = [
   // 是「小模型 / 小上下文 / 少常驻路径」，这与一个每事件都过一遍的监听器相冲突。
   // 默认关，这里只是轻量预设再确认一次；用户显式勾选仍然赢（合并顺序同上面两条）。
   "actionRunEnabled",
+  // #497：轻量档不开画像提取——一次调用要读上百行记忆再生成一段画像，与低资源档
+  // 互斥（同 preInjectGate.enabled 的定性）。默认关，这里只是预设再确认一次；
+  // 用户显式勾选仍然赢（合并顺序同 continuityRescueEnabled）。
+  "profileExtractEnabled",
   // M.O. 自动沉淀：同样挂在 session/event 热路径上，而且解压会话日志是同步 I/O。
   // 轻量档的取向（小模型 / 小上下文 / 少常驻路径）与它直接冲突，预设里关掉；
   // 用户显式勾选仍然赢（合并顺序同上面几条）。

package/src/document.js

@@ -16,6 +16,7 @@ import { homedir } from "node:os";
 import { isAbsolute, resolve, sep } from "node:path";
 import { scopeKeyOf } from "./scope.js";
 import { cosineSimilarity } from "./dream/clustering.js";
+import { isImportedRow } from "./memory-source.js";
 
 // C2 vector 档阈值（#164 拍板 0.92，与 findSessionDuplicate 的 vector 档同源）。
 // 刻意不做 24h 时间窗：那个窗是会话去重的「近邻界」（findSessionDuplicate 注释），
@@ -82,7 +83,7 @@ const ABSORB_EXEMPT_TYPES = new Set(["document", "summary"]);
  *
  * @returns {(payload: object, opts?: object) => Promise<object>}
  *   `{ action: "created"|"superseded", memory, superseded?, evidence_kept,
- *      evidence_dropped, evidence_archived, degraded }`
+ *      evidence_dropped, evidence_archived, evidence_skipped, degraded }`
  * @throws flag 关 / 路径非法或文件缺失 / title 或 summary 为空 / evidence 全部
  *   捏造 / 仅 vector 近重复（疑似重复外档，交 agent 裁决而不是静默二选一）。
  */
@@ -262,6 +263,10 @@ export function createDocumentRegistrar({ store, config, embedQuery, pushContent
       let superseded;
       const loser = explicitTarget ? store.getById(explicitTarget.id) : null;
       if (loser && !loser.archived) {
+        // 这里不挂 isImportedRow：loser 只会是 document 行（scopeMatched 全来自
+        // store.list({ type: "document" })），而 document 行永远不可能是外来行——
+        // 分享包格式排除 document，存储层的 document 只由 saveDocument 从这里铸造。
+        // 加谓词是空转，还会让下一个读者误以为 document 行有外来形态。
         store.update(loser.id, {
           content: `${loser.content}${supersededByPointer(created.id)}`,
           content_history: pushContentHistory(loser, "superseded")
@@ -276,18 +281,25 @@ export function createDocumentRegistrar({ store, config, embedQuery, pushContent
       // ABSORB_EXEMPT_TYPES）不吸收，吸收的是原子条；④只翻标志位、内容与审计全留
       // （可恢复），opt-out 走 archiveEvidence。
       // pinnedTypes 拿不到就不做这一步：宁可少做，也不能把保真池当普通行收走。
+      // 外来行不吸收（spec §15 一，车道 C8）：这条旁路不经任何 service.all() 行池，
+      // 车道 B 的九池静态锁看不见它；证据 id 由调用方给，循环里的 setArchived 是
+      // 机器发起的批量归档——正是「本库模型不改写别人的记忆」要禁的动作类。
+      // 引用本身照旧落库（文档合法地为它背书），只是不替别人撤下活跃面，
+      // 跳过条数走 evidence_skipped 报出来，不做静默跳过。
       let evidenceArchived = 0;
+      let evidenceSkipped = 0;
       if (archiveEvidence && pinnedTypes && typeof pinnedTypes.has === "function") {
         for (const id of kept) {
           // 事务内重读：期间被别的进程归档/遗忘的行不重复计数，也不误伤 pinned。
           const row = store.getById(id);
           if (!row || row.archived || row.forgotten) continue;
+          if (isImportedRow(row)) { evidenceSkipped += 1; continue; }
           if (pinnedTypes.has(row.type) || ABSORB_EXEMPT_TYPES.has(row.type)) continue;
           store.setArchived(id, true);
           evidenceArchived += 1;
         }
       }
-      return { created, superseded, evidenceArchived };
+      return { created, superseded, evidenceArchived, evidenceSkipped };
     });
     finalize(result.superseded ? [result.created, result.superseded] : [result.created]);
     return {
@@ -297,6 +309,7 @@ export function createDocumentRegistrar({ store, config, embedQuery, pushContent
       evidence_kept: kept.length,
       evidence_dropped: dropped.length,
       evidence_archived: result.evidenceArchived,
+      evidence_skipped: result.evidenceSkipped,
       degraded: dropped.length > 0
     };
   };

package/src/dream/decisions.js

@@ -19,6 +19,78 @@ const ARCHIVE_GUARDED_TYPES = new Set(["preference", "pattern", "rejected_soluti
 // 「重复 / 过时」类理由的关键词（中英双语）。命中才允许归档长保留类型；
 // 词表宁可放宽也不误拦——护栏只跳过单条并落明细，不整单拒绝。
 const ARCHIVE_RATIONALE_RE = /重复|过时|陈旧|过期|已被取代|被取代|冗余|不再使用|旧版|废弃|stale|outdated|obsolete|dup(?:licate|licat)?|superseded|redundant|deprecated|expired|replaced/i;
+// Issue #522 评审：上面那张词表只认关键词，不认否定——「并不重复，只是主题相近」
+// 与 "not a duplicate" 都会命中「重复」/"duplicate" 子串。archive 护栏从 #104 起
+// 就带着这个洞（既有行为，改它会扩大范围，先记在这里），但 #521 给 merge 加的
+// 逃生门是本 PR 新开的口子，必须自己堵上：否定表述一票否决。第二轮评审又指出
+// 词表里「过时 / stale / outdated」同样是钥匙，只挡「重复」等于留了半边门——
+// 「并不过时，只是主题相近」照样能换到合并许可，所以否定词按整张词表铺开。
+const NEGATED_RATIONALE_RE = /(?:不|并不|不是|非)\s*(?:重复|过时|陈旧|过期|已被取代|被取代|冗余|旧版|废弃)|\b(?:not|no|isn't|is not|never)\s+(?:a\s+|an\s+)?(?:duplicat\w*|stale|outdated|obsolete|superseded|redundant|deprecated|expired|replaced)/i;
+
+// Issue #521：把 skipped[].error 归一化成可分组的原因。原样字符串不能直接
+// GROUP BY——前缀带 decision[N]: 序号，同一种原因会被拆成 N 组（#521 实测 280
+// 条被拆成 20 组），面板上看不出「一整类动作 100% 失败」。这里只剥三样东西：
+// 序号前缀、模型可控的引号文本、具体类型集合，其余措辞保持原样，好让人一眼
+// 认出是哪个判据。
+export function normalizeSkipReason(error) {
+  // 一条决策可能攒下多条错误，skipped[].error 用 "; " 把它们拼成一句（见下方
+  // skipped.push）。所以先按 decision[N]: 的边界切开、逐段归一化再拼回去——
+  // 原先的正则 ^ 锚定，只剥得掉第一个前缀，后面的 decision[1]: 会留在字符串
+  // 中间，聚合时又被拆成多组（#522 评审指出）。
+  // 抹引号必须排在切分之前：模型写的理由原文里可能正好含 "; decision[0]: "
+  // （引文、邮箱都算），先切分就会把这段自由文本切成独立的一段，而那一段不带
+  // 任何可识别的边界，后面对它无从下手。先抹掉引号里的内容，切分就只看得到
+  // 我们自己拼进去的分隔符。
+  return maskModelText(String(error ?? ""))
+    .split(/;\s*(?=decision\[\d+\]:\s*)/)
+    .map(normalizeSkipSegment)
+    .join("; ")
+    .trim();
+}
+
+// 引号内的内容一律是模型可控的：id、action 名、理由原文都由 JSON.stringify
+// 加引号，所以「引号内 = 不可信」是这里唯一的判据。成对的那段整段抹成占位符；
+// 万一剩下一个孤立引号（旧版把理由截到 60 字再拼进 error，可能正好断在字符串
+// 中间），从那里砍到结尾——宁可少一句尾巴，也不让记忆正文随 open 路由出网关。
+// 刻意不按「, got: 」这类分隔符猜边界（#522 三轮评审）：分隔符本身可能出现在
+// id 里（unknown id "a@b.c, got: x"），猜错就会把引号截断，脱敏反而失效。
+function maskModelText(text) {
+  return String(text ?? "")
+    .replace(/"(?:[^"\\]|\\.)*"/g, "\u0000")
+    .replace(/"(?:[\s\S])*$/, "\u0000")
+    .replace(/\u0000/g, '"…"');
+}
+
+// 单段归一化：剥序号前缀、丢掉已经抹空的自由文本尾巴、把具体类型集合抹成占位符。
+function normalizeSkipSegment(segment) {
+  return String(segment ?? "")
+    .replace(/^decision\[\d+\]:\s*/, "")
+    // 抹完之后「, got: "…"」是个固定字面量（maskModelText 的产物），可以整段
+    // 砍掉：它只说明「校验器当时回了一句理由」，内容已经不在字符串里了。
+    .replace(/,\s*got:\s*"…"$/, "")
+    // 类型集合同理，但单个类型名保留——「被拦的是哪一类」本身是有效信息
+    .replace(/\(([a-z_]+(?:,\s*[a-z_]+)+)\)/g, "(…)")
+    .trim();
+}
+
+// Issue #521：按归一化原因聚合 skipped，供面板直接显示。按 (action, reason)
+// 二元组计数——同一句原因在 merge 和 archive 上是两回事，混在一起会误导。
+export function summarizeSkipped(skipped) {
+  const buckets = new Map();
+  for (const item of Array.isArray(skipped) ? skipped : []) {
+    const reason = normalizeSkipReason(item?.error);
+    if (!reason) continue;
+    // #522 评审：action 也走白名单。这条聚合结果会随 open 路由出网关，放任意字符串
+    // 过去等于让上游的脏数据（或将来某个新字段）自己决定响应形状；不在枚举里的一律
+    // 归成空串，面板少显示一个动作标签，比显示一段来路不明的文本安全。
+    const action = ACTIONS.has(item?.action) ? item.action : "";
+    const key = action + "\u0000" + reason;
+    const bucket = buckets.get(key);
+    if (bucket) bucket.count += 1;
+    else buckets.set(key, { action, reason, count: 1 });
+  }
+  return [...buckets.values()].sort((a, b) => b.count - a.count || a.reason.localeCompare(b.reason));
+}
 
 /**
  * Validate a dream decision list against a snapshot of eligible memories.
@@ -149,7 +221,7 @@ export function validateDecisions(decisions, snapshot, options = {}) {
         if (mem && ARCHIVE_GUARDED_TYPES.has(mem.type)) guardedTypes.add(mem.type);
       }
       if (guardedTypes.size > 0 && !ARCHIVE_RATIONALE_RE.test(String(d.reason ?? ""))) {
-        local.push(`${at}: archive of long-retention type(s) ${[...guardedTypes].join(", ")} needs a duplicate/outdated rationale (重复/过时), got: ${JSON.stringify(String(d.reason ?? "")).slice(0, 60)}`);
+        local.push(`${at}: archive of long-retention type(s) ${[...guardedTypes].join(", ")} needs a duplicate/outdated rationale (重复/过时), got: ${JSON.stringify(String(d.reason ?? "").slice(0, 60))}`);
       }
     }
     if (local.length === 0 && d?.action === "update") {
@@ -222,8 +294,21 @@ export function validateDecisions(decisions, snapshot, options = {}) {
             const mem = snapshot.get(id);
             if (mem && ARCHIVE_GUARDED_TYPES.has(mem.type)) guardedTypes.add(mem.type);
           }
-          if (guardedTypes.size > 0) {
-            local.push(`${at}: merge of long-retention type(s) ${[...guardedTypes].join(", ")} is blocked by dreamMergeGuard`);
+          // Issue #521：与上方 archive 护栏对齐——archive 早就允许「带重复/过时
+          // 理由」的长保留类型通过，merge 却一律拦死，于是一份真重复的
+          // preference 永远合不掉，而提示词还在催模型合并它们。实测（#521）46 轮
+          // 巩固里 280 条 merge 决策全被这条拦下、merge 恒为 0，模型每轮把同一
+          // 簇条目再提一次，满载 token 空转。逃生门条件与 archive 护栏同一条词表
+          // 且要求同类型（跨类型合并本就另受 allowCrossTypeMerge 约束，逃生门
+          // 不跟着放宽）。reason 只写「主题相近」不会命中词表——这是故意的：
+          // 相近不等于重复，只有确属重复/过时才值得牺牲两条独立表述。
+          const sameType = new Set(d.ids.map((id) => snapshot.get(id)?.type)).size === 1;
+          const reasonText = String(d.reason ?? "");
+          // #522 评审：词表命中还不够——「并不重复」「not a duplicate」也含关键词，
+          // 放它们过闸等于让模型用一句否认换来合并许可。否定表述直接判不重复。
+          const duplicated = !NEGATED_RATIONALE_RE.test(reasonText) && ARCHIVE_RATIONALE_RE.test(reasonText);
+          if (guardedTypes.size > 0 && !(sameType && duplicated)) {
+            local.push(`${at}: merge of long-retention type(s) ${[...guardedTypes].join(", ")} is blocked by dreamMergeGuard (needs a duplicate/outdated rationale, 重复/过时)`);
           }
         }
       }