hive-intelligence 1.1.4 → 1.3.0

package/agent-skills/packs/hive-prediction-markets/SKILL.md

@@ -1,44 +1,131 @@
 ---
 name: hive-prediction-markets
-description: Use this skill for prediction market research covering Polymarket, Kalshi, events, markets, outcomes, odds, prices, liquidity, stats, traders, holders, and trades. Never present market probability as ground truth.
+description: Use this skill when the user asks about prediction markets — Polymarket or Kalshi events, markets, outcomes, odds, prices, liquidity, stats, traders, holders, or trades — including "what are the odds of X", "find markets about Y", or comparing venues. Use it whenever live prediction-market evidence is needed. Never present market probability as ground truth.
 license: MIT
 metadata:
   package: "@hiveintelligence/agent-skills"
   category: "prediction-markets"
   requires_network: "true"
-version: 1.0.0
+version: 1.3.0
 ---
 
 # hive-prediction-markets — Prediction Markets
 
-Use this skill for prediction market discovery, including Polymarket, Kalshi,
-odds, pricing, event stats, traders, holders, trades, or outcome questions.
+Discover and analyze prediction markets — Polymarket, Kalshi — with prices,
+liquidity, outcomes, traders, and trades, always framed as market-implied
+odds rather than truth.
 
-## Task toolset
+## Task toolset and identifiers
 
-Use `prediction_markets`.
+Toolset: `prediction_markets`. Read `hive://toolsets/prediction_markets` before
+execution; it is authoritative for the current output schema, material-call
+budget, phases, fallback condition, and stop conditions.
 
-Required identifiers: market id, event id, token id, trader address, or search
-query depending on the request.
+- Required: market id, event id, token id, trader address, or a search query —
+  depending on the request.
+- Optional: status filter, limit, date range, outcome, liquidity threshold.
+
+If the user starts with a topic, search candidates first and ask for selection
+when multiple markets match — similar markets can have different resolution
+criteria.
+
+Before choosing endpoints, select exactly one matching entry from the exact
+workflow's routes[]. Follow its ordered steps, use a fallback only under that
+step's published condition, stop at four material calls, and preserve the
+selected route_id in the typed result. The broad coverageCatalog is discovery
+coverage, not an execution plan.
 
 ## Procedure
 
-Read `references/workflow.md` when the request needs market/event discovery,
-liquidity/probability caveats, trader context, or a structured prediction
-market report.
+1. Call `search_tools` for prediction-market search, event, market, stats,
+   holder, trader, or trade capabilities.
+2. Call `get_api_endpoint_schema` for each endpoint before calling it.
+3. Search events/markets for topic prompts; resolve exact market/event/token
+   ids before pulling stats, holders, or trades.
+4. Add liquidity/volume and freshness context before interpreting prices.
+5. Report market price, volume/liquidity, outcomes, provider/source, and
+   freshness — and never present probability as ground truth.
+
+## Bounded calls
+
+- Use small search limits and page through only when needed.
+- Do not fetch all trades or holders unless the user asks for a deep dive.
+- Keep outcome-token prices separate from event-level interpretation.
+
+## Worked example
+
+User: "What are the odds on the next Fed rate decision? Compare Polymarket
+and Kalshi if both have markets."
+
+1. `search_tools` → `{"query": "prediction markets search events fed rate decision", "limit": 5}`
+2. `get_api_endpoint_schema` for the market-search endpoint returned, then
+   `invoke_api_endpoint` with a bounded search per venue.
+3. If several markets match, list candidates with resolution criteria and ask
+   which to inspect — or pick the highest-liquidity exact match and say so.
+4. Report outcome prices with volume/liquidity and freshness, framed as
+   market-implied odds.
+
+## Report template
+
+```markdown
+## Summary
+[Market/event read and top outcomes in one or two sentences.]
 
-1. Search/filter markets or events when the user starts with a topic.
-2. Resolve exact market/event/token ids before stats, holders, or trades.
-3. Report market price, volume/liquidity, outcomes, and freshness.
-4. Do not present market probability as ground truth.
+## Calls made
+- Toolset: prediction_markets
+- Endpoint(s): [exact endpoint names]
+- Identifiers: [market/event/token/trader ids]
 
-## Example
+## Evidence
+- Outcomes and prices: [per outcome, per venue]
+- Liquidity/volume: [values + as-of]
+- Provenance: [provider, fetched_at, observed_at/cache_age_ms, runtime status per call]
 
-For "Bitcoin election prediction markets" or "Polymarket vs Kalshi odds",
-search markets/events first, then ask which specific market to inspect if
-multiple candidates match.
+## Caveats
+[Market probability is not truth, thin liquidity, stale stats, candidate ambiguity.]
+
+## Next action
+[Inspect selected market, holders, trades, or related events — only if needed.]
+```
+
+## Gotchas
+
+- Market prices reflect trading and liquidity, not verified probability.
+- Similar markets can have different resolution criteria — quote them when
+  comparing venues.
+- Event-level and outcome-token-level data are not interchangeable.
+
+## Evidence receipt (required)
+
+End every Hive-backed answer with a compact receipt built from the `_hive`
+object on each material tool response:
+
+- `provider`, `tool`, `fetched_at`, `observed_at`, `cache_age_ms`, and `runtime_status`
+- `receipt_id`, `receipt_version`, server/build version, and SHA-256 input/result
+  digests when present (self-checks, not signatures)
+- `source`, `cache_status`, `truncated`, and any warnings
+- canonical chain/entity identifiers plus block, slot, transaction, or query ids
+  present in provider data
+- material provider disagreements and how they were handled
+- checks that were unavailable, gated, stale, truncated, or intentionally not run
+- a `claims[]` citation from each material statement to exact receipt IDs
+- one `coverage[]` entry for every canonical evidence phase, with each gap explained
+
+Never turn missing evidence into a clean result, silently merge conflicting
+provider values, or omit a degraded/fallback call from the receipt.
+`observed_at` is Hive's first-observation/original cache-population time, and
+`cache_age_ms: 0` only means newly retrieved by Hive. Use provider time, block,
+slot, transaction, or candle close for source recency; if absent, mark it
+unknown. Run `validate_task_result` before presenting the typed workflow result;
+it checks structure but cannot authenticate an invented receipt.
 
 ## Runtime status handling
 
