@modusensus/dsh-mneme 0.11.0 → 0.13.0

package/src/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
@@ -356,6 +359,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);
@@ -389,33 +397,200 @@ 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++;
+    }
+    if (pendingSkipped > 0) {
+      logger?.warn?.(`dsh-mneme sleep: conflict freeze queue full (${pendingNow}/${maxPending}), skipped ${pendingSkipped} conflict(s)`);
     }
-    return { status: frozen > 0 ? "ok" : "noop", frozen, scopeCandidates: crossPairs.length, pairs: selected.length };
+    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
+    };
   }
 
   // 非 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 对：可能一对都没检测到，也可能全被台账挡下了
@@ -443,6 +618,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 +651,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 +715,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,
@@ -740,6 +923,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 +935,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 +961,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 +1079,391 @@ 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) return { status: "failed", error: "llm failed" };
+  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 +1527,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 +1568,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，
   // 不落空数组——审计行只记真实发生过的跳过。