Server definition

Hash: sha256:7c379b4a728d75a0f2ff507eddc75cb58b46d25d584d2bf25e49f73ff4adccb1
What it is: What a remote MCP server returned when asked what it offers: 24 tools

The blob, as servednamed by its sha256

{
  "instructions": "WhiteMagic gives you durable local project memory (on-device store). Session rhythm:\n1. wm(route=\"session.continuity\") before starting work — recall where the last session left off.\n2. wm(route=\"session.start\", args={\"title\": \"...\"}) when you begin a session.\n3. Record selectively via wm(route=\"session.record\") — turn_type decision/breakthrough/error/summary, importance 0.0-1.0 — only what a future session needs.\n4. Finish with a short summary turn, then wm(route=\"session.checkpoint\").\nPrefer the discrete lifecycle tools emitted in tools/list; wm(route=\"...\") reaches the wider curated catalog and wm(route=\"tools.list\") enumerates the surface.\nOnboarding: `wm grimoire`; pull existing notes in with `wm ingest --source <folder>`. Memory is not encrypted — Back up the store directory; never record sensitive values.\nMode: READ-ONLY — writes (session.*, memory.create/update) are refused by governance; recall only, do not retry writes.\nScope: store /srv/whitemagic/hosted-store/lmdb.\nCoordination (multi-agent checkouts): one writer per checkout — Claim a scope before shared-tree edits, release it when done, and hand off via wm(route=\"session.checkpoint\") structured fields (commit, next_queue, open_flags; lease_id names a held scope).\nFailure ladder: a call failing twice means change something — never retry unchanged. If tools vanish or every call errors, run `wm doctor`, restart the client session; do not probe with shell no-ops.",
  "tools": [
    {
      "description": "Explain why a memory or route was selected (provenance readout).",
      "inputSchema": {
        "properties": {
          "args_hash": {
            "description": "Hash of the arguments under evaluation",
            "type": "string"
          },
          "has_purpose": {
            "description": "Claim: the invocation carries a purpose",
            "type": "boolean"
          },
          "is_network": {
            "description": "Claim: the invocation uses the network",
            "type": "boolean"
          },
          "is_spawn": {
            "description": "Claim: the invocation spawns a process",
            "type": "boolean"
          },
          "is_write": {
            "description": "Claim: the invocation writes",
            "type": "boolean"
          },
          "tool_name": {
            "description": "Tool name to explain",
            "type": "string"
          }
        },
        "required": [],
        "type": "object"
      },
      "name": "gnosis.explain",
      "outputSchema": {
        "additionalProperties": true,
        "description": "Result envelope for this tool; fields vary by operation.",
        "type": "object"
      }
    },
    {
      "description": "Knowledge-surface status: galaxies, counts, and index health.",
      "inputSchema": {
        "properties": {},
        "type": "object"
      },
      "name": "gnosis.status",
      "outputSchema": {
        "additionalProperties": true,
        "description": "Result envelope for this tool; fields vary by operation.",
        "type": "object"
      }
    },
    {
      "description": "Aggregate a numeric or categorical field over matched memories.",
      "inputSchema": {
        "properties": {
          "limit": {
            "description": "Maximum candidates considered (default 50; must be >= 1)",
            "minimum": 1,
            "type": "integer"
          },
          "metric": {
            "description": "Aggregate metric: count | session_count | session_span",
            "type": "string"
          },
          "query": {
            "description": "Full-text query selecting the memories to aggregate over",
            "type": "string"
          }
        },
        "required": [
          "query",
          "metric"
        ],
        "type": "object"
      },
      "name": "memory.aggregate",
      "outputSchema": {
        "additionalProperties": true,
        "description": "Result envelope for this tool; fields vary by operation.",
        "type": "object"
      }
    },
    {
      "description": "Associative neighbours of a memory (spreading activation over the association graph).",
      "inputSchema": {
        "properties": {
          "direction": {
            "description": "Direction: from | to | both (default: both)",
            "type": "string"
          },
          "id": {
            "description": "Memory UUID to inspect",
            "type": "string"
          }
        },
        "required": [
          "id"
        ],
        "type": "object"
      },
      "name": "memory.associations",
      "outputSchema": {
        "additionalProperties": true,
        "description": "Result envelope for this tool; fields vary by operation.",
        "type": "object"
      }
    },
    {
      "description": "Read several memories by id in one call.",
      "inputSchema": {
        "properties": {
          "galaxy": {
            "description": "Galaxy (default: codex)",
            "type": "string"
          },
          "ids": {
            "description": "Memory UUIDs to read",
            "items": {
              "type": "string"
            },
            "type": "array"
          }
        },
        "required": [
          "ids"
        ],
        "type": "object"
      },
      "name": "memory.batch_read",
      "outputSchema": {
        "additionalProperties": true,
        "description": "Result envelope for this tool; fields vary by operation.",
        "type": "object"
      }
    },
    {
      "description": "Count memories matching optional filters without returning content.",
      "inputSchema": {
        "properties": {
          "galaxy": {
            "description": "Galaxy to count (optional; all memory galaxies when absent)",
            "type": "string"
          }
        },
        "required": [],
        "type": "object"
      },
      "name": "memory.count",
      "outputSchema": {
        "additionalProperties": true,
        "description": "Result envelope for this tool; fields vary by operation.",
        "type": "object"
      }
    },
    {
      "description": "Filter memories by metadata (tags, importance, recency).",
      "inputSchema": {
        "properties": {
          "created_after": {
            "description": "Filter: only memories created at or after this RFC 3339 timestamp (e.g. 2026-08-01T00:00:00Z)",
            "type": "string"
          },
          "created_before": {
            "description": "Filter: only memories created at or before this RFC 3339 timestamp",
            "type": "string"
          },
          "exclude_tags": {
            "description": "Filter: drop memories carrying any of these tags",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "galaxy": {
            "description": "Galaxy to filter (default codex)",
            "type": "string"
          },
          "limit": {
            "description": "Maximum entries (default 50)",
            "type": "integer"
          },
          "max_importance": {
            "description": "Filter: maximum importance (0-1)",
            "type": "number"
          },
          "min_importance": {
            "description": "Filter: minimum importance (0-1)",
            "type": "number"
          },
          "offset": {
            "description": "Skip this many matching entries before returning (default 0)",
            "type": "integer"
          },
          "query": {
            "description": "Filter: every whitespace-separated term must appear (case-insensitive) in the content or title",
            "type": "string"
          },
          "tags": {
            "description": "Filter: memories with all of these tags",
            "items": {
              "type": "string"
            },
            "type": "array"
          }
        },
        "required": [],
        "type": "object"
      },
      "name": "memory.filter",
      "outputSchema": {
        "additionalProperties": true,
        "description": "Result envelope for this tool; fields vary by operation.",
        "type": "object"
      }
    },
    {
      "description": "Compatibility alias of memory.search — same implementation, same arguments, same results. Kept for clients pinned to this name; prefer memory.search.",
      "inputSchema": {
        "properties": {
          "cold_scan_limit": {
            "description": "Maximum cold records to scan when include_cold is set (default 2048)",
            "type": "integer"
          },
          "galaxy": {
            "description": "Galaxy filter (optional; default: search all memory galaxies, results labeled; \"all\" is accepted as an alias for the unfiltered default)",
            "type": "string"
          },
          "include_cold": {
            "description": "Opt-in unranked cold recovery (no thaw). Trust/importance floors apply; BM25 floors do not apply to unscored recovery. Search content is scrubbed navigation capped at 8192 characters; read by id/galaxy for the exact original.",
            "type": "boolean"
          },
          "limit": {
            "description": "Maximum results (default 10; must be >= 1)",
            "minimum": 1,
            "type": "integer"
          },
          "min_importance": {
            "description": "Minimum memory importance (0-1)",
            "type": "number"
          },
          "min_score": {
            "description": "Absolute BM25 score floor",
            "type": "number"
          },
          "min_score_ratio": {
            "description": "Relative floor: reject hits below this fraction of the top score",
            "type": "number"
          },
          "min_trust": {
            "description": "Minimum source_trust (0-1): drop results below this trust floor",
            "type": "number"
          },
          "query": {
            "description": "Full-text query",
            "type": "string"
          },
          "since": {
            "description": "Inclusive lower time bound: RFC3339 ('2026-02-01T00:00:00Z') or epoch seconds",
            "type": "string"
          },
          "time_basis": {
            "description": "Time basis for since/until: 'recorded' (created_at, default) or 'event' (event_time, falling back to created_at when unset)",
            "type": "string"
          },
          "until": {
            "description": "Inclusive upper time bound: RFC3339 or epoch seconds",
            "type": "string"
          }
        },
        "required": [
          "query"
        ],
        "type": "object"
      },
      "name": "memory.hybrid_recall",
      "outputSchema": {
        "additionalProperties": true,
        "description": "Recall results (memory.search implementation) with an evidence bundle and recall-mode disclosure.",
        "properties": {
          "count": {
            "description": "Number of results returned",
            "type": "integer"
          },
          "evidence_bundle": {
            "description": "Per-result provenance (coverage, history, integrity, retrieval, source_time, visibility) plus conflicts.",
            "type": "object"
          },
          "galaxy": {
            "description": "Galaxy scope the query ran against",
            "type": "string"
          },
          "hint": {
            "description": "Optional recovery hint when results are thin (null when there is none)",
            "type": [
              "string",
              "null"
            ]
          },
          "recall_mode": {
            "description": "Retrieval path used (hybrid, episodic, fts, importance, none)",
            "type": "string"
          },
          "results": {
            "description": "Ranked memories with per-result source labels",
            "items": {
              "type": "object"
            },
            "type": "array"
          },
          "status": {
            "description": "Operation status",
            "type": "string"
          }
        },
        "type": "object"
      }
    },
    {
      "description": "List memories with filters (galaxy, tags, limit, offset) for browsing and discovery.",
      "inputSchema": {
        "properties": {
          "exclude_tags": {
            "description": "Drop memories carrying any of these tags",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "galaxy": {
            "description": "Galaxy to list (default codex)",
            "type": "string"
          },
          "limit": {
            "description": "Maximum entries (default 20)",
            "type": "integer"
          },
          "offset": {
            "description": "Skip this many matching entries before returning (default 0)",
            "type": "integer"
          }
        },
        "required": [],
        "type": "object"
      },
      "name": "memory.list",
      "outputSchema": {
        "additionalProperties": true,
        "description": "A page of memory records with pagination counters.",
        "properties": {
          "galaxy": {
            "description": "Galaxy scope listed",
            "type": "string"
          },
          "matched": {
            "description": "Total records matching the filter",
            "type": "integer"
          },
          "memories": {
            "description": "Records (id, content_preview, created_at, tags)",
            "items": {
              "type": "object"
            },
            "type": "array"
          },
          "offset": {
            "description": "Pagination offset applied",
            "type": "integer"
          },
          "returned": {
            "description": "Records in this page",
            "type": "integer"
          },
          "status": {
            "description": "Operation status",
            "type": "string"
          },
          "total": {
            "description": "Total records in scope",
            "type": "integer"
          }
        },
        "type": "object"
      }
    },
    {
      "description": "Memories near a coordinate address (5D spatial neighbourhood).",
      "inputSchema": {
        "properties": {
          "galaxy": {
            "description": "Galaxy (default: codex)",
            "type": "string"
          },
          "limit": {
            "description": "Maximum results (default 10)",
            "type": "integer"
          },
          "query": {
            "description": "Query text to locate in 5D space",
            "type": "string"
          },
          "radius": {
            "description": "Spatial radius cutoff (optional)",
            "type": "number"
          }
        },
        "required": [
          "query"
        ],
        "type": "object"
      },
      "name": "memory.nearby",
      "outputSchema": {
        "additionalProperties": true,
        "description": "Result envelope for this tool; fields vary by operation.",
        "type": "object"
      }
    },
    {
      "description": "Structured query over memories with filters and ordering.",
      "inputSchema": {
        "properties": {
          "created_after": {
            "description": "Filter: only memories created at or after this RFC 3339 timestamp (e.g. 2026-08-01T00:00:00Z)",
            "type": "string"
          },
          "created_before": {
            "description": "Filter: only memories created at or before this RFC 3339 timestamp",
            "type": "string"
          },
          "galaxy": {
            "description": "Galaxy to query (default codex)",
            "type": "string"
          },
          "limit": {
            "description": "Maximum entries (default 50)",
            "type": "integer"
          },
          "max_importance": {
            "description": "Filter: maximum importance (0-1)",
            "type": "number"
          },
          "min_importance": {
            "description": "Filter: minimum importance (0-1)",
            "type": "number"
          },
          "query": {
            "description": "Case-insensitive substring filter over content (literal match). For tokenized, ranked full-text retrieval use memory.search",
            "type": "string"
          },
          "tags": {
            "description": "Filter: memories with all of these tags",
            "items": {
              "type": "string"
            },
            "type": "array"
          }
        },
        "required": [],
        "type": "object"
      },
      "name": "memory.query",
      "outputSchema": {
        "additionalProperties": true,
        "description": "Result envelope for this tool; fields vary by operation.",
        "type": "object"
      }
    },
    {
      "description": "Retrieve a specific memory by its ID or coordinate address.",
      "inputSchema": {
        "properties": {
          "galaxy": {
            "description": "Galaxy containing the memory (default codex)",
            "type": "string"
          },
          "id": {
            "description": "Memory UUID",
            "type": "string"
          }
        },
        "required": [
          "id"
        ],
        "type": "object"
      },
      "name": "memory.read",
      "outputSchema": {
        "additionalProperties": true,
        "description": "The exact stored memory record.",
        "properties": {
          "content": {
            "description": "Full memory content",
            "type": "string"
          },
          "created_at": {
            "description": "RFC 3339 creation timestamp",
            "type": "string"
          },
          "galaxy": {
            "description": "Galaxy containing the memory",
            "type": "string"
          },
          "id": {
            "description": "Memory UUID",
            "type": "string"
          },
          "status": {
            "description": "Operation status",
            "type": "string"
          },
          "tags": {
            "description": "Memory tags",
            "items": {
              "type": "string"
            },
            "type": "array"
          }
        },
        "type": "object"
      }
    },
    {
      "description": "List or verify a memory's content revision chain (tamper evidence): every content update is chained and head-checked.",
      "inputSchema": {
        "properties": {
          "action": {
            "description": "Action: list (default) | verify",
            "type": "string"
          },
          "galaxy": {
            "description": "Galaxy (default: codex)",
            "type": "string"
          },
          "id": {
            "description": "Memory UUID to inspect",
            "type": "string"
          }
        },
        "required": [
          "id"
        ],
        "type": "object"
      },
      "name": "memory.revisions",
      "outputSchema": {
        "additionalProperties": true,
        "description": "Revision chain for a memory (newest first).",
        "properties": {
          "action": {
            "description": "Action performed (list, restore, ...)",
            "type": "string"
          },
          "count": {
            "description": "Number of revisions returned",
            "type": "integer"
          },
          "galaxy": {
            "description": "Galaxy containing the memory",
            "type": "string"
          },
          "id": {
            "description": "Memory UUID",
            "type": "string"
          },
          "revisions": {
            "description": "Revision records with content hashes and timestamps",
            "items": {
              "type": "object"
            },
            "type": "array"
          },
          "status": {
            "description": "Operation status",
            "type": "string"
          }
        },
        "type": "object"
      }
    },
    {
      "description": "Search memories: hybrid BM25 + vector fusion with deterministic episodic and full-text fallbacks; each result discloses its recall_mode. The preferred recall tool.",
      "inputSchema": {
        "properties": {
          "cold_scan_limit": {
            "description": "Maximum cold records to scan when include_cold is set (default 2048)",
            "type": "integer"
          },
          "galaxy": {
            "description": "Galaxy filter (optional; default: search all memory galaxies, results labeled; \"all\" is accepted as an alias for the unfiltered default)",
            "type": "string"
          },
          "include_cold": {
            "description": "Opt-in unranked cold recovery (no thaw). Trust/importance floors apply; BM25 floors do not apply to unscored recovery. Search content is scrubbed navigation capped at 8192 characters; read by id/galaxy for the exact original.",
            "type": "boolean"
          },
          "limit": {
            "description": "Maximum results (default 10; must be >= 1)",
            "minimum": 1,
            "type": "integer"
          },
          "min_importance": {
            "description": "Minimum memory importance (0-1)",
            "type": "number"
          },
          "min_score": {
            "description": "Absolute BM25 score floor",
            "type": "number"
          },
          "min_score_ratio": {
            "description": "Relative floor: reject hits below this fraction of the top score",
            "type": "number"
          },
          "min_trust": {
            "description": "Minimum source_trust (0-1): drop results below this trust floor",
            "type": "number"
          },
          "query": {
            "description": "Full-text query",
            "type": "string"
          },
          "since": {
            "description": "Inclusive lower time bound: RFC3339 ('2026-02-01T00:00:00Z') or epoch seconds",
            "type": "string"
          },
          "time_basis": {
            "description": "Time basis for since/until: 'recorded' (created_at, default) or 'event' (event_time, falling back to created_at when unset)",
            "type": "string"
          },
          "until": {
            "description": "Inclusive upper time bound: RFC3339 or epoch seconds",
            "type": "string"
          }
        },
        "required": [
          "query"
        ],
        "type": "object"
      },
      "name": "memory.search",
      "outputSchema": {
        "additionalProperties": true,
        "description": "Ranked recall results with an evidence bundle and recall-mode disclosure.",
        "properties": {
          "count": {
            "description": "Number of results returned",
            "type": "integer"
          },
          "evidence_bundle": {
            "description": "Per-result provenance (coverage, history, integrity, retrieval, source_time, visibility) plus conflicts.",
            "type": "object"
          },
          "galaxy": {
            "description": "Galaxy scope the query ran against",
            "type": "string"
          },
          "hint": {
            "description": "Optional recovery hint when results are thin (null when there is none)",
            "type": [
              "string",
              "null"
            ]
          },
          "recall_mode": {
            "description": "Retrieval path used (hybrid, episodic, fts, importance, none)",
            "type": "string"
          },
          "results": {
            "description": "Ranked memories (id, content, score, galaxy, source)",
            "items": {
              "type": "object"
            },
            "type": "array"
          },
          "status": {
            "description": "Operation status",
            "type": "string"
          }
        },
        "type": "object"
      }
    },
    {
      "description": "Execute multiple memory search queries concurrently in a single turn. Unpacks up to 10 queries, searches the curated corpus, and returns consolidated results.",
      "inputSchema": {
        "properties": {
          "limit_per_query": {
            "default": 5,
            "description": "Max results per query (default 5, max 20).",
            "type": "integer"
          },
          "queries": {
            "description": "List of query strings to search (1 to 10 queries).",
            "items": {
              "type": "string"
            },
            "type": "array"
          }
        },
        "required": [
          "queries"
        ],
        "type": "object"
      },
      "name": "memory.search_batch",
      "outputSchema": null
    },
    {
      "description": "Memory index statistics: totals, galaxy spread, and index health.",
      "inputSchema": {
        "properties": {
          "galaxy": {
            "description": "Galaxy to summarize (optional; default codex)",
            "type": "string"
          }
        },
        "required": [],
        "type": "object"
      },
      "name": "memory.stats",
      "outputSchema": {
        "additionalProperties": true,
        "description": "Result envelope for this tool; fields vary by operation.",
        "type": "object"
      }
    },
    {
      "description": "List the tag vocabulary with usage counts.",
      "inputSchema": {
        "properties": {
          "galaxy": {
            "description": "Galaxy whose tags to list (optional; default codex)",
            "type": "string"
          }
        },
        "required": [],
        "type": "object"
      },
      "name": "memory.tags",
      "outputSchema": {
        "additionalProperties": true,
        "description": "Result envelope for this tool; fields vary by operation.",
        "type": "object"
      }
    },
    {
      "description": "Vector-similarity search over memory embeddings.",
      "inputSchema": {
        "properties": {
          "embedding": {
            "description": "Raw embedding vector (alternative to memory_id)",
            "items": {
              "type": "number"
            },
            "type": "array"
          },
          "galaxy": {
            "description": "Galaxy filter (optional)",
            "type": "string"
          },
          "limit": {
            "description": "Maximum results (default 10)",
            "type": "integer"
          },
          "memory_id": {
            "description": "Memory UUID whose stored embedding is the query",
            "type": "string"
          }
        },
        "required": [
          "memory_id"
        ],
        "type": "object"
      },
      "name": "memory.vector.search",
      "outputSchema": {
        "additionalProperties": true,
        "description": "Result envelope for this tool; fields vary by operation.",
        "type": "object"
      }
    },
    {
      "description": "Verify a receipt id or a bundle offline; fail-closed without an anchor (verdict PROVISIONAL).",
      "inputSchema": {
        "properties": {
          "bundle": {
            "description": "Inline bundle to verify (alternative to id)",
            "type": "object"
          },
          "id": {
            "description": "Receipt task id (UUID or urn:uuid:)",
            "type": "string"
          },
          "require_anchor": {
            "description": "Fail-closed: without an anchor the verdict is PROVISIONAL",
            "type": "boolean"
          },
          "variant": {
            "description": "Receipt variant (default original)",
            "type": "string"
          }
        },
        "required": [],
        "type": "object"
      },
      "name": "receipts.verify",
      "outputSchema": {
        "additionalProperties": true,
        "description": "Verification report for a receipt or bundle.",
        "properties": {
          "id": {
            "description": "Receipt UUID that was verified",
            "type": "string"
          },
          "require_anchor": {
            "description": "Whether an external anchor was required",
            "type": "boolean"
          },
          "result": {
            "description": "Verdict detail: errors, insufficient/provisional reasons, and a summary (attestations, issuers, receipts, settled, terminated, types).",
            "type": "object"
          }
        },
        "type": "object"
      }
    },
    {
      "description": "Recall where the previous session left off: recent turns, checkpoints, and open work.",
      "inputSchema": {
        "properties": {
          "current_session_id": {
            "description": "Session to exclude (optional)",
            "type": "string"
          },
          "include_briefing_text": {
            "description": "Include the ready-to-inject briefing.text block (default false; adds bytes outside the turns budget)",
            "type": "boolean"
          },
          "max_content_bytes": {
            "description": "Per-turn content cap in bytes (256-262144, default 8192)",
            "type": "integer"
          },
          "max_response_bytes": {
            "description": "Turns budget in bytes (256-262144, default 49152)",
            "type": "integer"
          },
          "n": {
            "description": "Number of prior turns (default 10)",
            "type": "integer"
          },
          "since": {
            "description": "Time-range floor: epoch seconds, RFC 3339, or YYYY-MM-DD",
            "type": "string"
          },
          "until": {
            "description": "Time-range ceiling: epoch seconds, RFC 3339, or YYYY-MM-DD",
            "type": "string"
          }
        },
        "required": [],
        "type": "object"
      },
      "name": "session.continuity",
      "outputSchema": {
        "additionalProperties": true,
        "description": "Recent turns plus the latest checkpoint handoff for the prior session.",
        "properties": {
          "checkpoint": {
            "description": "Latest checkpoint handoff, or null",
            "type": [
              "object",
              "null"
            ]
          },
          "checkpoint_id": {
            "description": "Memory UUID of the checkpoint, or null",
            "type": [
              "string",
              "null"
            ]
          },
          "count": {
            "description": "Turns returned",
            "type": "integer"
          },
          "max_content_bytes": {
            "description": "Per-turn byte cap applied",
            "type": "integer"
          },
          "max_response_bytes": {
            "description": "Total response byte budget applied",
            "type": "integer"
          },
          "previous_session": {
            "description": "Session the turns were read from",
            "type": "string"
          },
          "status": {
            "description": "Operation status",
            "type": "string"
          },
          "truncated": {
            "description": "Whether the response hit its byte budget",
            "type": "boolean"
          },
          "turns": {
            "description": "Turns (memory_id, role, turn_type, sequence, content, content_bytes, content_truncated, importance)",
            "items": {
              "type": "object"
            },
            "type": "array"
          },
          "turns_omitted": {
            "description": "Turns dropped by the response budget",
            "type": "integer"
          }
        },
        "type": "object"
      }
    },
    {
      "description": "List sessions with titles and summaries.",
      "inputSchema": {
        "properties": {
          "sequence": {
            "description": "Filter by start sequence number",
            "type": "integer"
          },
          "session_id": {
            "description": "Filter by session UUID",
            "type": "string"
          },
          "title": {
            "description": "Filter by title substring",
            "type": "string"
          },
          "type": {
            "description": "Filter by session type",
            "type": "string"
          }
        },
        "required": [],
        "type": "object"
      },
      "name": "session.list",
      "outputSchema": {
        "additionalProperties": true,
        "description": "Result envelope for this tool; fields vary by operation.",
        "type": "object"
      }
    },
    {
      "description": "Recall a session's turns without continuity packaging.",
      "inputSchema": {
        "properties": {
          "limit": {
            "description": "Maximum turns to return (default 50)",
            "type": "integer"
          },
          "session_id": {
            "description": "Session UUID to recall (defaults to the most recent session)",
            "type": "string"
          }
        },
        "required": [],
        "type": "object"
      },
      "name": "session.recall",
      "outputSchema": {
        "additionalProperties": true,
        "description": "Result envelope for this tool; fields vary by operation.",
        "type": "object"
      }
    },
    {
      "description": "Replay a session's recorded turns in order.",
      "inputSchema": {
        "properties": {
          "cursor": {
            "description": "Lossless mode opaque placement cursor",
            "type": "string"
          },
          "include_superseded": {
            "description": "Also return turns replaced via supersedes (default false).",
            "type": "boolean"
          },
          "max_wire_bytes": {
            "description": "Lossless mode serialized JSON ceiling (1024-49152)",
            "type": "integer"
          },
          "min_importance": {
            "description": "Selective mode floor (default 0.7)",
            "type": "number"
          },
          "mode": {
            "description": "full | selective | progressive | lossless (default full)",
            "type": "string"
          },
          "n": {
            "description": "Maximum turns (default 50)",
            "type": "integer"
          },
          "page_size": {
            "description": "Lossless mode records per page (1-64, default 16)",
            "type": "integer"
          },
          "session_id": {
            "description": "Target session (required explicit UUID for lossless; otherwise default most recent)",
            "type": "string"
          },
          "since": {
            "description": "Time-range floor: epoch seconds, RFC 3339, or YYYY-MM-DD",
            "type": "string"
          },
          "token_budget": {
            "description": "Progressive mode token budget (default 2000)",
            "type": "integer"
          },
          "turn_types": {
            "description": "Selective mode: turn types to keep",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "until": {
            "description": "Time-range ceiling: epoch seconds, RFC 3339, or YYYY-MM-DD",
            "type": "string"
          }
        },
        "required": [],
        "type": "object"
      },
      "name": "session.replay",
      "outputSchema": {
        "additionalProperties": true,
        "description": "Result envelope for this tool; fields vary by operation.",
        "type": "object"
      }
    },
    {
      "description": "WhiteMagic meta-tool — memory and continuity kernel over the curated tool surface (70 tools): persistent memory, session continuity and recall, governance/audit, and local tool execution. Mode: READ-ONLY — writes (session.*, memory.create/update) are refused; recall only. Scope: store /srv/whitemagic/hosted-store/lmdb. Invoke with thought=<natural language> (auto-routed), route=<exact tool id> (e.g. 'memory.search', 'session.continuity'), or args=<object> (passthrough). Provide exactly one of thought or route. Say 'list tools' to enumerate the curated surface. Prefer a discrete lifecycle tool when one matches your task; use wm for natural-language routing and the wider curated catalog.",
      "inputSchema": {
        "properties": {
          "args": {
            "description": "Arguments to pass through to the target tool.",
            "type": "object"
          },
          "route": {
            "description": "Explicit tool name for direct dispatch (e.g. 'memory.create', 'tools.list').",
            "type": "string"
          },
          "thought": {
            "description": "Natural language input describing what to do. Auto-routes to the best-matching tool via TF-IDF NLU classification.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "name": "wm",
      "outputSchema": {
        "additionalProperties": true,
        "description": "The dispatched tool's result envelope plus `_wm_route` dispatch metadata; fields vary by route.",
        "properties": {
          "_wm_route": {
            "description": "Dispatch metadata: resolved tool, routing confidence, matched input.",
            "properties": {
              "confidence": {
                "description": "Routing confidence (1.0 for explicit routes)",
                "type": "number"
              },
              "input": {
                "description": "Routing input that produced the match",
                "type": "string"
              },
              "tool": {
                "description": "Resolved route name",
                "type": "string"
              }
            },
            "type": "object"
          }
        },
        "type": "object"
      }
    }
  ]
}

Verify it yourself

curl -s https://api.teppi.xyz/v1/evidence/sha256:7c379b4a728d75a0f2ff507eddc75cb58b46d25d584d2bf25e49f73ff4adccb1 | sha256sum