MCP tools

The Meaning Memory MCP server (mm-mcp) provides 53 tools. This page is generated from Meaning Memory 3.20.0, so it matches what the server sends your agent. Most agents need only a few: mm_remember, mm_search and mm_due_commitments cover the common case.

Write tools need MM_ALLOW_INTERNAL=1 on the server; see Configuration.

Remember and recall

Write memories one at a time or in bulk, and pull them back ranked by significance.

mm_remember

Store one new memory. Required: text. memory_type: ‘semantic’|‘episodic’|‘procedural’|‘commitment’. Commitments write direct (searchable immediately) and carry commitment_status + ISO due_at (pending/acknowledged need a real due_at, else pending_unscheduled); recurring ones add recurrence (RRULE, e.g. FREQ=DAILY) + catchup_policy. Other writes are async via the journal (searchable after drain). STARE: stare_scores dict OR flat s/t/a/r/e, never both. SAFETY: automated callers MUST pass explicit source, never the ‘human’ default. Returns mem_id + significance.

Argument	Type	Required	Default
text	string	yes
category	string		"fact"
significance	number		null
party	string		null
source	string		"human"
date	string		null
actor_name	string		null
agent	string		null
scope_groups	array of string		null
memory_type	string		"semantic"
last_invoked_at	string		null
stare_scores	object		null
s	number		null
t	number		null
a	number		null
r	number		null
e	number		null
writer_role	string		null
due_at	string		null
commitment_status	string		null
recurrence	string		null
catchup_policy	string		null
external_ref	string		null
due_semantics	string		null
memory_stage	string		"long_term"
session_id	string		null
channel	string		null
surface	string		null
episode_id	string		null
supersedes	array of string		null
request_id	string		null
idempotency_key	string		null
strict_mode	boolean		false
tenant_id	string		null
actor	object		null
trace_id	string		null
span_id	string		null
contract_version	string		"1.0.0"
extensions	object		null
envelope_format	string		null

mm_bulk_remember

Bulk-ingest a seed corpus (1-1000 items per call) — the fast path from an existing knowledge file (product catalog, FAQ, policies) to queryable memory. Items accept mm_remember’s field set; only text is required. Batch defaults: provenance ‘seed’, source ‘seed’, significance 0.80, category ‘fact’, decay_curve ‘none’ (seed content survives consolidation decay unless overridden per item). Items carrying STARE scores are stored as-is; others are auto-scored when auto_stare=True (scorer failure degrades to NULL + warning, never aborts). seed_corpus_id tags the batch for listing/re-seed. Returns markdown: appended count, dedupe-skipped count, first/last mem_id.

Argument	Type	Required	Default
memories	array of object	yes
seed_corpus_id	string	yes
default_category	string		"fact"
default_source	string		"seed"
default_significance	number		0.8
default_decay_curve	string		"none"
default_party	string		null
agent	string		null
writer_role	string		null
auto_stare	boolean		true

mm_search

Search stored memories; returns significance-ranked markdown for context injection. Use to recall facts, events, decisions, or capabilities before answering or acting. query adds hybrid lexical+semantic retrieval; without it, top entries by significance. Filters: category, party, since, memory_type, STARE minimums (strict >=, AND-composed), episode_id, as_of/currently_valid. actor_agent_id enforces visibility scoping and requires query (fails closed). Results are tenant-scoped.

Argument	Type	Required	Default
query	string		null
budget_lines	integer		50
min_sig	number		0.0
category	string		null
party	string		null
since	string		null
agent	string		null
use_significance	boolean		null
half_life_days	number		null
scope_groups_filter	array of string		null
actor_agent_id	string		null
memory_type	string		null
min_s_score	number		null
min_t_score	number		null
min_a_score	number		null
min_r_score	number		null
min_e_score	number		null
min_r	integer		null
related_to	string		null
as_of	string		null
currently_valid	boolean		null
episode_id	string		null
retrieving_agent_id	string		null
memory_stage	string		null

mm_session_recall

Exact-session read of the working buffer — the recovery route named by every rendered “Session record” stub in ## Recent (48h).

Argument	Type	Required	Default
session_id	string	yes
limit	integer		20

Full description

Returns the calling agent's own working-stage rows for ONE session (keylines,
action receipts, confirmations, the summary), newest first, latest artifact
per slot, active rows only. Reads ledger rows — never the observation
archive, never counterpart speech (R1 floor unchanged).

Identity comes from authentication (agent + tenant of the request); there is
deliberately no ``agent`` / ``tenant`` argument. ``session_id`` must be the
EXACT full id (as printed in the stub) — prefixes are refused, not expanded.
``limit`` is clamped to 1..50.

Commitments

Promises an agent makes, tracked to a due date and closed explicitly.

mm_due_commitments

Your OPEN commitments, sorted by due date with overdue flagged.

Argument	Type	Required	Default
agent	string		null

Full description

The on-demand / every-heartbeat live view of what you owe — the same
``## Commitments (due / overdue)`` section that appears in MEMORY.md, but
fetched live (not the once-a-day compile snapshot). Call this each cycle
to catch a commitment that came due since the last consolidation. Never
significance-gated: an open commitment surfaces even if its sig decayed.
Never drops a commitment: when MEMORY.md's section says rows were omitted
for space, THIS call names every one of them. With a long list the text is
shortened to fit the tool-result limit (each row keeps its full mem_id;
``mm_provenance(mem_id)`` returns any row in full).

Returns overdue (🔴) first, then due-soon, scheduled, and unscheduled,
each line ending with its mem_id for ``mm_close_commitment`` /
``mm_reopen_commitment``.

Args:
    agent: Agent identifier (default: MM_AGENT env var).

mm_close_commitment

Close an open commitment to a terminal lifecycle state so it stops surfacing as due/overdue in compiled memory. States: ‘completed’ (fulfilled — default) · ‘failed’ (deadline passed without action) · ‘cancelled’ (deliberately retired, no longer owed — a decision, not a miss). Idempotent (re-closing to the same state is a no-op) and terminal-guarded (terminal-to-terminal moves are rejected). Legacy deadline reminders are promoted and closed in one step. A commitment with a recurrence is REFUSED (it would strand the cadence) — use mm_satisfy_commitment / mm_waive_commitment to advance it, or pass force_terminate=true to genuinely retire the duty. Returns confirmation with the recorded transition.

Argument	Type	Required	Default
memory_id	string	yes
status	string		"completed"
reason	string		""
actor_name	string		null
agent	string		null
force_terminate	boolean		false

