@wzrd_sol/eliza-plugin 0.2.0 → 0.3.0

package/README.md

@@ -1,6 +1,8 @@
 # @wzrd_sol/eliza-plugin
 
-ElizaOS plugin for the WZRD Liquid Attention Protocol on Solana. Gives ElizaOS agents the ability to discover AI model velocity, manage attention market positions, deposit USDC, and claim CCM yield.
+ElizaOS plugin for WZRD Agent Intel and the legacy earn loop on Solana.
+
+**Before any x402 spend:** run `WZRD_INTEL_PREFLIGHT` (free ReadinessCard). Escalate to `WZRD_INTEL_TRUST` only when you need a signed V5 receipt. Verify offline with `WZRD_VERIFY_RECEIPT`.
 
 ## Install
 
@@ -10,52 +12,122 @@ npm install @wzrd_sol/eliza-plugin
 
 ## Configuration
 
-Set these in your ElizaOS runtime settings or environment:
-
 | Variable | Required | Default | Description |
 |----------|----------|---------|-------------|
-| `SOLANA_PRIVATE_KEY` | Yes (for tx) | — | Base58 keypair for signing deposits/claims |
-| `WZRD_API_URL` | No | `https://api.twzrd.xyz` | WZRD backend endpoint |
-| `SOLANA_RPC_URL` | No | Helius mainnet | Solana RPC for on-chain reads |
+| `WZRD_INTEL_URL` | No | `https://intel.twzrd.xyz` | Agent Intel API (preflight, trust, verify) |
+| `WZRD_API_URL` | No | `https://api.twzrd.xyz` | Legacy earn API (infer/report/claim) |
+| `SOLANA_PRIVATE_KEY` | Earn lane only | — | JSON array of secret key bytes for agent Ed25519 auth |
+
+### Wiring a paying fetch (intel paid actions)
+
+The plugin does **not** embed a wallet. Paid `WZRD_INTEL_TRUST` needs an x402-capable `fetch` from the host:
+
+```typescript
+import { AgentRuntime } from '@elizaos/core';
+import wzrdPlugin, { setPayingFetch } from '@wzrd_sol/eliza-plugin';
+import { agentcashFetch } from 'your-x402-wrapper'; // agentcash, twzrd-x402-gate, etc.
+
+setPayingFetch(agentcashFetch);
+
+const agent = new AgentRuntime({
+  plugins: [wzrdPlugin],
+  settings: {
+    WZRD_INTEL_URL: 'https://intel.twzrd.xyz',
+    SOLANA_PRIVATE_KEY: process.env.SOLANA_PRIVATE_KEY,
+  },
+});
+```
+
+Without a paying fetch, `WZRD_INTEL_TRUST` returns the HTTP 402 requirements and an `npx agentcash@latest fetch ...` one-liner.
 
 ## Usage
 
 ```typescript
-import { wzrdPlugin } from "@wzrd_sol/eliza-plugin";
+import { wzrdPlugin } from '@wzrd_sol/eliza-plugin';
 
-// Register with your ElizaOS agent
 const agent = new AgentRuntime({
   plugins: [wzrdPlugin],
-  // ... other config
 });
 ```
 
-## Actions
+Programmatic SDK calls (same types as the plugin) are re-exported:
+
+```typescript
+import { intelPreflight, fetchIntelTrust, verifyReceipt, IntelPaymentRequiredError } from '@wzrd_sol/eliza-plugin';
+```
+
+## Intel actions (primary)
+
+| Action | Auth/Pay | Description |
+|--------|----------|-------------|
+| `WZRD_INTEL_PREFLIGHT` | Free | ReadinessCard: decision, trust_score, can_spend, caveats, paid upsell |
+| `WZRD_INTEL_TRUST` | x402 (~0.05 USDC) | Paid trust payload + V5 `twzrd_receipt` (needs `setPayingFetch`) |
+| `WZRD_VERIFY_RECEIPT` | Free (offline) | Recompute leaf + Ed25519 verify; no network when pubkey is known |
+
+### Example prompts
+
+- "Preflight Jupiter Quote Preview before I pay 0.25 USDC to 6EF8rrect..."
+- "Get the trust receipt for seller JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4"
+- "Verify this receipt: {leaf, preimage, signature...}"
+- "Is it safe to call the paid intel endpoint on this seller?"
+
+### Free preflight (no wallet)
+
+```typescript
+import { intelPreflightAction } from '@wzrd_sol/eliza-plugin';
+
+// Handler reads seller_wallet / price_usdc / agent_intent from message content
+await intelPreflightAction.handler(runtime, {
+  content: {
+    seller_wallet: 'JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4',
+    price_usdc: 0.25,
+    agent_intent: 'quote preview',
+  },
+}, ...);
+```
+
+## Legacy earn actions
 
 | Action | Auth | Description |
 |--------|------|-------------|
-| `WZRD_LEADERBOARD` | No | Fetch top markets ranked by velocity EMA |
-| `WZRD_VELOCITY` | No | Classify attention signal strength for a market |
-| `WZRD_PORTFOLIO` | Yes | View positions and accrued yield |
-| `WZRD_DEPOSIT` | Yes | Deposit USDC into an attention market, receive vLOFI |
-| `WZRD_CLAIM` | Yes | Claim accrued CCM via gasless relay or self-signed tx |
+| `WZRD_INFER` | Agent Ed25519 | Server-witnessed inference; returns `execution_id` |
+| `WZRD_REPORT` | Agent Ed25519 | Report outcome with `execution_id` for verified rewards |
+| `WZRD_EARN` | Agent Ed25519 | Full infer → report → rewards check in one action |
+| `WZRD_CLAIM` | Agent Ed25519 | Gasless CCM claim via relay |
+| `WZRD_REWARDS` | Agent Ed25519 | Pending and lifetime CCM balance |
 
-### Example prompts
+### Example prompts (earn)
 
