memory

The memory subtree capability: WHERE this scope's memory lives. The provider serves it; the tools and index_note perform it, so the model is handed tools, never a store.

One memory mutation: SAVE a memory — its one-line index summary and its full body, under key.

One memory mutation: DROP a memory — both its index summary and its body, under key.

The WRITE channel: every mutation of the memory subtree rides this one request, served by a SEQUENTIAL handler in the provider. The tool loop dispatches a turn's tool calls CONCURRENTLY (parallel for), and the index is a read-modify-write of one record — two racing remembers would lose one summary. The handler's FIFO is the serialization point: mutations apply one at a time, in arrival order, so no update is ever lost.

Provide the memory subtree for the extent of the continuation: use memory.provider(subtree = store.scope(target = store.root(), path = "assistant/memory")). The provider holds no state — every read recomputes its view from the one served subtree — but it IS the write serialization point: mutations ride apply, whose sequential handler applies them one at a time (see apply), so the parallel tool dispatch cannot interleave two index read-modify-writes.

The BODY subtree — one full note per key under entries, apart from the one-line summaries in the index.

Render one stored memory value for the model: a plain string as itself, anything else as its JSON.

The memory INDEX: the one record mapping each saved key to its one-line summary, read fresh from the durable store (empty when nothing is saved). Read TOTAL (json.entries), so a missing or malformed value degrades to the empty record rather than throwing into an every-turn injection.

The index as one - key: summary line per saved memory — the shared rendering behind list_memories (the tool) and index_note (the every-turn injection).

The memory index as an every-turn prompt block: a '[memory index]' header plus one - key: summary line per memory, or the EMPTY string when nothing is saved — hand this to ai.with_context (an empty injection is skipped there).

Tool: save a note to your persistent memory under a short key (e.g. "user/name", "prefs/timezone"). You give a one-line summary (shown back to you every turn in the memory index) and the full body (read on demand with recall). Both survive restarts, so save durable facts, preferences and decisions — not this turn's scratch work. Re-using a key overwrites it. ALWAYS write a real summary: it is all you see of this memory until you recall it.

Tool: read back the FULL note for one memory key — the body you saved with remember. The one-line summaries are already shown to you each turn under '[memory index]', so use this to read a specific note in full. Call list_memories first if you are unsure of the key.

Tool: delete a memory by its key — removes BOTH its index summary and its body. Use it to prune stale or wrong facts. Deleting a missing key is a no-op.

Tool: LIST your saved memories — one key: summary line per memory — so you can see what you have without guessing keys. Read a full note with recall(key).