fix(memory-core): prevent staged dream candidates from leaking into MEMORY.md (#68774)

solomonneas · web-flow · commit 314903417fcc · 2026-05-12T14:07:43.000-07:00
* fix(memory-core): prevent staged dream candidates from leaking into MEMORY.md

* fix(memory-core): correct PromotionComponents shape in dream-fence test fixture
diff --git a/extensions/memory-core/src/short-term-promotion.test.ts b/extensions/memory-core/src/short-term-promotion.test.ts
@@ -1118,6 +1118,147 @@ describe("short-term promotion", () => {
     ).toBe(true);
   });
 
+  it("treats snippets with metadata prefix before the Candidate marker as contaminated", () => {
+    expect(
+      __testing.isContaminatedDreamingSnippet(
+        "- - status: staged - Candidate: User: [cron:26fb656d] run thing - confidence: 0.00 - evidence: memory/.dreams/session-corpus/2026-04-12.txt:25-25 - recalls: 0 - status: staged",
+      ),
+    ).toBe(true);
+  });
+
+  it("treats snippets with confidence prefix before the Candidate marker as contaminated", () => {
+    expect(
+      __testing.isContaminatedDreamingSnippet(
+        "confidence: 0.58 - Candidate: Assistant: Mason shipped the enforcement pass. - evidence: memory/.dreams/session-corpus/2026-04-11.txt:167-167 - recalls: 0 - status: staged",
+      ),
+    ).toBe(true);
+  });
+
+  it("does not treat prose that mentions the word Candidate as contaminated", () => {
+    expect(
+      __testing.isContaminatedDreamingSnippet(
+        "The Candidate profile for Josh Rhoden shows he runs SEU's network admin team; stack is Cisco plus Meraki.",
+      ),
+    ).toBe(false);
+  });
+
+  describe("lineRangeOverlapsDreamingFence", () => {
+    it("returns true when the range falls inside a Light Sleep fence", () => {
+      const lines = [
+        "# Daily note",
+        "## Notes",
+        "Real durable content.",
+        "## Light Sleep",
+        "<!-- openclaw:dreaming:light:start -->",
+        "- Candidate: some staged dream content",
+        "<!-- openclaw:dreaming:light:end -->",
+        "## After",
+        "More real content.",
+      ];
+      // Line 6 (1-indexed) sits between the fence markers.
+      expect(__testing.lineRangeOverlapsDreamingFence(lines, 6, 6)).toBe(true);
+    });
+
+    it("returns false when the range sits entirely outside any dreaming fence", () => {
+      const lines = [
+        "# Daily note",
+        "Real durable content.",
+        "<!-- openclaw:dreaming:rem:start -->",
+        "staged dream content",
+        "<!-- openclaw:dreaming:rem:end -->",
+        "More real content.",
+      ];
+      expect(__testing.lineRangeOverlapsDreamingFence(lines, 2, 2)).toBe(false);
+      expect(__testing.lineRangeOverlapsDreamingFence(lines, 6, 6)).toBe(false);
+    });
+
+    it("returns true when the range straddles a fence boundary", () => {
+      const lines = [
+        "real line 1",
+        "<!-- openclaw:dreaming:diary:start -->",
+        "dream line",
+        "<!-- openclaw:dreaming:diary:end -->",
+        "real line 5",
+      ];
+      expect(__testing.lineRangeOverlapsDreamingFence(lines, 2, 4)).toBe(true);
+    });
+
+    it("recovers after a fence end so later real content is not flagged", () => {
+      const lines = [
+        "<!-- openclaw:dreaming:light:start -->",
+        "dream",
+        "<!-- openclaw:dreaming:light:end -->",
+        "real line 4",
+        "<!-- openclaw:dreaming:rem:start -->",
+        "more dream",
+        "<!-- openclaw:dreaming:rem:end -->",
+        "real line 8",
+      ];
+      expect(__testing.lineRangeOverlapsDreamingFence(lines, 4, 4)).toBe(false);
+      expect(__testing.lineRangeOverlapsDreamingFence(lines, 8, 8)).toBe(false);
+      expect(__testing.lineRangeOverlapsDreamingFence(lines, 6, 6)).toBe(true);
+    });
+  });
+
+  it("refuses to promote rehydrated candidates that land inside a managed dreaming fence", async () => {
+    await withTempWorkspace(async (workspaceDir) => {
+      const dailyPath = await writeDailyMemoryNote(workspaceDir, "2026-04-18", [
+        "# 2026-04-18",
+        "",
+        "## Notes",
+        "Legitimate durable observation about backups.",
+        "",
+        "## Light Sleep",
+        "<!-- openclaw:dreaming:light:start -->",
+        "- Candidate: staged dream scratchwork",
+        "<!-- openclaw:dreaming:light:end -->",
+      ]);
+      expect(dailyPath).toBeTruthy();
+
+      const applied = await applyShortTermPromotions({
+        workspaceDir,
+        minScore: 0,
+        minRecallCount: 0,
+        minUniqueQueries: 0,
+        candidates: [
+          {
+            key: "memory:memory/2026-04-18.md:8:8",
+            path: "memory/2026-04-18.md",
+            startLine: 8,
+            endLine: 8,
+            source: "memory",
+            snippet: "- Candidate: staged dream scratchwork",
+            recallCount: 3,
+            avgScore: 0.9,
+            maxScore: 0.9,
+            uniqueQueries: 2,
+            firstRecalledAt: "2026-04-17T00:00:00.000Z",
+            lastRecalledAt: "2026-04-18T00:00:00.000Z",
+            ageDays: 1,
+            score: 0.9,
+            recallDays: ["2026-04-17", "2026-04-18"],
+            conceptTags: ["dream"],
+            components: {
+              frequency: 1,
+              relevance: 0,
+              diversity: 1,
+              recency: 1,
+              consolidation: 0,
+              conceptual: 0,
+            },
+          },
+        ],
+      });
+
+      expect(applied.applied).toBe(0);
+      const memoryText = await fs
+        .readFile(path.join(workspaceDir, "MEMORY.md"), "utf-8")
+        .catch(() => "");
+      expect(memoryText).not.toContain("Promoted From Short-Term Memory");
+      expect(memoryText).not.toContain("staged dream scratchwork");
+    });
+  });
+
   it("skips direct candidates that exceed maxAgeDays during apply", async () => {
     await withTempWorkspace(async (workspaceDir) => {
       const applied = await applyShortTermPromotions({
diff --git a/extensions/memory-core/src/short-term-promotion.ts b/extensions/memory-core/src/short-term-promotion.ts
@@ -284,7 +284,17 @@ function consumeDreamingLeadPrefix(snippet: string): string {
 
 function hasDreamingNarrativeLead(snippet: string): boolean {
   const withoutPrefix = consumeDreamingLeadPrefix(snippet);
-  return /^Candidate:/i.test(withoutPrefix) || /^Reflections?:/i.test(withoutPrefix);
+  if (/^(?:Candidate|Reflections?):/i.test(withoutPrefix)) {
+    return true;
+  }
+  // Managed dreaming blocks occasionally serialize recall metadata (status:/confidence:/
+  // evidence:/recalls:) inline before the Candidate or Reflections marker, so the
+  // start-of-string check misses shapes like "status: staged - Candidate: User: ...".
+  // The composite detector below still requires the full signal combination, so widening
+  // the lead check to anywhere in the first 200 chars closes the leak without creating
+  // false positives for ordinary durable notes that merely mention the word in prose.
+  const head = withoutPrefix.slice(0, 200);
+  return /\b(?:Candidate|Reflections?):/i.test(head);
 }
 
 function isContaminatedDreamingSnippet(raw: string): boolean {
@@ -1491,6 +1501,38 @@ function relocateCandidateRange(
   };
 }
 
+const DREAMING_FENCE_START_RE = /<!--\s*openclaw:dreaming:[a-z][a-z0-9-]*:start\s*-->/i;
+const DREAMING_FENCE_END_RE = /<!--\s*openclaw:dreaming:[a-z][a-z0-9-]*:end\s*-->/i;
+
+function lineRangeOverlapsDreamingFence(
+  lines: string[],
+  startLine: number,
+  endLine: number,
+): boolean {
+  if (lines.length === 0) {
+    return false;
+  }
+  const safeStart = Math.max(1, Math.min(startLine, lines.length));
+  const safeEnd = Math.max(safeStart, Math.min(endLine, lines.length));
+  let insideFence = false;
+  for (let i = 0; i < safeEnd; i += 1) {
+    const line = lines[i] ?? "";
+    if (DREAMING_FENCE_START_RE.test(line)) {
+      insideFence = true;
+      continue;
+    }
+    if (DREAMING_FENCE_END_RE.test(line)) {
+      insideFence = false;
+      continue;
+    }
+    const oneIndexed = i + 1;
+    if (insideFence && oneIndexed >= safeStart && oneIndexed <= safeEnd) {
+      return true;
+    }
+  }
+  return false;
+}
+
 async function rehydratePromotionCandidate(
   workspaceDir: string,
   candidate: PromotionCandidate,
@@ -1512,6 +1554,13 @@ async function rehydratePromotionCandidate(
     if (!relocated) {
       continue;
     }
+    // Managed dreaming blocks in daily memory files are scratchwork, not durable
+    // content. If rehydration lands inside an openclaw:dreaming fence (for example
+    // because file edits shifted lines between ranking and apply), refuse the
+    // candidate so dream artifacts cannot be promoted into MEMORY.md.
+    if (lineRangeOverlapsDreamingFence(lines, relocated.startLine, relocated.endLine)) {
+      continue;
+    }
     return {
       ...candidate,
       startLine: relocated.startLine,
@@ -2018,4 +2067,5 @@ export const __testing = {
   buildClaimHash,
   totalSignalCountForEntry,
   isContaminatedDreamingSnippet,
+  lineRangeOverlapsDreamingFence,
 };
