}

});

it("reconciles disabled->enabled config changes without waiting for another agent turn", async () => {

vi.useFakeTimers();

clearInternalHooks();

const logger = createLogger();

const harness = createCronHarness();

const onMock = vi.fn();

const api: DreamingPluginApiTestDouble = {

config: {

plugins: {

entries: {

"memory-core": {

config: {

dreaming: {

enabled: false,

frequency: "0 2 * * *",

timezone: "UTC",

},

},

},

},

},

},

pluginConfig: {},

logger,

runtime: {},

on: onMock,

};

try {

registerShortTermPromotionDreamingForTest(api);

await triggerGatewayStart(onMock, {

config: api.config,

getCron: () => harness.cron,

});

expect(harness.addCalls).toHaveLength(0);

api.config = {

plugins: {

entries: {

"memory-core": {

config: {

dreaming: {

enabled: true,

frequency: "30 6 * * *",

timezone: "America/New_York",

},

},

},

},

},

} as OpenClawConfig;

await vi.advanceTimersByTimeAsync(constants.RUNTIME_CRON_RECONCILE_INTERVAL_MS);

expect(harness.addCalls).toHaveLength(1);

expectCronSchedule(requireAddCall(harness, 0).schedule, "30 6 * * *", "America/New_York");

} finally {

await triggerGatewayStop(onMock).catch(() => undefined);

vi.useRealTimers();

clearInternalHooks();

}

});

it("reconciles cadence/timezone updates against the active cron service after startup", async () => {

clearInternalHooks();

const logger = createLogger();

let lastRuntimeConfigKey: string | null = null;

let lastRuntimeCronRef: CronServiceLike | null = null;

let startupCronRetryTimer: ReturnType<typeof setTimeout> | null = null;

let runtimeCronReconcileTimer: ReturnType<typeof setInterval> | null = null;

let startupCronRetryAttempts = 0;

let disposed = false;

const disposeStartupCronRetry = (): void => {

disposed = true;

clearStartupCronRetry();

if (runtimeCronReconcileTimer) {

clearInterval(runtimeCronReconcileTimer);

runtimeCronReconcileTimer = null;

}

gatewayContext = null;

resolveStartupCron = null;

};

}, STARTUP_CRON_RETRY_DELAY_MS);

};

const startRuntimeCronReconcileTimer = (): void => {

if (runtimeCronReconcileTimer) {

return;

}

runtimeCronReconcileTimer = setInterval(() => {

void reconcileManagedDreamingCron({ reason: "runtime" }).catch((err) => {

api.logger.error(`memory-core: dreaming cron reconcile failed: ${formatErrorMessage(err)}`);

});

}, RUNTIME_CRON_RECONCILE_INTERVAL_MS);

runtimeCronReconcileTimer.unref?.();

};

api.on("gateway_start", async (_event, ctx) => {

disposed = false;

// Store the gateway context for runtime cron resolution retries.

startupConfig: ctx.config,

startupCron: () => resolveCronServiceFromGatewayContext(ctx),

});

startRuntimeCronReconcileTimer();

scheduleStartupCronRetry();

} catch (err) {

api.logger.error(

DEFAULT_DREAMING_MIN_RECALL_COUNT: DEFAULT_MEMORY_DREAMING_MIN_RECALL_COUNT,

DEFAULT_DREAMING_MIN_UNIQUE_QUERIES: DEFAULT_MEMORY_DREAMING_MIN_UNIQUE_QUERIES,

DEFAULT_DREAMING_RECENCY_HALF_LIFE_DAYS: DEFAULT_MEMORY_DREAMING_RECENCY_HALF_LIFE_DAYS,

RUNTIME_CRON_RECONCILE_INTERVAL_MS,

STARTUP_CRON_RETRY_DELAY_MS,

STARTUP_CRON_RETRY_MAX_ATTEMPTS,

},

expect(requireRecord(await debug.json(), "debug request").imageInputCount).toBe(1);

});

it("answers image prompts when media context is the latest text part", async () => {

const server = await startQaMockOpenAiServer({

host: "127.0.0.1",

port: 0,

});

cleanups.push(async () => {

await server.stop();

});

const response = await fetch(`${server.baseUrl}/v1/responses`, {

method: "POST",

headers: { "content-type": "application/json" },

body: JSON.stringify({

stream: false,

model: "mock-openai/gpt-5.5",

input: [

{

role: "user",

content: [

{ type: "input_text", text: "Image understanding check: what do you see?" },

{

type: "input_image",

source: {

type: "base64",

mime_type: "image/png",

data: QA_IMAGE_PNG_BASE64,

},

},

{

type: "input_text",

text: "[media attached: media://inbound/red-top-blue-bottom.png (image/png)]",

},

],

},

],

}),

});

expect(response.status).toBe(200);

const payload = (await response.json()) as {

output?: Array<{ content?: Array<{ text?: string }> }>;

};

const text = payload.output?.[0]?.content?.[0]?.text ?? "";

expect(text.toLowerCase()).toContain("red");

expect(text.toLowerCase()).toContain("blue");

});