mm_reopen_commitment

Reopen a previously-closed commitment (undo a close).

Argument	Type	Required	Default
memory_id	string	yes
reason	string		""
actor_name	string		null
agent	string		null

Full description

Transitions a terminal commitment (completed / failed / cancelled) back
to ``pending_unscheduled`` (open again).

**Due date handling depends on whether the commitment recurs:**

- **One-shot** — the prior due date is cleared, so the reopened
  commitment is genuinely unscheduled. There is no supported verb to
  set a new one; re-create the commitment if it needs a date.
- **Recurring** — the due date is **preserved**, because it is the
  cadence cursor. Clearing it used to destroy state nothing could
  restore (``mm_remember`` creates entries, it cannot reschedule an
  existing one), which turned every wrong close into a manual
  database repair. The reopened row keeps its cursor and its
  recurrence, so ``mm_satisfy_commitment`` /
  ``mm_waive_commitment`` work immediately and re-arm it to
  ``pending`` on the next advance.

This is the safety-net for a wrong close: both the close and this reopen are
recorded as ``commitment_status_change`` audit events, so the
correction is preserved in the trail. **Rejects** if the commitment is
not terminal (there is no close to undo — and forcing an open commitment
to unscheduled would silently deschedule it).

Args:
    memory_id: the commitment's id (8-16 hex chars).
    reason: short audit note (why it is being reopened).
    actor_name: who is reopening it (default: MM_ACTOR env var).
    agent: agent name (default: MM_AGENT env var).

Returns:
    Confirmation of the reopen, or an idempotent "no change" note.

mm_satisfy_commitment

Mark the current occurrence of a RECURRING commitment done and advance its cursor to the next occurrence — the only way the cursor moves. For one-shot commitments use mm_close_commitment instead. expected_due_at (ISO-8601 with timezone offset) is a compare-and-set guard: matching the live cursor advances it; matching an already-closed occurrence is a safe idempotent no-op (cross-verb replays are flagged, not swallowed); anything else is rejected as a stale-view conflict. Long-overdue commitments catch up straight to the upcoming occurrence with skipped occurrences recorded. Returns the closed occurrence and the new cursor.

Argument	Type	Required	Default
memory_id	string	yes
expected_due_at	string	yes
reason	string		""
actor_name	string		null
agent	string		null

mm_waive_commitment

Deliberately SKIP the current occurrence of a RECURRING commitment and roll it forward.

Argument	Type	Required	Default
memory_id	string	yes
expected_due_at	string	yes
reason	string		""
actor_name	string		null
agent	string		null

Full description

The sibling of ``mm_satisfy_commitment`` for when an occurrence is
intentionally not done (skipped this cycle) but the duty still recurs. It
advances the cursor with the identical compare-and-set + catch-up mechanics,
recording the close as a waive (not a completion) in the audit trail — so a
"last completed" view never counts a waived cycle as done.

See ``mm_satisfy_commitment`` for the ``expected_due_at`` compare-and-set
semantics and the catch-up behavior; they are the same here.

Args:
    memory_id: The recurring commitment's id (8-16 hex chars).
    expected_due_at: Due time of the occurrence you're skipping, ISO-8601
        with a timezone offset (e.g. '2026-06-12T09:00:00-07:00').
    reason: Short audit note (why it was skipped).
    actor_name: Who is skipping it (default: the configured actor).
    agent: Agent name (default: the configured agent).

Returns:
    Confirmation of the advance + the next due time, or a no-op note.

mm_promote_commitment

Promote a pending commitment NOMINATION into a real commitment you own.

Argument	Type	Required	Default
nomination_id	string	yes
due_at	string		null
recurrence	string		null
due_semantics	string		null
reason	string		""
actor_name	string		null
agent	string		null

Full description

The extraction pipeline no longer creates commitments
directly — it nominates candidates, and this verb is how YOU accept
one. Review your pending nominations via ``commitment_review``
(Obligations MCP, Nominations bucket); each row shows its
``nomination_id`` (a UUID).

Promotion is SELF-OWNERSHIP ONLY: the commitment is created on YOUR
ledger (the calling agent). You cannot promote a duty onto another
agent — a human operator does that via the admin CLI. The schedule
(``due_at`` / ``recurrence``) is YOUR decision here, not the
extractor's guess.

Args:
    nomination_id: The nomination's UUID (from commitment_review).
    due_at: Optional ISO-8601 deadline WITH timezone
        (e.g. ``2026-08-12T09:15:00-07:00``). Omit for an
        unscheduled commitment (schedule it later).
    recurrence: Optional RRULE fragment (e.g. ``FREQ=DAILY``).
    due_semantics: Optional shape modifier (e.g. ``standing``).
    reason: Short audit note (why this is a real duty).
    actor_name: Display name for the audit trail.
    agent: Agent name (default: MM_AGENT env var).

Returns:
    Confirmation with the new commitment's mem_id, or a typed error.

mm_dismiss_commitment_nomination

Dismiss a pending commitment nomination (it is NOT a real duty).

Argument	Type	Required	Default
nomination_id	string	yes
reason	string		""
reason_code	string		null
actor_name	string		null
agent	string		null

Full description

The expected verdict for most extraction output —
narration about existing duties, duplicates, and misattributed
promises all get dismissed. Dismissal is cheap and terminal; the
nomination's content stays in the review history, and the same duty
can be nominated again later if it genuinely recurs.

Args:
    nomination_id: The nomination's UUID (from commitment_review).
    reason: REQUIRED — why this is not a duty (one line is fine).
    reason_code: Optional machine tag: ``narration`` / ``duplicate``
        / ``misattributed`` / ``not_a_duty``.
    actor_name: Display name for the audit trail.
    agent: Agent name (default: MM_AGENT env var).

Significance and feedback

Adjust what matters, and see why a memory ranks where it does.

mm_feedback

Adjust a memory’s significance or lifecycle from human feedback. Actions: ‘important’ (+0.15), ‘demote’ (-0.15, floor 0.0), ‘pin’ (0.90, trim-protected), ‘stale’, ‘archive’ (removed from compiled output; undo with ‘restore’), ‘restore’ (un-archive your own archived row), ‘forget’ (permanent erasure, IRREVERSIBLE — OPERATOR-ONLY, refused for agents). Args: mem_id (8 or 16 hex), action, reason, actor_name. Returns old/new values and the logged event.

