@modusensus/dsh-mneme 0.12.0 → 0.14.0-beta.1

package/lib/dream/sleep.js

@@ -13,6 +13,9 @@ import { STR, langOf } from "../lang.js";
 //      type=pattern entries carrying evidence id references.
 //   4. relation completion — orphan entities (zero relations) get implied
 //      relations completed from memory co-occurrence.
+//   5. affective attribution (v0.13.0, #619) — opt-in. Occasion-bound emotions
+//      become affective_context relations; only emotions recurring across
+//      enough independent sessions are minted as type=pattern traits.
 // Each phase is wrapped so one failure never aborts the others, and a missing
 // LLM route / semantic embedder only skips the phases that need it. A run is
 // abortable via an AbortController signal (user activity) — phases check the
@@ -20,6 +23,8 @@ import { STR, langOf } from "../lang.js";
 import { randomUUID, createHash } from "node:crypto";
 import { validateDecisions, applyDecisions, ACTIONS } from "./decisions.js";
 import { findPotentialConflicts, cosineSimilarity } from "./clustering.js";
+import { triagePair, recordLedgerTriage } from "./triage.js";
+import { supersedeInfoFirstPair } from "./decisions.js";
 import { scopeKeyOf } from "../scope.js";
 import { buildReceipt, describeStreamFailure, resolveDreamEffort, withEffortFallback, withMaxTokensFallback, maintainIndexAfterDream, fenceListBody, parseFailureMeta } from "../dream.js";
 import { computeHeat } from "../heat.js";
@@ -356,6 +361,11 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
   //   · 只筛同 scope 对：跨 scope 对本来就要停车进人工队列，不能被台账吞掉；
   //   · freeze 模式不筛：那一档只停车不送 LLM，台账与它无关（ledgerSkipped 记 0）；
   //   · ledgerSkipped 在这里一次数清，后面 candidates 直接取 samePairs，不再二次过滤。
+  // ⚠️ Issue #616：这个判据把「未标注」当成「同 scope」。scopeKeyOf 把 NULL/空串
+  // 归一成 null，于是两条都没标注时 null !== null 为 false，配对算同 scope、可以进
+  // 自动池。但「归属未知」和「归属相同」不是一回事：按 v0.8.1 #170，前者本该是不可
+  // 自动的范围。live 库活跃 8259 行里 2710 行（32.8%）两个 scope 全 NULL，受影响的
+  // 面不小。修法是把「任一未标注」显式判为不可自动，而不是继续让 null 自我相等。
   const isCrossScopePair = (p) =>
     scopeKeyOf(p.a.agent_scope) !== scopeKeyOf(p.b.agent_scope)
     || scopeKeyOf(p.a.workspace_scope) !== scopeKeyOf(p.b.workspace_scope);
@@ -368,7 +378,18 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
     if (!rec?.judged_at) return false;
     return (p.a.updated_at ?? "") <= rec.judged_at && (p.b.updated_at ?? "") <= rec.judged_at;
   };
-  const selectionPairs = config.conflictFreezeEnabled === true
+  // Issue #641（beta 第二阶段）：分诊账本的档位。#616 点名的父子绑定不继承——
+  // enforce 与 freeze 同开时 freeze 让位（本相位降级 shadow + warn）：freeze 照常
+  // 停车（shadow 语义 = 只记账零处置），绝不出现两套处置语义同时生效。宁可少处置，
+  // 不在打架的配置下跑。
+  let ledgerMode = config.conflictLedgerMode ?? "off";
+  if (ledgerMode === "enforce" && config.conflictFreezeEnabled === true) {
+    logger?.warn?.("dsh-mneme sleep: conflictLedgerMode=enforce coexists with conflictFreezeEnabled — degrading to shadow; disable one of them");
+    ledgerMode = "shadow";
+  }
+  // alreadyJudged 预筛只为省 LLM：freeze 与 enforce 都不走 LLM，筛不筛不影响成本，
+  // 不筛还能让 T2/T3/T4 的每轮观察持续刷新账本（tier 可能随内容更新而变）。
+  const selectionPairs = config.conflictFreezeEnabled === true || ledgerMode === "enforce"
     ? fresh
     : fresh.filter((p) => isCrossScopePair(p) || !alreadyJudged(p));
   const ledgerSkipped = fresh.length - selectionPairs.length;
@@ -382,6 +403,115 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
     selected.push(p);
   }
 
