memory: chunk daily dreaming ingestion (openclaw#61583)

Merged via squash.

Prepared head SHA: 88816a0
Co-authored-by: mbelinky <17249097+mbelinky@users.noreply.github.com>
Co-authored-by: mbelinky <132747814+mbelinky@users.noreply.github.com>
Reviewed-by: @mbelinky

Author: mbelinky

CHANGELOG.md

@@ -42,6 +42,7 @@ Docs: https://docs.openclaw.ai
 - Providers/CLI: remove bundled CLI text-provider backends and the `agents.defaults.cliBackends` surface, while keeping ACP harness sessions and Gemini media understanding on the native bundled providers.
 - Matrix/exec approvals: clarify unavailable-approval replies so Matrix no longer claims chat approvals are unsupported when native exec approvals are merely unconfigured. (#61424) Thanks @gumadeiras.
 - Docs/IRC: replace public IRC hostname examples with `irc.example.com` and recommend private servers for bot coordination while listing common public networks for intentional use.
+- Memory/dreaming: group nearby daily-note lines into short coherent chunks before staging them for dreaming, so one-off context from recent notes reaches REM/deep with better evidence and less line-level noise.
 
 ### Fixes
 

extensions/memory-core/src/dreaming-phases.test.ts

@@ -22,7 +22,7 @@ afterEach(async () => {
   await Promise.all(tempDirs.splice(0).map((dir) => fs.rm(dir, { recursive: true, force: true })));
 });
 
-function createHarness(config: OpenClawConfig) {
+function createHarness(config: OpenClawConfig, workspaceDir?: string) {
   let beforeAgentReply:
     | ((
         event: { cleanedBody: string },
@@ -36,7 +36,18 @@ function createHarness(config: OpenClawConfig) {
   };
 
   const api = {
-    config,
+    config: workspaceDir
+      ? {
+          ...config,
+          agents: {
+            ...config.agents,
+            defaults: {
+              ...config.agents?.defaults,
+              workspace: workspaceDir,
+            },
+          },
+        }
+      : config,
     pluginConfig: {},
     logger,
     registerHook: vi.fn(),
@@ -65,26 +76,29 @@ describe("memory-core dreaming phases", () => {
       "utf-8",
     );
 
-    const { beforeAgentReply } = createHarness({
-      plugins: {
-        entries: {
-          "memory-core": {
-            config: {
-              dreaming: {
-                enabled: true,
-                phases: {
-                  light: {
-                    enabled: true,
-                    limit: 20,
-                    lookbackDays: 2,
+    const { beforeAgentReply } = createHarness(
+      {
+        plugins: {
+          entries: {
+            "memory-core": {
+              config: {
+                dreaming: {
+                  enabled: true,
+                  phases: {
+                    light: {
+                      enabled: true,
+                      limit: 20,
+                      lookbackDays: 2,
+                    },
                   },
                 },
               },
             },
           },
         },
       },
-    });
+      workspaceDir,
+    );
 
     const readSpy = vi.spyOn(fs, "readFile");
     try {
@@ -103,7 +117,7 @@ describe("memory-core dreaming phases", () => {
     const dailyReadCount = readSpy.mock.calls.filter(
       ([target]) => String(target) === dailyPath,
     ).length;
-    expect(dailyReadCount).toBe(1);
+    expect(dailyReadCount).toBeLessThanOrEqual(1);
     await expect(
       fs.access(path.join(workspaceDir, "memory", ".dreams", "daily-ingestion.json")),
     ).resolves.toBeUndefined();
@@ -129,26 +143,89 @@ describe("memory-core dreaming phases", () => {
     });
     expect(before).toHaveLength(0);
 
-    const { beforeAgentReply } = createHarness({
-      plugins: {
-        entries: {
-          "memory-core": {
-            config: {
-              dreaming: {
-                enabled: true,
-                phases: {
-                  light: {
-                    enabled: true,
-                    limit: 20,
-                    lookbackDays: 2,
+    const { beforeAgentReply } = createHarness(
+      {
+        plugins: {
+          entries: {
+            "memory-core": {
+              config: {
+                dreaming: {
+                  enabled: true,
+                  phases: {
+                    light: {
+                      enabled: true,
+                      limit: 20,
+                      lookbackDays: 2,
+                    },
                   },
                 },
               },
             },
           },
         },
       },
+      workspaceDir,
+    );
+
+    await beforeAgentReply(
+      { cleanedBody: "__openclaw_memory_core_light_sleep__" },
+      { trigger: "heartbeat", workspaceDir },
+    );
+
+    const after = await rankShortTermPromotionCandidates({
+      workspaceDir,
+      minScore: 0,
+      minRecallCount: 0,
+      minUniqueQueries: 0,
+      nowMs: Date.parse("2026-04-05T10:05:00.000Z"),
     });
+    expect(after).toHaveLength(1);
+    expect(after[0]?.dailyCount).toBeGreaterThan(0);
+    expect(after[0]?.startLine).toBe(3);
+    expect(after[0]?.endLine).toBe(4);
+    expect(after[0]?.snippet).toContain("Move backups to S3 Glacier.");
+    expect(after[0]?.snippet).toContain("Keep retention at 365 days.");
+  });
+
+  it("keeps section context when chunking durable daily notes", async () => {
+    const workspaceDir = await createTempWorkspace();
+    await fs.mkdir(path.join(workspaceDir, "memory"), { recursive: true });
+    await fs.writeFile(
+      path.join(workspaceDir, "memory", "2026-04-05.md"),
+      [
+        "# 2026-04-05",
+        "",
+        "## Emma Rees",
+        "- She asked for more space after the last exchange.",
+        "- Better to keep messages short and low-pressure.",
+        "- Re-engagement should be time-bounded and optional.",
+      ].join("\n"),
+      "utf-8",
+    );
+
+    const { beforeAgentReply } = createHarness(
+      {
+        plugins: {
+          entries: {
+            "memory-core": {
+              config: {
+                dreaming: {
+                  enabled: true,
+                  phases: {
+                    light: {
+                      enabled: true,
+                      limit: 20,
+                      lookbackDays: 2,
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+      workspaceDir,
+    );
 
     await beforeAgentReply(
       { cleanedBody: "__openclaw_memory_core_light_sleep__" },
@@ -162,8 +239,86 @@ describe("memory-core dreaming phases", () => {
       minUniqueQueries: 0,
       nowMs: Date.parse("2026-04-05T10:05:00.000Z"),
     });
-    expect(after.length).toBeGreaterThan(0);
-    expect(after.some((candidate) => (candidate.dailyCount ?? 0) > 0)).toBe(true);
+    expect(after).toHaveLength(1);
+    expect(after[0]?.startLine).toBe(4);
+    expect(after[0]?.endLine).toBe(6);
+    expect(after[0]?.snippet).toContain("Emma Rees:");
+    expect(after[0]?.snippet).toContain("She asked for more space");
+    expect(after[0]?.snippet).toContain("messages short and low-pressure");
+  });
+
+  it("splits noisy daily notes into a few coherent chunks instead of one line per item", async () => {
+    const workspaceDir = await createTempWorkspace();
+    await fs.mkdir(path.join(workspaceDir, "memory"), { recursive: true });
+    await fs.writeFile(
+      path.join(workspaceDir, "memory", "2026-04-05.md"),
+      [
+        "# 2026-04-05",
+        "",
+        "## Operations",
+        "- Restarted the gateway after auth drift.",
+        "- Tokens now line up again.",
+        "",
+        "## Bex",
+        "- She prefers direct plans over open-ended maybes.",
+        "- Better to offer one concrete time window.",
+        "",
+        "11:30",
+        "",
+        "## Travel",
+        "- Flight lands at 08:10.",
+      ].join("\n"),
+      "utf-8",
+    );
+
+    const { beforeAgentReply } = createHarness(
+      {
+        plugins: {
+          entries: {
+            "memory-core": {
+              config: {
+                dreaming: {
+                  enabled: true,
+                  phases: {
+                    light: {
+                      enabled: true,
+                      limit: 20,
+                      lookbackDays: 2,
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+      workspaceDir,
+    );
+
+    await beforeAgentReply(
+      { cleanedBody: "__openclaw_memory_core_light_sleep__" },
+      { trigger: "heartbeat", workspaceDir },
+    );
+
+    const after = await rankShortTermPromotionCandidates({
+      workspaceDir,
+      minScore: 0,
+      minRecallCount: 0,
+      minUniqueQueries: 0,
+      nowMs: Date.parse("2026-04-05T10:05:00.000Z"),
+    });
+    expect(after).toHaveLength(3);
+    expect(after.map((candidate) => candidate.snippet)).toEqual(
+      expect.arrayContaining([
+        expect.stringContaining(
+          "Operations: Restarted the gateway after auth drift.; Tokens now line up again.",
+        ),
+        expect.stringContaining(
+          "Bex: She prefers direct plans over open-ended maybes.; Better to offer one concrete time window.",
+        ),
+        expect.stringContaining("Travel: Flight lands at 08:10."),
+      ]),
+    );
   });
 
   it("records light/rem signals that reinforce deep promotion ranking", async () => {
@@ -210,32 +365,35 @@ describe("memory-core dreaming phases", () => {
     expect(baseline).toHaveLength(1);
     const baselineScore = baseline[0]!.score;
 
-    const { beforeAgentReply } = createHarness({
-      plugins: {
-        entries: {
-          "memory-core": {
-            config: {
-              dreaming: {
-                enabled: true,
-                phases: {
-                  light: {
-                    enabled: true,
-                    limit: 10,
-                    lookbackDays: 7,
-                  },
-                  rem: {
-                    enabled: true,
-                    limit: 10,
-                    lookbackDays: 7,
-                    minPatternStrength: 0,
+    const { beforeAgentReply } = createHarness(
+      {
+        plugins: {
+          entries: {
+            "memory-core": {
+              config: {
+                dreaming: {
+                  enabled: true,
+                  phases: {
+                    light: {
+                      enabled: true,
+                      limit: 10,
+                      lookbackDays: 7,
+                    },
+                    rem: {
+                      enabled: true,
+                      limit: 10,
+                      lookbackDays: 7,
+                      minPatternStrength: 0,
+                    },
                   },
                 },
               },
             },
           },
         },
       },
-    });
+      workspaceDir,
+    );
 
     await beforeAgentReply(
       { cleanedBody: "__openclaw_memory_core_light_sleep__" },