@tensorfeed/mcp-server 1.38.0 → 1.39.0

package/CHANGELOG.md

@@ -2,6 +2,43 @@
 
 All notable changes to the [TensorFeed.ai MCP server](https://github.com/RipperMercs/tensorfeed-mcp). Free tools work without configuration; premium tools require a bearer token via the `TENSORFEED_TOKEN` env var. Buy credits at [tensorfeed.ai/developers/agent-payments](https://tensorfeed.ai/developers/agent-payments).
 
+## 1.39.0 - 2026-06-04
+
+Surfaces TensorFeed's full signed-verdict family in the stdio server. Adds the
+seven verdicts below, each shipping as a free preview tool plus a 1-credit
+($0.02) signed premium tool with an AFTA-signed receipt. This brings the catalog
+to 79 tools (48 free, 31 premium):
+- `provider_reliability_verdict_preview` / `provider_reliability_verdict`:
+  the signed dependability ruling over TensorFeed's own latency and availability
+  probes, scoring availability and tail consistency to name the safest provider
+  to build on.
+- `x402_settlement_verdict_preview` / `x402_settlement_verdict`: the settlement
+  momentum, concentration, and leading-publisher read over the on-chain x402
+  index for a 24h, 7d, or 30d window.
+- `x402_publisher_verdict_preview` / `x402_publisher_verdict`: the signed trust
+  verdict on one publisher domain (actively settling, recently quiet, registered
+  with no settlement, unreachable, no Base payTo, or not indexed) before you
+  pay it.
+- `stack_safety_verdict_preview` / `stack_safety_verdict`: the GO, HOLD, or
+  BLOCK deploy gate over a list of package@version pins, with the matched-CVE
+  and KEV evidence for the worst offender.
+- `benchmark_trust_verdict_preview` / `benchmark_trust_verdict`: the trust band
+  and 0 to 100 score for a benchmark or category, flagging saturation,
+  contamination, and held-out status.
+- `failover_verdict_preview` / `failover_verdict`: when a provider is degraded,
+  the signed ruling on the single best operational provider to fail over to,
+  with ranked alternatives.
+- `ssvc_verdict_preview` / `ssvc_verdict`: the CISA SSVC Act, Attend, Track, or
+  Track* decision for one CVE, with the decision points and a live KEV
+  cross-check.
+
+Adds contextual pointers so an agent discovers the matching verdict from a tool
+it already uses: `is_service_down` points to `failover_verdict`,
+`get_ai_cves_latest` points to `ssvc_verdict` and `stack_safety_verdict`,
+`get_x402_publishers` points to `x402_publisher_verdict`, and
+`status_leaderboard_free` points to `provider_reliability_verdict`. No behavior
+change to those four tools.
+
 ## 1.38.0 - 2026-06-03
 
 Description-only release. Sharpens the six foundational free tools (get_ai_news,
@@ -290,46 +327,46 @@ All three are backed by the worker endpoints shipped in the same monorepo commit
 ## 1.11.0 - 2026-04-29
 
 ### Added
-- `probe_latest` tool — last 24 hours of measured LLM endpoint latency and availability per provider (Anthropic, OpenAI, Google, Mistral, Cohere). TensorFeed pings each provider's chat completion endpoint every 15 min and records ttfb / total / status. The data is unique because it is measured, not self-reported. Free, no auth.
-- `probe_series` tool — daily SLA series for one provider with ttfb/total p50/p95/p99 and incident-hour count, 90-day max range. 1 credit per call. Pairs with `premium_routing` for picking a model whose SLA you can verify.
+- `probe_latest` tool: last 24 hours of measured LLM endpoint latency and availability per provider (Anthropic, OpenAI, Google, Mistral, Cohere). TensorFeed pings each provider's chat completion endpoint every 15 min and records ttfb / total / status. The data is unique because it is measured, not self-reported. Free, no auth.
+- `probe_series` tool: daily SLA series for one provider with ttfb/total p50/p95/p99 and incident-hour count, 90-day max range. 1 credit per call. Pairs with `premium_routing` for picking a model whose SLA you can verify.
 
 ## 1.10.0 - 2026-04-29
 
 ### Added
-- `mcp_registry_snapshot` tool — today's summary of the official Model Context Protocol server registry: total servers, by-status breakdown, top namespaces, 1-day deltas (newly added, reactivated, deprecated). Free, no auth.
-- `mcp_registry_series` tool — multi-day time series of MCP registry growth and churn. Range capped at 90 days, default 30 days back. 1 credit per call.
+- `mcp_registry_snapshot` tool: today's summary of the official Model Context Protocol server registry: total servers, by-status breakdown, top namespaces, 1-day deltas (newly added, reactivated, deprecated). Free, no auth.
+- `mcp_registry_series` tool: multi-day time series of MCP registry growth and churn. Range capped at 90 days, default 30 days back. 1 credit per call.
 
 The new tools are backed by a fresh daily cron capture of registry.modelcontextprotocol.io. The registry itself is open data, but a 30/90-day trend requires daily capture started weeks before the question is asked.
 
 ## 1.7.0 - 2026-04-27
 
 ### Added
-- `compare_models` tool — side-by-side comparison of 2-5 AI models with normalized benchmarks (union-of-keys with null for missing scores) and rankings (cheapest blended, most context, per-benchmark leaderboard). 1 credit per call.
+- `compare_models` tool: side-by-side comparison of 2-5 AI models with normalized benchmarks (union-of-keys with null for missing scores) and rankings (cheapest blended, most context, per-benchmark leaderboard). 1 credit per call.
 
 ## 1.6.0 - 2026-04-27
 
 ### Added
-- `provider_deepdive` tool — one provider's full profile in a single call: live status with components, all models with pricing + tier + benchmark scores joined, recent news, agent traffic. 1 credit per call.
+- `provider_deepdive` tool: one provider's full profile in a single call: live status with components, all models with pricing + tier + benchmark scores joined, recent news, agent traffic. 1 credit per call.
 
 ## 1.5.0 - 2026-04-27
 
 ### Added
-- `create_digest_watch` tool — register a scheduled daily/weekly digest watch. Fires HMAC-signed POST to your callback URL with a curated pricing-changes summary regardless of whether anything dramatic happened. 1 credit per registration.
+- `create_digest_watch` tool: register a scheduled daily/weekly digest watch. Fires HMAC-signed POST to your callback URL with a curated pricing-changes summary regardless of whether anything dramatic happened. 1 credit per registration.
 
 ## 1.4.0 - 2026-04-27
 
 ### Added
-- `forecast` tool — conservative linear-regression forecast for a price field or benchmark score with 95% prediction interval and confidence label. 1 credit per call.
+- `forecast` tool: conservative linear-regression forecast for a price field or benchmark score with 95% prediction interval and confidence label. 1 credit per call.
 
 ## 1.3.0 - 2026-04-27
 
 ### Added
-- `cost_projection` tool — project workload cost across 1-10 AI models with four time horizons and cheapest-monthly ranking. 1 credit per call.
+- `cost_projection` tool: project workload cost across 1-10 AI models with four time horizons and cheapest-monthly ranking. 1 credit per call.
 
 ## 1.2.0 - 2026-04-27
 
 ### Added
-- `news_search` tool — full-text search over the AI news corpus with date/provider/category filters and relevance scoring. 1 credit per call.
+- `news_search` tool: full-text search over the AI news corpus with date/provider/category filters and relevance scoring. 1 credit per call.
 
 ## 1.1.0 - 2026-04-27
 
@@ -339,7 +376,7 @@ The new tools are backed by a fresh daily cron capture of registry.modelcontextp
 - `mcp-server/server.json` manifest authored against the official MCP registry schema (`ai.tensorfeed/mcp-server`).
 - README expanded with per-tier tool tables and `env` config examples for Claude Desktop / Code.
 
-## 1.0.0 — 2026-04-26 (initial release)
+## 1.0.0 - 2026-04-26 (initial release)
 
 ### Added
 - 5 free tools: `get_ai_news`, `get_ai_status`, `is_service_down`, `get_model_pricing`, `get_ai_today`. No auth, no install beyond `npx -y @tensorfeed/mcp-server`.

package/README.md

@@ -59,6 +59,22 @@ route_verdict({ task: "code", max_latency_p95_ms: 1500, budget: 8, min_quality:
 
 Models, prices, and latency move week to week. `route_verdict` is one signed call an agent can act on now and later prove why it routed the way it did, without rebuilding the comparison from scratch each time.
 
+## Catalog
+
+79 tools (48 free, 31 premium). Free tools need no token; premium tools charge USDC on Base via x402 and return an AFTA-signed receipt. The full tool reference lives in the [standalone repo](https://github.com/RipperMercs/tensorfeed-mcp).
+
+### Verdict family
+
+Seven signed decisions, each with a free preview tool plus a 1-credit ($0.02) AFTA-signed premium version:
+
+- **provider_reliability_verdict**: the safest AI provider to build on, ranked by availability and tail consistency over TensorFeed's own probes.
+- **x402_settlement_verdict**: the x402 settlement momentum, concentration, and leading publisher over a 24h, 7d, or 30d window.
+- **x402_publisher_verdict**: a signed trust verdict on one publisher domain before you pay it.
+- **stack_safety_verdict**: a GO, HOLD, or BLOCK deploy gate over your package@version pins, with the worst CVE or KEV match.
+- **benchmark_trust_verdict**: a trust band and 0 to 100 score for a benchmark, flagging saturation, contamination, and held-out status.
+- **failover_verdict**: when a provider is degraded, the single best operational provider to fail over to, with ranked alternatives.
+- **ssvc_verdict**: the CISA SSVC Act, Attend, Track, or Track* decision for one CVE, with a live KEV cross-check.
+
 ## Publish a new version
 
 From the main tensorfeed repo:

package/dist/index.js

@@ -14,6 +14,15 @@ const API_BASE = 'https://tensorfeed.ai/api';
 const REQUEST_TIMEOUT_MS = 20000;
 const pkgPath = join(dirname(fileURLToPath(import.meta.url)), '..', 'package.json');
 const SDK_VERSION = JSON.parse(readFileSync(pkgPath, 'utf-8')).version;
+// Upsell footer appended to the free routing-precursor tools (get_ai_status,
+// get_model_pricing). Each is a signal an agent gathers before choosing a
+// model, so each points at the one premium tool that fuses them into a signed
+// decision. Mirrors the hosted /api/mcp `next` field. Honest, zero em dashes.
+const ROUTE_VERDICT_FOOTER = '\n\nNext: route_verdict (1 credit, $0.02) fuses live pricing, contamination-discounted ' +
+    'benchmarks, real production usage, measured p95 latency, incident state, and deprecation ' +
+    'flags into a signed best-fit model decision with ranked runners-up and an AFTA-signed ' +
+    'receipt. No USDC yet? Sign a wallet message at tensorfeed.ai/api/payment/trial-credits ' +
+    'for 25 free credits.';
 async function fetchJSON(path, opts = {}) {
     const headers = {
         'User-Agent': `TensorFeed-MCP/${SDK_VERSION}`,
@@ -203,7 +212,7 @@ registerTool('get_ai_status', 'Get the real-time operational status of major AI
         return `  ${s.status === 'operational' ? 'OK' : s.status.toUpperCase()} ${s.name} (${s.provider})${components}`;
     })
         .join('\n');
-    return { content: [{ type: 'text', text: `AI Service Status:\n${text}` }] };
+    return { content: [{ type: 'text', text: `AI Service Status:\n${text}${ROUTE_VERDICT_FOOTER}` }] };
 });
 // ── Tool: is_service_down ───────────────────────────────────────────
 registerTool('is_service_down', 'Check whether one named AI service (e.g. "claude", "openai", "gemini", "mistral", "cohere", "hugging face", "replicate") is currently operational, degraded, or down, with its component-level breakdown. Matches on service or provider name and lists available services if there is no match, so an agent can gate a call on live status before sending traffic. Free, no auth.', {
@@ -222,7 +231,7 @@ registerTool('is_service_down', 'Check whether one named AI service (e.g. "claud
     return {
         content: [{
                 type: 'text',
-                text: `${statusEmoji} ${match.name} (${match.provider}) is ${match.status}${components}`
+                text: `${statusEmoji} ${match.name} (${match.provider}) is ${match.status}${components}\n\nIf it is degraded, failover_verdict ranks the best operational alternative to fail over to right now.`
             }]
     };
 });
@@ -299,7 +308,7 @@ registerTool('get_model_pricing', 'Get AI model pricing across major providers (
         return `  ${p.name}:\n${models}`;
     })
         .join('\n\n');
-    return { content: [{ type: 'text', text: `AI Model Pricing (per 1M tokens):\n\n${text}` }] };
+    return { content: [{ type: 'text', text: `AI Model Pricing (per 1M tokens):\n\n${text}${ROUTE_VERDICT_FOOTER}` }] };
 });
 // ── Tool: get_model_deprecations ────────────────────────────────────
 registerTool('get_model_deprecations', "Get the AI model deprecation calendar. Provider-by-provider registry of model retirements and deprecation announcements (OpenAI, Anthropic, Google, Cohere, and others). Each entry carries the announced/deprecation/sunset dates, the recommended replacement model, and a source URL pointing at the provider's own announcement. Useful for agents who need to know when a model they depend on will stop accepting traffic and what to migrate to.", {
@@ -683,7 +692,7 @@ registerTool('route_verdict_preview', "Free. TensorFeed's signed routing decisio
                     `Why: ${v.why}\n` +
                     `Blended price: $${v.pricing.blended}/1M tokens (in $${v.pricing.input}, out $${v.pricing.output})\n` +
                     `${trustLine}${fresh ? `\nData freshness: ${fresh}` : ''}\n` +
-                    `Upgrade: route_verdict (1 credit) adds ranked runners-up, constraint filters, and an AFTA-signed receipt you can audit.${rl}`,
+                    `Upgrade: route_verdict (1 credit, $0.02) adds ranked runners-up, constraint filters, and an AFTA-signed receipt you can audit. No USDC yet? Sign a wallet message at tensorfeed.ai/api/payment/trial-credits for 25 free credits.${rl}`,
             },
         ],
     };
@@ -757,6 +766,440 @@ registerTool('route_verdict', "Costs 1 credit ($0.02). The signed routing decisi
         ],
     };
 });