it("lets image prompts beat stale exact marker directives from chat history", async () => {

const server = await startMockServer();

const response = await fetch(`${server.baseUrl}/v1/responses`, {

method: "POST",

headers: { "content-type": "application/json" },

body: JSON.stringify({

stream: false,

model: "mock-openai/gpt-5.5",

input: [

makeUserInput("Control UI bridge check. Marker exact marker: `ui bridge armed`"),

{

role: "assistant",

content: [{ type: "output_text", text: "ui bridge armed" }],

},

{

role: "user",

content: [

{

type: "input_text",

text: "Image understanding check: describe the top and bottom colors.",

},

{

type: "input_image",

source: {

type: "base64",

mime_type: "image/png",

data: QA_IMAGE_PNG_BASE64,

},

},

{

type: "input_text",

text: "[media attached: media://inbound/red-top-blue-bottom.png (image/png)]",

},

],

},

],

}),

});

expect(response.status).toBe(200);

const payload = (await response.json()) as {

output?: Array<{ content?: Array<{ text?: string }> }>;

};

const text = payload.output?.[0]?.content?.[0]?.text ?? "";

expect(text.toLowerCase()).toContain("red");

expect(text.toLowerCase()).toContain("blue");

expect(text).not.toBe("ui bridge armed");

});

