Implementation reference

SQLite + vectors

CREATE TABLE memory (
  id         TEXT PRIMARY KEY,
  content    TEXT NOT NULL,
  embedding  BLOB,        -- float32[d] → HNSW/FAISS
  created_at TEXT,
  relevancy  REAL,
  session    TEXT,
  status     TEXT DEFAULT 'active'
);
CREATE INDEX idx_session ON memory(session);

Embed on write, mirror the vector into an HNSW/FAISS ANN index, hydrate rows by id on hit.

Graph store (Cypher-style)

(:Memory {id, content, created_at})

(:Memory)-[:RELATES_TO]->(:Memory)
(:Memory)-[:CONTRADICTS]->(:Memory)
(:Memory)-[:SUPERSEDES]->(:Memory)

Typed traversal index over node/edge types; bound traversals by depth or relevancy.

Markdown

memories/<session>/mem_8f2a1c.md
inverted_index.json   # keyword → [file paths]

Router contract

def route(query: Query) -> Backend:
    if query.kind == "relationship":
        return GRAPH
    if query.needs_semantic:
        return VECTOR
    return MARKDOWN   # literal recall

Start rule-based; later swap the body for a learned classifier over the query embedding + metadata. Same signature, no caller changes.

Dreaming worker

def dream(store: MemoryStore) -> Governance:
    items = list(store.all())
    merge_duplicates(items)      # exact·semantic·near
    resolve_conflicts(items)     # recency·conf·source
    gov = session_rules(items)   # know·do·blacklist
    prune(items)                 # decay + caps
    return gov

Runs asynchronously when the agent is idle; emits a conflict-free state + the per-session governance object the next run loads.

Day Dream (in-session) is fired automatically by the plugin's Stop hook at session end: it reads the session .jsonl logs, tracks processed-vs-delta state (sending only unprocessed entries), calls an OpenRouter model to decide what to remember, then calls the Orchestrator to save it. Dream (night) above is the deep cross-session sweep over the whole store.

Retrieval ranking

score(item, q) = w_r · recency(item)
              + w_s · relevancy(item, q)

recency(item)  = exp(-Δt / τ)     # freshness decay
relevancy(i,q) = cos(emb_i, emb_q)

The four metrics

• Recency — % of queries where the freshest relevant item is ranked #1.
• Efficiency — memory tokens ÷ total tokens; target < 10% overhead.
• Relevancy — mean cosine of retrieved items to query; target > 0.7.
• Accuracy — task success rate, memory-on vs memory-off.