Continuous decaying working memory (global + per-project) that seeds new sessions

[RyanSeanPhillips]

Summary

A background loop that continuously distills conversations into a decaying, tiered working memory — global + per-project — that new sessions pull from to seed context. The capstone of the memory roadmap (depends on the cross-vendor index #11).

Why cldctrl is positioned for this

The moving parts already exist: the daemon (background, ~5min cadence), the conversation index with incremental (mtime/byte-offset) parsing — cross-vendor via #11, the summarizer (core/summaries.ts, claude --print), the control-plane per-project store + recaps/, and the MCP surface to seed/serve memory to any agent (Claude or Codex).

Design

1. Background extractor (daemon job). Each tick, for sessions with NEW turns only (incremental), distill salient facts/decisions/open-threads into memory entries tagged scope: global | project:<path>. Use a cheap model (Haiku) + batching; throttle to daemon cadence.
2. Tiered time-decay ("memory pyramid"). Recent entries verbose; as they age, progressively re-summarize (detail decays): last-day detailed → last-week summarized → older collapses to a one-line gist and falls back to the long-term search index. Keeps working memory bounded + recency-rich without context pollution. Decay policy configurable.
3. Two scopes. Global working memory (current focus, recent cross-project decisions/prefs) + per-project working memory (where we left off, open threads, decisions).
4. Seeding new conversations. On launch_session in project X, OFFER to inject that project's working memory (+ relevant global bits) into the kickoff — prefill + confirm (same model as cross-project coordination Cross-project coordination: a driver conversation that reads, dispatches, and verifies across projects #10) — and/or a get_working_memory({project}) MCP tool the agent pulls on demand.

Prior art to borrow from

• Stanford "Generative Agents" memory stream: score memories by recency + importance + relevance; periodic reflection synthesizes higher-level memories. ("Time decay on level of detail" ≈ reflection + recency weighting.)
• MemGPT/Letta: tiered memory paging (what's in context vs recall vs archival).
• mem0 / Zep: managed decay/summarization; Zep adds a temporal knowledge graph.

Risks / mitigations

• Cost: changed-sessions-only, batch, cheap model, daemon throttle.
• Trust: auto-extracted memory can be wrong; bad seed context is worse than none → make it visible + editable (dashboard "working memory" panel with pin/forget) and confirm-before-seed. Advisory, never silently authoritative.
• Scope bleed: explicit global-vs-project rules; user can correct/move.
• Privacy: all local (fits the data-stays-local edge).

Dependencies / order

Substrate = #11 (cross-vendor conversation index). Then the three-tier memory model: long-term search (built) → semantic/vector layer → this continuous working-memory loop. Relates to #10 (coordination uses the same prefill+confirm seeding) and the three-tier memory note.

[RyanSeanPhillips]

Design lens — borrow from how human memory works (to pull from when iterating)

Human memory already solves "keep the useful, shed the noise, surface what's relevant." Concrete mappings to this feature:

• Consolidation (hippocampus → neocortex, happens "offline"/during sleep). → the daemon's background reflection pass: periodically consolidate recent session detail into durable, compressed memory during idle ticks. The background loop is consolidation.
• Ebbinghaus forgetting curve + spaced repetition. → exponential time-decay of detail, BUT decay slowed by access frequency/importance (a memory that keeps getting used or seeded stays sharp; unused detail fades). Ties decay to usage, not just age.
• Gist vs verbatim (fuzzy-trace theory). → exactly the "detail decays, gist remains" tiering: verbatim recent → gist old. We persist gist long-term and let verbatim fade.
• Cued / associative recall (retrieval by context). → relevance-gated retrieval: pull memories cued by the current task/project/files, not a flat dump. (Pairs with the vector layer.)
• Salience/importance tagging. → an importance score at extraction (decisions, contracts, "remember this" > routine chatter); Generative Agents' recency+importance+relevance triad.
• Chunking / schemas. → cluster related memories into higher-level summaries during reflection (reduces count, raises signal).
• Reconsolidation (memories change when re-accessed) + interference (new similar memories blur old). → when a memory is revisited or a newer related one arrives, MERGE/update rather than duplicate (dedup by similarity).
• Recency + primacy. → weight recent and first-in-project ("how this project started") memories higher when seeding.

Iterate empirically: start with the dumb v0 (per-project last-session recap) and add these one at a time, each measured by "did seeding actually help?" Good first task when we pick this up: a short research pull on memory-stream / consolidation / spaced-repetition literature to firm up the decay + importance scoring before coding.