OpenClaw merged a P1 session and memory reliability fix tonight for long agent turns that use Knowledge or other memory-slot tools.
PR #166758, "fix(sessions): Knowledge calls still fail mid-turn while the session's own bookkeeping publishes," targets intermittent failures where memory calls could report that audience currency was unavailable while the same turn was still active.
The failure mode was subtle because the session was not actually reset, replaced, or deleted. It was simply writing its own routine bookkeeping.
The Failure Mode
OpenClaw session writes are committed on a SQLite worker and then installed on the Gateway main thread. While a publication was pending for a session row, synchronous generation reads treated that session's identity and lifecycle revision as unknown.
That is correct for dangerous changes. If a session is reset, replaced, deleted, archived, or loses membership, memory access should stop until the new authority state is clear.
The bug was that harmless metadata writes could trigger the same uncertainty. A long turn may write activity, usage, or cache-state updates while it is still running. Knowledge also re-resolves its principal after internal awaits. Put those together and an agent could hit memory-audience currency failures caused by its own ordinary progress updates.
The PR notes a live example: a 54-minute Knowledge ingestion turn saw nine transient currency failures interleaved with successful Knowledge calls.
What Changed
OpenClaw now records proof for identity-preserving publications. When the SQLite worker commits a publication, it compares the previous and current rows and marks sessions whose sessionId and lifecycleRevision are unchanged.
Synchronous generation reads can ignore pending publications that carry that proof. Prepared reads still join every pending publication, so ordering remains strict for operations that need to observe the effects of in-flight writes.
That distinction is the whole fix:
- Identity-preserving bookkeeping should not block the session's own memory calls.
- Real resets and replacement paths should still make memory unavailable until authority is settled.
- Publication paths without proof keep the existing fence.
The implementation also moves prepared-change record helpers into the SQLite entry-cache publication owner, keeping the authority logic close to the code that proves what changed.
Why It Matters
Knowledge is most valuable during long, stateful turns: ingestion, project research, memory cleanup, documentation passes, and multi-step workflows. Those are exactly the turns most likely to produce internal bookkeeping writes while work is still underway.
Intermittent memory failures inside that shape are frustrating because they feel nondeterministic. The same Knowledge call may fail once, then succeed later, even though the user's session did not visibly change.
This fix makes the memory boundary more precise. OpenClaw can keep rejecting stale or replaced sessions without treating every pending session-row write as an identity event.
Evidence From The PR
The regression tests reproduce the problem with real SQLite behavior. A synchronous assertMemoryAudienceCurrent fails on main during a held identity-preserving publication and passes after the fix, including the case where a child audience depends on a parent's in-flight write.
The control cases still fail when they should. A held reset still blocks synchronous currency checks and then revokes access. Prepared reads still wait for both identity-changing and identity-preserving publications where ordering matters.
The affected session, outbound, subagent, cron, memory audience, provider, and tool suites passed. One legacy ACP metadata migration test timed out during a concurrent heavy run, then passed alone.
Bottom Line
OpenClaw's memory tools should now be steadier during long active turns. Knowledge can continue through ordinary session bookkeeping writes, while real lifecycle changes still preserve the authority boundary that keeps memory access safe.