Use this to remember a user preference, project fact, decision, procedure,
    or lesson worth recalling later — not transient chat. Set `share` to make it
    visible to teammates ('team'/'project') instead of just yourself; the default
    is private. Content is de-duplicated softly and becomes searchable immediately.
    Returns the new memory's `id`, `content`, and resolved `visibility`, or an
    `{"error": ...}` object if `share` names a team/project you can't resolve.
    

    Call this before answering to retrieve what you already know. Results are
    access-controlled: only memories this agent (AGENT_MEMORY_AGENT_ID) is
    allowed to see are returned — private, its own, its teams'/projects', and
    global. Each result has `id`, `score` (relevance), `content`, `scope`, and
    `type`. Returns an empty list if nothing relevant is visible.
    

    Prefer this over `memory_search` when you want text to paste straight into a
    prompt: it selects and formats the highest-value memories within `max_tokens`,
    de-duplicates, and flags contradictions. Access-controlled to this agent's
    identity. Returns a formatted string (empty if nothing relevant is visible).
    

    Linked memories reinforce each other in recall, so a search that hits one can
    surface the other even with no shared keywords. Use it to connect a decision to
    its cause, or a fix to the problem it solved. Returns the created link, or an
    `{"error": ...}` object if either memory id does not exist.
    

    This closes the learning loop: `helpful=True` strengthens the memories and the
    links between them (they will resurface more readily); `helpful=False` weakens
    them and lowers their confidence. Only memories visible to this agent are
    affected — you cannot influence another identity's memories. Returns a summary
    of what was reinforced or weakened.
    

    Use it to correct content, re-weight importance/confidence, or pin a memory so
    it is never forgotten. Only the fields you pass are changed. Returns the updated
    `id`, `content`, and `updated_at`, or an `{"error": ...}` object if the id does
    not exist.
    

    Use this to promote a note you already stored to your team/project so
    collaborators can recall it, or to lock it back down. Only the memory's OWNER
    may change its visibility. The change propagates over sync — sharing reaches
    teammates, and making it private retracts it. Returns the memory's `id` and new
    `visibility`, or an `{"error": ...}` object if it doesn't exist, isn't yours, or
    `share` is invalid.
    

    A periodic hygiene pass: it collapses exact/near duplicates and combines
    strongly co-recalled clusters into higher-level concept memories, keeping the
    store compact and recall sharp. Safe to run occasionally rather than per-write.
    Returns counts of what was merged and created.
    

    Use before context runs out or when switching tasks, so the work can be reloaded
    later with `memory_reload_context` instead of being lost. Snapshots are rotated
    per session. Returns the new `snapshot_id` and `session_id`.
    

    A higher-level alternative to `memory_context_pack`: it splits the budget into
    sections — bedrock constants, proactive warnings and procedures, and relevance
    recall — in one prompt-ready block. With a `session_id`, repeated calls omit
    memories already delivered (bedrock constants always repeat). Access-controlled
    to this agent. Returns `text`, `sections`, `used_tokens`, `max_tokens`, `emphasis`.
    

    Answers "what did I change since I last parked this work?" — returns the
    top-level keys added, removed, and changed between the previous and latest
    snapshot, or an `{"error": ...}` object if the session has fewer than two.
    

    The counterpart to `memory_offload_context`: rehydrates the parked context so
    the agent can resume where it left off. Returns the snapshot's stored data, or
    an `{"error": ...}` object if the session/snapshot is not found.