@wzrd_sol/eliza-plugin 0.3.2 → 0.5.0

package/README.md

@@ -1,14 +1,28 @@
 # @wzrd_sol/eliza-plugin
 
-ElizaOS plugin for WZRD Agent Intel — x402 firewall, free preflight checks before spends,
-paid trust receipts (V6 + ERC-8004), and the earn loop on Solana.
+ElizaOS plugin for **WZRD Agent Intel** on the Solana x402 marketplace:
+free pre-spend checks, free merchant graph card, paid V6 trust receipt, offline verify.
+Also ships the **legacy** AO/CCM earn loop against `api.twzrd.xyz`.
+
+## Buyer sequence (marketplace default)
+
+Before any x402 spend:
+
+1. **Free preflight** - `WZRD_INTEL_PREFLIGHT` / `preSpendGate` - ReadinessCard `allow` / `warn` / `block`
+2. **Free merchant_card** - `WZRD_MERCHANT_CARD` (or inside `preSpendGate`) - if `wash_flagged: true`, **do not pay** (default)
+3. **Optional paid trust** - `WZRD_INTEL_TRUST` (~0.05 USDC) - full score + **signed V6 receipt**
+4. **Offline verify** - `WZRD_VERIFY_RECEIPT`
+
+This plugin exposes **actions + SDK helpers**. It does **not** auto-intercept every wallet signature.
+Wire `preSpendGate` / actions into your spend path, or compose with standalone `twzrd-x402-gate` on a paying fetch.
 
 ## 3-line quickstart
 
 ```typescript
 import wzrdPlugin from '@wzrd_sol/eliza-plugin';
 const agent = new AgentRuntime({ plugins: [wzrdPlugin] });
-// "Preflight seller JUP6Lkb... at 0.25 USDC" → allow/warn/block, free, no wallet
+// "Preflight seller JUP6Lkb... at 0.25 USDC" -> allow/warn/block, free, no wallet
+// "Merchant card for GFpLvoc..." -> wash_flagged refuse default
 ```
 
 ## Install
@@ -17,21 +31,30 @@ const agent = new AgentRuntime({ plugins: [wzrdPlugin] });
 npm install @wzrd_sol/eliza-plugin
 ```
 
+## Which package?
+
+| Package | Role | Auto-gates every payment? |
+|---------|------|---------------------------|
+| **`@wzrd_sol/eliza-plugin`** (this) | Eliza actions: preflight, merchant_card, paid trust, verify; re-exports SDK `preSpendGate` | No - call-site / LLM actions |
+| **`@wzrd_sol/plugin-trustgate`** | Smaller Eliza provider + `canSpendSafely` (preflight only) | No - opt-in `canSpendSafely` |
+| **`twzrd-x402-gate`** | Framework-agnostic fetch wrapper (preflight + wash refuse on 402) | Only if you wrap fetch |
+
 ## Configuration
 
 | Variable | Required | Default | Description |
 |----------|----------|---------|-------------|
-| `WZRD_INTEL_URL` | No | `https://intel.twzrd.xyz` | Agent Intel API (preflight, trust, verify) |
-| `WZRD_API_URL` | No | `https://api.twzrd.xyz` | Earn API (infer/report/claim) |
-| `SOLANA_PRIVATE_KEY` | Earn lane only | — | JSON array of secret key bytes for agent Ed25519 auth |
+| `WZRD_INTEL_URL` | No | `https://intel.twzrd.xyz` | Agent Intel API (preflight, merchant_card, trust, verify) |
+| `WZRD_API_URL` | No | `https://api.twzrd.xyz` | Earn API (infer/report/claim) - legacy lane |
+| `SOLANA_PRIVATE_KEY` | Earn lane only | - | JSON array of secret key bytes for agent Ed25519 auth |
 
 ## Intel actions (primary)
 
 | Action | Auth/Pay | Description |
 |--------|----------|-------------|
 | `WZRD_INTEL_PREFLIGHT` | Free | ReadinessCard: `decision`, `trust_score`, `can_spend`, `caveats`, `preflight_id` |
-| `WZRD_INTEL_TRUST` | x402 (~0.05 USDC) | Paid trust payload + V6 signed receipt + ERC-8004 `reputation_credential` |
-| `WZRD_VERIFY_RECEIPT` | Free (offline) | Recompute leaf + Ed25519 verify; no network when pubkey is known |
+| `WZRD_MERCHANT_CARD` | Free | Graph card: `wash_flagged`, tier, catalog join; **default refuse if wash** |
+| `WZRD_INTEL_TRUST` | x402 (~0.05 USDC) | Paid trust payload + **V6** signed receipt + ERC-8004 `reputation_credential` |
+| `WZRD_VERIFY_RECEIPT` | Free (offline) | Recompute leaf + Ed25519 verify; V6 primary (older V5 still accepted) |
 
 ### Preflight (free, no wallet)
 
@@ -56,52 +79,78 @@ Decision: allow
 Trust score: 72
 Can spend: yes
 Preflight ID: pf_abc123
-Paid deep dive available (0.05 USDC) — use WZRD_INTEL_TRUST
+Paid deep dive available (0.05 USDC) - use WZRD_INTEL_TRUST
 ```
 
-### Guard pattern: fire-before-pay with `withTwzrdGuard`
-
-For agents that call x402-gated URLs directly (not via pre-known seller wallet), pair this
-plugin with `twzrd-x402-gate` to intercept 402s before any spend:
+### Merchant card (free wash / demand-quality gate)
 
 ```typescript
