@modusensus/dsh-mneme 0.9.4 → 0.10.0

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,12 +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 { parseProvenanceSelector, 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";
@@ -387,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
@@ -1293,6 +1308,62 @@ 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。本端点补最后一段接线。
+  //
+  // 两个读方向共一条路径（#524）：?id=<memoryId> 是「这条记忆从哪几句蒸出来的」，
+  // ?sessionId=<sid> 是「这个会话蒸出了哪几段」。两个主键互斥——都缺 400、都给
+  // 400（择一意味着调用方发一个自己也不知道会被读哪个主键的请求，而两边结果形状
+  // 不同）。共用路径是有意的：多一条路径就多一处要登记的地方（SECURITY.md 两张
+  // 表、README 路由表、security-doc 的清单锁），而两者读的是同一批数据。
+  //
+  // 一个链接一个窗口：区间 + 区间里的原文行（按 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 = parseProvenanceSelector({
+          memoryId: url.searchParams.get("id"),
+          sessionId: url.searchParams.get("sessionId"),
+          limit: url.searchParams.get("limit")
+        });
+        if (!parsed.ok) {
+          sendJson(res, parsed.status, { error: parsed.error });
+          return;
+        }
+        const { status, body } = provenanceReply({ service, selector: parsed.selector, 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
@@ -1518,6 +1589,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（同一实现，
@@ -1571,7 +1769,7 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
     policy: "open",
     handler(req, res) {
       try {
-        const runs = (service.listDreamRuns?.({ limit: 5 }) ?? []).map((r) => ({
+        const toRun = (r) => ({
           created_at: r.created_at,
           status: r.status,
           provider: r.provider ?? null,
@@ -1582,8 +1780,23 @@ 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)
+        });
+        // Issue #495：organize 上线后 runs 会混进 run_type="organize"，而面板那张
+        // 卡的标题是「最近巩固」——一次 agent 主动整理就会把它顶成整理回执。
+        // 两条路里选了「标注」而不是过滤：runs 仍是全类型 5 条（审计面是证据，
+        // 不因显示面积省略），另给一个只含 auto/sleep 的 lastConsolidation 供那张
+        // 卡取数；面板再用 lastRun 是否为 organize 决定要不要标一句脚注。
+        // 这里不能只靠 runs[0] 的 run_type 过滤——一次整理写两行（dryRun 报告 +
+        // apply 回执），挤空 5 个名额时 runs 里可能一条巩固都没有。
+        const runs = (service.listDreamRuns?.({ limit: 5 }) ?? []).map(toRun);
+        const lastConsolidation = service.listDreamRuns?.({ limit: 1, excludeRunType: "organize" })?.[0];
         const pendingConflicts = service.countConflictPending?.() ?? 0;
         const ids = new Set();
         for (const row of service.listConflictPending?.({ limit: 200, includeResolved: false }) ?? []) {
@@ -1594,6 +1807,7 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
         }
         sendJson(res, 200, {
           lastRun: runs[0] ?? null,
+          lastConsolidation: lastConsolidation ? toRun(lastConsolidation) : null,
           runs,
           pendingConflicts,
           pendingMemoryIds: [...ids].slice(0, 200)

package/src/config.js

@@ -586,6 +586,16 @@ export const Config = z.object({
   // Minimum gap between two sleep runs (hours) — a second idle window within
   // this interval does not retrigger.
   sleepMinIntervalHours: z.natural().min(1).max(168).default(8),
+  // Issue #529（C 项的替代实现）：sleep 连续失败退避（默认关 = 行为逐字节不变）。
+  // 基数是 sleepMinIntervalHours，有效间隔 = 基数 × 2^连续失败数（成功清零），
+  // 封顶 max(基数, 24 小时)——不是硬 24 小时：这个键允许配到 168，用户配 48 就是
+  // 明说「两天跑一次」，退避只能放宽间隔、不该把用户自己的基数压小。
+  // 为什么不按 issue 原案用 snapshot_hash 判据：sleep 的
+  // snapshot_hash 是**跑完之后**对 phases 结果算的哈希（dream/sleep.js 的
+  // createHash(JSON.stringify(phases))），不是输入快照；同一批输入跑两次结果不同
+  // 就会得到不同哈希，用它当「同一输入又在失败」的判据不成立。退避与 #292 的
+  // autoDreamFailureBackoff 同构：只放大既有的最小间隔闸，不新增状态面。
+  sleepFailureBackoff: z.boolean().default(false),
   // Conflict adjudication strictness:
   //   gentle    only high-confidence conflicts (threshold 0.92) are resolved
   //   normal    standard dream-level (threshold 0.85)
@@ -653,6 +663,22 @@ export const Config = z.object({
   // 增长）；流式计费按实际用量，不按上限。
   sleepMaxTokens: z.natural().min(256).max(131072).default(8192).description("sleep 冲突消解与模式发现阶段的 LLM 输出预算上限（token）。原为硬编码 2048，sleepActionSet=full 实测需约 7000 导致裁决被截断而整轮失败；流式计费按实际用量，调大不增加成本。"),
 
+  // Issue #529：冲突阶段此前没有任何输入侧预算——同 scope 的全部相似对被一次性
+  // 拼进一个 prompt，实测单请求 163,054 输入 token（服务端 --ctx-size 163,840，
+  // 占 99.5%），449 对的池子必然撞墙；而失败的轮次不落 pairs、判 keep 又是
+  // no-op，下一轮冷却结束再送**完全相同的输入**，于是 23 轮连续 llm failed。
+  // 输出侧早有 sleepMaxTokens（#257），输入侧这一半一直是空的。
+  //
+  // 每批上限：0 = 不设上限（严格回退到旧的一次性全送，用于排查"是不是分批
+  // 引入的差异"）。取 12 是因为实测单对约 112~168 输入 token、12 对落在
+  // 1.5K~2K 区间，远低于任何服务商的上下文窗口，也不至于让 LLM 在长清单里
+  // 走神。
+  sleepConflictMaxPairs: z.natural().min(0).max(500).default(12).description("sleep 冲突阶段每批送给 LLM 的候选对上限（0 = 不设上限，回退旧的一次性全送）。实测单对约 112~168 输入 token，默认 12 对约 1.5K~2K。"),
+  // 每轮总上限：分批之后仍要有个总闸，否则一个 449 对的池子会拆成 38 批、
+  // 每批一次 LLM 往返，单轮跑上几小时（本身也没比撞墙好）。0 = 不设上限。
+  // 未入选的对不是"被丢弃"——它们留在 conflict_pending 与下一轮的候选池里。
+  sleepConflictMaxPairsPerRun: z.natural().min(0).max(5000).default(60).description("sleep 冲突阶段单轮累计裁定的候选对上限（0 = 不设上限）。默认 60 对 ≈ 5 批，约 10K 输入 token。"),
+
   // --- epistemic trust: memory source credibility (v0.4.5) -----------------
   // Distinguish memories by source: observation (measured / witnessed),
   // subjective (opinion / guess) and inferred (derived from other evidence).
@@ -966,7 +992,13 @@ export const Config = z.object({
   // 显式保存，画像正文必须是用户手写的原文，不给模型改写权。
   // 进 LIGHT_MODE_OFF：一次调用要读上百行记忆 + 一轮模型生成，与低资源档互斥（同
   // preInjectGate.enabled 的定性）；是预设不是强制，用户显式勾选仍然赢。
-  profileExtractEnabled: z.boolean().default(false)
+  profileExtractEnabled: z.boolean().default(false),
+
+  // #539 逐会话无痕：总开关默认关，保持旧用户行为；子代理选择器默认开，但总开关
+  // 未开时不生效。手动名单是精确的 session id 匹配。
+  sessionGateEnabled: z.boolean().default(false),
+  sessionGateSubagents: z.boolean().default(true),
+  sessionGateSessions: z.array(z.string()).default([])
 });
 
 // Fields forced to false by the light-mode preset. Everything not listed here

package/src/continuity.js

@@ -173,10 +173,10 @@ function noticeAlreadyInSurface(session, text) {
  * 挂两条监听（#249 §7 的 `agent/pre-step` 触发位 + 压缩事件面），返回 { dispose }。
  *
  * `store` 直接注入：本模块只写提案表、不碰检索/嵌入，没有用到 service 的任何能力。
- * 调用方负责父／子闸门（`autoInject` + `continuityRescueEnabled`）；本函数不做开关判定，
- * 保持"挂上就是开"的单一口径。
+ * 调用方负责父／子开关（`autoInject` + `continuityRescueEnabled`），本函数另检查逐会话
+ * 无痕闸门；保持"挂上就是开、命中会话就不处理"的单一口径。
  */
-export function createContinuityRescue(ctx, store) {
+export function createContinuityRescue(ctx, store, sessionGate = null) {
   // 待处理的边缘：sessionId → 压缩事件序号。**真落地**的压缩事件到达时置位，下一次 pre-step 消费后
   // 删除（同一个边缘绝不注入第二次）。只留序号、不留 Session：插件在宿主进程里只 apply
   // 一次、服务所有会话，握着 Session 就是握着它的全量日志不放——压缩完就收工、不再有
@@ -184,6 +184,10 @@ export function createContinuityRescue(ctx, store) {
   const edge = new Map();
 
   const unsubscribe = ctx.on("session/event", (session, event) => {
+    if (sessionGate?.isOff(session)) {
+      if (session?.id) edge.delete(session.id);
+      return;
+    }
     if (!isCompactionEdge(event)) return;
     if (!session?.id) return;
     if (!edge.has(session.id) && edge.size >= MAX_TRACKED_EDGES) {
@@ -200,6 +204,10 @@ export function createContinuityRescue(ctx, store) {
     // reject 是"这一步不该发生"，往里面塞消息没有意义；未知形状原样放行。
     if (decision?.kind !== "enter") return decision;
     const session = payload?.agent?.session;
+    if (sessionGate?.isOff(session)) {
+      if (session?.id) edge.delete(session.id);
+      return decision;
+    }
     const sessionId = session?.id;
     if (!sessionId) return decision;
     if (!edge.has(sessionId)) return decision;

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
     };
   };