+  // Issue #641（beta 第一阶段，shadow 档）：分诊账本。对 selected 全量做确定性
+  // 分诊（dup / cross-scope-dup / evolution / conflict，判据唯一实现见 triage.js）
+  // 并落 conflict_ledger。shadow = 只记账零处置：下面 freeze/LLM 路径一个字节都
+  // 不变——shadow 的存在意义就是让「分诊分布是否复现真实库 46/20/5/27」在真实
+  // 运行里可测，作为切 enforce 前的预注册证据。记账失败只 warn 计数，绝不反噬
+  // 相位（与 conflict_reviewed 同一条 best-effort 纪律）。
+  // 记账时点在 used 去重之后：被去重压掉的那半边对（同一条记忆配给了更高相似的
+  // 对手）本来就不是这一轮的候选，观察它们只会让分母虚高。
+  const ledgerTriage = ledgerMode !== "off"
+    ? await recordLedgerTriage(service, runId, selected, {
+        dupMinSimilarity: config.conflictLedgerDupMinSimilarity,
+        logger,
+        // 分块记账的取消检查：用户活动打断时停止记账，余下的对下一轮重见
+        signal
+      })
+    : null;
+
+  // Issue #641（beta 第二阶段，enforce 档）：确定性处置接线。T1（dup）走
+  // supersedeInfoFirstPair（与冻结分支自动档同一条契约，decisions.js 共享实现）；
+  // T1 走信息量优先 supersede、T3 走取代链（superseded_by 指向，不归档）、
+  // T2/T4 记账即处置——不停车、不送 LLM。人审队列与 LLM 裁决在本档下都不再
+  // 消费冲突候选，conflict_pending 恒空。每轮上限沿用
+  // sleepConflictMaxPairsPerRun：处置虽不走 LLM，归档/落链仍是写动作，写预算
+  // 与 freeze/auto 两档同口径。T4 的检索时消解（fuseRecall 矛盾感知 + 注入
+  // 标注）是后续 PR，本档先把人审摘出去。
+  if (ledgerMode === "enforce") {
+    const perRunCap = config.sleepConflictMaxPairsPerRun ?? 60;
+    const pool = perRunCap > 0 ? selected.slice(0, perRunCap) : selected;
+    let t1Resolved = 0;
+    let t1Failed = 0;
+    let t3Chained = 0;
+    const t1VectorFixups = [];
+    for (const p of pool) {
+      const verdict = triagePair(p.a, p.b, p.similarity, { dupMinSimilarity: config.conflictLedgerDupMinSimilarity });
+      if (verdict.tier === "evolution") {
+        // T3 取代链（beta 第三阶段）：旧行 superseded_by → 新行，检索降权，
+        // **不归档**——演进不是输赢，旧值仍是「曾经为真」的可追溯历史（与
+        // supersede 动作的归档语义不同）。新者胜对演进成立：间隔 ≥7 天的
+        // 同主题对，新记载才反映现状（服务器时钟，内容声称的时间不做键）。
+        const newer = (p.a.created_at ?? "") >= (p.b.created_at ?? "") ? p.a : p.b;
+        const older = newer === p.a ? p.b : p.a;
+        try {
+          if (service.supersedeChain(older.id, newer.id)) {
+            t3Chained += 1;
+            // 先落观察行再推进状态（#650 评审）：enforce 档下 recordLedgerTriage 只会
+            // 把这一对写成 open，UPDATE 于此才有行可命中；顺序反了就是静默落空。
+            service.saveConflictLedgerEntry({ run_id: runId, memory_a: p.a.id, memory_b: p.b.id, tier: verdict.tier, similarity: p.similarity, signals: verdict.signals });
+            service.setConflictLedgerStatus(p.a.id, p.b.id, "superseded");
+          }
+        } catch (error) {
+          logger?.warn?.(`dsh-mneme sleep: ledger T3 chain failed for ${p.a.id}/${p.b.id}: ${String(error)}`);
+        }
+        continue;
+      }
+      if (verdict.tier !== "dup") continue;
+      let res = null;
+      try {
+        res = supersedeInfoFirstPair(p, service, logger, config);
+      } catch (error) {
+        logger?.warn?.(`dsh-mneme sleep: ledger T1 supersede failed for ${p.a.id}/${p.b.id}: ${String(error)}`);
+      }
+      if (res?.applied) {
+        t1Resolved += 1;
+        // winner/loser 用 helper 判定的真实方向（信息量优先可能翻转 p.a/p.b）
+        t1VectorFixups.push({ action: "supersede", winner: res.winnerId, loser: res.loserId });
+        try {
+          // 账本状态推进 + 机器台账照记（与自动档同款 outcome 口径）——自动处置
+          // 也要能事后回答「这一对什么时候、被谁判的」。先落观察行（#650 评审）：
+          // 这一对未必已在账本里，直接 UPDATE 会命中 0 行而静默失记。
+          service.saveConflictLedgerEntry({ run_id: runId, memory_a: p.a.id, memory_b: p.b.id, tier: verdict.tier, similarity: p.similarity, signals: verdict.signals });
+          service.setConflictLedgerStatus(p.a.id, p.b.id, "superseded");
+          service.saveConflictReviewed?.({ run_id: runId, memory_a: p.a.id, memory_b: p.b.id, outcome: "supersede", judged_at: new Date().toISOString() });
+        } catch (error) {
+          logger?.warn?.(`dsh-mneme sleep: ledger bookkeeping after T1 supersede failed for ${p.a.id}/${p.b.id}: ${String(error)}`);
+        }
+      } else {
+        t1Failed += 1;
+      }
+    }
+    // 败者向量清理：T1 的 supersede 不在下面 LLM 通路的 maintainIndexAfterDream
+    // 清单里（enforce 已早退），必须在早退前自己清——已归档行留向量等于检索
+    // 层「看得见摸不着」。
+    if (t1VectorFixups.length > 0 && semantic?.embedder && semantic?.vectorIndex) {
+      try {
+        await maintainIndexAfterDream(t1VectorFixups, service, semantic);
+      } catch (error) {
+        logger?.warn?.(`dsh-mneme sleep: ledger T1 index maintenance failed: ${String(error)}`);
+      }
+    }
+    if (selected.length > pool.length) {
+      logger?.warn?.(`dsh-mneme sleep: conflict ledger enforce capped at ${pool.length}/${selected.length} pairs this run`);
+    }
+    return {
+      status: t1Failed > 0 ? "degraded" : t1Resolved > 0 || t3Chained > 0 ? "ok" : "noop",
+      clean: t1Failed === 0,
+      frozen: 0,
+      scopeCandidates: 0,
+      pairs: selected.length,
+      batches: 0,
+      ledgerSkipped,
+      // applied 是整轮回执的唯一写库口径（runSleep 的 totalApplied 只认这个键）。
+      // 缺了它，本档真实发生的 T1 归档与 T3 落链在 receipt / dream_runs.applied
+      // 里全是 0 ——「本相位说改了、整轮说没改」（#650 评审，#619 同族）。
+      applied: t1Resolved + t3Chained,
+      enforced: { t1Resolved, t1Failed, t3Chained },
+      ...(ledgerTriage ? { ledgerTriage } : {})
+    };
+  }
+
   // v0.8.1（issue #170 第 2 步）：跨 scope 相似对分流。同一内容落在两个归属下
   // （任一维标注键不等即算，NULL=未标注=全局也参与比较——「全局副本 + 专属副本
   // 并存」正是收窄/提升裁决的典型候选）不能自动裁决：归档败者可能销毁该内容在
@@ -389,33 +519,203 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
   // （专属 reason），同 scope 对维持既有路径（freeze 停车 / LLM 裁决）。
   const crossPairs = selected.filter(isCrossScopePair);
   const samePairs = selected.filter((p) => !isCrossScopePair(p));
+  // 四态：fresh（真的新插了一行）/ existing（这一对已在队列里）/ suppressed
+  // （已人工裁决且两侧未变，复核项 4）/ failed（写库抛错）。旧代码把
+  // 「返回非 null」一律当停车成功，existing 因此每轮虚报一遍 frozen（#603）。
   const parkPair = (p, reason) => {
     try {
-      // 返回 undefined = 该对已被人工裁决且两侧内容未变（复核项 4）——不算停车。
-      return service.saveConflictPending({ run_id: runId, memory_a: p.a.id, memory_b: p.b.id, reason }) != null;
+      const parked = service.saveConflictPending({ run_id: runId, memory_a: p.a.id, memory_b: p.b.id, reason, similarity: p.similarity });
+      if (parked == null) return "suppressed";
+      return parked.fresh === true ? "fresh" : "existing";
     } catch (error) {
       logger?.warn?.(`dsh-mneme sleep: failed to park conflict ${p.a.id}/${p.b.id}: ${String(error)}`);
-      return false;
+      return "failed";
     }
   };
   const scopeReason = (p) => STR.scopeCandidateReason[language](p.similarity.toFixed(2));
   const simReason = (p) => STR.similarityReason[language](p.similarity.toFixed(2));
 