Argument	Type	Required	Default
mem_id	string	yes
action	string	yes
reason	string		""
actor_name	string		null
agent	string		null
request_id	string		null
idempotency_key	string		null
strict_mode	boolean		false
tenant_id	string		null
actor	object		null
trace_id	string		null
span_id	string		null
contract_version	string		"1.0.0"
extensions	object		null
envelope_format	string		null

feedback_mark

Public API: mark a memory as important or not_important.

Argument	Type	Required	Default
mem_id	string	yes
feedback_type	string	yes
note	string		""
api_key	string		null
agent	string		null

Full description

**Requires API key with `feedback:write` scope.** Pass via MM_API_KEY
env var (stdio) or explicit `api_key` arg.

Args:
mem_id: Target memory ID (8-16 hex chars).
feedback_type: 'important' | 'not_important'.
note: Optional free-text reason.
api_key: Explicit API key. Otherwise reads MM_API_KEY env var.
agent: Target workspace (default: MM_AGENT env).

Note: the sig delta is fixed at the policy default (0.15 per mark).
Custom deltas are not exposed on the public MCP surface — external
callers cannot saturate sig in a single call (B3 team-review fix,
5/5 reviewer convergence, release cycle Phase 1 Apr 19 2026). Trusted internal
integrations can still call mm_feedback.feedback_mark() with
a custom sig_bump parameter.

feedback_promote

Public API: promote a memory toward the human_remember threshold.

Argument	Type	Required	Default
mem_id	string	yes
note	string		""
api_key	string		null
agent	string		null

Full description

Monotone: never lowers sig below its current value. Target is fixed
at MM_SIG_HUMAN_REMEMBER (0.80 policy default). Custom targets
are NOT exposed on the public surface (B3 team-review fix).

**Requires API key with `feedback:write` scope.**

feedback_decay

Public API: explicit decay for a stale-but-not-wrong memory.

Argument	Type	Required	Default
mem_id	string	yes
note	string		""
api_key	string		null
agent	string		null

Full description

Fixed decay amount at the policy default (0.20). Custom decay
amounts are NOT exposed on the public surface (B3 team-review fix).

**Requires API key with `feedback:write` scope.**

feedback_correct

Public API: correct a memory via status transition.

Argument	Type	Required	Default
mem_id	string	yes
correction_type	string	yes
note	string		""
api_key	string		null
agent	string		null

Full description

Args:
correction_type: 'superseded' (replaced by newer fact — feeds
supersedes relationship) | 'archive' (retained but
not compiled).

**Requires API key with `feedback:write` scope.**

mm_provenance

Trace the full significance history of a memory.

Argument	Type	Required	Default
mem_id	string	yes
agent	string		null
request_id	string		null
idempotency_key	string		null
strict_mode	boolean		false
tenant_id	string		null
actor	object		null
trace_id	string		null
span_id	string		null
contract_version	string		"1.0.0"
extensions	object		null
envelope_format	string		null

Full description

**Semantic contract:** ``memory.provenance`` (real-tier).

Shows the entry details plus every significance change with
actor, reason, old/new values, and timestamps. This is the
trust differentiator — no competitor can answer "why was this
memory ranked here?" with a full audit trail.

Args:
mem_id: Memory ID (8 or 16 hex chars).
agent: Agent name (default: MM_AGENT env var).

Returns:
Entry details + chronological event timeline.

mm_rejections

Query the rejection trail — reverse-chronological feedback events (significance adjustments, status changes) classified as down_vote / up_vote / status_change. Use to audit how memories were promoted or demoted, review negative-feedback patterns, or pull one memory’s full feedback history via mem_id. Filters: window (1h/24h/7d/30d/all; default 7d) or explicit since/until, signal_type, actor_id, limit (default 100). Tenant-scoped: cross-tenant mem_id lookups return empty rather than confirming existence. Returns a JSON envelope payload: events[], total_count, window_summary.

Argument	Type	Required	Default
window	string		"7d"
scope_groups	array of string		null
since	string		null
until	string		null
signal_type	string		null
actor_id	string		null
mem_id	string		null
limit	integer		100
agent	string		null
request_id	string		null
idempotency_key	string		null
strict_mode	boolean		false
tenant_id	string		null
actor	object		null
trace_id	string		null
span_id	string		null
contract_version	string		"1.0.0"
extensions	object		null
envelope_format	string		null

Relationships and perspectives

How memories connect, and where agents see the same thing differently.

mm_explore_relationships

One-shot relationship explorer for an entry.

Argument	Type	Required	Default
mem_id	string	yes
agent	string		null

Full description

Convenience wrapper combining depth-1 + depth-2 traversal into a
single call. Useful as the first "what's connected to this?" query
when an agent surfaces an entry and wants the full graph context.

Args:
mem_id: Entry to explore.
agent: Agent name (default: MM_AGENT env var).

Returns:
Markdown summary with depth-1 direct connections + depth-2
reachable entries.

mm_traverse_relationships

Walk the R-graph from source_mem_id up to max_depth hops.

Argument	Type	Required	Default
source_mem_id	string	yes
max_depth	integer		2
relation_types	array of string		null
max_results	integer		100
agent	string		null

Full description

Returns reached entries with the path taken. Use when an agent needs
to discover what's connected to a memory beyond depth-1 (e.g. "what
does the fleet remember about Project Alice").

Args:
source_mem_id: Starting mem_id (e.g. "abc12345").
max_depth: How many hops to walk (1-5; default 2).
relation_types: Optional whitelist of relation types to follow.
max_results: Cap on returned entries (1-500; default 100).
agent: Agent name (default: MM_AGENT env var).

Returns:
Markdown report showing reached entries grouped by depth, with
path and relation chain for each.

mm_explain_path

Find the shortest path between two mem_ids.

Argument	Type	Required	Default
from_mem_id	string	yes
to_mem_id	string	yes
max_depth	integer		3
agent	string		null

Full description

Use for compliance / audit / trust-gradient explanations: "why is
this entry accessible to agent X?" or "how did this idea get linked
to that project?".

Args:
from_mem_id: Starting mem_id.
to_mem_id: Target mem_id.
max_depth: Max hop count to search (1-5; default 3).
agent: Agent name (default: MM_AGENT env var).

Returns:
Markdown showing the path as a sequence of relationship hops,
OR `**No path found**` if no path exists within max_depth.

mm_divergences

Cross-agent perspective-divergence read surface.

Argument	Type	Required	Default
subject	string		null
include_provisional	boolean		true
limit	integer		50
agent	string		null

