Recall (Stream)

Recall assembles search results from three sources. It pulls memories from Hippocampus, scores from Salience, and connections from Synapse. It combines them into a ranked, association-weighted response. It owns nothing. It stores nothing. It computes at query time and returns what it found.

This is the fourth bounded context inside the hexagon. The first three own things — Hippocampus owns memories, Salience maintains scores, Synapse holds connections. Recall owns nothing. It reads from all three and assembles.

Diagram 13: RC-0001 -- Recall Bounded Context

graph LR
    subgraph Sources ["Assembly Sources"]
        HP(["Hippocampus"])
        SL(["Salience"])
        SY(["Synapse"])
    end

    subgraph RC ["Recall"]
        direction TB
        ASSY["Read-Only Assembler
No state, no storage"]
        RANK["Ranking & Assembly
Memories + Scores + Associations"]
        ASSY --- RANK
    end

    subgraph Consumers ["Result Consumers"]
        CX(["Cortex"])
        NP(["NotificationPort"])
    end

    HP -- "MemoryRetrieved" --> RC
    SL -- "SalienceScored" --> RC
    SY -- "AssociationsFound" --> RC

    RC -- "Search results
(immediate)" --> CX
    RC -- "Deeper associations
(background)" --> NP

    style Sources fill:#1a1a2e,stroke:#533483,stroke-width:1px
    style RC fill:#1a1a2e,stroke:#e94560,stroke-width:2px
    style Consumers fill:#1a1a2e,stroke:#0f3460,stroke-width:1px
    style HP fill:#1a1a2e,stroke:#533483,stroke-width:1px
    style SL fill:#1a1a2e,stroke:#533483,stroke-width:1px
    style SY fill:#1a1a2e,stroke:#533483,stroke-width:1px
    style CX fill:#1a1a2e,stroke:#0f3460,stroke-width:1px
    style NP fill:#1a1a2e,stroke:#0f3460,stroke-width:1px

Three inputs from three sources. Two outputs — one immediate, one ongoing. No persistence channel. Recall is pure assembly.

Remembering

Try to remember the name of that restaurant. The one with the good fish. It was somewhere downtown.

The first fragment comes fast. Downtown. Fish. Your partner mentioned it last week. That’s the top-of-mind answer — the strongest match for "good fish restaurant."

Then connections fire. Right — it was the night you talked about the job interview. You were nervous, and the waiter recommended the halibut. The halibut was good. That’s why you remember the fish.

Then deeper. Wasn’t that the same week you got the phone call from your mother? The mood that night — your partner noticed. That connects too, but it takes a moment to surface.

Some memories arrive immediately. Some surface minutes later, triggered by associations you didn’t consciously follow. Some show up the next day while you’re thinking about something else entirely.

That’s how remembering works. Not a single lookup. A fast answer, then a widening ripple of connections that keeps going after the first response.

Recall models this. The fast path returns immediately. The deep path keeps running in the background, and results push through as they’re found.

What It Owns

Nothing.

Recall has no data model. No persistence. No backing service. No file cabinet. If Recall restarts, there is nothing to rebuild — because there was nothing stored.

Recall maintains a local copy of current salience scores, built from SalienceScored events. This is a convenience cache, not owned state. If the cache is lost, the next SalienceScored events rebuild it. The scores belong to Salience. Recall just keeps a copy close at hand so it doesn’t have to ask at search time.

Where It Reads

Recall assembles from three sources. Each source answers a different question.

Source	What It Provides	Question It Answers
Hippocampus	MemoryRetrieved events — raw memories matching the query	What memories exist that match these search terms?
Salience	SalienceScored events — current vividity scores	How vivid is each memory right now? What should rank higher?
Synapse	AssociationsFound events — connected memories from graph traversal	What other memories connect to these results?

None of these sources know about each other. Hippocampus doesn’t know about scores. Salience doesn’t know about associations. Synapse doesn’t know about search terms. Recall is the only place where all three come together. Every event Recall consumes carries a TransactionContext that tracks its origin (Design F).

The Fast Path

A search comes in through Cortex. Recall handles it in three steps.

Match. Ask Hippocampus for memories matching the query. Content, metadata, tags — whatever the search filter specifies. Hippocampus returns MemoryRetrieved events for each match.

Rank. For each match, look up the current salience score from the local cache. Higher scores rank higher. A vivid memory that was accessed yesterday outranks a faded memory from last month, even if both match the query equally well.

Enrich. For each top result, ask Synapse for direct associations. If the top match connects to three other memories, include them. Association-activated memories surface even if they didn’t match the original query — because the connection is the relevance.

Assemble. Return the ranked, enriched result set to Cortex. The fast path is done.

The Deep Path

The fast path returned the first answer. The ripple is still expanding.

Synapse’s direct associations are one hop. Memory A connects to B, C, D. But B connects to E and F. C connects to G. The graph goes deeper. Following those threads takes time, and the mind shouldn’t wait for the full traversal before getting an answer.

So Recall does both. The fast path returns immediately with direct matches and one-hop associations. The deep path continues in the background — Synapse keeps traversing, and as it finds deeper connections, Recall pushes them through NotificationPort.

The mind gets the halibut restaurant right away. Five minutes later, a notification: "That dinner also connects to the conversation about your mother, which connects to the decision you made about the job." The deep path surfaced something the fast path couldn’t reach in time.

Not every search needs the deep path. A simple lookup — "what did I store yesterday?" — returns on the fast path and stops. The deep path fires when the query touches memories with rich association networks, where following the threads is likely to surface something useful.

The CQRS Split

Recall is the read side of a split that runs through the entire hexagon.

Hippocampus handles writes — StoreCommand, ClaimCommand, ReclassifyCommand. Those change state. Recall handles reads — SearchQuery, ReflectQuery. Those don’t change anything. They assemble from current state and return a view (a Read Model Set).

ReflectQuery is unique: it returns a reflection set (candidates for review), but then the mind enters a conversation loop — issuing AssociateCommand and ReclassifyCommand for each memory it judges. The query phase is Recall’s job. The judgment phase is the mind’s. See MSG-0006.

The split means Recall can be optimized independently from writes. Different data structures, different access patterns, different scaling characteristics. Hippocampus needs durability and consistency. Recall needs speed and associative reach. They serve different masters.

The communication between them is event-driven. Hippocampus emits MemoryRetrieved. Salience emits SalienceScored. Synapse emits AssociationsFound. Recall listens to all three and assembles. No direct calls. No shared state. Events flow one way.

Relationship to Cortex

Cortex is the only path in and out. SearchQuery arrives from the mind through Cortex. Recall processes it and returns results through Cortex. The mind never talks to Recall directly.

This is the same pattern as all the other bounded contexts. Cortex is the portal. Recall is behind it.

Summary

Aspect	Detail
Role	Read-only assembler. Combines memories, scores, and connections into ranked search results.
Owns	Nothing. Convenience cache of salience scores only.
Reads from	Hippocampus (memories), Salience (scores), Synapse (associations)
Fast path	Match, rank, enrich with direct associations. Return immediately.
Deep path	Background association traversal. Results push through NotificationPort as found.
Key invariant	Never writes. Never changes state. Pure read, pure assembly.
Queries handled	SearchQuery (find matching memories), ReflectQuery (structured introspection)
Persistence	None. If Recall restarts, nothing is lost — it reads from other contexts' state.

---

Previous: Synapse — the relationship layer that connects memories to each other.

Next: Cortex — the portal where the outside world meets the hexagon.