import fs from "node:fs/promises";

import path from "node:path";

import { describe, expect, it } from "vitest";

import { afterEach, describe, expect, it, vi } from "vitest";

import { writeDailyDreamingPhaseBlock, writeDeepDreamingReport } from "./dreaming-markdown.js";

import { createMemoryCoreTestHarness } from "./test-helpers.js";

const { createTempWorkspace } = createMemoryCoreTestHarness();

afterEach(() => {

vi.restoreAllMocks();

});

async function expectPathMissing(targetPath: string): Promise<void> {

const error = await fs.access(targetPath).then(

() => undefined,

expect(content).toContain("- Candidate: remember the API key is fake");

});

it("falls back when the injected timestamp is outside Date range", async () => {

vi.spyOn(Date, "now").mockReturnValue(Date.UTC(2026, 4, 30, 12, 0, 0));

const workspaceDir = await createTempWorkspace("openclaw-dreaming-markdown-");

const result = await writeDailyDreamingPhaseBlock({

workspaceDir,

phase: "light",

bodyLines: ["- Candidate: bounded fallback"],

nowMs: 8_640_000_000_000_001,

timezone,

storage: {

mode: "inline",

separateReports: false,

},

});

expect(requireInlinePath(result)).toBe(path.join(workspaceDir, "memory", "2026-05-30.md"));

});

it("keeps multiple inline phases in the shared daily memory file", async () => {

const workspaceDir = await createTempWorkspace("openclaw-dreaming-markdown-");

replaceManagedMarkdownBlock,

withTrailingNewline,

} from "openclaw/plugin-sdk/memory-host-markdown";

import { resolveMemoryCoreNowMs, resolveMemoryCoreTimestamp } from "./time.js";

const DAILY_PHASE_HEADINGS: Record<Exclude<MemoryDreamingPhaseName, "deep">, string> = {

light: "## Light Sleep",

timezone?: string;

storage: MemoryDreamingStorageConfig;

}): Promise<{ inlinePath?: string; reportPath?: string }> {

const nowMs = Number.isFinite(params.nowMs) ? (params.nowMs as number) : Date.now();

const nowMs = resolveMemoryCoreNowMs(params.nowMs);

const body = params.bodyLines.length > 0 ? params.bodyLines.join("\n") : "- No notable updates.";

let inlinePath: string | undefined;

let reportPath: string | undefined;

await appendMemoryHostEvent(params.workspaceDir, {

type: "memory.dream.completed",

timestamp: new Date(nowMs).toISOString(),

timestamp: resolveMemoryCoreTimestamp(nowMs),

phase: params.phase,

...(inlinePath ? { inlinePath } : {}),

...(reportPath ? { reportPath } : {}),

if (!shouldWriteSeparate(params.storage)) {

return undefined;

}

const nowMs = Number.isFinite(params.nowMs) ? (params.nowMs as number) : Date.now();

const nowMs = resolveMemoryCoreNowMs(params.nowMs);

const reportPath = resolveSeparateReportPath(params.workspaceDir, "deep", nowMs, params.timezone);

await fs.mkdir(path.dirname(reportPath), { recursive: true });

const body = params.bodyLines.length > 0 ? params.bodyLines.join("\n") : "- No durable changes.";

await fs.writeFile(reportPath, `# Deep Sleep\n\n${body}\n`, "utf-8");

await appendMemoryHostEvent(params.workspaceDir, {

type: "memory.dream.completed",

timestamp: new Date(nowMs).toISOString(),

timestamp: resolveMemoryCoreTimestamp(nowMs),

phase: "deep",

reportPath,

lineCount: params.bodyLines.length,

import { afterEach, describe, expect, it, vi } from "vitest";

import { buildMemoryFlushPlan } from "./flush-plan.js";

describe("buildMemoryFlushPlan", () => {

afterEach(() => {

vi.restoreAllMocks();

});

it("falls back when the injected timestamp is outside Date range", () => {

vi.spyOn(Date, "now").mockReturnValue(Date.UTC(2026, 4, 30, 12, 0, 0));

const plan = buildMemoryFlushPlan({

nowMs: 8_640_000_000_000_001,

});

expect(plan?.relativePath).toBe("memory/2026-05-30.md");

});

});

type MemoryFlushPlan,

type OpenClawConfig,

} from "openclaw/plugin-sdk/memory-core-host-runtime-core";

import { resolveMemoryCoreNowMs } from "./time.js";

export const DEFAULT_MEMORY_FLUSH_SOFT_TOKENS = 4000;

export const DEFAULT_MEMORY_FLUSH_FORCE_TRANSCRIPT_BYTES = 2 * 1024 * 1024;

if (year && month && day) {

return `${year}-${month}-${day}`;

}

return new Date(nowMs).toISOString().slice(0, 10);

return new Date(resolveMemoryCoreNowMs(nowMs)).toISOString().slice(0, 10);

}

function normalizeNonNegativeInt(value: unknown): number | null {

} = {},

): MemoryFlushPlan | null {

const resolved = params;

const nowMs = Number.isFinite(resolved.nowMs) ? (resolved.nowMs as number) : Date.now();

const nowMs = resolveMemoryCoreNowMs(resolved.nowMs);

const cfg = resolved.cfg;

const defaults = cfg?.agents?.defaults?.compaction?.memoryFlush;

if (defaults?.enabled === false) {

import { timestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";

export function resolveMemoryCoreNowMs(nowMs: unknown): number {

return timestampMsToIsoString(nowMs) === undefined ? Date.now() : (nowMs as number);

}

export function resolveMemoryCoreTimestamp(nowMs: unknown): string {

const timestampMs = resolveMemoryCoreNowMs(nowMs);

return timestampMsToIsoString(timestampMs) ?? new Date().toISOString();

}