-import wzrdPlugin from '@wzrd_sol/eliza-plugin';
-import { withTwzrdGuard } from 'twzrd-x402-gate';
-import { createAgentcashFetch } from 'agentcash';
+import { merchantCardAction, fetchMerchantCard } from '@wzrd_sol/eliza-plugin';
 
-// Wrap the paying fetch — guard runs preflight on every 402 before USDC moves.
-const x402Fetch = createAgentcashFetch({ apiKey: process.env.AGENTCASH_API_KEY });
-const safeFetch = withTwzrdGuard(x402Fetch, {
-  autoReceipt: true,   // auto-buy $0.05 TWZRD receipt on warn/allow
-  x402Fetch,
-});
+// Action (LLM-callable):
+// "Merchant card for GFpLvocNdEjnSsLH3VJQL6wGcjGxTbUBrj6fqN3Qe1Gs"
 
-// Wire safeFetch into any tool or skill that calls paid resources:
-const response = await safeFetch('https://api.exa.ai/search');
-// → decision=block throws before payment
-// → decision=warn/allow: payment proceeds, TWZRD receipt captured
+// Programmatic:
+const card = await fetchMerchantCard(sellerPubkey);
+if (card?.wash_flagged) return 'refuse dirty pay_to';
+// card unreachable -> fail-open (do not invent wash); use preflight decision only
 ```
 
-Guard flow:
-1. `safeFetch` hits the resource, gets HTTP 402.
-2. `withTwzrdGuard` reads `accepts[0].payTo` (seller wallet).
-3. Calls `POST /v1/intel/preflight` — free, no auth.
-4. `block` - throws, no payment made.
-5. `warn/allow` - returns the 402 for the x402 client to pay.
+Catalog enrichment is listing metadata only - never overrides wash.
 
-### Pre-spend gate (programmatic)
+### Pre-spend gate (programmatic - both free checks)
 
 ```typescript
-import { preSpendGate, fetchIntelTrust } from '@wzrd_sol/eliza-plugin';
+import { preSpendGate, fetchIntelTrust, fetchMerchantCard } from '@wzrd_sol/eliza-plugin';
 
-// Gate before paying:
-const gate = await preSpendGate({ seller_wallet: sellerPubkey });
+// Free preflight + free merchant_card wash refuse (default on):
+const gate = await preSpendGate({ seller_wallet: sellerPubkey, price_usdc: 0.25 });
 if (!gate.allow) return `Blocked (${gate.decision}): ${gate.reason}`;
+// gate.washFlagged === true was refuse default; null = card gap (fail-open)
 
 // Then pay and get the receipt:
 const trust = await fetchIntelTrust(sellerPubkey, { fetchImpl: myX402Fetch });
 ```
 
+**Default:** `refuseWashFlagged: true` - if free `merchant_card.wash_flagged`, do not pay.
+Soft cap: `{ washMaxUsdc: 0.05 }`. Opt out: `{ refuseWashFlagged: false }`.
+
+### Guard pattern: fire-before-pay with `installTwzrdAutoGate` (default-on)
+
+For agents that call x402-gated URLs directly (not via a pre-known seller wallet), pair this
+plugin with standalone **`twzrd-x402-gate`** (separate package - not bundled here) to intercept
+402s before any spend — and register the result as the plugin's paying fetch in one call:
+
+```typescript
+import wzrdPlugin, { installTwzrdAutoGate } from '@wzrd_sol/eliza-plugin';
+import { wrapFetchWithPayment } from '@x402/svm';
+
+// Guards the raw fetch (free preflight + free merchant_card wash refuse), hands the guarded
+// fetch to your x402 client, registers the result as the module paying fetch — a blocked or
+// wash-flagged seller throws before your client ever signs.
+installTwzrdAutoGate((guarded) => wrapFetchWithPayment(guarded, buyerWallet));
+
+const agent = new AgentRuntime({ plugins: [wzrdPlugin] });
+// WZRD_INTEL_TRUST and any tool/skill using resolvePayingFetch() now goes through the guard.
+```
+
+`payWrap` (the function you pass in) receives the **guarded** fetch — the guard has already
+run by the time your client sees a 402. Building the composition the other way round (guarding
+an already-paying client, e.g. one that resolves 402s internally and returns 200) is a no-op;
+see `twzrd-x402-gate`'s Compatibility note. Opt out with `TWZRD_AUTO_GATE=0` (env) or
+`{ disabled: true }`.
+
+Guard flow (in `twzrd-x402-gate`, not inside this plugin):
+1. The raw fetch hits the resource, gets HTTP 402.
+2. The guard reads `accepts[0].payTo` (seller wallet).
+3. Free `POST /v1/intel/preflight` — `decision=block` / score floor throws, `payWrap`'s client never signs.
+4. Free `GET /v1/intel/merchant_card/{payTo}` — `wash_flagged:true` refuses by default (only tightens step 3).
+5. Otherwise returns the 402 to `payWrap`'s client, which pays normally.
+
+For manual composition (managing the raw/paying split yourself) or `autoReceipt`/`escalateOnWarn`
+options, use `withTwzrdGuard` from `twzrd-x402-gate` directly and pass the result to `setPayingFetch`
+— see that package's README.
+
 ### Paid trust receipt (agentcash)
 
 ```typescript
@@ -112,7 +161,7 @@ setPayingFetch(createAgentcashFetch({ apiKey: process.env.AGENTCASH_API_KEY }));
 
 const agent = new AgentRuntime({ plugins: [wzrdPlugin] });
 // "Get the trust receipt for seller JUP6LkbZ..."
