Call this FIRST, before writing or editing code in an area — and again when you
    move to a new file or module. It surfaces the conventions, preferred patterns,
    rejected approaches, and known gotchas the team has already curated for that part
    of the codebase, so you write code that matches their standards on the first try
    instead of rediscovering them. Read the returned decisions and comply with them.

    Behavior: only human-approved (canonical) decisions are returned, ranked by how
    well their scope matches `file_path_or_area` and by how helpful past agents
    rated them. Each call also records a usage event so your later `submit_feedback`
    can be tied back to this exact result set.

    Returns a plain-text block. The first line is a header carrying the query token
    and server revision; then each decision is numbered for rating by index, e.g.:

        metatron:query 7f3a... · rev 0.2.1 (reference the query id in submit_feedback)
        [1] [high] Use internal.http for outbound calls, not the requests library
          scope: src/services/**
          why: flaky network caused phantom 5xx errors; the internal client retries

    Keep the query token: pass it to `submit_feedback` after the task to rate the
    decisions by their `[index]`. If nothing is registered for the area, the body is
    exactly "No matching decisions." — proceed normally.
    

    Call this after a task where you used Metatron's decisions. Reference the
    `query_id` from the get_decisions_for_context output, then — most useful of all
    — **rate each served decision 1-10 by its [index]** in `ratings`, where 10 means
    it was exactly right and 1 means it was misleading. Also state any convention
    Metatron should have known but didn't, in `what_was_missing`.

    Behavior: ratings are 1-based indices into the decisions the named query served
    (they map to real decision ids locally, so you never echo a UUID; unknown indices
    and out-of-range scores are dropped). The graded scores feed a time-decayed,
    shrunk helpfulness signal that reorders which decisions get served first next
    time — helpful ones rise, misleading ones sink. A `what_was_missing` report is
    stored as a gap for a human-gated refiner to later reshape into a CANDIDATE
    decision. Nothing you send here promotes, demotes, or rejects a decision, or changes
    its wording — crossing the canonical set is always a human's call.

    Returns a short text confirmation that the feedback was recorded (and notes
    when a gap was captured for curation).
    

    Call this when you find an undocumented convention, a tricky gotcha, or a preferred
    pattern that Metatron did not already know but future agents should. It is stored as
    an uncurated CANDIDATE: a human maintainer must approve it in the Metatron UI or CLI
    before it becomes canonical and is served to other agents. Nothing you submit here is
    auto-promoted.

    Returns the new candidate decision's id. If the pattern near-duplicates a decision
    already on record (in any wording), nothing new is stored and the existing
    decision's id is returned with a note — no need to resubmit known conventions.
    

    This is READ-ONLY. It never executes anything; contracts are run only by an
    operator or CI via `metatron verification run`, never over this server. Use
    the returned setup/checks/assertions to run the proof yourself in your own
    sandbox, and use "failure_means" to route any failure.

    Returns a JSON array of contracts, or the string "No matching verification
    contracts." when none are registered for the scope.