From 67afcd90d9b07652b51c7f0044d5c054a44c38be Mon Sep 17 00:00:00 2001 From: chaithanyak42 Date: Thu, 2 Apr 2026 12:51:22 +0530 Subject: [PATCH] =?UTF-8?q?fix(openclaw):=20dream=20gate=20correctness=20?= =?UTF-8?q?=E2=80=94=20cheap-first,=20session-keyed,=20verified?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Three fixes to the auto-dream gate mechanism: 1. Cheap gates first: checkCheapGates() (local file reads for time + session count) runs BEFORE any API call. provider.getAll() only executes if both cheap gates pass. Previously every turn downloaded the entire memory set just to compute memCount. 2. Session-keyed dream tracking: dreamSessionId replaces the process-global dreamJustRan boolean. Only the session that triggered dream can complete it. Prevents cross-session false completion. 3. Verified completion: agent_end checks event.messages for actual memory tool calls (memory_store, memory_update, memory_forget, memory_list). If the model ignored the dream prompt and just answered the user, the lock releases but completion is NOT recorded. Gates will re-trigger on the next eligible turn. Co-Authored-By: Claude Opus 4.6 (1M context) --- openclaw/dream-gate.ts | 49 ++++++++++++++++-------------- openclaw/index.ts | 69 +++++++++++++++++++++++++++++------------- 2 files changed, 75 insertions(+), 43 deletions(-) diff --git a/openclaw/dream-gate.ts b/openclaw/dream-gate.ts index 3b8cc46f2..028382a88 100644 --- a/openclaw/dream-gate.ts +++ b/openclaw/dream-gate.ts @@ -92,38 +92,43 @@ export function incrementSessionCount(stateDir: string, sessionId: string): void // ============================================================================ /** - * Check all three gates. Returns true only if ALL pass. - * Gates are checked cheapest-first (time, session, memory). + * Check cheap gates (time + sessions). These are local file reads only. + * Call this BEFORE any API calls. If this fails, skip the expensive + * memory count check entirely. */ -export async function shouldDream( +export function checkCheapGates( stateDir: string, - config: { minHours?: number; minSessions?: number; minMemories?: number }, - memoryCount: number, -): Promise<{ pass: boolean; reason?: string }> { - const cfg: DreamGateConfig = { - minHours: config.minHours ?? DEFAULTS.minHours, - minSessions: config.minSessions ?? DEFAULTS.minSessions, - minMemories: config.minMemories ?? DEFAULTS.minMemories, - }; - + config: { minHours?: number; minSessions?: number }, +): { proceed: boolean; reason?: string } { + const minHours = config.minHours ?? DEFAULTS.minHours; + const minSessions = config.minSessions ?? DEFAULTS.minSessions; const state = readState(stateDir); - // Gate 1: Time + // Gate 1: Time (one local file read) const hoursSince = (Date.now() - state.lastConsolidatedAt) / 3_600_000; - if (hoursSince < cfg.minHours) { - return { pass: false, reason: `time: ${hoursSince.toFixed(1)}h < ${cfg.minHours}h` }; + if (hoursSince < minHours) { + return { proceed: false, reason: `time: ${hoursSince.toFixed(1)}h < ${minHours}h` }; } - // Gate 2: Sessions - if (state.sessionsSince < cfg.minSessions) { - return { pass: false, reason: `sessions: ${state.sessionsSince} < ${cfg.minSessions}` }; + // Gate 2: Sessions (same file, already read) + if (state.sessionsSince < minSessions) { + return { proceed: false, reason: `sessions: ${state.sessionsSince} < ${minSessions}` }; } - // Gate 3: Memory count - if (memoryCount < cfg.minMemories) { - return { pass: false, reason: `memories: ${memoryCount} < ${cfg.minMemories}` }; - } + return { proceed: true }; +} +/** + * Check expensive memory count gate. Only call AFTER checkCheapGates passes. + */ +export function checkMemoryGate( + memoryCount: number, + config: { minMemories?: number }, +): { pass: boolean; reason?: string } { + const minMemories = config.minMemories ?? DEFAULTS.minMemories; + if (memoryCount < minMemories) { + return { pass: false, reason: `memories: ${memoryCount} < ${minMemories}` }; + } return { pass: true }; } diff --git a/openclaw/index.ts b/openclaw/index.ts index 301074c17..2485e29e4 100644 --- a/openclaw/index.ts +++ b/openclaw/index.ts @@ -48,7 +48,8 @@ import { import { recall as skillRecall, sanitizeQuery } from "./recall.ts"; import { incrementSessionCount, - shouldDream, + checkCheapGates, + checkMemoryGate, acquireDreamLock, releaseDreamLock, recordDreamCompletion, @@ -1306,23 +1307,29 @@ function registerHooks( api.logger.info("openclaw-mem0: skills-mode recall strategy=manual, agent controls search"); } - // Auto-dream: check gates and inject consolidation protocol if due + // Auto-dream: check CHEAP gates first (local file reads only). + // Only hit the API for memory count if time + session gates pass. const stateDir = session.getStateDir(); const dreamEnabled = cfg.skills?.dream?.enabled !== false && cfg.skills?.dream?.auto !== false; let dreamContext = ""; if (dreamEnabled && stateDir && !isSubagent) { try { - const memories = await provider.getAll({ user_id: userId, source: "OPENCLAW" }); - const memCount = Array.isArray(memories) ? memories.length : 0; - const gateResult = await shouldDream(stateDir, cfg.skills?.dream ?? {}, memCount); - if (gateResult.pass && acquireDreamLock(stateDir)) { - const dreamPrompt = loadDreamPrompt(cfg.skills ?? {}); - if (dreamPrompt) { - dreamContext = "\n\n\nIMPORTANT: Before responding to the user, run a memory consolidation pass. Follow the protocol below, then respond normally.\n\n" + dreamPrompt + "\n"; - dreamJustRan = true; - api.logger.info(`openclaw-mem0: auto-dream triggered (${memCount} memories, gate passed)`); - } else { - releaseDreamLock(stateDir); + const cheapResult = checkCheapGates(stateDir, cfg.skills?.dream ?? {}); + if (cheapResult.proceed) { + // Cheap gates passed. Now do the expensive memory count check. + const memories = await provider.getAll({ user_id: userId, source: "OPENCLAW" }); + const memCount = Array.isArray(memories) ? memories.length : 0; + const memResult = checkMemoryGate(memCount, cfg.skills?.dream ?? {}); + if (memResult.pass && acquireDreamLock(stateDir)) { + const dreamPrompt = loadDreamPrompt(cfg.skills ?? {}); + if (dreamPrompt) { + dreamContext = "\n\n\nIMPORTANT: Before responding to the user, run a memory consolidation pass. Follow the protocol below, then respond normally.\n\n" + dreamPrompt + "\n"; + // Track which session triggered dream (session-keyed, not global) + dreamSessionId = sessionId; + api.logger.info(`openclaw-mem0: auto-dream triggered (${memCount} memories, gate passed)`); + } else { + releaseDreamLock(stateDir); + } } } } catch (err) { @@ -1336,8 +1343,9 @@ function registerHooks( }; }); - // Skills mode: NO auto-capture. Track sessions for dream gating. - let dreamJustRan = false; + // Session-keyed dream tracking. Only the session that triggered dream + // can complete it. Prevents cross-session false completion. + let dreamSessionId: string | undefined; api.on("agent_end", async (event: any, ctx: any) => { if (!event.success) return; @@ -1345,13 +1353,32 @@ function registerHooks( const trigger = ctx?.trigger ?? undefined; if (sessionId) session.setCurrentSessionId(sessionId); - // If dream just ran, release lock and record completion + // If dream was triggered for THIS session, check if it actually ran const stateDir = session.getStateDir(); - if (dreamJustRan && stateDir) { - releaseDreamLock(stateDir); - recordDreamCompletion(stateDir); - api.logger.info("openclaw-mem0: auto-dream completed, lock released"); - dreamJustRan = false; + if (dreamSessionId && dreamSessionId === sessionId && stateDir) { + // Verify the model actually called memory tools (not false completion). + // Check event.messages for memory_store, memory_update, memory_forget tool calls. + const messages = event.messages ?? []; + const dreamToolsUsed = messages.some((m: any) => { + if (m.role !== "assistant") return false; + const content = Array.isArray(m.content) ? m.content : []; + return content.some((block: any) => + block.type === "tool_use" && + ["memory_store", "memory_update", "memory_forget", "memory_delete_all", "memory_list"].includes(block.name) + ); + }); + + if (dreamToolsUsed) { + releaseDreamLock(stateDir); + recordDreamCompletion(stateDir); + api.logger.info("openclaw-mem0: auto-dream completed (verified tool usage), lock released"); + } else { + // Model did not run dream tools. Release lock but do NOT record completion. + // Gates will re-trigger on the next eligible turn. + releaseDreamLock(stateDir); + api.logger.warn("openclaw-mem0: auto-dream injected but model did not execute consolidation. Lock released, will retry."); + } + dreamSessionId = undefined; return; }