+  // 待审对的键集合（与 pairKey 同形）。只用于 freeze 分支的「先滤已入队」，
+  // 分页拉全量：队列规模不受 50 条默认页长限制。
+  const loadPendingPairKeys = () => {
+    const keys = new Set();
+    if (typeof service.listConflictPending !== "function") return keys;
+    const pageSize = 500;
+    for (let offset = 0; ; offset += pageSize) {
+      const page = service.listConflictPending({ limit: pageSize, offset, includeResolved: false }) ?? [];
+      for (const row of page) keys.add(`${row.memory_a}\u0000${row.memory_b}`);
+      if (page.length < pageSize) break;
+    }
+    return keys;
+  };
+
   // Freeze mode: park pairs for manual review, no LLM required. Cross-scope
   // pairs carry the dedicated scope-candidate reason so the queue reads them
   // as ownership decisions rather than plain duplicates.
+  //
+  // Issue #603 第 1 层：这条分支此前绕过全部三个上限、直接裸跑 selected。
+  //   · 先滤已入队再截断——裸 slice 会饥饿：上限恒小于候选数时，前 N 个名额
+  //     每轮都被同一批已在队列里的对占住，后面的对永远轮不上；
+  //   · 接预算：conflictFreezeMaxPending 决定队列还能装多少，
+  //     sleepConflictMaxPairsPerRun 决定一轮最多处理多少，取两者较小值；
+  //   · 只把 fresh 计入 frozen，已入队的对不再虚报。
+  //
+  // ⚠️ Issue #616：下面这段 freeze 分支同时也是「自动裁决档」的唯一宿主——
+  // conflictAutoResolveEnabled 的全部逻辑（autoEnabled / autoPool / autoResolved）
+  // 都在这对花括号里面。两个配置键在面板上看是平行的，实际是父子：把 freeze
+  // 关掉，自动档会跟着静默消失，没有任何提示。拆开之前别把它们当独立开关用。
   if (config.conflictFreezeEnabled === true) {
+    const maxPending = Number.isInteger(config.conflictFreezeMaxPending) ? config.conflictFreezeMaxPending : 100;
+    const pendingNow = typeof service.countConflictPending === "function" ? (service.countConflictPending() ?? 0) : 0;
+    const room = Math.max(0, maxPending - pendingNow);
+    const pendingKeys = loadPendingPairKeys();
+    const unparked = selected.filter((p) => !pendingKeys.has(pairKey(p)));
+    const withinRoom = room > 0 ? unparked.slice(0, room) : [];
+    const pendingSkipped = unparked.length - withinRoom.length;
+    const perRunCap = config.sleepConflictMaxPairsPerRun ?? 60;
+    const pool = perRunCap > 0 ? withinRoom.slice(0, perRunCap) : withinRoom;
+    // 只报「有位置但被每轮上限截住」的那部分：队列满时再追一轮也没用，
+    // 报成 backlog 会让调度器空转（catchup 上限 24 轮）。
+    const perRunSkipped = withinRoom.length - pool.length;
+    // Issue #603 第 4 层（自动裁决档，默认关）：相似度极高的**同 scope** 对不再
+    // 进人工队列，直接保留信息量更大的那条、归档另一条。人只看模糊地带。
+    //
+    // 为什么阈值留在配置里而不是写死 0.95：这一档减的是峰值，
+    // 不是把队列清零——把阈值当常量会让人以为「开了就没事了」。
+    //
+    // 为什么跨 scope 永不自动：归属是用户的决定（v0.8.1 #170），归档败者可能
+    // 销毁某归属下的唯一副本。这条约束比减负重要。
+    //
+    // ⚠️ Issue #616：这条守卫有一个洞。isCrossScopePair 走 scopeKeyOf，NULL 归一
+    // 成 null，null !== null 判为 false —— 「未标注」因此被当成「同 scope」混进
+    // autoPool。live 库活跃 8259 行里 2710 行（32.8%）两个 scope 全 NULL。改判据
+    // 之前，别把这一档当成「归属安全」。
+    //
+    // 为什么用 supersede 而不是 conflict：conflict 会把「（已否决旧信息：…）」
+    // 追加到**赢家**正文，而赢家正是留下来的那条；近重复对再叠一段互相引用的
+    // 注记，等于用冗余污染幸存记忆。supersede 把可追溯性留在被归档的一侧，
+    // 赢家正文一字不动（#126 的原设计）。
+    const autoEnabled = config.conflictAutoResolveEnabled === true;
+    const autoMin = typeof config.conflictAutoResolveMinSimilarity === "number"
+      ? config.conflictAutoResolveMinSimilarity
+      : 0.95;
+    const autoPool = [];
+    const parkPool = [];
+    for (const p of pool) {
+      const eligible = autoEnabled
+        && !isCrossScopePair(p)
+        && typeof p.similarity === "number"
+        && p.similarity >= autoMin;
+      (eligible ? autoPool : parkPool).push(p);
+    }
+    let autoResolved = 0;
+    let autoFailed = 0;
+    // 这一档不走 LLM，没有批次时间戳可借（judgedAt 在下面那条 LLM 通路里才定义），
+    // 自己取一个：台账要能回答「什么时候判的」，不能留空。
+    const autoJudgedAt = new Date().toISOString();
+    // 保留**信息量更大**的那条，不是更新的那条。
+    //
+    // 「保留新的」看着合理，实测是错的：live 库 >=0.95 的 20 对里，11 对（55%）
+    // 新的那条比旧的短，平均短 132 字；降到 0.88 的 213 对里 122 对（57%）如此。
+    // 典型例子：「用户同时开 web profile 和 desktop profile 时出现开不了新对话/
+    // 会话异常，用户自己…」（371 字，旧）被压成「用户同时开 web profile 和
+    // desktop profile 的 dsh-mneme 时开不了新对话」（307 字，新）——蒸馏时压缩过
+    // 的一版反而更新。留新条等于把更完整的那条归档掉。
+    //
+    // 这与 mem0 的裁决规则一致：`configs/prompts.py:217` 明写「两句话说的是同一
+    // 件事时，留信息量最大的那条，不是留最新的」。cognee 反过来（「取更新的」），
+    // 那是反例——照抄会把「0:00 前必须躺下」削成残缺版。
+    //
+    // 长度相同才算「信息量相当」，此时退回更新时间，再退回 id：三级兜底保证同一
+    // 对每次判出同一个赢家（否则重放会来回翻，归档的可能是刚保住的那条）。
+    const infoFirst = (p) => {
+      const an = p.a.content?.length ?? 0;
+      const bn = p.b.content?.length ?? 0;
+      if (an !== bn) return an > bn ? [p.a, p.b] : [p.b, p.a];
+      const au = p.a.updated_at ?? "";
+      const bu = p.b.updated_at ?? "";
+      if (au !== bu) return au > bu ? [p.a, p.b] : [p.b, p.a];
+      return p.a.id > p.b.id ? [p.a, p.b] : [p.b, p.a];
+    };
+    for (const p of autoPool) {
+      const [winner, loser] = infoFirst(p);
+      const snapshot = new Map();
+      for (const m of [winner, loser]) {
+        snapshot.set(m.id, { updated_at: m.updated_at, content: m.content, title: m.title });
+      }
+      // trustEpistemicWeighting 显式关掉：它会在 applySupersede 里按 epistemic_status
+      // 交换赢家，那会让「留信息量更大的那条」这条契约随数据漂移。自动档的承诺
+      // 必须是确定的。
+      const { applied, conflicts } = applyDecisions(
+        [{ action: "supersede", winner: winner.id, loser: loser.id }],
+        service, logger, snapshot, { ...config, trustEpistemicWeighting: false }
+      );
+      if (applied > 0) {
+        autoResolved++;
+        // 记进机器侧台账：自动动作也要能事后回答「这一对什么时候、被谁判的」。
+        try {
+          service.saveConflictReviewed?.({
+            run_id: runId, memory_a: p.a.id, memory_b: p.b.id,
+            outcome: "supersede", judged_at: autoJudgedAt
+          });
+        } catch (error) {
+          logger?.warn?.(`dsh-mneme sleep: failed to record auto-resolved pair ${p.a.id}/${p.b.id}: ${String(error)}`);
+        }
+        continue;
+      }
+      // 自动档没落地 → 退回人工队列。绝不因为「本来想自动处理」就把这一对丢掉，
+      // 那才是真正的静默丢失。两种没落地的原因都要说清楚：
+      //   · CAS 冲突（applyDecisions 记在 conflicts 里）——两侧在快照之后被改过，
+      //     自动判的赢家可能已经不是该保的那条，人看一眼最稳；
+      //   · 其余异常（记在 failures 里）——写库失败之类，重试无意义就交给人。
+      autoFailed++;
+      logger?.warn?.(
+        `dsh-mneme sleep: auto-resolve skipped ${p.a.id}/${p.b.id}`
+        + (conflicts.length ? ` (concurrent edit)` : "")
+        + `, falling back to manual review`
+      );
+      parkPool.push(p);
+    }
     let frozen = 0;
-    for (const p of selected) {
-      if (parkPair(p, isCrossScopePair(p) ? scopeReason(p) : simReason(p))) frozen++;
+    let parkFailed = 0;
+    for (const p of parkPool) {
+      const outcome = parkPair(p, isCrossScopePair(p) ? scopeReason(p) : simReason(p));
+      if (outcome === "fresh") frozen++;
+      else if (outcome === "failed") parkFailed++;
     }
-    return { status: frozen > 0 ? "ok" : "noop", frozen, scopeCandidates: crossPairs.length, pairs: selected.length };
+    if (pendingSkipped > 0) {
+      logger?.warn?.(`dsh-mneme sleep: conflict freeze queue full (${pendingNow}/${maxPending}), skipped ${pendingSkipped} conflict(s)`);
+    }
+    return {
+      status: frozen > 0 || autoResolved > 0 ? "ok" : "noop",
+      frozen,
+      // 自动裁决掉的不进队列，但确实是这一轮干的活——分开报，别混进 frozen
+      // （frozen 的语义是「给人工队列新增了几行」，混进去面板就会虚高）。
+      // Issue #616：这两个字段目前**没有消费者**。dream.js 的两处 return 只透出
+      // frozen，面板也不读它们；conflict_reviewed 台账同样没有 API 暴露，且 schema
+      // 不记赢家（memory_a/b 是排序过的）。也就是说自动裁决干了什么，事后只能翻
+      // loser 正文的「（已被取代：…）」后缀反推。补可见性之前，别指望从报告里看出
+      // 这一档跑了几对。
+      autoResolved,
+      autoFailed,
+      // 写库抛错的对既没入队也不算落地：clean=false，别让调度器当「追完了」。
+      clean: parkFailed === 0,
+      scopeCandidates: crossPairs.length,
+      pairs: selected.length,
+      batches: 0,
+      ledgerSkipped,
+      perRunSkipped,
+      pendingSkipped,
+      // #641 shadow：分诊分布随相位结果透出（dream phases 与审计行都能看到），
+      // 面板消费在 beta 第二批接。
+      ...(ledgerTriage ? { ledgerTriage } : {})
+    };
   }
 
   // 非 freeze：跨 scope 对先停车（绝不进 LLM 裁决），同 scope 对照常走 LLM。
   let scopeParked = 0;
   for (const p of crossPairs) {
-    if (parkPair(p, scopeReason(p))) scopeParked++;
+    if (parkPair(p, scopeReason(p)) === "fresh") scopeParked++;
   }
   if (samePairs.length === 0) {
     // 没有可送 LLM 的同 scope 对：可能一对都没检测到，也可能全被台账挡下了
@@ -426,13 +726,14 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
       scopeCandidates: scopeParked,
       pairs: selected.length,
       batches: 0,
-      ledgerSkipped
+      ledgerSkipped,
+      ...(ledgerTriage ? { ledgerTriage } : {})
     };
   }
 
   // LLM adjudication（仅同 scope 对）。
   const route = resolveSleepRoute(ctx, config, logger);