-// → WZRD_INTEL_TRUST: runs free preflight, pays $0.05 USDC, returns VC
+// -> WZRD_INTEL_TRUST: free preflight + merchant_card, then pays $0.05 USDC, returns VC + V6 receipt
 ```
 
 ### Paid trust receipt (PayAI)
@@ -127,8 +176,9 @@ setPayingFetch((url, init) => payai.fetch(url, init));
 const agent = new AgentRuntime({ plugins: [wzrdPlugin] });
 ```
 
-Without a paying fetch, `WZRD_INTEL_TRUST` returns the HTTP 402 requirements and an
-`npx agentcash@latest fetch ...` one-liner to pay manually.
+Without a paying fetch, `WZRD_INTEL_TRUST` returns the HTTP 402 requirements and a
+manual pay one-liner. Caveat: `npx agentcash@latest fetch` has been a known-bad path
+for TWZRD paid trust (fee_payer slot); prefer a wired `setPayingFetch` client.
 
 **`WZRD_INTEL_TRUST` response fields:**
 
@@ -156,12 +206,20 @@ if (vc.distinctCounterparties < 3) return 'warn'; // thin history
 if (vc.washFactor < 0.5) return 'warn';           // suspicious ring
 ```
 
-`effectiveTrustScore` is the cross-facilitator wash-adjusted score — computed across all known
+`effectiveTrustScore` is the cross-facilitator wash-adjusted score - computed across all known
 x402 facilitators, not just one settlement path.
 
+### Facilitator settle attach (optional host pattern - not an Eliza action)
+
+If your x402 client uses TWZRD as facilitator (`https://intel.twzrd.xyz`), successful
+`POST /settle` may return `merchant_attach` + `twzrd_receipt` for the requirements `payTo`
+(best-effort; never voids on-chain settle). Discover via `GET /supported` (`twzrd.merchant_attach`).
+This plugin does not register a settle action - wire facilitator URL in the host payer.
+
 ### Example agent prompts (trust)
 
 - `"Preflight Jupiter Quote Preview before I pay 0.25 USDC to 6EF8rrect..."`
+- `"Merchant card for GFpLvocNdEjnSsLH3VJQL6wGcjGxTbUBrj6fqN3Qe1Gs"`
 - `"Get the trust receipt for seller JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4"`
 - `"Is it safe to call the paid intel endpoint on this seller?"`
 - `"Verify this receipt: {leaf, preimage, signature...}"`