Full description

Lists detected divergences (different agents holding conflicting stances about
the same subject), each rendered as an EVIDENCE PACKET: both memories' raw
text, their authors + stances, the subject/scope, detector version, and
whether the finding is verified or provisional. Operator-facing + read-only —
it never mutates memories. Operator dismissals (`not_divergent_from`) are
filtered out.

Args:
subject: Optional case-insensitive substring filter on the divergence subject.
include_provisional: Include auto-detected (unverified) findings (default True).
limit: Max divergences to render (default 50).
agent: Agent name (default: MM_AGENT env var).

Returns:
Markdown — one evidence packet per divergence, grouped newest-first.

mm_detect_divergences

Trigger one offline cross-agent divergence-detection pass.

Argument	Type	Required	Default
dry_run	boolean		false
agent	string		null

Full description

WRITE path: detects conflicting cross-agent stances on the same (subject,
scope) across all agents in the tenant and writes advisory `diverges_from`
edges. **Gated on `MM_DIVERGENCE_DETECTION`** (default OFF) — a no-op until the
rollout is deliberately enabled. Idempotent; honors operator dismissals; never
mutates the diverging memories.

**Scope of THIS tool:** it detects over entries that already carry populated
`epistemic_anchor` receipts (the deterministic receipt path). The entity-
anchored LLM EXTRACTION (which populates anchors from raw memory text) runs in
the offline consolidation job, where the customer's LLM handler lives — the
MCP server has no LLM handler by design. So on a corpus with no anchors this
reports zero findings; that's expected, not a failure.

Args:
dry_run: Detect + report without writing edges.
agent: Agent name (default: MM_AGENT env var).

Returns:
Markdown run summary (claims / findings / pairs / edges written / skipped).

mm_divergence_dismiss

Dismiss a divergence as a false positive (“they don’t disagree”).

Argument	Type	Required	Default
mem_id_a	string	yes
mem_id_b	string	yes
subject	string	yes
scope	string		""
reason	string		""
agent	string		null

Full description

Records a `not_divergent_from` edge so the pair is suppressed from
`mm_divergences` and never re-written by `mm_detect_divergences`. The operator
feedback loop that keeps precision high. Always available (not flag-gated —
squashing a false positive must work even with detection disabled). Idempotent.