-  if (!route) return { status: "skipped", reason: "no llm route", scopeCandidates: scopeParked, pairs: selected.length, batches: 0, ledgerSkipped };
+  if (!route) return { status: "skipped", reason: "no llm route", scopeCandidates: scopeParked, pairs: selected.length, batches: 0, ledgerSkipped, ...(ledgerTriage ? { ledgerTriage } : {}) };
   // 每轮总上限：分批解决的是单请求撞墙，不是"一个 449 对的池子该在一轮里跑完"。
   // 没进这一轮的对留在下一轮（它们既没被丢弃，也不在台账里）。
   const perRunCap = config.sleepConflictMaxPairsPerRun ?? 60;
@@ -443,6 +744,12 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
   // actionSet 已在候选构造前解析（跨类型候选需要它），这里只按档位选 prompt：
   // 默认档保持只有 conflict/keep 的窄 prompt，"full" 才开放六分支。
   const conflictPrompt = actionSet === "full" ? STR.prompts.conflictFull[language] : STR.prompts.conflict[language];
+  // reflectionUpdateEnabled=false：两份 conflict prompt 都教了模型怎么用 update
+  // （「信息部分过时 → update」那一支），只靠校验器拒会把每轮这份输出白付掉。
+  // 后缀与 dream 主链路共用同一条文案，两个入口对用户是同一个开关、同一种说法。
+  const conflictPromptGated = config.reflectionUpdateEnabled !== false
+    ? conflictPrompt
+    : conflictPrompt + STR.prompts.noUpdateSuffix[language];
   const runConflict = (batch, withEffort, tokens) => {
     conflictStreamFailure = "";
     const listText = batch.map((p) => STR.candidateConflicts[language](p)).join("\n\n");
@@ -470,7 +777,7 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
     maxTokens: tokens,
     ...(withEffort && sleepEffort ? { reasoningEffort: sleepEffort } : {}),
     messages: [
-      { role: "system", content: [{ type: "text", text: conflictPrompt }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } },
+      { role: "system", content: [{ type: "text", text: conflictPromptGated }], 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); }));
@@ -534,6 +841,8 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
       // Issue #536 review（CodeRabbit ②）：reflectionUpdateMaxPerRun 是**整轮**上限，
       // 分批后不能每批都拿整份额度——那样 N 批就是 N 倍上限。这里用的是本轮的剩余额度。
       maxUpdatePerRun: updateBudget,