@@ -189,6 +247,7 @@ x402 facilitators, not just one settlement path.
 import {
   intelPreflight,
   fetchIntelTrust,
+  fetchMerchantCard,
   verifyReceipt,
   preSpendGate,
   IntelPaymentRequiredError,
@@ -197,6 +256,7 @@ import {
 import type {
   ReadinessCard,
   PreflightResponse,
+  MerchantCard,
   IntelTrustResponse,
   TwzrdReceipt,
 } from '@wzrd_sol/eliza-plugin';
@@ -211,8 +271,8 @@ npm run build
 npm test
 ```
 
-`npm test` runs live free preflight against `intel.twzrd.xyz`, offline receipt verify, and a
-mocked paid trust path.
+`npm test` runs live free preflight against `intel.twzrd.xyz`, free merchant_card path,
+offline receipt verify, and a mocked paid trust path.
 
 Manual earn smoke (requires `SOLANA_PRIVATE_KEY`):
 
@@ -224,9 +284,9 @@ npx tsx test/earn-e2e.ts
 
 - [Agent Intel API](https://intel.twzrd.xyz)
 - [API docs / llms.txt](https://intel.twzrd.xyz/llms.txt)
-- [x402 gate (standalone firewall)](https://www.npmjs.com/package/twzrd-x402-gate)
+- [x402 gate (standalone fetch firewall)](https://www.npmjs.com/package/twzrd-x402-gate)
+- [plugin-trustgate (smaller Eliza spend guard)](https://www.npmjs.com/package/@wzrd_sol/plugin-trustgate)
 - [GOAT plugin](https://www.npmjs.com/package/@wzrd_sol/goat-plugin)
-- [TWZRD trust quickstart](https://intel.twzrd.xyz/docs/QUICKSTART.md)
 
 ## License
 

package/dist/actions/intel-preflight.js

@@ -43,7 +43,8 @@ export const intelPreflightAction = {
     similes: ['WZRD_PREFLIGHT', 'INTEL_PREFLIGHT', 'READINESS_CARD'],
     description: 'Free pre-spend ReadinessCard for a seller/resource/price/intent. Returns decision (allow/warn/block), ' +
         'trust_score, can_spend, caveats, paid_deep_dive upsell, and root_provenance when applicable. ' +
-        'Run this before any x402 payment.',
+        'Step 1 of the buyer sequence before any x402 payment; follow with WZRD_MERCHANT_CARD (wash refuse default) ' +
+        'or preSpendGate which runs both free checks.',
     examples: [
         [
             {

package/dist/actions/intel-trust.d.ts

@@ -1,7 +1,7 @@
 /**
- * WZRD_INTEL_TRUST — Paid trust payload + signed receipt (V5/V6) via x402-capable
- * fetch. Preflight-gated: the free ReadinessCard runs BEFORE the payment and a
- * decision=block aborts before any spend (the protocol's preflight-before-pay rule).
+ * WZRD_INTEL_TRUST — Paid trust payload + signed V6 receipt via x402-capable
+ * fetch. Preflight-gated: free ReadinessCard + free merchant_card wash check run
+ * BEFORE payment; decision=block or wash_flagged aborts before any spend.
  */
 import type { Action } from '@elizaos/core';
 export declare const intelTrustAction: Action;

package/dist/actions/intel-trust.js

@@ -4,8 +4,9 @@ import { resolvePayingFetch } from '../paying-fetch.js';
 export const intelTrustAction = {
     name: 'WZRD_INTEL_TRUST',
     similes: ['WZRD_TRUST_RECEIPT', 'INTEL_TRUST', 'GET_TRUST_RECEIPT'],
-    description: 'Paid GET /v1/intel/trust/{pubkey} (~0.05 USDC). Returns trust score + signed twzrd_receipt (V5/V6). ' +
-        'Runs the free preflight first and aborts on decision=block before spending. ' +
+    description: 'Paid GET /v1/intel/trust/{pubkey} (~0.05 USDC on Solana). Returns renormalized trust score + signed V6 ' +
+        'twzrd_receipt (portable offline proof). Runs free preflight + merchant_card wash check first; ' +
+        'aborts on decision=block or wash_flagged before any spend. ' +
         'Requires an x402-capable fetchImpl (setPayingFetch or host service). ' +
         'Surfaces payment requirements if no payer is configured.',
     examples: [
@@ -24,24 +25,32 @@ export const intelTrustAction = {
         }
         const apiBase = getIntelBase(runtime);
         const baseFetchImpl = resolvePayingFetch(runtime);
-        // preflight-before-pay: run the FREE ReadinessCard on the counterparty and
-        // abort on decision=block BEFORE any payment is signed/sent. failOpen=false so
+        // preflight-before-pay + wash refuse: FREE ReadinessCard + free merchant_card.
+        // Abort on decision=block or wash_flagged before any payment. failOpen=false so
         // the block-on-block guarantee holds even if the gate errors — a reference
-        // plugin must demonstrate the safe posture, not bypass it. The preflight call
-        // is free (the gate only ever reads), so this adds no spend.
+        // plugin must demonstrate the safe posture, not bypass it. Free reads only.
         try {
-            const gate = await preSpendGate({ seller_wallet: pubkey }, { apiBase, failOpen: false, fetchImpl: baseFetchImpl });
+            const gate = await preSpendGate({ seller_wallet: pubkey }, { apiBase, failOpen: false, refuseWashFlagged: true, fetchImpl: baseFetchImpl });
             if (!gate.allow) {
+                const washLine = gate.washFlagged === true
+                    ? `Wash flagged: yes (merchant_card refuse default)\n`
+                    : '';
                 await callback?.({
                     text: `Preflight blocked the trust purchase for ${pubkey}.\n` +
                         `Decision: ${gate.decision}${gate.trustScore != null ? `, trust_score=${gate.trustScore}` : ''}\n` +
+                        washLine +
                         `Reason: ${gate.reason}\n` +
                         `No payment was sent.`,
                 });
                 return {
                     success: false,
-                    error: 'preflight_block',
-                    data: { decision: gate.decision, trustScore: gate.trustScore, reason: gate.reason },
+                    error: gate.washFlagged === true ? 'wash_flagged' : 'preflight_block',
+                    data: {
+                        decision: gate.decision,
+                        trustScore: gate.trustScore,
+                        reason: gate.reason,
+                        washFlagged: gate.washFlagged ?? null,
+                    },
                 };
             }
         }

package/dist/actions/merchant-card.d.ts

@@ -0,0 +1,6 @@
+/**
+ * WZRD_MERCHANT_CARD — Free demand-quality graph card for a receive wallet.
+ * Includes wash_flagged (buyer refuse default) and optional catalog join.
+ */
+import type { Action } from '@elizaos/core';
+export declare const merchantCardAction: Action;

package/dist/actions/merchant-card.js

@@ -0,0 +1,85 @@
+import { fetchMerchantCard } from '@wzrd_sol/sdk';
+import { extractPubkey, getIntelBase, withTimeout } from '../intel-helpers.js';
+function formatMerchantCard(card) {
+    const lines = [
+        `Merchant card for ${card.merchant ?? 'unknown'}`,
+        `In corpus: ${card.in_corpus ? 'yes' : 'no'}`,
+        `Wash flagged: ${card.wash_flagged === true ? 'YES — default refuse pay' : card.wash_flagged === false ? 'no' : 'unknown'}`,
+    ];
+    if (card.wash_label)
+        lines.push(`Wash label: ${card.wash_label}`);
+    if (card.provider_reputation_tier)
+        lines.push(`Tier: ${card.provider_reputation_tier}`);
+    if (card.unique_payers_90d != null)
+        lines.push(`Unique payers (90d): ${card.unique_payers_90d}`);
+    if (card.offering_status)
+        lines.push(`Offering: ${card.offering_status}`);
+    if (card.catalog_enriched) {
+        const name = card.catalog && typeof card.catalog === 'object' && 'name' in card.catalog
+            ? String(card.catalog.name ?? '')
+            : '';
+        lines.push(`Catalog enriched: yes${name ? ` (${name})` : ''} — listing only, not quality proof`);
+    }
+    else {
+        lines.push('Catalog enriched: no (graph only)');
+    }
+    if (card.wash_flagged === true) {
+        lines.push('Policy: do not pay this pay_to (trustless default). Cap only if operator set washMaxUsdc.');
+    }
+    return lines.join('\n');
+}
+export const merchantCardAction = {
+    name: 'WZRD_MERCHANT_CARD',
+    similes: ['WZRD_MERCHANT', 'MERCHANT_CARD', 'INTEL_MERCHANT_CARD', 'CHECK_WASH'],
+    description: 'Free GET merchant demand-quality card for a Solana receive wallet (no auth). ' +
+        'Returns wash_flagged, tier, unique payers, catalog join when listed. ' +
+        'Default: if wash_flagged is true, do not pay that pay_to.',
+    examples: [
+        [
+            {
+                name: '{{user1}}',
+                content: { text: 'Merchant card for 7G73dUxj8Qn4yH4x9zXkKqZ8oKqZ8oKqZ8o' },
+            },
+            {
+                name: '{{agentName}}',
+                content: { text: 'Merchant card: wash_flagged YES — default refuse pay' },
+            },
+        ],
+    ],
+    validate: async () => true,
+    handler: async (runtime, message, _state, _opt, callback) => {
+        const content = (message.content ?? {});
+        const pubkey = extractPubkey(content);
+        if (!pubkey) {
+            await callback?.({
+                text: 'Provide a merchant/seller wallet (32-44 char base58) for merchant_card.',
+            });
+            return { success: false, error: 'Missing pubkey' };
+        }
+        const apiBase = getIntelBase(runtime);
+        try {
+            const card = await withTimeout(() => fetchMerchantCard(pubkey, { apiBase }));
+            if (!card) {
+                await callback?.({
+                    text: `Merchant card unavailable for ${pubkey} (network or invalid). ` +
+                        `Fail-open: do not invent wash_flagged; use WZRD_INTEL_PREFLIGHT decision only.`,
+                });
+                return { success: false, error: 'merchant_card_unavailable' };
+            }
+            const text = formatMerchantCard(card);
+            await callback?.({ text });
+            return {
+                success: true,
+                data: {
+                    ...card,
+                    refuse_pay: card.wash_flagged === true,
+                },
+            };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            await callback?.({ text: `Merchant card failed: ${msg}` });
+            return { success: false, error: msg };
+        }
+    },
+};

package/dist/actions/verify-receipt.d.ts

@@ -1,7 +1,7 @@
 /**
  * WZRD_VERIFY_RECEIPT — Offline leaf + Ed25519 verification (no network).
- * Handles both V5 and V6 receipts; the SDK selects the leaf binding from the
- * receipt's domain (V6 binds the reputation_* provenance fields into the leaf).
+ * Primary surface is V6 (reputation leaf). Older V5 receipts still verify when
+ * presented; the SDK selects the leaf binding from the receipt domain.
  */
 import type { Action } from '@elizaos/core';
 export declare const verifyReceiptAction: Action;

package/dist/actions/verify-receipt.js

@@ -3,11 +3,11 @@ import { getIntelBase, parseReceipt, withTimeout } from '../intel-helpers.js';
 export const verifyReceiptAction = {
     name: 'WZRD_VERIFY_RECEIPT',
     similes: ['WZRD_VERIFY', 'VERIFY_TWZRD_RECEIPT', 'CHECK_RECEIPT'],
-    description: 'Offline verify a TwzrdReceipt (V5 or V6): recompute keccak leaf from preimage and check Ed25519 signature ' +
-        'against the published TWZRD key. No network required when trustedPubkey is known.',
+    description: 'Offline verify a TwzrdReceipt (V6 primary; older V5 still accepted): recompute keccak leaf from preimage ' +
+        'and check Ed25519 signature against the published TWZRD key. No network required when trustedPubkey is known.',
     examples: [
         [
-            { name: '{{user1}}', content: { text: 'Verify this receipt: {"version":"v5","leaf":"0x...","preimage":{...}}' } },
+            { name: '{{user1}}', content: { text: 'Verify this receipt: {"version":"v6","leaf":"0x...","preimage":{...}}' } },
             { name: '{{agentName}}', content: { text: 'Receipt valid: leaf OK, signature OK.' } },
         ],
     ],

package/dist/index.d.ts

@@ -2,8 +2,11 @@
  * @wzrd_sol/eliza-plugin — WZRD Agent Intel + Earn Loop for ElizaOS
  *
  * Intel lane (default https://intel.twzrd.xyz):
- *   WZRD_INTEL_PREFLIGHT → WZRD_INTEL_TRUST → WZRD_VERIFY_RECEIPT
- * Paid intel requires caller-supplied x402 fetch via setPayingFetch().
+ *   WZRD_INTEL_PREFLIGHT → WZRD_MERCHANT_CARD → WZRD_INTEL_TRUST → WZRD_VERIFY_RECEIPT
+ * Paid intel requires a caller-supplied x402 fetch — either setPayingFetch(payingFetch)
+ * (already-composed, unguarded) or installTwzrdAutoGate(payWrap) (default-on: guards the
+ * raw fetch before your client signs, then registers it the same way).
+ * Default: preSpendGate refuses wash_flagged pay_to (free merchant_card).
  *
  * Earn lane (default https://api.twzrd.xyz):
  *   WZRD_INFER → WZRD_REPORT → WZRD_EARN → WZRD_CLAIM / WZRD_REWARDS
@@ -20,14 +23,15 @@ import { earnAction } from './actions/earn.js';
 import { claimAction } from './actions/claim.js';
 import { rewardsAction } from './actions/rewards.js';
 import { intelPreflightAction } from './actions/intel-preflight.js';
+import { merchantCardAction } from './actions/merchant-card.js';
 import { intelTrustAction } from './actions/intel-trust.js';
 import { verifyReceiptAction } from './actions/verify-receipt.js';
 export declare const wzrdPlugin: Plugin;
 export default wzrdPlugin;
-export { intelPreflightAction, intelTrustAction, verifyReceiptAction, earnAction, inferAction, reportAction, claimAction, rewardsAction, };
+export { intelPreflightAction, merchantCardAction, intelTrustAction, verifyReceiptAction, earnAction, inferAction, reportAction, claimAction, rewardsAction, };
 export { getWzrdClient, clearClientCache, getIntelApiBase, getIntelClient } from './client-factory.js';
-export { setPayingFetch, clearPayingFetch, resolvePayingFetch } from './paying-fetch.js';
+export { setPayingFetch, clearPayingFetch, resolvePayingFetch, installTwzrdAutoGate, } from './paying-fetch.js';
 export { WzrdClient } from './client.js';
 export type { InferResult, ReportResult, RewardsBalance, ClaimResult } from './client.js';
-export { IntelPaymentRequiredError, intelPreflight, fetchIntelTrust, verifyReceipt, preSpendGate, intelTrustUrl, TRUSTED_RECEIPT_PUBKEY, INTEL_TRUST_PRICE_USDC, } from '@wzrd_sol/sdk';
-export type { ReadinessCard, PreflightInput, PreflightResponse, TwzrdReceipt, IntelTrustResponse, VerifyReceiptResult, X402PaymentRequired, } from '@wzrd_sol/sdk';
+export { IntelPaymentRequiredError, intelPreflight, fetchIntelTrust, fetchMerchantCard, verifyReceipt, preSpendGate, intelTrustUrl, TRUSTED_RECEIPT_PUBKEY, INTEL_TRUST_PRICE_USDC, } from '@wzrd_sol/sdk';
+export type { ReadinessCard, PreflightInput, PreflightResponse, MerchantCard, TwzrdReceipt, IntelTrustResponse, VerifyReceiptResult, X402PaymentRequired, } from '@wzrd_sol/sdk';

package/dist/index.js

@@ -4,15 +4,18 @@ import { earnAction } from './actions/earn.js';
 import { claimAction } from './actions/claim.js';
 import { rewardsAction } from './actions/rewards.js';
 import { intelPreflightAction } from './actions/intel-preflight.js';
+import { merchantCardAction } from './actions/merchant-card.js';
 import { intelTrustAction } from './actions/intel-trust.js';
 import { verifyReceiptAction } from './actions/verify-receipt.js';
 export const wzrdPlugin = {
     name: 'wzrd',
-    description: 'WZRD Agent Intel — free ReadinessCard preflight (gates spends before paying), x402-paid trust receipts ' +
-        '(V5/V6), offline verification on intel.twzrd.xyz. Also ships the legacy earn loop (infer/report/claim) ' +
-        'on api.twzrd.xyz.',
+    description: 'WZRD Agent Intel — free ReadinessCard preflight + free merchant_card wash refuse (default), ' +
+        'then optional x402-paid V6 trust receipt (~0.05 USDC) + offline verify on intel.twzrd.xyz. ' +
+        'Buyer sequence is call-site / action-driven (not an auto-interceptor of all payments). ' +
+        'Also ships the legacy earn loop (infer/report/claim) on api.twzrd.xyz.',
     actions: [
         intelPreflightAction,
+        merchantCardAction,
         intelTrustAction,
         verifyReceiptAction,
         earnAction,
@@ -23,8 +26,8 @@ export const wzrdPlugin = {
     ],
 };
 export default wzrdPlugin;
-export { intelPreflightAction, intelTrustAction, verifyReceiptAction, earnAction, inferAction, reportAction, claimAction, rewardsAction, };
+export { intelPreflightAction, merchantCardAction, intelTrustAction, verifyReceiptAction, earnAction, inferAction, reportAction, claimAction, rewardsAction, };
 export { getWzrdClient, clearClientCache, getIntelApiBase, getIntelClient } from './client-factory.js';
-export { setPayingFetch, clearPayingFetch, resolvePayingFetch } from './paying-fetch.js';
+export { setPayingFetch, clearPayingFetch, resolvePayingFetch, installTwzrdAutoGate, } from './paying-fetch.js';
 export { WzrdClient } from './client.js';
-export { IntelPaymentRequiredError, intelPreflight, fetchIntelTrust, verifyReceipt, preSpendGate, intelTrustUrl, TRUSTED_RECEIPT_PUBKEY, INTEL_TRUST_PRICE_USDC, } from '@wzrd_sol/sdk';
+export { IntelPaymentRequiredError, intelPreflight, fetchIntelTrust, fetchMerchantCard, verifyReceipt, preSpendGate, intelTrustUrl, TRUSTED_RECEIPT_PUBKEY, INTEL_TRUST_PRICE_USDC, } from '@wzrd_sol/sdk';

package/dist/paying-fetch.d.ts

@@ -1,7 +1,24 @@
 /** x402-capable fetch injection for paid intel actions. No embedded wallet. */
 import type { IAgentRuntime } from '@elizaos/core';
+import { type InstallAutoGateOptions, type PayWrap } from 'twzrd-x402-gate';
 /** Host supplies an x402-capable fetch (agentcash, twzrd-x402-gate, etc.) before runtime creation. */
 export declare function setPayingFetch(f: typeof fetch): void;
+/**
+ * Default-on replacement for `setPayingFetch(payWrap(rawFetch))`: guards the raw fetch
+ * with the free TWZRD preflight BEFORE handing it to your x402 client's `payWrap`, so a
+ * blocked seller is refused before your client ever signs — then registers the result as
+ * the module paying fetch (same slot `setPayingFetch` writes to).
+ *
+ * Opt out with `TWZRD_AUTO_GATE=0` (env) or `{ disabled: true }`.
+ *
+ * @example
+ *   import { installTwzrdAutoGate } from '@wzrd_sol/eliza-plugin';
+ *   import { wrapFetchWithPayment } from '@x402/svm';
+ *
+ *   installTwzrdAutoGate((guarded) => wrapFetchWithPayment(guarded, buyerWallet));
+ *   const agent = new AgentRuntime({ plugins: [wzrdPlugin] });
+ */
+export declare function installTwzrdAutoGate(payWrap: PayWrap, options?: InstallAutoGateOptions): void;
 export declare function clearPayingFetch(): void;
 type FetchLike = typeof fetch;
 /** Resolve paying fetch: module setter > runtime service > runtime.fetch > global fetch. */

package/dist/paying-fetch.js

@@ -1,8 +1,27 @@
+import { installTwzrdAutoGate as buildAutoGate, } from 'twzrd-x402-gate';
 let modulePayingFetch = null;
 /** Host supplies an x402-capable fetch (agentcash, twzrd-x402-gate, etc.) before runtime creation. */
 export function setPayingFetch(f) {
     modulePayingFetch = f;
 }
+/**
+ * Default-on replacement for `setPayingFetch(payWrap(rawFetch))`: guards the raw fetch
+ * with the free TWZRD preflight BEFORE handing it to your x402 client's `payWrap`, so a
+ * blocked seller is refused before your client ever signs — then registers the result as
+ * the module paying fetch (same slot `setPayingFetch` writes to).
+ *
+ * Opt out with `TWZRD_AUTO_GATE=0` (env) or `{ disabled: true }`.
+ *
+ * @example
+ *   import { installTwzrdAutoGate } from '@wzrd_sol/eliza-plugin';
+ *   import { wrapFetchWithPayment } from '@x402/svm';
+ *
+ *   installTwzrdAutoGate((guarded) => wrapFetchWithPayment(guarded, buyerWallet));
+ *   const agent = new AgentRuntime({ plugins: [wzrdPlugin] });
+ */
+export function installTwzrdAutoGate(payWrap, options) {
+    setPayingFetch(buildAutoGate(payWrap, options));
+}
 export function clearPayingFetch() {
     modulePayingFetch = null;
 }

package/dist/test/plugin-registration.intel.js

@@ -10,7 +10,7 @@
 import assert from 'node:assert/strict';
 import { describe, it, before, after } from 'node:test';
 import { AgentRuntime } from '@elizaos/core';
-import wzrdPlugin, { intelPreflightAction, intelTrustAction, verifyReceiptAction, setPayingFetch, clearPayingFetch, getIntelClient, resolvePayingFetch, } from '@wzrd_sol/eliza-plugin';
+import wzrdPlugin, { intelPreflightAction, merchantCardAction, intelTrustAction, verifyReceiptAction, setPayingFetch, clearPayingFetch, getIntelClient, resolvePayingFetch, } from '@wzrd_sol/eliza-plugin';
 function mockMemory(content) {
     return {
         id: '00000000-0000-0000-0000-000000000001',
@@ -43,6 +43,7 @@ describe('wzrdPlugin intel registration + E2E (real runtime load)', () => {
     it('constructs runtime with plugins and registers intel actions', () => {
         const names = runtime.actions.map((a) => a.name);
         assert.ok(names.includes('WZRD_INTEL_PREFLIGHT'), 'preflight must be registered');
+        assert.ok(names.includes('WZRD_MERCHANT_CARD'), 'merchant card must be registered');
         assert.ok(names.includes('WZRD_INTEL_TRUST'), 'trust must be registered');
         assert.ok(names.includes('WZRD_VERIFY_RECEIPT'), 'verify must be registered');
     });
@@ -121,35 +122,115 @@ describe('wzrdPlugin intel registration + E2E (real runtime load)', () => {
             assert.ok(result.data);
     });
     it('PREFLIGHT-BEFORE-PAY: decision=block aborts the trust purchase before any payment', async () => {
-        // preSpendGate runs the FREE preflight via the SDK's intelPreflight, which uses
-        // the global fetch (not the injected paying fetch — that is reserved for the
-        // paid leg). So we stub global fetch to return a block ReadinessCard, and put a
-        // tripwire on the injected paying fetch: if the pay leg runs after a block, the
-        // tripwire fires and the test fails.
+        // preSpendGate runs FREE preflight + merchant_card via global fetch (not the
+        // injected paying fetch). Stub both; tripwire on pay leg.
         const realFetch = globalThis.fetch;
         let payAttempted = false;
         setPayingFetch(async () => {
             payAttempted = true;
             return { ok: true, status: 200, json: async () => ({}) };
         });
+        globalThis.fetch = (async (input) => {
+            const url = String(input);
+            if (url.includes('/merchant_card/')) {
+                return {
+                    ok: true,
+                    status: 200,
+                    json: async () => ({ wash_flagged: false }),
+                };
+            }
+            return {
+                ok: true,
+                status: 200,
+                json: async () => ({
+                    readiness_card: { decision: 'block', trust_score: 5, can_spend: false },
+                    reason: 'seller flagged by corpus',
+                }),
+            };
+        });
+        try {
+            const callbacks = [];
+            const result = await intelTrustAction.handler(mockRuntime(), mockMemory({ pubkey: '4LkEFjJdXARkKx8FBx4LBFa2SvJNmjQpgGDLoJcypZUE' }), undefined, undefined, async (r) => {
+                callbacks.push(r.text ?? '');
+                return [];
+            });
+            assert.equal(result?.success, false);
+            assert.equal(result?.error, 'preflight_block');
+            assert.equal(payAttempted, false, 'payment must NOT be attempted after a block decision');
+            assert.match(callbacks.join('\n'), /blocked|No payment was sent/i);
+        }
+        finally {
+            globalThis.fetch = realFetch;
+        }
+    });
+    it('WASH REFUSE: wash_flagged aborts trust purchase even when preflight allows', async () => {
+        const realFetch = globalThis.fetch;
+        let payAttempted = false;
+        setPayingFetch(async () => {
+            payAttempted = true;
+            return { ok: true, status: 200, json: async () => ({}) };
+        });
+        globalThis.fetch = (async (input) => {
+            const url = String(input);
+            if (url.includes('/merchant_card/')) {
+                return {
+                    ok: true,
+                    status: 200,
+                    json: async () => ({
+                        merchant: '4LkEFjJdXARkKx8FBx4LBFa2SvJNmjQpgGDLoJcypZUE',
+                        wash_flagged: true,
+                        wash_label: 'fleet_dominated',
+                    }),
+                };
+            }
+            return {
+                ok: true,
+                status: 200,
+                json: async () => ({
+                    readiness_card: { decision: 'allow', trust_score: 80, can_spend: true },
+                    reason: 'preflight decision=allow',
+                }),
+            };
+        });
+        try {
+            const callbacks = [];
+            const result = await intelTrustAction.handler(mockRuntime(), mockMemory({ pubkey: '4LkEFjJdXARkKx8FBx4LBFa2SvJNmjQpgGDLoJcypZUE' }), undefined, undefined, async (r) => {
+                callbacks.push(r.text ?? '');
+                return [];
+            });
+            assert.equal(result?.success, false);
+            assert.equal(result?.error, 'wash_flagged');
+            assert.equal(payAttempted, false, 'payment must NOT run after wash refuse');
+            assert.match(callbacks.join('\n'), /wash|No payment was sent/i);
+        }
+        finally {
+            globalThis.fetch = realFetch;
+        }
+    });
+    it('merchant card handler returns wash / catalog fields (mocked)', async () => {
+        const realFetch = globalThis.fetch;
         globalThis.fetch = (async () => ({
             ok: true,
             status: 200,
             json: async () => ({
-                readiness_card: { decision: 'block', trust_score: 5, can_spend: false },
-                reason: 'seller flagged by corpus',
+                merchant: '4LkEFjJdXARkKx8FBx4LBFa2SvJNmjQpgGDLoJcypZUE',
+                in_corpus: true,
+                wash_flagged: false,
+                wash_label: 'provider_organic_broad',
+                catalog_enriched: false,
+                offering_status: 'Offering unknown — graph only',
+                unique_payers_90d: 12,
             }),
         }));
         try {
             const callbacks = [];
-            const result = await intelTrustAction.handler(mockRuntime(), mockMemory({ pubkey: '4LkEFjJdXARkKx8FBx4LBFa2SvJNmjQpgGDLoJcypZUE' }), undefined, undefined, async (r) => {
+            const result = await merchantCardAction.handler(mockRuntime(), mockMemory({ pubkey: '4LkEFjJdXARkKx8FBx4LBFa2SvJNmjQpgGDLoJcypZUE' }), undefined, undefined, async (r) => {
                 callbacks.push(r.text ?? '');
                 return [];
             });
-            assert.equal(result?.success, false);
-            assert.equal(result?.error, 'preflight_block');
-            assert.equal(payAttempted, false, 'payment must NOT be attempted after a block decision');
-            assert.match(callbacks.join('\n'), /blocked|No payment was sent/i);
+            assert.equal(result?.success, true);
+            assert.match(callbacks.join('\n'), /Wash flagged: no/i);
+            assert.match(callbacks.join('\n'), /graph only/i);
         }
         finally {
             globalThis.fetch = realFetch;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@wzrd_sol/eliza-plugin",
-  "version": "0.3.2",
-  "description": "WZRD Agent Intel for ElizaOS — preflight ReadinessCards, x402-paid signed trust receipts (V6 reputation leaf), offline verification on intel.twzrd.xyz. Also ships the legacy earn loop.",
+  "version": "0.5.0",
+  "description": "WZRD Agent Intel for ElizaOS. Free buyer sequence: preflight ReadinessCard + merchant_card (wash_flagged refuse default). Paid: GET /v1/intel/trust (0.05 USDC) for signed V6 receipt. Offline verify. installTwzrdAutoGate(payWrap) registers a default-on guarded paying fetch in one call; setPayingFetch / actions / preSpendGate remain available for manual wiring. Also ships the legacy earn loop.",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -19,9 +19,10 @@
   },
   "dependencies": {
     "@solana/web3.js": "^1.95.0",
-    "@wzrd_sol/sdk": "^0.4.3",
+    "@wzrd_sol/sdk": "^0.4.7",
     "bs58": "^5.0.0",
-    "tweetnacl": "^1.0.3"
+    "tweetnacl": "^1.0.3",
+    "twzrd-x402-gate": "^0.5.0"
   },
   "peerDependencies": {
     "@elizaos/core": "^1.0.0"
@@ -47,6 +48,9 @@
     "receipt",
     "reputation",
     "preflight",
+    "merchant_card",
+    "wash",
+    "marketplace",
     "ccm",
     "inference",
     "earn",
@@ -59,8 +63,8 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/twzrd-sol/wzrd-final.git",
-    "directory": "agents/eliza-plugin"
+    "url": "git+https://github.com/twzrd-sol/twzrd-trust.git",
+    "directory": "eliza-plugin"
   },
   "bugs": {
     "url": "https://github.com/twzrd-sol/twzrd-trust/issues"