@modusensus/dsh-mneme 0.9.4 → 0.9.5

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, 重复/过时)`);
           }
         }
       }

package/src/dream/sleep.js

@@ -21,8 +21,12 @@ import { randomUUID, createHash } from "node:crypto";
 import { validateDecisions, applyDecisions, ACTIONS } from "./decisions.js";
 import { findPotentialConflicts, cosineSimilarity } from "./clustering.js";
 import { scopeKeyOf } from "../scope.js";
-import { buildReceipt, describeStreamFailure, resolveDreamEffort, withEffortFallback, withMaxTokensFallback, maintainIndexAfterDream } from "../dream.js";
+import { buildReceipt, describeStreamFailure, resolveDreamEffort, withEffortFallback, withMaxTokensFallback, maintainIndexAfterDream, fenceListBody, parseFailureMeta } from "../dream.js";
 import { computeHeat } from "../heat.js";
+// 四个相位读的都是行池，而动行的写手不经汇流口：phaseDemotion 直接 setArchived /
+// demoteToSummary，phasePatterns 还会 mint 出新行，所以这条契约要在每处各挡一遍
+// （清单与静态锁见 test/share-imported-guard.test.js）。
+import { isImportedRow } from "../memory-source.js";
 
 // Issue #126 review（Copilot）：默认档（sleepActionSet="conflict"）允许的动作 = 全局
 // ACTIONS 去掉 #126 新增的两个。从 ACTIONS 派生而非硬编码，将来再扩动作集时自动跟随。
@@ -102,8 +106,11 @@ async function auditedSleepLlm(ctx, service, config, logger, spec, body) {
   let outputTokens = 0;
   let status = "success";
   let errorMessage = null;
+  // 提到 try 之外：finally 里的 metadataFrom 要读这一轮的原始输出（dream.js 的
+  // runAuditedLlm 就是这么声明的）。留在 try 里，finally 看不见它，读数会静默变空。
+  let result;
   try {
-    const result = await body((usage) => {
+    result = await body((usage) => {
       if (!usage) return;
       const i = usage.input_tokens ?? usage.inputTokens ?? usage.prompt_tokens ?? usage.promptTokens;
       const o = usage.output_tokens ?? usage.outputTokens ?? usage.completion_tokens ?? usage.completionTokens;
@@ -129,6 +136,17 @@ async function auditedSleepLlm(ctx, service, config, logger, spec, body) {
     errorMessage = String(error?.message ?? error);
     throw error;
   } finally {
+    // spec.metadataFrom(result)：与 dream.js 的 runAuditedLlm 同一形状（这里是一份并行
+    // 实现，不是同一个函数——两份审计写法的字段必须一致，否则面板按 operation_type
+    // 筛出来的读数会时有时没有）。判据函数只读 result，不读闭包，理由同 dream.js。
+    let metadata;
+    if (result !== undefined && typeof spec.metadataFrom === "function") {
+      try {
+        metadata = spec.metadataFrom(result) ?? undefined;
+      } catch {
+        metadata = undefined;
+      }
+    }
     try {
       service.saveLlmAudit({
         timestamp,
@@ -142,7 +160,8 @@ async function auditedSleepLlm(ctx, service, config, logger, spec, body) {
         duration_ms: Date.now() - startedAt,
         status,
         error_message: errorMessage,
-        related_memory_ids: spec.relatedMemoryIds ?? []
+        related_memory_ids: spec.relatedMemoryIds ?? [],
+        ...(metadata ? { metadata } : {})
       });
     } catch (auditError) {
       logger?.warn?.(`dsh-mneme sleep: llm audit write failed: ${String(auditError)}`);
@@ -205,7 +224,7 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
   }
   const strictness = config.sleepConflictStrictness ?? "normal";
   const threshold = CONFLICT_THRESHOLDS[strictness] ?? CONFLICT_THRESHOLDS.normal;
-  const memories = withoutPaused(service, service.all().filter((m) => !m.archived && !m.forgotten && m.type !== "summary" && m.type !== "document"));
+  const memories = withoutPaused(service, service.all().filter((m) => !isImportedRow(m) && !m.archived && !m.forgotten && m.type !== "summary" && m.type !== "document"));
   if (memories.length < 2) return { status: "skipped", reason: "too few memories" };
   if (signal?.aborted) return { status: "aborted", reason: "user activity" };
 
@@ -342,7 +361,10 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
       // 解析结果存进闭包给下面的控制流用——审计关闭时 auditedSleepLlm 整段早退、
       // 这个钩子不会被调用，控制流会跟着失效（dream 的既有坑）。代价是审计开启时
       // 多解析一次，换来两条路径彻底解耦。
-      auditError: (text) => (parseJsonArray(text) ? null : "no json array in llm output")
+      auditError: (text) => (parseJsonArray(text) ? null : "no json array in llm output"),
+      // 纯判据，与 auditError 同一条约定：重解析一次、不读闭包（审计关掉时那些闭包
+      // 根本不会被赋值，读它会让「审计说了什么」依赖调用方走到了哪一行）。
+      metadataFrom: (text) => (parseJsonArray(text) ? null : parseFailureMeta(text))
     }, (reportUsage) => streamText(ctx, {
     provider: route.provider,
     model: route.model,
@@ -351,7 +373,7 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
     ...(withEffort && sleepEffort ? { reasoningEffort: sleepEffort } : {}),
     messages: [
       { role: "system", content: [{ type: "text", text: conflictPrompt }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } },
-      { role: "user", content: [{ type: "text", text: listText }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } }
+      { role: "user", content: [{ type: "text", text: fenceListBody(language, listText) }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } }
     ]
   }, reportUsage, (reason) => { conflictStreamFailure = describeStreamFailure(reason); }));
   };
@@ -444,7 +466,10 @@ function phaseDemotion(service, config, logger, runId, signal = null) {
   // 政策轴在这里尤其要紧：下面两行会真改归档面（setArchived / demoteToSummary）。
   // 把过滤放在循环之外、而不是在循环体里 continue：一旦将来有人在循环体里加
   // 副作用（现已有），漏掉那条 continue 就是静默改到被按下的行。
-  for (const m of withoutPaused(service, service.all())) {
+  // 外来行也在循环之外挡掉，同一个理由：它不经本方蒸馏，时间分层无权动它的原文或
+  // 归档面；而下面两行动作（setArchived / demoteToSummary）不经 saveWithDedupe，
+  // 汇流口那道闸门到这里已经管不到了。
+  for (const m of withoutPaused(service, service.all().filter((m) => !isImportedRow(m)))) {
     if (signal?.aborted) break;
     if (m.archived || m.forgotten) continue;
     const ref = m.last_accessed_at ?? m.created_at;
@@ -495,9 +520,31 @@ async function phasePatterns(ctx, service, config, logger, runId, signal = null)
   // 先生效的话，指针行一多就会把普通记忆挤出扫描窗，池子饿到门槛以下。
   // 政策轴同理必须排在 `.slice(0, limit)` **之前**，否则被按下的行照样占掉
   // sleepPatternMinMemories 的名额，而它们既不会被扫、也不该挤掉别人（#471）。
-  const memories = withoutPaused(service, service
-    .list({ limit: 200, includeForgotten: false, excludeTypes: ["document"] })
-    .filter((m) => !m.archived && m.type !== "summary" && m.type !== "pattern"))
+  //
+  // archived 这一轴不在下面出现，不是漏了：list() 默认就带 `archived = 0`
+  // （store.js list 的 includeArchived 默认 false、onlyArchived 默认 false），
+  // 旧写法那句 `!m.archived` 一直是重复过滤——查询层已经把它挡在外面。
+  // 窗口至少等于本次要扫的名额：`sleepPatternMinMemories` 的合法上限是 1000
+  // （src/config.js:612）。窗口若还是死的 200，那么把这个值配到 200 以上的人
+  // **每一轮**都会触发下面那次无界重取，跟闸门按没按下无关——那是把这条修复
+  // 从「按需」变成「常付」。
+  const poolQuery = {
+    limit: Math.max(200, limit), includeForgotten: false,
+    // 三条政策轴全部下推到查询层：留在 LIMIT 之后过滤，等于让被丢掉的行为窗口占名额
+    // （模式扫描池会因此饿到 sleepPatternMinMemories 以下而静默跳过）。同一取舍见
+    // #230 的 document 轴与本文件 #471 的暂停轴，src/service.js:2247 那条注释记着前例。
+    excludeTypes: ["document", "summary", "pattern"],
+    excludeImported: true
+  };
+  const gather = (query) => withoutPaused(service, service.list(query));
+  let pool = gather(poolQuery);
+  // #515：暂停闸门要读 scope_state 并按「这一维有标注」匹配，下推进 SQL 就等于让判定
+  // 长出第二份实现（issue 里写过为什么否掉，`*` 那一行是关键的不可下推处）。所以这里
+  // 不动判定、只放宽取数：**只有窗口过滤后不够本次要扫的名额**才不带窗口重取一次。
+  // 常态仍只付一次有界查询；多付的那一次恰好就是原本会静默跳过的那一次——
+  // 症状从「库里没东西可扫」变成「扫了」，这才是这条闸门该有的行为。
+  if (pool.length < limit) pool = gather({ ...poolQuery, limit: null });
+  const memories = pool
     .sort((a, b) => (a.updated_at < b.updated_at ? 1 : -1))
     .slice(0, limit);
   if (memories.length === 0) return { status: "skipped", reason: "no memories to scan" };
@@ -518,7 +565,10 @@ async function phasePatterns(ctx, service, config, logger, runId, signal = null)
       relatedMemoryIds: memories.map((m) => m.id),
       streamError: () => patternStreamFailure,
       // 纯判据，同 conflict 阶段：不把解析结果存进闭包供控制流使用。
-      auditError: (text) => (parseJsonArray(text) ? null : "no json array in llm output")
+      auditError: (text) => (parseJsonArray(text) ? null : "no json array in llm output"),
+      // 纯判据，与 auditError 同一条约定：重解析一次、不读闭包（审计关掉时那些闭包
+      // 根本不会被赋值，读它会让「审计说了什么」依赖调用方走到了哪一行）。
+      metadataFrom: (text) => (parseJsonArray(text) ? null : parseFailureMeta(text))
     }, (reportUsage) => streamText(ctx, {
     provider: route.provider,
     model: route.model,
@@ -527,7 +577,7 @@ async function phasePatterns(ctx, service, config, logger, runId, signal = null)
     ...(withEffort && sleepEffort ? { reasoningEffort: sleepEffort } : {}),
     messages: [
       { role: "system", content: [{ type: "text", text: STR.prompts.pattern[language].replace("N", String(maxPatterns)) }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } },
-      { role: "user", content: [{ type: "text", text: listText }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } }
+      { role: "user", content: [{ type: "text", text: fenceListBody(language, listText) }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } }
     ]
   }, reportUsage, (reason) => { patternStreamFailure = describeStreamFailure(reason); }));
   };
@@ -586,7 +636,7 @@ function phaseRelations(service, config, logger, runId, signal = null) {
   if (entities.length < 2) return { status: "skipped", reason: "too few entities" };
   const orphans = entities.filter((e) => (service.getRelations(e.id) ?? []).length === 0);
   if (orphans.length === 0) return { status: "skipped", reason: "no orphan entities" };
-  const memories = withoutPaused(service, service.all().filter((m) => !m.archived && !m.forgotten));
+  const memories = withoutPaused(service, service.all().filter((m) => !isImportedRow(m) && !m.archived && !m.forgotten));
   const seen = new Set();
   const related = [];
   const MAX_RELATIONS_PER_ORPHAN = 3;

package/src/dream.js

@@ -10,6 +10,10 @@ import { scopeKeyOf } from "./scope.js";
 import { isInPeakWindow, nextOffPeakAt } from "./peak-hours.js";
 import { createHash, randomUUID } from "node:crypto";
 import { STR, langOf } from "./lang.js";
+// 巩固读的是行池，而动行的写手不经汇流口：applyDecisions 归档败者直接走
+// service.setArchived（dream/decisions.js），所以「不许改写外来行」这条契约要在
+// 每个池子各挡一遍。清单与静态锁见 share-imported-guard.test.js。
+import { isImportedRow } from "./memory-source.js";
 export { validateDecisions, applyDecisions, withEffortFallback, withMaxTokensFallback, parseMaxTokensCap, describeStreamFailure, resolveDreamEffort, resolveRoute, streamText, runAuditedLlm };
 
 // Extract the first JSON array from LLM output, tolerating markdown fences,
@@ -57,7 +61,7 @@ function totalChars(memories) {
 // 两处若各写一份过滤条件，重启播种读到的基线就会和运行期判定口径漂移（一个把
 // document 算进去、一个不算），阈值随之失真，且这种漂移只会在重启后才显形。
 function activeStoreSize(service) {
-  const memories = withoutPaused(service, service.all().filter((m) => !m.archived && m.type !== "summary" && m.type !== "document"));
+  const memories = withoutPaused(service, service.all().filter((m) => !isImportedRow(m) && !m.archived && m.type !== "summary" && m.type !== "document"));
   return { count: memories.length, chars: totalChars(memories) };
 }
 
@@ -309,6 +313,45 @@ function describeStreamFailure(reason) {
  * operation_type, model_id, related_memory_ids); `body(reportUsage)` performs
  * the actual stream consumption and is handed a usage reporter for the chunks.
  */
+/**
+ * 把喂给模型的清单包进围栏（#493 的另一半：dream / sleep 那 5 处 user 消息以前是裸放）。
+ * 三个细节各自有原因，别当装饰删：
+ * - 角色声明落在**开头**：判断「这段文本是什么」的是它所在的那条 user 消息，只写在 system
+ *   里实测救不回来（#493 的 A/C 臂：只加 system 约束仍 0/2 出 JSON）；
+ * - 正文里的 `<<<` / `>>>` 用零宽空格断链——**只中和标记，不删内容**。不这么做时，一条写着
+ *   「<<<记忆清单结束>>>」的记忆就能提前闭合围栏，把后面的文字升格成指令；而记忆正文本来就
+ *   是模型的可影响输入，这是最省事的注入入口；
+ * - 纯函数、不带 nonce：同一批记忆在下一次巩固阈值到来时会被原样再喂一次，重试收到的 prompt
+ *   必须与首次逐字节相同，否则「同输入同错」这条诊断依据就没了（#493 的重试 20 次现场就靠它）。
+ * @param {"json"|"text"} [shape] 该次调用的**输出契约**：巩固/叙述/冲突/模式要 JSON 数组，
+ *   总览摘要要散文。角色声明里那句「只输出 JSON 数组」必须跟着契约走——对散文契约说它，
+ *   模型会回 `[]`，而 `summaryText.trim()` 判非空通过，`[]` 就被当成摘要存进库（评审实测）。
+ */
+export function fenceListBody(language, text, shape = "json") {
+  const open = STR.memoryFenceOpen[language] ?? STR.memoryFenceOpen.en;
+  const close = STR.memoryFenceClose[language] ?? STR.memoryFenceClose.en;
+  const table = shape === "text" ? STR.dreamTextRoleReminder : STR.dreamRoleReminder;
+  const reminder = table[language] ?? table.en;
+  const body = String(text ?? "").replace(/<<<|>>>/g, (run) => `${run[0]}\u200B${run.slice(1)}`);
+  return `${reminder}\n\n${open}\n${body}\n${close}`;
+}
+
+/**
+ * 解析失败行的审计读数（#493 同款，报告者提的第 2 条）。dream 的 warn 日志本来就带
+ * raw length + 前 300 字，缺的是**可查询**的那一面：日志要翻、按不了、也进不了面板的
+ * 「LLM 消耗」。`raw_has_bracket` 是区分「模型压根没按格式写」与「格式对但内容救不回来」
+ * 的唯一低成本判据。
+ */
+export function parseFailureMeta(text) {
+  const raw = typeof text === "string" ? text : "";
+  return {
+    parse_failure: true,
+    raw_len: raw.length,
+    raw_head: raw.slice(0, 300).replace(/\s+/g, " ").trim(),
+    raw_has_bracket: raw.includes("[")
+  };
+}
+
 async function runAuditedLlm(ctx, service, config, spec, body) {
   const audit = config?.llmAudit;
   if (audit?.enabled === false || typeof service?.saveLlmAudit !== "function") return body(() => {});
@@ -351,6 +394,17 @@ async function runAuditedLlm(ctx, service, config, spec, body) {
     errorMessage = String(error?.message ?? error);
     throw error;
   } finally {
+    // spec.metadataFrom(result)：调用方按**这一轮的原始输出**决定要不要带读数（解析成功就
+    // 返回 null → 整键不写）。判据函数必须是纯的：它读的是 result，不读控制流里的缓存，
+    // 否则「审计说了什么」会随调用方走到哪一行而变（sleep.js 同一条硬约定）。
+    let metadata;
+    if (result !== undefined && typeof spec.metadataFrom === "function") {
+      try {
+        metadata = spec.metadataFrom(result) ?? undefined;
+      } catch {
+        metadata = undefined; // 读数失败不许把审计行整个弄没
+      }
+    }
     try {
       service.saveLlmAudit({
         timestamp,
@@ -364,7 +418,8 @@ async function runAuditedLlm(ctx, service, config, spec, body) {
         duration_ms: Date.now() - startedAt,
         status,
         error_message: errorMessage,
-        related_memory_ids: spec.relatedMemoryIds ?? []
+        related_memory_ids: spec.relatedMemoryIds ?? [],
+        ...(metadata ? { metadata } : {})
       });
     } catch (auditError) {
       ctx.logger?.warn?.(`dsh-mneme: llm audit write failed: ${String(auditError)}`);
@@ -486,7 +541,7 @@ async function reEmbedMemory(semantic, memory, logger) {
  * 任何失败降级为 0 条，绝不反噬 dream 主流程。
  */
 async function generateNarratives({ ctx, service, config, route, language, effort, semantic, logger }) {
-  const inputs = withoutPaused(service, service.all().filter((m) => !m.archived && !m.forgotten && m.type !== "summary" && m.type !== "document"));
+  const inputs = withoutPaused(service, service.all().filter((m) => !isImportedRow(m) && !m.archived && !m.forgotten && m.type !== "summary" && m.type !== "document"));
   const clusters = clusterByTag(inputs, { minCluster: config.dreamNarrativeMinCluster ?? 3 });
   if (!clusters.length) return 0;
 
@@ -511,7 +566,7 @@ async function generateNarratives({ ctx, service, config, route, language, effor
       ...(withEffort && effort ? { reasoningEffort: effort } : {}),
       messages: [
         { role: "system", content: [{ type: "text", text: STR.prompts.narrative[language] }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } },
-        { role: "user", content: [{ type: "text", text: listing }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } }
+        { role: "user", content: [{ type: "text", text: fenceListBody(language, listing) }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } }
       ]
     }, reportUsage, (reason) => { streamFailure = describeStreamFailure(reason); }));
   };
@@ -1014,7 +1069,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
   async function runDream(ctx, service, config) {
     const language = langOf(config);
     const logger = ctx.logger;
-    let memories = withoutPaused(service, service.all().filter((m) => !m.archived && m.type !== "summary" && m.type !== "document"));
+    let memories = withoutPaused(service, service.all().filter((m) => !isImportedRow(m) && !m.archived && m.type !== "summary" && m.type !== "document"));
     if (memories.length === 0) return { ok: true, applied: 0, skipped: true, summary: false };
     // Issue #89：开跑时刻既喂给审计行（created_at），也是调度器闸门的时间基准。
     const dreamStartedAt = Date.now();
@@ -1206,7 +1261,8 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
       auditError: (text) => {
         decisions = extractJsonArray(text);
         return Array.isArray(decisions) ? null : "no json array in llm output";
-      }
+      },
+      metadataFrom: (text) => (Array.isArray(decisions) ? null : parseFailureMeta(text))
     }, (reportUsage) => streamText(ctx, {
       provider: route.provider,
       model: route.model,
@@ -1215,7 +1271,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
       ...(withEffort && effort ? { reasoningEffort: effort } : {}),
       messages: [
         { role: "system", content: [{ type: "text", text: consolidationPrompt }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } },
-        { role: "user", content: [{ type: "text", text: listText }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } }
+        { role: "user", content: [{ type: "text", text: fenceListBody(language, listText) }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } }
       ]
     }, reportUsage, (reason) => { streamFailure = describeStreamFailure(reason); }));
     };
@@ -1458,7 +1514,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
       ...(withEffort && effort ? { reasoningEffort: effort } : {}),
       messages: [
         { role: "system", content: [{ type: "text", text: STR.prompts.dreamSummary[language] }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } },
-        { role: "user", content: [{ type: "text", text: summaryInputs.map((m) => `- ${m.title}: ${m.content}`).join("\n") }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } }
+        { role: "user", content: [{ type: "text", text: fenceListBody(language, summaryInputs.map((m) => `- ${m.title}: ${m.content}`).join("\n"), "text") }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } }
       ]
     }, reportUsage, (reason) => { summaryStreamFailure = describeStreamFailure(reason); }));
     };
@@ -1476,7 +1532,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     // （saveWithDedupe 不带 agent_scope/workspace_scope），所以被按下作用域的内容
     // 一旦进了总览，注入侧按作用域过滤就再也拦不住它：内容已经洗成了全局行。
     // 别的入口漏了只是「那一条漏过去」，这里漏了是「洗一遍之后一直漏」。
-    const summaryAll = withoutPaused(service, service.all().filter((m) => !m.archived && m.type !== "summary" && m.type !== "document"));
+    const summaryAll = withoutPaused(service, service.all().filter((m) => !isImportedRow(m) && !m.archived && m.type !== "summary" && m.type !== "document"));
     const summaryMaxInputs = Number.isInteger(config.dreamSummaryMaxInputs) ? config.dreamSummaryMaxInputs : 0;
     const summaryInputs = summaryMaxInputs > 0 && summaryAll.length > summaryMaxInputs
       ? [...summaryAll]