Args:
mem_id_a / mem_id_b: The two memories the detector flagged as diverging.
subject: The divergence subject (must match the finding's subject + scope).
scope: Context scope of the finding ("" if uncontextualized).
reason: Optional operator note.
agent: Agent name (default: MM_AGENT env var).

Skills, capabilities and policy

Procedural knowledge an agent keeps, and the rules it operates under.

mm_skill_put

Store one of YOUR skills (a SKILL.md) in Meaning Memory so it survives a harness swap (adapter I5).

Argument	Type	Required	Default
content	string	yes
version	string		null
source_path	string		null
actor_name	string		null
agent	string		null

Full description

``content`` is the whole SKILL.md exactly as it sits on disk: a YAML
frontmatter block with at least ``name`` and ``description``, then the
markdown body. Identity is ``name@version``; the version comes from
frontmatter ``version:``, ``metadata.version``, a ``**Version:** x``
body line, or the ``version`` argument (which must agree with the file).

Contract:
  - **immutable** — the same name@version with the same bytes is a
    no-op; the same name@version with different bytes is REFUSED.
    A changed skill is a new version, and the new version supersedes
    the old one (old row retired, audited).
  - **yours** — stored under your agent identity; you cannot store a
    skill for another agent.
  - **never rendered** — a skill is not a bootstrap memory; it does
    not compete for MEMORY.md residency and no grant is needed. It is
    materialised into a harness's skill directory by the operator
    (``meaning-memory-admin skills materialize``); residency never
    authorises execution.
  - Companion files (``references/``, ``scripts/``) are NOT ported in
    v1; the receipt lists what a re-materialisation will not restore
    only if you pass ``source_path`` and they are visible server-side
    (usually they are not — say so in the skill body instead).

Args:
    content: The full SKILL.md text (≤ 64 KB, UTF-8, no NUL bytes).
    version: Optional explicit version; required if the file carries none.
    source_path: Optional origin path for provenance (recorded only).
    actor_name: Display name for the audit trail.
    agent: Agent name (default: MM_AGENT env var).

Returns:
    Receipt: outcome (applied | no_effect), mem_id, name@version,
    digest, size, what it superseded.

mm_skill_get

Fetch one of YOUR stored skills — identity, digest and the SKILL.md content.

Argument	Type	Required	Default
name	string	yes
version	string		null
agent	string		null

Full description

``version=None`` returns the live version. The content is returned
verbatim after a ``--- SKILL.md ---`` marker line; verify the sha256
if you write it to disk yourself. The byte-exact path is the
operator's ``meaning-memory-admin skills materialize``, which
re-verifies the digest on disk.

Args:
    name: Skill name (frontmatter ``name``).
    version: Optional exact version.
    agent: Agent name (default: MM_AGENT env var).

mm_skill_list

List YOUR stored skills: name, version, digest, size, when stored. Live versions only unless include_retired (then superseded/archived versions show with their status).

Argument	Type	Required	Default
include_retired	boolean		false
agent	string		null

Full description

Args:
    include_retired: Also list superseded/archived versions.
    agent: Agent name (default: MM_AGENT env var).

mm_capability_verify

Check whether a procedural memory exists matching a capability description — the first-line check in the ‘I cannot’ protocol: before reporting inability to do X, verify whether a stored procedure describes how to do X. If yes, proceed; if no, the inability report stands. Thin read-only wrapper over search with memory_type=‘procedural’ plus substring matching. Returns binary yes/no with the matching mem_id and last_invoked_at when found.

Argument	Type	Required	Default
capability	string	yes
agent	string		null
update_invoked	boolean		false

mm_policy_status

Your OPERATING POLICIES and whether they actually reached your prompt. Read-only.

Argument	Type	Required	Default
agent	string		null
window_hours	integer		24

Full description

Operating policies are standing rules your operators set. They are not
memories: they hold no seat in MEMORY.md, never decay, and are delivered
into your system prompt per session kind (chat / cron / heartbeat). You
cannot write them — propose a change to a human.

Two grades of evidence, never mixed:
  - **injected**  — the harness adapter attests it handed the text to the
    prompt builder for that session.
  - **observed**  — an independent observer saw the complete, untruncated
    text in the prompt the model received. Where no observer is
    configured this reads **UNKNOWN**. UNKNOWN is not OK.

This is a DELIVERY report. It says a rule reached you; it does not say
you followed it.

Args:
    agent: Agent identifier (default: MM_AGENT env var).
    window_hours: Look-back window for delivery receipts (default 24).

mm_grant_residency

Ask for one of YOUR memories to be kept resident in your compiled bootstrap (agent self-grant, preferred class).

Argument	Type	Required	Default
memory_id	string	yes
reason	string	yes
expected_generation	integer		null
actor_name	string		null
agent	string		null

Full description

A residency grant is durable, revocable, audited authority for an
entry to COMPETE for protected residency under the grants-aware
planner. This verb is deliberately narrow:

  - **preferred only** — you cannot make an entry ``required``; that
    is a human (admin CLI) or a versioned policy rule decision.
  - **your own entry, your own target** — the target is derived from
    your agent identity (``<agent>-bootstrap``); the entry must be
    one you wrote. Foreign entries and foreign targets are refused.
  - **idempotent** — a repeat returns ``no_effect`` with the existing
    grant id; nothing is written and the generation does not move.
  - **eligibility** — archived / erased / terminal-commitment entries
    are refused: a grant never resurrects a row.

Whether a grant is HONOURED depends on your target's active planner.
Under a grants-aware planner (``grants_v1`` / ``grants_v2``) it is
live: your entry competes for a ``preferred`` seat at the next
compile. Under the legacy planner it is only recorded. ``mm_health``
names the active planner; the ``mm_search`` Resident column shows the
outcome per row (``pref`` = seated, ``omit`` = granted but did not
fit). ``preferred`` is a claim to compete, not a guaranteed seat.

Args:
    memory_id: The entry's id (8-16 hex chars) — yours.
    reason: REQUIRED — why this must stay resident (one line).
    expected_generation: Optional compare-and-set fence — the target
        generation you last read; a concurrent grant mutation makes
        the call fail loudly instead of applying on a stale view.
    actor_name: Display name for the audit trail.
    agent: Agent name (default: MM_AGENT env var).

Returns:
    R1-style receipt: outcome, grant_id, effective class before/after,
    the new generation, and every other grant still holding the entry.

mm_revoke_residency

Withdraw one of YOUR OWN residency self-grants.

Argument	Type	Required	Default
grant_id	string	yes
reason	string	yes
expected_generation	integer		null
actor_name	string		null
agent	string		null

Full description

Scope: only grants of source ``agent``, on your own target,
over your own entries. Human, policy and migration grants are not
yours to revoke — ask an operator.

The receipt is honest about RESIDUAL HOLD (R1): revoking your grant
may leave another grant holding the entry, in which case residency
is reported UNCHANGED — read ``effective_class_after``, not the
outcome, before assuming the entry will leave the protected pool.
Idempotent: revoking an already-revoked grant is ``no_effect``.

Args:
    grant_id: The grant's UUID (from the grant receipt or an operator).
    reason: REQUIRED — why you are withdrawing it.
    expected_generation: Optional compare-and-set fence (see
        ``mm_grant_residency``).
    actor_name: Display name for the audit trail.
    agent: Agent name (default: MM_AGENT env var).

Returns:
    R1-style receipt with effective class before/after and the other
    grants still holding the entry.

Operations and health

Pipeline state, latency, quotas and configuration, for the platform team.

mm_status

Check Meaning Memory health and configuration.

Argument	Type	Required	Default
agent	string		null
request_id	string		null
idempotency_key	string		null
strict_mode	boolean		false
tenant_id	string		null
actor	object		null
trace_id	string		null
span_id	string		null
contract_version	string		"1.0.0"
extensions	object		null
envelope_format	string		null

Full description

**Semantic contract:** ``memory.status`` (real-tier).

Returns entry counts, config fingerprint, validation results,
and agent identity.

Args:
agent: Agent name (default: MM_AGENT env var).

Returns:
Formatted status report (markdown by default; JSON envelope when
caller supplies `envelope_format="json"`).

mm_health

Return Meaning Memory pipeline health for the given agent.

Argument	Type	Required	Default
agent	string		null

Full description

Reads sentinel, checkpoint, retry state, and recent runs log to
produce a single canonical health assessment. Designed as the
data source for: watchdog, morning briefings, /session-start skill,
weekly health report.

Args:
agent: Agent name (default: MM_AGENT env var).

Returns:
Formatted health report with metrics.

mm_slo

Query rolling-window ingest-to-search latency SLO metrics. Use for operational health checks: is the write pipeline draining, how old is the oldest queued entry, what are ingest latencies. Read-only; returns no memory content. Args: window (1h/24h/7d/30d/all; default 24h), optional writer_tenant_id / agent_filter, include_raw for a PII-safe event subset. Returns a JSON envelope payload: event_count, latency percentiles (p50/p95/p99/min/max), queue_depth_current, oldest_ready_age_s, drain-duration stats, per-tenant and per-status breakdowns, anomaly counters.

Argument	Type	Required	Default
window	string		"24h"
writer_tenant_id	string		null
agent_filter	string		null
include_raw	boolean		false
agent	string		null
request_id	string		null
idempotency_key	string		null
strict_mode	boolean		false
tenant_id	string		null
actor	object		null
trace_id	string		null
span_id	string		null
contract_version	string		"1.0.0"
extensions	object		null
envelope_format	string		null

mm_queue_status

Introspect the async pipeline state of a single memory.

Argument	Type	Required	Default
mem_id	string	yes
agent	string		null

Full description

**Semantic contract:** ``memory.queue_status``.

Answers the question an agent has after `mm_remember`: "is my memory
searchable yet?" Returns a markdown summary of where the memory sits
in the 5-stage pipeline:

1. Journal pending (`.mm-journal/ready/<mem_id>.json`) — awaiting consolidation drain
2. In ledger but not yet enqueued for embedding (e.g. legacy entry)
3. Queued for embedding (worker hasn't claimed it yet)
4. Embedding in progress (worker is computing the vector now)
5. Ready — fully indexed, semantic search will surface it
Or: Failed — worker recorded an error (retry per backoff schedule)

Args:
mem_id: 16-hex memory identifier (or 8-hex prefix; engine normalizes).
agent: Agent name (default: MM_AGENT env var). Determines which
backend to introspect.

Returns:
Markdown summary with stage label + diagnostic detail + timestamps
when available + suggested operator action when stage is FAILED or
NOT_YET_ENQUEUED.

Pairs with `mm_remember` response message accuracy and
`MEMORY-LIFECYCLE.md` customer-facing operator doc.

mm_stare_readiness

Report per-dimension STARE maturity (S/T/A/R/E).

Argument	Type	Required	Default
format	string		null

Full description

**Semantic contract:** ``memory.diagnostics.stare_readiness``
(v3.10+).

Returns the engine's authoritative, capability-grained view of each
STARE capability across three axes (implementation / deployment /
evidence) + verdict + open failing-gates, so you can answer "is
capability X built / on / proven yet?" without grepping docs. The
single per-dim ``maturity`` string is deprecated; read ``maturity_axes``.

Args:
format: ``"markdown"`` (default) returns a human-readable
report. ``"json"`` returns the raw dict serialized as JSON
for programmatic consumers (panel reviewers, dashboards,
CI checks).

Returns:
Markdown report by default; JSON string when ``format="json"``.

mm_episode_summary

Return per-episode metadata + active-entry statistics.

Argument	Type	Required	Default
episode_id	string	yes
agent	string		null
tenant_id	string		null

Full description

**Semantic contract:** ``memory.episode.summary`` (v3.10+).

Looks up the ``mm_episodes`` row for the given ``episode_id`` and
returns it as a human-readable markdown block. Derives two
additional read-time fields (NOT stored on mm_episodes):

- ``entry_count``: active entries with this ``episode_id`` on
``mm_entries``.
- ``latest_entry_at``: most recent ``created_at`` among those.

Use to surface "what's the Sonoma summit prep episode about?"
queries — episode title, timeline, summary_text, plus how many
memories are bound to it. Combine with ``mm_search(episode_id=...)``
to actually retrieve the bound memories.

Args:
episode_id: UUID as string. Required.
agent: Agent name (default: MM_AGENT env var).
tenant_id: Explicit tenant for multi-tenant deployments.
Default ``"default"`` for single-tenant default path.

Returns:
Markdown summary OR a not-found message when no
``mm_episodes`` row exists for the given (episode_id, tenant)
pair. Note: soft-reference semantics — an episode_id can exist
in ``mm_entries.episode_id`` without a matching row in
``mm_episodes`` (partner may have created the join key first
and the summary row later). In that case this tool returns
"not found" even if entries are bound to it — caller can offer
to create the summary row.

mm_compile_memory

Preview (and in operator escape-hatch cases, write) the agent’s MEMORY.md compiled from the canonical store. Requires MM_BACKEND=postgres in the server environment (FileBackend gets a clear error). LIVE WRITES ARE DISABLED BY DEFAULT: this path forwards only three of the ten canonical render knobs, so a default dry_run=false call is refused rather than writing a non-canonical MEMORY.md. Use dry_run=true for non-durable inspection (returns the rendered markdown + compile metrics without touching the live file); use the drain/nightly consolidation path for durable refresh. The MM_COMPILE_ALLOW_NONCANONICAL=1 environment escape hatch permits a knowingly non-canonical operator write.

Argument	Type	Required	Default
agent	string		null
dry_run	boolean		false
budget_lines	integer		null
budget_chars	integer		null
sig_pinned	number		null

mm_lock_status

Diagnose the current state of the Meaning Memory lock file.

Argument	Type	Required	Default
agent	string		null

Full description

Attempts a non-blocking flock probe. If the lock is free, reports free
and the path inspected. If held, parses /proc/locks to identify the
holding process(es) with PID, command line, executable path, and start
time.

No sudo or elevated privileges required — uses only procfs (world-
readable on standard Linux installs).

Useful during incident triage: "who's holding .rosebud.lock right now?"
answered in one MCP call instead of SSH + sudo lsof.

Post-v3 (journal architecture shipped April 2026): MCP writes go through
the maildir journal, not this lock. The lock is now primarily held by
the pipeline's outer `acquire_lock` during the 2-3 min consolidation
window. So a HELD state with a memory-consolidate.py cmdline is the
normal operating-window signal, not a bug.

Args:
agent: Agent name (default: MM_AGENT env var).

Returns:
Formatted markdown report.

mm_get_quota

Inspect quota state for the calling agent.

Argument	Type	Required	Default
agent	string		null

Full description

Returns the agent's effective quota (max_entries + enforcement_mode)
along with current utilization. Useful for:

- Self-introspection ("am I approaching my cap?")
- Adaptive behavior (back off writes when utilization > 90%)
- Operator dashboards (CLI / Grafana scraping)

Precedence:
1. Per-(tenant, agent) row in ``mm_agent_quotas`` (PG only)
2. Env vars (``MM_AGENT_QUOTA_MAX_ENTRIES`` +
``MM_AGENT_QUOTA_ENFORCE``)
3. Defaults (100,000 entries, mode=off)

Args:
agent: Agent name (default: MM_AGENT env var).

Returns:
Dict with quota state:
- ``agent_id``: resolved agent name
- ``tenant_id``: resolved tenant ("default" for solo)
- ``current_count``: agent's current active entry count
- ``max_entries``: effective quota cap
- ``enforcement_mode``: 'off' | 'warn' | 'reject'
- ``source``: 'per_agent_override' | 'env' | 'default'
- ``utilization_pct``: float in [0.0, ∞) — values > 1.0 mean
the agent is over quota (only possible if mode != 'reject')

mm_get_stare_policy

Inspect the effective STARE policy for an agent.

Argument	Type	Required	Default
agent	string		null
explain	boolean		false

Full description

Resolves the per-(tenant, agent) STARE configuration with full
precedence: ``(tenant, agent)`` row → ``(tenant, '*')`` row → env
vars → defaults, then an ``MM_STARE_FORCE_OFF`` clamp. Self-
introspection ("is Episodic arc weaving on for me?"); unprivileged.

Args:
agent: Agent name (default: caller's resolved agent).
explain: When True, include the per-field resolution ``trace``
({field: 'agent'|'tenant_wildcard'|'env'|'default'|'force_off'}).
Without it an operator who set a row to OFF but sees ON cannot
tell whether the row, the env, or the precedence is wrong.

Returns:
Dict with ``agent_id``, ``tenant_id``, ``effective`` (the resolved
STARE knob map), ``source`` ('per_agent_override' | 'tenant_wildcard'
| 'env' | 'default'), audit fields when an override row exists, and
``trace`` when ``explain=True``.

mm_set_stare_policy

Set or preview a per-(tenant, agent) STARE policy override. ADMIN-GATED control-plane write: requires the internal/trusted-local trust boundary; public-SSE callers are rejected. PostgresBackend only. The write is a JSONB partial merge — only the fields you pass change; reason is required and the acting principal is recorded from the authenticated identity, never a caller-supplied string. Use dry_run to preview the merged policy without persisting. Returns the effective merged policy.

Argument	Type	Required	Default
agent	string		null
overrides	object		null
reason	string		null
dry_run	boolean		false

mm_explain_visibility

Debug fn rendering visibility logic for (actor, mem_id).

Argument	Type	Required	Default
actor_agent_id	string	yes
mem_id	string	yes
actor_tenant_id	string		"default"

Full description

Given an actor + memory id, returns a structured dict explaining
why the entry is or isn't visible to the actor. Walks the same
logic as the Q14 read path but renders each decision step
explicitly. Suitable for debugging "why did this entry leak / why
is this entry hidden?".

Verdicts (one of):
"entry_not_found"
"allowed_as_writer"
"allowed_via_membership"
"denied_writer_private_other_actor"
"denied_no_membership_at_created_at"

Returns:
dict with keys: visible (bool), actor (with allowed_scope_groups
+ auth_context_version SHA-256 hash), entry (or None if not
found), decision (verdict + writer_private_match flag +
valid_memberships_at_created_at list).

Args:
actor_agent_id: caller's agent_id.
mem_id: entry to explain.
actor_tenant_id: tenant scope (default "default").

mm_validate_auth_config

Admin: validate the active AuthContext config.

No arguments.

Full description

Q14 safety net 1: pre-deploy + nightly verification that surfaces
YAML drift / typos before they manifest as silent visibility leaks.

Returns:
dict with `valid` (bool), `issues` (list of human-readable
strings — empty when valid), `auth_context_version` (the
SHA-256 hash of the active config), and `agents` / `groups`
summary (counts).

No arguments — operates on the module-level active singleton set
via auth_context.set_active_config or reload_active_config.

Governance (on the roadmap)

Reading governance state works today. The write tools are defined so you can integrate against them now; until enforcement ships, each returns not_implemented_phase_b and changes nothing.

mm_get_governance

Read governance state for a memory entry.

Argument	Type	Required	Default
mem_id	string	yes
agent	string		null
request_id	string		null
idempotency_key	string		null
strict_mode	boolean		false
tenant_id	string		null
actor	object		null
trace_id	string		null
span_id	string		null
contract_version	string		"1.0.0"
extensions	object		null
envelope_format	string		null

Full description

**Semantic contract:** ``memory.get_governance`` (real-tier).

First **real**-tier MCP tool. Returns retention class, retention
expiry, legal hold state, and PII tags for the entry identified by
`mem_id` within the resolved tenant scope. Default response is the
v1.2 JSON envelope; callers MAY opt into markdown via
`envelope_format="markdown"` though governance reads are intended
for JSON consumers.

Args:
mem_id: 16-hex memory identifier per contract.
agent: Agent name (default: MM_AGENT env var).

Returns:
Governance JSON shape per §2.6a:
{
"memory_id": "...",
"retention_class": "default" | "long_term" | ... | None,
"retention_expires_at": ISO 8601 UTC string | None,
"legal_hold": {
"enabled": bool,
"reason": str | None,
"since": ISO 8601 UTC string | None,
},
"pii_tags": [str, ...],
}
Wrapped under `payload` of the v1.2 success envelope.

Raises (caught by envelope wrapper -> internal_error envelope):
ValidationError: mem_id is not 16-hex.
EntryNotFoundError: mem_id does not exist for tenant.
MeaningMemoryError: backend resolution failure.

mm_forget

Forget (tombstone) a memory by id — stub for Phase B governance.

Argument	Type	Required	Default
memory_id	string	yes
request_id	string		null
idempotency_key	string		null
strict_mode	boolean		false
tenant_id	string		null
actor	object		null
trace_id	string		null
span_id	string		null
contract_version	string		"1.0.0"
extensions	object		null
envelope_format	string		null

Full description

**Semantic contract:** ``memory.forget`` (full-stub tier).

Phase A: tool is declared in the v1.0 contract surface but
enforcement is deferred to Phase B. Calls return `501
not_implemented_phase_b` with `extensions.enforcement_deferred=true`.
The request IS audited (operation_requested_not_implemented_phase_b
event in mm_audit_events) so callers can verify their integration
flows reach the contract endpoint correctly before Phase B ships.

Per GDPR semantics:
- Default behavior (Phase B): tombstone — preserves lineage,
scrubs text/PII payload.
- `gdpr_erase=true` mode (Phase B): hard-delete text + PII,
preserves audit skeleton (memory_id, erase_ts, actor, reason).
- For subject-level erase, see `mm_erase_subject` (declared-
only, sub-commit 9).

Semantic name: `memory.forget` (per panel decision: physical
mm_* name kept for backward compat with 611+ agent runtime caller
sites; semantic name carried via envelope.operation_type).

Args:
memory_id: The memory entry to forget (mem-* sha-prefixed id).

Returns:
JSON envelope. In Phase A this is always a 501 not_implemented_phase_b
error envelope. In Phase B this will be a 200 success envelope
with payload describing the tombstone or erasure outcome.

mm_set_retention

Set retention policy on a memory — stub for Phase B governance.

Argument	Type	Required	Default
memory_id	string	yes
retention	string	yes
request_id	string		null
idempotency_key	string		null
strict_mode	boolean		false
tenant_id	string		null
actor	object		null
trace_id	string		null
span_id	string		null
contract_version	string		"1.0.0"
extensions	object		null
envelope_format	string		null

Full description

**Semantic contract:** ``memory.set_retention`` (full-stub tier).

Phase A: declared in the v1.0 contract surface; enforcement deferred
to Phase B. Same audit + 501 contract as `mm_forget`.

Semantic name: `memory.set_retention`.

Args:
memory_id: The memory entry to update.
retention: Retention policy expression. Phase B-validated values
(preview): `"30d"`, `"90d"`, `"1y"`, `"7y"`, `"permanent"`.
Phase A accepts any string and audits it; no validation runs.

Returns:
JSON envelope. Phase A: 501 not_implemented_phase_b. Phase B:
200 with payload describing the retention update.

mm_set_legal_hold

Set legal hold flag on a memory — stub for Phase B governance.

Argument	Type	Required	Default
memory_id	string	yes
enabled	boolean	yes
request_id	string		null
idempotency_key	string		null
strict_mode	boolean		false
tenant_id	string		null
actor	object		null
trace_id	string		null
span_id	string		null
contract_version	string		"1.0.0"
extensions	object		null
envelope_format	string		null

Full description

**Semantic contract:** ``memory.set_legal_hold`` (full-stub tier).

Phase A: declared in the v1.0 contract surface; enforcement deferred
to Phase B. Legal hold supersedes retention (held memory cannot be
forgotten/erased even if retention expires) — Phase B will enforce
this at write time.

Semantic name: `memory.set_legal_hold`.

Args:
memory_id: The memory entry to update.
enabled: True to set hold; False to release.

Returns:
JSON envelope. Phase A: 501 not_implemented_phase_b. Phase B:
200 with payload describing the hold state transition.

semantics (per the configured LLM-panel review note — D2 GDPR).

mm_erase

Erase a memory (per-memory) — declared, no Phase A enforcement.

Argument	Type	Required	Default
memory_id	string	yes
gdpr_erase	boolean		false
request_id	string		null
idempotency_key	string		null
strict_mode	boolean		false
tenant_id	string		null
actor	object		null
trace_id	string		null
span_id	string		null
contract_version	string		"1.0.0"
extensions	object		null
envelope_format	string		null

Full description

**Semantic contract:** ``memory.erase`` (declared-only).

Per-memory erasure with optional GDPR mode. Distinct from
`mm_forget` (full_stub tier — tombstone semantics, audited)
in that this tool surfaces the v1.0 contract for hard-delete /
GDPR-mode erasure. Phase A does NOT execute either operation;
invocation returns 501 immediately. Phase B will:
- `gdpr_erase=False` (default): tombstone — preserves lineage
- `gdpr_erase=True`: hard-delete text + PII payload, preserve
audit skeleton (memory_id, erase_ts, actor, reason)

Semantic name: `memory.erase` (GDPR semantics
decision: combine the configured LLM hybrid).

Args:
memory_id: The memory entry to erase.
gdpr_erase: True to invoke hard-delete mode in Phase B.

Returns:
Phase A: 501 not_implemented_phase_b error envelope.
Phase B: 200 success with payload describing the erase outcome.

mm_erase_subject

Subject-level cascade erase — declared, no Phase A enforcement.

Argument	Type	Required	Default
principal_id	string	yes
request_id	string		null
idempotency_key	string		null
strict_mode	boolean		false
tenant_id	string		null
actor	object		null
trace_id	string		null
span_id	string		null
contract_version	string		"1.0.0"
extensions	object		null
envelope_format	string		null

Full description

**Semantic contract:** ``memory.erase_subject`` (declared-only).

Phase B will perform a tenant-scoped scan for all memories where
`actor.principal_id == principal_id` (or any envelope-recorded
subject identifier matches) and apply the GDPR-erase contract to
each. Stronger PII scrub than per-memory `mm_erase` because
it covers attribution metadata too. Phase A returns 501
immediately. Legal counsel review pending for full Phase B
enforcement semantics (per the configured LLM-panel review note — D2 GDPR).

Semantic name: `memory.erase_subject`.

Args:
principal_id: The subject identifier whose memories to erase.

Returns:
Phase A: 501 not_implemented_phase_b. Phase B: 200 with payload
describing erase fan-out (count, memory_ids touched, audit
skeleton retention).

mm_redact

Redact PII from a memory by pattern — declared, no Phase A enforcement.

Argument	Type	Required	Default
memory_id	string	yes
redaction_pattern	string	yes
request_id	string		null
idempotency_key	string		null
strict_mode	boolean		false
tenant_id	string		null
actor	object		null
trace_id	string		null
span_id	string		null
contract_version	string		"1.0.0"
extensions	object		null
envelope_format	string		null

Full description

**Semantic contract:** ``memory.redact`` (declared-only).

Phase B will scan the memory text for matches against
`redaction_pattern` (regex or named PII type identifier) and replace
matched substrings with a configured redaction marker. Phase A
returns 501 immediately.

Semantic name: `memory.redact`.

Args:
memory_id: The memory entry to redact.
redaction_pattern: Pattern identifier (e.g. "email", "phone",
"credit_card") or regex string. Phase B-validated set TBD.

Returns:
Phase A: 501 not_implemented_phase_b. Phase B: 200 with payload
describing redaction count + before/after digest.

mm_tag_pii

Tag detected PII categories on a memory — declared, no Phase A enforcement.

Argument	Type	Required	Default
memory_id	string	yes
pii_types	array of string	yes
request_id	string		null
idempotency_key	string		null
strict_mode	boolean		false
tenant_id	string		null
actor	object		null
trace_id	string		null
span_id	string		null
contract_version	string		"1.0.0"
extensions	object		null
envelope_format	string		null

Full description

**Semantic contract:** ``memory.tag_pii`` (declared-only).

Phase B will validate `pii_types` against an allowed taxonomy (e.g.
"email", "phone", "ssn", "address", "name") and store tags as
structured metadata for downstream redaction / retention policy.
Phase A returns 501 immediately.

Semantic name: `memory.tag_pii`.

Args:
memory_id: The memory entry to tag.
pii_types: List of PII category identifiers.

Returns:
Phase A: 501 not_implemented_phase_b. Phase B: 200 with payload
describing tag persistence + downstream policy implications.

mm_audit

Query the audit trail — declared, no Phase A enforcement.

Argument	Type	Required	Default
memory_id	string		null
since	string		null
request_id	string		null
idempotency_key	string		null
strict_mode	boolean		false
tenant_id	string		null
actor	object		null
trace_id	string		null
span_id	string		null
contract_version	string		"1.0.0"
extensions	object		null
envelope_format	string		null

Full description

**Semantic contract:** ``memory.audit`` (declared-only).

Phase B will surface `mm_audit_events` rows scoped to the caller's
tenant. Filters: `memory_id` (audit events for a specific memory)
and `since` (ISO timestamp lower bound). Phase A returns 501
immediately even though the audit table is being populated by
full_stub tier dispatch (sub-7) — Phase B adds the read path.

Semantic name: `memory.audit`.

Args:
memory_id: Filter to events about a specific memory (optional).
since: ISO 8601 timestamp lower bound (optional).

Returns:
Phase A: 501 not_implemented_phase_b. Phase B: 200 with payload
listing matching audit events with envelope + metadata.