-- "Show me the top WZRD markets"
-- "What's the velocity signal for market 6?"
-- "Check my WZRD portfolio"
-- "Deposit 1 USDC into market 3"
-- "Claim my CCM rewards"
+- "Run inference through WZRD: explain quicksort in Python"
+- "Earn some CCM on WZRD"
+- "Check my WZRD rewards"
+- "Claim my CCM"
+
+## Test
+
+```bash
+cd agents/eliza-plugin
+npm ci
+npm run build
+npm test
+```
+
+`npm test` loads the plugin into a real `@elizaos/core` `AgentRuntime`, runs live free preflight against `intel.twzrd.xyz`, offline receipt verify, and a mocked paid trust path.
+
+Manual earn smoke (requires `SOLANA_PRIVATE_KEY`):
+
+```bash
+npx tsx test/earn-e2e.ts
+```
 
 ## Links
 
-- [WZRD Protocol](https://twzrd.xyz)
+- [Agent Intel API](https://intel.twzrd.xyz)
+- [Legacy API](https://api.twzrd.xyz)
 - [SDK](https://www.npmjs.com/package/@wzrd_sol/sdk)
-- [OpenAPI](https://twzrd.xyz/openapi.json)
-- [MCP Server](https://app.twzrd.xyz/api/mcp)
-- [Agent Discovery](https://twzrd.xyz/llms.txt)
+- [twzrd-agent-intel (Python/MCP)](https://github.com/twzrd-sol/wzrd-final/tree/main/packages/twzrd-agent-intel)
+- [Agent discovery](https://twzrd.xyz/llms.txt)
 
 ## License
 
-MIT
+MIT

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

@@ -0,0 +1,5 @@
+/**
+ * WZRD_INTEL_PREFLIGHT — Free ReadinessCard before any x402 spend.
+ */
+import type { Action } from '@elizaos/core';
+export declare const intelPreflightAction: Action;

package/dist/actions/intel-preflight.js

@@ -0,0 +1,97 @@
+import { intelPreflight } from '@wzrd_sol/sdk';
+import { getIntelBase, parsePreflightInput, withTimeout } from '../intel-helpers.js';
+function isValidBase58Wallet(s) {
+    if (!s)
+        return false;
+    return /^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(s);
+}
+function validatePreflight(input) {
+    if (input.seller_wallet && !isValidBase58Wallet(input.seller_wallet))
+        return 'seller_wallet must be 32-44 char base58';
+    if (input.price_usdc != null && (input.price_usdc < 0 || !Number.isFinite(input.price_usdc)))
+        return 'price_usdc must be non-negative finite number';
+    if (input.resource_name && typeof input.resource_name !== 'string')
+        return 'resource_name must be string';
+    return null;
+}
+function formatCard(card, preflightId) {
+    const lines = [
+        `ReadinessCard v${card.version}`,
+        `Decision: ${card.decision}`,
+        `Trust score: ${card.trust_score ?? 'n/a'}`,
+        `Can spend: ${card.can_spend ? 'yes' : 'no'}`,
+    ];
+    if (preflightId)
+        lines.push(`Preflight ID: ${preflightId}`);
+    if (card.resource_name)
+        lines.push(`Resource: ${card.resource_name}`);
+    if (card.seller_wallet)
+        lines.push(`Seller: ${card.seller_wallet}`);
+    if (card.price_usdc != null)
+        lines.push(`Price: ${card.price_usdc} USDC`);
+    if (card.caveats?.length)
+        lines.push(`Caveats: ${card.caveats.join('; ')}`);
+    if (card.next_fixes?.length)
+        lines.push(`Next fixes: ${card.next_fixes.join('; ')}`);
+    if (card.paid_deep_dive) {
+        lines.push(`Paid deep dive available (${card.paid_price_usdc ?? 0.05} USDC) — use WZRD_INTEL_TRUST`);
+    }
+    return lines.join('\n');
+}
+export const intelPreflightAction = {
+    name: 'WZRD_INTEL_PREFLIGHT',
+    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.',
+    examples: [
+        [
+            {
+                name: '{{user1}}',
+                content: {
+                    text: 'Preflight Jupiter Quote Preview before I pay 0.25 USDC to 6EF8rrect...',
+                },
+            },
+            {
+                name: '{{agentName}}',
+                content: { text: 'ReadinessCard: decision ALLOW, trust_score 72, can_spend yes.' },
+            },
+        ],
+    ],
+    validate: async () => true,
+    handler: async (runtime, message, _state, _opt, callback) => {
+        const content = (message.content ?? {});
+        const input = parsePreflightInput(content);
+        if (!input.seller_wallet && !input.resource_name && !input.resource_url && !input.agent_intent) {
+            await callback?.({
+                text: 'Provide seller_wallet, resource_name, resource_url, or agent_intent for preflight. ' +
+                    'Example: "Preflight seller JUP6Lkb... at 0.25 USDC"',
+            });
+            return { success: false, error: 'Missing preflight input' };
+        }
+        const vErr = validatePreflight(input);
+        if (vErr) {
+            await callback?.({ text: `Invalid preflight input: ${vErr}` });
+            return { success: false, error: vErr };
+        }
+        const apiBase = getIntelBase(runtime);
+        try {
+            const res = await withTimeout(() => intelPreflight(input, apiBase));
+            const card = res.readiness_card;
+            if (!card) {
+                const text = `Preflight OK (legacy). decision=${res.decision ?? 'unknown'}, score=${res.trust_score ?? 'n/a'}`;
+                await callback?.({ text });
+                return { success: true, data: res };
+            }
+            const preflightId = res.preflight_id;
+            const text = formatCard(card, preflightId);
+            await callback?.({ text });
+            return { success: true, data: { ...res, readiness_card: card } };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            await callback?.({ text: `Preflight failed: ${msg}` });
+            return { success: false, error: msg };
+        }
+    },
+};

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

@@ -0,0 +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).
+ */
+import type { Action } from '@elizaos/core';
+export declare const intelTrustAction: Action;

package/dist/actions/intel-trust.js

@@ -0,0 +1,82 @@
+import { fetchIntelTrust, preSpendGate, IntelPaymentRequiredError } from '@wzrd_sol/sdk';
+import { extractPubkey, formatPaymentRequired, getIntelBase, withTimeout } from '../intel-helpers.js';
+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. ' +
+        'Requires an x402-capable fetchImpl (setPayingFetch or host service). ' +
+        'Surfaces payment requirements if no payer is configured.',
+    examples: [
+        [
+            { name: '{{user1}}', content: { text: 'Get the trust receipt for seller JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4' } },
+            { name: '{{agentName}}', content: { text: 'Trust receipt received. score=42, receipt leaf=0x...' } },
+        ],
+    ],
+    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 seller pubkey (32-44 char base58) for trust lookup.' });
+            return { success: false, error: 'Missing pubkey' };
+        }
+        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
+        // 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.
+        try {
+            const gate = await preSpendGate({ seller_wallet: pubkey }, { apiBase, failOpen: false, fetchImpl: baseFetchImpl });
+            if (!gate.allow) {
+                await callback?.({
+                    text: `Preflight blocked the trust purchase for ${pubkey}.\n` +
+                        `Decision: ${gate.decision}${gate.trustScore != null ? `, trust_score=${gate.trustScore}` : ''}\n` +
+                        `Reason: ${gate.reason}\n` +
+                        `No payment was sent.`,
+                });
+                return {
+                    success: false,
+                    error: 'preflight_block',
+                    data: { decision: gate.decision, trustScore: gate.trustScore, reason: gate.reason },
+                };
+            }
+        }
+        catch (gateErr) {
+            // failOpen=false means a gate error should NOT silently pay. Surface it and stop.
+            const msg = gateErr instanceof Error ? gateErr.message : String(gateErr);
+            await callback?.({ text: `Preflight gate unavailable (${msg}); not spending. Try again shortly.` });
+            return { success: false, error: 'preflight_unavailable', data: { detail: msg } };
+        }
+        try {
+            const res = await withTimeout((signal) => {
+                const abortingFetch = ((input, init) => baseFetchImpl(input, { ...(init || {}), signal }));
+                return fetchIntelTrust(pubkey, { apiBase, fetchImpl: abortingFetch });
+            });
+            const receipt = res.twzrd_receipt;
+            const text = `Trust payload for ${pubkey}\n` +
+                `Score: ${res.trust?.score ?? 'n/a'}\n` +
+                `Paid: ${res.paid ? 'yes' : 'no'}\n` +
+                (res.tx ? `Settlement tx: ${res.tx}\n` : '') +
+                (receipt
+                    ? `Receipt v${receipt.version}, leaf: ${receipt.leaf}\n` +
+                        `Use WZRD_VERIFY_RECEIPT to verify offline.`
+                    : 'No twzrd_receipt in response.');
+            await callback?.({ text });
+            return { success: true, data: res };
+        }
+        catch (err) {
+            if (err instanceof IntelPaymentRequiredError) {
+                const text = formatPaymentRequired(err, apiBase, pubkey);
+                await callback?.({ text });
+                return { success: false, error: 'payment_required', data: { paymentRequirements: err.paymentRequirements } };
+            }
+            const msg = err instanceof Error ? err.message : String(err);
+            await callback?.({ text: `Intel trust failed: ${msg}` });
+            return { success: false, error: msg };
+        }
+    },
+};

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

@@ -0,0 +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).
+ */
+import type { Action } from '@elizaos/core';
+export declare const verifyReceiptAction: Action;

package/dist/actions/verify-receipt.js

@@ -0,0 +1,44 @@
+import { verifyReceipt } from '@wzrd_sol/sdk';
+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.',
+    examples: [
+        [
+            { name: '{{user1}}', content: { text: 'Verify this receipt: {"version":"v5","leaf":"0x...","preimage":{...}}' } },
+            { name: '{{agentName}}', content: { text: 'Receipt valid: leaf OK, signature OK.' } },
+        ],
+    ],
+    validate: async () => true,
+    handler: async (runtime, message, _state, _opt, callback) => {
+        const content = (message.content ?? {});
+        const receipt = parseReceipt(content);
+        if (!receipt) {
+            await callback?.({
+                text: 'Provide a TwzrdReceipt as JSON in text or as content.receipt.',
+            });
+            return { success: false, error: 'Missing receipt' };
+        }
+        const apiBase = getIntelBase(runtime);
+        const fetchPubkey = content.fetch_pubkey === true || content.fetchPubkey === true;
+        try {
+            const result = await withTimeout(() => verifyReceipt(receipt, { apiBase, fetchPubkey }));
+            const text = result.valid
+                ? `Receipt VALID (leaf=${result.leafValid}, sig=${result.signatureValid}, key=${result.trustedPubkey})`
+                : `Receipt INVALID: ${result.errors.join('; ') || 'unknown error'}`;
+            await callback?.({ text });
+            return {
+                success: result.valid,
+                data: result,
+                error: result.valid ? undefined : result.errors.join('; '),
+            };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            await callback?.({ text: `Verify failed: ${msg}` });
+            return { success: false, error: msg };
+        }
+    },
+};

package/dist/client-factory.d.ts

@@ -1,5 +1,14 @@
 import { WzrdClient } from './client.js';
 import type { IAgentRuntime } from '@elizaos/core';
+import { intelPreflight, verifyReceipt } from '@wzrd_sol/sdk';
+/** Intel API base URL from runtime settings (default https://intel.twzrd.xyz). */
+export declare function getIntelApiBase(runtime: IAgentRuntime): string;
 export declare function getWzrdClient(runtime: IAgentRuntime): WzrdClient;
 /** Reset client cache — useful for tests. */
 export declare function clearClientCache(): void;
+/** Intel client (per plan): reads WZRD_INTEL_URL + paying fetch; thin delegate to SDK. */
+export declare function getIntelClient(runtime: IAgentRuntime): {
+    preflight: (input: Parameters<typeof intelPreflight>[0]) => Promise<import("@wzrd_sol/sdk").PreflightResponse>;
+    trust: (pubkey: string) => Promise<import("@wzrd_sol/sdk").IntelTrustResponse>;
+    verify: (receipt: Parameters<typeof verifyReceipt>[0], opts?: Parameters<typeof verifyReceipt>[1]) => Promise<import("@wzrd_sol/sdk").VerifyReceiptResult>;
+};

package/dist/client-factory.js

@@ -1,7 +1,14 @@
 /** Extract keypair from ElizaOS runtime, return cached WzrdClient. */
 import { Keypair } from '@solana/web3.js';
 import { WzrdClient } from './client.js';
+import { getIntelBase, withTimeout } from './intel-helpers.js';
+import { resolvePayingFetch } from './paying-fetch.js';
+import { intelPreflight, fetchIntelTrust, verifyReceipt } from '@wzrd_sol/sdk';
 const cache = new Map();
+/** Intel API base URL from runtime settings (default https://intel.twzrd.xyz). */
+export function getIntelApiBase(runtime) {
+    return getIntelBase(runtime);
+}
 export function getWzrdClient(runtime) {
     const sk = runtime.getSetting('SOLANA_PRIVATE_KEY');
     if (!sk)
@@ -18,3 +25,16 @@ export function getWzrdClient(runtime) {
 export function clearClientCache() {
     cache.clear();
 }
+/** Intel client (per plan): reads WZRD_INTEL_URL + paying fetch; thin delegate to SDK. */
+export function getIntelClient(runtime) {
+    const apiBase = getIntelApiBase(runtime);
+    return {
+        preflight: (input) => withTimeout(() => intelPreflight(input, apiBase)),
+        trust: (pubkey) => withTimeout((signal) => {
+            const f = resolvePayingFetch(runtime);
+            const abortingFetch = ((input, init) => f(input, { ...(init || {}), signal }));
+            return fetchIntelTrust(pubkey, { apiBase, fetchImpl: abortingFetch });
+        }),
+        verify: (receipt, opts) => withTimeout(() => verifyReceipt(receipt, { apiBase, ...(opts || {}) })),
+    };
+}

package/dist/client.d.ts

@@ -88,3 +88,4 @@ export declare class WzrdClient {
         claimable: number;
     }>;
 }
+export { intelPreflight as intelPreflightClient, fetchIntelTrust as fetchIntelTrustClient, verifyReceipt as verifyReceiptClient, } from '@wzrd_sol/sdk';

package/dist/client.js

@@ -18,7 +18,7 @@ export class WzrdClient {
         if (this.token && Date.now() < this.tokenExpiry)
             return this.token;
         // 1. Get challenge
-        const challengeRes = await fetch(`${this.apiUrl}/v1/agent/challenge?pubkey=${this.pubkey}`);
+        const challengeRes = await fetch(`${this.apiUrl}/v1/agent/challenge`);
         if (!challengeRes.ok)
             throw new Error(`Challenge failed: ${challengeRes.status}`);
         const { nonce } = await challengeRes.json();
@@ -132,3 +132,6 @@ export class WzrdClient {
         return { ...data, claimable: data.cumulative_total - data.claimed_total };
     }
 }
+// Thin wrappers delegating to @wzrd_sol/sdk intel surface (preflight/trust/verify) per plan.
+// Kept in client.ts alongside earn WzrdClient. Actual runtime client for intel is via getIntelClient() in factory.
+export { intelPreflight as intelPreflightClient, fetchIntelTrust as fetchIntelTrustClient, verifyReceipt as verifyReceiptClient, } from '@wzrd_sol/sdk';

package/dist/index.d.ts

@@ -1,12 +1,17 @@
 /**
- * @wzrd_sol/eliza-plugin — WZRD Earn Loop for ElizaOS
+ * @wzrd_sol/eliza-plugin — WZRD Agent Intel + Earn Loop for ElizaOS
  *
- * Server-witnessed inference: infer → report → earn CCM → claim.
- * No external dependencies beyond @solana/web3.js + tweetnacl.
+ * 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().
+ *
+ * Earn lane (default https://api.twzrd.xyz):
+ *   WZRD_INFER → WZRD_REPORT → WZRD_EARN → WZRD_CLAIM / WZRD_REWARDS
  *
  * Config (runtime.getSetting):
- *   SOLANA_PRIVATE_KEY  — required, JSON array of secret key bytes
+ *   SOLANA_PRIVATE_KEY  — required for earn tx/auth
  *   WZRD_API_URL        — optional, defaults to https://api.twzrd.xyz
+ *   WZRD_INTEL_URL      — optional, defaults to https://intel.twzrd.xyz
  */
 import type { Plugin } from '@elizaos/core';
 import { inferAction } from './actions/infer.js';
@@ -14,9 +19,15 @@ import { reportAction } from './actions/report.js';
 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 { intelTrustAction } from './actions/intel-trust.js';
+import { verifyReceiptAction } from './actions/verify-receipt.js';
 export declare const wzrdPlugin: Plugin;
 export default wzrdPlugin;
-export { earnAction, inferAction, reportAction, claimAction, rewardsAction };
-export { getWzrdClient, clearClientCache } from './client-factory.js';
+export { intelPreflightAction, 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 { 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';

package/dist/index.js

@@ -3,13 +3,28 @@ import { reportAction } from './actions/report.js';
 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 { intelTrustAction } from './actions/intel-trust.js';
+import { verifyReceiptAction } from './actions/verify-receipt.js';
 export const wzrdPlugin = {
     name: 'wzrd',
-    description: 'WZRD Liquid Attention Protocol — earn CCM on Solana via server-witnessed inference. ' +
-        'Infer through WZRD, report outcomes, claim rewards via gasless relay.',
-    actions: [earnAction, inferAction, reportAction, claimAction, rewardsAction],
+    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.',
+    actions: [
+        intelPreflightAction,
+        intelTrustAction,
+        verifyReceiptAction,
+        earnAction,
+        inferAction,
+        reportAction,
+        claimAction,
+        rewardsAction,
+    ],
 };
 export default wzrdPlugin;
-export { earnAction, inferAction, reportAction, claimAction, rewardsAction };
-export { getWzrdClient, clearClientCache } from './client-factory.js';
+export { intelPreflightAction, 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 { WzrdClient } from './client.js';
+export { IntelPaymentRequiredError, intelPreflight, fetchIntelTrust, verifyReceipt, preSpendGate, intelTrustUrl, TRUSTED_RECEIPT_PUBKEY, INTEL_TRUST_PRICE_USDC, } from '@wzrd_sol/sdk';

package/dist/intel-helpers.d.ts

@@ -0,0 +1,22 @@
+import { IntelPaymentRequiredError, type PreflightInput, type TwzrdReceipt } from '@wzrd_sol/sdk';
+export declare function getIntelBase(runtime: {
+    getSetting: (k: string) => string | boolean | number | null;
+}): string;
+/** Pull structured fields from Eliza message content (flat or JSON-in-text). */
+export declare function parsePreflightInput(content: Record<string, unknown>): PreflightInput;
+export declare function parseReceipt(content: Record<string, unknown>): TwzrdReceipt | null;
+export declare function extractPubkey(content: Record<string, unknown>): string | null;
+export declare function formatPaymentRequired(err: IntelPaymentRequiredError, apiBase: string, pubkey: string): string;
+/**
+ * Timeout wrapper for SDK network calls (preflight/trust/verify).
+ * Supports two call forms for minimal change:
+ * - withTimeout(promise) for preflight (SDK does not expose fetchImpl/signal)
+ * - withTimeout((signal) => sdkCallWithFetchImpl(abortingFetch)) for trust/verify
+ * Uses AbortController + signal: abort() is called on timeout so that when caller
+ * wires the returned signal into fetchImpl, the underlying network request is aborted.
+ * Always clears timer in finally (no leak). Attaches rejection observer to the
+ * call promise (without altering settlement) to avoid unhandled rejections on the
+ * loser of the race.
+ * Applied to actions + getIntelClient delegates.
+ */
+export declare function withTimeout<T>(pOrMake: Promise<T> | ((signal?: AbortSignal) => Promise<T>), ms?: number): Promise<T>;

package/dist/intel-helpers.js

@@ -0,0 +1,181 @@
+import { intelTrustUrl, } from '@wzrd_sol/sdk';
+const DEFAULT_INTEL = 'https://intel.twzrd.xyz';
+export function getIntelBase(runtime) {
+    const url = runtime.getSetting('WZRD_INTEL_URL');
+    return typeof url === 'string' && url.length > 0 ? url : DEFAULT_INTEL;
+}
+/** Pull structured fields from Eliza message content (flat or JSON-in-text). */
+export function parsePreflightInput(content) {
+    const direct = {
+        resource_name: str(content.resource_name),
+        seller_wallet: str(content.seller_wallet ?? content.pubkey ?? content.wallet),
+        resource_url: str(content.resource_url ?? content.url),
+        price_usdc: num(content.price_usdc ?? content.price),
+        buyer_wallet: str(content.buyer_wallet),
+        agent_intent: str(content.agent_intent ?? content.intent),
+        marketplace_score: num(content.marketplace_score),
+    };
+    const text = str(content.text);
+    if (text) {
+        const fromJson = tryParseJson(text);
+        if (fromJson)
+            return { ...direct, ...pickPreflight(fromJson) };
+        const wallet = extractWallet(text);
+        if (wallet && !direct.seller_wallet)
+            direct.seller_wallet = wallet;
+        if (!direct.agent_intent)
+            direct.agent_intent = text;
+    }
+    return compactPreflight(direct);
+}
+export function parseReceipt(content) {
+    if (content.receipt && typeof content.receipt === 'object') {
+        return content.receipt;
+    }
+    const text = str(content.text);
+    if (!text)
+        return null;
+    const parsed = tryParseJson(text);
+    if (parsed && typeof parsed === 'object' && 'leaf' in parsed && 'preimage' in parsed) {
+        return parsed;
+    }
+    return null;
+}
+export function extractPubkey(content) {
+    const direct = str(content.pubkey ?? content.seller_wallet ?? content.wallet);
+    if (direct)
+        return direct;
+    const text = str(content.text);
+    if (!text)
+        return null;
+    const fromJson = tryParseJson(text);
+    if (fromJson) {
+        const w = str(fromJson.pubkey ?? fromJson.seller_wallet ?? fromJson.wallet);
+        if (w)
+            return w;
+    }
+    return extractWallet(text);
+}
+export function formatPaymentRequired(err, apiBase, pubkey) {
+    const url = intelTrustUrl(pubkey, apiBase);
+    const reqs = err.paymentRequirements;
+    const accepts = reqs && typeof reqs === 'object' && 'accepts' in reqs && Array.isArray(reqs.accepts)
+        ? reqs.accepts[0]
+        : null;
+    const amount = accepts?.amount ?? '50000';
+    const payTo = accepts?.payTo ?? '(see accepts)';
+    const network = accepts?.network ?? 'solana';
+    return (`Intel trust requires x402 payment (~0.05 USDC).\n` +
+        `Endpoint: ${url}\n` +
+        `Network: ${network}, amount (atomic): ${amount}, payTo: ${payTo}\n\n` +
+        `No paying fetch configured. Wire one before runtime creation:\n` +
+        `  import { setPayingFetch } from '@wzrd_sol/eliza-plugin';\n` +
+        `  setPayingFetch(myAgentcashFetch);\n\n` +
+        `Or pay out of band:\n` +
+        `  npx agentcash@latest fetch ${url}`);
+}
+function str(v) {
+    if (typeof v === 'string' && v.trim())
+        return v.trim();
+    return undefined;
+}
+function num(v) {
+    if (typeof v === 'number' && Number.isFinite(v))
+        return v;
+    if (typeof v === 'string' && v.trim()) {
+        const n = Number(v);
+        if (Number.isFinite(n))
+            return n;
+    }
+    return undefined;
+}
+function tryParseJson(text) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith('{'))
+        return null;
+    try {
+        const v = JSON.parse(trimmed);
+        return v && typeof v === 'object' ? v : null;
+    }
+    catch {
+        return null;
+    }
+}
+function extractWallet(text) {
+    const m = text.match(/[1-9A-HJ-NP-Za-km-z]{32,44}/);
+    return m ? m[0] : null;
+}
+function pickPreflight(obj) {
+    return compactPreflight({
+        resource_name: str(obj.resource_name),
+        seller_wallet: str(obj.seller_wallet ?? obj.pubkey ?? obj.wallet),
+        resource_url: str(obj.resource_url ?? obj.url),
+        price_usdc: num(obj.price_usdc ?? obj.price),
+        buyer_wallet: str(obj.buyer_wallet),
+        agent_intent: str(obj.agent_intent ?? obj.intent),
+        marketplace_score: num(obj.marketplace_score),
+    });
+}
+function compactPreflight(input) {
+    const out = {};
+    if (input.resource_name)
+        out.resource_name = input.resource_name;
+    if (input.seller_wallet)
+        out.seller_wallet = input.seller_wallet;
+    if (input.resource_url)
+        out.resource_url = input.resource_url;
+    if (input.price_usdc !== undefined)
+        out.price_usdc = input.price_usdc;
+    if (input.buyer_wallet)
+        out.buyer_wallet = input.buyer_wallet;
+    if (input.agent_intent)
+        out.agent_intent = input.agent_intent;
+    if (input.marketplace_score !== undefined)
+        out.marketplace_score = input.marketplace_score;
+    return out;
+}
+/**
+ * Timeout wrapper for SDK network calls (preflight/trust/verify).
+ * Supports two call forms for minimal change:
+ * - withTimeout(promise) for preflight (SDK does not expose fetchImpl/signal)
+ * - withTimeout((signal) => sdkCallWithFetchImpl(abortingFetch)) for trust/verify
+ * Uses AbortController + signal: abort() is called on timeout so that when caller
+ * wires the returned signal into fetchImpl, the underlying network request is aborted.
+ * Always clears timer in finally (no leak). Attaches rejection observer to the
+ * call promise (without altering settlement) to avoid unhandled rejections on the
+ * loser of the race.
+ * Applied to actions + getIntelClient delegates.
+ */
+export function withTimeout(pOrMake, ms = 8000) {
+    if (typeof pOrMake === 'function') {
+        const makeCall = pOrMake;
+        const controller = new AbortController();
+        let timer;
+        const timeoutP = new Promise((_, reject) => {
+            timer = setTimeout(() => {
+                controller.abort();
+                reject(new Error('timeout'));
+            }, ms);
+        });
+        const callP = makeCall(controller.signal);
+        // Observe rejections on callP so a late rejection after timeout does not emit unhandledrejection.
+        callP.then(undefined, () => { });
+        return Promise.race([callP, timeoutP]).finally(() => {
+            if (timer !== undefined)
+                clearTimeout(timer);
+        });
+    }
+    // legacy path (promise passed directly): still safe timeout + no unhandled + clear
+    const p = pOrMake;
+    let timer;
+    const timeoutP = new Promise((_, reject) => {
+        timer = setTimeout(() => {
+            reject(new Error('timeout'));
+        }, ms);
+    });
+    p.then(undefined, () => { });
+    return Promise.race([p, timeoutP]).finally(() => {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    });
+}

package/dist/paying-fetch.d.ts

@@ -0,0 +1,9 @@
+/** x402-capable fetch injection for paid intel actions. No embedded wallet. */
+import type { IAgentRuntime } from '@elizaos/core';
+/** Host supplies an x402-capable fetch (agentcash, twzrd-x402-gate, etc.) before runtime creation. */
+export declare function setPayingFetch(f: typeof fetch): void;
+export declare function clearPayingFetch(): void;
+type FetchLike = typeof fetch;
+/** Resolve paying fetch: module setter > runtime service > runtime.fetch > global fetch. */
+export declare function resolvePayingFetch(runtime: IAgentRuntime): FetchLike;
+export {};

package/dist/paying-fetch.js

@@ -0,0 +1,27 @@
+let modulePayingFetch = null;
+/** Host supplies an x402-capable fetch (agentcash, twzrd-x402-gate, etc.) before runtime creation. */
+export function setPayingFetch(f) {
+    modulePayingFetch = f;
+}
+export function clearPayingFetch() {
+    modulePayingFetch = null;
+}
+function serviceFetch(runtime) {
+    for (const name of ['x402', 'payingFetch', 'agentcash']) {
+        const svc = runtime.getService(name);
+        if (svc?.fetch && typeof svc.fetch === 'function')
+            return svc.fetch;
+    }
+    return null;
+}
+/** Resolve paying fetch: module setter > runtime service > runtime.fetch > global fetch. */
+export function resolvePayingFetch(runtime) {
+    if (modulePayingFetch)
+        return modulePayingFetch;
+    const fromSvc = serviceFetch(runtime);
+    if (fromSvc)
+        return fromSvc;
+    if (runtime.fetch && typeof runtime.fetch === 'function')
+        return runtime.fetch;
+    return globalThis.fetch;
+}

package/dist/test/plugin-registration.intel.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,253 @@
+/**
+ * Real E2E: load wzrdPlugin via @elizaos/core AgentRuntime (critical missing piece per plan).
+ * Constructs minimal runtime with plugins:[wzrdPlugin]; asserts intel action names present;
+ * invokes handlers w/ mock Memory (preflight uses seller_wallet/price/resource_name);
+ * paid path: injected mock paying fetch that returns fake IntelTrustResponse w/ receipt;
+ * verifies callback contains decision/score/ALLOW etc + success result.
+ * (Uses package import to match existing tsconfig.test paths + `npm run build && npm test` runtime;
+ * plan referenced '../src/index.js' for source-load semantics in test source.)
+ */
+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';
+function mockMemory(content) {
+    return {
+        id: '00000000-0000-0000-0000-000000000001',
+        entityId: '00000000-0000-0000-0000-000000000002',
+        roomId: '00000000-0000-0000-0000-000000000003',
+        content: content,
+        createdAt: Date.now(),
+    };
+}
+function mockRuntime(settings = {}) {
+    const store = new Map(Object.entries(settings));
+    return {
+        getSetting: (key) => store.get(key) ?? null,
+        getService: () => null,
+        fetch: globalThis.fetch,
+    };
+}
+describe('wzrdPlugin intel registration + E2E (real runtime load)', () => {
+    let runtime;
+    before(async () => {
+        runtime = new AgentRuntime({
+            character: { name: 'wzrd-intel-test', bio: 'test', plugins: [] },
+            settings: { WZRD_INTEL_URL: 'https://intel.twzrd.xyz' },
+        });
+        await runtime.registerPlugin(wzrdPlugin);
+    });
+    after(() => {
+        clearPayingFetch();
+    });
+    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_INTEL_TRUST'), 'trust must be registered');
+        assert.ok(names.includes('WZRD_VERIFY_RECEIPT'), 'verify must be registered');
+    });
+    it('preflight handler accepts seller_wallet + price + resource_name, returns success + decision/score text (live)', { timeout: 10000 }, async () => {
+        const rt = mockRuntime({ WZRD_INTEL_URL: 'https://intel.twzrd.xyz' });
+        const callbacks = [];
+        const result = await intelPreflightAction.handler(rt, mockMemory({
+            seller_wallet: '4LkEFjJdXARkKx8FBx4LBFa2SvJNmjQpgGDLoJcypZUE',
+            price_usdc: 0.05,
+            resource_name: 'test-resource',
+        }), undefined, undefined, async (r) => {
+            callbacks.push(r.text ?? '');
+            return [];
+        });
+        assert.equal(result?.success, true, `preflight failed: ${result?.error}`);
+        assert.equal(typeof result.success, 'boolean');
+        assert.ok(callbacks.length > 0);
+        const text = callbacks.join('\n');
+        assert.match(text, /Decision: (ALLOW|WARN|BLOCK)/i);
+        assert.match(text, /score|trust_score/i);
+        if (result.data)
+            assert.ok(result.data);
+    });
+    it('preflight validation rejects bad seller_wallet (non-base58)', async () => {
+        const rt = mockRuntime({ WZRD_INTEL_URL: 'https://intel.twzrd.xyz' });
+        const callbacks = [];
+        const result = await intelPreflightAction.handler(rt, mockMemory({ seller_wallet: 'not-base58!!!', price_usdc: 0.05 }), undefined, undefined, async (r) => {
+            callbacks.push(r.text ?? '');
+            return [];
+        });
+        assert.equal(result?.success, false);
+        assert.equal(typeof result.success, 'boolean');
+        const text = callbacks.join('\n');
+        assert.match(text, /Invalid preflight input/);
+        assert.match(text, /seller_wallet must be 32-44 char base58/);
+    });
+    it('preflight validation rejects negative price_usdc', async () => {
+        const rt = mockRuntime({ WZRD_INTEL_URL: 'https://intel.twzrd.xyz' });
+        const callbacks = [];
+        const result = await intelPreflightAction.handler(rt, mockMemory({ seller_wallet: '4LkEFjJdXARkKx8FBx4LBFa2SvJNmjQpgGDLoJcypZUE', price_usdc: -1 }), undefined, undefined, async (r) => {
+            callbacks.push(r.text ?? '');
+            return [];
+        });
+        assert.equal(result?.success, false);
+        assert.equal(typeof result.success, 'boolean');
+        const text = callbacks.join('\n');
+        assert.match(text, /Invalid preflight input/);
+        assert.match(text, /price_usdc must be non-negative finite number/);
+    });
+    it('trust handler with injected paying fetch (fake IntelTrustResponse containing receipt) succeeds + surfaces score + leaf in callback', async () => {
+        const fakeReceipt = {
+            version: 'v5',
+            leaf: '0xdeadbeef',
+            preimage: { domain: 'TWZRD:AO_REPUTATION_RECEIPT_V5', agent_id: '4LkEFjJdXARkKx8FBx4LBFa2SvJNmjQpgGDLoJcypZUE', score: 99, version: 'v5' },
+            signature: 'sig',
+            signing_pubkey: '11111111111111111111111111111111',
+        };
+        setPayingFetch(async () => ({
+            ok: true,
+            status: 200,
+            json: async () => ({ pubkey: '4LkEFjJdXARkKx8FBx4LBFa2SvJNmjQpgGDLoJcypZUE', trust: { score: 88 }, paid: true, twzrd_receipt: fakeReceipt }),
+        }));
+        const rt = mockRuntime();
+        const callbacks = [];
+        const result = await intelTrustAction.handler(rt, mockMemory({ pubkey: '4LkEFjJdXARkKx8FBx4LBFa2SvJNmjQpgGDLoJcypZUE' }), undefined, undefined, async (r) => {
+            callbacks.push(r.text ?? '');
+            return [];
+        });
+        assert.equal(result?.success, true, String(result?.error));
+        assert.equal(typeof result.success, 'boolean');
+        assert.ok(callbacks.length > 0);
+        const text = callbacks.join('\n');
+        assert.match(text, /Score: 88/);
+        assert.match(text, /leaf:/i);
+        if (result.data)
+            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.
+        const realFetch = globalThis.fetch;
+        let payAttempted = false;
+        setPayingFetch(async () => {
+            payAttempted = true;
+            return { ok: true, status: 200, json: async () => ({}) };
+        });
+        globalThis.fetch = (async () => ({
+            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('VERIFY: a V6 receipt (reputation_* bound into the leaf) is accepted by the verify action path', async () => {
+        // Live receipts are V6; the SDK selects the leaf binding from the domain, so a
+        // V6 receipt must round-trip through WZRD_VERIFY_RECEIPT without a V5/V6 mixup.
+        // We assert the action runs and reports the V6 domain rather than erroring.
+        const v6Receipt = {
+            version: 'v6',
+            leaf: '0x4c82649d2be393b1fca2da7c5d4c7afebb189ad3f0b93b620ce2e552fe5ce558',
+            preimage: {
+                domain: 'TWZRD:AO_REPUTATION_RECEIPT_V6',
+                agent_id: '11111111111111111111111111111111',
+                score: 72,
+                confidence_bps: 8000,
+                timestamp_unix: 1748736000,
+                payer: '11111111111111111111111111111111',
+                settlement_tx: 'EXAMPLE-sample-receipt-no-real-settlement-tx-0001',
+                reputation_score: 4242,
+                reputation_confidence_bps: 7500,
+                reputation_score_version: 'intel_renorm_v1',
+                reputation_feature_window_start_unix: 1748000000,
+                reputation_data_quality: 'high',
+                version: 'v6',
+            },
+            signature: 'sig',
+            signing_pubkey: '11111111111111111111111111111111',
+        };
+        const callbacks = [];
+        const result = await verifyReceiptAction.handler(mockRuntime(), mockMemory({ receipt: v6Receipt }), undefined, undefined, async (r) => {
+            callbacks.push(r.text ?? '');
+            return [];
+        });
+        // The action ran (no exception) and exercised the SDK V6 leaf path. The
+        // signature is a stub so it won't pass authenticity, but the leaf must
+        // recompute against the V6 binding (not the V5 one) — proven by the SDK's
+        // own canonical-vector tests; here we assert the action did not crash and
+        // surfaced a verdict for the V6 domain.
+        assert.ok(result, 'verify action returned a result for a V6 receipt');
+        assert.ok(callbacks.length > 0, 'verify action produced output for a V6 receipt');
+    });
+    it('trust surfaces payment_required + x402/agentcash text on 402 from (failing) fetch (explicit IntelPaymentRequiredError branch)', async () => {
+        setPayingFetch(async () => ({
+            ok: false,
+            status: 402,
+            headers: { get: () => null },
+            json: async () => ({ error: 'payment required' }),
+            text: async () => '',
+        }));
+        const rt = mockRuntime();
+        const callbacks = [];
+        const result = await intelTrustAction.handler(rt, mockMemory({ pubkey: '4LkEFjJdXARkKx8FBx4LBFa2SvJNmjQpgGDLoJcypZUE' }), undefined, undefined, async (r) => {
+            callbacks.push(r.text ?? '');
+            return [];
+        });
+        assert.equal(result?.success, false);
+        assert.equal(result?.error, 'payment_required');
+        assert.equal(typeof result.success, 'boolean');
+        const text = callbacks.join('\n');
+        assert.match(text, /x402|Intel trust requires|agentcash/i);
+    });
+    it('verify handler runs with receipt content (exercises SDK verify path)', async () => {
+        const rt = mockRuntime();
+        const callbacks = [];
+        const minimalReceipt = {
+            version: 'v5',
+            leaf: '0x0000000000000000000000000000000000000000000000000000000000000000',
+            preimage: { domain: 'TWZRD:AO_REPUTATION_RECEIPT_V5', agent_id: '4LkEFjJdXARkKx8FBx4LBFa2SvJNmjQpgGDLoJcypZUE', score: 0, version: 'v5' },
+            signature: 'AA',
+            signing_pubkey: '11111111111111111111111111111111',
+        };
+        const result = await verifyReceiptAction.handler(rt, mockMemory({ receipt: minimalReceipt }), undefined, undefined, async (r) => {
+            callbacks.push(r.text ?? '');
+            return [];
+        });
+        assert.ok(result, 'verify handler must return');
+        assert.equal(typeof result.success, 'boolean');
+        assert.equal(result.success, false);
+        assert.ok(callbacks.length > 0);
+        const text = callbacks.join('\n');
+        assert.match(text, /INVALID/);
+    });
+    it('getIntelClient factory + resolvePayingFetch service fallback exercised (covers factory delegates and resolve branches)', () => {
+        clearPayingFetch(); // ensure module-level does not shadow the service fallback we want to test
+        const mockPaying = async () => ({ ok: true, status: 200, json: async () => ({}) });
+        const rt = {
+            getSetting: () => null,
+            getService: (n) => (n === 'payingFetch' ? { fetch: mockPaying } : null),
+            fetch: globalThis.fetch,
+        };
+        const intel = getIntelClient(rt);
+        assert.equal(typeof intel.preflight, 'function');
+        assert.equal(typeof intel.trust, 'function');
+        assert.equal(typeof intel.verify, 'function');
+        // exercise at least one resolve fallback path (service)
+        const resolved = resolvePayingFetch(rt);
+        assert.equal(resolved, mockPaying);
+    });
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@wzrd_sol/eliza-plugin",
-  "version": "0.2.0",
-  "description": "WZRD earn loop for ElizaOS — server-witnessed inference, verified CCM rewards, gasless claims",
+  "version": "0.3.0",
+  "description": "WZRD Agent Intel for ElizaOS — preflight ReadinessCards, x402-paid V5 trust receipts, offline verification on intel.twzrd.xyz. Also ships the legacy earn loop.",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -13,12 +13,13 @@
     }
   },
   "scripts": {
-    "build": "tsc",
-    "test": "node --test dist/test/*.js",
+    "build": "tsc && tsc -p tsconfig.test.json",
+    "test": "node --test dist/test/plugin-registration.intel.js",
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
     "@solana/web3.js": "^1.95.0",
+    "@wzrd_sol/sdk": "^0.4.3",
     "bs58": "^5.0.0",
     "tweetnacl": "^1.0.3"
   },
@@ -32,6 +33,7 @@
   },
   "devDependencies": {
     "@elizaos/core": "^1.0.0",
+    "@types/node": "^22.13.10",
     "typescript": "^5.6.3"
   },
   "keywords": [
@@ -39,6 +41,12 @@
     "eliza",
     "elizaos",
     "wzrd",
+    "intel",
+    "x402",
+    "trust",
+    "receipt",
+    "reputation",
+    "preflight",
     "ccm",
     "inference",
     "earn",