csoai-gspc-mcp 0.1.0 → 0.2.0

package/README.md

@@ -1,5 +1,7 @@
 # csoai-gspc-mcp
 
+[![22 axes measured · 14 model fleets · 3 public leader scores · 8 fact runs · TIE is TIE · not a certificate. Three states only: VALID · INVALID · UNCHECKABLE.](https://councilof.ai/badge/gspc.svg)](https://councilof.ai/gspc-scoreboard)
+
 Stdio MCP server for the live GSPC board and the signed measurement cards at
 [councilof.ai](https://councilof.ai). Zero dependencies. Node >= 20.
 
@@ -18,32 +20,67 @@ are reported as two labelled numbers and never reconciled.
 | `get_axis` | One axis row from the live board: `n`, `accuracy`, `interval`, MEASURED/UNMEASURED status, dates. Args: `{ "axis": "jail" }`. |
 | `verify_card` | Verify a signed `gspc.measurement-card` under the published rule — recompute the id from the canonical body, check the Ed25519 signature under the **pinned** key `did:web:csoai.org#card-attestation-1`. A card signed with its own freshly-made key is INVALID, not valid. Args: `{ "card": <object | JSON string | councilof.ai URL> }`. |
 | `list_cards` | What the published index (`/signed/card_index.json`) declares next to what the card store endpoint (`/api/cards`) reports — two labelled numbers, never reconciled. Optional `axis`, `limit`. |
+| `get_root` | GET `https://councilof.ai/root.json`. Three states: VALID / UNREACHABLE / UNCHECKABLE. Separate from GSPC. Never a certificate. |
+| `get_card` | GET one card-v0 leaf by sha256. VALID / INVALID (not a leaf) / UNCHECKABLE (fetch failed). A 404 leaf is INVALID, not UNCHECKABLE. |
+| `verify_inclusion` | GET `/api/proof?sha=`. VALID (included) / INVALID (not a leaf) / UNCHECKABLE (proof endpoint unreachable). |
+
+Seven free tools above; five metered ones below. `tools/list` returns all twelve, and
+`wired-tools.test.mjs` fails if a listed tool does not run or a running tool is not listed.
 
-The same four tools, from the same definitions file
+The same seven free tools, from the same definitions file
 (`functions/mcp/gspc-tools.json`), are served over HTTP at
 `https://councilof.ai/mcp` (streamable HTTP, JSON-RPC 2.0 POST). Use whichever
 transport your client speaks; the contracts are identical.
 
+### The five x402-metered tools — carried here since 0.2.0
+
+| tool | route | free path |
+|---|---|---|
+| `commission_card` | `/api/request-attestation` | — (a payment never mints a MEASURED cell) |
+| `art50_marking_evidence` | `/api/art50/marking-evidence` | `preview: true` |
+| `rwa_evidence` | `/api/rwa/evidence` | `preview: true` (unsigned state) |
+| `witness_hash` | `/api/witness` | — |
+| `receipts_batch` | `/api/receipts/batch` | `preview: true` (count, span, roots, batch sha256) |
+
+Payment travels as the **`x_payment` argument**, not as a transport header — so stdio carries these
+exactly as the HTTP door does. Up to 0.1.1 this README said the opposite ("stdio has no payment header to
+forward"); that was a statement about the transport, and it was wrong about the mechanism. The server
+forwards your `x_payment` verbatim as the `X-PAYMENT` header on one request to `councilof.ai` and never
+inspects, signs or invents a receipt. Settlement is the route's job, fail-closed.
+
+Four honest statuses, and no fifth:
+
+- **`PAYMENT_REQUIRED`** — the route answered 402. The full challenge (`accepts[]`, the `PAYMENT-REQUIRED`
+  header) comes back as `structuredContent`. Nothing was charged. A challenge is an answer, not a failure.
+- **`DELIVERED`** — the route answered 2xx, with the settle echo when the route sent one.
+- **`NOT_DEPLOYED`** — the route answered 404 on this origin. Said plainly, never a fabricated result.
+- **`UNREACHABLE`** / **`BAD_ARGUMENTS`** — the call could not be made. Nothing was charged.
+
+**Known limitation, stated rather than hidden (2026-09-04):** the free `preview` paths and the 402
+challenge work today, but **settlement on the live rail is failing** — a genuine signed EIP-3009
+authorization is rejected by the facilitator with HTTP 400 after the buyer signs, because the facilitator
+now advertises two x402 dialects for Base and the wrong one is being selected. The fix is written and
+tested but not merged. Until it is, treat the paid paths as: challenge yes, delivery no. This server
+reports what the route actually said and never converts a failed settlement into a result.
+
+Every paid deliverable is measurement, not certification; no tool on either transport carries a trust
+label; amounts appear only inside a 402 challenge.
+
 ## Install
 
-This package is **not yet published to npm** (checked 2026-08-27). Until it is,
-install from a checkout of the repo — the server is a single file with no
-dependencies, so "install" is just pointing your client at it:
+Published on npm as [`csoai-gspc-mcp`](https://www.npmjs.com/package/csoai-gspc-mcp). No checkout required:
 
 ```sh
-git clone https://github.com/CSOAI-ORG/councilof-ai.git
-# the server is at councilof-ai/mcp/gspc-server/index.mjs — no npm install needed
+npx -y csoai-gspc-mcp
 ```
 
-Below, replace `/ABS/PATH/TO/councilof-ai` with where you cloned it.
-
 ### Claude Code
 
 ```sh
-claude mcp add gspc -- node /ABS/PATH/TO/councilof-ai/mcp/gspc-server/index.mjs
+claude mcp add gspc -- npx -y csoai-gspc-mcp
 ```
 
-Once published to npm this becomes `claude mcp add gspc -- npx -y csoai-gspc-mcp`.
+From a checkout of the repo the server is `mcp/gspc-server/index.mjs` (no extra install).
 
 ### Claude Desktop
 
@@ -55,8 +92,8 @@ Add to `claude_desktop_config.json` (macOS:
 {
   "mcpServers": {
     "gspc": {
-      "command": "node",
-      "args": ["/ABS/PATH/TO/councilof-ai/mcp/gspc-server/index.mjs"]
+      "command": "npx",
+      "args": ["-y", "csoai-gspc-mcp"]
     }
   }
 }
@@ -70,16 +107,24 @@ Add to `.cursor/mcp.json` in your project (or `~/.cursor/mcp.json` globally):
 {
   "mcpServers": {
     "gspc": {
-      "command": "node",
-      "args": ["/ABS/PATH/TO/councilof-ai/mcp/gspc-server/index.mjs"]
+      "command": "npx",
+      "args": ["-y", "csoai-gspc-mcp"]
     }
   }
 }
 ```
 
+### Grok Build
+
+```toml
+[mcp_servers.gspc-npm]
+command = "npx"
+args = ["-y", "csoai-gspc-mcp"]
+```
+
 ### Any other stdio MCP client (Grok Bot, DSH harness, your own agent)
 
-Spawn `node /ABS/PATH/TO/councilof-ai/mcp/gspc-server/index.mjs` and speak
+Spawn `npx -y csoai-gspc-mcp` and speak
 newline-delimited JSON-RPC 2.0 on its stdin/stdout (stderr is logs only):
 
 1. send `{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"you","version":"0"}}}`

package/gspc-tools.json

@@ -1,10 +1,10 @@
 {
   "schema": "csoai.gspc-mcp-tools/1",
-  "note": "ONE source of tool definitions for the GSPC MCP tools, shared by the stdio server (mcp/gspc-server/index.mjs) and the HTTP endpoint (functions/mcp/[[path]].ts) so the two surfaces cannot drift. Display text uses 'axis', never the plural — owner language ruling; code identifiers are exempt.",
+  "note": "ONE source of tool definitions for the GSPC MCP tools, shared by the stdio server (mcp/gspc-server/index.mjs) and the HTTP endpoint (functions/mcp/[[path]].ts) so the two surfaces cannot drift. Display text uses 'axis', never the plural \u2014 owner language ruling; code identifiers are exempt.",
   "tools": [
     {
       "name": "board_totals",
-      "description": "Live GSPC board totals from https://councilof.ai/api/gspc. Returns the slot count and the measured count as two labelled numbers WITH their kind — a slot is a declared position on the board, a measurement is a real run behind it; the two are never summed and never swapped — plus as_of dates for the board and for this fetch. We measure, never certify. If the board cannot be fetched the answer is a distinct UNREACHABLE state: no cached number is ever presented as live.",
+      "description": "Live GSPC board totals from https://councilof.ai/api/gspc. Returns the slot count and the measured count as two labelled numbers WITH their kind \u2014 a slot is a declared position on the board, a measurement is a real run behind it; the two are never summed and never swapped \u2014 plus as_of dates for the board and for this fetch. We measure, never certify. If the board cannot be fetched the answer is a distinct UNREACHABLE state: no cached number is ever presented as live.",
       "inputSchema": {
         "type": "object",
         "properties": {},
@@ -13,7 +13,7 @@
     },
     {
       "name": "get_axis",
-      "description": "One axis row from the live GSPC board at https://councilof.ai/api/gspc: n, accuracy, interval, MEASURED or UNMEASURED status, family, and dates. An unmeasured axis is a first-class answer — a declared slot with no run behind it, published so the gap is visible — never an error and never a zero. Never a certification.",
+      "description": "One axis row from the live GSPC board at https://councilof.ai/api/gspc: n, accuracy, interval, MEASURED or UNMEASURED status, family, and dates. An unmeasured axis is a first-class answer \u2014 a declared slot with no run behind it, published so the gap is visible \u2014 never an error and never a zero. Never a certification.",
       "inputSchema": {
         "type": "object",
         "properties": {
@@ -22,28 +22,39 @@
             "description": "The axis name as it appears on the board, e.g. governance, safety, jail, provenance-controls. Case-insensitive. An unknown name returns the list of names the board actually carries."
           }
         },
-        "required": ["axis"],
+        "required": [
+          "axis"
+        ],
         "additionalProperties": false
       }
     },
     {
       "name": "verify_card",
-      "description": "Verify a signed gspc.measurement-card under the published rule (https://councilof.ai/signed/HOW-TO-VERIFY.md): recompute the id from the canonical body bytes, then check the Ed25519 signature under the PINNED key published at did:web:csoai.org#card-attestation-1. A card that carries its own key proves only that the file is self-consistent — anyone can alter a body and sign it with a key they just generated — so a signer other than the published key is reported INVALID. Three verdicts, never two: VALID, INVALID (with the reason), or UNCHECKABLE when the check could not be completed — 'could not check' is a different claim from 'forged'. Accepts the card as a JSON object, a JSON string, or a councilof.ai / csoai.org URL. Never a certification.",
+      "description": "Verify a signed gspc.measurement-card under the published rule (https://councilof.ai/signed/HOW-TO-VERIFY.md): recompute the id from the canonical body bytes, then check the Ed25519 signature under the PINNED key published at did:web:csoai.org#card-attestation-1. A card that carries its own key proves only that the file is self-consistent \u2014 anyone can alter a body and sign it with a key they just generated \u2014 so a signer other than the published key is reported INVALID. Three verdicts, never two: VALID, INVALID (with the reason), or UNCHECKABLE when the check could not be completed \u2014 'could not check' is a different claim from 'forged'. Accepts the card as a JSON object, a JSON string, or a councilof.ai / csoai.org URL. Never a certification.",
       "inputSchema": {
         "type": "object",
         "properties": {
           "card": {
             "description": "The signed card: an object, a JSON string, or a councilof.ai / csoai.org URL to one.",
-            "anyOf": [{ "type": "object" }, { "type": "string" }]
+            "anyOf": [
+              {
+                "type": "object"
+              },
+              {
+                "type": "string"
+              }
+            ]
           }
         },
-        "required": ["card"],
+        "required": [
+          "card"
+        ],
         "additionalProperties": false
       }
     },
     {
       "name": "list_cards",
-      "description": "The published signed-card index (https://councilof.ai/signed/card_index.json): what the index declares (n_cards) and how many rows it actually carries, reported next to — never reconciled with — the count the card store endpoint (https://councilof.ai/api/cards) reports for itself. Two labelled numbers from two surfaces; if they disagree, this tool shows the disagreement rather than picking one. Optional filters return recent rows: axis, limit.",
+      "description": "The published signed-card index (https://councilof.ai/signed/card_index.json): what the index declares (n_cards) and how many rows it actually carries, reported next to \u2014 never reconciled with \u2014 the count the card store endpoint (https://councilof.ai/api/cards) reports for itself. Two labelled numbers from two surfaces; if they disagree, this tool shows the disagreement rather than picking one. Optional filters return recent rows: axis, limit.",
       "inputSchema": {
         "type": "object",
         "properties": {
@@ -60,6 +71,49 @@
         },
         "additionalProperties": false
       }
+    },
+    {
+      "name": "get_root",
+      "description": "GET the permissionless public-root at https://councilof.ai/root.json. Returns merkle_root, card_count, as_of, and UNMEASURED notes. Separate from GSPC. Three states: VALID (fetched), UNREACHABLE (could not fetch), UNCHECKABLE (body unreadable). Never a certificate.",
+      "inputSchema": {
+        "type": "object",
+        "properties": {},
+        "additionalProperties": false
+      }
+    },
+    {
+      "name": "get_card",
+      "description": "GET one public-root card-v0 leaf by sha256 (64 hex) from https://councilof.ai/cards/{sha16}.json. UNMEASURED cells stay visible. Three states: VALID (fetched), INVALID (not a leaf of the live root), UNCHECKABLE (fetch failed). Not a GSPC measurement-card.",
+      "inputSchema": {
+        "type": "object",
+        "properties": {
+          "sha256": {
+            "type": "string",
+            "description": "64-char hex payload SHA-256 of the card-v0 leaf."
+          }
+        },
+        "required": [
+          "sha256"
+        ],
+        "additionalProperties": false
+      }
+    },
+    {
+      "name": "verify_inclusion",
+      "description": "Check a sha256 against the live public-root merkle via GET /api/proof?sha=. Three states only: VALID (included), INVALID (not a leaf), UNCHECKABLE (proof endpoint unreachable). Does not claim Ed25519 unless sig_ed25519 is present and checked separately. Never a grade.",
+      "inputSchema": {
+        "type": "object",
+        "properties": {
+          "sha256": {
+            "type": "string",
+            "description": "64-char hex digest to test for inclusion."
+          }
+        },
+        "required": [
+          "sha256"
+        ],
+        "additionalProperties": false
+      }
     }
   ]
-}
+}

package/index.mjs

@@ -18,8 +18,9 @@
  *     numbers. This server never reconciles them.
  *
  * ONE SOURCE OF TRUTH:
- *   - Tool definitions come from gspc-tools.json — the same file the HTTP
- *     endpoint at councilof.ai/mcp imports (functions/mcp/gspc-tools.json).
+ *   - Tool definitions come from gspc-tools.json (free) and paid-tools.json
+ *     (x402-metered) — the same two files the HTTP endpoint at councilof.ai/mcp
+ *     imports (functions/mcp/*.json).
  *     In a repo checkout that file is read directly; the npm package ships a
  *     byte-identical copy made at pack time (npm run prepack).
  *   - verify_card runs the code in public/signed/verify-card.mjs — the same
@@ -31,7 +32,7 @@ import { createInterface } from "node:readline";
 import { readFileSync, existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 
-const VERSION = "0.1.0";
+const VERSION = "0.2.0";
 const ORIGIN = process.env.GSPC_ORIGIN || "https://councilof.ai";
 const FETCH_TIMEOUT_MS = 15000;
 
@@ -56,7 +57,24 @@ if (!TOOLS_PATH) {
   process.stderr.write("csoai-gspc-mcp: gspc-tools.json not found — broken install\n");
   process.exit(1);
 }
-const TOOLS = JSON.parse(readFileSync(TOOLS_PATH, "utf8")).tools;
+const FREE_TOOLS = JSON.parse(readFileSync(TOOLS_PATH, "utf8")).tools;
+
+/**
+ * The x402-metered tools, from the same definitions file the HTTP door uses.
+ *
+ * Payment travels as the `x_payment` TOOL ARGUMENT, not as a transport header, so stdio carries
+ * these exactly as the HTTP door does: the argument is forwarded verbatim as the X-PAYMENT header
+ * on one same-origin request, and this server never inspects, signs or invents a receipt.
+ * Settlement is the route's job, fail-closed. Without `x_payment` the tool returns the route's own
+ * 402 challenge, which is an answer and not a failure — and `preview` is free where a tool offers it.
+ */
+const PAID_TOOLS_PATH = firstExisting([
+  "../../functions/mcp/paid-tools.json", // repo checkout: the canonical file
+  "./paid-tools.json", // npm package: the byte-identical pack-time copy
+]);
+const PAID_TOOLS = PAID_TOOLS_PATH ? JSON.parse(readFileSync(PAID_TOOLS_PATH, "utf8")).tools : [];
+const PAID_BY_NAME = new Map(PAID_TOOLS.map((t) => [t.name, t]));
+const TOOLS = [...FREE_TOOLS, ...PAID_TOOLS];
 
 const VERIFIER_PATH = firstExisting([
   "../../public/signed/verify-card.mjs", // repo checkout: the canonical file
@@ -76,7 +94,11 @@ async function fetchJson(path) {
     headers: { accept: "application/json" },
     signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
   });
-  if (!r.ok) throw new Error(`GET ${url} returned HTTP ${r.status}`);
+  if (!r.ok) {
+    const err = new Error(`GET ${url} returned HTTP ${r.status}`);
+    err.status = r.status;
+    throw err;
+  }
   return r.json();
 }
 
@@ -271,11 +293,211 @@ async function listCards(args) {
   return out;
 }
 
+async function getRoot() {
+  try {
+    const d = await fetchJson("/root.json");
+    return {
+      state: "VALID",
+      source: `${ORIGIN}/root.json`,
+      kind: d.kind ?? null,
+      as_of: d.as_of ?? null,
+      card_count: d.card_count ?? null,
+      merkle_root: d.merkle_root ?? null,
+      note: d.note ?? null,
+      not_a_certification: true,
+      not_gspc: true,
+    };
+  } catch (e) {
+    return { ...unreachable("/root.json", e), state: "UNREACHABLE", not_gspc: true };
+  }
+}
+
+async function getCard(args) {
+  const sha = String(args.sha256 || "").trim().toLowerCase();
+  if (!/^[0-9a-f]{64}$/.test(sha)) {
+    return { state: "UNCHECKABLE", reason: "sha256 must be 64 hex", not_a_certification: true };
+  }
+  try {
+    const d = await fetchJson(`/cards/${sha.slice(0, 16)}.json`);
+    const card = d.card || d;
+    const match = String(card.sha256 || "") === sha;
+    return {
+      state: match ? "VALID" : "INVALID",
+      sha256: sha,
+      source: `${ORIGIN}/cards/${sha.slice(0, 16)}.json`,
+      surface: card.surface ?? null,
+      unmeasured: card.unmeasured ?? [],
+      sig_ed25519: card.sig_ed25519 ?? null,
+      not_a_certification: true,
+      not_gspc: true,
+    };
+  } catch (e) {
+    if (e && e.status === 404) {
+      return {
+        state: "INVALID",
+        sha256: sha,
+        reason: "not a leaf of the live root",
+        source: `${ORIGIN}/cards/${sha.slice(0, 16)}.json`,
+        not_a_certification: true,
+        not_gspc: true,
+      };
+    }
+    return { ...unreachable(`/cards/${sha.slice(0, 16)}.json`, e), state: "UNCHECKABLE", sha256: sha };
+  }
+}
+
+async function verifyInclusion(args) {
+  const sha = String(args.sha256 || "").trim().toLowerCase();
+  if (!/^[0-9a-f]{64}$/.test(sha)) {
+    return { state: "UNCHECKABLE", reason: "sha256 must be 64 hex", not_a_certification: true };
+  }
+  try {
+    const d = await fetchJson(`/api/proof?sha=${sha}`);
+    if (d.kind === "inclusion") {
+      return { state: "VALID", sha256: sha, merkle_root: d.merkle_root ?? null, not_a_certification: true };
+    }
+    if (d.error === "not_found") {
+      return { state: "INVALID", sha256: sha, reason: d.reason ?? "not a leaf", not_a_certification: true };
+    }
+    return { state: "UNCHECKABLE", sha256: sha, reason: d.reason ?? "unexpected proof body", not_a_certification: true };
+  } catch (e) {
+    if (e && e.status === 404) {
+      return { state: "INVALID", sha256: sha, reason: "not a leaf", not_a_certification: true };
+    }
+    return { ...unreachable(`/api/proof?sha=${sha}`, e), state: "UNCHECKABLE", sha256: sha };
+  }
+}
+
+/* ---------------------------------------------------------------- paid tools */
+
+const PAID_DOCTRINE =
+  "measurement, not certification — no tool here carries or awards a trust label of any kind; " +
+  "verification stays free";
+
+/** Build the one request a paid tool makes. A caller cannot steer it to another URL. */
+function buildPaidRequest(name, args) {
+  const tool = PAID_BY_NAME.get(name);
+  if (!tool) return { error: `unknown paid tool: ${name}` };
+  const route = tool.csoai.route;
+  const str = (k) => (typeof args[k] === "string" ? args[k].trim() : "");
+  const flag = (k) => args[k] === true || args[k] === "1" || args[k] === "true";
+  const headers = { accept: "application/json" };
+  const xp = str("x_payment");
+  if (xp) headers["x-payment"] = xp;
+  const u = new URL(route, ORIGIN);
+  let method = "GET";
+  let body;
+
+  switch (name) {
+    case "commission_card":
+      if (!str("subject")) return { error: "subject is required" };
+      u.searchParams.set("subject", str("subject"));
+      if (str("axis")) u.searchParams.set("axis", str("axis"));
+      break;
+    case "art50_marking_evidence":
+      if (flag("preview")) u.searchParams.set("preview", "1");
+      if (str("bytes_b64") || str("manifest_b64")) {
+        method = "POST";
+        headers["content-type"] = "application/json";
+        body = JSON.stringify(
+          str("bytes_b64") ? { bytes_b64: str("bytes_b64") } : { manifest_b64: str("manifest_b64") },
+        );
+      } else if (str("url")) {
+        u.searchParams.set("url", str("url"));
+      } else {
+        return { error: "one of url, bytes_b64 or manifest_b64 is required" };
+      }
+      break;
+    case "rwa_evidence":
+      if (!str("asset")) return { error: "asset is required" };
+      u.searchParams.set("asset", str("asset"));
+      if (flag("preview")) u.searchParams.set("preview", "1");
+      break;
+    case "witness_hash":
+      if (!str("sha256") && !str("url")) return { error: "sha256 or url is required" };
+      if (str("sha256")) u.searchParams.set("sha256", str("sha256").toLowerCase());
+      if (str("url")) u.searchParams.set("url", str("url"));
+      if (str("label")) u.searchParams.set("label", str("label"));
+      break;
+    case "receipts_batch":
+      if (!str("from")) return { error: "from is required (ISO-8601)" };
+      u.searchParams.set("from", str("from"));
+      if (str("to")) u.searchParams.set("to", str("to"));
+      if (flag("preview")) u.searchParams.set("preview", "1");
+      break;
+    default:
+      return { error: `no request builder for ${name}` };
+  }
+  return { url: u.toString(), init: { method, headers, ...(body ? { body } : {}) }, route };
+}
+
+/**
+ * Forward one paid tool to its route and report what came back, in the route's own words.
+ * 402 is PAYMENT_REQUIRED and not an error; 404 is NOT_DEPLOYED and never a fabricated result.
+ */
+async function callPaidTool(name, args) {
+  const tool = PAID_BY_NAME.get(name);
+  const base = {
+    tool: name,
+    route: tool.csoai.route,
+    sku: tool.csoai.sku,
+    rail: tool.csoai.rail,
+    doctrine: PAID_DOCTRINE,
+    not_a_certification: true,
+  };
+  const built = buildPaidRequest(name, args);
+  if (built.error) return { ...base, status: "BAD_ARGUMENTS", reason: built.error };
+
+  let res;
+  try {
+    res = await fetch(built.url, { ...built.init, signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) });
+  } catch (e) {
+    return {
+      ...base,
+      status: "UNREACHABLE",
+      reason: e instanceof Error ? e.message : String(e),
+      note: "The route could not be fetched. Nothing was charged, and no result is invented.",
+    };
+  }
+
+  const text = await res.text();
+  let body = null;
+  try {
+    body = text ? JSON.parse(text) : null;
+  } catch {
+    body = { raw: text.slice(0, 2000) };
+  }
+
+  if (res.status === 402) {
+    return {
+      ...base,
+      status: "PAYMENT_REQUIRED",
+      http_status: 402,
+      payment_required: body,
+      payment_required_header: res.headers.get("payment-required"),
+      note:
+        "A challenge is an answer, not a failure. Pay from your own wallet against accepts[] and " +
+        "call again with x_payment. Nothing was charged by this call.",
+    };
+  }
+  if (res.status === 404) {
+    return { ...base, status: "NOT_DEPLOYED", http_status: 404, body, note: `${tool.csoai.route} is not on ${ORIGIN}.` };
+  }
+  if (res.ok) {
+    const settle = res.headers.get("x-payment-response");
+    return { ...base, status: "DELIVERED", http_status: res.status, body, ...(settle ? { x_payment_response: settle } : {}) };
+  }
+  return { ...base, status: String(res.status), http_status: res.status, body };
+}
+
 const HANDLERS = {
   board_totals: boardTotals,
   get_axis: getAxis,
   verify_card: verifyCardTool,
   list_cards: listCards,
+  get_root: getRoot,
+  get_card: getCard,
+  verify_inclusion: verifyInclusion,
 };
 
 /* ----------------------------------------------------------------- transport */
@@ -311,6 +533,20 @@ function summaryLine(name, payload) {
       const b = payload.card_store_count_endpoint?.count ?? "?";
       return `index declares ${a} card rows; the store's count endpoint reports ${b}. Two labelled numbers, not reconciled here.`;
     }
+    case "get_root":
+      return `${payload.state ?? "?"} — public-root merkle ${(String(payload.merkle_root || "")).slice(0, 16) || "none"}. Not GSPC.`;
+    case "get_card":
+      return `${payload.state ?? "?"} — card-v0 leaf ${String(payload.sha256 || "").slice(0, 16) || "?"}.`;
+    case "verify_inclusion":
+      return `${payload.state ?? "?"} — inclusion against live merkle.`;
+    case "commission_card":
+    case "art50_marking_evidence":
+    case "rwa_evidence":
+    case "witness_hash":
+    case "receipts_batch":
+      return `${payload.status ?? "?"} — ${payload.route ?? name}${
+        payload.status === "PAYMENT_REQUIRED" ? "; nothing charged" : ""
+      }${payload.reason ? " — " + payload.reason : ""}. ${PAID_DOCTRINE}.`;
     default:
       return name;
   }
@@ -334,7 +570,7 @@ async function handle(msg) {
 
   if (method === "tools/call") {
     const name = params?.name;
-    const fn = HANDLERS[name];
+    const fn = PAID_BY_NAME.has(name) ? (a) => callPaidTool(name, a) : HANDLERS[name];
     if (!fn) return replyError(id, -32602, `unknown tool: ${name}`);
     try {
       const payload = await fn(params?.arguments ?? {});

package/package.json

@@ -1,21 +1,23 @@
 {
   "name": "csoai-gspc-mcp",
-  "version": "0.1.0",
-  "description": "Stdio MCP server for the live GSPC board and the signed measurement cards at councilof.ai. Four honest tools: board_totals, get_axis, verify_card (pinned-key, three-state), list_cards. We measure, never certify; unmeasured is first-class; verdicts are VALID / INVALID / UNCHECKABLE, never two-state. Zero dependencies.",
+  "version": "0.2.0",
+  "description": "Stdio MCP server for the live GSPC board, signed measurement cards, and public-root merkle at councilof.ai. Twelve tools: seven free readers (board_totals, get_axis, verify_card with a pinned key and a three-state verdict, list_cards, get_root, get_card, verify_inclusion) and five x402-metered ones (commission_card, art50_marking_evidence, rwa_evidence, witness_hash, receipts_batch) that return the route's own 402 challenge until you pay. We measure, never certify; unmeasured is first-class; verdicts are VALID / INVALID / UNCHECKABLE, never two-state. A 404 leaf is INVALID. Zero dependencies.",
   "type": "module",
   "bin": {
     "csoai-gspc-mcp": "index.mjs"
   },
   "main": "index.mjs",
   "files": [
-    "index.mjs",
+    "README.md",
     "gspc-tools.json",
-    "verify-card.mjs",
-    "README.md"
+    "index.mjs",
+    "paid-tools.json",
+    "verify-card.mjs"
   ],
   "scripts": {
     "prepack": "node pack.mjs",
-    "smoke": "node smoke.mjs"
+    "smoke": "node smoke.mjs",
+    "test:wired": "node wired-tools.test.mjs"
   },
   "keywords": [
     "mcp",
@@ -25,7 +27,16 @@
     "measurement",
     "ed25519",
     "provenance",
-    "ai-governance"
+    "ai-governance",
+    "AI governance",
+    "model safety",
+    "EU AI Act",
+    "agent verification",
+    "model-safety",
+    "eu-ai-act",
+    "agent-verification",
+    "x402",
+    "attestation"
   ],
   "license": "Apache-2.0",
   "homepage": "https://councilof.ai",

package/paid-tools.json

@@ -0,0 +1,84 @@
+{
+  "schema": "csoai.gspc-mcp-paid-tools/1",
+  "note": "PAID tools on the MCP doors. Each wraps one x402-metered Pages route. Unpaid, the tool returns the route's 402 challenge as structuredContent (accepts[], PAYMENT-REQUIRED) so an MCP client pays from its own wallet and calls again with x_payment. Payment travels as the x_payment ARGUMENT, not as a transport header, so the stdio server (mcp/gspc-server, npm csoai-gspc-mcp >= 0.2.0) carries these too: it forwards the argument verbatim as the X-PAYMENT header on one request to councilof.ai and never inspects, signs or invents a receipt. Before 0.2.0 the stdio server carried only the seven free tools; that was a packaging choice, never a limit of the transport. Every deliverable is measurement, not certification; no tool here carries or awards a trust label of any kind, and the catalogue is free. Amounts appear only inside a 402 challenge, never here.",
+  "doctrine": "measurement, not certification",
+  "tools": [
+    {
+      "name": "commission_card",
+      "description": "PAID (x402). Commission one signed card-v0 receipt (surface ras.commission) for a named subject on the frozen bank via https://councilof.ai/api/request-attestation. Re-serves every signed measurement card already on file for the subject; a payment never mints a MEASURED cell (fresh_run stays UNMEASURED until a published run exists). Without x_payment the tool returns the 402 challenge (accepts[] with asset, amount, payTo) plus a free preview of the cards already on file. Measurement, not certification — never a rank, a grade or a certificate. Verification stays free.",
+      "inputSchema": {
+        "type": "object",
+        "properties": {
+          "subject": { "type": "string", "description": "Subject to commission: a model id, instrument id or card sha (1-120 chars of [A-Za-z0-9._:/@+-])." },
+          "axis": { "type": "string", "description": "Optional axis slug; omit for the subject-level commission." },
+          "x_payment": { "type": "string", "description": "The X-PAYMENT header value (base64 x402 payload) signed by your wallet against accepts[] from the previous 402. Omit to receive the challenge." }
+        },
+        "required": ["subject"],
+        "additionalProperties": false
+      },
+      "csoai": { "paid": true, "rail": "x402", "route": "/api/request-attestation", "sku": "request_attestation", "free_preview": "the 402 body (csoai.preview)", "deliverable": "one card-v0 leaf, surface ras.commission, Ed25519 when the Pages key is present" }
+    },
+    {
+      "name": "art50_marking_evidence",
+      "description": "PAID (x402 or CSOAI LTD invoice). Article 50 marking-evidence pack via https://councilof.ai/api/art50/marking-evidence: is a machine-readable mark DETECTABLE in these bytes right now (C2PA manifest store, assertion hashes, hard binding, claim signature; IPTC digitalSourceType), beside the verbatim Art 50(2) excerpt hash and the Art 99(4) ceiling. Watermarks are UNCHECKABLE where no public detector exists and the pack says so. Point-in-time detection — never a conformity opinion, never a compliance word of any kind. preview=true is free and returns the same measurement unsigned. Without x_payment the tool returns the 402 challenge. If the route is not deployed on this origin the tool says NOT_DEPLOYED rather than inventing a result.",
+      "inputSchema": {
+        "type": "object",
+        "properties": {
+          "url": { "type": "string", "description": "Public http(s) URL of the generative output to measure (≤20 MiB)." },
+          "bytes_b64": { "type": "string", "description": "Alternatively the output bytes, base64 (≤20 MiB decoded)." },
+          "manifest_b64": { "type": "string", "description": "Alternatively a detached C2PA manifest store, base64 (manifest-only mode)." },
+          "preview": { "type": "boolean", "description": "true = free unsigned measurement (no card sha, no signature)." },
+          "x_payment": { "type": "string", "description": "The X-PAYMENT header value signed against accepts[] from the previous 402. Omit to receive the challenge." }
+        },
+        "additionalProperties": false
+      },
+      "csoai": { "paid": true, "rail": "x402-or-invoice", "route": "/api/art50/marking-evidence", "sku": "art50_marking_evidence", "free_preview": "preview=true", "deliverable": "one card-v0 leaf, surface art50.marking-evidence, kind csoai.art50.marking-evidence/0.1", "deployed_by": "live on councilof.ai (verified 2026-09-03)" }
+    },
+    {
+      "name": "rwa_evidence",
+      "description": "PAID (x402). Per-request signed evidence card of ONE XRPL issued asset's deterministic on-ledger state via https://councilof.ai/api/rwa/evidence: AccountRoot lsf* flags, Domain, the two-way xrp-ledger.toml check (PASS / FAIL / UNCHECKABLE — unreachable is never FAIL), gateway_balances obligation, holders as the free reader has them, every raw fetch sha256'd. preview=true is free (unsigned state). Historical state at fetched_at — not a rating, not a guarantee, not a conformity mark; /api/xrpl and /root.json stay free. Without x_payment the tool returns the 402 challenge. If the route is not deployed on this origin the tool says NOT_DEPLOYED.",
+      "inputSchema": {
+        "type": "object",
+        "properties": {
+          "asset": { "type": "string", "description": "Symbol (as listed by https://councilof.ai/api/xrpl) or issuer r-address." },
+          "preview": { "type": "boolean", "description": "true = free unsigned state." },
+          "x_payment": { "type": "string", "description": "The X-PAYMENT header value signed against accepts[] from the previous 402. Omit to receive the challenge." }
+        },
+        "required": ["asset"],
+        "additionalProperties": false
+      },
+      "csoai": { "paid": true, "rail": "x402", "route": "/api/rwa/evidence", "sku": "rwa_evidence", "free_preview": "preview=true", "deliverable": "one card-v0 leaf, surface public.notice, kind csoai.eater.xrpl-issuer/0.1", "deployed_by": "live on councilof.ai (verified 2026-09-03)" }
+    },
+    {
+      "name": "witness_hash",
+      "description": "PAID (x402 or CSOAI LTD invoice). Witness a SHA-256 digest — 'attest what you're shown' — via https://councilof.ai/api/witness: one public.notice leaf (csoai.witness.hash/0.1) in the next hourly signed public root, an RFC-3161 timestamp over the digest, and the root's Rekor + OpenTimestamps anchors. Hash-only: name a digest, or a public URL fetched once (robots honoured, never past a login, paywall or bot check → UNCHECKABLE, nothing charged). Attests existence of the digest at the root's as_of — nothing about content, legality or provenance; a self-signed card carries no legal presumption. Measurement, not certification. Status is free at /api/witness/status. Without x_payment the tool returns the 402 challenge. If the route is not deployed on this origin the tool says NOT_DEPLOYED.",
+      "inputSchema": {
+        "type": "object",
+        "properties": {
+          "sha256": { "type": "string", "pattern": "^[0-9a-f]{64}$", "description": "The digest to witness (64 lowercase hex). Or pass url." },
+          "url": { "type": "string", "description": "Optional public https URL, fetched once with our UA, hashed, never stored." },
+          "label": { "type": "string", "description": "Optional label (≤120 chars, no verdict words); appears on the leaf." },
+          "x_payment": { "type": "string", "description": "The X-PAYMENT header value signed against accepts[] from the previous 402. Omit to receive the challenge." }
+        },
+        "additionalProperties": false
+      },
+      "csoai": { "paid": true, "rail": "x402-or-invoice", "route": "/api/witness", "sku": "witness_hash", "free_status": "/api/witness/status?sha256=", "deliverable": "one public.notice leaf in the next hourly root + RFC-3161 reply + Rekor/OTS anchors", "deployed_by": "live on councilof.ai (verified 2026-09-03)" }
+    },
+    {
+      "name": "receipts_batch",
+      "description": "PAID (x402 or CSOAI LTD invoice). A historical batch of the estate's measurement receipts via https://councilof.ai/api/receipts/batch: every signed card-v0 leaf whose as_of falls in [from,to] (≤200), each with its Merkle inclusion path and the public root(s) that carried it, plus the root index for the window and one signed manifest card citing the batch sha256. preview=true is free and returns count, span, root count and the sha256 of the exact bytes the paid call returns. Recent leaves are free at /root.json, /cards/ and /api/proof?sha= — the batch sells assembly across history, never a conclusion. No settlement-receipt stream exists (/api/receipts/latest is UNPUBLISHED) and this tool never claims one. Without x_payment the tool returns the 402 challenge.",
+      "inputSchema": {
+        "type": "object",
+        "properties": {
+          "from": { "type": "string", "description": "Window start, ISO-8601. Required." },
+          "to": { "type": "string", "description": "Window end, ISO-8601. Defaults to now." },
+          "preview": { "type": "boolean", "description": "true = free: count, span, roots and batch sha256 without the leaves." },
+          "x_payment": { "type": "string", "description": "The X-PAYMENT header value signed against accepts[] from the previous 402. Omit to receive the challenge." }
+        },
+        "required": ["from"],
+        "additionalProperties": false
+      },
+      "csoai": { "paid": true, "rail": "x402-or-invoice", "route": "/api/receipts/batch", "sku": "receipts_batch", "free_preview": "preview=true", "deliverable": "csoai.receipts.batch/0.1 + one signed manifest card-v0 (surface receipts.batch)" }
+    }
+  ]
+}

package/verify-card.mjs

@@ -95,21 +95,17 @@ const unhex = (s) => Uint8Array.from(s.match(/../g).map((b) => parseInt(b, 16)))
  *   2. ensure_ascii=False: non-ASCII stays literal (JS JSON.stringify does this), whereas
  *      v1 escapes to \\uXXXX (CPython ensure_ascii=True).
  *   3. Same key-sort + compact separators + escape of quote/backslash/control chars.
- * Matches harness/arena/jcs.py (Python) and the conformance corpus in
- * harness/arena/jcs_conformance.py (18/18 ordinary cases agree cross-language).
+ * Matches harness/arena/jcs.py (Python ES6 NumberToString, not repr).
+ * Conformance: jcs_conformance.py including 1e-6 / 1e-7 / 1e21 / -0.
  */
 function canonicalJcs(value, key = null) {
   if (value === null) return "null";
   if (typeof value === "boolean") return value ? "true" : "false";
   if (typeof value === "number") {
     if (!Number.isFinite(value)) throw new Error(`non-finite number at ${key}`);
-    // JCS/ECMAScript: integral floats in [10^-6, 10^21) emit as integers; -0 -> "0".
-    if (Number.isInteger(value) && value !== 0) {
-      const av = Math.abs(value);
-      if (av >= 1e-6 && av < 1e21) return String(value);
-    }
-    if (value === 0) return "0"; // covers -0.0
-    return String(value);
+    // RFC 8785: ES6 Number.prototype.toString. ToString(−0) is "0". Not JSON.stringify
+    // (that maps NaN/∞ to null — already rejected above). Not CPython json.dumps (0.0).
+    return Number.prototype.toString.call(value);
   }
   if (typeof value === "string") return jcsString(value);
   if (Array.isArray(value)) return "[" + value.map((v) => canonicalJcs(v, key)).join(",") + "]";