xytara 3.1.13 → 3.1.15

package/scripts/buyer_events_daily_report.js

@@ -0,0 +1,79 @@
+"use strict";
+
+// Daily buyer-journey report: reads the operator-only failure summary from the live runtime and
+// prints it as Markdown (to $GITHUB_STEP_SUMMARY when run in Actions). Exits 1 — so GitHub emails
+// the workflow owner — when money moved without a delivered result, or when failures that are OUR
+// fault exceed the threshold. Exits 0 with a notice when no operator token is configured.
+//
+// Usage: XYTARA_OPERATOR_READ_BEARER=... node scripts/buyer_events_daily_report.js [--days 1]
+// Env: XYTARA_URL (default https://xytara.onrender.com), BUYER_EVENTS_OURS_THRESHOLD (default 0).
+
+const fs = require("fs");
+
+function formatReport(summary, events, baseUrl) {
+  const t = summary.totals || {};
+  const lines = [
+    `## naxytra buyer journey — last ${summary.window_days} day(s)`,
+    "",
+    `Runtime: ${baseUrl} · generated ${summary.generated_at_iso}`,
+    "",
+    "| Paid calls served | 402 challenges | Failures | Our fault | Upstream | Buyer-side | Money moved, nothing delivered |",
+    "|---:|---:|---:|---:|---:|---:|---:|",
+    `| ${t.paid_ok || 0} | ${t.challenges_issued || 0} | ${t.failures || 0} | ${t.ours || 0} | ${t.upstream || 0} | ${t.buyer || 0} | ${t.money_moved || 0} |`,
+    ""
+  ];
+  const reasons = Array.isArray(summary.top_reasons) ? summary.top_reasons : [];
+  if (reasons.length) {
+    lines.push("### Top failure reasons", "", "| Service | Stage | Reason | Fault | Count |", "|---|---|---|---|---:|");
+    for (const r of reasons.slice(0, 15)) lines.push(`| ${r.service} | ${r.stage} | ${r.reason} | ${r.fault} | ${r.count} |`);
+    lines.push("");
+  }
+  const notable = (Array.isArray(events) ? events : []).filter((e) => e.money_moved || e.fault === "ours").slice(0, 20);
+  if (notable.length) {
+    lines.push("### Needs a look (money moved or our fault)", "", "| When (UTC) | Service | Route / tool | Reason | Request id |", "|---|---|---|---|---|");
+    for (const e of notable) lines.push(`| ${e.at_iso} | ${e.service} | ${e.task_or_tool || e.route || ""} | ${e.reason}${e.money_moved ? " (money moved)" : ""} | ${e.request_id || ""} |`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+async function main() {
+  const token = String(process.env.XYTARA_OPERATOR_READ_BEARER || "").trim();
+  const baseUrl = String(process.env.XYTARA_URL || "https://xytara.onrender.com").replace(/\/+$/, "");
+  const daysArg = process.argv.indexOf("--days");
+  const days = daysArg > -1 ? Number(process.argv[daysArg + 1]) || 1 : 1;
+  const out = (text) => {
+    if (process.env.GITHUB_STEP_SUMMARY) fs.appendFileSync(process.env.GITHUB_STEP_SUMMARY, `${text}\n`);
+    console.log(text);
+  };
+  if (!token) {
+    out("Buyer journey report skipped: set the XYTARA_OPERATOR_READ_BEARER secret to enable it.");
+    return;
+  }
+  const headers = { authorization: `Bearer ${token}` };
+  // The runtime may be asleep on a free tier: allow for a cold start.
+  const get = async (path) => {
+    const res = await fetch(`${baseUrl}${path}`, { headers, signal: AbortSignal.timeout(90000) });
+    if (!res.ok) throw new Error(`${path} -> HTTP ${res.status}`);
+    return res.json();
+  };
+  const since = new Date(Date.now() - days * 86400000).toISOString();
+  const summary = await get(`/v1/operator/buyer-events/summary?days=${days}`);
+  const listed = await get(`/v1/operator/buyer-events?since=${encodeURIComponent(since)}&limit=200`);
+  out(formatReport(summary, listed.events, baseUrl));
+  const threshold = Number(process.env.BUYER_EVENTS_OURS_THRESHOLD || 0);
+  const totals = summary.totals || {};
+  if ((totals.money_moved || 0) > 0 || (totals.ours || 0) > threshold) {
+    console.error(`ATTENTION: money_moved=${totals.money_moved || 0}, our-fault failures=${totals.ours || 0} (threshold ${threshold}).`);
+    process.exit(1);
+  }
+}
+
+if (require.main === module) {
+  main().catch((error) => {
+    console.error(`Buyer journey report failed: ${error && error.message ? error.message : error}`);
+    process.exit(1);
+  });
+}
+
+module.exports = { formatReport };

package/scripts/state_backup_offsite.js

@@ -0,0 +1,196 @@
+#!/usr/bin/env node
+"use strict";
+
+// Off-site, encrypted backups of the runtime's durable state (the Supabase snapshot row).
+//
+//   backup  <out_dir>                 read the live row, sanity-check it, gzip + AES-256-GCM encrypt
+//                                     it, verify the ciphertext decrypts back, write <out_dir>/
+//                                     xytara-state-<persisted>.enc + manifest.json (no secrets)
+//   decrypt <file.enc> <out.json>     decrypt a backup to the plain row { state_key, persisted_at_iso,
+//                                     snapshot }
+//   restore <file.enc> --runtime-stopped [--state-key k]
+//                                     write a decrypted backup back as the live row. ONLY with the
+//                                     runtime stopped (suspended on Render): a running runtime would
+//                                     overwrite it with its in-memory state on the next flush.
+//   selftest                          offline round-trip check (used by verify:all)
+//
+// Env: XYTARA_SUPABASE_URL, XYTARA_SUPABASE_SERVICE_ROLE_KEY, XYTARA_SUPABASE_STATE_TABLE
+// (default xytara_runtime_state), XYTARA_SUPABASE_STATE_KEY (default "default"), STATE_BACKUP_KEY
+// (base64, 32 bytes — keep a copy OFF this system: without it no backup can be decrypted),
+// STATE_BACKUP_MIN_PROVIDERS (default 1), STATE_BACKUP_MIN_BYTES (default 10000).
+// The snapshot contains secrets (provider owner secrets, auth tokens): it is only ever written
+// encrypted, and the manifest carries counts and digests only.
+
+const crypto = require("crypto");
+const fs = require("fs");
+const path = require("path");
+const zlib = require("zlib");
+
+const ENVELOPE_VERSION = "xytara-state-backup/1";
+
+function fail(message) {
+  console.error(`state backup: ${message}`);
+  process.exit(1);
+}
+
+function backupKey() {
+  const raw = String(process.env.STATE_BACKUP_KEY || "").trim();
+  if (!raw) fail("STATE_BACKUP_KEY is not set");
+  const key = Buffer.from(raw, "base64");
+  if (key.length !== 32) fail("STATE_BACKUP_KEY must be 32 bytes, base64-encoded");
+  return key;
+}
+
+function encrypt(rowJson, key) {
+  const plaintext = zlib.gzipSync(Buffer.from(rowJson, "utf8"), { level: 9 });
+  const iv = crypto.randomBytes(12);
+  const cipher = crypto.createCipheriv("aes-256-gcm", key, iv);
+  cipher.setAAD(Buffer.from(ENVELOPE_VERSION, "utf8"));
+  const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+  return {
+    v: ENVELOPE_VERSION,
+    alg: "AES-256-GCM",
+    compression: "gzip",
+    iv: iv.toString("base64"),
+    tag: cipher.getAuthTag().toString("base64"),
+    plaintext_sha256: crypto.createHash("sha256").update(rowJson, "utf8").digest("hex"),
+    ciphertext: ciphertext.toString("base64")
+  };
+}
+
+function decrypt(envelope, key) {
+  if (!envelope || envelope.v !== ENVELOPE_VERSION) throw new Error("not a xytara state backup envelope");
+  const decipher = crypto.createDecipheriv("aes-256-gcm", key, Buffer.from(envelope.iv, "base64"));
+  decipher.setAAD(Buffer.from(ENVELOPE_VERSION, "utf8"));
+  decipher.setAuthTag(Buffer.from(envelope.tag, "base64"));
+  const plaintext = Buffer.concat([decipher.update(Buffer.from(envelope.ciphertext, "base64")), decipher.final()]);
+  const rowJson = zlib.gunzipSync(plaintext).toString("utf8");
+  if (crypto.createHash("sha256").update(rowJson, "utf8").digest("hex") !== envelope.plaintext_sha256) {
+    throw new Error("decrypted content digest mismatch");
+  }
+  return rowJson;
+}
+
+function entryCount(value) {
+  if (value && value.__runtime_state_kind && Array.isArray(value.value)) return value.value.length;
+  if (Array.isArray(value)) return value.length;
+  return value && typeof value === "object" ? Object.keys(value).length : 0;
+}
+
+function summarize(row, rowJson) {
+  const snapshot = row.snapshot || {};
+  const counts = {};
+  for (const key of ["providerRegistry", "providerSettlementLedger", "providerPayouts", "externalCreditGrants", "accountSpendCredentials", "transactions", "deliveryReceipts", "quotes"]) {
+    if (snapshot[key] !== undefined) counts[key] = entryCount(snapshot[key]);
+  }
+  return { state_key: row.state_key, persisted_at_iso: row.persisted_at_iso, snapshot_bytes: Buffer.byteLength(JSON.stringify(snapshot), "utf8"), row_bytes: Buffer.byteLength(rowJson, "utf8"), section_count: Object.keys(snapshot).length, counts };
+}
+
+function supabaseConfig() {
+  const url = String(process.env.XYTARA_SUPABASE_URL || "").trim().replace(/\/+$/, "");
+  const serviceKey = String(process.env.XYTARA_SUPABASE_SERVICE_ROLE_KEY || "").trim();
+  if (!url || !serviceKey) fail("XYTARA_SUPABASE_URL and XYTARA_SUPABASE_SERVICE_ROLE_KEY are required");
+  return {
+    url,
+    serviceKey,
+    table: String(process.env.XYTARA_SUPABASE_STATE_TABLE || "xytara_runtime_state").trim(),
+    stateKey: String(process.env.XYTARA_SUPABASE_STATE_KEY || "default").trim()
+  };
+}
+
+async function fetchRow(cfg) {
+  const endpoint = `${cfg.url}/rest/v1/${encodeURIComponent(cfg.table)}?state_key=eq.${encodeURIComponent(cfg.stateKey)}&select=state_key,snapshot,persisted_at_iso&limit=1`;
+  let lastError = null;
+  for (let attempt = 1; attempt <= 4; attempt += 1) {
+    try {
+      const response = await fetch(endpoint, {
+        headers: { apikey: cfg.serviceKey, authorization: `Bearer ${cfg.serviceKey}` },
+        signal: AbortSignal.timeout(45000)
+      });
+      if (!response.ok) throw new Error(`HTTP ${response.status}: ${(await response.text()).slice(0, 200)}`);
+      const rows = await response.json();
+      if (!Array.isArray(rows) || !rows[0]) throw new Error(`no row for state_key "${cfg.stateKey}"`);
+      return rows[0];
+    } catch (error) {
+      lastError = error;
+      if (attempt < 4) await new Promise((resolve) => setTimeout(resolve, attempt * 15000));
+    }
+  }
+  throw lastError;
+}
+
+async function backup(outDir) {
+  if (!outDir) fail("usage: backup <out_dir>");
+  const key = backupKey();
+  const row = await fetchRow(supabaseConfig()).catch((error) => fail(`could not read the state row: ${error.message}`));
+  const rowJson = JSON.stringify(row);
+  const summary = summarize(row, rowJson);
+  // Sanity gate: a near-empty snapshot means something already went wrong — fail loudly (the
+  // failed scheduled run is the alert) instead of quietly storing an empty backup.
+  const minProviders = Number(process.env.STATE_BACKUP_MIN_PROVIDERS || 1);
+  const minBytes = Number(process.env.STATE_BACKUP_MIN_BYTES || 10000);
+  if ((summary.counts.providerRegistry || 0) < minProviders) fail(`snapshot has ${summary.counts.providerRegistry || 0} providers (< ${minProviders}): refusing to treat it as healthy`);
+  if (summary.snapshot_bytes < minBytes) fail(`snapshot is only ${summary.snapshot_bytes} bytes (< ${minBytes}): refusing to treat it as healthy`);
+  const envelope = encrypt(rowJson, key);
+  if (decrypt(envelope, key) !== rowJson) fail("round-trip check failed");
+  fs.mkdirSync(outDir, { recursive: true });
+  const stamp = String(row.persisted_at_iso || new Date().toISOString()).replace(/[^0-9A-Za-z]/g, "").slice(0, 15);
+  const fileName = `xytara-state-${stamp}.enc`;
+  fs.writeFileSync(path.join(outDir, fileName), JSON.stringify(envelope));
+  const manifest = { v: ENVELOPE_VERSION, file: fileName, created_at_iso: new Date().toISOString(), plaintext_sha256: envelope.plaintext_sha256, ...summary };
+  fs.writeFileSync(path.join(outDir, "manifest.json"), JSON.stringify(manifest, null, 2));
+  console.log(JSON.stringify(manifest, null, 2));
+}
+
+function decryptCommand(inFile, outFile) {
+  if (!inFile || !outFile) fail("usage: decrypt <file.enc> <out.json>");
+  const rowJson = decrypt(JSON.parse(fs.readFileSync(inFile, "utf8")), backupKey());
+  fs.writeFileSync(outFile, rowJson);
+  console.log(JSON.stringify(summarize(JSON.parse(rowJson), rowJson), null, 2));
+}
+
+async function restoreCommand(inFile, args) {
+  if (!inFile || !args.includes("--runtime-stopped")) {
+    fail("usage: restore <file.enc> --runtime-stopped [--state-key k]  (suspend the runtime first, or it will overwrite the restored row)");
+  }
+  const cfg = supabaseConfig();
+  const keyIndex = args.indexOf("--state-key");
+  const stateKey = keyIndex >= 0 && args[keyIndex + 1] ? args[keyIndex + 1] : cfg.stateKey;
+  const row = JSON.parse(decrypt(JSON.parse(fs.readFileSync(inFile, "utf8")), backupKey()));
+  const response = await fetch(`${cfg.url}/rest/v1/${encodeURIComponent(cfg.table)}?on_conflict=state_key`, {
+    method: "POST",
+    headers: { apikey: cfg.serviceKey, authorization: `Bearer ${cfg.serviceKey}`, "content-type": "application/json", prefer: "resolution=merge-duplicates,return=minimal" },
+    body: JSON.stringify([{ state_key: stateKey, snapshot: row.snapshot, persisted_at_iso: row.persisted_at_iso }]),
+    signal: AbortSignal.timeout(60000)
+  });
+  if (!response.ok) fail(`restore write failed: HTTP ${response.status}`);
+  console.log(`restored ${row.state_key}@${row.persisted_at_iso} into state_key "${stateKey}". Resume the runtime now.`);
+}
+
+function selftest() {
+  const key = crypto.randomBytes(32);
+  const row = { state_key: "default", persisted_at_iso: "2026-10-17T00:00:00.000Z", snapshot: { providerRegistry: { __runtime_state_kind: "Map", value: [["p", { status: "active", owner_secret: "prvown_x" }]] } } };
+  const rowJson = JSON.stringify(row);
+  const envelope = encrypt(rowJson, key);
+  if (decrypt(envelope, key) !== rowJson) fail("selftest: round trip mismatch");
+  if (JSON.stringify(envelope).includes("prvown_x")) fail("selftest: plaintext secret visible in the envelope");
+  let wrongKeyRejected = false;
+  try { decrypt(envelope, crypto.randomBytes(32)); } catch (_) { wrongKeyRejected = true; }
+  if (!wrongKeyRejected) fail("selftest: a wrong key decrypted the backup");
+  const tampered = { ...envelope, ciphertext: Buffer.from(Buffer.from(envelope.ciphertext, "base64").map((b, i) => (i === 0 ? b ^ 1 : b))).toString("base64") };
+  let tamperRejected = false;
+  try { decrypt(tampered, key); } catch (_) { tamperRejected = true; }
+  if (!tamperRejected) fail("selftest: tampered ciphertext was accepted");
+  console.log("xytara state-backup selftest passed (round trip, no plaintext secrets, wrong key + tamper rejected)");
+}
+
+async function main() {
+  const [command, ...args] = process.argv.slice(2);
+  if (command === "backup") return backup(args[0]);
+  if (command === "decrypt") return decryptCommand(args[0], args[1]);
+  if (command === "restore") return restoreCommand(args[0], args);
+  if (command === "selftest") return selftest();
+  fail("usage: state_backup_offsite.js backup <out_dir> | decrypt <file.enc> <out.json> | restore <file.enc> --runtime-stopped | selftest");
+}
+
+main().catch((error) => fail(error && error.message ? error.message : String(error)));

package/scripts/verify_a2a_rpc.js

@@ -1,105 +1,131 @@
-"use strict";
-
-// Verifies the A2A JSON-RPC endpoint with the in-band x402 payment extension
-// (lib/a2a_rpc.js). The facilitator verify/settle and the command executor are
-// injected as mocks so this runs offline and moves no money.
-
-const assert = require("assert");
-const {
-  handleA2ARpc,
-  META_PAYLOAD,
-  META_STATUS,
-  META_REQUIRED
-} = require("../lib/a2a_rpc");
-
-const accepts = [
-  { scheme: "exact", network: "eip155:84532", asset: "0xUSDC", amount: "1000", payTo: "0xPAYTO", extra: { name: "USDC", version: "2" } }
-];
-const config = { verification_mode: "x402_facilitator", x402: { accepts, facilitator_url: "https://facilitator", settle: true } };
-
-function deps(overrides) {
-  return Object.assign(
-    {
-      createFacilitator: () => ({}),
-      verifyX402Payment: async () => ({ ok: true, authorization: { payer: "0xPAYER", paymentRequirements: accepts[0] } }),
-      settleX402Payment: async () => ({ ok: true, settlement: { success: true, transaction: "0xTX", network: "eip155:84532" } }),
-      encodeReceipt: (s) => Buffer.from(JSON.stringify(s), "utf8").toString("base64"),
-      executeAuthorized: async (state, payload, authz) => ({ status: 200, payload: { ok: true, ran: payload.task_ref, azmode: authz.verification_mode } }),
-      buildNamedTaskPayload: (ref, body) => ({ command: ref, task_ref: ref, body }),
-      state: {}
-    },
-    overrides || {}
-  );
-}
-
-function send(params, ctxOverrides) {
-  return handleA2ARpc(
-    { jsonrpc: "2.0", id: 1, method: "message/send", params },
-    Object.assign({ config, resourceUrl: "https://xytara.onrender.com/v1/a2a", deps: deps() }, ctxOverrides || {})
-  );
-}
-
-async function main() {
-  // 1. Unpaid -> input-required + x402 requirements in-band.
-  let out = await send({ message: { metadata: { task_ref: "a2a.negotiate" } } });
-  assert.strictEqual(out.http, 200);
-  assert.strictEqual(out.body.result.status.state, "input-required");
-  assert.strictEqual(out.body.result.status.message.metadata[META_STATUS], "payment-required");
-  assert.deepStrictEqual(out.body.result.status.message.metadata[META_REQUIRED].accepts, accepts);
-
-  // 2. Paid -> completed + PAYMENT-RESPONSE + executed through the x402 authz context.
-  out = await send({ message: { metadata: { task_ref: "a2a.negotiate", [META_PAYLOAD]: "BASE64PAYLOAD" } } });
-  assert.strictEqual(out.body.result.status.state, "completed");
-  assert.strictEqual(out.body.result.status.message.metadata[META_STATUS], "payment-completed");
-  assert.ok(out.headers && out.headers["PAYMENT-RESPONSE"], "settled 200 must carry PAYMENT-RESPONSE");
-  assert.strictEqual(out.body.result.artifacts[0].parts[0].data.ran, "a2a.negotiate");
-  assert.strictEqual(out.body.result.artifacts[0].parts[0].data.azmode, "x402_facilitator");
-
-  // 2b. Paid but the skill execution fails -> task is reported "failed" (not
-  // "completed"), still carries the settlement receipt (money moved).
-  out = await send(
-    { message: { metadata: { task_ref: "a2a.negotiate", [META_PAYLOAD]: "B64" } } },
-    { deps: deps({ executeAuthorized: async () => ({ status: 500, payload: { ok: false, reason: "boom" } }) }) }
-  );
-  assert.strictEqual(out.body.result.status.state, "failed");
-  assert.strictEqual(out.body.result.status.message.metadata[META_STATUS], "payment-completed");
-  assert.ok(out.headers && out.headers["PAYMENT-RESPONSE"], "failed-after-payment still carries receipt");
-  assert.strictEqual(out.body.result.artifacts.length, 0);
-
-  // 3. Verify fails -> payment-rejected.
-  out = await send(
-    { message: { metadata: { [META_PAYLOAD]: "BAD" } } },
-    { deps: deps({ verifyX402Payment: async () => ({ ok: false, reason: "payment_verification_failed", detail: "insufficient_balance" }) }) }
-  );
-  assert.strictEqual(out.body.result.status.state, "failed");
-  assert.strictEqual(out.body.result.status.message.metadata[META_STATUS], "payment-rejected");
-
-  // 4. Settle fails -> payment-failed.
-  out = await send(
-    { message: { metadata: { [META_PAYLOAD]: "OK" } } },
-    { deps: deps({ settleX402Payment: async () => ({ ok: false, reason: "payment_settlement_failed", detail: "facilitator" }) }) }
-  );
-  assert.strictEqual(out.body.result.status.message.metadata[META_STATUS], "payment-failed");
-
-  // 5. Unknown method -> -32601.
-  out = await handleA2ARpc({ jsonrpc: "2.0", id: 9, method: "tasks/cancel" }, { config, resourceUrl: "x", deps: deps() });
-  assert.strictEqual(out.body.error.code, -32601);
-
-  // 6. x402 mode off -> -32010.
-  out = await handleA2ARpc(
-    { jsonrpc: "2.0", id: 9, method: "message/send", params: { message: {} } },
-    { config: { verification_mode: "local_signed", x402: { accepts } }, resourceUrl: "x", deps: deps() }
-  );
-  assert.strictEqual(out.body.error.code, -32010);
-
-  // 7. Non-2.0 envelope -> -32600.
-  out = await handleA2ARpc({ id: 1, method: "message/send" }, { config, resourceUrl: "x", deps: deps() });
-  assert.strictEqual(out.body.error.code, -32600);
-
-  console.log("verify_a2a_rpc: all A2A x402 JSON-RPC checks passed");
-}
-
-main().catch((error) => {
-  console.error("verify_a2a_rpc failed:", error && error.message ? error.message : error);
-  process.exitCode = 1;
-});
+"use strict";
+
+// Verifies the A2A JSON-RPC endpoint with the in-band x402 payment extension
+// (lib/a2a_rpc.js). The facilitator verify/settle and the command executor are
+// injected as mocks so this runs offline and moves no money.
+
+const assert = require("assert");
+const {
+  handleA2ARpc,
+  META_PAYLOAD,
+  META_STATUS,
+  META_REQUIRED,
+  META_ERROR
+} = require("../lib/a2a_rpc");
+
+const accepts = [
+  { scheme: "exact", network: "eip155:84532", asset: "0xUSDC", amount: "1000", payTo: "0xPAYTO", extra: { name: "USDC", version: "2" } }
+];
+const config = { verification_mode: "x402_facilitator", x402: { accepts, facilitator_url: "https://facilitator", settle: true } };
+
+function deps(overrides) {
+  return Object.assign(
+    {
+      createFacilitator: () => ({}),
+      verifyX402Payment: async () => ({ ok: true, authorization: { payer: "0xPAYER", paymentRequirements: accepts[0] } }),
+      settleX402Payment: async () => ({ ok: true, settlement: { success: true, transaction: "0xTX", network: "eip155:84532" } }),
+      encodeReceipt: (s) => Buffer.from(JSON.stringify(s), "utf8").toString("base64"),
+      executeAuthorized: async (state, payload, authz) => ({ status: 200, payload: { ok: true, ran: payload.task_ref, azmode: authz.verification_mode } }),
+      buildNamedTaskPayload: (ref, body) => ({ command: ref, task_ref: ref, body }),
+      state: {}
+    },
+    overrides || {}
+  );
+}
+
+function send(params, ctxOverrides) {
+  return handleA2ARpc(
+    { jsonrpc: "2.0", id: 1, method: "message/send", params },
+    Object.assign({ config, resourceUrl: "https://xytara.onrender.com/v1/a2a", deps: deps() }, ctxOverrides || {})
+  );
+}
+
+async function main() {
+  // 1. Unpaid -> input-required + x402 requirements in-band.
+  let out = await send({ message: { metadata: { task_ref: "a2a.negotiate" } } });
+  assert.strictEqual(out.http, 200);
+  assert.strictEqual(out.body.result.status.state, "input-required");
+  assert.strictEqual(out.body.result.status.message.metadata[META_STATUS], "payment-required");
+  assert.deepStrictEqual(out.body.result.status.message.metadata[META_REQUIRED].accepts, accepts);
+
+  // 2. Paid -> completed + PAYMENT-RESPONSE + executed through the x402 authz context.
+  out = await send({ message: { metadata: { task_ref: "a2a.negotiate", [META_PAYLOAD]: "BASE64PAYLOAD" } } });
+  assert.strictEqual(out.body.result.status.state, "completed");
+  assert.strictEqual(out.body.result.status.message.metadata[META_STATUS], "payment-completed");
+  assert.ok(out.headers && out.headers["PAYMENT-RESPONSE"], "settled 200 must carry PAYMENT-RESPONSE");
+  assert.strictEqual(out.body.result.artifacts[0].parts[0].data.ran, "a2a.negotiate");
+  assert.strictEqual(out.body.result.artifacts[0].parts[0].data.azmode, "x402_facilitator");
+
+  // 2b. Paid but the skill execution fails -> "failed", and the payment is NOT settled
+  // (verify -> execute -> settle: a failed skill never charges the paying agent).
+  let settleCalls = 0;
+  out = await send(
+    { message: { metadata: { task_ref: "a2a.negotiate", [META_PAYLOAD]: "B64" } } },
+    { deps: deps({
+      executeAuthorized: async () => ({ status: 500, payload: { ok: false, reason: "boom" } }),
+      settleX402Payment: async () => { settleCalls += 1; return { ok: true, settlement: { success: true } }; }
+    }) }
+  );
+  assert.strictEqual(out.body.result.status.state, "failed");
+  assert.strictEqual(out.body.result.status.message.metadata[META_STATUS], "not-charged");
+  assert.strictEqual(settleCalls, 0, "a failed skill must not be settled");
+  assert.ok(!(out.headers && out.headers["PAYMENT-RESPONSE"]), "nothing settled, so no receipt");
+  assert.strictEqual(out.body.result.artifacts.length, 0);
+
+  // 2c. A skill nothing can execute -> refused up front: no payment requested at all.
+  out = await send(
+    { message: { metadata: { task_ref: "a2a.negotiate" } } },
+    { deps: deps({ assessExecutability: () => ({ ok: false, payload: { reason: "capability_not_executable", detail: "no target", executable_task_refs: ["adapter.mcp.invoke"] } }) }) }
+  );
+  assert.strictEqual(out.body.result.status.state, "failed");
+  assert.strictEqual(out.body.result.status.message.metadata[META_STATUS], "not-required");
+  assert.ok(/adapter\.mcp\.invoke/.test(out.body.result.status.message.metadata[META_ERROR]), "the refusal names what IS executable");
+
+  // 2d. Settle times out but the authorization is used on-chain -> completed, not a lost payment.
+  out = await send(
+    { message: { metadata: { task_ref: "a2a.negotiate", [META_PAYLOAD]: "B64" } } },
+    { deps: deps({
+      verifyX402Payment: async () => ({ ok: true, authorization: { payer: "0xPAYER", paymentRequirements: accepts[0], paymentPayload: { payload: { authorization: { from: "0xPAYER", nonce: "0x01" } } } } }),
+      settleX402Payment: async () => ({ ok: false, reason: "facilitator_unreachable" }),
+      confirmAuthorizationUsed: async () => true
+    }) }
+  );
+  assert.strictEqual(out.body.result.status.state, "completed", "a settled-on-chain payment delivers despite the facilitator timeout");
+
+  // 3. Verify fails -> payment-rejected.
+  out = await send(
+    { message: { metadata: { [META_PAYLOAD]: "BAD" } } },
+    { deps: deps({ verifyX402Payment: async () => ({ ok: false, reason: "payment_verification_failed", detail: "insufficient_balance" }) }) }
+  );
+  assert.strictEqual(out.body.result.status.state, "failed");
+  assert.strictEqual(out.body.result.status.message.metadata[META_STATUS], "payment-rejected");
+
+  // 4. Settle fails -> payment-failed.
+  out = await send(
+    { message: { metadata: { [META_PAYLOAD]: "OK" } } },
+    { deps: deps({ settleX402Payment: async () => ({ ok: false, reason: "payment_settlement_failed", detail: "facilitator" }) }) }
+  );
+  assert.strictEqual(out.body.result.status.message.metadata[META_STATUS], "payment-failed");
+
+  // 5. Unknown method -> -32601.
+  out = await handleA2ARpc({ jsonrpc: "2.0", id: 9, method: "tasks/cancel" }, { config, resourceUrl: "x", deps: deps() });
+  assert.strictEqual(out.body.error.code, -32601);
+
+  // 6. x402 mode off -> -32010.
+  out = await handleA2ARpc(
+    { jsonrpc: "2.0", id: 9, method: "message/send", params: { message: {} } },
+    { config: { verification_mode: "local_signed", x402: { accepts } }, resourceUrl: "x", deps: deps() }
+  );
+  assert.strictEqual(out.body.error.code, -32010);
+
+  // 7. Non-2.0 envelope -> -32600.
+  out = await handleA2ARpc({ id: 1, method: "message/send" }, { config, resourceUrl: "x", deps: deps() });
+  assert.strictEqual(out.body.error.code, -32600);
+
+  console.log("verify_a2a_rpc: all A2A x402 JSON-RPC checks passed");
+}
+
+main().catch((error) => {
+  console.error("verify_a2a_rpc failed:", error && error.message ? error.message : error);
+  process.exitCode = 1;
+});