Memory Attention Router Skill

Turn long-term memory into a small, role-aware working-memory packet.

Do not use this skill as plain document RAG.
Do not dump raw memory lists into model context.
Route to the right memory blocks, compose a compact packet, write back new learnings, and retire stale memory when better evidence appears.

Trigger cues

Trigger immediately when the user states a durable rule or asks to preserve or replace memory, especially with phrases like:

• - from now on
• remember this
• always
• prefer
• avoid
• my rule is
• replace my previous rule
• going forward

Also trigger when a planning, execution, critique, or response step needs compact memory state rather than raw history.

Step roles

Choose the current step role before reading memory:

• - INLINECODE0
• INLINECODE1
• INLINECODE2
• INLINECODE3

Current type preferences:

• - planner -> preference, procedure, INLINECODE7
• INLINECODE8 -> preference, procedure, episode, INLINECODE12
• INLINECODE13 -> reflection, preference, INLINECODE16
• INLINECODE17 -> preference, summary, INLINECODE20

Important implication:

• - executor should preserve durable hard constraints as well as reusable procedures

Read flow

1. 1. Build a route request with:

1. 2. Run:

1. 3. Read the packet.
2. Use the packet in downstream reasoning.
3. Inspect debug.selected_blocks and debug.selected_memories when you need to understand why a memory was selected.

The router uses a deterministic two-stage flow:

1. 1. select the best blocks from task_scoped, session_scoped, durable_global, and INLINECODE36
2. score memories only inside the selected blocks

Write flow

Store memory after important outcomes:

INLINECODE37

Write memory when:

• - a durable user preference or rule is learned
• a reusable procedure becomes clear
• a tool result will matter later
• a failure pattern should influence future behavior
• a stable summary is worth keeping

If a new memory replaces an older one, include replaces_memory_id. The router will retire the old memory, link it forward to the replacement, and persist a retirement reason.

Reflect flow

At the end of meaningful work or after a failure cluster, create reflection and optionally procedure memory:

INLINECODE39

Use reflection for:

• - lessons
• warnings
• failure patterns
• reusable procedures derived from successful work

Refresh flow

When new evidence invalidates or replaces older memory:

INLINECODE40

Use refresh to:

• - deactivate stale memories
• mark replacements with INLINECODE41
• persist why the memory was retired with INLINECODE42
• create contradiction links when a replacement exists

Packet rules

A good packet contains:

• - INLINECODE43
• INLINECODE44
• INLINECODE45
• INLINECODE46
• INLINECODE47
• INLINECODE48

Current compactness targets:

• - selected_memory_ids -> cap at 5
• INLINECODE50 -> cap at 4
• INLINECODE51 -> cap at 3
• INLINECODE52 -> cap at 3
• INLINECODE53 -> cap at 3
• INLINECODE54 -> cap at 5

Prefer small, high-signal packets over broad recall.

Routing rules

• - Prefer durable, reusable memory over noisy transient notes.
• Preserve hard constraints for execution steps, not only planning steps.
• Use support edges to help validated memories win borderline ranking decisions.
• Treat contradicts edges directionally: penalize the stale target, not the newer memory asserting the contradiction.
• Use summary instead of verbose raw history when both carry the same signal.
• Retire stale memory when replacement is clear; do not allow conflicting active memories to accumulate indefinitely.

Bootstrap

Initialize the database:

INLINECODE58

Default DB path behavior:

• - if MAR_DB_PATH is set, that path is used
• otherwise, when installed at <workspace>/skills/memory-attention-router, the default is INLINECODE61

Inspect stored memories:

INLINECODE62

Inspect one memory:

INLINECODE63

File guide

See:

• - reference guide
• memory schema
• prompt templates
• testing guide