it("handles deeply nested image input shapes without recursive traversal failure", async () => {

const server = await startQaMockOpenAiServer({

host: "127.0.0.1",

if (isHeartbeatPrompt(prompt)) {

return "HEARTBEAT_OK";

}

if (/roundtrip image inspection check/i.test(allInputText) && imageInputCount > 0) {

return "Protocol note: the generated attachment shows the same QA lighthouse scene from the previous step.";

}

if (/image understanding check/i.test(allInputText) && imageInputCount > 0) {

return "Protocol note: the attached image is split horizontally, with red on top and blue on the bottom.";

}

if (/\bmarker\b/i.test(allInputText) && exactReplyDirective) {

return exactReplyDirective;

}

"- Re-open the copied file for final verification.",

].join("\n");

}

if (/roundtrip image inspection check/i.test(prompt) && imageInputCount > 0) {

return "Protocol note: the generated attachment shows the same QA lighthouse scene from the previous step.";

}

if (/image understanding check/i.test(prompt) && imageInputCount > 0) {

return "Protocol note: the attached image is split horizontally, with red on top and blue on the bottom.";

}

if (

/interrupted by a gateway reload/i.test(prompt) &&

/subagent recovery worker/i.test(allInputText)

extractExactReplyDirective(prompt) ?? extractExactReplyDirective(allInputText);

const exactMarkerDirective =

extractExactMarkerDirective(prompt) ?? extractExactMarkerDirective(allInputText);

const imageInputCount = countImageInputs(input);

const firstExactMarkerDirective = extractLabeledMarkerDirective(

allInputText,

"first exact marker",

if (/fanout worker beta/i.test(prompt)) {

return buildAssistantEvents("BETA-OK");

}

if (/roundtrip image inspection check/i.test(allInputText) && imageInputCount > 0) {

return buildAssistantEvents(

"Protocol note: the generated attachment shows the same QA lighthouse scene from the previous step.",

);

}

if (/image understanding check/i.test(allInputText) && imageInputCount > 0) {

return buildAssistantEvents(

"Protocol note: the attached image is split horizontally, with red on top and blue on the bottom.",

);

}

if (QA_REASONING_ONLY_RECOVERY_PROMPT_RE.test(allInputText)) {

if (!scenarioToolOutput) {

return buildToolCallEventsWithArgs("read", { path: "QA_KICKOFF_TASK.md" });

- set: sessionKey

value:

expr: "`agent:qa:subagent-direct-fallback:${randomUUID().slice(0, 8)}`"

- call: runAgentPrompt

args:

- ref: env

- sessionKey:

ref: sessionKey

message:

expr: config.prompt

timeoutMs:

expr: liveTurnTimeoutMs(env, 90000)

- call: waitForCondition

saveAs: outbound

args:

- lambda:

expr: "state.getSnapshot().messages.filter((message) => message.direction === 'outbound' && String(message.text ?? '').includes(config.expectedMarker)).at(-1)"

- expr: liveTurnTimeoutMs(env, 60000)

- expr: "env.providerMode === 'mock-openai' ? 100 : 250"

- assert:

expr: "String(outbound.text ?? '').trim().includes(config.expectedMarker)"

message:

expr: "`fallback completion marker missing from outbound QA DM: ${recentOutboundSummary(state)}`"

- try:

actions:

- call: runAgentPrompt

args:

- ref: env

- sessionKey:

ref: sessionKey

message:

expr: config.prompt

timeoutMs:

expr: liveTurnTimeoutMs(env, 90000)

- call: waitForCondition

saveAs: outbound

args:

- lambda:

expr: "state.getSnapshot().messages.filter((message) => message.direction === 'outbound' && String(message.text ?? '').includes(config.expectedMarker)).at(-1)"

- expr: liveTurnTimeoutMs(env, 180000)

- expr: "env.providerMode === 'mock-openai' ? 100 : 250"

- assert:

expr: "String(outbound.text ?? '').trim().includes(config.expectedMarker)"

message:

expr: "`fallback completion marker missing from outbound QA DM: ${recentOutboundSummary(state)}`"

catchAs: fallbackError

catch:

- set: fallbackDebugRequests

value:

expr: "env.mock ? [...(await fetchJson(`${env.mock.baseUrl}/debug/requests`))].slice(-20).map((request) => ({ plannedToolName: request.plannedToolName ?? null, plannedToolArgs: request.plannedToolArgs ?? null, prompt: String(request.prompt ?? '').slice(0, 280), allInputText: String(request.allInputText ?? '').slice(0, 280), toolOutput: request.toolOutput ? String(request.toolOutput).slice(0, 280) : null })) : []"

- set: fallbackTasks

value:

expr: "(await runQaCli(env, ['tasks', 'list', '--json', '--runtime', 'subagent'], { timeoutMs: liveTurnTimeoutMs(env, 60000), json: true }).catch((error) => ({ error: String(error?.message ?? error) })))"

- throw:

expr: "`subagent fallback marker missing: ${fallbackError?.message ?? fallbackError}; outbound=${recentOutboundSummary(state, 8)} tasks=${JSON.stringify(fallbackTasks)} requests=${JSON.stringify(fallbackDebugRequests)}`"

- if:

expr: "Boolean(env.mock)"

then:

args:

- lambda:

expr: "(async () => { const payload = await runQaCli(env, ['tasks', 'list', '--json', '--runtime', 'subagent'], { timeoutMs: liveTurnTimeoutMs(env, 60000), json: true }); return (payload.tasks ?? []).find((task) => task.label === config.expectedLabel && task.deliveryStatus === 'delivered' && task.status === 'succeeded') ?? null; })()"

- expr: liveTurnTimeoutMs(env, 30000)

- expr: liveTurnTimeoutMs(env, 60000)

- 250

- assert:

expr: "deliveredTask.deliveryStatus === 'delivered'"

expr: "!env.mock || Boolean((await fetchJson(`${env.mock.baseUrl}/debug/requests`)).find((request) => request.plannedToolName === 'image_generate' && String(request.prompt ?? '').includes(config.generatePromptSnippet)))"

message: expected image_generate call before roundtrip inspection

- assert:

expr: "!env.mock || (((await fetchJson(`${env.mock.baseUrl}/debug/requests`)).find((request) => String(request.prompt ?? '').includes(config.inspectPrompt))?.imageInputCount ?? 0) >= 1)"

message: expected generated artifact to be reattached on follow-up turn

expr: "!env.mock || (await fetchJson(`${env.mock.baseUrl}/debug/requests`)).some((request) => String(request.prompt ?? '').includes(config.inspectPrompt) && (request.imageInputCount ?? 0) >= 1)"

message:

expr: "`expected generated artifact to be reattached on follow-up turn; recentRequests=${JSON.stringify((await fetchJson(`${env.mock.baseUrl}/debug/requests`)).slice(-12).map((request) => ({ prompt: String(request.prompt ?? '').slice(0, 240), imageInputCount: request.imageInputCount, allInputText: String(request.allInputText ?? '').slice(0, 240) })))}`"

detailsExpr: "`MEDIA:${mediaPath}\\n${outbound.text}`"

```

- lambda:

async: true

expr: "(() => readDoctorMemoryStatus(env).then((payload) => payload.dreaming?.phases?.deep?.managedCronPresent === true ? payload : undefined))()"

- 30000

- expr: liveTurnTimeoutMs(env, 90000)

- 500

- call: listCronJobs

saveAs: jobs

expr: "managed.id"

catchAs: enableError

catch:

- set: enableFailureStatus

value:

expr: "(await readDoctorMemoryStatus(env).catch((error) => ({ error: String(error?.message ?? error) })))"

- set: enableFailureJobs

value:

expr: "(await listCronJobs(env).catch((error) => [{ error: String(error?.message ?? error) }]))"

- call: patchConfig

args:

- env:

- ref: env

- 60000

- throw:

expr: enableError

expr: "`managed dreaming cron missing: ${enableError?.message ?? enableError}; status=${JSON.stringify(enableFailureStatus)} jobs=${JSON.stringify(enableFailureJobs)}`"

detailsExpr: "JSON.stringify({ enabled: status.dreaming?.enabled ?? false, managedCronPresent: status.dreaming?.phases?.deep?.managedCronPresent ?? false, nextRunAtMs: status.dreaming?.phases?.deep?.nextRunAtMs ?? null })"

- name: runs the sweep after repeated recall signals and writes promotion artifacts