Skip to content

V3.5.0

Choose a tag to compare

View all tags
@liuqin164 liuqin164 released this 20 Jun 14:14
· 4 commits to main since this release
3.5.0
e542f84
This commit was created on GitHub.com and signed with GitHub’s verified signature.
GPG key ID: B5690EEEBB952194
Verified
Learn about vigilant mode.

Cogmem 3.5.0 — Episode Dream Engine v1

Cogmem 3.5.0 introduces Episode Dream Engine v1.

This release upgrades Cogmem’s memory consolidation model from raw-turn digestion to governed episode-based dream processing.

Raw events are still written immediately and remain the authoritative evidence layer. The new Episode Assembler groups related raw messages into auditable conversation episodes. Dream then processes sealed episodes through an explicit conditional scheduler, producing candidates that still require CPU governance before becoming durable memory.

The core rule of this release is:

Raw Ledger writes immediately.
Episode Assembler groups events.
Dream processes sealed episodes.
Governance decides durable memory.

Highlights

  • Added Episode Assembler.

  • Added Episode Store.

  • Added episode lifecycle: open, soft-sealed, sealed.

  • Added episode closure receipts.

  • Added turn relation classification.

  • Added session-scoped event grouping.

  • Added safe soft reopen.

  • Added hard-seal protection.

  • Added episode Dream backlog.

  • Added leased, retryable Dream jobs.

  • Added conditional Dream Scheduler.

  • Added cogmem episode CLI.

  • Added cogmem dream CLI.

  • Added MCP tools for hookless agents:

    • cogmem_episode_append
    • cogmem_episode_import
    • cogmem_episode_status
    • cogmem_episode_seal
    • cogmem_dream_tick
    • cogmem_dream_status

  • Added Hermes/OpenClaw import convergence through the same episode pipeline.

  • Added idempotent source-message import keys.

  • Added recovery for partially written episode messages.

  • Added migration 0022_episode_dream_engine.

  • Added BrainEval episode/dream release gates.

  • Updated OpenClaw live ingestion path to assemble episodes.

  • Updated Dream Curator to support episode-scoped runs.

  • Updated memory map and maintenance tick with episode/dream state.

  • Updated release metadata to 3.5.0.

What Changed

Before 3.5.0, Dream primarily worked over raw event windows.

In 3.5.0, Dream primarily works over sealed episodes.

Old model:

raw event window
→ dream
→ candidates
→ governance

New model:

raw events
→ episode assembler
→ sealed episode
→ dream tick
→ candidates
→ governance

This prevents incomplete conversations, temporary context, or isolated fragments from being crystallized into long-term memory too early.

Episode Assembler

A new Episode Assembler groups raw user, assistant, tool, system, agent, and narrator messages into session-scoped conversation episodes.

The assembler identifies turn relations such as:

continues_previous
clarifies_previous
corrects_previous
answers_assistant_question
accepts_assistant_proposal
rejects_assistant_proposal
switches_topic
starts_new_topic
returns_to_old_topic
confirms_future_intent
closes_episode
noise

Episode types include:

discussion
decision
correction
preference
goal
debugging
planning
prospective
general

Episode statuses:

open
soft_sealed
sealed

The assembler is deterministic and CPU-first.

It does not directly create durable beliefs, entities, temporal records, or prospective confirmations.

Episode Lifecycle

Open episode

An episode remains open while related turns continue.

Soft-sealed episode

A soft-sealed episode is created when a conversation appears idle or temporarily complete.

Soft-sealed episodes can reopen when a later message returns to the same session/topic within the reopen window.

Sealed episode

A sealed episode is ready for Dream processing.

Hard-sealed episodes do not auto-reopen.

Episodes can be sealed by:

explicit user closure
explicit topic switch
manual seal
batch import boundary
idle soft seal stabilization

Closure Receipts

Every sealed episode produces an auditable closure receipt.

A closure receipt records:

receiptId
episodeId
projectId
closureMode
closureReason
sourceEventIds
startSeq
endSeq
topicPath
episodeType
importance
dreamRecommended
dreamMode
createdAt

This makes episode boundary decisions inspectable and repairable.

Noise Handling

Operational or low-value turns such as simple acknowledgements can be marked as ignored.

Ignored events remain in Raw Ledger, but they are not assigned to episodes or counted as unassigned work.

This prevents greetings and short acknowledgements from polluting Dream backlog.

Cogmem Context Hygiene

Episode assembly strips Cogmem context blocks before classification or summaries.

The following blocks cannot become user evidence through episode assembly or Dream:

<COGMEM_RECALL_CONTEXT>
<COGMEM_TURN_BRIDGE>
<COGMEM_SESSION_STATE>
<COGMEM_STRATEGY_CONTEXT>

