const DREAMS_FILE_LOCKS_KEY = Symbol.for("openclaw.memoryCore.dreamingNarrative.fileLocks");

const EXPECTS_POSIX_PRIVATE_FILE_MODE = process.platform !== "win32";

type MockCallSource = { mock: { calls: Array<Array<unknown>> } };

function mockCallArg(source: MockCallSource, label: string, callIndex = 0, argIndex = 0): unknown {

const call = source.mock.calls[callIndex];

if (!call) {

throw new Error(`Expected ${label} call ${callIndex} to exist`);

}

if (!(argIndex in call)) {

throw new Error(`Expected ${label} call ${callIndex} argument ${argIndex} to exist`);

}

return call[argIndex];

}

function mockObjectArg(

source: MockCallSource,

label: string,

callIndex = 0,

argIndex = 0,

): Record<string, unknown> {

const value = mockCallArg(source, label, callIndex, argIndex);

if (!value || typeof value !== "object") {

throw new Error(`Expected ${label} call ${callIndex} argument ${argIndex} to be an object`);

}

return value as Record<string, unknown>;

}

function logIncludes(source: MockCallSource, text: string): boolean {

return source.mock.calls.some((call) => String(call[0]).includes(text));

}

function expectLogIncludes(source: MockCallSource, text: string): void {

expect(logIncludes(source, text), `Expected log to include ${text}`).toBe(true);

}

function expectLogExcludes(source: MockCallSource, text: string): void {

expect(logIncludes(source, text), `Expected log not to include ${text}`).toBe(false);

}

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

const accessResult = await fs

.access(targetPath)

.then(() => "exists")

.catch((error: unknown) => (error as { code?: unknown }).code);

expect(accessResult).toBe("ENOENT");

}

afterEach(() => {

vi.restoreAllMocks();

resolveGlobalMap<string, unknown>(DREAMS_FILE_LOCKS_KEY).clear();

});

expect(subagent.run).toHaveBeenCalledOnce();

expect(subagent.run.mock.calls[0][0]).toMatchObject({

idempotencyKey: expectedSessionKey,

sessionKey: expectedSessionKey,

lane: `dreaming-narrative:${expectedSessionKey}`,

lightContext: true,

deliver: false,

model: "anthropic/claude-sonnet-4-6",

});

const runOptions = mockObjectArg(subagent.run, "subagent run");

expect(runOptions.idempotencyKey).toBe(expectedSessionKey);

expect(runOptions.sessionKey).toBe(expectedSessionKey);

expect(runOptions.lane).toBe(`dreaming-narrative:${expectedSessionKey}`);

expect(runOptions.lightContext).toBe(true);

expect(runOptions.deliver).toBe(false);

expect(runOptions.model).toBe("anthropic/claude-sonnet-4-6");

expect(subagent.waitForRun).toHaveBeenCalledOnce();

expect(subagent.deleteSession).toHaveBeenCalledOnce();

});

expect(subagent.run).toHaveBeenCalledTimes(2);

expect(subagent.run.mock.calls[0]?.[0]).toMatchObject({

sessionKey: expectedSessionKey,

model: "ollama/missing-model",

});

expect(subagent.run.mock.calls[1]?.[0]).toMatchObject({

sessionKey: retrySessionKey,

});

expect(subagent.run.mock.calls[1]?.[0]).not.toHaveProperty("model");

const configuredRunOptions = mockObjectArg(subagent.run, "subagent run");

expect(configuredRunOptions.sessionKey).toBe(expectedSessionKey);

expect(configuredRunOptions.model).toBe("ollama/missing-model");

const retryRunOptions = mockObjectArg(subagent.run, "subagent run", 1);

expect(retryRunOptions.sessionKey).toBe(retrySessionKey);

expect(retryRunOptions).not.toHaveProperty("model");

expect(subagent.getSessionMessages).toHaveBeenCalledWith({

sessionKey: retrySessionKey,

limit: 5,

});

expect(subagent.deleteSession).toHaveBeenCalledOnce();

expect(subagent.deleteSession).toHaveBeenCalledWith({ sessionKey: retrySessionKey });

expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining("session default"));

expectLogIncludes(logger.warn, "session default");

});

