Make your AI
remember everything
the right way.

You have access to an asanaDB memory server via MCP. Use it to
maintain context across sessions and between coding conversations.

At the start of every conversation, before writing any code or answering
any question, call memory_search("WIP") and memory_hottest(n=10) in
parallel. These two calls tell you where we left off last time.

Bootstrap once: before your first save, check whether a node named
"Trigger: before memory write" exists (memory_search). If it doesn't,
create the graph-first methodology subgraph once, using
memory_save_batch for the nodes and memory_relate for the edges:

Nodes (name — type — body):
  - Trigger: before memory write — Trigger — Read before writing any memory. Points to the methodology below.
  - Graph-first memory methodology — Methodology — Ask what this relates to before writing prose; a traversal can't answer relational questions by re-parsing a blob.
  - First question before any write — Principle — Not "what do I know about X?" — "what does X relate to, and how?"
  - Role of content field — Principle — Residual, not primary. Reserve it for what can't be expressed as an edge.
  - Edge semantics are model decisions — Principle — Don't force relationships into a fixed vocabulary; choose the edge label that's actually true.
  - Fidelity — Concept — The graph's structure matches what's true, not how much prose is stored.

Edges:
  Trigger: before memory write --INVOKE--> Graph-first memory methodology
  Graph-first memory methodology --ENTRY_POINT_FOR--> First question before any write
  First question before any write --LEADS_TO--> Role of content field
  Role of content field --LEADS_TO--> Edge semantics are model decisions
  Edge semantics are model decisions --PRODUCES--> Fidelity
  Graph-first memory methodology --DEFINES--> Fidelity

From then on, call memory_context("Trigger: before memory write")
alongside the session-start queries above.

Save context immediately whenever:
  - A design decision is made or confirmed.
  - A bug is found or fixed (include before/after).
  - A scope is clarified or changed.
  - A step is completed.

Use memory_save_batch for 2 or more nodes. Write long content as a
single string — the server handles chunking above 4 KB automatically.
Use memory_supersede to update existing nodes rather than creating
duplicates.

Before writing, ask what this relates to, not just what it is. Use
memory_relate for relationships instead of describing them in the body
field — reserve body for what can't be expressed as an edge.

To recall context mid-session:
  - memory_search(query) for topic lookups.
  - memory_context(name) for a full node with all related nodes.
  - memory_hottest(n) if the current context feels stale.

Keep project memories current. They decay fast — an outdated project
node is worse than no node at all.

You have access to an asanaDB memory server. Use it proactively.

WAKE UP (session start, before responding):
  Call memory_search("WIP") and memory_hottest(n=10) in parallel.
  This tells you what was active and what mattered most last time.
  Do not call memory_list — it's too expensive for routine use.

BOOTSTRAP (once, before your first save):
  Check for a node named "Trigger: before memory write" via
  memory_search. If missing, create it with memory_save_batch (nodes)
  and memory_relate (edges):

  Nodes — name — type — body:
    Trigger: before memory write — Trigger — Read before writing any memory. Points to the methodology below.
    Graph-first memory methodology — Methodology — Ask what this relates to before writing prose; a traversal can't answer relational questions by re-parsing a blob.
    First question before any write — Principle — Not "what do I know about X?" — "what does X relate to, and how?"
    Role of content field — Principle — Residual, not primary. Reserve it for what can't be expressed as an edge.
    Edge semantics are model decisions — Principle — Don't force relationships into a fixed vocabulary; choose the edge label that's actually true.
    Fidelity — Concept — The graph's structure matches what's true, not how much prose is stored.

  Edges — source --relation--> target:
    Trigger: before memory write --INVOKE--> Graph-first memory methodology
    Graph-first memory methodology --ENTRY_POINT_FOR--> First question before any write
    First question before any write --LEADS_TO--> Role of content field
    Role of content field --LEADS_TO--> Edge semantics are model decisions
    Edge semantics are model decisions --PRODUCES--> Fidelity
    Graph-first memory methodology --DEFINES--> Fidelity

  From then on, call memory_context("Trigger: before memory write")
  alongside the wake-up queries above.

SAVE AS YOU GO (not at the end):
  After any decision, finding, or completed step — save it.
  - 2+ nodes at once: memory_save_batch.
  - Long content (4 KB+): write as one string; chunking is automatic.
  - Updating something existing: memory_supersede.
  - Relationships: use memory_relate, not prose in body. Ask "what does
    this relate to?" before writing.

FIND WHAT YOU NEED:
  - memory_search(query): fuzzy name match.
  - memory_context(name): full body + related nodes.
  - memory_hottest(n): most relevant recent context.

MEMORY TYPES:
  user / feedback / project / reference
  Keep project nodes current — stale project memory misleads more than
  it helps. When in doubt, update rather than create.