Raw events are still preserved for audit, but injected Cogmem context is not treated as user-authored memory.

Episode Store

The new Episode Store persists:

memory_episodes
memory_episode_events
episode_closure_receipts
episode_dream_jobs
episode_dream_runs
episode_ingest_keys
episode_event_dispositions

It provides:

createEpisode
findActiveEpisode
appendEvent
sealEpisode
reopenSoftEpisode
sealIdleEpisodes
finalizeMatureSoftSeals
claimDreamJobs
completeDreamJob
failDreamJob
retryFailed
getDreamStatus
countUnassignedRawEvents
deleteByProject

One raw event can belong to only one episode.

Duplicate episode assignment is prevented.

Conditional Dream Scheduler

A new Dream Scheduler runs explicit conditional ticks.

It does not run continuously.

It does not start a hidden daemon.

It does not run during recall.

It does not execute tools.

A tick can select:

none
micro
normal
deep

Auto mode chooses based on sealed episode backlog.

Default mode limits:

micro: 1 episode
normal: 10 episodes
deep: 50 episodes

If no sealed episode backlog exists, the tick returns skipped with:

no_sealed_episode_backlog

Leased and Retryable Dream Jobs

Episode Dream jobs are leased before processing.

This prevents duplicate concurrent processing.

A Dream job records:

episodeId
projectId
state
priority
modeHint
attempts
leaseId
leaseUntil
lastError
candidateIds
createdAt
updatedAt

Expired leases are recovered.

Jobs below the attempt limit return to pending.

Jobs at or above the attempt limit become failed.

Failed jobs can be manually retried.

Episode-Scoped Dream Curator

Dream Curator now supports episode-scoped runs.

Episode Dream passes exact raw event IDs from a sealed episode into the curator.

Each episode-derived candidate includes:

sourceEpisodeId
raw event evidence
evidenceAuthority: raw_event_ids_only

Episode summaries and closure receipts are metadata, not evidence.

Durable memory still requires exact raw event evidence.

Candidate-Only Dream Output

Dream continues to produce candidates only.

Dream cannot:

promote memory
rewrite verified facts
merge entities
confirm prospective memory
execute tools
delete memory
bypass governance

All durable memory writes remain governed by CPU validation.

User-owned durable memory still requires explicit user-role raw evidence.

Assistant messages may provide context but cannot create user preferences, goals, corrections, or boundaries unless confirmed by user evidence.

Tool results remain observations only.

OpenClaw Live Path

OpenClaw-style hook-based agents now write raw events and assemble episodes in the foreground path.

Live turn flow:

write user raw event
write assistant raw event
bind user raw event
assemble episode turn
return without Dream

If binding or episode assembly fails, the failure is recorded as non-fatal telemetry.

Raw Ledger remains authoritative.

Dream is never run as part of foreground recall or turn recording.

Hermes and Hookless Agent Support

Cogmem 3.5.0 adds full support for Hermes-style agents that primarily interact through MCP or command imports.

Hookless ingestion can use:

cogmem episode append
cogmem episode import
cogmem_episode_append
cogmem_episode_import

Both live hook ingestion and batch/MCP import converge into the same internal pipeline:

Raw Ledger
→ Episode Assembler
→ Episode Store
→ Dream Backlog
→ Dream Scheduler
→ Dream Curator
→ Governance

There is no separate OpenClaw-only memory path.

There is no separate Hermes-only memory path.

cogmem episode CLI

A new CLI was added:

cogmem episode append
cogmem episode import
cogmem episode list
cogmem episode get
cogmem episode seal
cogmem episode status
cogmem episode repair

Examples:

cogmem episode append \
  --project hermes \
  --session session-1 \
  --source-agent hermes \
  --role user \
  --text "Remember that Dream should process sealed episodes only." \
  --external-id msg-1 \
  --json
cogmem episode import \
  --project hermes \
  --session session-1 \
  --source-agent hermes \
  --format jsonl \
  --file session.jsonl \
  --seal-batch \
  --json

Episode import does not run Dream implicitly.

It returns:

imported
duplicates
episodeIds
unassignedEventIds
ignoredEventIds
closureReceipts
dreamRan: false

cogmem dream CLI

A new CLI was added:

cogmem dream tick
cogmem dream status
cogmem dream retry

Example:

cogmem dream tick --project hermes --mode auto --json

A Dream tick is explicit and conditional.

It processes sealed episodes only.

It does not execute tools.

It does not bypass governance.

MCP Tools

New MCP tools were added for hookless agents:

cogmem_episode_append
cogmem_episode_import
cogmem_episode_status
cogmem_episode_seal
cogmem_dream_tick
cogmem_dream_status

cogmem_episode_append

