@wzrd_sol/eliza-plugin 0.3.3 → 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,22 +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_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; 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)
 
@@ -57,60 +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, fetchMerchantCard } from '@wzrd_sol/eliza-plugin';
 
-// Gate before paying (free preflight + free merchant_card wash refuse, default on):
+// 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)
 
-// Or inspect the card alone:
-const card = await fetchMerchantCard(sellerPubkey);
-if (card?.wash_flagged) return 'refuse dirty pay_to';
-
 // 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.
+**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
@@ -121,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)
@@ -136,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:**
 
@@ -165,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...}"`
@@ -198,6 +247,7 @@ x402 facilitators, not just one settlement path.
 import {
   intelPreflight,
   fetchIntelTrust,
+  fetchMerchantCard,
   verifyReceipt,
   preSpendGate,
   IntelPaymentRequiredError,
@@ -206,6 +256,7 @@ import {
 import type {
   ReadinessCard,
   PreflightResponse,
+  MerchantCard,
   IntelTrustResponse,
   TwzrdReceipt,
 } from '@wzrd_sol/eliza-plugin';
@@ -220,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`):
 
@@ -233,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,5 +1,5 @@
 /**
- * WZRD_INTEL_TRUST — Paid trust payload + signed receipt (V5/V6) via x402-capable
+ * 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.
  */

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 free preflight + merchant_card wash check first; aborts on decision=block or wash_flagged. ' +
+    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: [

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

@@ -3,7 +3,9 @@
  *
  * Intel lane (default https://intel.twzrd.xyz):
  *   WZRD_INTEL_PREFLIGHT → WZRD_MERCHANT_CARD → WZRD_INTEL_TRUST → WZRD_VERIFY_RECEIPT
- * Paid intel requires caller-supplied x402 fetch via setPayingFetch().
+ * 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):
@@ -28,7 +30,7 @@ export declare const wzrdPlugin: Plugin;
 export default wzrdPlugin;
 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, fetchMerchantCard, verifyReceipt, preSpendGate, intelTrustUrl, TRUSTED_RECEIPT_PUBKEY, INTEL_TRUST_PRICE_USDC, } from '@wzrd_sol/sdk';

package/dist/index.js

@@ -9,8 +9,9 @@ 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 + merchant_card wash refuse (default), ' +
-        'x402-paid trust receipts (V5/V6), offline verification on intel.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,
@@ -27,6 +28,6 @@ export const wzrdPlugin = {
 export default wzrdPlugin;
 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, 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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@wzrd_sol/eliza-plugin",
-  "version": "0.3.3",
-  "description": "WZRD Agent Intel for ElizaOS — preflight ReadinessCards, free merchant_card wash refuse default, 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",
@@ -21,7 +21,8 @@
     "@solana/web3.js": "^1.95.0",
     "@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",