fix(dreaming): filter already-emitted entries in light phase to prevent verbatim repeats (fixes #72096)

liuhao1024 · liuhao1024 · commit 4705750ee489 · 2026-06-14T23:38:37.000+08:00
Light-phase dreaming re-summarized the same short-term recall entries
every cycle because it never checked whether an entry was already emitted
in a prior cycle.  This produced byte-for-byte identical work-summary
blocks in DREAMS.md across consecutive cycles.

Read the phase signal store before building the light-phase body and
skip entries whose  is at or after their
— meaning they were already emitted and have not been recalled again
since.  Entries without a prior  (first cycle) or with a
newer  (re-recalled since last emission) are kept.
diff --git a/extensions/memory-core/src/dreaming-phases.ts b/extensions/memory-core/src/dreaming-phases.ts
@@ -40,6 +40,7 @@ import { textSimilarity as snippetSimilarity } from "./memory/tokenize.js";
 import {
   filterLiveShortTermRecallEntries,
   readLightStagedKeys,
+  readPhaseSignalEntries,
   readShortTermRecallEntries,
   recordDreamingPhaseSignals,
   recordRemConsideredPhaseSignals,
@@ -1660,8 +1661,29 @@ async function runLightDreaming(params: {
       lookbackDays: params.config.lookbackDays,
     }),
   });
+  // Filter entries already emitted in a prior light-phase cycle and not
+  // recalled again since.  This prevents the work-summary block from
+  // repeating verbatim across consecutive cycles when the same entries
+  // remain within the lookback window.  See #72096.
+  const phaseSignals = await readPhaseSignalEntries({
+    workspaceDir: params.workspaceDir,
+    nowMs,
+  });
+  const freshEntries = recentEntries.filter((entry) => {
+    const signal = phaseSignals[entry.key];
+    if (!signal?.lastLightAt) {
+      return true; // never emitted → include
+    }
+    const lastLightMs = Date.parse(signal.lastLightAt);
+    const lastRecalledMs = Date.parse(entry.lastRecalledAt);
+    if (!Number.isFinite(lastLightMs) || !Number.isFinite(lastRecalledMs)) {
+      return true; // malformed timestamps → include conservatively
+    }
+    // Include only if the entry was recalled again after the last emission.
+    return lastRecalledMs > lastLightMs;
+  });
   const entries = dedupeEntries(
-    recentEntries
+    freshEntries
       .toSorted((a, b) => {
         const byTime = Date.parse(b.lastRecalledAt) - Date.parse(a.lastRecalledAt);
         if (byTime !== 0) {
diff --git a/extensions/memory-core/src/short-term-promotion.ts b/extensions/memory-core/src/short-term-promotion.ts
@@ -1775,6 +1775,24 @@ export async function readLightStagedKeys(params: {
   return keys;
 }
 
+/**
+ * Read the phase signal entries for a workspace so callers can inspect
+ * per-entry `lastLightAt` / `lastRemAt` timestamps for deduplication.
+ */
+export async function readPhaseSignalEntries(params: {
+  workspaceDir: string;
+  nowMs?: number;
+}): Promise<Record<string, ShortTermPhaseSignalEntry>> {
+  const workspaceDir = params.workspaceDir?.trim();
+  if (!workspaceDir) {
+    return {};
+  }
+  const nowMs = resolveMemoryCoreNowMs(params.nowMs);
+  const nowIso = resolveMemoryCoreTimestamp(nowMs);
+  const store = await readPhaseSignalStore(workspaceDir, nowIso);
+  return store.entries;
+}
+
 export async function rankShortTermPromotionCandidates(
   options: RankShortTermPromotionOptions,
 ): Promise<PromotionCandidate[]> {