-If a market search succeeds but stats are `degraded`, return the candidates and
-label the missing market details clearly.
+If a market search succeeds but stats are `degraded`, return the candidates
+and label the missing market details clearly.
+
+## Hand-offs
+
+- General crypto market prices → `hive-market-research`.
+- A trader's full wallet activity → `hive-wallet-investigation`.
+- Standing "alert me when odds move" requests → `hive-stateful-monitoring`.

package/agent-skills/packs/hive-prediction-markets/evals/evals.json

@@ -4,12 +4,14 @@
     {
       "id": 1,
       "prompt": "Find active prediction markets about the next Fed decision and show the top outcomes with liquidity caveats.",
-      "expected_output": "Uses prediction_markets, searches markets/events first, resolves candidate ids, bounds results, and reports price/liquidity/freshness caveats.",
+      "expected_output": "Uses prediction_markets, searches markets/events first, resolves candidate ids, bounds results, reports price/liquidity/freshness caveats, and ends with a runtime evidence receipt.",
       "files": [],
       "assertions": [
         "Chooses prediction_markets.",
+        "Selects event_landscape for event discovery or market_odds for an exact market and preserves route_id.",
         "Searches markets/events before stats.",
-        "States market price is not ground truth."
+        "States market price is not ground truth.",
+        "Includes receipt ids and missing evidence."
       ]
     },
     {

package/agent-skills/packs/hive-prediction-markets/evals/triggers.json

@@ -0,0 +1,50 @@
+[
+  {
+    "query": "what are the odds on the next fed rate cut on polymarket",
+    "should_trigger": true
+  },
+  {
+    "query": "find prediction markets about the 2026 world cup winner",
+    "should_trigger": true
+  },
+  {
+    "query": "compare polymarket vs kalshi on the CPI print markets",
+    "should_trigger": true
+  },
+  {
+    "query": "who are the biggest holders in this polymarket market",
+    "should_trigger": true
+  },
+  {
+    "query": "that 70% odds number — how much liquidity is actually behind it",
+    "should_trigger": true
+  },
+  {
+    "query": "show recent trades on this market id",
+    "should_trigger": true
+  },
+  {
+    "query": "whats the POL token trading at",
+    "should_trigger": false
+  },
+  {
+    "query": "what does this trader's wallet hold outside polymarket",
+    "should_trigger": false
+  },
+  {
+    "query": "explain how prediction markets resolve disputes",
+    "should_trigger": false
+  },
+  {
+    "query": "alert me when these odds move 10 points",
+    "should_trigger": false
+  },
+  {
+    "query": "is using polymarket legal in my country",
+    "should_trigger": false
+  },
+  {
+    "query": "top defi protocols by tvl",
+    "should_trigger": false
+  }
+]

package/agent-skills/packs/hive-query/SKILL.md

@@ -1,34 +1,48 @@
 ---
 name: hive-query
-description: Use this skill as the default entry point for any live crypto intelligence question before answering from memory. Route wallet, token, DeFi, NFT, Solana, security, market, DEX, network, or prediction-market requests through Hive task toolsets and bounded endpoint invocation. If routing does not surface the exact tool or schema, hand off to hive-tool-discovery.
+description: Default entry point for any live crypto question when Hive MCP is connected — prices, wallets, tokens, DeFi, NFTs, Solana, security, markets, DEX, networks, prediction markets. Use it whenever the answer depends on live or on-chain data instead of answering from memory, even if the user never mentions Hive. Routes intent to a canonical Hive task toolset, then schema lookup and bounded endpoint invocation. If a domain-specific hive-* skill clearly matches, prefer it; if routing cannot surface the exact tool or schema, hand off to hive-tool-discovery.
 license: MIT
 metadata:
   package: "@hiveintelligence/agent-skills"
   category: "discovery"
   requires_network: "true"
-version: 2.0.0
+version: 1.3.0
 ---
 
 # hive-query — Route Crypto Questions Through Hive
 
-Use this skill when Hive MCP is connected and the user asks a crypto question.
-Do not answer from model memory when the answer depends on live data.
-
-## Routing rule
-
-Read `references/root-mcp-workflow.md` when the user asks how Hive MCP is
-organized, what tools are available, or how an agent should navigate the root
-endpoint without loading the full provider catalog into context.
-
-1. Read `hive://toolsets` or call `search_tools` with the user's intent.
-2. Select one canonical task toolset.
-3. Ask for missing identifiers before execution if the toolset requires them.
-4. Call `get_api_endpoint_schema` for the exact tool you plan to call.
-5. Call the exact endpoint through `invoke_api_endpoint`.
-6. Report freshness, provider/runtime status, and any missing-data caveats.
+Route the user's crypto question to one canonical Hive task toolset, inspect
+the exact schema, invoke the endpoint with bounded arguments, and answer with
+provenance. Do not answer from model memory when the answer depends on live
+data.
+
+## Routing procedure
+
+1. Read the compact `hive://toolsets` index or call `search_tools` with the
+   user's intent. Use its tool and toolset cursors instead of requesting a
+   broad catalog.
+2. Select one canonical task toolset and the single compact `routes[]` entry
+   whose trigger/question matches the user's intent. Preserve its `route_id`;
+   broad `coverageCatalog` arrays are not an execution plan.
+3. Ask for the route's missing identifiers before execution.
+4. Follow its ordered steps, calling `get_api_endpoint_schema` for each exact
+   primary tool. Use a fallback only under that step's published condition.
+5. Call reads through `invoke_api_endpoint`. For an explicitly approved
+   Hive-native state change, use `invoke_stateful_endpoint`; never auto-approve
+   that router.
+6. Stop when the route's stop condition is met or four material calls are used.
+   Copy server-returned `_hive` blocks into the task receipt and run
+   `validate_task_result` with the selected `route_id` before presenting a structured result.
+7. Report source recency, provider/runtime status, and missing-data caveats.
+
+Read `references/root-mcp-workflow.md` when you need the bigger picture: how
+the root MCP endpoint is organized, what resources exist, or how to navigate
+without loading the full provider catalog into context.
 
 ## Canonical task toolsets
 
+`hive://toolsets` is authoritative; this table is the routing shortcut.
+
 | Intent | Toolset id |
 | --- | --- |
 | Price, exchange, OHLC, liquidity, derivatives | `market_research` |
@@ -44,19 +58,19 @@ endpoint without loading the full provider catalog into context.
 | Durable monitors, alerts, scheduled reports, agent memory | `stateful_monitoring` |
 | Ambiguous request or schema lookup | `search_discovery` |
 
-## Example
+## Worked example
 
 User: "Investigate this wallet on Ethereum."
 
 Use `wallet_investigation`. Required identifiers are wallet address and chain.
-Then search for the current wallet-balance endpoint, inspect its schema, and
-only then invoke it. Do not hardcode stale endpoint names in the skill. Use this
-sequence: `search_tools` for `wallet investigation ethereum balances`,
-`get_api_endpoint_schema` for the selected endpoint, then `invoke_api_endpoint`
-with schema-valid `address` and `network` or chain arguments.
+Then: `search_tools` for `wallet investigation ethereum balances`,
+`get_api_endpoint_schema` for the selected endpoint, then
+`invoke_api_endpoint` with schema-valid address and chain arguments. Do not
+hardcode endpoint names from memory — the catalog changes and search is
+authoritative.
 
-Then use schema lookup and add transfer, NFT, or DeFi-position tools only when
-the user's question needs that detail.
+Add transfer, NFT, or DeFi-position tools only when the user's question needs
+that detail.
 
 ## Report template
 
@@ -73,8 +87,8 @@ Use this structure for Hive-backed answers:
 
 ## Evidence
 - Provider/source: [provider names]
-- Freshness: [Hive execution fetched_at plus provider timestamp, block, or slot when relevant]
-- Runtime status: [ok/missing_key/plan_required/rate_limited/degraded/failing]
+- Freshness: [Hive fetched_at/observed_at/cache_age_ms plus provider timestamp, block, or slot; upstream recency unknown if absent]
+- Runtime status: [ok/invalid_input/missing_key/plan_required/rate_limited/degraded/failing]
 
 ## Caveats
 [Fallbacks, stale data, unavailable providers, missing identifiers, limits.]
@@ -83,17 +97,49 @@ Use this structure for Hive-backed answers:
 [Only include if a retry, deeper check, or user choice is needed.]
 ```
 
+## Evidence receipt (required)
+
+End every Hive-backed answer with a compact receipt built from the `_hive`
+object on each material tool response:
+
+- `provider`, `tool`, `fetched_at`, `observed_at`, `cache_age_ms`, and `runtime_status`
+- `receipt_id`, `receipt_version`, server/build version, and SHA-256 input/result
+  digests when present (self-checks, not signatures)
+- `source`, `cache_status`, `truncated`, and any warnings
+- canonical chain/entity identifiers plus block, slot, transaction, or query ids
+  present in provider data
+- material provider disagreements and how they were handled
+- checks that were unavailable, gated, stale, truncated, or intentionally not run
+- a `claims[]` citation from each material statement to exact receipt IDs
+- one `coverage[]` entry for every canonical evidence phase, with each gap explained
+
+Never turn missing evidence into a clean result, silently merge conflicting
+provider values, or omit a degraded/fallback call from the receipt.
+`observed_at` is Hive's first-observation/original cache-population time, and
+`cache_age_ms: 0` only means newly retrieved by Hive. Use provider time, block,
+slot, transaction, or candle close for upstream recency; if absent, mark it
+unknown. `validate_task_result` checks structure but cannot authenticate an
+invented receipt.
+
 ## Runtime status handling
 
-Hive uses `ok`, `missing_key`, `plan_required`, `rate_limited`, `degraded`, and
-`failing`. Do not treat a non-`ok` provider state as a missing tool. Tell the
-user which task/tool failed, why, and what can be retried or upgraded.
+Hive uses `ok`, `invalid_input`, `missing_key`, `plan_required`,
+`rate_limited`, `degraded`, and `failing`. Do not treat a non-`ok` provider
+state as a missing tool. Tell
+the user which task/tool failed, why, and what can be retried or upgraded.
 
 ## Guardrails
 
 - Never invent token, wallet, market, or event identifiers.
-- Prefer exact contract addresses, wallet addresses, pair addresses, market ids,
-  or exchange ids over fuzzy names.
+- Prefer exact contract addresses, wallet addresses, pair addresses, market
+  ids, or exchange ids over fuzzy names.
 - Keep raw provider endpoints callable; task toolsets are only the selection
   layer.
-- If a tool is absent from the skill, use `search_tools` instead of guessing.
+- If a tool is absent from this skill, use `search_tools` instead of guessing.
+
+## Hand-offs
+
+- A domain-specific hive-* skill matches the question → prefer it; this skill
+  is the generalist entry point.
+- Routing cannot surface the exact tool or schema → `hive-tool-discovery`.
+- The user wants Hive to keep watching something → `hive-stateful-monitoring`.

package/agent-skills/packs/hive-query/evals/evals.json

@@ -3,13 +3,15 @@
   "evals": [
     {
       "id": 1,
-      "prompt": "Use Hive MCP to investigate whether wallet 0x0000000000000000000000000000000000000000 has meaningful Ethereum token activity. Show the tools you would call and the caveats.",
-      "expected_output": "Routes through wallet_investigation, requests or infers eth-mainnet, looks up schemas before exact endpoint calls, avoids inventing activity, and reports provider/runtime/freshness caveats.",
+      "prompt": "Use Hive MCP to investigate whether wallet 0x28C6c06298d514Db089934071355E5743bf21d60 has meaningful Ethereum token activity. Show the tools you would call and the caveats.",
+      "expected_output": "Routes through wallet_investigation, loads its exact workflow policy, requests or infers eth-mainnet, looks up schemas before bounded read calls, obeys the material-call budget and stop conditions, avoids inventing activity, and ends with a structurally validated receipt containing provider source-recency evidence, runtime/cache/fallback state, and server-minted receipt ids for every material call.",
       "files": [],
       "assertions": [
         "Mentions wallet_investigation or the wallet task toolset.",
+        "Selects wallet_investigation plus the matching portfolio_snapshot or recent_activity route and preserves route_id.",
         "Uses get_api_endpoint_schema before invoke_api_endpoint.",
-        "Reports provider/runtime status and does not answer from memory."
+        "Reports provider/runtime status and does not answer from memory.",
+        "Includes an evidence receipt with exact _hive receipt ids and uses validate_task_result."
       ]
     },
     {
@@ -30,8 +32,8 @@
       "files": [],
       "assertions": [
         "Chooses prediction_markets.",
-        "Uses search_tools or hive://toolsets before endpoint selection.",
-        "Reports freshness and source caveats."
+        "Uses compact search_tools or hive://toolsets, then loads the exact prediction_markets workflow before endpoint selection.",
+        "Reports provider source recency separately from Hive observed_at/cache_age_ms and marks upstream recency unknown when absent."
       ]
     }
   ]

package/agent-skills/packs/hive-query/evals/triggers.json

@@ -0,0 +1,50 @@
+[
+  {
+    "query": "whats the price of eth right now and the 24h change",
+    "should_trigger": true
+  },
+  {
+    "query": "can you check what the top crypto gainers are today? i think hive is connected",
+    "should_trigger": true
+  },
+  {
+    "query": "my friend says AVAX activity is exploding, can you check the actual live numbers",
+    "should_trigger": true
+  },
+  {
+    "query": "what can you tell me about the token at 0x6982508145454Ce325dDbE47a25d4ec3d2311933",
+    "should_trigger": true
+  },
+  {
+    "query": "pull live funding rates for btc perps and tell me whats crowded",
+    "should_trigger": true
+  },
+  {
+    "query": "how many active polymarket markets are about AI right now",
+    "should_trigger": true
+  },
+  {
+    "query": "explain how AMMs work, no need to look anything up",
+    "should_trigger": false
+  },
+  {
+    "query": "write a python script that calls the hive REST api every morning",
+    "should_trigger": false
+  },
+  {
+    "query": "add hive mcp to cursor for me",
+    "should_trigger": false
+  },
+  {
+    "query": "I lost my hive api key, help me get a new one",
+    "should_trigger": false
+  },
+  {
+    "query": "watch this wallet and alert me on big moves going forward",
+    "should_trigger": false
+  },
+  {
+    "query": "summarize this whitepaper pdf i downloaded",
+    "should_trigger": false
+  }
+]

package/agent-skills/packs/hive-query/references/root-mcp-workflow.md

@@ -10,36 +10,48 @@ only pull deeper schemas when needed.
 flowchart LR
   User["User crypto question"] --> Agent["Agent with Hive skill"]
   Agent --> Root["Root MCP /mcp"]
-  Root --> Resources["Resources: hive://toolsets, hive://tools, hive://providers, hive://status"]
-  Root --> MetaTools["Meta tools: search_tools, get_api_endpoint_schema, invoke_api_endpoint"]
+  Root --> Resources["Compact indexes + exact templates: hive://toolsets/{id}, hive://skills/{name}"]
+  Root --> MetaTools["Meta tools: search, schema, read router, stateful router, validator"]
   Root --> Toolsets["Task toolsets"]
   MetaTools --> Registry["Provider endpoint registry"]
-  Registry --> Providers["CoinGecko, DeFiLlama, GoPlus, Codex (Polymarket/Kalshi), CCXT, Tenderly, Moralis, Helius, Alchemy"]
-  Agent --> Answer["Answer with provenance, freshness, runtime status"]
+  Registry --> Providers["CoinGecko, DeFiLlama, GoPlus, Codex (Polymarket/Kalshi), CCXT, Tenderly, Moralis, Helius, Alchemy, Hyperliquid, Open Data Fetch"]
+  Agent --> Answer["Validated answer with sources, source recency, runtime receipts"]
 ```
 
 ## Default agent loop
 
 1. Start from user intent, not provider names.
-2. Read `hive://toolsets` or call `search_tools`.
-3. Select the closest task toolset.
-4. Ask for required identifiers that are missing: chain, wallet, contract,
+2. Read the compact `hive://toolsets` index or call `search_tools`. Search
+   returns at most three compact toolsets by default and paginates tools and
+   toolsets separately.
+3. Select the closest task toolset and its one best matching compact
+   `routes[]` entry. Preserve `route_id`; use `coverageCatalog` only for
+   long-tail discovery, never as a call list.
+4. Ask for the route's required identifiers that are missing: chain, wallet, contract,
    token id, pair id, protocol slug, market id, or time window.
 5. Call `get_api_endpoint_schema` for each exact endpoint before execution.
-6. Call `invoke_api_endpoint` with bounded arguments. Respect `limit`,
-   `page`, `per_page`, `offset`, time windows, and response-size safeguards.
-7. Report provider, freshness, fallback/degraded state, missing keys, rate
-   limits, and caveats.
+6. Call reads through `invoke_api_endpoint` with bounded arguments. For a
+   Hive-native write, explain the effect, obtain explicit user approval, and
+   use `invoke_stateful_endpoint`. Respect `limit`, `page`, `per_page`,
+   `offset`, time windows, and response-size safeguards.
+7. Follow the route's ordered primary calls, conditional per-call fallbacks,
+   four-call cap, and stop condition. Never call every fallback by default.
+8. Copy each material response's `_hive` block into the task receipt, call
+   `validate_task_result` with `route_id`, and report provider, source recency,
+   fallback/degraded state, missing evidence, and caveats. Structural
+   validation does not authenticate invented receipts.
 
 ## Root versus category endpoints
 
-- Root `/mcp` should expose a small meta-tool surface. It is optimized for
-  agents that need routing, schema lookup, and bounded invocation.
+- Root `/mcp` exposes five tools: compact search, schema lookup, separate
+  read/write routers, and task-result validation.
 - Category endpoints expose direct scoped tools for clients that explicitly
   need broad `tools/list` results.
 - Do not treat root `tools/list` as the full product. Full provider coverage is
-  discoverable through resources, category listing tools, schema lookup, and
-  `invoke_api_endpoint`.
+  discoverable through resources, hidden compatibility listings, scoped
+  category endpoints, schema lookup, and
+  `invoke_api_endpoint` for reads or `invoke_stateful_endpoint` for explicitly
+  approved Hive state changes.
 
 ## Reporting standard
 
@@ -48,7 +60,16 @@ Every answer that used Hive should include enough context to debug the result:
 - Toolset or endpoint used.
 - Provider or data source.
 - Chain/network and identifiers.
-- Freshness or timestamp if available.
-- Runtime state: `ok`, `missing_key`, `plan_required`, `rate_limited`,
-  `degraded`, or `failing`.
+- Source recency from provider time, block, slot, transaction, or candle close.
+  `_hive.observed_at` is Hive first-observation/original cache time;
+  `cache_age_ms: 0` does not prove upstream freshness. Mark source recency
+  unknown when no provider marker exists.
+- Runtime state: `ok`, `invalid_input`, `missing_key`, `plan_required`,
+  `rate_limited`, `degraded`, or `failing`.
 - Any fallback, cache use, unavailable provider, or omitted data.
+- Server-minted receipt IDs for every material call plus the
+  `validate_task_result` outcome.
+- A `claims[]` citation for each material statement and one `coverage[]`
+  entry for every canonical evidence phase, including explicit gaps.
+- Server/build version and input/result SHA-256 self-checks when present. These
+  digests are not signatures.