recallnest 2.5.4 → 2.6.1

package/src/capture-engine.ts

@@ -5,9 +5,11 @@ import { extractErrorSignatures } from "./error-signature.js";
 import { verifyWrite } from "./write-verifier.js";
 // batchInternalDedup is available in ingest.ts for large-batch scenarios;
 // persistMemoryBatch relies on per-item conflict detection (A-2) instead.
-import { defaultEvolution, buildSupersedeMetadata, buildSupersedeMetadataForNew, buildPendingReviewMetadata, isActiveMemory, patchEvolution } from "./memory-evolution.js";
+import { defaultEvolution, buildSupersedeMetadata, buildSupersedeMetadataForNew, buildPendingReviewMetadata, isActiveMemory, parseEvolution, patchEvolution } from "./memory-evolution.js";
+import { archiveBeliefVersion, buildSupersedingBeliefMetadata } from "./belief-history.js";
 import { detectTopicTag, injectTopicTag } from "./topic-tag.js";
 import { assignDefaultConfidence, type ConfidenceMetadata } from "./confidence-tracker.js";
+import { parseDependsOnInput } from "./freshness.js";
 import {
   type CaseMemoryInput,
   CaseMemoryInputSchema,
@@ -59,9 +61,10 @@ import type { KGExtractor } from "./kg-extractor.js";
 import { scanForPII, redactSecrets } from "./pii-detector.js";
 import type { AuditLogger } from "./audit-log.js";
 import { checkAdmission, type ScopeRateLimiter, type AdmissionConfig } from "./admission-control.js";
+import { resolveNoisePrototypeBank, type NoisePrototypeBank } from "./noise-prototype-bank.js";
 import { tagNarrativeIfEnabled } from "./narrative-tagger.js";
 
-type StoreDeps = Pick<MemoryStore, "store"> & Partial<Pick<MemoryStore, "list" | "update" | "getById" | "get" | "vectorSearch">>;
+type StoreDeps = Pick<MemoryStore, "store"> & Partial<Pick<MemoryStore, "list" | "update" | "getById" | "get" | "vectorSearch" | "upsert">>;
 type ConflictStoreDeps = Pick<ConflictCandidateStore, "save" | "replace" | "getOpenByFingerprint" | "getLatestByFingerprint">;
 
 export interface PersistMemoryDeps {
@@ -78,9 +81,15 @@ export interface PersistMemoryDeps {
   rateLimiter?: ScopeRateLimiter | null;
   /** LME-8: Optional admission config overrides */
   admissionConfig?: Partial<AdmissionConfig>;
+  /**
+   * Noise-prototype shadow experiment (mlp borrow). undefined → env-governed
+   * shared instance (RECALLNEST_NOISE_PROTOTYPE, shadow default); null → off.
+   * Shadow-only: it observes and logs, it never rejects.
+   */
+  noisePrototypeBank?: NoisePrototypeBank | null;
 }
 
-interface DurableWriteInput {
+export interface DurableWriteInput {
   text: string;
   vector: number[];
   category: DurableMemoryCategory;
@@ -140,7 +149,7 @@ function mergeTags(...groups: string[][]): string[] {
   return merged.slice(0, 8);
 }
 
-function buildStructuredMetadata(params: {
+export function buildStructuredMetadata(params: {
   source: string;
   tags: string[];
   capture: string;
@@ -437,11 +446,15 @@ async function findCanonicalMatches(
   return entries.filter((entry) => {
     const boundary = extractBoundaryMetadata(entry.metadata);
     if (boundary?.layer !== "durable") return false;
+    // Belief-history rows carry the same canonicalKey as the live row they were copied
+    // from. Without this guard they'd be treated as dedupe/conflict targets — so rewriting
+    // a belief back to an older wording would look like a duplicate, not a change.
+    if (!isActiveMemory(entry.metadata)) return false;
     return extractCanonicalKey(entry.metadata) === canonicalKey;
   });
 }
 
-async function writeDurableEntry(
+export async function writeDurableEntry(
   deps: PersistMemoryDeps,
   params: DurableWriteInput,
 ): Promise<{
@@ -563,13 +576,26 @@ async function writeDurableEntry(
       }
     }
 
+    // latest-wins is where beliefs change. Archive the version being replaced first —
+    // overwriting in place used to delete the old text + vector outright, which is what
+    // made "what did I believe last month?" unanswerable no matter how retrieval queried.
+    const now = Date.now();
+    const previousEvo = parseEvolution(latest.metadata, latest.timestamp);
+    const { historyId } = await archiveBeliefVersion(
+      { store: deps.store, embedder: deps.embedder },
+      latest,
+      { now },
+    );
+
     const updated = await deps.store.update(latest.id, {
       text: params.text,
       vector: params.vector,
       importance: params.importance,
       category: params.category,
-      metadata: params.metadata,
-      timestamp: Date.now(),
+      // Merge rather than replace: a bare params.metadata would wipe the evolution block
+      // (version, access stats, supersede links) along with the text.
+      metadata: buildSupersedingBeliefMetadata(params.metadata, previousEvo, historyId, now),
+      timestamp: now,
       ...(params.language ? { language: params.language } : {}),
       ...(params.fts_text ? { fts_text: params.fts_text } : {}),
     });
@@ -582,16 +608,38 @@ async function writeDurableEntry(
     };
   }
 
+  // No canonical match was found, so this falls through to store(). With a canonicalKey the
+  // id is deterministic and store() upserts on id — so a row already sitting at that id is
+  // overwritten here without ever reaching the latest-wins branch above. findCanonicalMatches
+  // only scans the most recent CANONICAL_SCAN_LIMIT rows, so any canonical row older than that
+  // window lands on this path. Look it up by id directly, which no scan limit can hide.
+  const targetId = params.canonicalKey
+    ? deterministicId(params.scope, params.canonicalKey)
+    : undefined;
+  let metadataForStore = params.metadata;
+
+  if (targetId && deps.store.getById) {
+    const rowAtTargetId = await deps.store.getById(targetId);
+    if (rowAtTargetId && normalizeMemoryText(rowAtTargetId.text) !== normalizeMemoryText(params.text)) {
+      const now = Date.now();
+      const previousEvo = parseEvolution(rowAtTargetId.metadata, rowAtTargetId.timestamp);
+      const { historyId } = await archiveBeliefVersion(
+        { store: deps.store, embedder: deps.embedder },
+        rowAtTargetId,
+        { now },
+      );
+      metadataForStore = buildSupersedingBeliefMetadata(params.metadata, previousEvo, historyId, now);
+    }
+  }
+
   const stored = await deps.store.store({
-    id: params.canonicalKey
-      ? deterministicId(params.scope, params.canonicalKey)
-      : undefined,
+    id: targetId,
     text: params.text,
     vector: params.vector,
     category: params.category,
     scope: params.scope,
     importance: params.importance,
-    metadata: params.metadata,
+    metadata: metadataForStore,
     ...(params.language ? { language: params.language } : {}),
     ...(params.fts_text ? { fts_text: params.fts_text } : {}),
   });
@@ -833,6 +881,16 @@ export async function persistMemory(
     } catch {
       // Audit must never block memory writes
     }
+    // Noise-prototype shadow experiment: learn ONLY from the regex noise
+    // filter's own verdict (mlp #914 lesson — a heuristic's low-importance
+    // self-judgment must not be recycled as a noise label). Embedding only
+    // happens on a repeat sighting under the bank cap, so this stays cheap.
+    if (admission.reason === "noise_detected") {
+      const bank = resolveNoisePrototypeBank(deps.noisePrototypeBank);
+      if (bank) {
+        await bank.learnFromRejection(input.text, (text) => deps.embedder.embedPassage(text));
+      }
+    }
     return {
       id: `rejected-${Date.now()}`,
       text: input.text,
@@ -849,6 +907,15 @@ export async function persistMemory(
   }
 
   const vector = await deps.embedder.embedPassage(input.text);
+
+  // Noise-prototype shadow experiment, matching side: reuses the write-path
+  // embedding just computed (zero extra embedding). Log-only — the verdict
+  // never blocks this write while the experiment is in shadow.
+  {
+    const bank = resolveNoisePrototypeBank(deps.noisePrototypeBank);
+    bank?.matchShadow(input.text, vector);
+  }
+
   const language = detectLang(input.text);
   const fts_text = tokenizeFts(input.text, language);
   const resolvedScope = resolveScope(input);
@@ -876,6 +943,7 @@ export async function persistMemory(
         matchResult,
         deps.store as MemoryStore,
         resolvedScope,
+        { embedder: deps.embedder },
       );
       if (applied.handled) {
         const entry = applied.entry ?? {
@@ -1029,6 +1097,15 @@ export async function persistMemory(
     metadata = JSON.stringify(parsed);
   }
 
+  // Freshness (borrowed 2026-07-21): opt-in dependsOn declarations ride in metadata like
+  // validUntil/confidence do — pulled from raw input so StoreMemoryInputSchema stays untouched.
+  const dependsOn = parseDependsOnInput(rawObj?.dependsOn);
+  if (dependsOn) {
+    const parsed: Record<string, unknown> = JSON.parse(metadata);
+    parsed.dependsOn = dependsOn;
+    metadata = JSON.stringify(parsed);
+  }
+
   const { entry, disposition, conflictId } = await writeDurableEntry(deps, {
     text: input.text,
     vector,

package/src/cli.ts

@@ -15,12 +15,13 @@ import { basename, dirname, join, resolve } from "node:path";
 import { homedir } from "node:os";
 
 import { metaDir } from "./compat.js";
+import { PACKAGE_VERSION } from "./version.js";
 import type { RetrievalResult } from "./retriever.js";
 import { applyRetrievalProfile, listRetrievalProfiles } from "./retrieval-profiles.js";
 import { distillResults, formatExplainResults, formatSearchResults, selectBriefSeedResults, summarizeResults } from "./memory-output.js";
 import { archiveDirtyBriefAsset, assetSummaryLine, buildBriefAsset, buildPinAsset, getExportsDir, listDirtyBriefAssets, listMemoryAssets, listPinAssets, pinSummaryLine, saveBriefAsset, savePinAsset, writeExportArtifact } from "./memory-assets.js";
 import { indexAsset, indexPinnedAsset } from "./asset-sync.js";
-import { createComponents, createStoreOnly, expandHome, loadConfig, loadDotEnv, type LocalMemoryConfig } from "./runtime-config.js";
+import { createComponents, createStoreOnly, expandHome, loadConfig, loadDotEnv, resolveDbPath, type LocalMemoryConfig } from "./runtime-config.js";
 import { KGStore } from "./kg-store.js";
 import { isKGModeEnabled } from "./kg-extractor.js";
 import {
@@ -30,6 +31,7 @@ import {
   ingestCCTranscripts,
   ingestCodexSessions,
   ingestGeminiSessions,
+  ingestKimiSessions,
   ingestMarkdownFiles,
   ingestObsidianVault,
   ingestConnectorFile,
@@ -37,7 +39,7 @@ import {
 import { runDoctor, formatDoctorResults } from "./doctor.js";
 import { persistCaseMemory, persistMemory, persistWorkflowPattern } from "./capture-engine.js";
 import { scanMemoryPromotions, buildPromoteScanDeps, formatPromoteScanResult } from "./memory-promotion.js";
-import { runDream, formatDreamResult, DEFAULT_DREAM_CONFIG } from "./dream-pipeline.js";
+import { runDream, formatDreamResult, formatDreamMetrics, DEFAULT_DREAM_CONFIG, classifyDreamFailure, shouldBlockDreamRun, partitionAutoDreamScopes } from "./dream-pipeline.js";
 import { listScopesAboveThreshold } from "./activity-counter.js";
 import {
   CaseMemoryInputSchema,
@@ -153,7 +155,7 @@ const program = new Command();
 program
   .name("recallnest")
   .description("本地优先 AI 对话记忆搜索与蒸馏层")
-  .version("1.4.0");
+  .version(PACKAGE_VERSION);
 
 async function runRetrievalView(
   view: "search" | "explain" | "distill",
@@ -1358,7 +1360,7 @@ program
 program
   .command("ingest")
   .description("导入对话记录到索引")
-  .option("-s, --source <source>", "数据源: cc / codex / memory / desktop / all", "all")
+  .option("-s, --source <source>", "数据源: cc / codex / gemini / kimi / memory / desktop / all", "all")
   .option("-l, --limit <n>", "限制处理文件数（调试用）")
   .option("-v, --verbose", "详细输出")
   .option("--no-dedup", "跳过向量去重")
@@ -1462,6 +1464,14 @@ program
       console.log(`  ✅ Codex: ${formatIngestSummary(r)}`);
     }
 
+    // Kimi Code Sessions (wire.jsonl 事件流，~/.kimi-code/sessions/)
+    if (source === "all" || source === "kimi") {
+      console.log("🌙 导入 Kimi Code 对话...");
+      const r = await ingestKimiSessions(store, embedder, ingestOpts);
+      results.push(r);
+      console.log(`  ✅ Kimi: ${formatIngestSummary(r)}`);
+    }
+
     // Gemini Sessions (JSON format under ~/.gemini/tmp/*/chats/)
     if (source === "all" || source === "gemini") {
       console.log("💎 导入 Gemini 对话...");
@@ -1589,26 +1599,98 @@ program
     const kgStore = isKGModeEnabled() ? new KGStore({ dbPath: store.dbPath }) : null;
 
     if (options.auto) {
-      const scopes = listScopesAboveThreshold(DEFAULT_DREAM_CONFIG.minWritesForDream, { statsPath: activityStatsPath });
+      const eligible = listScopesAboveThreshold(DEFAULT_DREAM_CONFIG.minWritesForDream, { statsPath: activityStatsPath });
+      // 巨型 scope 交给专用 schedule,不占日常轮次的 wall-clock 预算(理由见
+      // DreamConfig.autoExcludeScopes:07-30 那轮 6h 只跑了 15/507,而 memory 独占 79% 的条数)。
+      const { run: scopes, deferred } = partitionAutoDreamScopes(eligible, DEFAULT_DREAM_CONFIG.autoExcludeScopes);
+      if (deferred.length > 0) {
+        // 不静默:被挪走的 scope 必须在日志里看得见,否则"今天怎么没跑 memory"只能靠翻代码回答。
+        // 前缀刻意用 `[dream]` 而不是 `dream --auto:`——后者是 dream-checkup.sh 抓「达标 scope 数」
+        // 的锚点,多一行同前缀的会混进它的取数。
+        console.log(`[dream] ${deferred.length} 个 scope 交给专用 schedule，本轮不跑 → ${deferred.join(", ")}`);
+      }
       if (scopes.length === 0) {
-        console.log("dream --auto: 无达标 scope（写计数均低于门槛）");
+        // 两种空:一种是真没人达标,一种是达标的全被挪走了——混成一句会让排障从这里开始跑偏。
+        console.log(
+          eligible.length === 0
+            ? "dream --auto: 无达标 scope（写计数均低于门槛）"
+            : "dream --auto: 达标 scope 全部交给专用 schedule，本轮无事可做",
+        );
         console.log("[[DREAM_STATUS]] skip");
         process.exit(0);
       }
       console.log(`dream --auto: ${scopes.length} 个达标 scope → ${scopes.join(", ")}`);
-      let anyFailed = false;
+
+      // Wall-clock 预算(2026-07-29 补)：防单轮跑成跨天。07-24 那轮跑了 4 天 15 小时，
+      // 把 07-25~27 三天的调度全堵死（上一次没结束，launchd 起不了新的）。
+      // 天花板见 DreamConfig.autoRunBudgetMs 的注释——截断会让靠后 scope 系统性饿死，
+      // 真解是 session scope TTL，不是把预算调大。
+      const budgetMs = Number(process.env.RECALLNEST_DREAM_BUDGET_MS ?? DEFAULT_DREAM_CONFIG.autoRunBudgetMs);
+      const deadline = Date.now() + budgetMs;
+
+      let fatalFailures = 0;
+      let transientFailures = 0;
+      let processed = 0;
+      // 2026-08-12 产出计量：`[[DREAM_STATUS]] ok` 只证明「没崩」，不证明「产出了东西」。
+      // 2026-07-23 查出的语义阈值卡在真实 p99 之上，就是这样静默跑了 2716 次零 insight
+      // 而无人察觉 —— 当时日志里每一轮都是 ok。
+      const tally = { produced: 0, noop: 0, partial: 0, skipped: 0 };
+      let effectsTotal = 0;
+      const degradedScopes: string[] = [];
       for (const scope of scopes) {
+        if (Date.now() > deadline) {
+          console.warn(
+            `[dream] wall-clock 预算 ${Math.round(budgetMs / 60_000)} 分钟耗尽：已处理 ` +
+              `${processed}/${scopes.length}，剩余 ${scopes.length - processed} 个 scope 本轮跳过`,
+          );
+          break;
+        }
+        processed++;
         try {
           const result = await runDream({ store, llm, embedder, scope, force: Boolean(options.force), activityStatsPath, kgStore });
+          tally[result.output.kind]++;
+          effectsTotal += result.output.effectsWritten;
+          if (result.output.degraded) degradedScopes.push(`${scope}=${result.output.degraded}`);
           console.log(`[scope=${scope}] ${formatDreamResult(result)}`);
         } catch (err) {
-          anyFailed = true;
-          // 单 scope 失败不阻断其他 scope
-          console.error(`[scope=${scope}] dream failed: ${err instanceof Error ? err.message : String(err)}`);
+          // 单 scope 失败不阻断其他 scope。
+          // 打完整 stack 而不只是 message：像「Array.from requires an array-like object」
+          // 这种原生错误，只有 message 时根本定位不到是哪一行抛的——2026-07-18/19 连着两天
+          // 因此 blocked，回头查日志除了这一句什么线索都没有，只能靠猜。
+          // 分类基于 message（不是 stack）：stack 里的文件路径不该参与判定。
+          const message = err instanceof Error ? err.message : String(err);
+          if (classifyDreamFailure(message) === "transient") transientFailures++;
+          else fatalFailures++;
+          console.error(`[scope=${scope}] dream failed: ${err instanceof Error ? (err.stack ?? err.message) : String(err)}`);
         }
       }
-      console.log(anyFailed ? "[[DREAM_STATUS]] blocked" : "[[DREAM_STATUS]] ok");
-      process.exit(anyFailed ? 1 : 0);
+
+      // 旧语义是「任一 scope 抛异常即 blocked」，在 475 个 scope 的规模下等于「有一个撞上
+      // store-write 锁就整轮红」，而整轮红会让 shell 脚本重试 → 重跑全量。改为：代码/数据
+      // 缺陷一票否决，环境性失败要成规模才算整轮失败。比例按已处理数算，不按总数。
+      // 结构性降级一票否决：它不是「今天数据不成簇」（那是合法的 noop），而是某条路径
+      // 整段断了 —— 向量管线空、或压根没配 LLM。判据只认确定性零值，不含任何阈值，
+      // 所以不会因为数据分布变化而误伤（详见 assertDreamSweepHealth 的注释）。
+      const structurallyBroken = degradedScopes.length > 0;
+      if (structurallyBroken) {
+        console.error(`[dream] ⚠ 结构性降级 ${degradedScopes.length} 个 scope：${degradedScopes.join(", ")}`);
+      }
+      const blocked = shouldBlockDreamRun({ totalScopes: processed, fatalFailures, transientFailures })
+        || structurallyBroken;
+      if (fatalFailures > 0 || transientFailures > 0) {
+        console.log(`[dream] 失败统计：fatal=${fatalFailures} transient=${transientFailures}（已处理 ${processed}）`);
+      }
+      // 这一行是 dream-consolidation.sh 存在性闸的锚点：STATUS=ok 却没有它 = 判失败。
+      // 它防的是「断言本身被某次重构悄悄删掉」—— 一个不需要调参的自检。
+      console.log(formatDreamMetrics({
+        tally,
+        degraded: degradedScopes.length,
+        effects: effectsTotal,
+        processed,
+        total: scopes.length,
+      }));
+      console.log(blocked ? "[[DREAM_STATUS]] blocked" : "[[DREAM_STATUS]] ok");
+      process.exit(blocked ? 1 : 0);
     }
 
     try {
@@ -1623,10 +1705,23 @@ program
       });
 
       console.log(formatDreamResult(result));
+      // 单 scope 也必须打产出计量：dream-consolidation.sh 的存在性闸对 STATUS=ok
+      // 一视同仁地要求这行，而本分支此前从不打 —— 08-12 那道闸上线后，周日的
+      // memory 轮次即使跑成功也会被判"产出断言缺失"。tally 在这里只有一格是 1。
+      const tally = { produced: 0, noop: 0, partial: 0, skipped: 0 };
+      tally[result.output.kind] = 1;
+      console.log(formatDreamMetrics({
+        tally,
+        degraded: result.output.degraded ? 1 : 0,
+        effects: result.output.effectsWritten,
+        processed: 1,
+        total: 1,
+      }));
       console.log(result.ran ? "[[DREAM_STATUS]] ok" : "[[DREAM_STATUS]] skip");
       process.exit(0);
     } catch (err) {
-      console.error(`dream failed: ${err instanceof Error ? err.message : String(err)}`);
+      // 同 --auto 分支：带 stack，否则原生错误无从定位。
+      console.error(`dream failed: ${err instanceof Error ? (err.stack ?? err.message) : String(err)}`);
       console.log("[[DREAM_STATUS]] blocked");
       process.exit(1);
     }
@@ -1741,7 +1836,7 @@ program
     }
 
     const config = loadConfig();
-    const dbPath = resolve(metaDir(import.meta), "..", expandHome(config.dbPath));
+    const dbPath = resolveDbPath(config);
 
     if (existsSync(dbPath)) {
       const { rmSync } = await import("node:fs");

package/src/conflict-engine.ts

@@ -9,6 +9,8 @@ import {
   parseMetadataObject,
 } from "./memory-boundaries.js";
 import type { MemoryStore } from "./store.js";
+import { archiveBeliefVersion, buildSupersedingBeliefMetadata } from "./belief-history.js";
+import { parseEvolution } from "./memory-evolution.js";
 import {
   type ConflictCandidateInput,
   ConflictCandidateInputSchema,
@@ -95,7 +97,8 @@ function buildMergedConflictMetadata(
 }
 
 export interface ResolveConflictDeps {
-  store: Pick<MemoryStore, "getById" | "update">;
+  // `store`/`upsert` are needed to archive the belief being replaced before overwriting it.
+  store: Pick<MemoryStore, "getById" | "update" | "store"> & Partial<Pick<MemoryStore, "upsert">>;
   embedder: Pick<Embedder, "embedPassage">;
   conflictStore: Pick<ConflictCandidateStore, "getById" | "replace">;
 }
@@ -144,13 +147,31 @@ export async function resolveConflictCandidate(
     }
 
     const vector = await deps.embedder.embedPassage(nextText);
+
+    // Conflict resolution is the most deliberate belief change there is — accepting the
+    // incoming version or merging both used to overwrite the existing row in place, losing
+    // precisely the "before" side of the decision. Archive it first.
+    const resolvedAtMs = Date.now();
+    const previousEvo = parseEvolution(existing.metadata, existing.timestamp);
+    const { historyId } = await archiveBeliefVersion(
+      { store: deps.store, embedder: deps.embedder },
+      existing,
+      { now: resolvedAtMs },
+    );
+
     const updated = await deps.store.update(existing.id, {
       text: nextText,
       vector,
       importance: nextImportance,
       category: nextCategory,
-      metadata: nextMetadata,
-      timestamp: Date.now(),
+      metadata: buildSupersedingBeliefMetadata(
+        nextMetadata,
+        previousEvo,
+        historyId,
+        resolvedAtMs,
+        `conflict:${input.resolution}`,
+      ),
+      timestamp: resolvedAtMs,
     });
     if (!updated) {
       throw new Error(`Failed to update durable memory ${existing.id}`);

package/src/consolidation-engine.ts

@@ -25,6 +25,7 @@ import { isActiveMemory, parseEvolution, buildSupersedeMetadata, buildConsolidat
 import { cosineSimilarity } from "./multi-vector.js";
 import type { LLMClient } from "./llm-client.js";
 import type { Embedder } from "./embedder.js";
+import { logWarn } from "./stderr-log.js";
 
 // ---------------------------------------------------------------------------
 // Config & Types
@@ -224,8 +225,18 @@ export class ConsolidationEngine {
           full.vector, 10, clusterThreshold, [scope],
         );
 
+        // Seeds are active-only (above), but vectorSearch filters by scope alone, so
+        // superseded belief-history rows surface here too. A rephrased belief sits well
+        // above mergeThreshold from its own archived version, and canonicalScore has no
+        // recency term — importance × access count are both inherited by the history row,
+        // so the two tie and the "weaker" one is picked arbitrarily. Lose that coin flip
+        // and the live belief gets marked consolidated, dropping out of default retrieval
+        // while the abandoned version stands in as canonical.
         const members = similar.filter(
-          s => s.entry.id !== entry.id && !clustered.has(s.entry.id) && s.entry.category === entry.category,
+          s => s.entry.id !== entry.id
+            && !clustered.has(s.entry.id)
+            && s.entry.category === entry.category
+            && isActive(s.entry),
         );
 
         if (members.length === 0) continue;
@@ -354,6 +365,14 @@ export interface ClusterConsolidationResult {
   entriesLinked: number;
   /** CC-9: Set when consecutive low-yield rounds trigger early termination */
   earlyStop?: "diminishing_returns";
+  /**
+   * 本轮被吸收的 LLM 调用失败数（超时 / 网络 / 熔断抛出）。
+   *
+   * 计出来是为了让「吸收」不等于「静默」：吸收前，单个 cluster 撞 15s 超时会把整个
+   * scope 的 dream 炸掉（2026-08-09 memory 轮次连挂两次的根因）；吸收后若不计数，
+   * 「LLM 全程不可用」和「今天没料可炼」会长得一模一样。
+   */
+  llmFailures: number;
 }
 
 /**
@@ -398,6 +417,7 @@ export async function clusterAndConsolidate(params: {
     insightsGenerated: 0,
     patternsExtracted: 0,
     entriesLinked: 0,
+    llmFailures: 0,
   };
 
   // Filter to active entries with vectors
@@ -462,8 +482,26 @@ export async function clusterAndConsolidate(params: {
     }
 
     // Generate insight via LLM from cluster member texts
+    //
+    // 单个 cluster 的 LLM 失败不该炸掉整个 scope。llm-client 的 chat() 在 catch 里是
+    // `throw err`（记完熔断计数后原样抛），所以 15s AbortController 超时会一路冒到
+    // runDream 之外 —— 2026-08-09 memory 轮次连挂两次正是这条路径：memory 是最大
+    // scope、cluster 最多，撞上一次超时的概率接近 1，且两次挂的位置不同（不是某对
+    // 内容有毒，是这一阶段本来就没有防护）。隔壁 llm-consolidation.ts:68 的同类调用
+    // 一直有 try/catch，本处缺的是同一层保护。
+    //
+    // 吸收成 null 而不是新开一条分支：generateL0 返回 null（熔断打开 / 空响应）本来
+    // 就是合法路径，下面 `if (!insight)` 已经按「零产出轮次」处理。失败另计 llmFailures，
+    // 避免吸收变静默。
     const combinedText = cluster.map(m => m.text).join("\n---\n");
-    const insight = await llm.generateL0(combinedText);
+    let insight: string | null;
+    try {
+      insight = await llm.generateL0(combinedText);
+    } catch (err) {
+      result.llmFailures++;
+      logWarn(`[WARN] cluster insight LLM 调用失败，本簇跳过: ${err instanceof Error ? err.message : String(err)}`);
+      insight = null;
+    }
 
     if (!insight) {
       // CC-9: No insight produced — this is a zero-yield round
@@ -536,9 +574,24 @@ export async function clusterAndConsolidate(params: {
 
     // HP-5: Cross-memory pattern extraction
     if (extractPatterns && cluster.length >= 3) {
-      const patternText = await llm.extractPattern(cluster.map(m => m.text));
+      // 同上：pattern 抽取失败也只丢这一簇的 pattern，不连坐已经写好的 insight。
+      let patternText: string | null;
+      try {
+        patternText = await llm.extractPattern(cluster.map(m => m.text));
+      } catch (err) {
+        result.llmFailures++;
+        logWarn(`[WARN] pattern 抽取 LLM 调用失败，本簇跳过: ${err instanceof Error ? err.message : String(err)}`);
+        patternText = null;
+      }
       if (patternText) {
-        const patternImportance = Math.min(maxImportance + 0.1, 1.0);
+        // 与同函数上方的 cluster insight 取同一个值：派生物继承源里最高的 importance，
+        // 不额外加成。原本这里是 maxImportance + 0.1，会让 LLM 抽出的 pattern 比它的
+        // 任何一条源记忆都重要——而 importance >= 0.95 在本仓库里是「人工 pin」的专用
+        // 语义（cli.ts pin 操作把值抬到 0.95；auto-gc 视其为永不归档、decay-engine 视其
+        // 为永不衰减）。于是任何一条源 >= 0.85 的 cluster，其派生 pattern 都会自动跨进
+        // 人类锚点频段。加成想表达的「pattern 比源更有价值」若要保留，应走独立通道
+        // （检索 boost / 独立 tier / 显式 flag），不该占用这个频段。
+        const patternImportance = maxImportance;
         const patternVector = await params.embedder.embedPassage(patternText);
         const patternEntry = await store.store({
           id: deterministicId(scope, `cluster-pattern:${sortedSourceIds.join(",")}`),
@@ -607,6 +660,89 @@ export function formatConsolidationResult(result: ConsolidationResult): string {
 // LC-P2: Cluster-aware deduplication for retrieval results
 // ---------------------------------------------------------------------------
 
+/**
+ * Whether an entry is a consolidation derivative — a cluster insight or a
+ * cross-memory pattern the LLM wrote from other entries, rather than something
+ * captured from the outside world.
+ *
+ * Single source of truth for the two metadata flags: retrieval uses it to
+ * collapse a derivative with its sources, and the dream gather uses it to keep
+ * derivatives from being re-consolidated as if they were raw material.
+ */
+export function isDerivedInsight(metadata: string | undefined): boolean {
+  if (!metadata) return false;
+  try {
+    const meta = JSON.parse(metadata) as Record<string, unknown>;
+    return meta.cluster_insight === true || meta.cross_memory_pattern === true;
+  } catch {
+    return false;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Synthesis uptake (Artel archivist_metrics.synthesis_uptake_rate 的对应物)
+// ---------------------------------------------------------------------------
+
+export interface SynthesisUptakeStats {
+  /** Entries scanned across the store (may be capped). */
+  scanned: number;
+  /** Derived insights found (cluster_insight / cross_memory_pattern). */
+  derivedTotal: number;
+  /** Derived insights with accessCount > 0 — actually read after synthesis. */
+  derivedRead: number;
+  /** derivedRead / derivedTotal; null when no derived insights exist. */
+  uptakeRate: number | null;
+  /** True when the scan hit the cap before exhausting the store. */
+  truncated: boolean;
+}
+
+/**
+ * Measure how many consolidation/dream products were ever read back.
+ * 把"升华产物没人用"从体感变成能报警的数字——uptake 长期为 0 说明
+ * 升华管线在产出无人消费的内容（或读打点断链）。
+ */
+export async function computeSynthesisUptake(
+  store: { listPage(opts: { limit?: number; offset?: number; includeVector?: boolean }): Promise<MemoryEntry[]> },
+  // 50K 覆盖当前 ~34K 生产库全量（2026-07-23 实测 cap 20K 只扫 57%，truncated 结论不完整）；
+  // metadata-only 分页扫描秒级，memory_stats 是低频人工工具，扫全比抽样值钱。
+  scanCap = 50_000,
+  pageSize = 1_000,
+): Promise<SynthesisUptakeStats> {
+  let scanned = 0;
+  let derivedTotal = 0;
+  let derivedRead = 0;
+  let offset = 0;
+  let truncated = false;
+
+  for (;;) {
+    const page = await store.listPage({ limit: pageSize, offset, includeVector: false });
+    if (page.length === 0) break;
+    for (const e of page) {
+      scanned++;
+      if (!isDerivedInsight(e.metadata)) continue;
+      derivedTotal++;
+      try {
+        const meta = JSON.parse(e.metadata || "{}") as Record<string, unknown>;
+        if (typeof meta.accessCount === "number" && meta.accessCount > 0) derivedRead++;
+      } catch { /* broken metadata → counts as unread */ }
+    }
+    offset += page.length;
+    if (page.length < pageSize) break;
+    if (offset >= scanCap) {
+      truncated = true;
+      break;
+    }
+  }
+
+  return {
+    scanned,
+    derivedTotal,
+    derivedRead,
+    uptakeRate: derivedTotal > 0 ? derivedRead / derivedTotal : null,
+    truncated,
+  };
+}
+
 /**
  * LC-P2: When a cluster insight and its source memories both appear in
  * retrieval results, keep only the cluster insight (it subsumes the
@@ -621,15 +757,13 @@ export function deduplicateByClusterInsight<T extends { entry: MemoryEntry; scor
   const coveredByInsight = new Set<string>();
 
   for (const r of results) {
-    if (!r.entry.metadata) continue;
+    if (!isDerivedInsight(r.entry.metadata)) continue;
     try {
-      const meta = JSON.parse(r.entry.metadata);
-      if (meta.cluster_insight === true || meta.cross_memory_pattern === true) {
-        const sources: unknown[] = meta.evolution?.sourceMemories;
-        if (Array.isArray(sources)) {
-          for (const id of sources) {
-            if (typeof id === "string") coveredByInsight.add(id);
-          }
+      const meta = JSON.parse(r.entry.metadata as string);
+      const sources: unknown[] = meta.evolution?.sourceMemories;
+      if (Array.isArray(sources)) {
+        for (const id of sources) {
+          if (typeof id === "string") coveredByInsight.add(id);
         }
       }
     } catch { /* skip unparseable */ }