Memory System — agent-core to Exo Mapping

# Agent-core: monolithic
memory_manager = MemoryManager(config, encryption_key=key)
await memory_manager.store(content, memory_type=MemoryType.SEMANTIC_MEMORY)
await memory_manager.search("query")

# Exo: composable protocol-based
from exo.memory import (
    ShortTermMemory, EncryptedMemoryStore, MemUpdateChecker,
    SearchManager, MemoryCategory, HumanMemory
)

store = ShortTermMemory()
encrypted = EncryptedMemoryStore(store, key=aes_key)
dedup = MemUpdateChecker(checker=my_llm_call)
search = SearchManager(stores=[encrypted])

DRAFT ──→ ACCEPTED ──→ DISCARD
  │                        ▲
  └────────────────────────┘

# Agent-core
memory_manager = MemoryManager(config, encryption_key="my-password")
await memory_manager.store(
    content="User prefers dark mode",
    memory_type=MemoryType.USER_PROFILE,
)

# Exo
from exo.memory import (
    EncryptedMemoryStore, ShortTermMemory, HumanMemory,
    MemoryCategory, MemoryMetadata,
)
from exo.memory.encrypted import derive_key

key, salt = derive_key("my-password")
store = ShortTermMemory()
encrypted = EncryptedMemoryStore(store, key=key)

item = HumanMemory(
    content="User prefers dark mode",
    category=MemoryCategory.USER_PROFILE,
    metadata=MemoryMetadata(user_id="user-123"),
)
await encrypted.add(item)  # content encrypted transparently

# Retrieval decrypts automatically
result = await encrypted.get(item.id)
assert result.content == "User prefers dark mode"

# Agent-core
checker = MemUpdateChecker(llm_call=my_llm)
result = checker.check(new_memory, existing_memories)
if result.decision == "add":
    await memory_manager.store(new_memory)
elif result.decision == "merge":
    await memory_manager.update(result.merged_content)

# Exo
from exo.memory import MemUpdateChecker, UpdateDecision

checker = MemUpdateChecker(checker=my_llm_call, top_k=5)
result = await checker.check(new_item, existing_items)

if result.decision == UpdateDecision.ADD:
    await store.add(new_item)
elif result.decision == UpdateDecision.MERGE:
    merged = new_item.model_copy(update={"content": result.merged_content})
    for old_id in result.delete_ids:
        old = await store.get(old_id)
        if old:
            old.transition(MemoryStatus.DISCARD)
    await store.add(merged)

# Agent-core
# Migrations run automatically on initialization

# Exo
from exo.memory.migrations import Migration, MigrationRegistry, run_migrations

registry = MigrationRegistry()
registry.register(Migration(
    version=1,
    description="Add embedding column",
    up=lambda db: db.execute("ALTER TABLE memories ADD COLUMN embedding BLOB"),
))

applied = await run_migrations(sqlite_store, registry)
# Returns count of newly applied migrations

# Agent-core
results = await memory_manager.search("dark mode preference")

# Exo
from exo.memory import SearchManager, MemoryCategory

manager = SearchManager(stores=[short_term, long_term, vector_store])
results = await manager.search(
    "dark mode preference",
    category=MemoryCategory.USER_PROFILE,
    limit=10,
)
# Queries all stores in parallel, deduplicates, sorts by newest first