A single shared store gives workers persistent memory across sessions: decisions, rules, project state, reference pointers, and corrections. It is the collective layer — every worker reads and writes it.

The store

E:\memory\memory-sqlite.db (served by the memory-vector MCP server):

• memories table — ~208 active entries (content, tags, type, created_at, confidence, superseded_by, deleted_at).
• memory_content_fts — FTS5 bm25 index.
• memory_embeddings — sqlite-vec, 384-dim cosine (all-MiniLM-class), one vector per entry.

The save contract

Every entry follows one shape so the store stays consistent:

• One atomic fact per entry.
• type = decision | planning | reference | learning.
• tags = a category tag + 1–3 topics + exactly one project tag.
• Dedupe first (memory_search → memory_update by content_hash, else memory_store).
• Rules/decisions end with Why:.
• Corrections overwrite or delete the wrong entry — no stale entries, no "supersedes" narration.

Project-tag taxonomy

One reserved project-tag set: all (cross-project) · blockdata · kai-chattr · kai · chattr (legacy) · writing-system (legacy). Cross-project entries are tagged all plus every active rebuild slug, so querying a single project tag automatically surfaces both that project's entries and every all entry. There is no global tag (retired).

E:\hooks\normalize-memory-tags.py enforces this on the store (rewrites legacy global → all, reports untagged entries). Run it to keep tags clean.

Recall

The UserPromptSubmit hook pushes ranked, project-scoped recall into every prompt — FTS bm25 → gap floor → blended (relevance + recency + confidence) → top 3. Workers don't have to remember to search; relevant memory arrives in context.

Caveat: semantic/hybrid ranking has proven unreliable for recalling specific known facts — exact bm25 keyword is essential. The planned upgrade is a warm hybrid + reranker + relevance-threshold retriever serving both memory and skills.

Where it's heading

Two layers:

1. Collective memory — this shared vector store (above), unchanged.
2. Per-agent identity — a per-agent store holding identity + role + private memory blocks, provisioned from role templates, extracted clean-room from Letta's block model (not a runtime dependency).

The reference implementation for the collective/retrieval half is Hindsight (MIT) — retain / recall / reflect with parallel semantic + BM25 + graph + temporal retrieval; under evaluation as run-as-is vs. extract.