### Fixes

- Memory/search: stop recall tracking from writing dreaming side-effect artifacts when `dreaming.enabled=false`, while preserving normal search results. Fixes #84436. (#84444) Thanks @NianJiuZst.

- fix(config): validate browser sandbox bind sources [AI]. (#84799) Thanks @pgondhi987.

- doctor: constrain legacy plugin cleanup paths [AI]. (#84801) Thanks @pgondhi987.

- Update/doctor: prune stale local bundled plugin install records that point at old compiled bundled output so current bundled plugin schemas win after upgrade. (#84863) Thanks @fuller-stack-dev.

import os from "node:os";

import path from "node:path";

import type { MemoryEmbeddingProbeResult } from "openclaw/plugin-sdk/memory-core-host-engine-storage";

import { resolveMemoryRemDreamingConfig } from "openclaw/plugin-sdk/memory-core-host-status";

import {

resolveMemoryDreamingConfig,

resolveMemoryRemDreamingConfig,

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

import { buildAgentSessionKey } from "openclaw/plugin-sdk/routing";

import { resolvePreferredOpenClawTmpDir } from "openclaw/plugin-sdk/temp-path";

import {

const { config: cfg, diagnostics } = await loadMemoryCommandConfig("memory search");

emitMemorySecretResolveDiagnostics(diagnostics, { json: Boolean(opts.json) });

const agentId = resolveAgent(cfg, opts.agent);

const memoryPluginConfig = resolveMemoryPluginConfig(cfg);

const dreamingEnabled = resolveMemoryDreamingConfig({

pluginConfig: memoryPluginConfig,

cfg,

}).enabled;

const dreaming = resolveShortTermPromotionDreamingConfig({

pluginConfig: resolveMemoryPluginConfig(cfg),

pluginConfig: memoryPluginConfig,

cfg,

});

await withMemoryManagerForAgent({

typeof (manager as { status?: () => { workspaceDir?: string } }).status === "function"

? manager.status().workspaceDir

: undefined;

void recordShortTermRecalls({

workspaceDir,

query,

results,

timezone: dreaming.timezone,

}).catch(() => {

// Recall tracking is best-effort and must not block normal search results.

});

if (dreamingEnabled) {

void recordShortTermRecalls({

workspaceDir,

query,

results,

timezone: dreaming.timezone,

}).catch(() => {

// Recall tracking is best-effort and must not block normal search results.

});

}

if (opts.json) {

defaultRuntime.writeJson({ results });

return;

source: "memory",

},

]);

getRuntimeConfig.mockReturnValue({

plugins: {

entries: {

"memory-core": {

config: {

dreaming: {

enabled: true,

},

},

},

},

},

});

mockManager({

search,

status: () => makeMemoryStatus({ workspaceDir }),

expect(close).toHaveBeenCalled();

});

});

it("does not record short-term recall entries from memory search when dreaming is disabled", async () => {

await withTempWorkspace(async (workspaceDir) => {

const close = vi.fn(async () => {});

const search = vi.fn(async () => [

{

path: "memory/2026-04-03.md",

startLine: 1,

endLine: 2,

score: 0.91,

snippet: "Move backups to S3 Glacier.",

source: "memory",

},

]);

getRuntimeConfig.mockReturnValue({

plugins: {

entries: {

"memory-core": {

config: {

dreaming: {

enabled: false,

},

},

},

},

},

});

mockManager({

search,

status: () => makeMemoryStatus({ workspaceDir }),

close,

});

const writeJson = spyRuntimeJson(defaultRuntime);

await runMemoryCli(["search", "glacier", "--json"]);

const payload = firstWrittenJsonArg<{ results: Array<{ path: string }> }>(writeJson);

if (!payload) {

throw new Error("Expected memory search JSON payload");

}

expect(payload.results).toHaveLength(1);

expect(payload.results[0]?.path).toBe("memory/2026-04-03.md");

await expectPathMissing(

path.join(workspaceDir, "memory", ".dreams", "short-term-recall.json"),

);

expect(close).toHaveBeenCalled();

});

});

});

},

]);

const tool = createMemorySearchToolOrThrow();

const tool = createMemorySearchToolOrThrow({

config: asOpenClawConfig({

agents: { list: [{ id: "main", default: true }] },

plugins: {

entries: {

"memory-core": {

config: {

dreaming: {

enabled: true,

},

},

},

},

},

}),

});

await tool.execute("call_recall_persist", { query: "glacier backup" });

const storePath = path.join(workspaceDir, "memory", ".dreams", "short-term-recall.json");

const tool = createSearchTool(

asOpenClawConfig({

agents: { list: [{ id: "main", default: true }] },

plugins: {

entries: {

"memory-core": {

config: {

dreaming: {

enabled: true,

},

},

},

},

},

memory: {

backend: "qmd",

citations: "on",

const tool = createSearchTool(

asOpenClawConfig({

agents: { list: [{ id: "main", default: true }] },

plugins: {

entries: {

"memory-core": {

config: {

dreaming: {

enabled: true,

},

},

},

},

},

}),

);

setMemorySearchImpl(async () => [

"memory-core": {

config: {

dreaming: {

enabled: true,

timezone: "Europe/London",

},

},

const [firstCall] = recallTrackingMock.recordShortTermRecalls.mock.calls;

expect(firstCall?.[0]?.timezone).toBe("Europe/London");

});

it("skips recall tracking when dreaming is disabled", async () => {

setMemorySearchImpl(async () => [

{

path: "memory/2026-04-03.md",

startLine: 1,

endLine: 2,

score: 0.95,

snippet: "Move backups to S3 Glacier.",

source: "memory" as const,

},

]);

const tool = createSearchTool(

asOpenClawConfig({

agents: { list: [{ id: "main", default: true }] },

plugins: {

entries: {

"memory-core": {

config: {

dreaming: {

enabled: false,

},

},

},

},

},

}),

);

const result = await tool.execute("call_recall_disabled", { query: "glacier" });

const details = result.details as { results: Array<{ path: string }> };

expect(details.results).toHaveLength(1);

expect(details.results[0]?.path).toBe("memory/2026-04-03.md");

expect(recallTrackingMock.recordShortTermRecalls).not.toHaveBeenCalled();

});

});

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

import {

resolveMemoryCorePluginConfig,

resolveMemoryDreamingConfig,

resolveMemoryDeepDreamingConfig,

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

import { filterMemorySearchHitsBySessionVisibility } from "./session-search-visibility.js";

mode: citationsMode,

sessionKey: options.agentSessionKey,

});

const pluginConfig = resolveMemoryCorePluginConfig(cfg);

const dreamingEnabled = resolveMemoryDreamingConfig({

pluginConfig,

cfg,

}).enabled;

const dreaming = resolveMemoryDeepDreamingConfig({

pluginConfig,

cfg,

});

const searchStartedAt = Date.now();

let rawResults: MemorySearchResult[] = [];

let surfacedMemoryResults: Array<MemorySearchResult & { corpus: MemorySource }> = [];

...result,

corpus: result.source,

}));

const sleepTimezone = resolveMemoryDeepDreamingConfig({

pluginConfig: resolveMemoryCorePluginConfig(cfg),

cfg,

}).timezone;

queueShortTermRecallTracking({

workspaceDir: status.workspaceDir,

query,

rawResults,

surfacedResults: memoryResults,

timezone: sleepTimezone,

});

if (dreamingEnabled) {

queueShortTermRecallTracking({

workspaceDir: status.workspaceDir,

query,

rawResults,

surfacedResults: memoryResults,

timezone: dreaming.timezone,

});

}

provider = status.provider;

model = status.model;

fallback = status.fallback;