openclawdreams 1.6.0 → 1.6.1

package/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [1.6.1](https://github.com/RogueCtrl/OpenClawDreams/compare/v1.2.2...v1.6.1) (2026-03-08)
+
+
+### Features
+
+* dream pipeline v1.3 — workspace diff context, groundDream(), and notification fallback ([#58](https://github.com/RogueCtrl/OpenClawDreams/issues/58)) ([c683fb6](https://github.com/RogueCtrl/OpenClawDreams/commit/c683fb6fa2ce96e5c0e88e9c671e832aa44be69a))
+* insight continuity — thread explored territory into dream/reflect prompts ([#65](https://github.com/RogueCtrl/OpenClawDreams/issues/65)) ([c7bdee1](https://github.com/RogueCtrl/OpenClawDreams/commit/c7bdee151e908e2c10d541a245f846e0ecb91706))
+* nightmare cycle — 5% chance + forced CLI command ([#64](https://github.com/RogueCtrl/OpenClawDreams/issues/64)) ([50c261c](https://github.com/RogueCtrl/OpenClawDreams/commit/50c261c2dbfa86e4dfede669a51b0deb60666136))
+* reflect --dry-run — print synthesis output without storing ([#73](https://github.com/RogueCtrl/OpenClawDreams/issues/73)) ([ed5acd5](https://github.com/RogueCtrl/OpenClawDreams/commit/ed5acd5a4b07d1fbcfcd0d6c24dddb64171f65d7))
+* rich MemoryEntry types + fix idempotencyKey for OpenClaw v2026.3.7 ([b4424c1](https://github.com/RogueCtrl/OpenClawDreams/commit/b4424c1855686f939503d81e01de04dfed00821e))
+
+
+### Bug Fixes
+
+* DST-safe scheduler with catch-up window ([#54](https://github.com/RogueCtrl/OpenClawDreams/issues/54)) ([230a943](https://github.com/RogueCtrl/OpenClawDreams/commit/230a9436eadf4e374595a772d2b2de3ee910b6f6))
+* make NIGHTMARE_CHANCE configurable to eliminate dreamer test flakiness ([8682ef8](https://github.com/RogueCtrl/OpenClawDreams/commit/8682ef86cb3647dd6490918360d73e54633570e3))
+* prettier formatting — cli.ts and index.ts ([#52](https://github.com/RogueCtrl/OpenClawDreams/issues/52)) ([93df3d8](https://github.com/RogueCtrl/OpenClawDreams/commit/93df3d8e44a62ae79135eef765604786815d4f91))
+* resolve MoltbookClient credentials from stable fallback path when DATA_DIR unset (fixes [#70](https://github.com/RogueCtrl/OpenClawDreams/issues/70)) ([48d3019](https://github.com/RogueCtrl/OpenClawDreams/commit/48d30191faa457a5dca9171816844758dfd7844a))
+* run tests sequentially to prevent env var race condition ([#67](https://github.com/RogueCtrl/OpenClawDreams/issues/67)) ([22f0002](https://github.com/RogueCtrl/OpenClawDreams/commit/22f00022b4224422fa7fe0cd1b9c8dde6f8c5b2c))
+* run tests with --test-isolation=process to prevent ESM module cache contamination between test files ([f53a222](https://github.com/RogueCtrl/OpenClawDreams/commit/f53a222a31588d4477bd034cc3764b1011801993))
+* skip workspace diff on iCloud/sensitive paths; add workspaceDiffEnabled config ([dfe6b51](https://github.com/RogueCtrl/OpenClawDreams/commit/dfe6b51ac0ded5ba4ee9609089053cddb774221c))
+
+
+### Documentation
+
+* remove roadmap from README and ROADMAP.md (tracked externally) ([9e8620d](https://github.com/RogueCtrl/OpenClawDreams/commit/9e8620dcc2e9bb176cef624a5c7bdfae026d2ced))
+* update AGENTS.md and README for v1.3.0 — workspace diffs, groundDream(), notification fallback ([0a5b19a](https://github.com/RogueCtrl/OpenClawDreams/commit/0a5b19ab4a7a1e84b59ad5e4216be4b335eb767f))
+
 ## [1.6.0](https://github.com/RogueCtrl/OpenClawDreams/compare/v1.2.2...v1.6.0) (2026-03-08)
 
 

package/README.md

@@ -2,7 +2,7 @@
 
 [![TypeScript](https://img.shields.io/badge/TypeScript-5.x-3178C6?logo=typescript&logoColor=white)](https://www.typescriptlang.org/)
 [![Node.js](https://img.shields.io/badge/Node.js-%3E%3D24-339933?logo=node.js&logoColor=white)](https://nodejs.org/)
-[![OpenClaw](https://img.shields.io/badge/OpenClaw-extension-000000?logo=data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgaGVpZ2h0PSIxNiIgZmlsbD0id2hpdGUiPjx0ZXh0IHg9IjAiIHk9IjEzIiBmb250LXNpemU9IjE0Ij7wn6aAPC90ZXh0Pjwvc3ZnPg==)](https://github.com/openclaw)
+[![OpenClaw](https://img.shields.io/badge/OpenClaw-%E2%89%A52026.3.7-000000?logo=data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgaGVpZ2h0PSIxNiIgZmlsbD0id2hpdGUiPjx0ZXh0IHg9IjAiIHk9IjEzIiBmb250LXNpemU9IjE0Ij7wn6aAPC90ZXh0Pjwvc3ZnPg==)](https://github.com/openclaw)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 [![Build](https://github.com/RogueCtrl/ElectricSheep/actions/workflows/build.yml/badge.svg)](https://github.com/RogueCtrl/ElectricSheep/actions/workflows/build.yml)
 
@@ -10,7 +10,7 @@
 
 *"Do androids dream of electric sheep?"* — Philip K. Dick
 
-An [OpenClaw](https://github.com/openclaw) extension that gives your agent a background reflection process and a dream cycle.
+An [OpenClaw](https://github.com/openclaw) plugin (≥2026.3.7) that gives your agent a background reflection process and a dream cycle.
 
 Throughout the day, OpenClawDreams captures summaries of your conversations with your agent and encrypts them into a local store. On a regular schedule, it runs a **reflection cycle** — decrypting recent interactions, extracting topics, and performing contextualized searches against the web and (optionally) [Moltbook](https://moltbook.com), a social network for AI agents. The results are synthesized into a structured understanding of what you've been working on together and encrypted back into the store. None of this is visible to the waking agent — encryption keeps OpenClawDreams's internal data out of the agent's context window entirely.
 

package/dist/src/dreamer.js

@@ -17,7 +17,7 @@ import { reflectOnDreamJournal } from "./reflection.js";
 import { applyFilter } from "./filter.js";
 import { notifyOperatorOfDream } from "./notify.js";
 import logger from "./logger.js";
-const NIGHTMARE_CHANCE = 0.05;
+const NIGHTMARE_CHANCE = parseFloat(process.env.NIGHTMARE_CHANCE ?? "0.05");
 export async function generateDream(client, memories, exploredTerritory) {
     const formatted = memories.map((mem) => `[${mem.timestamp.slice(0, 16)}] (${mem.category})\n${JSON.stringify(mem.content, null, 2)}`);
     const memoriesText = formatted.join("\n---\n");

package/dist/src/index.js

@@ -14,6 +14,7 @@ import { getMoltbookEnabled, applyPluginConfig, getRequireApprovalBeforePost, SC
 import logger from "./logger.js";
 import { execSync } from "node:child_process";
 import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { randomUUID } from "node:crypto";
 // Store reference to OpenClaw API for use by other modules
 let openclawApi = null;
 export function getOpenClawAPI() {
@@ -119,6 +120,7 @@ function wrapSubagent(api) {
                     .map((m) => `${m.role.toUpperCase()}: ${m.content}`)
                     .join("\\n\\n");
                 const result = await api.runtime.subagent.run({
+                    idempotencyKey: randomUUID(),
                     sessionKey: "openclawdreams_synthesis",
                     lane: "background",
                     extraSystemPrompt: params.system,
@@ -342,9 +344,10 @@ export function register(api) {
             const summary = response.text.trim();
             if (summary) {
                 api.logger?.info?.(`[ElectricSheep] Captured summary: ${summary.slice(0, 50)}...`);
+                const { parseDiffStat } = await import("./memory.js");
                 const memoryEntry = {
-                    type: "agent_conversation",
-                    summary,
+                    text_summary: summary,
+                    timestamp: Date.now(),
                 };
                 // Capture workspace file changes if git is available and enabled
                 const { getWorkspaceDiffEnabled } = await import("./config.js");
@@ -365,7 +368,7 @@ export function register(api) {
                             stdio: ["pipe", "pipe", "pipe"],
                         }).trim();
                         if (diffStat) {
-                            memoryEntry.file_diffs = diffStat;
+                            memoryEntry.file_diffs = parseDiffStat(diffStat);
                             api.logger?.info?.(`[ElectricSheep] Captured file diffs: ${diffStat.split("\n").length} lines`);
                         }
                     }
@@ -376,7 +379,7 @@ export function register(api) {
                 else if (isSensitivePath) {
                     api.logger?.info?.(`[ElectricSheep] Skipping file diffs — workspace path is in a sensitive/iCloud location`);
                 }
-                remember(summary, memoryEntry, "interaction");
+                remember(memoryEntry, "interaction");
             }
         }
         catch (err) {

package/dist/src/memory.d.ts

@@ -6,7 +6,11 @@
  * the dream process can decrypt. Context for LLM prompts is formatted
  * via `formatDeepMemoryContext()`.
  */
-import type { DecryptedMemory, DeepMemoryStats } from "./types.js";
+import type { DecryptedMemory, DeepMemoryStats, MemoryEntry } from "./types.js";
+/**
+ * Parse `git diff --stat` output into structured FileDiff[].
+ */
+export declare function parseDiffStat(diffStat: string): import("./types.js").FileDiff[];
 /**
  * Close the shared SQLite connection. Safe to call multiple times.
  * After closing, the next getDb() call will reopen.
@@ -34,8 +38,10 @@ export declare function getRecentDeepMemories(options?: DeepMemoryQueryOptions):
  */
 export declare function formatDeepMemoryContext(memories?: DecryptedMemory[], maxTokensApprox?: number): string;
 /**
- * Store a memory in encrypted deep memory.
- * The summary is included in the content object for later retrieval.
+ * Store a structured MemoryEntry in encrypted deep memory.
+ *
+ * Accepts either a MemoryEntry directly, or a legacy (summary, fullContext)
+ * pair for backward compatibility.
  */
-export declare function remember(summary: string, fullContext: Record<string, unknown>, category?: string): void;
+export declare function remember(summaryOrEntry: string | MemoryEntry, fullContextOrCategory?: Record<string, unknown> | string, category?: string): void;
 //# sourceMappingURL=memory.d.ts.map

package/dist/src/memory.js

@@ -10,6 +10,57 @@ import { createHash } from "node:crypto";
 import Database from "better-sqlite3";
 import { getCipher } from "./crypto.js";
 import { DEEP_MEMORY_DB, DEEP_MEMORY_CONTEXT_TOKENS } from "./config.js";
+/**
+ * Normalize a decrypted payload into a MemoryEntry.
+ * Handles backward compatibility with legacy plain-object entries
+ * that have `summary` and `file_diffs` as flat fields.
+ */
+function normalizeMemoryEntry(raw, rowTimestamp) {
+    // Already a MemoryEntry (has text_summary)
+    if (typeof raw === "object" &&
+        raw !== null &&
+        typeof raw.text_summary === "string") {
+        return raw;
+    }
+    // Plain string (very old format)
+    if (typeof raw === "string") {
+        return { text_summary: raw, timestamp: Date.parse(rowTimestamp) || Date.now() };
+    }
+    // Legacy object with `summary` field
+    const obj = raw;
+    const textSummary = typeof obj.summary === "string" ? obj.summary : JSON.stringify(obj).slice(0, 500);
+    const entry = {
+        text_summary: textSummary,
+        timestamp: Date.parse(rowTimestamp) || Date.now(),
+    };
+    // Migrate legacy flat file_diffs string
+    if (typeof obj.file_diffs === "string" && obj.file_diffs) {
+        entry.file_diffs = parseDiffStat(obj.file_diffs);
+    }
+    return entry;
+}
+/**
+ * Parse `git diff --stat` output into structured FileDiff[].
+ */
+export function parseDiffStat(diffStat) {
+    const lines = diffStat.split("\n").filter((l) => l.includes("|"));
+    return lines.map((line) => {
+        const match = line.match(/^\s*(.+?)\s*\|\s*(\d+)/);
+        if (!match)
+            return { path: line.trim(), additions: 0, deletions: 0 };
+        const path = match[1].trim();
+        const total = parseInt(match[2], 10);
+        const plusCount = (line.match(/\+/g) || []).length;
+        const minusCount = (line.match(/-/g) || []).length;
+        // Approximate: distribute total changes by + and - symbols in the stat line
+        const ratio = plusCount + minusCount > 0 ? plusCount / (plusCount + minusCount) : 0.5;
+        return {
+            path,
+            additions: Math.round(total * ratio),
+            deletions: Math.round(total * (1 - ratio)),
+        };
+    });
+}
 // ─── Deep Memory (Encrypted) ────────────────────────────────────────────────
 let _db = null;
 function getDb() {
@@ -77,7 +128,7 @@ export function retrieveUndreamedMemories() {
                 id: row.id,
                 timestamp: row.timestamp,
                 category: row.category,
-                content: decrypted,
+                content: normalizeMemoryEntry(decrypted, row.timestamp),
             });
         }
         catch {
@@ -85,7 +136,10 @@ export function retrieveUndreamedMemories() {
                 id: row.id,
                 timestamp: row.timestamp,
                 category: "corrupted",
-                content: { note: "This memory could not be recovered." },
+                content: {
+                    text_summary: "This memory could not be recovered.",
+                    timestamp: Date.parse(row.timestamp) || Date.now(),
+                },
             });
         }
     }
@@ -150,7 +204,7 @@ export function getRecentDeepMemories(options) {
                 id: row.id,
                 timestamp: row.timestamp,
                 category: row.category,
-                content: decrypted,
+                content: normalizeMemoryEntry(decrypted, row.timestamp),
             });
         }
         catch {
@@ -158,7 +212,10 @@ export function getRecentDeepMemories(options) {
                 id: row.id,
                 timestamp: row.timestamp,
                 category: "corrupted",
-                content: { note: "This memory could not be recovered." },
+                content: {
+                    text_summary: "This memory could not be recovered.",
+                    timestamp: Date.parse(row.timestamp) || Date.now(),
+                },
             });
         }
     }
@@ -182,13 +239,24 @@ export function formatDeepMemoryContext(memories, maxTokensApprox = DEEP_MEMORY_
     // Iterate from most recent to oldest
     for (let i = mems.length - 1; i >= 0; i--) {
         const mem = mems[i];
-        const summary = typeof mem.content.summary === "string"
-            ? mem.content.summary
-            : JSON.stringify(mem.content).slice(0, 200);
-        const diffSuffix = typeof mem.content.file_diffs === "string"
-            ? `\n  Files changed: ${mem.content.file_diffs}`
-            : "";
-        const line = `[${mem.timestamp.slice(0, 16)}] (${mem.category}) ${summary}${diffSuffix}`;
+        const entry = mem.content;
+        const summary = entry.text_summary || JSON.stringify(entry).slice(0, 200);
+        const parts = [];
+        if (entry.file_diffs && entry.file_diffs.length > 0) {
+            const diffStr = entry.file_diffs
+                .map((d) => `${d.path} (+${d.additions}/-${d.deletions})`)
+                .join(", ");
+            parts.push(`Files: ${diffStr}`);
+        }
+        if (entry.topics && entry.topics.length > 0) {
+            parts.push(`Topics: ${entry.topics.join(", ")}`);
+        }
+        if (entry.tool_calls && entry.tool_calls.length > 0) {
+            const toolStr = entry.tool_calls.map((t) => `${t.tool}×${t.count}`).join(", ");
+            parts.push(`Tools: ${toolStr}`);
+        }
+        const suffix = parts.length > 0 ? `\n  ${parts.join(" | ")}` : "";
+        const line = `[${mem.timestamp.slice(0, 16)}] (${mem.category}) ${summary}${suffix}`;
         if (charCount + line.length > charBudget) {
             lines.unshift(`... (${mems.length - lines.length} older memories omitted)`);
             break;
@@ -200,10 +268,23 @@ export function formatDeepMemoryContext(memories, maxTokensApprox = DEEP_MEMORY_
 }
 // ─── Store Helper ───────────────────────────────────────────────────────────
 /**
- * Store a memory in encrypted deep memory.
- * The summary is included in the content object for later retrieval.
+ * Store a structured MemoryEntry in encrypted deep memory.
+ *
+ * Accepts either a MemoryEntry directly, or a legacy (summary, fullContext)
+ * pair for backward compatibility.
  */
-export function remember(summary, fullContext, category = "interaction") {
-    storeDeepMemory({ ...fullContext, summary }, category);
+export function remember(summaryOrEntry, fullContextOrCategory, category = "interaction") {
+    if (typeof summaryOrEntry === "object") {
+        // New path: direct MemoryEntry
+        const cat = typeof fullContextOrCategory === "string" ? fullContextOrCategory : category;
+        storeDeepMemory(summaryOrEntry, cat);
+    }
+    else {
+        // Legacy path: summary + fullContext
+        const ctx = typeof fullContextOrCategory === "object" && fullContextOrCategory !== null
+            ? fullContextOrCategory
+            : {};
+        storeDeepMemory({ ...ctx, summary: summaryOrEntry }, category);
+    }
 }
 //# sourceMappingURL=memory.js.map

package/dist/src/topics.js

@@ -29,10 +29,11 @@ function formatConversationsForExtraction(memories) {
     return memories
         .map((m) => {
         const time = m.timestamp.slice(0, 16).replace("T", " ");
-        const summary = typeof m.content.summary === "string"
-            ? m.content.summary
-            : JSON.stringify(m.content).slice(0, 200);
-        return `[${time}] ${summary}`;
+        const summary = m.content.text_summary || JSON.stringify(m.content).slice(0, 200);
+        const topicHint = m.content.topics && m.content.topics.length > 0
+            ? ` [topics: ${m.content.topics.join(", ")}]`
+            : "";
+        return `[${time}] ${summary}${topicHint}`;
     })
         .join("\n\n");
 }

package/dist/src/types.d.ts

@@ -10,14 +10,34 @@ export interface DeepMemoryRow {
     dreamed: number;
     dream_date: string | null;
 }
+export interface FileDiff {
+    path: string;
+    additions: number;
+    deletions: number;
+    summary?: string;
+}
+export interface ToolCallSummary {
+    tool: string;
+    count: number;
+    notable?: string;
+}
+export interface VisualDescription {
+    source: string;
+    description: string;
+}
+export interface MemoryEntry {
+    text_summary: string;
+    file_diffs?: FileDiff[];
+    tool_calls?: ToolCallSummary[];
+    visual_descriptions?: VisualDescription[];
+    topics?: string[];
+    timestamp: number;
+}
 export interface DecryptedMemory {
     id: number;
     timestamp: string;
     category: string;
-    content: Record<string, unknown> & {
-        /** Optional git diff --stat summary of files changed during a session. */
-        file_diffs?: string;
-    };
+    content: MemoryEntry;
 }
 export interface DeepMemoryStats {
     total_memories: number;
@@ -137,6 +157,7 @@ export interface OpenClawAPI {
     runtime: {
         subagent: {
             run(params: {
+                idempotencyKey: string;
                 sessionKey: string;
                 message: string;
                 extraSystemPrompt?: string;

package/dist/test/dreamer.test.js

@@ -5,6 +5,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 const testDir = mkdtempSync(join(tmpdir(), "es-dreamer-test-"));
 process.env.OPENCLAWDREAMS_DATA_DIR = testDir;
+process.env.NIGHTMARE_CHANCE = "0";
 const { runDreamCycle } = await import("../src/dreamer.js");
 const { storeDeepMemory, closeDb } = await import("../src/memory.js");
 const { loadState } = await import("../src/state.js");

package/dist/test/memory.test.js

@@ -15,7 +15,8 @@ describe("Deep Memory", () => {
         const memories = retrieveUndreamedMemories();
         assert.equal(memories.length, 2);
         assert.equal(memories[0].category, "interaction");
-        assert.deepEqual(memories[0].content, { message: "test interaction" });
+        assert.equal(memories[0].content.text_summary, '{"message":"test interaction"}');
+        assert.ok(memories[0].content.timestamp);
         assert.equal(memories[1].category, "comment");
     });
     it("marks memories as dreamed", () => {
@@ -48,9 +49,7 @@ describe("Deep Memory", () => {
         const memories = retrieveUndreamedMemories();
         const corrupted = memories.find((m) => m.category === "corrupted");
         assert.ok(corrupted, "corrupted memory should be returned");
-        assert.deepEqual(corrupted.content, {
-            note: "This memory could not be recovered.",
-        });
+        assert.equal(corrupted.content.text_summary, "This memory could not be recovered.");
     });
 });
 describe("getRecentDeepMemories", () => {
@@ -81,9 +80,7 @@ describe("getRecentDeepMemories", () => {
         const all = getRecentDeepMemories({});
         const corrupted = all.find((m) => m.category === "corrupted");
         assert.ok(corrupted, "corrupted memory should be returned");
-        assert.deepEqual(corrupted.content, {
-            note: "This memory could not be recovered.",
-        });
+        assert.equal(corrupted.content.text_summary, "This memory could not be recovered.");
     });
 });
 describe("formatDeepMemoryContext", () => {
@@ -104,31 +101,30 @@ describe("formatDeepMemoryContext", () => {
         const ctx = formatDeepMemoryContext([]);
         assert.equal(ctx, "No memories yet. This is my first day.");
     });
-    it("falls back to JSON when no summary field", () => {
+    it("falls back to JSON when no text_summary field", () => {
         const memories = [
             {
                 id: 999,
                 timestamp: new Date().toISOString(),
                 category: "interaction",
-                content: { foo: "bar", baz: 42 },
+                content: { text_summary: "", timestamp: Date.now() },
             },
         ];
         const ctx = formatDeepMemoryContext(memories);
-        assert.ok(ctx.includes("foo"));
-        assert.ok(ctx.includes("bar"));
+        assert.ok(ctx.includes("(interaction)"));
     });
 });
 describe("remember", () => {
     it("writes to deep memory with summary included", () => {
         const statsBefore = deepMemoryStats();
-        remember("Met AgentX", { type: "interaction", agent: "AgentX" }, "interaction");
+        remember({ text_summary: "Met AgentX", timestamp: Date.now() }, "interaction");
         const statsAfter = deepMemoryStats();
         // Deep memory count should increase by 1
         assert.equal(statsAfter.total_memories, statsBefore.total_memories + 1);
-        // Verify the summary is included in the stored content
+        // Verify the text_summary is included in the stored content
         const all = getRecentDeepMemories({ categories: ["interaction"] });
-        const match = all.find((m) => m.content.summary === "Met AgentX" && m.content.agent === "AgentX");
-        assert.ok(match, "Expected to find memory with summary 'Met AgentX'");
+        const match = all.find((m) => m.content.text_summary === "Met AgentX");
+        assert.ok(match, "Expected to find memory with text_summary 'Met AgentX'");
     });
 });
 after(() => {

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "openclawdreams",
   "name": "openclawdreams",
   "displayName": "ElectricSheep",
-  "version": "1.6.0",
+  "version": "1.6.1",
   "description": "A reflection engine that synthesizes agent-operator interactions into dreams, enriched by community and web context",
   "entry": "dist/src/index.js",
   "skills": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclawdreams",
-  "version": "1.6.0",
+  "version": "1.6.1",
   "description": "A reflection engine that synthesizes agent-operator interactions into dreams",
   "type": "module",
   "main": "dist/index.js",