it("retries with the session default when the configured model run ends unavailable", async () => {

expect(subagent.deleteSession).toHaveBeenCalledTimes(2);

expect(subagent.deleteSession.mock.calls[0]?.[0]).toEqual({ sessionKey: expectedSessionKey });

expect(subagent.deleteSession.mock.calls[1]?.[0]).toEqual({ sessionKey: retrySessionKey });

expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining("unknown model"));

expectLogIncludes(logger.warn, "unknown model");

});

it("does not hide configured model authorization failures by retrying", async () => {

expect(subagent.run).toHaveBeenCalledOnce();

expect(subagent.waitForRun).not.toHaveBeenCalled();

expect(subagent.deleteSession).not.toHaveBeenCalled();

expect(logger.warn).toHaveBeenCalledWith(

expect.stringContaining("narrative generation failed"),

);

expectLogIncludes(logger.warn, "narrative generation failed");

});

it("skips narrative when no snippets are available", async () => {

});

expect(subagent.waitForRun).toHaveBeenCalledOnce();

expect(subagent.waitForRun.mock.calls[0][0]).toMatchObject({ timeoutMs: 60_000 });

expect(logger.warn).toHaveBeenCalledWith(

expect.stringContaining("narrative session cleanup failed for rem phase"),

);

expect(mockObjectArg(subagent.waitForRun, "wait for run").timeoutMs).toBe(60_000);

expectLogIncludes(logger.warn, "narrative session cleanup failed for rem phase");

});

it("handles subagent error gracefully", async () => {

// Should not throw.

expect(logger.warn).toHaveBeenCalled();

await expect(fs.access(path.join(workspaceDir, "DREAMS.md"))).rejects.toMatchObject({

code: "ENOENT",

});

await expectPathMissing(path.join(workspaceDir, "DREAMS.md"));

});

it("falls back to a local narrative when subagent runtime is request-scoped", async () => {

const content = await fs.readFile(path.join(workspaceDir, "DREAMS.md"), "utf-8");

expect(content).toContain("API endpoints need authentication");

expect(logger.info).toHaveBeenCalledWith(expect.stringContaining("request-scoped"));

expect(logger.warn).not.toHaveBeenCalledWith(expect.stringContaining("request-scoped"));

expect(logger.warn).not.toHaveBeenCalledWith(expect.stringContaining(workspaceDir));

expect(logger.warn).not.toHaveBeenCalledWith(

expect.stringContaining("narrative session cleanup failed"),

);

expectLogIncludes(logger.info, "request-scoped");

expectLogExcludes(logger.warn, "request-scoped");

expectLogExcludes(logger.warn, workspaceDir);

expectLogExcludes(logger.warn, "narrative session cleanup failed");

expect(subagent.deleteSession).not.toHaveBeenCalled();

});

const content = await fs.readFile(path.join(workspaceDir, "DREAMS.md"), "utf-8");

expect(content).toContain("A durable candidate surfaced.");

expect(logger.info).toHaveBeenCalledWith(expect.stringContaining("request-scoped"));

expect(logger.warn).not.toHaveBeenCalledWith(expect.stringContaining("request-scoped"));

expectLogIncludes(logger.info, "request-scoped");

expectLogExcludes(logger.warn, "request-scoped");

expect(subagent.deleteSession).not.toHaveBeenCalled();

});

logger,

});

await expect(fs.access(path.join(workspaceDir, "DREAMS.md"))).rejects.toMatchObject({

code: "ENOENT",

});

expect(logger.warn).toHaveBeenCalledWith(

expect.stringContaining("narrative generation failed"),

);

await expectPathMissing(path.join(workspaceDir, "DREAMS.md"));

expectLogIncludes(logger.warn, "narrative generation failed");

});

it("cleans up session even on failure", async () => {

const sessionFiles = await fs.readdir(sessionsDir);

expect(sessionFiles).toContainEqual(expect.stringMatching(/^orphan\.jsonl\.deleted\./));

expect(sessionFiles).toContain("still-live.jsonl");

expect(logger.info).toHaveBeenCalledWith(expect.stringContaining("dreaming cleanup scrubbed"));

expectLogIncludes(logger.info, "dreaming cleanup scrubbed");

});

it("isolates narrative sessions across workspaces even at the same timestamp", async () => {