+      // reflectionUpdateEnabled=false：update 单条跳过（同 dream 主链路口径）。
+      allowUpdate: config.reflectionUpdateEnabled !== false,
       minAgeHours: config.reflectionUpdateMinAgeHours,
       skipInvalid: config.dreamSkipInvalid !== false,
       allowCrossTypeMerge: config.allowCrossTypeMerge === true,
@@ -724,7 +1033,10 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
     conflicts,
     // Issue #126：#104 同向——被跳过的逐对明细要进审计行，否则事后无法判断
     // 是哪一对、因何被跳过（此前只进 logger.warn，splice 后就地消失）。
-    skipped
+    skipped,
+    // #641 shadow：分诊分布随相位结果透出（四个出口都要带——freeze/空池/无路由/
+    // LLM 全路径，缺一个出口 shadow 期就有部分轮次查不到分布）。
+    ...(ledgerTriage ? { ledgerTriage } : {})
   };
 }
 
@@ -740,6 +1052,9 @@ function phaseDemotion(service, config, logger, runId, signal = null) {
   const compressCut = Date.now() - compressDays * 86400000;
   const demoted = [];
   const archived = [];
+  // 被判定为「该降级」但 demoteToSummary 实际没动手的条数。单独报出来：
+  // 它正是「台账说降级了 N 条、实际一条没变」那个缺口，藏起来就等于没修。
+  let demoteSkipped = 0;
   // 政策轴在这里尤其要紧：下面两行会真改归档面（setArchived / demoteToSummary）。
   // 把过滤放在循环之外、而不是在循环体里 continue：一旦将来有人在循环体里加
   // 副作用（现已有），漏掉那条 continue 就是静默改到被按下的行。
@@ -749,6 +1064,10 @@ function phaseDemotion(service, config, logger, runId, signal = null) {
   for (const m of withoutPaused(service, service.all().filter((m) => !isImportedRow(m)))) {
     if (signal?.aborted) break;
     if (m.archived || m.forgotten) continue;
+    // 已降级的行不必再进判定链：demoteToSummary 见到 _full_content 会直接返回，
+    // 但这行每轮仍会被选中、空转一次事务，再被下面无条件 push 进 demoted。
+    // 提前挡掉既省事务，也让「这一轮到底动了什么」从源头算得准（#603 台账）。
+    if (m._full_content) continue;
     const ref = m.last_accessed_at ?? m.created_at;
     if (!ref) continue;
     const t = new Date(ref).getTime();
@@ -771,14 +1090,20 @@ function phaseDemotion(service, config, logger, runId, signal = null) {
     } else if (t < archiveCut) {
       // minRefTimeMs re-checks freshness inside demoteToSummary's transaction:
       // a recall touch landing after this snapshot must not demote the memory.
-      service.demoteToSummary(m.id, makeSummary(m), { minRefTimeMs: archiveCut });
-      demoted.push(m.id);
+      //
+      // 返回值必须看：demoteToSummary 在三种情况下返回 undefined（行不存在、
+      // 已降级、快照后被 recall 摸热），而这里原来无条件 push，于是台账把没发生
+      // 的降级记成发生了——live 库实测 12 轮里虚报 43%–99%（#603）。
+      const updated = service.demoteToSummary(m.id, makeSummary(m), { minRefTimeMs: archiveCut });
+      if (updated) demoted.push(m.id);
+      else demoteSkipped++;
     }
   }
   return {
     status: demoted.length || archived.length ? "ok" : "noop",
     demoted,
-    archived
+    archived,
+    demoteSkipped
   };
 }
 
@@ -883,18 +1208,402 @@ async function phasePatterns(ctx, service, config, logger, runId, signal = null)
   // applyDecisions 的 @param config。
   // #512：runId 也必须给——这是 sleep 唯一的真实铸造路径，漏了它，铸造出来的
   // pattern 就只能追到「sleep 这条管道」，追不到「哪一轮 sleep」（正是 #512 要补的口子）。
-  const { applied, failures, conflicts } = applyDecisions(
+  const { applied, merged, failures, conflicts } = applyDecisions(
     decisions, service, logger, snapshot, { ...config, mintSource: "sleep", runId }
   );
   return {
-    status: applied > 0 ? "ok" : "noop",
+    // A pattern that hit an existing same-title row is refreshed in place, not
+    // minted. Counting it as `ok` with `applied: 0` claims a mint that did not
+    // happen; report the refresh separately (#619 audit round 6).
+    status: applied > 0 ? "ok" : (merged > 0 ? "refreshed" : "noop"),
     scanned: memories.length,
     applied,
+    merged,
     failures,
     conflicts
   };
 }
 
+/**
+ * Phase 5 — affective attribution (issue #619). The LLM reads recent memories and
+ * names emotions, but the shape of what it may write is fixed here, not by the
+ * prompt: an emotion tied to **one occasion** becomes an `affective_context`
+ * relation carrying the attribution on the edge; only an emotion that recurs
+ * across sleepAffectiveTraitMinSessions **independent sessions** may be minted as
+ * a standing trait (a type=pattern memory, through the same
+ * validateDecisions/applyDecisions channel every other mint uses).
+ *
+ * The whole point is the guardrail, so it lives in code and not in the prompt:
+ *  - the model may *claim* trait, but the claim only survives if provenance shows
+ *    enough distinct sessions. A single session is downgraded to occasion, never
+ *    dropped silently — dropped claims are counted and reported.
+ *  - person/target must resolve to entities that already exist; an emotion about
+ *    an unknown name is not evidence, it is a hallucination.
+ *  - evidence ids must be inside the scanned pool (same rule phasePatterns uses).
+ * Off by default (sleepAffectiveEnabled) and a child of sleepModeEnabled: no
+ * route, no entities, or the flag off all mean "skip", never "run anyway".
+ */
+async function phaseAffective(ctx, service, config, logger, runId, signal = null) {
+  if (config.sleepAffectiveEnabled !== true) return { status: "skipped", reason: "disabled" };
+  const route = resolveSleepRoute(ctx, config, logger);
+  if (!route) return { status: "skipped", reason: "no llm route" };
+  const entities = service.listEntities({ limit: 1000 }) ?? [];
+  if (entities.length < 2) return { status: "skipped", reason: "too few entities" };
+  const limit = config.sleepPatternMinMemories ?? 100;
+  const poolQuery = {
+    limit: Math.max(200, limit),
+    includeForgotten: false,
+    excludeTypes: ["document", "summary", "pattern"],
+    excludeImported: true
+  };
+  const gather = (query) => withoutPaused(service, service.list(query));
+  let pool = gather(poolQuery);
+  if (pool.length < limit) pool = gather({ ...poolQuery, limit: null });
+  const memories = [...pool].sort((a, b) => String(b.updated_at).localeCompare(String(a.updated_at))).slice(0, limit);
+  if (memories.length === 0) return { status: "skipped", reason: "no memories" };
+  const scannedIds = new Set(memories.map((m) => m.id));
+  const byName = new Map();
+  for (const e of entities) byName.set(e.name.toLowerCase(), e);
+  const traitMinSessions = config.sleepAffectiveTraitMinSessions ?? 3;
+  const maxRelations = config.sleepAffectiveMaxRelationsPerRun ?? 10;
+  const maxTraits = config.sleepMaxPatternPerRun ?? 3;
+  const language = langOf(config).startsWith("zh") ? "zh" : "en";
+  const entityNames = entities.map((e) => e.name).slice(0, 200).join(", ");
+  const listText = memories.map((m) => `id=${m.id} | time=${m.updated_at ?? ""} | type=${m.type} | title=${m.title} | content=${m.content}`).join("\n");
+  let streamFailure;
+  const runAffective = (tokens) => auditedSleepLlm(
+    ctx, service, config, logger,
+    {
+      triggerSource: "sleep",
+      operationType: "sleep_affective",
+      modelId: `${route.provider}:${route.model}`,
+      relatedMemoryIds: memories.map((m) => m.id),
+      streamError: () => streamFailure,
+      auditError: (out) => (parseJsonArray(out) ? null : "no json array in llm output"),
+      metadataFrom: (out) => (parseJsonArray(out) ? null : parseFailureMeta(out))
+    },
+    (reportUsage) => streamText(ctx, {
+      provider: route.provider,
+      model: route.model,
+      purpose: "sleep-affective",
+      maxTokens: tokens,
+      messages: [
+        {
+          role: "system",
+          content: [{ type: "text", text: STR.prompts.affective[language].replaceAll("{{MIN_SESSIONS}}", String(traitMinSessions)) }],
+          source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" }
+        },
+        { role: "user", content: [{ type: "text", text: fenceListBody(language, `${entityNames}\n---\n${listText}`) }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } }
+      ]
+    }, reportUsage, (reason) => { streamFailure = describeStreamFailure(reason); })
+  );
+  const text = await withMaxTokensFallback(ctx, config.sleepMaxTokens ?? 2048, runAffective, () => streamFailure);
+  if (text === undefined) {
+    // #619 可见化 A：失败原因不能只写成 "llm failed"。conflict 相位
+    // （src/dream/sleep.js 的 adjudicateBatch 调用处）早就把 stream 层的原文写进
+    // warn 并挂在返回值的 `failure` 上，理由写在它旁边的注释里：只写 "llm failed"
+    // 的话，运维分不清是上下文超限、模型拒收还是用户活动打断。affective 相位漏了
+    // 这一步，实测 2026-11-10T16:09 那一轮审计行只有 {"status":"failed",
+    // "error":"llm failed"}，502 原文只能去 llm_audit_logs 里捞。
+    // 相位自身不重试 5xx（withMaxTokensFallback 只处理 max_tokens 被拒、
+    // withEffortFallback 只处理 effort 被拒），所以这里记的就是一次性失败的真因。
+    if (streamFailure) logger?.warn?.(`dsh-mneme sleep: affective stream aborted or errored (${streamFailure})`);
+    return { status: "failed", error: "llm failed", failure: streamFailure || undefined };
+  }
+  const items = parseJsonArray(text) ?? [];
+  if (items.length === 0) return { status: "skipped", reason: "no attributions found" };
+  const relations = [];
+  const merges = [];
+  const traits = [];
+  const dropped = [];
+  let downgradedCount = 0;
+  const sessionCache = new Map();
+  const sessionsFor = (memoryIds) => {
+    const out = new Set();
+    for (const id of memoryIds) {
+      if (!sessionCache.has(id)) {
+        let rows = [];
+        try {
+          rows = service.provenanceFor?.(id) ?? [];
+        } catch {
+          rows = [];
+        }
+        sessionCache.set(id, rows.map((r) => r.session_id).filter((s) => typeof s === "string" && s));
+      }
+      for (const s of sessionCache.get(id)) out.add(s);
+    }
+    return out;
+  };
+  for (const item of items) {
+    if (signal?.aborted) break;
+    if (!item || typeof item !== "object") continue;
+    const person = byName.get(String(item.person ?? "").toLowerCase());
+    const target = byName.get(String(item.target ?? "").toLowerCase());
+    if (!person || !target || person.id === target.id) {
+      dropped.push({ reason: "unknown entity", person: item.person, target: item.target });
+      continue;
+    }
+    const evidence = (Array.isArray(item.evidence) ? item.evidence : []).filter((id) => scannedIds.has(id));
+    if (evidence.length === 0) {
+      dropped.push({ reason: "no real evidence", person: item.person, target: item.target });
+      continue;
+    }
+    const emotion = String(item.emotion ?? "").trim();
+    if (!emotion) {
+      dropped.push({ reason: "no emotion", person: item.person, target: item.target });
+      continue;
+    }
+    // The guardrail: a claimed trait is checked against provenance, and a claim
+    // that does not survive is demoted — not discarded. Demoted claims are the
+    // interesting number: they are exactly the mis-attributions the probe hunts.
+    const claimedTrait = String(item.attribution ?? "").toLowerCase() === "trait";
+    const sessions = sessionsFor(evidence);
+    const downgraded = claimedTrait && sessions.size < traitMinSessions;
+    const attribution = claimedTrait && !downgraded ? "trait" : "occasion";
+    const record = {
+      person: person.name,
+      target: target.name,
+      emotion,
+      attribution,
+      evidence,
+      sessionCount: sessions.size,
+      why: String(item.why ?? "").slice(0, 200),
+      ...(downgraded ? { downgradedFrom: "trait" } : {})
+    };
+    if (downgraded) downgradedCount += 1;
+    if (attribution === "trait") {
+      traits.push(record);
+      continue;
+    }
+    // #619 / Ephor: entity_relations 没有 UNIQUE 约束，saveRelation 每次
+    // randomUUID() 新插一条。同一个 (person, target, 场合) 跑第二轮就会得到
+    // 第二条一模一样的边——而探针会拿同一批段反复回放，重复边会让 sessionCount
+    // 看起来比真实场合数多，主指标直接失真。
+    //
+    // 「同一场合」不能拿 evidence 有没有交集来判。两次判据都基于证据列表，
+    // 而证据列表既不是场合本身、也不稳定：
+    //   ① 模型给 evidence 的顺序不定（parseJsonArray 也不排序），[m1,m2] 与
+    //      [m2,m1] 是同一场合的两种写法；
+    //   ② 同一会话里的两条不同记忆各说一句「他很焦虑」，证据天然不相交，可
+    //      它们是同一个场合——那时该合并成一条边，而不是各写一条把边数抬高；
+    //   ③ 反过来，第一轮看到 1 条证据、第二轮攒到 2 条（含新会话），若判成重复
+    //      就整条丢掉，边上 sessionCount 永远停在第一次那个数，将来读归因覆盖率
+    //      会一直读到 1。
+    // 所以键落在会话层：同一 (person, target, emotion) 且两边的会话集有交集，
+    // 就是同一场合。命中时把 evidence 并集写回、按并集重算 sessionCount，而不是
+    // 丢弃——被扩充的边记进 merged，让「这一轮其实补了证据」在返回值里看得见。
+    // 这一步在 cap 之前：合并既有边不新增行，不该占名额。
+    const currentSessions = sessions;
+    const priorEdges = (service.getRelations(person.id) ?? []).filter((r) =>
+      r.relation_type === "affective_context" && r.to_entity === target.id
+    );
+    let mergedInto = null;
+    for (const edge of priorEdges) {
+      const meta = edge.metadata && typeof edge.metadata === "object" ? edge.metadata : null;
+      const priorEmotion = String(meta?.emotion ?? "").trim();
+      if (priorEmotion !== emotion) continue;
+      const priorEvidence = Array.isArray(meta?.evidence)
+        ? meta.evidence
+        : (edge.memory_id ? [edge.memory_id] : []);
+      const priorSessions = sessionsFor(priorEvidence);
+      // "Same occasion" is judged on session keys first. Only when either side
+      // has no session key at all does it fall back to an evidence intersection:
+      // memory_save writes memories without provenance (1671 of 8517 active rows
+      // in the live database have none), so sessionsFor returns an empty set and
+      // a session-only test would write the same edge again on every sleep pass,
+      // inflating sessionCount past the real number of occasions.
+      const sameOccasion = [...priorSessions].some((s) => currentSessions.has(s))
+        || ((priorSessions.size === 0 || currentSessions.size === 0)
+          && priorEvidence.some((id) => evidence.includes(id)));
+      if (!sameOccasion) continue;
+      mergedInto = { edge, priorEvidence, priorSessions };
+      break;
+    }
+    if (mergedInto) {
+      const { edge, priorEvidence, priorSessions } = mergedInto;
+      const unionEvidence = [...new Set([...priorEvidence, ...evidence])];
+      const unionSessions = new Set([...priorSessions, ...currentSessions]);
+      const mergedMetadata = {
+        ...(edge.metadata && typeof edge.metadata === "object" ? edge.metadata : {}),
+        emotion,
+        // 保留首个 attribution，但降级痕迹一旦有就留着——合并不能把
+        // 「它曾被判成 trait 又被降级」这段历史抹掉。
+        attribution: (edge.metadata && edge.metadata.attribution) || attribution,
+        evidence: unionEvidence,
+        sessionCount: unionSessions.size,
+        lastMergedRunId: runId
+      };
+      if (record.downgradedFrom && !mergedMetadata.downgradedFrom) {
+        mergedMetadata.downgradedFrom = record.downgradedFrom;
+      }
+      try {
+        service.updateRelationMetadata?.(edge.id, mergedMetadata);
+        merges.push({
+          id: edge.id,
+          from: person.name,
+          to: target.name,
+          emotion,
+          evidence: unionEvidence.length,
+          sessionCount: unionSessions.size
+        });
+      } catch (error) {
+        logger?.warn?.(`dsh-mneme sleep: affective relation merge ${person.name}/${target.name} failed: ${String(error)}`);
+      }
+      continue;
+    }
+    if (relations.length >= maxRelations) {
+      dropped.push({ reason: "relation cap", person: person.name, target: target.name });
+      continue;
+    }
+    try {
+      const saved = service.saveRelation({
+        from_entity: person.id,
+        to_entity: target.id,
+        relation_type: "affective_context",
+        memory_id: evidence[0],
+        source: "llm",
+        metadata: {
+          emotion,
+          attribution,
+          why: record.why,
+          evidence,
+          sessionCount: sessions.size,
+          ...(record.downgradedFrom ? { downgradedFrom: record.downgradedFrom } : {}),
+          model: `${route.provider}:${route.model}`,
+          runId
+        }
+      });
+      relations.push({ id: saved?.id, from: person.name, to: target.name, emotion, attribution, ...(record.downgradedFrom ? { downgradedFrom: record.downgradedFrom } : {}) });
+    } catch (error) {
+      logger?.warn?.(`dsh-mneme sleep: affective relation ${person.name}/${target.name} failed: ${String(error)}`);
+    }
+  }
+  // Traits ride the standard decision channel so they inherit every existing cap
+  // and the #512 mint ledger. No new write path is introduced for them.
+  let applied = 0;
+  let refreshedTraits = 0;
+  let failures = [];
+  let conflicts = [];
+  let ok = true;
+  // Candidates beyond the cap are otherwise neither minted, demoted, nor
+  // recorded: they simply vanish, while `traits` still counts them and a reader
+  // concludes they were handled. Record them the same way `relation cap` records
+  // edges, so "everything that disappears is accounted for" holds for traits.
+  for (const t of traits.slice(maxTraits)) {
+    dropped.push({ reason: "trait cap", person: t.person, target: t.target });
+  }
+  if (traits.length > 0) {
+    const decisions = traits.slice(0, maxTraits).map((t) => ({
+      action: "create",
+      type: "pattern",
+      title: STR.affectiveTrait.title[language](t),
+      content: STR.affectiveTrait.content[language](t),
+      importance: 3,
+      evidence: t.evidence
+    }));
+    const snapshot = new Map();
+    const validated = validateDecisions(decisions, snapshot, { maxCreatePerRun: maxTraits, allowedActions: ["create"] });
+    ok = validated.ok;
+    if (ok) {
+      const result = applyDecisions(decisions, service, logger, snapshot, { ...config, mintSource: "sleep", runId });
+      applied = result.applied;
+      failures = result.failures;
+      conflicts = result.conflicts;
+      // A trait whose pattern was refreshed in place (same title, same row) is
+      // not a new conclusion. Keep it out of `applied` and report it as a
+      // refresh, otherwise two different targets would read as two minted
+      // patterns while only one row exists (#619 audit round 6).
+      refreshedTraits = result.merged ?? 0;
+      // Ocasion edges observed before a disposition was confirmed do not get
+      // rewritten — an edge records "this occasion was observed", which stays
+      // true. But the edge and the pattern would then answer "how many
+      // occasions" differently (edge.sessionCount vs pattern evidence), and a
+      // coverage query reading both would have no way to tell they describe the
+      // same thing. Mark them instead of mutating the count: the edge still
+      // means one observed occasion, and `promotedToTrait` says that occasion is
+      // now part of a confirmed disposition.
+      for (const trait of traits.slice(0, maxTraits)) {
+        const person = byName.get(String(trait.person ?? "").toLowerCase());
+        const target = byName.get(String(trait.target ?? "").toLowerCase());
+        if (!person || !target || person.id === target.id) continue;
+        for (const edge of service.getRelations(person.id) ?? []) {
+          if (edge.relation_type !== "affective_context" || edge.to_entity !== target.id) continue;
+          const meta = edge.metadata && typeof edge.metadata === "object" ? edge.metadata : null;
+          if (String(meta?.emotion ?? "").trim() !== trait.emotion) continue;
+          if (meta?.promotedToTrait === true) continue;
+          try {
+            service.updateRelationMetadata?.(edge.id, {
+              ...meta,
+              promotedToTrait: true,
+              traitSessionCount: trait.sessionCount
+            });
+          } catch (error) {
+            logger?.warn?.(`dsh-mneme sleep: marking occasion ${edge.id} as promoted failed: ${String(error)}`);
+          }
+        }
+      }
+    }
+  }
+  // Aborting mid-pass is not "did nothing" and not "all done". Even when nothing
+  // was written yet, "noop" would claim the whole pool was examined and found
+  // empty — the loop broke at an arbitrary index, so it examined an unknown
+  // prefix. Report it as aborted either way.
+  if (signal?.aborted) {
+    return {
+      status: "aborted",
+      reason: "user activity",
+      scanned: memories.length,
+      relations: relations.length,
+      edgeWrites: relations.length,
+      merged: merges.length,
+      mergedList: merges,
+      applied,
+      refreshedTraits,
+      traits: traits.length,
+      downgraded: downgradedCount,
+      dropped
+    };
+  }
+  if (!ok) {
+    return {
+      status: "failed",
+      error: "trait decisions rejected by validation",
+      scanned: memories.length,
+      relations: relations.length,
+      edgeWrites: relations.length,
+      merged: merges.length,
+      mergedList: merges,
+      applied: 0,
+      refreshedTraits,
+      traits: traits.length,
+      downgraded: downgradedCount,
+      dropped
+    };
+  }
+  return {
+    // "refreshed" is a real write that minted nothing: the trait pattern already
+    // existed under the same title and was rewritten in place. Calling that
+    // "noop" would say the phase examined the pool and found nothing to do.
+    status: relations.length + merges.length + applied > 0 ? "ok" : (refreshedTraits > 0 ? "refreshed" : "noop"),
+    scanned: memories.length,
+    relations: relations.length,
+    merged: merges.length,
+    // #619: edges are real writes but not "applied decisions", so the receipt
+    // would read `:0` for a run that did write. Count them separately instead
+    // of folding them into `applied` (that would make the two numbers mean
+    // different things depending on which phase produced them).
+    edgeWrites: relations.length,
+    mergedList: merges,
+    applied,
+    refreshedTraits,
+    failures,
+    conflicts,
+    traits: traits.length,
+    downgraded: downgradedCount,
+    dropped
+  };
+}
+
 /**
  * Phase 4 — entity relation completion. Detects orphan entities (zero
  * relations) and completes implied relations from memory co-occurrence:
@@ -958,7 +1667,9 @@ function deriveStatus(phases) {
   const anyError = list.some((p) => p.status === "failed" || p.status === "error");
   // Issue #126 review（Copilot）：phase 自身可以是 degraded（合法子集已应用但有条目被
   // 跳过），它同样算"有产出"——否则整轮会被误判成 noop，把真实变更报成空轮。
-  const anyWork = list.some((p) => p.status === "ok" || p.status === "degraded");
+  // #619：`refreshed` 也是一次真实写入（同题行原地刷新），只是没铸出新条目。把它
+  // 排除在 anyWork 之外，整轮会被记成 noop，审计行又变回「跑了、什么都没干」。
+  const anyWork = list.some((p) => p.status === "ok" || p.status === "degraded" || p.status === "refreshed");
   const anyDegraded = list.some((p) => p.status === "degraded");
   // Issue #529：被打断（用户恢复活动）既不是失败也不是"没活干"。相位层已经用
   // aborted 区分了这两种，整轮层若回落到 noop，审计行就又把"没跑完"记成"跑过、
@@ -997,10 +1708,40 @@ export async function runSleep(ctx, service, config, logger, semantic = null, si
   await attempt("demotion", () => phaseDemotion(service, config, logger, runId, signal));
   await attempt("patterns", () => phasePatterns(ctx, service, config, logger, runId, signal));
   await attempt("relations", () => phaseRelations(service, config, logger, runId, signal));
+  // #619：情感归因排在 relations 之后——它要读实体与 provenance，先让孤立实体的
+  // 结构边补完，再往上挂情绪轴；两相写的是不同 relation_type，不抢同一批对。
+  await attempt("affective", () => phaseAffective(ctx, service, config, logger, runId, signal));
 
   const status = deriveStatus(phases);
   const route = resolveSleepRoute(ctx, config, logger);
-  const totalApplied = Object.values(phases).reduce((n, p) => n + (Number.isInteger(p?.applied) ? p.applied : 0), 0);
+  // #619: a phase may write rows that are not "applied decisions" — the
+  // affective phase inserts relation edges directly — and it may also extend an
+  // existing edge instead of inserting one. Both are store writes, and the
+  // receipt has to answer "did this run change anything", so both count. A run
+  // whose only effect was extending an edge would otherwise read `:0`, i.e.
+  // "ran and did nothing", which is exactly what a probe must never see.
+  //
+  // The per-kind numbers stay apart in `phases` (`applied` / `edgeWrites` /
+  // `merged` / `refreshedTraits`); the receipt is a single write count on
+  // purpose, because buildReceipt/parseReceipt are an eight-field contract
+  // shared with organize.js and four test files. Detail lives in
+  // dream_runs.phases JSON, not in the receipt.
+  //
+  // #619 / Ephor 第七轮 ①：`refreshedTraits` 必须计入。它是「同一标题的 pattern
+  // 被原地重写」的条数——库确实变了，但没有铸新条目，所以它既不在 `applied` 里
+  // （那会把刷新谎报成铸造），也不在 `merged` 里（affective 相位的 `merged` 是
+  // **边**合并数 `merges.length`，同名不同义）。漏掉它的后果实测过：第二轮
+  // `phase.status=refreshed`、`refreshedTraits=1`，整轮 receipt 第 7 段仍是 0，
+  // 于是「相位说改了、整轮说没改」，正是上一轮刚修掉的「改了库读成 0」形态。
+  const totalApplied = Object.values(phases).reduce(
+    (n, p) =>
+      n +
+      (Number.isInteger(p?.applied) ? p.applied : 0) +
+      (Number.isInteger(p?.edgeWrites) ? p.edgeWrites : 0) +
+      (Number.isInteger(p?.merged) ? p.merged : 0) +
+      (Number.isInteger(p?.refreshedTraits) ? p.refreshedTraits : 0),
+    0
+  );
   // Issue #126（与 #104 同向）：把各 phase 的跳过明细汇总成一行审计数据，带 phase
   // 名（同一次 run 里 conflicts 与 patterns 都可能产出 skipped）。全空时写 NULL，
   // 不落空数组——审计行只记真实发生过的跳过。