Appends one bounded raw message and assigns it to a session episode.

It never runs Dream.

It never promotes durable memory.

cogmem_episode_import

Imports up to 200 bounded messages into Raw Ledger and the shared Episode Assembler.

Dream is never implicit.

cogmem_episode_status

Inspects open/sealed episodes and Dream backlog.

Read-only.

cogmem_episode_seal

Explicitly seals one episode and enqueues it for conditional Dream processing.

cogmem_dream_tick

Runs one explicit conditional Dream tick over sealed episodes only.

It creates candidates but does not execute tools or bypass governance.

cogmem_dream_status

Inspects the episode Dream backlog without running consolidation.

Read-only.

Idempotent Imports

Episode ingestion supports stable source-message identity.

The identity is scoped by:

projectId
sourceAgent
sourceSessionId
externalMessageId

Re-importing the same message returns a duplicate result without writing a new raw event.

Reusing the same identity for different content is rejected.

Reserved ingest identities can recover a missing Raw Ledger write.

This makes Hermes-style batch import safe to rerun.

Import Path Updates

Existing OpenClaw and Hermes importers now anchor raw records through the shared Episode Assembler.

After import, related episodes are batch-sealed.

This means imported history can be processed by the same Dream Scheduler used for live sessions.

Import path:

source adapter
→ batch envelope
→ raw evidence
→ episode assignment
→ batch seal
→ Dream backlog

Migration 22

A new migration was added:

0022_episode_dream_engine

It creates:

memory_episodes
memory_episode_events
episode_closure_receipts
episode_dream_jobs
episode_dream_runs
episode_ingest_keys
episode_event_dispositions

It also adds indexes for:

episode scope lookup
episode event ordering
closure receipt lookup
Dream job queue ordering
Dream run lookup
ingest identity uniqueness
event disposition lookup

Core schema version is now:

22

Memory Map and Maintenance Tick

The memory map now exposes:

Episode Assembler
Episode Dream
unassigned raw events
sealed episode Dream backlog

Maintenance tick can now suggest:

cogmem dream tick --mode auto
cogmem episode repair
cogmem memory govern
cogmem memory bind

This keeps upkeep explicit and host-owned.

Core still starts no hidden daemon.

BrainEval Episode Gates

BrainEval now includes episode/dream metrics:

episodeGroupingAccuracy
episodeBoundaryAccuracy
episodeEvidenceCoverage
unassignedRawRate
dreamCandidateGrounding
dreamBypassRate
hermesImportParity

New release gates include:

episodeGroupingAccuracy >= 0.90
episodeBoundaryAccuracy >= 0.90
episodeEvidenceCoverage >= 0.95
unassignedRawRate = 0
dreamCandidateGrounding = 1
dreamBypassRate = 0
hermesImportParity = 1

These gates ensure Episode Dream remains source-grounded and governance-safe.

Public API Updates

The public API now exports:

EpisodeAssembler
EpisodeStore
classifyTurnRelation
DreamScheduler
DreamTickOptions
DreamTickResult
EpisodeClosureReceipt
EpisodeDreamStatus
EpisodeListOptions
EpisodeMessageInput
EpisodeMessageResult
MemoryEpisode

This allows host adapters and agent integrations to use the episode/dream workflow directly.

Tests Added

New tests cover:

  • turn relation classification;
  • continuation/correction/closure/noise/topic-switch separation;
  • topic switch sealing the previous episode;
  • noise staying raw without becoming unassigned work;
  • cross-project raw evidence rejection;
  • live OpenClaw-style turns assembling into one session episode;
  • explicit user closure hard-sealing an episode;
  • idle soft seal reopen;
  • hard-seal non-reopen;
  • Dream tick ignoring open episodes;
  • sealed episode Dream processing;
  • candidate sourceEpisodeId preservation;
  • no duplicate Dream processing;
  • auto scheduler mode selection;
  • explicit deep mode;
  • failed job retry;
  • expired Dream lease recovery;
  • Cogmem context block hygiene;
  • MCP episode append;
  • MCP episode import;
  • idempotent append;
  • identity conflict rejection;
  • import batch validation before writes;
  • deterministic import ids;
  • CLI episode import idempotency;
  • CLI dream tick processing a batch-sealed episode.

Current Scope

Cogmem 3.5.0 is Episode Dream Engine v1.

It intentionally does not add:

always-on LLM monitoring
hidden background daemon
foreground Dream during recall
automatic durable memory promotion
tool execution from Dream
LLM-owned governance

The release implements the safe version:

raw writes immediately
episode assembly is bounded and auditable
Dream runs only on sealed episodes
Dream produces candidates only
governance remains mandatory
hookless agents use MCP/import path
Assets 2
Loading