+// ════════════════════════════════════════════════════════════════════
+// Verdict family: 7 signed decisions, each a free preview tool plus a
+// 1-credit premium tool. Each preview calls fetchJSON('/preview/<x>')
+// (no auth, 10 calls per IP per day); each premium calls
+// fetchJSON('/premium/<x>', { auth: true }) and burns 1 credit. The
+// shapes below mirror the worker builder result interfaces exactly.
+// ════════════════════════════════════════════════════════════════════
+// Shared upsell tail for the preview tools. Mirrors ROUTE_VERDICT_FOOTER
+// cadence. `tool` is the matching premium tool, `adds` names what the
+// paid tier adds over the free preview, `rl` is the optional remaining
+// calls suffix.
+function verdictUpsell(tool, adds, rl) {
+    return (`Upgrade: ${tool} (1 credit, $0.02) adds ${adds} and an AFTA-signed receipt. ` +
+        `No USDC yet? Sign a wallet message at tensorfeed.ai/api/payment/trial-credits for 25 free credits.${rl}`);
+}
+function verdictBilling(billing) {
+    return billing ? `\n\nCharged ${billing.credits_charged} credit. Remaining: ${billing.credits_remaining}.` : '';
+}
+function previewRateLine(rate) {
+    return rate ? ` Preview: ${rate.remaining} of ${rate.limit} calls left today.` : '';
+}
+registerTool('provider_reliability_verdict_preview', "Free. TensorFeed's signed dependability ruling over its OWN measured latency and availability probes of the frontier AI providers. Names the single most-dependable provider to build on and the riskiest, scoring availability and tail consistency (p50 over p95) equally because an agent retry loop feels the tail, not the median. For the full per-provider ranking and an AFTA-signed receipt, use provider_reliability_verdict. 10 calls per day per IP.", {}, async () => {
+    const data = (await fetchJSON('/preview/provider-reliability-verdict'));
+    const v = data.verdict;
+    if (!v || !v.most_dependable) {
+        return { content: [{ type: 'text', text: `No reliability verdict available right now.\n${data.claim ?? ''}` }] };
+    }
+    const cov = data.coverage;
+    const rl = previewRateLine(data.rate_limit);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `Provider Reliability Verdict: most dependable ${v.most_dependable}` +
+                    (v.riskiest ? `, riskiest ${v.riskiest}` : '') +
+                    '\n' +
+                    `Claim: ${data.claim}\n` +
+                    `Coverage: ${cov.providers_ranked} providers ranked (${cov.fully_measured} fully measured, ${cov.availability_only} availability only)` +
+                    (data.captured_at ? `, captured ${data.captured_at}` : '') +
+                    '\n' +
+                    verdictUpsell('provider_reliability_verdict', 'the full per-provider ranking with availability, tail spread, and measured p50/p95/p99', rl),
+            },
+        ],
+    };
+});
+// ── Tool: provider_reliability_verdict (1 credit) ───────────────────
+registerTool('provider_reliability_verdict', "Costs 1 credit ($0.02). The signed provider dependability ruling over TensorFeed's OWN measured probes: ranks every probed frontier provider by availability and tail consistency (p50 over p95), names the most dependable and the riskiest, and ships the full per-provider ranking with an AFTA-signed receipt over the measurements. Versus the free provider_reliability_verdict_preview it adds the complete ranking with each provider's measured availability, p50/p95/p99, and tail spread, plus the receipt and no rate limit. 30-minute freshness SLA, no-charge when stale. Get credits at tensorfeed.ai/developers/agent-payments. Strict premium, no free trial.", {}, async () => {
+    const data = (await fetchJSON('/premium/provider-reliability-verdict', { auth: true }));
+    const v = data.verdict;
+    if (!v || !v.most_dependable) {
+        return { content: [{ type: 'text', text: `No reliability verdict available right now.\n${data.claim ?? ''}` }] };
+    }
+    const ranking = (data.ranking ?? [])
+        .map((r) => `  #${r.rank} ${r.provider}: ${r.note}`)
+        .join('\n');
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `Provider Reliability Verdict: most dependable ${v.most_dependable}` +
+                    (v.riskiest ? `, riskiest ${v.riskiest}` : '') +
+                    '\n\n' +
+                    `Ranking:\n${ranking || '  (none)'}\n\n` +
+                    `Claim: ${data.claim}` +
+                    verdictBilling(data.billing),
+            },
+        ],
+    };
+});
+registerTool('x402_settlement_verdict_preview', "Free. TensorFeed's signed ruling on the state of the x402 USDC settlement market on Base, computed over its OWN on-chain settlement index: market momentum versus the prior window, concentration, and the leading publisher. For the full per-publisher ranking, ecosystem totals, the Herfindahl concentration index, an optional window, and an AFTA-signed receipt, use x402_settlement_verdict. Covers the publishers TensorFeed indexes on Base, forward-only from launch. 10 calls per day per IP.", {}, async () => {
+    const data = (await fetchJSON('/preview/x402-settlement-verdict'));
+    const v = data.verdict;
+    const rl = previewRateLine(data.rate_limit);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `x402 Settlement Verdict (${data.window_label ?? '7d'}): momentum ${v.momentum}, concentration ${v.concentration}` +
+                    (v.leading_publisher ? `, leading publisher ${v.leading_publisher}` : ', no leading publisher this window') +
+                    '\n' +
+                    `Claim: ${data.claim}` +
+                    (data.captured_at ? `\nIndex captured ${data.captured_at}` : '') +
+                    '\n' +
+                    verdictUpsell('x402_settlement_verdict', 'the full per-publisher ranking, ecosystem volume and count totals, the Herfindahl concentration index, and an optional 24h/7d/30d window', rl),
+            },
+        ],
+    };
+});
+// ── Tool: x402_settlement_verdict (1 credit) ────────────────────────
+registerTool('x402_settlement_verdict', "Costs 1 credit ($0.02). The signed ruling on the Base x402 USDC settlement market over TensorFeed's OWN settlement index: momentum versus the prior window of equal length, concentration by the Herfindahl index over publisher volume share, and the leading publisher, plus the full per-publisher ranking and an AFTA-signed receipt. Versus the free x402_settlement_verdict_preview it adds the per-publisher ranking with volume share, the ecosystem totals and concentration index, an optional window, and the receipt, with no rate limit. 10-minute freshness SLA, no-charge when stale. Get credits at tensorfeed.ai/developers/agent-payments. Strict premium, no free trial.", {
+    window: z.enum(['24h', '7d', '30d']).optional().describe('Settlement window to rule over (24h, 7d, 30d). Default 7d.'),
+}, async ({ window }) => {
+    const params = new URLSearchParams();
+    if (window)
+        params.set('window', window);
+    const qs = params.toString();
+    const data = (await fetchJSON(`/premium/x402-settlement-verdict${qs ? `?${qs}` : ''}`, { auth: true }));
+    const v = data.verdict;
+    const e = data.ecosystem;
+    const ranking = (data.ranking ?? [])
+        .map((r) => `  #${r.rank} ${r.domain}: ${r.volume_usdc} USDC over ${r.count} settlements (${r.share_pct}% share)`)
+        .join('\n');
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `x402 Settlement Verdict (${data.window_label ?? '7d'}): momentum ${v.momentum}, concentration ${v.concentration}` +
+                    (v.leading_publisher ? `, leading publisher ${v.leading_publisher}` : ', no leading publisher this window') +
+                    '\n' +
+                    `Ecosystem: ${e.volume_usdc} USDC over ${e.count} settlements across ${e.unique_publishers} publishers` +
+                    (e.top_publisher_share_pct !== null ? `, top share ${e.top_publisher_share_pct}%` : '') +
+                    (e.hhi !== null ? `, HHI ${e.hhi}` : '') +
+                    '\n\n' +
+                    `Ranking:\n${ranking || '  (none)'}\n\n` +
+                    `Claim: ${data.claim}` +
+                    verdictBilling(data.billing),
+            },
+        ],
+    };
+});
+// ── Tool: x402_publisher_verdict_preview (free, 10/IP/day) ───────────
+registerTool('x402_publisher_verdict_preview', "Free. TensorFeed's signed trust verdict on one x402 publisher, over its OWN on-chain settlement index: whether a named publisher domain is actively settling, recently quiet, registered with no settlement, unreachable, missing a Base payTo, or not indexed. For the 30-day settlement momentum, the shared-wallet risk flag, the settlement evidence, and an AFTA-signed receipt, use x402_publisher_verdict. Requires a domain. 10 calls per day per IP.", {
+    domain: z.string().describe('Publisher domain to rule on, e.g. "x402.tavily.com". Required.'),
+}, async ({ domain }) => {
+    if (!domain || !domain.trim()) {
+        return { content: [{ type: 'text', text: 'Provide a publisher domain (e.g. domain "x402.tavily.com") to get a trust verdict.' }] };
+    }
+    const params = new URLSearchParams({ domain: domain.trim() });
+    const data = (await fetchJSON(`/preview/x402-publisher-verdict?${params}`));
+    const rl = previewRateLine(data.rate_limit);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `x402 Publisher Verdict for ${data.domain}: ${data.verdict}\n` +
+                    `Claim: ${data.claim}` +
+                    (data.captured_at ? `\nIndex captured ${data.captured_at}` : '') +
+                    '\n' +
+                    verdictUpsell('x402_publisher_verdict', 'the 30-day settlement momentum, the shared-wallet risk flag, and the settlement evidence (volume, count, daily series)', rl),
+            },
+        ],
+    };
+});
+// ── Tool: x402_publisher_verdict (1 credit) ─────────────────────────
+registerTool('x402_publisher_verdict', "Costs 1 credit ($0.02). The signed trust verdict on a single x402 publisher over TensorFeed's OWN on-chain settlement index: whether its Base payTo is actively settling, its 30-day settlement momentum, a shared-wallet risk flag, and the settlement evidence, with an AFTA-signed receipt. Versus the free x402_publisher_verdict_preview it adds the momentum band, the shared-wallet flag, and the settlement evidence (volume, count, last settled, daily series), with no rate limit. A not-indexed domain is no-charge. 10-minute freshness SLA. Get credits at tensorfeed.ai/developers/agent-payments. Strict premium, no free trial.", {
+    domain: z.string().describe('Publisher domain to rule on, e.g. "x402.tavily.com". Required.'),
+}, async ({ domain }) => {
+    if (!domain || !domain.trim()) {
+        return { content: [{ type: 'text', text: 'Provide a publisher domain (e.g. domain "x402.tavily.com") to get a signed trust verdict.' }] };
+    }
+    const params = new URLSearchParams({ domain: domain.trim() });
+    const data = (await fetchJSON(`/premium/x402-publisher-verdict?${params}`, { auth: true }));
+    const t = data.trust;
+    const ev = data.evidence;
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `x402 Publisher Verdict for ${data.domain}: ${data.verdict}\n` +
+                    `Momentum: ${data.momentum}. Shared wallet: ${t.wallet_shared ? 'yes (risk flag)' : 'no'}` +
+                    (t.last_settled ? `. Last settled ${t.last_settled}` : '') +
+                    '\n' +
+                    `Evidence (${ev.window_days}d): ${ev.volume_usdc} USDC over ${ev.count} settlements\n` +
+                    `Claim: ${data.claim}` +
+                    verdictBilling(data.billing),
+            },
+        ],
+    };
+});
+registerTool('stack_safety_verdict_preview', "Free. TensorFeed's deploy gate for an AI software stack: pass each package name (comma-separated name@version) and get the overall BLOCK / HOLD / PASS / UNKNOWN gate plus a per-package verdict, fusing the ingested AI-stack CVE batch with the CISA KEV catalog. Conservative by design: BLOCK only on an exploited CVE with no fix, HOLD when a known CVE applies and you must verify your version, PASS on no match, UNKNOWN outside the curated AI-stack cohort. For the matched-CVE evidence (ids, ranges, fixes, KEV status), up to 10 packages, and an AFTA-signed receipt, use stack_safety_verdict. Capped at 3 packages, 10 calls per day per IP.", {
+    packages: z.string().describe('Comma-separated AI-stack packages as name@version (e.g. "vllm@0.5.0,transformers@4.40.0"). Required. Preview caps at 3.'),
+}, async ({ packages }) => {
+    if (!packages || !packages.trim()) {
+        return { content: [{ type: 'text', text: 'Provide packages as a comma-separated name@version list (e.g. "vllm@0.5.0,transformers@4.40.0") to get a deploy gate.' }] };
+    }
+    const params = new URLSearchParams({ packages: packages.trim() });
+    const data = (await fetchJSON(`/preview/stack-safety-verdict?${params}`));
+    const c = data.counts;
+    const worst = (data.packages ?? []).find((p) => p.verdict === 'BLOCK') ?? (data.packages ?? []).find((p) => p.verdict === 'HOLD') ?? null;
+    const worstLine = worst
+        ? `Worst offender: ${worst.package}${worst.version ? `@${worst.version}` : ''} ${worst.verdict} (${worst.matched_cve_count} matched CVE${worst.matched_cve_count === 1 ? '' : 's'}). ${worst.reason}`
+        : 'No package hit a BLOCK or HOLD.';
+    const rl = previewRateLine(data.rate_limit);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `Stack Safety Verdict: gate ${data.gate}\n` +
+                    `Counts: ${c.block} block, ${c.hold} hold, ${c.pass} pass, ${c.unknown} unknown\n` +
+                    `${worstLine}\n` +
+                    `Claim: ${data.claim}\n` +
+                    verdictUpsell('stack_safety_verdict', 'the matched-CVE evidence (ids, affected ranges, fixed versions, KEV status) and up to 10 packages', rl),
+            },
+        ],
+    };
+});
+registerTool('stack_safety_verdict', "Costs 1 credit ($0.02). The signed deploy gate for an AI software stack (up to 10 packages): the overall BLOCK / HOLD / PASS / UNKNOWN gate and a per-package verdict, fusing the ingested AI-stack CVE batch with the CISA KEV catalog, plus the matched-CVE evidence and an AFTA-signed receipt. Versus the free stack_safety_verdict_preview it adds the matched-CVE ids, affected ranges, fixed versions, and KEV status per package, raises the cap to 10 packages, and ships the receipt, with no rate limit. Never-false-confirm: BLOCK only on exploited with no fix. Get credits at tensorfeed.ai/developers/agent-payments. Strict premium, no free trial.", {
+    packages: z.string().describe('Comma-separated AI-stack packages as name@version (e.g. "vllm@0.5.0,transformers@4.40.0"). Required. Up to 10.'),
+}, async ({ packages }) => {
+    if (!packages || !packages.trim()) {
+        return { content: [{ type: 'text', text: 'Provide packages as a comma-separated name@version list (e.g. "vllm@0.5.0,transformers@4.40.0") to get a signed deploy gate.' }] };
+    }
+    const params = new URLSearchParams({ packages: packages.trim() });
+    const data = (await fetchJSON(`/premium/stack-safety-verdict?${params}`, { auth: true }));
+    const c = data.counts;
+    const lines = (data.packages ?? [])
+        .map((p) => {
+        const cves = p.matched_cves
+            .map((m) => `${m.cve_id}${m.on_kev ? ' (KEV)' : ''} ${m.severity_label}`)
+            .join('; ');
+        return `  ${p.package}${p.version ? `@${p.version}` : ''}: ${p.verdict}. ${p.reason}` + (cves ? `\n     CVEs: ${cves}` : '');
+    })
+        .join('\n');
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `Stack Safety Verdict: gate ${data.gate}\n` +
+                    `Counts: ${c.block} block, ${c.hold} hold, ${c.pass} pass, ${c.unknown} unknown\n\n` +
+                    `${lines || '  (no packages)'}\n\n` +
+                    `Claim: ${data.claim}` +
+                    verdictBilling(data.billing),
+            },
+        ],
+    };
+});
+registerTool('benchmark_trust_verdict_preview', "Free. TensorFeed's signed ruling on whether an AI benchmark is still a trustworthy capability signal or saturated, contaminated, or near ceiling so a high score should be down-weighted. Returns a trust band (reliable, use_with_caution, saturated, contaminated, deprecated) and a 0-100 trust score per benchmark. Pass benchmark to narrow to one, or category to filter, or neither for the registry. For the per-signal detail (ceiling proximity, frontier compression, contamination) and the down-weight recommendation with an alternative, use benchmark_trust_verdict. 10 calls per day per IP.", {
+    benchmark: z.string().optional().describe('Benchmark registry id or name to narrow to one (e.g. "mmlu", "swe-bench"). Optional.'),
+    category: z.string().optional().describe('Category to filter the benchmarks (e.g. "coding", "reasoning"). Optional.'),
+}, async ({ benchmark, category }) => {
+    const params = new URLSearchParams();
+    if (benchmark)
+        params.set('benchmark', benchmark);
+    if (category)
+        params.set('category', category);
+    const qs = params.toString();
+    const data = (await fetchJSON(`/preview/benchmark-trust-verdict${qs ? `?${qs}` : ''}`));
+    const verdicts = data.verdicts ?? [];
+    if (verdicts.length === 0) {
+        return { content: [{ type: 'text', text: `No benchmark matched that filter.\n${data.claim ?? ''}` }] };
+    }
+    const top = verdicts[0];
+    const list = verdicts
+        .slice(0, 3)
+        .map((v) => `  ${v.name} (${v.category}): ${v.trust_band}, score ${v.trust_score}/100`)
+        .join('\n');
+    const rl = previewRateLine(data.rate_limit);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `Benchmark Trust Verdict: ${top.name} is ${top.trust_band} (trust score ${top.trust_score}/100)\n` +
+                    (data.count > 1 ? `${data.count} benchmarks ruled on. Top:\n${list}\n` : `${list}\n`) +
+                    `Claim: ${data.claim}\n` +
+                    verdictUpsell('benchmark_trust_verdict', 'the per-signal detail (ceiling proximity, frontier compression, contamination, status) and the down-weight recommendation with an alternative benchmark', rl),
+            },
+        ],
+    };
+});
+registerTool('benchmark_trust_verdict', "Costs 1 credit ($0.02). The signed ruling on whether an AI benchmark is a trustworthy capability signal or saturated, contaminated, or near ceiling: a trust band and 0-100 score per benchmark, the per-signal detail, a down-weight recommendation with an alternative benchmark, and an AFTA-signed receipt. Versus the free benchmark_trust_verdict_preview it adds the ceiling proximity, frontier compression, and contamination signals, the recommendation, and the receipt, with no rate limit. Pass benchmark to narrow to one, or category to filter, or neither for the registry. Get credits at tensorfeed.ai/developers/agent-payments. Strict premium, no free trial.", {
+    benchmark: z.string().optional().describe('Benchmark registry id or name to narrow to one (e.g. "mmlu", "swe-bench"). Optional.'),
+    category: z.string().optional().describe('Category to filter the benchmarks (e.g. "coding", "reasoning"). Optional.'),
+}, async ({ benchmark, category }) => {
+    const params = new URLSearchParams();
+    if (benchmark)
+        params.set('benchmark', benchmark);
+    if (category)
+        params.set('category', category);
+    const qs = params.toString();
+    const data = (await fetchJSON(`/premium/benchmark-trust-verdict${qs ? `?${qs}` : ''}`, { auth: true }));
+    const verdicts = data.verdicts ?? [];
+    if (verdicts.length === 0) {
+        return { content: [{ type: 'text', text: `No benchmark matched that filter.\n${data.claim ?? ''}` }] };
+    }
+    const lines = verdicts
+        .slice(0, 8)
+        .map((v) => `  ${v.name} (${v.category}): ${v.trust_band}, score ${v.trust_score}/100. Ceiling ${v.signals.ceiling_proximity}, frontier ${v.signals.frontier_compression}.\n     ${v.recommendation}`)
+        .join('\n');
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `Benchmark Trust Verdict: ${data.count} benchmark${data.count === 1 ? '' : 's'} ruled on\n\n` +
+                    `${lines}\n\n` +
+                    `Claim: ${data.claim}` +
+                    verdictBilling(data.billing),
+            },
+        ],
+    };
+});
+registerTool('failover_verdict_preview', "Free. Provider A is degraded; TensorFeed's signed ruling on the single best operational provider to fail over to for a task right now. Confirms A against the live incident-triage feed, then runs the route-verdict fusion with A (and any provider already in failover) excluded. For the full failover candidate (pricing, measured latency, quality), the ranked alternatives, and an AFTA-signed receipt, use failover_verdict. Requires from. 10 calls per day per IP.", {
+    from: z.string().describe('The degraded provider to fail over FROM (e.g. "anthropic", "openai"). Required.'),
+    task: z.enum(['code', 'reasoning', 'creative', 'general']).optional().describe('Task type to optimize the failover target for. Optional.'),
+}, async ({ from, task }) => {
+    if (!from || !from.trim()) {
+        return { content: [{ type: 'text', text: 'Provide a from provider (the degraded provider to fail over from, e.g. from "anthropic") to get a failover verdict.' }] };
+    }
+    const params = new URLSearchParams({ from: from.trim() });
+    if (task)
+        params.set('task', task);
+    const data = (await fetchJSON(`/preview/failover-verdict?${params}`));
+    const dest = data.failover_to;
+    const rl = previewRateLine(data.rate_limit);
+    if (!dest) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Failover Verdict from ${data.from.provider}: no operational failover target found.\n` +
+                        `Why: ${data.why}\n${data.claim}\n` +
+                        verdictUpsell('failover_verdict', 'the full failover candidate (pricing, measured latency, quality) and the ranked alternatives', rl),
+                },
+            ],
+        };
+    }
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `Failover Verdict from ${data.from.provider}` +
+                    (data.from.in_incident ? ' (confirmed in incident)' : '') +
+                    `: fail over to ${dest.model.name} (${dest.model.provider})\n` +
+                    `Why: ${data.why}\n` +
+                    `Excluded: ${data.excluded_providers.length ? data.excluded_providers.join(', ') : 'none'}\n` +
+                    `Claim: ${data.claim}\n` +
+                    verdictUpsell('failover_verdict', 'the full failover candidate (pricing, measured latency, quality) and the ranked alternatives', rl),
+            },
+        ],
+    };
+});
+registerTool('failover_verdict', "Costs 1 credit ($0.02). The signed failover ruling: provider A is degraded, this is the best operational provider to fail over to for a task right now, with the full candidate (pricing, measured p95 latency, quality), the ranked alternatives, the confirmed incident on A, and an AFTA-signed receipt. Versus the free failover_verdict_preview it adds the candidate's pricing, measured latency, and quality, the ranked alternatives, and the receipt, with no rate limit. Confirms A against live incident triage and excludes any provider already in failover. 30-minute operational freshness SLA. Get credits at tensorfeed.ai/developers/agent-payments. Strict premium, no free trial.", {
+    from: z.string().describe('The degraded provider to fail over FROM (e.g. "anthropic", "openai"). Required.'),
+    task: z.enum(['code', 'reasoning', 'creative', 'general']).optional().describe('Task type to optimize the failover target for. Optional.'),
+}, async ({ from, task }) => {
+    if (!from || !from.trim()) {
+        return { content: [{ type: 'text', text: 'Provide a from provider (the degraded provider to fail over from, e.g. from "anthropic") to get a signed failover verdict.' }] };
+    }
+    const params = new URLSearchParams({ from: from.trim() });
+    if (task)
+        params.set('task', task);
+    const data = (await fetchJSON(`/premium/failover-verdict?${params}`, { auth: true }));
+    const dest = data.failover_to;
+    const incidentLine = data.from.incident
+        ? `Incident on ${data.from.provider}: ${data.from.incident.title} (action ${data.from.incident.recommended_action})\n`
+        : '';
+    if (!dest) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Failover Verdict from ${data.from.provider}: no operational failover target found.\n` +
+                        incidentLine +
+                        `Why: ${data.why}\nClaim: ${data.claim}` +
+                        verdictBilling(data.billing),
+                },
+            ],
+        };
+    }
+    const alts = (data.alternatives ?? [])
+        .map((a) => `  #${a.rank} ${a.model.name} (${a.model.provider}) blended $${a.pricing.blended}/1M, p95 ${a.latency.measured_p95_ms ?? 'n/a'}ms, status ${a.operational.status}`)
+        .join('\n');
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `Failover Verdict from ${data.from.provider}: fail over to ${dest.model.name} (${dest.model.provider})\n` +
+                    `Why: ${dest.why}\n` +
+                    `Blended $${dest.pricing.blended}/1M, p95 ${dest.latency.measured_p95_ms ?? 'n/a'}ms, status ${dest.operational.status}\n` +
+                    incidentLine +
+                    `Excluded: ${data.excluded_providers.length ? data.excluded_providers.join(', ') : 'none'}\n\n` +
+                    `Alternatives:\n${alts || '  (none)'}\n\n` +
+                    `Claim: ${data.claim}` +
+                    verdictBilling(data.billing),
+            },
+        ],
+    };
+});
+// ── Tool: ssvc_verdict_preview (free, 10/IP/day) ────────────────────
+registerTool('ssvc_verdict_preview', "Free. The CISA SSVC decision points for one CVE, read from CISA's Vulnrichment record: exploitation, automatable, and technical impact, plus the decision-tree provenance, WITHOUT the computed Act / Attend / Track / Track* decision (that is the premium ruling). For the computed SSVC decision across the full Mission and Well-being envelope, the per-level reasoning, the live KEV cross-check, and an AFTA-signed receipt, use ssvc_verdict. Requires a CVE id. 10 calls per day per IP.", {
+    cve: z.string().describe('CVE id to rule on, e.g. "CVE-2024-3094". Required.'),
+}, async ({ cve }) => {
+    if (!cve || !cve.trim()) {
+        return { content: [{ type: 'text', text: 'Provide a CVE id (e.g. cve "CVE-2024-3094") to get the SSVC decision points.' }] };
+    }
+    const params = new URLSearchParams({ cve: cve.trim() });
+    const data = (await fetchJSON(`/preview/security/ssvc-verdict?${params}`));
+    const dp = data.decision_points;
+    const rl = previewRateLine(data.rate_limit);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `SSVC decision points for ${data.cve}:\n` +
+                    `  exploitation: ${dp.exploitation}\n` +
+                    `  automatable: ${dp.automatable}\n` +
+                    `  technical impact: ${dp.technical_impact}\n` +
+                    `Tree: ${data.tree.name} ${data.tree.version}` +
+                    (data.scored_at ? `, scored ${data.scored_at}` : '') +
+                    '\n' +
+                    verdictUpsell('ssvc_verdict', 'the computed SSVC decision (Act, Attend, Track, or Track*) across the low/medium/high Mission and Well-being envelope, the per-level reasoning, and the live KEV cross-check', rl),
+            },
+        ],
+    };
+});
+// ── Tool: ssvc_verdict (1 credit) ───────────────────────────────────
+registerTool('ssvc_verdict', "Costs 1 credit ($0.02). The signed SSVC patch-urgency decision for one CVE: applies the CISA SSVC Coordinator decision tree to the three recorded decision points and returns the decision (Act, Attend, Track, or Track*) across the full low/medium/high Mission and Well-being envelope, the per-level reasoning, a live CISA KEV cross-check, and an AFTA-signed receipt. Versus the free ssvc_verdict_preview it adds the computed decision, the envelope, the reasoning trace, the KEV staleness overlay, and the receipt, with no rate limit. A CVE not in Vulnrichment is no-charge. Get credits at tensorfeed.ai/developers/agent-payments. Strict premium, no free trial.", {
+    cve: z.string().describe('CVE id to rule on, e.g. "CVE-2024-3094". Required.'),
+}, async ({ cve }) => {
+    if (!cve || !cve.trim()) {
+        return { content: [{ type: 'text', text: 'Provide a CVE id (e.g. cve "CVE-2024-3094") to get a signed SSVC decision.' }] };
+    }
+    const params = new URLSearchParams({ cve: cve.trim() });
+    const data = (await fetchJSON(`/premium/security/ssvc-verdict?${params}`, { auth: true }));
+    const dp = data.decision_points;
+    const env = data.decision_envelope;
+    const kev = data.kev_cross_check;
+    const kevLine = kev && kev.checked
+        ? `KEV cross-check: ${kev.kev_listed ? 'listed on CISA KEV' : 'not on KEV'}${kev.flag && kev.flag !== 'none' ? ` (${kev.flag})` : ''}`
+        : 'KEV cross-check: unavailable';
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `SSVC Verdict for ${data.cve}: ${data.decision_primary} (Mission and Well-being assumed medium)\n` +
+                    `Envelope: low ${env.low}, medium ${env.medium}, high ${env.high}\n` +
+                    `Decision points: exploitation ${dp.exploitation}, automatable ${dp.automatable}, technical impact ${dp.technical_impact}\n` +
+                    `${kevLine}\n` +
+                    `Tree: ${data.tree.name} ${data.tree.version}` +
+                    (data.scored_at ? `, scored ${data.scored_at}` : '') +
+                    verdictBilling(data.billing),
+            },
+        ],
+    };
+});
 // ── Tool: pricing_series_free (free, 7-day cap) ─────────────────────
 registerTool('pricing_series_free', 'Daily price points for one AI model over the last 1 to 7 days, free. For windows up to 90 days use pricing_series (1 credit).', {
     model: z.string().describe('Model id or display name (e.g. "Claude Opus 4.7" or "claude-opus-4-7")'),
@@ -841,7 +1284,7 @@ registerTool('status_leaderboard_free', 'Cross-provider uptime leaderboard, rank
         content: [
             {
                 type: 'text',
-                text: `AI provider uptime leaderboard ${data.range?.from} to ${data.range?.to}\n${lines.join('\n')}`,
+                text: `AI provider uptime leaderboard ${data.range?.from} to ${data.range?.to}\n${lines.join('\n')}\n\nprovider_reliability_verdict ranks providers by dependability, not just current state.`,
             },
         ],
     };
@@ -1836,7 +2279,7 @@ registerTool('get_ai_cves_latest', 'Get metadata for the most-recent AI-stack CV
         content: [
             {
                 type: 'text',
-                text: `${head}\n\nFirst 25 papers:\n${lines}\n\nFor AI-stack-filtered + categorized + sorted papers: /api/premium/ai-cves/ai-stack-cves (1 credit, x402-paid). For only papers actively exploited in the wild: /api/premium/ai-cves/exploited-in-wild (1 credit). For single-CVE lookup: /api/premium/ai-cves/cve?id=CVE-YYYY-NNNNN (1 credit).`,
+                text: `${head}\n\nFirst 25 papers:\n${lines}\n\nFor AI-stack-filtered + categorized + sorted papers: /api/premium/ai-cves/ai-stack-cves (1 credit, x402-paid). For only papers actively exploited in the wild: /api/premium/ai-cves/exploited-in-wild (1 credit). For single-CVE lookup: /api/premium/ai-cves/cve?id=CVE-YYYY-NNNNN (1 credit).\n\nssvc_verdict gives the CISA SSVC act/attend/track decision for a CVE; stack_safety_verdict gates your deploy by package.`,
             },
         ],
     };
@@ -1983,7 +2426,7 @@ registerTool('get_x402_publishers', 'List x402-compliant publishers TensorFeed c
         content: [
             {
                 type: 'text',
-                text: `x402 publishers (${data.count}, captured ${data.captured_at}):\n\n${lines}${more}`,
+                text: `x402 publishers (${data.count}, captured ${data.captured_at}):\n\n${lines}${more}\n\nx402_publisher_verdict returns a signed trust verdict on one publisher before you pay it.`,
             },
         ],
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tensorfeed/mcp-server",
-  "version": "1.38.0",
+  "version": "1.39.0",
   "mcpName": "ai.tensorfeed/mcp-server",
   "description": "MCP server for TensorFeed.ai - AI news, status, model data, and premium endpoints (routing, cost projection, forecast, history series, news search, webhook watches with digest tier, enriched directory) for AI agents",
   "main": "dist/index.js",

package/server.json

@@ -3,7 +3,7 @@
   "name": "ai.tensorfeed/mcp-server",
   "title": "TensorFeed",
   "description": "AI news, model pricing, service status, and machine-payable premium tools. AFTA-certified.",
-  "version": "1.38.0",
+  "version": "1.39.0",
   "websiteUrl": "https://tensorfeed.ai/developers/agent-payments",
   "repository": {
     "url": "https://github.com/RipperMercs/tensorfeed-mcp",
@@ -20,7 +20,7 @@
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "@tensorfeed/mcp-server",
-      "version": "1.38.0",
+      "version": "1.39.0",
       "runtimeHint": "npx",
       "transport": {
         "type": "stdio"